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