TQ2440LED驱动

keytounix

这篇文档重在记述TQ2440的LED驱动，重点在于将LED作为混杂设备注册的方法

即 misc_register(&dev)和misc_deregister(&register)

这篇文档所基于的环境如下

硬件环境：TQ2440开发板

kernel :linux 2.6.32

文件系统: busybox1.13.1，yaffs2

效果图如下

 

一、code

 

1. /*
   
2. name: leds driver for tq2660
   
3. author :keytounix
   
4. as char devices
   
5. */
   
6. #include <linux/module.h>
   
7. #include <linux/kernel.h>
   
8. #include <linux/init.h>
   
9. #include <linux/sched.h>
   
10. #include <linux/poll.h>
    
11. #include <linux/timer.h>
    
12. #include <linux/irq.h>
    
13. #include <linux/cdev.h>
    
14. #include <linux/wait.h>//waitqueue
    
15. 
    
16. #include <linux/errno.h>
    
17. #include <linux/interrupt.h>//irq
    
18. 
    
19. #include <linux/io.h>
    
20. #include <linux/types.h>
    
21. #include <linux/delay.h>
    
22. #include <linux/semaphore.h>//sem
    
23. 
    
24. #include <linux/fs.h>
    
25. #include <linux/platform_device.h>//
    
26. 
    
27. #include <linux/miscdevice.h>
    
28. 
    
29. #include <linux/device.h>
    
30. #include <linux/workqueue.h>//workqueue
    
31. 
    
32. 
    
33. #include <asm/uaccess.h>
    
34. #include <asm/irq.h>
    
35. 
    
36. //soc相关
    
37. 
    
38. 
    
39. #include <mach/gpio.h>
    
40. #include <mach/regs-clock.h>
    
41. #include <mach/regs-gpio.h>
    
42. #include <mach/hardware.h>
    
43. #include <mach/irqs.h>
    
44. 
    
45. 
    
46. #define led_name "usr_leds"
    
47. #define LED_NAME "usr_leds"
    
48. 
    
49. //这个，是为了实现
    
50. 
    
51. //任何时刻只能有一个
    
52. 
    
53. //使用者能操作led
    
54. 
    
55. struct semaphore sem[4];
    
56. //打开
    
57. 
    
58. static int led_open0(struct inode *nodep,struct file * filep);
    
59. static int led_open1(struct inode *nodep,struct file * filep);
    
60. static int led_open2(struct inode *nodep,struct file * filep);
    
61. static int led_open3(struct inode *nodep,struct file * filep);
    
62. //关闭
    
63. 
    
64. static int led_release(struct inode *nodep,struct file * filep);
    
65. //ioctrl函数
    
66. 
    
67. static int led_ioctl(struct inode *nodep,struct file * filep,unsigned int cmd,long args);
    
68. //写数据
    
69. 
    
70. static int led_write(struct file * filep,char * __user buff,size_t count, loff_t *offt);
    
71. //这个函数用来实现对led的读写
    
72. 
    
73. 
    
74. 
    
75. 
    
76. static void led_display(int ledno,int status);
    
77. 
    
78. struct file_operations fops[]=
    
79. {
    
80. [0]={
    
81. .owner=THIS_MODULE,
    
82. .open=    led_open0,
    
83. .release=led_release,
    
84. .write =led_write,
    
85. .ioctl=led_ioctl,
    
86. },
    
87. [1]=
    
88. {
    
89. .owner=THIS_MODULE,
    
90. .open=led_open1,
    
91. .release=led_release,
    
92. .write =led_write,
    
93. .ioctl=led_ioctl,
    
94. },
    
95. [2]=
    
96. {
    
97. .owner=THIS_MODULE,
    
98. .open=led_open2,
    
99. .release=led_release,
    
100. .write =led_write,
     
101. .ioctl=led_ioctl,
     
102. },
     
103. [3]=
     
104. {
     
105. .owner=THIS_MODULE,
     
106. .open=led_open3,
     
107. .release=led_release,
     
108. .write =led_write,
     
109. .ioctl=led_ioctl,
     
110. },
     
111. 
     
112. };
     
113. struct LED_INFO
     
114. {
     
115. char * name;
     
116. unsigned pin;
     
117. }led_info[]=
     
118. {
     
119. [0]={
     
120. .name="led1",
     
121. .pin=S3C2410_GPB(5)
     
122. },
     
123. [1]={
     
124. .name="led2",
     
125. .pin=S3C2410_GPB(6)
     
126. },
     
127. [2]={
     
128. .name="led3",
     
129. .pin=S3C2410_GPB(7)
     
130. },
     
131. [3]={
     
132. .name="led4",
     
133. .pin=S3C2410_GPB(8)
     
134. }
     
135. };
     
136. 
     
137. static struct miscdevice led_dev[]=
     
138. {
     
139. [0]=
     
140. {
     
141. .minor =MISC_DYNAMIC_MINOR,
     
142. .name ="led0",
     
143. .fops =&fops[0]    
     
144. },
     
145. [1]=
     
146. {
     
147. .minor =MISC_DYNAMIC_MINOR,
     
148. .name ="led1",
     
149. .fops=&fops[1]
     
150. },
     
151. [2]=
     
152. {
     
153. .minor=MISC_DYNAMIC_MINOR,
     
154. .name ="led2",
     
155. .fops =&fops[2]
     
156. },
     
157. [3]=
     
158. {
     
159. .minor=MISC_DYNAMIC_MINOR,
     
160. .name ="led3",
     
161. .fops=&fops[3]
     
162. }
     
163. };
     
164. 
     
165. 
     
166. #define LED_ON 0
     
167. #define LED_OFF 1
     
168. #define pin(x) led_info[x].pin
     
169. 
     
170. 
     
171. #define _DEBUG_ 1
     
172. 
     
173. 
     
174. #if _DEBUG_
     
175. 
     
176. #define debug(format,msg...) printk(format,##msg)
     
177. 
     
178. #else
     
179. 
     
180. #define debug(format,msg...) (void *)(0)
     
181. 
     
182. #endif
     
183. #define dbgi(name,i) debug("in %s ,%s is %d\n",__func__,name,i)
     
184. 
     
185. //打开函数，这个 函数里面我们需要获得sem
     
186. 
     
187. static int led_open0(struct inode * nodep,struct file *filep)
     
188. {
     
189.     down(&sem[0]);
     
190.     dbgi("filep->private_data",0);
     
191.     filep->private_data=0;
     
192.     return 0;
     
193. }
     
194. static int led_open1(struct inode * nodep,struct file *filep)
     
195. {
     
196.     down(&sem[1]);
     
197.     dbgi("filep->private_data",1);
     
198.     filep->private_data=1;
     
199.     return 0;
     
200. }
     
201. static int led_open2(struct inode * nodep,struct file *filep)
     
202. {
     
203.     down(&sem[2]);
     
204.     dbgi("filep->private_data",2);
     
205.     filep->private_data=2;
     
206.     return 0;
     
207. }
     
208. static int led_open3(struct inode * nodep,struct file *filep)
     
209. {
     
210.     down(&sem[3]);
     
211.     dbgi("filep->private_data",3);
     
212.     filep->private_data=3;
     
213.     return 0;
     
214. }
     
215. 
     
216. //关闭函数
     
217. 
     
218. static int led_release(struct inode *nodep,struct file *filep)
     
219. {
     
220.     int i=filep->private_data;
     
221.     dbgi("filep->private_data",i);
     
222.     i=(i<=3 && i>=0?i:0);
     
223.     up(&sem[i]);
     
224.     return 0;
     
225. }
     
226. 
     
227. 
     
228. //ioctrl函数
     
229. 
     
230. static int led_ioctl(struct inode * nodep,struct file *filep,unsigned int cmd ,long args)
     
231. {
     
232.     return 0;
     
233. }
     
234. 
     
235. static void led_display(int ledno,int status)
     
236. {
     
237. s3c2410_gpio_setpin(pin(ledno),status);    
     
238. debug("in %s,ledno=%d,ledstatus=%d\n",__func__,ledno,status);
     
239.     return;
     
240. }
     
241. //
     
242. 
     
243. static int led_write(struct file * filep,char * __user buff,size_t count, loff_t *offt)
     
244. {
     
245.     int i=filep->private_data;
     
246.     
     
247.     char led_status[6];
     
248.     int cmd;
     
249.     dbgi("before i =(i<=3 && i>=0 ? i: 0),i=",i);
     
250.     i =(i<=3 && i>=0 ? i: 0);
     
251.     dbgi("after i =(i<=3 && i>=0 ? i: 0),i=",i);
     
252.     copy_from_user(led_status,buff,count);
     
253.     if(led_status[0]=='1' || led_status[0]==1)
     
254.         cmd=LED_ON;
     
255.     else
     
256.         cmd=LED_OFF;
     
257.         
     
258.         led_display(i,cmd);
     
259.     return 0;
     
260. }
     
261. 
     
262. ////
     
263. 
     
264. static void __init led_init()
     
265. {
     
266. 
     
267.     int i=4;
     
268.        for(i=0;i<=3;i++)
     
269.        {
     
270.     misc_register(&led_dev[i]);
     
271.     init_MUTEX(&sem[i]);
     
272.     }
     
273. }
     
274. static void __exit led_exit()
     
275. {    int i=4;
     
276.     for(i=0;i<=3;i++)
     
277.     misc_deregister(&led_dev[i]);
     
278. }
     
279. 
     
280. MODULE_AUTHOR("keytounix");
     
281. MODULE_LICENSE("GPL");
     
282. MODULE_DESCRIPTION("driver leds for TQ2440");
     
283. module_init(led_init);
     
284. module_exit(led_exit);

 

二、Makefile

 

1. TARGET=led
3. KERNEL=2.6.32
5. CC=arm-linux-gcc -w
7. obj-m :=$(TARGET).o
9. KERNELDIR :=/kernel/linux-$(KERNEL)
13. default:
15. make -C $(KERNELDIR) M=$(shell pwd) modules

 

三、test code

 

1. //arm-linux-gcc -marcharmv4t t.c -o t
   
2. 
   
3. //#insmod led.ko
   
4. 
   
5. //#mdev -s
   
6. 
   
7. //#./t /dev/ledx 1or0
   
8. 
   
9. #include <stdio.h>
   
10. #include <stdlib.h>
    
11. #include <fcntl.h>
    
12. #include <unistd.h>
    
13. int main(int argn,char*argv[])
    
14. {
    
15. int fd=open(argv[1],O_WRONLY,0640);
    
16. int w_size=write(fd,argv[2],sizeof(argv[2]));
    
17. close(fd);
    
18. return 0;
    
19. }