总线设备驱动模型--设备篇

740阅读　0评论2013-07-23　枫海8深蓝
分类：LINUX

    上篇主要对总线进行了一些梳理，现在来看看内核对于设备的处理过程。

点击(此处)折叠或打开

  1. struct device {
  2.     struct device        *parent;     /*指向父节点的指针*/

  4.     struct device_private    *p;

  6.     struct kobject kobj;/*用它联系到sysfs中*/
  7.     const char        *init_name; /*初始化设备的名字 */
  8.     const struct device_type *type;/*device属性文件*/

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

  14.     struct bus_type    *bus;        /* 属于那条总线 */
  15.     struct device_driver *driver;    /*那个驱动能匹配该设备*/
  16.     void        *platform_data;    
  17.     struct dev_pm_info    power;
  18.     struct dev_pm_domain    *pm_domain;

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

  30.     struct device_dma_parameters *dma_parms;

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

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

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

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

  43.     spinlock_t        devres_lock;
  44.     struct list_head    devres_head;

  46.     struct klist_node    knode_class;
  47.     struct class        *class;
  48.     const struct attribute_group **groups;    /* optional groups */

  50.     void    (*release)(struct device *dev);
  51. };
来看看strcut device的结构变量，首先是指向父节点的指针parent,kobj是内嵌在device中的kbojcet，匹配的驱动，属于哪条总线，其中比较重要的是release函数，当这个设备被删去时，内核调用该方法，所有的注册到内核的设备结构必须有一个release方法。和总线一样，device也有一个联系bus、device、driver的数据结构。

点击(此处)折叠或打开

  1. struct device_private {
  2.     struct klist klist_children;//子设备的链表
  3.     struct klist_node knode_parent;//连接到父设备的klist_childern时所用的节点
  4.     struct klist_node knode_driver;//连接到驱动的设备时用到得节点
  5.     struct klist_node knode_bus;//连接到总线时所用的节点
  6.     void *driver_data;          //用于在设备结构中存放相关的驱动信息
  7.     struct device *device;     //指向属于有的device
  8. };
  9. #define to_device_private_parent(obj)    \
  10.     container_of(obj, struct device_private, knode_parent)//从父设备的klist_children上节点，获取相应的private
  11. #define to_device_private_driver(obj)    \
  12.     container_of(obj, struct device_private, knode_driver)//从驱动链表上获得private
  13. #define to_device_private_bus(obj)    \
  14.     container_of(obj, struct device_private, knode_bus) //从总线上获得private
从数据结构上看出，device也有和bus总线一样的。

点击(此处)折叠或打开

  1. /* interface for exporting device attributes */
  2. struct device_attribute {
  3.     struct attribute    attr;
  4.     ssize_t (*show)(struct device *dev, struct device_attribute *attr,
  5.             char *buf);
  6.     ssize_t (*store)(struct device *dev, struct device_attribute *attr,
  7.              const char *buf, size_t count);
  8. };

  10. #define DEVICE_ATTR(_name, _mode, _show, _store) \
  11. struct device_attribute dev_attr_##_name = __ATTR(_name, _mode, _show, _store)
sysf中的设备入口的属性结构

点击(此处)折叠或打开

  1. struct device_type {
  2.     const char *name;
  3.     const struct attribute_group **groups;
  4.     int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
  5.     char *(*devnode)(struct device *dev, mode_t *mode);
  6.     void (*release)(struct device *dev);

  8.     const struct dev_pm_ops *pm;
  9. };
同bus过程一样，device的初始化也是在driver_init完成初始化的

点击(此处)折叠或打开

  1. int __init devices_init(void)
  2. {
  3.     devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
  4.     if (!devices_kset)
  5.         return -ENOMEM;
  6.     dev_kobj = kobject_create_and_add("dev", NULL);
  7.     if (!dev_kobj)
  8.         goto dev_kobj_err;
  9.     sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
  10.     if (!sysfs_dev_block_kobj)
  11.         goto block_kobj_err;
  12.     sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
  13.     if (!sysfs_dev_char_kobj)
  14.         goto char_kobj_err;

  16.     return 0;

  18.  char_kobj_err:
  19.     kobject_put(sysfs_dev_block_kobj);
  20.  block_kobj_err:
  21.     kobject_put(dev_kobj);
  22.  dev_kobj_err:
  23.     kset_unregister(devices_kset);
  24.     return -ENOMEM;
  25. }
这个函数干的事情很明显，就是创建在sysfs中的devices目录和dev目录，还在dev目录下创建了block和char两个子目录。

点击(此处)折叠或打开

  1. static const struct kset_uevent_ops device_uevent_ops = {
  2.     .filter =    dev_uevent_filter,
  3.     .name =        dev_uevent_name,
  4.     .uevent =    dev_uevent,
  5. };
这部分用于向用户控件传递event事件。
下面来分析下设备的注册过程

点击(此处)折叠或打开

  1. int device_register(struct device *dev)
  2. {
  3.     device_initialize(dev);
  4.     return device_add(dev);
  5. }
device_register是提供给外界注册设备的接口，主要调用device_initialize完成dev结构的初始化，然后调用device_add将其加入到系统中。

点击(此处)折叠或打开

  1. void device_initialize(struct device *dev)
  2. {
  3.     dev->kobj.kset = devices_kset;
  4.     kobject_init(&dev->kobj, &device_ktype);
  5.     INIT_LIST_HEAD(&dev->dma_pools);
  6.     mutex_init(&dev->mutex);
  7.     lockdep_set_novalidate_class(&dev->mutex);
  8.     spin_lock_init(&dev->devres_lock);
  9.     INIT_LIST_HEAD(&dev->devres_head);
  10.     device_pm_init(dev);
  11.     set_dev_node(dev, -1);
  12. }
主要是完成device结构的初始化，把device中能初始化的部分全部初始化。主要是将device_ktype加入到kobject中。

点击(此处)折叠或打开

  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); //增加dev的引用计数
  8.     if (!dev)
  9.         goto done;

  11.     if (!dev->p) {
  12.         error = device_private_init(dev);//分配和初始化dev->p
  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);//设置dev名字
  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); //将dev加入sysfs
  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);//创建uevent属性文件
  52.     if (error)
  53.         goto attrError;

  55.     if (MAJOR(dev->devt)) {
  56.         error = device_create_file(dev, &devt_attr);//如果没有设备号，就创建dev属性
  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);//在dev下创建设备文件
  65.     }

  67.     error = device_add_class_symlinks(dev);//dev与class创建软链接
  68.     if (error)
  69.         goto SymlinkError;
  70.     error = device_add_attrs(dev); //添加device/type/class定义的属性集合
  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. int device_create_file(struct device *dev,
  2.          const struct device_attribute *attr)
  3. {
  4.     int error = 0;
  5.     if (dev)
  6.         error = sysfs_create_file(&dev->kobj, &attr->attr);
  7.     return error;
  8. }
从上面可以看出 error = device_create_file(dev, &uevent_attr)创建了uevent的属性。调用error = device_create_file(dev, &devt_attr);如果dev没有被分配设备号，添加dev属性，之后会调用device_create_sys_dev_entry在/sys/dev下添加相应的软链接，最后在调用devtmpfs_create_node在/dev下创建相应的设备文件。

点击(此处)折叠或打开

  1. static int device_add_class_symlinks(struct device *dev)
  2. {
  3.     int error;

  5.     if (!dev->class)
  6.         return 0;

  8.     error = sysfs_create_link(&dev->kobj,
  9.                  &dev->class->p->subsys.kobj,
  10.                  "subsystem");
  11.     if (error)
  12.         goto out;

  14.     if (dev->parent && device_is_not_partition(dev)) {
  15.         error = sysfs_create_link(&dev->kobj, &dev->parent->kobj,
  16.                      "device");
  17.         if (error)
  18.             goto out_subsys;
  19.     }

  21. #ifdef CONFIG_BLOCK
  22.     /* /sys/block has directories and does not need symlinks */
  23.     if (sysfs_deprecated && dev->class == &block_class)
  24.         return 0;
  25. #endif

  27.     /* link in the class directory pointing to the device */
  28.     error = sysfs_create_link(&dev->class->p->subsys.kobj,
  29.                  &dev->kobj, dev_name(dev));
  30.     if (error)
  31.         goto out_device;

  33.     return 0;

  35. out_device:
  36.     sysfs_remove_link(&dev->kobj, "device");

  38. out_subsys:
  39.     sysfs_remove_link(&dev->kobj, "subsystem");
  40. out:
  41.     return error;
  42. }
这个函数主要是添加dev与class间的软链接，下面来看看重点的，将dev挂入到bus的设备链表中。

点击(此处)折叠或打开

  1. int bus_add_device(struct device *dev)
  2. {
  3.     struct bus_type *bus = bus_get(dev->bus);
  4.     int error = 0;

  6.     if (bus) {
  7.         pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev));
  8.         error = device_add_attrs(bus, dev);
  9.         if (error)
  10.             goto out_put;
  11.         error = sysfs_create_link(&bus->p->devices_kset->kobj,
  12.                         &dev->kobj, dev_name(dev));
  13.         if (error)
  14.             goto out_id;
  15.         error = sysfs_create_link(&dev->kobj,
  16.                 &dev->bus->p->subsys.kobj, "subsystem");//创建bus与dev的软链接
  17.         if (error)
  18.             goto out_subsys;
  19.         klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices); //挂入链表
  20.     }
  21.     return 0;

  23. out_subsys:
  24.     sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));
  25. out_id:
  26.     device_remove_attrs(bus, dev);
  27. out_put:
  28.     bus_put(dev->bus);
  29.     return error;
  30. }
可以看出，其只做了一个添加dev与bus间的软链接，并将dev挂到bus的设备链表中。之后dpm_sysfs_add增加dev下的power属性， 在将dev加入到dpm_list的链表中。 

点击(此处)折叠或打开

  1. void device_pm_add(struct device *dev)
  2. {
  3.     pr_debug("PM: Adding info for %s:%s\n",
  4.          dev->bus ? dev->bus->name : "No Bus", dev_name(dev));
  5.     mutex_lock(&dpm_list_mtx);
  6.     if (dev->parent && dev->parent->power.is_prepared)
  7.         dev_warn(dev, "parent %s should not be sleeping\n",
  8.             dev_name(dev->parent));
  9.     list_add_tail(&dev->power.entry, &dpm_list);
  10.     dev_pm_qos_constraints_init(dev);
  11.     mutex_unlock(&dpm_list_mtx);
  12. }
kobject_uevent(&dev->kobj, KOBJ_ADD)会做kobject_uevent发布KOBJ_ADD消息，最后会进入中要的函数bus_probe_device(dev)，为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. }

点击(此处)折叠或打开

  1. int device_attach(struct device *dev)
  2. {
  3.     int ret = 0;

  5.     device_lock(dev);
  6.     if (dev->driver) {
  7.         if (klist_node_attached(&dev->p->knode_driver)) {
  8.             ret = 1;
  9.             goto out_unlock;
  10.         }
  11.         ret = device_bind_driver(dev);
  12.         if (ret == 0)
  13.             ret = 1;
  14.         else {
  15.             dev->driver = NULL;
  16.             ret = 0;
  17.         }
  18.     } else {
  19.         pm_runtime_get_noresume(dev);
  20.         ret = bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
  21.         pm_runtime_put_sync(dev);
  22.     }
  23. out_unlock:
  24.     device_unlock(dev);
  25.     return ret;
  26. }
上面主要的做的是，当device被注册时候，会匹配drv是否有匹配的项，其匹配过程主要是调用__device_attach。

点击(此处)折叠或打开

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

  5.     if (!driver_match_device(drv, dev))
  6.         return 0;

  8.     return driver_probe_device(drv, dev);
  9. }
如果匹配成功，就会调用probe函数。先来看看匹配的过程，主要是调用bus的match函数。

点击(此处)折叠或打开

  1. static inline int driver_match_device(struct device_driver *drv,
  2.                  struct device *dev)
  3. {
  4.     return drv->bus->match ? drv->bus->match(dev, drv) : 1;
  5. }
匹配成功后，调用probe函数，从下面可以看出如果bus的probe函数存在，调用bus的，如果不存在，则调用dev的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.     }

  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.     } else {
  44.         pr_debug("%s: probe of %s rejects match %d\n",
  45.          drv->name, dev_name(dev), ret);
  46.     }
  47.     /*
  48.      * Ignore errors returned by ->probe so that the next driver can try
  49.      * its luck.
  50.      */
  51.     ret = 0;
  52. done:
  53.     atomic_dec(&probe_count);
  54.     wake_up(&probe_waitqueue);
  55.     return ret;
  56. }
寻找到合适的驱动后，下面做的主要是如果有parent节点，把knode_parent挂入klist_children链表。如果dev有属于的class,也挂入到链表中，上面对device的分析也就完了，下面来看一个例子。

点击(此处)折叠或打开

  1. extern struct device my_bus;
  2. extern struct bus_type my_bus_type;

  4. /* Why need this ?*/
  5. static void my_dev_release(struct device *dev)
  6. {
  7.     
  8. }

  10. struct device my_dev = {
  11.     .bus = &my_bus_type,
  12.     .parent = &my_bus,
  13.     .release = my_dev_release,
  14. };

  16. /*
  17.  * Export a simple attribute.
  18.  */
  19. static ssize_t mydev_show(struct device *dev, char *buf)
  20. {
  21.     return sprintf(buf, "%s\n", "This is my device!");
  22. }

  24. static DEVICE_ATTR(dev, S_IRUGO, mydev_show, NULL);

  26. static int __init my_device_init(void)
  27. {
  28.     int ret = 0;
  29.         
  30.         /* 初始化设备 */
  31.     strncpy(my_dev.bus_id, "my_dev", BUS_ID_SIZE);
  32.         
  33.         /*注册设备*/
  34.     device_register(&my_dev);
  35.         
  36.     /*创建属性文件*/
  37.     device_create_file(&my_dev, &dev_attr_dev);
  38.     
  39.     return ret;    

  41. }

  43. static void my_device_exit(void)
  44. {
  45.     device_unregister(&my_dev);
  46. }

  48. module_init(my_device_init);
  49. module_exit(my_device_exit);


上一篇：platform驱动小结
下一篇：总线设备驱动模型---总线篇