韦东山完全开发手册 这本是上 按键驱动程序有点不理解，求指导

qulei

1.这本是上的按键驱动中，没有把GPIO口设置成外部中断模式，但是我测试后，中断还是可以发生。我还把中断触发方式进行了替换，会有不同的现象，可以说明不是查询方式中断,是吗？
2.这个驱动程序中  memset((void *)press_cnt, 0, sizeof(press_cnt)); 指令对press_cnt数组进行清零，所以在测试的时候按键的次数不能累加。将这个程序屏蔽后，可以实现累加，但是这样每次打印出的信息不是一个按键的信息了，是你以前按键次数的所有信息.
大神求解，我附上源码...
驱动

1. #include <linux/module.h>
   
2. #include <linux/kernel.h>
   
3. #include <linux/fs.h>
   
4. #include <linux/init.h>
   
5. #include <linux/delay.h>
   
6. #include <asm/irq.h>
   
7. #include <linux/interrupt.h>
   
8. #include <asm/uaccess.h>
   
9. #include <mach/regs-gpio.h>
   
10. #include <mach/hardware.h>
    
11. #include <linux/sched.h>
    
12. 
    
13. #define DEVICE_NAME     "ok6410keys"   /* 加载模式后，执行”cat /proc/devices”命令看到的设备名称 */
    
14. #define KEY_MAJOR    252         /* 主设备号 */
    
15. 
    
16. struct key_irq_desc {
    
17.     int irq;
    
18.     unsigned long flags;
    
19.     char *name;
    
20. };
    
21. 
    
22. /* 用来指定按键所用的外部中断引脚及中断触发方式, 名字 */
    
23. static struct key_irq_desc key_irqs [] = {
    
24.     {IRQ_EINT(0), IRQF_TRIGGER_FALLING, "KEY1"}, /* K1 */
    
25.     {IRQ_EINT(1), IRQF_TRIGGER_FALLING, "KEY2"}, /* K2 */
    
26.     {IRQ_EINT(2), IRQF_TRIGGER_FALLING, "KEY3"}, /* K3 */
    
27.     {IRQ_EINT(3), IRQF_TRIGGER_FALLING, "KEY4"}, /* K4 */
    
28.     {IRQ_EINT(4), IRQF_TRIGGER_FALLING, "KEY5"}, /* K5 */
    
29.     {IRQ_EINT(5), IRQF_TRIGGER_FALLING, "KEY6"}, /* K6 */
    
30. };
    
31. 
    
32. /* 按键被按下的次数(准确地说，是发生中断的次数) */
    
33. static volatile int press_cnt [] = {0, 0, 0, 0, 0, 0};
    
34. 
    
35. /* 等待队列:
    
36. * 当没有按键被按下时，如果有进程调用s3c6410_keys_read函数，
    
37. * 它将休眠
    
38. */
    
39. static DECLARE_WAIT_QUEUE_HEAD(key_waitq);
    
40. 
    
41. /* 中断事件标志, 中断服务程序将它置1，s3c6410_keys_read将它清0 */
    
42. static volatile int ev_press = 0;
    
43. 
    
44. 
    
45. static irqreturn_t key_interrupt(int irq, void *dev_id)
    
46. {
    
47.     volatile int *press_cnt = (volatile int *)dev_id;
    
48.    
    
49.     *press_cnt = *press_cnt + 1; /* 按键计数加1 */
    
50.     ev_press = 1;                /* 表示中断发生了 */
    
51.     wake_up_interruptible(&key_waitq);   /* 唤醒休眠的进程 */
    
52.    
    
53.     return IRQ_RETVAL(IRQ_HANDLED);
    
54. }
    
55. 
    
56. 
    
57. /* 应用程序对设备文件/dev/ok6410keys执行open(...)时，
    
58. * 就会调用s3c6410_key_open函数
    
59. */
    
60. static int s3c6410_key_open(struct inode *inode, struct file *file)
    
61. {
    
62.     int i;
    
63.     int err;
    
64.    
    
65.     for (i = 0; i < sizeof(key_irqs)/sizeof(key_irqs[0]); i++) {
    
66.         // 注册中断处理函数
    
67.         err = request_irq(key_irqs[i].irq, key_interrupt, key_irqs[i].flags,
    
68.                           key_irqs[i].name, (void *)&press_cnt[i]);
    
69.         if (err)
    
70.             break;
    
71.     }
    
72. 
    
73.     if (err) {
    
74.         // 释放已经注册的中断
    
75.         i--;
    
76.         for (; i >= 0; i--)
    
77.             free_irq(key_irqs[i].irq, (void *)&press_cnt[i]);
    
78.         return -EBUSY;
    
79.     }
    
80.    
    
81.     return 0;
    
82. }
    
83. 
    
84. 
    
85. /* 应用程序对设备文件/dev/ok6410keys执行close(...)时，
    
86. * 就会调用s3c6410_key_close函数
    
87. */
    
88. static int s3c6410_key_close(struct inode *inode, struct file *file)
    
89. {
    
90.     int i;
    
91.    
    
92.     for (i = 0; i < sizeof(key_irqs)/sizeof(key_irqs[0]); i++) {
    
93.         // 释放已经注册的中断
    
94.         free_irq(key_irqs[i].irq, (void *)&press_cnt[i]);
    
95.     }
    
96. 
    
97.     return 0;
    
98. }
    
99. 
    
100. 
     
101. /* 应用程序对设备文件/dev/ok6410keys执行read(...)时，
     
102. * 就会调用s3c6410_key_read函数
     
103. */
     
104. static int s3c6410_key_read(struct file *filp, char __user *buff,
     
105.                                          size_t count, loff_t *offp)
     
106. {
     
107.     unsigned long err;
     
108.    
     
109.     /* 如果ev_press等于0，休眠 */
     
110.     wait_event_interruptible(key_waitq, ev_press);
     
111. 
     
112.     /* 执行到这里时，ev_press等于1，将它清0 */
     
113.     ev_press = 0;
     
114. 
     
115.     /* 将按键状态复制给用户，并清0 */
     
116.     err = copy_to_user(buff, (const void *)press_cnt, min(sizeof(press_cnt), count));
     
117.     memset((void *)press_cnt, 0, sizeof(press_cnt));
     
118. 
     
119.     return err ? -EFAULT : 0;
     
120. }
     
121. 
     
122. /* 这个结构是字符设备驱动程序的核心
     
123. * 当应用程序操作设备文件时所调用的open、read、write等函数，
     
124. * 最终会调用这个结构中的对应函数
     
125. */
     
126. static struct file_operations s3c6410_key_fops = {
     
127.     .owner   =   THIS_MODULE,    /* 这是一个宏，指向编译模块时自动创建的__this_module变量 */
     
128.     .open    =   s3c6410_key_open,
     
129.     .release =   s3c6410_key_close,
     
130.     .read    =   s3c6410_key_read,
     
131. };
     
132. 
     
133. /*
     
134. * 执行“insmod s3c6410_key.ko”命令时就会调用这个函数
     
135. */
     
136. static int __init s3c6410_key_init(void)
     
137. {
     
138.     int ret;
     
139. 
     
140.     /* 注册字符设备驱动程序
     
141.      * 参数为主设备号、设备名字、file_operations结构；
     
142.      * 这样，主设备号就和具体的file_operations结构联系起来了，
     
143.      * 操作主设备为KEY_MAJOR的设备文件时，就会调用s3c6410_key_fops中的相关成员函数
     
144.      * KEY_MAJOR可以设为0，表示由内核自动分配主设备号
     
145.      */
     
146.     ret = register_chrdev(KEY_MAJOR, DEVICE_NAME, &s3c6410_key_fops);
     
147.     if (ret < 0) {
     
148.       printk(DEVICE_NAME " can't register major number\n");
     
149.       return ret;
     
150.     }
     
151.    
     
152.     printk(DEVICE_NAME " initialized\n");
     
153.     return 0;
     
154. }
     
155. 
     
156. /*
     
157. * 执行”rmmod s3c6410_key.ko”命令时就会调用这个函数
     
158. */
     
159. static void __exit s3c6410_key_exit(void)
     
160. {
     
161.     /* 卸载驱动程序 */
     
162.     unregister_chrdev(KEY_MAJOR, DEVICE_NAME);
     
163. }
     
164. 
     
165. /* 这两行指定驱动程序的初始化函数和卸载函数 */
     
166. module_init(s3c6410_key_init);
     
167. module_exit(s3c6410_key_exit);
     
168. 
     
169. /* 描述驱动程序的一些信息，不是必须的 */
     
170. MODULE_DESCRIPTION("S3C6410 key Driver");   // 一些描述信息
     
171. MODULE_LICENSE("GPL");                              // 遵循的协议
     

复制代码

测试程序

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <unistd.h>
   
4. #include <sys/ioctl.h>
   
5. 
   
6. int main()
   
7. {
   
8.     int i;
   
9.     int ret;
   
10.     int fd;
    
11.     int press_cnt[6];
    
12.    
    
13.     fd = open("/dev/ok6410keys", 0);  // 打开设备
    
14.     if (fd < 0) {
    
15.         printf("Can't open /dev/ok6410keys\n");
    
16.         return -1;
    
17.     }
    
18. 
    
19.     // 这是个无限循环，进程有可能在read函数中休眠，当有按键被按下时，它才返回
    
20.     while (1) {
    
21.         // 读出按键被按下的次数
    
22.         ret = read(fd, press_cnt, sizeof(press_cnt));
    
23.         if (ret < 0) {
    
24.             printf("read err!\n");
    
25.             continue;
    
26.         }
    
27. 
    
28.         for (i = 0; i < sizeof(press_cnt)/sizeof(press_cnt[0]); i++) {
    
29.             // 如果被按下的次数不为0，打印出来
    
30.             if (press_cnt[i])
    
31.                 printf("K%d has been pressed %d times!\n", i+1, press_cnt[i]);
    
32.         }
    
33.     }
    
34.    
    
35.     close(fd);
    
36.     return 0;   
    
37. }
    

复制代码

飞凌-unix

楼主，你还是比对一下代码文件吧

qulei

飞凌-unix 发表于 2014-4-25 08:44
楼主，你还是比对一下代码文件吧

:( 程序中就没有关于GPIO口的设置，怎么实现中断的。。。

qulei

:'(:'( ，高手在那里。。。

qulei

:dizzy:  就没人能帮我解决吗？