Linux Platform devices 平台设备驱动

柔光的暖阳◎ 2022-06-02 02:26 199阅读 0赞

设备总线驱动模型：http://blog.csdn.net/lizuobin2/article/details/51570196

本文主要参考：http://www.wowotech.net/device\_model/platform\_device.html

platform平台设备驱动是基于设备总线驱动模型的，它只不过是将 device 进一步封装成为 platform\_device，将 device\_driver 进一步封装成为 platform\_device\_driver,前面已经分析过设备总线驱动模型，关于device 与 device\_driver 的注册过程以及它们在sysfs文件系统中的层次关系就不在分析，本文重点分析platform平台设备驱动与设备总线驱动模型相比较新增添的那些东西。

![20160608012422012][]

在Linux设备模型的抽象中，存在着一类称作“Platform Device”的设备，内核是这样描述它们的（Documentation/driver-model/platform.txt）：

Platform devices are devices that typically appear as autonomous entities in the system. This includes legacy port-based devices and host bridges to peripheral buses, and most controllers integrated into system-on-chip platforms.  What they usually have in common is direct addressing from a CPU bus.  Rarely, a platform\_device will be connected through a segment of some other kind of bus; but its registers will still be directly addressable.

概括来说，Platform设备包括：基于端口的设备（已不推荐使用，保留下来只为兼容旧设备，legacy）；连接物理总线的桥设备；集成在SOC平台上面的控制器；连接在其它bus上的设备（很少见）。等等。  
    这些设备有一个基本的特征：可以通过CPU bus直接寻址（例如在嵌入式系统常见的“寄存器”）。因此，由于这个共性，内核在设备模型的基础上（device和device\_driver），对这些设备进行了更进一步的封装，抽象出paltform bus、platform device和platform driver，以便驱动开发人员可以方便的开发这类设备的驱动。  
    可以说，paltform设备对Linux驱动工程师是非常重要的，因为我们编写的大多数设备驱动，都是为了驱动plaftom设备。

platform\_bus\_type  
    我们知道，在设备总线驱动模型的中，BUS像一个月老一样，通过它的match函数，将注册到bus中的device与driver进行配对，那么每一个不同的bus 都有自己的match函数，我们来看看platform\_bus\_type.

\[cpp\]  [view plain][]  [copy][view plain]

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\_dev\_pm\_ops,  
7.  \};

\[cpp\]  [view plain][]  [copy][view plain]

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

如果platform\_device\_driver中定义了id\_table，则调用 platform\_match\_id 进行匹配

举个例子：

\[cpp\]  [view plain][]  [copy][view plain]

1.  static struct platform\_device\_id s3c24xx\_driver\_ids\[\] = \{  
2.      \{  
3.          .name       = "s3c2410-i2c",  
4.          .driver\_data    = TYPE\_S3C2410,  
5.      \}, \{  
6.          .name       = "s3c2440-i2c",  
7.          .driver\_data    = TYPE\_S3C2440,  
8.      \}, \{ \},  
9.  \};

\[cpp\]  [view plain][]  [copy][view plain]

1.  struct platform\_device s3c\_device\_i2c0 = \{  
2.      .name         = "s3c2410-i2c",  
3.  \#ifdef CONFIG\_S3C\_DEV\_I2C1  
4.      .id       = 0,  
5.  \#else  
6.      .id       = -1,  
7.  \#endif  
8.      .num\_resources    = ARRAY\_SIZE(s3c\_i2c\_resource),  
9.      .resource     = s3c\_i2c\_resource,  
10. \};

\[cpp\]  [view plain][]  [copy][view plain]

1.  static const struct platform\_device\_id \*platform\_match\_id(struct platform\_device\_id \*id, struct platform\_device \*pdev)  
2.  \{  
3.      while (id->name\[0\]) \{  
4.          if (strcmp(pdev->name, id->name) == 0) \{  
5.              pdev->id\_entry = id;  
6.              return id;  
7.          \}  
8.          id++;  
9.      \}  
10.     return NULL;  
11. \}

显然，platform\_match\_id 的作用就是遍历整个 Id\_table 数组，寻找是否有与 platform\_device->name 同名的，如果有，则返回这个 Platform\_device\_id ,使用Id\_table 打破了原本设备总线驱动模型，一个 device 只能用与一个 device\_driver 配对的局限性。现在一个platform\_device\_driver 可以与多个platform\_device配对。

如果没有，则只是根据 platform\_device\_driver->name 与 platform\_device->name 进行比较，这也就是老师为啥在写平台设备驱动程序的时候经常说，“将驱动注册到内核中去，如果有同名设备，则调用driver->probe函数....”。

pletform\_device 中的 id 的作用：

if (pdev->id != -1)      /\* 如果不是-1 对name编号 \*/    
        dev\_set\_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);    
    else                             /\* -1时直接是名字 \*/  
        dev\_set\_name(&pdev->dev, pdev->name);

从device封装而来的platform\_device

\[cpp\]  [view plain][]  [copy][view plain]

1.  struct platform\_device \{  
2.      const char  \* name;  
3.      int     id;  
4.      struct device   dev;  
5.      u32     num\_resources;  
6.      struct resource \* resource;  
7.    
8.      struct platform\_device\_id   \*id\_entry;  
9.    
10.     /\* arch specific additions \*/  
11.     struct pdev\_archdata    archdata;  
12. \};

name，设备的名称，该名称在设备注册时，会拷贝到dev.init\_name中。  
    dev，真正的设备，通过 container\_of ,就能找到整个platform\_device ，访问其它成员，如后面要提到的 resource   
    num\_resources、resource，该设备的资源描述，由struct resource（include/linux/ioport.h）结构抽象。   
    在Linux中， 系统资源包括I/O、Memory、Register、IRQ、DMA、Bus等多种类型 。这些资源大多具有独占性，不允许多个设备同时使用，因此Linux内核提供了一些API，用于分配、管理这些资源。   
     当某个设备需要使用某些资源时，只需利用struct resource组织这些资源（如名称、类型、起始、结束地址等），并保存在该设备的resource指针中即可。然后在设备probe时，设备需求会调用资源管理接口，分配、使用这些资源。而内核的资源管理逻辑，可以判断这些资源是否已被使用、是否可被使用等等。

\[cpp\]  [view plain][]  [copy][view plain]

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

\[cpp\]  [view plain][]  [copy][view plain]

1.  static struct resource led\_resource\[\] = \{   //jz2440的参数，驱动未测试   
2.      \[0\] = \{  
3.          .start = 0x56000010,  
4.          .end   = 0x56000010 + 8 - 1,  
5.          .flags = IORESOURCE\_MEM,  
6.      \},  
7.      \[1\] = \{  
8.          .start = 5,  
9.          .end   = 5,  
10.         .flags = IORESOURCE\_IRQ,  
11.     \},  
12. \};  
13. static struct platform\_device led\_dev = \{  
14.     .name = "myled",    //设备名字 与 驱动相匹配  
15.     .id   = -1,  
16.     .num\_resources = ARRAY\_SIZE(led\_resource),  
17.     .resource = led\_resource,  
18.       
19.     .dev = \{  
20.         .release = led\_release,  
21.         //.devt = MKDEV(252, 1),  
22.     \},  
23. \};

从 device\_driver 封装而来的platform\_device\_dirver

\[cpp\]  [view plain][]  [copy][view plain]

1.  struct platform\_driver \{  
2.      int (\*probe)(struct platform\_device \*);  
3.      int (\*remove)(struct platform\_device \*);  
4.      void (\*shutdown)(struct platform\_device \*);  
5.      int (\*suspend)(struct platform\_device \*, pm\_message\_t state);  
6.      int (\*resume)(struct platform\_device \*);  
7.      struct device\_driver driver;  
8.      struct platform\_device\_id \*id\_table;  
9.  \};

\[cpp\]  [view plain][]  [copy][view plain]

1.  int platform\_driver\_register(struct platform\_driver \*drv)  
2.  \{  
3.      drv->driver.bus = &platform\_bus\_type;  
4.      if (drv->probe)  
5.          drv->driver.probe = platform\_drv\_probe;  
6.      if (drv->remove)  
7.          drv->driver.remove = platform\_drv\_remove;  
8.      if (drv->shutdown)  
9.          drv->driver.shutdown = platform\_drv\_shutdown;  
10.   
11.     return driver\_register(&drv->driver);  
12. \}

struct platform\_driver结构和struct device\_driver非常类似,上边的platform\_drv\_probe、platform\_drv\_remove、platform\_drv\_shutdown，只不过稍作转换调用platform\_driver中的probe、remove、shutdown函数，举个例子稍微看一下

\[cpp\]  [view plain][]  [copy][view plain]

1.  static int platform\_drv\_probe(struct device \*\_dev)  
2.  \{  
3.      struct platform\_driver \*drv = to\_platform\_driver(\_dev->driver);  
4.      struct platform\_device \*dev = to\_platform\_device(\_dev);  
5.    
6.      return drv->probe(dev);  
7.  \}

Platform Device提供的API

\[cpp\]  [view plain][]  [copy][view plain]

1.  /\* include/linux/platform\_device.h \*/  
2.  extern int platform\_device\_register(struct platform\_device \*);  
3.  extern void platform\_device\_unregister(struct platform\_device \*);  
4.     
5.  extern void arch\_setup\_pdev\_archdata(struct platform\_device \*);  
6.  extern struct resource \*platform\_get\_resource(struct platform\_device \*, unsigned int, unsigned int);  
7.  extern int platform\_get\_irq(struct platform\_device \*, unsigned int);  
8.  extern struct resource \*platform\_get\_resource\_byname(struct platform\_device \*, unsigned int, const char \*);  
9.  extern int platform\_get\_irq\_byname(struct platform\_device \*, const char \*);  
10. extern int platform\_add\_devices(struct platform\_device \*\*, int);  
11.    
12. extern struct platform\_device \*platform\_device\_register\_full(const struct platform\_device\_info \*pdevinfo);  
13.    
14. static inline struct platform\_device \*platform\_device\_register\_resndata(  
15.                 struct device \*parent, const char \*name, int id,  
16.                 const struct resource \*res, unsigned int num,  
17.                 const void \*data, size\_t size)  
18.    
19. static inline struct platform\_device \*platform\_device\_register\_simple(  
20.                 const char \*name, int id,  
21.                 const struct resource \*res, unsigned int num)  
22.    
23. static inline struct platform\_device \*platform\_device\_register\_data(  
24.                 struct device \*parent, const char \*name, int id,  
25.                 const void \*data, size\_t size)  
26.    
27. extern struct platform\_device \*platform\_device\_alloc(const char \*name, int id);  
28. extern int platform\_device\_add\_resources(struct platform\_device \*pdev,  
29.                                          const struct resource \*res,  
30.                                          unsigned int num);  
31. extern int platform\_device\_add\_data(struct platform\_device \*pdev,  
32.                                     const void \*data, size\_t size);  
33. extern int platform\_device\_add(struct platform\_device \*pdev);  
34. extern void platform\_device\_del(struct platform\_device \*pdev);  
35. extern void platform\_device\_put(struct platform\_device \*pdev);

platform\_device\_register、platform\_device\_unregister，Platform设备的注册/注销接口，和底层的device\_register等接口类似。  
    arch\_setup\_pdev\_archdata，设置platform\_device变量中的archdata指针。  
    platform\_get\_resource、platform\_get\_irq、platform\_get\_resource\_byname、platform\_get\_irq\_byname，通过这些接口，可以获取platform\_device变量中的resource信息，以及直接获取IRQ的number等等。  
    platform\_device\_register\_full、platform\_device\_register\_resndata、platform\_device\_register\_simple、platform\_device\_register\_data，其它形式的设备注册。调用者只需要提供一些必要的信息，如name、ID、resource等，Platform模块就会自动分配一个struct platform\_device变量，填充内容后，注册到内核中。  
    platform\_device\_alloc，以name和id为参数，动态分配一个struct platform\_device变量。  
    platform\_device\_add\_resources，向platform device中增加资源描述。  
    platform\_device\_add\_data，向platform device中添加自定义的数据（保存在pdev->dev.platform\_data指针中）。  
    platform\_device\_add、platform\_device\_del、platform\_device\_put，其它操作接口。  
  
Platform Driver提供的API  
    platform\_driver\_registe、platform\_driver\_unregister，platform driver的注册、注销接口。  
    platform\_driver\_probe，主动执行probe动作。  
    platform\_set\_drvdata、platform\_get\_drvdata，设置或者获取driver保存在device变量中的私有数据。  
  
懒人API

\[cpp\]  [view plain][]  [copy][view plain]

1.  extern struct platform\_device \*platform\_create\_bundle(  
2.        struct platform\_driver \*driver, int (\*probe)(struct platform\_device \*),  
3.        struct resource \*res, unsigned int n\_res,  
4.        const void \*data, size\_t size);

只要提供一个platform\_driver（要把driver的probe接口显式的传入），并告知该设备占用的资源信息，platform模块就会帮忙分配资源，并执行probe操作。对于那些不需要热拔插的设备来说，这种方式是最省事的了。

简单一例：

开发板：Mini2440

内核版本：2.6.32.2

\[cpp\]  [view plain][]  [copy][view plain]

1.  \#include <linux/module.h>  
2.  \#include <linux/kernel.h>  
3.  \#include <linux/fs.h>  
4.  \#include <linux/init.h>  
5.  \#include <linux/device.h>  
6.  \#include <linux/interrupt.h>  
7.  \#include <linux/sched.h>   
8.  \#include <linux/irq.h>  
9.  \#include <asm/uaccess.h>  
10.   
11. \#include <linux/platform\_device.h>  
12. \#include <linux/io.h>  
13.   
14. static int major;  
15.   
16. static struct class \*cls;  
17. static struct device \*dev;  
18.   
19. static volatile unsigned long \*gpio\_con;  
20. static volatile unsigned long \*gpio\_dat;  
21. static int pin;  
22.   
23. static int led\_open(struct inode \*inode, struct file \*file)\{  
24.   
25.     \*gpio\_con &= ~(0x03 << (pin\*2));  
26.     \*gpio\_con |=  (0x01 << (pin\*2));  
27.     return 0;  
28. \}  
29.   
30. static ssize\_t led\_write(struct file \*file, const char \_\_user \*buf,  
31.     size\_t count, loff\_t \*ppos)\{  
32.   
33.     int val;  
34.     copy\_from\_user(&val, buf, count);  
35.   
36.     if(val == 1)\{  
37.           
38.         \*gpio\_dat &= ~(1<<pin);  
39.     \}else\{  
40.       
41.         \*gpio\_dat &=  (1<<pin);  
42.     \}  
43.   
44.     return 0;  
45. \}  
46.   
47. static struct file\_operations led\_fops = \{  
48.   
49.     .owner = THIS\_MODULE,  
50.     .open  = led\_open,  
51.     .write = led\_write,  
52. \};  
53.   
54. static int led\_probe(struct platform\_device \*pdev)\{  
55.   
56.     struct resource \*res;  
57.     // 最后一个参数 0 表示第1个该类型的资源  
58.     res = platform\_get\_resource(pdev, IORESOURCE\_MEM, 0);  
59.     gpio\_con = ioremap(res->start, res->end - res->start + 1);  
60.     gpio\_dat = gpio\_con + 1;  
61.   
62.     res = platform\_get\_resource(pdev, IORESOURCE\_IRQ, 0);  
63.     pin = res->start;  
64.   
65.     printk("led\_probe, found led\\n");  
66.   
67.     // 注册设备驱动 创建设备节点  
68.     major = register\_chrdev(0, "myled", &led\_fops);  
69.     // 创建类  
70.     cls = class\_create(THIS\_MODULE, "myled");  
71.     // 创建设备节点  
72.     dev = device\_create(cls, NULL, MKDEV(major, 0), NULL, "led");  
73.   
74.     return 0;  
75. \}  
76.   
77. static int led\_remove(struct platform\_device \*pdev)\{  
78.   
79.     printk("led\_remove, remove led\\n");   
80.     // 删除设备节点  
81.     device\_unregister(dev);  
82.     // 销毁类  
83.     class\_destroy(cls);  
84.     // 取消注册设备驱动  
85.     unregister\_chrdev(major, "myled");  
86.     // 取消内存映射  
87.     iounmap(gpio\_con);  
88.   
89.     return 0;  
90. \}  
91.   
92. struct platform\_driver led\_drv = \{  
93.   
94.     .probe  = led\_probe,    //匹配到dev之后调用probe  
95.     .remove = led\_remove,  
96.     .driver = \{  
97.         .name = "myled",  
98.     \},  
99. \};  
100.   
101. static int led\_drv\_init(void)\{  
102.   
103.     platform\_driver\_register(&led\_drv);  
104.     return 0;  
105. \}  
106.   
107. static void led\_drv\_exit(void)\{  
108.       
109.     platform\_driver\_unregister(&led\_drv);  
110. \}  
111.   
112. module\_init(led\_drv\_init);  
113. module\_exit(led\_drv\_exit);  
114. MODULE\_LICENSE("GPL");

转自：http://blog.csdn.net/lizuobin2/article/details/51607813

[20160608012422012]: /images/20220602/64571095cd34434c8725c2b736f9674a.png
[view plain]: http://blog.csdn.net/lizuobin2/article/details/51607813#