外部中断驱动问题，能注册成功中断但是无法进入中断，求助

pjj1992

最近用ok6410写外部中断的驱动，用的是第2组外部中断，看芯片手册是53号中断，注册中断没问题，但是怎么也进不了中断函数，我觉得是寄存器配置问题，捣鼓了好几天，参考了好些资料，还是不能进入中断，谁能不能告诉我这个的寄存器配置流程。下面贴我的代码，若能指点一二，不胜感激！！！

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 <asm/io.h>
   
7. #include <asm/uaccess.h>
   
8. #include <linux/interrupt.h>
   
9. 
   
10. volatile static unsigned long *REG_GPC_CON2;
    
11. volatile static unsigned long *REG_GPC_DAT;
    
12. volatile static unsigned long *REG_GPC_PULL;
    
13. volatile static unsigned long *REG_EINT_CON2;
    
14. volatile static unsigned long *REG_EINT_MASK2;
    
15. volatile static unsigned long *REG_EINT_PEND2;
    
16. volatile static unsigned long *REG_VIC1_INTENABLE;
    
17. volatile static unsigned long *REG_VIC1_VECTADDR;
    
18. volatile static unsigned long *REG_VIC1_CLEAR;
    
19. volatile static unsigned long *REG_VIC1_STATUS;
    
20. volatile static unsigned long *REG_VIC1_ADDRESS;
    
21. volatile static unsigned long *REG_VIC0_ADDRESS;
    
22. volatile static unsigned long *REG_VIC1_SELECT;
    
23. 
    
24. static irqreturn_t EINT_TEST(int irq, void *dev_id)
    
25. {
    
26.         *REG_EINT_PEND2 |= (0x1 << 18);
    
27.         printk("this is interrupt!\n");
    
28.         *REG_VIC1_ADDRESS = 0x0;
    
29.         *REG_VIC0_ADDRESS = 0x0;
    
30. 
    
31.         return IRQ_HANDLED;
    
32. }
    
33. 
    
34. //用户程序接口部分
    
35. static int EINT_open(struct inode* n, struct file* f)
    
36. {
    
37.         int result;
    
38. 
    
39.         REG_GPC_CON2 = (volatile unsigned long *)ioremap(0x7F008040, 4);
    
40.         REG_GPC_DAT = (volatile unsigned long *)ioremap(0x7F008044, 4);
    
41.         REG_GPC_PULL = (volatile unsigned long *)ioremap(0x7F008048, 4);
    
42.         REG_EINT_CON2 = (volatile unsigned long *)ioremap(0x7F008200, 4);
    
43.         REG_EINT_MASK2 = (volatile unsigned long *)ioremap(0x7F008240, 4);
    
44.         REG_EINT_PEND2 = (volatile unsigned long *)ioremap(0x7F008260, 4);
    
45.         REG_VIC1_INTENABLE = (volatile unsigned long *)ioremap(0x71300010, 4);
    
46.         REG_VIC1_VECTADDR = (volatile unsigned long *)ioremap(0x71300100, 4);
    
47.         REG_VIC1_CLEAR = (volatile unsigned long *)ioremap(0x71300014, 4);
    
48.         REG_VIC1_STATUS = (volatile unsigned long *)ioremap(0x71300000, 4);
    
49.         REG_VIC1_ADDRESS = (volatile unsigned long *)ioremap(0x71300F00, 4);
    
50.         REG_VIC1_SELECT = (volatile unsigned long *)ioremap(0x7130000c, 4);
    
51.         REG_VIC0_ADDRESS = (volatile unsigned long *)ioremap(0x71200F00, 4);
    
52.         
    
53. //        printk("%d \n\n", sizeof(REG_GPC_CON2));
    
54. /************引脚配置**********/
    
55.         *REG_GPC_CON2 &= ~(0xF << 8);
    
56.         *REG_GPC_CON2 |= (0x7 << 8); //外部中断
    
57.         *REG_GPC_PULL &= ~(0x3 << 4);
    
58.         *REG_GPC_PULL |= (0x1 << 4); //下拉电阻使能
    
59.         *REG_EINT_CON2 &= ~(0x7 << 16);
    
60.         *REG_EINT_CON2 |= (0x1 << 16); //high level
    
61.         *REG_EINT_MASK2 &= ~(0x1 << 18);
    
62. 
    
63. /******总中断控制器配置********/
    
64.         *REG_VIC1_CLEAR |= (0x1 << 21);
    
65.         *REG_VIC1_SELECT &= ~(0x1 << 21);
    
66.         *REG_VIC1_ADDRESS = 0x0;
    
67.         *REG_VIC0_ADDRESS = 0x0;
    
68. 
    
69. /*********中断使能************/
    
70.         *REG_VIC1_INTENABLE |= (0x1 << 21); //中断控制器中断使能
    
71. 
    
72. /*********加载中断程序*******/
    
73.         REG_VIC1_VECTADDR[21] = (unsigned )EINT_TEST; //中断程序地址
    
74. 
    
75.         result = request_irq(53, EINT_TEST, IRQF_DISABLED, "EINT", NULL); //注册中断
    
76.         if(result != 0)
    
77.         {
    
78.                 printk("EINT error! -> %d\n", result);
    
79.                 free_irq(53, NULL);
    
80.                 return result;
    
81.         }
    
82.         
    
83.         printk("Open Finished!\n");      
    
84.         return 0;
    
85. }
    
86. 
    
87. static int EINT_close(struct inode* n, struct file* f)
    
88. {        
    
89. 
    
90.         iounmap(REG_GPC_CON2);
    
91.         iounmap(REG_GPC_DAT);
    
92.         iounmap(REG_GPC_PULL);
    
93.         iounmap(REG_EINT_CON2);
    
94.         iounmap(REG_EINT_MASK2);
    
95.         iounmap(REG_EINT_PEND2);
    
96.         iounmap(REG_VIC1_INTENABLE);
    
97.         iounmap(REG_VIC1_VECTADDR);
    
98.         iounmap(REG_VIC1_CLEAR);
    
99.         iounmap(REG_VIC1_STATUS);
    
100.         iounmap(REG_VIC1_ADDRESS);
     
101.         iounmap(REG_VIC0_ADDRESS);
     
102.         iounmap(REG_VIC1_SELECT);
     
103.         free_irq(53, NULL);
     
104.         printk("Close Finished!\n");
     
105.         return 0;
     
106. }
     
107. 
     
108. static ssize_t EINT_write(struct file* f, const char __user* buf, size_t len, loff_t* l)
     
109. {
     
110.         printk("Write Finished!\n");
     
111.         return len;
     
112. }
     
113. 
     
114. static ssize_t EINT_read(struct file* f, char __user* buf, size_t len, loff_t* l)
     
115. {
     
116.         printk("Read Finished!\n");
     
117.         return 0;
     
118. }
     
119. 
     
120. 
     
121. //操作系统接口部分
     
122. #define DEV_NAME        "EINT"
     
123. #define DEV_COUNT        1
     
124. 
     
125. static struct class* pClass;
     
126. int major;
     
127. 
     
128. static struct file_operations fops =
     
129. {
     
130.         .owner = THIS_MODULE,
     
131.         .open = EINT_open,
     
132.         .write = EINT_write,
     
133.         .read = EINT_read,
     
134.         .release = EINT_close,
     
135. };
     
136. 
     
137. 
     
138. static int __init EINT_init(void)
     
139. {
     
140.         major = register_chrdev(0, DEV_NAME, &fops);
     
141.         pClass = class_create(THIS_MODULE, DEV_NAME);
     
142.         if (pClass == NULL)
     
143.         {
     
144.                 unregister_chrdev(major, DEV_NAME);
     
145.                 return -1;
     
146.         }
     
147.         device_create(pClass, NULL, MKDEV(major, 0),  NULL, DEV_NAME);
     
148.         
     
149. /*        REG_GPC_CON2 = (volatile unsigned long *)ioremap(0x7F008040, 4);
     
150.         REG_GPC_DAT = (volatile unsigned long *)ioremap(0x7F008044, 4);
     
151.         REG_GPC_PULL = (volatile unsigned long *)ioremap(0x7F008048, 4);
     
152.         REG_EINT_CON2 = (volatile unsigned long *)ioremap(0x7F008200, 4);
     
153.         REG_EINT_MASK2 = (volatile unsigned long *)ioremap(0x7F008240, 4);
     
154.         REG_EINT_PEND2 = (volatile unsigned long *)ioremap(0x7F008260, 4);
     
155. */
     
156.         printk("Init Finished!\n");
     
157. 
     
158.         return 0;
     
159. }
     
160. 
     
161. static void __exit EINT_exit(void)
     
162. {
     
163.         unregister_chrdev(major, DEV_NAME);
     
164.         if (pClass)
     
165.         {
     
166.                 device_destroy(pClass, MKDEV(major, 0));
     
167.                 class_destroy(pClass);
     
168.         }
     
169.         printk("Exit Finished!\n");
     
170. }
     
171. 
     
172. MODULE_LICENSE("GPL");
     
173. MODULE_AUTHOR("PuJunji");
     
174. module_init(EINT_init);
     
175. module_exit(EINT_exit);
     
176. //代码结束
     
177. 
     

复制代码

pjj1992

或者谁给我一份能用的外部中断的驱动代码也好，卡在这里了