Linux SPI驱动

===============================
本文系本站原创,欢迎转载!
转载请注明出处:http://www.cnblogs.com/gdt-a20

===============================

board_list——》struct boardinfo——》struct spi_board_info——》struct spidev_data——》struct spi_device——》通过struct spi_device->device_entry成员挂接到全局spi设备链表device_list

      相比于前面介绍的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设备的板级信息填充的结构：

     

 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控制器的表述结构：

 

 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总线上的设备，其表述结构为：

 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 };

 

再看一下对于spi设备结构更高层次的表述结构：

 1 struct spidev_data {
 2     dev_t            devt;
 3     spinlock_t        spi_lock;
 4     struct spi_device    *spi;            //指向spi设备结构
 5     struct list_head    device_entry;    //spi设备链表device_list挂接点   
 6     /* buffer is NULL unless this device is open (users > 0) */
 7     struct mutex        buf_lock;
 8     unsigned        users;
 9     u8            *buffer;
10 };

 

而driver端的表述结构struct spi_driver，具体如下:

1 struct spi_driver {
2     const struct spi_device_id *id_table; //匹配的设备表
3     int            (*probe)(struct spi_device *spi);
4     int            (*remove)(struct spi_device *spi);
5     void            (*shutdown)(struct spi_device *spi);
6     int            (*suspend)(struct spi_device *spi, pm_message_t mesg);
7     int            (*resume)(struct spi_device *spi);
8     struct device_driver    driver;
9 };

 

是不是很标准？哈，好了，关于相关的数据结构就先介绍这么多。

二、spi核心代码的初始化分析

 1 static int __init spi_init(void)
 2 {
 3     int    status;
 4  
 5   //其中buf为static u8    *buf, 
 6 //SPI_BUFSIZ为#define    SPI_BUFSIZ    max(32,SMP_CACHE_BYTES)
 7     buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
 8     if (!buf) {
 9         status = -ENOMEM;
10         goto err0;
11     }
12   
13   //注册spi_bus
14     status = bus_register(&spi_bus_type);
15     if (status < 0)
16         goto err1;
17   
18   //在sys/class下产生spi_master这个节点，用于自动产生设备节点
19 //下面挂接的是控制器的节点
20     status = class_register(&spi_master_class);
21     if (status < 0)
22         goto err2;
23     return 0;
24 err2:
25     bus_unregister(&spi_bus_type);
26 err1:
27     kfree(buf);
28     buf = NULL;
29 err0:
30     return status;
31 }
32 //其中注册bus结构为
33 struct bus_type spi_bus_type = {
34     .name        = "spi",
35     .dev_attrs    = spi_dev_attrs,
36     .match        = spi_match_device,    //匹配函数
37     .uevent        = spi_uevent,
38     .suspend    = spi_suspend,
39     .resume        = spi_resume,
40 };
41 //类函数为
42 static struct class spi_master_class = {
43     .name        = "spi_master",
44     .owner        = THIS_MODULE,
45     .dev_release    = spi_master_release,
46 };
47 //顺便把driver与device的匹配函数也一起分析了吧，很简单
48 static int spi_match_device(struct device *dev, struct device_driver *drv)
49 {
50     const struct spi_device    *spi = to_spi_device(dev);
51     const struct spi_driver    *sdrv = to_spi_driver(drv);
52     /* Attempt an OF style match */
53     
54     //利用of表进行匹配
55     if (of_driver_match_device(dev, drv))
56         return 1;
57   
58         //利用id表进行匹配
59     if (sdrv->id_table)
60         return !!spi_match_id(sdrv->id_table, spi);
61   
62         //利用名字进行匹配
63     return strcmp(spi->modalias, drv->name) == 0;
64 } 

 

      首先看一下spi总线的注册代码很简单，位于driver/spi/spi.c下：

    再看一下driver的注册，spi_register_driver函数：

 1 int spi_register_driver(struct spi_driver *sdrv)
 2 {
 3     
 4     //很类似于platfor的注册，很简单，
 5 //就不具体介绍了
 6     sdrv->driver.bus = &spi_bus_type;
 7     if (sdrv->probe)
 8         sdrv->driver.probe = spi_drv_probe;
 9     if (sdrv->remove)
10         sdrv->driver.remove = spi_drv_remove;
11     if (sdrv->shutdown)
12         sdrv->driver.shutdown = spi_drv_shutdown;
13         
14     //注册标准的driver，此时会去匹配bus设备链表上
15 //支持的device，找到会调用相应函数
16     return driver_register(&sdrv->driver);
17 }

 

还有个板级信息的添加函数：

 1 int __init
 2 spi_register_board_info(struct spi_board_info const *info, unsigned n)
 3 {
 4     struct boardinfo    *bi;
 5     bi = kmalloc(sizeof(*bi) + n * sizeof *info, GFP_KERNEL);
 6     if (!bi)
 7         return -ENOMEM;
 8     bi->n_board_info = n;
 9     memcpy(bi->board_info, info, n * sizeof *info);
10     mutex_lock(&board_lock);
11     list_add_tail(&bi->list, &board_list);
12     mutex_unlock(&board_lock);
13     return 0;
14 }

 

函数很简单，利用定义的spi_board_info信息，填充了boardinfo结构，并挂到board_list链表。

最后来看一下一个重量级函数，master的注册函数：

  1 int spi_register_master(struct spi_master *master)
  2 {
  3     static atomic_t        dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
  4     struct device        *dev = master->dev.parent;
  5     int            status = -ENODEV;
  6     int            dynamic = 0;
  7   //内嵌的标准设备结构必须初始化好
  8     if (!dev)
  9         return -ENODEV;
 10     /* even if it's just one always-selected device, there must
 11      * be at least one chipselect
 12 */
 13      
 14     //支持的设备数量为0，出错返回
 15     if (master->num_chipselect == 0)
 16         return -EINVAL;
 17     /* convention:  dynamically assigned bus IDs count down from the max */
 18     
 19     if (master->bus_num < 0) {
 20         /* FIXME switch to an IDR based scheme, something like
 21          * I2C now uses, so we can't run out of "dynamic" IDs
 22 */
 23       //控制器编号（总线编号）不能小于0
 24         master->bus_num = atomic_dec_return(&dyn_bus_id);
 25         dynamic = 1;
 26     }
 27     spin_lock_init(&master->bus_lock_spinlock);
 28     mutex_init(&master->bus_lock_mutex);
 29     master->bus_lock_flag = 0;
 30     /* register the device, then userspace will see it.
 31      * registration fails if the bus ID is in use.
 32 */
 33      
 34     //设置master->dev的名字，形式为spi+bus_num,如：spi0
 35     dev_set_name(&master->dev, "spi%u", master->bus_num);
 36     
 37     //注册master内嵌的标准device结构
 38     status = device_add(&master->dev);
 39     if (status < 0)
 40         goto done;
 41     dev_dbg(dev, "registered master %s%s/n", dev_name(&master->dev),
 42             dynamic ? " (dynamic)" : "");
 43     /* populate children from any spi device tables */
 44     
 45     //重点哦，扫描并实例化spi设备
 46     scan_boardinfo(master);
 47     status = 0;
 48     /* Register devices from the device tree */
 49     of_register_spi_devices(master);
 50 done:
 51     return status;
 52 }
 53 //先来看scan_boardinfo这个分支
 54 static void scan_boardinfo(struct spi_master *master)
 55 {
 56     struct boardinfo    *bi;
 57     mutex_lock(&board_lock);
 58     
 59     //找到我们注册的spi相关的板级信息结构体
 60 //还记得board_list吧
 61     list_for_each_entry(bi, &board_list, list) {
 62         struct spi_board_info    *chip = bi->board_info;
 63         unsigned        n;
 64     
 65     //因为可能存在多个spi总线，因此spi信息结构也会有
 66 //多个，找到bus号匹配的就对了
 67         for (n = bi->n_board_info; n > 0; n--, chip++) {
 68             if (chip->bus_num != master->bus_num)
 69                 continue;
 70             /* NOTE: this relies on spi_new_device to
 71              * issue diagnostics when given bogus inputs
 72 */
 73             
 74             //找到了就要实例化它上面的设备了
 75             (void) spi_new_device(master, chip);
 76         }
 77     }
 78     mutex_unlock(&board_lock);
 79 }
 80 //跟进spi_new_device函数
 81 struct spi_device *spi_new_device(struct spi_master *master,
 82                   struct spi_board_info *chip)
 83 {
 84     struct spi_device    *proxy;
 85     int            status;
 86     /* NOTE:  caller did any chip->bus_num checks necessary.
 87      *
 88      * Also, unless we change the return value convention to use
 89      * error-or-pointer (not NULL-or-pointer), troubleshootability
 90      * suggests syslogged diagnostics are best here (ugh).
 91 */
 92   
 93   //为需要实例化的设备分配内存
 94 //同时会将bus成员制定为spi_bus_type，parent
 95 //指定为该master，层次关系
 96     proxy = spi_alloc_device(master);
 97     if (!proxy)
 98         return NULL;
 99     WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
100   //各个成员赋值，都是用我们注册的板级信息
101     proxy->chip_select = chip->chip_select;
102     proxy->max_speed_hz = chip->max_speed_hz;
103     proxy->mode = chip->mode;
104     proxy->irq = chip->irq;
105     strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
106     proxy->dev.platform_data = (void *) chip->platform_data;
107     proxy->controller_data = chip->controller_data;
108     proxy->controller_state = NULL;
109   
110   //把该设备添加到spi总线
111     status = spi_add_device(proxy);
112     if (status < 0) {
113         spi_dev_put(proxy);
114         return NULL;
115     }
116     return proxy;
117 }
118 //继续spi_add_device函数
119 int spi_add_device(struct spi_device *spi)
120 {
121     static DEFINE_MUTEX(spi_add_lock);
122     struct device *dev = spi->master->dev.parent;
123     struct device *d;
124     int status;
125     /* Chipselects are numbered 0..max; validate. */
126     
127     //spi设备的编号不能大于master定义的最大数目
128     if (spi->chip_select >= spi->master->num_chipselect) {
129         dev_err(dev, "cs%d >= max %d/n",
130             spi->chip_select,
131             spi->master->num_chipselect);
132         return -EINVAL;
133     }
134     /* Set the bus ID string */
135     //设备节点名字，形式：spi0.0
136     dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
137             spi->chip_select);
138 
139     /* We need to make sure there's no other device with this
140      * chipselect **BEFORE** we call setup(), else we'll trash
141      * its configuration.  Lock against concurrent add() calls.
142 */
143     mutex_lock(&spi_add_lock);
144   
145   //确保设备不会重复注册
146     d = bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev));
147     if (d != NULL) {
148         dev_err(dev, "chipselect %d already in use/n",
149                 spi->chip_select);
150         put_device(d);
151         status = -EBUSY;
152         goto done;
153     }
154     /* Drivers may modify this initial i/o setup, but will
155      * normally rely on the device being setup.  Devices
156      * using SPI_CS_HIGH can't coexist well otherwise...
157 */
158      
159     //设置spi模式和时钟速率
160 //会调用spi->master->setup函数设置
161     status = spi_setup(spi);
162     if (status < 0) {
163         dev_err(dev, "can't %s %s, status %d/n",
164                 "setup", dev_name(&spi->dev), status);
165         goto done;
166     }
167     /* Device may be bound to an active driver when this returns */
168     
169     //将该实例化的设备添加到总线
170     status = device_add(&spi->dev);
171     if (status < 0)
172         dev_err(dev, "can't %s %s, status %d/n",
173                 "add", dev_name(&spi->dev), status);
174     else
175         dev_dbg(dev, "registered child %s/n", dev_name(&spi->dev));
176 done:
177     mutex_unlock(&spi_add_lock);
178     return status;
179 }
180 //最后看下spi_setup函数
181 int spi_setup(struct spi_device *spi)
182 {
183     unsigned    bad_bits;
184     int        status;
185     /* help drivers fail *cleanly* when they need options
186      * that aren't supported with their current master
187 */
188     
189     //必须和当前的master设置的模式匹配
190     bad_bits = spi->mode & ~spi->master->mode_bits;
191     if (bad_bits) {
192         dev_dbg(&spi->dev, "setup: unsupported mode bits %x/n",
193             bad_bits);
194         return -EINVAL;
195     }
196     if (!spi->bits_per_word)
197         spi->bits_per_word = 8;
198         
199         //最后调用控制器平台相关的setup成员设置该spi设备
200     status = spi->master->setup(spi);
201     dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s"
202                 "%u bits/w, %u Hz max --> %d/n",
203             (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
204             (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
205             (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
206             (spi->mode & SPI_3WIRE) ? "3wire, " : "",
207             (spi->mode & SPI_LOOP) ? "loopback, " : "",
208             spi->bits_per_word, spi->max_speed_hz,
209             status);
210     return status;
211 }
212 //回头看下一开始下面的那个分支of_register_spi_devices
213 void of_register_spi_devices(struct spi_master *master)
214 {
215     struct spi_device *spi;
216     struct device_node *nc;
217     const __be32 *prop;
218     int rc;
219     int len;
220   //如果定义了of_node成员才会走该分支
221     if (!master->dev.of_node)
222         return;
223         
224   //从控制器master->dev.of_node中去获取注册SPI设备spi_device的信息，然
225 //后分配结构体spi_device并注册
226     for_each_child_of_node(master->dev.of_node, nc) {
227         /* Alloc an spi_device */
228         spi = spi_alloc_device(master);
229         if (!spi) {
230             dev_err(&master->dev, "spi_device alloc error for %s/n",
231                 nc->full_name);
232             spi_dev_put(spi);
233             continue;
234         }
235         /* Select device driver */
236         if (of_modalias_node(nc, spi->modalias,
237                      sizeof(spi->modalias)) < 0) {
238             dev_err(&master->dev, "cannot find modalias for %s/n",
239                 nc->full_name);
240             spi_dev_put(spi);
241             continue;
242         }
243         /* Device address */
244         prop = of_get_property(nc, "reg", &len);
245         if (!prop || len < sizeof(*prop)) {
246             dev_err(&master->dev, "%s has no 'reg' property/n",
247                 nc->full_name);
248             spi_dev_put(spi);
249             continue;
250         }
251         spi->chip_select = be32_to_cpup(prop);
252         /* Mode (clock phase/polarity/etc.) */
253         if (of_find_property(nc, "spi-cpha", NULL))
254             spi->mode |= SPI_CPHA;
255         if (of_find_property(nc, "spi-cpol", NULL))
256             spi->mode |= SPI_CPOL;
257         if (of_find_property(nc, "spi-cs-high", NULL))
258             spi->mode |= SPI_CS_HIGH;
259         /* Device speed */
260         prop = of_get_property(nc, "spi-max-frequency", &len);
261         if (!prop || len < sizeof(*prop)) {
262             dev_err(&master->dev, "%s has no 'spi-max-frequency' property/n",
263                 nc->full_name);
264             spi_dev_put(spi);
265             continue;
266         }
267         spi->max_speed_hz = be32_to_cpup(prop);
268         /* IRQ */
269         spi->irq = irq_of_parse_and_map(nc, 0);
270         /* Store a pointer to the node in the device structure */
271         of_node_get(nc);
272         spi->dev.of_node = nc;
273         /* Register the new device */
274         request_module(spi->modalias);
275         rc = spi_add_device(spi);
276         if (rc) {
277             dev_err(&master->dev, "spi_device register error %s/n",
278                 nc->full_name);
279             spi_dev_put(spi);
280         }
281     }
282 }

 

 

三、spi设备文件的自动产生代码分析

      这部分代码相当于注册了一个spi实际driver，既是核心平台无关代码，又是个具体实例，我们来看下一下具体做了什么，也好学习一spi_driver的各部分具体都需要做些什么,代码位于driver/spi/spidev.c下：

  1 static int __init spidev_init(void)
  2 {
  3     int status;
  4     /* Claim our 256 reserved device numbers.  Then register a class
  5      * that will key udev/mdev to add/remove /dev nodes.  Last, register
  6      * the driver which manages those device numbers.
  7 */
  8     BUILD_BUG_ON(N_SPI_MINORS > 256);
  9     
 10     //注册主设备号为153的spi字符设备，spidev_fops结构下面会介绍
 11 //暂且不表
 12     status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
 13     if (status < 0)
 14         return status;
 15   //在sys/class下产生spidev这个节点，udev会利用其在dev下产生spidev
 16 //这个设备节点
 17     spidev_class = class_create(THIS_MODULE, "spidev");
 18     if (IS_ERR(spidev_class)) {
 19         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
 20         return PTR_ERR(spidev_class);
 21     }
 22         //注册spi驱动，该函数上面已经分析过    
 23     status = spi_register_driver(&spidev_spi_driver);
 24     if (status < 0) {
 25         class_destroy(spidev_class);
 26         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
 27     }
 28     return status;
 29 }
 30 //先看一下spidev_spi_driver具体的结构
 31 static struct spi_driver spidev_spi_driver = {
 32     .driver = {
 33         .name =        "spidev",
 34         .owner =    THIS_MODULE,
 35     },
 36     .probe =    spidev_probe,
 37     .remove =    __devexit_p(spidev_remove),
 38     /* NOTE:  suspend/resume methods are not necessary here.
 39      * We don't do anything except pass the requests to/from
 40      * the underlying controller.  The refrigerator handles
 41      * most issues; the controller driver handles the rest.
 42 */
 43 };
 44 //利用bus的match函数匹配成功后将首先调用spidev_probe函数，我们具体看下该函数：
 45 static int __devinit spidev_probe(struct spi_device *spi)
 46 {
 47     struct spidev_data    *spidev;
 48     int            status;
 49     unsigned long        minor;
 50     /* Allocate driver data */
 51     
 52     //申请spidev_data所需内存，前面已经讲过该结构
 53     spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
 54     if (!spidev)
 55         return -ENOMEM;
 56     /* Initialize the driver data */
 57         //赋值
 58     spidev->spi = spi;
 59     spin_lock_init(&spidev->spi_lock);
 60     mutex_init(&spidev->buf_lock);
 61     INIT_LIST_HEAD(&spidev->device_entry);
 62     /* If we can allocate a minor number, hook up this device.
 63      * Reusing minors is fine so long as udev or mdev is working.
 64 */
 65     mutex_lock(&device_list_lock);
 66     
 67     //找到一个最小的次设备号
 68 //addr为内存区的起始地址，size为要查找的最大长度
 69 //返回第一个位为0的位号
 70     minor = find_first_zero_bit(minors, N_SPI_MINORS);
 71     if (minor < N_SPI_MINORS) {
 72         struct device *dev;
 73     
 74        //下面两句用于在sys/class/spidev下产生类似于
 75 //spidev%d.%d形式的节点，这样，udev等工具就可以
 76 //自动在dev下创建相应设备号的设备节点
 77         spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
 78         dev = device_create(spidev_class, &spi->dev, spidev->devt,
 79                     spidev, "spidev%d.%d",
 80                     spi->master->bus_num, spi->chip_select);
 81         status = IS_ERR(dev) ? PTR_ERR(dev) : 0;
 82     } else {
 83         dev_dbg(&spi->dev, "no minor number available!/n");
 84         status = -ENODEV;
 85     }
 86     
 87     //如果成功标明刚才的次设备号已被占用
 88 //并且将该设备挂接到device_list链表
 89     if (status == 0) {
 90         set_bit(minor, minors);
 91         list_add(&spidev->device_entry, &device_list);
 92     }
 93     mutex_unlock(&device_list_lock);
 94        //设置spi->dev->p = spidev
 95     if (status == 0)
 96         spi_set_drvdata(spi, spidev);
 97     else
 98         kfree(spidev);
 99     return status;
100 }

 

      当我们利用板级信息添加一个设备的时候，该driver如果匹配到这个设备，那么就会自动为其创建设备节点，封装spidev_data

信息，并且挂到全局设备链表device_list。

      最后看一下刚才注册的字符设备的统一操作集：

     

  1 static const struct file_operations spidev_fops = {
  2     .owner =    THIS_MODULE,
  3     /* REVISIT switch to aio primitives, so that userspace
  4      * gets more complete API coverage.  It'll simplify things
  5      * too, except for the locking.
  6 */
  7     .write =    spidev_write,
  8     .read =        spidev_read,
  9     .unlocked_ioctl = spidev_ioctl,
 10     .open =        spidev_open,
 11     .release =    spidev_release,
 12 };
 13 //按应用的操作顺序先看下open函数
 14 static int spidev_open(struct inode *inode, struct file *filp)
 15 {
 16     struct spidev_data    *spidev;
 17     int            status = -ENXIO;
 18     mutex_lock(&device_list_lock);
 19   
 20   //遍历spi设备链表device_list，根据设备号找到spidev_data结构
 21     list_for_each_entry(spidev, &device_list, device_entry) {
 22         if (spidev->devt == inode->i_rdev) {
 23             status = 0;
 24             break;
 25         }
 26     }
 27     if (status == 0) {
 28         //buffer为空，为其申请内存
 29         if (!spidev->buffer) {
 30             spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);
 31             if (!spidev->buffer) {
 32                 dev_dbg(&spidev->spi->dev, "open/ENOMEM/n");
 33                 status = -ENOMEM;
 34             }
 35         }
 36         
 37         //设备用户使用量+1
 38         if (status == 0) {
 39             spidev->users++;
 40             
 41             //传到filp的私有成员，在read，write的时候可以从其得到该结构
 42             filp->private_data = spidev;
 43             nonseekable_open(inode, filp);
 44         }
 45     } else
 46         pr_debug("spidev: nothing for minor %d/n", iminor(inode));
 47     mutex_unlock(&device_list_lock);
 48     return status;
 49 }
 50 //再看read函数
 51 static ssize_t
 52 spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
 53 {
 54     struct spidev_data    *spidev;
 55     ssize_t            status = 0;
 56     /* chipselect only toggles at start or end of operation */
 57     if (count > bufsiz)
 58         return -EMSGSIZE;
 59   
 60   //得到传递的结构
 61     spidev = filp->private_data;
 62     mutex_lock(&spidev->buf_lock);
 63     
 64     //调用具体的读函数
 65     status = spidev_sync_read(spidev, count);
 66     if (status > 0) {
 67         unsigned long    missing;
 68     //将得到的信息传递给用户
 69         missing = copy_to_user(buf, spidev->buffer, status);
 70         if (missing == status)
 71             status = -EFAULT;
 72         else
 73             status = status - missing;
 74     }
 75     mutex_unlock(&spidev->buf_lock);
 76     return status;
 77 }
 78 //跟进spidev_sync_read函数，下面的操作比较直白，简要分析下
 79 //只关注主流程
 80 static inline ssize_t
 81 spidev_sync_read(struct spidev_data *spidev, size_t len)
 82 {
 83     //临时传输操作结构
 84     struct spi_transfer    t = {
 85             .rx_buf        = spidev->buffer,
 86             .len        = len,
 87         };
 88         
 89     //传输所用的信息结构
 90     struct spi_message    m;
 91   //初始化该结构
 92     spi_message_init(&m);
 93     //加到请求队列尾
 94     spi_message_add_tail(&t, &m);
 95     //调用spidev_sync继续
 96     return spidev_sync(spidev, &m);
 97 }
 98 //继续spidev_sync函数
 99 static ssize_t
100 spidev_sync(struct spidev_data *spidev, struct spi_message *message)
101 {
102     DECLARE_COMPLETION_ONSTACK(done);
103     int status;
104     message->complete = spidev_complete;
105     //设置个完成量
106     message->context = &done;
107     spin_lock_irq(&spidev->spi_lock);
108     if (spidev->spi == NULL)
109         status = -ESHUTDOWN;
110     else
111         //继续调用spi_async函数
112         status = spi_async(spidev->spi, message);
113     spin_unlock_irq(&spidev->spi_lock);
114     if (status == 0) {
115         //等待完成
116         wait_for_completion(&done);
117         status = message->status;
118         if (status == 0)
119             status = message->actual_length;
120     }
121     return status;
122 }
123 //spi_async函数
124 int spi_async(struct spi_device *spi, struct spi_message *message)
125 {
126     struct spi_master *master = spi->master;
127     int ret;
128     unsigned long flags;
129     spin_lock_irqsave(&master->bus_lock_spinlock, flags);
130     if (master->bus_lock_flag)
131         ret = -EBUSY;
132     else
133         //好长...继续跟进
134         ret = __spi_async(spi, message);
135     spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
136     return ret;
137 }
138 //__spi_async函数
139 static int __spi_async(struct spi_device *spi, struct spi_message *message)
140 {
141     struct spi_master *master = spi->master;
142     /* Half-duplex links include original MicroWire, and ones with
143      * only one data pin like SPI_3WIRE (switches direction) or where
144      * either MOSI or MISO is missing.  They can also be caused by
145      * software limitations.
146 */
147     if ((master->flags & SPI_MASTER_HALF_DUPLEX)
148             || (spi->mode & SPI_3WIRE)) {
149         struct spi_transfer *xfer;
150         unsigned flags = master->flags;
151         list_for_each_entry(xfer, &message->transfers, transfer_list) {
152             if (xfer->rx_buf && xfer->tx_buf)
153                 return -EINVAL;
154             if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
155                 return -EINVAL;
156             if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
157                 return -EINVAL;
158         }
159     }
160     message->spi = spi;
161     message->status = -EINPROGRESS;
162     
163     //最后调用master->transfer具体的平台相关的结构
164     return master->transfer(spi, message);
165 }

 

      read函数就分析到此，至于write函数就不具体分析了，流程是相似的！

四、总结

     根据前面的积累，这次简要分析了下spi设备驱动的模型，由于和i2c很相似，就不给出具体框图了，后面有时间会结合具体平台分析一下spi的实例，这次就到这里了 @^.^@