6.Linux按键驱动-阻塞与非阻塞

默认打开文件时间是阻塞的

1. 当设置打开方式为非阻塞时，无数据时会返回。
2. 当设置打开方式为阻塞时，无数据的时候会等待

复制代码

1.设置打开方式为非阻塞

立即返回，无法读出，返回-1

2.设置为阻塞

焦点在于驱动程序中的.read函数的支持

3.代码实现
应用程序：

1. #include <stdio.h>
2. #include <sys/types.h>
3. #include <sys/stat.h>
4. #include <fcntl.h>
5. #include <unistd.h>
6. #include <poll.h>
7. #include <signal.h>
9. static int fd;
11. /* 信号处理函数 */
12. /*static void sig_func(int sig)
13. {
14.         int val;
15.         int num;
16.         read(fd,&val,4);
17.         num  = val >>8;
18.         printf("get button: %d val = %d\n", num, val - num *(1 << 8));
19. }*/
21. int main(int argc, char** argv)
22. {
23.        
24.         int val;
25.         int num;
26.         struct pollfd fds[1];
27.         int timeout_ms = 5000;
28.         int ret;
29.         int flags;
30.         int i;
31.         /* 判断输入值是否合法 */
32.         if(argc != 2)
33.         {
34.                 printf("Usage ./button_app /dev/devname\n");
35.                 return -1;
36.         }
38.         fd = open(argv[1], O_RDONLY);
39.         if (fd == -1)
40.         {
41.                 printf("open err\n");
42.         }
43.         else
44.         {
45.                 printf("open success\n");
46.         }
48.         /* 初始化文件监听描述符 */
49.         /*fds[0].fd     = fd;
50.         fds[0].events = POLLIN;*/
52.         /*绑定SIGIO和sig_func */
53.         //signal(SIGIO, sig_func);
54.        
55.         /* APP把自己的pid告诉驱动 */
56.         //fcntl(fd, F_SETOWN, getpid());/* APP把自己的pid告诉驱动程序 */
57.         //flags = fcntl(fd,F_GETFL);/* 获得标志位 */
58.         //fcntl(fd, F_SETFL, flags | FASYNC);/* 使能异步通知 */
59.         //printf("设置了FASYNC\n");
60.         /*while(1)
61.         {
62.                 printf("www.100ask.net \n");
63.                 sleep(2);
64.         }*/
65.        
66.        
67.         /*while(1)
68.         {
69.                 ret = poll(fds, 1, timeout_ms);
70.                 if((ret == 1) && (fds[0].revents == POLLIN))
71.                 {
72.                         read(fd, &val, 4);
73.                         num  = val >>8;
74.                         printf("get button: %d val = %d\n", num, val - num *(1 << 8));
75.                 }
76.                 else
77.                 {
78.                         printf("timeout\n");
79.                 }
80.         }*/
82.         /* 设置打开方式为非阻塞 */
83.         fcntl(fd,F_SETFL,O_NONBLOCK);
84.         for (i = 0; i < 10; i++)
85.         {
86.                 if (read(fd, &val, 4) == 4)
87.                         printf("get button: 0x%x\n", val);
88.                 else
89.                         printf("get button: -1\n");
90.         }
92.         /* 设置打开方式为阻塞 */
93.         flags = fcntl(fd,F_GETFL);
94.         fcntl(fd,F_SETFL,flags & ~O_NONBLOCK);
95.         while(1)
96.         {
97.                 if (read(fd, &val, 4) == 4)
98.                 {
99.                         num  = val >>8;
100.                         printf("get button: %d val = %d\n", num, val - num *(1 << 8));
101.                 }
102.                 else
103.                         printf("get button: -1\n");
104.         }
106.        
107.         close(fd);
108.         return 0;
109. }

复制代码

驱动程序：

1. #include <linux/module.h>
2. #include <linux/fs.h>
3. #include <linux/errno.h>
4. #include <linux/miscdevice.h>
5. #include <linux/kernel.h>
6. #include <linux/major.h>
7. #include <linux/mutex.h>
8. #include <linux/proc_fs.h>
9. #include <linux/seq_file.h>
10. #include <linux/stat.h>
11. #include <linux/init.h>
12. #include <linux/device.h>
13. #include <linux/tty.h>
14. #include <linux/kmod.h>
15. #include <linux/gfp.h>
16. #include <linux/gpio/consumer.h>
17. #include <linux/platform_device.h>
18. #include <linux/of_gpio.h>
19. #include <linux/of_irq.h>
20. #include <linux/interrupt.h>
21. #include <linux/irq.h>
22. #include <linux/slab.h>
23. #include <linux/poll.h>
24. #include <linux/fcntl.h>
26. /* 定义结构体来描述gpio */
27. struct gpio_key{
28.         int gpio;
29.         struct gpio_desc* gpiod;
30.         int flag;
31.         int irq;
32. };
34. /* 定义全局变量来存储设备树中的所有gpio节点信息 */
35. static struct gpio_key* gpio_keys_100ask;
37. /* 字符设备的主设备号 */
38. static unsigned int major = 0;
39. static struct class *gpio_class;
40. //static int g_key = 0;
42. /* 定义等待队列 */
43. static DECLARE_WAIT_QUEUE_HEAD(gpio_key_wait);
44. struct fasync_struct * button_fasync;
46. /* 环形缓冲区 */
47. #define BUF_LEN 128
48. static int g_keys[BUF_LEN];
49. static int r, w;
51. #define NEXT_POS(x) ((x+1) % BUF_LEN)
53. int is_key_buf_empty(void)
54. {
55.         return (r == w);
56. }
58. int is_key_buf_full(void)
59. {
60.         return (r == NEXT_POS(w));
61. }
63. void put_key(int key)
64. {
65.         if (!is_key_buf_full())
66.         {
67.                 g_keys[w] = key;
68.                 w = NEXT_POS(w);
69.         }
70. }
72. int get_key(void)
73. {
74.         int key = 0;
75.         if (!is_key_buf_empty())
76.         {
77.                 key = g_keys[r];
78.                 r = NEXT_POS(r);
79.         }
80.         return key;
81. }
83. static ssize_t gpio_read(struct file *fp, char __user *buf, size_t size, loff_t * offset)
84. {
85.         int err;
86.         int key;
87.         if(is_key_buf_empty() && (fp->f_flags & O_NONBLOCK))
88.         {
89.                 return -EAGAIN;
90.         }
91.         //wait_event_interruptible(gpio_key_wait, !is_key_buf_empty());
92.         key = get_key();
93.         //err = copy_to_user(buf, &g_key, 4);
94.         err = copy_to_user(buf, &key, 4);
95.         //g_key = 0;
96.         //printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
97.         return 4;
98. }
100. static unsigned int gpio_poll(struct file *fp, struct poll_table_struct *wait)
101. {
102.         //printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
103.         poll_wait(fp, &gpio_key_wait, wait);
104.         return is_key_buf_empty() ? 0 : POLLIN | POLLRDNORM;
105. }
107. static int gpio_fasync(int fd , struct file *file, int on)
108. {
109.         //printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
110.         if (fasync_helper(fd, file, on, &button_fasync) >= 0)
111.         {
112.                 return 0;
113.         }
114.         else
115.         {
116.                 return -EIO;
117.         }
118. }
120. static const struct file_operations gpio_fops = {
121.         .owner = THIS_MODULE,
122.         .read  = gpio_read,
123.         .poll  = gpio_poll,
124.         .fasync = gpio_fasync,
125. };
127. static irqreturn_t gpio_key_isr(int irq, void *dev_id)
128. {
129.         struct gpio_key* gpio_key = dev_id;
130.         int val;
131.         int key;
132.         val = gpio_get_value(gpio_key->gpio);
133.         //printk("key %d %d\n", gpio_key->gpio, val);
134.         //g_key = (gpio_key->gpio << 8) | val;
135.         key = (gpio_key->gpio << 8) | val;
136.        
137.         put_key(key);
138.         wake_up_interruptible(&gpio_key_wait);
140.         /* 发信号 */
141.         kill_fasync(&button_fasync, SIGIO, POLL_IN);
142.         //printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
143.         return IRQ_HANDLED;
144. }
146. static int gpio_probe(struct platform_device *pdev)
147. {
148.         int count, i;
149.         struct device_node *node;
150.         int err;
152.         node = pdev->dev.of_node;
153.         count = of_gpio_count(node);
154.         if (!count)
155.         {
156.                 printk("%s %s line %d, there isn't any gpio available\n", __FILE__, __FUNCTION__, __LINE__);
157.                 return -1;
158.         }
159.        
160.         /* 申请资源 */
161.         gpio_keys_100ask = kzalloc(sizeof(struct gpio_key) * count, GFP_KERNEL);
162.         if (!gpio_keys_100ask)
163.         {
164.                 printk("kzalloc error\n");
165.                 return -1;
166.         }
168.         /* 获得资源 */
169.         for (i = 0; i < count; i++)
170.         {
171.                 gpio_keys_100ask[i].gpio = of_get_gpio(node, i);
172.                 if (gpio_keys_100ask[i].gpio < 0)
173.                 {
174.                         printk("%s %s line %d, of_get_gpio_flags fail\n", __FILE__, __FUNCTION__, __LINE__);
175.                         return -1;
176.                 }
177.                 gpio_keys_100ask[i].gpiod = gpio_to_desc(gpio_keys_100ask[i].gpio);
178.                 gpio_keys_100ask[i].irq   = gpio_to_irq(gpio_keys_100ask[i].gpio);
180.                 /* 申请中断 */
181.                 err = request_irq(gpio_keys_100ask[i].irq, gpio_key_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "test1_gpio_keys_100ask", &gpio_keys_100ask[i]);
182.                 if (err)
183.                 {
184.                         printk("request_irq err\n");
185.                 }
186.         }
188.         /* 注册字符设备 */
189.         major = register_chrdev(major, "100ask_key", &gpio_fops);
190.         if(major < 0)
191.         {
192.                 printk("register_chrdev err'\n");
193.                 return -1;
194.         }
196.         /* 注册类 */
197.         gpio_class = class_create(THIS_MODULE, "100ask_key_class");
199.         /* 注册设备 */
200.         device_create(gpio_class, NULL, MKDEV(major,0), NULL, "100ask_key_button");
201.         printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
202.         return 0;
203. }
205. static int gpio_remove(struct platform_device *pdev)
206. {
207.         int count, i;
208.         struct device_node *node;
210.         node = pdev->dev.of_node;
211.         count = of_gpio_count(node);
212.         device_destroy(gpio_class, MKDEV(major,0));
213.         class_destroy(gpio_class);
214.         unregister_chrdev(major, "100ask_key");
216.         for (i = 0; i < count; i++)
217.         {
218.                 free_irq(gpio_keys_100ask[i].irq, &gpio_keys_100ask[i]);
219.         }
220.         kfree(gpio_keys_100ask);
221.         printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
222.         return 0;
223. }
225. /*
226. * 在设备树中添加的节点的compatible属性为："test1_100ask,test1_gpio_key"
227. */
228. static const struct of_device_id gpio_key_of_match[] = {
229.         {.compatible = "test1_100ask,test1_gpio_key"},
230.         {/* 这里必须要有一个空项，表示结束 */}
231. };
233. static struct platform_driver gpio_driver = {
234.         .driver = {
235.                 .name        = "test1_gpio_keys_100ask",
236.                 .of_match_table = gpio_key_of_match,
237.         },
238.         .probe        = gpio_probe,
239.         .remove = gpio_remove,
240. };
242. /* 基于platform总线来实现这个程序 */
243. static int gpio_init(void)  
244. {
245.         int ret;
247.         ret = platform_driver_register(&gpio_driver);
248.         if (ret != 0)
249.         {
250.                 printk("platform_driver_register err\n");
251.                 return -1;
252.         }
253.         else
254.         {
255.                 printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
256.         }
257.         return ret;
258. }
260. static void gpio_exit(void)
261. {
262.         platform_driver_unregister(&gpio_driver);
263.         printk("%s %s line %d\n", __FILE__, __FUNCTION__, __LINE__);
264. }
266. module_init(gpio_init);
267. module_exit(gpio_exit);
268. MODULE_LICENSE("GPL");

复制代码

4.代码路径：

1. /home/book/nfs_rootfs/CSDN/01_gpio_irq/06_read_key_irq_poll_fasync_block

复制代码