zoukankan      html  css  js  c++  java

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

    一、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 ", 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目录，即/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 ", 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... ", 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 ", 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 ",
    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 ",
    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 ",
    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 ",
    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 ",
    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 ",
    13.             __func__, dev_name(dev));
    14.         goto probe_failed;
    15.     }
    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 ",
    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 ",
    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 ",
    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 ",
    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 ",
    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 ",
    104.                 dev_name(&spi->dev), status);
    105.     else
    106.         dev_dbg(dev, "registered child %s ", 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 ", 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 ",
    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 ",
    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 ",
    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 ",
    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 ",
    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 ",
    5.             __func__, kobject_name(&dev->kobj));
    6.         return;
    7.     }
    9.     pr_debug("driver: '%s': %s: bound to device '%s' ", 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函数实现传输的。
  • 相关阅读:
    MongoDB安装
    前端构建工具gulp入门教程
    限制input输入类型(多种方法实现)
    【E20200105-1】Centos 7.x 下vsftpd配置文件常用配置详解
    【E20200102-1】centos 7 下vsftp的安装和配置
    【E20200101-1】Centos 7.x 关闭防火墙（firewall）和SELinux
    Linux下如何修改用户默认目录
    linux给普通用户增加ssh权限
    在IIS7中应用Application Request Routing配置反向代理
    vmware相关服务默认禁用 修改服务弹出服务拒绝访问解决办法
  • 原文地址：https://www.cnblogs.com/muhuacat/p/7061908.html
Copyright © 2011-2022 走看看