【OK210试用体验】功能篇（2）Linux字符驱动之Key按键驱动

gjianw217 当前离线 经验 688 窥视卡 雷达卡

gjianw217 ( 楼主 ) 2015-8-14 00:24:02  只看该作者 4340 | 4 倒序浏览

    前面进行了OK210试用体验的入门篇介绍，算是初步入门，分别包含：
   【OK210试用体验】的第一篇：开箱验板
   【OK210试用体验】的第二篇：板载资源
   【OK210试用体验】的第三篇：开发环境（软件安装，开发环境，烧写系统）
   【OK210试用体验】的第四篇：编程入门（NFS登录，驱动入门）
    前一篇介绍了功能篇的字符驱动之LED灯，今天是功能篇的第二篇：字符驱动之Key按键的控制，本节主要分3部分：硬件分析，软件基础，驱动编程。
一、硬件分析
    在【OK210试用体验】的第二篇：板载资源中，简单分析了Key按键的功能和作用。其实对Key的操作，和对LED的操作是一相对的，都是对GPIO的最基本操作，也是入门操作。Key是对GPIO的输入进行操作，LED是对GPIO的输出进行操作。
    首先从OK210的底板原理图中可知，OK210的5个按键，通过核心板接到了S5PV210的XEINT3-7引脚上，如下图，

    接着从用户手册的第103页中得知，这些引脚没有复用功能，默认为GPI，即通用端口输入，如下图，其实在用户手册的92而，有这么一句话：，想必大家都知道其什么意思了。
GPH0,1,2,3: 32 in/out port - Key pad, External Wake-up (up-to 32-bit). (GPH* groups are in Alive region)

    也就是说，要对5个Key的操作，就是对XEINT3-7这5个引脚的控制。
二、软件基础
1 字符设备驱动
字符驱动模块，可以简单的总结为如下图所示：包括对设备文件的创建，字符驱动的注册以及文件操作的编写等。

其实个人理解，对字符驱动的编写，就是对struct file_operations 结构体的填充，该结构体定义在linux/fs.h头文件中，在2.6.35.7内核中，定义为如下形式：

1. struct file_operations {
   
2.         struct module *owner;
   
3.         loff_t (*llseek) (struct file *, loff_t, int);
   
4.         ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
   
5.         ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
   
6.         ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
   
7.         ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
   
8.         int (*readdir) (struct file *, void *, filldir_t);
   
9.         unsigned int (*poll) (struct file *, struct poll_table_struct *);
   
10.         int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
    
11.         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
    
12.         long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
    
13.         int (*mmap) (struct file *, struct vm_area_struct *);
    
14.         int (*open) (struct inode *, struct file *);
    
15.         int (*flush) (struct file *, fl_owner_t id);
    
16.         int (*release) (struct inode *, struct file *);
    
17.         int (*fsync) (struct file *, int datasync);
    
18.         int (*aio_fsync) (struct kiocb *, int datasync);
    
19.         int (*fasync) (int, struct file *, int);
    
20.         int (*lock) (struct file *, int, struct file_lock *);
    
21.         ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
    
22.         unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
    
23.         int (*check_flags)(int);
    
24.         int (*flock) (struct file *, int, struct file_lock *);
    
25.         ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
    
26.         ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
    
27.         int (*setlease)(struct file *, long, struct file_lock **);
    
28. };

复制代码

本节将会用到open，read，poll，fasync，release这5个函数，下面将会一一介绍。
2 驱动中断
驱动程序中进行中断处理涉及到的最基本的内核API，主要用于申请和释放中断，在linux/sched.h里声明，其原型为：
int request_irq(unsigned int irq,
void (*handler)(int irq, void *dev_id, struct pt_regs *regs
),
unsigned long irqflags,
const char * devname,
void *dev_id);
irq是要申请的硬件中断号；handler是向系统登记的中断处理函数。这是一个回调函数，中断发生时，系统调用这个函数，传入的参数包括硬件中断号，device id，寄存器值。dev_id就是下面的request_irq时传递给系统的参数dev_id。irqflags是中断处理的一些属性。比较重要的有SA_INTERRUPT，标明中断处理程序是快速处理程序(设置SA_INTERRUPT)还是慢速处理程序(不设置SA_INTERRUPT)。快速处理程序被调用时屏蔽所有中断，慢速处理程序不屏蔽。还有一个SA_SHIRQ属性，设置了以后运行多个设备共享中断。dev_id在中断共享时会用到。一般设置为这个设备的 device结构本身或者NULL。中断处理程序可以用dev_id找到相应的控制这个中断的设备，或者用irq2dev_map找到中断对应的设备。
void free_irq(unsigned int irq,void *dev_id);

三、驱动编程
(一）、本驱动程序分别实现了对按键的简单读（read)操作，支持轮询机制（poll）和支持异步机制（fasync）。
1简单读（read)操作
简单的读操作的工作原理是：当应用程序读取键值时，会调用按键驱动程序的read函数，而实现的read函数检测完读取长度后没有直接读取键值而是等待按键消息，如果没有按键，程序会进入休眠状态，这样可以节省大量的CPU，而当按下按键时硬件会产生中断，程序自动进入中断处理函数，在中断处理函数中，驱动程序读取键值存入全局变量并激活read函数中等待的消息，应用程序被迅速唤醒并通过read函数读取键值，如此，完成了获取键值的工作。测试程序见TestButtons1()。
2支持轮询机制（poll）
上面的实现的按键驱动程序有个弊端，如果不按键，应用程序将会永远阻塞在这里，幸运的是，linux内核提供了poll机制，可以设置超时等待时间，如果在这个时间内读取到键值则正常返回，反之则超时退出。测试程序见TestButtons2()。
3支持异步机制（fasync）
很多情况下，程序在等待按键期间需要处理其它任务而不是在这里空等，这时，就需要采用异步模式了。所谓异步模式，实际上是采用消息机制，即当驱动程序检测到按键后发送消息给应用程序，应用程序接收到消息后再去读取键值。与前面的两种模式相比，最大的不同在于异步方式是驱动告诉应用程序来读而不是应用程序主动去读。测试程序见TestButtons3()。
下面是按键采用异步机制的测试结果：

（二）程序代码
1驱动程序：

1. 
   
2. #include
   
3. #include
   
4. #include
   
5. #include
   
6. #include
   
7. #include
   
8. #include
   
9. #include
   
10. #include
    
11. #include
    
12. #include
    
13. #include
    
14. 
    
15. 
    
16. static dev_t devno;
    
17. static struct cdev cdev;
    
18. static struct class* my_buttons_class;
    
19. static struct device* my_buttons_device;
    
20. 
    
21. static wait_queue_head_t my_button_waitq;
    
22. static struct fasync_struct *my_button_fasync;
    
23. static volatile int pressed = 0;
    
24. static unsigned char key_val;
    
25. 
    
26. struct key_desc{
    
27.         unsigned int  pin;
    
28.         unsigned char value;
    
29.         char* name;
    
30. };
    
31. 
    
32. static struct key_desc my_key_descs[] = {
    
33.         [0] = {
    
34.                 .pin = S5PV210_GPH0(3),
    
35.                 .value = 0x01,
    
36.                 .name ="Key1",
    
37.         },
    
38. 
    
39.         [1] = {
    
40.                 .pin = S5PV210_GPH0(4),
    
41.                 .value = 0x02,
    
42.                 .name ="Key2",
    
43.         },
    
44. 
    
45.         [2] = {
    
46.                 .pin = S5PV210_GPH0(5),
    
47.                 .value = 0x03,
    
48.                 .name ="Key3",
    
49.         },
    
50. 
    
51.         [3] = {
    
52.                 .pin = S5PV210_GPH0(6),
    
53.                 .value = 0x04,
    
54.                 .name ="Key4",
    
55.         },
    
56. 
    
57.         [4] = {
    
58.                 .pin = S5PV210_GPH0(7),
    
59.                 .value = 0x05,
    
60.                 .name ="Key5",
    
61.         },
    
62. 
    
63. };
    
64. 
    
65. #define BUTTONS_NUM        ARRAY_SIZE(my_key_descs)
    
66. 
    
67. static irqreturn_t my_buttons_irq(int irq, void *dev_id){
    
68.         volatile struct key_desc *key = (volatile struct key_desc *)dev_id;
    
69. 
    
70.         if(gpio_get_value(key->pin)){
    
71.                 key_val = key->value|0x80;
    
72.         }
    
73.         else{
    
74.                 key_val = key->value;
    
75.         }
    
76. 
    
77.         pressed = 1;
    
78.         wake_up_interruptible(&my_button_waitq);
    
79. 
    
80.     kill_fasync(&my_button_fasync, SIGIO, POLL_IN);  //用kill_fasync函数告诉应用程序，有数据可读了
    
81.         return IRQ_RETVAL(IRQ_HANDLED);
    
82. }
    
83. 
    
84. static int my_buttons_open(struct inode *inode, struct file *file){
    
85.         int ret;
    
86. 
    
87.         ret = request_irq( IRQ_EINT3,   my_buttons_irq, IRQ_TYPE_EDGE_BOTH, "key1", &my_key_descs[0]);
    
88.         if(ret)
    
89.                 return ret;
    
90.         ret = request_irq( IRQ_EINT4,   my_buttons_irq, IRQ_TYPE_EDGE_BOTH, "key2", &my_key_descs[1]);
    
91.         if(ret)
    
92.                 return ret;
    
93.          ret = request_irq( IRQ_EINT5,   my_buttons_irq, IRQ_TYPE_EDGE_BOTH, "key3", &my_key_descs[2]);
    
94.         if(ret)
    
95.                 return ret;
    
96.          ret = request_irq( IRQ_EINT6,   my_buttons_irq, IRQ_TYPE_EDGE_BOTH, "key4", &my_key_descs[3]);
    
97.         if(ret)
    
98.                 return ret;
    
99.         ret = request_irq( IRQ_EINT7,   my_buttons_irq, IRQ_TYPE_EDGE_BOTH, "key5", &my_key_descs[4]);
    
100.         if(ret)
     
101.                 return ret;
     
102. 
     
103.         return 0;
     
104. }
     
105. 
     
106. static ssize_t my_buttons_read(struct file * file, char __user *data, size_t count, loff_t *loff){
     
107.         if(count != 1){
     
108.                 printk(KERN_ERR "The driver can only give one key value once!n");
     
109.                 return -ENOMEM;
     
110.         }
     
111. 
     
112.         wait_event_interruptible(my_button_waitq, pressed);
     
113.         pressed = 0;
     
114. 
     
115.         if(copy_to_user(data, &key_val, 1)){
     
116.                 printk(KERN_ERR "The driver can not copy the data to user area!n");
     
117.                 return -ENOMEM;
     
118.         }
     
119. 
     
120.         return 0;
     
121. }
     
122. 
     
123. static unsigned my_buttons_poll(struct file *file, poll_table *wait){
     
124.         unsigned int mask = 0;
     
125.         poll_wait(file, &my_button_waitq, wait);
     
126. 
     
127.         if (pressed)
     
128.                 mask |= POLLIN | POLLRDNORM;
     
129. 
     
130.         return mask;
     
131. }
     
132. 
     
133. static int my_buttons_fasync(int fd, struct file * file, int on){
     
134.     return fasync_helper(fd, file, on,  &my_button_fasync);
     
135. }
     
136. 
     
137. static int my_buttons_close(struct inode *inode, struct file *file){
     
138.         free_irq(IRQ_EINT3,  &my_key_descs[0]);
     
139.         free_irq(IRQ_EINT4,  &my_key_descs[1]);
     
140.         free_irq(IRQ_EINT5,  &my_key_descs[2]);
     
141.         free_irq(IRQ_EINT6,  &my_key_descs[3]);
     
142.         free_irq(IRQ_EINT7,  &my_key_descs[4]);
     
143. 
     
144.         return 0;
     
145. }
     
146. 
     
147. struct file_operations my_buttons_ops = {
     
148.         .open    = my_buttons_open,
     
149.         .read    = my_buttons_read,
     
150.         .poll    = my_buttons_poll,
     
151.         .fasync  = my_buttons_fasync,
     
152.         .release = my_buttons_close,
     
153. };
     
154. 
     
155. int my_buttons_init(void){
     
156.         int ret;
     
157. 
     
158.         cdev_init(&cdev, &my_buttons_ops);
     
159.         cdev.owner = THIS_MODULE;
     
160. 
     
161.         ret = alloc_chrdev_region(&devno, 0, 1, "buttons");
     
162.         if(ret){
     
163.                 printk(KERN_ERR "alloc char device region faild!n");
     
164.                 return ret;
     
165.         }
     
166. 
     
167.         ret = cdev_add(&cdev, devno, 1);
     
168.         if(ret){
     
169.                 printk(KERN_ERR "add char device faild!n");
     
170.                 goto add_error;
     
171.         }
     
172. 
     
173.         my_buttons_class = class_create(THIS_MODULE, "buttonsdrv");
     
174.         if(IS_ERR(my_buttons_class)){
     
175.                 printk(KERN_ERR "create class error!n");
     
176.                 goto class_error;
     
177.         }
     
178. 
     
179.         my_buttons_device = device_create(my_buttons_class, NULL, devno, NULL, "buttons");
     
180.         if(IS_ERR(my_buttons_device)){
     
181.                 printk(KERN_ERR "create buttons device error!n");
     
182.                 goto device_error;
     
183.         }
     
184. 
     
185.         init_waitqueue_head(&my_button_waitq);
     
186. 
     
187.         return 0;
     
188. 
     
189. device_error:
     
190.         class_destroy(my_buttons_class);
     
191. class_error:
     
192.         cdev_del(&cdev);
     
193. add_error:
     
194.         unregister_chrdev_region(devno,1);
     
195. 
     
196.         return -ENODEV;
     
197. }
     
198. 
     
199. void my_buttons_exit(void){
     
200.         device_destroy(my_buttons_class, devno);
     
201.         class_destroy(my_buttons_class);
     
202.         cdev_del(&cdev);
     
203.         unregister_chrdev_region(devno, 1);
     
204. }
     
205. 
     
206. module_init(my_buttons_init);
     
207. module_exit(my_buttons_exit);
     
208. MODULE_LICENSE("GPL");
     
209. MODULE_AUTHOR("gjianw217@163.com");
     
210. MODULE_DESCRIPTION("Buttons' Driver");

复制代码

2应用程序：

1. #include
   
2. #include
   
3. #include
   
4. #include
   
5. #include
   
6. #include
   
7. void TestButtons1()
   
8. {
   
9. 
   
10.         int fd = open("/dev/buttons", O_RDWR);
    
11.         if(fd < 0){
    
12.                 printf("open error");;
    
13.                 return 0;
    
14.         }
    
15. 
    
16.         unsigned char key;
    
17.         while(1){
    
18.                 read(fd, &key, 1);
    
19.                 printf("The key = %xn", key);
    
20.         }
    
21. 
    
22.         close(fd);
    
23. }
    
24. 
    
25. 
    
26. void TestButtons2()
    
27. {
    
28. int fd;
    
29.         unsigned char key_val;
    
30.         int ret;
    
31. 
    
32.         struct pollfd fds[1];
    
33. 
    
34.         fd = open("/dev/buttons", O_RDWR);
    
35.         if (fd < 0){
    
36.                 printf("can't open!n");
    
37.         }
    
38. 
    
39.         fds[0].fd     = fd;
    
40.         fds[0].events = POLLIN;
    
41.         while (1){
    
42.                 ret = poll(fds, 1, 5000);
    
43.                 if (ret == 0){
    
44.                         printf("time outn");
    
45.                 }
    
46.                 else{
    
47.                         read(fd, &key_val, 1);
    
48.                         printf("key_val = 0x%xn", key_val);
    
49.                 }
    
50.         }
    
51. }
    
52. 
    
53. 
    
54. int asycfd;
    
55. 
    
56. void my_signal_fun(int signum)
    
57. {
    
58.     unsigned char key_val;
    
59.     read(asycfd, &key_val, 1);
    
60.     printf("key_val: 0x%xn", key_val);
    
61. }
    
62. 
    
63. void TestButtons3()
    
64. {
    
65. unsigned char key_val;
    
66.     int ret;
    
67.     int Oflags;
    
68. 
    
69.     signal(SIGIO, my_signal_fun);
    
70. 
    
71.     asycfd = open("/dev/buttons", O_RDWR | O_NONBLOCK);
    
72.     if (asycfd < 0){
    
73.         printf("can't open!n");
    
74.         return -1;
    
75.     }
    
76. 
    
77.     fcntl(asycfd, F_SETOWN, getpid());
    
78.     Oflags = fcntl(asycfd, F_GETFL);
    
79.     fcntl(asycfd, F_SETFL, Oflags | FASYNC);
    
80. 
    
81. 
    
82.     int rest;
    
83.     while (1){
    
84.         printf("Hellon");
    
85.         while(rest = sleep(50)){
    
86.             sleep(rest);
    
87.         }
    
88.     }
    
89. }
    
90. int main()
    
91. {
    
92.     //TestButtons1();
    
93. //    TestButtons2();
    
94.     TestButtons3();
    
95. 
    
96. }

复制代码

3Makefile：

1. #buttons Makefile
   
2. ARCH=arm
   
3. CROSS_COMPILE=/home/ok210/arm-2009q3/bin/arm-none-linux-gnueabi-
   
4. APP_COMPILE=/home/ok210/arm-2009q3/bin/arm-none-linux-gnueabi-
   
5. #obj-m := app-drv.o
   
6. obj-m := keys-drv.o
   
7. #KDIR := /path/to/kernel/linux/
   
8. KDIR := /home/ok210/android-kernel-samsung-dev/
   
9. PWD := $(shell pwd)
   
10. default:
    
11.         make -C $(KDIR) M=$(PWD) ARCH=$(ARCH) CROSS_COMPILE=$(CROSS_COMPILE) modules
    
12. app:keys-app.c
    
13.         $(APP_COMPILE)gcc -o app keys-app.c
    
14. clean:
    
15.         $(MAKE) -C $(KDIR) M=$(PWD) clean

复制代码

欢迎大家关注本人的微信公众号【口袋物联】,微信号为koudaiwulian。

沙发

chkconfig 发表于 2015-10-11 14:30:32

请问你上篇的 cat /dev/butions出现段错误，后来怎么解决的

板凳

gjianw217 发表于 2015-10-11 15:33:08

xianyoudian 发表于 2015-10-8 20:04
请问一下，我的程序中request_irq申请中断后，使用exec 5

仔细检查对应的引脚及地址，应该可以的！不行用我的代码试试

4#

gjianw217 发表于 2015-10-11 15:33:41

chkconfig 发表于 2015-10-11 14:30
请问你上篇的 cat /dev/butions出现段错误，后来怎么解决的

地址错误，认真检查代码！

5#

chkconfig 发表于 2015-10-11 19:38:17

能看看我的代码吗？模仿你写的。感激不尽