Linux spi驱动分析(二)----SPI核心(bus、device_driver和device)

1490阅读　0评论2017-05-29　Enlightener
分类：嵌入式

一、spi总线注册

        这里所说的SPI核心，就是指/drivers/spi/目录下spi.c文件中提供给其他文件的函数，首先看下spi核心的初始化函数spi_init(void)。程序如下：

点击(此处)折叠或打开

  1. static int __init spi_init(void)
  2. {
  3.     int    status;

  5.     buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
  6.     if (!buf) {
  7.         status = -ENOMEM;
  8.         goto err0;
  9.     }

  11.     status = bus_register(&spi_bus_type);
  12.     if (status < 0)
  13.         goto err1;

  15.     status = class_register(&spi_master_class);
  16.     if (status < 0)
  17.         goto err2;
  18.     return 0;

  20. err2:
  21.     bus_unregister(&spi_bus_type);
  22. err1:
  23.     kfree(buf);
  24.     buf = NULL;
  25. err0:
  26.     return status;
  27. }
  28. postcore_initcall(spi_init);

        说明：
        1) 由postcore_initcall(spi_init);可以看出，此宏在系统初始化时是先于module_init()执行的。

        2) 申请的buf空间用于在spi数据传输中。

        3) 接下来是总线注册和类注册，首先看下总线注册。

点击(此处)折叠或打开

  1. struct subsys_private {
  2.     struct kset subsys;
  3.     struct kset *devices_kset;

  5.     struct kset *drivers_kset;
  6.     struct klist klist_devices;
  7.     struct klist klist_drivers;
  8.     struct blocking_notifier_head bus_notifier;
  9.     unsigned int drivers_autoprobe:1;
  10.     struct bus_type *bus;

  12.     struct list_head class_interfaces;
  13.     struct kset glue_dirs;
  14.     struct mutex class_mutex;
  15.     struct class *class;
  16. };
  17. struct bus_type {
  18.     const char        *name;
  19.     struct bus_attribute    *bus_attrs;
  20.     struct device_attribute    *dev_attrs;
  21.     struct driver_attribute    *drv_attrs;

  23.     int (*match)(struct device *dev, struct device_driver *drv);
  24.     int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
  25.     int (*probe)(struct device *dev);
  26.     int (*remove)(struct device *dev);
  27.     void (*shutdown)(struct device *dev);

  29.     int (*suspend)(struct device *dev, pm_message_t state);
  30.     int (*resume)(struct device *dev);

  32.     const struct dev_pm_ops *pm;

  34.     struct subsys_private *p;
  35. };
  36. struct bus_type spi_bus_type = {
  37.     .name        = "spi",
  38.     .dev_attrs    = spi_dev_attrs,
  39.     .match        = spi_match_device,
  40.     .uevent        = spi_uevent,
  41.     .pm        = &spi_pm,
  42. };
  43. int bus_register(struct bus_type *bus)
  44. {
  45.     int retval;
  46.     struct subsys_private *priv;

  48.     priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
  49.     if (!priv)
  50.         return -ENOMEM;

  52.     priv->bus = bus;
  53.     bus->p = priv;

  55.     BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);
  56.     //总线的名字”spi”,我们说过了一个kobject对应一个目录，这里为这个目录赋值名字
  57.     retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
  58.     if (retval)
  59.         goto out;

  61.     priv->subsys.kobj.kset = bus_kset;
  62.     priv->subsys.kobj.ktype = &bus_ktype;
  63.     priv->drivers_autoprobe = 1;
  64.     //创建devices命名的目录
  65.     retval = kset_register(&priv->subsys);
  66.     if (retval)
  67.         goto out;
  68.     //创建属性文件
  69.     retval = bus_create_file(bus, &bus_attr_uevent);
  70.     if (retval)
  71.         goto bus_uevent_fail;

  73.     priv->devices_kset = kset_create_and_add("devices", NULL,
  74.                          &priv->subsys.kobj);
  75.     if (!priv->devices_kset) {
  76.         retval = -ENOMEM;
  77.         goto bus_devices_fail;
  78.     }

  80.     priv->drivers_kset = kset_create_and_add("drivers", NULL,
  81.                          &priv->subsys.kobj);
  82.     if (!priv->drivers_kset) {
  83.         retval = -ENOMEM;
  84.         goto bus_drivers_fail;
  85.     }

  87.     klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
  88.     klist_init(&priv->klist_drivers, NULL, NULL);

  90.     retval = add_probe_files(bus);    //添加探测属性
  91.     if (retval)
  92.         goto bus_probe_files_fail;

  94.     retval = bus_add_attrs(bus);    //添加其他属性
  95.     if (retval)
  96.         goto bus_attrs_fail;

  98.     pr_debug("bus: '%s': registered\n", bus->name);
  99.     return 0;

  101. bus_attrs_fail:
  102.     remove_probe_files(bus);
  103. bus_probe_files_fail:
  104.     kset_unregister(bus->p->drivers_kset);
  105. bus_drivers_fail:
  106.     kset_unregister(bus->p->devices_kset);
  107. bus_devices_fail:
  108.     bus_remove_file(bus, &bus_attr_uevent);
  109. bus_uevent_fail:
  110.     kset_unregister(&bus->p->subsys);
  111. out:
  112.     kfree(bus->p);
  113.     bus->p = NULL;
  114.     return retval;
  115. }

        说明：

        1)  首先不管是设备还是驱动，都是挂接在某条总线上的，也就是说我们根据总线类型的不同来区分各种设备和驱动。

        2) 从总线注册函数bus_register(struct bus_type *bus)中可以发现，首先申请了一个subsys_private结构体内存。该结构体中包含了三个kset结构，分别是struct kset subsys、struct kset *devices_kset和struct kset *drivers_kset。

        3) subsys是用来向上链接的。

        4) 当发现一个设备或者驱动的时候，对于每一次设备或者驱动注册(设备是被插入了，驱动就是.ko模块被加载)，都得分配一个device或者device_drive结构，每一次都需要将device结构挂入drivers或devices(kset结构)链表中，这样才能通过总线找到挂接在这个总线上的所有设备和驱动。这里仅仅将设备和驱动挂接在总线上，并不能表明设备和驱动之间的关系，这样的处理仅仅表明了驱动、设备与总线的关系，它们申明了我现在挂接在这条总线上，以后操作我就通过这条总线。

        5) 总线的目录名为”spi”。也就是说在/sys/bus目录下有一个spi目录，即。内核中有spi总线驱动，bus_register(&spi_bus_type)就是用来注册总线的，该函数调用完成后，就会在/sys/bus/目录下创建spi目录。

        接下来看下总线中spi_match_device()函数，此函数在(四)中的设备注册中会调用，如下：

点击(此处)折叠或打开

  1. static int spi_match_device(struct device *dev, struct device_driver *drv)
  2. {
  3.     const struct spi_device    *spi = to_spi_device(dev);
  4.     const struct spi_driver    *sdrv = to_spi_driver(drv);

  6.     /* Attempt an OF style match */
  7.     if (of_driver_match_device(dev, drv))
  8.         return 1;

  10.     if (sdrv->id_table)
  11.         return !!spi_match_id(sdrv->id_table, spi);

  13.     return strcmp(spi->modalias, drv->name) == 0;
  14. }

        说明：

        1) 首先查看驱动和设备是否匹配，如果不匹配，退出。

        2) 判断驱动中是否支持id数组，如果支持，查找匹配此id的spi_device。

        3) 比较设备的名字的和驱动的名字是否相同。

二、spi驱动注册

        在《Linux spi驱动分析(四)----SPI设备驱动(W25Q32BV)》中，执行语句spi_register_driver(&w25q_driver);，从而注册spi驱动。函数如下：

点击(此处)折叠或打开

  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. };
  10. static struct spi_driver w25q_driver = {
  11.     .driver    = {
  12.         .name    = "spi-w25q",
  13.         .owner    = THIS_MODULE,
  14.     },
  15.     //.id_table    = w25q_ids,
  16.     .probe    = w25q_probe,
  17.     .remove    = __devexit_p(w25q_remove),
  18. };
  19. int spi_register_driver(struct spi_driver *sdrv)
  20. {
  21.     sdrv->driver.bus = &spi_bus_type;
  22.     if (sdrv->probe)
  23.         sdrv->driver.probe = spi_drv_probe;
  24.     if (sdrv->remove)
  25.         sdrv->driver.remove = spi_drv_remove;
  26.     if (sdrv->shutdown)
  27.         sdrv->driver.shutdown = spi_drv_shutdown;
  28.     return driver_register(&sdrv->driver);
  29. }

        说明：

        1) 驱动是如何插入到/sys/bus/drivers/spi目录下的？在driver_register->driver_register->bus_add_driver函数中有个重要的语句drv->kobj.kset = &bus->drivers，这里就是将driver的kobj所属的kset挂接上总线的kset。

        2) 在struct spi_driver中指明驱动的名称，这里是"spi-w25q"。

        3) spi_register_driver()函数的参数为spi_driver结构。函数定义了bus_type，也就是驱动挂接的总线类型。函数接下来对结构体spi_driver中的device_driver成员赋值。

        4) 驱动注册，程序如下：

点击(此处)折叠或打开

  1. struct device_driver {
  2.     const char        *name; //设备驱动的名字
  3.     struct bus_type        *bus; //设备驱动挂接的总线类型

  5.     struct module        *owner;
  6.     const char        *mod_name;    /* used for built-in modules */

  8.     bool suppress_bind_attrs;    /* disables bind/unbind via sysfs */

  10.     const struct of_device_id    *of_match_table;

  12.     int (*probe) (struct device *dev);
  13.     int (*remove) (struct device *dev);
  14.     void (*shutdown) (struct device *dev);
  15.     int (*suspend) (struct device *dev, pm_message_t state);
  16.     int (*resume) (struct device *dev);
  17.     const struct attribute_group **groups;

  19.     const struct dev_pm_ops *pm;

  21.     struct driver_private *p;
  22. };
  23. int driver_register(struct device_driver *drv)
  24. {
  25.     int ret;
  26.     struct device_driver *other;

  28.     BUG_ON(!drv->bus->p);

  30.     if ((drv->bus->probe && drv->probe) ||
  31.      (drv->bus->remove && drv->remove) ||
  32.      (drv->bus->shutdown && drv->shutdown))
  33.         printk(KERN_WARNING "Driver '%s' needs updating - please use "
  34.             "bus_type methods\n", drv->name);
  35.     /* 在kobject结构组成的链表中查找是否已经存在这个驱动,前面讲过,驱动必然挂接在某个总线
  36.        上，返回值是device_driver结构的指针 */
  37.     other = driver_find(drv->name, drv->bus);
  38.     if (other) {
  39.         put_driver(other);
  40.         printk(KERN_ERR "Error: Driver '%s' is already registered, "
  41.             "aborting...\n", drv->name);
  42.         return -EBUSY;
  43.     }

  45.     ret = bus_add_driver(drv);
  46.     if (ret)
  47.         return ret;
  48.     ret = driver_add_groups(drv, drv->groups);
  49.     if (ret)
  50.         bus_remove_driver(drv);
  51.     return ret;
  52. }

        说明：

        1) driver_register()完成挂接驱动至总线及生成设备树的过程。

        2) 首先调用driver_find()函数在spi总线上查找该驱动是否已经存在，如果存在，忙退出。

        3) 如果该驱动在SPI总线上不存在，调用bus_add_driver(drv)增加该驱动。

        4) 调用driver_add_groups(drv, drv->groups)函数增加驱动组。

        接下来看bus_add_driver函数，程序如下：

点击(此处)折叠或打开

  1. int bus_add_driver(struct device_driver *drv)
  2. {
  3.     struct bus_type *bus;
  4.     struct driver_private *priv;
  5.     int error = 0;

  7.     bus = bus_get(drv->bus);
  8.     if (!bus)
  9.         return -EINVAL;

  11.     pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);

  13.     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
  14.     if (!priv) {
  15.         error = -ENOMEM;
  16.         goto out_put_bus;
  17.     }
  18.     klist_init(&priv->klist_devices, NULL, NULL);
  19.     priv->driver = drv;
  20.     drv->p = priv;
  21.     priv->kobj.kset = bus->p->drivers_kset;
  22.     error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
  23.                  "%s", drv->name);
  24.     if (error)
  25.         goto out_unregister;

  27.     if (drv->bus->p->drivers_autoprobe) {
  28.         error = driver_attach(drv);     //这个函数是重点.
  29.         if (error)
  30.             goto out_unregister;
  31.     }
  32.     klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
  33.     module_add_driver(drv->owner, drv);

  35.     error = driver_create_file(drv, &driver_attr_uevent);
  36.     if (error) {
  37.         printk(KERN_ERR "%s: uevent attr (%s) failed\n",
  38.             __func__, drv->name);
  39.     }
  40.     error = driver_add_attrs(bus, drv);
  41.     if (error) {
  42.         /* How the hell do we get out of this pickle? Give up */
  43.         printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
  44.             __func__, drv->name);
  45.     }

  47.     if (!drv->suppress_bind_attrs) {
  48.         error = add_bind_files(drv);
  49.         if (error) {
  50.             /* Ditto */
  51.             printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
  52.                 __func__, drv->name);
  53.         }
  54.     }

  56.     kobject_uevent(&priv->kobj, KOBJ_ADD);
  57.     return 0;

  59. out_unregister:
  60.     kobject_put(&priv->kobj);
  61.     kfree(drv->p);
  62.     drv->p = NULL;
  63. out_put_bus:
  64.     bus_put(bus);
  65.     return error;
  66. }

        说明：

        1) 首先创建struct driver_private *priv结构体内存，注意此结构体是struct device_driver的成员变量。

        2) 初始化priv成员变量。

        3) 如果驱动总线支持自动探测，则调用error = driver_attach(drv); 实现探测。由(二)中bus_register()函数可以看出，bus->p->drivers_autoprobe = 1，支持自动探测。

        4) driver_attach(drv); 的作用是：如果驱动还未挂接在总线上，挂接它并且调用probe函数进行探测。

点击(此处)折叠或打开

  1. int driver_attach(struct device_driver *drv)
  2. {
  3.     return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
  4. }
        这个函数会调用__driver_attach函数，如下：

点击(此处)折叠或打开

  1. static int __driver_attach(struct device *dev, void *data)
  2. {
  3.     struct device_driver *drv = data;

  5.     /*
  6.      * Lock device and try to bind to it. We drop the error
  7.      * here and always return 0, because we need to keep trying
  8.      * to bind to devices and some drivers will return an error
  9.      * simply if it didn't support the device.
  10.      *
  11.      * driver_probe_device() will spit a warning if there
  12.      * is an error.
  13.      */

  15.     if (!driver_match_device(drv, dev))
  16.         return 0;

  18.     if (dev->parent)    /* Needed for USB */
  19.         device_lock(dev->parent);
  20.     device_lock(dev);
  21.     if (!dev->driver)
  22.         driver_probe_device(drv, dev);    //此函数就是我们要找的函数
  23.     device_unlock(dev);
  24.     if (dev->parent)
  25.         device_unlock(dev->parent);

  27.     return 0;
  28. }
        driver_probe_device()函数如下：

点击(此处)折叠或打开

  1. int driver_probe_device(struct device_driver *drv, struct device *dev)
  2. {
  3.     int ret = 0;

  5.     if (!device_is_registered(dev))
  6.         return -ENODEV;

  8.     pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
  9.          drv->bus->name, __func__, dev_name(dev), drv->name);

  11.     pm_runtime_get_noresume(dev);
  12.     pm_runtime_barrier(dev);
  13.     ret = really_probe(dev, drv);
  14.     pm_runtime_put_sync(dev);

  16.     return ret;
  17. }
          driver_probe_device函数中有一个really_probe函数,这是我们的最终目的地。

点击(此处)折叠或打开

  1. static int really_probe(struct device *dev, struct device_driver *drv)
  2. {
  3.     int ret = 0;

  5.     atomic_inc(&probe_count);
  6.     pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
  7.          drv->bus->name, __func__, drv->name, dev_name(dev));
  8.     WARN_ON(!list_empty(&dev->devres_head));

  10.     dev->driver = drv;
  11.     if (driver_sysfs_add(dev)) {
  12.         printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
  13.             __func__, dev_name(dev));
  14.         goto probe_failed;
  15.     }

  16.
  17.     if (dev->bus->probe) {
  18.         ret = dev->bus->probe(dev);
  19.         if (ret)
  20.             goto probe_failed;
  21.     } else if (drv->probe) {
  22.         ret = drv->probe(dev);
  23.         if (ret)
  24.             goto probe_failed;
  25.     }

  27.     driver_bound(dev);
  28.     ret = 1;
  29.     pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
  30.          drv->bus->name, __func__, dev_name(dev), drv->name);
  31.     goto done;

  33. probe_failed:
  34.     devres_release_all(dev);
  35.     driver_sysfs_remove(dev);
  36.     dev->driver = NULL;

  38.     if (ret != -ENODEV && ret != -ENXIO) {
  39.         /* driver matched but the probe failed */
  40.         printk(KERN_WARNING
  41.          "%s: probe of %s failed with error %d\n",
  42.          drv->name, dev_name(dev), ret);
  43.     }
  44.     /*
  45.      * Ignore errors returned by ->probe so that the next driver can try
  46.      * its luck.
  47.      */
  48.     ret = 0;
  49. done:
  50.     atomic_dec(&probe_count);
  51.     wake_up(&probe_waitqueue);
  52.     return ret;
  53. }

        说明：

        1) 在if (dev->bus->probe)中，由于此处还没有定义设备，所以不执行if里面的程序。在else if (drv->probe)中，驱动里面有探测函数，所以执行ret = drv->probe(dev);。因为此处还没有定义设备，所以此处执行没有效果。

        在 bus_for_each_dev函数中可以找到device结构：

点击(此处)折叠或打开

  1. int bus_for_each_dev(struct bus_type *bus, struct device *start,
  2.          void *data, int (*fn)(struct device *, void *))
  3. {
  4.     struct klist_iter i;
  5.     struct device *dev;
  6.     int error = 0;

  8.     if (!bus)
  9.         return -EINVAL;

  11.     klist_iter_init_node(&bus->p->klist_devices, &i,
  12.              (start ? &start->p->knode_bus : NULL));
  13.    
  14.     while ((dev = next_device(&i)) && !error)
  15.         error = fn(dev, data);
  16.     klist_iter_exit(&i);
  17.     return error;
  18. }

        说明：

        1) 查找每个挂接在spi总线上的设备，看他们是否有注册，并调用相应的函数也就是__driver_attach函数。实际上就是查找device结构。

三、spi设备注册

        在《Linux spi驱动分析(一)----总线驱动》中，spi_new_device()函数调用了spi_add_device(proxy)，程序如下：

点击(此处)折叠或打开

  1. struct device {
  2.     struct device        *parent;

  4.     struct device_private    *p;

  6.     struct kobject kobj;
  7.     const char        *init_name; /* initial name of the device */
  8.     const struct device_type *type;

  10.     struct mutex        mutex;    /* mutex to synchronize calls to
  11.                      * its driver.
  12.                      */

  14.     struct bus_type    *bus;        /* type of bus device is on */
  15.     struct device_driver *driver;    /* which driver has allocated this
  16.                      device */
  17.     void        *platform_data;    /* Platform specific data, device
  18.                      core doesn't touch it */
  19.     struct dev_pm_info    power;
  20.     struct dev_power_domain    *pwr_domain;

  22. #ifdef CONFIG_NUMA
  23.     int        numa_node;    /* NUMA node this device is close to */
  24. #endif
  25.     u64        *dma_mask;    /* dma mask (if dma'able device) */
  26.     u64        coherent_dma_mask;/* Like dma_mask, but for
  27.                      alloc_coherent mappings as
  28.                      not all hardware supports
  29.                      64 bit addresses for consistent
  30.                      allocations such descriptors. */

  32.     struct device_dma_parameters *dma_parms;

  34.     struct list_head    dma_pools;    /* dma pools (if dma'ble) */

  36.     struct dma_coherent_mem    *dma_mem; /* internal for coherent mem
  37.                      override */
  38.     /* arch specific additions */
  39.     struct dev_archdata    archdata;

  41.     struct device_node    *of_node; /* associated device tree node */

  43.     dev_t            devt;    /* dev_t, creates the sysfs "dev" */

  45.     spinlock_t        devres_lock;
  46.     struct list_head    devres_head;

  48.     struct klist_node    knode_class;
  49.     struct class        *class;
  50.     const struct attribute_group **groups;    /* optional groups */

  52.     void    (*release)(struct device *dev);
  53. };
  54. int spi_add_device(struct spi_device *spi)
  55. {
  56.     static DEFINE_MUTEX(spi_add_lock);
  57.     struct device *dev = spi->master->dev.parent;
  58.     struct device *d;
  59.     int status;

  61.     /* Chipselects are numbered 0..max; validate. */
  62.     if (spi->chip_select >= spi->master->num_chipselect) {
  63.         dev_err(dev, "cs%d >= max %d\n",
  64.             spi->chip_select,
  65.             spi->master->num_chipselect);
  66.         return -EINVAL;
  67.     }

  69.     /* Set the bus ID string */
  70.     dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
  71.             spi->chip_select);


  74.     /* We need to make sure there's no other device with this
  75.      * chipselect **BEFORE** we call setup(), else we'll trash
  76.      * its configuration. Lock against concurrent add() calls.
  77.      */
  78.     mutex_lock(&spi_add_lock);

  80.     d = bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev));
  81.     if (d != NULL) {
  82.         dev_err(dev, "chipselect %d already in use\n",
  83.                 spi->chip_select);
  84.         put_device(d);
  85.         status = -EBUSY;
  86.         goto done;
  87.     }

  89.     /* Drivers may modify this initial i/o setup, but will
  90.      * normally rely on the device being setup. Devices
  91.      * using SPI_CS_HIGH can't coexist well otherwise...
  92.      */
  93.     status = spi_setup(spi);
  94.     if (status < 0) {
  95.         dev_err(dev, "can't setup %s, status %d\n",
  96.                 dev_name(&spi->dev), status);
  97.         goto done;
  98.     }

  100.     /* Device may be bound to an active driver when this returns */
  101.     status = device_add(&spi->dev);
  102.     if (status < 0)
  103.         dev_err(dev, "can't add %s, status %d\n",
  104.                 dev_name(&spi->dev), status);
  105.     else
  106.         dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));

  108. done:
  109.     mutex_unlock(&spi_add_lock);
  110.     return status;
  111. }

        说明：

        1) 在设备device的定义中，定义了这个设备挂接的总线和驱动。

        2) spi_add_device()函数首先判断是否超出最大设备数，如果超过，直接退出。

        3) 设置设备名称，此名称即是/sys/bus/spi/devices/下的一个目录。

        4) 在spi总线上寻找此设备，如果找到，退出。

        5) 调用spi_setup(spi)函数。

        6) 调用device_add(&spi->dev)函数对设备进行初始化和注册。程序如下：

点击(此处)折叠或打开

  1. int device_add(struct device *dev)
  2. {
  3.     struct device *parent = NULL;
  4.     struct class_interface *class_intf;
  5.     int error = -EINVAL;

  7.     dev = get_device(dev);
  8.     if (!dev)
  9.         goto done;

  11.     if (!dev->p) {
  12.         error = device_private_init(dev);
  13.         if (error)
  14.             goto done;
  15.     }

  17.     /*
  18.      * for statically allocated devices, which should all be converted
  19.      * some day, we need to initialize the name. We prevent reading back
  20.      * the name, and force the use of dev_name()
  21.      */
  22.     if (dev->init_name) {
  23.         dev_set_name(dev, "%s", dev->init_name);
  24.         dev->init_name = NULL;
  25.     }

  27.     if (!dev_name(dev)) {
  28.         error = -EINVAL;
  29.         goto name_error;
  30.     }

  32.     pr_debug("device: '%s': %s\n", dev_name(dev), __func__);

  34.     parent = get_device(dev->parent);
  35.     setup_parent(dev, parent);

  37.     /* use parent numa_node */
  38.     if (parent)
  39.         set_dev_node(dev, dev_to_node(parent));

  41.     /* first, register with generic layer. */
  42.     /* we require the name to be set before, and pass NULL */
  43.     error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);
  44.     if (error)
  45.         goto Error;

  47.     /* notify platform of device entry */
  48.     if (platform_notify)
  49.         platform_notify(dev);

  51.     error = device_create_file(dev, &uevent_attr);
  52.     if (error)
  53.         goto attrError;

  55.     if (MAJOR(dev->devt)) {
  56.         error = device_create_file(dev, &devt_attr);
  57.         if (error)
  58.             goto ueventattrError;

  60.         error = device_create_sys_dev_entry(dev);
  61.         if (error)
  62.             goto devtattrError;

  64.         devtmpfs_create_node(dev);
  65.     }

  67.     error = device_add_class_symlinks(dev);
  68.     if (error)
  69.         goto SymlinkError;
  70.     error = device_add_attrs(dev);
  71.     if (error)
  72.         goto AttrsError;
  73.     error = bus_add_device(dev);
  74.     if (error)
  75.         goto BusError;
  76.     error = dpm_sysfs_add(dev);
  77.     if (error)
  78.         goto DPMError;
  79.     device_pm_add(dev);

  81.     /* Notify clients of device addition. This call must come
  82.      * after dpm_sysf_add() and before kobject_uevent().
  83.      */
  84.     if (dev->bus)
  85.         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
  86.                      BUS_NOTIFY_ADD_DEVICE, dev);

  88.     kobject_uevent(&dev->kobj, KOBJ_ADD);
  89.     bus_probe_device(dev);
  90.     if (parent)
  91.         klist_add_tail(&dev->p->knode_parent,
  92.              &parent->p->klist_children);

  94.     if (dev->class) {
  95.         mutex_lock(&dev->class->p->class_mutex);
  96.         /* tie the class to the device */
  97.         klist_add_tail(&dev->knode_class,
  98.              &dev->class->p->klist_devices);

  100.         /* notify any interfaces that the device is here */
  101.         list_for_each_entry(class_intf,
  102.                  &dev->class->p->class_interfaces, node)
  103.             if (class_intf->add_dev)
  104.                 class_intf->add_dev(dev, class_intf);
  105.         mutex_unlock(&dev->class->p->class_mutex);
  106.     }
  107. done:
  108.     put_device(dev);
  109.     return error;
  110.  DPMError:
  111.     bus_remove_device(dev);
  112.  BusError:
  113.     device_remove_attrs(dev);
  114.  AttrsError:
  115.     device_remove_class_symlinks(dev);
  116.  SymlinkError:
  117.     if (MAJOR(dev->devt))
  118.         devtmpfs_delete_node(dev);
  119.     if (MAJOR(dev->devt))
  120.         device_remove_sys_dev_entry(dev);
  121.  devtattrError:
  122.     if (MAJOR(dev->devt))
  123.         device_remove_file(dev, &devt_attr);
  124.  ueventattrError:
  125.     device_remove_file(dev, &uevent_attr);
  126.  attrError:
  127.     kobject_uevent(&dev->kobj, KOBJ_REMOVE);
  128.     kobject_del(&dev->kobj);
  129.  Error:
  130.     cleanup_device_parent(dev);
  131.     if (parent)
  132.         put_device(parent);
  133. name_error:
  134.     kfree(dev->p);
  135.     dev->p = NULL;
  136.     goto done;
  137. }

          说明：

          1) 首先获取设备dev，对dev的成员进行初始化。

          2) kobject_add()完成目录的创建。

          3) 创建文件。

          4) bus_probe_device(dev);，总线探测设备，程序如下：

点击(此处)折叠或打开

  1. void bus_probe_device(struct device *dev)
  2. {
  3.     struct bus_type *bus = dev->bus;
  4.     int ret;

  6.     if (bus && bus->p->drivers_autoprobe) {
  7.         ret = device_attach(dev);
  8.         WARN_ON(ret < 0);
  9.     }
  10. }
  11. int device_attach(struct device *dev)
  12. {
  13.     int ret = 0;

  15.     device_lock(dev);
  16.     if (dev->driver) {
  17.         if (klist_node_attached(&dev->p->knode_driver)) {
  18.             ret = 1;
  19.             goto out_unlock;
  20.         }
  21.         ret = device_bind_driver(dev);
  22.         if (ret == 0)
  23.             ret = 1;
  24.         else {
  25.             dev->driver = NULL;
  26.             ret = 0;
  27.         }
  28.     } else {
  29.         pm_runtime_get_noresume(dev);
  30.         ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
  31.         pm_runtime_put_sync(dev);
  32.     }
  33. out_unlock:
  34.     device_unlock(dev);
  35.     return ret;
  36. }

        说明：
        1) 由(二)中的总线注册函数可知，bus->p->drivers_autoprobe = 1。

        2) 调用device_attach()函数加载设备。

        3) 由于程序还没有对dev->driver进行赋值，所以此处程序走的是else。

        4) bus_for_each_drv()函数调用__device_attach()函数，程序如下：

点击(此处)折叠或打开

  1. int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
  2.          void *data, int (*fn)(struct device_driver *, void *))
  3. {
  4.     struct klist_iter i;
  5.     struct device_driver *drv;
  6.     int error = 0;

  8.     if (!bus)
  9.         return -EINVAL;

  11.     klist_iter_init_node(&bus->p->klist_drivers, &i,
  12.              start ? &start->p->knode_bus : NULL);
  13.     while ((drv = next_driver(&i)) && !error)
  14.         error = fn(drv, data);
  15.     klist_iter_exit(&i);
  16.     return error;
  17. }
  18. static inline int driver_match_device(struct device_driver *drv,
  19.                  struct device *dev)
  20. {
  21.     return drv->bus->match ? drv->bus->match(dev, drv) : 1;
  22. }
  23. static int __device_attach(struct device_driver *drv, void *data)
  24. {
  25.     struct device *dev = data;

  27.     if (!driver_match_device(drv, dev))
  28.         return 0;

  30.     return driver_probe_device(drv, dev);
  31. }

        说明：          
        1) __device_attach()函数使用了两个参数，一个参数为dev，另外一个就是bus_for_each_drv()函数提供的。

        2) __device_attach()函数首先使用函数driver_match_device(drv, dev)查看驱动是否匹配设备，如果不匹配，退出。driver_match_device(drv, dev)中，判断是否有drv->bus->match，从(二)总线注册中知道，总线中有match，所以调用(二)中的spi_match_device()函数。

         3) driver_probe_device()函数完成驱动探测，程序如下：

点击(此处)折叠或打开

  1. int driver_probe_device(struct device_driver *drv, struct device *dev)
  2. {
  3.     int ret = 0;

  5.     if (!device_is_registered(dev))
  6.         return -ENODEV;

  8.     pr_debug("bus: '%s': %s: matched device %s with driver %s\n",
  9.          drv->bus->name, __func__, dev_name(dev), drv->name);

  11.     pm_runtime_get_noresume(dev);
  12.     pm_runtime_barrier(dev);
  13.     ret = really_probe(dev, drv);
  14.     pm_runtime_put_sync(dev);

  16.     return ret;
  17. }
  18. static int really_probe(struct device *dev, struct device_driver *drv)
  19. {
  20.     int ret = 0;

  22.     atomic_inc(&probe_count);
  23.     pr_debug("bus: '%s': %s: probing driver %s with device %s\n",
  24.          drv->bus->name, __func__, drv->name, dev_name(dev));
  25.     WARN_ON(!list_empty(&dev->devres_head));

  27.     dev->driver = drv;
  28.     if (driver_sysfs_add(dev)) {
  29.         printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",
  30.             __func__, dev_name(dev));
  31.         goto probe_failed;
  32.     }

  34.     if (dev->bus->probe) {
  35.         ret = dev->bus->probe(dev);
  36.         if (ret)
  37.             goto probe_failed;
  38.     } else if (drv->probe) {
  39.         ret = drv->probe(dev);
  40.         if (ret)
  41.             goto probe_failed;
  42.     }

  44.     driver_bound(dev);
  45.     ret = 1;
  46.     pr_debug("bus: '%s': %s: bound device %s to driver %s\n",
  47.          drv->bus->name, __func__, dev_name(dev), drv->name);
  48.     goto done;

  50. probe_failed:
  51.     devres_release_all(dev);
  52.     driver_sysfs_remove(dev);
  53.     dev->driver = NULL;

  55.     if (ret != -ENODEV && ret != -ENXIO) {
  56.         /* driver matched but the probe failed */
  57.         printk(KERN_WARNING
  58.          "%s: probe of %s failed with error %d\n",
  59.          drv->name, dev_name(dev), ret);
  60.     }
  61.     /*
  62.      * Ignore errors returned by ->probe so that the next driver can try
  63.      * its luck.
  64.      */
  65.     ret = 0;
  66. done:
  67.     atomic_dec(&probe_count);
  68.     wake_up(&probe_waitqueue);
  69.     return ret;
  70. }

        说明：

        1) driver_probe_device()函数调用really_probe()函数。

        2) 在really_probe()函数中，由于设备的总线中没有探测函数，所以不执行if (dev->bus->probe)。

        3) spi驱动中有探测函数，所以执行else if (drv->probe)里面的程序，即ret = drv->probe(dev);，从(三)中的int spi_register_driver(struct spi_driver *sdrv)函数可以看到，驱动的探测函数为spi_drv_probe()，程序如下：

点击(此处)折叠或打开

  1. static int spi_drv_probe(struct device *dev)
  2. {
  3.     const struct spi_driver        *sdrv = to_spi_driver(dev->driver);

  5.     return sdrv->probe(to_spi_device(dev));
  6. }

        说明：

        1) 首先获取spi_driver结构体。

        2) 调用spi_driver结构体中的探测函数，即为(三)中的w25q_probe()函数。
        在really_probe()函数中，调用driver_bound(dev);函数实现设备与驱动的绑定，程序如下：

点击(此处)折叠或打开

  1. static void driver_bound(struct device *dev)
  2. {
  3.     if (klist_node_attached(&dev->p->knode_driver)) {
  4.         printk(KERN_WARNING "%s: device %s already bound\n",
  5.             __func__, kobject_name(&dev->kobj));
  6.         return;
  7.     }

  9.     pr_debug("driver: '%s': %s: bound to device '%s'\n", dev_name(dev),
  10.          __func__, dev->driver->name);

  12.     klist_add_tail(&dev->p->knode_driver, &dev->driver->p->klist_devices);

  14.     if (dev->bus)
  15.         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,
  16.                      BUS_NOTIFY_BOUND_DRIVER, dev);
  17. }

        说明：

        1) 使用klist_add_tail()将设备与驱动链接在一起。

四、总结

        在device和device_drive结构中，device中存在一个struct device_driver *driver，而在device_drive中并没有同样的包含device结构。对于一个设备来说，只能绑定一个驱动；而对于一个驱动来说，可以对应多个设备。 也就是说这里device中的driver指针将会指向其绑定的驱动。回到probe探测函数，对一个设备驱动进行注册的过程中，会在其相应的总线（也就是其挂接的总线）上发出一个探测，这个探测会搜寻所有挂接在这个总线上的尚未被绑定的设备（也就是driver指针为NULL），然后将driver指针指向这个驱动的结构，同时将这个设备的device结构挂接在device_driver结构中的klist链表中。 当一个设备被注册时，它也会去寻找挂接在同一条总线上的驱动，并将自己与这个驱动联系起来。

五、spi传输函数

        spi核心提供了数据传输函数，如下：

点击(此处)折叠或打开

  1. static inline void spi_message_init(struct spi_message *m)
  2. {
  3.     memset(m, 0, sizeof *m);
  4.     INIT_LIST_HEAD(&m->transfers);
  5. }
  6. static inline void
  7. spi_message_add_tail(struct spi_transfer *t, struct spi_message *m)
  8. {
  9.     list_add_tail(&t->transfer_list, &m->transfers);
  10. }
  11. static inline int
  12. spi_write(struct spi_device *spi, const void *buf, size_t len)
  13. {
  14.     struct spi_transfer    t = {
  15.             .tx_buf        = buf,
  16.             .len        = len,
  17.         };
  18.     struct spi_message    m;

  20.     spi_message_init(&m);
  21.     spi_message_add_tail(&t, &m);
  22.     return spi_sync(spi, &m);
  23. }
  24. static inline int
  25. spi_read(struct spi_device *spi, void *buf, size_t len)
  26. {
  27.     struct spi_transfer    t = {
  28.             .rx_buf        = buf,
  29.             .len        = len,
  30.         };
  31.     struct spi_message    m;

  33.     spi_message_init(&m);
  34.     spi_message_add_tail(&t, &m);
  35.     return spi_sync(spi, &m);
  36. }
  37. static inline ssize_t spi_w8r8(struct spi_device *spi, u8 cmd)
  38. {
  39.     ssize_t            status;
  40.     u8            result;

  42.     status = spi_write_then_read(spi, &cmd, 1, &result, 1);

  44.     /* return negative errno or unsigned value */
  45.     return (status < 0) ? status : result;
  46. }
  47. static inline ssize_t spi_w8r16(struct spi_device *spi, u8 cmd)
  48. {
  49.     ssize_t            status;
  50.     u16            result;

  52.     status = spi_write_then_read(spi, &cmd, 1, (u8 *) &result, 2);

  54.     /* return negative errno or unsigned value */
  55.     return (status < 0) ? status : result;
  56. }

        说明：

        1) 传输开始时，首先初始化spi_message，然后将传输的spi_transfer链入spi_message中。
        2) spi_message中，有一个transfers队列，spi_transfer结构体通过这个队列挂到spi_message中。一个spi_message代表一次传输会话，spi_transfer代表一次单独的IO操作。比如，有些spi设备需要先读后写，那么这个读写过程就是一次spi会话，里面包括两个transfer，一个定义写操作的参数，另一个定义读操作的参数。

        3) 最后都是调用spi_sync()函数实现传输的，如下：

点击(此处)折叠或打开

  1. int spi_sync(struct spi_device *spi, struct spi_message *message)
  2. {
  3.     return __spi_sync(spi, message, 0);
  4. }
  5. static int __spi_sync(struct spi_device *spi, struct spi_message *message,
  6.          int bus_locked)
  7. {
  8.     DECLARE_COMPLETION_ONSTACK(done);
  9.     int status;
  10.     struct spi_master *master = spi->master;

  12.     message->complete = spi_complete;
  13.     message->context = &done;

  15.     if (!bus_locked)
  16.         mutex_lock(&master->bus_lock_mutex);

  18.     status = spi_async_locked(spi, message);

  20.     if (!bus_locked)
  21.         mutex_unlock(&master->bus_lock_mutex);

  23.     if (status == 0) {
  24.         wait_for_completion(&done);
  25.         status = message->status;
  26.     }
  27.     message->context = NULL;
  28.     return status;
  29. }
  30. int spi_async_locked(struct spi_device *spi, struct spi_message *message)
  31. {
  32.     struct spi_master *master = spi->master;
  33.     int ret;
  34.     unsigned long flags;

  36.     spin_lock_irqsave(&master->bus_lock_spinlock, flags);

  38.     ret = __spi_async(spi, message);

  40.     spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);

  42.     return ret;

  44. }
  45. static int __spi_async(struct spi_device *spi, struct spi_message *message)
  46. {
  47.     struct spi_master *master = spi->master;

  49.     /* Half-duplex links include original MicroWire, and ones with
  50.      * only one data pin like SPI_3WIRE (switches direction) or where
  51.      * either MOSI or MISO is missing. They can also be caused by
  52.      * software limitations.
  53.      */
  54.     if ((master->flags & SPI_MASTER_HALF_DUPLEX)
  55.             || (spi->mode & SPI_3WIRE)) {
  56.         struct spi_transfer *xfer;
  57.         unsigned flags = master->flags;

  59.         list_for_each_entry(xfer, &message->transfers, transfer_list) {
  60.             if (xfer->rx_buf && xfer->tx_buf)
  61.                 return -EINVAL;
  62.             if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
  63.                 return -EINVAL;
  64.             if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
  65.                 return -EINVAL;
  66.         }
  67.     }

  69.     message->spi = spi;
  70.     message->status = -EINPROGRESS;
  71.     return master->transfer(spi, message);
  72. }

        说明：

        1) 由上面的函数调用轨迹看，最后就是调用master的transfer函数实现传输的。

上一篇：STM32 NVIC 中断优先级管理
下一篇：Linux spi驱动分析(一)----总线驱动