AM3358的中断怎么设置的

看手册看了很久也没搞明白下列问题：
看手册说最多可以支持128个中断，但是这些中断怎么用那？
那些手册上已经标注了名称的中断是否还能给其他设备使用？
是不是只有DMA中断可以给其他设备使用？
另外，手册上说每组IO口有中断A和终端B，是不是说每组IO口最多可以有两个引脚被当成中断使用？
那位能给指点指点，多谢！！

TQ3358提供的6个用户按键是用GPIO中断功能做的，结合源码的例子去理解

多谢版主回复！
但是用户按键的源码在哪里？Uboot里面？

uboot里面也有的
kernel是在board-am335xevm.c源文件中添加的  查找关键字key

Tetra 发表于 2013-12-25 11:26
多谢版主回复！
但是用户按键的源码在哪里？Uboot里面？

uboot里面也有的
kernel是在board-am335xevm.c源文件中添加的  查找关键字key

好的，多谢版主

天嵌技术支持01 发表于 2013-12-30 11:10
uboot里面也有的
kernel是在board-am335xevm.c源文件中添加的  查找关键字key

      我先在也遇到了点问题，已经看过你说的board-am335xevm.c文件了，应该是在内核启动的时候对一些内部资源进行初始化和平台设备注册，驱动程序应该是gpio_keys.c用平台设备驱动，在probe函数里读平台设备的管脚和中断资源然后申请和注册（setup_key函数）。我看它的过程顺序是gpio_request-》gpio_direction_input-》gpio_set_debounce-》gpio_to_irq-》request_threaded_irq。
     我先在的问题是，我想做一个外部中断的实验，申请的是TQ3358的gpio1_16和gpio1_17就是那两个LED灯的管脚（因为那六个按键中断好像中断不共享），我知道在board-am335xevm.c文件里，这两个管脚已经初始化为输出模式，那我还能不能在驱动中通过像gpio_keys.c中的那样申请管脚，更改管脚模式，和注册成为中断，现在的情况是申请管脚和注册中断已经成功了，但是就是进入不了中断，/proc/interrupts里面相应的中断次数一直是0。谢谢回复！

1. /*
   
2. misc device driver ,add the extern interrupt to asy connect with
   
3. the user application.
   
4. */
   
5. #include <linux/module.h>
   
6. #include <linux/fs.h>
   
7. #include <linux/miscdevice.h>
   
8. #include <linux/init.h>
   
9. #include <linux/gpio.h>
   
10. #include <linux/interrupt.h>
    
11. 
    
12. #include <linux/mm.h>
    
13. #include <linux/slab.h>
    
14. #include <linux/sched.h>
    
15. 
    
16. #include <asm/uaccess.h>
    
17. 
    
18. #define GPIO_TO_PIN(bank, gpio) (32 * (bank) + (gpio))
    
19. 
    
20. #define DEVICE_NAME         "hello"
    
21. #define MAX_KEY_BUF      16
    
22. #define KEY_NUM          2
    
23. 
    
24. #define KEYSTATUS_UP    0
    
25. #define KEYSTATUS_DOWNX 2
    
26. #define KEYSTATUS_DOWN  1
    
27. 
    
28. #define KEY_TIMER_DELAY 200
    
29. 
    
30. typedef unsigned char KEY_RET ;
    
31. 
    
32. static struct key_info
    
33. {
    
34.         const char *desc;
    
35.         int gpio_port;
    
36.         int key_no;
    
37. } key_info_tab[KEY_NUM] =
    
38. {
    
39.         {"KEY_1",GPIO_TO_PIN(1, 16),0},
    
40.         {"KEY_2",GPIO_TO_PIN(1, 17),1},
    
41. };
    
42. 
    
43. static struct key_dev
    
44. {
    
45.         unsigned int keystatus[KEY_NUM];
    
46.         KEY_RET buf[MAX_KEY_BUF];
    
47.         unsigned int head ,tail;
    
48.         wait_queue_head_t wq;
    
49.         struct miscdevice miscdev;
    
50. } *keydevp;
    
51. 
    
52. static struct timer_list key_timer[KEY_NUM];/*按键的延时*/
    
53. 
    
54. int ISKEY_DOWN(int k)
    
55. {
    
56.         unsigned int gpio = key_info_tab[k].gpio_port;
    
57.         printk("gpio(%d)_get_value:%d\n",gpio,gpio_get_value(gpio));
    
58.         return gpio_get_value(gpio);
    
59. }
    
60. /*按键延时处理函数*/
    
61. void keyboard_timer_handler(unsigned long data)
    
62. {
    
63.         int key = data;
    
64.         printk("handler data is:%d",key);
    
65.         if (ISKEY_DOWN(key))
    
66.         {
    
67.                 if (keydevp->keystatus[key] == KEYSTATUS_DOWNX)
    
68.                 {
    
69.                         keydevp->keystatus[key] = KEYSTATUS_DOWN;
    
70.                         if(keydevp->tail<MAX_KEY_BUF)
    
71.                         {
    
72.                                 keydevp->buf[keydevp->tail] = key;
    
73.                                 keydevp->tail++;
    
74.                         }
    
75.                         else
    
76.                         {
    
77.                                 keydevp->tail=0;
    
78.                                 keydevp->buf[keydevp->tail] = key;
    
79.                                 keydevp->tail++;
    
80.                         }
    
81.                         wake_up_interruptible(&(keydevp->wq));
    
82.                         key_timer[key].expires = jiffies + KEY_TIMER_DELAY;
    
83.                         add_timer(&key_timer[key]);
    
84.                 }
    
85.                 else
    
86.                 {
    
87.                         key_timer[key].expires = jiffies + KEY_TIMER_DELAY;
    
88.                         add_timer(&key_timer[key]);
    
89.                 }
    
90.         }
    
91.         else
    
92.         {
    
93.                 keydevp->keystatus[key] = KEYSTATUS_UP;
    
94.                 del_timer(&key_timer[key]);
    
95.                 enable_irq(gpio_to_irq(key_info_tab[key].gpio_port));
    
96.         }
    
97. }
    
98. 
    
99. /*中断处理顶半部*/
    
100. static irqreturn_t keyboard_interrupt(int irq,void *dev_id){
     
101.         struct key_info *key;
     
102.         key = dev_id;
     
103.         disable_irq(gpio_to_irq(key->gpio_port));
     
104. 
     
105.         keydevp->keystatus[key->key_no] = KEYSTATUS_DOWNX;
     
106.         key_timer[key->key_no].expires = jiffies + KEY_TIMER_DELAY;
     
107.         add_timer(&key_timer[key->key_no]);
     
108.         return IRQ_HANDLED;
     
109. }
     
110. 
     
111. static ssize_t hello_read(struct file *filp, char __user *buf, size_t count,loff_t*ppos)
     
112. {
     
113.         int ret ;
     
114.         retry: if (keydevp->head != keydevp->tail)
     
115.         {
     
116.                 if(keydevp->head<MAX_KEY_BUF)
     
117.                 {
     
118.                         ret=copy_to_user(buf,&keydevp->buf[keydevp->head],1);
     
119.                         keydevp->buf[keydevp->head]=0;
     
120.                         keydevp->head++;
     
121.                         return ret;
     
122.                 }
     
123.                 else
     
124.                 {
     
125.                         keydevp->head=0;
     
126.                         ret=copy_to_user(buf,&keydevp->buf[keydevp->head],1);
     
127.                         keydevp->buf[keydevp->head]=0;
     
128.                         keydevp->head++;
     
129.                         return ret;
     
130.                 }
     
131.         }
     
132.         else
     
133.         {
     
134.                 if (filp->f_flags &O_NONBLOCK)
     
135.                 {
     
136.                         return - EAGAIN;
     
137.                 }
     
138.                 interruptible_sleep_on(&(keydevp->wq));
     
139.         goto retry;
     
140.         }
     
141.         return 0;
     
142. }
     
143. 
     
144. static int hello_open(struct inode *inode, struct file *file)
     
145. {
     
146.         return 0;
     
147. }
     
148. 
     
149. static int hello_close(struct inode *inode, struct file *file)
     
150. {
     
151.         return 0;
     
152. }
     
153. 
     
154. static struct file_operations hello_fops=
     
155. {
     
156.         .owner                        =        THIS_MODULE,
     
157.         .open                         =         hello_open,
     
158.         .release                 =         hello_close,
     
159.         .read                   =       hello_read,
     
160. };
     
161. 
     
162. static struct miscdevice misc = {
     
163.         .minor        = MISC_DYNAMIC_MINOR,
     
164.         .name        = DEVICE_NAME,
     
165.         .fops        = &hello_fops,
     
166. };
     
167. 
     
168. /*注册按键中断*/
     
169. int keyboard_request_irqs(void)
     
170. {
     
171.         struct key_info *k;
     
172.         int i, ret ,irq ,irqflags;
     
173.         for(i=0;i<sizeof(key_info_tab)/sizeof(struct key_info);i++)
     
174.         {
     
175.                 k = &key_info_tab[i];
     
176.                 /*缺少外部中断状态设置*/
     
177. 
     
178.                 ret = gpio_request(k->gpio_port,k->desc);
     
179.                 if(ret < 0 )
     
180.                 {       
     
181.                         printk("can't request gpio!%d error:%d\n",k->gpio_port,ret);
     
182.                         return -1;       
     
183.                 }
     
184. 
     
185.                 ret = gpio_direction_input(k->gpio_port);
     
186.                 if(ret < 0)
     
187.                 {
     
188.                         printk("can't config gpio!%d error:%d\n",k->gpio_port,ret);
     
189.                         return -1;
     
190.                 }
     
191.         /*
     
192.                 ret = gpio_set_debounce(k->gpio_port,2000);
     
193.                 if(ret < 0)
     
194.                 {
     
195.                         printk("can't set debounce!%d error:%d\n",k->gpio_port,ret);
     
196.                         return -1;
     
197.                 }
     
198.         */
     
199.                 irq = gpio_to_irq(k->gpio_port);
     
200. 
     
201.                 irqflags = IRQF_SHARED | IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING;
     
202.                 if(irq < 0)
     
203.                 {
     
204.                         printk("unable to get irq number for GPIO%d\n",k->gpio_port);
     
205.                         return -1;
     
206.                 }
     
207.                 else   
     
208.                         printk("get irq(%d) number for GPIO\n",irq);
     
209. 
     
210.                 enable_irq(irq);
     
211. 
     
212.                 ret = request_irq(irq,keyboard_interrupt,irqflags,k->desc,k);
     
213.                 if(ret < 0)
     
214.                 {
     
215.                         printk("can't request irq!%d error:%d\n",irq,ret);
     
216.                         return -1;               
     
217.                 }
     
218. 
     
219.                 printk("request resources ok!%d\n",i);
     
220.         }
     
221.         return 0;
     
222. }
     
223. 
     
224. /*释放按键中断*/
     
225. void keyboard_free_irqs(void)
     
226. {
     
227.         struct key_info *k;
     
228.         int i;
     
229.         for (i = 0; i < sizeof(key_info_tab) / sizeof(struct key_info); i++)
     
230.         {
     
231.                 k = &key_info_tab[i];
     
232.                 gpio_free(k->gpio_port);
     
233.                 free_irq(gpio_to_irq(k->gpio_port), k);
     
234.                 printk("free resources ok!%d\n",i);
     
235.         }
     
236. }
     
237. 
     
238. static int __init hello_init(void)
     
239. {
     
240.         int ret , i;
     
241. 
     
242.         ret=keyboard_request_irqs();
     
243.        
     
244.         /*初始化设备结构体*/
     
245.         keydevp=kmalloc(sizeof(struct key_dev),GFP_KERNEL);
     
246.         if(!keydevp)
     
247.                 return - ENOMEM;
     
248.         memset(keydevp, 0, sizeof(struct key_dev));
     
249.         keydevp->head=keydevp->tail = 0;
     
250.         keydevp->miscdev=misc;
     
251.         for(i=0;i<KEY_NUM;i++)
     
252.                 keydevp->keystatus[i] = KEYSTATUS_UP;
     
253. 
     
254.         /*初始化等待队列*/
     
255.         init_waitqueue_head(&(keydevp->wq));
     
256.         /*初始化延时定时器*/
     
257.         for(i=0;i<KEY_NUM;i++)
     
258.                 setup_timer(&key_timer[i],keyboard_timer_handler,i);
     
259. 
     
260.         /*注册misc设备*/
     
261.         ret = misc_register(&(keydevp->miscdev));
     
262.         if(ret!=0)
     
263.         {
     
264.                 printk("init hello unsuccessfully!\n");
     
265.                 return -1;
     
266.         }
     
267.         printk("hello init!\n");
     
268.         return 0;
     
269. }
     
270. 
     
271. static void __exit hello_exit(void)
     
272. {
     
273.         int i ;
     
274.         keyboard_free_irqs();
     
275.         for(i=0;i<KEY_NUM;i++)
     
276.                 del_timer(&key_timer[i]);
     
277.         kfree(keydevp);
     
278.         misc_deregister(&(keydevp->miscdev));
     
279.         printk("hello  exit!\n");
     
280. }
     
281. 
     
282. MODULE_LICENSE("GPL");
     
283. module_init(hello_init);
     
284. module_exit(hello_exit);

复制代码

这是我的全部代码，照着一些书上的例子做的。

taiyuankejizhu 发表于 2014-1-10 08:25
我先在也遇到了点问题，已经看过你说的board-am335xevm.c文件了，应该是在内核启动的时候对一些内 ...

请确认是否将我司做的led驱动例程删除
如没有删除会和你自己做的驱动例程会有冲突

天嵌技术支持01 发表于 2014-1-11 16:20
请确认是否将我司做的led驱动例程删除
如没有删除会和你自己做的驱动例程会有冲突

（1）没有删除led的例程驱动删除，led的例程里也是将那两个管脚设为GPIO，不过是输出模式在board-am335xevm.c里面，led驱动加载阶段并没有申请这两个管脚，实在open（）里面申请的，这样的话我想把这两个管脚作为中断输入不可以吗？相当于只改GPIO的输入输出模式，不可以的话这个gpio_direction_input（）函数是干嘛的？
（2）如果要把那六个按键在am335xevm.c里配置成中断共享模式要怎么改呀？

关于中断的使用，网上有很多资料。

taiyuankejizhu 发表于 2014-1-13 08:05
（1）没有删除led的例程驱动删除，led的例程里也是将那两个管脚设为GPIO，不过是输出模式在board-am335xe ...

http://blog.csdn.net/droidphone/article/details/7445825