按键驱动(异步通知方式)在FL2440的开发(2.6.33.7内核)

iletlet

一、开发环境

    主   机：fedora 14 (2.6.33.7)
    开发板：FL2440(nandflash:K9F1G08 128m)
    编译器：arm-linux-gcc 4.3.2

 

二、原理分析

    具体原来见《按键驱动(轮询方式)在FL2440的开发(2.6.33.7内核)》，这里不再重复。

    结合阻塞与非阻塞访问、poll 函数可以较好地解决设备的读写，但是如果有了异步通知就更方便了。异步通知的意思是：一旦设备就绪，则主动通知应用程序，这样应用程序根本就不需要查询设备状态，这一点非常类似于硬件上“中断”地概念，比较准确的称谓是“信号驱动(SIGIO)的异步I/O”。

 

三、实现步骤

    1. 编写按键驱动代码，取名为fl2440_keys.c

1. #include <linux/kernel.h>
   
2. #include <linux/module.h>
   
3. #include <linux/init.h>
   
4. #include <linux/fs.h>
   
5. #include <linux/wait.h>
   
6. #include <linux/sched.h>
   
7. #include <linux/semaphore.h>
   
8. #include <linux/interrupt.h>
   
9. #include <linux/irq.h>
   
10. #include <linux/device.h>
    
11. 
    
12. #include <mach/regs-gpio.h>
    
13. #include <mach/irqs.h>
    
14. #include <mach/gpio-nrs.h>
    
15. #include <mach/gpio-fns.h>
    
16. 
    
17. #include <asm/irq.h>
    
18. #include <asm/uaccess.h>
    
19. #include <asm/signal.h>
    
20. 
    
21. #define DEVICE_MAJOR    0                //主设备号，0表示动态分配
    
22. #define DEVICE_NAME        "fl2440_keys"    //设备名
    
23. 
    
24. 
    
25. #define KEY_DOWN        0    //按键按下
    
26. #define KEY_UP            1    //按键抬起
    
27. #define KEY_UNCERTAIN    2    //按键不确定
    
28. #define KEY_COUNT        4    //4个按键
    
29. 
    
30. #define KEY_TIMER_DELAY1    (HZ/50)    //按键按下去抖延时20毫秒
    
31. #define KEY_TIMER_DELAY2    (HZ/10)    //按键按下去抖延时100毫秒
    
32. 
    
33. static volatile int key_status[KEY_COUNT];        //记录4个按键的状态
    
34. static struct timer_list key_timers[KEY_COUNT];    //4个按键去抖动定时器
    
35. static volatile int ev_press = 0;                //按键按下产生标识，用于在读设备的时候来判断是否有数据可读
    
36. 
    
37. static struct class *keys_class;                //声明一个按键类
    
38. static struct fasync_struct *fasync_queue;        //声明一个异步队列
    
39. static struct semaphore sem;                    //声明一个信号量，用于对按键状态读取的并发控制
    
40. static spinlock_t spin = SPIN_LOCK_UNLOCKED;    //声明一个自旋锁，用于对按键设备打开的并发控制
    
41. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);    //等待队列的定义并初始化
    
42. 
    
43. static int major = DEVICE_MAJOR;                //major用于保存动态申请成功后返回的主设备号
    
44. static int g_count = 0;                            //设备打开计数，同一个时间只允许一个用户打开设备
    
45. 
    
46. //硬件设备资源结构体
    
47. struct key_irq_desc
    
48. {
    
49.     int irq;            //中断号
    
50.     int pin;            //对应的IO引脚
    
51.     int pin_setting;    //引脚配置
    
52.     char *name;            //按键名称，注意这个名称，在后面一个现象中会出现
    
53. };
    
54. 
    
55. //定义4个按键资源结构体数组
    
56. static struct key_irq_desc key_irqs[] =
    
57. {
    
58.     {IRQ_EINT0,S3C2410_GPF(0),S3C2410_GPF0_EINT0,"KEY0"},
    
59.     {IRQ_EINT2,S3C2410_GPF(2),S3C2410_GPF2_EINT2,"KEY1"},
    
60.     {IRQ_EINT3,S3C2410_GPF(3),S3C2410_GPF3_EINT3,"KEY2"},
    
61.     {IRQ_EINT4,S3C2410_GPF(4),S3C2410_GPF4_EINT4,"KEY3"},
    
62. };
    
63. 
    
64. /*
    
65.  *按键按下产生中断的处理函数
    
66.  *
    
67.  *按键按下产生中断，首先判断按键的状态，如果处于抬起状态，则标志状态为不确定，
    
68.  *然后延时避免抖动，再启动按键对应的定时器，用于判断按键是否真的按下
    
69.  */
    
70. static irqreturn_t keys_interrupt(int irq, void *dev_id)
    
71. {
    
72.     int key = (int)dev_id;
    
73.     
    
74.     if(key_status[key] == KEY_UP)
    
75.     {
    
76.         key_status[key] = KEY_UNCERTAIN;
    
77.         
    
78.         key_timers[key].expires = jiffies + KEY_TIMER_DELAY1;
    
79.         add_timer(&key_timers[key]);
    
80.     }    
    
81.     return IRQ_RETVAL(IRQ_HANDLED);
    
82. }
    
83. 
    
84. //定时器处理函数，由按键中断调用，用于判断按键是否真的按下
    
85. static void keys_timer(unsigned long arg)
    
86. {
    
87.     //获取当前按键资源的索引
    
88.     int key = arg;
    
89.     
    
90.     //获取当前按键上的电平值来判断按键是按下还是抬起
    
91.     int up = s3c2410_gpio_getpin(key_irqs[key].pin);
    
92.     
    
93.     if(!up)    //低电平，按键按下
    
94.     {
    
95.         if(key_status[key] == KEY_UNCERTAIN)
    
96.         {
    
97.             //标识当前按键状态为按下
    
98.             key_status[key] = KEY_DOWN;
    
99.             
    
100.             //标识当前按键已按下并唤醒等待队列让设备进行读取
     
101.             ev_press = 1;
     
102.             
     
103.             //调用kill_fasync向用户释放SIGIO信号，与用户空间的signal对应
     
104.             if(fasync_queue)
     
105.                 kill_fasync(&fasync_queue, SIGIO, POLL_IN);
     
106.         }
     
107.         
     
108.         //设置当前按键抬起去抖动定时器的延时并启动定时器
     
109.         key_timers[key].expires = jiffies + KEY_TIMER_DELAY2;
     
110.         add_timer(&key_timers[key]);
     
111.     }
     
112.     else    //高电平，按键抬起
     
113.     {
     
114.         //标识当前按键状态为抬起
     
115.         key_status[key] = KEY_UP;
     
116.     }    
     
117.     
     
118. }
     
119. 
     
120. //按键设备打开函数
     
121. static int keys_open(struct inode *inode, struct file *filp)
     
122. {
     
123.     int i, ret;
     
124. 
     
125.     //自旋锁和g_count用于确保设备不能同时打开多次
     
126.     spin_lock(&spin);
     
127.     
     
128.     //如果设备已经被打开，则释放自旋锁并返回
     
129.     if(g_count)
     
130.     {
     
131.         spin_unlock(&spin);
     
132.         return -EBUSY;
     
133.     }
     
134. 
     
135.     for(i=0; i<KEY_COUNT; i++)
     
136.     {
     
137.         //设置GPF0 2 3 4为中断模式
     
138.         s3c2410_gpio_cfgpin(key_irqs[i].pin, key_irqs[i].pin_setting);
     
139.         
     
140.         //设置中断类型为下降沿有效
     
141.         set_irq_type(key_irqs[i].irq, IRQ_TYPE_EDGE_FALLING);
     
142.         
     
143.         //向系统申请中断
     
144.         ret = request_irq(key_irqs[i].irq, keys_interrupt, IRQ_DISABLED,key_irqs[i].name, (void *)i);
     
145.         
     
146.         if(ret)
     
147.         {
     
148.             break;
     
149.         }
     
150.         key_status[i] = KEY_UP;
     
151.         
     
152.         //建立4个定时器
     
153.         setup_timer(&key_timers[i],keys_timer, i);    
     
154.     }
     
155.     
     
156.     if(ret)
     
157.     {
     
158.         //中断申请失败处理
     
159.         i --;
     
160.         
     
161.         for(; i>=0; i--)
     
162.         {
     
163.             //释放已注册成功的中断
     
164.             disable_irq(key_irqs[i].irq);
     
165.             free_irq(key_irqs[i].irq, (void *)i);
     
166.         }
     
167.         spin_unlock(&spin);    
     
168.         return -EBUSY;
     
169.     }
     
170.     
     
171.     g_count ++;
     
172.     spin_unlock(&spin);
     
173.     
     
174.     return 0;
     
175. }
     
176. 
     
177. //按键设备读取函数
     
178. static int keys_read(struct file *file, char __user *buf, size_t count, loff_t *offp)
     
179. {
     
180.     int ret;
     
181. 
     
182.     //如果ev_press未置1，即按键未按下，则返回
     
183.     if(!ev_press)
     
184.     {
     
185.         return -1;
     
186.     }
     
187.     if(down_interruptible(&sem))
     
188.     {
     
189.         return -ERESTARTSYS;
     
190.     }
     
191.     
     
192.     //将内核中的按键状态数据拷贝到用户空间给应用程序使用
     
193.     ret = copy_to_user(buf, (void *)key_status, min(sizeof(key_status),count));
     
194.     
     
195.     ev_press = 0;
     
196.     up(&sem);
     
197.     
     
198.     return ret?-EFAULT:min(sizeof(key_status),count);    
     
199.         
     
200.     up(&sem);
     
201.         
     
202. }
     
203. 
     
204. //按键设备异步函数
     
205. static int keys_fasync(int fd, struct file *filp, int on)
     
206. {
     
207.     int ret;
     
208.     
     
209.     //处理FASYNC标志变更的
     
210.     ret = fasync_helper(fd, filp, on, &fasync_queue);
     
211.     
     
212.     if(ret < 0)
     
213.         return ret;
     
214.         
     
215.     return 0;
     
216.     
     
217. }
     
218. 
     
219. static int keys_release(struct inode *inode, struct file *filp)
     
220. {
     
221.     int i;
     
222.     
     
223.     //释放4个定时器和中断
     
224.     for(i=0; i<KEY_COUNT; i++)
     
225.     {
     
226.         del_timer(&key_timers[i]);
     
227.         
     
228.         disable_irq(key_irqs[i].irq);
     
229.         free_irq(key_irqs[i].irq, (void *)i);
     
230.     }
232.     spin_lock(&spin);
         g_count --;
         spin_unlock(&spin);
     
233.     
     
234.     keys_fasync(-1, filp, 0);
     
235.     return 0;
     
236. }
     
237. 
     
238. static struct file_operations key_fops =
     
239. {
     
240.     .owner        = THIS_MODULE,
     
241.     .open         = keys_open,
     
242.     .release    = keys_release,
     
243.     .read        = keys_read,
     
244.     .fasync        = keys_fasync,
     
245. };
     
246. 
     
247. 
     
248. static int __init keys_init(void)
     
249. {    
     
250.     //动态注册设备，返回主设备号
     
251.     major = register_chrdev(DEVICE_MAJOR, DEVICE_NAME, &key_fops);
     
252.     if(major<0)
     
253.     {
     
254.         printk("fl2440_keys register failed!\n");
     
255.         return major;    
     
256.     }
     
257.     
     
258.     printk("fl2440_keys register sucess!\n");
     
259.     init_MUTEX(&sem);
     
260.     
     
261.     //创建类设备
     
262.     keys_class = class_create(THIS_MODULE, DEVICE_NAME);
     
263.     if(IS_ERR(keys_class))
     
264.     {
     
265.         printk(DEVICE_NAME "register class failed!");
     
266.         return -1;
     
267.     }
     
268.     //根据类创建设备，即模块加载的时候就会自动在/dev创建设备节点
     
269.     device_create(keys_class, NULL, MKDEV(major, 0), NULL, DEVICE_NAME);
     
270.     
     
271.     return major;    
     
272. }
     
273. 
     
274. static void __exit keys_exit(void)
     
275. {
     
276.     device_destroy(keys_class, MKDEV(major, 0));    //销毁类设备
     
277.     
     
278.     class_destroy(keys_class);                        //销毁类
     
279.     
     
280.     unregister_chrdev(major, DEVICE_NAME);            //注销设备
     
281.     
     
282. }
     
283. 
     
284. module_init(keys_init);
     
285. module_exit(keys_exit);
     
286. 
     
287. MODULE_LICENSE("GPL");
     
288. MODULE_AUTHOR("y.q.yang");
     
289. MODULE_DESCRIPTION("a fasync driver for fl2440 keys");

四、将按键驱动部署到内核中

    1. 修改相应配置文件。

1. #cp -f fl2440_keys.c drivers/char //把驱动源码复制到内核驱动的字符设备下
   
2. 
   
3. #vim drivers/char/Kconfig //添加按键设备配置
4. config FL2440_KEYS
5.     tristate "FL2440 Keys Device"
6.     depends on ARCH_S3C2440
7.     default y
8.     ---help---
9.       Fl2440 User Keys
   
10. 
    
11. #gedit drivers/char/Makefile //添加按键设备配置
12. obj-$(CONFIG_FL2440_KEYS) += fl2440_keys.o

    2. 配置内核，选择按键设备选项

1. #make menuconfig
   
2. Device Drivers --->
   
3.     Character devices --->
   
4.         <*> FL2440 Keys Device (NEW)

     3. 编译内核并下载到开发板上，启动的时候可以看到按键设备注册成功，

1. io scheduler noop registered
   
2. io scheduler deadline registered
   
3. io scheduler cfq registered (default)
   
4. Console: switching to colour frame buffer device 80x40
   
5. fb0: s3c2410fb frame buffer device
   
6. adc    initialized
   
7. register sucessed, pwm major is 253
   
8. fl2440_keys register

    不过并没有自动生成/dev下的设备节点，可能是我的文件系统做的不对。

1. [root@yyq2440 /]# ls dev
2. console null

    查看已加载的设备：#cat /proc/devices，可以看到fl2440_keys的主设备号为252

1. 136 pts
   
2. 180 usb
   
3. 188 ttyUSB
   
4. 189 usb_device
   
5. 204 s3c2410_serial
   
6. 230 fl2440_backlight
   
7. 231 fl2440_leds
   
8. 252 fl2440_keys
   
9. 253 fl2440_pwm
   
10. 254 rtc
    
11. 
    
12. Block devices:

     4. 编写用户空间测试程序，名为key_test.c

1. #include <sys/types.h>
   
2. #include <sys/stat.h>
   
3. #include <stdio.h>
   
4. #include <fcntl.h>
   
5. #include <signal.h>
   
6. #include <unistd.h>
   
7. 
   
8. static int fd;
   
9. int key_status[4];
   
10. 
    
11. void key_handler(int num)
    
12. {
    
13.     int i;
    
14.     int ret;
    
15.     
    
16.     ret = read(fd, &key_status, sizeof(key_status));
    
17.     
    
18.     if(ret != sizeof(key_status))
    
19.     {
    
20.         if(errno != EAGAIN)
    
21.         {
    
22.             printf("Read Button Device Faild!\n");
    
23.             
    
24.             return ;
    
25.         }
    
26.     }
    
27.     else
    
28.     {
    
29.         for(i=0; i<4; i++)
    
30.         {
    
31.             if(key_status[i] == 0)
    
32.             {
    
33.                 printf("Key%d Down\n", i+1);
    
34.             }
    
35.         }
    
36.     }
    
37.     
    
38. }
    
39. 
    
40. void main()
    
41. {
    
42.     int oflags;
    
43.     //打开设备
    
44.     fd = open("/dev/fl2440_key", O_RDWR, S_IRUSR | S_IWUSR);
    
45.     //启动信号驱动机制
    
46.     signal(SIGIO, key_handler);
    
47.     //设置信号所要发送的进程，getpid()获得当前进程号
    
48.     fcntl(fd, F_SETOWN, getpid());
    
49.     //获得文件状态标记
    
50.     oflags = fcntl(fd, F_GETFL);
    
51.     //设置打开的文件为异步操作模式
    
52.     fcntl(fd, F_SETFL, oflags | FASYNC);
    
53.     //最后进入一个死循环，程序什么都不干了，只有信号能激发input_handler 的运行
    
54.     //如果程序中没有这个死循环，会立即执行完毕
    
55.     while (1);
    
56. }

    5. 在开发主机上交叉编译测试应用程序，并复制到文件系统的/usr/sbin目录下，然后重新编译文件系统下载到开发板上

1. #arm-linux-gcc -o buttons_test buttons_test.c

     6. 在开发板上的文件系统中创建一个按键设备的节点，然后运行测试程序，效果图如下，观测按开发板上的按键时，在串口工具中会输出对应按键被按下的信息，也不会出现抖动现象（即按某个按键时，不会多次产生该按键按下的情况）

1. [root@yyq2440 /]# mknod /dev/fl2440_keys c 252 0
   
2. [root@yyq2440 /]# key_test
   
3. Key1 Down
   
4. Key2 Down
   
5. Key1 Down
   
6. Key3 Down
   
7. Key4 Down
   
8. Key1 Down
   
9. Key2 Down
   
10. Key3 Down
    
11. Key4 Down
    
12. Key4 Down
    
13. Key3 Down
    
14. Key2 Down
    
15. Key1 Down

    即可看到异步通知驱动正常工作，跟轮询方式的驱动一样。

2011-03-04