Merge branch 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/jk/spufs into...

[linux-2.6-omap-h63xx.git] / arch / xtensa / kernel / traps.c

diff --git a/arch/xtensa/kernel/traps.c b/arch/xtensa/kernel/traps.c
index 27e409089a7b9837ce33927236f21ea89323fdf1..c7a021d9f696bba087df97b70d433a0a216c575b 100644 (file)
--- a/arch/xtensa/kernel/traps.c
+++ b/arch/xtensa/kernel/traps.c
@@ -75,7 +75,7 @@ extern void system_call (struct pt_regs*);
 #define USER           0x02
 
 #define COPROCESSOR(x)                                                 \
-{ XCHAL_EXCCAUSE_COPROCESSOR ## x ## _DISABLED, USER, fast_coprocessor }
+{ EXCCAUSE_COPROCESSOR ## x ## _DISABLED, USER, fast_coprocessor }
 
 typedef struct {
        int cause;
@@ -83,63 +83,63 @@ typedef struct {
        void* handler;
 } dispatch_init_table_t;
 
-dispatch_init_table_t __init dispatch_init_table[] = {
-
-{ XCHAL_EXCCAUSE_ILLEGAL_INSTRUCTION,  0,         do_illegal_instruction},
-{ XCHAL_EXCCAUSE_SYSTEM_CALL,          KRNL,      fast_syscall_kernel },
-{ XCHAL_EXCCAUSE_SYSTEM_CALL,          USER,      fast_syscall_user },
-{ XCHAL_EXCCAUSE_SYSTEM_CALL,          0,         system_call },
-/* XCHAL_EXCCAUSE_INSTRUCTION_FETCH unhandled */
-/* XCHAL_EXCCAUSE_LOAD_STORE_ERROR unhandled*/
-{ XCHAL_EXCCAUSE_LEVEL1_INTERRUPT,     0,         do_interrupt },
-{ XCHAL_EXCCAUSE_ALLOCA,               USER|KRNL, fast_alloca },
-/* XCHAL_EXCCAUSE_INTEGER_DIVIDE_BY_ZERO unhandled */
-/* XCHAL_EXCCAUSE_PRIVILEGED unhandled */
+static dispatch_init_table_t __initdata dispatch_init_table[] = {
+
+{ EXCCAUSE_ILLEGAL_INSTRUCTION,        0,         do_illegal_instruction},
+{ EXCCAUSE_SYSTEM_CALL,                KRNL,      fast_syscall_kernel },
+{ EXCCAUSE_SYSTEM_CALL,                USER,      fast_syscall_user },
+{ EXCCAUSE_SYSTEM_CALL,                0,         system_call },
+/* EXCCAUSE_INSTRUCTION_FETCH unhandled */
+/* EXCCAUSE_LOAD_STORE_ERROR unhandled*/
+{ EXCCAUSE_LEVEL1_INTERRUPT,   0,         do_interrupt },
+{ EXCCAUSE_ALLOCA,             USER|KRNL, fast_alloca },
+/* EXCCAUSE_INTEGER_DIVIDE_BY_ZERO unhandled */
+/* EXCCAUSE_PRIVILEGED unhandled */
 #if XCHAL_UNALIGNED_LOAD_EXCEPTION || XCHAL_UNALIGNED_STORE_EXCEPTION
 #ifdef CONFIG_UNALIGNED_USER
-{ XCHAL_EXCCAUSE_UNALIGNED,            USER,      fast_unaligned },
+{ EXCCAUSE_UNALIGNED,          USER,      fast_unaligned },
 #else
-{ XCHAL_EXCCAUSE_UNALIGNED,            0,         do_unaligned_user },
+{ EXCCAUSE_UNALIGNED,          0,         do_unaligned_user },
 #endif
-{ XCHAL_EXCCAUSE_UNALIGNED,            KRNL,      fast_unaligned },
+{ EXCCAUSE_UNALIGNED,          KRNL,      fast_unaligned },
 #endif
-{ XCHAL_EXCCAUSE_ITLB_MISS,            0,         do_page_fault },
-{ XCHAL_EXCCAUSE_ITLB_MISS,            USER|KRNL, fast_second_level_miss},
-{ XCHAL_EXCCAUSE_ITLB_MULTIHIT,                0,         do_multihit },
-{ XCHAL_EXCCAUSE_ITLB_PRIVILEGE,       0,         do_page_fault },
-/* XCHAL_EXCCAUSE_SIZE_RESTRICTION unhandled */
-{ XCHAL_EXCCAUSE_FETCH_CACHE_ATTRIBUTE,        0,         do_page_fault },
-{ XCHAL_EXCCAUSE_DTLB_MISS,            USER|KRNL, fast_second_level_miss},
-{ XCHAL_EXCCAUSE_DTLB_MISS,            0,         do_page_fault },
-{ XCHAL_EXCCAUSE_DTLB_MULTIHIT,                0,         do_multihit },
-{ XCHAL_EXCCAUSE_DTLB_PRIVILEGE,       0,         do_page_fault },
-/* XCHAL_EXCCAUSE_DTLB_SIZE_RESTRICTION unhandled */
-{ XCHAL_EXCCAUSE_STORE_CACHE_ATTRIBUTE,        USER|KRNL, fast_store_prohibited },
-{ XCHAL_EXCCAUSE_STORE_CACHE_ATTRIBUTE,        0,         do_page_fault },
-{ XCHAL_EXCCAUSE_LOAD_CACHE_ATTRIBUTE, 0,         do_page_fault },
+{ EXCCAUSE_ITLB_MISS,          0,         do_page_fault },
+{ EXCCAUSE_ITLB_MISS,          USER|KRNL, fast_second_level_miss},
+{ EXCCAUSE_ITLB_MULTIHIT,              0,         do_multihit },
+{ EXCCAUSE_ITLB_PRIVILEGE,     0,         do_page_fault },
+/* EXCCAUSE_SIZE_RESTRICTION unhandled */
+{ EXCCAUSE_FETCH_CACHE_ATTRIBUTE,      0,         do_page_fault },
+{ EXCCAUSE_DTLB_MISS,          USER|KRNL, fast_second_level_miss},
+{ EXCCAUSE_DTLB_MISS,          0,         do_page_fault },
+{ EXCCAUSE_DTLB_MULTIHIT,              0,         do_multihit },
+{ EXCCAUSE_DTLB_PRIVILEGE,     0,         do_page_fault },
+/* EXCCAUSE_DTLB_SIZE_RESTRICTION unhandled */
+{ EXCCAUSE_STORE_CACHE_ATTRIBUTE,      USER|KRNL, fast_store_prohibited },
+{ EXCCAUSE_STORE_CACHE_ATTRIBUTE,      0,         do_page_fault },
+{ EXCCAUSE_LOAD_CACHE_ATTRIBUTE,       0,         do_page_fault },
 /* XCCHAL_EXCCAUSE_FLOATING_POINT unhandled */
-#if (XCHAL_CP_MASK & 1)
+#if XTENSA_HAVE_COPROCESSOR(0)
 COPROCESSOR(0),
 #endif
-#if (XCHAL_CP_MASK & 2)
+#if XTENSA_HAVE_COPROCESSOR(1)
 COPROCESSOR(1),
 #endif
-#if (XCHAL_CP_MASK & 4)
+#if XTENSA_HAVE_COPROCESSOR(2)
 COPROCESSOR(2),
 #endif
-#if (XCHAL_CP_MASK & 8)
+#if XTENSA_HAVE_COPROCESSOR(3)
 COPROCESSOR(3),
 #endif
-#if (XCHAL_CP_MASK & 16)
+#if XTENSA_HAVE_COPROCESSOR(4)
 COPROCESSOR(4),
 #endif
-#if (XCHAL_CP_MASK & 32)
+#if XTENSA_HAVE_COPROCESSOR(5)
 COPROCESSOR(5),
 #endif
-#if (XCHAL_CP_MASK & 64)
+#if XTENSA_HAVE_COPROCESSOR(6)
 COPROCESSOR(6),
 #endif
-#if (XCHAL_CP_MASK & 128)
+#if XTENSA_HAVE_COPROCESSOR(7)
 COPROCESSOR(7),
 #endif
 { EXCCAUSE_MAPPED_DEBUG,               0,              do_debug },
@@ -176,7 +176,7 @@ void do_unhandled(struct pt_regs *regs, unsigned long exccause)
        printk("Caught unhandled exception in '%s' "
               "(pid = %d, pc = %#010lx) - should not happen\n"
               "\tEXCCAUSE is %ld\n",
-              current->comm, current->pid, regs->pc, exccause);
+              current->comm, task_pid_nr(current), regs->pc, exccause);
        force_sig(SIGILL, current);
 }
 
@@ -228,7 +228,7 @@ do_illegal_instruction(struct pt_regs *regs)
        /* If in user mode, send SIGILL signal to current process. */
 
        printk("Illegal Instruction in '%s' (pid = %d, pc = %#010lx)\n",
-           current->comm, current->pid, regs->pc);
+           current->comm, task_pid_nr(current), regs->pc);
        force_sig(SIGILL, current);
 }
 
@@ -254,7 +254,7 @@ do_unaligned_user (struct pt_regs *regs)
        current->thread.error_code = -3;
        printk("Unaligned memory access to %08lx in '%s' "
               "(pid = %d, pc = %#010lx)\n",
-              regs->excvaddr, current->comm, current->pid, regs->pc);
+              regs->excvaddr, current->comm, task_pid_nr(current), regs->pc);
        info.si_signo = SIGBUS;
        info.si_errno = 0;
        info.si_code = BUS_ADRALN;
@@ -305,7 +305,7 @@ do_debug(struct pt_regs *regs)
 
 #define set_handler(idx,handler) (exc_table[idx] = (unsigned long) (handler))
 
-void trap_init(void)
+void __init trap_init(void)
 {
        int i;
 
@@ -349,9 +349,7 @@ void show_regs(struct pt_regs * regs)
 
        wmask = regs->wmask & ~1;
 
-       for (i = 0; i < 32; i++) {
-               if (wmask & (1 << (i / 4)))
-                       break;
+       for (i = 0; i < 16; i++) {
                if ((i % 8) == 0)
                        printk ("\n" KERN_INFO "a%02d: ", i);
                printk("%08lx ", regs->areg[i]);
@@ -482,16 +480,15 @@ void die(const char * str, struct pt_regs * regs, long err)
        if (!user_mode(regs))
                show_stack(NULL, (unsigned long*)regs->areg[1]);
 
+       add_taint(TAINT_DIE);
        spin_unlock_irq(&die_lock);
 
        if (in_interrupt())
                panic("Fatal exception in interrupt");
 
-       if (panic_on_oops) {
-               printk(KERN_EMERG "Fatal exception: panic in 5 seconds\n");
-               ssleep(5);
+       if (panic_on_oops)
                panic("Fatal exception");
-       }
+
        do_exit(err);
 }