迅为i.MX6ULL终结者设备树下的Platform驱动实验程序编写

阳阳天

文章目录
. P9 f7 ?7 z* ?, u( L# `  u

• 1 修改设备树文件
• 2 platform驱动程序
• 3 应用测试程序
  9 e: e7 i7 D! Q7 g  K7 K

1 修改设备树文件

设备树文件可以直接使用第三十五章中添加的gpioled子节点即可，不用重复添加。

2 platform驱动程序

本实验例程路径：i.MX6UL终结者光盘资料/06_Linux驱动例程/15_gpioled_dts
+ B- e! n- u  p' x3 C: Y创建led_driver.c文件，具体内容如下：

1. 1 #include <linux/types.h>
   . D: f/ `; |# M) Z% V
2.   2 #include <linux/kernel.h>
   6 p& V& J: S+ W, d+ u+ W, L" L  C
3.   3 #include <linux/delay.h>
   
4.   4 #include <linux/ide.h>
   
5.   5 #include <linux/init.h>
   
6.   6 #include <linux/module.h>
   
7.   7 #include <linux/errno.h>
   * d1 [* k# r: ~, I# g) k; O  d& F
8.   8 #include <linux/gpio.h>
   
9.   9 #include <linux/cdev.h>
   
10. 10 #include <linux/device.h>
    
11. 11 #include <linux/of_gpio.h>
    " i. o& \: t' G
12. 12 #include <linux/semaphore.h>
    ' P8 q- ~3 j8 p* [! c* p* m" M
13. 13 #include <linux/timer.h>
    ' J- t! u, d" P( l$ ~2 _
14. 14 #include <linux/irq.h>
    7 f7 e* W5 |: x! L' m6 F4 Z
15. 15 #include <linux/wait.h>
    + r" p, [; G' g# g  g
16. 16 #include <linux/poll.h>
    
17. 17 #include <linux/fs.h>
    # X4 J% F7 c/ [" g- w
18. 18 #include <linux/fcntl.h>
    
19. 19 #include <linux/platform_device.h>
    
20. 20 #include <asm/mach/map.h>
    
21. 21 #include <asm/uaccess.h>
    
22. 22 #include <asm/io.h>
    
23. 23
    
24. 24 #define LEDDEV_CNT              1                    /* 设备号长度   */
    % C0 ]( J; B, M. Z& H) e/ h: N" Y
25. 25 #define LEDDEV_NAME             "dtsplatled"    /* 设备名字     */
    ' ]% h9 b5 p3 }% S' y) I
26. 26 #define LEDOFF                  0
    - L1 O6 f6 d* L# p- O2 l" d% j
27. 27 #define LEDON                   1
    + z9 I' S) S  x& U, G5 m4 C: g) ~
28. 28
    ! A' j5 |2 k4 w9 F# E
29. 29 /* leddev设备结构体 */
    5 e% j3 u  S- M6 J) a9 V, y7 i
30. 30 struct leddev_dev{
    " ~. q# c* j1 Q$ V# \/ E3 H- P" r! r
31. 31         dev_t devid;                            /* 设备号       */
    + r7 D4 Z- f3 I& a: y
32. 32         struct cdev cdev;                       /* cdev         */
    
33. 33         struct class *class;            /* 类           */
    * H, @5 C* i* Z/ @1 T0 O9 a4 q: a
34. 34         struct device *device;          /* 设备 */
    % s+ h8 r3 q9 y( E/ z% c2 e
35. 35         int major;                     /* 主设备号     */
    + i) i- A0 v+ k! [7 ~. @5 V
36. 36         struct device_node *node;       /* LED设备节点 */
    ! ~% k2 R5 c+ @8 a' z* X4 q) q
37. 37         int led0;                      /* LED灯GPIO标号 */
    
38. 38 };
    / x) J! ]1 ]5 [. Y- }/ t. o6 K
39. 39
    4 v; v0 |+ i" k% y( M: c9 D
40. 40 struct leddev_dev leddev;               /* led设备 */
    
41. 41
    
42. 42 /*
    / A7 u9 s5 n  w4 H
43. 43  * @description         : LED打开/关闭
    
44. 44  * @param - sta         : LEDON(0) 打开LED，LEDOFF(1) 关闭LED
    
45. 45  * @return                      : 无
    
46. 46  */
    
47. 47 void led0_switch(u8 sta)
    - a/ R4 R4 ^+ k$ M# `
48. 48 {
    1 \) B- s( p' |. P7 U# A
49. 49         if (sta == LEDON )
    - a' W& p3 E, t/ L4 L3 F
50. 50                 gpio_set_value(leddev.led0, 0);
    
51. 51         else if (sta == LEDOFF)
    - V+ f& X9 ^4 |1 }) f4 I6 r
52. 52                 gpio_set_value(leddev.led0, 1);
    
53. 53 }
    9 A: ^7 d, T" }5 E3 z8 G8 i# ^
54. 54
    
55. 55 /*
    
56. 56  * @description         : 打开设备
    
57. 57  * @param - inode       : 传递给驱动的inode
    
58. 58  * @param - filp        : 设备文件，file结构体有个叫做private_data的成员变量
    9 ^2 V% L: d' R  D: }& ^' |. D* J
59. 59  * 一般在open的时候将private_data指向设备结构体。
    
60. 60  * @return                      : 0 成功;其他 失败
    * v. p# U3 r- H' c& G+ r  ^
61. 61  */
    
62. 62 static int led_open(struct inode *inode, struct file *filp)
    
63. 63 {
    ( b+ a: U& X* n& B6 N6 X
64. 64         filp->private_data = &leddev; /* 设置私有数据  */
    
65. 65         return 0;
    " R- e# [7 R( [8 U% g  u5 o+ g6 O2 \
66. 66 }
    
67. 67
    
68. 68 /*
    
69. 69  * @description         : 向设备写数据
    # U' y. Y' ^* ~; r: P
70. 70  * @param - filp        : 设备文件，表示打开的文件描述符
    
71. 71  * @param - buf         : 要写给设备写入的数据
    2 O6 u3 ?8 X2 z' N  |/ ?9 Y) |4 @. D
72. 72  * @param - cnt         : 要写入的数据长度
    : \  W% z$ k  N2 }+ p1 S0 `. t
73. 73  * @param - offt        : 相对于文件首地址的偏移
    0 t" k9 Q! {1 L; f3 H
74. 74  * @return                      : 写入的字节数，如果为负值，表示写入失败
    
75. 75  */
    
76. 76 static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
    . B; L7 V  s. g- I
77. 77 {
    $ {0 d* s7 i- u- a  y3 }" a: q
78. 78         int retvalue;
    * {: u( M9 ^& }2 U" ?0 v- K2 K
79. 79         unsigned char databuf[2];
    
80. 80         unsigned char ledstat;
    8 e0 l% n0 [( S
81. 81
    " P. H( W# h/ q( Y+ `+ y
82. 82         retvalue = copy_from_user(databuf, buf, cnt);
    
83. 83         if(retvalue < 0) {
    
84. 84
    0 M) r: T( \3 U7 e7 n4 ?# G
85. 85                 printk("kernel write failed!\r\n");
    1 V# L5 ^. p0 w
86. 86                 return -EFAULT;
    
87. 87         }
    
88. 88
    
89. 89         ledstat = databuf[0];
    / S7 F: t( d4 p) N
90. 90         if (ledstat == LEDON) {
    
91. 91                 led0_switch(LEDON);
    
92. 92         } else if (ledstat == LEDOFF) {
    ' |9 h3 F, O* R: j4 J" u
93. 93                 led0_switch(LEDOFF);
    
94. 94         }
    , _5 E0 R1 w- x3 x0 v
95. 95         return 0;
    
96. 96 }
      b/ L5 Z0 A4 H' O( _
97. 97
    7 H( c6 |5 L; l0 d
98. 98 /* 设备操作函数 */
    $ Y' a6 d0 h) o5 i2 F+ [3 w; h
99. 99 static struct file_operations led_fops = {
    
100. 100         .owner = THIS_MODULE,
     8 B- Y7 |/ x7 ^5 M2 p" C$ J7 Z
101. 101         .open = led_open,
     
102. 102         .write = led_write,
     * m6 ?0 A; Q1 @3 x2 D
103. 103 };
     / A* J8 y0 K/ ], I% `3 M
104. 104
       d( M+ \/ U3 q& D9 q3 h3 I  M
105. 105 /*
     
106. 106  * @description         : flatform驱动的probe函数，当驱动与
     ) R9 j9 q9 y& `% z
107. 107  *                                        设备匹配以后此函数就会执行
     1 v; J8 q& }) {0 [0 [% W1 R0 s
108. 108  * @param - dev         : platform设备
     
109. 109  * @return                      : 0，成功;其他负值,失败
       B0 c! K7 q% Y% Q8 ^- V
110. 110  */
     
111. 111 static int led_probe(struct platform_device *dev)
     
112. 112 {
     
113. 113         printk("led driver and device was matched!\r\n");
     8 N* a8 \- C  Q+ W. r- Q# e7 v
114. 114         /* 1、设置设备号 */
     
115. 115         if (leddev.major) {
     : {' V' }0 @# C) n' n& H- S
116. 116                 leddev.devid = MKDEV(leddev.major, 0);
     % q2 X, {6 R  @; W$ _3 |9 d( J# x
117. 117               register_chrdev_region(leddev.devid, LEDDEV_CNT, LEDDEV_NAME);
     
118. 118         } else {
     
119. 119              alloc_chrdev_region(&leddev.devid, 0, LEDDEV_CNT, LEDDEV_NAME);
     1 ]% V, m$ l& t( u, C/ l& `4 e
120. 120                 leddev.major = MAJOR(leddev.devid);
     
121. 121         }
     % I, d* W# b: ?! I2 Q8 k9 K# e
122. 122
     
123. 123         /* 2、注册设备      */
     
124. 124         cdev_init(&leddev.cdev, &led_fops);
     / C/ o+ q+ i4 g5 K) @+ [0 L" @
125. 125         cdev_add(&leddev.cdev, leddev.devid, LEDDEV_CNT);
     
126. 126
     1 M7 _) e& x# F# [. a4 x; ~* _
127. 127         /* 3、创建类      */
     
128. 128         leddev.class = class_create(THIS_MODULE, LEDDEV_NAME);
     
129. 129         if (IS_ERR(leddev.class)) {
     " `6 n) }3 r& N6 z1 s% i$ P0 o0 e
130. 130                 return PTR_ERR(leddev.class);
     
131. 131         }
     
132. 132
     . r" [$ O$ j8 d
133. 133         /* 4、创建设备 */
     6 M5 i2 v4 L( r& ?
134. 134         leddev.device = device_create(leddev.class, NULL, leddev.devid,
     " D1 T$ @3 A- i, ~2 }1 L' ~) ^- X
135. NULL, LEDDEV_NAME);
     7 o3 ]  d" V: f' b
136. 135         if (IS_ERR(leddev.device)) {
     
137. 136                 return PTR_ERR(leddev.device);
     
138. 137         }
     
139. 138
     
140. 139         /* 5、初始化IO */
     
141. 140         leddev.node = of_find_node_by_path("/gpioled");
     
142. 141         if (leddev.node == NULL){
     
143. 142                 printk("gpioled node nost find!\r\n");
     1 G" K# m% w- f6 f; p
144. 143                 return -EINVAL;
     : }6 @+ `8 ~! ~: K* x
145. 144         }
     + M: ~% A3 ]2 w7 R
146. 145
     - r" K: K7 z1 E  {
147. 146         leddev.led0 = of_get_named_gpio(leddev.node, "led-gpio", 0);
     ( m: f- M2 o( F* u2 B
148. 147         if (leddev.led0 < 0) {
     
149. 148                 printk("can't get led-gpio\r\n");
     
150. 149                 return -EINVAL;
     
151. 150         }
     
152. 151
     3 `9 l, I: e3 b
153. 152         gpio_request(leddev.led0, "led0");
     
154. 153     gpio_direction_output(leddev.led0, 1); /* led0 IO设置为输出，默认高电平 */
     
155. 154         return 0;
     
156. 155 }
     
157. 156
     + g! O' F) |7 Y3 ^% \
158. 157 /*
     / p8 g, B1 |& y; f! x. J7 e
159. 158  * @description : platform驱动的remove函数，移除platform
     ) X: U% h) x4 T1 L3 ]* n" z3 x
160. 驱动的时候此函数会执行
     
161. 159  * @param - dev         : platform设备
     5 _2 G* L" i0 t+ |
162. 160  * @return         : 0，成功;其他负值,失败
     
163. 161  */
     * X" P( ^9 b0 ]. ]3 i& L
164. 162 static int led_remove(struct platform_device *dev)
     7 |3 R6 ?  _  h
165. 163 {
     9 {' P( S9 H2 H& F' U5 \& ~# `
166. 164         gpio_set_value(leddev.led0, 1);         /* 卸载驱动的时候关闭LED */
     & g7 T1 Z9 t! f3 g) H) |
167. 165
     , K' W/ Y( b6 i. c; h3 G
168. 166         cdev_del(&leddev.cdev);                         /*  删除cdev */
     - V8 e( i9 a& T7 ~) u8 i
169. 167         unregister_chrdev_region(leddev.devid, LEDDEV_CNT); /* 注销设备号 */
     ) V- F4 n0 X2 a# h
170. 168         device_destroy(leddev.class, leddev.devid);
     ( b8 G3 r8 k7 w! Y) ?
171. 169         class_destroy(leddev.class);
     
172. 170         return 0;
     8 g: J" z3 i4 I: \
173. 171 }
     , E- c9 m& s$ ^7 ?
174. 172
     & h$ P/ E: n7 C0 f# m9 A0 n
175. 173 /* 匹配列表 */
     
176. 174 static const struct of_device_id led_of_match[] = {
     ) A! [7 A2 y- h* \4 [
177. 175         { .compatible = "gpioled" },
     , f& _: {- B2 b% l0 |' A& M
178. 176         { /* Sentinel */ }
     
179. 177 };
     ! D7 n8 Q( Y- x$ f- y0 K
180. 178
     & O# Y6 R- t* ?
181. 179 /* platform驱动结构体 */
     
182. 180 static struct platform_driver led_driver = {
     
183. 181         .driver         = {
     6 @5 V# h% k- Z/ R
184. 182                 .name   = "imx6ul-led",     /* 驱动名字，用于和设备匹配 */
     
185. 183                 .of_match_table = led_of_match, /* 设备树匹配表 */
     $ |: ]1 l, b/ N$ k$ p0 X1 F
186. 184         },
     6 o) F, q, H! |/ l: _
187. 185         .probe          = led_probe,
     
188. 186         .remove         = led_remove,
     
189. 187 };
     , j9 r: }% n. O8 X( l1 d6 M
190. 188
     
191. 189 /*
       z9 j7 i( h1 S" ^4 m) R
192. 190  * @description : 驱动模块加载函数
     
193. 191  * @param               : 无
     
194. 192  * @return              : 无
     
195. 193  */
     ( w1 v9 H# u) `8 `% }& y
196. 194 static int __init leddriver_init(void)
     
197. 195 {
     ) q* @$ H  J2 Y2 G
198. 196         return platform_driver_register(&led_driver);
     
199. 197 }
     4 @6 o% U) F+ C0 }& H8 R' D6 X( `% ~
200. 198
     4 T! h: K4 l1 I: t% p0 K7 r
201. 199 /*
     
202. 200  * @description : 驱动模块卸载函数
     2 X( T, H6 P* v0 A  \
203. 201  * @param               : 无
     
204. 202  * @return              : 无
     
205. 203  */
     
206. 204 static void __exit leddriver_exit(void)
     
207. 205 {
     " q$ v, G1 M7 D2 l1 c
208. 206         platform_driver_unregister(&led_driver);
     
209. 207 }
     $ T1 S) ~8 S/ h; M& D, ?& R9 m
210. 208
     5 ~& \4 n4 U$ @5 u0 }8 r$ Z9 M
211. 209 module_init(leddriver_init);
     % S! V2 k% q8 U' Q) Y/ ?8 ~$ D  C
212. 210 module_exit(leddriver_exit);
     
213. 211 MODULE_LICENSE("GPL");
     
214. 212 MODULE_AUTHOR("topeet");
     5 A7 v: ]1 X( q9 u$ b/ E5 m" `- m

复制代码

5 ^% H9 }; t" _; i! y

第 174~177 行，匹配表，描述了此驱动都和什么样的设备匹配，第 175 行添加了一条值为"gpioled"的 compatible 属性值，当设备树中某个设备节点的 compatible 属性值也为 “gpioled”的时候就会与此驱动匹配。
第 180~187 行，platform_driver 驱动结构体，182 行设置这个 platform 驱动的名字为“imx6ul-led”，因此，当驱动加载成功以后就会在/sys/bus/platform/drivers/目录下存在一个名为“imx6u-led”的文件。 第 183 行设置 of_match_table 为上面的 led_of_match。

3 应用测试程序

应用测试程序直接使用上一章44.3.2的led_test.c即可。