pcDuino Linux驱动开发四 -- 最简单的中断驱动

tjcfeng

基于前面提到的最精简的框架，中断程序只是多了一个irq注册和响应的代码。
需要增加的函数有：

request_irq //请求注册irq
free_irq //释放请求
和一个自定义的irq响应函数。

当然，为了程序能够真正完成工作，还需要一个阻塞响应机制，以便用户程序能够等到中断的到达。
这里同样使用了最简单的方式，增加的函数：

DECLARE_COMPLETION(MSG); //linux内核定义好的宏，给一个变量名称即可
init_completion(&MSG); //初始化
wait_for_completion(&MSG); //阻塞函数
complete(&MSG); //打断阻塞的函数

下面上代码，对照之前的GPIO框架，可以很清晰地看出区别：

1. #include <linux/init.h>
   
2. #include <linux/module.h>
   
3. #include <linux/fs.h>
   
4. #include <linux/cdev.h>
   
5. #include <linux/device.h>
   
6. #include <linux/wait.h>
   
7. #include <linux/delay.h>
   
8. #include <asm/io.h>
   
9. #include <asm/uaccess.h>
   
10. #include <linux/interrupt.h>
    
11. 
    
12. #include "../A10.h"
    
13. 
    
14. /**********************************************************************/
    
15.         #define KEY_IRQ                28
    
16.        
    
17.         #define KEY_BACK                17
    
18.         #define KEY_HOME                19
    
19.         #define KEY_MENU                18
    
20.        
    
21.         #define KEY_BACK_BIT                        0x20000        //(0x1 << 17)
    
22.         #define KEY_MENU_BIT                        0x40000        //(0x1 << 18)
    
23.         #define KEY_HOME_BIT                        0x80000        //(0x1 << 19)
    
24.        
    
25.         #define KEY_DOWN                0
    
26.         #define KEY_UP                                1
    
27. 
    
28.         volatile static unsigned long* REG_PH_CFG2;
    
29.         volatile static unsigned long* REG_PH_PULL1;
    
30.         volatile static unsigned long* REG_PIO_INT_CFG2;
    
31.         volatile static unsigned long* REG_PIO_INT_CTL;
    
32.         volatile static unsigned long* REG_PIO_INT_STATUS;
    
33.         volatile static unsigned long* REG_PH_DAT;
    
34.        
    
35.         /*volatile static unsigned long* REG_INTC_IRQ_PEND_REG0;
    
36.         volatile static unsigned long* REG_INTC_IRQ_TYPE_SEL0;
    
37.         volatile static unsigned long* REG_INTC_EN_REG0;
    
38.         volatile static unsigned long* REG_INTC_MASK_REG0;*/
    
39.        
    
40.         static int Inited = 0;
    
41. 
    
42.         DECLARE_COMPLETION(MSG);
    
43.         static unsigned char KeyFlag = 0;
    
44.         static unsigned char KeyHL = 255;
    
45.        
    
46. static irqreturn_t KEY_ISR(int irq, void* dev_id)
    
47. {
    
48.         unsigned int State, Data;
    
49. 
    
50.         State = *REG_PIO_INT_STATUS;
    
51.         *REG_PIO_INT_STATUS |= (KEY_HOME_BIT + KEY_MENU_BIT + KEY_BACK_BIT); //Clear INT Pending
    
52. 
    
53.         mdelay(1);
    
54.         *REG_PH_CFG2 &= ~((0x7 << 12) + (0x7 << 8) + (0x7 << 4)); //Input
    
55.         Data = *REG_PH_DAT;
    
56.         *REG_PH_CFG2 |= ((0x6 << 12) + (0x6 << 8) + (0x6 << 4)); //EINT
    
57. 
    
58.         //printk("IRQ State - %u ___ IRQ Data - %u\n", State, Data);
    
59.        
    
60.         if ((State & KEY_BACK_BIT) == KEY_BACK_BIT )
    
61.         {
    
62.                 KeyFlag = KEY_BACK;
    
63.                 if ((Data & KEY_BACK_BIT)  == KEY_BACK_BIT) KeyHL = KEY_UP; else KeyHL = KEY_DOWN;
    
64.         }
    
65.         else
    
66.                 if ((State & KEY_MENU_BIT) == KEY_MENU_BIT)
    
67.                 {
    
68.                         KeyFlag = KEY_MENU;
    
69.                         if ((Data & KEY_MENU_BIT)  == KEY_MENU_BIT) KeyHL = KEY_UP; else KeyHL = KEY_DOWN;
    
70.                 }
    
71.                 else
    
72.                         if ((State & KEY_HOME_BIT) == KEY_HOME_BIT)
    
73.                         {
    
74.                                 KeyFlag = KEY_HOME;
    
75.                                 if ((Data & KEY_HOME_BIT) == KEY_HOME_BIT) KeyHL = KEY_UP; else KeyHL = KEY_DOWN;
    
76.                         }
    
77.                        
    
78.         if ((KeyFlag != 0) && (KeyHL != 255)) complete(&MSG);
    
79. 
    
80.         return IRQ_HANDLED;
    
81. }
    
82. 
    
83. static int KEY_open(struct inode* n, struct file* f)
    
84. {
    
85.         int Result = 0;
    
86. 
    
87.         Inited++;
    
88.         if (Inited > 1)
    
89.         {
    
90.                 return 0;
    
91.         }
    
92. 
    
93.         REG_PH_CFG2 = (volatile unsigned long*) ioremap(PH_CFG2, 4);
    
94.         REG_PH_PULL1 = (volatile unsigned long*) ioremap(PH_PULL1, 4);
    
95.         REG_PIO_INT_CFG2 = (volatile unsigned long*) ioremap(PIO_INT_CFG2, 4);
    
96.         REG_PIO_INT_CTL= (volatile unsigned long*) ioremap(PIO_INT_CTL, 4);
    
97.         REG_PIO_INT_STATUS = (volatile unsigned long*) ioremap(PIO_INT_STATUS, 4);
    
98.         REG_PH_DAT = (volatile unsigned long*) ioremap(PH_DAT, 4);
    
99.        
    
100.         /*REG_INTC_IRQ_PEND_REG0 = (volatile unsigned long*) ioremap(INTC_IRQ_PEND_REG0, 4);
     
101.         REG_INTC_IRQ_TYPE_SEL0 = (volatile unsigned long*) ioremap(INTC_IRQ_TYPE_SEL0, 4);
     
102.         REG_INTC_EN_REG0 = (volatile unsigned long*) ioremap(INTC_EN_REG0, 4);
     
103.         REG_INTC_MASK_REG0 = (volatile unsigned long*) ioremap(INTC_MASK_REG0, 4);*/
     
104.        
     
105.         *REG_PH_CFG2 &= ~((0x7 << 12) + (0x7 << 8) + (0x7 << 4));
     
106.         *REG_PH_CFG2 |= ((0x6 << 12) + (0x6 << 8) + (0x6 << 4)); //EINT
     
107.         *REG_PH_PULL1 &= ~((0x3 << 6) + (0x3 << 4) + (0x3 << 2));
     
108.         *REG_PH_PULL1 |= ((0x1 << 6) + (0x1 << 4) + (0x1 << 2)); //Pull_UP
     
109.         *REG_PIO_INT_CFG2 &= ~((0xF << 12) + (0xF << 8) + (0xF << 4));
     
110.         *REG_PIO_INT_CFG2 |= ((0x4 << 12) + (0x4 << 8) + (0x4<< 4)); //Double Edge
     
111.         //*REG_PH_DAT |= KEY_HOME_BIT + KEY_MENU_BIT + KEY_BACK_BIT;
     
112.        
     
113.         //*REG_INTC_IRQ_TYPE_SEL0 &= ~((0x1 << KEY_MENU) + (0x1 << KEY_HOME) + (0x1 << KEY_BACK)); //Is IRQ, not FIQ
     
114.         //*REG_INTC_EN_REG0 |= ((0x1 << KEY_MENU) + (0x1 << KEY_HOME) + (0x1 << KEY_BACK)); //Enable INT
     
115.        
     
116.         *REG_PIO_INT_CTL |= ((0x1 << KEY_MENU) + (0x1 << KEY_HOME) + (0x1 << KEY_BACK)); //Enable INT
     
117. 
     
118.         Result = request_irq(KEY_IRQ, KEY_ISR, IRQF_DISABLED, "KEY", NULL);
     
119.         if (Result != 0)
     
120.         {
     
121.                 //printk("Request IRQ file! ErrorCode: %d\n", Result);
     
122.                 free_irq(KEY_IRQ, NULL);
     
123.                 return Result;
     
124.         }
     
125. 
     
126.         init_completion(&MSG);
     
127.         //printk("Open Finished!\n");
     
128.         return Result;
     
129. }
     
130. 
     
131. static ssize_t KEY_write(struct file* f, const char __user* buf, size_t len, loff_t* l)
     
132. {
     
133.         unsigned char Buf[2];
     
134.        
     
135.         if (copy_from_user(&Buf, buf, len)) return -1;
     
136. 
     
137.         //printk("Write Finished!\n");
     
138.         return len;
     
139. }
     
140. 
     
141. static ssize_t KEY_read(struct file* f, char __user* buf, size_t len, loff_t* l)
     
142. {
     
143.         unsigned char Buf[2];
     
144.         int Len = sizeof(Buf);
     
145. 
     
146.         wait_for_completion(&MSG);
     
147. 
     
148.         Buf[0] = KeyFlag;
     
149.         Buf[1] = KeyHL;
     
150.         if (copy_to_user(buf, &Buf, sizeof(Buf))) return 0;
     
151. 
     
152.         KeyFlag = 0;
     
153.         KeyHL = 255;
     
154.        
     
155.         //printk("Read Finished!\n");
     
156.         return Len;
     
157. }
     
158. 
     
159. static int KEY_close(struct inode* n, struct file* f)
     
160. {
     
161.         Inited--;
     
162.         if (Inited > 0)
     
163.         {
     
164.                 return 0;
     
165.         }
     
166.        
     
167.         free_irq(KEY_IRQ, NULL);
     
168.         //remove_wait_queue(&MSG);
     
169.        
     
170.         iounmap(REG_PH_CFG2);
     
171.         iounmap(REG_PH_PULL1);
     
172.         iounmap(REG_PIO_INT_CFG2);
     
173.         iounmap(REG_PIO_INT_STATUS);
     
174.         iounmap(REG_PH_DAT);
     
175.        
     
176.         /*iounmap(REG_INTC_IRQ_PEND_REG0);
     
177.         iounmap(REG_INTC_IRQ_TYPE_SEL0);
     
178.         iounmap(REG_INTC_EN_REG0);
     
179.         iounmap(REG_INTC_MASK_REG0);*/
     
180. 
     
181.         //printk("Close Finished!\n");
     
182.         return 0;
     
183. }
     
184. 
     
185. /**********************************************************************/
     
186.         #define DEV_NAME        "KEY"
     
187.         #define DEV_COUNT        1
     
188. 
     
189.         static struct class* pClass;
     
190.         int major;
     
191.        
     
192.         static struct file_operations fops =
     
193.         {
     
194.                 .owner = THIS_MODULE,
     
195.                 .open = KEY_open,
     
196.                 .write = KEY_write,
     
197.                 .read = KEY_read,
     
198.                 .release = KEY_close,
     
199.         };
     
200. 
     
201. static int __init KEY_init(void)
     
202. {
     
203.         major = register_chrdev(0, DEV_NAME, &fops);
     
204.         pClass = class_create(THIS_MODULE, DEV_NAME);
     
205.         if (pClass == NULL)
     
206.         {
     
207.                 unregister_chrdev(major, DEV_NAME);
     
208.                 return -1;
     
209.         }
     
210.         device_create(pClass, NULL, MKDEV(major, 0),  NULL, DEV_NAME);
     
211.         //printk("Init Finished!\n");
     
212. 
     
213.         return 0;
     
214. }
     
215. 
     
216. static void __exit KEY_exit(void)
     
217. {
     
218.         unregister_chrdev(major, DEV_NAME);
     
219.         if (pClass)
     
220.         {
     
221.                 device_destroy(pClass, MKDEV(major, 0));
     
222.                 class_destroy(pClass);
     
223.         }
     
224.         //printk("Exit Finished!\n");
     
225. }
     
226. 
     
227. MODULE_LICENSE("GPL");
     
228. MODULE_AUTHOR("LiuYang");
     
229. module_init(KEY_init);
     
230. module_exit(KEY_exit);
     

复制代码

Makefile文件同前，改一下文件名.o即可。

测试程序：

1. #include <stdio.h>
   
2. #include <unistd.h>
   
3. #include <fcntl.h>
   
4. 
   
5. int main(int argc, char **argv)
   
6. {
   
7.         int f;
   
8.         int I;
   
9.         int Len;
   
10.         unsigned char Buf[2];
    
11.        
    
12.         f = open("/dev/KEY", O_RDWR);
    
13.         printf("File Handle: %d\n", f);
    
14.         if (f < 0)
    
15.         {
    
16.                 printf("Open KEY fail!\n");
    
17.                 return -1;
    
18.         }
    
19. 
    
20. for (I = 0; I < 6; I++)
    
21.         {
    
22.                 Len = read(f, &Buf, 2);
    
23.                 printf("Len: %d -- Key: %d  -- HL: %d\n", Len, Buf[0], Buf[1]);
    
24.         }
    
25.        
    
26.         close(f);
    
27. 
    
28.         return 0;
    
29. }
    

复制代码

这样，测试程序在调用了read之后会阻塞在那里，等待驱动程序中中断的达到。每次按下按键后，程序就继续执行了。wait_for_completion有很多种，可以增加超时之类的来完成自己的要求。

顺便说一下，pcDuino已经占用了这个中断，测试的话，在启动后需要先rmmod sw_interrupt，以保证本程序的运行。

ddsama

一如既往地支持

tjcfeng

jyq 发表于 2014-8-18 11:16
一如既往地支持

多谢，献丑了