Linux实验十三---按键中断实验

步骤1：同LED

步骤2：同LED

步骤3：编译

　　cd workdir/driver/Linux3.2Drivers/fs210_key/

　　vim Makefile

　　修改同LED

　　make

步骤4：将ko文件复制到NFS系统目录中。

　　cp fs210_key.ko /source/rootfs

　　make key_test

步骤5：启动开发版

　　加载驱动

　　insmod fs210_key.ko

Disabling lock debugging due to kernel taint
key : init_module

　　mknod /dev/pwm c 252 0
　　chmod 777 /dev/key
　　./key_test

附：程序源码

　　fs210_key.c

  1 #include <linux/module.h> 
  2 #include <linux/kernel.h>
  3 #include <linux/init.h>
  4 #include <linux/fs.h>
  5 #include <linux/cdev.h>
  6 #include <linux/sched.h>
  7 #include <linux/interrupt.h>
  8 #include <linux/irq.h>
  9 //#include <linux/slab.h>
 10 #include <asm/uaccess.h>
 11 
 12 #include <asm/io.h>
 13 //#include <mach/irqs.h>
 14 
 15 MODULE_LICENSE("Dual BSD/GPL");
 16 MODULE_AUTHOR("farsight");
 17 
 18 #define GPH0CON 0xe0200c00
 19 #define GPH2CON 0xe0200c40
 20 
 21 static int key_major = 252;
 22 static int key_minor = 0;
 23 
 24 struct key_device
 25 {
 26     int keyval;
 27     struct cdev cdev;
 28     struct semaphore sem;
 29     wait_queue_head_t rq;
 30 } key_device;
 31 
 32 void *gph0con;
 33 void *gph2con;
 34 
 35 static int fs210_key_open(struct inode *inode, struct file *filp)
 36 {
 37     struct key_device *dev = container_of(inode->i_cdev, struct key_device, cdev);
 38 
 39     filp->private_data = dev;
 40     printk("fs210_key is opened\n");
 41     return 0;
 42 }
 43 
 44 static int fs210_key_release(struct inode *inode, struct file *filp)
 45 {
 46     printk("fs210_key is closed\n");
 47     return 0;
 48 }
 49 
 50 static int fs210_key_read(struct file *filp, char __user *buf, size_t size, loff_t *off)
 51 {
 52     struct key_device *dev = filp->private_data;
 53 
 54     down(&dev->sem);
 55     while (dev->keyval == 0)
 56     {
 57         up(&dev->sem);
 58         if (filp->f_flags & O_NONBLOCK)
 59             return -EAGAIN;
 60         if (wait_event_interruptible(dev->rq, dev->keyval != 0))
 61             return -ERESTARTSYS;
 62         down(&dev->sem);
 63     }
 64     if (copy_to_user(buf, &dev->keyval, sizeof(int)))
 65     {
 66         up(&dev->sem);
 67         return -EFAULT;
 68     }
 69     dev->keyval = 0;
 70     up(&dev->sem);
 71 
 72     return sizeof(int);
 73 }
 74 
 75 static struct file_operations fs210_key_ops = {
 76     .owner = THIS_MODULE,
 77     .open = fs210_key_open,
 78     .release = fs210_key_release,
 79     .read = fs210_key_read,
 80 };
 81 
 82 static irqreturn_t  handler(int irqno, void *dev_id)
 83 {
 84     static long old_jiffies = 0;
 85 
 86     if (jiffies - old_jiffies < 20) return IRQ_HANDLED;
 87 
 88     old_jiffies = jiffies;
 89     printk("irq: interrupt %d\n", irqno);
 90     switch (irqno)
 91     {
 92     case IRQ_EINT(0) :
 93         key_device.keyval = 1;
 94         break;
 95     case IRQ_EINT(1) :
 96         key_device.keyval = 2;
 97         break;
 98     case IRQ_EINT(2) :
 99         key_device.keyval = 3;
100         break;
101     case IRQ_EINT(3) :
102         key_device.keyval = 4;
103         break;
104     case IRQ_EINT(4) :
105         key_device.keyval = 5;
106         break;
107     case IRQ_EINT(5) :
108         key_device.keyval = 6;
109         break;
110     case IRQ_EINT(22) :
111         key_device.keyval = 7;
112         break;
113     case IRQ_EINT(23) :
114         key_device.keyval = 8;
115         break;
116     }
117     wake_up(&key_device.rq);
118 
119     return IRQ_HANDLED;
120 }
121 
122 static int key_request_irq(void)
123 {
124     int result;
125 
126     result = request_irq(IRQ_EINT(0), handler, IRQF_DISABLED|IRQF_TRIGGER_FALLING, "key_1", NULL);    
127     if (result)    {
128         printk("key: request irq %d failed!\n", IRQ_EINT(0));
129         return result;
130     }
131 
132     result = request_irq(IRQ_EINT(1), handler, IRQF_DISABLED|IRQF_TRIGGER_FALLING, "key_2", NULL);    
133     if (result)    {
134         printk("key: request irq %d failed!\n", IRQ_EINT(1));
135         goto _error_irq1;
136     }
137 
138     result = request_irq(IRQ_EINT(2), handler, IRQF_DISABLED|IRQF_TRIGGER_FALLING, "key_3", NULL);    
139     if (result)    {
140         printk("key: request irq %d failed!\n", IRQ_EINT(2));
141         goto _error_irq2;
142     }
143 
144     result = request_irq(IRQ_EINT(3), handler, IRQF_DISABLED|IRQF_TRIGGER_FALLING, "key_4", NULL);    
145     if (result)    {
146         printk("key: request irq %d failed!\n", IRQ_EINT(3));
147         goto _error_irq3;
148     }
149 
150     result = request_irq(IRQ_EINT(4), handler, IRQF_DISABLED|IRQF_TRIGGER_FALLING, "key_5", NULL);    
151     if (result)    {
152         printk("key: request irq %d failed!\n", IRQ_EINT(4));
153         goto _error_irq4;
154     }
155 
156     result = request_irq(IRQ_EINT(5), handler, IRQF_DISABLED|IRQF_TRIGGER_FALLING, "key_6", NULL);    
157     if (result)    {
158         printk("key: request irq %d failed!\n", IRQ_EINT(5));
159         goto _error_irq5;
160     }
161 
162     result = request_irq(IRQ_EINT(22), handler, IRQF_DISABLED|IRQF_TRIGGER_FALLING, "key_7", NULL);    
163     if (result)    {
164         printk("key: request irq %d failed!\n", IRQ_EINT(22));
165         goto _error_irq22;
166     }
167 
168     result = request_irq(IRQ_EINT(23), handler, IRQF_DISABLED|IRQF_TRIGGER_FALLING, "key_8", NULL);    
169     if (result)    {
170         printk("key: request irq %d failed!\n", IRQ_EINT(23));
171         goto _error_irq23;
172     }
173 
174     return 0;
175 
176 _error_irq23:
177     free_irq(IRQ_EINT(22), NULL);
178 _error_irq22:
179     free_irq(IRQ_EINT(5), NULL);
180 _error_irq5 :
181     free_irq(IRQ_EINT(4), NULL);
182 _error_irq4 :
183     free_irq(IRQ_EINT(3), NULL);
184 _error_irq3 :
185     free_irq(IRQ_EINT(2), NULL);
186 _error_irq2 :
187     free_irq(IRQ_EINT(1), NULL);
188 _error_irq1 :
189     free_irq(IRQ_EINT(0), NULL);
190 
191 
192     return result;
193 }
194 
195 static void init_key(void)
196 {
197     gph0con = ioremap(GPH0CON, 4);
198     gph2con = ioremap(GPH2CON, 4);
199     writel((readl(gph0con) | 0xffffff), gph0con);
200     writel((readl(gph2con) | (0xff<<24)), gph2con);
201 }
202 
203 static void key_free_irq(void)
204 {
205     free_irq(IRQ_EINT(0), NULL);
206     free_irq(IRQ_EINT(1), NULL);
207     free_irq(IRQ_EINT(2), NULL);
208     free_irq(IRQ_EINT(3), NULL);
209     free_irq(IRQ_EINT(4), NULL);
210     free_irq(IRQ_EINT(5), NULL);
211     free_irq(IRQ_EINT(22), NULL);
212     free_irq(IRQ_EINT(23), NULL);
213 }
214 
215 static int key_setup_cdev(struct cdev *cdev, struct file_operations *ops)
216 {
217     int result;
218     dev_t devno = MKDEV(key_major, key_minor);
219     cdev_init(cdev, ops);
220     cdev->owner = THIS_MODULE;
221     result = cdev_add(cdev, devno, 1);
222     if (result)
223     {
224         printk("key: fail to add cdev\n");
225         return result;
226     }
227     return 0;
228 }
229 
230 static int __init fs210_key_init(void)
231 {
232     int result;
233     dev_t devno = MKDEV(key_major, key_minor);
234     
235     result = register_chrdev_region(devno, 1, "fs210_key");
236     if (result)
237     {
238         printk("key: unable to get major %d\n", key_major);
239         return result;
240     }
241 
242     result = key_setup_cdev(&key_device.cdev, &fs210_key_ops);
243     if (result)
244         goto _error1;
245 
246     result = key_request_irq();
247     if (result)
248         goto _error2;
249 
250     init_key();
251     key_device.keyval = 0;
252     //init_MUTEX(&key_device.sem);  //  can used in kernel which version is no more than 2.6.35
253     sema_init(&key_device.sem, 1);
254     init_waitqueue_head(&key_device.rq);
255     printk("key : init_module\n");
256 
257     return 0;
258 
259 _error2:
260     cdev_del(&key_device.cdev);
261 _error1:
262     unregister_chrdev_region(devno, 1);
263 
264     return result;
265 }
266 
267 static void __exit fs210_key_exit(void)
268 {
269     dev_t devno = MKDEV(key_major, key_minor);
270     key_free_irq();
271     cdev_del(&key_device.cdev);
272     unregister_chrdev_region(devno, 1);
273     printk("key: cleanup_module!\n");
274 }
275 
276 module_init(fs210_key_init);
277 module_exit(fs210_key_exit);

　　

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <unistd.h>
 4 #include <fcntl.h>
 5 #include <sys/types.h>
 6 #include <sys/ioctl.h>
 7 
 8 int main()
 9 {
10     int fd;
11     int keyval;
12     
13     if ((fd = open("/dev/key", O_RDONLY)) < 0)
14     {
15         perror("fail to open");
16         exit(-1);
17     }
18 
19     while ( 1 )
20     {
21         if (read(fd, &keyval, sizeof(int)) < 0)
22         {
23             perror("fail to read");
24         }
25         printf("key %d is pressed\n", keyval);
26     }
27 
28     return 0;
29 }

　　key_test.c

posted on 2018-08-07 10:07  kingofloong  阅读(576)  评论(0)    收藏  举报
博客园  ©  2004-2026
浙公网安备 33010602011771号 浙ICP备2021040463号-3