阻塞型驱动设计

阻塞型驱动设计
1.阻塞的必要性
当一个设备无法立刻满足用户的读写请求时应当如何处理？ 例如：调用read时，设备没有数据提供, 但以后可能会有；或者一个进程试图向设备写入数据，但是设备暂时没有准备好接收数据。当上述情况发生的时候，驱动程序应当(缺省地)阻塞进程，使它进入等待（睡眠）状态，直到请求可以得到满足。

A准备对B（驱动程序）读取数据，B说现在还没数据。请A先进候车室等待，B之后有了数据。B就将A唤醒。

2.内核等待队列
在实现阻塞驱动的过程中，也需要有一个“候车室”来安排被阻塞的进程“休息”，当唤醒它们的条件成熟时，则可以从“候车室”中将这些进程唤醒。而这个“候车室”就是等待队列。

1、定义等待队列

wait_queue_head_t my_queue

2、初始化等待队列

init_waitqueue_head(&my_queue);

3、定义+初始化等待队列

DECLARE_WAIT_QUEUE_HEAD(my_queue);

3.进入等待队列，睡眠

  wait_event(queue,condition)

当condition(布尔表达式)为真时，立即返回；否则让进程进入TASK_UNINTERRUPTIBLE模式的睡眠，并挂在queue参数所指定的等待队列上。

 wait_event_interruptible(queue,condition)

当condition(布尔表达式)为真时，立即返回；否则让进程进入TASK_INTERRUPTIBLE的睡眠，并挂在queue参数所指定的等待队列上。

 int wait_event_killable(queue, condition)

当condition(一个布尔表达式)为真时，立即返回；否则让进程进入TASK_KILLABLE的睡眠，并挂在queue参数所指定的等待队列上。

4.从等待队列中唤醒进程
  wake_up(wait_queue_t *q)

从等待队列q中唤醒状态为TASK_UNINTERRUPTIBLE，TASK_INTERRUPTIBLE，TASK_KILLABLE 的所有进程。

  wake_up_interruptible(wait_queue_t *q)

从等待队列q中唤醒状态为TASK_INTERRUPTIBLE 的进程。

5.对按键程序进行改造
key.c

1. #include <linux/module.h>
   
2. #include <linux/init.h>
   
3. #include <linux/miscdevice.h>
   
4. #include <linux/fs.h>
   
5. #include <asm/uaccess.h>
   
6. #include <linux/io.h>
   
7. #include <linux/irqreturn.h>
   
8. #include <linux/interrupt.h>
   
9. #include <linux/uaccess.h>
   
10. 
    
11. #define GPFCON (volatile unsigned long*) 0x56000050
    
12. #define GPFDAT (volatile unsigned long*) 0x56000054
    
13. 
    
14. unsigned int *gpio_data;
    
15. 
    
16. struct work_struct *work1;
    
17. struct timer_list key_timer;
    
18. wait_queue_head_t key_q;
    
19. 
    
20. unsigned int key_num = 0;
    
21. 
    
22. void key_timer_func(unsigned long data)
    
23. {
    
24.     unsigned int key_val;
    
25.     key_val = readw(gpio_data);
    
26.     if((key_val & 0x01) == 0)
    
27.     {
    
28.         key_num = 4;
    
29.     }
    
30.     else if((key_val& 0x02) == 0)
    
31.     {
    
32.         key_num = 1;
    
33.     }
    
34.     else if((key_val & 0x04) == 0)
    
35.     {
    
36.         key_num = 3;
    
37.     }
    
38.     else if((key_val & 0x10) == 0)
    
39.     {
    
40.         key_num = 2;
    
41.     }
    
42. 
    
43.     wake_up(&key_q);                                 //唤醒进程
    
44. }
    
45. 
    
46. void work1_func(struct work_struct *work)
    
47. {
    
48.     mod_timer(&key_timer, jiffies + HZ/10);
    
49. }
    
50. 
    
51. irqreturn_t key_int(int irq, void *dev_id)
    
52. {
    
53.     //1.检测是否发生了按键中断
    
54.     
    
55.     //2.清除已经发生的按键中断
    
56.    
    
57.     //3.提交下半部
    
58.     schedule_work(work1);
    
59. 
    
60.     return 0;
    
61. }
    
62. 
    
63. void key_hw_init()
    
64. {
    
65.     unsigned int *gpio_config;
    
66.     unsigned short data;
    
67.     
    
68.     gpio_config = ioremap(GPFCON, 4);
    
69.     gpio_data = ioremap(GPFDAT, 4);
    
70.     data = readw(gpio_config);
    
71.     data &= ~0x33f;
    
72.     data |= 0x22a;
    
73.     writew(data, gpio_config);
    
74. }
    
75. 
    
76. int key_open(struct inode *inode, struct file *filp)
    
77. {
    
78.     return 0;
    
79. }
    
80. 
    
81. ssize_t key_read(struct file *filp, char __user *buf, size_t size, loff_t *pos)
    
82. {
    
83.     wait_event(key_q, key_num);                                 //进入睡眠
    
84. 
    
85.     printk("in kernel :key num is %d\n",key_num);
    
86.     copy_to_user(buf, &key_num, 4);
    
87. 
    
88.     key_num = 0;
    
89. 
    
90.     return 4;
    
91. }
    
92. 
    
93. struct file_operations key_fops = {
    
94.     .open = key_open,
    
95.     .read = key_read,
    
96. };
    
97. 
    
98. struct miscdevice key_miscdev = {
    
99.     .minor = 200,
    
100.     .name = "tq2400key",
     
101.     .fops = &key_fops,
     
102. };
     
103. 
     
104. static int button_init()
     
105. {
     
106.     int ret;
     
107.     ret = misc_register(&key_miscdev);
     
108.     if(ret != 0)
     
109.     {
     
110.         printk(KERN_ERR"misc_register failed\n");
     
111.     }
     
112.     //按键初始化
     
113.     key_hw_init();
     
114. 
     
115.     //注册中断处理程序
     
116.     ret = request_irq(IRQ_EINT0, &key_int, IRQF_TRIGGER_FALLING, "tq2440key", 0);
     
117.     ret = request_irq(IRQ_EINT1, &key_int, IRQF_TRIGGER_FALLING, "tq2440key", 0);
     
118.     ret = request_irq(IRQ_EINT2, &key_int, IRQF_TRIGGER_FALLING, "tq2440key", 0);
     
119.     ret = request_irq(IRQ_EINT4, &key_int, IRQF_TRIGGER_FALLING, "tq2440key", 0);
     
120. 
     
121.     //创建工作
     
122.     work1 = kmalloc(sizeof(struct work_struct), GFP_KERNEL);
     
123.     INIT_WORK(work1, work1_func);
     
124. 
     
125.     //初始化定时器
     
126.     init_timer(&key_timer);
     
127.     key_timer.function = key_timer_func;
     
128. 
     
129.     //注册定时器
     
130.     add_timer(&key_timer);
     
131. 
     
132.     //初始化等待队列
     
133.     init_waitqueue_head(&key_q);                                //初始化等待队列
     
134.     return 0;
     
135. }
     
136. 
     
137. static void button_exit()
     
138. {
     
139.     misc_deregister(&key_miscdev);
     
140.     //注销中断处理函数
     
141.     free_irq(IRQ_EINT0, 0);
     
142.     free_irq(IRQ_EINT1, 0);
     
143.     free_irq(IRQ_EINT2, 0);
     
144.     free_irq(IRQ_EINT4, 0);
     
145. }
     
146. 
     
147. module_init(button_init);
     
148. module_exit(button_exit);