git.oblomov.eu Git - linux-2.6/blob - arch/sparc64/kernel/traps.c

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