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

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

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

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

第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");

代码中以前讲过的知识点这里就不再重述了！
第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

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

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