转自 http://www.cnblogs.com/sankye/p/3955630.html 一.spidev.c文件 看一个设备驱动的方法： module_init标识的入口初始化函数spidev_init,(module_exit标识的出口函数) 设备与设备驱动匹配时候调用的probe方法spidev_probe 设备驱动的操作函数集file_operations--->spidev_fops @@open方法spidev_open
进行检查, 重点是以后三条语句,其他的见下面代码注释:

1. spidev->users++; //spidev_data使用者计数++ 
2. filp->private_data = spidev; //spidev_data放在文件的私有数据里 
3. nonseekable_open(inode, filp);  //设置文件的打开模式(文件读写指针不会跟随读写操作移动)

 
@@read方法spidev_read
spidev = filp->private_data;=========>>status = spidev_sync_read(spidev, count);===========>>
spidev_sync(spidev, &m);==========>>status = spi_async(spidev->spi, message);===========>>
wait_for_completion(&done);========>>到了这一步是重点,在spi_async()方法中,使用以下语句将要做的事情加到workqueue中
list_add_tail(&m->queue, &bitbang->queue);
queue_work(bitbang->workqueue, &bitbang->work);
此后所有的处理程序便转移到在之前初始化的work方法中看以下代码: 点击(此处)折叠或打开

1. static void bitbang_work(struct work_struct *work)
2. {
3.     struct spi_bitbang    *bitbang =
4.         container_of(work, struct spi_bitbang, work);
5.     unsigned long        flags;
6.     int            do_setup = -1;
7.     int            (*setup_transfer)(struct spi_device *,
8.                     struct spi_transfer *);
10.     setup_transfer = bitbang->setup_transfer;
12.     spin_lock_irqsave(&bitbang->lock, flags);
13.     bitbang->busy = 1;
14.     while (!list_empty(&bitbang->queue)) {
15.         struct spi_message    *m;
16.         struct spi_device    *spi;
17.         unsigned        nsecs;
18.         struct spi_transfer    *t = NULL;
19.         unsigned        tmp;
20.         unsigned        cs_change;
21.         int            status;
23.         m = container_of(bitbang->queue.next, struct spi_message,
24.                 queue);
25.         list_del_init(&m->queue);
26.         spin_unlock_irqrestore(&bitbang->lock, flags);
28.         /* FIXME this is made-up ... the correct value is known to
29.          * word-at-a-time bitbang code, and presumably chipselect()
30.          * should enforce these requirements too?
31.          */
32.         nsecs = 100;
34.         spi = m->spi;
35.         tmp = 0;
36.         cs_change = 1;
37.         status = 0;
39.         list_for_each_entry (t, &m->transfers, transfer_list) {
41.             /* override speed or wordsize? */
42.             if (t->speed_hz || t->bits_per_word)
43.                 do_setup = 1;
45.             /* init (-1) or override (1) transfer params */
46.             if (do_setup != 0) {
47.                 if (!setup_transfer) {
48.                     status = -ENOPROTOOPT;
49.                     break;
50.                 }
51.                 status = setup_transfer(spi, t);
52.                 if (status < 0)
53.                     break;
54.             }
56.             /* set up default clock polarity, and activate chip;
57.              * this implicitly updates clock and spi modes as
58.              * previously recorded for this device via setup().
59.              * (and also deselects any other chip that might be
60.              * selected ...)
61.              */
62.             if (cs_change) {
63.                 bitbang->chipselect(spi, BITBANG_CS_ACTIVE);
64.                 ndelay(nsecs);
65.             }
66.             cs_change = t->cs_change;
67.             if (!t->tx_buf && !t->rx_buf && t->len) {
68.                 status = -EINVAL;
69.                 break;
70.             }
72.             /* transfer data. the lower level code handles any
73.              * new dma mappings it needs. our caller always gave
74.              * us dma-safe buffers.
75.              */
76.             if (t->len) {
77.                 /* REVISIT dma API still needs a designated
78.                  * DMA_ADDR_INVALID; ~0 might be better.
79.                  */
80.                 if (!m->is_dma_mapped)
81.                     t->rx_dma = t->tx_dma = 0;
82.                 status = bitbang->txrx_bufs(spi, t);
83.             }
84.             if (status > 0)
85.                 m->actual_length += status;
86.             if (status != t->len) {
87.                 /* always report some kind of error */
88.                 if (status >= 0)
89.                     status = -EREMOTEIO;
90.                 break;
91.             }
92.             status = 0;
94.             /* protocol tweaks before next transfer */
95.             if (t->delay_usecs)
96.                 udelay(t->delay_usecs);
98.             if (!cs_change)
99.                 continue;
100.             if (t->transfer_list.next == &m->transfers)
101.                 break;
103.             /* sometimes a short mid-message deselect of the chip
104.              * may be needed to terminate a mode or command
105.              */
106.             ndelay(nsecs);
107.             bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
108.             ndelay(nsecs);
109.         }
111.         m->status = status;
112.         m->complete(m->context);
114.         /* restore speed and wordsize if it was overridden */
115.         if (do_setup == 1)
116.             setup_transfer(spi, NULL);
117.         do_setup = 0;
119.         /* normally deactivate chipselect ... unless no error and
120.          * cs_change has hinted that the next message will probably
121.          * be for this chip too.
122.          */
123.         if (!(status == 0 && cs_change)) {
124.             ndelay(nsecs);
125.             bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
126.             ndelay(nsecs);
127.         }
129.         spin_lock_irqsave(&bitbang->lock, flags);
130.     }
131.     bitbang->busy = 0;
132.     spin_unlock_irqrestore(&bitbang->lock, flags);
133. }

结束处理所有任务后,见上面红 {MOD}底纹部分解除wait_for_completion(&done);
最后missing = copy_to_user(buf, spidev->buffer, status);将数据发送到用户空间

@@write方法spidev_write
与上面open方式基本相同

@@ioctl方法spidev_ioctl
具体的详解见下面章节(三,四)

下面是spidev.c添加注释部分    

1. #include  
2. #include  
3. #include  
4. #include  
5. #include  
6. #include  
7. #include  
8. #include  
9. #include  
10. #include  
11. #include  
12. #include  
13. #include  
14.  
15. #define SPIDEV_MAJOR            153 //spidev主设备号 
16. #define N_SPI_MINORS            32  /* ... up to 256 */ 
17. static DECLARE_BITMAP(minors, N_SPI_MINORS);    //声明次设备位图 
18. #define SPI_MODE_MASK (SPI_CPHA|SPI_CPOL|SPI_CS_HIGH|SPI_LSB_FIRST|SPI_3WIRE|SPI_LOOP|SPI_NO_CS|SPI_READY) 
19.  
20. struct spidev_data { 
21.     dev_t   devt;               //设备号 
22.     spinlock_t  spi_lock;       //自旋锁 
23.     struct spi_device   *spi;   //spi设备结构体 
24.     struct list_head    device_entry; 
25.     struct mutex    buf_lock;   //互斥锁 
26.     unsigned        users;      //使用者计数 
27.     u8          *buffer;        //缓冲区 
28. }; 
29.  
30. static LIST_HEAD(device_list);  //声明spi设备链表 
31. static DEFINE_MUTEX(device_list_lock);  //定义互斥锁 
32. static unsigned bufsiz = 4096;  //最大传输缓冲区大小 
33. module_param(bufsiz, uint, S_IRUGO); 
34. MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message"); 
35.  
36. static void spidev_complete(void *arg) 
37. { 
38.     complete(arg);  //调用complete 
39. } 
40.  
41. static ssize_t spidev_sync(struct spidev_data *spidev, struct spi_message *message) 
42. { 
43.     DECLARE_COMPLETION_ONSTACK(done); 
44.     int status; 
45.  
46.     message->complete = spidev_complete; //设置spi消息的complete方法 回调函数 
47.     message->context = &done; 
48.  
49.     spin_lock_irq(&spidev->spi_lock); 
50.     if (spidev->spi == NULL) //判断是否有指定对应的spi设备 
51.         status = -ESHUTDOWN; 
52.     else 
53.         status = spi_async(spidev->spi, message);    //spi异步同步 
54.     spin_unlock_irq(&spidev->spi_lock); 
55.  
56.     if (status == 0) { 
57.         wait_for_completion(&done); //等待传输完成 
58.         status = message->status;    //获取spi消息传输事务状态 
59.         if (status == 0) 
60.             status = message->actual_length; //status等于传输的实际长度 
61.     } 
62.     return status;  //返回实际传输长度 
63. } 
64.  
65. static inline ssize_t spidev_sync_write(struct spidev_data *spidev, size_t len) 
66. { 
67.     struct spi_transfer t = { 
68.             .tx_buf     = spidev->buffer,    //发送缓冲区 
69.             .len        = len,  //发送数据长度 
70.         }; 
71.     struct spi_message  m; 
72.  
73.     spi_message_init(&m);   //初始化spi消息(初始化spi传递事务队列) 
74.     spi_message_add_tail(&t, &m);   //添加spr传递到该队列 
75.     return spidev_sync(spidev, &m); //同步读写 
76. } 
77.  
78. static inline ssize_t spidev_sync_read(struct spidev_data *spidev, size_t len) 
79. { 
80.     struct spi_transfer t = { 
81.             .rx_buf     = spidev->buffer,    //接收缓冲区