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

armeasy

在Linux设备驱动中，使用中断的设备需要申请和释放对应的中断，分别使用内核提供的request_irq()和free_irq()函数。

1. 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：向系统登记的中断处理函数，是一个回调函数，中断发生时，系统调用这个函数，dev_id参数将被传递给它。

irqflags：中断处理的属性，若设置了SA_INTERRUPT，则表示中断处理程序是快速处理程序，快速处理程序被调用时屏蔽所有中断，慢速处理程序不屏蔽；若设置了SA_SHIRQ，则表示多个设备共享中断，dev_id在中断共享时会用到，一般设置为这个设备的设备结构体或者NULL。

devname：中断描述文件，每一个中断可指定一种中断描述名。

dev_id：传递给handler或设置为NULL。

request_irq()返回0表示成功，返回-INVAL表示中断号无效或处理函数指针为NULL，返回-EBUSY 表示中断已经被占用且不能共享。

与request_irq()向对应的函数为free_irq()，它的原型如下：

1. void free_irq(unsigned int irq,void *dev_id);

复制代码

free_irq()中参数的定义与request_irq()相同。

编写一个驱动模块，通过request_irq函数实现按键中断，卸载驱动时通过free_irq函数释放中断资源。

在kernel/drivers/char/x4412目录下新建x4412-eint.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. /* 定义并初始化等待队列头 */
    
16. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
    
17. static struct class *cdrv_class;
    
18. static struct device *cdrv_device;
    
19. typedef struct pin_desc
    
20. {
    
21.          unsigned int pin;
    
22.          unsigned int key_val;
    
23. }pin_desc;
    
24. 
    
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. /* 键值: 按下时, 0x01,0x02,0x03,0x04,0x05,0x06 */
    
35. /* 键值: 松开时, 0x81,0x82,0x83,0x84,0x05,0x06 */
    
36. static unsigned char key_val;
    
37. static int ev_press = 0;
    
38. int major;
    
39. /* 用户中断处理函数 */
    
40. static irqreturn_t x4412_buttons_irq(int irq, void *dev_id)
    
41. {
    
42.          struct pin_desc *pindesc = (struct pin_desc *)dev_id;
    
43.          unsigned int pinval;
    
44.          printk("eint occured..\r\n");
    
45.          pinval = gpio_get_value(pindesc->pin);
    
46.          if(pinval)
    
47.          {
    
48.                    key_val = 0x80 | (pindesc->key_val);/* 松开 */  
    
49.          }
    
50.          else
    
51.          {
    
52.                    key_val = pindesc->key_val;/* 按下 */
    
53.          }
    
54.          ev_press = 1;                           /* 表示中断已经发生 */
    
55.          wake_up_interruptible(&button_waitq);   /* 唤醒休眠的进程 */
    
56.          return IRQ_HANDLED;
    
57. }
    
58. 
    
59. static int x4412_eint_open(struct inode * inode, struct file * filp)
    
60. {
    
61.          return 0;
    
62. }
    
63. static ssize_t x4412_eint_read(struct file *file, char __user *buf, size_t count,loff_t *ppos)
    
64. {
    
65.          if (count != 1)
    
66.                    return -EINVAL;     
    
67.          wait_event_interruptible(button_waitq, ev_press);
    
68.          if(copy_to_user(buf, &key_val, 1))
    
69.                    return -EFAULT;
    
70.          ev_press = 0;
    
71.          return 1;
    
72. }
    
73. static int x4412_eint_release(struct inode *inode, struct file *file)
    
74. {
    
75.          int irq;
    
76.          irq = gpio_to_irq(pins_desc[0].pin);
    
77.          free_irq(irq, &pins_desc[0]);
    
78.          irq = gpio_to_irq(pins_desc[1].pin);
    
79.          free_irq(irq,&pins_desc[1]);
    
80.          irq = gpio_to_irq(pins_desc[2].pin);
    
81.          free_irq(irq,&pins_desc[2]);
    
82.        irq = gpio_to_irq(pins_desc[3].pin);
    
83.          free_irq(irq, &pins_desc[3]);
    
84.          irq = gpio_to_irq(pins_desc[4].pin);
    
85.          free_irq(irq,&pins_desc[4]);
    
86.          irq = gpio_to_irq(pins_desc[5].pin);
    
87.          free_irq(irq,&pins_desc[5]);
    
88.          return 0;
    
89. }
    
90. static const struct file_operations x4412_eint_fops =
    
91. {
    
92.          .owner = THIS_MODULE,
    
93.          .read = x4412_eint_read,
    
94.          .open = x4412_eint_open,
    
95.          .release = x4412_eint_release,
    
96. };
    
97. /* 驱动入口函数 */
    
98. static int x4412_eint_init(void)
    
99. {
    
100.          int ret,irq;
     
101.          major = register_chrdev(0, "x4412-key", &x4412_eint_fops);
     
102.          cdrv_class = class_create(THIS_MODULE, "x4412-eint");
     
103.          cdrv_device = device_create(cdrv_class, NULL, MKDEV(major, 0), NULL, "x4412-eint");
     
104.          irq = gpio_to_irq(pins_desc[0].pin);
     
105.          ret = request_irq(irq, x4412_buttons_irq,IRQ_TYPE_EDGE_BOTH,  "LEFT", &pins_desc[0]);
     
106.          if(ret)
     
107.                    printk("request irq_eint8 error!\r\n");
     
108.          irq = gpio_to_irq(pins_desc[1].pin);
     
109.          ret = request_irq(irq, x4412_buttons_irq,IRQ_TYPE_EDGE_BOTH, "RIGHT",&pins_desc[1]);
     
110.          if(ret)
     
111.                    printk("request irq_eint11 error!\r\n");
     
112.          irq = gpio_to_irq(pins_desc[2].pin);
     
113.          ret = request_irq(irq, x4412_buttons_irq, IRQ_TYPE_EDGE_BOTH, "UP",   &pins_desc[2]);
     
114.          if(ret)
     
115.                    printk("request irq_eint10 error!\r\n");
     
116.          irq = gpio_to_irq(pins_desc[3].pin);
     
117.          ret = request_irq(irq, x4412_buttons_irq, IRQ_TYPE_EDGE_BOTH, "DOWN", &pins_desc[3]);
     
118.          if(ret)
     
119.                    printk("request irq_eint9 error!\r\n");
     
120.          irq = gpio_to_irq(pins_desc[4].pin);
     
121.          ret = request_irq(irq, x4412_buttons_irq, IRQ_TYPE_EDGE_BOTH, "MENU", &pins_desc[4]);
     
122.          if(ret)
     
123.                    printk("request irq_eint13 error!\r\n");
     
124.          irq = gpio_to_irq(pins_desc[5].pin);
     
125.          ret = request_irq(irq, x4412_buttons_irq, IRQ_TYPE_EDGE_BOTH, "BACK", &pins_desc[5]);
     
126.          if(ret)
     
127.                    printk("request irq_eint12 error!\r\n");
     
128.          return 0;
     
129. }
     
130. /* 驱动出口函数 */
     
131. static void x4412_eint_exit(void)
     
132. {
     
133.          unregister_chrdev(major, "x4412-key");
     
134.          device_unregister(cdrv_device);  //卸载类下的设备
     
135.          class_destroy(cdrv_class);       //卸载类
     
136. }
     
137. module_init(x4412_eint_init);  //用于修饰入口函数
     
138. module_exit(x4412_eint_exit);  //用于修饰出口函数     
     
139. MODULE_AUTHOR("www.9tripod.com");
     
140. MODULE_LICENSE("GPL");

复制代码

       驱动模块在x4412_eint_init函数中通过gpio_to_irq函数获取开发板上六个按键对应的GPIO口的中断号，再通过request_irq函数申请中断。在中断服务线程x4412_buttons_irq中通过gpio_get_value函数获取当前按键的按下或抬起状态，并保存在变量key_val中。在x4412_eint_read函数中通过copy_to_user函数向上层上报按键键值及按下或抬起的状态。

       在驱动模块中添加了等待队列机制。程序开始声明并初始化了等待队列头：

1. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);

复制代码

       在读函数中，调用wait_event_interruptible函数定义了一个等待事件，它允许被中断打断。

1. wait_event_interruptible(button_waitq, ev_press);

复制代码

       在应用程序通过read函数从驱动模块中读取键值时，如果没有中断产生，将一时处于等待状态。每当产生一次中断，ev_press将被清零，应用程序再次调用时，在没有中断产生的情况下又会进入等待状态。

       在中断服务线程中，每当产生一次中断，将通过wake_up_interruptible函数唤醒等待队列，读函数中的等待队列被唤醒，应用程序将会读到按键键值。

       将内核中默认的按键中断驱动取消，通过menuconfig即可配置：

1. Device Drivers  ---> Input device support  ---> Keyboards  ---> GPIO Buttons

复制代码

       取消选中即可，否则将会与现有驱动冲突。编辑kernel/drivers/char/x4412/Kconfig文件，添加以下内容：

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

复制代码

       编辑kernel/drivers/char/x4412/Makefile文件，添加以下内容：

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

复制代码

       编译内核，在kernel/drivers/char/x4412目录下将会生成目标映像x4412-eint.ko。

       在ubuntu的用户目录或samba目录下新建测试程序x4412-eint-app.c文件，编辑内容如下：

1. #include <stdio.h>
   
2. #include <sys/types.h>
   
3. #include <sys/stat.h>
   
4. #include <fcntl.h>
   
5. #include <unistd.h>
   
6. int main(int argc ,char *argv[])
   
7. {
   
8.          int fd;
   
9.          unsigned char key_val;
   
10.          fd = open("/dev/x4412-eint",O_RDWR);
    
11.          if (fd < 0)
    
12.          {
    
13.                    printf("open error\n");
    
14.          }
    
15.          while(1)
    
16.          {
    
17.                    read(fd,&key_val,1);
    
18.                    printf("key_val = 0x%x\n",key_val);
    
19.          }
    
20.          return 0;
    
21. }

复制代码

       使用如下指令编译应用程序：

1. arm-none-linux-gnueabi-gcc x4412-eint-app.c -o x4412-eint-app

复制代码

       加载驱动模块，通过cat /proc/ interrupts指令可以查看驱动模块申请的中断信息：

1. [root@x4412 mnt]# cat /proc/interrupts
   
2.            CPU0       CPU3  
   
3. ……   
   
4. 360:          9          0  exynos-eint  LEFT
   
5. 361:         14          0  exynos-eint  DOWN
   
6. 362:         13          0  exynos-eint  UP
   
7. 363:         10          0  exynos-eint  RIGHT
   
8. 364:          8          0  exynos-eint  BACK
   
9. 365:          8          0  exynos-eint  MENU
   
10. 373:          1          0  exynos-eint  eth0
    
11. 383:          1          0  exynos-eint  hpd
    
12. ……
    
13. [root@x4412 mnt]#

复制代码

       第一列对应中断号，第二列和第三列表示在CPU0和CPU3上的中断次数，第四列表示可编程中断控制器，第五列表示设备名称，即request_irq的devname段。

       按下开发板上六个独立按键的任意一个，将会输出打印信息“eintoccured..”，表明中断已经产生。执行应用程序，观察实验现象：

1. [root@x4412 mnt]# ./x4412-eint-app
   
2. [ 3410.952271] eint occured..
   
3. key_val = 0x3
   
4. [ 3411.187970] eint occured..
   
5. key_val = 0x83
   
6. [ 3411.552708] eint occured..
   
7. key_val = 0x4
   
8. [ 3411.775483] eint occured..
   
9. [ 3411.776791] eint occured..
   
10. key_val = 0x84

复制代码

       当没有按下按键，即没有中断产生时，不会有任何打印输出，这时read函数正在等待队列被唤醒。只有按下中断后，等待队列才会被唤醒，应用程序才能够读出按键键值并打印输出。

可直接在x4412开发板或ibox卡片电脑上测试的驱动模块和应用程序：注意内核也需要更新，否则中断会冲突。
x4412-eint.ko (5.36 KB, 下载次数: 4)

2014-10-13 15:38 上传

点击文件名下载附件

x4412-eint-app (5.97 KB, 下载次数: 4)

2014-10-13 15:38 上传

点击文件名下载附件

zImage.part1.rar (1.9 MB, 下载次数: 5)

2014-10-13 15:38 上传

点击文件名下载附件

zImage.part2.rar (1.74 MB, 下载次数: 5)

2014-10-13 15:39 上传

点击文件名下载附件