projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[PATCH] ieee80211: Fix debug comments ipw->ieee80211
[deliverable/linux.git] / arch / sparc64 / kernel / traps.c
1 /* $Id: traps.c,v 1.85 2002/02/09 19:49:31 davem Exp $
2 * arch/sparc64/kernel/traps.c
3 *
4 * Copyright (C) 1995,1997 David S. Miller (davem@caip.rutgers.edu)
5 * Copyright (C) 1997,1999,2000 Jakub Jelinek (jakub@redhat.com)
6 */
7
8 /*
9 * I like traps on v9, :))))
10 */
11
12 #include <linux/config.h>
13 #include <linux/module.h>
14 #include <linux/sched.h> /* for jiffies */
15 #include <linux/kernel.h>
16 #include <linux/kallsyms.h>
17 #include <linux/signal.h>
18 #include <linux/smp.h>
19 #include <linux/smp_lock.h>
20 #include <linux/mm.h>
21 #include <linux/init.h>
22
23 #include <asm/delay.h>
24 #include <asm/system.h>
25 #include <asm/ptrace.h>
26 #include <asm/oplib.h>
27 #include <asm/page.h>
28 #include <asm/pgtable.h>
29 #include <asm/unistd.h>
30 #include <asm/uaccess.h>
31 #include <asm/fpumacro.h>
32 #include <asm/lsu.h>
33 #include <asm/dcu.h>
34 #include <asm/estate.h>
35 #include <asm/chafsr.h>
36 #include <asm/psrcompat.h>
37 #include <asm/processor.h>
38 #include <asm/timer.h>
39 #include <asm/kdebug.h>
40 #ifdef CONFIG_KMOD
41 #include <linux/kmod.h>
42 #endif
43
44 struct notifier_block *sparc64die_chain;
45 static DEFINE_SPINLOCK(die_notifier_lock);
46
47 int register_die_notifier(struct notifier_block *nb)
48 {
49 int err = 0;
50 unsigned long flags;
51 spin_lock_irqsave(&die_notifier_lock, flags);
52 err = notifier_chain_register(&sparc64die_chain, nb);
53 spin_unlock_irqrestore(&die_notifier_lock, flags);
54 return err;
55 }
56
57 /* When an irrecoverable trap occurs at tl > 0, the trap entry
58 * code logs the trap state registers at every level in the trap
59 * stack. It is found at (pt_regs + sizeof(pt_regs)) and the layout
60 * is as follows:
61 */
62 struct tl1_traplog {
63 struct {
64 unsigned long tstate;
65 unsigned long tpc;
66 unsigned long tnpc;
67 unsigned long tt;
68 } trapstack[4];
69 unsigned long tl;
70 };
71
72 static void dump_tl1_traplog(struct tl1_traplog *p)
73 {
74 int i;
75
76 printk("TRAPLOG: Error at trap level 0x%lx, dumping track stack.\n",
77 p->tl);
78 for (i = 0; i < 4; i++) {
79 printk(KERN_CRIT
80 "TRAPLOG: Trap level %d TSTATE[%016lx] TPC[%016lx] "
81 "TNPC[%016lx] TT[%lx]\n",
82 i + 1,
83 p->trapstack[i].tstate, p->trapstack[i].tpc,
84 p->trapstack[i].tnpc, p->trapstack[i].tt);
85 }
86 }
87
88 void do_call_debug(struct pt_regs *regs)
89 {
90 notify_die(DIE_CALL, "debug call", regs, 0, 255, SIGINT);
91 }
92
93 void bad_trap(struct pt_regs *regs, long lvl)
94 {
95 char buffer[32];
96 siginfo_t info;
97
98 if (notify_die(DIE_TRAP, "bad trap", regs,
99 0, lvl, SIGTRAP) == NOTIFY_STOP)
100 return;
101
102 if (lvl < 0x100) {
103 sprintf(buffer, "Bad hw trap %lx at tl0\n", lvl);
104 die_if_kernel(buffer, regs);
105 }
106
107 lvl -= 0x100;
108 if (regs->tstate & TSTATE_PRIV) {
109 sprintf(buffer, "Kernel bad sw trap %lx", lvl);
110 die_if_kernel(buffer, regs);
111 }
112 if (test_thread_flag(TIF_32BIT)) {
113 regs->tpc &= 0xffffffff;
114 regs->tnpc &= 0xffffffff;
115 }
116 info.si_signo = SIGILL;
117 info.si_errno = 0;
118 info.si_code = ILL_ILLTRP;
119 info.si_addr = (void __user *)regs->tpc;
120 info.si_trapno = lvl;
121 force_sig_info(SIGILL, &info, current);
122 }
123
124 void bad_trap_tl1(struct pt_regs *regs, long lvl)
125 {
126 char buffer[32];
127
128 if (notify_die(DIE_TRAP_TL1, "bad trap tl1", regs,
129 0, lvl, SIGTRAP) == NOTIFY_STOP)
130 return;
131
132 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
133
134 sprintf (buffer, "Bad trap %lx at tl>0", lvl);
135 die_if_kernel (buffer, regs);
136 }
137
138 #ifdef CONFIG_DEBUG_BUGVERBOSE
139 void do_BUG(const char *file, int line)
140 {
141 bust_spinlocks(1);
142 printk("kernel BUG at %s:%d!\n", file, line);
143 }
144 #endif
145
146 void instruction_access_exception(struct pt_regs *regs,
147 unsigned long sfsr, unsigned long sfar)
148 {
149 siginfo_t info;
150
151 if (notify_die(DIE_TRAP, "instruction access exception", regs,
152 0, 0x8, SIGTRAP) == NOTIFY_STOP)
153 return;
154
155 if (regs->tstate & TSTATE_PRIV) {
156 printk("instruction_access_exception: SFSR[%016lx] SFAR[%016lx], going.\n",
157 sfsr, sfar);
158 die_if_kernel("Iax", regs);
159 }
160 if (test_thread_flag(TIF_32BIT)) {
161 regs->tpc &= 0xffffffff;
162 regs->tnpc &= 0xffffffff;
163 }
164 info.si_signo = SIGSEGV;
165 info.si_errno = 0;
166 info.si_code = SEGV_MAPERR;
167 info.si_addr = (void __user *)regs->tpc;
168 info.si_trapno = 0;
169 force_sig_info(SIGSEGV, &info, current);
170 }
171
172 void instruction_access_exception_tl1(struct pt_regs *regs,
173 unsigned long sfsr, unsigned long sfar)
174 {
175 if (notify_die(DIE_TRAP_TL1, "instruction access exception tl1", regs,
176 0, 0x8, SIGTRAP) == NOTIFY_STOP)
177 return;
178
179 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
180 instruction_access_exception(regs, sfsr, sfar);
181 }
182
183 void data_access_exception(struct pt_regs *regs,
184 unsigned long sfsr, unsigned long sfar)
185 {
186 siginfo_t info;
187
188 if (notify_die(DIE_TRAP, "data access exception", regs,
189 0, 0x30, SIGTRAP) == NOTIFY_STOP)
190 return;
191
192 if (regs->tstate & TSTATE_PRIV) {
193 /* Test if this comes from uaccess places. */
194 unsigned long fixup;
195 unsigned long g2 = regs->u_regs[UREG_G2];
196
197 if ((fixup = search_extables_range(regs->tpc, &g2))) {
198 /* Ouch, somebody is trying ugly VM hole tricks on us... */
199 #ifdef DEBUG_EXCEPTIONS
200 printk("Exception: PC<%016lx> faddr<UNKNOWN>\n", regs->tpc);
201 printk("EX_TABLE: insn<%016lx> fixup<%016lx> "
202 "g2<%016lx>\n", regs->tpc, fixup, g2);
203 #endif
204 regs->tpc = fixup;
205 regs->tnpc = regs->tpc + 4;
206 regs->u_regs[UREG_G2] = g2;
207 return;
208 }
209 /* Shit... */
210 printk("data_access_exception: SFSR[%016lx] SFAR[%016lx], going.\n",
211 sfsr, sfar);
212 die_if_kernel("Dax", regs);
213 }
214
215 info.si_signo = SIGSEGV;
216 info.si_errno = 0;
217 info.si_code = SEGV_MAPERR;
218 info.si_addr = (void __user *)sfar;
219 info.si_trapno = 0;
220 force_sig_info(SIGSEGV, &info, current);
221 }
222
223 #ifdef CONFIG_PCI
224 /* This is really pathetic... */
225 extern volatile int pci_poke_in_progress;
226 extern volatile int pci_poke_cpu;
227 extern volatile int pci_poke_faulted;
228 #endif
229
230 /* When access exceptions happen, we must do this. */
231 static void spitfire_clean_and_reenable_l1_caches(void)
232 {
233 unsigned long va;
234
235 if (tlb_type != spitfire)
236 BUG();
237
238 /* Clean 'em. */
239 for (va = 0; va < (PAGE_SIZE << 1); va += 32) {
240 spitfire_put_icache_tag(va, 0x0);
241 spitfire_put_dcache_tag(va, 0x0);
242 }
243
244 /* Re-enable in LSU. */
245 __asm__ __volatile__("flush %%g6\n\t"
246 "membar #Sync\n\t"
247 "stxa %0, [%%g0] %1\n\t"
248 "membar #Sync"
249 : /* no outputs */
250 : "r" (LSU_CONTROL_IC | LSU_CONTROL_DC |
251 LSU_CONTROL_IM | LSU_CONTROL_DM),
252 "i" (ASI_LSU_CONTROL)
253 : "memory");
254 }
255
256 void do_iae(struct pt_regs *regs)
257 {
258 siginfo_t info;
259
260 spitfire_clean_and_reenable_l1_caches();
261
262 if (notify_die(DIE_TRAP, "instruction access exception", regs,
263 0, 0x8, SIGTRAP) == NOTIFY_STOP)
264 return;
265
266 info.si_signo = SIGBUS;
267 info.si_errno = 0;
268 info.si_code = BUS_OBJERR;
269 info.si_addr = (void *)0;
270 info.si_trapno = 0;
271 force_sig_info(SIGBUS, &info, current);
272 }
273
274 void do_dae(struct pt_regs *regs)
275 {
276 siginfo_t info;
277
278 #ifdef CONFIG_PCI
279 if (pci_poke_in_progress && pci_poke_cpu == smp_processor_id()) {
280 spitfire_clean_and_reenable_l1_caches();
281
282 pci_poke_faulted = 1;
283
284 /* Why the fuck did they have to change this? */
285 if (tlb_type == cheetah || tlb_type == cheetah_plus)
286 regs->tpc += 4;
287
288 regs->tnpc = regs->tpc + 4;
289 return;
290 }
291 #endif
292 spitfire_clean_and_reenable_l1_caches();
293
294 if (notify_die(DIE_TRAP, "data access exception", regs,
295 0, 0x30, SIGTRAP) == NOTIFY_STOP)
296 return;
297
298 info.si_signo = SIGBUS;
299 info.si_errno = 0;
300 info.si_code = BUS_OBJERR;
301 info.si_addr = (void *)0;
302 info.si_trapno = 0;
303 force_sig_info(SIGBUS, &info, current);
304 }
305
306 static char ecc_syndrome_table[] = {
307 0x4c, 0x40, 0x41, 0x48, 0x42, 0x48, 0x48, 0x49,
308 0x43, 0x48, 0x48, 0x49, 0x48, 0x49, 0x49, 0x4a,
309 0x44, 0x48, 0x48, 0x20, 0x48, 0x39, 0x4b, 0x48,
310 0x48, 0x25, 0x31, 0x48, 0x28, 0x48, 0x48, 0x2c,
311 0x45, 0x48, 0x48, 0x21, 0x48, 0x3d, 0x04, 0x48,
312 0x48, 0x4b, 0x35, 0x48, 0x2d, 0x48, 0x48, 0x29,
313 0x48, 0x00, 0x01, 0x48, 0x0a, 0x48, 0x48, 0x4b,
314 0x0f, 0x48, 0x48, 0x4b, 0x48, 0x49, 0x49, 0x48,
315 0x46, 0x48, 0x48, 0x2a, 0x48, 0x3b, 0x27, 0x48,
316 0x48, 0x4b, 0x33, 0x48, 0x22, 0x48, 0x48, 0x2e,
317 0x48, 0x19, 0x1d, 0x48, 0x1b, 0x4a, 0x48, 0x4b,
318 0x1f, 0x48, 0x4a, 0x4b, 0x48, 0x4b, 0x4b, 0x48,
319 0x48, 0x4b, 0x24, 0x48, 0x07, 0x48, 0x48, 0x36,
320 0x4b, 0x48, 0x48, 0x3e, 0x48, 0x30, 0x38, 0x48,
321 0x49, 0x48, 0x48, 0x4b, 0x48, 0x4b, 0x16, 0x48,
322 0x48, 0x12, 0x4b, 0x48, 0x49, 0x48, 0x48, 0x4b,
323 0x47, 0x48, 0x48, 0x2f, 0x48, 0x3f, 0x4b, 0x48,
324 0x48, 0x06, 0x37, 0x48, 0x23, 0x48, 0x48, 0x2b,
325 0x48, 0x05, 0x4b, 0x48, 0x4b, 0x48, 0x48, 0x32,
326 0x26, 0x48, 0x48, 0x3a, 0x48, 0x34, 0x3c, 0x48,
327 0x48, 0x11, 0x15, 0x48, 0x13, 0x4a, 0x48, 0x4b,
328 0x17, 0x48, 0x4a, 0x4b, 0x48, 0x4b, 0x4b, 0x48,
329 0x49, 0x48, 0x48, 0x4b, 0x48, 0x4b, 0x1e, 0x48,
330 0x48, 0x1a, 0x4b, 0x48, 0x49, 0x48, 0x48, 0x4b,
331 0x48, 0x08, 0x0d, 0x48, 0x02, 0x48, 0x48, 0x49,
332 0x03, 0x48, 0x48, 0x49, 0x48, 0x4b, 0x4b, 0x48,
333 0x49, 0x48, 0x48, 0x49, 0x48, 0x4b, 0x10, 0x48,
334 0x48, 0x14, 0x4b, 0x48, 0x4b, 0x48, 0x48, 0x4b,
335 0x49, 0x48, 0x48, 0x49, 0x48, 0x4b, 0x18, 0x48,
336 0x48, 0x1c, 0x4b, 0x48, 0x4b, 0x48, 0x48, 0x4b,
337 0x4a, 0x0c, 0x09, 0x48, 0x0e, 0x48, 0x48, 0x4b,
338 0x0b, 0x48, 0x48, 0x4b, 0x48, 0x4b, 0x4b, 0x4a
339 };
340
341 /* cee_trap in entry.S encodes AFSR/UDBH/UDBL error status
342 * in the following format. The AFAR is left as is, with
343 * reserved bits cleared, and is a raw 40-bit physical
344 * address.
345 */
346 #define CE_STATUS_UDBH_UE (1UL << (43 + 9))
347 #define CE_STATUS_UDBH_CE (1UL << (43 + 8))
348 #define CE_STATUS_UDBH_ESYNDR (0xffUL << 43)
349 #define CE_STATUS_UDBH_SHIFT 43
350 #define CE_STATUS_UDBL_UE (1UL << (33 + 9))
351 #define CE_STATUS_UDBL_CE (1UL << (33 + 8))
352 #define CE_STATUS_UDBL_ESYNDR (0xffUL << 33)
353 #define CE_STATUS_UDBL_SHIFT 33
354 #define CE_STATUS_AFSR_MASK (0x1ffffffffUL)
355 #define CE_STATUS_AFSR_ME (1UL << 32)
356 #define CE_STATUS_AFSR_PRIV (1UL << 31)
357 #define CE_STATUS_AFSR_ISAP (1UL << 30)
358 #define CE_STATUS_AFSR_ETP (1UL << 29)
359 #define CE_STATUS_AFSR_IVUE (1UL << 28)
360 #define CE_STATUS_AFSR_TO (1UL << 27)
361 #define CE_STATUS_AFSR_BERR (1UL << 26)
362 #define CE_STATUS_AFSR_LDP (1UL << 25)
363 #define CE_STATUS_AFSR_CP (1UL << 24)
364 #define CE_STATUS_AFSR_WP (1UL << 23)
365 #define CE_STATUS_AFSR_EDP (1UL << 22)
366 #define CE_STATUS_AFSR_UE (1UL << 21)
367 #define CE_STATUS_AFSR_CE (1UL << 20)
368 #define CE_STATUS_AFSR_ETS (0xfUL << 16)
369 #define CE_STATUS_AFSR_ETS_SHIFT 16
370 #define CE_STATUS_AFSR_PSYND (0xffffUL << 0)
371 #define CE_STATUS_AFSR_PSYND_SHIFT 0
372
373 /* Layout of Ecache TAG Parity Syndrome of AFSR */
374 #define AFSR_ETSYNDROME_7_0 0x1UL /* E$-tag bus bits <7:0> */
375 #define AFSR_ETSYNDROME_15_8 0x2UL /* E$-tag bus bits <15:8> */
376 #define AFSR_ETSYNDROME_21_16 0x4UL /* E$-tag bus bits <21:16> */
377 #define AFSR_ETSYNDROME_24_22 0x8UL /* E$-tag bus bits <24:22> */
378
379 static char *syndrome_unknown = "<Unknown>";
380
381 asmlinkage void cee_log(unsigned long ce_status,
382 unsigned long afar,
383 struct pt_regs *regs)
384 {
385 char memmod_str[64];
386 char *p;
387 unsigned short scode, udb_reg;
388
389 printk(KERN_WARNING "CPU[%d]: Correctable ECC Error "
390 "AFSR[%lx] AFAR[%016lx] UDBL[%lx] UDBH[%lx]\n",
391 smp_processor_id(),
392 (ce_status & CE_STATUS_AFSR_MASK),
393 afar,
394 ((ce_status >> CE_STATUS_UDBL_SHIFT) & 0x3ffUL),
395 ((ce_status >> CE_STATUS_UDBH_SHIFT) & 0x3ffUL));
396
397 udb_reg = ((ce_status >> CE_STATUS_UDBL_SHIFT) & 0x3ffUL);
398 if (udb_reg & (1 << 8)) {
399 scode = ecc_syndrome_table[udb_reg & 0xff];
400 if (prom_getunumber(scode, afar,
401 memmod_str, sizeof(memmod_str)) == -1)
402 p = syndrome_unknown;
403 else
404 p = memmod_str;
405 printk(KERN_WARNING "CPU[%d]: UDBL Syndrome[%x] "
406 "Memory Module \"%s\"\n",
407 smp_processor_id(), scode, p);
408 }
409
410 udb_reg = ((ce_status >> CE_STATUS_UDBH_SHIFT) & 0x3ffUL);
411 if (udb_reg & (1 << 8)) {
412 scode = ecc_syndrome_table[udb_reg & 0xff];
413 if (prom_getunumber(scode, afar,
414 memmod_str, sizeof(memmod_str)) == -1)
415 p = syndrome_unknown;
416 else
417 p = memmod_str;
418 printk(KERN_WARNING "CPU[%d]: UDBH Syndrome[%x] "
419 "Memory Module \"%s\"\n",
420 smp_processor_id(), scode, p);
421 }
422 }
423
424 int cheetah_pcache_forced_on;
425
426 void cheetah_enable_pcache(void)
427 {
428 unsigned long dcr;
429
430 printk("CHEETAH: Enabling P-Cache on cpu %d.\n",
431 smp_processor_id());
432
433 __asm__ __volatile__("ldxa [%%g0] %1, %0"
434 : "=r" (dcr)
435 : "i" (ASI_DCU_CONTROL_REG));
436 dcr |= (DCU_PE | DCU_HPE | DCU_SPE | DCU_SL);
437 __asm__ __volatile__("stxa %0, [%%g0] %1\n\t"
438 "membar #Sync"
439 : /* no outputs */
440 : "r" (dcr), "i" (ASI_DCU_CONTROL_REG));
441 }
442
443 /* Cheetah error trap handling. */
444 static unsigned long ecache_flush_physbase;
445 static unsigned long ecache_flush_linesize;
446 static unsigned long ecache_flush_size;
447
448 /* WARNING: The error trap handlers in assembly know the precise
449 * layout of the following structure.
450 *
451 * C-level handlers below use this information to log the error
452 * and then determine how to recover (if possible).
453 */
454 struct cheetah_err_info {
455 /*0x00*/u64 afsr;
456 /*0x08*/u64 afar;
457
458 /* D-cache state */
459 /*0x10*/u64 dcache_data[4]; /* The actual data */
460 /*0x30*/u64 dcache_index; /* D-cache index */
461 /*0x38*/u64 dcache_tag; /* D-cache tag/valid */
462 /*0x40*/u64 dcache_utag; /* D-cache microtag */
463 /*0x48*/u64 dcache_stag; /* D-cache snooptag */
464
465 /* I-cache state */
466 /*0x50*/u64 icache_data[8]; /* The actual insns + predecode */
467 /*0x90*/u64 icache_index; /* I-cache index */
468 /*0x98*/u64 icache_tag; /* I-cache phys tag */
469 /*0xa0*/u64 icache_utag; /* I-cache microtag */
470 /*0xa8*/u64 icache_stag; /* I-cache snooptag */
471 /*0xb0*/u64 icache_upper; /* I-cache upper-tag */
472 /*0xb8*/u64 icache_lower; /* I-cache lower-tag */
473
474 /* E-cache state */
475 /*0xc0*/u64 ecache_data[4]; /* 32 bytes from staging registers */
476 /*0xe0*/u64 ecache_index; /* E-cache index */
477 /*0xe8*/u64 ecache_tag; /* E-cache tag/state */
478
479 /*0xf0*/u64 __pad[32 - 30];
480 };
481 #define CHAFSR_INVALID ((u64)-1L)
482
483 /* This table is ordered in priority of errors and matches the
484 * AFAR overwrite policy as well.
485 */
486
487 struct afsr_error_table {
488 unsigned long mask;
489 const char *name;
490 };
491
492 static const char CHAFSR_PERR_msg[] =
493 "System interface protocol error";
494 static const char CHAFSR_IERR_msg[] =
495 "Internal processor error";
496 static const char CHAFSR_ISAP_msg[] =
497 "System request parity error on incoming addresss";
498 static const char CHAFSR_UCU_msg[] =
499 "Uncorrectable E-cache ECC error for ifetch/data";
500 static const char CHAFSR_UCC_msg[] =
501 "SW Correctable E-cache ECC error for ifetch/data";
502 static const char CHAFSR_UE_msg[] =
503 "Uncorrectable system bus data ECC error for read";
504 static const char CHAFSR_EDU_msg[] =
505 "Uncorrectable E-cache ECC error for stmerge/blkld";
506 static const char CHAFSR_EMU_msg[] =
507 "Uncorrectable system bus MTAG error";
508 static const char CHAFSR_WDU_msg[] =
509 "Uncorrectable E-cache ECC error for writeback";
510 static const char CHAFSR_CPU_msg[] =
511 "Uncorrectable ECC error for copyout";
512 static const char CHAFSR_CE_msg[] =
513 "HW corrected system bus data ECC error for read";
514 static const char CHAFSR_EDC_msg[] =
515 "HW corrected E-cache ECC error for stmerge/blkld";
516 static const char CHAFSR_EMC_msg[] =
517 "HW corrected system bus MTAG ECC error";
518 static const char CHAFSR_WDC_msg[] =
519 "HW corrected E-cache ECC error for writeback";
520 static const char CHAFSR_CPC_msg[] =
521 "HW corrected ECC error for copyout";
522 static const char CHAFSR_TO_msg[] =
523 "Unmapped error from system bus";
524 static const char CHAFSR_BERR_msg[] =
525 "Bus error response from system bus";
526 static const char CHAFSR_IVC_msg[] =
527 "HW corrected system bus data ECC error for ivec read";
528 static const char CHAFSR_IVU_msg[] =
529 "Uncorrectable system bus data ECC error for ivec read";
530 static struct afsr_error_table __cheetah_error_table[] = {
531 { CHAFSR_PERR, CHAFSR_PERR_msg },
532 { CHAFSR_IERR, CHAFSR_IERR_msg },
533 { CHAFSR_ISAP, CHAFSR_ISAP_msg },
534 { CHAFSR_UCU, CHAFSR_UCU_msg },
535 { CHAFSR_UCC, CHAFSR_UCC_msg },
536 { CHAFSR_UE, CHAFSR_UE_msg },
537 { CHAFSR_EDU, CHAFSR_EDU_msg },
538 { CHAFSR_EMU, CHAFSR_EMU_msg },
539 { CHAFSR_WDU, CHAFSR_WDU_msg },
540 { CHAFSR_CPU, CHAFSR_CPU_msg },
541 { CHAFSR_CE, CHAFSR_CE_msg },
542 { CHAFSR_EDC, CHAFSR_EDC_msg },
543 { CHAFSR_EMC, CHAFSR_EMC_msg },
544 { CHAFSR_WDC, CHAFSR_WDC_msg },
545 { CHAFSR_CPC, CHAFSR_CPC_msg },
546 { CHAFSR_TO, CHAFSR_TO_msg },
547 { CHAFSR_BERR, CHAFSR_BERR_msg },
548 /* These two do not update the AFAR. */
549 { CHAFSR_IVC, CHAFSR_IVC_msg },
550 { CHAFSR_IVU, CHAFSR_IVU_msg },
551 { 0, NULL },
552 };
553 static const char CHPAFSR_DTO_msg[] =
554 "System bus unmapped error for prefetch/storequeue-read";
555 static const char CHPAFSR_DBERR_msg[] =
556 "System bus error for prefetch/storequeue-read";
557 static const char CHPAFSR_THCE_msg[] =
558 "Hardware corrected E-cache Tag ECC error";
559 static const char CHPAFSR_TSCE_msg[] =
560 "SW handled correctable E-cache Tag ECC error";
561 static const char CHPAFSR_TUE_msg[] =
562 "Uncorrectable E-cache Tag ECC error";
563 static const char CHPAFSR_DUE_msg[] =
564 "System bus uncorrectable data ECC error due to prefetch/store-fill";
565 static struct afsr_error_table __cheetah_plus_error_table[] = {
566 { CHAFSR_PERR, CHAFSR_PERR_msg },
567 { CHAFSR_IERR, CHAFSR_IERR_msg },
568 { CHAFSR_ISAP, CHAFSR_ISAP_msg },
569 { CHAFSR_UCU, CHAFSR_UCU_msg },
570 { CHAFSR_UCC, CHAFSR_UCC_msg },
571 { CHAFSR_UE, CHAFSR_UE_msg },
572 { CHAFSR_EDU, CHAFSR_EDU_msg },
573 { CHAFSR_EMU, CHAFSR_EMU_msg },
574 { CHAFSR_WDU, CHAFSR_WDU_msg },
575 { CHAFSR_CPU, CHAFSR_CPU_msg },
576 { CHAFSR_CE, CHAFSR_CE_msg },
577 { CHAFSR_EDC, CHAFSR_EDC_msg },
578 { CHAFSR_EMC, CHAFSR_EMC_msg },
579 { CHAFSR_WDC, CHAFSR_WDC_msg },
580 { CHAFSR_CPC, CHAFSR_CPC_msg },
581 { CHAFSR_TO, CHAFSR_TO_msg },
582 { CHAFSR_BERR, CHAFSR_BERR_msg },
583 { CHPAFSR_DTO, CHPAFSR_DTO_msg },
584 { CHPAFSR_DBERR, CHPAFSR_DBERR_msg },
585 { CHPAFSR_THCE, CHPAFSR_THCE_msg },
586 { CHPAFSR_TSCE, CHPAFSR_TSCE_msg },
587 { CHPAFSR_TUE, CHPAFSR_TUE_msg },
588 { CHPAFSR_DUE, CHPAFSR_DUE_msg },
589 /* These two do not update the AFAR. */
590 { CHAFSR_IVC, CHAFSR_IVC_msg },
591 { CHAFSR_IVU, CHAFSR_IVU_msg },
592 { 0, NULL },
593 };
594 static const char JPAFSR_JETO_msg[] =
595 "System interface protocol error, hw timeout caused";
596 static const char JPAFSR_SCE_msg[] =
597 "Parity error on system snoop results";
598 static const char JPAFSR_JEIC_msg[] =
599 "System interface protocol error, illegal command detected";
600 static const char JPAFSR_JEIT_msg[] =
601 "System interface protocol error, illegal ADTYPE detected";
602 static const char JPAFSR_OM_msg[] =
603 "Out of range memory error has occurred";
604 static const char JPAFSR_ETP_msg[] =
605 "Parity error on L2 cache tag SRAM";
606 static const char JPAFSR_UMS_msg[] =
607 "Error due to unsupported store";
608 static const char JPAFSR_RUE_msg[] =
609 "Uncorrectable ECC error from remote cache/memory";
610 static const char JPAFSR_RCE_msg[] =
611 "Correctable ECC error from remote cache/memory";
612 static const char JPAFSR_BP_msg[] =
613 "JBUS parity error on returned read data";
614 static const char JPAFSR_WBP_msg[] =
615 "JBUS parity error on data for writeback or block store";
616 static const char JPAFSR_FRC_msg[] =
617 "Foreign read to DRAM incurring correctable ECC error";
618 static const char JPAFSR_FRU_msg[] =
619 "Foreign read to DRAM incurring uncorrectable ECC error";
620 static struct afsr_error_table __jalapeno_error_table[] = {
621 { JPAFSR_JETO, JPAFSR_JETO_msg },
622 { JPAFSR_SCE, JPAFSR_SCE_msg },
623 { JPAFSR_JEIC, JPAFSR_JEIC_msg },
624 { JPAFSR_JEIT, JPAFSR_JEIT_msg },
625 { CHAFSR_PERR, CHAFSR_PERR_msg },
626 { CHAFSR_IERR, CHAFSR_IERR_msg },
627 { CHAFSR_ISAP, CHAFSR_ISAP_msg },
628 { CHAFSR_UCU, CHAFSR_UCU_msg },
629 { CHAFSR_UCC, CHAFSR_UCC_msg },
630 { CHAFSR_UE, CHAFSR_UE_msg },
631 { CHAFSR_EDU, CHAFSR_EDU_msg },
632 { JPAFSR_OM, JPAFSR_OM_msg },
633 { CHAFSR_WDU, CHAFSR_WDU_msg },
634 { CHAFSR_CPU, CHAFSR_CPU_msg },
635 { CHAFSR_CE, CHAFSR_CE_msg },
636 { CHAFSR_EDC, CHAFSR_EDC_msg },
637 { JPAFSR_ETP, JPAFSR_ETP_msg },
638 { CHAFSR_WDC, CHAFSR_WDC_msg },
639 { CHAFSR_CPC, CHAFSR_CPC_msg },
640 { CHAFSR_TO, CHAFSR_TO_msg },
641 { CHAFSR_BERR, CHAFSR_BERR_msg },
642 { JPAFSR_UMS, JPAFSR_UMS_msg },
643 { JPAFSR_RUE, JPAFSR_RUE_msg },
644 { JPAFSR_RCE, JPAFSR_RCE_msg },
645 { JPAFSR_BP, JPAFSR_BP_msg },
646 { JPAFSR_WBP, JPAFSR_WBP_msg },
647 { JPAFSR_FRC, JPAFSR_FRC_msg },
648 { JPAFSR_FRU, JPAFSR_FRU_msg },
649 /* These two do not update the AFAR. */
650 { CHAFSR_IVU, CHAFSR_IVU_msg },
651 { 0, NULL },
652 };
653 static struct afsr_error_table *cheetah_error_table;
654 static unsigned long cheetah_afsr_errors;
655
656 /* This is allocated at boot time based upon the largest hardware
657 * cpu ID in the system. We allocate two entries per cpu, one for
658 * TL==0 logging and one for TL >= 1 logging.
659 */
660 struct cheetah_err_info *cheetah_error_log;
661
662 static __inline__ struct cheetah_err_info *cheetah_get_error_log(unsigned long afsr)
663 {
664 struct cheetah_err_info *p;
665 int cpu = smp_processor_id();
666
667 if (!cheetah_error_log)
668 return NULL;
669
670 p = cheetah_error_log + (cpu * 2);
671 if ((afsr & CHAFSR_TL1) != 0UL)
672 p++;
673
674 return p;
675 }
676
677 extern unsigned int tl0_icpe[], tl1_icpe[];
678 extern unsigned int tl0_dcpe[], tl1_dcpe[];
679 extern unsigned int tl0_fecc[], tl1_fecc[];
680 extern unsigned int tl0_cee[], tl1_cee[];
681 extern unsigned int tl0_iae[], tl1_iae[];
682 extern unsigned int tl0_dae[], tl1_dae[];
683 extern unsigned int cheetah_plus_icpe_trap_vector[], cheetah_plus_icpe_trap_vector_tl1[];
684 extern unsigned int cheetah_plus_dcpe_trap_vector[], cheetah_plus_dcpe_trap_vector_tl1[];
685 extern unsigned int cheetah_fecc_trap_vector[], cheetah_fecc_trap_vector_tl1[];
686 extern unsigned int cheetah_cee_trap_vector[], cheetah_cee_trap_vector_tl1[];
687 extern unsigned int cheetah_deferred_trap_vector[], cheetah_deferred_trap_vector_tl1[];
688
689 void __init cheetah_ecache_flush_init(void)
690 {
691 unsigned long largest_size, smallest_linesize, order, ver;
692 int node, i, instance;
693
694 /* Scan all cpu device tree nodes, note two values:
695 * 1) largest E-cache size
696 * 2) smallest E-cache line size
697 */
698 largest_size = 0UL;
699 smallest_linesize = ~0UL;
700
701 instance = 0;
702 while (!cpu_find_by_instance(instance, &node, NULL)) {
703 unsigned long val;
704
705 val = prom_getintdefault(node, "ecache-size",
706 (2 * 1024 * 1024));
707 if (val > largest_size)
708 largest_size = val;
709 val = prom_getintdefault(node, "ecache-line-size", 64);
710 if (val < smallest_linesize)
711 smallest_linesize = val;
712 instance++;
713 }
714
715 if (largest_size == 0UL || smallest_linesize == ~0UL) {
716 prom_printf("cheetah_ecache_flush_init: Cannot probe cpu E-cache "
717 "parameters.\n");
718 prom_halt();
719 }
720
721 ecache_flush_size = (2 * largest_size);
722 ecache_flush_linesize = smallest_linesize;
723
724 /* Discover a physically contiguous chunk of physical
725 * memory in 'sp_banks' of size ecache_flush_size calculated
726 * above. Store the physical base of this area at
727 * ecache_flush_physbase.
728 */
729 for (node = 0; ; node++) {
730 if (sp_banks[node].num_bytes == 0)
731 break;
732 if (sp_banks[node].num_bytes >= ecache_flush_size) {
733 ecache_flush_physbase = sp_banks[node].base_addr;
734 break;
735 }
736 }
737
738 /* Note: Zero would be a valid value of ecache_flush_physbase so
739 * don't use that as the success test. :-)
740 */
741 if (sp_banks[node].num_bytes == 0) {
742 prom_printf("cheetah_ecache_flush_init: Cannot find %d byte "
743 "contiguous physical memory.\n", ecache_flush_size);
744 prom_halt();
745 }
746
747 /* Now allocate error trap reporting scoreboard. */
748 node = NR_CPUS * (2 * sizeof(struct cheetah_err_info));
749 for (order = 0; order < MAX_ORDER; order++) {
750 if ((PAGE_SIZE << order) >= node)
751 break;
752 }
753 cheetah_error_log = (struct cheetah_err_info *)
754 __get_free_pages(GFP_KERNEL, order);
755 if (!cheetah_error_log) {
756 prom_printf("cheetah_ecache_flush_init: Failed to allocate "
757 "error logging scoreboard (%d bytes).\n", node);
758 prom_halt();
759 }
760 memset(cheetah_error_log, 0, PAGE_SIZE << order);
761
762 /* Mark all AFSRs as invalid so that the trap handler will
763 * log new new information there.
764 */
765 for (i = 0; i < 2 * NR_CPUS; i++)
766 cheetah_error_log[i].afsr = CHAFSR_INVALID;
767
768 __asm__ ("rdpr %%ver, %0" : "=r" (ver));
769 if ((ver >> 32) == 0x003e0016) {
770 cheetah_error_table = &__jalapeno_error_table[0];
771 cheetah_afsr_errors = JPAFSR_ERRORS;
772 } else if ((ver >> 32) == 0x003e0015) {
773 cheetah_error_table = &__cheetah_plus_error_table[0];
774 cheetah_afsr_errors = CHPAFSR_ERRORS;
775 } else {
776 cheetah_error_table = &__cheetah_error_table[0];
777 cheetah_afsr_errors = CHAFSR_ERRORS;
778 }
779
780 /* Now patch trap tables. */
781 memcpy(tl0_fecc, cheetah_fecc_trap_vector, (8 * 4));
782 memcpy(tl1_fecc, cheetah_fecc_trap_vector_tl1, (8 * 4));
783 memcpy(tl0_cee, cheetah_cee_trap_vector, (8 * 4));
784 memcpy(tl1_cee, cheetah_cee_trap_vector_tl1, (8 * 4));
785 memcpy(tl0_iae, cheetah_deferred_trap_vector, (8 * 4));
786 memcpy(tl1_iae, cheetah_deferred_trap_vector_tl1, (8 * 4));
787 memcpy(tl0_dae, cheetah_deferred_trap_vector, (8 * 4));
788 memcpy(tl1_dae, cheetah_deferred_trap_vector_tl1, (8 * 4));
789 if (tlb_type == cheetah_plus) {
790 memcpy(tl0_dcpe, cheetah_plus_dcpe_trap_vector, (8 * 4));
791 memcpy(tl1_dcpe, cheetah_plus_dcpe_trap_vector_tl1, (8 * 4));
792 memcpy(tl0_icpe, cheetah_plus_icpe_trap_vector, (8 * 4));
793 memcpy(tl1_icpe, cheetah_plus_icpe_trap_vector_tl1, (8 * 4));
794 }
795 flushi(PAGE_OFFSET);
796 }
797
798 static void cheetah_flush_ecache(void)
799 {
800 unsigned long flush_base = ecache_flush_physbase;
801 unsigned long flush_linesize = ecache_flush_linesize;
802 unsigned long flush_size = ecache_flush_size;
803
804 __asm__ __volatile__("1: subcc %0, %4, %0\n\t"
805 " bne,pt %%xcc, 1b\n\t"
806 " ldxa [%2 + %0] %3, %%g0\n\t"
807 : "=&r" (flush_size)
808 : "0" (flush_size), "r" (flush_base),
809 "i" (ASI_PHYS_USE_EC), "r" (flush_linesize));
810 }
811
812 static void cheetah_flush_ecache_line(unsigned long physaddr)
813 {
814 unsigned long alias;
815
816 physaddr &= ~(8UL - 1UL);
817 physaddr = (ecache_flush_physbase +
818 (physaddr & ((ecache_flush_size>>1UL) - 1UL)));
819 alias = physaddr + (ecache_flush_size >> 1UL);
820 __asm__ __volatile__("ldxa [%0] %2, %%g0\n\t"
821 "ldxa [%1] %2, %%g0\n\t"
822 "membar #Sync"
823 : /* no outputs */
824 : "r" (physaddr), "r" (alias),
825 "i" (ASI_PHYS_USE_EC));
826 }
827
828 /* Unfortunately, the diagnostic access to the I-cache tags we need to
829 * use to clear the thing interferes with I-cache coherency transactions.
830 *
831 * So we must only flush the I-cache when it is disabled.
832 */
833 static void __cheetah_flush_icache(void)
834 {
835 unsigned long i;
836
837 /* Clear the valid bits in all the tags. */
838 for (i = 0; i < (1 << 15); i += (1 << 5)) {
839 __asm__ __volatile__("stxa %%g0, [%0] %1\n\t"
840 "membar #Sync"
841 : /* no outputs */
842 : "r" (i | (2 << 3)), "i" (ASI_IC_TAG));
843 }
844 }
845
846 static void cheetah_flush_icache(void)
847 {
848 unsigned long dcu_save;
849
850 /* Save current DCU, disable I-cache. */
851 __asm__ __volatile__("ldxa [%%g0] %1, %0\n\t"
852 "or %0, %2, %%g1\n\t"
853 "stxa %%g1, [%%g0] %1\n\t"
854 "membar #Sync"
855 : "=r" (dcu_save)
856 : "i" (ASI_DCU_CONTROL_REG), "i" (DCU_IC)
857 : "g1");
858
859 __cheetah_flush_icache();
860
861 /* Restore DCU register */
862 __asm__ __volatile__("stxa %0, [%%g0] %1\n\t"
863 "membar #Sync"
864 : /* no outputs */
865 : "r" (dcu_save), "i" (ASI_DCU_CONTROL_REG));
866 }
867
868 static void cheetah_flush_dcache(void)
869 {
870 unsigned long i;
871
872 for (i = 0; i < (1 << 16); i += (1 << 5)) {
873 __asm__ __volatile__("stxa %%g0, [%0] %1\n\t"
874 "membar #Sync"
875 : /* no outputs */
876 : "r" (i), "i" (ASI_DCACHE_TAG));
877 }
878 }
879
880 /* In order to make the even parity correct we must do two things.
881 * First, we clear DC_data_parity and set DC_utag to an appropriate value.
882 * Next, we clear out all 32-bytes of data for that line. Data of
883 * all-zero + tag parity value of zero == correct parity.
884 */
885 static void cheetah_plus_zap_dcache_parity(void)
886 {
887 unsigned long i;
888
889 for (i = 0; i < (1 << 16); i += (1 << 5)) {
890 unsigned long tag = (i >> 14);
891 unsigned long j;
892
893 __asm__ __volatile__("membar #Sync\n\t"
894 "stxa %0, [%1] %2\n\t"
895 "membar #Sync"
896 : /* no outputs */
897 : "r" (tag), "r" (i),
898 "i" (ASI_DCACHE_UTAG));
899 for (j = i; j < i + (1 << 5); j += (1 << 3))
900 __asm__ __volatile__("membar #Sync\n\t"
901 "stxa %%g0, [%0] %1\n\t"
902 "membar #Sync"
903 : /* no outputs */
904 : "r" (j), "i" (ASI_DCACHE_DATA));
905 }
906 }
907
908 /* Conversion tables used to frob Cheetah AFSR syndrome values into
909 * something palatable to the memory controller driver get_unumber
910 * routine.
911 */
912 #define MT0 137
913 #define MT1 138
914 #define MT2 139
915 #define NONE 254
916 #define MTC0 140
917 #define MTC1 141
918 #define MTC2 142
919 #define MTC3 143
920 #define C0 128
921 #define C1 129
922 #define C2 130
923 #define C3 131
924 #define C4 132
925 #define C5 133
926 #define C6 134
927 #define C7 135
928 #define C8 136
929 #define M2 144
930 #define M3 145
931 #define M4 146
932 #define M 147
933 static unsigned char cheetah_ecc_syntab[] = {
934 /*00*/NONE, C0, C1, M2, C2, M2, M3, 47, C3, M2, M2, 53, M2, 41, 29, M,
935 /*01*/C4, M, M, 50, M2, 38, 25, M2, M2, 33, 24, M2, 11, M, M2, 16,
936 /*02*/C5, M, M, 46, M2, 37, 19, M2, M, 31, 32, M, 7, M2, M2, 10,
937 /*03*/M2, 40, 13, M2, 59, M, M2, 66, M, M2, M2, 0, M2, 67, 71, M,
938 /*04*/C6, M, M, 43, M, 36, 18, M, M2, 49, 15, M, 63, M2, M2, 6,
939 /*05*/M2, 44, 28, M2, M, M2, M2, 52, 68, M2, M2, 62, M2, M3, M3, M4,
940 /*06*/M2, 26, 106, M2, 64, M, M2, 2, 120, M, M2, M3, M, M3, M3, M4,
941 /*07*/116, M2, M2, M3, M2, M3, M, M4, M2, 58, 54, M2, M, M4, M4, M3,
942 /*08*/C7, M2, M, 42, M, 35, 17, M2, M, 45, 14, M2, 21, M2, M2, 5,
943 /*09*/M, 27, M, M, 99, M, M, 3, 114, M2, M2, 20, M2, M3, M3, M,
944 /*0a*/M2, 23, 113, M2, 112, M2, M, 51, 95, M, M2, M3, M2, M3, M3, M2,
945 /*0b*/103, M, M2, M3, M2, M3, M3, M4, M2, 48, M, M, 73, M2, M, M3,
946 /*0c*/M2, 22, 110, M2, 109, M2, M, 9, 108, M2, M, M3, M2, M3, M3, M,
947 /*0d*/102, M2, M, M, M2, M3, M3, M, M2, M3, M3, M2, M, M4, M, M3,
948 /*0e*/98, M, M2, M3, M2, M, M3, M4, M2, M3, M3, M4, M3, M, M, M,
949 /*0f*/M2, M3, M3, M, M3, M, M, M, 56, M4, M, M3, M4, M, M, M,
950 /*10*/C8, M, M2, 39, M, 34, 105, M2, M, 30, 104, M, 101, M, M, 4,
951 /*11*/M, M, 100, M, 83, M, M2, 12, 87, M, M, 57, M2, M, M3, M,
952 /*12*/M2, 97, 82, M2, 78, M2, M2, 1, 96, M, M, M, M, M, M3, M2,
953 /*13*/94, M, M2, M3, M2, M, M3, M, M2, M, 79, M, 69, M, M4, M,
954 /*14*/M2, 93, 92, M, 91, M, M2, 8, 90, M2, M2, M, M, M, M, M4,
955 /*15*/89, M, M, M3, M2, M3, M3, M, M, M, M3, M2, M3, M2, M, M3,
956 /*16*/86, M, M2, M3, M2, M, M3, M, M2, M, M3, M, M3, M, M, M3,
957 /*17*/M, M, M3, M2, M3, M2, M4, M, 60, M, M2, M3, M4, M, M, M2,
958 /*18*/M2, 88, 85, M2, 84, M, M2, 55, 81, M2, M2, M3, M2, M3, M3, M4,
959 /*19*/77, M, M, M, M2, M3, M, M, M2, M3, M3, M4, M3, M2, M, M,
960 /*1a*/74, M, M2, M3, M, M, M3, M, M, M, M3, M, M3, M, M4, M3,
961 /*1b*/M2, 70, 107, M4, 65, M2, M2, M, 127, M, M, M, M2, M3, M3, M,
962 /*1c*/80, M2, M2, 72, M, 119, 118, M, M2, 126, 76, M, 125, M, M4, M3,
963 /*1d*/M2, 115, 124, M, 75, M, M, M3, 61, M, M4, M, M4, M, M, M,
964 /*1e*/M, 123, 122, M4, 121, M4, M, M3, 117, M2, M2, M3, M4, M3, M, M,
965 /*1f*/111, M, M, M, M4, M3, M3, M, M, M, M3, M, M3, M2, M, M
966 };
967 static unsigned char cheetah_mtag_syntab[] = {
968 NONE, MTC0,
969 MTC1, NONE,
970 MTC2, NONE,
971 NONE, MT0,
972 MTC3, NONE,
973 NONE, MT1,
974 NONE, MT2,
975 NONE, NONE
976 };
977
978 /* Return the highest priority error conditon mentioned. */
979 static __inline__ unsigned long cheetah_get_hipri(unsigned long afsr)
980 {
981 unsigned long tmp = 0;
982 int i;
983
984 for (i = 0; cheetah_error_table[i].mask; i++) {
985 if ((tmp = (afsr & cheetah_error_table[i].mask)) != 0UL)
986 return tmp;
987 }
988 return tmp;
989 }
990
991 static const char *cheetah_get_string(unsigned long bit)
992 {
993 int i;
994
995 for (i = 0; cheetah_error_table[i].mask; i++) {
996 if ((bit & cheetah_error_table[i].mask) != 0UL)
997 return cheetah_error_table[i].name;
998 }
999 return "???";
1000 }
1001
1002 extern int chmc_getunumber(int, unsigned long, char *, int);
1003
1004 static void cheetah_log_errors(struct pt_regs *regs, struct cheetah_err_info *info,
1005 unsigned long afsr, unsigned long afar, int recoverable)
1006 {
1007 unsigned long hipri;
1008 char unum[256];
1009
1010 printk("%s" "ERROR(%d): Cheetah error trap taken afsr[%016lx] afar[%016lx] TL1(%d)\n",
1011 (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
1012 afsr, afar,
1013 (afsr & CHAFSR_TL1) ? 1 : 0);
1014 printk("%s" "ERROR(%d): TPC[%016lx] TNPC[%016lx] TSTATE[%016lx]\n",
1015 (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
1016 regs->tpc, regs->tnpc, regs->tstate);
1017 printk("%s" "ERROR(%d): M_SYND(%lx), E_SYND(%lx)%s%s\n",
1018 (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
1019 (afsr & CHAFSR_M_SYNDROME) >> CHAFSR_M_SYNDROME_SHIFT,
1020 (afsr & CHAFSR_E_SYNDROME) >> CHAFSR_E_SYNDROME_SHIFT,
1021 (afsr & CHAFSR_ME) ? ", Multiple Errors" : "",
1022 (afsr & CHAFSR_PRIV) ? ", Privileged" : "");
1023 hipri = cheetah_get_hipri(afsr);
1024 printk("%s" "ERROR(%d): Highest priority error (%016lx) \"%s\"\n",
1025 (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
1026 hipri, cheetah_get_string(hipri));
1027
1028 /* Try to get unumber if relevant. */
1029 #define ESYND_ERRORS (CHAFSR_IVC | CHAFSR_IVU | \
1030 CHAFSR_CPC | CHAFSR_CPU | \
1031 CHAFSR_UE | CHAFSR_CE | \
1032 CHAFSR_EDC | CHAFSR_EDU | \
1033 CHAFSR_UCC | CHAFSR_UCU | \
1034 CHAFSR_WDU | CHAFSR_WDC)
1035 #define MSYND_ERRORS (CHAFSR_EMC | CHAFSR_EMU)
1036 if (afsr & ESYND_ERRORS) {
1037 int syndrome;
1038 int ret;
1039
1040 syndrome = (afsr & CHAFSR_E_SYNDROME) >> CHAFSR_E_SYNDROME_SHIFT;
1041 syndrome = cheetah_ecc_syntab[syndrome];
1042 ret = chmc_getunumber(syndrome, afar, unum, sizeof(unum));
1043 if (ret != -1)
1044 printk("%s" "ERROR(%d): AFAR E-syndrome [%s]\n",
1045 (recoverable ? KERN_WARNING : KERN_CRIT),
1046 smp_processor_id(), unum);
1047 } else if (afsr & MSYND_ERRORS) {
1048 int syndrome;
1049 int ret;
1050
1051 syndrome = (afsr & CHAFSR_M_SYNDROME) >> CHAFSR_M_SYNDROME_SHIFT;
1052 syndrome = cheetah_mtag_syntab[syndrome];
1053 ret = chmc_getunumber(syndrome, afar, unum, sizeof(unum));
1054 if (ret != -1)
1055 printk("%s" "ERROR(%d): AFAR M-syndrome [%s]\n",
1056 (recoverable ? KERN_WARNING : KERN_CRIT),
1057 smp_processor_id(), unum);
1058 }
1059
1060 /* Now dump the cache snapshots. */
1061 printk("%s" "ERROR(%d): D-cache idx[%x] tag[%016lx] utag[%016lx] stag[%016lx]\n",
1062 (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
1063 (int) info->dcache_index,
1064 info->dcache_tag,
1065 info->dcache_utag,
1066 info->dcache_stag);
1067 printk("%s" "ERROR(%d): D-cache data0[%016lx] data1[%016lx] data2[%016lx] data3[%016lx]\n",
1068 (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
1069 info->dcache_data[0],
1070 info->dcache_data[1],
1071 info->dcache_data[2],
1072 info->dcache_data[3]);
1073 printk("%s" "ERROR(%d): I-cache idx[%x] tag[%016lx] utag[%016lx] stag[%016lx] "
1074 "u[%016lx] l[%016lx]\n",
1075 (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
1076 (int) info->icache_index,
1077 info->icache_tag,
1078 info->icache_utag,
1079 info->icache_stag,
1080 info->icache_upper,
1081 info->icache_lower);
1082 printk("%s" "ERROR(%d): I-cache INSN0[%016lx] INSN1[%016lx] INSN2[%016lx] INSN3[%016lx]\n",
1083 (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
1084 info->icache_data[0],
1085 info->icache_data[1],
1086 info->icache_data[2],
1087 info->icache_data[3]);
1088 printk("%s" "ERROR(%d): I-cache INSN4[%016lx] INSN5[%016lx] INSN6[%016lx] INSN7[%016lx]\n",
1089 (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
1090 info->icache_data[4],
1091 info->icache_data[5],
1092 info->icache_data[6],
1093 info->icache_data[7]);
1094 printk("%s" "ERROR(%d): E-cache idx[%x] tag[%016lx]\n",
1095 (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
1096 (int) info->ecache_index, info->ecache_tag);
1097 printk("%s" "ERROR(%d): E-cache data0[%016lx] data1[%016lx] data2[%016lx] data3[%016lx]\n",
1098 (recoverable ? KERN_WARNING : KERN_CRIT), smp_processor_id(),
1099 info->ecache_data[0],
1100 info->ecache_data[1],
1101 info->ecache_data[2],
1102 info->ecache_data[3]);
1103
1104 afsr = (afsr & ~hipri) & cheetah_afsr_errors;
1105 while (afsr != 0UL) {
1106 unsigned long bit = cheetah_get_hipri(afsr);
1107
1108 printk("%s" "ERROR: Multiple-error (%016lx) \"%s\"\n",
1109 (recoverable ? KERN_WARNING : KERN_CRIT),
1110 bit, cheetah_get_string(bit));
1111
1112 afsr &= ~bit;
1113 }
1114
1115 if (!recoverable)
1116 printk(KERN_CRIT "ERROR: This condition is not recoverable.\n");
1117 }
1118
1119 static int cheetah_recheck_errors(struct cheetah_err_info *logp)
1120 {
1121 unsigned long afsr, afar;
1122 int ret = 0;
1123
1124 __asm__ __volatile__("ldxa [%%g0] %1, %0\n\t"
1125 : "=r" (afsr)
1126 : "i" (ASI_AFSR));
1127 if ((afsr & cheetah_afsr_errors) != 0) {
1128 if (logp != NULL) {
1129 __asm__ __volatile__("ldxa [%%g0] %1, %0\n\t"
1130 : "=r" (afar)
1131 : "i" (ASI_AFAR));
1132 logp->afsr = afsr;
1133 logp->afar = afar;
1134 }
1135 ret = 1;
1136 }
1137 __asm__ __volatile__("stxa %0, [%%g0] %1\n\t"
1138 "membar #Sync\n\t"
1139 : : "r" (afsr), "i" (ASI_AFSR));
1140
1141 return ret;
1142 }
1143
1144 void cheetah_fecc_handler(struct pt_regs *regs, unsigned long afsr, unsigned long afar)
1145 {
1146 struct cheetah_err_info local_snapshot, *p;
1147 int recoverable;
1148
1149 /* Flush E-cache */
1150 cheetah_flush_ecache();
1151
1152 p = cheetah_get_error_log(afsr);
1153 if (!p) {
1154 prom_printf("ERROR: Early Fast-ECC error afsr[%016lx] afar[%016lx]\n",
1155 afsr, afar);
1156 prom_printf("ERROR: CPU(%d) TPC[%016lx] TNPC[%016lx] TSTATE[%016lx]\n",
1157 smp_processor_id(), regs->tpc, regs->tnpc, regs->tstate);
1158 prom_halt();
1159 }
1160
1161 /* Grab snapshot of logged error. */
1162 memcpy(&local_snapshot, p, sizeof(local_snapshot));
1163
1164 /* If the current trap snapshot does not match what the
1165 * trap handler passed along into our args, big trouble.
1166 * In such a case, mark the local copy as invalid.
1167 *
1168 * Else, it matches and we mark the afsr in the non-local
1169 * copy as invalid so we may log new error traps there.
1170 */
1171 if (p->afsr != afsr || p->afar != afar)
1172 local_snapshot.afsr = CHAFSR_INVALID;
1173 else
1174 p->afsr = CHAFSR_INVALID;
1175
1176 cheetah_flush_icache();
1177 cheetah_flush_dcache();
1178
1179 /* Re-enable I-cache/D-cache */
1180 __asm__ __volatile__("ldxa [%%g0] %0, %%g1\n\t"
1181 "or %%g1, %1, %%g1\n\t"
1182 "stxa %%g1, [%%g0] %0\n\t"
1183 "membar #Sync"
1184 : /* no outputs */
1185 : "i" (ASI_DCU_CONTROL_REG),
1186 "i" (DCU_DC | DCU_IC)
1187 : "g1");
1188
1189 /* Re-enable error reporting */
1190 __asm__ __volatile__("ldxa [%%g0] %0, %%g1\n\t"
1191 "or %%g1, %1, %%g1\n\t"
1192 "stxa %%g1, [%%g0] %0\n\t"
1193 "membar #Sync"
1194 : /* no outputs */
1195 : "i" (ASI_ESTATE_ERROR_EN),
1196 "i" (ESTATE_ERROR_NCEEN | ESTATE_ERROR_CEEN)
1197 : "g1");
1198
1199 /* Decide if we can continue after handling this trap and
1200 * logging the error.
1201 */
1202 recoverable = 1;
1203 if (afsr & (CHAFSR_PERR | CHAFSR_IERR | CHAFSR_ISAP))
1204 recoverable = 0;
1205
1206 /* Re-check AFSR/AFAR. What we are looking for here is whether a new
1207 * error was logged while we had error reporting traps disabled.
1208 */
1209 if (cheetah_recheck_errors(&local_snapshot)) {
1210 unsigned long new_afsr = local_snapshot.afsr;
1211
1212 /* If we got a new asynchronous error, die... */
1213 if (new_afsr & (CHAFSR_EMU | CHAFSR_EDU |
1214 CHAFSR_WDU | CHAFSR_CPU |
1215 CHAFSR_IVU | CHAFSR_UE |
1216 CHAFSR_BERR | CHAFSR_TO))
1217 recoverable = 0;
1218 }
1219
1220 /* Log errors. */
1221 cheetah_log_errors(regs, &local_snapshot, afsr, afar, recoverable);
1222
1223 if (!recoverable)
1224 panic("Irrecoverable Fast-ECC error trap.\n");
1225
1226 /* Flush E-cache to kick the error trap handlers out. */
1227 cheetah_flush_ecache();
1228 }
1229
1230 /* Try to fix a correctable error by pushing the line out from
1231 * the E-cache. Recheck error reporting registers to see if the
1232 * problem is intermittent.
1233 */
1234 static int cheetah_fix_ce(unsigned long physaddr)
1235 {
1236 unsigned long orig_estate;
1237 unsigned long alias1, alias2;
1238 int ret;
1239
1240 /* Make sure correctable error traps are disabled. */
1241 __asm__ __volatile__("ldxa [%%g0] %2, %0\n\t"
1242 "andn %0, %1, %%g1\n\t"
1243 "stxa %%g1, [%%g0] %2\n\t"
1244 "membar #Sync"
1245 : "=&r" (orig_estate)
1246 : "i" (ESTATE_ERROR_CEEN),
1247 "i" (ASI_ESTATE_ERROR_EN)
1248 : "g1");
1249
1250 /* We calculate alias addresses that will force the
1251 * cache line in question out of the E-cache. Then
1252 * we bring it back in with an atomic instruction so
1253 * that we get it in some modified/exclusive state,
1254 * then we displace it again to try and get proper ECC
1255 * pushed back into the system.
1256 */
1257 physaddr &= ~(8UL - 1UL);
1258 alias1 = (ecache_flush_physbase +
1259 (physaddr & ((ecache_flush_size >> 1) - 1)));
1260 alias2 = alias1 + (ecache_flush_size >> 1);
1261 __asm__ __volatile__("ldxa [%0] %3, %%g0\n\t"
1262 "ldxa [%1] %3, %%g0\n\t"
1263 "casxa [%2] %3, %%g0, %%g0\n\t"
1264 "membar #StoreLoad | #StoreStore\n\t"
1265 "ldxa [%0] %3, %%g0\n\t"
1266 "ldxa [%1] %3, %%g0\n\t"
1267 "membar #Sync"
1268 : /* no outputs */
1269 : "r" (alias1), "r" (alias2),
1270 "r" (physaddr), "i" (ASI_PHYS_USE_EC));
1271
1272 /* Did that trigger another error? */
1273 if (cheetah_recheck_errors(NULL)) {
1274 /* Try one more time. */
1275 __asm__ __volatile__("ldxa [%0] %1, %%g0\n\t"
1276 "membar #Sync"
1277 : : "r" (physaddr), "i" (ASI_PHYS_USE_EC));
1278 if (cheetah_recheck_errors(NULL))
1279 ret = 2;
1280 else
1281 ret = 1;
1282 } else {
1283 /* No new error, intermittent problem. */
1284 ret = 0;
1285 }
1286
1287 /* Restore error enables. */
1288 __asm__ __volatile__("stxa %0, [%%g0] %1\n\t"
1289 "membar #Sync"
1290 : : "r" (orig_estate), "i" (ASI_ESTATE_ERROR_EN));
1291
1292 return ret;
1293 }
1294
1295 /* Return non-zero if PADDR is a valid physical memory address. */
1296 static int cheetah_check_main_memory(unsigned long paddr)
1297 {
1298 int i;
1299
1300 for (i = 0; ; i++) {
1301 if (sp_banks[i].num_bytes == 0)
1302 break;
1303 if (paddr >= sp_banks[i].base_addr &&
1304 paddr < (sp_banks[i].base_addr + sp_banks[i].num_bytes))
1305 return 1;
1306 }
1307 return 0;
1308 }
1309
1310 void cheetah_cee_handler(struct pt_regs *regs, unsigned long afsr, unsigned long afar)
1311 {
1312 struct cheetah_err_info local_snapshot, *p;
1313 int recoverable, is_memory;
1314
1315 p = cheetah_get_error_log(afsr);
1316 if (!p) {
1317 prom_printf("ERROR: Early CEE error afsr[%016lx] afar[%016lx]\n",
1318 afsr, afar);
1319 prom_printf("ERROR: CPU(%d) TPC[%016lx] TNPC[%016lx] TSTATE[%016lx]\n",
1320 smp_processor_id(), regs->tpc, regs->tnpc, regs->tstate);
1321 prom_halt();
1322 }
1323
1324 /* Grab snapshot of logged error. */
1325 memcpy(&local_snapshot, p, sizeof(local_snapshot));
1326
1327 /* If the current trap snapshot does not match what the
1328 * trap handler passed along into our args, big trouble.
1329 * In such a case, mark the local copy as invalid.
1330 *
1331 * Else, it matches and we mark the afsr in the non-local
1332 * copy as invalid so we may log new error traps there.
1333 */
1334 if (p->afsr != afsr || p->afar != afar)
1335 local_snapshot.afsr = CHAFSR_INVALID;
1336 else
1337 p->afsr = CHAFSR_INVALID;
1338
1339 is_memory = cheetah_check_main_memory(afar);
1340
1341 if (is_memory && (afsr & CHAFSR_CE) != 0UL) {
1342 /* XXX Might want to log the results of this operation
1343 * XXX somewhere... -DaveM
1344 */
1345 cheetah_fix_ce(afar);
1346 }
1347
1348 {
1349 int flush_all, flush_line;
1350
1351 flush_all = flush_line = 0;
1352 if ((afsr & CHAFSR_EDC) != 0UL) {
1353 if ((afsr & cheetah_afsr_errors) == CHAFSR_EDC)
1354 flush_line = 1;
1355 else
1356 flush_all = 1;
1357 } else if ((afsr & CHAFSR_CPC) != 0UL) {
1358 if ((afsr & cheetah_afsr_errors) == CHAFSR_CPC)
1359 flush_line = 1;
1360 else
1361 flush_all = 1;
1362 }
1363
1364 /* Trap handler only disabled I-cache, flush it. */
1365 cheetah_flush_icache();
1366
1367 /* Re-enable I-cache */
1368 __asm__ __volatile__("ldxa [%%g0] %0, %%g1\n\t"
1369 "or %%g1, %1, %%g1\n\t"
1370 "stxa %%g1, [%%g0] %0\n\t"
1371 "membar #Sync"
1372 : /* no outputs */
1373 : "i" (ASI_DCU_CONTROL_REG),
1374 "i" (DCU_IC)
1375 : "g1");
1376
1377 if (flush_all)
1378 cheetah_flush_ecache();
1379 else if (flush_line)
1380 cheetah_flush_ecache_line(afar);
1381 }
1382
1383 /* Re-enable error reporting */
1384 __asm__ __volatile__("ldxa [%%g0] %0, %%g1\n\t"
1385 "or %%g1, %1, %%g1\n\t"
1386 "stxa %%g1, [%%g0] %0\n\t"
1387 "membar #Sync"
1388 : /* no outputs */
1389 : "i" (ASI_ESTATE_ERROR_EN),
1390 "i" (ESTATE_ERROR_CEEN)
1391 : "g1");
1392
1393 /* Decide if we can continue after handling this trap and
1394 * logging the error.
1395 */
1396 recoverable = 1;
1397 if (afsr & (CHAFSR_PERR | CHAFSR_IERR | CHAFSR_ISAP))
1398 recoverable = 0;
1399
1400 /* Re-check AFSR/AFAR */
1401 (void) cheetah_recheck_errors(&local_snapshot);
1402
1403 /* Log errors. */
1404 cheetah_log_errors(regs, &local_snapshot, afsr, afar, recoverable);
1405
1406 if (!recoverable)
1407 panic("Irrecoverable Correctable-ECC error trap.\n");
1408 }
1409
1410 void cheetah_deferred_handler(struct pt_regs *regs, unsigned long afsr, unsigned long afar)
1411 {
1412 struct cheetah_err_info local_snapshot, *p;
1413 int recoverable, is_memory;
1414
1415 #ifdef CONFIG_PCI
1416 /* Check for the special PCI poke sequence. */
1417 if (pci_poke_in_progress && pci_poke_cpu == smp_processor_id()) {
1418 cheetah_flush_icache();
1419 cheetah_flush_dcache();
1420
1421 /* Re-enable I-cache/D-cache */
1422 __asm__ __volatile__("ldxa [%%g0] %0, %%g1\n\t"
1423 "or %%g1, %1, %%g1\n\t"
1424 "stxa %%g1, [%%g0] %0\n\t"
1425 "membar #Sync"
1426 : /* no outputs */
1427 : "i" (ASI_DCU_CONTROL_REG),
1428 "i" (DCU_DC | DCU_IC)
1429 : "g1");
1430
1431 /* Re-enable error reporting */
1432 __asm__ __volatile__("ldxa [%%g0] %0, %%g1\n\t"
1433 "or %%g1, %1, %%g1\n\t"
1434 "stxa %%g1, [%%g0] %0\n\t"
1435 "membar #Sync"
1436 : /* no outputs */
1437 : "i" (ASI_ESTATE_ERROR_EN),
1438 "i" (ESTATE_ERROR_NCEEN | ESTATE_ERROR_CEEN)
1439 : "g1");
1440
1441 (void) cheetah_recheck_errors(NULL);
1442
1443 pci_poke_faulted = 1;
1444 regs->tpc += 4;
1445 regs->tnpc = regs->tpc + 4;
1446 return;
1447 }
1448 #endif
1449
1450 p = cheetah_get_error_log(afsr);
1451 if (!p) {
1452 prom_printf("ERROR: Early deferred error afsr[%016lx] afar[%016lx]\n",
1453 afsr, afar);
1454 prom_printf("ERROR: CPU(%d) TPC[%016lx] TNPC[%016lx] TSTATE[%016lx]\n",
1455 smp_processor_id(), regs->tpc, regs->tnpc, regs->tstate);
1456 prom_halt();
1457 }
1458
1459 /* Grab snapshot of logged error. */
1460 memcpy(&local_snapshot, p, sizeof(local_snapshot));
1461
1462 /* If the current trap snapshot does not match what the
1463 * trap handler passed along into our args, big trouble.
1464 * In such a case, mark the local copy as invalid.
1465 *
1466 * Else, it matches and we mark the afsr in the non-local
1467 * copy as invalid so we may log new error traps there.
1468 */
1469 if (p->afsr != afsr || p->afar != afar)
1470 local_snapshot.afsr = CHAFSR_INVALID;
1471 else
1472 p->afsr = CHAFSR_INVALID;
1473
1474 is_memory = cheetah_check_main_memory(afar);
1475
1476 {
1477 int flush_all, flush_line;
1478
1479 flush_all = flush_line = 0;
1480 if ((afsr & CHAFSR_EDU) != 0UL) {
1481 if ((afsr & cheetah_afsr_errors) == CHAFSR_EDU)
1482 flush_line = 1;
1483 else
1484 flush_all = 1;
1485 } else if ((afsr & CHAFSR_BERR) != 0UL) {
1486 if ((afsr & cheetah_afsr_errors) == CHAFSR_BERR)
1487 flush_line = 1;
1488 else
1489 flush_all = 1;
1490 }
1491
1492 cheetah_flush_icache();
1493 cheetah_flush_dcache();
1494
1495 /* Re-enable I/D caches */
1496 __asm__ __volatile__("ldxa [%%g0] %0, %%g1\n\t"
1497 "or %%g1, %1, %%g1\n\t"
1498 "stxa %%g1, [%%g0] %0\n\t"
1499 "membar #Sync"
1500 : /* no outputs */
1501 : "i" (ASI_DCU_CONTROL_REG),
1502 "i" (DCU_IC | DCU_DC)
1503 : "g1");
1504
1505 if (flush_all)
1506 cheetah_flush_ecache();
1507 else if (flush_line)
1508 cheetah_flush_ecache_line(afar);
1509 }
1510
1511 /* Re-enable error reporting */
1512 __asm__ __volatile__("ldxa [%%g0] %0, %%g1\n\t"
1513 "or %%g1, %1, %%g1\n\t"
1514 "stxa %%g1, [%%g0] %0\n\t"
1515 "membar #Sync"
1516 : /* no outputs */
1517 : "i" (ASI_ESTATE_ERROR_EN),
1518 "i" (ESTATE_ERROR_NCEEN | ESTATE_ERROR_CEEN)
1519 : "g1");
1520
1521 /* Decide if we can continue after handling this trap and
1522 * logging the error.
1523 */
1524 recoverable = 1;
1525 if (afsr & (CHAFSR_PERR | CHAFSR_IERR | CHAFSR_ISAP))
1526 recoverable = 0;
1527
1528 /* Re-check AFSR/AFAR. What we are looking for here is whether a new
1529 * error was logged while we had error reporting traps disabled.
1530 */
1531 if (cheetah_recheck_errors(&local_snapshot)) {
1532 unsigned long new_afsr = local_snapshot.afsr;
1533
1534 /* If we got a new asynchronous error, die... */
1535 if (new_afsr & (CHAFSR_EMU | CHAFSR_EDU |
1536 CHAFSR_WDU | CHAFSR_CPU |
1537 CHAFSR_IVU | CHAFSR_UE |
1538 CHAFSR_BERR | CHAFSR_TO))
1539 recoverable = 0;
1540 }
1541
1542 /* Log errors. */
1543 cheetah_log_errors(regs, &local_snapshot, afsr, afar, recoverable);
1544
1545 /* "Recoverable" here means we try to yank the page from ever
1546 * being newly used again. This depends upon a few things:
1547 * 1) Must be main memory, and AFAR must be valid.
1548 * 2) If we trapped from user, OK.
1549 * 3) Else, if we trapped from kernel we must find exception
1550 * table entry (ie. we have to have been accessing user
1551 * space).
1552 *
1553 * If AFAR is not in main memory, or we trapped from kernel
1554 * and cannot find an exception table entry, it is unacceptable
1555 * to try and continue.
1556 */
1557 if (recoverable && is_memory) {
1558 if ((regs->tstate & TSTATE_PRIV) == 0UL) {
1559 /* OK, usermode access. */
1560 recoverable = 1;
1561 } else {
1562 unsigned long g2 = regs->u_regs[UREG_G2];
1563 unsigned long fixup = search_extables_range(regs->tpc, &g2);
1564
1565 if (fixup != 0UL) {
1566 /* OK, kernel access to userspace. */
1567 recoverable = 1;
1568
1569 } else {
1570 /* BAD, privileged state is corrupted. */
1571 recoverable = 0;
1572 }
1573
1574 if (recoverable) {
1575 if (pfn_valid(afar >> PAGE_SHIFT))
1576 get_page(pfn_to_page(afar >> PAGE_SHIFT));
1577 else
1578 recoverable = 0;
1579
1580 /* Only perform fixup if we still have a
1581 * recoverable condition.
1582 */
1583 if (recoverable) {
1584 regs->tpc = fixup;
1585 regs->tnpc = regs->tpc + 4;
1586 regs->u_regs[UREG_G2] = g2;
1587 }
1588 }
1589 }
1590 } else {
1591 recoverable = 0;
1592 }
1593
1594 if (!recoverable)
1595 panic("Irrecoverable deferred error trap.\n");
1596 }
1597
1598 /* Handle a D/I cache parity error trap. TYPE is encoded as:
1599 *
1600 * Bit0: 0=dcache,1=icache
1601 * Bit1: 0=recoverable,1=unrecoverable
1602 *
1603 * The hardware has disabled both the I-cache and D-cache in
1604 * the %dcr register.
1605 */
1606 void cheetah_plus_parity_error(int type, struct pt_regs *regs)
1607 {
1608 if (type & 0x1)
1609 __cheetah_flush_icache();
1610 else
1611 cheetah_plus_zap_dcache_parity();
1612 cheetah_flush_dcache();
1613
1614 /* Re-enable I-cache/D-cache */
1615 __asm__ __volatile__("ldxa [%%g0] %0, %%g1\n\t"
1616 "or %%g1, %1, %%g1\n\t"
1617 "stxa %%g1, [%%g0] %0\n\t"
1618 "membar #Sync"
1619 : /* no outputs */
1620 : "i" (ASI_DCU_CONTROL_REG),
1621 "i" (DCU_DC | DCU_IC)
1622 : "g1");
1623
1624 if (type & 0x2) {
1625 printk(KERN_EMERG "CPU[%d]: Cheetah+ %c-cache parity error at TPC[%016lx]\n",
1626 smp_processor_id(),
1627 (type & 0x1) ? 'I' : 'D',
1628 regs->tpc);
1629 panic("Irrecoverable Cheetah+ parity error.");
1630 }
1631
1632 printk(KERN_WARNING "CPU[%d]: Cheetah+ %c-cache parity error at TPC[%016lx]\n",
1633 smp_processor_id(),
1634 (type & 0x1) ? 'I' : 'D',
1635 regs->tpc);
1636 }
1637
1638 void do_fpe_common(struct pt_regs *regs)
1639 {
1640 if (regs->tstate & TSTATE_PRIV) {
1641 regs->tpc = regs->tnpc;
1642 regs->tnpc += 4;
1643 } else {
1644 unsigned long fsr = current_thread_info()->xfsr[0];
1645 siginfo_t info;
1646
1647 if (test_thread_flag(TIF_32BIT)) {
1648 regs->tpc &= 0xffffffff;
1649 regs->tnpc &= 0xffffffff;
1650 }
1651 info.si_signo = SIGFPE;
1652 info.si_errno = 0;
1653 info.si_addr = (void __user *)regs->tpc;
1654 info.si_trapno = 0;
1655 info.si_code = __SI_FAULT;
1656 if ((fsr & 0x1c000) == (1 << 14)) {
1657 if (fsr & 0x10)
1658 info.si_code = FPE_FLTINV;
1659 else if (fsr & 0x08)
1660 info.si_code = FPE_FLTOVF;
1661 else if (fsr & 0x04)
1662 info.si_code = FPE_FLTUND;
1663 else if (fsr & 0x02)
1664 info.si_code = FPE_FLTDIV;
1665 else if (fsr & 0x01)
1666 info.si_code = FPE_FLTRES;
1667 }
1668 force_sig_info(SIGFPE, &info, current);
1669 }
1670 }
1671
1672 void do_fpieee(struct pt_regs *regs)
1673 {
1674 if (notify_die(DIE_TRAP, "fpu exception ieee", regs,
1675 0, 0x24, SIGFPE) == NOTIFY_STOP)
1676 return;
1677
1678 do_fpe_common(regs);
1679 }
1680
1681 extern int do_mathemu(struct pt_regs *, struct fpustate *);
1682
1683 void do_fpother(struct pt_regs *regs)
1684 {
1685 struct fpustate *f = FPUSTATE;
1686 int ret = 0;
1687
1688 if (notify_die(DIE_TRAP, "fpu exception other", regs,
1689 0, 0x25, SIGFPE) == NOTIFY_STOP)
1690 return;
1691
1692 switch ((current_thread_info()->xfsr[0] & 0x1c000)) {
1693 case (2 << 14): /* unfinished_FPop */
1694 case (3 << 14): /* unimplemented_FPop */
1695 ret = do_mathemu(regs, f);
1696 break;
1697 }
1698 if (ret)
1699 return;
1700 do_fpe_common(regs);
1701 }
1702
1703 void do_tof(struct pt_regs *regs)
1704 {
1705 siginfo_t info;
1706
1707 if (notify_die(DIE_TRAP, "tagged arithmetic overflow", regs,
1708 0, 0x26, SIGEMT) == NOTIFY_STOP)
1709 return;
1710
1711 if (regs->tstate & TSTATE_PRIV)
1712 die_if_kernel("Penguin overflow trap from kernel mode", regs);
1713 if (test_thread_flag(TIF_32BIT)) {
1714 regs->tpc &= 0xffffffff;
1715 regs->tnpc &= 0xffffffff;
1716 }
1717 info.si_signo = SIGEMT;
1718 info.si_errno = 0;
1719 info.si_code = EMT_TAGOVF;
1720 info.si_addr = (void __user *)regs->tpc;
1721 info.si_trapno = 0;
1722 force_sig_info(SIGEMT, &info, current);
1723 }
1724
1725 void do_div0(struct pt_regs *regs)
1726 {
1727 siginfo_t info;
1728
1729 if (notify_die(DIE_TRAP, "integer division by zero", regs,
1730 0, 0x28, SIGFPE) == NOTIFY_STOP)
1731 return;
1732
1733 if (regs->tstate & TSTATE_PRIV)
1734 die_if_kernel("TL0: Kernel divide by zero.", regs);
1735 if (test_thread_flag(TIF_32BIT)) {
1736 regs->tpc &= 0xffffffff;
1737 regs->tnpc &= 0xffffffff;
1738 }
1739 info.si_signo = SIGFPE;
1740 info.si_errno = 0;
1741 info.si_code = FPE_INTDIV;
1742 info.si_addr = (void __user *)regs->tpc;
1743 info.si_trapno = 0;
1744 force_sig_info(SIGFPE, &info, current);
1745 }
1746
1747 void instruction_dump (unsigned int *pc)
1748 {
1749 int i;
1750
1751 if ((((unsigned long) pc) & 3))
1752 return;
1753
1754 printk("Instruction DUMP:");
1755 for (i = -3; i < 6; i++)
1756 printk("%c%08x%c",i?' ':'<',pc[i],i?' ':'>');
1757 printk("\n");
1758 }
1759
1760 static void user_instruction_dump (unsigned int __user *pc)
1761 {
1762 int i;
1763 unsigned int buf[9];
1764
1765 if ((((unsigned long) pc) & 3))
1766 return;
1767
1768 if (copy_from_user(buf, pc - 3, sizeof(buf)))
1769 return;
1770
1771 printk("Instruction DUMP:");
1772 for (i = 0; i < 9; i++)
1773 printk("%c%08x%c",i==3?' ':'<',buf[i],i==3?' ':'>');
1774 printk("\n");
1775 }
1776
1777 void show_stack(struct task_struct *tsk, unsigned long *_ksp)
1778 {
1779 unsigned long pc, fp, thread_base, ksp;
1780 struct thread_info *tp = tsk->thread_info;
1781 struct reg_window *rw;
1782 int count = 0;
1783
1784 ksp = (unsigned long) _ksp;
1785
1786 if (tp == current_thread_info())
1787 flushw_all();
1788
1789 fp = ksp + STACK_BIAS;
1790 thread_base = (unsigned long) tp;
1791
1792 printk("Call Trace:");
1793 #ifdef CONFIG_KALLSYMS
1794 printk("\n");
1795 #endif
1796 do {
1797 /* Bogus frame pointer? */
1798 if (fp < (thread_base + sizeof(struct thread_info)) ||
1799 fp >= (thread_base + THREAD_SIZE))
1800 break;
1801 rw = (struct reg_window *)fp;
1802 pc = rw->ins[7];
1803 printk(" [%016lx] ", pc);
1804 print_symbol("%s\n", pc);
1805 fp = rw->ins[6] + STACK_BIAS;
1806 } while (++count < 16);
1807 #ifndef CONFIG_KALLSYMS
1808 printk("\n");
1809 #endif
1810 }
1811
1812 void dump_stack(void)
1813 {
1814 unsigned long *ksp;
1815
1816 __asm__ __volatile__("mov %%fp, %0"
1817 : "=r" (ksp));
1818 show_stack(current, ksp);
1819 }
1820
1821 EXPORT_SYMBOL(dump_stack);
1822
1823 static inline int is_kernel_stack(struct task_struct *task,
1824 struct reg_window *rw)
1825 {
1826 unsigned long rw_addr = (unsigned long) rw;
1827 unsigned long thread_base, thread_end;
1828
1829 if (rw_addr < PAGE_OFFSET) {
1830 if (task != &init_task)
1831 return 0;
1832 }
1833
1834 thread_base = (unsigned long) task->thread_info;
1835 thread_end = thread_base + sizeof(union thread_union);
1836 if (rw_addr >= thread_base &&
1837 rw_addr < thread_end &&
1838 !(rw_addr & 0x7UL))
1839 return 1;
1840
1841 return 0;
1842 }
1843
1844 static inline struct reg_window *kernel_stack_up(struct reg_window *rw)
1845 {
1846 unsigned long fp = rw->ins[6];
1847
1848 if (!fp)
1849 return NULL;
1850
1851 return (struct reg_window *) (fp + STACK_BIAS);
1852 }
1853
1854 void die_if_kernel(char *str, struct pt_regs *regs)
1855 {
1856 static int die_counter;
1857 extern void __show_regs(struct pt_regs * regs);
1858 extern void smp_report_regs(void);
1859 int count = 0;
1860
1861 /* Amuse the user. */
1862 printk(
1863 " \\|/ ____ \\|/\n"
1864 " \"@'/ .. \\`@\"\n"
1865 " /_| \\__/ |_\\\n"
1866 " \\__U_/\n");
1867
1868 printk("%s(%d): %s [#%d]\n", current->comm, current->pid, str, ++die_counter);
1869 notify_die(DIE_OOPS, str, regs, 0, 255, SIGSEGV);
1870 __asm__ __volatile__("flushw");
1871 __show_regs(regs);
1872 if (regs->tstate & TSTATE_PRIV) {
1873 struct reg_window *rw = (struct reg_window *)
1874 (regs->u_regs[UREG_FP] + STACK_BIAS);
1875
1876 /* Stop the back trace when we hit userland or we
1877 * find some badly aligned kernel stack.
1878 */
1879 while (rw &&
1880 count++ < 30&&
1881 is_kernel_stack(current, rw)) {
1882 printk("Caller[%016lx]", rw->ins[7]);
1883 print_symbol(": %s", rw->ins[7]);
1884 printk("\n");
1885
1886 rw = kernel_stack_up(rw);
1887 }
1888 instruction_dump ((unsigned int *) regs->tpc);
1889 } else {
1890 if (test_thread_flag(TIF_32BIT)) {
1891 regs->tpc &= 0xffffffff;
1892 regs->tnpc &= 0xffffffff;
1893 }
1894 user_instruction_dump ((unsigned int __user *) regs->tpc);
1895 }
1896 #ifdef CONFIG_SMP
1897 smp_report_regs();
1898 #endif
1899
1900 if (regs->tstate & TSTATE_PRIV)
1901 do_exit(SIGKILL);
1902 do_exit(SIGSEGV);
1903 }
1904
1905 extern int handle_popc(u32 insn, struct pt_regs *regs);
1906 extern int handle_ldf_stq(u32 insn, struct pt_regs *regs);
1907
1908 void do_illegal_instruction(struct pt_regs *regs)
1909 {
1910 unsigned long pc = regs->tpc;
1911 unsigned long tstate = regs->tstate;
1912 u32 insn;
1913 siginfo_t info;
1914
1915 if (notify_die(DIE_TRAP, "illegal instruction", regs,
1916 0, 0x10, SIGILL) == NOTIFY_STOP)
1917 return;
1918
1919 if (tstate & TSTATE_PRIV)
1920 die_if_kernel("Kernel illegal instruction", regs);
1921 if (test_thread_flag(TIF_32BIT))
1922 pc = (u32)pc;
1923 if (get_user(insn, (u32 __user *) pc) != -EFAULT) {
1924 if ((insn & 0xc1ffc000) == 0x81700000) /* POPC */ {
1925 if (handle_popc(insn, regs))
1926 return;
1927 } else if ((insn & 0xc1580000) == 0xc1100000) /* LDQ/STQ */ {
1928 if (handle_ldf_stq(insn, regs))
1929 return;
1930 }
1931 }
1932 info.si_signo = SIGILL;
1933 info.si_errno = 0;
1934 info.si_code = ILL_ILLOPC;
1935 info.si_addr = (void __user *)pc;
1936 info.si_trapno = 0;
1937 force_sig_info(SIGILL, &info, current);
1938 }
1939
1940 void mem_address_unaligned(struct pt_regs *regs, unsigned long sfar, unsigned long sfsr)
1941 {
1942 siginfo_t info;
1943
1944 if (notify_die(DIE_TRAP, "memory address unaligned", regs,
1945 0, 0x34, SIGSEGV) == NOTIFY_STOP)
1946 return;
1947
1948 if (regs->tstate & TSTATE_PRIV) {
1949 extern void kernel_unaligned_trap(struct pt_regs *regs,
1950 unsigned int insn,
1951 unsigned long sfar,
1952 unsigned long sfsr);
1953
1954 kernel_unaligned_trap(regs, *((unsigned int *)regs->tpc),
1955 sfar, sfsr);
1956 return;
1957 }
1958 info.si_signo = SIGBUS;
1959 info.si_errno = 0;
1960 info.si_code = BUS_ADRALN;
1961 info.si_addr = (void __user *)sfar;
1962 info.si_trapno = 0;
1963 force_sig_info(SIGBUS, &info, current);
1964 }
1965
1966 void do_privop(struct pt_regs *regs)
1967 {
1968 siginfo_t info;
1969
1970 if (notify_die(DIE_TRAP, "privileged operation", regs,
1971 0, 0x11, SIGILL) == NOTIFY_STOP)
1972 return;
1973
1974 if (test_thread_flag(TIF_32BIT)) {
1975 regs->tpc &= 0xffffffff;
1976 regs->tnpc &= 0xffffffff;
1977 }
1978 info.si_signo = SIGILL;
1979 info.si_errno = 0;
1980 info.si_code = ILL_PRVOPC;
1981 info.si_addr = (void __user *)regs->tpc;
1982 info.si_trapno = 0;
1983 force_sig_info(SIGILL, &info, current);
1984 }
1985
1986 void do_privact(struct pt_regs *regs)
1987 {
1988 do_privop(regs);
1989 }
1990
1991 /* Trap level 1 stuff or other traps we should never see... */
1992 void do_cee(struct pt_regs *regs)
1993 {
1994 die_if_kernel("TL0: Cache Error Exception", regs);
1995 }
1996
1997 void do_cee_tl1(struct pt_regs *regs)
1998 {
1999 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2000 die_if_kernel("TL1: Cache Error Exception", regs);
2001 }
2002
2003 void do_dae_tl1(struct pt_regs *regs)
2004 {
2005 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2006 die_if_kernel("TL1: Data Access Exception", regs);
2007 }
2008
2009 void do_iae_tl1(struct pt_regs *regs)
2010 {
2011 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2012 die_if_kernel("TL1: Instruction Access Exception", regs);
2013 }
2014
2015 void do_div0_tl1(struct pt_regs *regs)
2016 {
2017 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2018 die_if_kernel("TL1: DIV0 Exception", regs);
2019 }
2020
2021 void do_fpdis_tl1(struct pt_regs *regs)
2022 {
2023 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2024 die_if_kernel("TL1: FPU Disabled", regs);
2025 }
2026
2027 void do_fpieee_tl1(struct pt_regs *regs)
2028 {
2029 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2030 die_if_kernel("TL1: FPU IEEE Exception", regs);
2031 }
2032
2033 void do_fpother_tl1(struct pt_regs *regs)
2034 {
2035 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2036 die_if_kernel("TL1: FPU Other Exception", regs);
2037 }
2038
2039 void do_ill_tl1(struct pt_regs *regs)
2040 {
2041 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2042 die_if_kernel("TL1: Illegal Instruction Exception", regs);
2043 }
2044
2045 void do_irq_tl1(struct pt_regs *regs)
2046 {
2047 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2048 die_if_kernel("TL1: IRQ Exception", regs);
2049 }
2050
2051 void do_lddfmna_tl1(struct pt_regs *regs)
2052 {
2053 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2054 die_if_kernel("TL1: LDDF Exception", regs);
2055 }
2056
2057 void do_stdfmna_tl1(struct pt_regs *regs)
2058 {
2059 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2060 die_if_kernel("TL1: STDF Exception", regs);
2061 }
2062
2063 void do_paw(struct pt_regs *regs)
2064 {
2065 die_if_kernel("TL0: Phys Watchpoint Exception", regs);
2066 }
2067
2068 void do_paw_tl1(struct pt_regs *regs)
2069 {
2070 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2071 die_if_kernel("TL1: Phys Watchpoint Exception", regs);
2072 }
2073
2074 void do_vaw(struct pt_regs *regs)
2075 {
2076 die_if_kernel("TL0: Virt Watchpoint Exception", regs);
2077 }
2078
2079 void do_vaw_tl1(struct pt_regs *regs)
2080 {
2081 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2082 die_if_kernel("TL1: Virt Watchpoint Exception", regs);
2083 }
2084
2085 void do_tof_tl1(struct pt_regs *regs)
2086 {
2087 dump_tl1_traplog((struct tl1_traplog *)(regs + 1));
2088 die_if_kernel("TL1: Tag Overflow Exception", regs);
2089 }
2090
2091 void do_getpsr(struct pt_regs *regs)
2092 {
2093 regs->u_regs[UREG_I0] = tstate_to_psr(regs->tstate);
2094 regs->tpc = regs->tnpc;
2095 regs->tnpc += 4;
2096 if (test_thread_flag(TIF_32BIT)) {
2097 regs->tpc &= 0xffffffff;
2098 regs->tnpc &= 0xffffffff;
2099 }
2100 }
2101
2102 extern void thread_info_offsets_are_bolixed_dave(void);
2103
2104 /* Only invoked on boot processor. */
2105 void __init trap_init(void)
2106 {
2107 /* Compile time sanity check. */
2108 if (TI_TASK != offsetof(struct thread_info, task) ||
2109 TI_FLAGS != offsetof(struct thread_info, flags) ||
2110 TI_CPU != offsetof(struct thread_info, cpu) ||
2111 TI_FPSAVED != offsetof(struct thread_info, fpsaved) ||
2112 TI_KSP != offsetof(struct thread_info, ksp) ||
2113 TI_FAULT_ADDR != offsetof(struct thread_info, fault_address) ||
2114 TI_KREGS != offsetof(struct thread_info, kregs) ||
2115 TI_UTRAPS != offsetof(struct thread_info, utraps) ||
2116 TI_EXEC_DOMAIN != offsetof(struct thread_info, exec_domain) ||
2117 TI_REG_WINDOW != offsetof(struct thread_info, reg_window) ||
2118 TI_RWIN_SPTRS != offsetof(struct thread_info, rwbuf_stkptrs) ||
2119 TI_GSR != offsetof(struct thread_info, gsr) ||
2120 TI_XFSR != offsetof(struct thread_info, xfsr) ||
2121 TI_USER_CNTD0 != offsetof(struct thread_info, user_cntd0) ||
2122 TI_USER_CNTD1 != offsetof(struct thread_info, user_cntd1) ||
2123 TI_KERN_CNTD0 != offsetof(struct thread_info, kernel_cntd0) ||
2124 TI_KERN_CNTD1 != offsetof(struct thread_info, kernel_cntd1) ||
2125 TI_PCR != offsetof(struct thread_info, pcr_reg) ||
2126 TI_CEE_STUFF != offsetof(struct thread_info, cee_stuff) ||
2127 TI_PRE_COUNT != offsetof(struct thread_info, preempt_count) ||
2128 TI_NEW_CHILD != offsetof(struct thread_info, new_child) ||
2129 TI_SYS_NOERROR != offsetof(struct thread_info, syscall_noerror) ||
2130 TI_RESTART_BLOCK != offsetof(struct thread_info, restart_block) ||
2131 TI_KUNA_REGS != offsetof(struct thread_info, kern_una_regs) ||
2132 TI_KUNA_INSN != offsetof(struct thread_info, kern_una_insn) ||
2133 TI_FPREGS != offsetof(struct thread_info, fpregs) ||
2134 (TI_FPREGS & (64 - 1)))
2135 thread_info_offsets_are_bolixed_dave();
2136
2137 /* Attach to the address space of init_task. On SMP we
2138 * do this in smp.c:smp_callin for other cpus.
2139 */
2140 atomic_inc(&init_mm.mm_count);
2141 current->active_mm = &init_mm;
2142 }
Linux kernel - Deliverables
This page took 0.099068 seconds and 5 git commands to generate.