实在没辙了,按键驱动,麻烦大家,请指点一下,附代码~~ 谢谢

bejoey_pro

实在没辙了,按键驱动,麻烦大家,请指点一下,附代码~~ 谢谢
一个很简单的 按键驱动, 搞了三天也insmod不上去....    电脑上输入insmod **.ko 后,  直接就死机了......  
系统:Redhat 2.6.18
代码如下:

1. 
   
2. #include <linux/module.h>
   
3. #include <linux/types.h>
   
4. #include <linux/fs.h>
   
5. #include <linux/mm.h>
   
6. #include <linux/errno.h>
   
7. #include <linux/sched.h>
   
8. #include <linux/init.h>
   
9. #include <linux/cdev.h>
   
10. #include <linux/interrupt.h>
    
11. 
    
12. #include <asm/io.h>
    
13. #include <asm/system.h>
    
14. #include <asm/uaccess.h>
    
15. #include <asm-arm/irq.h>
    
16. #include <asm-arm/arch-s3c2410/irqs.h>
    
17. #include <asm-arm/arch-s3c2410/regs-gpio.h>
    
18. #include <asm-arm/arch-s3c2410/hardware.h>
    
19. 
    
20. #define DEVICE_NAME        "mini_buttons"
    
21. #define BUTTONS_NUM        6
    
22. #define MAX_BUTTONS_BUF        16
    
23. #define BUTTONS_MAJOR        252
    
24. 
    
25. #define BUTTONSTATUS_DOWNX        0
    
26. #define BUTTONSTATUS_DOWN        1
    
27. #define BUTTONSTATUS_UP                2
    
28. 
    
29. #define BUTTONS_TIMER_DELAY        (HZ/50)
    
30. #define BUTTONS_TIMER_DELAY1        (HZ/10)
    
31. 
    
32. static int buttons_major = BUTTONS_MAJOR;
    
33. 
    
34. 
    
35. struct buttons_dev
    
36. {
    
37.         struct cdev cdev;
    
38.         unsigned int buttonStatus[BUTTONS_NUM];
    
39.         unsigned char buf[MAX_BUTTONS_BUF];
    
40.         unsigned int head,tail;
    
41.         wait_queue_head_t wq;
    
42. };
    
43. 
    
44. static struct buttons_dev *buttons_devp;
    
45. 
    
46. static struct buttons_info
    
47. {
    
48.         unsigned int irq_no;
    
49.         unsigned int gpio_port;
    
50.         unsigned int buttons_no;
    
51. }buttons_info_tab[BUTTONS_NUM] =
    
52. {
    
53.         {IRQ_EINT8,S3C2410_GPG0,1},
    
54.         {IRQ_EINT11,S3C2410_GPG3,2},
    
55.         {IRQ_EINT13,S3C2410_GPG5,3},
    
56.         {IRQ_EINT14,S3C2410_GPG6,4},
    
57.         {IRQ_EINT15,S3C2410_GPG7,5},
    
58.         {IRQ_EINT19,S3C2410_GPG11,6},
    
59. };
    
60. 
    
61. static struct timer_list buttons_timer[BUTTONS_NUM];
    
62. 
    
63. 
    
64. void __iomem * virt_GPGCON;
    
65. void __iomem * virt_GPGDAT;
    
66. void __iomem * virt_SRCPND;
    
67. void __iomem * virt_INTMSK;
    
68. void __iomem * virt_INTPND;
    
69. void __iomem * virt_EINTPEND;
    
70. void __iomem * virt_EINTMASK;
    
71. void __iomem * virt_EXTINT1;
    
72. void __iomem * virt_EXTINT2;
    
73. 
    
74. static int buttons_open(struct inode *inode,struct file *filp);
    
75. static int buttons_release(struct inode *inode,struct file *filp);
    
76. static ssize_t buttons_read(struct file *filp,char __user *buf,
    
77.                                 size_t size,loff_t *ppos);
    
78. 
    
79. static struct file_operations buttons_fops =
    
80. {
    
81.         .owner = THIS_MODULE,
    
82.         .open = buttons_open,
    
83.         .release = buttons_release,
    
84.         .read = buttons_read,
    
85. //        .write = buttons_write,
    
86. };
    
87. 
    
88. static void buttons_ioremap(void)
    
89. {
    
90.    virt_INTPND=ioremap(0x4a000010,4);
    
91.    virt_EINTPEND=ioremap(0x560000a8,4);
    
92.    virt_SRCPND=ioremap(0x4a000000,4);
    
93. //   virt_EXTINT0=ioremap(0x56000088,4);
    
94.    virt_EXTINT1=ioremap(0x5600008c,4);
    
95.    virt_EXTINT2=ioremap(0x56000090,4);
    
96.    virt_GPGDAT=ioremap(0x56000064,4);
    
97.    virt_EINTMASK=ioremap(0x560000a4,4);
    
98.    virt_INTMSK=ioremap(0x4a000008,4);
    
99.    virt_GPGCON=ioremap(0x56000060,4);
    
100. }
     
101. 
     
102. static void buttons_iounmap(void)
     
103. {
     
104.         iounmap(&virt_INTPND);
     
105.         iounmap(&virt_EINTPEND);
     
106.         iounmap(&virt_SRCPND);
     
107. //        iounmap(&virt_EXTINT0);
     
108.         iounmap(&virt_EXTINT1);
     
109.         iounmap(&virt_EXTINT2);
     
110.         iounmap(&virt_GPGDAT);
     
111.         iounmap(&virt_EINTMASK);
     
112.         iounmap(&virt_INTMSK);
     
113.         iounmap(&virt_GPGCON);
     
114. }
     
115. 
     
116. static void buttons_enable_irq(void)
     
117. {
     
118.         unsigned int value;
     
119.         iowrite32((1<<5),virt_SRCPND);
     
120.         iowrite32((1<<5),virt_INTPND);
     
121.         value = ioread32(virt_INTMSK);
     
122.         value &= ~(1<<5);
     
123.         iowrite32(value,virt_INTMSK);       
     
124. 
     
125.         value = 0;
     
126.         value |= (1<<8)|(1<<11)|(1<<13)|(1<<14)|(1<<15)|(1<<19);
     
127.         iowrite32(value,virt_EINTPEND);
     
128. 
     
129.         value = ioread32(virt_EINTMASK);
     
130.         value &= ~((1<<8)|(1<<11)|(1<<13)|(1<<14)|(1<<15)|(1<<19));
     
131.         iowrite32(value,virt_EINTMASK);
     
132. 
     
133. }
     
134. 
     
135. static void buttons_enable_irq_again(void)
     
136. {
     
137.         unsigned int value;
     
138.         value = 0;
     
139.         value = ioread32(virt_INTPND);
     
140.         if(value = (1<<5))
     
141.         {
     
142.                 iowrite32((1<<5),virt_SRCPND);
     
143.                 iowrite32((1<<5),virt_INTPND);
     
144.                 value = ioread32(virt_EINTPEND);
     
145.                 if(value = (1<<8))
     
146.                 {
     
147.                         iowrite32(value,virt_EINTPEND);
     
148.                 }else if(value = (1<<11))
     
149.                 {
     
150.                         iowrite32(value,virt_EINTPEND);
     
151.                 }else if(value = (1<<13))
     
152.                 {
     
153.                         iowrite32(value,virt_EINTPEND);
     
154.                 }else if(value = (1<<14))
     
155.                 {
     
156.                         iowrite32(value,virt_EINTPEND);
     
157.                 }else if(value = (1<<15))
     
158.                 {
     
159.                         iowrite32(value,virt_EINTPEND);
     
160.                 }else if(value = (1<<19))
     
161.                 {
     
162.                         iowrite32(value,virt_EINTPEND);
     
163.                 }
     
164.         }
     
165. }
     
166. 
     
167. static void buttons_lowlevel(void)
     
168. {
     
169.         unsigned int value;
     
170.         value = 0;
     
171. 
     
172.         value &= ~((7<<0)|(7<<12)|(7<<20)|(7<<24)|(7<<28));
     
173.         iowrite32(value,virt_EXTINT1);
     
174. 
     
175.         value &= ~(7<<12);
     
176.         iowrite32(value,virt_EXTINT2);
     
177. }
     
178. 
     
179. static int buttons_open(struct inode *inode,struct file *filp)
     
180. {
     
181.         filp->private_data = buttons_devp;
     
182.         buttons_devp->head = buttons_devp->tail =0;
     
183.         return 0;
     
184. }
     
185. 
     
186. static int buttons_release(struct inode *inode,struct file *filp)
     
187. {
     
188.         return 0;
     
189. }
     
190. 
     
191. static ssize_t buttons_read(struct file *filp,char __user *buf,
     
192.                                 size_t size,loff_t *ppos)
     
193. {
     
194.         int ret;
     
195.         retry:if(buttons_devp->head != buttons_devp->tail)
     
196.         {
     
197. //                buf = buttons_devp->buf[buttons_devp->tail];
     
198.                 ret = copy_to_user(buf,(void *)buttons_devp->buf[buttons_devp->tail],sizeof(unsigned char));
     
199.                 (buttons_devp->tail)++;
     
200.                 if(buttons_devp->tail == MAX_BUTTONS_BUF)
     
201.                 {
     
202.                         buttons_devp->tail = 0;
     
203.                 }
     
204.         }else{
     
205.                 __set_current_state(TASK_INTERRUPTIBLE);
     
206.                 if(filp->f_flags & O_NONBLOCK)
     
207.                 {
     
208.                         return -EAGAIN;
     
209.                 }
     
210.                 schedule();
     
211.                 if(signal_pending(current))
     
212.                 {
     
213.                         return -ERESTARTSYS;
     
214.                 }
     
215.                 goto retry;
     
216.         }
     
217.         return ret;
     
218. }
     
219.                
     
220. static int is_buttons_down(unsigned long data)
     
221. {
     
222.         int key = data;
     
223.         unsigned long ret;
     
224.         void __iomem * base = S3C24XX_GPIO_BASE(buttons_info_tab[key].gpio_port);
     
225.         unsigned long offs = S3C2410_GPIO_OFFSET(buttons_info_tab[key].gpio_port);
     
226.         ret = __raw_readl(base + 0x04) & (1 << offs);
     
227.         if(ret == 0)
     
228.                 return 1;
     
229.         else
     
230.                 return 0;
     
231. }
     
232. 
     
233. static void buttons_event(int data)
     
234. {
     
235.         int key = data;
     
236.         buttons_devp->buf[buttons_devp->head] = buttons_info_tab[key].buttons_no;
     
237.         (buttons_devp->head)++;
     
238.         if(buttons_devp->head == MAX_BUTTONS_BUF)
     
239.                 buttons_devp->head = 0;
     
240.         wake_up_interruptible(&buttons_devp->wq);
     
241. }
     
242. 
     
243. static void buttons_timer_func(unsigned long data)
     
244. {
     
245.         int key = data;
     
246.         if(is_buttons_down(key))
     
247.         {
     
248.                 if(buttons_devp->buttonStatus[key] == BUTTONSTATUS_DOWNX)
     
249.                 {
     
250.                         buttons_devp->buttonStatus[key] == BUTTONSTATUS_DOWN;
     
251.                         buttons_event(key);
     
252.                         buttons_timer[key].expires = jiffies + BUTTONS_TIMER_DELAY1;
     
253.                         add_timer(&buttons_timer[key]);
     
254.                 }else{
     
255.                         buttons_timer[key].expires = jiffies + BUTTONS_TIMER_DELAY1;
     
256.                         add_timer(&buttons_timer[key]);
     
257.                 }
     
258.         }else{
     
259.                 buttons_devp->buttonStatus[key] == BUTTONSTATUS_UP;
     
260.                 enable_irq(buttons_info_tab[key].irq_no);
     
261.         }
     
262. }
     
263. 
     
264. static irqreturn_t buttons_eint_func(int irq,void *dev_id,struct pt_regs *regs)
     
265. {
     
266.         int key = dev_id;
     
267.         disable_irq(buttons_info_tab[key].irq_no);
     
268.         buttons_enable_irq_again();
     
269.         buttons_devp->buttonStatus[key] = BUTTONSTATUS_DOWNX;
     
270.         buttons_timer[key].expires = jiffies + BUTTONS_TIMER_DELAY;
     
271.         add_timer(&buttons_timer[key]);
     
272. }
     
273. 
     
274. static int request_irqs(void)
     
275. {
     
276.         int i,ret;
     
277.         buttons_lowlevel();
     
278.         for(i = 0;i < sizeof(buttons_info_tab)/sizeof(buttons_info_tab[1]);i++)
     
279.         {
     
280.                 set_irq_type(buttons_info_tab[i].irq_no,IRQT_LOW);
     
281.                 ret = request_irq(buttons_info_tab[i].irq_no,buttons_eint_func,        SA_INTERRUPT,DEVICE_NAME,i);
     
282.                 if(ret)
     
283.                         return - EINVAL;
     
284.         }
     
285.         return 0;
     
286. }
     
287. 
     
288. static int buttons_setup_cdev(struct buttons_dev *dev,int index)
     
289. {
     
290.         int err,devno = MKDEV(buttons_major,index);
     
291.         cdev_init(&dev->cdev,&buttons_fops);
     
292.         dev->cdev.owner = THIS_MODULE;
     
293.         dev->cdev.ops = &buttons_fops;
     
294.         err = cdev_add(&dev->cdev,devno,1);
     
295.         if(err)
     
296.                 printk(KERN_NOTICE "Error %d adding",err);
     
297.         buttons_enable_irq();
     
298.         request_irqs();
     
299.         /*****  IOREMAP  *****/
     
300.         buttons_ioremap();
     
301.         return 0;
     
302. }
     
303. 
     
304. static int __init buttons_init(void)
     
305. {
     
306.         int i,result;
     
307.         dev_t devno = MKDEV(buttons_major,0);
     
308.         if(buttons_major)
     
309.                 result = register_chrdev_region(devno,1,DEVICE_NAME);
     
310.         else{
     
311.                 result = alloc_chrdev_region(&devno,0,1,DEVICE_NAME);
     
312.                 buttons_major = MAJOR(devno);
     
313.         }
     
314.         if(result)
     
315.                 return result;
     
316.         buttons_devp->head = buttons_devp->tail = 0;
     
317.         for(i = 0;i < BUTTONS_NUM;i++)
     
318.                 buttons_devp->buttonStatus[i] = BUTTONSTATUS_UP;
     
319.         for(i = 0;i < BUTTONS_NUM;i++)
     
320.                 setup_timer(&buttons_timer[i],buttons_timer_func,i);
     
321.         init_waitqueue_head(&(buttons_devp->wq));
     
322.         buttons_setup_cdev(buttons_devp,0);
     
323.         return 0;
     
324. }
     
325. module_init(buttons_init);
     
326. 
     
327. static void __exit buttons_exit(void)
     
328. {
     
329.         int i;
     
330. //        for(i = 0;i < sizeof(buttons_info_tab)/sizeof(buttons_info_tab[i]);i++)
     
331.                 buttons_iounmap();
     
332.         for(i = 0;i < sizeof(buttons_info_tab)/sizeof(buttons_info_tab[i]);i++)
     
333.                 free_irq(buttons_info_tab[i].irq_no,i);
     
334.         cdev_del(&buttons_devp->cdev);
     
335.         for(i = 0;i < BUTTONS_NUM;i++)
     
336.                 del_timer(&buttons_timer[i]);
     
337.         unregister_chrdev_region(MKDEV(buttons_major,0),1);
     
338. }
     
339. module_exit(buttons_exit);
     
340. MODULE_LICENSE("Dual BSD/GPL");
     
341. MODULE_AUTHOR("bejoey_pro");
     
342. 
     
343. 
     

复制代码

[ 本帖最后由 bejoey_pro 于 2009-4-11 16:17 编辑 ]

cjaizss

发代码的时候请用code包起来