Linux 设备驱动开发 —— platform设备驱动应用实例解析

前面我们已经学习了platform设备的理论知识Linux 设备驱动开发 —— platform 设备驱动 ，下面将通过一个实例来深入我们的学习。

一、platform 驱动的工作过程

platform模型驱动编程，platform 驱动只是在字符设备驱动外套一层platform_driver 的外壳。

在一般情况下，2.6内核中已经初始化并挂载了一条platform总线在sysfs文件系统中。那么我们编写platform模型驱动时，需要完成两个工作：

a -- 实现platform驱动

架构就很简单，如下所示：

platform驱动模型三个对象：platform总线、platform设备、platform驱动。

platform总线对应的内核结构：struct bus_type-->它包含的最关键的函数：match() (要注意的是，这块由内核完成，我们不参与)

platform设备对应的内核结构：struct platform_device-->注册：platform_device_register(unregister)

platform驱动对应的内核结构：struct platform_driver-->注册：platform_driver_register(unregister)

那具体platform驱动的工作过程是什么呢：

如果先注册设备，驱动还没有注册，那么设备在被注册到总线上时，将不会匹配到与自己同名的驱动，然后在驱动注册到总线上时，因为设备已注册，那么总线会立即匹配与绑定这时的同名的设备与驱动，再调用驱动中的probe函数等；

如果是驱动先注册，同设备驱动一样先会匹配失败，匹配失败将导致它的probe函数暂不调用，而是要等到设备注册成功并与自己匹配绑定后才会调用。

二、实现platform 驱动与设备的详细过程

1、思考问题？

在分析platform 之前，可以先思考一下下面的问题：

a -- 为什么要用 platform 驱动？不用platform驱动可以吗？

b -- 设备驱动中引入platform 概念有什么好处？

现在先不回答，看完下面的分析就明白了，后面会附上总结。

2、platform_device 结构体 VS platform_driver 结构体

这两个结构体分别描述了设备和驱动，二者有什么关系呢？先看一下具体结构体对比

设备（硬件部分）：中断号，寄存器，DMA等                    platform_device 结构体	驱动（软件部分）                          platform_driver 结构体
struct platform_device {     const char    *name;       名字     int        id;     bool        id_auto;     struct device    dev;   硬件模块必须包含该结构体     u32        num_resources;        资源个数     struct resource    *resource;         资源  人脉     const struct platform_device_id    *id_entry;     /* arch specific additions */     struct pdev_archdata    archdata; };	struct platform_driver {     int (*probe)(struct platform_device *);     硬件和软件匹配成功之后调用该函数     int (*remove)(struct platform_device *);     硬件卸载了调用该函数     void (*shutdown)(struct platform_device *);     int (*suspend)(struct platform_device *, pm_message_t state);     int (*resume)(struct platform_device *);     struct device_driver driver;内核里所有的驱动程序必须包含该结构体     const struct platform_device_id *id_table;  八字 };
设备实例： static struct platform_device hello_device= {     .name = "bigbang",     .id = -1,     .dev.release = hello_release, };	驱动实例： static struct platform_driver hello_driver= {     .driver.name = "bigbang",     .probe = hello_probe,     .remove = hello_remove, };

前面提到，实现platform模型的过程就是总线对设备和驱动的匹配过程 。打个比方，就好比相亲，总线是红娘，设备是男方，驱动是女方：

a -- 红娘（总线）负责男方（设备）和女方（驱动）的撮合；

b -- 男方（女方）找到红娘，说我来登记一下，看有没有合适的姑娘（汉子）—— int (*probe)(struct platform_device *) 匹配成功后驱动执行的第一个函数），当然如果男的跟小三跑了（设备卸载），女方也不会继续待下去的（
 int (*remove)(struct platform_device *)）。

3、设备资源结构体

在struct platform_device 结构体中有一重要成员 struct resource *resource

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. #define IORESOURCE_MEM        0x00000200
9. #define IORESOURCE_IRQ        0x00000400

flags 指资源类型，我们常用的是 IORESOURCE_MEM、IORESOURCE_IRQ  这两种。start 和 end 的含义会随着 flags而变更，如

a -- flags为IORESOURCE_MEM 时，start 、end 分别表示该platform_device占据的内存的开始地址和结束值；

b -- flags为 IORESOURCE_IRQ
  时，start 、end 分别表示该platform_device使用的中断号的开始地址和结束值；

下面看一个实例：

1. static struct  resource beep_resource[] =
2. {
3. [0] = {
4. .start = 0x114000a0,
5. .end = 0x114000a0+0x4,
6. .flags = IORESOURCE_MEM,
7. },
8. [1] = {
9. .start = 0x139D0000,
10. .end = 0x139D0000+0x14,
11. .flags = IORESOURCE_MEM,
12. },
13. };

4、将字符设备添加到 platform的driver中

      前面我们提到platform 驱动只是在字符设备驱动外套一层platform_driver 的外壳，下面我们看一下添加的过程：

1. static struct file_operations hello_ops=
2. {
3. .open = hello_open,
4. .release = hello_release,
5. .unlocked_ioctl = hello_ioctl,
6. };
7. static int hello_remove(struct platform_device *pdev)
8. {
9. 注销分配的各种资源
10. }
11. static int hello_probe(struct platform_device *pdev)
12. {
13. 1.申请设备号
14. 2.cdev初始化注册,&hello_ops
15. 3.从pdev读出硬件资源
16. 4.对硬件资源初始化，ioremap，request_irq( )
17. }
18. static int hello_init(void)
19. {
20. 只注册 platform_driver
21. }
22. static void hello_exit(void)
23. {
24. 只注销 platform_driver
25. }

      可以看到，

5、platform是如何匹配device和driver

      这时就该总线出场了，系统为platform总线定义了一个bus_type 的实例platform_bus_type，其定义如下：

1. struct bus_type platform_bus_type = {
2. .name        = "platform",
3. .dev_groups    = platform_dev_groups,
4. .match        = platform_match,
5. .uevent        = platform_uevent,
6. .pm        = &platform_dev_pm_ops,
7. };

      其又是怎样工作的呢？在platform.c (e:\linux-3.14-fs4412\drivers\base)    31577    2014/3/31 中可以看到

1. __platform_driver_register（）
2. {
3. drv->driver.bus = &platform_bus_type;     536行
4. }

    在 platform_bus_type 中调用 了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. 匹配设备树信息，如果有设备树，就调用 of_driver_match_device() 函数进行匹配
6. if (of_driver_match_device(dev, drv))
7. return 1;
8. 匹配id_table
9. if (pdrv->id_table)
10. return platform_match_id(pdrv->id_table, pdev) != NULL;
11. 最基本匹配规则
12. return (strcmp(pdev->name, drv->name) == 0);
13. }

6、解决问题

      现在可以回答这两个问题了

a -- 为什么要用 platform 驱动？不用platform驱动可以吗？

b -- 设备驱动中引入platform 概念有什么好处？

      引入platform模型符合Linux 设备模型 —— 总线、设备、驱动，设备模型中配套的sysfs节点都可以用，方便我们的开发；当然你也可以选择不用，不过就失去了一些platform带来的便利；

      Linux 字符设备驱动开发基础（二）—— 编写简单 PWM 设备驱动， 下面来看一下，套上platform 外壳后的程序：

1、device.c

1. #include <linux/module.h>
2. #include <linux/device.h>
3. #include <linux/platform_device.h>
4. #include <linux/ioport.h>
5. static struct resource beep_resource[] =
6. {
7. [0] ={
8. .start = 0x114000a0,
9. .end =  0x114000a0 + 0x4,
10. .flags = IORESOURCE_MEM,
11. },
12. [1] ={
13. .start = 0x139D0000,
14. .end =  0x139D0000 + 0x14,
15. .flags = IORESOURCE_MEM,
16. }
17. };
18. static void hello_release(struct device *dev)
19. {
20. printk("hello_release\n");
21. return ;
22. }
23. static struct platform_device hello_device=
24. {
25. .name = "bigbang",
26. .id = -1,
27. .dev.release = hello_release,
28. .num_resources = ARRAY_SIZE(beep_resource),
29. .resource = beep_resource,
30. };
31. static int hello_init(void)
32. {
33. printk("hello_init");
34. return platform_device_register(&hello_device);
35. }
36. static void hello_exit(void)
37. {
38. printk("hello_exit");
39. platform_device_unregister(&hello_device);
40. return;
41. }
42. MODULE_LICENSE("GPL");
43. module_init(hello_init);
44. module_exit(hello_exit);

2、driver.c

1. #include <linux/module.h>
2. #include <linux/fs.h>
3. #include <linux/cdev.h>
4. #include <linux/device.h>
5. #include <linux/platform_device.h>
6. #include <asm/io.h>
7. static int major = 250;
8. static int minor=0;
9. static dev_t devno;
10. static struct class *cls;
11. static struct device *test_device;
12. #define TCFG0         0x0000
13. #define TCFG1         0x0004
14. #define TCON          0x0008
15. #define TCNTB0        0x000C
16. #define TCMPB0        0x0010
17. static unsigned int *gpd0con;
18. static void *timer_base;
19. #define  MAGIC_NUMBER    'k'
20. #define  BEEP_ON    _IO(MAGIC_NUMBER    ,0)
21. #define  BEEP_OFF   _IO(MAGIC_NUMBER    ,1)
22. #define  BEEP_FREQ   _IO(MAGIC_NUMBER   ,2)
23. static void fs4412_beep_init(void)
24. {
25. writel ((readl(gpd0con)&~(0xf<<0)) | (0x2<<0),gpd0con);
26. writel ((readl(timer_base +TCFG0  )&~(0xff<<0)) | (0xff <<0),timer_base +TCFG0);
27. writel ((readl(timer_base +TCFG1 )&~(0xf<<0)) | (0x2 <<0),timer_base +TCFG1 );
28. writel (500, timer_base +TCNTB0  );
29. writel (250, timer_base +TCMPB0 );
30. writel ((readl(timer_base +TCON )&~(0xf<<0)) | (0x2 <<0),timer_base +TCON );
31. }
32. void fs4412_beep_on(void)
33. {
34. writel ((readl(timer_base +TCON )&~(0xf<<0)) | (0x9 <<0),timer_base +TCON );
35. }
36. void fs4412_beep_off(void)
37. {
38. writel ((readl(timer_base +TCON )&~(0xf<<0)) | (0x0 <<0),timer_base +TCON );
39. }
40. static void beep_unmap(void)
41. {
42. iounmap(gpd0con);
43. iounmap(timer_base);
44. }
45. static int beep_open (struct inode *inode, struct file *filep)
46. {
47. fs4412_beep_on();
48. return 0;
49. }
50. static int beep_release(struct inode *inode, struct file *filep)
51. {
52. fs4412_beep_off();
53. return 0;
54. }
55. #define BEPP_IN_FREQ 100000
56. static void beep_freq(unsigned long arg)
57. {
58. writel(BEPP_IN_FREQ/arg, timer_base +TCNTB0  );
59. writel(BEPP_IN_FREQ/(2*arg), timer_base +TCMPB0 );
60. }
61. static long beep_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
62. {
63. switch(cmd)
64. {
65. case BEEP_ON:
66. fs4412_beep_on();
67. break;
68. case BEEP_OFF:
69. fs4412_beep_off();
70. break;
71. case BEEP_FREQ:
72. beep_freq( arg );
73. break;
74. default :
75. return -EINVAL;
76. }
77. return 0;
78. }
79. static struct file_operations beep_ops=
80. {
81. .open     = beep_open,
82. .release = beep_release,
83. .unlocked_ioctl      = beep_ioctl,
84. };
85. static int beep_probe(struct platform_device *pdev)
86. {
87. int ret;
88. printk("match ok!");
89. gpd0con = ioremap(pdev->resource[0].start,pdev->resource[0].end - pdev->resource[0].start);
90. timer_base = ioremap(pdev->resource[1].start, pdev->resource[1].end - pdev->resource[1].start);
91. devno = MKDEV(major,minor);
92. ret = register_chrdev(major,"beep",&beep_ops);
93. cls = class_create(THIS_MODULE, "myclass");
94. if(IS_ERR(cls))
95. {
96. unregister_chrdev(major,"beep");
97. return -EBUSY;
98. }
99. test_device = device_create(cls,NULL,devno,NULL,"beep");//mknod /dev/hello
100. if(IS_ERR(test_device))
101. {
102. class_destroy(cls);
103. unregister_chrdev(major,"beep");
104. return -EBUSY;
105. }
106. fs4412_beep_init();
107. return 0;
108. }
109. static int beep_remove(struct platform_device *pdev)
110. {
111. beep_unmap();
112. device_destroy(cls,devno);
113. class_destroy(cls);
114. unregister_chrdev(major,"beep");
115. return 0;
116. }
117. static struct platform_driver beep_driver=
118. {
119. .driver.name = "bigbang",
120. .probe = beep_probe,
121. .remove = beep_remove,
122. };
123. static int beep_init(void)
124. {
125. printk("beep_init");
126. return platform_driver_register(&beep_driver);
127. }
128. static void beep_exit(void)
129. {
130. printk("beep_exit");
131. platform_driver_unregister(&beep_driver);
132. return;
133. }
134. MODULE_LICENSE("GPL");
135. module_init(beep_init);
136. module_exit(beep_exit);

3、makefile

1. ifneq  ($(KERNELRELEASE),)
2. obj-m:=device.o driver.o
3. $(info "2nd")
4. else
5. #KDIR := /lib/modules/$(shell uname -r)/build
6. KDIR := /home/fs/linux/linux-3.14-fs4412
7. PWD:=$(shell pwd)
8. all:
9. $(info "1st")
10. make -C $(KDIR) M=$(PWD) modules
11. clean:
12. rm -f *.ko *.o *.symvers *.mod.c *.mod.o *.order
13. endif

4、test.c

1. #include <sys/types.h>
2. #include <sys/stat.h>
3. #include <fcntl.h>
4. #include <stdio.h>
5. main()
6. {
7. int fd,i,lednum;
8. fd = open("/dev/beep",O_RDWR);
9. if(fd<0)
10. {
11. perror("open fail \n");
12. return ;
13. }
14. sleep(10);
15. close(fd);
16. }