Linux spi驱动分析(三)----spiddev分析

一、spidev简单介绍

        如果在内核中配置spidev，会在“/dev”目录下产生设备节点，通过此节点可以操作挂载在该SPI总线上的设备，接下来将从驱动层和应用层

来分析程序。

二、spidev驱动层

2.1、驱动注册

        分析一个设备驱动，一般都是从module_init和module_exit处开始，本文也不例外，程序如下：

点击(此处)折叠或打开

1. #define SPIDEV_MAJOR            153    /* assigned*/
   
2. #define N_SPI_MINORS            32    /*... upto 256 */
   
3. 
   
4. static DECLARE_BITMAP(minors, N_SPI_MINORS);
   
5. static struct spi_driver spidev_spi_driver ={
   
6.     .driver ={
   
7.         .name =        "spidev",
   
8.         .owner =    THIS_MODULE,
   
9.     },
   
10.     .probe =    spidev_probe,
    
11.     .remove =    __devexit_p(spidev_remove),
    
12. 
    
13.     /* NOTE: suspend/resume methods arenot necessary here.
    
14.      * We don'tdo anything except pass the requests to/from
    
15.      * the underlying controller. The refrigerator handles
    
16.      * most issues; the controller driver handles the rest.
    
17.      */
    
18. };
    
19. 
    
20. /*-------------------------------------------------------------------------*/
    
21. 
    
22. static int __init spidev_init(void)
    
23. {
    
24.     int status;
    
25. 
    
26.     /* Claim our 256 reserved device numbers.Then register a class
    
27.      * that will key udev/mdevto add/remove/dev nodes. Last, register
    
28.      * the driver which manages those device numbers.
    
29.      */
    
30.     BUILD_BUG_ON(N_SPI_MINORS > 256);
    
31.     status = register_chrdev(SPIDEV_MAJOR,"spi", &spidev_fops);
    
32.     if (status< 0)
    
33.         return status;
    
34. 
    
35.     spidev_class = class_create(THIS_MODULE,"spidev");
    
36.     if (IS_ERR(spidev_class)){
    
37.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
    
38.         return PTR_ERR(spidev_class);
    
39.     }
    
40. 
    
41.     status = spi_register_driver(&spidev_spi_driver);
    
42.     if (status< 0) {
    
43.         class_destroy(spidev_class);
    
44.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
    
45.     }
    
46.     return status;
    
47. }
    
48. module_init(spidev_init);
    
49. 
    
50. static void __exit spidev_exit(void)
    
51. {
    
52.     spi_unregister_driver(&spidev_spi_driver);
    
53.     class_destroy(spidev_class);
    
54.     unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
    
55. }
    
56. module_exit(spidev_exit);
    
57. 
    
58. MODULE_AUTHOR("Andrea Paterniani,");
    
59. MODULE_DESCRIPTION("User mode SPI device interface");
    
60. MODULE_LICENSE("GPL");
    
61. MODULE_ALIAS("spi:spidev");

        说明：

        1) 在驱动注册函数中，首先注册函数操作集spidev_fops，该内容将在2.3中具体讲述。

        2) 生成spidev设备类，此类的表现是在“/sys/class”目录下生成一个名为spidev目录。

        3) 注册spi驱动。

        4) 退出函数是注册函数的相反过程，就是释放注册函数中注册的资源。

2.2、探测和移除函数

        探测函数程序如下：

点击(此处)折叠或打开

1. static int __devinit spidev_probe(struct spi_device*spi)
   
2. {
   
3.     struct spidev_data    *spidev;
   
4.     int            status;
   
5.     unsigned long        minor;
   
6. 
   
7.     /* Allocate driver data*/
   
8.     spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
   
9.     if (!spidev)
   
10.         return -ENOMEM;
    
11. 
    
12.     /* Initialize the driver data*/
    
13.     spidev->spi= spi;
    
14.     spin_lock_init(&spidev->spi_lock);
    
15.     mutex_init(&spidev->buf_lock);
    
16. 
    
17.     INIT_LIST_HEAD(&spidev->device_entry);
    
18. 
    
19.     /* If we can allocate a minor number, hook up this device.
    
20.      * Reusing minors is fine so long as udev or mdev is working.
    
21.      */
    
22.     mutex_lock(&device_list_lock);
    
23.     minor = find_first_zero_bit(minors, N_SPI_MINORS);
    
24.     if (minor< N_SPI_MINORS){
    
25.         struct device *dev;
    
26. 
    
27.         spidev->devt= MKDEV(SPIDEV_MAJOR, minor);
    
28.         dev = device_create(spidev_class,&spi->dev, spidev->devt,
    
29.                  spidev, "spidev%d.%d",
    
30.                  spi->master->bus_num, spi->chip_select);
    
31.         status = IS_ERR(dev)? PTR_ERR(dev): 0;
    
32.     } else{
    
33.         dev_dbg(&spi->dev,"no minor number available!\n");
    
34.         status = -ENODEV;
    
35.     }
    
36.     if (status== 0){
    
37.         set_bit(minor, minors);
    
38.         list_add(&spidev->device_entry,&device_list);
    
39.     }
    
40.     mutex_unlock(&device_list_lock);
    
41. 
    
42.     if (status== 0)
    
43.         spi_set_drvdata(spi, spidev);
    
44.     else
    
45.         kfree(spidev);
    
46. 
    
47.     return status;
    
48. }

        说明：

        1) 首先声明spidev_data结构体内存。

        2) 初始化其成员变量。

        3) 在位图中寻找第一个未被用到的位。

        4) 如果位图寻找正确，创建“/dev”目录下的设备节点。

        4) 将spidev结构体中的链表插入局部全局链表device_list中，以便在函数操作集中的open函数中使用            

        移除函数如下：

点击(此处)折叠或打开

1. static int __devexit spidev_remove(struct spi_device*spi)
   
2. {
   
3.     struct spidev_data    *spidev = spi_get_drvdata(spi);
   
4. 
   
5.     /* make sure opson existing fds can abort cleanly */
   
6.     spin_lock_irq(&spidev->spi_lock);
   
7.     spidev->spi= NULL;
   
8.     spi_set_drvdata(spi,NULL);
   
9.     spin_unlock_irq(&spidev->spi_lock);
   
10. 
    
11.     /* prevent new opens*/
    
12.     mutex_lock(&device_list_lock);
    
13.     list_del(&spidev->device_entry);
    
14.     device_destroy(spidev_class, spidev->devt);
    
15.     clear_bit(MINOR(spidev->devt), minors);
    
16.     if (spidev->users== 0)
    
17.         kfree(spidev);
    
18.     mutex_unlock(&device_list_lock);
    
19. 
    
20.     return 0;
    
21. }

        说明：

        1) 移除函数就是探测函数的相反过程，主要就是释放探测函数中申请的资源。

2.2、函数操作集spidev_fop

        spidev_fop具体如下：

点击(此处)折叠或打开

1. static const struct file_operations spidev_fops= {
   
2.     .owner =    THIS_MODULE,
   
3.     /* REVISIT switchto aio primitives, so that userspace
   
4.      * gets more complete API coverage. It'll simplify things
   
5.      * too, exceptfor the locking.
   
6.      */
   
7.     .write =    spidev_write,
   
8.     .read =        spidev_read,
   
9.     .unlocked_ioctl = spidev_ioctl,
   
10.     .compat_ioctl = spidev_compat_ioctl,
    
11.     .open =        spidev_open,
    
12.     .release =    spidev_release,
    
13.     .llseek =    no_llseek,
    
14. };

        首先看下打开函数spidev_open，程序如下：

点击(此处)折叠或打开

1. static int spidev_open(struct inode*inode, struct file*filp)
   
2. {
   
3.     struct spidev_data    *spidev;
   
4.     int            status = -ENXIO;
   
5. 
   
6.     mutex_lock(&device_list_lock);
   
7. 
   
8.     list_for_each_entry(spidev,&device_list, device_entry){
   
9.         if (spidev->devt== inode->i_rdev){
   
10.             status = 0;
    
11.             break;
    
12.         }
    
13.     }
    
14.     if (status== 0){
    
15.         if (!spidev->buffer){
    
16.             spidev->buffer= kmalloc(bufsiz, GFP_KERNEL);
    
17.             if (!spidev->buffer){
    
18.                 dev_dbg(&spidev->spi->dev,"open/ENOMEM\n");
    
19.                 status = -ENOMEM;
    
20.             }
    
21.         }
    
22.         if (status== 0){
    
23.             spidev->users++;
    
24.             filp->private_data= spidev;
    
25.             nonseekable_open(inode, filp);
    
26.         }
    
27.     } else
    
28.         pr_debug("spidev: nothing for minor %d\n", iminor(inode));
    
29. 
    
30.     mutex_unlock(&device_list_lock);
    
31.     return status;
    
32. }

        说明：

        1) 程序首先上本地全局互斥锁。

        2) 遍历链表device_list，通过设备号找到在探测函数中创建的设备结构体spidev。

        3) 如果寻找成功，将其保存在file的私有成员中，供其他操作集中的函数使用。

        realease函数如下：

点击(此处)折叠或打开

1. static int spidev_release(struct inode*inode, struct file*filp)
   
2. {
   
3.     struct spidev_data    *spidev;
   
4.     int            status = 0;
   
5. 
   
6.     mutex_lock(&device_list_lock);
   
7.     spidev = filp->private_data;
   
8.     filp->private_data= NULL;
   
9. 
   
10.     /* last close?*/
    
11.     spidev->users--;
    
12.     if (!spidev->users){
    
13.         int        dofree;
    
14. 
    
15.         kfree(spidev->buffer);
    
16.         spidev->buffer= NULL;
    
17. 
    
18.         /*... after we unbound from the underlying device?*/
    
19.         spin_lock_irq(&spidev->spi_lock);
    
20.         dofree = (spidev->spi== NULL);
    
21.         spin_unlock_irq(&spidev->spi_lock);
    
22. 
    
23.         if (dofree)
    
24.             kfree(spidev);
    
25.     }
    
26.     mutex_unlock(&device_list_lock);
    
27. 
    
28.     return status;
    
29. }

        说明：

        1) 首先减少使用次数。

        2) 释放传输buf空间。

       3) 释放结构体内存。

        spi读数据函数如下：

点击(此处)折叠或打开

1. static inline ssize_t
   
2. spidev_sync_read(struct spidev_data *spidev, size_t len)
   
3. {
   
4.     struct spi_transfer    t = {
   
5.             .rx_buf        = spidev->buffer,
   
6.             .len        =len,
   
7.         };
   
8.     struct spi_message    m;
   
9. 
   
10.     spi_message_init(&m);
    
11.     spi_message_add_tail(&t,&m);
    
12.     return spidev_sync(spidev,&m);
    
13. }
    
14. static ssize_t
    
15. spidev_read(struct file *filp, char __user *buf, size_t count, loff_t*f_pos)
    
16. {
    
17.     struct spidev_data    *spidev;
    
18.     ssize_t            status = 0;
    
19. 
    
20.     /* chipselect only toggles at startor end of operation*/
    
21.     if (count> bufsiz)
    
22.         return -EMSGSIZE;
    
23. 
    
24.     spidev = filp->private_data;
    
25. 
    
26.     mutex_lock(&spidev->buf_lock);
    
27.     status = spidev_sync_read(spidev, count);
    
28.     if (status> 0) {
    
29.         unsigned long    missing;
    
30. 
    
31.         missing = copy_to_user(buf, spidev->buffer, status);
    
32.         if (missing== status)
    
33.             status = -EFAULT;
    
34.         else
    
35.             status = status - missing;
    
36.     }
    
37.     mutex_unlock(&spidev->buf_lock);
    
38. 
    
39.     return status;
    
40. }

        说明：

        1) 进入读函数中，首先上互斥锁。

        2) 然后调用spidev_sync_read函数读数据。

        3) 如果读取成功，将读取到的数据拷贝到应用层。

        4) 解互斥锁。

        5) 在spidev_sync_read函数中，首先定义一个传输结构体spi_transfer，由于是读操作，所以只初始化其接收buf。

        6) 初始化spi_message，调用函数spidev_sync传输数据，其具体程序如下：

点击(此处)折叠或打开

1. static ssize_t
   
2. spidev_sync(struct spidev_data *spidev, struct spi_message *message)
   
3. {
   
4.     DECLARE_COMPLETION_ONSTACK(done);
   
5.     int status;
   
6. 
   
7.     message->complete= spidev_complete;
   
8.     message->context= &done;
   
9. 
   
10.     spin_lock_irq(&spidev->spi_lock);
    
11.     if (spidev->spi== NULL)
    
12.         status = -ESHUTDOWN;
    
13.     else
    
14.         status = spi_async(spidev->spi, message);
    
15.     spin_unlock_irq(&spidev->spi_lock);
    
16. 
    
17.     if (status== 0){
    
18.         wait_for_completion(&done);
    
19.         status = message->status;
    
20.         if (status== 0)
    
21.             status = message->actual_length;
    
22.     }
    
23.     return status;
    
24. }

        说明：

        1) 首先定义并初始化一个completion。

        2) 上自旋锁，调用spi_async函数传输数据，spi_async就是在Linux核心中提供的传输函数。

        3) 如果调用传输函数成功，则等待。

        3) wait_for_completion(&done);等待传输完成，如果传输正确，函数返回值为传输的字节数。

        函数操作集写函数spidev_write程序如下：

点击(此处)折叠或打开

1. static inline ssize_t
   
2. spidev_sync_write(struct spidev_data *spidev, size_t len)
   
3. {
   
4.     struct spi_transfer    t = {
   
5.             .tx_buf        = spidev->buffer,
   
6.             .len        =len,
   
7.         };
   
8.     struct spi_message    m;
   
9. 
   
10.     spi_message_init(&m);
    
11.     spi_message_add_tail(&t,&m);
    
12.     return spidev_sync(spidev,&m);
    
13. }
    
14. static ssize_t
    
15. spidev_write(struct file *filp, const char __user*buf,
    
16.         size_t count, loff_t *f_pos)
    
17. {
    
18.     struct spidev_data    *spidev;
    
19.     ssize_t            status = 0;
    
20.     unsigned long        missing;
    
21. 
    
22.     /* chipselect only toggles at startor end of operation*/
    
23.     if (count> bufsiz)
    
24.         return -EMSGSIZE;
    
25. 
    
26.     spidev = filp->private_data;
    
27. 
    
28.     mutex_lock(&spidev->buf_lock);
    
29.     missing = copy_from_user(spidev->buffer, buf, count);
    
30.     if (missing== 0){
    
31.         status = spidev_sync_write(spidev, count);
    
32.     } else
    
33.         status = -EFAULT;
    
34.     mutex_unlock(&spidev->buf_lock);
    
35. 
    
36.     return status;
    
37. }

        说明：

        1) 写函数首先上互斥锁，然后从应用层拷贝需要写的数据。

        2) 如果拷贝成功，调用函数spidev_sync_write完成写数据。

        3) 解互斥锁。

        4) spidev_sync_write函数中，首先定义spi_transfer传输结构体，由于是写，此结构体只有tx_buf。

        5) 初始化spi_message，然后调用spidev_sync传输数据，此函数在上面的读操作中已经讲述。

        ioctl函数如下：

点击(此处)折叠或打开

1. static long
   
2. spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
   
3. {
   
4.     int            err= 0;
   
5.     int            retval = 0;
   
6.     struct spidev_data    *spidev;
   
7.     struct spi_device    *spi;
   
8.     u32            tmp;
   
9.     unsigned        n_ioc;
   
10.     struct spi_ioc_transfer    *ioc;
    
11. 
    
12.     /* Check typeand command number */
    
13.     if (_IOC_TYPE(cmd)!= SPI_IOC_MAGIC)
    
14.         return -ENOTTY;
    
15. 
    
16.     /* Check access direction once here; don't repeat below.
    
17.      * IOC_DIR is from the user perspective, while access_ok is
    
18.      * from the kernel perspective; so they look reversed.
    
19.      */
    
20.     if (_IOC_DIR(cmd)& _IOC_READ)
    
21.         err =!access_ok(VERIFY_WRITE,
    
22.                 (void __user *)arg, _IOC_SIZE(cmd));
    
23.     if (err== 0 && _IOC_DIR(cmd)& _IOC_WRITE)
    
24.         err =!access_ok(VERIFY_READ,
    
25.                 (void __user *)arg, _IOC_SIZE(cmd));
    
26.     if (err)
    
27.         return -EFAULT;
    
28. 
    
29.     /* guard against device removal before,or while,
    
30.      * we issue this ioctl.
    
31.      */
    
32.     spidev = filp->private_data;
    
33.     spin_lock_irq(&spidev->spi_lock);
    
34.     spi = spi_dev_get(spidev->spi);
    
35.     spin_unlock_irq(&spidev->spi_lock);
    
36. 
    
37.     if (spi== NULL)
    
38.         return -ESHUTDOWN;
    
39. 
    
40.     /* use the buffer lock herefor triple duty:
    
41.      * - prevent I/O(from us) so calling spi_setup()is safe;
    
42.      * - prevent concurrent SPI_IOC_WR_* from morphing
    
43.      * data fields while SPI_IOC_RD_* reads them;
    
44.      * - SPI_IOC_MESSAGE needs the buffer locked"normally".
    
45.      */
    
46.     mutex_lock(&spidev->buf_lock);
    
47. 
    
48.     switch (cmd){
    
49.     /* read requests*/
    
50.     case SPI_IOC_RD_MODE:
    
51.         retval = __put_user(spi->mode& SPI_MODE_MASK,
    
52.                     (__u8 __user *)arg);
    
53.         break;
    
54.     case SPI_IOC_RD_LSB_FIRST:
    
55.         retval = __put_user((spi->mode& SPI_LSB_FIRST)? 1 : 0,
    
56.                     (__u8 __user *)arg);
    
57.         break;
    
58.     case SPI_IOC_RD_BITS_PER_WORD:
    
59.         retval = __put_user(spi->bits_per_word,(__u8 __user *)arg);
    
60.         break;
    
61.     case SPI_IOC_RD_MAX_SPEED_HZ:
    
62.         retval = __put_user(spi->max_speed_hz,(__u32 __user *)arg);
    
63.         break;
    
64. 
    
65.     /* write requests*/
    
66.     case SPI_IOC_WR_MODE:
    
67.         retval = __get_user(tmp,(u8 __user *)arg);
    
68.         if (retval== 0){
    
69.             u8    save = spi->mode;
    
70. 
    
71.             if (tmp & ~SPI_MODE_MASK){
    
72.                 retval = -EINVAL;
    
73.                 break;
    
74.             }
    
75. 
    
76.             tmp |= spi->mode& ~SPI_MODE_MASK;
    
77.             spi->mode= (u8)tmp;
    
78.             retval = spi_setup(spi);
    
79.             if (retval < 0)
    
80.                 spi->mode= save;
    
81.             else
    
82.                 dev_dbg(&spi->dev,"spi mode %02x\n", tmp);
    
83.         }
    
84.         break;
    
85.     case SPI_IOC_WR_LSB_FIRST:
    
86.         retval = __get_user(tmp,(__u8 __user *)arg);
    
87.         if (retval== 0){
    
88.             u8    save = spi->mode;
    
89. 
    
90.             if (tmp)
    
91.                 spi->mode|= SPI_LSB_FIRST;
    
92.             else
    
93.                 spi->mode&= ~SPI_LSB_FIRST;
    
94.             retval = spi_setup(spi);
    
95.             if (retval < 0)
    
96.                 spi->mode= save;
    
97.             else
    
98.                 dev_dbg(&spi->dev,"%csb first\n",
    
99.                         tmp ? 'l' :'m');
    
100.         }
     
101.         break;
     
102.     case SPI_IOC_WR_BITS_PER_WORD:
     
103.         retval = __get_user(tmp,(__u8 __user *)arg);
     
104.         if (retval== 0){
     
105.             u8    save = spi->bits_per_word;
     
106. 
     
107.             spi->bits_per_word= tmp;
     
108.             retval = spi_setup(spi);
     
109.             if (retval < 0)
     
110.                 spi->bits_per_word= save;
     
111.             else
     
112.                 dev_dbg(&spi->dev,"%d bits per word\n", tmp);
     
113.         }
     
114.         break;
     
115.     case SPI_IOC_WR_MAX_SPEED_HZ:
     
116.         retval = __get_user(tmp,(__u32 __user *)arg);
     
117.         if (retval== 0){
     
118.             u32    save = spi->max_speed_hz;
     
119. 
     
120.             spi->max_speed_hz= tmp;
     
121.             retval = spi_setup(spi);
     
122.             if (retval < 0)
     
123.                 spi->max_speed_hz= save;
     
124.             else
     
125.                 dev_dbg(&spi->dev,"%d Hz (max)\n", tmp);
     
126.         }
     
127.         break;
     
128. 
     
129.     default:
     
130.         /* segmentedand/or full-duplex I/O request*/
     
131.         if (_IOC_NR(cmd)!= _IOC_NR(SPI_IOC_MESSAGE(0))
     
132.                 || _IOC_DIR(cmd)!= _IOC_WRITE){
     
133.             retval = -ENOTTY;
     
134.             break;
     
135.         }
     
136. 
     
137.         tmp = _IOC_SIZE(cmd);
     
138.         if ((tmp% sizeof(struct spi_ioc_transfer))!= 0){
     
139.             retval = -EINVAL;
     
140.             break;
     
141.         }
     
142.         n_ioc = tmp / sizeof(struct spi_ioc_transfer);
     
143.         if (n_ioc== 0)
     
144.             break;
     
145. 
     
146.         /* copy into scratch area*/
     
147.         ioc = kmalloc(tmp, GFP_KERNEL);
     
148.         if (!ioc){
     
149.             retval = -ENOMEM;
     
150.             break;
     
151.         }
     
152.         if (__copy_from_user(ioc,(void __user *)arg, tmp)){
     
153.             kfree(ioc);
     
154.             retval = -EFAULT;
     
155.             break;
     
156.         }
     
157. 
     
158.         /* translateto spi_message, execute*/
     
159.         retval = spidev_message(spidev, ioc, n_ioc);
     
160.         kfree(ioc);
     
161.         break;
     
162.     }
     
163. 
     
164.     mutex_unlock(&spidev->buf_lock);
     
165.     spi_dev_put(spi);
     
166.     return retval;
     
167. }

        说明：

        1) 函数首先判断命令是否有效，如果无效，直接退出。

        2) 上互斥锁。

        3) switch分支中，前面的case都是支持对SPI设备的设置，包括模式、传输位、位方向和最大速率等。

        4) 在设置分支中，最后调用spi_setup实现设置，此函数最终是调用总线驱动中的gsc3280_spi_setup(struct spi_device *spi)

实现设置。

        5) default分支中是进行数据传输的分支，首先判断是否是有效的数据，如果不是，退出switch分支。

        6) 申请内存，复制从应用层传过来的数据。

        7) 调用spidev_message函数实现数据传输。

        8) 解互斥锁，退出。

        spidev_message函数如下：

点击(此处)折叠或打开

1. static int spidev_message(struct spidev_data*spidev,
   
2.         struct spi_ioc_transfer *u_xfers, unsigned n_xfers)
   
3. {
   
4.     struct spi_message    msg;
   
5.     struct spi_transfer    *k_xfers;
   
6.     struct spi_transfer    *k_tmp;
   
7.     struct spi_ioc_transfer *u_tmp;
   
8.     unsigned        n, total;
   
9.     u8            *buf;
   
10.     int            status = -EFAULT;
    
11. 
    
12.     spi_message_init(&msg);
    
13.     k_xfers = kcalloc(n_xfers, sizeof(*k_tmp), GFP_KERNEL);
    
14.     if (k_xfers== NULL)
    
15.         return -ENOMEM;
    
16. 
    
17.     /* Construct spi_message, copying any tx datato bounce buffer.
    
18.      * We walk the array of user-provided transfers, usingeach one
    
19.      * to initialize a kernel version of the same transfer.
    
20.      */
    
21.     buf = spidev->buffer;
    
22.     total = 0;
    
23.     for (n= n_xfers, k_tmp= k_xfers, u_tmp= u_xfers;
    
24.             n;
    
25.             n--, k_tmp++, u_tmp++){
    
26.         k_tmp->len= u_tmp->len;
    
27. 
    
28.         total += k_tmp->len;
    
29.         if (total> bufsiz) {
    
30.             status = -EMSGSIZE;
    
31.             goto done;
    
32.         }
    
33. 
    
34.         if (u_tmp->rx_buf){
    
35.             k_tmp->rx_buf= buf;
    
36.             if (!access_ok(VERIFY_WRITE,(u8 __user *)
    
37.                         (uintptr_t) u_tmp->rx_buf,
    
38.                         u_tmp->len))
    
39.                 goto done;
    
40.         }
    
41.         if (u_tmp->tx_buf){
    
42.             k_tmp->tx_buf= buf;
    
43.             if (copy_from_user(buf,(const u8 __user*)
    
44.                         (uintptr_t) u_tmp->tx_buf,
    
45.                     u_tmp->len))
    
46.                 goto done;
    
47.         }
    
48.         buf += k_tmp->len;
    
49. 
    
50.         k_tmp->cs_change= !!u_tmp->cs_change;
    
51.         k_tmp->bits_per_word= u_tmp->bits_per_word;
    
52.         k_tmp->delay_usecs= u_tmp->delay_usecs;
    
53.         k_tmp->speed_hz= u_tmp->speed_hz;
    
54. #ifdef VERBOSE
    
55.         dev_dbg(&spidev->spi->dev,
    
56.             " xfer len %zd %s%s%s%dbits %u usec %uHz\n",
    
57.             u_tmp->len,
    
58.             u_tmp->rx_buf? "rx " : "",
    
59.             u_tmp->tx_buf? "tx " : "",
    
60.             u_tmp->cs_change? "cs " : "",
    
61.             u_tmp->bits_per_word? : spidev->spi->bits_per_word,
    
62.             u_tmp->delay_usecs,
    
63.             u_tmp->speed_hz? : spidev->spi->max_speed_hz);
    
64. #endif
    
65.         spi_message_add_tail(k_tmp,&msg);
    
66.     }
    
67. 
    
68.     status = spidev_sync(spidev,&msg);
    
69.     if (status< 0)
    
70.         goto done;
    
71. 
    
72.     /* copy any rx data out of bounce buffer*/
    
73.     buf = spidev->buffer;
    
74.     for (n= n_xfers, u_tmp= u_xfers; n; n--, u_tmp++){
    
75.         if (u_tmp->rx_buf){
    
76.             if (__copy_to_user((u8 __user*)
    
77.                     (uintptr_t) u_tmp->rx_buf, buf,
    
78.                     u_tmp->len)){
    
79.                 status = -EFAULT;
    
80.                 goto done;
    
81.             }
    
82.         }
    
83.         buf += u_tmp->len;
    
84.     }
    
85.     status = total;
    
86. 
    
87. done:
    
88.     kfree(k_xfers);
    
89.     return status;
    
90. }

        说明：

        1) 申请传输的结构体内存。

        2) 通过for循环，对spi_ioc_transfer类型的数据进行转换。

        3) 转换中，首先对本次传输的数据大小进行累计，如果总传输量超出buf的大小，直接退出。

        4) 如果本次传输是接收，则设置接收数组，并对buf进行检查，查看是否可读。

        5) 如果本次传输是写，则从应用层拷贝数据。

        6) 对传输中参数进行赋值，包括速度、模式、速率等等。

        7) 调用spidev_sync进行数据传输。

        8) 将接收数据拷贝到应用层。

三、应用层

        在应用层提供了二中驱动的测试程序，在“/documenation/spi”目录下，文件名称为spidev_test.c中，具体程序如下：

点击(此处)折叠或打开

1. int main(int argc, char*argv[])
   
2. {
   
3.     int ret = 0;
   
4.     int fd;
   
5. 
   
6.     parse_opts(argc, argv);
   
7. 
   
8.     fd = open(device, O_RDWR);
   
9.     if (fd< 0)
   
10.         pabort("can't open device");
    
11. 
    
12.     /*
    
13.      * spi mode
    
14.      */
    
15.     ret = ioctl(fd, SPI_IOC_WR_MODE,&mode);
    
16.     if (ret== -1)
    
17.         pabort("can't set spi mode");
    
18. 
    
19.     ret = ioctl(fd, SPI_IOC_RD_MODE,&mode);
    
20.     if (ret== -1)
    
21.         pabort("can't get spi mode");
    
22. 
    
23.     /*
    
24.      * bits per word
    
25.      */
    
26.     ret = ioctl(fd, SPI_IOC_WR_BITS_PER_WORD,&bits);
    
27.     if (ret== -1)
    
28.         pabort("can't set bits per word");
    
29. 
    
30.     ret = ioctl(fd, SPI_IOC_RD_BITS_PER_WORD,&bits);
    
31.     if (ret== -1)
    
32.         pabort("can't get bits per word");
    
33. 
    
34.     /*
    
35.      * max speed hz
    
36.      */
    
37.     ret = ioctl(fd, SPI_IOC_WR_MAX_SPEED_HZ,&speed);
    
38.     if (ret== -1)
    
39.         pabort("can't set max speed hz");
    
40. 
    
41.     ret = ioctl(fd, SPI_IOC_RD_MAX_SPEED_HZ,&speed);
    
42.     if (ret== -1)
    
43.         pabort("can't get max speed hz");
    
44. 
    
45.     printf("spi mode: %d\n", mode);
    
46.     printf("bits per word: %d\n", bits);
    
47.     printf("max speed: %d Hz (%d KHz)\n", speed, speed/1000);
    
48. 
    
49.     transfer(fd);
    
50. 
    
51.     close(fd);
    
52. 
    
53.     return ret;
    
54. }

        说明：

        1) 首先打开设备。

        2) 然后设置工作模式、位大小和速率等。

        3) 传输数据

From:http://blog.chinaunix.net/uid-25445243-id-4059262.html