【OK210试用体验】poll方式获取按键值

陈星 当前离线 经验 4705 窥视卡 雷达卡

陈星 ( 楼主 ) 2015-10-23 14:42:17  只看该作者 3295 | 0 倒序浏览

1.    1.驱动程序
   
2.                 static struct class * key_class;        定义驱动节点类
   
3.                 static struct device  *key_device;    定义驱动结构体
   
4.                 static DECLARE_WAIT_QUEUE_HEAD(button_waitq);    定义队列进程
   
5.                 static volatile int ev_press = 0;    定义队列进程唤醒标志位
   
6.                 static unsigned char value;        
   
7. 
   
8.                 struct key_desc{                    定义按键信息结构体
   
9.                          unsigned int  pin;        管脚信息
   
10.                          unsigned int  value;     管脚值
    
11.                 };
    
12. 
    
13.                 static struct key_desc my_key_descs[5] = {            初始化按键信息
    
14.                         {    S5PV210_GPH0(3),    0x01    },
    
15.                         {    S5PV210_GPH0(4),    0x02    },
    
16.                         {    S5PV210_GPH0(5),    0x03    },
    
17.                         {    S5PV210_GPH0(6),    0x04    },
    
18.                         {    S5PV210_GPH0(7),    0x05    },
    
19.                 };
    
20. 
    
21.                 static irqreturn_t button_irq(int irq, void *dev_id)        中断服务函数
    
22.                 {
    
23.                         struct key_desc *  pindesc = (struct key_desc *) dev_id;    取出按键信息
    
24.                         unsigned int pinval;
    
25. 
    
26.                         pinval = gpio_get_value(pindesc->pin);    获IO键值
    
27.    
    
28.                         if(pinval)                处理键值
    
29.                         {
    
30.                            value = 0x80 | pindesc->value;
    
31.                         }
    
32.                         else
    
33.                         {
    
34.                             value = pindesc->value;
    
35.                         }        
    
36.                         ev_press = 1;    置位队列进程唤醒标志位
    
37.                         wake_up_interruptible(&button_waitq);    唤醒队列进程
    
38.                         return IRQ_RETVAL(IRQ_HANDLED);
    
39.                 }
    
40. 
    
41.                 static int key_open(struct inode *inode, struct file *file)    open驱动函数
    
42.                 {
    
43.                     int i;
    
44.                     i= request_irq(IRQ_EINT3,button_irq,IRQF_SHARED|IRQ_TYPE_EDGE_BOTH,"key1",&my_key_descs[0]);    申请中断。参数：中断号，中断服务函数，中断模式，中断名称，中断信息
    
45.                     i= request_irq(IRQ_EINT4,button_irq,IRQF_SHARED|IRQ_TYPE_EDGE_BOTH,"key2",&my_key_descs[1]);
    
46.                     i= request_irq(IRQ_EINT5,button_irq,IRQF_SHARED|IRQ_TYPE_EDGE_BOTH,"key3",&my_key_descs[2]);
    
47.                     i= request_irq(IRQ_EINT6,button_irq,IRQF_SHARED|IRQ_TYPE_EDGE_BOTH,"key4",&my_key_descs[3]);
    
48.                     i= request_irq(IRQ_EINT7,button_irq,IRQF_SHARED|IRQ_TYPE_EDGE_BOTH,"key5",&my_key_descs[4]);
    
49.                     return 0;
    
50.                 }
    
51. 
    
52.                 static int key_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)    read驱动函数
    
53.                 {
    
54.                     int x;
    
55.                     if(size != 1)
    
56.                     return -EINVAL;   
    
57. 
    
58.                     wait_event_interruptible(button_waitq,ev_press);        休眠进程，同时判断标志位
    
59. 
    
60.                     copy_to_user(buf, &value, 1);    复制数据至用户区
    
61.                     ev_press = 0;    清除队列进程唤醒标志位
    
62.                     return sizeof(value);        
    
63.                 }
    
64. 
    
65.                 static int key_release(struct inode *inode, struct file *file)    release驱动函数
    
66.                 {
    
67.                         free_irq(IRQ_EINT3,&my_key_descs[0]);    释放中断。参数：中断号，中断信息
    
68.                         free_irq(IRQ_EINT4,&my_key_descs[1]);
    
69.                         free_irq(IRQ_EINT5,&my_key_descs[2]);
    
70.                         free_irq(IRQ_EINT6,&my_key_descs[3]);
    
71.                         free_irq(IRQ_EINT7,&my_key_descs[4]);
    
72.                         return 0;
    
73.                 }
    
74. 
    
75.                 static unsigned  key_poll(struct file *file, poll_table *wait)   poll驱动函数
    
76.                 {
    
77.                     unsigned int mask = 0;
    
78.                     poll_wait(file, &button_waitq, wait);        进入poll等待模式，等待事件发生或超时退出
    
79.                     if(ev_press)   
    
80.                         mask |= POLLIN | POLLRDNORM;    普通或优先级带数据可读，普通数据可读
    
81. 
    
82.                     return mask;
    
83.                 }
    
84. 
    
85.                 static struct file_operations fops = {        驱动配置信息
    
86.                          .owner      =       THIS_MODULE,
    
87.                          .open        =       key_open,
    
88.                          .release     =       key_release,
    
89.                          .read         =       key_read,
    
90.                          .read         =       key_read,   
    
91.                  };
    
92. 
    
93.                 static int keys_init(void)    安装驱动函数
    
94.                 {
    
95.                        a=register_chrdev(0,"aaa",&fops);
    
96.                        key_class = class_create(THIS_MODULE, "aaa");
    
97.                        key_device = device_create(key_class, NULL, MKDEV(a, 0), NULL, "button");
    
98.                        return 0;
    
99.                 }
    
100. 
     
101.                 static void keys_exit(void)    卸载驱动函数
     
102.                 {
     
103.                     unregister_chrdev(a,"aaa");
     
104.                     device_unregister(key_device);
     
105.                     class_destroy(key_class);
     
106.                 }
     
107. 
     
108.                 module_init(keys_init);        安装驱动
     
109.                 module_exit(keys_exit);        卸载驱动
     
110.                 MODULE_LICENSE("GPL");     自动安装节点时需要的许可
     
111. 
     
112.             2.应用程序
     
113.                 int main(int argc, char **argv)
     
114.             {
     
115.                 int fd;
     
116.                 unsigned char x;
     
117.                 int a;
     
118. 
     
119.                     struct pollfd fds[1];    定义pollfd结构类型的数组
     
120. 
     
121.                 fd = open("/dev/button",0);    打开驱动
     
122.                 if(fd<0)
     
123.                 {
     
124.                     printf("driver not or dev name notn");
     
125.                     return fd;
     
126.                 }
     
127. 
     
128.                 fds[0].fd = fd;    保存文件信息
     
129.                 fds[0].events = POLLIN;    将测试条件设置成普通或优先级带数据可读
     
130. 
     
131.                 while(1)  
     
132.               {   
     
133.                     a = poll(fds, 1, 5000);    调用poll函数，等待5s，只读取一个中断值
     
134.                     if(a == 0)    无中断触发，返回0
     
135.                     {
     
136.                         printf("time outn");  
     
137.                     }
     
138.                     else
     
139.                     {
     
140.                         read(fd,&x,1);    读取信息：进入读取函数，触发休眠，被唤醒后才会继续执行程序
     
141.                         printf("x = %dn",x);    打印出读取的信息
     
142.                     }
     
143.                }   
     
144. 
     
145.                 return 0;
     
146.             }
     
147. 
     
148.             3.Makefile
     
149.                 ARCH=arm
     
150.                 CROSS_COMPILE=/usr/local/arm/arm-2009q3/bin/arm-none-linux-gnueabi-
     
151.                 APP_COMPILE=/usr/local/arm/arm-2009q3/bin/arm-none-linux-gnueabi-
     
152.                 obj-m := aaa.o
     
153.                 KDIR := /usr/android-kernel-samsung-dev/
     
154.                 PWD := $(shell pwd)
     
155.                 default:
     
156.                     make -C $(KDIR) M=$(PWD) ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE) modules
     
157.                 clean:
     
158.                     $(MAKE) -C $(KDIR) M=$(PWD) clean
     

复制代码