TQ2440adc驱动1-作为简单的字符设备

keytounix

一、环境描述及效果展示

硬件环境:TQ2440开发板

内核版本:linux-2.6.32

文件系统:busybox-1.13.1

交叉工具:arm-2009q1,codesource出品

效果如下

 

 

二、code

//ad.c TQ2440,
1. #include <linux/module.h>
   
2. #include <linux/kernel.h>
   
3. #include <linux/init.h>
   
4. #include <linux/sched.h>
   
5. #include <linux/poll.h>
   
6. #include <linux/timer.h>
   
7. #include <linux/irq.h>
   
8. #include <linux/cdev.h>
   
9. #include <linux/clk.h>
   
10. #include <linux/wait.h>//waitqueue
    
11. #include <linux/errno.h>
    
12. #include <linux/interrupt.h>//irq
    
13. #include <linux/io.h>
    
14. #include <linux/types.h>
    
15. #include <linux/delay.h>
    
16. #include <linux/semaphore.h>//sem
    
17. #include <linux/fs.h>
    
18. #include <linux/platform_device.h>//
    
19. #include <linux/miscdevice.h>
    
20. 
    
21. #include <linux/device.h>
    
22. #include <linux/workqueue.h>//workqueue
    
23. 
    
24. #include <asm/uaccess.h>
    
25. #include <asm/irq.h>
    
26. 
    
27. //soc相关
    
28. 
    
29. #include <mach/gpio.h>
    
30. #include <mach/regs-clock.h>
    
31. #include <mach/regs-gpio.h>
    
32. #include <mach/hardware.h>
    
33. #include <mach/irqs.h>//IRQ_ADC
    
34. 
    
35. 
    
36. #include <plat/regs-adc.h>//这个头文件，包含了ADC
    
37. 
    
38. 
    
39. #include <plat/map.h>
    
40. //取消调试信息，则只需要#define _DEBUG_ 0
    
41. #define _DEBUG_ 1
    
42. #define DEV_NAME "usr_adc"
    
43. 
    
44. 
    
45. #if _DEBUG_
    
46. #define debug(format,msg...) printk(format,##msg)
    
47. #else
    
48. #define debug(format,msg...) (void *)(0)
    
49. #endif
    
50. 
    
51. char * iok="ok";
    
52. char *ino="no";
    
53. char * msg;
    
54. 
    
55. //ADCCON
    
56. static void __iomem * VIR_ADC_BASE;
    
57. #define base_addr VIR_ADC_BASE
    
58. //clk
    
59. static struct clk *adc_clk;
    
60. 
    
61. //这个值是全局变量，是用来存放采样值
    
62. unsigned short volatile value;
    
63. 
    
64. //这个值用来标识转换完成
    
65. unsigned int volatile end_of_conv;
    
66. 
    
67. DECLARE_WAIT_QUEUE_HEAD(wq);
    
68. DECLARE_MUTEX(lock);
    
69. 
    
70. struct
    
71. {
    
72. int ch;
    
73. int prescale;    
    
74. }adc_dev;
    
75. 
    
76. 
    
77. //相关头文件plat/regs-adc.h
    
78. //下面开始书写启动ADC的函数
    
79. //这个函数很关键
    
80. /*
    
81. 15            14                13-6            5-3                 2                1             0
    
82. ecflg prscen prscvl sel_mux stdbm read_start enable_start
    
83. */
    
84. static int start_adc(int ch,int prescale)
    
85. {
    
86.     //使用256分频|使用AIN2|使能ADC
    
87. 
    
88.     unsigned int temp=0;
    
89.     //0111，1111，1101,0001
    
90.     temp |= S3C2410_ADCCON_PRSCEN |S3C2410_ADCCON_PRSCVL(prescale)|S3C2410_ADCCON_SELMUX(ch);
    
91.     debug("in %s,writel temp=%02x--------->[ok]\n",__func__,temp);    
    
92. 
    
93. 
    
94.     writel(temp,(VIR_ADC_BASE+S3C2410_ADCCON));
    
95.      debug("in %s,writel temp=%02x--------->[ok]\n",__func__,temp);
    
96. 
    
97. 
    
98.     temp |= S3C2410_ADCCON_ENABLE_START;
    
99.     writel(temp,(VIR_ADC_BASE+S3C2410_ADCCON));
    
100.      debug("in %s,writel temp=%02x--------->[ok]\n",__func__,temp);
     
101. 
     
102.     return 0;
     
103. }
     
104. 
     
105. //irq proc
     
106. //ADC中断处理程序
     
107. static irqreturn_t irq_proc(int irq, void *dev_id)
     
108. {
     
109.     value=readl(VIR_ADC_BASE +S3C2410_ADCDAT0)&0x3ff;
     
110.     end_of_conv=1;
     
111.     
     
112.     
     
113.     debug("in %s,readl,value=%d\n",__func__,value);    
     
114.     wake_up_interruptible(&wq);
     
115.     
     
116.     
     
117.     debug("in %s,readl,avale=%d\n",__func__,value);    
     
118.     return IRQ_RETVAL(IRQ_HANDLED);
     
119. }
     
120. 
     
121. 
     
122. //打开设备
     
123. static int dev_open(struct inode *nodep,struct file *filep)
     
124. {
     
125.     
     
126.     int ret=0;
     
127.     if(down_trylock(&lock))
     
128.         {
     
129.             ret= -EBUSY;
     
130.             goto out;    
     
131.         }
     
132.     
     
133.     
     
134.     //value初始化为0或者初始化为0xff
     
135.     //end_of_conv结束标志初始化为0
     
136.     //初始化AD通道为2.分频0xff
     
137.     value=0x0000;
     
138.     end_of_conv=0;
     
139.     adc_dev.ch=2;
     
140.     adc_dev.prescale=0xff;
     
141.     
     
142.     //进行 ioremap
     
143.     
     
144.     VIR_ADC_BASE =ioremap(S3C2410_PA_ADC,0x20);
     
145.     msg=(VIR_ADC_BASE==NULL ? iok : ino);
     
146.     debug("in %s,ioremap VIR_ADC_BASE=%p--------->[%s]\n",__func__,VIR_ADC_BASE,msg);
     
147.     if(VIR_ADC_BASE==NULL)
     
148.         {
     
149.             ret =-ENOMEM;    
     
150.             goto out;
     
151.         }
     
152.         
     
153.         
     
154.     //writel(0,base_addr+S3C2410_ADCTSC);
     
155.     ret=request_irq(IRQ_ADC,irq_proc,IRQF_SHARED,DEV_NAME,&adc_dev);
     
156.     msg=(ret==0 ? iok : ino);
     
157.     debug("in %s,request_irq--------->[%s]\n",__func__,msg);
     
158.     if (ret)
     
159.         goto out;
     
160.         
     
161.         
     
162.             
     
163.     //获得时钟源plat-s3c/clock.c
     
164.     adc_clk = clk_get(NULL,"adc");
     
165.     msg=(adc_clk==NULL ? iok : ino);
     
166.     debug("in %s,clk_get--------->[%s]\n",__func__,msg);
     
167.     if(adc_clk==NULL)
     
168.         {
     
169.             
     
170.             ret =-ENOENT;    
     
171.             goto out;
     
172.         };
     
173.      clk_enable(adc_clk);    
     
174.         
     
175.         
     
176. out:        
     
177.     return ret;
     
178. }
     
179. 
     
180. 
     
181. //read
     
182. static int dev_read(struct file* filep,char * buf, ssize_t count,loff_t *ops)
     
183. {
     
184.     int ret=0;;
     
185.                 
     
186.             /*
     
187.             注意这个结构
     
188.             if(end_of_conv==0){}
     
189.             else{}
     
190.             为什么会有这个结构?
     
191.             
     
192.          考虑应用程序的结构
     
193.             int fd=open();
     
194.          ...............
     
195.          do{
     
196.                   ...
     
197.                   i=read();
     
198.                  ...
     
199.                   }while(i>0);
     
200.          close(fd);
     
201.             
     
202.              ...............
     
203.             
     
204.             //如果数据转换完成，
     
205.             //则啥也不做直接进入下一步
     
206.             
     
207.             }
     
208.      put_user(value,buf);
     
209.      不能用这个，那样返回的数据是不正确的
     
210.      */
     
211.     
     
212.     if(end_of_conv==0)
     
213.         {
     
214.         start_adc(adc_dev.ch,adc_dev.prescale);
     
215.             //非阻塞读
     
216.          if(filep->f_flags & O_NONBLOCK)
     
217.                  {
     
218.                      ret=-EAGAIN;
     
219.                      debug("in %s,filep->f_flags & O_NONBLOCK------>[return]\n",__func__);
     
220.                      goto out;    
     
221.                  }
     
222.              else//阻塞读
     
223.                  {
     
224.                  debug("in %s,wait_event end_of_conv=1------------->[start]\n",__func__);
     
225.                  //等待事件end_of_conv==1，或者等待2s，
     
226.                  wait_event_interruptible_timeout(wq,end_of_conv==1,200);
     
227.                  debug("in %s,finish wait_event end_of_conv=1------------->[finish]\n",__func__);
     
228.                  }
     
229.             
     
230.         }
     
231.         else
     
232.             {}
     
233. 
     
234.         copy_to_user(buf,(char *)&value,sizeof(value));
     
235.         end_of_conv=0;
     
236.         value=0;
     
237.     out:    
     
238.         return ret;
     
239.         
     
240.         
     
241. }
     
242. 
     
243. 
     
244. 
     
245. //dev_release
     
246. static int dev_release(struct inode *nodep,struct file *filep)
     
247. {
     
248.     free_irq(IRQ_ADC,&adc_dev);    
     
249.     
     
250.     //释放ioremap
     
251.     VIR_ADC_BASE==NULL? 0 : iounmap(VIR_ADC_BASE);
     
252.     
     
253.     
     
254.     //释放adc_clk
     
255.     if(adc_clk!=NULL)
     
256.         {
     
257.             clk_disable(adc_clk);
     
258.             clk_put(adc_clk);
     
259.             adc_clk=NULL;    
     
260.         }
     
261.     up(&lock);    
     
262.         return 0;
     
263. }
     
264. static int dev_write(struct file* filep,char * buf, ssize_t count,loff_t *ops)
     
265. {
     
266.     debug("\nsorry,this dev can't be write\n");
     
267.     return 0;
     
268. }
     
269. 
     
270. 
     
271. 
     
272. //字符设备关键结构体
     
273. struct file_operations file_ops=
     
274. {
     
275. .owner    =THIS_MODULE,
     
276. .open     = dev_open,
     
277. .read        =dev_read,
     
278. .write    =dev_write,
     
279. .release =dev_release,
     
280. };
     
281. 
     
282. 
     
283. 
     
284. //我们将这个注册为混杂设备
     
285. struct miscdevice adc_fops=
     
286. {
     
287. .minor =MISC_DYNAMIC_MINOR,
     
288. .name =DEV_NAME,
     
289. .fops= &file_ops,    
     
290. 
     
291. };
     
292. 
     
293. //dev_init
     
294. 
     
295. static __init int dev_init(void)
     
296. {
     
297. 
     
298.     int ret;
     
299.     ret=misc_register(&adc_fops);
     
300.        msg=(ret==0?iok : ino);
     
301.        debug("in %s,misc_register--------->[%s]\n",__func__,msg);
     
302.        return ret;
     
303. 
     
304. }
     
305. 
     
306. 
     
307. 
     
308. //dev_exit
     
309. 
     
310. static __exit int dev_exit(void)
     
311. {
     
312. 
     
313.     int ret;
     
314.     ret=misc_deregister(&adc_fops);
     
315.        msg=(ret==0?iok : ino);
     
316.        debug("in %s,misc_deregister--------->[%s]\n",__func__,msg);
     
317.        return ret;
     
318. 
     
319. }
     
320. 
     
321. 
     
322. MODULE_AUTHOR("keytounix");
     
323. MODULE_LICENSE("GPL");
     
324. MODULE_DESCRIPTION("driver adc for TQ2440");
     
325. module_init(dev_init);
     
326. module_exit(dev_exit);

三、 Makefile

 

1. TARGET=ad
   
2. #这个对应ad.c
   
3. #ad.c是上面那个驱动文件
   
4. #生成目标文件ad.ko
   
5. 
   
6. #-W是显示警告信息
   
7. #-w不显示警告信息
   
8. CC=arm-linux-gcc -w
   
9. 
   
10. #ad.ko
    
11. obj-m :=$(TARGET).o
    
12. 
    
13. #这个是内核路径
    
14. KERNELDIR :=/home/kernel/linux-2.6.32
    
15. 
    
16. default:
    
17.     make -C $(KERNELDIR) M=$(shell pwd) modules
    
18. 
    
19. clean:
    
20.     rm -rf module* *.symvers $(TARGET).o $(TARGET).mod.c $(TARGET).mod.o $(TARGET).ko $(TARGET).tmp_versions

四 、测试应用程序read

//read.c
1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <errno.h>
   
4. #include <fcntl.h>
   
5. 
   
6. int main(int argc, char *argv[])
   
7. {
   
8.     int fd;
   
9.     if(argc==1)
   
10.     {
11.      //./test 设备名 是否阻塞读取 是否循环读取
    
12.     printf("./test /dev/usr_adc 1 1\n");
    
13.     printf("./test dev_name BLOCK LOOP\n");
    
14.     return 0;
    
15.     }
    
16.     //以阻塞方式打开设备文件，非阻塞时flags=O_NONBLOCK
    
17.     if(argc==3 && argv[2][0]=='0')
    
18.     fd = open(argv[1], O_NONBLOCK|O_RDWR);
    
19.     else
    
20.         fd = open(argv[1], 0|O_RDWR);
    
21.      
    
22.     if(fd < 0)
    
23.     {
    
24.         printf("Open %s Device Faild!\n",argv[1]);
    
25.         exit(1);
    
26.     }
    
27.     else
    
28.         {
    
29.         printf("open %s ok\n",argv[1])    ;
    
30.         }
    
31. 
    
32.     
    
33.     
    
34.         int ret;
    
35.         int data;
    
36.         
    
37.     do
    
38.     {
    
39.     ret = read(fd, &data, sizeof(data));
    
40. 
    
41.        printf("Read %s value is: %d\n", argv[1],data);
    
42.        }while(argc==4 && argv[3][0]=='1');
    
43. 
    
44.     close(fd);
    
45. 
    
46.     return 0;
    
47. }
48. //arm-linux-gcc -march=armv4t read.c -o read
49. //使用方法 #./read /dev/usr_adc 1 0