Linux设备模型－－platform

左手的ㄟ右手 2022-03-26 17:42 204阅读 0赞

[http://blog.csdn.net/woshixingaaa/archive/2011/05/21/6436172.aspx][http_blog.csdn.net_woshixingaaa_archive_2011_05_21_6436172.aspx]

首先看一下我的系统中都有什么设备挂在了platform虚拟总线上：

platform的初始化：首先系统启动的时候会调用platform\_bus\_init来初始化这个虚拟总线，让后向虚拟总线注册即将挂载这条总线上的设备。platform\_bus\_type部分是内核为我们实现好的，我们只关系platform\_device与platform\_driver就行了。

1.  **struct** bus\_type platform\_bus\_type = \{  
2.      .name       = "platform",  
3.      .dev\_attrs  = platform\_dev\_attrs,  
4.      .match      = platform\_match,  
5.      .uevent     = platform\_uevent,  
6.      .pm     = PLATFORM\_PM\_OPS\_PTR,  
7.  \};  
8.  EXPORT\_SYMBOL\_GPL(platform\_bus\_type);  
9.    
10. **int** \_\_init platform\_bus\_init(**void**)  
11. \{  
12.     **int** error;  
13.   
14.     early\_platform\_cleanup();  
15.   
16.     error = device\_register(&platform\_bus);  
17.     **if** (error)  
18.         **return** error;  
19.     error =  bus\_register(&platform\_bus\_type);  
20.     **if** (error)  
21.         device\_unregister(&platform\_bus);  
22.     **return** error;  
23. \}

记住总线也是一种设备，所以首先注册总线设备，然后注册总线。

1.  **static** **struct** platform\_device \*smdk2410\_devices\[\] \_\_initdata = \{  
2.      &s3c\_device\_usb,  
3.      &s3c\_device\_lcd,  
4.      &s3c\_device\_wdt,  
5.      &s3c\_device\_i2c0,  
6.      &s3c\_device\_iis,  
7.  \};

把设备挂到platform总线上：

1.  **static** **void** \_\_init smdk2410\_init(**void**)  
2.  \{  
3.      s3c\_i2c0\_set\_platdata(NULL);  
4.      platform\_add\_devices(smdk2410\_devices, ARRAY\_SIZE(smdk2410\_devices));  
5.      smdk\_machine\_init();  
6.  \}

首先来看一个重要的数据结构：

1.  **struct** resource \{  
2.      resource\_size\_t start;    /\*资源的起始物理地址\*/  
3.      resource\_size\_t end;      /\*资源的结束物理地址\*/  
4.      **const** **char** \*name;         /\*资源的名称\*/  
5.      unsigned **long** flags;      /\*资源的类型\*/  
6.      **struct** resource \*parent, \*sibling, \*child; /\*资源的链表指针\*/  
7.  \};  
8.    
9.  **struct** platform\_device \{  
10.     **const** **char**  \* name;          /\*设备名\*/  
11.     **int**     id;              /\*设备编号，配合设备名使用\*/   
12.     **struct** device   dev;  
13.     u32     num\_resources;  
14.     **struct** resource \* resource;      /\*设备资源\*/  
15.   
16.     **struct** platform\_device\_id   \*id\_entry;  
17. \};  
18.   
19. **struct** platform\_driver \{  
20.     **int** (\*probe)(**struct** platform\_device \*);  
21.     **int** (\*remove)(**struct** platform\_device \*);  
22.     **void** (\*shutdown)(**struct** platform\_device \*);  
23.     **int** (\*suspend)(**struct** platform\_device \*, pm\_message\_t state);  
24.     **int** (\*suspend\_late)(**struct** platform\_device \*, pm\_message\_t state);  
25.     **int** (\*resume\_early)(**struct** platform\_device \*);  
26.     **int** (\*resume)(**struct** platform\_device \*);  
27.     **struct** device\_driver driver;  
28.     **struct** platform\_device\_id \*id\_table;  
29. \};

设备的分配：  
 **struct**  platform\_device \*platform\_device\_alloc( **const**   **char**  \*name,  **int**  id);   //name:设备名，id:设备id，一般为-1     
 设备的注册：  
 **int**  platform\_device\_add( **struct**  platform\_device \*pdev)；    
 获取资源:  
 **struct**  resource \*platform\_get\_resource( **struct**  platform\_device \*dev, unsigned  **int**  type, unsigned  **int**  num);   /\*dev:资源所属的设备，type:获取的资源类型，num:获取的资源数\*/  
这里详述platform\_device与platform\_driver是怎样匹配上的，这里跟踪函数的执行过程，首先是platform\_driver\_register：

1.  **int** platform\_driver\_register(**struct** platform\_driver \*drv)  
2.  \{  
3.      。。。。。。。。。。  
4.      **return** driver\_register(&drv->driver);  
5.  \}  
6.  **int** driver\_register(**struct** device\_driver \*drv)  
7.  \{  
8.      。。。。。。。。。。。  
9.      ret = bus\_add\_driver(drv);  
10.     。。。。。。。。。。。  
11. \}  
12. **int** bus\_add\_driver(**struct** device\_driver \*drv)  
13. \{  
14.     。。。。。。。。。。。。  
15.     **if** (drv->bus->p->drivers\_autoprobe) \{  
16.         error = driver\_attach(drv);  
17.         **if** (error)  
18.             **goto** out\_unregister;  
19.     \}  
20.     。。。。。。。。。。。。      
21. \}  
22. **int** driver\_attach(**struct** device\_driver \*drv)  
23. \{  
24.     **return** bus\_for\_each\_dev(drv->bus, NULL, drv, \_\_driver\_attach);  
25. \}

这里来看\_\_driver\_attach这个函数，其中分别调用了driver\_match\_device，driver\_probe\_device函数。如果匹配成果调用probe函数，否则返回。

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

匹配的时候调用的bus的match函数。

找到platform\_match:

1.  **static** **int** platform\_match(**struct** device \*dev, **struct** device\_driver \*drv)  
2.  \{  
3.      **struct** platform\_device \*pdev = to\_platform\_device(dev);  
4.      **struct** platform\_driver \*pdrv = to\_platform\_driver(drv);  
5.    
6.      /\* match against the id table first \*/  
7.      **if** (pdrv->id\_table)  
8.          **return** platform\_match\_id(pdrv->id\_table, pdev) != NULL;  
9.    
10.     /\* fall-back to driver name match \*/  
11.     **return** (strcmp(pdev->name, drv->name) == 0);  
12. \}

最后一行可以看到通过pdev->name与drv->name进行匹配，也就是说是通过设备与驱动的名字进行匹配。匹配成功后调用驱动的probe函数。

1.  **int** driver\_probe\_device(**struct** device\_driver \*drv, **struct** device \*dev)  
2.  \{  
3.      。。。。。。。。。  
4.      ret = really\_probe(dev, drv);  
5.      。。。。。。。。  
6.  \}  
7.  **static** **int** really\_probe(**struct** device \*dev, **struct** device\_driver \*drv)  
8.  \{  
9.      。。。。。。。。  
10.     **if** (dev->bus->probe) \{  
11.         ret = dev->bus->probe(dev);  
12.         **if** (ret)  
13.             **goto** probe\_failed;  
14.     \} **else** **if** (drv->probe) \{  
15.         ret = drv->probe(dev);  
16.         **if** (ret)  
17.             **goto** probe\_failed;  
18.     \}  
19.     。。。。。。。。  
20. \}

由relly\_probe函数可以看出，如果bus定义了probe函数，则调用bus的probe函数；如果bus，没有定义而driver定义了probe函数，则调用driver的probe函数。由上边的platform\_bus\_type可以看出bus并没有定义probe函数，所以调用driver的probe函数。

测试程序：device.c

1.  \#include <linux/module.h>  
2.  \#include <linux/init.h>  
3.  \#include <linux/device.h>  
4.  \#include <linux/string.h>  
5.  \#include <linux/module.h>  
6.  \#include <linux/platform\_device.h>  
7.    
8.  **static** **struct** platform\_device \*my\_device;  
9.    
10. **static** **int** \_\_init platform\_dev\_init(**void**) \{  
11.     **int** ret;  
12.       
13.     //分配结构  
14.     my\_device = platform\_device\_alloc("my\_dev", -1);  
15.     //注册设备  
16.     ret = platform\_device\_add(my\_device);  
17.       
18.     **if**(ret)  
19.         printk("platform\_device\_add failed!/n");  
20.           
21.     **return** ret;  
22. \}  
23.   
24. **static** **void** \_\_exit platform\_dev\_exit(**void**) \{  
25.     platform\_device\_unregister(my\_device);//卸载设备  
26. \}  
27.   
28. module\_init(platform\_dev\_init);  
29. module\_exit(platform\_dev\_exit);  
30. MODULE\_LICENSE("GPL");

driver.c

1.  \#include <linux/module.h>  
2.  \#include <linux/kernel.h>  
3.  \#include <linux/init.h>  
4.  \#include <linux/device.h>  
5.  \#include <linux/string.h>  
6.  \#include <linux/module.h>  
7.  \#include <linux/platform\_device.h>  
8.    
9.  **static** **int** my\_probe(**struct** device \*dev) \{  
10.     printk("Driver found device!/n");  
11.     **return** 0;  
12. \}  
13.   
14. **static** **int** my\_remove(**struct** device \*dev) \{  
15.     printk("Driver found device unpluged!/n");  
16.     **return** 0;  
17. \}  
18. //定义platform\_driver结构体  
19. **static** **struct** platform\_driver my\_driver = \{  
20.     .probe  = my\_probe,  
21.     .remove = my\_remove,      
22.     .driver = \{  
23.         .owner = THIS\_MODULE,  
24.         .name = "my\_dev",  
25.     \},  
26. \};  
27.   
28. **static** **int** \_\_init my\_driver\_init(**void**) \{  
29.     **return** platform\_driver\_register(&my\_driver);  
30. \}  
31.   
32. **static** **void** \_\_exit my\_driver\_exit(**void**) \{  
33.     platform\_driver\_unregister(&my\_driver);  
34. \}  
35.   
36. module\_init(my\_driver\_init);  
37. module\_exit(my\_driver\_exit);  
38. MODULE\_LICENSE("GPL");

测试效果：

1.  root@hacker:/home/hacker/platform\# insmod driver.ko  
2.  root@hacker:/home/hacker/platform\# insmod device.ko  
3.  root@hacker:/home/hacker/platform\# dmesg  
4.  \[ 4499.724439\] Driver found device!  
5.  root@hacker:/home/hacker/platform\# rmmod driver.ko  
6.  root@hacker:/home/hacker/platform\# dmesg  
7.  \[ 4499.724439\] Driver found device!  
8.  \[ 4513.368712\] Driver found device unpluged!  
9.  root@hacker:/home/hacker/platform\# rmmod device.ko  
10.   
11. root@hacker:/home/hacker/platform\# insmod device.ko  
12. root@hacker:/home/hacker/platform\# insmod driver.ko  
13. root@hacker:/home/hacker/platform\# dmesg  
14. \[ 4540.509227\] Driver found device!  
15. root@hacker:/home/hacker/platform\# rmmod device.ko  
16. root@hacker:/home/hacker/platform\# dmesg  
17. \[ 4540.509227\] Driver found device!  
18. \[ 4545.786076\] Driver found device unpluged!  
19. root@hacker:/home/hacker/platform\# rmmod driver.ko  
20. root@hacker:/home/hacker/platform\# dmesg  
21. \[ 4540.509227\] Driver found device!  
22. \[ 4545.786076\] Driver found device unpluged!

[http_blog.csdn.net_woshixingaaa_archive_2011_05_21_6436172.aspx]: http://blog.csdn.net/woshixingaaa/archive/2011/05/21/6436172.aspx