求助，加载内核出现0oops错误~~苦啊~~~~

ady2002

错误如下

1. Unable to handle kernel NULL pointer dereference at virtual address 00000000
   
2. pgd = c0a40000
   
3. *pgd = 00000000, *pmd = 00000000
   
4. Internal error: Oops: 0
   
5. CPU: 0
   
6. pc : [<c6cb00a4>]    lr : [<c001f0e4>]    Not tainted
   
7. sp : c0a6de04  ip : c0a6de1c  fp : c0a6de44
   
8. r10: c0223020  r9 : c0a6de48  r8 : c021ae7c
   
9. r7 : c021afdc  r6 : 20000000  r5 : c6cb085c  r4 : c3561560
   
10. r3 : c6cb0a28  r2 : 00000000  r1 : c6cb09fc  r0 : c6cb0678
    
11. Flags: nzcv  IRQs off  FIQs on  Mode SVC_32  Segment user
    
12. Control: C000317F  Table: 30A40000  DAC: 00000015
    
13. Process insmod (pid: 67, stackpage=c0a6d000)
    
14. Stack: (0xc0a6ddf4 to 0xc0a6e000)
    
15. dde0:                                              c001f0e4 c6cb00a4 00000093
    
16. de00: ffffffff c3561560 0000000b c0a6de44 c0a6de1c c001f0e4 c6cb0070 ea000000
    
17. de20: c0a6de90 00000001 c001f258 60000013 ffffffff c6cb0794 c0a6deac c0a6de48
    
18. de40: c001e4e0 c001f034 0000000b 00000001 080097c4 ea000000 c3561560 0000000b
    
19. de60: 00000000 40000013 20000000 00000000 c6cb0794 c0a6deac c0a6de90 c0a6de90
    
20. de80: c001f254 c001f258 60000013 ffffffff c3561560 00000000 0000000b c6cb0060
    
21. dea0: c0a6ded8 c0a6deb0 c001f30c c001f198 c6cb09f0 00000000 c6cb0794 00000060
    
22. dec0: ffffffea 0202dc58 c0a6c000 c0a6df04 c0a6dedc c6cb04a8 c001f274 00000000
    
23. dee0: c004511c c0044638 c0a6df04 c6cb0000 00000000 c3497000 c0a6dfa4 c0a6df08
    
24. df00: c002c450 c6cb038c c3497000 c0a6df1c c3499000 0000000b c35613e0 00000060
    
25. df20: c6ca0000 c6cb0060 00000b30 00000000 00000000 00000000 00000000 00000000
    
26. df40: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000
    
27. df60: 00000000 00000000 00000000 00000000 00000000 00000000 00000000 bfffd0f0
    
28. df80: 0202a840 0202dc58 00000080 c001e9a4 c0a6c000 00000000 00000000 c0a6dfa8
    
29. dfa0: c001e820 c002bd68 bfffd0f0 c0027dc8 0201f3b0 0202dc58 ffffffff fbad2084
    
30. dfc0: bfffd0f0 0202a840 0202dc58 c6cb0000 00000b30 00000000 00000000 bfffd0c0
    
31. dfe0: 4009eb40 bfffd0b0 02010064 4009eb4c 60000010 0201f3b0 00000000 00000000
    
32. Backtrace:
    
33. Function entered at [<c001f024>] from [<c001e4e0>]
    
34. Function entered at [<c001f188>] from [<c001f30c>]
    
35. r7 = C6CB0060  r6 = 0000000B  r5 = 00000000  r4 = C3561560
    
36. Function entered at [<c001f264>] from [<c6cb04a8>]
    
37. Function entered at [<c6cb037c>] from [<c002c450>]
    
38. r6 = C3497000  r5 = 00000000  r4 = C6CB0000
    
39. Function entered at [<c002bd58>] from [<c001e820>]
    
40. Code: e59f305c e59f505c e5932000 e59f3058 (e5924000)
    
41. Kernel panic: Aiee, killing interrupt handler!
    
42. In interrupt handler - not syncing
    

复制代码

ady2002

源代码如下

1. /* driver/char/adc0809.c
   
2. *  this is a adc0809 char device driver.
   
3. * Any problem pls contact [email]support@hhcn.com[/email]
   
4. */
   
5. #include <module.h>
   
6. #include <linux/fs.h>
   
7. #include <linux/iobuf.h>
   
8. #include <linux/major.h>
   
9. #include <linux/blkdev.h>
   
10. #include <linux/capability.h>
    
11. #include <linux/smp_lock.h>
    
12. #include <asm/uaccess.h>
    
13. #include <asm/hardware.h>
    
14. #include <asm/arch/cpu_s3c2410.h>
    
15. #include <asm/io.h>
    
16. #include <linux/vmalloc.h>
    
17. #include <linux/kernel.h>
    
18. 
    
19. #include <linux/signal.h>
    
20. #include <linux/sched.h>
    
21. #include <linux/timer.h>
    
22. #include <linux/interrupt.h>
    
23. #include <asm/irq.h>
    
24. #include <asm/arch/hardware.h>
    
25. #include <asm/arch/irqs.h>
    
26. 
    
27. #include <linux/init.h>
    
28. #include <linux/timer.h>
    
29. 
    
30. 
    
31. //#include "adc0809_ioctl.h"
    
32. 
    
33. MODULE_LICENSE("GPL");
    
34. 
    
35. #define ADC0809_MAJOR 231
    
36. /*define the adc0809 major node is 231*/
    
37. 
    
38. 
    
39. #define adc0809_sle (*(volatile unsigned long *)ADC_GPACON)
    
40. #define adc0809_sle_data (*(volatile unsigned long *)ADC_GPADATA)
    
41. 
    
42. 
    
43. unsigned long ADC_GPACON, ADC_GPADATA;
    
44. static unsigned long ADC_1; //ADC_1, ADC_2, ADC_3, ADC_4, ADC_5, ADC_6, ADC_7;
    
45. unsigned long ADC_DATA;
    
46. static unsigned long r_TCFG0,r_TCFG1,r_TCNTB1,r_TCMPB1,r_TCON,r_GPCCON;
    
47. 
    
48. unsigned long adc_write_addr;
    
49. unsigned long adc_read_addr;
    
50. //int * adc_read_addr,* adc_write_addr;
    
51. 
    
52. 
    
53. devfs_handle_t devfs_adc;
    
54. 
    
55. void adc0809_interrupt(int,void *,struct pt_regs *);
    
56. 
    
57. int  adc0809_open(struct inode *, struct file *);
    
58. int  adc0809_release(struct inode *, struct file *);
    
59. //int  adc0809_ioctl(struct inode *, struct file *, unsigned int, unsigned long);
    
60. ssize_t adc0809_read(struct file *, char * , size_t , loff_t *);
    
61. ssize_t adc0809_write(struct file *, const char *, size_t , loff_t *);
    
62. 
    
63. static struct file_operations adc0809_fops = {
    
64.        // ioctl:          adc0809_ioctl,   //根据参数确定读取的引脚;
    
65.         open:           adc0809_open,                //选中片选NGCS2(初始化ADC0809的管脚配置),初始化adc_read_addr;
    
66.         read:           adc0809_read,
    
67.         write:          adc0809_write,
    
68.         release:        adc0809_release,
    
69. };
    
70. 
    
71. //struct timer_list timer_ForData;  // 定时器
    
72. 
    
73. char data; //变量类型不同也会出错,之前使用unsigned long所得是一连串八位数字要么是-1
    
74. //unsigned long addr;
    
75. 
    
76. int adc0809_sum=0;
    
77. /*------------中断处理函数------------------*/
    
78. void adc0809_interrupt(int irq,void *d,struct pt_regs *regs)
    
79. {
    
80.         char adc0809_v=0,adc0809_u=0;
    
81. /*clear interrupt register for INT_TIMER0*/
    
82.         SRCPND &= (~0x00000800);    //bit11
    
83.         INTPND = INTPND;
    
84.         (*(volatile unsigned char *) ADC_1) = (char) 1;
    
85. 
    
86. 
    
87.           data = (*(volatile unsigned long *) adc_read_addr);
    
88.         if(data<200){adc0809_v=0;}
    
89.                 else adc0809_v=1;
    
90.         if(adc0809_v<adc0809_u){adc0809_sum=adc0809_sum+1;}
    
91.                 else adc0809_sum=adc0809_sum;
    
92.         adc0809_u=adc0809_v;
    
93. printk("data:%d\n",data);
    
94. printk("adc0809_u:%d\n",adc0809_u);
    
95. printk("adc0809_v:%d\n",adc0809_v);
    
96. printk("adc0809_sum:%d\n",adc0809_sum);
    
97. }
    
98. 
    
99. /*------- Open/close code for raw IO.-----*/
    
100. int adc0809_open(struct inode *inode, struct file *filp)
     
101. {
     
102.           adc_read_addr = ADC_DATA;
     
103.        
     
104.         printk("open ok\n");
     
105.           return 0;
     
106. }
     
107. /*------------read()----------------*/
     
108. ssize_t adc0809_read(struct file *filp, char * buf,
     
109.                  size_t size, loff_t *offp)
     
110. {       
     
111.         char key;
     
112.        
     
113.        
     
114.         key =adc0809_sum;
     
115.         printk("key_driver:%d\n",key);
     
116.         copy_to_user(buf,&key,1);//put_user(key,buf);
     
117.         //printk("adc0809_read:adc_read_addr=0x%x\n",adc_read_addr);
     
118.         return 1;
     
119. }
     
120. /*------------------write()-------------------------------*/
     
121. ssize_t adc0809_write(struct file *filp, const char *buf,
     
122.                   size_t size, loff_t *offp)
     
123. {
     
124.    char key;
     
125.    if (get_user(key, buf))
     
126.                return -EFAULT;
     
127.    printk("adc0809_write:adc_write_addr=0x%x; key = %c\n",adc_write_addr,key);
     
128. 
     
129.         (*(volatile unsigned char *) adc_write_addr) = key;
     
130.    //put_user(key,buf);
     
131.    return 1;
     
132. }
     
133. 
     
134. /*----------------release()---------------------*/
     
135. int adc0809_release(struct inode *inode, struct file *filp)
     
136. {
     
137.         printk("release ok\n");
     
138.         return 0;
     
139. }
     
140. 
     
141. /*-------------------iormap()--地址影射函数---*/
     
142. static int address_map(void)
     
143. {
     
144.            r_TCFG0 = ioremap(0x51000000,4); //定时器配置寄存器0
     
145.             r_TCFG1 = ioremap(0x51000004,4); //定时器配置寄存器1
     
146.             r_TCNTB1 = ioremap(0x51000018,4);
     
147.            r_TCMPB1 = ioremap(0x5100001C,4);
     
148.             r_TCON = ioremap(0x51000008,4);
     
149.             r_GPCCON = ioremap(0x56000020,4);
     
150. 
     
151.         ADC_GPACON = (unsigned int)ioremap(0x56000000,4);  //物理寄存器的影射,个人认为这里都是指CPLD的物理寄存器
     
152.           ADC_GPADATA = ioremap(0x56000004,4);
     
153.           ADC_1 = ioremap(0x10002010,4);
     
154. 
     
155.           /*---
     
156.         ADC_0 = ioremap(0x10000010,4);
     
157.        
     
158.           ADC_2 = ioremap(0x10004010,4);
     
159.           ADC_3 = ioremap(0x10006010,4);
     
160.           ADC_4 = ioremap(0x10008010,4);
     
161.           ADC_5 = ioremap(0x1000a010,4);
     
162.           ADC_6 = ioremap(0x1000c010,4);
     
163.           ADC_7 = ioremap(0x1000e010,4);  ----*/
     
164.           ADC_DATA = ioremap(0x10000020,4);
     
165.             return 0;
     
166. 
     
167. }
     
168. /*--------------------------------------------------------------------------*/
     
169. int __init adc0809_init(void)
     
170. {
     
171.   static int result;
     
172.   //unsigned long gpfup;
     
173.   //volatile unsigned int bankcon2;       
     
174.   address_map();
     
175.   printk("*********************adc0809_init**************\n");
     
176. 
     
177. 
     
178. // bankcon2=(volatile unsigned int)ioremap(0x4800000c,4);
     
179. // *(volatile unsigned int*)bankcon2 |= 3<<13;  //
     
180.   /* select NGCS2 */
     
181.   adc0809_sle |= 0x2000;
     
182.   adc0809_sle_data &= (~0x2000);
     
183. 
     
184. printk("***********00000000000000000!!***********\n");
     
185.        
     
186. 
     
187. /*-----------初始化S3C2410的时钟timer0--------------------------*/
     
188.         (*(volatile unsigned int *)r_TCFG0) &= 0x11111100;//prescaler=0
     
189.         (*(volatile unsigned int *)r_TCFG1) &= (~0x000000F0);//MUX1=1/2
     
190. //        (*(volatile unsigned int *)r_TCFG1) &= (~0x000000D0);//MUX1=1/8  时间T=r_TCNTB1/625000(s)
     
191.         (*(volatile unsigned int *)r_TCNTB1) = 25000;         //时间为10ms
     
192.             (*(volatile unsigned int *)r_TCMPB1) = 0x00000000;
     
193.             (*(volatile unsigned int *)r_TCON) |= 0x00000E00;
     
194.            (*(volatile unsigned int *)r_TCON) &= (~0x00000200);
     
195.            (*(volatile unsigned int *)r_TCON) |= 0x00000100;
     
196. 
     
197.         disable_irq(IRQ_TIMER1);
     
198.             enable_irq(IRQ_TIMER1);
     
199. printk("***********11111111111111***********\n");
     
200.         result=request_irq(IRQ_TIMER1,&adc0809_interrupt,SA_INTERRUPT,"adc0809",NULL);
     
201. printk("***********222222222222222***********\n");
     
202.         if (!result)
     
203.         {
     
204.                 printk("Get assigned irq %d,result=%d\n",IRQ_TIMER1,result);
     
205. //                return result;
     
206.         }
     
207. /*--*/
     
208. printk("***********Init ok!!***********\n");
     
209.        
     
210. 
     
211.         
     
212.   devfs_adc =
     
213.         devfs_register(NULL,"adc0809",DEVFS_FL_DEFAULT,
     
214.                        ADC0809_MAJOR, 0,
     
215.              S_IFCHR | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP,
     
216.                        &adc0809_fops,NULL);
     
217.         return 0;
     
218. 
     
219. //printk("*********************adc0809_init**************\n");
     
220. }
     
221. //int __init adc0809_exit(void)
     
222. static void __exit adc0809_exit(void)
     
223. {
     
224.         (*(volatile unsigned int *)r_TCON) &= (~0x00000100);
     
225.              disable_irq(IRQ_TIMER1);
     
226.         free_irq(IRQ_TIMER1,NULL);
     
227.              printk("exit ok\n");
     
228. //free_irq(IRQ_EINT2, adc0809_interrupt);
     
229.           devfs_unregister(devfs_adc);
     
230. }
     
231. 
     
232. module_init(adc0809_init);
     
233. module_exit(adc0809_exit);
     
234. 
     

复制代码

通过打印信息，发现加载时
是在初始化程序int __init adc0809_init(void)
中的result=request_irq(IRQ_TIMER1,&adc0809_interrupt,SA_INTERRUPT,"adc0809",NULL);
这一局过不去
实在找不到问题所在 郁闷死了

Steiny

不懂
帮顶
学习
有用

dreamice

我建议你用你第一天贴出来那个程序。
你这个程序错误太多了。

ady2002

第一天贴的程序 没有加时钟中断啊  deamice救救啊

[ 本帖最后由 ady2002 于 2008-11-20 17:00 编辑 ]

ady2002

原帖由 dreamice 于 2008-11-20 16:54 发表
我建议你用你第一天贴出来那个程序。
你这个程序错误太多了。

希望 deamice能帮我指出错误之处哦，我也可以得到提升
第一天的程序虽然可能，我这个程序其实也就是在那个程序上加了个时钟中断，
痛苦啊~~~~~~

dreamice

原帖由 ady2002 于 2008-11-20 17:08 发表

希望 deamice能帮我指出错误之处哦，我也可以得到提升
第一天的程序虽然可能，我这个程序其实也就是在那个程序上加了个时钟中断，
痛苦啊~~~~~~

我给你提的问题都很基本，但你还是没明白如何写一个中断处理程序。所以，你得时钟中断在这里就错得很离奇。

ady2002

原帖由 dreamice 于 2008-11-20 17:12 发表


我给你提的问题都很基本，但你还是没明白如何写一个中断处理程序。所以，你得时钟中断在这里就错得很离奇。

中断处理程序 不是 就是 中断函数  申请中断  注册 以及注销中断处理程序吗？
ldd2上看的

dreamice

就按你说的这些基本要素，你好好检查一下你的程序是不是符合一个驱动程序的基本要求。

eveson

这也不是一眼就看出来的啊。