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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
traps.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：21k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

traps.c：源码内容
  1. /*
  2.  *  linux/arch/parisc/traps.c
  3.  *
  4.  *  Copyright (C) 1991, 1992  Linus Torvalds
  5.  *  Copyright (C) 1999, 2000  Philipp Rumpf <prumpf@tux.org>
  6.  */
  8. /*
  9.  * 'Traps.c' handles hardware traps and faults after we have saved some
  10.  * state in 'asm.s'.
  11.  */
  13. #include <linux/config.h>
  14. #include <linux/sched.h>
  15. #include <linux/kernel.h>
  16. #include <linux/string.h>
  17. #include <linux/errno.h>
  18. #include <linux/ptrace.h>
  19. #include <linux/timer.h>
  20. #include <linux/mm.h>
  21. #include <linux/smp.h>
  22. #include <linux/smp_lock.h>
  23. #include <linux/spinlock.h>
  24. #include <linux/init.h>
  25. #include <linux/interrupt.h>
  26. #include <asm/system.h>
  27. #include <asm/uaccess.h>
  28. #include <asm/io.h>
  29. #include <asm/irq.h>
  30. #include <asm/atomic.h>
  32. #include <asm/smp.h>
  33. #include <asm/pdc.h>
  35. #ifdef CONFIG_KWDB
  36. #include <kdb/break.h> /* for BI2_KGDB_GDB */
  37. #include <kdb/kgdb_types.h> /* for __() */
  38. #include <kdb/save_state.h> /* for struct save_state */
  39. #include <kdb/kgdb_machine.h> /* for pt_regs_to_ssp and ssp_to_pt_regs */
  40. #include <kdb/trap.h> /* for I_BRK_INST */
  41. #endif /* CONFIG_KWDB */
  44. static inline void console_verbose(void)
  45. {
  46. console_loglevel = 15;
  47. }
  50. void page_exception(void);
  52. /*
  53.  * These constants are for searching for possible module text
  54.  * segments.  VMALLOC_OFFSET comes from mm/vmalloc.c; MODULE_RANGE is
  55.  * a guess of how much space is likely to be vmalloced.
  56.  */
  57. #define VMALLOC_OFFSET (8*1024*1024)
  58. #define MODULE_RANGE (8*1024*1024)
  60. int kstack_depth_to_print = 24;
  62. static void printbinary(unsigned long x, int nbits)
  63. {
  64. unsigned long mask = 1UL << (nbits - 1);
  65. while (mask != 0) {
  66. printk(mask & x ? "1" : "0");
  67. mask >>= 1;
  68. }
  69. }
  71. void show_regs(struct pt_regs *regs)
  72. {
  73. int i;
  74. #ifdef __LP64__
  75. #define RFMT " %016lx"
  76. #else
  77. #define RFMT " %08lx"
  78. #endif
  80. printk("n"); /* don't want to have that pretty register dump messed up */
  82. printk("     YZrvWESTHLNXBCVMcbcbcbcbOGFRQPDInPSW: ");
  83. printbinary(regs->gr[0], 32);
  84. printk("    %sn", print_tainted());
  86. for (i = 0; i < 32; i += 4) {
  87. int j;
  88. printk("r%d-%dt", i, i + 3);
  89. for (j = 0; j < 4; j++) {
  90. printk(RFMT, i + j == 0 ? 0 : regs->gr[i + j]);
  91. }
  92. printk("n");
  93. }
  95. for (i = 0; i < 8; i += 4) {
  96. int j;
  97. printk("sr%d-%dt", i, i + 4);
  98. for (j = 0; j < 4; j++) {
  99. printk(RFMT, regs->sr[i + j]);
  100. }
  101. printk("n");
  102. }
  104. #if REDICULOUSLY_VERBOSE
  105. for (i = 0; i < 32; i++) {
  106. printk("FR%2d : %016lx  ", i, regs->fr[i]);
  107. if ((i & 1) == 1)
  108. printk("n");
  109. }
  110. #endif
  112. printk("nIASQ:" RFMT RFMT " IAOQ:" RFMT RFMT "n",
  113.        regs->iasq[0], regs->iasq[1], regs->iaoq[0], regs->iaoq[1]);
  114. printk(" IIR: %08lx    ISR:" RFMT "  IOR:" RFMT "nORIG_R28:" RFMT
  115.        "n", regs->iir, regs->isr, regs->ior, regs->orig_r28);
  116. }
  118. void
  119. die_if_kernel (char *str, struct pt_regs *regs, long err)
  120. {
  121. if (user_mode(regs)) {
  122. #if 1
  123. if (err == 0)
  124. return; /* STFU */
  126. /* XXX for debugging only */
  127. printk ("!!die_if_kernel: %s(%d): %s %ldn",
  128. current->comm, current->pid, str, err);
  129. show_regs(regs);
  130. #endif
  131. return;
  132. }
  134. printk("%s[%d]: %s %ldn", current->comm, current->pid, str, err);
  136. show_regs(regs);
  138. /* Wot's wrong wif bein' racy? */
  139. if (current->thread.flags & PARISC_KERNEL_DEATH) {
  140. printk("die_if_kernel recursion detected.n");
  141. sti();
  142. while (1);
  143. }
  144. current->thread.flags |= PARISC_KERNEL_DEATH;
  145. do_exit(SIGSEGV);
  146. }
  148. asmlinkage void cache_flush_denied(struct pt_regs * regs, long error_code)
  149. {
  150. }
  152. asmlinkage void do_general_protection(struct pt_regs * regs, long error_code)
  153. {
  154. }
  156. #ifndef CONFIG_MATH_EMULATION
  158. asmlinkage void math_emulate(long arg)
  159. {
  160. }
  162. #endif /* CONFIG_MATH_EMULATION */
  164. int syscall_ipi(int (*syscall) (struct pt_regs *), struct pt_regs *regs)
  165. {
  166. return syscall(regs);
  167. }
  169. struct {
  170. int retval;
  172. int (*func) (void *, struct pt_regs *);
  173. void * data;
  174. } ipi_action[NR_CPUS];
  176. void ipi_interrupt(int irq, void *unused, struct pt_regs *regs)
  177. {
  178. int cpu = smp_processor_id();
  180. if(!ipi_action[cpu].func)
  181. BUG();
  183. ipi_action[cpu].retval =
  184. ipi_action[cpu].func(ipi_action[cpu].data, regs);
  185. }
  187. /* gdb uses break 4,8 */
  188. #define GDB_BREAK_INSN 0x10004
  189. void handle_gdb_break(struct pt_regs *regs, int wot)
  190. {
  191. struct siginfo si;
  193. si.si_code = wot;
  194. si.si_addr = (void *) (regs->iaoq[0] & ~3);
  195. si.si_signo = SIGTRAP;
  196. si.si_errno = 0;
  197. force_sig_info(SIGTRAP, &si, current);
  198. }
  200. void handle_break(unsigned iir, struct pt_regs *regs)
  201. {
  202. struct siginfo si;
  203. #ifdef CONFIG_KWDB
  204. struct save_state ssp;
  205. #endif /* CONFIG_KWDB */   
  207. flush_all_caches();
  208. switch(iir) {
  209. case 0x00:
  210. /* show registers, halt */
  211. cli();
  212. printk("break 0,0: pid=%d command='%s'n",
  213.        current->pid, current->comm);
  214. die_if_kernel("Breakpoint", regs, 0);
  215. show_regs(regs);
  216. si.si_code = TRAP_BRKPT;
  217. si.si_addr = (void *) (regs->iaoq[0] & ~3);
  218. si.si_signo = SIGTRAP;
  219. force_sig_info(SIGTRAP, &si, current);
  220. break;
  222. case GDB_BREAK_INSN:
  223. die_if_kernel("Breakpoint", regs, 0);
  224. handle_gdb_break(regs, TRAP_BRKPT);
  225. break;
  227. #ifdef CONFIG_KWDB
  229. case KGDB_BREAK_INSN:
  230. mtctl(0, 15);
  231. pt_regs_to_ssp(regs, &ssp);
  232. kgdb_trap(I_BRK_INST, &ssp, 1);
  233. ssp_to_pt_regs(&ssp, regs);
  234. break;
  236. case KGDB_INIT_BREAK_INSN:
  237. mtctl(0, 15);
  238. pt_regs_to_ssp(regs, &ssp);
  239. kgdb_trap(I_BRK_INST, &ssp, 1);
  240. ssp_to_pt_regs(&ssp, regs);
  242. /* Advance pcoq to skip break */
  243. regs->iaoq[0] = regs->iaoq[1];
  244. regs->iaoq[1] += 4;
  245. break;
  247. #endif /* CONFIG_KWDB */
  249. default:
  250. set_eiem(0);
  251. printk("break %#08x: pid=%d command='%s'n",
  252.        iir, current->pid, current->comm);
  253. show_regs(regs);
  254. si.si_signo = SIGTRAP;
  255. si.si_code = TRAP_BRKPT;
  256. si.si_addr = (void *) (regs->iaoq[0] & ~3);
  257. force_sig_info(SIGTRAP, &si, current);
  258. return;
  259. }
  260. }
  262. /* Format of the floating-point exception registers. */
  263. struct exc_reg {
  264. unsigned int exception : 6;
  265. unsigned int ei : 26;
  266. };
  268. /* Macros for grabbing bits of the instruction format from the 'ei'
  269.    field above. */
  270. /* Major opcode 0c and 0e */
  271. #define FP0CE_UID(i) (((i) >> 6) & 3)
  272. #define FP0CE_CLASS(i) (((i) >> 9) & 3)
  273. #define FP0CE_SUBOP(i) (((i) >> 13) & 7)
  274. #define FP0CE_SUBOP1(i) (((i) >> 15) & 7) /* Class 1 subopcode */
  275. #define FP0C_FORMAT(i) (((i) >> 11) & 3)
  276. #define FP0E_FORMAT(i) (((i) >> 11) & 1)
  278. /* Major opcode 0c, uid 2 (performance monitoring) */
  279. #define FPPM_SUBOP(i) (((i) >> 9) & 0x1f)
  281. /* Major opcode 2e (fused operations).   */
  282. #define FP2E_SUBOP(i)  (((i) >> 5) & 1)
  283. #define FP2E_FORMAT(i) (((i) >> 11) & 1)
  285. /* Major opcode 26 (FMPYSUB) */
  286. /* Major opcode 06 (FMPYADD) */
  287. #define FPx6_FORMAT(i) ((i) & 0x1f)
  289. /* Flags and enable bits of the status word. */
  290. #define FPSW_FLAGS(w) ((w) >> 27)
  291. #define FPSW_ENABLE(w) ((w) & 0x1f)
  292. #define FPSW_V (1<<4)
  293. #define FPSW_Z (1<<3)
  294. #define FPSW_O (1<<2)
  295. #define FPSW_U (1<<1)
  296. #define FPSW_I (1<<0)
  298. /* Emulate a floating point instruction if necessary and possible
  299.    (this will be moved elsewhere eventually).  Return zero if
  300.    successful or if emulation was not required, -1 if the instruction
  301.    is actually illegal or unimplemented.  The status word passed as
  302.    the first parameter will be modified to signal exceptions, if
  303.    any. */
  305. /* FIXME!!!  This is really incomplete and, at the moment, most
  306.    illegal FP instructions will simply act as no-ops.  Obviously that
  307.    is *not* what we want.  Also we don't even try to handle exception
  308.    types other than the 'unimplemented' ones. */
  309. int
  310. fp_emul_insn(u32 *sw, struct exc_reg exc, struct pt_regs *regs)
  311. {
  312. switch (exc.exception) {
  313. case 0x3:  /* Unimplemented, opcode 06 */
  314. break;
  315. case 0x9:  /* Unimplemented, opcode 0c */
  316. /* We do not support quadword operations, end of
  317.                    story.  There's no support for them in GCC. */
  318. if (FP0C_FORMAT(exc.ei) == 3)
  319. return -1; /* SIGILL */
  320. /* Fall through. */
  321. case 0xa:  /* Unimplemented, opcode 0e */
  322. if (FP0CE_CLASS(exc.ei) == 1) {
  323. /* FCNV instructions of various sorts. */
  324. } else {
  325. if (FP0CE_CLASS(exc.ei == 0)
  326.     && FP0CE_SUBOP(exc.ei == 5)) {
  327. /* FRND instructions should be
  328.                                    emulated, at some point, I
  329.                                    guess. */
  330. return -1; /* SIGILL */
  331. }
  332. }
  333. break;
  334. case 0x23: /* Unimplemented, opcode 26 */
  335. break;
  336. case 0x2b: /* Unimplemented, opcode 2e */
  337. break;
  338. case 0x1:  /* Unimplemented, opcode 0e/0c */
  339. /* FIXME: How the hell are we supposed to tell which
  340.                    opcode it is? */
  341. break;
  342. default:
  343. return -1; /* Punt */
  344. }
  346. return 0;
  347. }
  349. /* Handle a floating point exception.  Return zero if the faulting
  350.    instruction can be completed successfully. */
  351. int
  352. handle_fpe(struct pt_regs *regs)
  353. {
  354. struct siginfo si;
  355. union {
  356. struct fpsw {
  357. /* flag bits */
  358. unsigned int fv : 1;
  359. unsigned int fz : 1;
  360. unsigned int fo : 1;
  361. unsigned int fu : 1;
  362. unsigned int fi : 1;
  364. unsigned int c : 1;
  365. unsigned int pad1 : 4;
  366. unsigned int cq : 11;
  367. unsigned int rm : 2;
  368. unsigned int pad2 : 2;
  369. unsigned int t : 1;
  370. unsigned int d : 1;
  372. /* enable bits */
  373. unsigned int ev : 1;
  374. unsigned int ez : 1;
  375. unsigned int eo : 1;
  376. unsigned int eu : 1;
  377. unsigned int ei : 1;
  378. } status;
  379. u32 word;
  380. } sw;
  381. struct exc_reg excepts[7];
  382. unsigned int code = 0;
  383. unsigned int throw;
  385. /* Status word = FR0L. */
  386. memcpy(&sw, regs->fr, sizeof(sw));
  387. /* Exception words = FR0R-FR3R. */
  388. memcpy(excepts, ((char *) regs->fr) + 4, sizeof(excepts));
  390. /* This is all CPU dependent.  Since there is no public
  391.            documentation on the PA2.0 processors we will just assume
  392.            everything is like the 7100/7100LC/7300LC for now.
  394.    Specifically: All exceptions are marked as "unimplemented"
  395.    in the exception word, and the only exception word used is
  396.    excepts[1]. */
  398. /* Try to emulate the instruction.  Also determine if it is
  399.            really an illegal instruction in the process.
  401.    FIXME: fp_emul_insn() only checks for the "unimplemented"
  402.    exceptions at the moment.  So this may break horribly on
  403.    PA2.0, where we may want to also check to see if we should
  404.    just send SIGFPE (or maybe not, let's see the documentation
  405.    first...) */
  406. if (fp_emul_insn(&sw.word, excepts[1], regs) == -1)
  407. goto send_sigill;
  409. /* Take the intersection of the flag bits in the FPSW and the
  410.            enable bits in the FPSW. */
  411. throw = FPSW_FLAGS(sw.word) & FPSW_ENABLE(sw.word);
  413. /* Concoct an appropriate si_code.  Of course we don't know
  414.            what to do if multiple exceptions were enabled and multiple
  415.            flags were set.  Maybe that's why HP/UX doesn't implement
  416.            feenableexcept(). */
  418. if (throw == 0)
  419. goto success; /* Duh. */
  420. else if (throw & FPSW_V)
  421. code = FPE_FLTINV;
  422. else if (throw & FPSW_Z)
  423. code = FPE_FLTDIV;
  424. else if (throw & FPSW_O)
  425. code = FPE_FLTOVF;
  426. else if (throw & FPSW_U)
  427. code = FPE_FLTUND;
  428. else if (throw & FPSW_I)
  429. code = FPE_FLTRES;
  431. #if 1 /* Debugging... */
  432. printk("Unemulated floating point exception, pid=%d (%s)n",
  433.        current->pid, current->comm);
  434. show_regs(regs);
  435. {
  436. int i;
  437. printk("FP Status: %08xn", sw.word);
  438. printk("FP Exceptions:n");
  439. for (i = 0; i < 7; i++) {
  440. printk("tExcept%d: exception %03x insn %06xn",
  441.        i, excepts[i].exception, excepts[i].ei);
  442. }
  443. }
  444. #endif
  446. /* FIXME: Should we clear the flag bits, T bit, and exception
  447.            registers here? */
  449. si.si_signo = SIGFPE;
  450. si.si_errno = 0;
  451. si.si_code = code;
  452. si.si_addr = (void *) regs->iaoq[0];
  453. force_sig_info(SIGFPE, &si, current);
  454. return -1;
  456.  send_sigill:
  457. si.si_signo = SIGILL;
  458. si.si_errno = 0;
  459. si.si_code = ILL_COPROC;
  460. si.si_addr = (void *) regs->iaoq[0];
  461. force_sig_info(SIGILL, &si, current);
  462. return -1;
  464.  success:
  465. /* We absolutely have to clear the T bit and exception
  466.            registers to allow the process to recover.  Otherwise every
  467.            subsequent floating point instruction will trap. */
  468. sw.status.t = 0;
  469. memset(excepts, 0, sizeof(excepts));
  471. memcpy(regs->fr, &sw, sizeof(sw));
  472. memcpy(((char *) regs->fr) + 4,excepts , sizeof(excepts));
  473. return 0;
  474. }
  476. int handle_toc(void)
  477. {
  478. return 0;
  479. }
  481. void default_trap(int code, struct pt_regs *regs)
  482. {
  483. printk("Trap %d on CPU %dn", code, smp_processor_id());
  485. show_regs(regs);
  486. }
  488. void (*cpu_lpmc) (int code, struct pt_regs *regs) = default_trap;
  491. #ifdef CONFIG_KWDB
  492. int
  493. debug_call (void) {
  494.     printk ("Debug call.n");
  495.     return 0;
  496. }
  498. int
  499. debug_call_leaf (void) {
  500.     return 0;
  501. }
  502. #endif /* CONFIG_KWDB */
  504. extern void do_page_fault(struct pt_regs *, int, unsigned long);
  505. extern void parisc_terminate(char *, struct pt_regs *, int, unsigned long);
  506. extern void transfer_pim_to_trap_frame(struct pt_regs *);
  507. extern void pdc_console_restart(void);
  509. void handle_interruption(int code, struct pt_regs *regs)
  510. {
  511. unsigned long fault_address = 0;
  512. unsigned long fault_space = 0;
  513. struct siginfo si;
  514. #ifdef CONFIG_KWDB
  515. struct save_state ssp;
  516. #endif /* CONFIG_KWDB */   
  518. if (code == 1)
  519.     pdc_console_restart();  /* switch back to pdc if HPMC */
  520. else
  521.     sti();
  523. #ifdef __LP64__
  525. /*
  526.  * FIXME:
  527.  * For 32 bit processes we don't want the b bits (bits 0 & 1)
  528.  * in the ior. This is more appropriately handled in the tlb
  529.  * miss handlers. Changes need to be made to support addresses
  530.  * >32 bits for 64 bit processes.
  531.  */
  533. regs->ior &= 0x3FFFFFFFFFFFFFFFUL;
  534. #endif
  536. #if 0
  537. printk("interrupted with code %d, regs %pn", code, regs);
  538. show_regs(regs);
  539. #endif
  541. switch(code) {
  542. case  1:
  543. parisc_terminate("High Priority Machine Check (HPMC)",regs,code,0);
  544. /* NOT REACHED */
  545. case  3: /* Recovery counter trap */
  546. regs->gr[0] &= ~PSW_R;
  547. if (regs->iasq[0])
  548. handle_gdb_break(regs, TRAP_TRACE);
  549. /* else this must be the start of a syscall - just let it
  550.  * run.
  551.  */
  552. return;
  554. case  5:
  555. flush_all_caches();
  556. cpu_lpmc(5, regs);
  557. return;
  559. case  6:
  560. fault_address = regs->iaoq[0];
  561. fault_space   = regs->iasq[0];
  562. break;
  564. case  9: /* Break Instruction */
  565. handle_break(regs->iir,regs);
  566. return;
  568. case 14:
  569. /* Assist Exception Trap, i.e. floating point exception. */
  570. die_if_kernel("Floating point exception", regs, 0); /* quiet */
  571. handle_fpe(regs);
  572. return;
  573. case 15:
  574. case 16:  /* Non-Access TLB miss faulting address is in IOR */
  575. case 17:
  576. case 26:
  577. fault_address = regs->ior;
  578. fault_space   = regs->isr;
  580. if (code == 26 && fault_space == 0)
  581.     parisc_terminate("Data access rights fault in kernel",regs,code,fault_address);
  582. break;
  584. case 19:
  585. regs->gr[0] |= PSW_X; /* So we can single-step over the trap */
  586. /* fall thru */
  587. case 21:
  588. handle_gdb_break(regs, TRAP_HWBKPT);
  589. return;
  591. case 25: /* Taken branch trap */
  592. regs->gr[0] &= ~PSW_T;
  593. if (regs->iasq[0])
  594. handle_gdb_break(regs, TRAP_BRANCH);
  595. /* else this must be the start of a syscall - just let it
  596.  * run.
  597.  */
  598. return;
  600. #if 0 /* def CONFIG_KWDB */
  601. case I_TAKEN_BR: /* 25 */
  602. mtctl(0, 15);
  603. pt_regs_to_ssp(regs, &ssp);
  604. kgdb_trap(I_TAKEN_BR, &ssp, 1);
  605. ssp_to_pt_regs(&ssp, regs);
  606. break;
  607. #endif /* CONFIG_KWDB */
  609. case  8:
  610. die_if_kernel("Illegal instruction", regs, code);
  611. si.si_code = ILL_ILLOPC;
  612. goto give_sigill;
  614. case 10:
  615. die_if_kernel("Priviledged operation - shouldn't happen!", regs, code);
  616. si.si_code = ILL_PRVOPC;
  617. goto give_sigill;
  618. case 11:
  619. die_if_kernel("Priviledged register - shouldn't happen!", regs, code);
  620. si.si_code = ILL_PRVREG;
  621. give_sigill:
  622. si.si_signo = SIGILL;
  623. si.si_errno = 0;
  624. si.si_addr = (void *) regs->iaoq[0];
  625. force_sig_info(SIGILL, &si, current);
  626. return;
  628. case 28:  /* Unaligned just causes SIGBUS for now */
  629. die_if_kernel("Unaligned data reference", regs, code);
  630. si.si_code = BUS_ADRALN;
  631. si.si_signo = SIGBUS;
  632. si.si_errno = 0;
  633. si.si_addr = (void *) regs->ior;
  634. force_sig_info(SIGBUS, &si, current);
  635. return;
  637. default:
  638. if (user_mode(regs)) {
  639. printk("nhandle_interruption() pid=%d command='%s'n",
  640.     current->pid, current->comm);
  641. show_regs(regs);
  642. /* SIGBUS, for lack of a better one. */
  643. si.si_signo = SIGBUS;
  644. si.si_code = BUS_OBJERR;
  645. si.si_errno = 0;
  646. si.si_addr = (void *) regs->ior;
  647. force_sig_info(SIGBUS, &si, current);
  648. return;
  649. }
  650. parisc_terminate("Unexpected Interruption!",regs,code,0);
  651. /* NOT REACHED */
  652. }
  654. if (user_mode(regs)) {
  655.     if (fault_space != regs->sr[7]) {
  656. if (fault_space == 0)
  657. printk("User Fault on Kernel Space ");
  658. else /* this case should never happen, but whatever... */
  659. printk("User Fault (long pointer) ");
  660. printk("pid=%d command='%s'n", current->pid, current->comm);
  661. show_regs(regs);
  662. si.si_signo = SIGSEGV;
  663. si.si_errno = 0;
  664. si.si_code = SEGV_MAPERR;
  665. si.si_addr = (void *) regs->ior;
  666. force_sig_info(SIGSEGV, &si, current);
  667. return;
  668.     }
  669. }
  670. else {
  672.     /*
  673.      * The kernel should never fault on its own address space.
  674.      */
  676.     if (fault_space == 0)
  677.     parisc_terminate("Kernel Fault",regs,code,fault_address);
  678. }
  680. #ifdef CONFIG_KWDB
  681. debug_call_leaf ();
  682. #endif /* CONFIG_KWDB */
  684. do_page_fault(regs, code, fault_address);
  686. /*
  687.  * This should not be necessary.
  688.  * However, we do not currently
  689.  * implement flush_page_to_ram.
  690.  *
  691.  * The problem is that if we just
  692.  * brought in some code through the
  693.  * D-cache, the I-cache may not see
  694.  * it since it hasn't been flushed
  695.  * to ram.
  696.  */
  698. /*  flush_all_caches(); */
  700. #if 0
  701. printk("returning %pn", regs);
  702. /* show_regs(regs); */
  703. #endif
  705. return;
  707. }
  709. void show_stack(unsigned long sp)
  710. {
  711. #if 1
  712. if ((sp & 0xc0000000UL) == 0xc0000000UL) {
  714.     __u32 *stackptr;
  715.     __u32 *dumpptr;
  717.     /* Stack Dump! */
  719.     stackptr = (__u32 *)sp;
  720.     dumpptr  = (__u32 *)(sp & ~(INIT_TASK_SIZE - 1));
  721.     printk("nDumping Stack from %p to %p:n",dumpptr,stackptr);
  722.     while (dumpptr < stackptr) {
  723. printk("%04x %08x %08x %08x %08x %08x %08x %08x %08xn",
  724.     ((__u32)dumpptr) & 0xffff,
  725.     dumpptr[0], dumpptr[1], dumpptr[2], dumpptr[3],
  726.     dumpptr[4], dumpptr[5], dumpptr[6], dumpptr[7]);
  727. dumpptr += 8;
  728.     }
  729. }
  730. #endif
  731. }
  734. void parisc_terminate(char *msg, struct pt_regs *regs, int code, unsigned long offset)
  735. {
  736. set_eiem(0);
  737. cli();
  739. if (code == 1)
  740.     transfer_pim_to_trap_frame(regs);
  742. #if 1
  743. show_stack(regs->gr[30]);
  744. #endif
  746. printk("n%s: Code=%d regs=%p (Addr=%08lx)n",msg,code,regs,offset);
  747. show_regs(regs);
  749. for(;;)
  750.     ;
  751. }
  753. void transfer_pim_to_trap_frame(struct pt_regs *regs)
  754. {
  755.     register int i;
  756.     extern unsigned int hpmc_pim_data[];
  757.     struct pdc_hpmc_pim_11 *pim_narrow;
  758.     struct pdc_hpmc_pim_20 *pim_wide;
  760.     if (boot_cpu_data.cpu_type >= pcxu) {
  762. pim_wide = (struct pdc_hpmc_pim_20 *)hpmc_pim_data;
  764. /*
  765.  * Note: The following code will probably generate a
  766.  * bunch of truncation error warnings from the compiler.
  767.  * Could be handled with an ifdef, but perhaps there
  768.  * is a better way.
  769.  */
  771. regs->gr[0] = pim_wide->cr[22];
  773. for (i = 1; i < 32; i++)
  774.     regs->gr[i] = pim_wide->gr[i];
  776. for (i = 0; i < 32; i++)
  777.     regs->fr[i] = pim_wide->fr[i];
  779. for (i = 0; i < 8; i++)
  780.     regs->sr[i] = pim_wide->sr[i];
  782. regs->iasq[0] = pim_wide->cr[17];
  783. regs->iasq[1] = pim_wide->iasq_back;
  784. regs->iaoq[0] = pim_wide->cr[18];
  785. regs->iaoq[1] = pim_wide->iaoq_back;
  787. regs->cr30 = pim_wide->cr[30];
  788. regs->sar  = pim_wide->cr[11];
  789. regs->iir  = pim_wide->cr[19];
  790. regs->isr  = pim_wide->cr[20];
  791. regs->ior  = pim_wide->cr[21];
  792.     }
  793.     else {
  794. pim_narrow = (struct pdc_hpmc_pim_11 *)hpmc_pim_data;
  796. regs->gr[0] = pim_narrow->cr[22];
  798. for (i = 1; i < 32; i++)
  799.     regs->gr[i] = pim_narrow->gr[i];
  801. for (i = 0; i < 32; i++)
  802.     regs->fr[i] = pim_narrow->fr[i];
  804. for (i = 0; i < 8; i++)
  805.     regs->sr[i] = pim_narrow->sr[i];
  807. regs->iasq[0] = pim_narrow->cr[17];
  808. regs->iasq[1] = pim_narrow->iasq_back;
  809. regs->iaoq[0] = pim_narrow->cr[18];
  810. regs->iaoq[1] = pim_narrow->iaoq_back;
  812. regs->cr30 = pim_narrow->cr[30];
  813. regs->sar  = pim_narrow->cr[11];
  814. regs->iir  = pim_narrow->cr[19];
  815. regs->isr  = pim_narrow->cr[20];
  816. regs->ior  = pim_narrow->cr[21];
  817.     }
  819.     /*
  820.      * The following fields only have meaning if we came through
  821.      * another path. So just zero them here.
  822.      */
  824.     regs->ksp = 0;
  825.     regs->kpc = 0;
  826.     regs->orig_r28 = 0;
  827. }
  829. int __init check_ivt(void *iva)
  830. {
  831. int i;
  832. u32 check = 0;
  833. u32 *ivap;
  834. u32 *hpmcp;
  835. u32 length;
  836. extern void os_hpmc(void);
  837. extern void os_hpmc_end(void);
  839. if(strcmp((char *)iva, "cows can fly"))
  840. return -1;
  842. ivap = (u32 *)iva;
  844. for (i = 0; i < 8; i++)
  845.     *ivap++ = 0;
  847. /* Compute Checksum for HPMC handler */
  849. length = (u32)((unsigned long)os_hpmc_end - (unsigned long)os_hpmc);
  850. ivap[7] = length;
  852. hpmcp = (u32 *)os_hpmc;
  854. for(i=0; i<length/4; i++)
  855.     check += *hpmcp++;
  857. for(i=0; i<8; i++)
  858.     check += ivap[i];
  860. ivap[5] = -check;
  862. return 0;
  863. }
  865. #ifndef __LP64__
  866. extern const void fault_vector_11;
  867. #endif
  868. extern const void fault_vector_20;
  870. void __init trap_init(void)
  871. {
  872. volatile long eiem;
  873. void *iva;
  875. printk("trap_initn");
  877. if (boot_cpu_data.cpu_type >= pcxu)
  878. iva = (void *) &fault_vector_20;
  879. else
  880. #ifdef __LP64__
  881. panic("Can't boot 64-bit OS on PA1.1 processor!");
  882. #else
  883. iva = (void *) &fault_vector_11;
  884. #endif
  886. if(check_ivt(iva))
  887. panic("IVT invalid");
  889. mtctl(0, 30);
  890. mtctl(90000000, 16);
  891. set_eiem(-1L);
  892. mtctl(-1L, 23);
  893. asm volatile ("rsm 0,%0" : "=r" (eiem));
  894. }