adc01a12d15487ff8ae335f8352b9820d00b9395
[linux-2.6.git] / arch / avr32 / kernel / traps.c
1 /*
2  * Copyright (C) 2004-2006 Atmel Corporation
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation.
7  */
8 #undef DEBUG
9 #include <linux/sched.h>
10 #include <linux/init.h>
11 #include <linux/module.h>
12 #include <linux/kallsyms.h>
13 #include <linux/notifier.h>
14
15 #include <asm/traps.h>
16 #include <asm/sysreg.h>
17 #include <asm/addrspace.h>
18 #include <asm/ocd.h>
19 #include <asm/mmu_context.h>
20 #include <asm/uaccess.h>
21
22 static void dump_mem(const char *str, unsigned long bottom, unsigned long top)
23 {
24         unsigned long p;
25         int i;
26
27         printk("%s(0x%08lx to 0x%08lx)\n", str, bottom, top);
28
29         for (p = bottom & ~31; p < top; ) {
30                 printk("%04lx: ", p & 0xffff);
31
32                 for (i = 0; i < 8; i++, p += 4) {
33                         unsigned int val;
34
35                         if (p < bottom || p >= top)
36                                 printk("         ");
37                         else {
38                                 if (__get_user(val, (unsigned int __user *)p)) {
39                                         printk("\n");
40                                         goto out;
41                                 }
42                                 printk("%08x ", val);
43                         }
44                 }
45                 printk("\n");
46         }
47
48 out:
49         return;
50 }
51
52 static inline int valid_stack_ptr(struct thread_info *tinfo, unsigned long p)
53 {
54         return (p > (unsigned long)tinfo)
55                 && (p < (unsigned long)tinfo + THREAD_SIZE - 3);
56 }
57
58 #ifdef CONFIG_FRAME_POINTER
59 static inline void __show_trace(struct task_struct *tsk, unsigned long *sp,
60                                 struct pt_regs *regs)
61 {
62         unsigned long lr, fp;
63         struct thread_info *tinfo;
64
65         tinfo = (struct thread_info *)
66                 ((unsigned long)sp & ~(THREAD_SIZE - 1));
67
68         if (regs)
69                 fp = regs->r7;
70         else if (tsk == current)
71                 asm("mov %0, r7" : "=r"(fp));
72         else
73                 fp = tsk->thread.cpu_context.r7;
74
75         /*
76          * Walk the stack as long as the frame pointer (a) is within
77          * the kernel stack of the task, and (b) it doesn't move
78          * downwards.
79          */
80         while (valid_stack_ptr(tinfo, fp)) {
81                 unsigned long new_fp;
82
83                 lr = *(unsigned long *)fp;
84                 printk(" [<%08lx>] ", lr);
85                 print_symbol("%s\n", lr);
86
87                 new_fp = *(unsigned long *)(fp + 4);
88                 if (new_fp <= fp)
89                         break;
90                 fp = new_fp;
91         }
92         printk("\n");
93 }
94 #else
95 static inline void __show_trace(struct task_struct *tsk, unsigned long *sp,
96                                 struct pt_regs *regs)
97 {
98         unsigned long addr;
99
100         while (!kstack_end(sp)) {
101                 addr = *sp++;
102                 if (kernel_text_address(addr)) {
103                         printk(" [<%08lx>] ", addr);
104                         print_symbol("%s\n", addr);
105                 }
106         }
107 }
108 #endif
109
110 void show_trace(struct task_struct *tsk, unsigned long *sp,
111                        struct pt_regs *regs)
112 {
113         if (regs &&
114             (((regs->sr & MODE_MASK) == MODE_EXCEPTION) ||
115              ((regs->sr & MODE_MASK) == MODE_USER)))
116                 return;
117
118         printk ("Call trace:");
119 #ifdef CONFIG_KALLSYMS
120         printk("\n");
121 #endif
122
123         __show_trace(tsk, sp, regs);
124         printk("\n");
125 }
126
127 void show_stack(struct task_struct *tsk, unsigned long *sp)
128 {
129         unsigned long stack;
130
131         if (!tsk)
132                 tsk = current;
133         if (sp == 0) {
134                 if (tsk == current) {
135                         register unsigned long *real_sp __asm__("sp");
136                         sp = real_sp;
137                 } else {
138                         sp = (unsigned long *)tsk->thread.cpu_context.ksp;
139                 }
140         }
141
142         stack = (unsigned long)sp;
143         dump_mem("Stack: ", stack,
144                  THREAD_SIZE + (unsigned long)tsk->thread_info);
145         show_trace(tsk, sp, NULL);
146 }
147
148 void dump_stack(void)
149 {
150         show_stack(NULL, NULL);
151 }
152 EXPORT_SYMBOL(dump_stack);
153
154 ATOMIC_NOTIFIER_HEAD(avr32_die_chain);
155
156 int register_die_notifier(struct notifier_block *nb)
157 {
158         pr_debug("register_die_notifier: %p\n", nb);
159
160         return atomic_notifier_chain_register(&avr32_die_chain, nb);
161 }
162 EXPORT_SYMBOL(register_die_notifier);
163
164 int unregister_die_notifier(struct notifier_block *nb)
165 {
166         return atomic_notifier_chain_unregister(&avr32_die_chain, nb);
167 }
168 EXPORT_SYMBOL(unregister_die_notifier);
169
170 static DEFINE_SPINLOCK(die_lock);
171
172 void __die(const char *str, struct pt_regs *regs, unsigned long err,
173            const char *file, const char *func, unsigned long line)
174 {
175         struct task_struct *tsk = current;
176         static int die_counter;
177
178         console_verbose();
179         spin_lock_irq(&die_lock);
180         bust_spinlocks(1);
181
182         printk(KERN_ALERT "%s", str);
183         if (file && func)
184                 printk(" in %s:%s, line %ld", file, func, line);
185         printk("[#%d]:\n", ++die_counter);
186         print_modules();
187         show_regs(regs);
188         printk("Process %s (pid: %d, stack limit = 0x%p)\n",
189                tsk->comm, tsk->pid, tsk->thread_info + 1);
190
191         if (!user_mode(regs) || in_interrupt()) {
192                 dump_mem("Stack: ", regs->sp,
193                          THREAD_SIZE + (unsigned long)tsk->thread_info);
194         }
195
196         bust_spinlocks(0);
197         spin_unlock_irq(&die_lock);
198         do_exit(SIGSEGV);
199 }
200
201 void __die_if_kernel(const char *str, struct pt_regs *regs, unsigned long err,
202                      const char *file, const char *func, unsigned long line)
203 {
204         if (!user_mode(regs))
205                 __die(str, regs, err, file, func, line);
206 }
207
208 asmlinkage void do_nmi(unsigned long ecr, struct pt_regs *regs)
209 {
210 #ifdef CONFIG_SUBARCH_AVR32B
211         /*
212          * The exception entry always saves RSR_EX. For NMI, this is
213          * wrong; it should be RSR_NMI
214          */
215         regs->sr = sysreg_read(RSR_NMI);
216 #endif
217
218         printk("NMI taken!!!!\n");
219         die("NMI", regs, ecr);
220         BUG();
221 }
222
223 asmlinkage void do_critical_exception(unsigned long ecr, struct pt_regs *regs)
224 {
225         printk("Unable to handle critical exception %lu at pc = %08lx!\n",
226                ecr, regs->pc);
227         die("Oops", regs, ecr);
228         BUG();
229 }
230
231 asmlinkage void do_address_exception(unsigned long ecr, struct pt_regs *regs)
232 {
233         siginfo_t info;
234
235         die_if_kernel("Oops: Address exception in kernel mode", regs, ecr);
236
237 #ifdef DEBUG
238         if (ecr == ECR_ADDR_ALIGN_X)
239                 pr_debug("Instruction Address Exception at pc = %08lx\n",
240                          regs->pc);
241         else if (ecr == ECR_ADDR_ALIGN_R)
242                 pr_debug("Data Address Exception (Read) at pc = %08lx\n",
243                          regs->pc);
244         else if (ecr == ECR_ADDR_ALIGN_W)
245                 pr_debug("Data Address Exception (Write) at pc = %08lx\n",
246                          regs->pc);
247         else
248                 BUG();
249
250         show_regs(regs);
251 #endif
252
253         info.si_signo = SIGBUS;
254         info.si_errno = 0;
255         info.si_code = BUS_ADRALN;
256         info.si_addr = (void __user *)regs->pc;
257
258         force_sig_info(SIGBUS, &info, current);
259 }
260
261 /* This way of handling undefined instructions is stolen from ARM */
262 static LIST_HEAD(undef_hook);
263 static spinlock_t undef_lock = SPIN_LOCK_UNLOCKED;
264
265 void register_undef_hook(struct undef_hook *hook)
266 {
267         spin_lock_irq(&undef_lock);
268         list_add(&hook->node, &undef_hook);
269         spin_unlock_irq(&undef_lock);
270 }
271
272 void unregister_undef_hook(struct undef_hook *hook)
273 {
274         spin_lock_irq(&undef_lock);
275         list_del(&hook->node);
276         spin_unlock_irq(&undef_lock);
277 }
278
279 static int do_cop_absent(u32 insn)
280 {
281         int cop_nr;
282         u32 cpucr;
283         if ( (insn & 0xfdf00000) == 0xf1900000 )
284                 /* LDC0 */
285                 cop_nr = 0;
286         else
287                 cop_nr = (insn >> 13) & 0x7;
288
289         /* Try enabling the coprocessor */
290         cpucr = sysreg_read(CPUCR);
291         cpucr |= (1 << (24 + cop_nr));
292         sysreg_write(CPUCR, cpucr);
293
294         cpucr = sysreg_read(CPUCR);
295         if ( !(cpucr & (1 << (24 + cop_nr))) ){
296                 printk("Coprocessor #%i not found!\n", cop_nr);
297                 return -1;
298         }
299
300         return 0;
301 }
302
303 #ifdef CONFIG_BUG
304 #ifdef CONFIG_DEBUG_BUGVERBOSE
305 static inline void do_bug_verbose(struct pt_regs *regs, u32 insn)
306 {
307         char *file;
308         u16 line;
309         char c;
310
311         if (__get_user(line, (u16 __user *)(regs->pc + 2)))
312                 return;
313         if (__get_user(file, (char * __user *)(regs->pc + 4))
314             || (unsigned long)file < PAGE_OFFSET
315             || __get_user(c, file))
316                 file = "<bad filename>";
317
318         printk(KERN_ALERT "kernel BUG at %s:%d!\n", file, line);
319 }
320 #else
321 static inline void do_bug_verbose(struct pt_regs *regs, u32 insn)
322 {
323
324 }
325 #endif
326 #endif
327
328 asmlinkage void do_illegal_opcode(unsigned long ecr, struct pt_regs *regs)
329 {
330         u32 insn;
331         struct undef_hook *hook;
332         siginfo_t info;
333         void __user *pc;
334
335         if (!user_mode(regs))
336                 goto kernel_trap;
337
338         local_irq_enable();
339
340         pc = (void __user *)instruction_pointer(regs);
341         if (__get_user(insn, (u32 __user *)pc))
342                 goto invalid_area;
343
344         if (ecr == ECR_COPROC_ABSENT) {
345                 if (do_cop_absent(insn) == 0)
346                         return;
347         }
348
349         spin_lock_irq(&undef_lock);
350         list_for_each_entry(hook, &undef_hook, node) {
351                 if ((insn & hook->insn_mask) == hook->insn_val) {
352                         if (hook->fn(regs, insn) == 0) {
353                                 spin_unlock_irq(&undef_lock);
354                                 return;
355                         }
356                 }
357         }
358         spin_unlock_irq(&undef_lock);
359
360 invalid_area:
361
362 #ifdef DEBUG
363         printk("Illegal instruction at pc = %08lx\n", regs->pc);
364         if (regs->pc < TASK_SIZE) {
365                 unsigned long ptbr, pgd, pte, *p;
366
367                 ptbr = sysreg_read(PTBR);
368                 p = (unsigned long *)ptbr;
369                 pgd = p[regs->pc >> 22];
370                 p = (unsigned long *)((pgd & 0x1ffff000) | 0x80000000);
371                 pte = p[(regs->pc >> 12) & 0x3ff];
372                 printk("page table: 0x%08lx -> 0x%08lx -> 0x%08lx\n", ptbr, pgd, pte);
373         }
374 #endif
375
376         info.si_signo = SIGILL;
377         info.si_errno = 0;
378         info.si_addr = (void __user *)regs->pc;
379         switch (ecr) {
380         case ECR_ILLEGAL_OPCODE:
381         case ECR_UNIMPL_INSTRUCTION:
382                 info.si_code = ILL_ILLOPC;
383                 break;
384         case ECR_PRIVILEGE_VIOLATION:
385                 info.si_code = ILL_PRVOPC;
386                 break;
387         case ECR_COPROC_ABSENT:
388                 info.si_code = ILL_COPROC;
389                 break;
390         default:
391                 BUG();
392         }
393
394         force_sig_info(SIGILL, &info, current);
395         return;
396
397 kernel_trap:
398 #ifdef CONFIG_BUG
399         if (__kernel_text_address(instruction_pointer(regs))) {
400                 insn = *(u16 *)instruction_pointer(regs);
401                 if (insn == AVR32_BUG_OPCODE) {
402                         do_bug_verbose(regs, insn);
403                         die("Kernel BUG", regs, 0);
404                         return;
405                 }
406         }
407 #endif
408
409         die("Oops: Illegal instruction in kernel code", regs, ecr);
410 }
411
412 asmlinkage void do_fpe(unsigned long ecr, struct pt_regs *regs)
413 {
414         siginfo_t info;
415
416         printk("Floating-point exception at pc = %08lx\n", regs->pc);
417
418         /* We have no FPU... */
419         info.si_signo = SIGILL;
420         info.si_errno = 0;
421         info.si_addr = (void __user *)regs->pc;
422         info.si_code = ILL_COPROC;
423
424         force_sig_info(SIGILL, &info, current);
425 }
426
427
428 void __init trap_init(void)
429 {
430
431 }