求助，移植ADC驱动时kernel panic

Issacwcj

昨天移植了ADC驱动，但内核启动过程中会崩掉。

看内核警告应该是 ioremap处出现了空指针（我是这么判断的。。），但我看不出来。
麻烦高手指点一二~感激不尽~

以下是错误信息：
Unable to handle kernel NULL pointer dereference at virtual address 00000000
pgd = c0004000
[00000000] *pgd=00000000
Internal error: Oops: 805 [#1]
last sysfs file:
Modules linked in:
CPU: 0    Not tainted  (2.6.32.46 #1
PC is at adc_init+0x78/0xb4
LR is at __arm_ioremap_pfn+0x120/0x138
pc : [<c0019ec0>]    lr : [<c00365bc>]    psr: a0000013
sp : c3823fb0  ip : 00000000  fp : 00000000
r10: 00000000  r9 : 00000000  r8 : 00000000
r7 : 00000000  r6 : 00000000  r5 : c0022680  r4 : c0443d34
r3 : 00000000  r2 : c486e004  r1 : ffffffe0  r0 : c0400384
Flags: NzCv  IRQs on  FIQs on  Mode SVC_32  ISA ARM  Segment kernel
Control: c000717f  Table: 30004000  DAC: 00000017
Process swapper (pid: 1, stack limit = 0xc3822270)
Stack: (0xc3823fb0 to 0xc3824000)
3fa0:                                     c0019e48 c002f37c c0019e48 00000000
3fc0: c040dbe0 c040dbe0 c00224c4 c0022680 00000000 00000000 00000000 00000000
3fe0: 00000000 c00083fc 00000000 00000000 00000000 c0030868 11cc37dc 33ec33cc
[<c0019ec0>] (adc_init+0x78/0xb4) from [<c002f37c>] (do_one_initcall+0x5c/0x1bc)
[<c002f37c>] (do_one_initcall+0x5c/0x1bc) from [<c00083fc>] (kernel_init+0xa0/0x1)
[<c00083fc>] (kernel_init+0xa0/0x11 from [<c0030868>] (kernel_thread_exit+0x0/0)
Code: ea000007 e2802004 e3a03000 e59f0030 (e5832000)
---[ end trace 0cab6b11a4649c09 ]---

这个是驱动源码：

1. #include <linux/errno.h>
   
2. #include <linux/kernel.h>
   
3. #include <linux/module.h>
   
4. #include <linux/fs.h>
   
5. #include <linux/init.h>
   
6. #include <linux/serio.h>
   
7. #include <linux/delay.h>
   
8. #include <linux/miscdevice.h>
   
9. #include <linux/clk.h>
   
10. #include <linux/wait.h>
    
11. #include <linux/irq.h>
    
12. #include <linux/sched.h>
    
13. #include <asm/io.h>
    
14. #include <asm/irq.h>
    
15. #include <asm/uaccess.h>
    
16. #include <plat/regs-adc.h>
    
17. 
    
18. #define DEVICE_NAME        "adc"
    
19. 
    
20. static void __iomem *base_addr;
    
21. 
    
22. typedef struct {
    
23.         wait_queue_head_t wait;
    
24.         int channel;
    
25.         int prescale;
    
26. }ADC_DEV;
    
27. 
    
28. DECLARE_MUTEX(ADC_LOCK);
    
29. 
    
30. static ADC_DEV adc_dev;
    
31. static volatile int ev_adc = 0;
    
32. static int adc_finish=0;
    
33. static int owned_adc=0;
    
34. static int adc_data;
    
35. static struct clk    *adc_clock;
    
36. 
    
37. #define ADCCON (base_addr + S3C2410_ADCCON)    //ADC control
    
38. 
    
39. #define ADCTSC (base_addr + S3C2410_ADCTSC)    //ADC touch screen control
    
40. 
    
41. #define ADCDLY (base_addr + S3C2410_ADCDLY)    //ADC start or Interval Delay
    
42. 
    
43. #define ADCDAT0 (base_addr + S3C2410_ADCDAT0)    //ADC conversion data 0
    
44. 
    
45. #define ADCDAT1 (base_addr + S3C2410_ADCDAT1)    //ADC conversion data 1
    
46. 
    
47. #define ADCUPDN (base_addr + 0x14)    //Stylus Up/Down interrupt status
    
48. 
    
49. /* ADCCON寄存器设置 */
    
50. #define PRESCALE_DIS (0 << 14)                //预分频禁止
    
51. #define PRESCALE_EN (1 << 14)                //预分频使能
    
52. #define PRSCVL(x) ((x) << 6)                //预分频系数，0~255之间
    
53. #define ADC_INPUT(x) ((x) << 3)                //设置模拟信号输入频道
    
54. #define ADC_START (1 << 0)                //通过读取启动ADC
    
55. #define ADC_ENDCVT (1 << 15)                //转换结束标志
    
56. 
    
57. /* 设置输入频道为ch，预分频系数为prescale，并使能ADC转换 */
    
58. static void start_adc(int ch,int prescale)
    
59. {
    
60.         unsigned int tmp;
    
61. 
    
62.         tmp = PRESCALE_EN | PRSCVL(prescale) | ADC_INPUT(ch);
    
63.         writel(tmp,ADCCON);
    
64. 
    
65.         tmp = readl(ADCCON);
    
66.         tmp |= ADC_START;
    
67.         writel(tmp,ADCCON);
    
68. }
    
69. 
    
70. static irqreturn_t adc_interrupt(int irq,void *dev_id)
    
71. {
    
72.         if(owned_adc){       
    
73.                 adc_data = readl(ADCDAT0)& 0x3ff;
    
74.                 adc_finish = 1 ;
    
75.                 wake_up_interruptible(&adc_dev.wait);
    
76.         }
    
77.         return IRQ_HANDLED;
    
78. }
    
79. 
    
80. static ssize_t adc_read(struct file *filp,char *buffer , size_t count ,loff_t *ppos)
    
81. {
    
82.         if(down_trylock(&ADC_LOCK)==0){
    
83.                 owned_adc = 1;
    
84.                 start_adc(adc_dev.channel,adc_dev.prescale);
    
85.                 wait_event_interruptible(adc_dev.wait,adc_finish);
    
86.                
    
87.                 adc_finish = 0;
    
88. 
    
89.                 copy_to_user(buffer,(char *)&adc_data,sizeof(adc_data));
    
90.                 owned_adc = 0;
    
91. 
    
92.                 up(&ADC_LOCK);
    
93.                 return sizeof(adc_data);
    
94.         }
    
95.         return -EINVAL;
    
96. }
    
97. 
    
98. static int adc_open(struct inode *inode,struct file *filp)
    
99. {
    
100.         int ret;
     
101.         init_waitqueue_head(&(adc_dev.wait));
     
102. 
     
103.         adc_dev.channel = 0;
     
104.         adc_dev.prescale = 0xff;
     
105. 
     
106.         ret = request_irq(IRQ_ADC,adc_interrupt,IRQF_SHARED,DEVICE_NAME,&adc_dev);
     
107.         if(ret){
     
108.                 free_irq(IRQ_ADC,&adc_dev);
     
109.                 return ret;
     
110.         }
     
111.         return 0;
     
112. }
     
113. 
     
114. static int adc_release(struct inode *inode , struct file *filp)
     
115. {
     
116.         free_irq(IRQ_ADC,&adc_dev);
     
117.         return 0;
     
118. }
     
119. 
     
120. static struct file_operations adc_fops = {
     
121.         .owner        =        THIS_MODULE,
     
122.         .open         =        adc_open,
     
123.         .read        =        adc_read,
     
124.         .release=        adc_release,
     
125. };
     
126. 
     
127. static struct miscdevice adc_misc ={
     
128.         .minor        =        MISC_DYNAMIC_MINOR,
     
129.         .name        =        DEVICE_NAME,
     
130.         .fops        =        &adc_fops,
     
131. };
     
132. 
     
133. static int __init adc_init(void)
     
134. {
     
135.         int ret;
     
136.         printk("func:%s",__FUNCTION__);
     
137.        
     
138.         adc_clock = clk_get(NULL,"adc");
     
139. 
     
140.         if(!adc_clock){
     
141.                 printk(KERN_ERR "failed to get adc clock source \n");
     
142.                 return -ENOENT;
     
143.         }
     
144. 
     
145.         clk_enable(adc_clock);
     
146.        
     
147.         base_addr = ioremap(S3C2410_PA_ADC,0x20);
     
148.         if(base_addr == NULL){
     
149.                 printk(KERN_ERR "Failed to remap register block\n");
     
150.                 return -ENOMEM;
     
151.         }
     
152. 
     
153.         writel(ADCTSC,0);
     
154.        
     
155.         ret = misc_register(&adc_misc);
     
156.        
     
157.         printk(DEVICE_NAME "\t :initiated!\n");
     
158. 
     
159.         return ret;
     
160. }
     
161. 
     
162. static void __exit adc_exit(void)
     
163. {
     
164.     free_irq(IRQ_ADC, &adc_dev);
     
165.     iounmap(base_addr);
     
166. 
     
167.     if (adc_clock) {
     
168.         clk_disable(adc_clock);
     
169.         clk_put(adc_clock);
     
170.         adc_clock = NULL;
     
171.     }
     
172. 
     
173.     misc_deregister(&adc_misc);
     
174. }
     
175. 
     
176. EXPORT_SYMBOL(ADC_LOCK);
     
177. module_init(adc_init);
     
178. module_exit(adc_exit);
     
179. MODULE_LICENSE("GPL");
     
180. M

复制代码