开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
traps.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：21k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

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 by Ralf Baechle
  7.  * Copyright (C) 1995, 1996 Paul M. Antoine
  8.  * Copyright (C) 1998 Ulf Carlsson
  9.  * Copyright (C) 1999 Silicon Graphics, Inc.
  10.  * Copyright (C) 2002  Maciej W. Rozycki
  11.  */
  12. #include <linux/config.h>
  13. #include <linux/init.h>
  14. #include <linux/mm.h>
  15. #include <linux/module.h>
  16. #include <linux/sched.h>
  17. #include <linux/smp.h>
  18. #include <linux/smp_lock.h>
  19. #include <linux/spinlock.h>
  21. #include <asm/bootinfo.h>
  22. #include <asm/branch.h>
  23. #include <asm/cpu.h>
  24. #include <asm/module.h>
  25. #include <asm/pgtable.h>
  26. #include <asm/io.h>
  27. #include <asm/ptrace.h>
  28. #include <asm/watch.h>
  29. #include <asm/system.h>
  30. #include <asm/traps.h>
  31. #include <asm/uaccess.h>
  32. #include <asm/mmu_context.h>
  33. #include <asm/cachectl.h>
  34. #include <asm/types.h>
  36. extern asmlinkage void __xtlb_mod(void);
  37. extern asmlinkage void __xtlb_tlbl(void);
  38. extern asmlinkage void __xtlb_tlbs(void);
  39. extern asmlinkage void handle_adel(void);
  40. extern asmlinkage void handle_ades(void);
  41. extern asmlinkage void handle_ibe(void);
  42. extern asmlinkage void handle_dbe(void);
  43. extern asmlinkage void handle_sys(void);
  44. extern asmlinkage void handle_bp(void);
  45. extern asmlinkage void handle_ri(void);
  46. extern asmlinkage void handle_cpu(void);
  47. extern asmlinkage void handle_ov(void);
  48. extern asmlinkage void handle_tr(void);
  49. extern asmlinkage void handle_fpe(void);
  50. extern asmlinkage void handle_watch(void);
  51. extern asmlinkage void handle_mcheck(void);
  52. extern asmlinkage void handle_reserved(void);
  54. extern int fpu_emulator_cop1Handler(int xcptno, struct pt_regs *xcp,
  55. struct mips_fpu_soft_struct *ctx);
  57. void fpu_emulator_init_fpu(void);
  59. char watch_available = 0;
  60. char dedicated_iv_available = 0;
  62. int (*be_board_handler)(struct pt_regs *regs, int is_fixup);
  64. int kstack_depth_to_print = 24;
  66. /*
  67.  * These constant is for searching for possible module text segments.
  68.  * MODULE_RANGE is a guess of how much space is likely to be vmalloced.
  69.  */
  70. #define MODULE_RANGE (8*1024*1024)
  72. #define OPCODE 0xfc000000
  74. /*
  75.  * If the address is either in the .text section of the
  76.  * kernel, or in the vmalloc'ed module regions, it *may*
  77.  * be the address of a calling routine
  78.  */
  80. #ifdef CONFIG_MODULES
  82. extern struct module *module_list;
  83. extern struct module kernel_module;
  85. static inline int kernel_text_address(long addr)
  86. {
  87. extern char _stext, _etext;
  88. int retval = 0;
  89. struct module *mod;
  91. if (addr >= (long) &_stext && addr <= (long) &_etext)
  92. return 1;
  94. for (mod = module_list; mod != &kernel_module; mod = mod->next) {
  95. /* mod_bound tests for addr being inside the vmalloc'ed
  96.  * module area. Of course it'd be better to test only
  97.  * for the .text subset... */
  98. if (mod_bound(addr, 0, mod)) {
  99. retval = 1;
  100. break;
  101. }
  102. }
  104. return retval;
  105. }
  107. #else
  109. static inline int kernel_text_address(long addr)
  110. {
  111. extern char _stext, _etext;
  113. return (addr >= (long) &_stext && addr <= (long) &_etext);
  114. }
  116. #endif
  118. /*
  119.  * This routine abuses get_user()/put_user() to reference pointers
  120.  * with at least a bit of error checking ...
  121.  */
  122. void show_stack(long *sp)
  123. {
  124. int i;
  125. long stackdata;
  127. printk("Stack:");
  128. i = 0;
  129. while ((long) sp & (PAGE_SIZE - 1)) {
  130. if (i && ((i % 4) == 0))
  131. printk("n      ");
  132. if (i > 40) {
  133. printk(" ...");
  134. break;
  135. }
  137. if (__get_user(stackdata, sp++)) {
  138. printk(" (Bad stack address)");
  139. break;
  140. }
  142. printk(" %016lx", stackdata);
  143. i++;
  144. }
  145. printk("n");
  146. }
  148. void show_trace(long *sp)
  149. {
  150. int i;
  151. long addr;
  153. printk("Call Trace:");
  154. i = 0;
  155. while ((long) sp & (PAGE_SIZE - 1)) {
  157. if (__get_user(addr, sp++)) {
  158. if (i && ((i % 3) == 0))
  159. printk("n           ");
  160. printk(" (Bad stack address)n");
  161. break;
  162. }
  164. /*
  165.  * If the address is either in the text segment of the
  166.  * kernel, or in the region which contains vmalloc'ed
  167.  * memory, it *may* be the address of a calling
  168.  * routine; if so, print it so that someone tracing
  169.  * down the cause of the crash will be able to figure
  170.  * out the call path that was taken.
  171.  */
  173. if (kernel_text_address(addr)) {
  174. if (i && ((i % 3) == 0))
  175. printk("n           ");
  176. if (i > 40) {
  177. printk(" ...");
  178. break;
  179. }
  181. printk(" [<%016lx>]", addr);
  182. i++;
  183. }
  184. }
  185. printk("n");
  186. }
  188. void show_trace_task(struct task_struct *tsk)
  189. {
  190. show_trace((long *)tsk->thread.reg29);
  191. }
  194. void show_code(unsigned int *pc)
  195. {
  196. long i;
  198. printk("nCode:");
  200. for(i = -3 ; i < 6 ; i++) {
  201. unsigned int insn;
  202. if (__get_user(insn, pc + i)) {
  203. printk(" (Bad address in epc)n");
  204. break;
  205. }
  206. printk("%c%08x%c",(i?' ':'<'),insn,(i?' ':'>'));
  207. }
  208. }
  210. void show_regs(struct pt_regs *regs)
  211. {
  212. printk("Cpu %dn", smp_processor_id());
  213. /* Saved main processor registers. */
  214. printk("$0      : %016lx %016lx %016lx %016lxn",
  215.        0UL, regs->regs[1], regs->regs[2], regs->regs[3]);
  216. printk("$4      : %016lx %016lx %016lx %016lxn",
  217.                regs->regs[4], regs->regs[5], regs->regs[6], regs->regs[7]);
  218. printk("$8      : %016lx %016lx %016lx %016lxn",
  219.        regs->regs[8], regs->regs[9], regs->regs[10], regs->regs[11]);
  220. printk("$12     : %016lx %016lx %016lx %016lxn",
  221.                regs->regs[12], regs->regs[13], regs->regs[14], regs->regs[15]);
  222. printk("$16     : %016lx %016lx %016lx %016lxn",
  223.        regs->regs[16], regs->regs[17], regs->regs[18], regs->regs[19]);
  224. printk("$20     : %016lx %016lx %016lx %016lxn",
  225.                regs->regs[20], regs->regs[21], regs->regs[22], regs->regs[23]);
  226. printk("$24     : %016lx %016lxn",
  227.        regs->regs[24], regs->regs[25]);
  228. printk("$28     : %016lx %016lx %016lx %016lxn",
  229.        regs->regs[28], regs->regs[29], regs->regs[30], regs->regs[31]);
  230. printk("Hi      : %016lxn", regs->hi);
  231. printk("Lo      : %016lxn", regs->lo);
  233. /* Saved cp0 registers. */
  234. printk("epc     : %016lx    %snbadvaddr: %016lxn",
  235.        regs->cp0_epc, print_tainted(), regs->cp0_badvaddr);
  236. printk("Status  : %08x  [ ", (unsigned int) regs->cp0_status);
  237. if (regs->cp0_status & ST0_KX) printk("KX ");
  238. if (regs->cp0_status & ST0_SX) printk("SX ");
  239. if (regs->cp0_status & ST0_UX) printk("UX ");
  240. switch (regs->cp0_status & ST0_KSU) {
  241. case KSU_USER: printk("USER "); break;
  242. case KSU_SUPERVISOR: printk("SUPERVISOR "); break;
  243. case KSU_KERNEL: printk("KERNEL "); break;
  244. default: printk("BAD_MODE "); break;
  245. }
  246. if (regs->cp0_status & ST0_ERL) printk("ERL ");
  247. if (regs->cp0_status & ST0_EXL) printk("EXL ");
  248. if (regs->cp0_status & ST0_IE) printk("IE ");
  249. printk("]n");
  251. printk("Cause   : %08xn", (unsigned int) regs->cp0_cause);
  252. }
  254. void show_registers(struct pt_regs *regs)
  255. {
  256. show_regs(regs);
  257. printk("Process %s (pid: %d, stackpage=%016lx)n",
  258. current->comm, current->pid, (unsigned long) current);
  259. show_stack((long *) regs->regs[29]);
  260. show_trace((long *) regs->regs[29]);
  261. show_code((unsigned int *) regs->cp0_epc);
  262. printk("n");
  263. }
  265. static spinlock_t die_lock = SPIN_LOCK_UNLOCKED;
  267. void __die(const char * str, struct pt_regs * regs, const char * file,
  268.    const char * func, unsigned long line)
  269. {
  270. console_verbose();
  271. spin_lock_irq(&die_lock);
  272. printk("%s", str);
  273. if (file && func)
  274. printk(" in %s:%s, line %ld", file, func, line);
  275. printk(":n");
  276. show_registers(regs);
  277. spin_unlock_irq(&die_lock);
  278. do_exit(SIGSEGV);
  279. }
  281. void __die_if_kernel(const char * str, struct pt_regs * regs,
  282.      const char * file, const char * func, unsigned long line)
  283. {
  284. if (!user_mode(regs))
  285. __die(str, regs, file, func, line);
  286. }
  288. extern const struct exception_table_entry __start___dbe_table[];
  289. extern const struct exception_table_entry __stop___dbe_table[];
  291. void __declare_dbe_table(void)
  292. {
  293. __asm__ __volatile__(
  294. ".sectiont__dbe_table,"a"nt"
  295. ".previous"
  296. );
  297. }
  299. static inline unsigned long
  300. search_one_table(const struct exception_table_entry *first,
  301.  const struct exception_table_entry *last,
  302.  unsigned long value)
  303. {
  304. const struct exception_table_entry *mid;
  305. long diff;
  307. while (first < last) {
  308. mid = (last - first) / 2 + first;
  309. diff = mid->insn - value;
  310. if (diff < 0)
  311. first = mid + 1;
  312. else
  313. last = mid;
  314. }
  315. return (first == last && first->insn == value) ? first->nextinsn : 0;
  316. }
  318. extern spinlock_t modlist_lock;
  320. static inline unsigned long
  321. search_dbe_table(unsigned long addr)
  322. {
  323. unsigned long ret = 0;
  325. #ifndef CONFIG_MODULES
  326. /* There is only the kernel to search.  */
  327. ret = search_one_table(__start___dbe_table, __stop___dbe_table-1, addr);
  328. return ret;
  329. #else
  330. unsigned long flags;
  332. /* The kernel is the last "module" -- no need to treat it special.  */
  333. struct module *mp;
  334. struct archdata *ap;
  336. spin_lock_irqsave(&modlist_lock, flags);
  337. for (mp = module_list; mp != NULL; mp = mp->next) {
  338. if (!mod_member_present(mp, archdata_end) ||
  339.              !mod_archdata_member_present(mp, struct archdata,
  340.  dbe_table_end))
  341. continue;
  342. ap = (struct archdata *)(mp->archdata_start);
  344. if (ap->dbe_table_start == NULL ||
  345.     !(mp->flags & (MOD_RUNNING | MOD_INITIALIZING)))
  346. continue;
  347. ret = search_one_table(ap->dbe_table_start,
  348.        ap->dbe_table_end - 1, addr);
  349. if (ret)
  350. break;
  351. }
  352. spin_unlock_irqrestore(&modlist_lock, flags);
  353. return ret;
  354. #endif
  355. }
  357. asmlinkage void do_be(struct pt_regs *regs)
  358. {
  359. unsigned long new_epc;
  360. unsigned long fixup = 0;
  361. int data = regs->cp0_cause & 4;
  362. int action = MIPS_BE_FATAL;
  364. if (data && !user_mode(regs))
  365. fixup = search_dbe_table(regs->cp0_epc);
  367. if (fixup)
  368. action = MIPS_BE_FIXUP;
  370. if (be_board_handler)
  371. action = be_board_handler(regs, fixup != 0);
  373. switch (action) {
  374. case MIPS_BE_DISCARD:
  375. return;
  376. case MIPS_BE_FIXUP:
  377. if (fixup) {
  378. new_epc = fixup_exception(dpf_reg, fixup,
  379.   regs->cp0_epc);
  380. regs->cp0_epc = new_epc;
  381. return;
  382. }
  383. break;
  384. default:
  385. break;
  386. }
  388. /*
  389.  * Assume it would be too dangerous to continue ...
  390.  */
  391. printk(KERN_ALERT "%s bus error, epc == %08lx, ra == %08lxn",
  392.        data ? "Data" : "Instruction",
  393.        regs->cp0_epc, regs->regs[31]);
  394. die_if_kernel("Oops", regs);
  395. force_sig(SIGBUS, current);
  396. }
  398. asmlinkage void do_ov(struct pt_regs *regs)
  399. {
  400. siginfo_t info;
  402. if (compute_return_epc(regs))
  403. return;
  405. info.si_code = FPE_INTOVF;
  406. info.si_signo = SIGFPE;
  407. info.si_errno = 0;
  408. info.si_addr = (void *)regs->cp0_epc;
  409. force_sig_info(SIGFPE, &info, current);
  410. }
  412. /*
  413.  * XXX Delayed fp exceptions when doing a lazy ctx switch XXX
  414.  */
  415. asmlinkage void do_fpe(struct pt_regs *regs, unsigned long fcr31)
  416. {
  417. if (fcr31 & FPU_CSR_UNI_X) {
  418. int sig;
  420. /*
  421.    * Unimplemented operation exception.  If we've got the full
  422.  * software emulator on-board, let's use it...
  423.  *
  424.  * Force FPU to dump state into task/thread context.  We're
  425.  * moving a lot of data here for what is probably a single
  426.  * instruction, but the alternative is to pre-decode the FP
  427.  * register operands before invoking the emulator, which seems
  428.  * a bit extreme for what should be an infrequent event.
  429.  */
  430. save_fp(current);
  432. /* Run the emulator */
  433. sig = fpu_emulator_cop1Handler (0, regs,
  434. &current->thread.fpu.soft);
  436. /*
  437.  * We can't allow the emulated instruction to leave any of
  438.  * the cause bit set in $fcr31.
  439.  */
  440. current->thread.fpu.soft.sr &= ~FPU_CSR_ALL_X;
  442. /* Restore the hardware register state */
  443. restore_fp(current);
  445. /* If something went wrong, signal */
  446. if (sig)
  447. {
  448. /*
  449.  * Return EPC is not calculated in the FPU emulator,
  450.  * if a signal is being send. So we calculate it here.
  451.  */
  452. compute_return_epc(regs);
  453. force_sig(sig, current);
  454. }
  456. return;
  457. }
  459. if (compute_return_epc(regs))
  460. return;
  461. force_sig(SIGFPE, current);
  462. }
  464. static inline int get_insn_opcode(struct pt_regs *regs, unsigned int *opcode)
  465. {
  466. unsigned long *epc;
  468. epc = (unsigned long *) regs->cp0_epc +
  469.       ((regs->cp0_cause & CAUSEF_BD) != 0);
  470. if (!get_user(opcode, epc))
  471. return 0;
  473. force_sig(SIGSEGV, current);
  474. return 1;
  475. }
  477. asmlinkage void do_bp(struct pt_regs *regs)
  478. {
  479. unsigned int opcode, bcode;
  480. siginfo_t info;
  482. if (get_insn_opcode(regs, &opcode))
  483. return;
  485. /*
  486.  * There is the ancient bug in the MIPS assemblers that the break
  487.  * code starts left to bit 16 instead to bit 6 in the opcode.
  488.  * Gas is bug-compatible ...
  489.  */
  490. bcode = ((opcode >> 16) & ((1 << 20) - 1));
  492. /*
  493.  * (A short test says that IRIX 5.3 sends SIGTRAP for all break
  494.  * insns, even for break codes that indicate arithmetic failures.
  495.  * Weird ...)
  496.  * But should we continue the brokenness???  --macro
  497.  */
  498. switch (bcode) {
  499. case 6:
  500. case 7:
  501. if (bcode == 7)
  502. info.si_code = FPE_INTDIV;
  503. else
  504. info.si_code = FPE_INTOVF;
  505. info.si_signo = SIGFPE;
  506. info.si_errno = 0;
  507. info.si_addr = (void *)regs->cp0_epc;
  508. force_sig_info(SIGFPE, &info, current);
  509. break;
  510. default:
  511. force_sig(SIGTRAP, current);
  512. }
  513. }
  515. asmlinkage void do_tr(struct pt_regs *regs)
  516. {
  517. unsigned int opcode, tcode = 0;
  518. siginfo_t info;
  520. if (get_insn_opcode(regs, &opcode))
  521. return;
  523.         /* Immediate versions don't provide a code.  */
  524. if (!(opcode & OPCODE))
  525. tcode = ((opcode >> 6) & ((1 << 20) - 1));
  527. /*
  528.  * (A short test says that IRIX 5.3 sends SIGTRAP for all trap
  529.  * insns, even for trap codes that indicate arithmetic failures.
  530.  * Weird ...)
  531.  * But should we continue the brokenness???  --macro
  532.  */
  533. switch (tcode) {
  534. case 6:
  535. case 7:
  536. if (tcode == 7)
  537. info.si_code = FPE_INTDIV;
  538. else
  539. info.si_code = FPE_INTOVF;
  540. info.si_signo = SIGFPE;
  541. info.si_errno = 0;
  542. info.si_addr = (void *)regs->cp0_epc;
  543. force_sig_info(SIGFPE, &info, current);
  544. break;
  545. default:
  546. force_sig(SIGTRAP, current);
  547. }
  548. }
  550. asmlinkage void do_ri(struct pt_regs *regs)
  551. {
  552. die_if_kernel("Reserved instruction in kernel code", regs);
  554. if (compute_return_epc(regs))
  555. return;
  557. force_sig(SIGILL, current);
  558. }
  560. asmlinkage void do_cpu(struct pt_regs *regs)
  561. {
  562. unsigned int cpid;
  563. void fpu_emulator_init_fpu(void);
  564. int sig;
  566. cpid = (regs->cp0_cause >> CAUSEB_CE) & 3;
  567. if (cpid != 1)
  568. goto bad_cid;
  570. if (!(mips_cpu.options & MIPS_CPU_FPU))
  571. goto fp_emul;
  573. regs->cp0_status |= ST0_CU1;
  575. #ifdef CONFIG_SMP
  576. if (current->used_math) {
  577. lazy_fpu_switch(0, current);
  578. } else {
  579. init_fpu();
  580. current->used_math = 1;
  581. }
  582. current->flags |= PF_USEDFPU;
  583. #else
  584. if (last_task_used_math == current)
  585. return;
  587. if (current->used_math) { /* Using the FPU again.  */
  588. lazy_fpu_switch(last_task_used_math, current);
  589. } else { /* First time FPU user.  */
  590. lazy_fpu_switch(last_task_used_math, 0);
  591. init_fpu();
  592. current->used_math = 1;
  593. }
  594. last_task_used_math = current;
  595. #endif
  596. return;
  598. fp_emul:
  599. if (last_task_used_math != current) {
  600. if (!current->used_math) {
  601. fpu_emulator_init_fpu();
  602. current->used_math = 1;
  603. }
  604. }
  605. sig = fpu_emulator_cop1Handler(0, regs, &current->thread.fpu.soft);
  606. last_task_used_math = current;
  607. if (sig) {
  608. /*
  609.  * Return EPC is not calculated in the FPU emulator, if
  610.  * a signal is being send. So we calculate it here.
  611.  */
  612. compute_return_epc(regs);
  613. force_sig(sig, current);
  614. }
  615. return;
  617. bad_cid:
  618. compute_return_epc(regs);
  619. force_sig(SIGILL, current);
  620. }
  622. asmlinkage void do_watch(struct pt_regs *regs)
  623. {
  624. extern void dump_tlb_all(void);
  626. /*
  627.  * We use the watch exception where available to detect stack
  628.  * overflows.
  629.  */
  630. dump_tlb_all();
  631. show_regs(regs);
  632. panic("Caught WATCH exception - probably caused by stack overflow.");
  633. }
  635. asmlinkage void do_mcheck(struct pt_regs *regs)
  636. {
  637. show_regs(regs);
  638. dump_tlb_all();
  639. /*
  640.  * Some chips may have other causes of machine check (e.g. SB1
  641.  * graduation timer)
  642.  */
  643. panic("Caught Machine Check exception - %scaused by multiple "
  644.       "matching entries in the TLB.",
  645.       (regs->cp0_status & ST0_TS) ? "" : "not ");
  646. }
  648. asmlinkage void do_reserved(struct pt_regs *regs)
  649. {
  650. /*
  651.  * Game over - no way to handle this if it ever occurs.  Most probably
  652.  * caused by a new unknown cpu type or after another deadly
  653.  * hard/software error.
  654.  */
  655. panic("Caught reserved exception %ld - should not happen.",
  656.       (regs->cp0_cause & 0x1f) >> 2);
  657. }
  659. static inline void watch_init(unsigned long cputype)
  660. {
  661. switch(cputype) {
  662. case CPU_R10000:
  663. case CPU_R4000MC:
  664. case CPU_R4400MC:
  665. case CPU_R4000SC:
  666. case CPU_R4400SC:
  667. case CPU_R4000PC:
  668. case CPU_R4400PC:
  669. case CPU_R4200:
  670. case CPU_R4300:
  671. set_except_vector(23, handle_watch);
  672. watch_available = 1;
  673. break;
  674. }
  675. }
  677. unsigned long exception_handlers[32];
  679. /*
  680.  * As a side effect of the way this is implemented we're limited
  681.  * to interrupt handlers in the address range from
  682.  * KSEG0 <= x < KSEG0 + 256mb on the Nevada.  Oh well ...
  683.  */
  684. void *set_except_vector(int n, void *addr)
  685. {
  686. unsigned long handler = (unsigned long) addr;
  687. unsigned long old_handler = exception_handlers[n];
  689. exception_handlers[n] = handler;
  690. if (n == 0 && mips_cpu.options & MIPS_CPU_DIVEC) {
  691. *(volatile u32 *)(KSEG0+0x200) = 0x08000000 |
  692.                                  (0x03ffffff & (handler >> 2));
  693. flush_icache_range(KSEG0+0x200, KSEG0 + 0x204);
  694. }
  695. return (void *)old_handler;
  696. }
  698. asmlinkage int (*save_fp_context)(struct sigcontext *sc);
  699. asmlinkage int (*restore_fp_context)(struct sigcontext *sc);
  700. extern asmlinkage int _save_fp_context(struct sigcontext *sc);
  701. extern asmlinkage int _restore_fp_context(struct sigcontext *sc);
  703. extern asmlinkage int fpu_emulator_save_context(struct sigcontext *sc);
  704. extern asmlinkage int fpu_emulator_restore_context(struct sigcontext *sc);
  706. void __init per_cpu_trap_init(void)
  707. {
  708. unsigned int cpu = smp_processor_id();
  710. /* Some firmware leaves the BEV flag set, clear it.  */
  711. clear_cp0_status(ST0_CU1|ST0_CU2|ST0_CU3|ST0_BEV);
  712. set_cp0_status(ST0_CU0|ST0_FR|ST0_KX|ST0_SX|ST0_UX);
  714. /*
  715.  * Some MIPS CPUs have a dedicated interrupt vector which reduces the
  716.  * interrupt processing overhead.  Use it where available.
  717.  */
  718. if (mips_cpu.options & MIPS_CPU_DIVEC)
  719. set_cp0_cause(CAUSEF_IV);
  721. cpu_data[cpu].asid_cache = ASID_FIRST_VERSION;
  722. set_context(((long)(&pgd_current[cpu])) << 23);
  723. set_wired(0);
  724. }
  726. void __init trap_init(void)
  727. {
  728. extern char except_vec0;
  729. extern char except_vec1_r4k;
  730. extern char except_vec1_r10k;
  731. extern char except_vec2_generic;
  732. extern char except_vec3_generic, except_vec3_r4000;
  733. extern char except_vec4;
  734. unsigned long i;
  735. int dummy;
  737. per_cpu_trap_init();
  739. /* Copy the generic exception handlers to their final destination. */
  740. memcpy((void *)(KSEG0 + 0x100), &except_vec2_generic, 0x80);
  741. memcpy((void *)(KSEG0 + 0x180), &except_vec3_generic, 0x80);
  743. /*
  744.  * Setup default vectors
  745.  */
  746. for(i = 0; i <= 31; i++)
  747. set_except_vector(i, handle_reserved);
  749. /*
  750.  * Only some CPUs have the watch exceptions or a dedicated
  751.  * interrupt vector.
  752.  */
  753. watch_init(mips_cpu.cputype);
  755. /*
  756.  * Some MIPS CPUs have a dedicated interrupt vector which reduces the
  757.  * interrupt processing overhead.  Use it where available.
  758.  */
  759. memcpy((void *)(KSEG0 + 0x200), &except_vec4, 8);
  761. if (mips_cpu.options & MIPS_CPU_MCHECK)
  762. set_except_vector(24, handle_mcheck);
  764. /*
  765.  * The Data Bus Errors / Instruction Bus Errors are signaled
  766.  * by external hardware.  Therefore these two exceptions
  767.  * may have board specific handlers.
  768.  */
  769. bus_error_init();
  771. /*
  772.  * Handling the following exceptions depends mostly of the cpu type
  773.  */
  774. switch(mips_cpu.cputype) {
  775.         case CPU_SB1:
  776. #ifdef CONFIG_SB1_CACHE_ERROR
  777. {
  778. /* Special cache error handler for SB1 */
  779. extern char except_vec2_sb1;
  780. memcpy((void *)(KSEG0 + 0x100), &except_vec2_sb1, 0x80);
  781. memcpy((void *)(KSEG1 + 0x100), &except_vec2_sb1, 0x80);
  782. }
  783. #endif
  784. /* Enable timer interrupt and scd mapped interrupt */
  785. clear_cp0_status(0xf000);
  786. set_cp0_status(0xc00);
  788. /* Fall through. */
  789. case CPU_R10000:
  790. case CPU_R4000MC:
  791. case CPU_R4400MC:
  792. case CPU_R4000SC:
  793. case CPU_R4400SC:
  794. case CPU_R4000PC:
  795. case CPU_R4400PC:
  796. case CPU_R4200:
  797. case CPU_R4300:
  798. case CPU_R4600:
  799. case CPU_R5000:
  800. case CPU_NEVADA:
  801. case CPU_5KC:
  802. case CPU_20KC:
  803. case CPU_RM7000:
  804. /* Debug TLB refill handler.  */
  805. memcpy((void *)KSEG0, &except_vec0, 0x80);
  806. if ((mips_cpu.options & MIPS_CPU_4KEX)
  807.     && (mips_cpu.options & MIPS_CPU_4KTLB)) {
  808. memcpy((void *)KSEG0 + 0x080, &except_vec1_r4k, 0x80);
  809. } else {
  810. memcpy((void *)KSEG0 + 0x080, &except_vec1_r10k, 0x80);
  811. }
  812. if (mips_cpu.options & MIPS_CPU_VCE) {
  813. memcpy((void *)(KSEG0 + 0x180), &except_vec3_r4000,
  814.        0x80);
  815. } else {
  816. memcpy((void *)(KSEG0 + 0x180), &except_vec3_generic,
  817.        0x80);
  818. }
  820. set_except_vector(1, __xtlb_mod);
  821. set_except_vector(2, __xtlb_tlbl);
  822. set_except_vector(3, __xtlb_tlbs);
  823. set_except_vector(4, handle_adel);
  824. set_except_vector(5, handle_ades);
  826. set_except_vector(6, handle_ibe);
  827. set_except_vector(7, handle_dbe);
  829. set_except_vector(8, handle_sys);
  830. set_except_vector(9, handle_bp);
  831. set_except_vector(10, handle_ri);
  832. set_except_vector(11, handle_cpu);
  833. set_except_vector(12, handle_ov);
  834. set_except_vector(13, handle_tr);
  835. set_except_vector(15, handle_fpe);
  836. break;
  838. case CPU_R8000:
  839. panic("R8000 is unsupported");
  840. break;
  842. case CPU_UNKNOWN:
  843. default:
  844. panic("Unknown CPU type");
  845. }
  846. flush_icache_range(KSEG0, KSEG0 + 0x200);
  848. if (mips_cpu.options & MIPS_CPU_FPU) {
  849.         save_fp_context = _save_fp_context;
  850. restore_fp_context = _restore_fp_context;
  851. } else {
  852. save_fp_context = fpu_emulator_save_context;
  853. restore_fp_context = fpu_emulator_restore_context;
  854. }
  856. if (mips_cpu.isa_level == MIPS_CPU_ISA_IV)
  857. set_cp0_status(ST0_XX);
  859. atomic_inc(&init_mm.mm_count); /* XXX UP?  */
  860. current->active_mm = &init_mm;
  861. }