arch/mips/kernel/traps.c

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 1994 - 1999, 2000, 01, 06 Ralf Baechle
   7  * Copyright (C) 1995, 1996 Paul M. Antoine
   8  * Copyright (C) 1998 Ulf Carlsson
   9  * Copyright (C) 1999 Silicon Graphics, Inc.
  10  * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com
  11  * Copyright (C) 2000, 01 MIPS Technologies, Inc.
  12  * Copyright (C) 2002, 2003, 2004, 2005  Maciej W. Rozycki
  13  */
  14 #include <linux/init.h>
  15 #include <linux/mm.h>
  16 #include <linux/module.h>
  17 #include <linux/sched.h>
  18 #include <linux/smp.h>
  19 #include <linux/smp_lock.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/kallsyms.h>
  22 #include <linux/bootmem.h>
  23 #include <linux/interrupt.h>
  24
  25 #include <asm/bootinfo.h>
  26 #include <asm/branch.h>
  27 #include <asm/break.h>
  28 #include <asm/cpu.h>
  29 #include <asm/dsp.h>
  30 #include <asm/fpu.h>
  31 #include <asm/mipsregs.h>
  32 #include <asm/mipsmtregs.h>
  33 #include <asm/module.h>
  34 #include <asm/pgtable.h>
  35 #include <asm/ptrace.h>
  36 #include <asm/sections.h>
  37 #include <asm/system.h>
  38 #include <asm/tlbdebug.h>
  39 #include <asm/traps.h>
  40 #include <asm/uaccess.h>
  41 #include <asm/mmu_context.h>
  42 #include <asm/watch.h>
  43 #include <asm/types.h>
  44
  45 extern asmlinkage void handle_int(void);
  46 extern asmlinkage void handle_tlbm(void);
  47 extern asmlinkage void handle_tlbl(void);
  48 extern asmlinkage void handle_tlbs(void);
  49 extern asmlinkage void handle_adel(void);
  50 extern asmlinkage void handle_ades(void);
  51 extern asmlinkage void handle_ibe(void);
  52 extern asmlinkage void handle_dbe(void);
  53 extern asmlinkage void handle_sys(void);
  54 extern asmlinkage void handle_bp(void);
  55 extern asmlinkage void handle_ri(void);
  56 extern asmlinkage void handle_cpu(void);
  57 extern asmlinkage void handle_ov(void);
  58 extern asmlinkage void handle_tr(void);
  59 extern asmlinkage void handle_fpe(void);
  60 extern asmlinkage void handle_mdmx(void);
  61 extern asmlinkage void handle_watch(void);
  62 extern asmlinkage void handle_mt(void);
  63 extern asmlinkage void handle_dsp(void);
  64 extern asmlinkage void handle_mcheck(void);
  65 extern asmlinkage void handle_reserved(void);
  66
  67 extern int fpu_emulator_cop1Handler(struct pt_regs *xcp,
  68         struct mips_fpu_struct *ctx);
  69
  70 void (*board_be_init)(void);
  71 int (*board_be_handler)(struct pt_regs *regs, int is_fixup);
  72 void (*board_nmi_handler_setup)(void);
  73 void (*board_ejtag_handler_setup)(void);
  74 void (*board_bind_eic_interrupt)(int irq, int regset);
  75
  76
  77 static void show_raw_backtrace(unsigned long *sp)
  78 {
  79         unsigned long addr;
  80
  81         printk("Call Trace:");
  82 #ifdef CONFIG_KALLSYMS
  83         printk("\n");
  84 #endif
  85         while (!kstack_end(sp)) {
  86                 addr = *sp++;
  87                 if (__kernel_text_address(addr))
  88                         print_ip_sym(addr);
  89         }
  90         printk("\n");
  91 }
  92
  93 #ifdef CONFIG_KALLSYMS
  94 static int raw_show_trace;
  95 static int __init set_raw_show_trace(char *str)
  96 {
  97         raw_show_trace = 1;
  98         return 1;
  99 }
 100 __setup("raw_show_trace", set_raw_show_trace);
 101
 102 extern unsigned long unwind_stack(struct task_struct *task,
 103                                   unsigned long **sp, unsigned long pc);
 104 static void show_backtrace(struct task_struct *task, struct pt_regs *regs)
 105 {
 106         unsigned long *sp = (long *)regs->regs[29];
 107         unsigned long pc = regs->cp0_epc;
 108         int top = 1;
 109
 110         if (raw_show_trace || !__kernel_text_address(pc)) {
 111                 show_raw_backtrace(sp);
 112                 return;
 113         }
 114         printk("Call Trace:\n");
 115         while (__kernel_text_address(pc)) {
 116                 print_ip_sym(pc);
 117                 pc = unwind_stack(task, &sp, pc);
 118                 if (top && pc == 0)
 119                         pc = regs->regs[31];    /* leaf? */
 120                 top = 0;
 121         }
 122         printk("\n");
 123 }
 124 #else
 125 #define show_backtrace(task, r) show_raw_backtrace((long *)(r)->regs[29]);
 126 #endif
 127
 128 /*
 129  * This routine abuses get_user()/put_user() to reference pointers
 130  * with at least a bit of error checking ...
 131  */
 132 static void show_stacktrace(struct task_struct *task, struct pt_regs *regs)
 133 {
 134         const int field = 2 * sizeof(unsigned long);
 135         long stackdata;
 136         int i;
 137         unsigned long *sp = (unsigned long *)regs->regs[29];
 138
 139         printk("Stack :");
 140         i = 0;
 141         while ((unsigned long) sp & (PAGE_SIZE - 1)) {
 142                 if (i && ((i % (64 / field)) == 0))
 143                         printk("\n       ");
 144                 if (i > 39) {
 145                         printk(" ...");
 146                         break;
 147                 }
 148
 149                 if (__get_user(stackdata, sp++)) {
 150                         printk(" (Bad stack address)");
 151                         break;
 152                 }
 153
 154                 printk(" %0*lx", field, stackdata);
 155                 i++;
 156         }
 157         printk("\n");
 158         show_backtrace(task, regs);
 159 }
 160
 161 static noinline void prepare_frametrace(struct pt_regs *regs)
 162 {
 163         __asm__ __volatile__(
 164                 "1: la $2, 1b\n\t"
 165 #ifdef CONFIG_64BIT
 166                 "sd $2, %0\n\t"
 167                 "sd $29, %1\n\t"
 168                 "sd $31, %2\n\t"
 169 #else
 170                 "sw $2, %0\n\t"
 171                 "sw $29, %1\n\t"
 172                 "sw $31, %2\n\t"
 173 #endif
 174                 : "=m" (regs->cp0_epc),
 175                 "=m" (regs->regs[29]), "=m" (regs->regs[31])
 176                 : : "memory");
 177 }
 178
 179 void show_stack(struct task_struct *task, unsigned long *sp)
 180 {
 181         struct pt_regs regs;
 182         if (sp) {
 183                 regs.regs[29] = (unsigned long)sp;
 184                 regs.regs[31] = 0;
 185                 regs.cp0_epc = 0;
 186         } else {
 187                 if (task && task != current) {
 188                         regs.regs[29] = task->thread.reg29;
 189                         regs.regs[31] = 0;
 190                         regs.cp0_epc = task->thread.reg31;
 191                 } else {
 192                         prepare_frametrace(&regs);
 193                 }
 194         }
 195         show_stacktrace(task, &regs);
 196 }
 197
 198 /*
 199  * The architecture-independent dump_stack generator
 200  */
 201 void dump_stack(void)
 202 {
 203         unsigned long stack;
 204
 205 #ifdef CONFIG_KALLSYMS
 206         if (!raw_show_trace) {
 207                 struct pt_regs regs;
 208                 prepare_frametrace(&regs);
 209                 show_backtrace(current, &regs);
 210                 return;
 211         }
 212 #endif
 213         show_raw_backtrace(&stack);
 214 }
 215
 216 EXPORT_SYMBOL(dump_stack);
 217
 218 void show_code(unsigned int *pc)
 219 {
 220         long i;
 221
 222         printk("\nCode:");
 223
 224         for(i = -3 ; i < 6 ; i++) {
 225                 unsigned int insn;
 226                 if (__get_user(insn, pc + i)) {
 227                         printk(" (Bad address in epc)\n");
 228                         break;
 229                 }
 230                 printk("%c%08x%c", (i?' ':'<'), insn, (i?' ':'>'));
 231         }
 232 }
 233
 234 void show_regs(struct pt_regs *regs)
 235 {
 236         const int field = 2 * sizeof(unsigned long);
 237         unsigned int cause = regs->cp0_cause;
 238         int i;
 239
 240         printk("Cpu %d\n", smp_processor_id());
 241
 242         /*
 243          * Saved main processor registers
 244          */
 245         for (i = 0; i < 32; ) {
 246                 if ((i % 4) == 0)
 247                         printk("$%2d   :", i);
 248                 if (i == 0)
 249                         printk(" %0*lx", field, 0UL);
 250                 else if (i == 26 || i == 27)
 251                         printk(" %*s", field, "");
 252                 else
 253                         printk(" %0*lx", field, regs->regs[i]);
 254
 255                 i++;
 256                 if ((i % 4) == 0)
 257                         printk("\n");
 258         }
 259
 260         printk("Hi    : %0*lx\n", field, regs->hi);
 261         printk("Lo    : %0*lx\n", field, regs->lo);
 262
 263         /*
 264          * Saved cp0 registers
 265          */
 266         printk("epc   : %0*lx ", field, regs->cp0_epc);
 267         print_symbol("%s ", regs->cp0_epc);
 268         printk("    %s\n", print_tainted());
 269         printk("ra    : %0*lx ", field, regs->regs[31]);
 270         print_symbol("%s\n", regs->regs[31]);
 271
 272         printk("Status: %08x    ", (uint32_t) regs->cp0_status);
 273
 274         if (current_cpu_data.isa_level == MIPS_CPU_ISA_I) {
 275                 if (regs->cp0_status & ST0_KUO)
 276                         printk("KUo ");
 277                 if (regs->cp0_status & ST0_IEO)
 278                         printk("IEo ");
 279                 if (regs->cp0_status & ST0_KUP)
 280                         printk("KUp ");
 281                 if (regs->cp0_status & ST0_IEP)
 282                         printk("IEp ");
 283                 if (regs->cp0_status & ST0_KUC)
 284                         printk("KUc ");
 285                 if (regs->cp0_status & ST0_IEC)
 286                         printk("IEc ");
 287         } else {
 288                 if (regs->cp0_status & ST0_KX)
 289                         printk("KX ");
 290                 if (regs->cp0_status & ST0_SX)
 291                         printk("SX ");
 292                 if (regs->cp0_status & ST0_UX)
 293                         printk("UX ");
 294                 switch (regs->cp0_status & ST0_KSU) {
 295                 case KSU_USER:
 296                         printk("USER ");
 297                         break;
 298                 case KSU_SUPERVISOR:
 299                         printk("SUPERVISOR ");
 300                         break;
 301                 case KSU_KERNEL:
 302                         printk("KERNEL ");
 303                         break;
 304                 default:
 305                         printk("BAD_MODE ");
 306                         break;
 307                 }
 308                 if (regs->cp0_status & ST0_ERL)
 309                         printk("ERL ");
 310                 if (regs->cp0_status & ST0_EXL)
 311                         printk("EXL ");
 312                 if (regs->cp0_status & ST0_IE)
 313                         printk("IE ");
 314         }
 315         printk("\n");
 316
 317         printk("Cause : %08x\n", cause);
 318
 319         cause = (cause & CAUSEF_EXCCODE) >> CAUSEB_EXCCODE;
 320         if (1 <= cause && cause <= 5)
 321                 printk("BadVA : %0*lx\n", field, regs->cp0_badvaddr);
 322
 323         printk("PrId  : %08x\n", read_c0_prid());
 324 }
 325
 326 void show_registers(struct pt_regs *regs)
 327 {
 328         show_regs(regs);
 329         print_modules();
 330         printk("Process %s (pid: %d, threadinfo=%p, task=%p)\n",
 331                 current->comm, current->pid, current_thread_info(), current);
 332         show_stacktrace(current, regs);
 333         show_code((unsigned int *) regs->cp0_epc);
 334         printk("\n");
 335 }
 336
 337 static DEFINE_SPINLOCK(die_lock);
 338
 339 NORET_TYPE void ATTRIB_NORET die(const char * str, struct pt_regs * regs)
 340 {
 341         static int die_counter;
 342 #ifdef CONFIG_MIPS_MT_SMTC
 343         unsigned long dvpret = dvpe();
 344 #endif /* CONFIG_MIPS_MT_SMTC */
 345
 346         console_verbose();
 347         spin_lock_irq(&die_lock);
 348         bust_spinlocks(1);
 349 #ifdef CONFIG_MIPS_MT_SMTC
 350         mips_mt_regdump(dvpret);
 351 #endif /* CONFIG_MIPS_MT_SMTC */
 352         printk("%s[#%d]:\n", str, ++die_counter);
 353         show_registers(regs);
 354         spin_unlock_irq(&die_lock);
 355
 356         if (in_interrupt())
 357                 panic("Fatal exception in interrupt");
 358
 359         if (panic_on_oops) {
 360                 printk(KERN_EMERG "Fatal exception: panic in 5 seconds\n");
 361                 ssleep(5);
 362                 panic("Fatal exception");
 363         }
 364
 365         do_exit(SIGSEGV);
 366 }
 367
 368 extern const struct exception_table_entry __start___dbe_table[];
 369 extern const struct exception_table_entry __stop___dbe_table[];
 370
 371 void __declare_dbe_table(void)
 372 {
 373         __asm__ __volatile__(
 374         ".section\t__dbe_table,\"a\"\n\t"
 375         ".previous"
 376         );
 377 }
 378
 379 /* Given an address, look for it in the exception tables. */
 380 static const struct exception_table_entry *search_dbe_tables(unsigned long addr)
 381 {
 382         const struct exception_table_entry *e;
 383
 384         e = search_extable(__start___dbe_table, __stop___dbe_table - 1, addr);
 385         if (!e)
 386                 e = search_module_dbetables(addr);
 387         return e;
 388 }
 389
 390 asmlinkage void do_be(struct pt_regs *regs)
 391 {
 392         const int field = 2 * sizeof(unsigned long);
 393         const struct exception_table_entry *fixup = NULL;
 394         int data = regs->cp0_cause & 4;
 395         int action = MIPS_BE_FATAL;
 396
 397         /* XXX For now.  Fixme, this searches the wrong table ...  */
 398         if (data && !user_mode(regs))
 399                 fixup = search_dbe_tables(exception_epc(regs));
 400
 401         if (fixup)
 402                 action = MIPS_BE_FIXUP;
 403
 404         if (board_be_handler)
 405                 action = board_be_handler(regs, fixup != 0);
 406
 407         switch (action) {
 408         case MIPS_BE_DISCARD:
 409                 return;
 410         case MIPS_BE_FIXUP:
 411                 if (fixup) {
 412                         regs->cp0_epc = fixup->nextinsn;
 413                         return;
 414                 }
 415                 break;
 416         default:
 417                 break;
 418         }
 419
 420         /*
 421          * Assume it would be too dangerous to continue ...
 422          */
 423         printk(KERN_ALERT "%s bus error, epc == %0*lx, ra == %0*lx\n",
 424                data ? "Data" : "Instruction",
 425                field, regs->cp0_epc, field, regs->regs[31]);
 426         die_if_kernel("Oops", regs);
 427         force_sig(SIGBUS, current);
 428 }
 429
 430 static inline int get_insn_opcode(struct pt_regs *regs, unsigned int *opcode)
 431 {
 432         unsigned int __user *epc;
 433
 434         epc = (unsigned int __user *) regs->cp0_epc +
 435               ((regs->cp0_cause & CAUSEF_BD) != 0);
 436         if (!get_user(*opcode, epc))
 437                 return 0;
 438
 439         force_sig(SIGSEGV, current);
 440         return 1;
 441 }
 442
 443 /*
 444  * ll/sc emulation
 445  */
 446
 447 #define OPCODE 0xfc000000
 448 #define BASE   0x03e00000
 449 #define RT     0x001f0000
 450 #define OFFSET 0x0000ffff
 451 #define LL     0xc0000000
 452 #define SC     0xe0000000
 453 #define SPEC3  0x7c000000
 454 #define RD     0x0000f800
 455 #define FUNC   0x0000003f
 456 #define RDHWR  0x0000003b
 457
 458 /*
 459  * The ll_bit is cleared by r*_switch.S
 460  */
 461
 462 unsigned long ll_bit;
 463
 464 static struct task_struct *ll_task = NULL;
 465
 466 static inline void simulate_ll(struct pt_regs *regs, unsigned int opcode)
 467 {
 468         unsigned long value, __user *vaddr;
 469         long offset;
 470         int signal = 0;
 471
 472         /*
 473          * analyse the ll instruction that just caused a ri exception
 474          * and put the referenced address to addr.
 475          */
 476
 477         /* sign extend offset */
 478         offset = opcode & OFFSET;
 479         offset <<= 16;
 480         offset >>= 16;
 481
 482         vaddr = (unsigned long __user *)
 483                 ((unsigned long)(regs->regs[(opcode & BASE) >> 21]) + offset);
 484
 485         if ((unsigned long)vaddr & 3) {
 486                 signal = SIGBUS;
 487                 goto sig;
 488         }
 489         if (get_user(value, vaddr)) {
 490                 signal = SIGSEGV;
 491                 goto sig;
 492         }
 493
 494         preempt_disable();
 495
 496         if (ll_task == NULL || ll_task == current) {
 497                 ll_bit = 1;
 498         } else {
 499                 ll_bit = 0;
 500         }
 501         ll_task = current;
 502
 503         preempt_enable();
 504
 505         compute_return_epc(regs);
 506
 507         regs->regs[(opcode & RT) >> 16] = value;
 508
 509         return;
 510
 511 sig:
 512         force_sig(signal, current);
 513 }
 514
 515 static inline void simulate_sc(struct pt_regs *regs, unsigned int opcode)
 516 {
 517         unsigned long __user *vaddr;
 518         unsigned long reg;
 519         long offset;
 520         int signal = 0;
 521
 522         /*
 523          * analyse the sc instruction that just caused a ri exception
 524          * and put the referenced address to addr.
 525          */
 526
 527         /* sign extend offset */
 528         offset = opcode & OFFSET;
 529         offset <<= 16;
 530         offset >>= 16;
 531
 532         vaddr = (unsigned long __user *)
 533                 ((unsigned long)(regs->regs[(opcode & BASE) >> 21]) + offset);
 534         reg = (opcode & RT) >> 16;
 535
 536         if ((unsigned long)vaddr & 3) {
 537                 signal = SIGBUS;
 538                 goto sig;
 539         }
 540
 541         preempt_disable();
 542
 543         if (ll_bit == 0 || ll_task != current) {
 544                 compute_return_epc(regs);
 545                 regs->regs[reg] = 0;
 546                 preempt_enable();
 547                 return;
 548         }
 549
 550         preempt_enable();
 551
 552         if (put_user(regs->regs[reg], vaddr)) {
 553                 signal = SIGSEGV;
 554                 goto sig;
 555         }
 556
 557         compute_return_epc(regs);
 558         regs->regs[reg] = 1;
 559
 560         return;
 561
 562 sig:
 563         force_sig(signal, current);
 564 }
 565
 566 /*
 567  * ll uses the opcode of lwc0 and sc uses the opcode of swc0.  That is both
 568  * opcodes are supposed to result in coprocessor unusable exceptions if
 569  * executed on ll/sc-less processors.  That's the theory.  In practice a
 570  * few processors such as NEC's VR4100 throw reserved instruction exceptions
 571  * instead, so we're doing the emulation thing in both exception handlers.
 572  */
 573 static inline int simulate_llsc(struct pt_regs *regs)
 574 {
 575         unsigned int opcode;
 576
 577         if (unlikely(get_insn_opcode(regs, &opcode)))
 578                 return -EFAULT;
 579
 580         if ((opcode & OPCODE) == LL) {
 581                 simulate_ll(regs, opcode);
 582                 return 0;
 583         }
 584         if ((opcode & OPCODE) == SC) {
 585                 simulate_sc(regs, opcode);
 586                 return 0;
 587         }
 588
 589         return -EFAULT;                 /* Strange things going on ... */
 590 }
 591
 592 /*
 593  * Simulate trapping 'rdhwr' instructions to provide user accessible
 594  * registers not implemented in hardware.  The only current use of this
 595  * is the thread area pointer.
 596  */
 597 static inline int simulate_rdhwr(struct pt_regs *regs)
 598 {
 599         struct thread_info *ti = task_thread_info(current);
 600         unsigned int opcode;
 601
 602         if (unlikely(get_insn_opcode(regs, &opcode)))
 603                 return -EFAULT;
 604
 605         if (unlikely(compute_return_epc(regs)))
 606                 return -EFAULT;
 607
 608         if ((opcode & OPCODE) == SPEC3 && (opcode & FUNC) == RDHWR) {
 609                 int rd = (opcode & RD) >> 11;
 610                 int rt = (opcode & RT) >> 16;
 611                 switch (rd) {
 612                         case 29:
 613                                 regs->regs[rt] = ti->tp_value;
 614                                 return 0;
 615                         default:
 616                                 return -EFAULT;
 617                 }
 618         }
 619
 620         /* Not ours.  */
 621         return -EFAULT;
 622 }
 623
 624 asmlinkage void do_ov(struct pt_regs *regs)
 625 {
 626         siginfo_t info;
 627
 628         die_if_kernel("Integer overflow", regs);
 629
 630         info.si_code = FPE_INTOVF;
 631         info.si_signo = SIGFPE;
 632         info.si_errno = 0;
 633         info.si_addr = (void __user *) regs->cp0_epc;
 634         force_sig_info(SIGFPE, &info, current);
 635 }
 636
 637 /*
 638  * XXX Delayed fp exceptions when doing a lazy ctx switch XXX
 639  */
 640 asmlinkage void do_fpe(struct pt_regs *regs, unsigned long fcr31)
 641 {
 642         die_if_kernel("FP exception in kernel code", regs);
 643
 644         if (fcr31 & FPU_CSR_UNI_X) {
 645                 int sig;
 646
 647                 preempt_disable();
 648
 649 #ifdef CONFIG_PREEMPT
 650                 if (!is_fpu_owner()) {
 651                         /* We might lose fpu before disabling preempt... */
 652                         own_fpu();
 653                         BUG_ON(!used_math());
 654                         restore_fp(current);
 655                 }
 656 #endif
 657                 /*
 658                  * Unimplemented operation exception.  If we've got the full
 659                  * software emulator on-board, let's use it...
 660                  *
 661                  * Force FPU to dump state into task/thread context.  We're
 662                  * moving a lot of data here for what is probably a single
 663                  * instruction, but the alternative is to pre-decode the FP
 664                  * register operands before invoking the emulator, which seems
 665                  * a bit extreme for what should be an infrequent event.
 666                  */
 667                 save_fp(current);
 668                 /* Ensure 'resume' not overwrite saved fp context again. */
 669                 lose_fpu();
 670
 671                 preempt_enable();
 672
 673                 /* Run the emulator */
 674                 sig = fpu_emulator_cop1Handler (regs, &current->thread.fpu);
 675
 676                 preempt_disable();
 677
 678                 own_fpu();      /* Using the FPU again.  */
 679                 /*
 680                  * We can't allow the emulated instruction to leave any of
 681                  * the cause bit set in $fcr31.
 682                  */
 683                 current->thread.fpu.fcr31 &= ~FPU_CSR_ALL_X;
 684
 685                 /* Restore the hardware register state */
 686                 restore_fp(current);
 687
 688                 preempt_enable();
 689
 690                 /* If something went wrong, signal */
 691                 if (sig)
 692                         force_sig(sig, current);
 693
 694                 return;
 695         }
 696
 697         force_sig(SIGFPE, current);
 698 }
 699
 700 asmlinkage void do_bp(struct pt_regs *regs)
 701 {
 702         unsigned int opcode, bcode;
 703         siginfo_t info;
 704
 705         die_if_kernel("Break instruction in kernel code", regs);
 706
 707         if (get_insn_opcode(regs, &opcode))
 708                 return;
 709
 710         /*
 711          * There is the ancient bug in the MIPS assemblers that the break
 712          * code starts left to bit 16 instead to bit 6 in the opcode.
 713          * Gas is bug-compatible, but not always, grrr...
 714          * We handle both cases with a simple heuristics.  --macro
 715          */
 716         bcode = ((opcode >> 6) & ((1 << 20) - 1));
 717         if (bcode < (1 << 10))
 718                 bcode <<= 10;
 719
 720         /*
 721          * (A short test says that IRIX 5.3 sends SIGTRAP for all break
 722          * insns, even for break codes that indicate arithmetic failures.
 723          * Weird ...)
 724          * But should we continue the brokenness???  --macro
 725          */
 726         switch (bcode) {
 727         case BRK_OVERFLOW << 10:
 728         case BRK_DIVZERO << 10:
 729                 if (bcode == (BRK_DIVZERO << 10))
 730                         info.si_code = FPE_INTDIV;
 731                 else
 732                         info.si_code = FPE_INTOVF;
 733                 info.si_signo = SIGFPE;
 734                 info.si_errno = 0;
 735                 info.si_addr = (void __user *) regs->cp0_epc;
 736                 force_sig_info(SIGFPE, &info, current);
 737                 break;
 738         default:
 739                 force_sig(SIGTRAP, current);
 740         }
 741 }
 742
 743 asmlinkage void do_tr(struct pt_regs *regs)
 744 {
 745         unsigned int opcode, tcode = 0;
 746         siginfo_t info;
 747
 748         die_if_kernel("Trap instruction in kernel code", regs);
 749
 750         if (get_insn_opcode(regs, &opcode))
 751                 return;
 752
 753         /* Immediate versions don't provide a code.  */
 754         if (!(opcode & OPCODE))
 755                 tcode = ((opcode >> 6) & ((1 << 10) - 1));
 756
 757         /*
 758          * (A short test says that IRIX 5.3 sends SIGTRAP for all trap
 759          * insns, even for trap codes that indicate arithmetic failures.
 760          * Weird ...)
 761          * But should we continue the brokenness???  --macro
 762          */
 763         switch (tcode) {
 764         case BRK_OVERFLOW:
 765         case BRK_DIVZERO:
 766                 if (tcode == BRK_DIVZERO)
 767                         info.si_code = FPE_INTDIV;
 768                 else
 769                         info.si_code = FPE_INTOVF;
 770                 info.si_signo = SIGFPE;
 771                 info.si_errno = 0;
 772                 info.si_addr = (void __user *) regs->cp0_epc;
 773                 force_sig_info(SIGFPE, &info, current);
 774                 break;
 775         default:
 776                 force_sig(SIGTRAP, current);
 777         }
 778 }
 779
 780 asmlinkage void do_ri(struct pt_regs *regs)
 781 {
 782         die_if_kernel("Reserved instruction in kernel code", regs);
 783
 784         if (!cpu_has_llsc)
 785                 if (!simulate_llsc(regs))
 786                         return;
 787
 788         if (!simulate_rdhwr(regs))
 789                 return;
 790
 791         force_sig(SIGILL, current);
 792 }
 793
 794 asmlinkage void do_cpu(struct pt_regs *regs)
 795 {
 796         unsigned int cpid;
 797
 798         die_if_kernel("do_cpu invoked from kernel context!", regs);
 799
 800         cpid = (regs->cp0_cause >> CAUSEB_CE) & 3;
 801
 802         switch (cpid) {
 803         case 0:
 804                 if (!cpu_has_llsc)
 805                         if (!simulate_llsc(regs))
 806                                 return;
 807
 808                 if (!simulate_rdhwr(regs))
 809                         return;
 810
 811                 break;
 812
 813         case 1:
 814                 preempt_disable();
 815
 816                 own_fpu();
 817                 if (used_math()) {      /* Using the FPU again.  */
 818                         restore_fp(current);
 819                 } else {                        /* First time FPU user.  */
 820                         init_fpu();
 821                         set_used_math();
 822                 }
 823
 824                 preempt_enable();
 825
 826                 if (!cpu_has_fpu) {
 827                         int sig = fpu_emulator_cop1Handler(regs,
 828                                                 &current->thread.fpu);
 829                         if (sig)
 830                                 force_sig(sig, current);
 831 #ifdef CONFIG_MIPS_MT_FPAFF
 832                         else {
 833                         /*
 834                          * MIPS MT processors may have fewer FPU contexts
 835                          * than CPU threads. If we've emulated more than
 836                          * some threshold number of instructions, force
 837                          * migration to a "CPU" that has FP support.
 838                          */
 839                          if(mt_fpemul_threshold > 0
 840                          && ((current->thread.emulated_fp++
 841                             > mt_fpemul_threshold))) {
 842                           /*
 843                            * If there's no FPU present, or if the
 844                            * application has already restricted
 845                            * the allowed set to exclude any CPUs
 846                            * with FPUs, we'll skip the procedure.
 847                            */
 848                           if (cpus_intersects(current->cpus_allowed,
 849                                                 mt_fpu_cpumask)) {
 850                             cpumask_t tmask;
 851
 852                             cpus_and(tmask,
 853                                         current->thread.user_cpus_allowed,
 854                                         mt_fpu_cpumask);
 855                             set_cpus_allowed(current, tmask);
 856                             current->thread.mflags |= MF_FPUBOUND;
 857                           }
 858                          }
 859                         }
 860 #endif /* CONFIG_MIPS_MT_FPAFF */
 861                 }
 862
 863                 return;
 864
 865         case 2:
 866         case 3:
 867                 die_if_kernel("do_cpu invoked from kernel context!", regs);
 868                 break;
 869         }
 870
 871         force_sig(SIGILL, current);
 872 }
 873
 874 asmlinkage void do_mdmx(struct pt_regs *regs)
 875 {
 876         force_sig(SIGILL, current);
 877 }
 878
 879 asmlinkage void do_watch(struct pt_regs *regs)
 880 {
 881         /*
 882          * We use the watch exception where available to detect stack
 883          * overflows.
 884          */
 885         dump_tlb_all();
 886         show_regs(regs);
 887         panic("Caught WATCH exception - probably caused by stack overflow.");
 888 }
 889
 890 asmlinkage void do_mcheck(struct pt_regs *regs)
 891 {
 892         const int field = 2 * sizeof(unsigned long);
 893         int multi_match = regs->cp0_status & ST0_TS;
 894
 895         show_regs(regs);
 896
 897         if (multi_match) {
 898                 printk("Index   : %0x\n", read_c0_index());
 899                 printk("Pagemask: %0x\n", read_c0_pagemask());
 900                 printk("EntryHi : %0*lx\n", field, read_c0_entryhi());
 901                 printk("EntryLo0: %0*lx\n", field, read_c0_entrylo0());
 902                 printk("EntryLo1: %0*lx\n", field, read_c0_entrylo1());
 903                 printk("\n");
 904                 dump_tlb_all();
 905         }
 906
 907         show_code((unsigned int *) regs->cp0_epc);
 908
 909         /*
 910          * Some chips may have other causes of machine check (e.g. SB1
 911          * graduation timer)
 912          */
 913         panic("Caught Machine Check exception - %scaused by multiple "
 914               "matching entries in the TLB.",
 915               (multi_match) ? "" : "not ");
 916 }
 917
 918 asmlinkage void do_mt(struct pt_regs *regs)
 919 {
 920         int subcode;
 921
 922         subcode = (read_vpe_c0_vpecontrol() & VPECONTROL_EXCPT)
 923                         >> VPECONTROL_EXCPT_SHIFT;
 924         switch (subcode) {
 925         case 0:
 926                 printk(KERN_DEBUG "Thread Underflow\n");
 927                 break;
 928         case 1:
 929                 printk(KERN_DEBUG "Thread Overflow\n");
 930                 break;
 931         case 2:
 932                 printk(KERN_DEBUG "Invalid YIELD Qualifier\n");
 933                 break;
 934         case 3:
 935                 printk(KERN_DEBUG "Gating Storage Exception\n");
 936                 break;
 937         case 4:
 938                 printk(KERN_DEBUG "YIELD Scheduler Exception\n");
 939                 break;
 940         case 5:
 941                 printk(KERN_DEBUG "Gating Storage Schedulier Exception\n");
 942                 break;
 943         default:
 944                 printk(KERN_DEBUG "*** UNKNOWN THREAD EXCEPTION %d ***\n",
 945                         subcode);
 946                 break;
 947         }
 948         die_if_kernel("MIPS MT Thread exception in kernel", regs);
 949
 950         force_sig(SIGILL, current);
 951 }
 952
 953
 954 asmlinkage void do_dsp(struct pt_regs *regs)
 955 {
 956         if (cpu_has_dsp)
 957                 panic("Unexpected DSP exception\n");
 958
 959         force_sig(SIGILL, current);
 960 }
 961
 962 asmlinkage void do_reserved(struct pt_regs *regs)
 963 {
 964         /*
 965          * Game over - no way to handle this if it ever occurs.  Most probably
 966          * caused by a new unknown cpu type or after another deadly
 967          * hard/software error.
 968          */
 969         show_regs(regs);
 970         panic("Caught reserved exception %ld - should not happen.",
 971               (regs->cp0_cause & 0x7f) >> 2);
 972 }
 973
 974 asmlinkage void do_default_vi(struct pt_regs *regs)
 975 {
 976         show_regs(regs);
 977         panic("Caught unexpected vectored interrupt.");
 978 }
 979
 980 /*
 981  * Some MIPS CPUs can enable/disable for cache parity detection, but do
 982  * it different ways.
 983  */
 984 static inline void parity_protection_init(void)
 985 {
 986         switch (current_cpu_data.cputype) {
 987         case CPU_24K:
 988         case CPU_34K:
 989         case CPU_5KC:
 990                 write_c0_ecc(0x80000000);
 991                 back_to_back_c0_hazard();
 992                 /* Set the PE bit (bit 31) in the c0_errctl register. */
 993                 printk(KERN_INFO "Cache parity protection %sabled\n",
 994                        (read_c0_ecc() & 0x80000000) ? "en" : "dis");
 995                 break;
 996         case CPU_20KC:
 997         case CPU_25KF:
 998                 /* Clear the DE bit (bit 16) in the c0_status register. */
 999                 printk(KERN_INFO "Enable cache parity protection for "
1000                        "MIPS 20KC/25KF CPUs.\n");
1001                 clear_c0_status(ST0_DE);
1002                 break;
1003         default:
1004                 break;
1005         }
1006 }
1007
1008 asmlinkage void cache_parity_error(void)
1009 {
1010         const int field = 2 * sizeof(unsigned long);
1011         unsigned int reg_val;
1012
1013         /* For the moment, report the problem and hang. */
1014         printk("Cache error exception:\n");
1015         printk("cp0_errorepc == %0*lx\n", field, read_c0_errorepc());
1016         reg_val = read_c0_cacheerr();
1017         printk("c0_cacheerr == %08x\n", reg_val);
1018
1019         printk("Decoded c0_cacheerr: %s cache fault in %s reference.\n",
1020                reg_val & (1<<30) ? "secondary" : "primary",
1021                reg_val & (1<<31) ? "data" : "insn");
1022         printk("Error bits: %s%s%s%s%s%s%s\n",
1023                reg_val & (1<<29) ? "ED " : "",
1024                reg_val & (1<<28) ? "ET " : "",
1025                reg_val & (1<<26) ? "EE " : "",
1026                reg_val & (1<<25) ? "EB " : "",
1027                reg_val & (1<<24) ? "EI " : "",
1028                reg_val & (1<<23) ? "E1 " : "",
1029                reg_val & (1<<22) ? "E0 " : "");
1030         printk("IDX: 0x%08x\n", reg_val & ((1<<22)-1));
1031
1032 #if defined(CONFIG_CPU_MIPS32) || defined(CONFIG_CPU_MIPS64)
1033         if (reg_val & (1<<22))
1034                 printk("DErrAddr0: 0x%0*lx\n", field, read_c0_derraddr0());
1035
1036         if (reg_val & (1<<23))
1037                 printk("DErrAddr1: 0x%0*lx\n", field, read_c0_derraddr1());
1038 #endif
1039
1040         panic("Can't handle the cache error!");
1041 }
1042
1043 /*
1044  * SDBBP EJTAG debug exception handler.
1045  * We skip the instruction and return to the next instruction.
1046  */
1047 void ejtag_exception_handler(struct pt_regs *regs)
1048 {
1049         const int field = 2 * sizeof(unsigned long);
1050         unsigned long depc, old_epc;
1051         unsigned int debug;
1052
1053         printk(KERN_DEBUG "SDBBP EJTAG debug exception - not handled yet, just ignored!\n");
1054         depc = read_c0_depc();
1055         debug = read_c0_debug();
1056         printk(KERN_DEBUG "c0_depc = %0*lx, DEBUG = %08x\n", field, depc, debug);
1057         if (debug & 0x80000000) {
1058                 /*
1059                  * In branch delay slot.
1060                  * We cheat a little bit here and use EPC to calculate the
1061                  * debug return address (DEPC). EPC is restored after the
1062                  * calculation.
1063                  */
1064                 old_epc = regs->cp0_epc;
1065                 regs->cp0_epc = depc;
1066                 __compute_return_epc(regs);
1067                 depc = regs->cp0_epc;
1068                 regs->cp0_epc = old_epc;
1069         } else
1070                 depc += 4;
1071         write_c0_depc(depc);
1072
1073 #if 0
1074         printk(KERN_DEBUG "\n\n----- Enable EJTAG single stepping ----\n\n");
1075         write_c0_debug(debug | 0x100);
1076 #endif
1077 }
1078
1079 /*
1080  * NMI exception handler.
1081  */
1082 void nmi_exception_handler(struct pt_regs *regs)
1083 {
1084 #ifdef CONFIG_MIPS_MT_SMTC
1085         unsigned long dvpret = dvpe();
1086         bust_spinlocks(1);
1087         printk("NMI taken!!!!\n");
1088         mips_mt_regdump(dvpret);
1089 #else
1090         bust_spinlocks(1);
1091         printk("NMI taken!!!!\n");
1092 #endif /* CONFIG_MIPS_MT_SMTC */
1093         die("NMI", regs);
1094         while(1) ;
1095 }
1096
1097 #define VECTORSPACING 0x100     /* for EI/VI mode */
1098
1099 unsigned long ebase;
1100 unsigned long exception_handlers[32];
1101 unsigned long vi_handlers[64];
1102
1103 /*
1104  * As a side effect of the way this is implemented we're limited
1105  * to interrupt handlers in the address range from
1106  * KSEG0 <= x < KSEG0 + 256mb on the Nevada.  Oh well ...
1107  */
1108 void *set_except_vector(int n, void *addr)
1109 {
1110         unsigned long handler = (unsigned long) addr;
1111         unsigned long old_handler = exception_handlers[n];
1112
1113         exception_handlers[n] = handler;
1114         if (n == 0 && cpu_has_divec) {
1115                 *(volatile u32 *)(ebase + 0x200) = 0x08000000 |
1116                                                  (0x03ffffff & (handler >> 2));
1117                 flush_icache_range(ebase + 0x200, ebase + 0x204);
1118         }
1119         return (void *)old_handler;
1120 }
1121
1122 #ifdef CONFIG_CPU_MIPSR2_SRS
1123 /*
1124  * MIPSR2 shadow register set allocation
1125  * FIXME: SMP...
1126  */
1127
1128 static struct shadow_registers {
1129         /*
1130          * Number of shadow register sets supported
1131          */
1132         unsigned long sr_supported;
1133         /*
1134          * Bitmap of allocated shadow registers
1135          */
1136         unsigned long sr_allocated;
1137 } shadow_registers;
1138
1139 static void mips_srs_init(void)
1140 {
1141         shadow_registers.sr_supported = ((read_c0_srsctl() >> 26) & 0x0f) + 1;
1142         printk(KERN_INFO "%d MIPSR2 register sets available\n",
1143                shadow_registers.sr_supported);
1144         shadow_registers.sr_allocated = 1;      /* Set 0 used by kernel */
1145 }
1146
1147 int mips_srs_max(void)
1148 {
1149         return shadow_registers.sr_supported;
1150 }
1151
1152 int mips_srs_alloc(void)
1153 {
1154         struct shadow_registers *sr = &shadow_registers;
1155         int set;
1156
1157 again:
1158         set = find_first_zero_bit(&sr->sr_allocated, sr->sr_supported);
1159         if (set >= sr->sr_supported)
1160                 return -1;
1161
1162         if (test_and_set_bit(set, &sr->sr_allocated))
1163                 goto again;
1164
1165         return set;
1166 }
1167
1168 void mips_srs_free(int set)
1169 {
1170         struct shadow_registers *sr = &shadow_registers;
1171
1172         clear_bit(set, &sr->sr_allocated);
1173 }
1174
1175 static void *set_vi_srs_handler(int n, void *addr, int srs)
1176 {
1177         unsigned long handler;
1178         unsigned long old_handler = vi_handlers[n];
1179         u32 *w;
1180         unsigned char *b;
1181
1182         if (!cpu_has_veic && !cpu_has_vint)
1183                 BUG();
1184
1185         if (addr == NULL) {
1186                 handler = (unsigned long) do_default_vi;
1187                 srs = 0;
1188         } else
1189                 handler = (unsigned long) addr;
1190         vi_handlers[n] = (unsigned long) addr;
1191
1192         b = (unsigned char *)(ebase + 0x200 + n*VECTORSPACING);
1193
1194         if (srs >= mips_srs_max())
1195                 panic("Shadow register set %d not supported", srs);
1196
1197         if (cpu_has_veic) {
1198                 if (board_bind_eic_interrupt)
1199                         board_bind_eic_interrupt (n, srs);
1200         } else if (cpu_has_vint) {
1201                 /* SRSMap is only defined if shadow sets are implemented */
1202                 if (mips_srs_max() > 1)
1203                         change_c0_srsmap (0xf << n*4, srs << n*4);
1204         }
1205
1206         if (srs == 0) {
1207                 /*
1208                  * If no shadow set is selected then use the default handler
1209                  * that does normal register saving and a standard interrupt exit
1210                  */
1211
1212                 extern char except_vec_vi, except_vec_vi_lui;
1213                 extern char except_vec_vi_ori, except_vec_vi_end;
1214 #ifdef CONFIG_MIPS_MT_SMTC
1215                 /*
1216                  * We need to provide the SMTC vectored interrupt handler
1217                  * not only with the address of the handler, but with the
1218                  * Status.IM bit to be masked before going there.
1219                  */
1220                 extern char except_vec_vi_mori;
1221                 const int mori_offset = &except_vec_vi_mori - &except_vec_vi;
1222 #endif /* CONFIG_MIPS_MT_SMTC */
1223                 const int handler_len = &except_vec_vi_end - &except_vec_vi;
1224                 const int lui_offset = &except_vec_vi_lui - &except_vec_vi;
1225                 const int ori_offset = &except_vec_vi_ori - &except_vec_vi;
1226
1227                 if (handler_len > VECTORSPACING) {
1228                         /*
1229                          * Sigh... panicing won't help as the console
1230                          * is probably not configured :(
1231                          */
1232                         panic ("VECTORSPACING too small");
1233                 }
1234
1235                 memcpy (b, &except_vec_vi, handler_len);
1236 #ifdef CONFIG_MIPS_MT_SMTC
1237                 if (n > 7)
1238                         printk("Vector index %d exceeds SMTC maximum\n", n);
1239                 w = (u32 *)(b + mori_offset);
1240                 *w = (*w & 0xffff0000) | (0x100 << n);
1241 #endif /* CONFIG_MIPS_MT_SMTC */
1242                 w = (u32 *)(b + lui_offset);
1243                 *w = (*w & 0xffff0000) | (((u32)handler >> 16) & 0xffff);
1244                 w = (u32 *)(b + ori_offset);
1245                 *w = (*w & 0xffff0000) | ((u32)handler & 0xffff);
1246                 flush_icache_range((unsigned long)b, (unsigned long)(b+handler_len));
1247         }
1248         else {
1249                 /*
1250                  * In other cases jump directly to the interrupt handler
1251                  *
1252                  * It is the handlers responsibility to save registers if required
1253                  * (eg hi/lo) and return from the exception using "eret"
1254                  */
1255                 w = (u32 *)b;
1256                 *w++ = 0x08000000 | (((u32)handler >> 2) & 0x03fffff); /* j handler */
1257                 *w = 0;
1258                 flush_icache_range((unsigned long)b, (unsigned long)(b+8));
1259         }
1260
1261         return (void *)old_handler;
1262 }
1263
1264 void *set_vi_handler(int n, void *addr)
1265 {
1266         return set_vi_srs_handler(n, addr, 0);
1267 }
1268
1269 #else
1270
1271 static inline void mips_srs_init(void)
1272 {
1273 }
1274
1275 #endif /* CONFIG_CPU_MIPSR2_SRS */
1276
1277 /*
1278  * This is used by native signal handling
1279  */
1280 asmlinkage int (*save_fp_context)(struct sigcontext *sc);
1281 asmlinkage int (*restore_fp_context)(struct sigcontext *sc);
1282
1283 extern asmlinkage int _save_fp_context(struct sigcontext *sc);
1284 extern asmlinkage int _restore_fp_context(struct sigcontext *sc);
1285
1286 extern asmlinkage int fpu_emulator_save_context(struct sigcontext *sc);
1287 extern asmlinkage int fpu_emulator_restore_context(struct sigcontext *sc);
1288
1289 #ifdef CONFIG_SMP
1290 static int smp_save_fp_context(struct sigcontext *sc)
1291 {
1292         return cpu_has_fpu
1293                ? _save_fp_context(sc)
1294                : fpu_emulator_save_context(sc);
1295 }
1296
1297 static int smp_restore_fp_context(struct sigcontext *sc)
1298 {
1299         return cpu_has_fpu
1300                ? _restore_fp_context(sc)
1301                : fpu_emulator_restore_context(sc);
1302 }
1303 #endif
1304
1305 static inline void signal_init(void)
1306 {
1307 #ifdef CONFIG_SMP
1308         /* For now just do the cpu_has_fpu check when the functions are invoked */
1309         save_fp_context = smp_save_fp_context;
1310         restore_fp_context = smp_restore_fp_context;
1311 #else
1312         if (cpu_has_fpu) {
1313                 save_fp_context = _save_fp_context;
1314                 restore_fp_context = _restore_fp_context;
1315         } else {
1316                 save_fp_context = fpu_emulator_save_context;
1317                 restore_fp_context = fpu_emulator_restore_context;
1318         }
1319 #endif
1320 }
1321
1322 #ifdef CONFIG_MIPS32_COMPAT
1323
1324 /*
1325  * This is used by 32-bit signal stuff on the 64-bit kernel
1326  */
1327 asmlinkage int (*save_fp_context32)(struct sigcontext32 *sc);
1328 asmlinkage int (*restore_fp_context32)(struct sigcontext32 *sc);
1329
1330 extern asmlinkage int _save_fp_context32(struct sigcontext32 *sc);
1331 extern asmlinkage int _restore_fp_context32(struct sigcontext32 *sc);
1332
1333 extern asmlinkage int fpu_emulator_save_context32(struct sigcontext32 *sc);
1334 extern asmlinkage int fpu_emulator_restore_context32(struct sigcontext32 *sc);
1335
1336 static inline void signal32_init(void)
1337 {
1338         if (cpu_has_fpu) {
1339                 save_fp_context32 = _save_fp_context32;
1340                 restore_fp_context32 = _restore_fp_context32;
1341         } else {
1342                 save_fp_context32 = fpu_emulator_save_context32;
1343                 restore_fp_context32 = fpu_emulator_restore_context32;
1344         }
1345 }
1346 #endif
1347
1348 extern void cpu_cache_init(void);
1349 extern void tlb_init(void);
1350 extern void flush_tlb_handlers(void);
1351
1352 void __init per_cpu_trap_init(void)
1353 {
1354         unsigned int cpu = smp_processor_id();
1355         unsigned int status_set = ST0_CU0;
1356 #ifdef CONFIG_MIPS_MT_SMTC
1357         int secondaryTC = 0;
1358         int bootTC = (cpu == 0);
1359
1360         /*
1361          * Only do per_cpu_trap_init() for first TC of Each VPE.
1362          * Note that this hack assumes that the SMTC init code
1363          * assigns TCs consecutively and in ascending order.
1364          */
1365
1366         if (((read_c0_tcbind() & TCBIND_CURTC) != 0) &&
1367             ((read_c0_tcbind() & TCBIND_CURVPE) == cpu_data[cpu - 1].vpe_id))
1368                 secondaryTC = 1;
1369 #endif /* CONFIG_MIPS_MT_SMTC */
1370
1371         /*
1372          * Disable coprocessors and select 32-bit or 64-bit addressing
1373          * and the 16/32 or 32/32 FPR register model.  Reset the BEV
1374          * flag that some firmware may have left set and the TS bit (for
1375          * IP27).  Set XX for ISA IV code to work.
1376          */
1377 #ifdef CONFIG_64BIT
1378         status_set |= ST0_FR|ST0_KX|ST0_SX|ST0_UX;
1379 #endif
1380         if (current_cpu_data.isa_level == MIPS_CPU_ISA_IV)
1381                 status_set |= ST0_XX;
1382         change_c0_status(ST0_CU|ST0_MX|ST0_RE|ST0_FR|ST0_BEV|ST0_TS|ST0_KX|ST0_SX|ST0_UX,
1383                          status_set);
1384
1385         if (cpu_has_dsp)
1386                 set_c0_status(ST0_MX);
1387
1388 #ifdef CONFIG_CPU_MIPSR2
1389         write_c0_hwrena (0x0000000f); /* Allow rdhwr to all registers */
1390 #endif
1391
1392 #ifdef CONFIG_MIPS_MT_SMTC
1393         if (!secondaryTC) {
1394 #endif /* CONFIG_MIPS_MT_SMTC */
1395
1396         /*
1397          * Interrupt handling.
1398          */
1399         if (cpu_has_veic || cpu_has_vint) {
1400                 write_c0_ebase (ebase);
1401                 /* Setting vector spacing enables EI/VI mode  */
1402                 change_c0_intctl (0x3e0, VECTORSPACING);
1403         }
1404         if (cpu_has_divec) {
1405                 if (cpu_has_mipsmt) {
1406                         unsigned int vpflags = dvpe();
1407                         set_c0_cause(CAUSEF_IV);
1408                         evpe(vpflags);
1409                 } else
1410                         set_c0_cause(CAUSEF_IV);
1411         }
1412 #ifdef CONFIG_MIPS_MT_SMTC
1413         }
1414 #endif /* CONFIG_MIPS_MT_SMTC */
1415
1416         cpu_data[cpu].asid_cache = ASID_FIRST_VERSION;
1417         TLBMISS_HANDLER_SETUP();
1418
1419         atomic_inc(&init_mm.mm_count);
1420         current->active_mm = &init_mm;
1421         BUG_ON(current->mm);
1422         enter_lazy_tlb(&init_mm, current);
1423
1424 #ifdef CONFIG_MIPS_MT_SMTC
1425         if (bootTC) {
1426 #endif /* CONFIG_MIPS_MT_SMTC */
1427                 cpu_cache_init();
1428                 tlb_init();
1429 #ifdef CONFIG_MIPS_MT_SMTC
1430         }
1431 #endif /* CONFIG_MIPS_MT_SMTC */
1432 }
1433
1434 /* Install CPU exception handler */
1435 void __init set_handler (unsigned long offset, void *addr, unsigned long size)
1436 {
1437         memcpy((void *)(ebase + offset), addr, size);
1438         flush_icache_range(ebase + offset, ebase + offset + size);
1439 }
1440
1441 /* Install uncached CPU exception handler */
1442 void __init set_uncached_handler (unsigned long offset, void *addr, unsigned long size)
1443 {
1444 #ifdef CONFIG_32BIT
1445         unsigned long uncached_ebase = KSEG1ADDR(ebase);
1446 #endif
1447 #ifdef CONFIG_64BIT
1448         unsigned long uncached_ebase = TO_UNCAC(ebase);
1449 #endif
1450
1451         memcpy((void *)(uncached_ebase + offset), addr, size);
1452 }
1453
1454 void __init trap_init(void)
1455 {
1456         extern char except_vec3_generic, except_vec3_r4000;
1457         extern char except_vec4;
1458         unsigned long i;
1459
1460         if (cpu_has_veic || cpu_has_vint)
1461                 ebase = (unsigned long) alloc_bootmem_low_pages (0x200 + VECTORSPACING*64);
1462         else
1463                 ebase = CAC_BASE;
1464
1465         mips_srs_init();
1466
1467         per_cpu_trap_init();
1468
1469         /*
1470          * Copy the generic exception handlers to their final destination.
1471          * This will be overriden later as suitable for a particular
1472          * configuration.
1473          */
1474         set_handler(0x180, &except_vec3_generic, 0x80);
1475
1476         /*
1477          * Setup default vectors
1478          */
1479         for (i = 0; i <= 31; i++)
1480                 set_except_vector(i, handle_reserved);
1481
1482         /*
1483          * Copy the EJTAG debug exception vector handler code to it's final
1484          * destination.
1485          */
1486         if (cpu_has_ejtag && board_ejtag_handler_setup)
1487                 board_ejtag_handler_setup ();
1488
1489         /*
1490          * Only some CPUs have the watch exceptions.
1491          */
1492         if (cpu_has_watch)
1493                 set_except_vector(23, handle_watch);
1494
1495         /*
1496          * Initialise interrupt handlers
1497          */
1498         if (cpu_has_veic || cpu_has_vint) {
1499                 int nvec = cpu_has_veic ? 64 : 8;
1500                 for (i = 0; i < nvec; i++)
1501                         set_vi_handler(i, NULL);
1502         }
1503         else if (cpu_has_divec)
1504                 set_handler(0x200, &except_vec4, 0x8);
1505
1506         /*
1507          * Some CPUs can enable/disable for cache parity detection, but does
1508          * it different ways.
1509          */
1510         parity_protection_init();
1511
1512         /*
1513          * The Data Bus Errors / Instruction Bus Errors are signaled
1514          * by external hardware.  Therefore these two exceptions
1515          * may have board specific handlers.
1516          */
1517         if (board_be_init)
1518                 board_be_init();
1519
1520         set_except_vector(0, handle_int);
1521         set_except_vector(1, handle_tlbm);
1522         set_except_vector(2, handle_tlbl);
1523         set_except_vector(3, handle_tlbs);
1524
1525         set_except_vector(4, handle_adel);
1526         set_except_vector(5, handle_ades);
1527
1528         set_except_vector(6, handle_ibe);
1529         set_except_vector(7, handle_dbe);
1530
1531         set_except_vector(8, handle_sys);
1532         set_except_vector(9, handle_bp);
1533         set_except_vector(10, handle_ri);
1534         set_except_vector(11, handle_cpu);
1535         set_except_vector(12, handle_ov);
1536         set_except_vector(13, handle_tr);
1537
1538         if (current_cpu_data.cputype == CPU_R6000 ||
1539             current_cpu_data.cputype == CPU_R6000A) {
1540                 /*
1541                  * The R6000 is the only R-series CPU that features a machine
1542                  * check exception (similar to the R4000 cache error) and
1543                  * unaligned ldc1/sdc1 exception.  The handlers have not been
1544                  * written yet.  Well, anyway there is no R6000 machine on the
1545                  * current list of targets for Linux/MIPS.
1546                  * (Duh, crap, there is someone with a triple R6k machine)
1547                  */
1548                 //set_except_vector(14, handle_mc);
1549                 //set_except_vector(15, handle_ndc);
1550         }
1551
1552
1553         if (board_nmi_handler_setup)
1554                 board_nmi_handler_setup();
1555
1556         if (cpu_has_fpu && !cpu_has_nofpuex)
1557                 set_except_vector(15, handle_fpe);
1558
1559         set_except_vector(22, handle_mdmx);
1560
1561         if (cpu_has_mcheck)
1562                 set_except_vector(24, handle_mcheck);
1563
1564         if (cpu_has_mipsmt)
1565                 set_except_vector(25, handle_mt);
1566
1567         if (cpu_has_dsp)
1568                 set_except_vector(26, handle_dsp);
1569
1570         if (cpu_has_vce)
1571                 /* Special exception: R4[04]00 uses also the divec space. */
1572                 memcpy((void *)(CAC_BASE + 0x180), &except_vec3_r4000, 0x100);
1573         else if (cpu_has_4kex)
1574                 memcpy((void *)(CAC_BASE + 0x180), &except_vec3_generic, 0x80);
1575         else
1576                 memcpy((void *)(CAC_BASE + 0x080), &except_vec3_generic, 0x80);
1577
1578         signal_init();
1579 #ifdef CONFIG_MIPS32_COMPAT
1580         signal32_init();
1581 #endif
1582
1583         flush_icache_range(ebase, ebase + 0x400);
1584         flush_tlb_handlers();
1585 }