[米联客-XILINX-H3_CZ08_7100] LINUX驱动篇连载-05 基于设备树的平台驱动

软件版本：vitis2021.1(vivado2021.1)

操作系统：WIN10 64bit

硬件平台：适用XILINX Z7/ZU系列FPGA

登录“米联客”FPGA社区-www.uisrc.com视频课程、答疑解惑！

---

1 概述

在完成了平台总线的学习之后，我们将进行设备树的学习。设备树实际上是对平台总线的一种简化。学习完本章之后，你应该能有所了解。

实验目的：

• 理解设备树的结构。
• 掌握设备树的编写。
• 理解为什么需要设备树。
• 掌握基于设备树的驱动编写。
  

2 系统框图

        和平台总线实现的驱动不同的地方在于，设备树将平台设备，也就是platform_device进行了完全的抽象，对于不同的设备并不需要去写一个个平台设备。而只是需要修改设备树就行了。设备树的框图具体如下。

        实质上与平台总线的实现并没有太大的区别，重要的是，通过设备树简化了平台设备的部分。

3 介绍

        这个部分将主要讲述设备树的结构。设备树启动过程。设备树该如何写。

3.1 设备树

        设备树是一个用节点描述系统中设备的树状结构。如下图。

一根节点多个子节点，子节点又可以包含多个子节点，以树状的结构散开。在程序分析部分将会看到详细的设备树的代码。

（在部署好开发环境的虚拟机上的 /uisrc-lab-xlnx/sources/kernel/arch/arm64/boot/dts/xilinx 文件中能够查看到具体的设备树文件。这个目录也是之前制作系统时，所替换设备树文件的地方。）

3.2 设备树文件类型

        在设备树目录内，将会出现不同后缀名的文件。这里介绍一下，不同后缀名的意思。

早期的Linux还没有设备树这个概念的时候，为了防止内核的体积太过臃肿，设计了平台设备和平台驱动两个结构，但是随着设备树的引进，平台设备被设备树所取代。

在编写驱动程序时，我们只需关心设备树和平台驱动两样东西，使用平台驱动直接调用设备树的内容。

在了解设备树之前，先要搞清楚以下几个概念：

• DTS：dts文件是对Device Tree的描述，放置在内核的/arch/arm64/boot/dts目录，描述了一个板子的硬件资源。以前写在mach-xxx文件中的内容被转成了dts文件。
• DTC：编译工具，存放在目录scripts/dtc位置，它可以将.dts文件编译成.dtb文件。
• DTB：DTC编译*.dts生成的二进制文件(.dtb)，bootloader在引导内核时，会预先读取.dtb到内存，进而由内核解析。
• DTSI：由于同一系列SOC很多相同的地方，为了减少代码的冗余，设备树将这些共同部分提炼保存在.dtsi文件中，供不同的dts共同使用。
  

3.3 dts节点（node）

设备树节点是用节点名和单元地址和一个用大括号作为节点定义的开始和结尾来定义的。

• [lable:]：设备树文件允许标签附加在任何节点或者属性上。
• node-name：是指节点的名字。
• [@unit-address]：是指节点所在的基地址。
• [properties definitions]：是指相关属性的定义。
• [child nodes]：是指相关的子节点。
  

如果父节点中有子节点相同的属性，那么以设备树的父节点的属性为主。

3.4 dts文件结构

        所有的dts文件都需要有一个root节点，并且root节点内必须有一个cpus节点和至少一个的memory节点。如下图。

3.5 root节点

        设备树文件有一个root节点，所有的其他设备节点都是它的子节点。下面展示的是它的一些必须属性和可选属性。

3.6 aliases节点

        设备树可以有一个别名节点，也就是aliases节点。用来定义一个或者更多的属性。别名节点只能存在于设备树的root节点中，并且节点名字为aliaes。

        客户端程序会通过alias的属性名来引用设备的全路径，或者部分路径。

3.7 chosen节点

        /chosen 节点并不代表系统中的一个真实的设备，但是，描述了当系统固件在运行的时候会被选择或者指定的参数。这个节点一定得在root节点下。下图是他的可选属性。

3.8 memory节点

        所有的设备树文件都需要内存设备节点，用来描述系统物理内存的布局。如果一个系统有多个范围的内存，多个内存节点将会被创建。或者可以在一个单独的内存节点的reg属性中指定多个范围的内存。下图是它可选和必须属性。

3.9 cpus节点

设备树所必须的cpus节点，它不代表系统中一个真实的设备。它作为一个系统cpus的子cpu节点的容器存在。下图是它所需的属性。

1:/cpus/cpu节点

一个cpu节点就代表一个硬件的可执行块。能够运行操作系统而不会受到运行其他操作系统cpu的干扰。下图为它所需的属性。

4 搭建工程

这个部分主要讲如何把dts文件放入开发环境，然后编译成系统文件。当然，附件中已经提供好修改过设备树的文件，在BOOT内，只需要将挂载的SD卡中的BOOT部分替换为附件中的就行。

4.1 根据dts文件制作系统

在已经部署好开发环境的基础上进行，确定系统的其他文件已经拷贝至对应目录。参考“[米联客-XILINX-H3_CZ08_7100] LINUX驱动篇连载-01 Hello World”的制作系统部分。这里在已经制作过的系统的基础上，仅替换 dts 设备文件，做简单演示。

将“6.DeviceTree”中“soc_dts”文件夹内的dts文件复制至“boards/mz7x/ubuntu/output/files/kernel-dts”、“boards/mz7x/ubuntu/output/files/uboot-dts”两个文件夹内。

在 “uisrc-lab-xlnx” 目录下，打开终端输入“source /script/mz7xcfg.sh”，先后输入 “move_file.sh”， “make_uboot.sh”，“make_kernel.sh”，“create_image.sh”。

在完成了系统制作之后，打开“uisrc-lab-xlnx/boards/mz7x/ubuntu/images/boot”。找到生成的boot文件。将其拷贝复制进U盘的BOOT文件内。

4.2 上传驱动文件

将“DriveTree”文件夹上传至虚拟机。使用各种方式都可以。

至此，准备工作已经完成。

5 程序分析

程序分析部分和之前有些不一样，这次除了分析驱动文件之外，还需要分析一个设备树文件。在理解前面的设备树介绍的情况下，我们来实践分析一下设备树文件。

5.1 设备树分析

zynq-mz7x.dts

1. /*
   
2. *  Copyright (C) 2011 - 2014 Xilinx
   
3. *  Copyright (C) 2012 National Instruments Corp.
   
4. *
   
5. * This software is licensed under the terms of the GNU General Public
   
6. * License version 2, as published by the Free Software Foundation, and
   
7. * may be copied, distributed, and modified under those terms.
   
8. *
   
9. * This program is distributed in the hope that it will be useful,
   
10. * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
11. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    
12. * GNU General Public License for more details.
    
13. */
    
14. /dts-v1/;
    
15. /include/ "zynq-7000.dtsi"
    
16. 
    
17. / {
    
18. model = "Zynq MZ7X Development Board";
    
19. compatible = "xlnx,zynq-MZ7X", "xlnx,zynq-7000";
    
20. 
    
21. aliases {
    
22.   ethernet0 = &axi_ethernet_0;
    
23.   ethernet1 = &gem1;
    
24.   serial0 = &uart0;
    
25.   spi0 = &qspi;
    
26.   mmc0 = &sdhci0;
    
27.   mmc1 = &sdhci1;
    
28. };
    
29. 
    
30. memory@0 {
    
31.   device_type = "memory";
    
32.   reg = <0x0 0x40000000>;
    
33. };
    
34. 
    
35. chosen {
    
36.   bootargs = "";
    
37.   stdout-path = "serial0:115200n8";
    
38. };
    
39. 
    
40. usb_phy1: phy0@e0003000 {
    
41.   compatible = "ulpi-phy";
    
42.   #phy-cells = <0>;
    
43.   reg = <0xe0003000 0x1000>;
    
44.   view-port = <0x0170>;
    
45.   drv-vbus;
    
46. };
    
47. 
    
48. gpio-led {
    
49.   compatible = "xlnx,zynqmp-led-1.0";
    
50.   gpios = <&gpio0 0x7 0x0>;
    
51. };
    
52. };
    
53. 
    
54. / {
    
55. cpus {
    
56.   cpu@0 {
    
57.    operating-points = <666666 1000000 333333 1000000>;
    
58.   };
    
59. };
    
60. };
    
61. 
    
62. / {
    
63. amba_pl: amba_pl {
    
64.   #address-cells = <1>;
    
65.   #size-cells = <1>;
    
66.   compatible = "simple-bus";
    
67.   ranges ;
    
68.   axi_dma_0: dma@40400000 {
    
69.    #dma-cells = <1>;
    
70.    axistream-connected = <&axi_ethernet_0>;
    
71.    axistream-control-connected = <&axi_ethernet_0>;
    
72.    clock-names = "s_axi_lite_aclk", "m_axi_sg_aclk", "m_axi_mm2s_aclk", "m_axi_s2mm_aclk";
    
73.    clocks = <&clkc 15>, <&clkc 15>, <&clkc 15>, <&clkc 15>;
    
74.    compatible = "xlnx,eth-dma";
    
75.    interrupt-names = "mm2s_introut", "s2mm_introut";
    
76.    interrupt-parent = <&intc>;
    
77.    interrupts = <0 29 4 0 30 4>;
    
78.    reg = <0x40400000 0x10000>;
    
79.    xlnx,addrwidth = /bits/ 8 <0x20>;
    
80.    xlnx,include-dre ;
    
81.    xlnx,num-queues = /bits/ 16 <0x1>;
    
82.   };
    
83.   axi_ethernet_0: ethernet@41000000 {
    
84.    axistream-connected = <&axi_dma_0>;
    
85.    axistream-control-connected = <&axi_dma_0>;
    
86.    clock-frequency = <100000000>;
    
87.    clock-names = "s_axi_lite_clk", "axis_clk", "gtx_clk", "ref_clk";
    
88.    clocks = <&clkc 15>, <&clkc 15>, <&clkc 16>, <&clkc 17>;
    
89.    compatible = "xlnx,axi-ethernet-7.2", "xlnx,axi-ethernet-1.00.a";
    
90.    device_type = "network";
    
91.    interrupt-names = "mac_irq", "interrupt";
    
92.    interrupt-parent = <&intc>;
    
93.    interrupts = <0 31 1 0 32 4>;
    
94.    local-mac-address = [00 0a 35 00 00 00];
    
95.    phy-mode = "rgmii";
    
96.    reg = <0x41000000 0x40000>;
    
97.    xlnx = <0x0>;
    
98.    xlnx,axiliteclkrate = <0x0>;
    
99.    xlnx,axisclkrate = <0x0>;
    
100.    xlnx,channel-ids = <0x1>;
     
101.    xlnx,clockselection = <0x0>;
     
102.    xlnx,enableasyncsgmii = <0x0>;
     
103.    xlnx,gt-type = <0x0>;
     
104.    xlnx,gtinex = <0x0>;
     
105.    xlnx,gtlocation = <0x0>;
     
106.    xlnx,gtrefclksrc = <0x0>;
     
107.    xlnx,include-dre ;
     
108.    xlnx,instantiatebitslice0 = <0x0>;
     
109.    xlnx,num-queues = /bits/ 16 <0x1>;
     
110.    xlnx,phy-type = <0x8>;
     
111.    xlnx,phyaddr = <0x1>;
     
112.    xlnx,phyrst-board-interface-dummy-port = <0x0>;
     
113.    xlnx,rable = <0x0>;
     
114.    xlnx,rxcsum = <0x0>;
     
115.    xlnx,rxlane0-placement = <0x0>;
     
116.    xlnx,rxlane1-placement = <0x0>;
     
117.    xlnx,rxmem = <0x1000>;
     
118.    xlnx,rxnibblebitslice0used = <0x0>;
     
119.    xlnx,tx-in-upper-nibble = <0x1>;
     
120.    xlnx,txcsum = <0x0>;
     
121.    xlnx,txlane0-placement = <0x0>;
     
122.    xlnx,txlane1-placement = <0x0>;
     
123.    xlnx,versal-gt-board-flow = <0x0>;
     
124.             phy-handle = <&phy0>;
     
125.    axi_ethernet_0_mdio: mdio {
     
126.     #address-cells = <1>;
     
127.     #size-cells = <0>;
     
128.                 phy0: phy@1 {
     
129.      device_type = "ethernet-phy";
     
130.      reg = <0x1>;
     
131.     };
     
132.    };
     
133.   };
     
134.   axi_vdma_0: dma@43000000 {
     
135.    #dma-cells = <1>;
     
136.    clock-names = "s_axi_lite_aclk", "m_axi_mm2s_aclk", "m_axis_mm2s_aclk";
     
137.    clocks = <&clkc 15>, <&clkc 15>, <&clkc 15>;
     
138.    compatible = "xlnx,axi-vdma-6.3", "xlnx,axi-vdma-1.00.a";
     
139.    interrupt-names = "mm2s_introut";
     
140.    interrupt-parent = <&intc>;
     
141.    interrupts = <0 33 4>;
     
142.    reg = <0x43000000 0x10000>;
     
143.    xlnx,addrwidth = <0x40>;
     
144.    xlnx,flush-fsync = <0x1>;
     
145.    xlnx,num-fstores = <0x1>;
     
146.    dma-channel@43000000 {
     
147.     compatible = "xlnx,axi-vdma-mm2s-channel";
     
148.     interrupts = <0 33 4>;
     
149.     xlnx,datawidth = <0x20>;
     
150.     xlnx,device-id = <0x0>;
     
151.     xlnx,genlock-mode ;
     
152.    };
     
153.   };
     
154.         axi_vdma_lcd {
     
155.    compatible = "topic,vdma-fb";
     
156.    dmas = <&axi_vdma_0 0>;
     
157.    dma-names = "axivdma";
     
158.   };
     
159. };
     
160. };
     
161. 
     
162. &gem1 {
     
163. status = "okay";
     
164. phy-mode = "rgmii-id";
     
165. xlnx,ptp-enet-clock = <0x69f6bcb>;
     
166. phy-handle = <&ethernet_phy>;
     
167. 
     
168. ethernet_phy: ethernet-phy@0 {
     
169.   reg = <0>;
     
170.   device_type = "ethernet-phy";
     
171. };
     
172. };
     
173. 
     
174. &gpio0 {
     
175. emio-gpio-width = <64>;
     
176. gpio-mask-high = <0x0>;
     
177. gpio-mask-low = <0x5600>;
     
178. };
     
179. 
     
180. &intc {
     
181. num_cpus = <2>;
     
182. num_interrupts = <96>;
     
183. };
     
184. 
     
185. &qspi {
     
186. u-boot,dm-pre-reloc;
     
187. status = "okay";
     
188. is-dual = <1>;
     
189. num-cs = <1>;
     
190. flash@0 {
     
191.   compatible = "n25q128a11";
     
192.   reg = <0x0>;
     
193.   spi-tx-bus-width = <8>;
     
194.   spi-rx-bus-width = <8>;
     
195.   spi-max-frequency = <125000000>;
     
196. };
     
197. };
     
198. 
     
199. &sdhci0 {
     
200. u-boot,dm-pre-reloc;
     
201. status = "okay";
     
202. xlnx,has-cd = <0x0>;
     
203. xlnx,has-power = <0x0>;
     
204. xlnx,has-wp = <0x0>;
     
205. };
     
206. 
     
207. &sdhci1 {
     
208. status = "okay";
     
209. xlnx,has-cd = <0x0>;
     
210. xlnx,has-power = <0x0>;
     
211. xlnx,has-wp = <0x0>;
     
212. };
     
213. 
     
214. &uart0 {
     
215. u-boot,dm-pre-reloc;
     
216. device_type = "serial";
     
217. port-number = <0>;
     
218. status = "okay";
     
219. };
     
220. 
     
221. &usb1 {
     
222. status = "okay";
     
223. dr_mode = "host";
     
224. usb-phy = <&usb_phy1>;
     
225. usb-reset = <&gpio0 46 0>;
     
226. };
     
227. 
     
228. &clkc {
     
229. fclk-enable = <0x7>;
     
230. ps-clk-frequency = <33333333>;
     
231. };

复制代码

需要将LED的设备节点插入到设备树文件中，可以手动修改，也能直接将提供的设备树直接替换原来的，设备树的路径如下：

• 内核设备树：/uisrc-lab-xlnx/sources/kernel/arch/arm64/boot/dts/Xilinx/zynqmp-mzux.dts
• uboot设备树：/uisrc-lab-xlnx/sources/uboot/arch/arm/dts/zynqmp-mzux.dts
  

1:gpio-led 节点

1. gpio-led {
   
2.   compatible = "xlnx,zynqmp-led-1.0";
   
3.   gpios = <&gpio0 0x7 0x0>;
   
4. };

复制代码

含义：在设备树中添加gpio-led节点。

具体分析：

• gpio-led：设备节点名，也就是node-name。
• compatible：兼容名，驱动将会通过这个在设备树中找到该节点。
• gpio：定义的两个led的管脚，分别是MIO38，和MIO23。
  

5.2 驱动程序分析

platform_gpio_drv.c

1. //1、添加头文件
   
2. #include <linux/init.h>
   
3. #include <linux/module.h>
   
4. #include <linux/fs.h>
   
5. #include <linux/of_gpio.h>
   
6. #include <linux/platform_device.h>
   
7. #include <linux/mod_devicetable.h>
   
8. 
   
9. static unsigned int led_major;
   
10. static struct class *led_class;
    
11. 
    
12. struct led_driver
    
13. {
    
14. int gpio1;
    
15. // int gpio2;
    
16. int irq;
    
17. struct device dev;
    
18. };
    
19. struct led_driver *led_dri = NULL;
    
20. 
    
21. const struct file_operations led_fops = {
    
22. 
    
23. };
    
24. 
    
25. //在probe函数中打印获取数据包里面的名字及GPIO
    
26. int gpio_pdrv_probe(struct platform_device *pdev)
    
27. {
    
28. struct device_node *node;
    
29. // unsigned int gpio1, gpio2;
    
30. unsigned int gpio1;
    
31. unsigned int ret = 0;
    
32. 
    
33. printk("gpio pdrv probe!\n");
    
34. printk("pdrv name = %s!\n", pdev->name);
    
35. 
    
36. //申请主设备号
    
37. led_major = register_chrdev(0, "led_drv", &led_fops);
    
38. if (led_major < 0)
    
39. {
    
40.   printk("register chrdev led major error!\n");
    
41.   return -ENOMEM;
    
42. }
    
43. 
    
44. //创建类
    
45. led_class = class_create(THIS_MODULE, "led_class");
    
46. 
    
47. //创建设备
    
48. device_create(led_class, NULL, MKDEV(led_major, 0), NULL, "led_device%d", 0);
    
49. 
    
50. //硬件初始化
    
51. 
    
52. //申请空间
    
53. led_dri = devm_kmalloc(&pdev->dev, sizeof(struct led_driver), GFP_KERNEL);
    
54. if (led_dri == NULL)
    
55. {
    
56.   printk("devm kmalloc led_driver error!\n");
    
57.   return -1;
    
58. }
    
59. 
    
60. //获取从设备节点传过来的pdev中的dev及node节点
    
61. led_dri->dev = pdev->dev;
    
62. node = pdev->dev.of_node;
    
63. 
    
64. //从node节点处获得GPIO号
    
65. gpio1 = of_get_gpio(node, 0);
    
66. printk("of get gpio1 number = %d\n", gpio1);
    
67. if (gpio1 < 0)
    
68. {
    
69.   printk("of get gpio error!\n");
    
70.   return -1;
    
71. }
    
72. // gpio2 = of_get_gpio(node, 1);
    
73. // printk("of get gpio2 number = %d\n", gpio2);
    
74. // if (gpio2 < 0)
    
75. // {
    
76. //  printk("of get gpio error!\n");
    
77. //  return -1;
    
78. // }
    
79. 
    
80. //申请GPIO
    
81. ret = gpio_request(gpio1, "plattree_led");
    
82. if (ret < 0)
    
83. {
    
84.   printk("plattree led gpio request error!\n");
    
85.   return ret;
    
86. }
    
87. // ret = gpio_request(gpio2, "plattree_led");
    
88. // if (ret < 0)
    
89. // {
    
90. //  printk("plattree led gpio request error!\n");
    
91. //  return ret;
    
92. // }
    
93. 
    
94. //设置GPIO为输出模式，并设备为0，灭灯
    
95. gpio_direction_output(gpio1, 0);
    
96. // gpio_direction_output(gpio2, 0);
    
97. 
    
98. led_dri->gpio1 = gpio1;
    
99. // led_dri->gpio2 = gpio2;
    
100. 
     
101. return 0;
     
102. }
     
103. 
     
104. int gpio_pdrv_remove(struct platform_device *pdev)
     
105. {
     
106. printk("led pdrv remove!\n");
     
107. 
     
108. gpio_set_value(led_dri->gpio1, 1);
     
109. // gpio_set_value(led_dri->gpio2, 1);
     
110. 
     
111. gpio_free(led_dri->gpio1);
     
112. // gpio_free(led_dri->gpio2);
     
113. device_destroy(led_class, MKDEV(led_major, 0));
     
114. class_destroy(led_class);
     
115. unregister_chrdev(led_major, "led_drv");
     
116. 
     
117. return 0;
     
118. }
     
119. 
     
120. //of_match_table实现
     
121. const struct of_device_id gpio_of_match_table[] = {
     
122. {
     
123.   .compatible = "xlnx,zynqmp-led-1.0",
     
124. },
     
125. {}};
     
126. 
     
127. //当驱动在设备中找到name之后，进行配对获取resource资源，进入probe函数
     
128. struct platform_driver gpio_drv = {
     
129. .driver = {
     
130.   .name = "zynqmp_led",
     
131.   .of_match_table = gpio_of_match_table,
     
132. },
     
133. .probe = gpio_pdrv_probe,
     
134. .remove = gpio_pdrv_remove,
     
135. };
     
136. 
     
137. //实现装载入口函数和卸载入口函数
     
138. static __init int platform_gpio_drv_init(void)
     
139. {
     
140. //创建pdrv，并且注册到总线中
     
141. return platform_driver_register(&gpio_drv);
     
142. }
     
143. static __exit void platform_gpio_drv_exit(void)
     
144. {
     
145. //注销设备
     
146. platform_driver_unregister(&gpio_drv);
     
147. }
     
148. 
     
149. //声明装载入口函数和卸载入口函数
     
150. module_init(platform_gpio_drv_init);
     
151. module_exit(platform_gpio_drv_exit);
     
152. 
     
153. 
     
154. //添加GPL协议
     
155. MODULE_LICENSE("GPL");
     
156. MODULE_AUTHOR("msxbo");

复制代码

行12~22，创建一个结构体用来存放设备信息。

行30~165，初始化函数，完成的任务有，申请设备号，创建类，创建设备，申请空间，获取node节点，获取GPIO号，申请GOIO，设置GPIO输出模式并置0。

行167~189，驱动注销，先将LED灯全部点亮，然后释放LED占用的GPIO资源，最后依次注销初始化中的内容。

1:platform_driver_register函数

1. int platform_driver_register(struct platform_driver *driver)

复制代码

含义：向平台总线注册平台驱动。

具体分析：

• pdrv：注册的平台驱动。
• 返回值：0，设置成功；负值，设置失败。
  

2:platform_driver结构体

1. //2.当驱动在设备中找到name之后，进行配对获取resource资源，进入probe函数
   
2. struct platform_driver gpio_drv = {
   
3.    .driver = {
   
4.       .name = "zynqmp_led",
   
5.       .of_match_table = gpio_of_match_table,
   
6. },
   
7.    .probe = gpio_pdrv_probe,
   
8.    .remove = gpio_pdrv_remove,
   
9. };

复制代码

含义：构建平台注册的结构体。

具体分析：

• .of_match_table：用来在设备树中找到对应node的函数。
• .probe：gpio初始化函数。
• .remoe：当移除gpio时会执行的函数。
  

3:of_get_gpio函数

~/uisrc-lab-xlnx/sources/kernel/include/linux/of_gpio.h

1. /**
   
2. * of_get_gpio() - Get a GPIO number to use with GPIO API
   
3. * @np:  device node to get GPIO from
   
4. * @index: index of the GPIO
   
5. *
   
6. * Returns GPIO number to use with Linux generic GPIO API, or one of the errno
   
7. * value on the error condition.
   
8. */
   
9. static inline int of_get_gpio(struct device_node *np, int index)
   
10. {
    
11.     return of_get_gpio_flags(np, index, NULL);
    
12. }

复制代码

含义：从节点出通过index获取GPIO号。

具体分析：

• np：从设备树处获得的节点。
  

4:gpio_request函数

1. int gpio_request(unsigned gpio, const char *label)

复制代码

含义：gpio_request函数用来向系统申请一个GPIO管脚，每一个管脚在使用前都需要使用这个函数初始化，若不使用这个函数直接使用GPIO，则GPIO不会反应。

具体分析：

• 参数：gpio，需要申请的gpio标号；lable，gpio的名字，可自由设定。
• 返回值：0，申请成功；其他值，申请失败。
  

5:gpio_direction_output函数

1. static inline int gpio_direction_output(unsigned gpio, int value)

复制代码

含义：设置gpio为输出模式，并设置0或1，来控制输出的开关。

具体分析：

• gpio：为需要申请的gpio标号。
• value：0为灭灯，1为开灯。
  

6:gpio_set_value函数

1. static inline void gpio_set_value(unsigned gpio, int value)

复制代码

含义：设置gpio的引脚值。

6 程序编译

        这个部分先介绍makefile文档，然后再在虚拟机终端进行交叉编译，生成驱动文件。

6.1 makefile文件

1. #已经编译过的内核源码路径
   
2. KERNEL_DIR = /home/uisrc/uisrc-lab-xlnx/sources/kernel
   
3. 
   
4. export ARCH=arm
   
5. export CROSS_COMPILE=arm-linux-gnueabihf-
   
6. 
   
7. #当前路径
   
8. CURRENT_DIR = $(shell pwd)
   
9. 
   
10. MODULE =  platform_gpio_drv
    
11. 
    
12. all :
    
13. #进入并调用内核源码目录中Makefile的规则, 将当前的目录中的源码编译成模块
    
14. make -C $(KERNEL_DIR) M=$(CURRENT_DIR) modules
    
15. rm -rf *.mod.c *.mod.o *.symvers *.order *.o
    
16. 
    
17. ifneq ($(APP), )
    
18. $(CROSS_COMPILE)gcc $(APP).c -o $(APP)
    
19. endif
    
20. 
    
21. clean :
    
22. make -C $(KERNEL_DIR) M=$(CURRENT_DIR) clean
    
23. 
    
24. #指定编译哪个文件
    
25. obj-m += $(MODULE).o

复制代码

第10行输入自定义的文件名。其他部分不用修改。详细解释参考hello world的程序编译部分。

6.2 交叉编译

打开4.1节已经上传完成的文件。右击桌面打开终端，确定终端目录在当前文件夹内。输入“make”，编译成功后，图片如下。

7 演示

7.1 硬件准备

SD2.0 启动 01 而模式开关为 ON OFF（7100 需要先将系统烧录进qspi，然后才能从qspi启动sd卡，“[米联客-XILINX-H3_CZ08_7100] LINUX基础篇连载-04 从vitis移植Ubuntu实现二次开发”）

将 PS 端串口线连接电脑，如果要使用 ssh 登录，将网口线同样连接至电脑，最后给开发板通电。每次重新上电，需要重新插拔 PS 串口，否则会登录失败。

7.2 程序准备

将6.2于虚拟机中交叉编译完成的驱动文件上传至开发板。

确认开发板上的灯是否都亮起。

在终端管理员权限下输入“insmod platform_gpio_drv.ko”。

7.3 实验结果。

打开终端，输入dmesg。内核打印出驱动中所要求的数据。