嵌入式Linux驱动——SPI子系统解读（三）

   第一部分，将对SPI子系统整体进行描述，同时给出SPI的相关数据结构，最后描述SPI总线的注册。

   第二部分，该文将对SPI的主控制器(master)驱动进行描述。

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

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

本文属于第三部分。

5. SPI设备驱动

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

         5.1 SPI设备驱动的注册

         SPI设备驱动的定义、注册、以及卸载，所在位置/kernel3.0/driver/spi/spidev.c

static const struct file_operations spidev_fops = {    .owner = THIS_MODULE,    .open  = spidev_open,                       .write = spidev_write,    .read  = spidev_read,    .release = spidev_release,    .llseek  = no_llseek,    .unlocked_ioctl = spidev_ioctl,    .compat_ioctl   = spidev_compat_ioctl,};static struct spi_driver spidev_spi_driver = {    .driver = {        .name  = "spidev",               //spi驱动和设备匹配的标识        .owner = THIS_MODULE,    },    .probe  = spidev_probe,    .remove = __devexit_p(spidev_remove),};static int __init spidev_init(void){    int status;        BUILD_BUG_ON(N_SPI_MINORS > 256);   //检查次设备号    status = register_chrdev(SPIDEV_MAJOR,"spi",&spidev_fops);    if(status < 0)                      //注册字符设备（可以在硬件的/proc/devices目录下查看）        return status;        spidev_class = class_create(THIS_MODULE,"spidev");    if(IS_ERR(spidev_class))            //创建spidev类（可以在/sys/bus/class下查看）    {        unregister_chrdev(SPIDEV_MAJOR,spidev_spi_driver.driver.name);        return PTR_ERR(spidev_class);    }        status = spi_register_driver(&spidev_spi_driver);    if(status < 0)                      //spi设备驱动的注册，深入追踪可以发现其调用了spidev_probe函数    {        class_destroy(spidev_class);        unregister_chrdev(SPIDEV_MAJOR,spidev_spi_driver.driver.name);    }    return status;};module_init(spidev_init);static void __exit spidev_exit(void){    spi_unregister_driver(&spidev_spi_driver);    class_destroy(spidev_class);    unregister_chrdev(SPIDEV_MAJOR,spidev_spi_driver.driver.name);};   module_exit(spidev_exit); 

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

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

         1、spi_register_driver函数， 该函数位于/kernel3.0/drivers/spi/spidev.c。

int spi_register_driver(struct spi_driver *sdrv){    sdrv->driver.bus = &spi_bus_type;    if(sdrv->probe)              //driver下的函数赋值        sdrv->driver.probe = spi_drv_probe;    if(sdrv->remove)                  sdrv->driver.remove = spi_drv_remove;    if(sdrv->shutdown)        sdrv->driver.shutdown = spi_drv_shutdown;    return driver_register(&sdrv->driver);}EXPORT_SYMBOL_GPL(spi_register_driver);        

         2、driver_register函数，该函数位于/kernel3.0/drivers/base/driver.c。

int driver_register(struct device_driver *drv){    int ret;    struct device_driver *other;        BUG_ON(!drv->bus->p);    if((drv->bus->probe && drv->probe) || (drv->bus->remove && drv->remove)        || (drv->bus->shutdown && drv->shutdown))        printk(KERN_WARNING "Driver '%s' needs updating -please use"             "bus_type methods\n",drv->name);    other = driver_find(drv->name,drv->bus);    if(other)    {        put_driver(other);        printk(KERN_ERR "Error: Driver '%s' is already registered, ""aborting...\n", drv->name);return -EBUSY;    }        ret = bus_add_driver(drv);    if(ret)        return ret;    ret = driver_add_groups(drv,drv->groups);    if(ret)        bus_remove_driver(drv);    return ret;}；EXPORT_SYMBOL_GPL(driver_register);  

         3、bus_add_driver函数，该函数位于/kernel3.0/drivers/base/bus.c。

int bus_add_driver(struct device_driver *drv){    struct bus_type *bus;    struct driver_private *priv;    int error = 0;        bus = bus_get(drv->bus);  //获取驱动对应的bus总线    if(!bus)        return -EINVAL;        pr_debug("bus: '%s':add driver %s\n",bus->name,drv->name);        priv = kalloc(sizeof(*priv),GFP_KERNEL);    if(!priv)    {        error = -ENOMEM;        goto out_put_bus;    }    klist_init(&priv->klist_devices,NULL,NULL);    priv->driver = drv;    drv->p = priv;    priv->kobj.kset = bus->p->drivers_kset;    error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,     "%s", drv->name);    if (error)    goto out_unregister;    if (drv->bus->p->drivers_autoprobe)    {    error = driver_attach(drv);    if (error)    goto out_unregister;    }    klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);    module_add_driver(drv->owner, drv);    error = driver_create_file(drv, &driver_attr_uevent);    if (error) {   printk(KERN_ERR "%s: uevent attr (%s) failed\n",    __func__, drv->name);    }    error = driver_add_attrs(bus, drv);    if (error) {    /* How the hell do we get out of this pickle? Give up */    printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",    __func__, drv->name);    }    if (!drv->suppress_bind_attrs) {    error = add_bind_files(drv);    if (error) {    /* Ditto */    printk(KERN_ERR "%s: add_bind_files(%s) failed\n",    __func__, drv->name);    }    }    kobject_uevent(&priv->kobj, KOBJ_ADD);    return 0;out_unregister:    kobject_put(&priv->kobj);    kfree(drv->p);    drv->p = NULL;out_put_bus:    bus_put(bus);return error;}

         4、driver_attech函数，该函数位于/kernel3.0/drivers/base/dd.c。

int driver_attach(struct device_driver *dev){    return bus_for_each_dev(dev->bus,NULL,drv,__driver_attach);}EXPORT_SYMBOL_GPL(driver_attach);/*往下追踪bus_for_each_dev函数，该函数位于/kernel3.0/drivers/base/bus.c*/int bus_for_each_dev(struct bus_type *bus, struct device *start,     void *data, int (*fn)(struct device *, void *)){    struct klist_iter i;    struct device *dev;    int error = 0;    if (!bus)    return -EINVAL;    klist_iter_init_node(&bus->p->klist_devices, &i,         (start ? &start->p->knode_bus : NULL));    while ((dev = next_device(&i)) && !error)    error = fn(dev, data);  //通过上一个函数，可以发现fn就是传进来的__driver_attach函数，    klist_iter_exit(&i);        //fn(dev,data) 也就是__driver_attach(dev,data)    return error;}EXPORT_SYMBOL_GPL(bus_for_each_dev);/*往下追踪__driver_attach函数，该函数位于/kernel3.0/drivers/base/dd.c*/static int __driver_attach(struct device *dev, void *data){    struct device_driver *drv = data;    /*     * Lock device and try to bind to it. We drop the error     * here and always return 0, because we need to keep trying     * to bind to devices and some drivers will return an error     * simply if it didn't support the device.     *     * driver_probe_device() will spit a warning if there     * is an error.     */    //在这里进行了驱动和设备的匹配    if (!driver_match_device(drv, dev))    //匹配(重点)    return 0;    if (dev->parent)/* Needed for USB */    device_lock(dev->parent);    device_lock(dev);    if (!dev->driver)    driver_probe_device(drv, dev);    //probe(重点)    device_unlock(dev);    if (dev->parent)    device_unlock(dev->parent);    return 0;}/*往下追踪driver_match_device函数，看看该函数是如何匹配的，*//*该函数位于/kernel3.0/drivers/base/base.h                 */static inline int driver_match_device(struct device_driver *drv,      struct device *dev){   //dri->bus->match = spi_match_device(该函数位于/kernel3.0/drivers/spi/spi.c里面)    //到此为止spi驱动和设备进行了匹配    return drv->bus->match ? drv->bus->match(dev, drv) : 1;}/*往下追踪driver_probe_device函数，看该函数是如何调用spi设备驱动的probe函数，*//*该函数位于/kernel3.0/drivers/base/dd.c*/int driver_probe_device(struct device_driver *drv, struct device *dev){    int ret = 0;    if (!device_is_registered(dev))    return -ENODEV;    pr_debug("bus: '%s': %s: matched device %s with driver %s\n",     drv->bus->name, __func__, dev_name(dev), drv->name);    pm_runtime_get_noresume(dev);    pm_runtime_barrier(dev);    ret = really_probe(dev, drv);    //(重点)    pm_runtime_put_sync(dev);    return ret;}/*往下追踪really_probe函数，在该函数中调用了SPI设备里面的probe函数，*//*该函数位于/kernel3.0/drivers/base/dd.c*/static int really_probe(struct device *dev, struct device_driver *drv){    int ret = 0;    atomic_inc(&probe_count);    pr_debug("bus: '%s': %s: probing driver %s with device %s\n",     drv->bus->name, __func__, drv->name, dev_name(dev));    WARN_ON(!list_empty(&dev->devres_head));    dev->driver = drv;    if (driver_sysfs_add(dev)) {    printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",    __func__, dev_name(dev));    goto probe_failed;    }    if (dev->bus->probe) {          //在这里进行了probe函数的调用    ret = dev->bus->probe(dev);     if (ret)    goto probe_failed;    } else if (drv->probe) {    ret = drv->probe(dev);    if (ret)    goto probe_failed;    }           driver_bound(dev);    ret = 1;    pr_debug("bus: '%s': %s: bound device %s to driver %s\n",     drv->bus->name, __func__, dev_name(dev), drv->name);    goto done;    probe_failed:    devres_release_all(dev);    driver_sysfs_remove(dev);    dev->driver = NULL;    if (ret != -ENODEV && ret != -ENXIO) {    /* driver matched but the probe failed */    printk(KERN_WARNING           "%s: probe of %s failed with error %d\n",           drv->name, dev_name(dev), ret);    }    /*     * Ignore errors returned by ->probe so that the next driver can try     * its luck.     */    ret = 0;done:    atomic_dec(&probe_count);    wake_up(&probe_waitqueue);    return ret;}  

 vi者相等

在该系列函数中，SPI设备驱动注册后，在driver_match_device函数中进行了SPI设备和SPI设备驱动的匹配，最后在really_probe函数中调用了spidev_probe函数。

5.2 SPI驱动函数分析

        1、spidev_probe函数，该函数位于/kernel3.0/drivers/spi/spidev.c。

static int __devinit spidev_probe(struct spi_device *spi){    struct spidev_data *spidev;    int status;    unsigned long minor;        /*申请一个spidev_data结构体空间*/    spidev = kzalloc(sizeof(*spidev),GFP_KERNEL);    if(!spidev)        return -ENOMEM;    /*初始化spidev结构体元素*/    spidev->spi = spi;                      //保存spi_device    spin_lock_init(&spidev->spi_lock);      //初始化自旋锁    mutex_init(&spidev->buf_lock);          //初始化互斥体        INIT_LIST_HEAD(&spidev->device_entry);  //初始化双向循环链表头         mutex_lock(&device_list_lock);          //上锁    /*在一个unsigned long类型的变量的位图中找到其第一个为0位的所在的位置即为minor(次设备号)的值*/    minor = find_first_zero_bit(minors,N_SPI_MINORS);    if(minor < N_SPI_MINORS)    {        struct device *dev;        spidev->devt = MKDEV(SPIDEV_MAJOR,minor);  //根据主次设备号获取设备号                /*在/dev下面创建spidev设备节点*/        dev = device_create(spidev_class,&spi->dev,spidev->devt,            spidev,"spidev%d.%d",spi->master->bus_num,spi->chip_select);        status = IS_ERR(dev) ? PTR_ERR(dev) : 0;    }    else    {        dev_dbg(&spi->dev,"no minor number available!\n");        status = -ENODEV;    }    if(status == 0)    {        set_bit(minor,minors);              //保存已使用的次设备号        list_add(&spidev->device_entry,&device_list); //在链表头list后面添加spidev条目    }    mutex_unlock(&device_list_lock);        //解锁        if(status == 0)        spi_set_drvdata(spi,spidev);    else        kfree(spidev);                    return status;      }              

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

        2、spidev_remove函数，该函数位于/kernel3.0/drivers/spi/spidev.c。

static int __devexit spidev_remove(struct spi_device *spi){    struct spidev_data *spidev = spi_get_drvdata(spi);        spin_lock_irq(&spidev->spi_lock);    spidev->spi = NULL;    spi_set_drvdata(spi,NULL);    spin_unlock_irq(&spidev->spi_lock);        mutex_lock(&device_list_lock);                 //上锁    list_del(&spidev->device_entry);               //将链表里的device_entry删除    device_destroy(spidev_class,spidev->devt);     //销毁/dev下的设备节点    clear_bit(MINOR(spidev->devt),minors);         //将位图中申请的次设备号的位置置0    if(spidev->users == 0)        kfree(spidev);    mutex_unlock(&device_list_lock);              //解锁        return 0;       }

        3、spidev_open函数，该函数位于/kernel3.0/drivers/spi/spidev.c。

static int spidev_open(struct *inode,struct file *filp){    struct spidev_data *spidev;    int     status = -ENXIO;        mutex_lock(&device_list_lock);              //上锁(多个程序调用open方法，但他们共享一个buffer，                                                //        因此对buufer需要进行互斥保护)    //从list头开始遍历entry，即遍历所有的spidev    list_for_each_entry(spidev,&device_list,device_entry)      {                                                  if(spidev->devt == inode->i_rdev)       //判断设备号是否相等        {            status = 0;                         //找到匹配的spi设备            break;        }    }        if(status == 0)    {        if(!spidev->buffer)        {   //分配buffer缓冲区,默认4KB            spidev->buffer = kmalloc(bufsiz,GFP_KERNEL);            if(!spidev->buffer)            {                dev_dbg(&spidev->spi->dev,"open/ENOMEX\n");                status = -ENOMEME;            }        }        if(status == 0)        {               spidev->users++;               //成功open后，用户增加            filp->private_data = spidev;   //将spidev保存到文件的私有指针里面            nonseekable_open(inode,filp);  //禁用lseek        }    }    else    {        pr_debug("spidev:nothing for minor %d\n",iminor(inode));    }    mutex_unlock(&device_list_lock);       //解锁    return status;}       

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

        4、spidev_release函数，该函数位于/kernel3.0/drivers/spi/spidev.c。

static int spidev_release(struct inode *inode,struct file *filp){    struct spidev_data *spidev;    int         status = 0;        mutex_lock(&device_list_lock);   //上锁    spidev = filp->private_data;     //将文件保存的数据给spidev    filp->private_data = NULL;       //清空文件的私有数据        spidev->users--;                 //用户减一    if(!spidev->users)               //如果用户为0    {        int dofree;                kfree(spidev->buffer);       //释放缓冲区        spidev->buffer = NULL;                spin_lock_irq(&spidev->spi_lock);        dofree = (spidev->spi == NULL);          spin_unlock_irq(&spidev->spi_lock);                if(dofree)            kfree(spidev);          //释放spidev,在probe中申请的    }    mutex_unlock(&device_list_lock);  //解锁        return status;}     

 至此，对于protocol驱动层的框架进行了简单的分析，在下一篇将对该驱动层很多未分析的函数进行一一讲解。