源自 http://blog.chinaunix.net/uid-27664726-id-3334923.html

 如果你瞭解了前面匯流排、裝置模型，分析匯流排裝置驅動模型的driver相對來說會輕鬆很多。開始也是看看其資料結構。

點選(此處)摺疊或開啟

1. struct device_driver {
   
2.     const char        *name;                 //驅動的名字
   
3.     struct bus_type        *bus;             //驅動呈現屬於的匯流排型別
   
4.     struct module        *owner;
   
5.     const
    char        *mod_name;    /* used for built-in modules */
   
6.     bool suppress_bind_attrs;    /* disables bind/unbind via sysfs */
   
7.     const struct of_device_id    *of_match_table;
   
8.     int (*probe) (struct device *dev);     //驅動掛載的時候呼叫
9.     int (*remove) (struct device *dev);    //解除安裝的時候呼叫
10.     void (*shutdown)
     (struct device *dev);
    
11.     int (*suspend) (struct device *dev, pm_message_t state);
    
12.     int (*resume) (struct device *dev);
    
13.     const struct attribute_group **groups;
    
14.     const struct dev_pm_ops *pm;
    
15.     struct driver_private *p;
    
16. };

與device型別相似，其中有一個指向driver_private的指標p，一些與其他的元件相關的聯絡都被移到這個結構變數中。

點選(此處

)摺疊或開啟

1. struct driver_private {
   
2.     struct kobject kobj;      //在sysfs中代表目錄本身
   
3.     struct klist klist_devices;//驅動連結串列
   
4.     struct klist_node knode_bus; //掛載在匯流排的驅動連結串列的節點
   
5.     struct module_kobject *mkobj;//driver與相關的module之間的聯絡
   
6.     struct device_driver *driver;
   
7. };
   
8. #define to_driver(obj) container_of(obj, struct driver_private, kobj)

由上面可以看出driver指標最後也有driver_private回到了device_driver之中，下面也來看看驅動的屬性檔案的表示方法

點選(此處)摺疊或開啟

1. struct driver_attribute {
   
2.     struct attribute attr;
   
3.     ssize_t (*show)(struct device_driver *driver, char *buf);
   
4.     ssize_t (*store)(struct device_driver *driver, const char *buf,
   
5.              size_t count);
   
6. };
   
7. #define DRIVER_ATTR(_name, _mode, _show, _store)    \
   
8. struct driver_attribute driver_attr_##_name =        \
   
9.     __ATTR(_name, _mode, _show, _store)

上面只是有兩個讀寫函式，看完了關於驅動的一些重要的資料結構，那麼開始重要的，如何向核心註冊一個drv呢？我們使用driver_register

點選(此處)摺疊或開啟

1. int driver_register(struct device_driver *drv)
   
2. {
   
3.     int ret;
   
4.     struct device_driver *other;
   
5.     BUG_ON(!drv->bus->p);
   
6.     if ((drv->bus->probe && drv->probe) ||
   
7.      (drv->bus->remove && drv->remove) ||
   
8.      (drv->bus->shutdown && drv->shutdown))
   
9.         printk(KERN_WARNING "Driver '%s' needs updating - please use "
   
10.             "bus_type methods\n", drv->name);
    
11.     other = driver_find(drv->name, drv->bus);
    
12.     if (other) {
    
13.         put_driver(other);
    
14.         printk(KERN_ERR "Error: Driver '%s' is already registered, "
    
15.             "aborting...\n", drv->name);
    
16.         return -EBUSY;
    
17.     }
    
18.     ret = bus_add_driver(drv);
    
19.     if (ret)
    
20.         return ret;
    
21.     ret = driver_add_groups(drv, drv->groups);
    
22.     if (ret)
    
23.         bus_remove_driver(drv);
    
24.     return ret;
    
25. }

從函式可以看出，首先drv->bus一定要預先設定。在使用driver_find從bus的驅動連結串列中特定名字的driver，那麼就進入這個函式的重點的東西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;
   
6.     bus = bus_get(drv->bus);//增加對bus的引用
   
7.     if (!bus)
   
8.         return -EINVAL;
   
9.     pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);
   
10.     priv = kzalloc(sizeof(*priv), GFP_KERNEL);//分配初始化一個drv->p，也就是上面的driver_private結構
    
11.     if (!priv) {
    
12.         error = -ENOMEM;
    
13.         goto out_put_bus;
    
14.     }
    
15.     klist_init(&priv->klist_devices, NULL, NULL);
    
16.     priv->driver = drv;
    
17.     drv->p = priv;
    
18.     priv->kobj.kset = bus->p->drivers_kset;
    
19.     error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,
    
20.                  "%s", drv->name);//將drv加入sysfs
    
21.     if (error)
    
22.         goto out_unregister;
    
23.     if (drv->bus->p->drivers_autoprobe) {
    
24.         error = driver_attach(drv);//如果匯流排可以自動的probe，就會呼叫匹配函式
    
25.         if (error)
    
26.             goto out_unregister;
    
27.     }
    
28.     klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);//將drv掛入到匯流排的連結串列中
    
29.     module_add_driver(drv->owner, drv);//建立driver相關的模組
    
30.     error = driver_create_file(drv, &driver_attr_uevent);//在drv目錄下建立event屬性檔案
    
31.     if (error) {
    
32.         printk(KERN_ERR "%s: uevent attr (%s) failed\n",
    
33.             __func__, drv->name);
    
34.     }
    
35.     error = driver_add_attrs(bus, drv);//新增屬性
    
36.     if (error) {
    
37.         /* How the hell do we get out of this pickle? Give up */
    
38.         printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",
    
39.             __func__, drv->name);
    
40.     }
    
41.     if (!drv->suppress_bind_attrs) {
    
42.         error = add_bind_files(drv);
    
43.         if (error) {
    
44.             /* Ditto */
    
45.             printk(KERN_ERR "%s: add_bind_files(%s) failed\n",
    
46.                 __func__, drv->name);
    
47.         }
    
48.     }
    
49.     kobject_uevent(&priv->kobj, KOBJ_ADD);//向用戶空間釋出kobj_add訊息
    
50.     return 0;
    
51. out_unregister:
    
52.     kobject_put(&priv->kobj);
    
53.     kfree(drv->p);
    
54.     drv->p = NULL;
    
55. out_put_bus:
    
56.     bus_put(bus);
    
57.     return error;
    
58. }

其實上面的處理過程相對於裝置來說，會簡單很多，下面主要對當驅動掛接的時候，怎麼去匹配進行分析。

點選(此處)摺疊或開啟

1. int driver_attach(struct device_driver *drv)
   
2. {
   
3.     return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
   
4. }

點選(此處)摺疊或開啟

1. static int __driver_attach(struct device *dev, void *data)
   
2. {
   
3.     struct device_driver *drv = data;
   
4.     /*
   
5.      * Lock device and try to bind to it. We drop the error
   
6.      * here and always return 0, because we need to keep trying
   
7.      * to bind to devices and some drivers will return an error
   
8.      * simply if it didn't support the device.
   
9.      *
   
10.      * driver_probe_device() will spit a warning if there
    
11.      * is an error.
    
12.      */
    
13.     if (!driver_match_device(drv, dev))
    
14.         return 0;
    
15.     if (dev->parent)    /* Needed for USB */
    
16.         device_lock(dev->parent);
    
17.     device_lock(dev);
    
18.     if (!dev->driver)
    
19.         driver_probe_device(drv, dev);
    
20.     device_unlock(dev);
    
21.     if (dev->parent)
    
22.         device_unlock(dev->parent);
    
23.     return 0;

點選(此處)摺疊或開啟

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. }

最終也是呼叫匯流排的match函式來完成裝置與驅動的匹配的過程。 以上分析了匯流排、裝置、驅動三種類型，主要是在註冊上，其主要是在sysfs中建立目錄和屬性檔案。在裝置或者驅動註冊到總線上，匯流排是如何為其找到對應的驅動的過程，下面一個圖能很好的說明這一過程。 由圖可以清楚的看出，bus的作用是向核心註冊一條匯流排，並將drv一一加入到匯流排的drv連結串列，dev一一加入到匯流排的dev連結串列。當有裝置或驅動註冊的時候，在驅動或者裝置連結串列一一取出，呼叫匯流排的match函式來完成匹配，匹配成功後呼叫匯流排的probe函式。 回顧下driver_register的作用，首先會將drv放入到bus得drv連結串列，從bus的dev連結串列取出每一個dev，用匯流排的match函式來判斷能否支援drv device_register的作用和driver一樣，將dev放入到bus得dev連結串列，從bus的drv連結串列取出每一個drv，用匯流排的match函式來判斷能否支援dev。

點選(此處)摺疊或開啟

1. extern struct bus_type my_bus_type;
   
2. static int my_probe(struct device *dev)
   
3. {
   
4.     printk("Driver found device which my driver can handle!\n");
   
5.     return 0;
   
6. }
   
7. static int my_remove(struct device *dev)
   
8. {
   
9.     printk("Driver found device unpluged!\n");
   
10.     return 0;
    
11. }
    
12. struct device_driver my_driver = {
    
13.     .name = "my_dev",
    
14.     .bus = &my_bus_type,
    
15.     .probe = my_probe,
    
16.         .remove    = my_remove,
    
17. };
    
18. /*
    
19.  * Export a simple attribute.
    
20.  */
    
21. static ssize_t mydriver_show(struct device_driver *driver, char *buf)
    
22. {
    
23.     return sprintf(buf, "%s\n", "This is my driver!");
    
24. }
    
25. static DRIVER_ATTR(drv, S_IRUGO, mydriver_show, NULL);
    
26. static int __init my_driver_init(void)
    
27. {
    
28.     int ret = 0;
    
29.         /*註冊驅動*/
    
30.     driver_register(&my_driver);
    
31.     /*建立屬性檔案*/
    
32.     driver_create_file(&my_driver, &driver_attr_drv);
    
33.     return ret;    
    
34. }
    
35. static void my_driver_exit(void)
    
36. {
    
37.     driver_unregister(&my_driver);
    
38. }
    
39. module_init(my_driver_init);
    
40. module_exit(my_driver_exit);