点击(此处)折叠或打开

1. /*
2. * gpio_irqTest.c
3. * PB27 receive this signal as IRQ and make the LED linking on PB17 turn on or turn off
4. *
5. */
6. #include <linux/types.h>
7. #include <linux/kernel.h>
8. #include <linux/module.h>
9. #include <linux/init.h>
10. #include <linux/platform_device.h>
11. #include <linux/cdev.h>
12. #include <linux/ioctl.h>
13. #include <linux/fs.h>
14. #include <linux/gpio.h>
15. #include <linux/delay.h>
16. #include <linux/cdev.h>
17. #include <linux/interrupt.h>
18. #include <asm/io.h>
19. #include <asm/io.h>
20. #include <mach/gpio.h>
21. #include <mach/hardware.h>
22. #include <mach/board.h>
23. #include <mach/gpio.h>
24. #include <mach/at91_pio.h>
25. #include <mach/at91_aic.h>
26. #include <mach/at91_pmc.h>
27. void led_on()
28. {
29. // at91_set_gpio_output(AT91_PIN_PB17,1);
30. printk("led on\n");
31. }
32. void led_off()
33. {
34. // at91_set_gpio_output(AT91_PIN_PB17 ,0);
35. printk("led off.\n");
36. }
37. struct light_dev *light_devp;
38. int light_major = 200;
39. struct light_dev
40. {
41. struct cdev cdev;
42. unsigned char value;
43. };
44. static void io_init(void)
45. {
46. at91_set_GPIO_periph(AT91_PIN_PB27, 0);
47. at91_set_gpio_input(AT91_PIN_PB27, 1);
48. at91_set_deglitch(AT91_PIN_PB27, 1);
49. }
50. struct gpio_irq_desc
51. {
52. int pin;
53. int irq;
54. unsigned long flags;
55. char *name;
56. };
57. static struct gpio_irq_desc gpio_irq={AT91_PIN_PB27, AT91_PIN_PB27,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING|IRQF_ONESHOT,"PB27"};
58. static irqreturn_t gpio_irqhandler(int irq, void *dev_id)
59. {
60. printk(KERN_INFO "In hard irq handler.\n");
61. return IRQ_WAKE_THREAD;
62. }
63. static irqreturn_t gpio_threadhandler(int irq, void *dev_id)
64. {
65. int rst;
66. rst = at91_get_gpio_value(gpio_irq.pin);
67. printk(KERN_INFO "gpio stat: %d\n", rst);
68. if(rst == 0){
69. led_on();
70. }else{
71. led_off();
72. }
73. printk(KERN_INFO "sleep 3000ms\n");
74. msleep(3000);
75. printk(KERN_INFO "awake after sleep\n");
76. return IRQ_HANDLED;
77. }
78. int light_open(struct inode *inode,struct file *filp)
79. {
80. int err;
81. struct light_dev *dev;
82. dev = container_of(inode->i_cdev,struct light_dev,cdev);
83. filp->private_data = dev;
84. printk(KERN_DEBUG "%s", __FUNCTION__);
85. io_init();
86. // err = request_threaded_irq(gpio_irq.irq,gpio_irqhandler,gpio_threadhandler,gpio_irq.flags,gpio_irq.name,(void*)0);
87. err = request_threaded_irq(gpio_irq.irq,NULL,gpio_threadhandler,gpio_irq.flags,gpio_irq.name,(void*)0);
88. if(err)
89. {
90. // free_irq(gpio_irq.irq,(void*)0);
91. printk(KERN_DEBUG "request irq failed.\n");
92. return -EBUSY;
93. }
94. return 0;
95. }
96. int light_release(struct inode *inode,struct file *filp)
97. {
98. free_irq(gpio_irq.irq,(void*)0);
99. return 0;
100. }
101. int light_ioctl(struct inode *inode,struct file *filp,unsigned int cmd, unsigned long arg)
102. {
103. struct light_dev *dev = filp->private_data;
104. switch(cmd)
105. {
106. case 0:
107. at91_set_gpio_output(AT91_PIN_PB19,0);
108. break;
109. case 1:
110. at91_set_gpio_output(AT91_PIN_PB19,1);
111. led_off();
112. break;
113. default:
114. return -ENOTTY;
115. // break;
116. }
117. return 0;
118. }
119. struct file_operations light_fops =
120. {
121. .owner = THIS_MODULE,
122. .open = light_open,
123. .release = light_release,
124. .unlocked_ioctl = light_ioctl,
125. };
126. static void light_setup_cdev(struct light_dev *dev,int index)
127. {
128. int err,devno = MKDEV(light_major,index);
129. cdev_init(&dev->cdev,&light_fops);
130. dev->cdev.owner = THIS_MODULE;
131. dev->cdev.ops = &light_fops;
132. err = cdev_add(&dev->cdev,devno,1);
133. if(err)
134. {
135. printk(KERN_NOTICE "Error %d adding LED%d",err,index);
136. }
137. }
138. int __init light_init(void)
139. {
140. int result;
141. dev_t dev = MKDEV(light_major,0);
142. if(light_major)
143. {
144. result = register_chrdev_region(dev,1,"gpio");
145. }
146. if(result < 0)
147. {
148. printk(KERN_DEBUG "%s: register char dev failed.\n", __FUNCTION__);
149. return result;
150. }
151. light_devp = kmalloc(sizeof(struct light_dev),GFP_KERNEL);
152. if(!light_devp)
153. {
154. result = - ENOMEM;
155. goto fail_malloc;
156. }
157. memset(light_devp,0,sizeof(struct light_dev));
158. light_setup_cdev(light_devp,0);
159. printk(KERN_DEBUG "%s done\n", __FUNCTION__);
160. return 0;
161. fail_malloc:unregister_chrdev_region(dev,light_devp);
162. return result;
163. }
164. void __exit light_cleanup(void)
165. {
166. cdev_del(&light_devp->cdev);
167. kfree(light_devp);
168. unregister_chrdev_region(MKDEV(light_major,0),1);
169. }
170. module_init(light_init);
171. module_exit(light_cleanup);
172. MODULE_AUTHOR("Enzo Fang");
173. MODULE_LICENSE("Dual BSD/GPL");