按键输入驱动程序～希望各位指点

简单侶途

首先，说明我的程序是查询模式的按键输入驱动程序
先看看寄存器的配置吧：
配置为输入模式input  ：000
pc_cfg2 &= ~( 7<<12 | 7<<16 );   /*  19--bit[14:12]  20--bit[18:16]*/

加内部上拉电阻，确保电平的稳定，按下为低电平，松开为高电平

1.驱动程序部分

1. #include <linux/module.h>
   
2. #include <linux/moduleparam.h>
   
3. #include <linux/errno.h>
   
4. #include <linux/poll.h>
   
5. #include <linux/sched.h>
   
6. #include <linux/spinlock.h>
   
7. #include <linux/slab.h>
   
8. #include <linux/ipmi.h>
   
9. #include <linux/mutex.h>
   
10. #include <linux/init.h>
    
11. #include <linux/device.h>
    
12. #include <linux/cdev.h>
    
13. #include <linux/compat.h>
    
14. #include <asm/io.h>
    
15. 
    
16. #include<linux/fs.h>
    
17. #include<linux/kernel.h>
    
18. #include<linux/uaccess.h>
    
19. #include<linux/types.h>
    
20. #include <asm/gpio.h>
    
21. #include <linux/gpio.h>
    
22. #include <plat/sys_config.h>
    
23. #include <linux/delay.h>
    
24. #include <asm/irq.h>
    
25. #include <linux/moduleparam.h>
    
26. #include <linux/spinlock.h>
    
27. #include <linux/ipmi.h>
    
28. #include <linux/mutex.h>
    
29. 
    
30. //#define PIO_BASE  0x01c20800
    
31. #define PC_BASE   (PIO_BASE + 2*0x24)
    
32. #define PC_CFG2   (PC_BASE  + 0x08)
    
33. #define PC_DAT    (PC_BASE  + 0x10)
    
34. #define PC_PULL1  (PC_BASE  + 0x20)
    
35. 
    
36. static volatile unsigned int *pc_cfg2;
    
37. static volatile unsigned int *pc_pull1;
    
38. static volatile unsigned int *pc_dat;
    
39. 
    
40. static struct class *keydrv_class;
    
41. static struct class_device        *keydrv_class_dev;
    
42. 
    
43. static int major;
    
44. /*
    
45. * 1. Configure register PG_CFG0 enable PG0 as input pin .
    
46. * 2. Configure register PG_PULL0 enable PG0 pull-up .
    
47. */
    
48. 
    
49. static int key_open(struct inode *inode, struct file *file)
    
50. {
    
51.         *pc_cfg2 &= ~( 7<<12 | 7<<16 );   /*  19--bit[14:12] */
    
52.         *pc_pull1 &= ~( 3<<6 | 3<<8 );    /*  19--bit[7:6]   */
    
53.         *pc_pull1 |= ( 1<<6  | 1<<8 );     /*01 is pull up*/
    
54.         return 0;
    
55. }
    
56. 
    
57. static int key_close(struct inode *inode, struct file *file)
    
58. {
    
59.         return 0;
    
60. }
    
61. 
    
62. static ssize_t key_read(struct file *file, char __user *buf,
    
63.                                             size_t size,loff_t *ppos)
    
64. {
    
65.         static char keyval[2];
    
66.     if (size != sizeof(keyval))
    
67.                 return -EINVAL;
    
68.         keyval[0] =        (*pc_dat & (1<<19))? 1:0;
    
69.         keyval[1] =        (*pc_dat & (1<<20))? 1:0;
    
70.         copy_to_user(buf, &keyval,sizeof(keyval));        
    
71.         return sizeof(keyval);
    
72. }
    
73. 
    
74. static const struct file_operations key_fops = {
    
75.         .owner              = THIS_MODULE,
    
76.         .open         = key_open,
    
77.         .release      = key_close,
    
78.         .read         = key_read,
    
79. };
    
80. 
    
81. static int keys_init(void)
    
82. {
    
83.         major = register_chrdev(0,"key", &key_fops);
    
84.         keydrv_class = class_create(THIS_MODULE, "key");
    
85.         keydrv_class_dev = device_create(keydrv_class, NULL, MKDEV(major, 0), NULL, "buttons"); /* /dev/buttons */
    
86.         /* ioremap*/
    
87.         pc_cfg2  = ioremap(PC_CFG2,4);
    
88.         pc_pull1 = ioremap(PC_PULL1,4);
    
89.         pc_dat   = ioremap(PC_DAT,4);        
    
90.         return 0;
    
91. }
    
92. 
    
93. static void keys_exit(void)
    
94. {
    
95.         device_destroy(keydrv_class,MKDEV(major, 0));
    
96.         class_destroy(keydrv_class);
    
97.         unregister_chrdev(major,"key");
    
98.         //注销LED设备  
    
99.         iounmap(pc_cfg2);
    
100.         iounmap(pc_pull1);
     
101.         iounmap(pc_dat);
     
102. }
     
103. 
     
104. module_init(keys_init);
     
105. module_exit(keys_exit);
     
106. MODULE_LICENSE("GPL");

复制代码

2.应用程序部分：

1. #include <sys/types.h>
   
2. #include <sys/stat.h>
   
3. #include <fcntl.h>
   
4. #include <stdio.h>
   
5. 
   
6. int main(int argc, char **argv)
   
7. {
   
8.         int fd;
   
9.         unsigned char key_val[2];
   
10.         int cnt = 0;
    
11. 
    
12.         fd = open("/dev/buttons", O_RDWR);
    
13.         if (fd < 0) {
    
14.                 printf("can't open!\n");
    
15.                 return -1;
    
16.         }
    
17.         while (1){
    
18.                 read(fd,key_val, sizeof(key_val));
    
19.                 if ( (key_val[0] == 0) || (key_val[1] == 0) )
    
20.                         printf("%04d key pressed: %d , %d\n", cnt++, key_val[0],key_val[1]);
    
21.         }
    
22.         return 0;
    
23. }
    

复制代码

简单侶途

用单片机思维来给按键消抖：
效果为：每按一次打印一次，只有按键松开另外的按键才可以按下

1. #include <sys/types.h>
   
2. #include <sys/stat.h>
   
3. #include <fcntl.h>
   
4. #include <stdio.h>
   
5. 
   
6. void delay(int t);
   
7. 
   
8. int main(int argc, char **argv)
   
9. {
   
10.         int fd;
    
11.         unsigned char key_val[2];
    
12.         int cnt = 0;
    
13.         char key_flag = 1;
    
14. 
    
15.         fd = open("/dev/buttons", O_RDWR);
    
16.         if (fd < 0) {
    
17.                 printf("can't open!\n");
    
18.                 return -1;
    
19.         }
    
20.         while (1){
    
21.                 read(fd,key_val, sizeof(key_val));
    
22.                 if ( (key_val[0] == 0) || (key_val[1] == 0) ) {
    
23.                         delay(100);        //延时消抖
    
24.                         if( (key_val[0] == 0) || (key_val[1] == 0) ) {
    
25.                                 if(key_flag == 1)
    
26.                                         printf("%04d key pressed: %d , %d\n", cnt++, key_val[0],key_val[1]);
    
27.                                 key_flag = 2;
    
28.                         }
    
29.                 }
    
30.                 else
    
31.                         key_flag = 1;
    
32.         }
    
33.         return 0;
    
34. }
    
35. 
    
36. 
    
37. void delay(int t)
    
38. {
    
39.         int j;
    
40.         for(t = 0;t<256;t++)
    
41.                 for(j=0;j<256;j++);
    
42. }

复制代码

本人能力有限，尝试用在驱动程序里面用定时器作按键消抖，但是不知道哪里配置问题，程序没反应。
所以只能作这样的修改了。