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

2012-09-02 10:57:50

分类： LINUX

    linux从2.6起就加入了一套新的驱动管理和注册的机制platform平台总线，是一条虚拟的总线，设备用platform_device表示，驱 动用platform_driver进行注册。于传统的bus/device/driver机制相比，platform由内核进行统一管理，在驱动中使用 资源，提高了代码的安全性和可移植性。

下面来看看内核时怎么注册platform总线的过程

点击(此处)折叠或打开

1. int __init platform_bus_init(void)
   
2. {
   
3.     int error;
   
4. 
   
5.     early_platform_cleanup();
   
6. 
   
7.     error = device_register(&platform_bus);//注册了platform的设备
   
8.     if (error)
   
9.         return error;
   
10.     error = bus_register(&platform_bus_type);//注册了platform总线
    
11.     if (error)
    
12.         device_unregister(&platform_bus);
    
13.     return error;
    
14. }

点击(此处)折叠或打开

1. struct device platform_bus = {
   
2.     .init_name    = "platform",
   
3. };

点击(此处)折叠或打开

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

其过程和总线的注册过程差不多，驱动和设备匹配后，调用platform的match函数。由传统的机制，也不难总结出platform的开发流程为

1、定义一个platform_device，并注册

2、定义一个platform_driver，并注册

定义platform_device过程

点击(此处)折叠或打开

1. struct platform_device *platform_device_alloc(const char *name, int id)
   
2. {
   
3.     struct platform_object *pa;
   
4. 
   
5.     pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);
   
6.     if (pa) {
   
7.         strcpy(pa->name, name);
   
8.         pa->pdev.name = pa->name;
   
9.         pa->pdev.id = id;
   
10.         device_initialize(&pa->pdev.dev);
    
11.         pa->pdev.dev.release = platform_device_release;
    
12.         arch_setup_pdev_archdata(&pa->pdev);
    
13.     }
    
14. 
    
15.     return pa ? &pa->pdev : NULL;
    
16. }

下面首先来看看platform_device的注册过程

点击(此处)折叠或打开

1. struct platform_device {
   
2.     const char    * name;                  //设备名
   
3.     int        id;                         //设备ID
   
4.     struct device    dev;
   
5.     u32        num_resources;              //设备使用的资源的数目
   
6.     struct resource    * resource;         //设备使用的资源
7. 
   
8.     const struct platform_device_id    *id_entry;
   
9. 
   
10.     /* MFD cell pointer */
    
11.     struct mfd_cell *mfd_cell;
    
12. 
    
13.     /* arch specific additions */
    
14.     struct pdev_archdata    archdata;
    
15. };

点击(此处)折叠或打开

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

在struct resource结构中我们通常只关心start、end和flags这3个字段，分别表示资源的开始值、结束值和类型，flags可以用内存资源，IO资源，中断资源等。

点击(此处)折叠或打开

1. int platform_device_register(struct platform_device *pdev)
   
2. {
   
3.     device_initialize(&pdev->dev);//dev初始化
   
4.     arch_setup_pdev_archdata(pdev);
   
5.     return platform_device_add(pdev);//加入到dev链表
   
6. }

点击(此处)折叠或打开

1. int platform_device_add(struct platform_device *pdev)
   
2. {
   
3.     int i, ret = 0;
   
4. 
   
5.     if (!pdev)
   
6.         return -EINVAL;
   
7. 
   
8.     if (!pdev->dev.parent)
   
9.         pdev->dev.parent = &platform_bus;//父设备设置为platform_bus
   
10. 
    
11.     pdev->dev.bus = &platform_bus_type;//设备挂载在platforrm总线上
    
12. 
    
13.     if (pdev->id != -1)
    
14.         dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);
    
15.     else
    
16.         dev_set_name(&pdev->dev, "%s", pdev->name);
    
17. 
    
18.     for (i = 0; i <</span> pdev->num_resources; i++) {    //完成资源的初始化
    
19.         struct resource *p, *r = &pdev->resource[i];
    
20. 
    
21.         if (r->name == NULL)
    
22.             r->name = dev_name(&pdev->dev);
    
23. 
    
24.         p = r->parent;
    
25.         if (!p) {
    
26.             if (resource_type(r) == IORESOURCE_MEM)
    
27.                 p = &iomem_resource;
    
28.             else if (resource_type(r) == IORESOURCE_IO)
    
29.                 p = &ioport_resource;
    
30.         }
    
31. 
    
32.         if (p && insert_resource(p, r)) {
    
33.             printk(KERN_ERR
    
34.              "%s: failed to claim resource %d\n",
    
35.              dev_name(&pdev->dev), i);
    
36.             ret = -EBUSY;
    
37.             goto failed;
    
38.         }
    
39.     }
    
40. 
    
41.     pr_debug("Registering platform device '%s'. Parent at %s\n",
    
42.          dev_name(&pdev->dev), dev_name(pdev->dev.parent));
    
43. 
    
44.     ret = device_add(&pdev->dev);
    
45.     if (ret == 0)
    
46.         return ret;
    
47. 
    
48.  failed:
    
49.     while (--i >= 0) {
    
50.         struct resource *r = &pdev->resource[i];
    
51.         unsigned long type = resource_type(r);
    
52. 
    
53.         if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
    
54.             release_resource(r);
    
55.     }
    
56. 
    
57.     return ret;
    
58. }

其上最后也是调用device_add的，其主要是将device加入到bus总线中，并由device_attach完成设备与驱动之间的匹配，这个过程在设备一篇中已经有详细的分析过程中，再看看驱动的注册过程。

点击(此处)折叠或打开

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.     const struct platform_device_id *id_table;
   
9. };

可见，它包含了设备操作的功能函数，同时包含了device_driver结构。内核提供的platform_driver结构的注册为

点击(此处)折叠或打开

1. int platform_driver_register(struct platform_driver *drv)
   
2. {
   
3.     drv->driver.bus = &platform_bus_type;//注册到总线上，drv与dev匹配通过platform_bus_type注册的platform_match完成
   
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. }

其注册函数中比较重要的还是调用了driver_register，添加到platform总线链表，完成设备与驱动之间的匹配过程，其主要的过程在总线设备驱动模型的驱动篇已经有过分析。

点击(此处)折叠或打开

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

下面看看看驱动和设备的匹配过程，由以前可以看出，主要是调用bus的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.     /* Attempt an OF style match first */
   
7.     if (of_driver_match_device(dev, drv))
   
8.         return 1;
   
9. 
   
10.     /* Then try to match against the id table */
    
11.     if (pdrv->id_table)
    
12.         return platform_match_id(pdrv->id_table, pdev) != NULL;
    
13. 
    
14.     /* fall-back to driver name match */
    
15.     return (strcmp(pdev->name, drv->name) == 0);
    
16. }

由上面可以看出，只需要比较dev的名字和drv的名字，如果是相同的话就匹配成功。

在platform的设备驱动的编写有两种方法：

1、在bsp版文件中实现定义，在文件中将platform_device被化为一个数组，最后通过platform_add_devices函数注册。对于2440来说位于arch\arm\mach-s3c2440\mach-smdk2440.c中定义

点击(此处)折叠或打开

1. static struct platform_device *smdk2440_devices[] __initdata = {
   
2.     &s3c_device_usb,
   
3.     &s3c_device_lcd,
   
4.     &s3c_device_wdt,
   
5.     &s3c_device_i2c,
   
6.     &s3c_device_iis,
   
7. };

如果我们要实现一个设备的添加，那么只需要加入一个struct platform_device的数组，然后只需要编写对应的platform_driver驱动程序就可以了。从这种方法可以看出，存在一个很明显的缺点，如果要改写驱动，就要重新的编译内核。

2、第二种方法只需要单独编写一个内核模块加载到内核中。

例子：

device文件：platform_dev.c

点击(此处)折叠或打开

1. struct platform_device *my_led_dev;
   
2.   
   
3. static int __init platform_dev_init(void)
   
4. {
   
5.     int ret;
   
6.       
   
7.  //分配一个 platform_device结构体
   
8.     my_led_dev = platform_device_alloc("platform_led", -1);
   
9.       
   
10.     ret = platform_device_add(my_led_dev);//将自定义的设备添加到内核设备架构中
    
11.       
    
12.     if(ret)
    
13.         platform_device_put(my_led_dev);//销毁platform设备结构
    
14.       
    
15.     return ret;
    
16. }
    
17.   
    
18. static void __exit platform_dev_exit(void)
    
19. {
    
20.     platform_device_unregister(my_led_dev);//注销platform_device
    
21. }
    
22.   
    
23. module_init(platform_dev_init);
    
24. module_exit(platform_dev_exit);
    
25.   
    
26. MODULE_AUTHOR("Sola");
    
27. MODULE_LICENSE("GPL");

drv文件：platform_drv.c

点击(此处)折叠或打开

1. static int s3c6410_led_open(struct inode *inode, struct file *file)
   
2. {
   
3.    unsigned tmp;
   
4.           tmp = readl(S3C64XX_GPMCON);
   
5.      tmp = (tmp & ~(0xFFFF))|(0x1111U);
   
6.           writel(tmp, S3C64XX_GPMCON);
   
7.   
   
8.      return 0;
   
9. }
   
10.   
    
11.   
    
12. static int s3c6410_led_close(struct inode *inode, struct file *file)
    
13. {
    
14. 
    
15.     return 0;
    
16. }
    
17.   
    
18.   
    
19. static int s3c6410_led_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
    
20. {
    
21.      printk("#########read######\n");
    
22.      return count;
    
23. }
    
24. 
    
25. static int s3c6410_led_write (struct file *filp, const char __user *buf, size_t count,loff_t *f_pos)
    
26. {
    
27.      char wbuf[10];
    
28.      unsigned tmp;
    
29. 
    
30.      copy_from_user(wbuf,buf,count);
    
31.   if(wbuf[0]==1)//1号灯亮
    
32.      switch(wbuf[1])
    
33.      {
    
34.          case 0: //off
    
35.              tmp = readl(S3C64XX_GPMDAT);
    
36.                            tmp |= (0x1U);
    
37.                            writel(tmp, S3C64XX_GPMDAT);
    
38.              break;
    
39.          case 1: //on
    
40.              tmp = readl(S3C64XX_GPMDAT);
    
41.                            tmp &= ~(0x1U);
    
42.                            writel(tmp, S3C64XX_GPMDAT);
    
43.              break;
    
44.          default :
    
45.              break;
    
46.      }
    
47.   
    
48.   if(wbuf[0]==2)//2号灯亮
    
49.      switch(wbuf[1])
    
50.      {
    
51.          case 0: //off
    
52.              tmp = readl(S3C64XX_GPMDAT);
    
53.                            tmp |= (0x2U);
    
54.                            writel(tmp, S3C64XX_GPMDAT);
    
55.              break;
    
56.          case 1: //on
    
57.              tmp = readl(S3C64XX_GPMDAT);
    
58.                            tmp &= ~(0x2U);
    
59.                            writel(tmp, S3C64XX_GPMDAT);
    
60.              break;
    
61.          default :
    
62.              break;
    
63.      }
    
64.   
    
65.   if(wbuf[0]==3)//3号灯亮
    
66.      switch(wbuf[1])
    
67.      {
    
68.          case 0: //off
    
69.              tmp = readl(S3C64XX_GPMDAT);
    
70.                            tmp |= (0x4U);
    
71.                            writel(tmp, S3C64XX_GPMDAT);
    
72.              break;
    
73.          case 1: //on
    
74.              tmp = readl(S3C64XX_GPMDAT);
    
75.                            tmp &= ~(0x4U);
    
76.                            writel(tmp, S3C64XX_GPMDAT);
    
77.              break;
    
78.          default :
    
79.              break;
    
80.      }
    
81.   
    
82.   if(wbuf[0]==4)//4号灯亮
    
83.      switch(wbuf[1])
    
84.      {
    
85.          case 0: //off
    
86.              tmp = readl(S3C64XX_GPMDAT);
    
87.                            tmp |= (0x8U);
    
88.                            writel(tmp, S3C64XX_GPMDAT);
    
89.              break;
    
90.          case 1: //on
    
91.              tmp = readl(S3C64XX_GPMDAT);
    
92.                            tmp &= ~(0x8U);
    
93.                            writel(tmp, S3C64XX_GPMDAT);
    
94.              break;
    
95.          default :
    
96.              break;
    
97.      }
    
98.      return count;
    
99. }
    
100.   
     
101.   
     
102. static struct file_operations led_fops = {
     
103.     .owner = THIS_MODULE,
     
104.     .open = s3c6410_led_open,
     
105.     .release = s3c6410_led_close,
     
106.     .read = s3c6410_led_read,
     
107.  .write = s3c6410_led_write,
     
108. };
     
109.   
     
110.   
     
111. static int my_plat_probe(struct platform_device *dev)
     
112. {
     
113.     int rc;
     
114.  printk("Test platform_led dev\n");
     
115.  //注册设备
     
116.  rc = register_chrdev(LED_MAJOR,"platform_led",&led_fops);
     
117.   if (rc <</span>0)
     
118.      {
     
119.          printk ("register %s char dev error\n","led");
     
120.          return -1;
     
121.      }
     
122.      printk ("ok!\n");
     
123.      return 0;
     
124. }
     
125.   
     
126. static int my_plat_remove(struct platform_device *dev)
     
127. {
     
128.     printk("my platfrom device has removed.\n");
     
129.     return 0;
     
130. }
     
131.   
     
132. struct platform_driver my_led_drv = {
     
133.     .probe = my_plat_probe,
     
134.     .remove = my_plat_remove,
     
135.     .driver = {
     
136.         .owner = THIS_MODULE,
     
137.         .name = "platform_led",
     
138.     },
     
139. };
     
140.   
     
141. static int __init platform_drv_init(void)
     
142. {
     
143.     int ret;
     
144.   
     
145.     ret = platform_driver_register(&my_led_drv);
     
146.       
     
147.     return ret;
     
148. }
     
149.   
     
150. static void __exit platform_drv_exit(void)
     
151. {
     
152.     platform_driver_unregister(&my_led_drv);
     
153. }
     
154.   
     
155. module_init(platform_drv_init);
     
156. module_exit(platform_drv_exit);
     
157.   
158. MODULE_LICENSE("GPL");