dev_spi.h

浏览该文件的文档.

/*
 * Copyright (c) 2006-2024 RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2012-11-23     Bernard      Add extern "C"
 * 2020-06-13     armink       fix the 3 wires issue
 * 2022-09-01     liYony       fix api rt_spi_sendrecv16 about MSB and LSB bug
 */
 
#ifndef __DEV_SPI_H__
#define __DEV_SPI_H__
 
#include <stdlib.h>
#include <rtthread.h>
#include <drivers/dev_pin.h>
#include <drivers/core/driver.h>


#ifdef __cplusplus
extern "C"{
#endif

#define RT_SPI_CPHA     (1<<0)                             
#define RT_SPI_CPOL     (1<<1)                             
 
#define RT_SPI_LSB      (0<<2)                             
#define RT_SPI_MSB      (1<<2)                             
 
#define RT_SPI_MASTER   (0<<3)                             
#define RT_SPI_SLAVE    (1<<3)                             
 
#define RT_SPI_CS_HIGH  (1<<4)                             
#define RT_SPI_NO_CS    (1<<5)                             
#define RT_SPI_3WIRE    (1<<6)                             
#define RT_SPI_READY    (1<<7)                             
 
#define RT_SPI_MODE_MASK    (RT_SPI_CPHA | RT_SPI_CPOL | RT_SPI_MSB | RT_SPI_SLAVE | RT_SPI_CS_HIGH | RT_SPI_NO_CS | RT_SPI_3WIRE | RT_SPI_READY)
 
#define RT_SPI_MODE_0       (0 | 0)                        
#define RT_SPI_MODE_1       (0 | RT_SPI_CPHA)              
#define RT_SPI_MODE_2       (RT_SPI_CPOL | 0)              
#define RT_SPI_MODE_3       (RT_SPI_CPOL | RT_SPI_CPHA)    
 
#define RT_SPI_BUS_MODE_SPI         (1<<0)
#define RT_SPI_BUS_MODE_QSPI        (1<<1)

struct rt_spi_message
{
    const void *send_buf;
    void *recv_buf;
    rt_size_t length;
    struct rt_spi_message *next;
 
    unsigned cs_take    : 1;
    unsigned cs_release : 1;
};

struct rt_spi_configuration
{
    rt_uint8_t mode;
    rt_uint8_t data_width;
#ifdef RT_USING_DM
    rt_uint8_t data_width_tx;
    rt_uint8_t data_width_rx;
#else
    rt_uint16_t reserved;
#endif
 
    rt_uint32_t max_hz;
};
 
struct rt_spi_ops;

struct rt_spi_bus
{
    struct rt_device parent;
    rt_uint8_t mode;
    const struct rt_spi_ops *ops;
 
#ifdef RT_USING_DM
    rt_base_t *pins;
    rt_bool_t slave;
    int num_chipselect;
#endif /* RT_USING_DM */
 
    struct rt_mutex lock;
    struct rt_spi_device *owner;
};

struct rt_spi_ops
{
    rt_err_t (*configure)(struct rt_spi_device *device, struct rt_spi_configuration *configuration);
    rt_ssize_t (*xfer)(struct rt_spi_device *device, struct rt_spi_message *message);
};
 
#ifdef RT_USING_DM
struct rt_spi_delay
{
#define RT_SPI_DELAY_UNIT_USECS 0
#define RT_SPI_DELAY_UNIT_NSECS 1
#define RT_SPI_DELAY_UNIT_SCK   2
    rt_uint16_t value;
    rt_uint8_t  unit;
};
#endif /* RT_USING_DM */

struct rt_spi_device
{
    struct rt_device parent;
    struct rt_spi_bus *bus;
 
#ifdef RT_USING_DM
    const char *name;
    const struct rt_spi_device_id *id;
    const struct rt_ofw_node_id *ofw_id;
 
    rt_uint8_t chip_select;
    struct rt_spi_delay cs_setup;
    struct rt_spi_delay cs_hold;
    struct rt_spi_delay cs_inactive;
#endif
 
    struct rt_spi_configuration config;
    rt_base_t cs_pin;
    void   *user_data;
};

struct rt_qspi_message
{
    struct rt_spi_message parent;
 
    /* instruction stage */
    struct
    {
        rt_uint8_t content;
        rt_uint8_t qspi_lines;
    } instruction;
 
    /* address and alternate_bytes stage */
    struct
    {
        rt_uint32_t content;
        rt_uint8_t size;
        rt_uint8_t qspi_lines;
    } address, alternate_bytes;
 
    /* dummy_cycles stage */
    rt_uint32_t dummy_cycles;
 
    /* number of lines in qspi data stage, the other configuration items are in parent */
    rt_uint8_t qspi_data_lines;
};

struct rt_qspi_configuration
{
    struct rt_spi_configuration parent;
    /* The size of medium */
    rt_uint32_t medium_size;
    /* double data rate mode */
    rt_uint8_t ddr_mode;
    /* the data lines max width which QSPI bus supported, such as 1, 2, 4 */
    rt_uint8_t qspi_dl_width ;
};

struct rt_qspi_device
{
    struct rt_spi_device parent;
 
    struct rt_qspi_configuration config;
 
    void (*enter_qspi_mode)(struct rt_qspi_device *device);
 
    void (*exit_qspi_mode)(struct rt_qspi_device *device);
};
 
#define SPI_DEVICE(dev) ((struct rt_spi_device *)(dev))
 
#ifdef RT_USING_DM
struct rt_spi_device_id
{
    char name[20];
    void *data;
};
 
struct rt_spi_driver
{
    struct rt_driver parent;
 
    const struct rt_spi_device_id *ids;
    const struct rt_ofw_node_id *ofw_ids;
 
    rt_err_t (*probe)(struct rt_spi_device *device);
    rt_err_t (*remove)(struct rt_spi_device *device);
    rt_err_t (*shutdown)(struct rt_spi_device *device);
};
 
rt_err_t rt_spi_driver_register(struct rt_spi_driver *driver);
rt_err_t rt_spi_device_register(struct rt_spi_device *device);
 
#define RT_SPI_DRIVER_EXPORT(driver)  RT_DRIVER_EXPORT(driver, spi, BUILIN)
#endif /* RT_USING_DM */

rt_err_t rt_spi_bus_register(struct rt_spi_bus       *bus,
                             const char              *name,
                             const struct rt_spi_ops *ops);
 

rt_err_t rt_spi_bus_attach_device(struct rt_spi_device *device,
                                  const char           *name,
                                  const char           *bus_name,
                                  void                 *user_data);
 

rt_err_t rt_spi_bus_attach_device_cspin(struct rt_spi_device *device,
                                        const char           *name,
                                        const char           *bus_name,
                                        rt_base_t             cs_pin,
                                        void                 *user_data);

rt_err_t rt_spi_bus_configure(struct rt_spi_device *device);

rt_err_t rt_spi_take_bus(struct rt_spi_device *device);

rt_err_t rt_spi_release_bus(struct rt_spi_device *device);

rt_err_t rt_spi_take(struct rt_spi_device *device);

rt_err_t rt_spi_release(struct rt_spi_device *device);

rt_err_t rt_spi_configure(struct rt_spi_device        *device,
                          struct rt_spi_configuration *cfg);
 

rt_err_t rt_spi_send_then_recv(struct rt_spi_device *device,
                               const void           *send_buf,
                               rt_size_t             send_length,
                               void                 *recv_buf,
                               rt_size_t             recv_length);

rt_err_t rt_spi_send_then_send(struct rt_spi_device *device,
                               const void           *send_buf1,
                               rt_size_t             send_length1,
                               const void           *send_buf2,
                               rt_size_t             send_length2);

rt_ssize_t rt_spi_transfer(struct rt_spi_device *device,
                           const void           *send_buf,
                           void                 *recv_buf,
                           rt_size_t             length);

rt_err_t rt_spi_sendrecv8(struct rt_spi_device *device,
                          rt_uint8_t            senddata,
                          rt_uint8_t           *recvdata);

rt_err_t rt_spi_sendrecv16(struct rt_spi_device *device,
                           rt_uint16_t           senddata,
                           rt_uint16_t          *recvdata);

struct rt_spi_message *rt_spi_transfer_message(struct rt_spi_device  *device,
                                               struct rt_spi_message *message);

rt_inline rt_size_t rt_spi_recv(struct rt_spi_device *device,
                                void                 *recv_buf,
                                rt_size_t             length)
{
    return rt_spi_transfer(device, RT_NULL, recv_buf, length);
}

rt_inline rt_size_t rt_spi_send(struct rt_spi_device *device,
                                const void           *send_buf,
                                rt_size_t             length)
{
    return rt_spi_transfer(device, send_buf, RT_NULL, length);
}

rt_inline void rt_spi_message_append(struct rt_spi_message *list,
                                     struct rt_spi_message *message)
{
    RT_ASSERT(list != RT_NULL);
    if (message == RT_NULL)
        return; /* not append */
 
    while (list->next != RT_NULL)
    {
        list = list->next;
    }
 
    list->next = message;
    message->next = RT_NULL;
}

rt_err_t rt_qspi_configure(struct rt_qspi_device *device, struct rt_qspi_configuration *cfg);

rt_err_t rt_qspi_bus_register(struct rt_spi_bus *bus, const char *name, const struct rt_spi_ops *ops);

rt_size_t rt_qspi_transfer_message(struct rt_qspi_device  *device, struct rt_qspi_message *message);

rt_err_t rt_qspi_send_then_recv(struct rt_qspi_device *device, const void *send_buf, rt_size_t send_length,void *recv_buf, rt_size_t recv_length);

rt_err_t rt_qspi_send(struct rt_qspi_device *device, const void *send_buf, rt_size_t length);
 
#ifdef __cplusplus
}
#endif

 
#endif