OK6410按键驱动程序(改)亲测可以运行

1. #include <linux/kernel.h>
2. #include <linux/module.h>
3. #include <linux/init.h>
4. #include <linux/fs.h>
5. #include <linux/gpio.h>
6. #include <linux/types.h>
7. #include <linux/cdev.h>
8. #include <linux/interrupt.h>
9. #include <linux/sched.h>
10. #include <linux/device.h>
11. #include <linux/poll.h>
12. #include <linux/semaphore.h>
13. #include <linux/timer.h>
14. #include <asm/irq.h>
15. #include <asm/uaccess.h>
16. //#include <mach/hardware.h>
17. #include <mach/irqs.h>
18. #define DEVICE_NAME "keyint"
19. #define KEYNUM 6
20. dev_t devid;
21. //static DEFINE_SEMAPHORE(key_lock);  //declare a mutex lock for keyint
22. //定义一个信号量
23. struct semaphore key_lock;
24. static struct fasync_struct *key_async;
25. static struct timer_list key_timer;
26. struct key_irq_desc {
27. int irq;        //irq num
28. unsigned long flags;    //irq flags,identified the way of irq here,eq.edge,level
29. char *name;        //irq name
30. };
31. static struct key_irq_desc key_irqs[] = {
32. //下降沿产生中断
33. {IRQ_EINT(0), IRQF_TRIGGER_FALLING, "KEY1"},
34. {IRQ_EINT(1), IRQF_TRIGGER_FALLING, "KEY2"},
35. {IRQ_EINT(2), IRQF_TRIGGER_FALLING, "KEY3"},
36. {IRQ_EINT(3), IRQF_TRIGGER_FALLING, "KEY4"},
37. {IRQ_EINT(4), IRQF_TRIGGER_FALLING, "KEY5"},
38. {IRQ_EINT(5), IRQF_TRIGGER_FALLING, "KEY6"},
39. };
40. /*define a waiting queue here*/
41. static DECLARE_WAIT_QUEUE_HEAD(key_waitq);
42. /*define a event flag ev_press*/
43. static volatile int ev_press = 0;
44. static volatile int press_cnt[KEYNUM] = {0,0,0,0,0,0};
45. /*中断处理函数*/
46. static irqreturn_t keys_interrupt(int irq, void *dev_id)
47. {
48. volatile int *press_cnt = (volatile int *) dev_id;
49. /*set the pressed key flag(must do here due to not be static value)*/
50. *press_cnt = *press_cnt + 1;
51. //延时10ms后执行定时器处理函数
52. mod_timer(&key_timer,jiffies+HZ/100);        //start timer after 10ms
53. return IRQ_RETVAL(IRQ_HANDLED);
54. }
55. //定时器处理函数
56. static void key_timer_func(unsigned long data)
57. {
58. ev_press = 1;
59. //唤醒等待队列
60. wake_up_interruptible(&key_waitq);
61. kill_fasync(&key_async, SIGIO, POLL_IN);
62. }
63. static int key_fasync(int fd, struct file *filp, int on)
64. {
65. printk("Function key_fasync\n");
66. return fasync_helper(fd,filp,on,&key_async);
67. }
68. static unsigned key_poll(struct file *file, poll_table *wait)
69. {
70. unsigned int mask=0;
71. //指明要使用的等待队列
72. poll_wait(file,&key_waitq,wait);
73. //返回掩码
74. if(ev_press)
75. mask |= POLL_IN | POLLRDNORM;
76. printk("poll wait\n");
77. return mask;
78. }
79. static int key_open(struct inode *inode, struct file *file)
80. {
81. int num;
82. if(file->f_flags & O_NONBLOCK) {
83. if(down_trylock(&key_lock)) return -EBUSY;
84. }
85. else {
86. down(&key_lock);
87. }
88. //为每个按键注册中断处理程序
89. for(num=0;num<KEYNUM;num++) {
90. request_irq(key_irqs[num].irq, keys_interrupt, key_irqs[num].flags, key_irqs[num].name, (void *)&press_cnt[num]);
91. }
92. return 0;
93. }
94. static int key_close(struct inode *inode, struct file *file)
95. {
96. int num;
97. //释放中断号
98. for(num=0;num<6;num++) {
99. free_irq(key_irqs[num].irq, (void *)&press_cnt[num]);
100. }
101. up(&key_lock);
102. printk("key_close free irqs\n");
103. return 0;
104. }
105. static int key_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
106. {
107. //    unsigned int err;
108. //判断是阻塞读还是非阻塞读
109. if(filp->f_flags & O_NONBLOCK) {
110. if(!ev_press)  return -EAGAIN;
111. }
112. else {
113. /*if ev_press==0,then sleep*/
114. /*阻塞，当有按键按下时(中断)被唤醒*/
115. wait_event_interruptible(key_waitq,ev_press);
116. }
117. //阻塞结束，有键按下了
118. ev_press = 0;
119. //拷贝数据到用户空间
120. copy_to_user(buff,(const void *)press_cnt,min(sizeof(press_cnt),count));
121. memset((void *)press_cnt,0,sizeof(press_cnt));
122. //    printk("read and clean press_cnt\n");
123. return 1;
124. }
125. static struct file_operations key_ops = {
126. .owner     = THIS_MODULE,
127. .open     = key_open,
128. .release = key_close,
129. .read     = key_read,
130. .poll     = key_poll,
131. .fasync     = key_fasync,
132. };
133. static struct cdev *cdev_keyint;
134. static struct class *keyint_class;
135. //模块初始化函数
136. static int __init s3c6410_keyint_init(void) {
137. int val;
138. /*timer initial */
139. init_timer(&key_timer);
140. key_timer.function = key_timer_func;
141. add_timer(&key_timer);
142. /*初始化信号量*/
143. init_MUTEX(&key_lock);
144. /*register device*/
145. val = alloc_chrdev_region(&devid,0,1,DEVICE_NAME);
146. if(val) {
147. return -1;
148. printk("register keyint error\n");
149. }
150. cdev_keyint = cdev_alloc();
151. cdev_init(cdev_keyint, &key_ops);
152. cdev_keyint->owner = THIS_MODULE;
153. cdev_keyint->ops   = &key_ops;
154. val = cdev_add(cdev_keyint,devid,1);
155. if(val) {
156. return -1;
157. printk("add device error\n");
158. }
159. keyint_class = class_create(THIS_MODULE,DEVICE_NAME);
160. device_create(keyint_class,NULL,devid,NULL,"%s",DEVICE_NAME);
161. printk("KEY initialezed ^_^\n");
162. return 0;
163. }
164. static void __exit s3c6410_keyint_exit(void)
165. {
166. cdev_del(cdev_keyint);
167. device_destroy(keyint_class,devid);
168. class_destroy(keyint_class);
169. unregister_chrdev_region(devid,1);
170. }
171. module_init(s3c6410_keyint_init);
172. module_exit(s3c6410_keyint_exit);
173. MODULE_LICENSE("GPL");

测试程序:

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <unistd.h>
4. #include <sys/ioctl.h>
5. int main(int argc, char **argv)
6. {
7. int fd;
8. int val;
9. int i;
10. int key_value[6];
11. fd = open("/dev/keyint",0);
12. if(fd<0) {
13. printf("open devie error\n");
14. return -1;
15. }
16. while(1) {
17. val = read(fd,key_value, sizeof(key_value));
18. if(val<0) {
19. printf("read error\n");
20. continue;
21. }
22. for(i=0;i<6;i++) {
23. if(key_value[i])
24. printf("KEY%d pressed\n",(i+1),key_value[i]);
25. }
26. }
27. close(fd);
28. return 0;
29. }

测试现象