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