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