Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1079561
  • 博文数量: 146
  • 博客积分: 190
  • 博客等级: 入伍新兵
  • 技术积分: 5225
  • 用 户 组: 普通用户
  • 注册时间: 2012-06-06 08:24
个人简介

慢行者

文章分类

全部博文(146)

文章存档

2013年(145)

2012年(1)

分类: LINUX

2013-04-26 11:20:09

该系列文章将分为四个部分:

   第一部分,将对SPI子系统整体进行描述,同时给出SPI的相关数据结构,最后描述SPI总线的注册。基于S3C2440的嵌入式Linux驱动——SPI子系统解读(一)

   第二部分,该文将对SPI的主控制器(master)驱动进行描述。基于S3C2440的嵌入式Linux驱动——SPI子系统解读(二)

   第三部分,即本篇文章,该文将对SPI设备驱动,也称protocol 驱动,进行讲解。

   第四部分,通过SPI设备驱动留给用户层的API,我们将从上到下描述数据是如何通过SPI的protocol 驱动,由bitbang中转,最后由master驱动将数据传输出

                   去。 基于S3C2440的嵌入式Linux驱动——SPI子系统解读(四)

本文属于第部分。

5. SPI设备驱动

    在主控制器驱动中,spi_device已经注册了,在设备驱动中,首先要做的就是注册spi_driver,并提供用户层相应的API。

5.1 SPI设备驱动的注册

下列数据结构及函数位于drivers/spi/spidev.c。


[cpp]
  1. static 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.  
  14. /* The main reason to have this class is to make mdev/udev create the
  15. * /dev/spidevB.C character device nodes exposing our userspace API.
  16. * It also simplifies memory management.
  17. */ 
  18.  
  19. static struct class *spidev_class; 
  20.  
  21. static struct spi_driver spidev_spi = { 
  22.     .driver = { 
  23.         .name =        "spidev"
  24.         .owner =    THIS_MODULE, 
  25.     }, 
  26.     .probe =    spidev_probe, 
  27.     .remove =    __devexit_p(spidev_remove), 
  28.  
  29.     /* NOTE:  suspend/resume methods are not necessary here.
  30.      * We don't do anything except pass the requests to/from
  31.      * the underlying controller.  The refrigerator handles
  32.      * most issues; the controller driver handles the rest.
  33.      */ 
  34. }; 
  35.  
  36. static int __init spidev_init(void
  37.     int status; 
  38.  
  39.     /* Claim our 256 reserved device numbers.  Then register a class
  40.      * that will key udev/mdev to add/remove /dev nodes.  Last, register
  41.      * the driver which manages those device numbers.
  42.      */ 
  43.     BUILD_BUG_ON(N_SPI_MINORS > 256);    /*检查次设备号*/ 
  44.     status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops); /*注册字符设备,major=153*/ 
  45.     if (status < 0) 
  46.         return status; 
  47.  
  48.     spidev_class = class_create(THIS_MODULE, "spidev");     /*创建spidev类*/ 
  49.     if (IS_ERR(spidev_class)) { 
  50.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name); 
  51.         return PTR_ERR(spidev_class); 
  52.     } 
  53.  
  54.     status = spi_register_driver(&spidev_spi);      /*注册spi_driver,并调用probe方法*/ 
  55.     if (status < 0) { 
  56.         class_destroy(spidev_class); 
  57.         unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name); 
  58.     } 
  59.     return status; 
  60. module_init(spidev_init); 
  61.  
  62. static void __exit spidev_exit(void
  63.     spi_unregister_driver(&spidev_spi);         /*注销spi_driver*/ 
  64.     class_destroy(spidev_class);                /*注销类*/ 
  65.     unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);/*注销字符设备*/ 
  66. module_exit(spidev_exit); 


该函数中,创建了一个字符设备以提供API给用户层,同时创建了一个spidev类,最后注册spi_driver到内核中。


在这里我们看到了SPI设备驱动是如何提供API给用户层的,那就是通过再熟悉不过的字符设备。通过字符设备,给用户层提供了5个API:open,release,write,read和ioctl。本文在后面将介绍open和close,剩余3个将在本系列的第四篇文章中介绍。

接着看下spi_register_driver函数, 该函数位于drivers/spi/spidev.c。

[cpp]
  1. /**
  2. * spi_register_driver - register a SPI driver
  3. * @sdrv: the driver to register
  4. * Context: can sleep
  5. */ 
  6. int spi_register_driver(struct spi_driver *sdrv) 
  7.     sdrv->driver.bus = &spi_bus_type; 
  8.     if (sdrv->probe) 
  9.         sdrv->driver.probe = spi_drv_probe; 
  10.     if (sdrv->remove) 
  11.         sdrv->driver.remove = spi_drv_remove; 
  12.     if (sdrv->shutdown) 
  13.         sdrv->driver.shutdown = spi_drv_shutdown; 
  14.     return driver_register(&sdrv->driver); 
  15. EXPORT_SYMBOL_GPL(spi_register_driver); 


在调用driver_register的过程中,将用driver.name和spi_device的modalias字段进行比较,两者相等则将该spi_driver和spi_device进行绑定。


当spi_driver注册成功以后,将调用probe方法:spidev_probe函数。

5.2 probe方法

我们来看看spidev_probe这个函数,该函数位于drivers/spi/spidev.c。

[cpp]
  1. #define SPIDEV_MAJOR            153    /* assigned */ 
  2. #define N_SPI_MINORS            32    /* ... up to 256 */ 
  3.  
  4. static unsigned long    minors[N_SPI_MINORS / BITS_PER_LONG];    /**/ 
  5.  
  6. static LIST_HEAD(device_list); 
  7. static DEFINE_MUTEX(device_list_lock); 
  8.  
  9. static int spidev_probe(struct spi_device *spi) 
  10.     struct spidev_data  *spidev; 
  11.     int         status; 
  12.     unsigned long       minor; 
  13.  
  14.     /* Allocate driver data */ 
  15.     spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);  /*以kmalloc分配内存,并清0*/ 
  16.     if (!spidev) 
  17.         return -ENOMEM; 
  18.  
  19.     /* Initialize the driver data */ 
  20.     spidev->spi = spi;                   /*保存spi_device*/ 
  21.     spin_lock_init(&spidev->spi_lock);   /*初始化自旋锁*/ 
  22.     mutex_init(&spidev->buf_lock);       /*初始化互斥体*/ 
  23.  
  24.     INIT_LIST_HEAD(&spidev->device_entry);   /*初始化链表头,链表为双向循环链表*/ 
  25.  
  26.     /* If we can allocate a minor number, hook up this device.
  27.      * Reusing minors is fine so long as udev or mdev is working.
  28.      */ 
  29.     mutex_lock(&device_list_lock);      /*上锁*/ 
  30.     minor = find_first_zero_bit(minors, N_SPI_MINORS);  /*分配次设备号*/ 
  31.     if (minor < N_SPI_MINORS) { 
  32.         struct device *dev; 
  33.  
  34.         spidev->devt = MKDEV(SPIDEV_MAJOR, minor);   /*根据主次设备号来获取设备号*/ 
  35.         dev = device_create(spidev_class, &spi->dev, spidev->devt,    /*创建设备节点*/ 
  36.                     spidev, "spidev%d.%d"
  37.                     spi->master->bus_num, spi->chip_select); 
  38.         status = IS_ERR(dev) ? PTR_ERR(dev) : 0; 
  39.     } else
  40.         dev_dbg(&spi->dev, "no minor number available!\n"); 
  41.         status = -ENODEV; 
  42.     } 
  43.     if (status == 0) { 
  44.         set_bit(minor, minors);     /*保存已使用的次设备号*/ 
  45.         list_add(&spidev->device_entry, &device_list);/*在链表头list后面添加entry*/ 
  46.     } 
  47.     mutex_unlock(&device_list_lock);/*解锁互斥体*/ 
  48.  
  49.     if (status == 0) 
  50.         spi_set_drvdata(spi, spidev);/*spi->dev.driver_data=spidev*/ 
  51.     else 
  52.         kfree(spidev); 
  53.  
  54.     return status; 


其中用到的的struct spidev_data结构如下:


[cpp]
  1. struct spidev_data { 
  2.     dev_t            devt; 
  3.     spinlock_t        spi_lock; 
  4.     struct spi_device    *spi; 
  5.     struct list_head    device_entry; 
  6.  
  7.     /* buffer is NULL unless this device is open (users > 0) */ 
  8.     struct mutex        buf_lock; 
  9.     unsigned        users; 
  10.     u8            *buffer; 
  11. }; 
  12. "font-size: 12px;"
  13.  


   这个函数中,分配了spidev_data和次设备号,随后根据主次设备号创建了设备节点。设备节点的名字是spidev“bus_num””.chip_select",意思就是该设备是在第几个SPI接口上的第几个设备。

   此外,将spidev添加到device_list中,这样做就方便查找该spidev。

5.3 remove方法

下列函数位于drivers/spi/spidev.c。


[cpp]
  1. static int spidev_remove(struct spi_device *spi) 
  2.     struct spidev_data  *spidev = spi_get_drvdata(spi); 
  3.  
  4.     /* make sure ops on existing fds can abort cleanly */ 
  5.     spin_lock_irq(&spidev->spi_lock); 
  6.     spidev->spi = NULL; 
  7.     spi_set_drvdata(spi, NULL); 
  8.     spin_unlock_irq(&spidev->spi_lock); 
  9.  
  10.     /* prevent new opens */ 
  11.     mutex_lock(&device_list_lock); 
  12.     list_del(&spidev->device_entry); /*删除entry*/ 
  13.     device_destroy(spidev_class, spidev->devt);  /*删除设备节点*/ 
  14.     clear_bit(MINOR(spidev->devt), minors);/*删除使用的次设备号信息*/ 
  15.     if (spidev->users == 0) 
  16.         kfree(spidev); 
  17.     mutex_unlock(&device_list_lock); 
  18.  
  19.     return 0; 



6. open和release


接着来看下open和release系统调用的API接口,其余3个接口将在本系列的第四篇文章中给出。

6.1 open方法

下列函数位于drivers/spi/spidev.c。


[cpp]
  1. static int spidev_open(struct inode *inode, struct file *filp) 
  2.     struct spidev_data  *spidev; 
  3.     int         status = -ENXIO; 
  4.  
  5.     lock_kernel();          /*加锁大内核锁,可以睡眠,只能在进程上下文使用*/ 
  6.     mutex_lock(&device_list_lock);  /*加锁互斥体*/ 
  7.  
  8.     list_for_each_entry(spidev, &device_list, device_entry) {/*从list开始遍历entry,即遍历所有的spidev*/ 
  9.         if (spidev->devt == inode->i_rdev) {  /*判断设备号是否相等*/ 
  10.             status = 0;                         /*找到匹配的spi设备*/ 
  11.             break
  12.         } 
  13.     } 
  14.     if (status == 0) { 
  15.         /*NOTE:多个程序调用open方法,但他们共享一个buffer,因此对buufer需要进行互斥保护*/ 
  16.         if (!spidev->buffer) {           /*buffer为空*/  
  17.             spidev->buffer = kmalloc(bufsiz, GFP_KERNEL);/*分配buffer缓冲区,默认4KB*/ 
  18.             if (!spidev->buffer) { 
  19.                 dev_dbg(&spidev->spi->dev, "open/ENOMEM\n"); 
  20.                 status = -ENOMEM; 
  21.             } 
  22.         } 
  23.         if (status == 0) { 
  24.             spidev->users++;     /*成功open以后,增加用户计数*/ 
  25.             filp->private_data = spidev; /*保存spidev指针*/ 
  26.             nonseekable_open(inode, filp);  /*禁用lseek*/ 
  27.         } 
  28.     } else 
  29.         pr_debug("spidev: nothing for minor %d\n", iminor(inode)); 
  30.  
  31.     mutex_unlock(&device_list_lock);/*释放互斥体*/ 
  32.     unlock_kernel();                /*释放大内核锁*/ 
  33.     return status; 


在这里,以device_list为链表头,遍历所有的spidev_data结构,通过设备节点的设备号和spidev_data中保存的设备号进行匹配,来找到属于该设备节点的spi设备。随后,分配了spi设备驱动层所使用的缓冲区,最后增加打开计数。


6.2 release方法

下列函数位于drivers/spi/spidev.c。


[cpp]
  1. static int spidev_release(struct inode *inode, struct file *filp) 
  2.     struct spidev_data  *spidev; 
  3.     int         status = 0; 
  4.  
  5.     mutex_lock(&device_list_lock);  /*加锁互斥体*/ 
  6.     spidev = filp->private_data; /*获取spidev*/ 
  7.     filp->private_data = NULL;        
  8.  
  9.     /* last close? */ 
  10.     spidev->users--;             /*关闭设备文件,减少用户计数*/ 
  11.     if (!spidev->users) {            /*如果用户数为0*/ 
  12.         int     dofree; 
  13.  
  14.         kfree(spidev->buffer);       /*释放缓冲区*/ 
  15.         spidev->buffer = NULL; 
  16.  
  17.         /* ... after we unbound from the underlying device? */ 
  18.         spin_lock_irq(&spidev->spi_lock);    /*加锁互斥体*/ 
  19.         dofree = (spidev->spi == NULL);      /*????*/ 
  20.         spin_unlock_irq(&spidev->spi_lock);  /*释放互斥体*/ 
  21.  
  22.         if (dofree) 
  23.             kfree(spidev);          /*释放spidev,在probe中分配*/ 
  24.     } 
  25.     mutex_unlock(&device_list_lock);/*释放互斥体*/ 
  26.  
  27.     return status; 



至此,对于protocol驱动层的框架进行了简单的分析,在下一篇将对该驱动层很多未分析的函数进行一一讲解。下一篇的内容非常的重要哦。

阅读(2514) | 评论(0) | 转发(2) |
给主人留下些什么吧!~~