输入子系统具体应用---ADC驱动

keytounix

gcc version 4.3.3 (Sourcery G++ Lite 2009q1-176)
文件系统： busybox 1.13.1+yaffs
开发板内核版本：linux2.6.32

效果图1 ：默认参数

效果图2：自定义参数

 

一.  代码

//adc.c

1. #include <linux/input.h>
   
2. #include <linux/module.h>
   
3. #include <linux/init.h>
   
4. #include <asm/irq.h>
   
5. #include <asm/io.h>
   
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/clk.h>
    
15. #include <linux/wait.h>//waitqueue
    
16. #include <linux/errno.h>
    
17. #include <linux/interrupt.h>//irq
    
18. #include <linux/io.h>
    
19. #include <linux/types.h>
    
20. #include <linux/delay.h>
    
21. #include <linux/semaphore.h>//sem
    
22. #include <linux/fs.h>
    
23. #include <linux/platform_device.h>//
    
24. #include <linux/miscdevice.h>
    
25. #include <linux/device.h>
    
26. #include <linux/workqueue.h>//workqueue
    
27. #include <asm/uaccess.h>
    
28. #include <asm/irq.h>
    
29. //soc相关
    
30. #include <mach/gpio.h>
    
31. #include <mach/regs-clock.h>
    
32. #include <mach/regs-gpio.h>
    
33. #include <mach/hardware.h>
    
34. #include <mach/irqs.h>
    
35. //IRQ_ADC
    
36. 
    
37. #include <plat/regs-adc.h>
    
38. //这个头文件，包含了ADC
    
39. 
    
40. #include <plat/map.h>
    
41. //取消调试信息，则只需要#define _DEBUG_ 0
    
42. #define DEV_NAME "adc_as_input"
    
43. #define DEV_PHYS "usr_adc/input0"
    
44. #define rADCCON (adc_base_addr)
    
45. #define rADCDATA (adc_base_addr +S3C2410_ADCDAT0)
    
46. char *adc_dev_name =DEV_NAME;
    
47. char *msg=NULL;
    
48. char *iok="ok";
    
49. char *ino="no";
    
50. 
    
51. //取消调试信息，则只需要
    
52. #define _DEBUG_ 0
    
53. #if _DEBUG_==1
    
54. #define debug(format,msg...) printk(format,##msg)
    
55. #else
    
56. #define debug(format,msg...) do{}while(0)
    
57. #endif
    
58. 
    
59. static struct input_dev *adc_dev=NULL;
    
60. unsigned int adc_ch =2;
    
61. //这个是通道选择,TQ2440上的AD 电阻接在AIN2上
    
62. unsigned int adc_pre=0xff;
    
63. //这个是预分频，我们设置他默认为0xff
    
64. unsigned int adc_rate =0;
    
65. //默认的分别率，意思时说 数据变化<adc_rate 则不上报
    
66. static struct clk *adc_clk=NULL;
    
67. //时钟，因为AD采样过程是需要时钟参与的，所以需要clk
    
68. static unsigned int volatile value=0;
    
69. //这个保存实时采样的值
    
70. static unsigned int volatile old_value=0;
    
71. //这个保存上一次采样后认定的值，所谓认定的值，是和实时的值相区别的
    
72. static void __iomem * adc_base_addr=NULL;
    
73. //这个，是为了端口 映射，ioremap操作，为啥？因为这是在linux中，有MMU功能的，不能直接操作端口
    
74. 
    
75. /*
    
76. 如下展示了 AD控制字寄存器
    
77. 15 14 13-6 5-3 2 1 0
    
78. ecflg prscen prscvl sel_mux stdbm read_start enable_start
    
79. 
    
80. ecflg： 0 AD转换中，1： ad转换结束
    
81. prscen： ：0 关闭 分频，1 ：使能分频
    
82. prscvl： 分频的值
    
83. sel_mux： 0-7 依次对应 0-7通道
    
84. stdbm： 0； 标准操作 1： 备用操作
    
85. read_start： 0 关闭 1 使能
    
86. enable_start：0 无操作 1 开始 转换
    
87. ad采样的时钟频率由ADCPSR决定
    
88. 加入CPU时钟频率 66M 完成一次转换至少需要16个时钟周期
    
89. 则采样频率如下
    
90.     f=66MHz/(2*(20+1))/16=98.2kHz=10.2us
    
91. 由于 2410内部没有 采样保持电路，
    
92. 因此信号的输入频率最好低于100HZ
    
93. */
    
94. /*
    
95. start_adc:
    
96. 以adc_con_value为控制字，开启ADC设备
    
97. 设置adc_con_value 的函数 为 set_adc
    
98. */
    
99. static unsigned int adc_con_value=0;
    
100. static int start_adc(void)
     
101. {
     
102.     //使用256分频|使用AIN2|使能ADC
     
103.     adc_con_value |= S3C2410_ADCCON_ENABLE_START;
     
104.     writel(adc_con_value,(rADCCON));
     
105.     debug("in %s,writel adc_con_value=%02x--------->[ok]\n",__func__,adc_con_value);
     
106.     return 0;
     
107. };
     
108. /*
     
109. set_adc(int ch,int prescale)
     
110. 设置adc_con_value；
     
111. ch:通道
     
112. prescale:分频
     
113. */
     
114. static int set_adc(int ch,int prescale)
     
115. {
     
116.     //使用adc_pre分频|使用adc_ch|使能ADC
     
117.     adc_con_value=0;
     
118.     
     
119.     //0111，1111，1101,0001
     
120.     adc_con_value |= S3C2410_ADCCON_PRSCEN |S3C2410_ADCCON_PRSCVL(prescale)|S3C2410_ADCCON_SELMUX(ch);
     
121.        debug("in %s,write temp=%02x--------->[ing]\n",__func__,adc_con_value);
     
122.     writel(adc_con_value,(rADCCON));
     
123.     debug("in %s,writel temp=%02x--------->[ok]\n",__func__,adc_con_value);
     
124. 
     
125.     return 0;
     
126. }
     
127. /*
     
128. run_adc:
     
129. 以ch,prescale参数运行set_adc
     
130. 并且启动adc
     
131. */
     
132. static int run_adc(int ch,int prescale)
     
133. {
     
134.     set_adc(ch,prescale) ;
     
135.     start_adc();
     
136.     return 0;
     
137. }
     
138. 
     
139. /*
     
140. irq_proc：中断处理函数
     
141. 流程是
     
142. 首先读取一次DATA0寄存器的值，存为value
     
143. 接着与上一次保存的值(old_value)比较，
     
144. if
     
145. 二者之间的差值在分别率 adc_rate内
     
146. 则上报EV_ABS事件，
     
147. 事件的值ev_var由3部分组成
     
148. 实时adc的值(0-9)
     
149. ad通道adc_ch的值(10-12)
     
150. 分别率的值adc_rate(13-15)，这个是我们自己添加的,意味着最大值为00000111=7
     
151. 分频值adc_pre(16-31)//,
     
152. 保存value到old_value
     
153. end if
     
154. 最后再次start adc
     
155. 注意这里我们没有采用中断的底半部机制，是有待提高的
     
156. 具体可以见按键驱动
     
157. */
     
158. static irqreturn_t irq_proc(int irq, void *dummy)
     
159. {
     
160.          value=readl(rADCDATA)&0x3ff;
     
161.     if(((old_value -value) >=adc_rate)||((value-old_value -value ) >=adc_rate))
     
162.      {
     
163.         value |= (adc_ch & 0x0f)<<10;
     
164.         value |=(adc_rate &0x0f)<<13;
     
165.         value |= (adc_pre & 0xff) << 16;
     
166.         input_report_abs(adc_dev, ABS_X,value);
     
167.         //AB_X代表的是 (value &0x03ff) | (ch << 10) | adc_rate <<13 |(pre <<16)
     
168.         debug("in %s,value=%02x\n",__func__,value);
     
169.         input_sync(adc_dev);
     
170.         old_value=value;
     
171.      }
     
172.         
     
173.     start_adc();
     
174.     
     
175.      return IRQ_RETVAL(IRQ_HANDLED);
     
176. }
     
177. 
     
178. /*
     
179. 这个是回调事件处理函数，作用是什么呢？
     
180. 一般来说我们感兴趣的信息方向是这样的
     
181. 用户程序<--....设备，即读取设备信息，比如读取按键信息，则按键信息主动上报给用户
     
182. 但是有些设备，我们需要给他一个信息，利用这个信息操作硬件，比如我们想给她一个LED控制信息
     
183. 让这个信息控制LED，就要用到这个函数了
     
184. type=EV_LED,
     
185. code=LED_NUML| LED_CAPSL|LED_SCROLLL| LED_COMPOSE|LED_KANA中的一个
     
186. var =xy这个是我们感兴趣的
     
187. //pre,rate,ch,var
     
188. //16，3，3，10
     
189. */
     
190. int adc_event(struct input_dev *dev, unsigned int type, unsigned int code, int var)
     
191. {
     
192.     if (type == EV_LED)
     
193.     {
     
194.         //AB_X代表的是 (value &0x03ff) | (ch << 10) | adc_rate <<13 |(pre <<16)
     
195.         adc_ch=(var >>10) &0x07;
     
196.         adc_rate =(var >>13) & 0x07;
     
197.         adc_pre=((unsigned int)var >>16) & 0xffff;
     
198.         if(adc_pre==0)
     
199.             adc_pre=1;
     
200.         debug("in %s->%s():%02x,%02x,%02x,%02x\n",__FILE__,__func__,adc_pre,adc_rate,adc_ch,var & 0x3ff);
     
201.         return 0;
     
202.     }
     
203.     return -1;
     
204. }
     
205. 
     
206. 
     
207. /*
     
208. adcinit过程如下
     
209. 1. input_allocate_device
     
210. 2. ioremap
     
211. 3. irq:request_irq
     
212. 4. clk:clk_get,clk_enable
     
213. 5. input_register_device
     
214. 6. run_adc
     
215. 其中 必须先进行ioremap,再进行request_irq，否则会出现oops错误
     
216. */
     
217. static int __init adc_init(void)
     
218. {
     
219.     int ret=0;
     
220. //申请 内存
     
221.     adc_dev = input_allocate_device();
     
222.     debug("%s: input_allocate_device() adc_dev=%p\n" ,__FILE__,adc_dev);
     
223.     if (adc_dev==NULL) {
     
224.         printk(KERN_ERR "%s: Not enough memory\n" ,__FILE__);
     
225.         return -ENOMEM;
     
226.         
     
227.     }
     
228.     debug("%s: input_allocate_device() adc_dev=%p\n" ,__FILE__,adc_dev);
     
229. //ioremap操作
     
230.     adc_base_addr=ioremap(S3C2410_PA_ADC,0x20);
     
231.     debug("in %s,ioremap VIR_adc_base_addr=%p--------->[%s]\n",__func__,adc_base_addr,adc_base_addr==NULL?ino:iok);
     
232.     if(adc_base_addr==NULL)
     
233.         {
     
234.             printk(KERN_ERR "%s:%s Can't ioremap %d\n", __FILE__,__func__,S3C2410_PA_ADC);
     
235.             ret =-EIO;
     
236.             goto err_free_dev;
     
237.         }
     
238.     
     
239. //free_irq最后一个参数必须和request_irq最后一个参数一致,都为adc_dev
     
240.     if (request_irq(IRQ_ADC,irq_proc, IRQF_SHARED|IRQF_SAMPLE_RANDOM, adc_dev_name, adc_dev)) {
     
241.                 printk(KERN_ERR "%s:%s: Can't allocate irq %d\n", __FILE__,__func__,IRQ_ADC);
     
242.                   ret = -EIO;
     
243.             goto err_free_map;
     
244.         }
     
245.     
     
246.     debug("%s: request_irq()\n" ,__FILE__);
     
247.        
     
248. //clk操作
     
249.     adc_clk = clk_get(NULL,"adc");
     
250. 
     
251.     if(adc_clk==NULL)
     
252.         {
     
253.         printk(KERN_ERR "%s:%s: Failed to clk_get\n",__FILE__,__func__);
     
254.             ret =-ENOENT;
     
255.             goto err_free_irq;
     
256.         };
     
257.     clk_enable(adc_clk);
     
258. 
     
259. //adc_dev相关的设置
     
260.     adc_dev->name=DEV_NAME;
     
261.     adc_dev->phys=DEV_PHYS;
     
262.     adc_dev->id.bustype=BUS_VIRTUAL;
     
263.     
     
264.     adc_dev->id.vendor=0x0001;
     
265.     adc_dev->id.product=0x0001;
     
266.     adc_dev->id.version=0x0001;
     
267.     
     
268.     adc_dev->event=adc_event;
     
269. //设置事件支持
     
270.         set_bit(EV_ABS ,adc_dev->evbit);
     
271.     set_bit(EV_LED,adc_dev->evbit);
     
272.     adc_dev->ledbit[0]=(LED_NUML| LED_CAPSL|LED_SCROLLL| LED_COMPOSE|LED_KANA);
     
273.     
     
274.     input_set_abs_params(adc_dev, ABS_X, 0, 0xFFFFFFFF, 1, 0);
     
275.     ////AB_X代表的是 (value &0x0fff) | (ch << 16) | adc_rate <<20 |(pre <<24)
     
276.     debug("%s:%s input_register_device()\n" ,__FILE__,__func__);
     
277.        ret = input_register_device(adc_dev);
     
278.     if (ret) {
     
279.         printk(KERN_ERR "%s:%s: Failed to register device\n",__FILE__,__func__);
     
280.         goto err_free_irq;
     
281.     }
     
282. //最后 run_adc
     
283.     run_adc(adc_ch,adc_pre);
     
284.     printk("%s->%s(),%s has init!\nadc_ch=0x%02x,adc_rate=0x%02x,adc_pre=0x%02x.\n",__FILE__,__func__,DEV_NAME,adc_ch,adc_rate,adc_pre);
     
285.        return 0;
     
286. err_free_irq:
     
287.         //Trying to free already-free IRQ 4
     
288.         // free_irq最后一个参数必须和request_irq最后一个参数一致
     
289.         //否则出现 Trying to free already-free IRQ 80错误
     
290.     
     
291.     free_irq(IRQ_ADC, adc_dev);
     
292.         
     
293. err_free_map:
     
294.      if(adc_base_addr!=NULL) iounmap(adc_base_addr);
     
295. err_free_dev:
     
296.     
     
297.     input_free_device(adc_dev);
     
298.     
     
299.     return ret;
     
300. }
     
301. 
     
302. 
     
303. /*
     
304. adc_exit过程
     
305. 1. input_unregister_device
     
306. 2. free_irq(IRQ_ADC, adc_dev);
     
307. 3. iounmap
     
308. 4. clk_disable;clk_put
     
309. 其中必须先free_irq再进行iounmap
     
310. */
     
311. static void __exit adc_exit(void)
     
312. {
     
313.         
     
314.     if(adc_dev!=NULL)
     
315.     {
     
316.         input_unregister_device(adc_dev);
     
317.         //Trying to free already-free IRQ 4
     
318.         // free_irq最后一个参数必须和request_irq最后一个参数一致
     
319.         //否则出现 Trying to free already-free IRQ 80错误
     
320.         free_irq(IRQ_ADC, adc_dev);
     
321.         
     
322.     }
     
323.     if(adc_base_addr!=NULL) iounmap(adc_base_addr);
     
324.     if(adc_clk!=NULL)
     
325.     {
     
326.             clk_disable(adc_clk);
     
327.             clk_put(adc_clk);
     
328.             adc_clk=NULL;
     
329.     }
     
330.     printk("%s->%s(),%s has exit!\n",__FILE__,__func__,DEV_NAME);
     
331. }
     
332. /*
     
333. 参考
     
334. http://blog.csdn.net/ralph_sqd/article/details/5933388
     
335. http://blog.csdn.net/wangyunqian6/article/details/6563921
     
336. */
     
337. module_param(adc_ch,int,0644);
     
338. MODULE_PARM_DESC(adc_ch,"set ad channel");
     
339. 
     
340. module_param(adc_pre,int,0644);
     
341. MODULE_PARM_DESC(adc_pre,"set adc prescale");
     
342. 
     
343. module_param(adc_rate,int,0644);
     
344. MODULE_PARM_DESC(adc_rate,"set adc's distinguishability");
     
345. 
     
346. MODULE_DESCRIPTION("driver adc for TQ2440");
     
347. 
     
348. MODULE_AUTHOR("keytounix");
     
349. MODULE_LICENSE("GPL");
     
350. module_init(adc_init);
     
351. module_exit(adc_exit);

二.  测试文件

1. //test.c
   
2. #include <string.h>
   
3. #include <stdio.h>
   
4. #include <sys/types.h>
   
5. #include <sys/stat.h>
   
6. #include <fcntl.h>
   
7. #include <linux/input.h>
   
8. #include <linux/uinput.h>
   
9. #include <stdio.h>
   
10. #include <sys/time.h>
    
11. #include <sys/types.h>
    
12. #include <unistd.h>
    
13. /*
    
14. #define EV_SYN 0x00
    
15.   
    
16. #define EV_KEY 0x01 //按键
    
17.   
    
18. #define EV_REL 0x02 //相对坐标(轨迹球)
    
19.   
    
20. #define EV_ABS 0x03 //绝对坐标
    
21.   
    
22. #define EV_MSC 0x04 //其他
    
23.   
    
24. #define EV_SW 0x05
    
25.   
    
26. #define EV_LED 0x11 //LED
    
27.   
    
28. #define EV_SND 0x12//声音
    
29.   
    
30. #define EV_REP 0x14//repeat
    
31.   
    
32. #define EV_FF 0x15
    
33.   
    
34. #define EV_PWR 0x16
    
35.   
    
36. #define EV_FF_STATUS 0x17
    
37.   
    
38. #define EV_MAX 0x1f
    
39.   
    
40. #define EV_CNT (EV_MAX+1)
    
41. struct input_event {
    
42.   
    
43. struct timeval time; //按键时间
    
44.   
    
45. __u16 type; //类型，在下面有定义
    
46.   
    
47. __u16 code; //要模拟成什么按键
    
48.   
    
49. __s32 value;//是按下还是释放
    
50.   
    
51. };
    
52. */
    
53. #ifdef DEBUG
    
54. #define debug(format,msg...) printf(format,##msg)
    
55. #else
    
56. #define debug(format,msg...) do{}while(0)
    
57. #endif
    
58. #define EVEN_NAME "/dev/event0"
    
59. 
    
60. int main(int argn,char * argv[])
    
61. {
    
62.     int fd;
    
63.     fd_set rfds;
    
64.     struct timeval tv;
    
65.     struct input_event event;
    
66.     unsigned int var=0;
    
67.     fd = open(EVEN_NAME,O_RDWR|O_NONBLOCK);
    
68.     if(fd<=0){
    
69.          printf("error open %s\n",EVEN_NAME);
    
70.          return -1;
    
71.          }
    
72.     int i = 1;
    
73.     while(1)
    
74.          {
    
75.     //轮寻 直到 fd 可读 或者 5s超时时间
    
76. 
    
77.     FD_ZERO(&rfds);
    
78.     FD_SET(fd, &rfds);
    
79.     tv.tv_sec = 5;
    
80.     tv.tv_usec = 0;
    
81.     select(fd+1, &rfds, NULL, NULL, &tv);
    
82.          
    
83.     /*AB_X事件格式
    
84.     (value &0x0fff) | (ch << 16) | adc_rate <<20 |(pre <<24)
    
85.     pre,rate,ch,var
    
86.     16，3，3，10
    
87.     */
    
88.     read(fd,&event,sizeof(struct input_event)) ;
    
89.     if(event.type==EV_ABS)
    
90.     {
    
91.     var=event.value;
    
92.      debug("in %s->%s():%02x,%02x,%02x，%02x\n",__FILE__,__func__,(var>>16)&0xffff,(var>>13)&0x07,(var>>10)&0x07,var & 0x03ff);
    
93.     }
    
94.     sleep(1);
    
95.     
    
96.     /*
    
97.         如下 是 操作 LED事件的
    
98.     */
    
99. if(event.type!=EV_SYN)
    
100.     {
     
101.     event.type = EV_LED;
     
102.     i++;
     
103.     i%=0xff;
     
104.     event.value = event.value &(~0x3ff);
     
105.     event.code = 0;
     
106.     gettimeofday(&event.time,0);
     
107.     write(fd,&event,sizeof(event));
     
108.     }
     
109. }
     
110.     close(fd);
     
111. }

三.  Makefile

A=arm-linux-ar
ARCH=arm
CC=arm-linux-gcc
TESTFILE=test.c
MYFLAGS= -DDEBUG -g
obj-m:=adc.o
    KDIR=/opt/linux/kernel/linux-2.6.32
all:
    $(MAKE)  -C $(KDIR) M=$(PWD)  modules
    $(CC) $(TESTFILE)  $(MYFLAGS) -o test

clean:
    rm -f *.mod.c *.mod.o *.ko *.o *.tmp_versions Module.symvers modules.order test