Linux设备模型之spi子系统


相比于前面介绍的i2c子系统（见  ），spi子系统相对简单，和i2c的结构也很相似，这里主要介绍一下平台无关部分的代码。先概括的说一下，spi总线或者说是spi控制器用结构体struct spi_master来表述，而一般不会明显的主动实现这个结构而是借助板级的一些信息结构，利用spi的模型填充，存在板级信息的一条链表board_list，上面挂接着板级spi设备的描述信息，其挂接的结构是struct boardinfo，这个结构内部嵌入了具体的板级spi设备所需信息结构struct spi_board_info，对于要操控的spi设备，用struct spidev_data来描述，内嵌了具体设备信息结构struct spi_device，并通过struct spi_device->device_entry成员挂接到全局spi设备链表device_list，结构struct spi_device就是根据前面board_list上所挂的信息填充的，而driver端比较简单，用struct spi_driver来描述，一会儿会看到该结构和标准的platform非常相似，总括的说下一般编写流程：对于soc，spi控制器一般注册成platform，当driver匹配后，会根据platform_device等信息构造出spi_master，一般发生在driver的probe函数，并且注册该master，在master的注册过程中会去遍历board_list找到bus号相同的spi设备信息，并实例化它，好了先就说这么多，下面先看一下具体的数据结构。

一、spi相关的数据结构

      先看一下spi设备的板级信息填充的结构：

      [cpp]

  1. struct boardinfo {  
  2.     struct list_head    list;              //用于挂接到链表头board_list上                 
  3.     unsigned        n_board_info;      //设备信息号，spi_board_info成员的编号   
  4.     struct spi_board_info   board_info[0];     //内嵌的spi_board_info结构   
  5. };  
  6. //其中内嵌的描述spi设备的具体信息的结构struct spi_board_info为：   
  7. struct spi_board_info {  
  8.     /* the device name and module name are coupled, like platform_bus; 
  9.      * "modalias" is normally the driver name. 
  10.      * 
  11.      * platform_data goes to spi_device.dev.platform_data, 
  12.      * controller_data goes to spi_device.controller_data, 
  13.      * irq is copied too 
  14.      */  
  15.     char        modalias[SPI_NAME_SIZE];     //名字   
  16.     const void  *platform_data;              //如同注释写的指向spi_device.dev.platform_data   
  17.     void        *controller_data;            //指向spi_device.controller_data   
  18.     int     irq;                         //中断号   
  19.     /* slower signaling on noisy or low voltage boards */  
  20.     u32     max_speed_hz;                //时钟速率   
  21.     /* bus_num is board specific and matches the bus_num of some 
  22.      * spi_master that will probably be registered later. 
  23.      * 
  24.      * chip_select reflects how this chip is wired to that master; 
  25.      * it's less than num_chipselect. 
  26.      */  
  27.     u16     bus_num;                     //所在的spi总线编号   
  28.     u16     chip_select;                     
  29.     /* mode becomes spi_device.mode, and is essential for chips 
  30.      * where the default of SPI_CS_HIGH = 0 is wrong. 
  31.      */  
  32.     u8      mode;                        //模式   
  33.     /* ... may need additional spi_device chip config data here. 
  34.      * avoid stuff protocol drivers can set; but include stuff 
  35.      * needed to behave without being bound to a driver: 
  36.      *  - quirks like clock rate mattering when not selected 
  37.      */  
  38. };   

     利用boardinfo->list成员会将自身挂接到全局的board_list链表上。

     再来看一下spi控制器的表述结构：

  [cpp]

  1. struct spi_master {  
  2.     struct device   dev;                //内嵌的标准dev结构   
  3.     /* other than negative (== assign one dynamically), bus_num is fully 
  4.      * board-specific.  usually that simplifies to being SOC-specific. 
  5.      * example:  one SOC has three SPI controllers, numbered 0..2, 
  6.      * and one board's schematics might show it using SPI-2.  software 
  7.      * would normally use bus_num=2 for that controller. 
  8.      */  
  9.     s16         bus_num;                  //标识的总线号   
  10.     /* chipselects will be integral to many controllers; some others 
  11.      * might use board-specific GPIOs. 
  12.      */  
  13.     u16         num_chipselect;  
  14.     /* some SPI controllers pose alignment requirements on DMAable 
  15.      * buffers; let protocol drivers know about these requirements. 
  16.      */  
  17.     u16         dma_alignment;           //dma对其要求   
  18.     /* spi_device.mode flags understood by this controller driver */  
  19.     u16         mode_bits;               //代表操作的spi_device.mode   
  20.     /* other constraints relevant to this driver */  
  21.     u16         flags;                   //另外的一些标志   
  22. #define SPI_MASTER_HALF_DUPLEX  BIT(0)      /* can't do full duplex */   
  23. #define SPI_MASTER_NO_RX    BIT(1)      /* can't do buffer read */   
  24. #define SPI_MASTER_NO_TX    BIT(2)      /* can't do buffer write */   
  25.     /* lock and mutex for SPI bus locking */  
  26.     spinlock_t      bus_lock_spinlock;  
  27.     struct mutex        bus_lock_mutex;  
  28.     /* flag indicating that the SPI bus is locked for exclusive use */  
  29.     bool            bus_lock_flag;  
  30.     /* Setup mode and clock, etc (spi driver may call many times). 
  31.      * 
  32.      * IMPORTANT:  this may be called when transfers to another 
  33.      * device are active.  DO NOT UPDATE SHARED REGISTERS in ways 
  34.      * which could break those transfers. 
  35.      */  
  36.     int         (*setup)(struct spi_device *spi);   //设置模式   
  37.     /* bidirectional bulk transfers 
  38.      * 
  39.      * + The transfer() method may not sleep; its main role is 
  40.      *   just to add the message to the queue. 
  41.      * + For now there's no remove-from-queue operation, or 
  42.      *   any other request management 
  43.      * + To a given spi_device, message queueing is pure fifo 
  44.      * 
  45.      * + The master's main job is to process its message queue, 
  46.      *   selecting a chip then transferring data 
  47.      * + If there are multiple spi_device children, the i/o queue 
  48.      *   arbitration algorithm is unspecified (round robin, fifo, 
  49.      *   priority, reservations, preemption, etc) 
  50.      * 
  51.      * + Chipselect stays active during the entire message 
  52.      *   (unless modified by spi_transfer.cs_change != 0). 
  53.      * + The message transfers use clock and SPI mode parameters 
  54.      *   previously established by setup() for this device 
  55.      */  
  56.     int         (*transfer)(struct spi_device *spi,    //传输函数   
  57.                         struct spi_message *mesg);  
  58.     /* called on release() to free memory provided by spi_master */  
  59.     void            (*cleanup)(struct spi_device *spi);  
  60. };  

   而对于要操控的spi总线上的设备，其表述结构为：

[cpp]

  1. struct spi_device {  
  2.     struct device       dev;               //内嵌标准device结构体   
  3.     struct spi_master   *master;         //spi主控制器   
  4.     u32         max_speed_hz;              //时钟速率   
  5.     u8          chip_select;               //设备编号   
  6.     u8          mode;                      //模式   
  7. #define SPI_CPHA    0x01            /* clock phase */   
  8. #define SPI_CPOL    0x02            /* clock polarity */   
  9. #define SPI_MODE_0  (0|0)           /* (original MicroWire) */   
  10. #define SPI_MODE_1  (0|SPI_CPHA)   
  11. #define SPI_MODE_2  (SPI_CPOL|0)   
  12. #define SPI_MODE_3  (SPI_CPOL|SPI_CPHA)   
  13. #define SPI_CS_HIGH 0x04            /* chipselect active high? */   
  14. #define SPI_LSB_FIRST   0x08            /* per-word bits-on-wire */   
  15. #define SPI_3WIRE   0x10            /* SI/SO signals shared */   
  16. #define SPI_LOOP    0x20            /* loopback mode */   
  17. #define SPI_NO_CS   0x40            /* 1 dev/bus, no chipselect */   
  18. #define SPI_READY   0x80            /* slave pulls low to pause */   
  19.     u8          bits_per_word;  
  20.     int         irq;                        //中断号   
  21.     void            *controller_state;        //控制状态   
  22.     void            *controller_data;         //私有数据   
  23.     char            modalias[SPI_NAME_SIZE];  //名字   
  24.     /* 
  25.      * likely need more hooks for more protocol options affecting how 
  26.      * the controller talks to each chip, like: 
  27.      *  - memory packing (12 bit samples into low bits, others zeroed) 
  28.      *  - priority 
  29.      *  - drop chipselect after each word 
  30.      *  - chipselect delays 
  31.      *  - ... 
  32.      */  
  33. };  
  • 1
  • 2
  • 3
  • 下一页

相关内容