【正点原子Linux连载】第十九章 设备树下的platform驱动编写 摘自【正点原子】ATK-DLRK3568嵌入式Linux驱动开发指南

1）实验平台：正点原子ATK-DLRK3568开发板
2）平台购买地址：https://detail.tmall.com/item.htm?id=731866264428
3）全套实验源码+手册+视频下载地址： http://www.openedv.com/docs/boards/xiaoxitongban

第十九章 设备树下的platform驱动编写

上一章我们详细的讲解了Linux下的驱动分离与分层，以及总线、设备和驱动这样的驱动框架。基于总线、设备和驱动这样的驱动框架，Linux内核提出来platform这个虚拟总线，相应的也有platform设备和platform驱动。上一章我们讲解了传统的、未采用设备树的platform设备和驱动编写方法。最新的Linux内核已经支持了设备树，因此在设备树下如何编写platform驱动就显得尤为重要，本章我们就来学习一下如何在设备树下编写platform驱动。

19.1 设备树下的platform驱动简介
platform驱动框架分为总线、设备和驱动，其中总线不需要我们这些驱动程序员去管理，这个是Linux内核提供的，我们在编写驱动的时候只要关注于设备和驱动的具体实现即可。在没有设备树的Linux内核下，我们需要分别编写并注册platform_device和platform_driver，分别代表设备和驱动。在使用设备树的时候，设备的描述被放到了设备树中，因此platform_device就不需要我们去编写了，我们只需要实现platform_driver即可。
19.1.1 创建设备的pinctrl节点
在platform驱动框架下必须使用pinctrl来配置引脚复用功能。我们以本章实验需要用到的LED0为例，编写LED0引脚的 pinctrl配置。打开rk3568-pinctrl.dtsi文件，RK3568的所有引脚pinctrl配置都是在这个文件里面完成的，在pinctrl节点下添加如下所示内容：
示例代码19.1.1.1 GPIO的pinctrl配置

1 led-gpios{
2       /omit-if-no-ref/
3       led_gpio: led-pin {
4           rockchip,pins =
5               <0 RK_PC0 RK_FUNC_GPIO &pcfg_pull_none>;
6       };
7   };
1
2
3
4
5
6
7

示例代码19.1.1.1中的第3行的led_gpio节点就是LED的pinctrl配置，把GPIO0_C0端口复用为GPIO功能。
1

19.1.2 在设备树中创建设备节点
接下来要在设备树中创建设备节点来描述设备信息，重点是要设置好compatible属性的值，因为platform总线需要通过设备节点的compatible属性值来匹配驱动！这点要切记。修改10.4.2小节中我们创建的gpioled节点，修改以后的内容如下：
示例代码19.1.2.1 gpioled设备节点

1 gpioled {
2     compatible = "alientek,led";
3     pinctrl-names = "alientek,led";
4     pinctrl-0 = <&led_gpio>;
5     led-gpio = <&gpio0 RK_PC0 GPIO_ACTIVE_HIGH>;
6     status = "okay";
7 };
1
2
3
4
5
6
7

第2行的compatible属性值为“alientek,led”，因此一会在编写platform驱动的时候of_match_table属性表中要有“alientek,led”。
第4行里，pinctrl-0属性设置LED的PIN对应的pinctrl节点，也就是我们在示例代码19.1.1.1中编写的led_gpio。
19.1.3 编写platform驱动的时候要注意兼容属性
上一章已经详细的讲解过了，在使用设备树的时候platform驱动会通过of_match_table来保存兼容性值，也就是表明此驱动兼容哪些设备。所以，of_match_table将会尤为重要，比如本例程的platform驱动中platform_driver就可以按照如下所示设置：
示例代码19.1.3.1 of_match_table匹配表的设置

1  	static const struct of_device_id led_of_match[] = {
2   	{ .compatible = "alientek,led" },  /* 兼容属性 */
3   	{ /* Sentinel */ }
4  	};
5   
6  	MODULE_DEVICE_TABLE(of, led_of_match);
7  
8  	static struct platform_driver led_platform_driver = {
9   	.driver = {
10      	.name       = "rk3568-led",
11      	.of_match_table = led_of_match,
12  	},
13  	.probe          = led_probe,
14  	.remove         = led_remove,
15 	};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

第1~4行，of_device_id表，也就是驱动的兼容表，是一个数组，每个数组元素为of_device_id类型。每个数组元素都是一个兼容属性，表示兼容的设备，一个驱动可以跟多个设备匹配。这里我们仅仅匹配了一个设备，那就是示例代码19.1.2中创建的gpioled这个设备。第2行的compatible值为“alientek,led”，驱动中的compatible属性和设备中的compatible属性相匹配，因此驱动中对应的probe函数就会执行。注意第3行是一个空元素，在编写of_device_id的时候最后一个元素一定要为空！
1

第6行，通过MODULE_DEVICE_TABLE声明一下led_of_match这个设备匹配表。
第11行，设置platform_driver中的of_match_table匹配表为上面创建的leds_of_match，至此我们就设置好了platform驱动的匹配表了。
最后就是编写驱动程序，基于设备树的platform驱动和上一章无设备树的platform驱动基本一样，都是当驱动和设备匹配成功以后先根据设备树里的pinctrl属性设置PIN的电气特性再去执行probe函数。我们需要在probe函数里面执行字符设备驱动那一套，当注销驱动模块的时候remove函数就会执行，都是大同小异的。
19.2 检查引脚复用配置
19.2.1 检查引脚pinctrl配置
RK3568的一个引脚可以复用为多种功能，比如GPIO0_C0这个IO就可以用作：GPIO，PWM1_M0，GPU_AVS和UART0_RX这四个功能。我们在学习STM32单片机开发的时候，一个IO可以被多个外设使用，比如GPIO0_C0同时作为PWM1_M0、UART0_RX，但是同一时刻只能用做一个功能，做PWM1_M0的时候就不能做UART0_RX！在嵌入式Linux下，我们要严格按照一个引脚对应一个功能来设计硬件，比如GPIO0_C0现在要用作GPIO来驱动LED灯，那么就不能将GPIO0_C0作为其他功能。
正点原子RK3568开发板上将GPIO0_C0连接到了LED0上，也就是将其用作普通的GPIO，对应的pinctrl配置就是示例代码19.1.1.1。但是rk3568-pinctrl.dtsi是瑞芯微根据自己官方开发板编写的，因此GPIO0_C0就可能被瑞芯微方用作其他功能，大家在rk3568-pinctrl.dtsi里面找到如下所示代码：

图19.2.1.1 acodec_pins节点
从图19.2.1.1可以看出，瑞芯微官方将GPIO0_C0复用为ACODEC，前面说了，一个IO只能复用为一个功能，所以如果pwm1使能的话，我们就不能再将GPIO0_C0复用为GPIO了。
同样的，继续在rk3568-pinctrl.dtsi文件里面查找，会发现如图19.2.1.2所示的地方也将GPIO0_C0复用为了uart0的rx功能：

图19.2.1.2 i2s0m0_lrck_rx节点
图19.2.1.2中的uart0-xfer节点也将GPIO0_C0复用为uart0_rx，大家继续在rk3568-pinctrl.dtsi文件中搜索，还会找到GPIO0_C0的其他复用功能。
19.2.2 检查GPIO占用
上一小节只是检查了一下，GPIO0_C0这个引脚有没有被复用为多个设备，本节我们将GPIO0_C0复用为GPIO。因为我们是在瑞芯微官方提供的设备树上修改的，因此还要检查一下当GPIO0_C0作为GPIO的时候，瑞芯微官方有没有将这个GPIO分配给其他设备。其实对于GPIO0_C0这个引脚来说不会的，因为瑞芯微官方没有将其复用为GPIO，所以也就不存在说将其在作为GPIO分配给其他设备。但是我们在实际开发中要考虑到这一点，说不定其他的引脚就会被分配给某个设备做GPIO，而我们没有检查，导致两个设备都用这一个GPIO，那么肯定有一个因为申请不到GPIO而导致驱动无法工作。
所以当我们将一个引脚用作GPIO的时候，一定要检查一下当前设备树里面是否有其他设备也使用到了这个GPIO，保证设备树中只有一个设备树在使用这个GPIO。
19.3 硬件原理图分析
本实验的硬件原理参考6.2小节即可。
19.4 实验程序编写
本实验对应的例程路径为：开发板光盘01、程序源码Linux驱动例程17_dtsplatform。
本章实验我们编写基于设备树的platform驱动，所以需要在设备树中添加设备节点，然后我们只需要编写platform驱动即可。
19.4.1 修改设备树文件
首先修改设备树文件，加上我们需要的设备信息，本章我们就使用到一个LED0。需要创建LED0引脚的pinctrl节点，这个直接使用示例代码19.1.1.1中的led_gpio节点。另外也要创建一个LED0设备节点，这个直接使用示例代码19.1.2.1中的 gpioled设备节点。
19.4.2 platform驱动程序编写
设备已经准备好了，接下来就要编写相应的platform驱动了，新建名为“17_dtsplatform”的文件夹，然后在17_dtsplatform文件夹里面创建vscode工程，工作区命名为“dtsplatform”。新建名为leddriver.c的驱动文件，在leddriver.c中输入如下所示内容：
示例代码19.4.2.1 leddriver.c文件代码段

1   #include <linux/types.h>
2   #include <linux/kernel.h>
3   #include <linux/delay.h>
4   #include <linux/ide.h>
5   #include <linux/init.h>
6   #include <linux/module.h>
7   #include <linux/errno.h>
8   #include <linux/gpio.h>
9   #include <linux/cdev.h>
10  #include <linux/device.h>
11  #include <linux/of_gpio.h>
12  #include <linux/semaphore.h>
13  #include <linux/timer.h>
14  #include <linux/irq.h>
15  #include <linux/wait.h>
16  #include <linux/poll.h>
17  #include <linux/fs.h>
18  #include <linux/fcntl.h>
19  #include <linux/platform_device.h>
20  //#include <asm/mach/map.h>
21  #include <asm/uaccess.h>
22  #include <asm/io.h>
23  
24  
25  #define LEDDEV_CNT    	1               		/* 设备号长度  	*/
26  #define LEDDEV_NAME     	"dtsplatled"    	/* 设备名字     	*/
27  #define LEDOFF          	0
28  #define LEDON           	1
29  
30  /* leddev设备结构体 */
31  struct leddev_dev{
32      dev_t devid;                	/* 设备号    		*/
33      struct cdev cdev;           	/* cdev     		*/
34      struct class *class;        	/* 类      			*/
35      struct device *device;      	/* 设备       		*/  
36      struct device_node *node;   	/* LED设备节点 		*/
37      int gpio_led;               	/* LED灯GPIO标号 	*/
38  };
39  
40  struct leddev_dev leddev;       	/* led设备 		*/
41  
42  /*
43   * @description 	: LED打开/关闭
44   * @param - sta 	: LEDON(0) 打开LED，LEDOFF(1) 关闭LED
45   * @return       	: 无
46   */
47  void led_switch(u8 sta)
48  {
49      if (sta == LEDON )
50          gpio_set_value(leddev.gpio_led, 1);
51      else if (sta == LEDOFF)
52          gpio_set_value(leddev.gpio_led, 0);
53  }
54  
55  static int led_gpio_init(struct device_node *nd)
56  {
57      int ret;
58  
59      /* 从设备树中获取GPIO */
60      leddev.gpio_led = of_get_named_gpio(nd, "led-gpio", 0);
61      if(!gpio_is_valid(leddev.gpio_led)) {
62          printk(KERN_ERR "leddev: Failed to get led-gpio\n");
63          return -EINVAL;
64      }
65      
66      /* 申请使用GPIO */
67      ret = gpio_request(leddev.gpio_led, "LED");
68      if (ret) {
69          printk(KERN_ERR "led: Failed to request led-gpio\n");
70          return ret;
71      }
72      
73      /* 将GPIO设置为输出模式并设置GPIO初始电平状态 */
74      gpio_direction_output(leddev.gpio_led,0);
75      
76      return 0;
77  }
78  
79  /*
80   * @description  	: 打开设备
81   * @param – inode	: 传递给驱动的inode
82   * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
83   *                    一般在open的时候将private_data指向设备结构体。
84   * @return        	: 0 成功;其他 失败
85   */
86  static int led_open(struct inode *inode, struct file *filp)
87  {
88      return 0;
89  }
90  
91  /*
92   * @description 	: 向设备写数据 
93   * @param - filp 	: 设备文件，表示打开的文件描述符
94   * @param - buf  	: 要写给设备写入的数据
95   * @param - cnt  	: 要写入的数据长度
96   * @param - offt 	: 相对于文件首地址的偏移
97   * @return        	: 写入的字节数，如果为负值，表示写入失败
98   */
99  static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
100 {
101     int retvalue;
102     unsigned char databuf[1];
103     unsigned char ledstat;
104 
105     retvalue = copy_from_user(databuf, buf, cnt);
106     if(retvalue < 0) {
107         printk("kernel write failed!\r\n");
108         return -EFAULT;
109     }
110     
111     ledstat = databuf[0];
112     if (ledstat == LEDON) {
113         led_switch(LEDON);
114     } else if (ledstat == LEDOFF) {
115         led_switch(LEDOFF);
116     }
117     return 0;
118 }
119 
120 /* 设备操作函数 */
121 static struct file_operations led_fops = {
122     .owner = THIS_MODULE,
123     .open = led_open,
124     .write = led_write,
125 };
126 
127 /*
128  * @description 	: flatform驱动的probe函数，当驱动与
129  *                    设备匹配以后此函数就会执行
130  * @param - dev  	: platform设备
131  * @return       	: 0，成功;其他负值,失败
132  */
133 static int led_probe(struct platform_device *pdev)
134 {   
135     int ret;
136     
137     printk("led driver and device was matched!\r\n");
138     
139     /* 初始化 LED */
140     ret = led_gpio_init(pdev->dev.of_node);
141     if(ret < 0)
142         return ret;
143         
144     /* 1、设置设备号 */
145     ret = alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT, 
LEDDEV_NAME);
146     if(ret < 0) {
147         pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", 
LEDDEV_NAME, ret);
148         goto free_gpio;
149     }
150     
151     /* 2、初始化cdev  */
152     leddev.cdev.owner = THIS_MODULE;
153     cdev_init(&leddev.cdev, &led_fops);
154     
155     /* 3、添加一个cdev */
156     ret = cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT);
157     if(ret < 0)
158         goto del_unregister;
159     
160     /* 4、创建类      */
161     leddev.class = class_create(THIS_MODULE, LEDDEV_NAME);
162     if (IS_ERR(leddev.class)) {
163         goto del_cdev;
164     }
165 
166     /* 5、创建设备 */
167     leddev.device = device_create(leddev.class, NULL, leddev.devid, 
NULL, LEDDEV_NAME);
168     if (IS_ERR(leddev.device)) {
169         goto destroy_class;
170     }
171     
172     return 0;
173 destroy_class:
174     class_destroy(leddev.class);
175 del_cdev:
176     cdev_del(&leddev.cdev);
177 del_unregister:
178     unregister_chrdev_region(leddev.devid, LEDDEV_CNT);
179 free_gpio:
180     gpio_free(leddev.gpio_led);
181     return -EIO;
182 }
183 
184 /*
185  * @description	: platform驱动的remove函数
186  * @param - dev 	: platform设备
187  * @return       	: 0，成功;其他负值,失败
188  */
189 static int led_remove(struct platform_device *dev)
190 {
191     gpio_set_value(leddev.gpio_led, 0);/* 卸载驱动的时候关闭LED */
192     gpio_free(leddev.gpio_led); 		/* 注销GPIO 	*/
193     cdev_del(&leddev.cdev);             	/*  删除cdev 	*/
194     unregister_chrdev_region(leddev.devid, LEDDEV_CNT);
195     device_destroy(leddev.class, leddev.devid); /* 注销设备 */
196     class_destroy(leddev.class); 		/* 注销类 */
197     return 0;
198 }
199 
200 /* 匹配列表 */
201 static const struct of_device_id led_of_match[] = {
202     { .compatible = "alientek,led" },
203     { /* Sentinel */ }
204 };
205 
206 MODULE_DEVICE_TABLE(of, led_of_match);
207 
208 /* platform驱动结构体 */
209 static struct platform_driver led_driver = {
210     .driver     = {
211         .name   = "rk3568-led",         	/* 驱动名字，用于和设备匹配 */
212         .of_match_table = led_of_match, /* 设备树匹配表        */
213     },
214     .probe      = led_probe,
215     .remove     = led_remove,
216 };
217         
218 /*
219  * @description 	: 驱动模块加载函数
220  * @param       	: 无
221  * @return      	: 无
222  */
223 static int __init leddriver_init(void)
224 {
225     return platform_driver_register(&led_driver);
226 }
227 
228 /*
229  * @description 	: 驱动模块卸载函数
230  * @param       	: 无
231  * @return      	: 无
232  */
233 static void __exit leddriver_exit(void)
234 {
235     platform_driver_unregister(&led_driver);
236 }
237 
238 module_init(leddriver_init);
239 module_exit(leddriver_exit);
240 MODULE_LICENSE("GPL");
241 MODULE_AUTHOR("ALIENTEK");
242 MODULE_INFO(intree, "Y");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245

代码中以前讲过的知识点这里就不再重述了！
第55~77行，自定义函数led_gpio_init，该函数的参数是struct device_node类型的指针，也就是led对应的设备节点，当调用函数的时候传递进来。
第133~182行，platform下的 probe函数：led_probe，当设备树中的设备节点与驱动之间匹配成功会先去初始化pinctrl里面配置的IO，也就是根据示例代码19.1.1.1中的属性进行配置，然后再执行probe函数，第140行调用led_gpio_init函数时，将pdev->dev.of_node作为参数传递到函数中，platform_device结构体中内置了一个device结构体类型的成员变量dev。在device结构体中定义了一个device_node类型的指针变量of_node，使用设备树的情况下，当匹配成功之后，of_node会指向设备树中定义的节点，所以在这里我们不需要通过调用of_find_node_by_path(“/gpioled”)函数得到led的节点。我们原来在驱动加载函数里面做的工作现在全部放到probe函数里面完成。
第189~198行，platform下的remove函数：led_remove，当platform驱动模块被卸载时此函数就会执行。在此函数里面释放内存、注销字符设备等，也就是将原来驱动卸载函数里面的工作全部都放到remove函数中完成。
第201~204行，匹配表，描述了此驱动都和什么样的设备匹配，第202行添加了一条值为"alientek,led"的compatible属性值，当设备树中某个设备节点的compatible属性值也为“alientek,led”的时候就会与此驱动匹配。
第209~216行，platform_driver驱动结构体变量led_driver，211行设置这个platform驱动的名字为“rk3568-led”，因此，当驱动加载成功以后就会在/sys/bus/platform/drivers/目录下存在一个名为“rk3568-led”的文件。第212行绑定platform驱动的of_match_table表。
第223~226行，platform驱动模块入口函数，在此函数里面通过platform_driver_register向Linux内核注册一个platform驱动led_driver。
第233~236行，platform驱动驱动模块出口函数，在此函数里面通过platform_driver_unregister从Linux内核卸载一个platform驱动led_driver。
19.4.3 编写测试APP
测试APP就直接使用上一章18.4.2小节编写的ledApp.c即可。
19.5 运行测试
19.5.1 编译驱动程序和测试APP
1、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第五章实验基本一样，只是将obj-m变量的值改为“leddriver.o”，Makefile内容如下所示：
示例代码19.5.1.1 Makefile文件

1  KERNELDIR := /home/alientek/rk3568_linux_sdk/kernel
...... 
4  obj-m := leddriver.o
......
11 clean:
12  $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
1
2
3
4
5
6

第4行，设置obj-m变量的值为“leddriver.o”。
输入如下命令编译出驱动模块文件：
1
2

make ARCH=arm64 //ARCH=arm64必须指定，否则编译会失败
编译成功以后就会生成一个名为“leddriver.o”的驱动模块文件。
2、编译测试APP
测试APP直接使用上一章的ledApp这个测试软件即可。
19.5.2 运行测试
在Ubuntu中将上一小节编译出来的leddriver.ko通过adb命令发送到开发板的/lib/modules/4.19.232目录下，命令如下：
adb push leddriver.ko /lib/modules/4.19.232
发送成功以后进入到开发板目录lib/modules/4.19.232中，输入如下命令加载leddriver.ko这个驱动模块：
depmod //第一次加载驱动的时候需要运行此命令
modprobe leddriver //加载驱动模块
驱动模块加载完成以后到/sys/bus/platform/drivers/目录下查看驱动是否存在，我们在leddriver.c中设置name字段为“rk3568-led”，因此会在/sys/bus/platform/drivers/目录下存在名为“rk3568-led”这个文件，结果如图19.5.2.1所示：

图19.5.2.1 rk3568-led驱动
同理，在/sys/bus/platform/devices/目录下也存在led的设备文件，也就是设备树中gpioled这个节点，如图19.5.2.2所示：

图19.5.2.2 gpioled设备
驱动和模块都存在，当驱动和设备匹配成功以后就会输出如图19.5.2.3所示一行语句：

图19.5.2.3 驱动和设备匹配成功
驱动和设备匹配成功以后就可以测试LED灯驱动了，输入如下命令打开LED灯：
./ledApp /dev/dtsplatled 1 //打开LED灯
在输入如下命令关闭LED灯：
./ledApp /dev/dtsplatled 0 //关闭LED灯
观察一下LED灯能否打开和关闭，如果可以的话就说明驱动工作正常，如果要卸载驱动的话输入如下命令即可：
rmmod leddriver.ko