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

' N0 e; a% n' x- L35.1 设备树下的platform驱动简介
/ ^0 U; @$ J4 m& J  n' eplatform驱动框架分为总线、设备和驱动，其中总线不需要我们这些驱动程序员去管理，这个是Linux内核提供的，我们在编写驱动的时候只要关注于设备和驱动的具体实现即可。在没有设备树的Linux内核下，我们需要分别编写并注册platform_device和platform_driver，分别代表设备和驱动。在使用设备树的时候，设备的描述被放到了设备树中，因此platform_device就不需要我们去编写了，我们只需要实现platform_driver即可。
0 V) R: z# u! N! D* `5 G35.1.1 修改pinctrl-stm32.c文件
在前面第25章的时候我们详细的讲解了pinctrl，但是在后续的实验中却一直没有使用pinctrl。按道理来讲，在我们使用某个引脚的时候需要先配置其电气属性，比如复用、输入还是输入、默认上下拉等！但是在前面的实验中均没有配置引脚的电气属性，也就是引脚的pinctrl配置。这是因为ST针对STM32MP1提供的Linux系统中，其pinctrl配置的电气属性只能在platform平台下被引用，前面的实验都没用到platform，所以pinctrl配置是不起作用的！
# `6 H, V2 j/ c5 {$ n笔者在使用NXP的I.MX6ULL芯片的时候，Linux系统启动运行过程中会自动解析设备树下的pinctrl配置，然后初始化引脚的电气属性，不需要platform驱动框架。所以pinctrl什么时候有效，不同的芯片厂商有不同的处理费方法，一切以实际所使用的芯片为准！
对于STM32MP1来说，在使用pinctrl的时候需要修改一下pinctrl-stm32.c这个文件，否则当某个引脚用作GPIO的时候会提示此引脚无法申请到，如图35.1.1.1所示：



1 C! y+ l5 {+ i: V图35.1.1.1 IO申请失败
从图35.1.1.1可以看出，提示PI0这个IO已经被其他外设申请走了，不能再申请。打开pinctrl-stm32.c这个文件，找到如下所示代码：
+ p' i9 s4 X( ?- n0 r  g" z

1. 示例代码35.1.1.1 stm32_pmx_ops结构体
   
2. 1 static const struct pinmux_ops stm32_pmx_ops = {
   
3. 2           .get_functions_count    = stm32_pmx_get_funcs_cnt,
   - o' C$ {: N7 R/ T4 V5 C* ]
4. 3           .get_function_name  = stm32_pmx_get_func_name,
   
5. 4           .get_function_groups    = stm32_pmx_get_func_groups,
   
6. 5           .set_mux        = stm32_pmx_set_mux,
   1 O) K; x7 \; X6 L$ u: g9 Z
7. 6           .gpio_set_direction = stm32_pmx_gpio_set_direction,
   ( M1 p. Q3 H! ]6 h
8. 7           .strict         = true,
   
9. 8 };

复制代码

第7行的strict成员变量默认为true，我们需要将其改为false，改完以后如图35.1.1.2所示：
3 w# I3 K7 @: [! Y


! G( `3 r/ z" ]! ?图35.1.1.2 修改后的stm32_pmx_ops结构体
- f# T, {. i7 m2 `% R& V修改完成以后使用如下命令重新编译Linux内核：
; f/ s( t/ A+ I( z( c7 Imake uImage LOADADDR=0XC2000040 -j16 //编译内核
编译完成以后使用新的uImage启动即可。
! }$ [4 u8 p, _35.1.2 创建设备的pinctrl节点
上面已经说了，在platform驱动框架下必须使用pinctrl来配置引脚复用功能。我们以本章实验需要用到的LED0为例，编写LED0引脚的 pinctrl配置。打开stm32mp15-pinctrl.dtsi文件，STM32MP1的所有引脚pinctrl配置都是在这个文件里面完成的，在pinctrl节点下添加如下所示内容：
- Z5 W6 w! f) }* t4 N$ }

1. 示例代码35.1.2.1 GPIO的pinctrl配置
   
2. 1 led_pins_a: gpioled-0 {
   
3. 2           pins {
   
4. 3                       pinmux = <STM32_PINMUX('I', 0, GPIO)>;
   
5. 4                       drive-push-pull;
   ! _( z! `- U. I, q1 j$ `7 s5 t
6. 5                       bias-pull-up;
   
7. 6                       output-high;
   
8. 7                       slew-rate = <0>;
   
9. 8           };
   - v2 j. d7 E" Y6 r7 l6 l
10. 9 };

复制代码

示例代码35.1.2.1中的gpio_pins_a节点就是LED的pinctrl配置，把PI0端口复用为GPIO功能，同时设置PI0的电气特性。我们已经在25.1.1小节详细的讲解过如何配置STM32MP1的电气属性，大家可以回过头去看一下，这里我们就简单介绍一下LED0的配置：
7 x5 F7 S- X8 v7 G$ N5 G第3行，设置PI0复用为GPIO功能。
第4行，设置PI0为推挽输出。
第5行，设置PI0内部上拉。
9 P: X1 j. C* g: @! b5 y第6行，设置PI0默认输出高电平。
第7行，设置PI0的速度为0档，也就是最慢。
添加完成以后如图35.1.2.1所示：
8 O* Z0 V5 _6 h9 H
4 X/ h: w7 j+ B2 s0 ?

图35.1.2.1 led对应的pinctrl节点
  R! Q. ?! n/ `1 Y35.1.3 在设备树中创建设备节点
接下来要在设备树中创建设备节点来描述设备信息，重点是要设置好compatible属性的值，因为platform总线需要通过设备节点的compatible属性值来匹配驱动！这点要切记。修改25.4.1.2小节中我们创建的gpioled节点，修改以后的内容如下：
示例代码35.1.3.1 gpioled设备节点

1. 1 gpioled {
     r4 n/ f% S) w
2. 2           compatible = "alientek,led";
   ! ?5 |" E" p/ j( m- M
3. 3           pinctrl-names = "default";
   
4. 4           status = "okay";
   0 }! f! u8 j# c0 n* U) J
5. 5           pinctrl-0 = <&led_pins_a>;
   
6. 6                  led-gpio = <&gpioi 0 GPIO_ACTIVE_LOW>;
   9 @, L" u& r3 w) r4 z3 ]1 d$ \5 O
7. 7 };

复制代码

第2行的compatible属性值为“alientek,led”，因此一会在编写platform驱动的时候of_match_table属性表中要有“alientek,led”。
, D  Z* p. K/ P: C第5行里，pinctrl-0属性设置LED的PIN对应的pinctrl节点，也就是我们在示例代码35.1.1中编写的led_pins_a。
8 I6 Q# C8 E8 [- I. ^
35.1.4 编写platform驱动的时候要注意兼容属性
在使用设备树的时候platform驱动会通过of_match_table来保存兼容性值，也就是表明此驱动兼容哪些设备。所以，of_match_table将会尤为重要，比如本例程的platform驱动中platform_driver就可以按照如下所示设置：
, ~: g1 ~' R# u6 O, {6 I1 h+ b. \, j

1. 示例代码35.1.4.1 of_match_table匹配表的设置
   
2. 1          static const struct of_device_id led_of_match[] = {
   
3. 2           { .compatible = "alientek,led" },  /* 兼容属性 */
   
4. 3           { /* Sentinel */ }
   4 R# R4 b2 N6 @  y) Q5 m2 \
5. 4          };
   3 Q/ f% k& M2 `2 x+ Y
6. 5   
   
7. 6          MODULE_DEVICE_TABLE(of, led_of_match);
   - i0 n- {" n/ z& Q1 T
8. 7  
   1 C3 S6 D4 L: u% B0 {8 Z8 _
9. 8          static struct platform_driver led_platform_driver = {
   
10. 9           .driver = {
    
11. 10              .name       = "stm32mp1-led",
    
12. 11              .of_match_table = led_of_match,
    ( p5 K3 U# {# c+ Q; g, G( K  P
13. 12          },
    7 U( B" K2 u. P
14. 13          .probe          = led_probe,
    2 |' p# x; t1 e, z/ {& v% x: u1 B" H0 \
15. 14          .remove         = led_remove,
    
16. 15         };

复制代码

第1~4行，of_device_id表，也就是驱动的兼容表，是一个数组，每个数组元素为of_device_id类型。每个数组元素都是一个兼容属性，表示兼容的设备，一个驱动可以跟多个设备匹配。这里我们仅仅匹配了一个设备，那就是示例代码35.1.2中创建的gpioled这个设备。第2行的compatible值为“alientek,led”，驱动中的compatible属性和设备中的compatible属性相匹配，因此驱动中对应的probe函数就会执行。注意第3行是一个空元素，在编写of_device_id的时候最后一个元素一定要为空！
% k9 }9 W, K5 @6 ~第6行，通过MODULE_DEVICE_TABLE声明一下led_of_match这个设备匹配表。
3 P: c  T' b( _0 k第11行，设置platform_driver中的of_match_table匹配表为上面创建的leds_of_match，至此我们就设置好了platform驱动的匹配表了。
最后就是编写驱动程序，基于设备树的platform驱动和上一章无设备树的platform驱动基本一样，都是当驱动和设备匹配成功以后先根据设备树里的pinctrl属性设置PIN的电气特性再去执行probe函数。我们需要在probe函数里面执行字符设备驱动那一套，当注销驱动模块的时候remove函数就会执行，都是大同小异的。
% s2 W! ~" Q4 b) |0 {
+ ^" i, J' b" r. ?35.2 检查引脚复用配置
35.2.1 检查引脚pinctrl配置
$ C3 B, d1 l1 O6 l: f! J3 iSTM32MP1的一个引脚可以复用为多种功能，比如PI0可以作为GPIO、TIM5_CH4、SPI2_NSS、DCMI_D13、LCD_G5等。我们在做STM32单片机开发的时候，一个IO可以被多个外设使用，比如PI0同时作为TIM5_CH4、LCD_G5，但是同一时刻只能用做一个功能，比如做LCD_G5的时候就不能做TIM5_CH4！在嵌入式Linux下，我们要严格按照一个引脚对应一个功能来设计硬件，比如PI0现在要用作GPIO来驱动LED灯，那么就不能将PI0作为其他功能，比如你在设计硬件的时候就不能再将PI0作为LCD_G5。
$ y" a2 O( e% v6 j& R  h3 d4 ~正点原子STM32MP1开发板上将PI0连接到了LED0上，也就是将其用作普通的GPIO，对应的pinctrl配置就是示例代码35.1.2.1。但是stm32mp15-pinctrl.dtsi是ST根据自己官方EVK开发板编写的，因此PI0就可能被ST官方用作其他功能，大家在stm32mp15-pinctrl.dtsi里面找到如下所示代码：


# a0 t" k( Q" I0 `
图35.2.1.1 ltdc_pins_a节点
从图35.2.1.1可以看出，ST官方默认将PI0复用为LCD_G5，前面说了，一个IO只能复用为一个功能，因此我们需要将图35.2.1.1中的“<STM32_PINMUX(‘I’, 0, AF14)>”屏蔽掉，因为我们现在要将PI0用作GPIO。同样的，继续在stm32mp15-pinctrl.dtsi文件里面查找，会发现如图35.2.1.2所示的地方也将PI0复用为了LCD_G5：
8 d' B( m. h. E' _1 V

' P: d* L& b0 U
/ E& ]/ Q+ H$ T8 K  K* _3 J9 z图35.2.1.2 ltdc_pins_sleep_a节点
/ P1 c, f' N! E3 P9 M( i4 b9 W图35.2.1.2中的ltdc_pins_sleep_a节点也将PI0复用为LCD_G5，将这行代码也屏蔽掉。确保所使用的设备树中，一个引脚只复用为一个功能！

35.2.2 检查GPIO占用
( |# _7 ]: D0 o/ `9 x, I. f, \, T上一小节只是检查了一下，PI0这个引脚有没有被复用为多个设备，本节我们将PI0复用为GPIO。因为我们是在ST官方提供的设备树上修改的，因此还要检查一下当PI0作为GPIO的时候，ST官方有没有将这个GPIO分配给其他设备。其实对于PI0这个引脚来说不会的，因为ST官方将其复用为了LCD_G5，所以也就不存在说将其在作为GPIO分配给其他设备。但是我们在实际开发中要考虑到这一点，说不定其他的引脚就会被分配给某个设备做GPIO，而我们没有检查，导致两个设备都用这一个GPIO，那么肯定有一个因为申请不到GPIO而导致驱动无法工作。
8 k- L- [9 c+ g$ u% Y所以当我们将一个引脚用作GPIO的时候，一定要检查一下当前设备树里面是否有其他设备也使用到了这个GPIO，保证设备树中只有一个设备树在使用这个GPIO。

35.3 硬件原理图分析
  [$ c2 |. @3 r5 @0 Q% w1 r本实验的硬件原理参考21.2小节即可。

* l5 F5 z) `/ e( ~0 h8 w35.4 实验程序编写
- T7 y+ I% k" r6 D- f& z: A( ]本实验对应的例程路径为：开发板光盘 1、程序源码2、Linux驱动例程18_dtsplatform。
本章实验我们编写基于设备树的platform驱动，所以需要在设备树中添加设备节点，然后我们只需要编写platform驱动即可。
  h, Z: j" E4 t' o7 [9 Q& \5 `35.4.1 修改设备树文件
首先修改设备树文件，加上我们需要的设备信息，本章我们就使用到一个LED0。需要创建LED0引脚的pinctrl节点，这个直接使用示例代码35.1.2.1中的led_pins_a节点。另外也要创建一个LED0设备节点，这个直接使用示例代码35.1.3.1中的 gpioled设备节点。
: t  p: c- N8 ~& ?3 N& X9 X  ^35.4.2 platform驱动程序编写
设备已经准备好了，接下来就要编写相应的platform驱动了，新建名为“18_dtsplatform”的文件夹，然后在18_dtsplatform文件夹里面创建vscode工程，工作区命名为“dtsplatform”。新建名为leddriver.c的驱动文件，在leddriver.c中输入如下所示内容：

1. 示例代码35.4.2.1 leddriver.c文件代码段
   
2. 1   #include <linux/types.h>
   
3. 2   #include <linux/kernel.h>
   
4. 3   #include <linux/delay.h>
   ) v3 {8 ^, ]1 C7 g: N
5. 4   #include <linux/ide.h>
   
6. 5   #include <linux/init.h>
   8 A' u5 s2 b9 b0 D8 ?
7. 6   #include <linux/module.h>
   
8. 7   #include <linux/errno.h>
   
9. 8   #include <linux/gpio.h>
   6 d! l$ s0 D8 X/ L' ~+ f3 M& S
10. 9   #include <linux/cdev.h>
    
11. 10  #include <linux/device.h>
    ! j; V& ]3 [" g1 m, I- V
12. 11  #include <linux/of_gpio.h>
    
13. 12  #include <linux/semaphore.h>
    # a8 F% Z; t' }9 ]5 H
14. 13  #include <linux/timer.h>
    2 Y5 y  i* E' W$ }, J7 M0 T
15. 14  #include <linux/irq.h>
    ; x* X7 k: n0 M+ P
16. 15  #include <linux/wait.h>
    
17. 16  #include <linux/poll.h>
    
18. 17  #include <linux/fs.h>
    4 N: }1 V4 C2 U# ^
19. 18  #include <linux/fcntl.h>
    6 g0 W: d! X6 D$ U: s
20. 19  #include <linux/platform_device.h>
    
21. 20  #include <asm/mach/map.h>
    
22. 21  #include <asm/uaccess.h>
    
23. 22  #include <asm/io.h>
    # T4 y" \2 Z1 c$ J
24. 23  
    
25. 24  #define LEDDEV_CNT          1                               /* 设备号长度          */
    $ _; u. X7 p. d! j& J
26. 25  #define LEDDEV_NAME         "dtsplatled"            /* 设备名字     */
    ; s' V( s, v& g3 j1 |4 y
27. 26  #define LEDOFF               0
    
28. 27  #define LEDON                1
    . I9 X  ?0 ]; V
29. 28  
    , U( C; p! Z+ M% h  O
30. 29  /* leddev设备结构体 */
    
31. 30  struct leddev_dev{
    / ^0 f# L1 N. }6 y9 L3 f
32. 31      dev_t devid;                                        /* 设备号                    */
    ; c! ?5 E0 d% p% X0 [* Y
33. 32      struct cdev cdev;                                  /* cdev                     */
    
34. 33      struct class *class;                                /* 类                              */
      |0 D  Z( z% g6 d0 w& s
35. 34      struct device *device;                              /* 设备                       */  
    
36. 35      struct device_node *node;                           /* LED设备节点                 */
    
37. 36      int gpio_led;                                       /* LED灯GPIO标号        */
    
38. 37  };
    . a# j$ o+ _8 T+ ]& @, t* N
39. 38  
    
40. 39  struct leddev_dev leddev;                               /* led设备                 */
    
41. 40  
    - i. Q7 a, N* J$ C& H1 B
42. 41  /*
    
43. 42   * @description         : LED打开/关闭
    
44. 43   * @param - sta         : LEDON(0) 打开LED，LEDOFF(1) 关闭LED
    & ^. Q# Y! C/ k/ L( z
45. 44   * @return                : 无
    / i! j9 l% e: S- y5 E5 H
46. 45   */
    
47. 46  void led_switch(u8 sta)
    & U# j& f5 b8 W3 \8 O. }; g8 i# l
48. 47  {
    9 r+ p3 f7 N  j8 p6 E
49. 48      if (sta == LEDON )
    & r7 Q1 ]( [# h# _) w/ p
50. 49          gpio_set_value(leddev.gpio_led, 0);
    
51. 50      else if (sta == LEDOFF)
    
52. 51          gpio_set_value(leddev.gpio_led, 1);
    1 F8 C' q% r* g- y) z# ~4 }' X8 _. t
53. 52  }
    
54. 53  
    1 a4 n6 p' g  a% C
55. 54  static int led_gpio_init(struct device_node *nd)
    1 a+ c8 q# l! j. c. `6 c2 ^# J
56. 55  {
    - P$ I7 Y) N2 y; K$ I; |
57. 56      int ret;
    
58. 57  
    
59. 58      /* 从设备树中获取GPIO */
    3 O0 C' g% R+ W- Q+ J
60. 59      leddev.gpio_led = of_get_named_gpio(nd, "led-gpio", 0);
    ! Y& {1 k- A: n1 t8 H
61. 60      if(!gpio_is_valid(leddev.gpio_led)) {
    . u2 Y( g) S& D/ [9 g* _+ G9 D
62. 61          printk(KERN_ERR "leddev: Failed to get led-gpio\n");
    
63. 62          return -EINVAL;
    ! e$ m9 V/ M- j7 z8 u6 z  u! M% t
64. 63      }
    
65. 64      
    & r- @% j3 T$ B% @4 Y
66. 65      /* 申请使用GPIO */
    
67. 66      ret = gpio_request(leddev.gpio_led, "LED0");
    
68. 67      if (ret) {
    ! x$ g( u4 v- G& s
69. 68          printk(KERN_ERR "led: Failed to request led-gpio\n");
    
70. 69          return ret;
    
71. 70      }
      p6 z  L  g5 }8 z
72. 71      
    
73. 72      /* 将GPIO设置为输出模式并设置GPIO初始电平状态 */
    , T) f0 o! r# a9 a+ Z
74. 73      gpio_direction_output(leddev.gpio_led,1);
    ! N! A0 U" f: @' j# X. z: ]
75. 74      
    4 G/ |2 `0 q5 P* u% ?; O6 Z
76. 75      return 0;
    2 H' X" ^+ Q* e% b  Z7 S* X
77. 76  }
    0 V1 k! r. _1 F
78. 77  
    
79. 78  /*
    * s3 U5 s( k$ W& F* Z8 L1 `" V6 b" Q
80. 79   * @description          : 打开设备
    " ]. W9 Q: |# Y6 |) Y# J
81. 80   * @param – inode        : 传递给驱动的inode
    . m1 x7 a' E0 J0 \4 C
82. 81   * @param - filp         : 设备文件，file结构体有个叫做private_data的成员变量
    
83. 82   *                    一般在open的时候将private_data指向设备结构体。
    6 {* U3 Q7 ^. X3 g
84. 83   * @return                : 0 成功;其他 失败
    
85. 84   */
    & u6 S1 q$ g" p) T0 }
86. 85  static int led_open(struct inode *inode, struct file *filp)
    
87. 86  {
    
88. 87      return 0;
    2 v5 y& F! Z) P* h) d3 K# P+ r
89. 88  }
    
90. 89  
      J3 t: l+ C/ n0 v( v
91. 90  /*
    
92. 91   * @description         : 向设备写数据
    
93. 92   * @param – filp        : 设备文件，表示打开的文件描述符
    
94. 93   * @param - buf         : 要写给设备写入的数据
    
95. 94   * @param - cnt          : 要写入的数据长度
    3 P3 s" n1 L2 Z6 ~- w
96. 95   * @param – offt        : 相对于文件首地址的偏移
    
97. 96   * @return                : 写入的字节数，如果为负值，表示写入失败
    
98. 97   */
    7 k0 T/ t2 |" e7 t, G" d
99. 98  static ssize_t led_write(struct file *filp, const char __user *buf,
    
100. size_t cnt, loff_t *offt)
     ; _- K$ b% i; P+ ?# i
101. 99  {
     
102. 100     int retvalue;
     
103. 101     unsigned char databuf[1];
     
104. 102     unsigned char ledstat;
     # w! U/ ^" k, b( Z
105. 103
     , Q! e# d# q) @
106. 104     retvalue = copy_from_user(databuf, buf, cnt);
     2 x3 f  Q2 c5 Z& O8 |! L; Y; u
107. 105     if(retvalue < 0) {
     5 o( o+ g- s& J$ X, P2 b7 D) f- a# r
108. 106         printk("kernel write failed!\r\n");
     + n/ Q; ^6 J; M$ u( E, s6 |
109. 107         return -EFAULT;
     # V$ w2 p& I" B. N! |
110. 108     }
     0 `1 v  v; x2 E' Z( b
111. 109     
     
112. 110     ledstat = databuf[0];
     
113. 111     if (ledstat == LEDON) {
     ) L/ f  C' W8 K6 s5 O
114. 112         led_switch(LEDON);
     4 m5 t1 s7 E" r3 o# R9 @7 e% ~
115. 113     } else if (ledstat == LEDOFF) {
     ' {! T! l. S& D) W
116. 114         led_switch(LEDOFF);
     
117. 115     }
     . a& P4 |, T$ v  ~5 }  B+ ^% q
118. 116     return 0;
     
119. 117 }
     
120. 118
     ( p& C. l' a/ p1 K2 v4 V7 O% Y; y
121. 119 /* 设备操作函数 */
     ) t, `9 g8 e# [; j
122. 120 static struct file_operations led_fops = {
     
123. 121     .owner = THIS_MODULE,
     
124. 122     .open = led_open,
     / t& Z+ |, s* T0 M
125. 123     .write = led_write,
     , x+ F# ^  p* f1 m
126. 124 };
     2 ]; r/ I, B( b. Y; c
127. 125
     ( u$ `- T0 W3 R
128. 126 /*
     0 l+ B' W$ M9 f' n
129. 127  * @description         : flatform驱动的probe函数，当驱动与设备匹配以后此函数
     , w' a! }, R/ z+ n5 K+ |
130. 128  *                     就会执行
     - S2 l$ {# A" K5 V& v7 \9 l9 n7 S( ]
131. 129  * @param - dev         : platform设备
     ; G. c5 D; u( i2 r/ Z
132. 130  * @return                : 0，成功;其他负值,失败
     
133. 131  */
     
134. 132 static int led_probe(struct platform_device *pdev)
     : w* \" [0 c( O
135. 133 {   
     7 m" b. F' ]1 ?; e
136. 134     int ret;
     
137. 135     
     
138. 136     printk("led driver and device was matched!\r\n");
     
139. 137     
     
140. 138     /* 初始化 LED */
     
141. 139     ret = led_gpio_init(pdev->dev.of_node);
     3 m4 K' [5 E1 J* B
142. 140     if(ret < 0)
     
143. 141         return ret;
     
144. 142         
     
145. 143     /* 1、设置设备号 */
     
146. 144     ret = alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT,
     
147. LEDDEV_NAME);
     
148. 145     if(ret < 0) {
     
149. 146         pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n",
     
150. LEDDEV_NAME, ret);
     ; Z5 b/ }0 S9 J& p# B( o) x, N5 o
151. 147         goto free_gpio;
     
152. 148     }
     % X2 b4 B+ ]7 N  j  M5 d: Q
153. 149     
     
154. 150     /* 2、初始化cdev  */
       S$ J$ B: P% V+ n. m3 ^3 M) W
155. 151     leddev.cdev.owner = THIS_MODULE;
     
156. 152     cdev_init(&leddev.cdev, &led_fops);
     4 E: \& _3 K: G; ~# \( y* n
157. 153     
     % m0 U( R2 L1 `& j! p% B9 s
158. 154     /* 3、添加一个cdev */
       A, |" J2 c; `/ Q, u
159. 155     ret = cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT);
     3 |) [- a7 N% [
160. 156     if(ret < 0)
     
161. 157         goto del_unregister;
     . G# \+ r3 }2 y
162. 158     
     4 j: t4 x4 f4 V0 h
163. 159     /* 4、创建类      */
     + j7 q# Z- O1 _! H/ i* S
164. 160     leddev.class = class_create(THIS_MODULE, LEDDEV_NAME);
     $ X  p- c" z+ P; a$ [
165. 161     if (IS_ERR(leddev.class)) {
     
166. 162         goto del_cdev;
     
167. 163     }
     ! d6 S4 U& P5 o, ~
168. 164
     # n3 J+ |4 ]6 {" l; _  q% x- O
169. 165     /* 5、创建设备 */
     
170. 166     leddev.device = device_create(leddev.class, NULL, leddev.devid,
     1 z8 X) o' _3 {7 `; A
171. NULL, LEDDEV_NAME);
     7 O  V3 `( ^! T/ b
172. 167     if (IS_ERR(leddev.device)) {
     
173. 168         goto destroy_class;
     4 D; z+ Q; E, X7 }
174. 169     }
     7 `; t' l3 A# d- Y, \* N
175. 170     
     
176. 171     return 0;
     3 w) z$ a# _; V$ t) U
177. 172 destroy_class:
     " O' [+ @* v$ ]
178. 173     class_destroy(leddev.class);
     6 K4 ?5 h- S) Q1 p4 o$ V
179. 174 del_cdev:
     4 ~1 x' x" H$ q- S
180. 175     cdev_del(&leddev.cdev);
     
181. 176 del_unregister:
     : T- O' s. Y1 w9 _2 |% X0 d
182. 177     unregister_chrdev_region(leddev.devid, LEDDEV_CNT);
     , |4 c! B  r3 `$ n
183. 178 free_gpio:
     7 `! j9 G: W5 `2 N$ E
184. 179     gpio_free(leddev.gpio_led);
     
185. 180     return -EIO;
     
186. 181 }
     8 `1 a* m$ B) N" q
187. 182
     
188. 183 /*
     - C/ b+ i% z. F* t4 ]! x$ ?7 r) B
189. 184  * @description         : platform驱动的remove函数
     & e2 X- l: T% e
190. 185  * @param - dev         : platform设备
     
191. 186  * @return               : 0，成功;其他负值,失败
     ' B3 t4 }' X# q) s7 |* ^$ t! [* b0 q
192. 187  */
     $ w( N( g+ Z% n+ V0 j! r
193. 188 static int led_remove(struct platform_device *dev)
     
194. 189 {
     
195. 190     gpio_set_value(leddev.gpio_led, 1);        /* 卸载驱动的时候关闭LED */
     3 F5 s0 m& d) q3 h4 E
196. 191     gpio_free(leddev.gpio_led);                         /* 注销GPIO */
     
197. 192     cdev_del(&leddev.cdev);                             /*  删除cdev */
     $ l7 G" y. p8 F( W" |4 Y
198. 193     unregister_chrdev_region(leddev.devid, LEDDEV_CNT);
     7 v/ K; r4 s1 R4 ^' R
199. 194     device_destroy(leddev.class, leddev.devid);         /* 注销设备         */
     3 i( L" W$ }( L, U) h! S
200. 195     class_destroy(leddev.class);                                         /* 注销类         */
     ' h! W" D+ o  }, T" p5 N
201. 196     return 0;
     
202. 197 }
     
203. 198
     
204. 199 /* 匹配列表 */
     
205. 200 static const struct of_device_id led_of_match[] = {
     6 S! G2 I- t" d  s# W* z$ O# G
206. 201     { .compatible = "alientek,led" },
       V/ o2 _3 v# X2 a
207. 202     { /* Sentinel */ }
     " O$ m5 s, j3 U7 }  X) ^; l
208. 203 };
     4 u; [  A" w0 F6 I9 j4 Z
209. 204
     
210. 205 MODULE_DEVICE_TABLE(of, led_of_match);
     5 P  r( o7 w6 R# o% S
211. 206
     8 j9 q6 Y5 c: \6 X" d+ w+ K
212. 207 /* platform驱动结构体 */
     
213. 208 static struct platform_driver led_driver = {
     
214. 209     .driver     = {
     4 V& Q& u& V9 l: w  [: ~2 ]
215. 210         .name   = "stm32mp1-led",                 /* 驱动名字，用于和设备匹配 */
     ) l: P& d: U7 E, z# }8 e
216. 211         .of_match_table = led_of_match,         /* 设备树匹配表        */
     
217. 212     },
     9 ]" v4 p: H. r! g
218. 213     .probe      = led_probe,
     , M" s/ Q1 J" N5 Y+ _
219. 214     .remove     = led_remove,
     , ?* _3 y; i2 _1 G( c
220. 215 };
     
221. 216         
     ) }1 L3 q. N+ A/ ?1 @: H. z" T- F8 J
222. 217 /*
     : _! M1 `9 r1 L' h( m
223. 218  * @description         : 驱动模块加载函数
     9 ~# C  U1 u2 _. n6 P
224. 219  * @param               : 无
     
225. 220  * @return              : 无
     3 t7 O/ T" k% L) `; h+ ~$ K
226. 221  */
     ; T6 _* C7 K& h$ N9 r1 B
227. 222 static int __init leddriver_init(void)
     
228. 223 {
     * H3 f2 v$ F. a
229. 224     return platform_driver_register(&led_driver);
     
230. 225 }
     
231. 226
     
232. 227 /*
     
233. 228  * @description         : 驱动模块卸载函数
     
234. 229  * @param               : 无
     
235. 230  * @return              : 无
     
236. 231  */
     
237. 232 static void __exit leddriver_exit(void)
     
238. 233 {
     
239. 234     platform_driver_unregister(&led_driver);
     ( z1 t3 e2 }+ c2 S# |
240. 235 }
     9 [2 t5 H1 a" K( a# d* Z' f
241. 236
     
242. 237 module_init(leddriver_init);
     ( N' _. w4 D- c8 }2 o1 F2 t6 ^
243. 238 module_exit(leddriver_exit);
     . h# F+ i% B% {4 }$ G* P
244. 239 MODULE_LICENSE("GPL");
     
245. 240 MODULE_AUTHOR("ALIENTEK");
     ; L7 D% U. E3 {8 ~, b
246. 241 MODULE_INFO(intree, "Y");
     

复制代码

! j% j' A8 @  F+ S3 {) ~3 @代码中以前讲过的知识点这里就不再重述了！
4 z" Q+ c$ C8 r% i: H. n: t$ `第54~76行，自定义函数led_gpio_init，该函数的参数是struct device_node类型的指针，也就是led对应的设备节点，当调用函数的时候传递进来。
第132~181行，platform下的 probe函数：led_probe，当设备树中的设备节点与驱动之间匹配成功会先去初始化pinctrl里面配置的IO，也就是根据示例代码35.1.2.1中的属性进行配置，然后再执行probe函数，第139行调用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函数里面完成。
* F3 {2 {) T8 i# A9 |2 h0 g  |) D% |1 X第188~197行，platform下的remove函数：led_remove，当platform驱动模块被卸载时此函数就会执行。在此函数里面释放内存、注销字符设备等，也就是将原来驱动卸载函数里面的工作全部都放到remove函数中完成。
第200~203行，匹配表，描述了此驱动都和什么样的设备匹配，第201行添加了一条值为"alientek,led"的compatible属性值，当设备树中某个设备节点的compatible属性值也为“alientek,led”的时候就会与此驱动匹配。
第208~215行，platform_driver驱动结构体变量led_driver，210行设置这个platform驱动的名字为“stm32mp1-led”，因此，当驱动加载成功以后就会在/sys/bus/platform/drivers/目录下存在一个名为“stm32mp1-led”的文件。第211行绑定platform驱动的of_match_table表。
第222~225行，platform驱动模块入口函数，在此函数里面通过platform_driver_register向Linux内核注册一个platform驱动led_driver。
第232~235行，platform驱动驱动模块出口函数，在此函数里面通过platform_driver_unregister从Linux内核卸载一个platform驱动led_driver。
" h( d- j6 k# M$ X3 R4 t: p% ]2 M35.4.3 编写测试APP
, q) U; {  {: Y1 o5 C5 l8 T0 p测试APP就直接使用上一章34.4.2小节编写的ledApp.c即可。
4 ?7 W) F# T3 J4 T: p% K, i
5 I4 `* S) y4 s. g35.5 运行测试
35.5.1 编译驱动程序和测试APP
" I; {* c4 c( s" J8 w& e( H2 N1、编译驱动程序
% S) z- N; e. ^( v. j- z编写Makefile文件，本章实验的Makefile文件和第四十章实验基本一样，只是将obj-m变量的值改为“leddriver.o”，Makefile内容如下所示：
0 p2 M" {7 T9 U3 M示例代码35.5.1.1 Makefile文件
7 w2 N4 Z: k# [( I& q

1. 1  KERNELDIR := /home/zuozhongkai/linux/my_linux/linux-5.4.31
   + c- Y! ~+ b2 C7 G; G
2. ......
   
3. 4  obj-m := leddriver.o
   
4. ......
   
5. 11 clean:
   & S+ Z+ L0 G: U/ g. D
6. 12  $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

复制代码

第4行，设置obj-m变量的值为“leddriver.o”。
输入如下命令编译出驱动模块文件：
6 c" U, e+ E! Y8 j3 G3 s( k
make -j32
3 j0 p: T; Z( X( s7 s编译成功以后就会生成一个名为“leddriver.o”的驱动模块文件。
2、编译测试APP
测试APP直接使用上一章的ledApp这个测试软件即可。
35.5.2 运行测试
将上一小节编译出来leddriver.ko拷贝到rootfs/lib/modules/5.4.31目录中，重启开发板，进入到目录lib/modules/5.4.31中，输入如下命令加载leddriver.ko这个驱动模块。
depmod //第一次加载驱动的时候需要运行此命令
modprobe leddriver.ko //加载驱动模块
6 m6 X- i! f  _. o! x驱动模块加载完成以后到/sys/bus/platform/drivers/目录下查看驱动是否存在，我们在leddriver.c中设置name字段为“stm32mp1-led”，因此会在/sys/bus/platform/drivers/目录下存在名为“stm32mp1-led”这个文件，结果如图35.5.2.1所示：

6 i# c" M; H& r2 z  A

2 O( {. X- |1 P" O( C图35.5.2.1 stm32mp1-led驱动
8 N2 F$ }. C( K0 h' Z同理，在/sys/bus/platform/devices/目录下也存在led的设备文件，也就是设备树中gpioled这个节点，如图35.5.2.2所示：


  O* g. G' Z: o
图35.5.2.2 gpioled设备
驱动和模块都存在，当驱动和设备匹配成功以后就会输出如图35.5.2.3所示一行语句：
( h8 {/ U& a9 d! X+ c0 Z


图35.5.2.3 驱动和设备匹配成功
. H/ q6 \. ~6 k0 V0 }* n9 v驱动和设备匹配成功以后就可以测试LED灯驱动了，输入如下命令打开LED灯：
. @" B! h  m3 U  h./ledApp /dev/dtsplatled 1 //打开LED灯
在输入如下命令关闭LED灯：
. w" c6 t+ a/ l9 x, Y5 e& ]  c' E./ledApp /dev/dtsplatled 0 //关闭LED灯
* X- ^* i9 a& q3 k6 K- e' j3 e" [观察一下LED灯能否打开和关闭，如果可以的话就说明驱动工作正常，如果要卸载驱动的话输入如下命令即可：
rmmod leddriver.ko
————————————————
版权声明：正点原子
. G2 L. L0 n; Y* w3 G' C

% C0 b' S5 m2 P* l/ ^; x