关于platform设备驱动中platform_device和platform_driver的注册顺序

对于platform设备的概念在此不再赘述，在这里主要是和大家分享一下刚刚解决的一个问题，在网上的很多资料里说对于Platform设备，必须先注册platform_device然后再注册platform_driver，但我发现的事实似乎不是如此。这个结论是小弟我在一个简单的platform设备测试程序中得到的，platform设备测试程序如下：
plat_dev.c:

1. #include<linux/module.h>
   
2. #include<linux/init.h>
   
3. #include<linux/kernel.h>
   
4. #include<linux/device.h>
   
5. #include<linux/platform_device.h>
   
6. 
   
7. struct platform_device my_dev =
   
8. {
   
9.         .name = "my_dev",
   
10.         .id   = -1,
    
11. };
    
12. 
    
13. 
    
14. 
    
15. static int __init platform_dev_init(void)
    
16. {
    
17.         int ret;
    
18.        
    
19.         ret = platform_device_register(&my_dev);
    
20. 
    
21.         if(ret)
    
22.         {
    
23.                 printk(KERN_NOTICE "##my_dev failed to register.\n");
    
24.         }
    
25.         else
    
26.         {
    
27.                 printk(KERN_NOTICE "##register my_dev.\n");
    
28.         }
    
29.         return ret;
    
30. }
    
31. 
    
32. 
    
33. 
    
34. static void __exit platform_dev_exit(void)
    
35. {
    
36.         platform_device_unregister(&my_dev);
    
37.         printk(KERN_NOTICE "##my_dev unregister.\n");
    
38. }
    
39. 
    
40. 
    
41. 
    
42. module_init(platform_dev_init);
    
43. module_exit(platform_dev_exit);
    
44. MODULE_LICENSE("GPL");
    
45. 
    

复制代码

plat_drv.c:

1. #include<linux/module.h>
   
2. #include<linux/init.h>
   
3. #include<linux/kernel.h>
   
4. #include<linux/device.h>
   
5. #include<linux/platform_device.h>
   
6. 
   
7. 
   
8. static int probe_test(struct platform_device *pdev)
   
9. {
   
10.         printk(KERN_NOTICE "##driver found device.\n");
    
11.         return 0;
    
12. }
    
13. 
    
14. 
    
15. 
    
16. static int remove_test(struct platform_device *pdev)
    
17. {
    
18.         printk(KERN_DEBUG "##remove device.\n");
    
19.         return 0;
    
20. }
    
21. 
    
22. 
    
23. 
    
24. struct platform_driver my_drv =
    
25. {
    
26.         .probe = probe_test,
    
27.         .remove = remove_test,
    
28.         .driver =
    
29.         {
    
30.                 .name = "my_dev",
    
31.                 .owner = THIS_MODULE,
    
32.         },       
    
33. };
    
34. 
    
35. 
    
36. static int __init platform_drv_init(void)
    
37. {
    
38.         int ret;
    
39.        
    
40.         ret = platform_driver_register(&my_drv);
    
41. 
    
42.         if(ret)
    
43.         {
    
44.                 printk(KERN_NOTICE "##driver failed to register.\n");
    
45.         }
    
46.         else
    
47.         {
    
48.                 printk(KERN_NOTICE "##register driver.\n",ret);
    
49.         }
    
50.         return ret;
    
51. }
    
52. 
    
53. 
    
54. 
    
55. static void __exit platform_drv_exit(void)
    
56. {
    
57.         platform_driver_unregister(&my_drv);
    
58.         printk(KERN_NOTICE "##driver unregister.\n");
    
59. }
    
60. 
    
61. 
    
62. 
    
63. module_init(platform_drv_init);
    
64. module_exit(platform_drv_exit);
    
65. MODULE_LICENSE("GPL");
    

复制代码

1. [root@EmbedSky platform]# insmod plat_drv.ko
   
2. ##register driver.
   
3. [root@EmbedSky platform]# insmod plat_dev.ko
   
4. ##driver found device.
   
5. ##register my_dev.

复制代码

虽然测试结果只有寥寥几行，但已足以令我傻眼……对于此我当时有两个疑惑：
1.我是先加载的plat_drv.ko,也就是说相应的platform_device还未被注册，可是驱动却能注册成功。。
2.为何probe在加载plat_dev.ko，也就是说相应的Platform_device被注册时会被调用

这样看似乎是没法看出问题所在的。。。没办法，只能扎进源码里找答案了。。
我首先解决的是第二个问题，跟踪platform_device_register(),在platform_device_register()-->platform_device_add()-->device_add()-->bus_attach_device()-->bus_for_each_drv()中，遍历platform_bus下的klist_drivers,并且通过调用__device_attach()函数进行匹配，在__device_attach()中，如果匹配成功，则调用driver_probe_device()-->really_probe-->driver->probe,在此调用driver中得probe....所以就算是后注册platform_device,只要能够匹配到对应的驱动,驱动中的probe函数也一样能被调用！
然后是第一个问题，跟踪platform_driver_register(),发现在platform_driver_register()-->driver_register()-->bus_add_driver()中有这么一段：

1. if (drv->bus->p->drivers_autoprobe) {
   
2.                 error = driver_attach(drv);/*搜寻匹配的设备与驱动相关联*/
   
3.                 if (error)
   
4.                         goto out_unregister;
   
5.         }

复制代码

driver_attach()的内容：

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;
   
4. 
   
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.          */
    
14. 
    
15.         if (!driver_match_device(drv, dev))
    
16.                 return 0;
    
17. 
    
18.         if (dev->parent)        /* Needed for USB */
    
19.                 down(&dev->parent->sem);
    
20.         down(&dev->sem);
    
21.         if (!dev->driver)
    
22.                 driver_probe_device(drv, dev);
    
23.         up(&dev->sem);
    
24.         if (dev->parent)
    
25.                 up(&dev->parent->sem);
    
26. 
    
27.         return 0;
    
28. }

复制代码

这个函数是问题的关键，可以发现，无论是否和一个设备匹配，该函数最终的会返回0，而在bus_for_each_dev()中，遍历klist_devices，调用__device_attach和每一个device进行匹配，即使最后找不到匹配的设备，bus_for_each_dev()返回的error值也是0！相关代码：

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;
   
7. 
   
8.         if (!bus)
   
9.                 return -EINVAL;
   
10. 
    
11.         klist_iter_init_node(&bus->p->klist_devices, &i,
    
12.                              (start ? &start->p->knode_bus : NULL));
    
13.         while ((dev = next_device(&i)) && !error)
    
14.                 error = fn(dev, data);
    
15.         klist_iter_exit(&i);
    
16.         return error;
    
17. }

复制代码

也就是说最后返回给bus_add_driver()的error值是0，这样即使没有找到匹配的设备也不会导致驱动的注册失败!
得到的结论是：不论是注册device还是driver都会进行匹配，并且在匹配成功的情况下调用driver->probe,也就是说在这一点上，并不一定要先注册设备再注册驱动。。。即使是后注册设备也能调用probe...只是习惯上来说(或者其他我不知道的原因)应该是设备在先驱动在后.
就这样一个比较二的问题还是可以看出，驱动的学习最终还是要落在对内核源码的理解上，要对其内部的细节和原理进行探索，这样自己肚子里才感觉有东西，不能只停留在书本或者网友对其的分析阐述上！以上全属本人愚见，分析不到位之处望各路朋友指出！

做驱动要的就是楼主这种精神