x4412&ibox项目实战43－Linux中断编程实验（二）

armeasy

在上面的实例中，进入中断后仅仅是将按键的值读取出来，系统开销非常的小。但是在实际应用中，在中断中执行的任务要复杂得多，它可能要耗用较大的时间来处理。为了在中断执行时间尽可能短和中断处理需完成大量工作之间找到一个平衡点，Linux将中断处理程序分解为两个半部：顶半部（top half）和底半部（bottom half）。

顶半部完成尽可能少的比较紧急的功能，它往往只是简单地读取寄存器中的中断状态并清除中断标志后就进行“登记中断”的工作。“登记中断”意味着将底半部处理程序挂到该设备的底半部执行队列中去。这样，顶半部执行的速度就会很快，可以服务更多的中断请求。

现在，中断处理工作的重心就落在了底半部的头上，它来完成中断事件的绝大多数任务。底半部几乎做了中断处理程序所有的事情，而且可以被新的中断打断，这也是底半部和顶半部的最大不同，因为顶半部往往被设计成不可中断。底半部则相对来说并不是非常紧急的，而且相对比较耗时，不在硬件中断服务程序中执行。

尽管顶半部、底半部的结合能够改善系统的响应能力，但是，僵化地认为Linux设备驱动中的中断处理一定要分两个半部则是不对的。如果中断要处理的工作本身很少，则完全可以直接在顶半部全部完成。比如前面的实验，中断中执行的任务相当少，就没有必要。

Linux系统实现底半部的机制主要有tasklet、工作队列和软中断。为了掌握他们的用法，将上一小节实验的内容通过tasklet机制实现。在kernel/drivers/char/x4412目录下新建驱动程序x4412-eint-tasklet.c文件，编辑内容如下：

1. #include <linux/irq.h>  
   
2. #include <linux/interrupt.h>
   
3. #include <linux/module.h>
   
4. #include <linux/types.h>
   
5. #include <linux/fs.h>
   
6. #include <linux/errno.h>
   
7. #include <linux/sched.h>
   
8. #include <linux/init.h>
   
9. #include <linux/cdev.h>
   
10. #include <asm/uaccess.h>
    
11. #include <linux/slab.h>
    
12. #include <linux/device.h>
    
13. #include <mach/gpio.h>
    
14. /* 定义并初始化等待队列头 */
    
15. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
    
16. static struct class *cdrv_class;
    
17. static struct device *cdrv_device;
    
18. void x4412_eint_do_tasklet(unsigned long data);
    
19. DECLARE_TASKLET(x4412_eint_tasklet,x4412_eint_do_tasklet,0);
    
20. typedef struct pin_desc
    
21. {
    
22.          unsigned int pin;
    
23.          unsigned int key_val;
    
24. }pin_desc;
    
25. static struct pin_desc pins_desc[6] =
    
26. {
    
27.         {EXYNOS4_GPX1(0),0x01},//LEFT
    
28.         {EXYNOS4_GPX1(3),0x02},//RIGHT
    
29.         {EXYNOS4_GPX1(2),0x03},//UP
    
30.             {EXYNOS4_GPX1(1),0x04},//DOWN
    
31.           {EXYNOS4_GPX1(5),0x05},//MENU
    
32.             {EXYNOS4_GPX1(4),0x06},//BACK
    
33. };
    
34. 
    
35. struct pin_desc *pin_desc_p;
    
36. static unsigned char key_val;
    
37. static int ev_press = 0;
    
38. int major;
    
39. 
    
40. void x4412_eint_do_tasklet(unsigned long data)
    
41. {
    
42.          unsigned int pinval;
    
43.          pinval = gpio_get_value(pin_desc_p->pin);
    
44.          if(pinval)
    
45.          {
    
46.                    key_val = 0x80 | (pin_desc_p->key_val);//松开
    
47.          }
    
48.          else
    
49.          {
    
50.                    key_val = pin_desc_p->key_val;// 按下
    
51.          }
    
52.          ev_press = 1;
    
53.          printk("eint occured.\r\n");
    
54.          wake_up_interruptible(&button_waitq);
    
55. }
    
56. /* 用户中断处理函数 */
    
57. static irqreturn_t x4412_buttons_irq(int irq, void *dev_id)
    
58. {
    
59.          pin_desc_p = (struct pin_desc *)dev_id;
    
60.          tasklet_schedule(&x4412_eint_tasklet);
    
61.          return IRQ_HANDLED;
    
62. }
    
63. static int x4412_eint_open(struct inode * inode, struct file * filp)
    
64. {
    
65.          return 0;
    
66. }
    
67. static ssize_t x4412_eint_read(struct file *file, char __user *buf, size_t count,loff_t *ppos)
    
68. {
    
69.          if (count != 1)
    
70.                    return -EINVAL;     
    
71.          wait_event_interruptible(button_waitq, ev_press);
    
72.          if(copy_to_user(buf, &key_val, 1))
    
73.                    return -EFAULT;
    
74.          ev_press = 0;
    
75.          return 1;
    
76. }
    
77. static int x4412_eint_release(struct inode *inode, struct file *file)
    
78. {
    
79.          int irq;
    
80.          irq = gpio_to_irq(pins_desc[0].pin);
    
81.          free_irq(irq, &pins_desc[0]);
    
82.          irq = gpio_to_irq(pins_desc[1].pin);
    
83.          free_irq(irq,&pins_desc[1]);
    
84.          irq = gpio_to_irq(pins_desc[2].pin);
    
85.          free_irq(irq,&pins_desc[2]);
    
86.        irq = gpio_to_irq(pins_desc[3].pin);
    
87.          free_irq(irq, &pins_desc[3]);
    
88.          irq = gpio_to_irq(pins_desc[4].pin);
    
89.          free_irq(irq,&pins_desc[4]);
    
90.          irq = gpio_to_irq(pins_desc[5].pin);
    
91.          free_irq(irq,&pins_desc[5]);
    
92.          return 0;
    
93. }
    
94. static const struct file_operations x4412_eint_fops =
    
95. {
    
96.          .owner = THIS_MODULE,
    
97.          .read = x4412_eint_read,
    
98.          .open = x4412_eint_open,
    
99.          .release = x4412_eint_release,
    
100. };
     
101. /* 驱动入口函数 */
     
102. static int x4412_eint_init(void)
     
103. {
     
104.          int ret,irq;
     
105.          major = register_chrdev(0, "x4412-key", &x4412_eint_fops);
     
106.          cdrv_class = class_create(THIS_MODULE, "x4412-eint");
     
107.          cdrv_device = device_create(cdrv_class, NULL, MKDEV(major, 0), NULL, "x4412-eint");
     
108.          irq = gpio_to_irq(pins_desc[0].pin);
     
109.          ret = request_irq(irq, x4412_buttons_irq,IRQ_TYPE_EDGE_BOTH,  "LEFT", &pins_desc[0]);
     
110.          if(ret)
     
111.                    printk("request irq_eint8 error!\r\n");
     
112.          irq = gpio_to_irq(pins_desc[1].pin);
     
113.          ret = request_irq(irq, x4412_buttons_irq,IRQ_TYPE_EDGE_BOTH, "RIGHT",&pins_desc[1]);
     
114.          if(ret)
     
115.                    printk("request irq_eint11 error!\r\n");
     
116.          irq = gpio_to_irq(pins_desc[2].pin);
     
117.          ret = request_irq(irq, x4412_buttons_irq, IRQ_TYPE_EDGE_BOTH, "UP",   &pins_desc[2]);
     
118.          if(ret)
     
119.                    printk("request irq_eint10 error!\r\n");
     
120.          irq = gpio_to_irq(pins_desc[3].pin);
     
121.          ret = request_irq(irq, x4412_buttons_irq, IRQ_TYPE_EDGE_BOTH, "DOWN", &pins_desc[3]);
     
122.          if(ret)
     
123.                    printk("request irq_eint9 error!\r\n");
     
124.          irq = gpio_to_irq(pins_desc[4].pin);
     
125.          ret = request_irq(irq, x4412_buttons_irq, IRQ_TYPE_EDGE_BOTH, "MENU", &pins_desc[4]);
     
126.          if(ret)
     
127.                    printk("request irq_eint13 error!\r\n");
     
128.          irq = gpio_to_irq(pins_desc[5].pin);
     
129.          ret = request_irq(irq, x4412_buttons_irq, IRQ_TYPE_EDGE_BOTH, "BACK", &pins_desc[5]);
     
130.          if(ret)
     
131.                    printk("request irq_eint12 error!\r\n");
     
132.          pin_desc_p = kmalloc(sizeof(struct pin_desc), GFP_KERNEL);
     
133.          if(!pin_desc_p)
     
134.          {
     
135.                    return -ENOMEM;
     
136.          }
     
137.          return 0;
     
138. }
     
139. /* 驱动出口函数 */
     
140. static void x4412_eint_exit(void)
     
141. {
     
142.          unregister_chrdev(major, "x4412-key");
     
143.          device_unregister(cdrv_device);  //卸载类下的设备
     
144.          class_destroy(cdrv_class);       //卸载类
     
145. }
     
146. module_init(x4412_eint_init);  //用于修饰入口函数
     
147. module_exit(x4412_eint_exit);  //用于修饰出口函数     
     
148. MODULE_AUTHOR("www.9tripod.com");
     
149. MODULE_LICENSE("GPL");

复制代码

       和前一小节的源码比较，不然发现使用tasklet相当的简单，在程序的开始声明tasklet的执行函数，并通过DECLARE_TASKLET宏关联该执行函数：

1. void x4412_eint_do_tasklet(unsigned long data);
   
2. DECLARE_TASKLET(x4412_eint_tasklet,x4412_eint_do_tasklet,0);

复制代码

       在中断顶半部，即x4412_buttons_irq 函数中引用tasklet_schedule函数就能使系统在适当的时候调度运行：

1. tasklet_schedule(&x4412_eint_tasklet);

复制代码

       值得说明的是，在上一小节的中断服务线程中通过dev_id传入了pins_desc结构体，因此程序中定义了一个全局结构体指针，用于将dev_id传入到中断顶关部的结构体引用到中断底半部中。

       编辑kernel/drivers/char/x4412/Kconfig文件，添加如下语句：

1. config X4412_EINT_TASKLET_DRIVER
   
2.          tristate "x4412 eint tasklet driver"
   
3.          default m
   
4.          help
   
5.          compile for x4412 eint tasklet driver,y for kernel,m for module.

复制代码

       编辑kernel/drivers/char/x4412/Makefile文件，添加如下语句：

1. obj-$(CONFIG_X4412_EINT_TASKLET_DRIVER) += x4412-eint-tasklet.o

复制代码

       编译内核，加载驱动后测试驱动模块，观察和上一章节的现象是否相同。