arch/powerpc/xmon/xmon.c

   1 /*
   2  * Routines providing a simple monitor for use on the PowerMac.
   3  *
   4  * Copyright (C) 1996-2005 Paul Mackerras.
   5  * Copyright (C) 2001 PPC64 Team, IBM Corp
   6  * Copyrignt (C) 2006 Michael Ellerman, IBM Corp
   7  *
   8  *      This program is free software; you can redistribute it and/or
   9  *      modify it under the terms of the GNU General Public License
  10  *      as published by the Free Software Foundation; either version
  11  *      2 of the License, or (at your option) any later version.
  12  */
  13 #include <linux/errno.h>
  14 #include <linux/sched.h>
  15 #include <linux/smp.h>
  16 #include <linux/mm.h>
  17 #include <linux/reboot.h>
  18 #include <linux/delay.h>
  19 #include <linux/kallsyms.h>
  20 #include <linux/kmsg_dump.h>
  21 #include <linux/cpumask.h>
  22 #include <linux/export.h>
  23 #include <linux/sysrq.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/irq.h>
  26 #include <linux/bug.h>
  27 #include <linux/nmi.h>
  28 #include <linux/ctype.h>
  29
  30 #include <asm/ptrace.h>
  31 #include <asm/string.h>
  32 #include <asm/prom.h>
  33 #include <asm/machdep.h>
  34 #include <asm/xmon.h>
  35 #include <asm/processor.h>
  36 #include <asm/pgtable.h>
  37 #include <asm/mmu.h>
  38 #include <asm/mmu_context.h>
  39 #include <asm/cputable.h>
  40 #include <asm/rtas.h>
  41 #include <asm/sstep.h>
  42 #include <asm/irq_regs.h>
  43 #include <asm/spu.h>
  44 #include <asm/spu_priv1.h>
  45 #include <asm/setjmp.h>
  46 #include <asm/reg.h>
  47 #include <asm/debug.h>
  48 #include <asm/hw_breakpoint.h>
  49
  50 #ifdef CONFIG_PPC64
  51 #include <asm/hvcall.h>
  52 #include <asm/paca.h>
  53 #endif
  54
  55 #if defined(CONFIG_PPC_SPLPAR)
  56 #include <asm/plpar_wrappers.h>
  57 #else
  58 static inline long plapr_set_ciabr(unsigned long ciabr) {return 0; };
  59 #endif
  60
  61 #include "nonstdio.h"
  62 #include "dis-asm.h"
  63
  64 #ifdef CONFIG_SMP
  65 static cpumask_t cpus_in_xmon = CPU_MASK_NONE;
  66 static unsigned long xmon_taken = 1;
  67 static int xmon_owner;
  68 static int xmon_gate;
  69 #else
  70 #define xmon_owner 0
  71 #endif /* CONFIG_SMP */
  72
  73 static unsigned long in_xmon __read_mostly = 0;
  74
  75 static unsigned long adrs;
  76 static int size = 1;
  77 #define MAX_DUMP (128 * 1024)
  78 static unsigned long ndump = 64;
  79 static unsigned long nidump = 16;
  80 static unsigned long ncsum = 4096;
  81 static int termch;
  82 static char tmpstr[128];
  83
  84 static long bus_error_jmp[JMP_BUF_LEN];
  85 static int catch_memory_errors;
  86 static long *xmon_fault_jmp[NR_CPUS];
  87
  88 /* Breakpoint stuff */
  89 struct bpt {
  90         unsigned long   address;
  91         unsigned int    instr[2];
  92         atomic_t        ref_count;
  93         int             enabled;
  94         unsigned long   pad;
  95 };
  96
  97 /* Bits in bpt.enabled */
  98 #define BP_CIABR        1
  99 #define BP_TRAP         2
 100 #define BP_DABR         4
 101
 102 #define NBPTS   256
 103 static struct bpt bpts[NBPTS];
 104 static struct bpt dabr;
 105 static struct bpt *iabr;
 106 static unsigned bpinstr = 0x7fe00008;   /* trap */
 107
 108 #define BP_NUM(bp)      ((bp) - bpts + 1)
 109
 110 /* Prototypes */
 111 static int cmds(struct pt_regs *);
 112 static int mread(unsigned long, void *, int);
 113 static int mwrite(unsigned long, void *, int);
 114 static int handle_fault(struct pt_regs *);
 115 static void byterev(unsigned char *, int);
 116 static void memex(void);
 117 static int bsesc(void);
 118 static void dump(void);
 119 static void prdump(unsigned long, long);
 120 static int ppc_inst_dump(unsigned long, long, int);
 121 static void dump_log_buf(void);
 122 static void backtrace(struct pt_regs *);
 123 static void excprint(struct pt_regs *);
 124 static void prregs(struct pt_regs *);
 125 static void memops(int);
 126 static void memlocate(void);
 127 static void memzcan(void);
 128 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
 129 int skipbl(void);
 130 int scanhex(unsigned long *valp);
 131 static void scannl(void);
 132 static int hexdigit(int);
 133 void getstring(char *, int);
 134 static void flush_input(void);
 135 static int inchar(void);
 136 static void take_input(char *);
 137 static unsigned long read_spr(int);
 138 static void write_spr(int, unsigned long);
 139 static void super_regs(void);
 140 static void remove_bpts(void);
 141 static void insert_bpts(void);
 142 static void remove_cpu_bpts(void);
 143 static void insert_cpu_bpts(void);
 144 static struct bpt *at_breakpoint(unsigned long pc);
 145 static struct bpt *in_breakpoint_table(unsigned long pc, unsigned long *offp);
 146 static int  do_step(struct pt_regs *);
 147 static void bpt_cmds(void);
 148 static void cacheflush(void);
 149 static int  cpu_cmd(void);
 150 static void csum(void);
 151 static void bootcmds(void);
 152 static void proccall(void);
 153 void dump_segments(void);
 154 static void symbol_lookup(void);
 155 static void xmon_show_stack(unsigned long sp, unsigned long lr,
 156                             unsigned long pc);
 157 static void xmon_print_symbol(unsigned long address, const char *mid,
 158                               const char *after);
 159 static const char *getvecname(unsigned long vec);
 160
 161 static int do_spu_cmd(void);
 162
 163 #ifdef CONFIG_44x
 164 static void dump_tlb_44x(void);
 165 #endif
 166 #ifdef CONFIG_PPC_BOOK3E
 167 static void dump_tlb_book3e(void);
 168 #endif
 169
 170 static int xmon_no_auto_backtrace;
 171
 172 extern void xmon_enter(void);
 173 extern void xmon_leave(void);
 174
 175 #ifdef CONFIG_PPC64
 176 #define REG             "%.16lx"
 177 #else
 178 #define REG             "%.8lx"
 179 #endif
 180
 181 #ifdef __LITTLE_ENDIAN__
 182 #define GETWORD(v)      (((v)[3] << 24) + ((v)[2] << 16) + ((v)[1] << 8) + (v)[0])
 183 #else
 184 #define GETWORD(v)      (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
 185 #endif
 186
 187 static char *help_string = "\
 188 Commands:\n\
 189   b     show breakpoints\n\
 190   bd    set data breakpoint\n\
 191   bi    set instruction breakpoint\n\
 192   bc    clear breakpoint\n"
 193 #ifdef CONFIG_SMP
 194   "\
 195   c     print cpus stopped in xmon\n\
 196   c#    try to switch to cpu number h (in hex)\n"
 197 #endif
 198   "\
 199   C     checksum\n\
 200   d     dump bytes\n\
 201   di    dump instructions\n\
 202   df    dump float values\n\
 203   dd    dump double values\n\
 204   dl    dump the kernel log buffer\n"
 205 #ifdef CONFIG_PPC64
 206   "\
 207   dp[#] dump paca for current cpu, or cpu #\n\
 208   dpa   dump paca for all possible cpus\n"
 209 #endif
 210   "\
 211   dr    dump stream of raw bytes\n\
 212   e     print exception information\n\
 213   f     flush cache\n\
 214   la    lookup symbol+offset of specified address\n\
 215   ls    lookup address of specified symbol\n\
 216   m     examine/change memory\n\
 217   mm    move a block of memory\n\
 218   ms    set a block of memory\n\
 219   md    compare two blocks of memory\n\
 220   ml    locate a block of memory\n\
 221   mz    zero a block of memory\n\
 222   mi    show information about memory allocation\n\
 223   p     call a procedure\n\
 224   r     print registers\n\
 225   s     single step\n"
 226 #ifdef CONFIG_SPU_BASE
 227 "  ss   stop execution on all spus\n\
 228   sr    restore execution on stopped spus\n\
 229   sf  # dump spu fields for spu # (in hex)\n\
 230   sd  # dump spu local store for spu # (in hex)\n\
 231   sdi # disassemble spu local store for spu # (in hex)\n"
 232 #endif
 233 "  S    print special registers\n\
 234   t     print backtrace\n\
 235   x     exit monitor and recover\n\
 236   X     exit monitor and dont recover\n"
 237 #if defined(CONFIG_PPC64) && !defined(CONFIG_PPC_BOOK3E)
 238 "  u    dump segment table or SLB\n"
 239 #elif defined(CONFIG_PPC_STD_MMU_32)
 240 "  u    dump segment registers\n"
 241 #elif defined(CONFIG_44x) || defined(CONFIG_PPC_BOOK3E)
 242 "  u    dump TLB\n"
 243 #endif
 244 "  ?    help\n"
 245 "  # n  limit output to n lines per page (for dp, dpa, dl)\n"
 246 "  zr   reboot\n\
 247   zh    halt\n"
 248 ;
 249
 250 static struct pt_regs *xmon_regs;
 251
 252 static inline void sync(void)
 253 {
 254         asm volatile("sync; isync");
 255 }
 256
 257 static inline void store_inst(void *p)
 258 {
 259         asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p));
 260 }
 261
 262 static inline void cflush(void *p)
 263 {
 264         asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p));
 265 }
 266
 267 static inline void cinval(void *p)
 268 {
 269         asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p));
 270 }
 271
 272 /**
 273  * write_ciabr() - write the CIABR SPR
 274  * @ciabr:      The value to write.
 275  *
 276  * This function writes a value to the CIARB register either directly
 277  * through mtspr instruction if the kernel is in HV privilege mode or
 278  * call a hypervisor function to achieve the same in case the kernel
 279  * is in supervisor privilege mode.
 280  */
 281 static void write_ciabr(unsigned long ciabr)
 282 {
 283         if (!cpu_has_feature(CPU_FTR_ARCH_207S))
 284                 return;
 285
 286         if (cpu_has_feature(CPU_FTR_HVMODE)) {
 287                 mtspr(SPRN_CIABR, ciabr);
 288                 return;
 289         }
 290         plapr_set_ciabr(ciabr);
 291 }
 292
 293 /**
 294  * set_ciabr() - set the CIABR
 295  * @addr:       The value to set.
 296  *
 297  * This function sets the correct privilege value into the the HW
 298  * breakpoint address before writing it up in the CIABR register.
 299  */
 300 static void set_ciabr(unsigned long addr)
 301 {
 302         addr &= ~CIABR_PRIV;
 303
 304         if (cpu_has_feature(CPU_FTR_HVMODE))
 305                 addr |= CIABR_PRIV_HYPER;
 306         else
 307                 addr |= CIABR_PRIV_SUPER;
 308         write_ciabr(addr);
 309 }
 310
 311 /*
 312  * Disable surveillance (the service processor watchdog function)
 313  * while we are in xmon.
 314  * XXX we should re-enable it when we leave. :)
 315  */
 316 #define SURVEILLANCE_TOKEN      9000
 317
 318 static inline void disable_surveillance(void)
 319 {
 320 #ifdef CONFIG_PPC_PSERIES
 321         /* Since this can't be a module, args should end up below 4GB. */
 322         static struct rtas_args args;
 323         int token;
 324
 325         /*
 326          * At this point we have got all the cpus we can into
 327          * xmon, so there is hopefully no other cpu calling RTAS
 328          * at the moment, even though we don't take rtas.lock.
 329          * If we did try to take rtas.lock there would be a
 330          * real possibility of deadlock.
 331          */
 332         token = rtas_token("set-indicator");
 333         if (token == RTAS_UNKNOWN_SERVICE)
 334                 return;
 335
 336         rtas_call_unlocked(&args, token, 3, 1, NULL, SURVEILLANCE_TOKEN, 0, 0);
 337
 338 #endif /* CONFIG_PPC_PSERIES */
 339 }
 340
 341 #ifdef CONFIG_SMP
 342 static int xmon_speaker;
 343
 344 static void get_output_lock(void)
 345 {
 346         int me = smp_processor_id() + 0x100;
 347         int last_speaker = 0, prev;
 348         long timeout;
 349
 350         if (xmon_speaker == me)
 351                 return;
 352
 353         for (;;) {
 354                 last_speaker = cmpxchg(&xmon_speaker, 0, me);
 355                 if (last_speaker == 0)
 356                         return;
 357
 358                 /*
 359                  * Wait a full second for the lock, we might be on a slow
 360                  * console, but check every 100us.
 361                  */
 362                 timeout = 10000;
 363                 while (xmon_speaker == last_speaker) {
 364                         if (--timeout > 0) {
 365                                 udelay(100);
 366                                 continue;
 367                         }
 368
 369                         /* hostile takeover */
 370                         prev = cmpxchg(&xmon_speaker, last_speaker, me);
 371                         if (prev == last_speaker)
 372                                 return;
 373                         break;
 374                 }
 375         }
 376 }
 377
 378 static void release_output_lock(void)
 379 {
 380         xmon_speaker = 0;
 381 }
 382
 383 int cpus_are_in_xmon(void)
 384 {
 385         return !cpumask_empty(&cpus_in_xmon);
 386 }
 387 #endif
 388
 389 static inline int unrecoverable_excp(struct pt_regs *regs)
 390 {
 391 #if defined(CONFIG_4xx) || defined(CONFIG_PPC_BOOK3E)
 392         /* We have no MSR_RI bit on 4xx or Book3e, so we simply return false */
 393         return 0;
 394 #else
 395         return ((regs->msr & MSR_RI) == 0);
 396 #endif
 397 }
 398
 399 static int xmon_core(struct pt_regs *regs, int fromipi)
 400 {
 401         int cmd = 0;
 402         struct bpt *bp;
 403         long recurse_jmp[JMP_BUF_LEN];
 404         unsigned long offset;
 405         unsigned long flags;
 406 #ifdef CONFIG_SMP
 407         int cpu;
 408         int secondary;
 409         unsigned long timeout;
 410 #endif
 411
 412         local_irq_save(flags);
 413         hard_irq_disable();
 414
 415         bp = in_breakpoint_table(regs->nip, &offset);
 416         if (bp != NULL) {
 417                 regs->nip = bp->address + offset;
 418                 atomic_dec(&bp->ref_count);
 419         }
 420
 421         remove_cpu_bpts();
 422
 423 #ifdef CONFIG_SMP
 424         cpu = smp_processor_id();
 425         if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
 426                 get_output_lock();
 427                 excprint(regs);
 428                 printf("cpu 0x%x: Exception %lx %s in xmon, "
 429                        "returning to main loop\n",
 430                        cpu, regs->trap, getvecname(TRAP(regs)));
 431                 release_output_lock();
 432                 longjmp(xmon_fault_jmp[cpu], 1);
 433         }
 434
 435         if (setjmp(recurse_jmp) != 0) {
 436                 if (!in_xmon || !xmon_gate) {
 437                         get_output_lock();
 438                         printf("xmon: WARNING: bad recursive fault "
 439                                "on cpu 0x%x\n", cpu);
 440                         release_output_lock();
 441                         goto waiting;
 442                 }
 443                 secondary = !(xmon_taken && cpu == xmon_owner);
 444                 goto cmdloop;
 445         }
 446
 447         xmon_fault_jmp[cpu] = recurse_jmp;
 448
 449         bp = NULL;
 450         if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT))
 451                 bp = at_breakpoint(regs->nip);
 452         if (bp || unrecoverable_excp(regs))
 453                 fromipi = 0;
 454
 455         if (!fromipi) {
 456                 get_output_lock();
 457                 excprint(regs);
 458                 if (bp) {
 459                         printf("cpu 0x%x stopped at breakpoint 0x%lx (",
 460                                cpu, BP_NUM(bp));
 461                         xmon_print_symbol(regs->nip, " ", ")\n");
 462                 }
 463                 if (unrecoverable_excp(regs))
 464                         printf("WARNING: exception is not recoverable, "
 465                                "can't continue\n");
 466                 release_output_lock();
 467         }
 468
 469         cpumask_set_cpu(cpu, &cpus_in_xmon);
 470
 471  waiting:
 472         secondary = 1;
 473         while (secondary && !xmon_gate) {
 474                 if (in_xmon == 0) {
 475                         if (fromipi)
 476                                 goto leave;
 477                         secondary = test_and_set_bit(0, &in_xmon);
 478                 }
 479                 barrier();
 480         }
 481
 482         if (!secondary && !xmon_gate) {
 483                 /* we are the first cpu to come in */
 484                 /* interrupt other cpu(s) */
 485                 int ncpus = num_online_cpus();
 486
 487                 xmon_owner = cpu;
 488                 mb();
 489                 if (ncpus > 1) {
 490                         smp_send_debugger_break();
 491                         /* wait for other cpus to come in */
 492                         for (timeout = 100000000; timeout != 0; --timeout) {
 493                                 if (cpumask_weight(&cpus_in_xmon) >= ncpus)
 494                                         break;
 495                                 barrier();
 496                         }
 497                 }
 498                 remove_bpts();
 499                 disable_surveillance();
 500                 /* for breakpoint or single step, print the current instr. */
 501                 if (bp || TRAP(regs) == 0xd00)
 502                         ppc_inst_dump(regs->nip, 1, 0);
 503                 printf("enter ? for help\n");
 504                 mb();
 505                 xmon_gate = 1;
 506                 barrier();
 507         }
 508
 509  cmdloop:
 510         while (in_xmon) {
 511                 if (secondary) {
 512                         if (cpu == xmon_owner) {
 513                                 if (!test_and_set_bit(0, &xmon_taken)) {
 514                                         secondary = 0;
 515                                         continue;
 516                                 }
 517                                 /* missed it */
 518                                 while (cpu == xmon_owner)
 519                                         barrier();
 520                         }
 521                         barrier();
 522                 } else {
 523                         cmd = cmds(regs);
 524                         if (cmd != 0) {
 525                                 /* exiting xmon */
 526                                 insert_bpts();
 527                                 xmon_gate = 0;
 528                                 wmb();
 529                                 in_xmon = 0;
 530                                 break;
 531                         }
 532                         /* have switched to some other cpu */
 533                         secondary = 1;
 534                 }
 535         }
 536  leave:
 537         cpumask_clear_cpu(cpu, &cpus_in_xmon);
 538         xmon_fault_jmp[cpu] = NULL;
 539 #else
 540         /* UP is simple... */
 541         if (in_xmon) {
 542                 printf("Exception %lx %s in xmon, returning to main loop\n",
 543                        regs->trap, getvecname(TRAP(regs)));
 544                 longjmp(xmon_fault_jmp[0], 1);
 545         }
 546         if (setjmp(recurse_jmp) == 0) {
 547                 xmon_fault_jmp[0] = recurse_jmp;
 548                 in_xmon = 1;
 549
 550                 excprint(regs);
 551                 bp = at_breakpoint(regs->nip);
 552                 if (bp) {
 553                         printf("Stopped at breakpoint %lx (", BP_NUM(bp));
 554                         xmon_print_symbol(regs->nip, " ", ")\n");
 555                 }
 556                 if (unrecoverable_excp(regs))
 557                         printf("WARNING: exception is not recoverable, "
 558                                "can't continue\n");
 559                 remove_bpts();
 560                 disable_surveillance();
 561                 /* for breakpoint or single step, print the current instr. */
 562                 if (bp || TRAP(regs) == 0xd00)
 563                         ppc_inst_dump(regs->nip, 1, 0);
 564                 printf("enter ? for help\n");
 565         }
 566
 567         cmd = cmds(regs);
 568
 569         insert_bpts();
 570         in_xmon = 0;
 571 #endif
 572
 573 #ifdef CONFIG_BOOKE
 574         if (regs->msr & MSR_DE) {
 575                 bp = at_breakpoint(regs->nip);
 576                 if (bp != NULL) {
 577                         regs->nip = (unsigned long) &bp->instr[0];
 578                         atomic_inc(&bp->ref_count);
 579                 }
 580         }
 581 #else
 582         if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
 583                 bp = at_breakpoint(regs->nip);
 584                 if (bp != NULL) {
 585                         int stepped = emulate_step(regs, bp->instr[0]);
 586                         if (stepped == 0) {
 587                                 regs->nip = (unsigned long) &bp->instr[0];
 588                                 atomic_inc(&bp->ref_count);
 589                         } else if (stepped < 0) {
 590                                 printf("Couldn't single-step %s instruction\n",
 591                                     (IS_RFID(bp->instr[0])? "rfid": "mtmsrd"));
 592                         }
 593                 }
 594         }
 595 #endif
 596         insert_cpu_bpts();
 597
 598         touch_nmi_watchdog();
 599         local_irq_restore(flags);
 600
 601         return cmd != 'X' && cmd != EOF;
 602 }
 603
 604 int xmon(struct pt_regs *excp)
 605 {
 606         struct pt_regs regs;
 607
 608         if (excp == NULL) {
 609                 ppc_save_regs(&regs);
 610                 excp = &regs;
 611         }
 612
 613         return xmon_core(excp, 0);
 614 }
 615 EXPORT_SYMBOL(xmon);
 616
 617 irqreturn_t xmon_irq(int irq, void *d)
 618 {
 619         unsigned long flags;
 620         local_irq_save(flags);
 621         printf("Keyboard interrupt\n");
 622         xmon(get_irq_regs());
 623         local_irq_restore(flags);
 624         return IRQ_HANDLED;
 625 }
 626
 627 static int xmon_bpt(struct pt_regs *regs)
 628 {
 629         struct bpt *bp;
 630         unsigned long offset;
 631
 632         if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
 633                 return 0;
 634
 635         /* Are we at the trap at bp->instr[1] for some bp? */
 636         bp = in_breakpoint_table(regs->nip, &offset);
 637         if (bp != NULL && offset == 4) {
 638                 regs->nip = bp->address + 4;
 639                 atomic_dec(&bp->ref_count);
 640                 return 1;
 641         }
 642
 643         /* Are we at a breakpoint? */
 644         bp = at_breakpoint(regs->nip);
 645         if (!bp)
 646                 return 0;
 647
 648         xmon_core(regs, 0);
 649
 650         return 1;
 651 }
 652
 653 static int xmon_sstep(struct pt_regs *regs)
 654 {
 655         if (user_mode(regs))
 656                 return 0;
 657         xmon_core(regs, 0);
 658         return 1;
 659 }
 660
 661 static int xmon_break_match(struct pt_regs *regs)
 662 {
 663         if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
 664                 return 0;
 665         if (dabr.enabled == 0)
 666                 return 0;
 667         xmon_core(regs, 0);
 668         return 1;
 669 }
 670
 671 static int xmon_iabr_match(struct pt_regs *regs)
 672 {
 673         if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) != (MSR_IR|MSR_64BIT))
 674                 return 0;
 675         if (iabr == NULL)
 676                 return 0;
 677         xmon_core(regs, 0);
 678         return 1;
 679 }
 680
 681 static int xmon_ipi(struct pt_regs *regs)
 682 {
 683 #ifdef CONFIG_SMP
 684         if (in_xmon && !cpumask_test_cpu(smp_processor_id(), &cpus_in_xmon))
 685                 xmon_core(regs, 1);
 686 #endif
 687         return 0;
 688 }
 689
 690 static int xmon_fault_handler(struct pt_regs *regs)
 691 {
 692         struct bpt *bp;
 693         unsigned long offset;
 694
 695         if (in_xmon && catch_memory_errors)
 696                 handle_fault(regs);     /* doesn't return */
 697
 698         if ((regs->msr & (MSR_IR|MSR_PR|MSR_64BIT)) == (MSR_IR|MSR_64BIT)) {
 699                 bp = in_breakpoint_table(regs->nip, &offset);
 700                 if (bp != NULL) {
 701                         regs->nip = bp->address + offset;
 702                         atomic_dec(&bp->ref_count);
 703                 }
 704         }
 705
 706         return 0;
 707 }
 708
 709 static struct bpt *at_breakpoint(unsigned long pc)
 710 {
 711         int i;
 712         struct bpt *bp;
 713
 714         bp = bpts;
 715         for (i = 0; i < NBPTS; ++i, ++bp)
 716                 if (bp->enabled && pc == bp->address)
 717                         return bp;
 718         return NULL;
 719 }
 720
 721 static struct bpt *in_breakpoint_table(unsigned long nip, unsigned long *offp)
 722 {
 723         unsigned long off;
 724
 725         off = nip - (unsigned long) bpts;
 726         if (off >= sizeof(bpts))
 727                 return NULL;
 728         off %= sizeof(struct bpt);
 729         if (off != offsetof(struct bpt, instr[0])
 730             && off != offsetof(struct bpt, instr[1]))
 731                 return NULL;
 732         *offp = off - offsetof(struct bpt, instr[0]);
 733         return (struct bpt *) (nip - off);
 734 }
 735
 736 static struct bpt *new_breakpoint(unsigned long a)
 737 {
 738         struct bpt *bp;
 739
 740         a &= ~3UL;
 741         bp = at_breakpoint(a);
 742         if (bp)
 743                 return bp;
 744
 745         for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
 746                 if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
 747                         bp->address = a;
 748                         bp->instr[1] = bpinstr;
 749                         store_inst(&bp->instr[1]);
 750                         return bp;
 751                 }
 752         }
 753
 754         printf("Sorry, no free breakpoints.  Please clear one first.\n");
 755         return NULL;
 756 }
 757
 758 static void insert_bpts(void)
 759 {
 760         int i;
 761         struct bpt *bp;
 762
 763         bp = bpts;
 764         for (i = 0; i < NBPTS; ++i, ++bp) {
 765                 if ((bp->enabled & (BP_TRAP|BP_CIABR)) == 0)
 766                         continue;
 767                 if (mread(bp->address, &bp->instr[0], 4) != 4) {
 768                         printf("Couldn't read instruction at %lx, "
 769                                "disabling breakpoint there\n", bp->address);
 770                         bp->enabled = 0;
 771                         continue;
 772                 }
 773                 if (IS_MTMSRD(bp->instr[0]) || IS_RFID(bp->instr[0])) {
 774                         printf("Breakpoint at %lx is on an mtmsrd or rfid "
 775                                "instruction, disabling it\n", bp->address);
 776                         bp->enabled = 0;
 777                         continue;
 778                 }
 779                 store_inst(&bp->instr[0]);
 780                 if (bp->enabled & BP_CIABR)
 781                         continue;
 782                 if (mwrite(bp->address, &bpinstr, 4) != 4) {
 783                         printf("Couldn't write instruction at %lx, "
 784                                "disabling breakpoint there\n", bp->address);
 785                         bp->enabled &= ~BP_TRAP;
 786                         continue;
 787                 }
 788                 store_inst((void *)bp->address);
 789         }
 790 }
 791
 792 static void insert_cpu_bpts(void)
 793 {
 794         struct arch_hw_breakpoint brk;
 795
 796         if (dabr.enabled) {
 797                 brk.address = dabr.address;
 798                 brk.type = (dabr.enabled & HW_BRK_TYPE_DABR) | HW_BRK_TYPE_PRIV_ALL;
 799                 brk.len = 8;
 800                 __set_breakpoint(&brk);
 801         }
 802
 803         if (iabr)
 804                 set_ciabr(iabr->address);
 805 }
 806
 807 static void remove_bpts(void)
 808 {
 809         int i;
 810         struct bpt *bp;
 811         unsigned instr;
 812
 813         bp = bpts;
 814         for (i = 0; i < NBPTS; ++i, ++bp) {
 815                 if ((bp->enabled & (BP_TRAP|BP_CIABR)) != BP_TRAP)
 816                         continue;
 817                 if (mread(bp->address, &instr, 4) == 4
 818                     && instr == bpinstr
 819                     && mwrite(bp->address, &bp->instr, 4) != 4)
 820                         printf("Couldn't remove breakpoint at %lx\n",
 821                                bp->address);
 822                 else
 823                         store_inst((void *)bp->address);
 824         }
 825 }
 826
 827 static void remove_cpu_bpts(void)
 828 {
 829         hw_breakpoint_disable();
 830         write_ciabr(0);
 831 }
 832
 833 static void set_lpp_cmd(void)
 834 {
 835         unsigned long lpp;
 836
 837         if (!scanhex(&lpp)) {
 838                 printf("Invalid number.\n");
 839                 lpp = 0;
 840         }
 841         xmon_set_pagination_lpp(lpp);
 842 }
 843 /* Command interpreting routine */
 844 static char *last_cmd;
 845
 846 static int
 847 cmds(struct pt_regs *excp)
 848 {
 849         int cmd = 0;
 850
 851         last_cmd = NULL;
 852         xmon_regs = excp;
 853
 854         if (!xmon_no_auto_backtrace) {
 855                 xmon_no_auto_backtrace = 1;
 856                 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
 857         }
 858
 859         for(;;) {
 860 #ifdef CONFIG_SMP
 861                 printf("%x:", smp_processor_id());
 862 #endif /* CONFIG_SMP */
 863                 printf("mon> ");
 864                 flush_input();
 865                 termch = 0;
 866                 cmd = skipbl();
 867                 if( cmd == '\n' ) {
 868                         if (last_cmd == NULL)
 869                                 continue;
 870                         take_input(last_cmd);
 871                         last_cmd = NULL;
 872                         cmd = inchar();
 873                 }
 874                 switch (cmd) {
 875                 case 'm':
 876                         cmd = inchar();
 877                         switch (cmd) {
 878                         case 'm':
 879                         case 's':
 880                         case 'd':
 881                                 memops(cmd);
 882                                 break;
 883                         case 'l':
 884                                 memlocate();
 885                                 break;
 886                         case 'z':
 887                                 memzcan();
 888                                 break;
 889                         case 'i':
 890                                 show_mem(0);
 891                                 break;
 892                         default:
 893                                 termch = cmd;
 894                                 memex();
 895                         }
 896                         break;
 897                 case 'd':
 898                         dump();
 899                         break;
 900                 case 'l':
 901                         symbol_lookup();
 902                         break;
 903                 case 'r':
 904                         prregs(excp);   /* print regs */
 905                         break;
 906                 case 'e':
 907                         excprint(excp);
 908                         break;
 909                 case 'S':
 910                         super_regs();
 911                         break;
 912                 case 't':
 913                         backtrace(excp);
 914                         break;
 915                 case 'f':
 916                         cacheflush();
 917                         break;
 918                 case 's':
 919                         if (do_spu_cmd() == 0)
 920                                 break;
 921                         if (do_step(excp))
 922                                 return cmd;
 923                         break;
 924                 case 'x':
 925                 case 'X':
 926                         return cmd;
 927                 case EOF:
 928                         printf(" <no input ...>\n");
 929                         mdelay(2000);
 930                         return cmd;
 931                 case '?':
 932                         xmon_puts(help_string);
 933                         break;
 934                 case '#':
 935                         set_lpp_cmd();
 936                         break;
 937                 case 'b':
 938                         bpt_cmds();
 939                         break;
 940                 case 'C':
 941                         csum();
 942                         break;
 943                 case 'c':
 944                         if (cpu_cmd())
 945                                 return 0;
 946                         break;
 947                 case 'z':
 948                         bootcmds();
 949                         break;
 950                 case 'p':
 951                         proccall();
 952                         break;
 953 #ifdef CONFIG_PPC_STD_MMU
 954                 case 'u':
 955                         dump_segments();
 956                         break;
 957 #elif defined(CONFIG_44x)
 958                 case 'u':
 959                         dump_tlb_44x();
 960                         break;
 961 #elif defined(CONFIG_PPC_BOOK3E)
 962                 case 'u':
 963                         dump_tlb_book3e();
 964                         break;
 965 #endif
 966                 default:
 967                         printf("Unrecognized command: ");
 968                         do {
 969                                 if (' ' < cmd && cmd <= '~')
 970                                         putchar(cmd);
 971                                 else
 972                                         printf("\\x%x", cmd);
 973                                 cmd = inchar();
 974                         } while (cmd != '\n');
 975                         printf(" (type ? for help)\n");
 976                         break;
 977                 }
 978         }
 979 }
 980
 981 #ifdef CONFIG_BOOKE
 982 static int do_step(struct pt_regs *regs)
 983 {
 984         regs->msr |= MSR_DE;
 985         mtspr(SPRN_DBCR0, mfspr(SPRN_DBCR0) | DBCR0_IC | DBCR0_IDM);
 986         return 1;
 987 }
 988 #else
 989 /*
 990  * Step a single instruction.
 991  * Some instructions we emulate, others we execute with MSR_SE set.
 992  */
 993 static int do_step(struct pt_regs *regs)
 994 {
 995         unsigned int instr;
 996         int stepped;
 997
 998         /* check we are in 64-bit kernel mode, translation enabled */
 999         if ((regs->msr & (MSR_64BIT|MSR_PR|MSR_IR)) == (MSR_64BIT|MSR_IR)) {
1000                 if (mread(regs->nip, &instr, 4) == 4) {
1001                         stepped = emulate_step(regs, instr);
1002                         if (stepped < 0) {
1003                                 printf("Couldn't single-step %s instruction\n",
1004                                        (IS_RFID(instr)? "rfid": "mtmsrd"));
1005                                 return 0;
1006                         }
1007                         if (stepped > 0) {
1008                                 regs->trap = 0xd00 | (regs->trap & 1);
1009                                 printf("stepped to ");
1010                                 xmon_print_symbol(regs->nip, " ", "\n");
1011                                 ppc_inst_dump(regs->nip, 1, 0);
1012                                 return 0;
1013                         }
1014                 }
1015         }
1016         regs->msr |= MSR_SE;
1017         return 1;
1018 }
1019 #endif
1020
1021 static void bootcmds(void)
1022 {
1023         int cmd;
1024
1025         cmd = inchar();
1026         if (cmd == 'r')
1027                 ppc_md.restart(NULL);
1028         else if (cmd == 'h')
1029                 ppc_md.halt();
1030         else if (cmd == 'p')
1031                 if (pm_power_off)
1032                         pm_power_off();
1033 }
1034
1035 static int cpu_cmd(void)
1036 {
1037 #ifdef CONFIG_SMP
1038         unsigned long cpu, first_cpu, last_cpu;
1039         int timeout;
1040
1041         if (!scanhex(&cpu)) {
1042                 /* print cpus waiting or in xmon */
1043                 printf("cpus stopped:");
1044                 last_cpu = first_cpu = NR_CPUS;
1045                 for_each_possible_cpu(cpu) {
1046                         if (cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1047                                 if (cpu == last_cpu + 1) {
1048                                         last_cpu = cpu;
1049                                 } else {
1050                                         if (last_cpu != first_cpu)
1051                                                 printf("-0x%lx", last_cpu);
1052                                         last_cpu = first_cpu = cpu;
1053                                         printf(" 0x%lx", cpu);
1054                                 }
1055                         }
1056                 }
1057                 if (last_cpu != first_cpu)
1058                         printf("-0x%lx", last_cpu);
1059                 printf("\n");
1060                 return 0;
1061         }
1062         /* try to switch to cpu specified */
1063         if (!cpumask_test_cpu(cpu, &cpus_in_xmon)) {
1064                 printf("cpu 0x%x isn't in xmon\n", cpu);
1065                 return 0;
1066         }
1067         xmon_taken = 0;
1068         mb();
1069         xmon_owner = cpu;
1070         timeout = 10000000;
1071         while (!xmon_taken) {
1072                 if (--timeout == 0) {
1073                         if (test_and_set_bit(0, &xmon_taken))
1074                                 break;
1075                         /* take control back */
1076                         mb();
1077                         xmon_owner = smp_processor_id();
1078                         printf("cpu 0x%x didn't take control\n", cpu);
1079                         return 0;
1080                 }
1081                 barrier();
1082         }
1083         return 1;
1084 #else
1085         return 0;
1086 #endif /* CONFIG_SMP */
1087 }
1088
1089 static unsigned short fcstab[256] = {
1090         0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
1091         0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
1092         0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
1093         0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
1094         0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
1095         0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
1096         0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
1097         0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
1098         0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
1099         0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
1100         0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
1101         0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
1102         0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
1103         0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
1104         0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
1105         0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
1106         0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
1107         0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
1108         0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
1109         0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
1110         0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
1111         0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
1112         0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
1113         0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
1114         0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
1115         0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
1116         0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
1117         0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
1118         0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
1119         0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
1120         0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
1121         0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
1122 };
1123
1124 #define FCS(fcs, c)     (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
1125
1126 static void
1127 csum(void)
1128 {
1129         unsigned int i;
1130         unsigned short fcs;
1131         unsigned char v;
1132
1133         if (!scanhex(&adrs))
1134                 return;
1135         if (!scanhex(&ncsum))
1136                 return;
1137         fcs = 0xffff;
1138         for (i = 0; i < ncsum; ++i) {
1139                 if (mread(adrs+i, &v, 1) == 0) {
1140                         printf("csum stopped at "REG"\n", adrs+i);
1141                         break;
1142                 }
1143                 fcs = FCS(fcs, v);
1144         }
1145         printf("%x\n", fcs);
1146 }
1147
1148 /*
1149  * Check if this is a suitable place to put a breakpoint.
1150  */
1151 static long check_bp_loc(unsigned long addr)
1152 {
1153         unsigned int instr;
1154
1155         addr &= ~3;
1156         if (!is_kernel_addr(addr)) {
1157                 printf("Breakpoints may only be placed at kernel addresses\n");
1158                 return 0;
1159         }
1160         if (!mread(addr, &instr, sizeof(instr))) {
1161                 printf("Can't read instruction at address %lx\n", addr);
1162                 return 0;
1163         }
1164         if (IS_MTMSRD(instr) || IS_RFID(instr)) {
1165                 printf("Breakpoints may not be placed on mtmsrd or rfid "
1166                        "instructions\n");
1167                 return 0;
1168         }
1169         return 1;
1170 }
1171
1172 static char *breakpoint_help_string =
1173     "Breakpoint command usage:\n"
1174     "b                show breakpoints\n"
1175     "b <addr> [cnt]   set breakpoint at given instr addr\n"
1176     "bc               clear all breakpoints\n"
1177     "bc <n/addr>      clear breakpoint number n or at addr\n"
1178     "bi <addr> [cnt]  set hardware instr breakpoint (POWER8 only)\n"
1179     "bd <addr> [cnt]  set hardware data breakpoint\n"
1180     "";
1181
1182 static void
1183 bpt_cmds(void)
1184 {
1185         int cmd;
1186         unsigned long a;
1187         int mode, i;
1188         struct bpt *bp;
1189         const char badaddr[] = "Only kernel addresses are permitted "
1190                 "for breakpoints\n";
1191
1192         cmd = inchar();
1193         switch (cmd) {
1194 #ifndef CONFIG_8xx
1195         case 'd':       /* bd - hardware data breakpoint */
1196                 mode = 7;
1197                 cmd = inchar();
1198                 if (cmd == 'r')
1199                         mode = 5;
1200                 else if (cmd == 'w')
1201                         mode = 6;
1202                 else
1203                         termch = cmd;
1204                 dabr.address = 0;
1205                 dabr.enabled = 0;
1206                 if (scanhex(&dabr.address)) {
1207                         if (!is_kernel_addr(dabr.address)) {
1208                                 printf(badaddr);
1209                                 break;
1210                         }
1211                         dabr.address &= ~HW_BRK_TYPE_DABR;
1212                         dabr.enabled = mode | BP_DABR;
1213                 }
1214                 break;
1215
1216         case 'i':       /* bi - hardware instr breakpoint */
1217                 if (!cpu_has_feature(CPU_FTR_ARCH_207S)) {
1218                         printf("Hardware instruction breakpoint "
1219                                "not supported on this cpu\n");
1220                         break;
1221                 }
1222                 if (iabr) {
1223                         iabr->enabled &= ~BP_CIABR;
1224                         iabr = NULL;
1225                 }
1226                 if (!scanhex(&a))
1227                         break;
1228                 if (!check_bp_loc(a))
1229                         break;
1230                 bp = new_breakpoint(a);
1231                 if (bp != NULL) {
1232                         bp->enabled |= BP_CIABR;
1233                         iabr = bp;
1234                 }
1235                 break;
1236 #endif
1237
1238         case 'c':
1239                 if (!scanhex(&a)) {
1240                         /* clear all breakpoints */
1241                         for (i = 0; i < NBPTS; ++i)
1242                                 bpts[i].enabled = 0;
1243                         iabr = NULL;
1244                         dabr.enabled = 0;
1245                         printf("All breakpoints cleared\n");
1246                         break;
1247                 }
1248
1249                 if (a <= NBPTS && a >= 1) {
1250                         /* assume a breakpoint number */
1251                         bp = &bpts[a-1];        /* bp nums are 1 based */
1252                 } else {
1253                         /* assume a breakpoint address */
1254                         bp = at_breakpoint(a);
1255                         if (bp == NULL) {
1256                                 printf("No breakpoint at %lx\n", a);
1257                                 break;
1258                         }
1259                 }
1260
1261                 printf("Cleared breakpoint %lx (", BP_NUM(bp));
1262                 xmon_print_symbol(bp->address, " ", ")\n");
1263                 bp->enabled = 0;
1264                 break;
1265
1266         default:
1267                 termch = cmd;
1268                 cmd = skipbl();
1269                 if (cmd == '?') {
1270                         printf(breakpoint_help_string);
1271                         break;
1272                 }
1273                 termch = cmd;
1274                 if (!scanhex(&a)) {
1275                         /* print all breakpoints */
1276                         printf("   type            address\n");
1277                         if (dabr.enabled) {
1278                                 printf("   data   "REG"  [", dabr.address);
1279                                 if (dabr.enabled & 1)
1280                                         printf("r");
1281                                 if (dabr.enabled & 2)
1282                                         printf("w");
1283                                 printf("]\n");
1284                         }
1285                         for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
1286                                 if (!bp->enabled)
1287                                         continue;
1288                                 printf("%2x %s   ", BP_NUM(bp),
1289                                     (bp->enabled & BP_CIABR) ? "inst": "trap");
1290                                 xmon_print_symbol(bp->address, "  ", "\n");
1291                         }
1292                         break;
1293                 }
1294
1295                 if (!check_bp_loc(a))
1296                         break;
1297                 bp = new_breakpoint(a);
1298                 if (bp != NULL)
1299                         bp->enabled |= BP_TRAP;
1300                 break;
1301         }
1302 }
1303
1304 /* Very cheap human name for vector lookup. */
1305 static
1306 const char *getvecname(unsigned long vec)
1307 {
1308         char *ret;
1309
1310         switch (vec) {
1311         case 0x100:     ret = "(System Reset)"; break;
1312         case 0x200:     ret = "(Machine Check)"; break;
1313         case 0x300:     ret = "(Data Access)"; break;
1314         case 0x380:     ret = "(Data SLB Access)"; break;
1315         case 0x400:     ret = "(Instruction Access)"; break;
1316         case 0x480:     ret = "(Instruction SLB Access)"; break;
1317         case 0x500:     ret = "(Hardware Interrupt)"; break;
1318         case 0x600:     ret = "(Alignment)"; break;
1319         case 0x700:     ret = "(Program Check)"; break;
1320         case 0x800:     ret = "(FPU Unavailable)"; break;
1321         case 0x900:     ret = "(Decrementer)"; break;
1322         case 0x980:     ret = "(Hypervisor Decrementer)"; break;
1323         case 0xa00:     ret = "(Doorbell)"; break;
1324         case 0xc00:     ret = "(System Call)"; break;
1325         case 0xd00:     ret = "(Single Step)"; break;
1326         case 0xe40:     ret = "(Emulation Assist)"; break;
1327         case 0xe60:     ret = "(HMI)"; break;
1328         case 0xe80:     ret = "(Hypervisor Doorbell)"; break;
1329         case 0xf00:     ret = "(Performance Monitor)"; break;
1330         case 0xf20:     ret = "(Altivec Unavailable)"; break;
1331         case 0x1300:    ret = "(Instruction Breakpoint)"; break;
1332         case 0x1500:    ret = "(Denormalisation)"; break;
1333         case 0x1700:    ret = "(Altivec Assist)"; break;
1334         default: ret = "";
1335         }
1336         return ret;
1337 }
1338
1339 static void get_function_bounds(unsigned long pc, unsigned long *startp,
1340                                 unsigned long *endp)
1341 {
1342         unsigned long size, offset;
1343         const char *name;
1344
1345         *startp = *endp = 0;
1346         if (pc == 0)
1347                 return;
1348         if (setjmp(bus_error_jmp) == 0) {
1349                 catch_memory_errors = 1;
1350                 sync();
1351                 name = kallsyms_lookup(pc, &size, &offset, NULL, tmpstr);
1352                 if (name != NULL) {
1353                         *startp = pc - offset;
1354                         *endp = pc - offset + size;
1355                 }
1356                 sync();
1357         }
1358         catch_memory_errors = 0;
1359 }
1360
1361 #define LRSAVE_OFFSET           (STACK_FRAME_LR_SAVE * sizeof(unsigned long))
1362 #define MARKER_OFFSET           (STACK_FRAME_MARKER * sizeof(unsigned long))
1363
1364 static void xmon_show_stack(unsigned long sp, unsigned long lr,
1365                             unsigned long pc)
1366 {
1367         int max_to_print = 64;
1368         unsigned long ip;
1369         unsigned long newsp;
1370         unsigned long marker;
1371         struct pt_regs regs;
1372
1373         while (max_to_print--) {
1374                 if (sp < PAGE_OFFSET) {
1375                         if (sp != 0)
1376                                 printf("SP (%lx) is in userspace\n", sp);
1377                         break;
1378                 }
1379
1380                 if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
1381                     || !mread(sp, &newsp, sizeof(unsigned long))) {
1382                         printf("Couldn't read stack frame at %lx\n", sp);
1383                         break;
1384                 }
1385
1386                 /*
1387                  * For the first stack frame, try to work out if
1388                  * LR and/or the saved LR value in the bottommost
1389                  * stack frame are valid.
1390                  */
1391                 if ((pc | lr) != 0) {
1392                         unsigned long fnstart, fnend;
1393                         unsigned long nextip;
1394                         int printip = 1;
1395
1396                         get_function_bounds(pc, &fnstart, &fnend);
1397                         nextip = 0;
1398                         if (newsp > sp)
1399                                 mread(newsp + LRSAVE_OFFSET, &nextip,
1400                                       sizeof(unsigned long));
1401                         if (lr == ip) {
1402                                 if (lr < PAGE_OFFSET
1403                                     || (fnstart <= lr && lr < fnend))
1404                                         printip = 0;
1405                         } else if (lr == nextip) {
1406                                 printip = 0;
1407                         } else if (lr >= PAGE_OFFSET
1408                                    && !(fnstart <= lr && lr < fnend)) {
1409                                 printf("[link register   ] ");
1410                                 xmon_print_symbol(lr, " ", "\n");
1411                         }
1412                         if (printip) {
1413                                 printf("["REG"] ", sp);
1414                                 xmon_print_symbol(ip, " ", " (unreliable)\n");
1415                         }
1416                         pc = lr = 0;
1417
1418                 } else {
1419                         printf("["REG"] ", sp);
1420                         xmon_print_symbol(ip, " ", "\n");
1421                 }
1422
1423                 /* Look for "regshere" marker to see if this is
1424                    an exception frame. */
1425                 if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
1426                     && marker == STACK_FRAME_REGS_MARKER) {
1427                         if (mread(sp + STACK_FRAME_OVERHEAD, &regs, sizeof(regs))
1428                             != sizeof(regs)) {
1429                                 printf("Couldn't read registers at %lx\n",
1430                                        sp + STACK_FRAME_OVERHEAD);
1431                                 break;
1432                         }
1433                         printf("--- Exception: %lx %s at ", regs.trap,
1434                                getvecname(TRAP(&regs)));
1435                         pc = regs.nip;
1436                         lr = regs.link;
1437                         xmon_print_symbol(pc, " ", "\n");
1438                 }
1439
1440                 if (newsp == 0)
1441                         break;
1442
1443                 sp = newsp;
1444         }
1445 }
1446
1447 static void backtrace(struct pt_regs *excp)
1448 {
1449         unsigned long sp;
1450
1451         if (scanhex(&sp))
1452                 xmon_show_stack(sp, 0, 0);
1453         else
1454                 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
1455         scannl();
1456 }
1457
1458 static void print_bug_trap(struct pt_regs *regs)
1459 {
1460 #ifdef CONFIG_BUG
1461         const struct bug_entry *bug;
1462         unsigned long addr;
1463
1464         if (regs->msr & MSR_PR)
1465                 return;         /* not in kernel */
1466         addr = regs->nip;       /* address of trap instruction */
1467         if (addr < PAGE_OFFSET)
1468                 return;
1469         bug = find_bug(regs->nip);
1470         if (bug == NULL)
1471                 return;
1472         if (is_warning_bug(bug))
1473                 return;
1474
1475 #ifdef CONFIG_DEBUG_BUGVERBOSE
1476         printf("kernel BUG at %s:%u!\n",
1477                bug->file, bug->line);
1478 #else
1479         printf("kernel BUG at %p!\n", (void *)bug->bug_addr);
1480 #endif
1481 #endif /* CONFIG_BUG */
1482 }
1483
1484 static void excprint(struct pt_regs *fp)
1485 {
1486         unsigned long trap;
1487
1488 #ifdef CONFIG_SMP
1489         printf("cpu 0x%x: ", smp_processor_id());
1490 #endif /* CONFIG_SMP */
1491
1492         trap = TRAP(fp);
1493         printf("Vector: %lx %s at [%lx]\n", fp->trap, getvecname(trap), fp);
1494         printf("    pc: ");
1495         xmon_print_symbol(fp->nip, ": ", "\n");
1496
1497         printf("    lr: ", fp->link);
1498         xmon_print_symbol(fp->link, ": ", "\n");
1499
1500         printf("    sp: %lx\n", fp->gpr[1]);
1501         printf("   msr: %lx\n", fp->msr);
1502
1503         if (trap == 0x300 || trap == 0x380 || trap == 0x600 || trap == 0x200) {
1504                 printf("   dar: %lx\n", fp->dar);
1505                 if (trap != 0x380)
1506                         printf(" dsisr: %lx\n", fp->dsisr);
1507         }
1508
1509         printf("  current = 0x%lx\n", current);
1510 #ifdef CONFIG_PPC64
1511         printf("  paca    = 0x%lx\t softe: %d\t irq_happened: 0x%02x\n",
1512                local_paca, local_paca->soft_enabled, local_paca->irq_happened);
1513 #endif
1514         if (current) {
1515                 printf("    pid   = %ld, comm = %s\n",
1516                        current->pid, current->comm);
1517         }
1518
1519         if (trap == 0x700)
1520                 print_bug_trap(fp);
1521
1522         printf(linux_banner);
1523 }
1524
1525 static void prregs(struct pt_regs *fp)
1526 {
1527         int n, trap;
1528         unsigned long base;
1529         struct pt_regs regs;
1530
1531         if (scanhex(&base)) {
1532                 if (setjmp(bus_error_jmp) == 0) {
1533                         catch_memory_errors = 1;
1534                         sync();
1535                         regs = *(struct pt_regs *)base;
1536                         sync();
1537                         __delay(200);
1538                 } else {
1539                         catch_memory_errors = 0;
1540                         printf("*** Error reading registers from "REG"\n",
1541                                base);
1542                         return;
1543                 }
1544                 catch_memory_errors = 0;
1545                 fp = &regs;
1546         }
1547
1548 #ifdef CONFIG_PPC64
1549         if (FULL_REGS(fp)) {
1550                 for (n = 0; n < 16; ++n)
1551                         printf("R%.2ld = "REG"   R%.2ld = "REG"\n",
1552                                n, fp->gpr[n], n+16, fp->gpr[n+16]);
1553         } else {
1554                 for (n = 0; n < 7; ++n)
1555                         printf("R%.2ld = "REG"   R%.2ld = "REG"\n",
1556                                n, fp->gpr[n], n+7, fp->gpr[n+7]);
1557         }
1558 #else
1559         for (n = 0; n < 32; ++n) {
1560                 printf("R%.2d = %.8x%s", n, fp->gpr[n],
1561                        (n & 3) == 3? "\n": "   ");
1562                 if (n == 12 && !FULL_REGS(fp)) {
1563                         printf("\n");
1564                         break;
1565                 }
1566         }
1567 #endif
1568         printf("pc  = ");
1569         xmon_print_symbol(fp->nip, " ", "\n");
1570         if (TRAP(fp) != 0xc00 && cpu_has_feature(CPU_FTR_CFAR)) {
1571                 printf("cfar= ");
1572                 xmon_print_symbol(fp->orig_gpr3, " ", "\n");
1573         }
1574         printf("lr  = ");
1575         xmon_print_symbol(fp->link, " ", "\n");
1576         printf("msr = "REG"   cr  = %.8lx\n", fp->msr, fp->ccr);
1577         printf("ctr = "REG"   xer = "REG"   trap = %4lx\n",
1578                fp->ctr, fp->xer, fp->trap);
1579         trap = TRAP(fp);
1580         if (trap == 0x300 || trap == 0x380 || trap == 0x600)
1581                 printf("dar = "REG"   dsisr = %.8lx\n", fp->dar, fp->dsisr);
1582 }
1583
1584 static void cacheflush(void)
1585 {
1586         int cmd;
1587         unsigned long nflush;
1588
1589         cmd = inchar();
1590         if (cmd != 'i')
1591                 termch = cmd;
1592         scanhex((void *)&adrs);
1593         if (termch != '\n')
1594                 termch = 0;
1595         nflush = 1;
1596         scanhex(&nflush);
1597         nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
1598         if (setjmp(bus_error_jmp) == 0) {
1599                 catch_memory_errors = 1;
1600                 sync();
1601
1602                 if (cmd != 'i') {
1603                         for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1604                                 cflush((void *) adrs);
1605                 } else {
1606                         for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1607                                 cinval((void *) adrs);
1608                 }
1609                 sync();
1610                 /* wait a little while to see if we get a machine check */
1611                 __delay(200);
1612         }
1613         catch_memory_errors = 0;
1614 }
1615
1616 static unsigned long
1617 read_spr(int n)
1618 {
1619         unsigned int instrs[2];
1620         unsigned long (*code)(void);
1621         unsigned long ret = -1UL;
1622 #ifdef CONFIG_PPC64
1623         unsigned long opd[3];
1624
1625         opd[0] = (unsigned long)instrs;
1626         opd[1] = 0;
1627         opd[2] = 0;
1628         code = (unsigned long (*)(void)) opd;
1629 #else
1630         code = (unsigned long (*)(void)) instrs;
1631 #endif
1632
1633         /* mfspr r3,n; blr */
1634         instrs[0] = 0x7c6002a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1635         instrs[1] = 0x4e800020;
1636         store_inst(instrs);
1637         store_inst(instrs+1);
1638
1639         if (setjmp(bus_error_jmp) == 0) {
1640                 catch_memory_errors = 1;
1641                 sync();
1642
1643                 ret = code();
1644
1645                 sync();
1646                 /* wait a little while to see if we get a machine check */
1647                 __delay(200);
1648                 n = size;
1649         }
1650
1651         return ret;
1652 }
1653
1654 static void
1655 write_spr(int n, unsigned long val)
1656 {
1657         unsigned int instrs[2];
1658         unsigned long (*code)(unsigned long);
1659 #ifdef CONFIG_PPC64
1660         unsigned long opd[3];
1661
1662         opd[0] = (unsigned long)instrs;
1663         opd[1] = 0;
1664         opd[2] = 0;
1665         code = (unsigned long (*)(unsigned long)) opd;
1666 #else
1667         code = (unsigned long (*)(unsigned long)) instrs;
1668 #endif
1669
1670         instrs[0] = 0x7c6003a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1671         instrs[1] = 0x4e800020;
1672         store_inst(instrs);
1673         store_inst(instrs+1);
1674
1675         if (setjmp(bus_error_jmp) == 0) {
1676                 catch_memory_errors = 1;
1677                 sync();
1678
1679                 code(val);
1680
1681                 sync();
1682                 /* wait a little while to see if we get a machine check */
1683                 __delay(200);
1684                 n = size;
1685         }
1686 }
1687
1688 static unsigned long regno;
1689 extern char exc_prolog;
1690 extern char dec_exc;
1691
1692 static void super_regs(void)
1693 {
1694         int cmd;
1695         unsigned long val;
1696
1697         cmd = skipbl();
1698         if (cmd == '\n') {
1699                 unsigned long sp, toc;
1700                 asm("mr %0,1" : "=r" (sp) :);
1701                 asm("mr %0,2" : "=r" (toc) :);
1702
1703                 printf("msr  = "REG"  sprg0= "REG"\n",
1704                        mfmsr(), mfspr(SPRN_SPRG0));
1705                 printf("pvr  = "REG"  sprg1= "REG"\n",
1706                        mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
1707                 printf("dec  = "REG"  sprg2= "REG"\n",
1708                        mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
1709                 printf("sp   = "REG"  sprg3= "REG"\n", sp, mfspr(SPRN_SPRG3));
1710                 printf("toc  = "REG"  dar  = "REG"\n", toc, mfspr(SPRN_DAR));
1711
1712                 return;
1713         }
1714
1715         scanhex(&regno);
1716         switch (cmd) {
1717         case 'w':
1718                 val = read_spr(regno);
1719                 scanhex(&val);
1720                 write_spr(regno, val);
1721                 /* fall through */
1722         case 'r':
1723                 printf("spr %lx = %lx\n", regno, read_spr(regno));
1724                 break;
1725         }
1726         scannl();
1727 }
1728
1729 /*
1730  * Stuff for reading and writing memory safely
1731  */
1732 static int
1733 mread(unsigned long adrs, void *buf, int size)
1734 {
1735         volatile int n;
1736         char *p, *q;
1737
1738         n = 0;
1739         if (setjmp(bus_error_jmp) == 0) {
1740                 catch_memory_errors = 1;
1741                 sync();
1742                 p = (char *)adrs;
1743                 q = (char *)buf;
1744                 switch (size) {
1745                 case 2:
1746                         *(u16 *)q = *(u16 *)p;
1747                         break;
1748                 case 4:
1749                         *(u32 *)q = *(u32 *)p;
1750                         break;
1751                 case 8:
1752                         *(u64 *)q = *(u64 *)p;
1753                         break;
1754                 default:
1755                         for( ; n < size; ++n) {
1756                                 *q++ = *p++;
1757                                 sync();
1758                         }
1759                 }
1760                 sync();
1761                 /* wait a little while to see if we get a machine check */
1762                 __delay(200);
1763                 n = size;
1764         }
1765         catch_memory_errors = 0;
1766         return n;
1767 }
1768
1769 static int
1770 mwrite(unsigned long adrs, void *buf, int size)
1771 {
1772         volatile int n;
1773         char *p, *q;
1774
1775         n = 0;
1776         if (setjmp(bus_error_jmp) == 0) {
1777                 catch_memory_errors = 1;
1778                 sync();
1779                 p = (char *) adrs;
1780                 q = (char *) buf;
1781                 switch (size) {
1782                 case 2:
1783                         *(u16 *)p = *(u16 *)q;
1784                         break;
1785                 case 4:
1786                         *(u32 *)p = *(u32 *)q;
1787                         break;
1788                 case 8:
1789                         *(u64 *)p = *(u64 *)q;
1790                         break;
1791                 default:
1792                         for ( ; n < size; ++n) {
1793                                 *p++ = *q++;
1794                                 sync();
1795                         }
1796                 }
1797                 sync();
1798                 /* wait a little while to see if we get a machine check */
1799                 __delay(200);
1800                 n = size;
1801         } else {
1802                 printf("*** Error writing address "REG"\n", adrs + n);
1803         }
1804         catch_memory_errors = 0;
1805         return n;
1806 }
1807
1808 static int fault_type;
1809 static int fault_except;
1810 static char *fault_chars[] = { "--", "**", "##" };
1811
1812 static int handle_fault(struct pt_regs *regs)
1813 {
1814         fault_except = TRAP(regs);
1815         switch (TRAP(regs)) {
1816         case 0x200:
1817                 fault_type = 0;
1818                 break;
1819         case 0x300:
1820         case 0x380:
1821                 fault_type = 1;
1822                 break;
1823         default:
1824                 fault_type = 2;
1825         }
1826
1827         longjmp(bus_error_jmp, 1);
1828
1829         return 0;
1830 }
1831
1832 #define SWAP(a, b, t)   ((t) = (a), (a) = (b), (b) = (t))
1833
1834 static void
1835 byterev(unsigned char *val, int size)
1836 {
1837         int t;
1838
1839         switch (size) {
1840         case 2:
1841                 SWAP(val[0], val[1], t);
1842                 break;
1843         case 4:
1844                 SWAP(val[0], val[3], t);
1845                 SWAP(val[1], val[2], t);
1846                 break;
1847         case 8: /* is there really any use for this? */
1848                 SWAP(val[0], val[7], t);
1849                 SWAP(val[1], val[6], t);
1850                 SWAP(val[2], val[5], t);
1851                 SWAP(val[3], val[4], t);
1852                 break;
1853         }
1854 }
1855
1856 static int brev;
1857 static int mnoread;
1858
1859 static char *memex_help_string =
1860     "Memory examine command usage:\n"
1861     "m [addr] [flags] examine/change memory\n"
1862     "  addr is optional.  will start where left off.\n"
1863     "  flags may include chars from this set:\n"
1864     "    b   modify by bytes (default)\n"
1865     "    w   modify by words (2 byte)\n"
1866     "    l   modify by longs (4 byte)\n"
1867     "    d   modify by doubleword (8 byte)\n"
1868     "    r   toggle reverse byte order mode\n"
1869     "    n   do not read memory (for i/o spaces)\n"
1870     "    .   ok to read (default)\n"
1871     "NOTE: flags are saved as defaults\n"
1872     "";
1873
1874 static char *memex_subcmd_help_string =
1875     "Memory examine subcommands:\n"
1876     "  hexval   write this val to current location\n"
1877     "  'string' write chars from string to this location\n"
1878     "  '        increment address\n"
1879     "  ^        decrement address\n"
1880     "  /        increment addr by 0x10.  //=0x100, ///=0x1000, etc\n"
1881     "  \\        decrement addr by 0x10.  \\\\=0x100, \\\\\\=0x1000, etc\n"
1882     "  `        clear no-read flag\n"
1883     "  ;        stay at this addr\n"
1884     "  v        change to byte mode\n"
1885     "  w        change to word (2 byte) mode\n"
1886     "  l        change to long (4 byte) mode\n"
1887     "  u        change to doubleword (8 byte) mode\n"
1888     "  m addr   change current addr\n"
1889     "  n        toggle no-read flag\n"
1890     "  r        toggle byte reverse flag\n"
1891     "  < count  back up count bytes\n"
1892     "  > count  skip forward count bytes\n"
1893     "  x        exit this mode\n"
1894     "";
1895
1896 static void
1897 memex(void)
1898 {
1899         int cmd, inc, i, nslash;
1900         unsigned long n;
1901         unsigned char val[16];
1902
1903         scanhex((void *)&adrs);
1904         cmd = skipbl();
1905         if (cmd == '?') {
1906                 printf(memex_help_string);
1907                 return;
1908         } else {
1909                 termch = cmd;
1910         }
1911         last_cmd = "m\n";
1912         while ((cmd = skipbl()) != '\n') {
1913                 switch( cmd ){
1914                 case 'b':       size = 1;       break;
1915                 case 'w':       size = 2;       break;
1916                 case 'l':       size = 4;       break;
1917                 case 'd':       size = 8;       break;
1918                 case 'r':       brev = !brev;   break;
1919                 case 'n':       mnoread = 1;    break;
1920                 case '.':       mnoread = 0;    break;
1921                 }
1922         }
1923         if( size <= 0 )
1924                 size = 1;
1925         else if( size > 8 )
1926                 size = 8;
1927         for(;;){
1928                 if (!mnoread)
1929                         n = mread(adrs, val, size);
1930                 printf(REG"%c", adrs, brev? 'r': ' ');
1931                 if (!mnoread) {
1932                         if (brev)
1933                                 byterev(val, size);
1934                         putchar(' ');
1935                         for (i = 0; i < n; ++i)
1936                                 printf("%.2x", val[i]);
1937                         for (; i < size; ++i)
1938                                 printf("%s", fault_chars[fault_type]);
1939                 }
1940                 putchar(' ');
1941                 inc = size;
1942                 nslash = 0;
1943                 for(;;){
1944                         if( scanhex(&n) ){
1945                                 for (i = 0; i < size; ++i)
1946                                         val[i] = n >> (i * 8);
1947                                 if (!brev)
1948                                         byterev(val, size);
1949                                 mwrite(adrs, val, size);
1950                                 inc = size;
1951                         }
1952                         cmd = skipbl();
1953                         if (cmd == '\n')
1954                                 break;
1955                         inc = 0;
1956                         switch (cmd) {
1957                         case '\'':
1958                                 for(;;){
1959                                         n = inchar();
1960                                         if( n == '\\' )
1961                                                 n = bsesc();
1962                                         else if( n == '\'' )
1963                                                 break;
1964                                         for (i = 0; i < size; ++i)
1965                                                 val[i] = n >> (i * 8);
1966                                         if (!brev)
1967                                                 byterev(val, size);
1968                                         mwrite(adrs, val, size);
1969                                         adrs += size;
1970                                 }
1971                                 adrs -= size;
1972                                 inc = size;
1973                                 break;
1974                         case ',':
1975                                 adrs += size;
1976                                 break;
1977                         case '.':
1978                                 mnoread = 0;
1979                                 break;
1980                         case ';':
1981                                 break;
1982                         case 'x':
1983                         case EOF:
1984                                 scannl();
1985                                 return;
1986                         case 'b':
1987                         case 'v':
1988                                 size = 1;
1989                                 break;
1990                         case 'w':
1991                                 size = 2;
1992                                 break;
1993                         case 'l':
1994                                 size = 4;
1995                                 break;
1996                         case 'u':
1997                                 size = 8;
1998                                 break;
1999                         case '^':
2000                                 adrs -= size;
2001                                 break;
2002                         case '/':
2003                                 if (nslash > 0)
2004                                         adrs -= 1 << nslash;
2005                                 else
2006                                         nslash = 0;
2007                                 nslash += 4;
2008                                 adrs += 1 << nslash;
2009                                 break;
2010                         case '\\':
2011                                 if (nslash < 0)
2012                                         adrs += 1 << -nslash;
2013                                 else
2014                                         nslash = 0;
2015                                 nslash -= 4;
2016                                 adrs -= 1 << -nslash;
2017                                 break;
2018                         case 'm':
2019                                 scanhex((void *)&adrs);
2020                                 break;
2021                         case 'n':
2022                                 mnoread = 1;
2023                                 break;
2024                         case 'r':
2025                                 brev = !brev;
2026                                 break;
2027                         case '<':
2028                                 n = size;
2029                                 scanhex(&n);
2030                                 adrs -= n;
2031                                 break;
2032                         case '>':
2033                                 n = size;
2034                                 scanhex(&n);
2035                                 adrs += n;
2036                                 break;
2037                         case '?':
2038                                 printf(memex_subcmd_help_string);
2039                                 break;
2040                         }
2041                 }
2042                 adrs += inc;
2043         }
2044 }
2045
2046 static int
2047 bsesc(void)
2048 {
2049         int c;
2050
2051         c = inchar();
2052         switch( c ){
2053         case 'n':       c = '\n';       break;
2054         case 'r':       c = '\r';       break;
2055         case 'b':       c = '\b';       break;
2056         case 't':       c = '\t';       break;
2057         }
2058         return c;
2059 }
2060
2061 static void xmon_rawdump (unsigned long adrs, long ndump)
2062 {
2063         long n, m, r, nr;
2064         unsigned char temp[16];
2065
2066         for (n = ndump; n > 0;) {
2067                 r = n < 16? n: 16;
2068                 nr = mread(adrs, temp, r);
2069                 adrs += nr;
2070                 for (m = 0; m < r; ++m) {
2071                         if (m < nr)
2072                                 printf("%.2x", temp[m]);
2073                         else
2074                                 printf("%s", fault_chars[fault_type]);
2075                 }
2076                 n -= r;
2077                 if (nr < r)
2078                         break;
2079         }
2080         printf("\n");
2081 }
2082
2083 #ifdef CONFIG_PPC64
2084 static void dump_one_paca(int cpu)
2085 {
2086         struct paca_struct *p;
2087 #ifdef CONFIG_PPC_STD_MMU_64
2088         int i = 0;
2089 #endif
2090
2091         if (setjmp(bus_error_jmp) != 0) {
2092                 printf("*** Error dumping paca for cpu 0x%x!\n", cpu);
2093                 return;
2094         }
2095
2096         catch_memory_errors = 1;
2097         sync();
2098
2099         p = &paca[cpu];
2100
2101         printf("paca for cpu 0x%x @ %p:\n", cpu, p);
2102
2103         printf(" %-*s = %s\n", 20, "possible", cpu_possible(cpu) ? "yes" : "no");
2104         printf(" %-*s = %s\n", 20, "present", cpu_present(cpu) ? "yes" : "no");
2105         printf(" %-*s = %s\n", 20, "online", cpu_online(cpu) ? "yes" : "no");
2106
2107 #define DUMP(paca, name, format) \
2108         printf(" %-*s = %#-*"format"\t(0x%lx)\n", 20, #name, 18, paca->name, \
2109                 offsetof(struct paca_struct, name));
2110
2111         DUMP(p, lock_token, "x");
2112         DUMP(p, paca_index, "x");
2113         DUMP(p, kernel_toc, "lx");
2114         DUMP(p, kernelbase, "lx");
2115         DUMP(p, kernel_msr, "lx");
2116         DUMP(p, emergency_sp, "p");
2117 #ifdef CONFIG_PPC_BOOK3S_64
2118         DUMP(p, mc_emergency_sp, "p");
2119         DUMP(p, in_mce, "x");
2120         DUMP(p, hmi_event_available, "x");
2121 #endif
2122         DUMP(p, data_offset, "lx");
2123         DUMP(p, hw_cpu_id, "x");
2124         DUMP(p, cpu_start, "x");
2125         DUMP(p, kexec_state, "x");
2126 #ifdef CONFIG_PPC_STD_MMU_64
2127         for (i = 0; i < SLB_NUM_BOLTED; i++) {
2128                 u64 esid, vsid;
2129
2130                 if (!p->slb_shadow_ptr)
2131                         continue;
2132
2133                 esid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].esid);
2134                 vsid = be64_to_cpu(p->slb_shadow_ptr->save_area[i].vsid);
2135
2136                 if (esid || vsid) {
2137                         printf(" slb_shadow[%d]:       = 0x%016lx 0x%016lx\n",
2138                                 i, esid, vsid);
2139                 }
2140         }
2141         DUMP(p, vmalloc_sllp, "x");
2142         DUMP(p, slb_cache_ptr, "x");
2143         for (i = 0; i < SLB_CACHE_ENTRIES; i++)
2144                 printf(" slb_cache[%d]:        = 0x%016lx\n", i, p->slb_cache[i]);
2145 #endif
2146         DUMP(p, dscr_default, "llx");
2147 #ifdef CONFIG_PPC_BOOK3E
2148         DUMP(p, pgd, "p");
2149         DUMP(p, kernel_pgd, "p");
2150         DUMP(p, tcd_ptr, "p");
2151         DUMP(p, mc_kstack, "p");
2152         DUMP(p, crit_kstack, "p");
2153         DUMP(p, dbg_kstack, "p");
2154 #endif
2155         DUMP(p, __current, "p");
2156         DUMP(p, kstack, "lx");
2157         DUMP(p, stab_rr, "lx");
2158         DUMP(p, saved_r1, "lx");
2159         DUMP(p, trap_save, "x");
2160         DUMP(p, soft_enabled, "x");
2161         DUMP(p, irq_happened, "x");
2162         DUMP(p, io_sync, "x");
2163         DUMP(p, irq_work_pending, "x");
2164         DUMP(p, nap_state_lost, "x");
2165         DUMP(p, sprg_vdso, "llx");
2166
2167 #ifdef CONFIG_PPC_TRANSACTIONAL_MEM
2168         DUMP(p, tm_scratch, "llx");
2169 #endif
2170
2171 #ifdef CONFIG_PPC_POWERNV
2172         DUMP(p, core_idle_state_ptr, "p");
2173         DUMP(p, thread_idle_state, "x");
2174         DUMP(p, thread_mask, "x");
2175         DUMP(p, subcore_sibling_mask, "x");
2176 #endif
2177
2178         DUMP(p, user_time, "llx");
2179         DUMP(p, system_time, "llx");
2180         DUMP(p, user_time_scaled, "llx");
2181         DUMP(p, starttime, "llx");
2182         DUMP(p, starttime_user, "llx");
2183         DUMP(p, startspurr, "llx");
2184         DUMP(p, utime_sspurr, "llx");
2185         DUMP(p, stolen_time, "llx");
2186 #undef DUMP
2187
2188         catch_memory_errors = 0;
2189         sync();
2190 }
2191
2192 static void dump_all_pacas(void)
2193 {
2194         int cpu;
2195
2196         if (num_possible_cpus() == 0) {
2197                 printf("No possible cpus, use 'dp #' to dump individual cpus\n");
2198                 return;
2199         }
2200
2201         for_each_possible_cpu(cpu)
2202                 dump_one_paca(cpu);
2203 }
2204
2205 static void dump_pacas(void)
2206 {
2207         unsigned long num;
2208         int c;
2209
2210         c = inchar();
2211         if (c == 'a') {
2212                 dump_all_pacas();
2213                 return;
2214         }
2215
2216         termch = c;     /* Put c back, it wasn't 'a' */
2217
2218         if (scanhex(&num))
2219                 dump_one_paca(num);
2220         else
2221                 dump_one_paca(xmon_owner);
2222 }
2223 #endif
2224
2225 static void
2226 dump(void)
2227 {
2228         int c;
2229
2230         c = inchar();
2231
2232 #ifdef CONFIG_PPC64
2233         if (c == 'p') {
2234                 xmon_start_pagination();
2235                 dump_pacas();
2236                 xmon_end_pagination();
2237                 return;
2238         }
2239 #endif
2240
2241         if ((isxdigit(c) && c != 'f' && c != 'd') || c == '\n')
2242                 termch = c;
2243         scanhex((void *)&adrs);
2244         if (termch != '\n')
2245                 termch = 0;
2246         if (c == 'i') {
2247                 scanhex(&nidump);
2248                 if (nidump == 0)
2249                         nidump = 16;
2250                 else if (nidump > MAX_DUMP)
2251                         nidump = MAX_DUMP;
2252                 adrs += ppc_inst_dump(adrs, nidump, 1);
2253                 last_cmd = "di\n";
2254         } else if (c == 'l') {
2255                 dump_log_buf();
2256         } else if (c == 'r') {
2257                 scanhex(&ndump);
2258                 if (ndump == 0)
2259                         ndump = 64;
2260                 xmon_rawdump(adrs, ndump);
2261                 adrs += ndump;
2262                 last_cmd = "dr\n";
2263         } else {
2264                 scanhex(&ndump);
2265                 if (ndump == 0)
2266                         ndump = 64;
2267                 else if (ndump > MAX_DUMP)
2268                         ndump = MAX_DUMP;
2269                 prdump(adrs, ndump);
2270                 adrs += ndump;
2271                 last_cmd = "d\n";
2272         }
2273 }
2274
2275 static void
2276 prdump(unsigned long adrs, long ndump)
2277 {
2278         long n, m, c, r, nr;
2279         unsigned char temp[16];
2280
2281         for (n = ndump; n > 0;) {
2282                 printf(REG, adrs);
2283                 putchar(' ');
2284                 r = n < 16? n: 16;
2285                 nr = mread(adrs, temp, r);
2286                 adrs += nr;
2287                 for (m = 0; m < r; ++m) {
2288                         if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2289                                 putchar(' ');
2290                         if (m < nr)
2291                                 printf("%.2x", temp[m]);
2292                         else
2293                                 printf("%s", fault_chars[fault_type]);
2294                 }
2295                 for (; m < 16; ++m) {
2296                         if ((m & (sizeof(long) - 1)) == 0)
2297                                 putchar(' ');
2298                         printf("  ");
2299                 }
2300                 printf("  |");
2301                 for (m = 0; m < r; ++m) {
2302                         if (m < nr) {
2303                                 c = temp[m];
2304                                 putchar(' ' <= c && c <= '~'? c: '.');
2305                         } else
2306                                 putchar(' ');
2307                 }
2308                 n -= r;
2309                 for (; m < 16; ++m)
2310                         putchar(' ');
2311                 printf("|\n");
2312                 if (nr < r)
2313                         break;
2314         }
2315 }
2316
2317 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr);
2318
2319 static int
2320 generic_inst_dump(unsigned long adr, long count, int praddr,
2321                         instruction_dump_func dump_func)
2322 {
2323         int nr, dotted;
2324         unsigned long first_adr;
2325         unsigned long inst, last_inst = 0;
2326         unsigned char val[4];
2327
2328         dotted = 0;
2329         for (first_adr = adr; count > 0; --count, adr += 4) {
2330                 nr = mread(adr, val, 4);
2331                 if (nr == 0) {
2332                         if (praddr) {
2333                                 const char *x = fault_chars[fault_type];
2334                                 printf(REG"  %s%s%s%s\n", adr, x, x, x, x);
2335                         }
2336                         break;
2337                 }
2338                 inst = GETWORD(val);
2339                 if (adr > first_adr && inst == last_inst) {
2340                         if (!dotted) {
2341                                 printf(" ...\n");
2342                                 dotted = 1;
2343                         }
2344                         continue;
2345                 }
2346                 dotted = 0;
2347                 last_inst = inst;
2348                 if (praddr)
2349                         printf(REG"  %.8x", adr, inst);
2350                 printf("\t");
2351                 dump_func(inst, adr);
2352                 printf("\n");
2353         }
2354         return adr - first_adr;
2355 }
2356
2357 static int
2358 ppc_inst_dump(unsigned long adr, long count, int praddr)
2359 {
2360         return generic_inst_dump(adr, count, praddr, print_insn_powerpc);
2361 }
2362
2363 void
2364 print_address(unsigned long addr)
2365 {
2366         xmon_print_symbol(addr, "\t# ", "");
2367 }
2368
2369 void
2370 dump_log_buf(void)
2371 {
2372         struct kmsg_dumper dumper = { .active = 1 };
2373         unsigned char buf[128];
2374         size_t len;
2375
2376         if (setjmp(bus_error_jmp) != 0) {
2377                 printf("Error dumping printk buffer!\n");
2378                 return;
2379         }
2380
2381         catch_memory_errors = 1;
2382         sync();
2383
2384         kmsg_dump_rewind_nolock(&dumper);
2385         xmon_start_pagination();
2386         while (kmsg_dump_get_line_nolock(&dumper, false, buf, sizeof(buf), &len)) {
2387                 buf[len] = '\0';
2388                 printf("%s", buf);
2389         }
2390         xmon_end_pagination();
2391
2392         sync();
2393         /* wait a little while to see if we get a machine check */
2394         __delay(200);
2395         catch_memory_errors = 0;
2396 }
2397
2398 /*
2399  * Memory operations - move, set, print differences
2400  */
2401 static unsigned long mdest;             /* destination address */
2402 static unsigned long msrc;              /* source address */
2403 static unsigned long mval;              /* byte value to set memory to */
2404 static unsigned long mcount;            /* # bytes to affect */
2405 static unsigned long mdiffs;            /* max # differences to print */
2406
2407 static void
2408 memops(int cmd)
2409 {
2410         scanhex((void *)&mdest);
2411         if( termch != '\n' )
2412                 termch = 0;
2413         scanhex((void *)(cmd == 's'? &mval: &msrc));
2414         if( termch != '\n' )
2415                 termch = 0;
2416         scanhex((void *)&mcount);
2417         switch( cmd ){
2418         case 'm':
2419                 memmove((void *)mdest, (void *)msrc, mcount);
2420                 break;
2421         case 's':
2422                 memset((void *)mdest, mval, mcount);
2423                 break;
2424         case 'd':
2425                 if( termch != '\n' )
2426                         termch = 0;
2427                 scanhex((void *)&mdiffs);
2428                 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
2429                 break;
2430         }
2431 }
2432
2433 static void
2434 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
2435 {
2436         unsigned n, prt;
2437
2438         prt = 0;
2439         for( n = nb; n > 0; --n )
2440                 if( *p1++ != *p2++ )
2441                         if( ++prt <= maxpr )
2442                                 printf("%.16x %.2x # %.16x %.2x\n", p1 - 1,
2443                                         p1[-1], p2 - 1, p2[-1]);
2444         if( prt > maxpr )
2445                 printf("Total of %d differences\n", prt);
2446 }
2447
2448 static unsigned mend;
2449 static unsigned mask;
2450
2451 static void
2452 memlocate(void)
2453 {
2454         unsigned a, n;
2455         unsigned char val[4];
2456
2457         last_cmd = "ml";
2458         scanhex((void *)&mdest);
2459         if (termch != '\n') {
2460                 termch = 0;
2461                 scanhex((void *)&mend);
2462                 if (termch != '\n') {
2463                         termch = 0;
2464                         scanhex((void *)&mval);
2465                         mask = ~0;
2466                         if (termch != '\n') termch = 0;
2467                         scanhex((void *)&mask);
2468                 }
2469         }
2470         n = 0;
2471         for (a = mdest; a < mend; a += 4) {
2472                 if (mread(a, val, 4) == 4
2473                         && ((GETWORD(val) ^ mval) & mask) == 0) {
2474                         printf("%.16x:  %.16x\n", a, GETWORD(val));
2475                         if (++n >= 10)
2476                                 break;
2477                 }
2478         }
2479 }
2480
2481 static unsigned long mskip = 0x1000;
2482 static unsigned long mlim = 0xffffffff;
2483
2484 static void
2485 memzcan(void)
2486 {
2487         unsigned char v;
2488         unsigned a;
2489         int ok, ook;
2490
2491         scanhex(&mdest);
2492         if (termch != '\n') termch = 0;
2493         scanhex(&mskip);
2494         if (termch != '\n') termch = 0;
2495         scanhex(&mlim);
2496         ook = 0;
2497         for (a = mdest; a < mlim; a += mskip) {
2498                 ok = mread(a, &v, 1);
2499                 if (ok && !ook) {
2500                         printf("%.8x .. ", a);
2501                 } else if (!ok && ook)
2502                         printf("%.8x\n", a - mskip);
2503                 ook = ok;
2504                 if (a + mskip < a)
2505                         break;
2506         }
2507         if (ook)
2508                 printf("%.8x\n", a - mskip);
2509 }
2510
2511 static void proccall(void)
2512 {
2513         unsigned long args[8];
2514         unsigned long ret;
2515         int i;
2516         typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
2517                         unsigned long, unsigned long, unsigned long,
2518                         unsigned long, unsigned long, unsigned long);
2519         callfunc_t func;
2520
2521         if (!scanhex(&adrs))
2522                 return;
2523         if (termch != '\n')
2524                 termch = 0;
2525         for (i = 0; i < 8; ++i)
2526                 args[i] = 0;
2527         for (i = 0; i < 8; ++i) {
2528                 if (!scanhex(&args[i]) || termch == '\n')
2529                         break;
2530                 termch = 0;
2531         }
2532         func = (callfunc_t) adrs;
2533         ret = 0;
2534         if (setjmp(bus_error_jmp) == 0) {
2535                 catch_memory_errors = 1;
2536                 sync();
2537                 ret = func(args[0], args[1], args[2], args[3],
2538                            args[4], args[5], args[6], args[7]);
2539                 sync();
2540                 printf("return value is 0x%lx\n", ret);
2541         } else {
2542                 printf("*** %x exception occurred\n", fault_except);
2543         }
2544         catch_memory_errors = 0;
2545 }
2546
2547 /* Input scanning routines */
2548 int
2549 skipbl(void)
2550 {
2551         int c;
2552
2553         if( termch != 0 ){
2554                 c = termch;
2555                 termch = 0;
2556         } else
2557                 c = inchar();
2558         while( c == ' ' || c == '\t' )
2559                 c = inchar();
2560         return c;
2561 }
2562
2563 #define N_PTREGS        44
2564 static char *regnames[N_PTREGS] = {
2565         "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2566         "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2567         "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2568         "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
2569         "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
2570 #ifdef CONFIG_PPC64
2571         "softe",
2572 #else
2573         "mq",
2574 #endif
2575         "trap", "dar", "dsisr", "res"
2576 };
2577
2578 int
2579 scanhex(unsigned long *vp)
2580 {
2581         int c, d;
2582         unsigned long v;
2583
2584         c = skipbl();
2585         if (c == '%') {
2586                 /* parse register name */
2587                 char regname[8];
2588                 int i;
2589
2590                 for (i = 0; i < sizeof(regname) - 1; ++i) {
2591                         c = inchar();
2592                         if (!isalnum(c)) {
2593                                 termch = c;
2594                                 break;
2595                         }
2596                         regname[i] = c;
2597                 }
2598                 regname[i] = 0;
2599                 for (i = 0; i < N_PTREGS; ++i) {
2600                         if (strcmp(regnames[i], regname) == 0) {
2601                                 if (xmon_regs == NULL) {
2602                                         printf("regs not available\n");
2603                                         return 0;
2604                                 }
2605                                 *vp = ((unsigned long *)xmon_regs)[i];
2606                                 return 1;
2607                         }
2608                 }
2609                 printf("invalid register name '%%%s'\n", regname);
2610                 return 0;
2611         }
2612
2613         /* skip leading "0x" if any */
2614
2615         if (c == '0') {
2616                 c = inchar();
2617                 if (c == 'x') {
2618                         c = inchar();
2619                 } else {
2620                         d = hexdigit(c);
2621                         if (d == EOF) {
2622                                 termch = c;
2623                                 *vp = 0;
2624                                 return 1;
2625                         }
2626                 }
2627         } else if (c == '$') {
2628                 int i;
2629                 for (i=0; i<63; i++) {
2630                         c = inchar();
2631                         if (isspace(c) || c == '\0') {
2632                                 termch = c;
2633                                 break;
2634                         }
2635                         tmpstr[i] = c;
2636                 }
2637                 tmpstr[i++] = 0;
2638                 *vp = 0;
2639                 if (setjmp(bus_error_jmp) == 0) {
2640                         catch_memory_errors = 1;
2641                         sync();
2642                         *vp = kallsyms_lookup_name(tmpstr);
2643                         sync();
2644                 }
2645                 catch_memory_errors = 0;
2646                 if (!(*vp)) {
2647                         printf("unknown symbol '%s'\n", tmpstr);
2648                         return 0;
2649                 }
2650                 return 1;
2651         }
2652
2653         d = hexdigit(c);
2654         if (d == EOF) {
2655                 termch = c;
2656                 return 0;
2657         }
2658         v = 0;
2659         do {
2660                 v = (v << 4) + d;
2661                 c = inchar();
2662                 d = hexdigit(c);
2663         } while (d != EOF);
2664         termch = c;
2665         *vp = v;
2666         return 1;
2667 }
2668
2669 static void
2670 scannl(void)
2671 {
2672         int c;
2673
2674         c = termch;
2675         termch = 0;
2676         while( c != '\n' )
2677                 c = inchar();
2678 }
2679
2680 static int hexdigit(int c)
2681 {
2682         if( '0' <= c && c <= '9' )
2683                 return c - '0';
2684         if( 'A' <= c && c <= 'F' )
2685                 return c - ('A' - 10);
2686         if( 'a' <= c && c <= 'f' )
2687                 return c - ('a' - 10);
2688         return EOF;
2689 }
2690
2691 void
2692 getstring(char *s, int size)
2693 {
2694         int c;
2695
2696         c = skipbl();
2697         do {
2698                 if( size > 1 ){
2699                         *s++ = c;
2700                         --size;
2701                 }
2702                 c = inchar();
2703         } while( c != ' ' && c != '\t' && c != '\n' );
2704         termch = c;
2705         *s = 0;
2706 }
2707
2708 static char line[256];
2709 static char *lineptr;
2710
2711 static void
2712 flush_input(void)
2713 {
2714         lineptr = NULL;
2715 }
2716
2717 static int
2718 inchar(void)
2719 {
2720         if (lineptr == NULL || *lineptr == 0) {
2721                 if (xmon_gets(line, sizeof(line)) == NULL) {
2722                         lineptr = NULL;
2723                         return EOF;
2724                 }
2725                 lineptr = line;
2726         }
2727         return *lineptr++;
2728 }
2729
2730 static void
2731 take_input(char *str)
2732 {
2733         lineptr = str;
2734 }
2735
2736
2737 static void
2738 symbol_lookup(void)
2739 {
2740         int type = inchar();
2741         unsigned long addr;
2742         static char tmp[64];
2743
2744         switch (type) {
2745         case 'a':
2746                 if (scanhex(&addr))
2747                         xmon_print_symbol(addr, ": ", "\n");
2748                 termch = 0;
2749                 break;
2750         case 's':
2751                 getstring(tmp, 64);
2752                 if (setjmp(bus_error_jmp) == 0) {
2753                         catch_memory_errors = 1;
2754                         sync();
2755                         addr = kallsyms_lookup_name(tmp);
2756                         if (addr)
2757                                 printf("%s: %lx\n", tmp, addr);
2758                         else
2759                                 printf("Symbol '%s' not found.\n", tmp);
2760                         sync();
2761                 }
2762                 catch_memory_errors = 0;
2763                 termch = 0;
2764                 break;
2765         }
2766 }
2767
2768
2769 /* Print an address in numeric and symbolic form (if possible) */
2770 static void xmon_print_symbol(unsigned long address, const char *mid,
2771                               const char *after)
2772 {
2773         char *modname;
2774         const char *name = NULL;
2775         unsigned long offset, size;
2776
2777         printf(REG, address);
2778         if (setjmp(bus_error_jmp) == 0) {
2779                 catch_memory_errors = 1;
2780                 sync();
2781                 name = kallsyms_lookup(address, &size, &offset, &modname,
2782                                        tmpstr);
2783                 sync();
2784                 /* wait a little while to see if we get a machine check */
2785                 __delay(200);
2786         }
2787
2788         catch_memory_errors = 0;
2789
2790         if (name) {
2791                 printf("%s%s+%#lx/%#lx", mid, name, offset, size);
2792                 if (modname)
2793                         printf(" [%s]", modname);
2794         }
2795         printf("%s", after);
2796 }
2797
2798 #ifdef CONFIG_PPC_BOOK3S_64
2799 void dump_segments(void)
2800 {
2801         int i;
2802         unsigned long esid,vsid;
2803         unsigned long llp;
2804
2805         printf("SLB contents of cpu 0x%x\n", smp_processor_id());
2806
2807         for (i = 0; i < mmu_slb_size; i++) {
2808                 asm volatile("slbmfee  %0,%1" : "=r" (esid) : "r" (i));
2809                 asm volatile("slbmfev  %0,%1" : "=r" (vsid) : "r" (i));
2810                 if (esid || vsid) {
2811                         printf("%02d %016lx %016lx", i, esid, vsid);
2812                         if (esid & SLB_ESID_V) {
2813                                 llp = vsid & SLB_VSID_LLP;
2814                                 if (vsid & SLB_VSID_B_1T) {
2815                                         printf("  1T  ESID=%9lx  VSID=%13lx LLP:%3lx \n",
2816                                                 GET_ESID_1T(esid),
2817                                                 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T,
2818                                                 llp);
2819                                 } else {
2820                                         printf(" 256M ESID=%9lx  VSID=%13lx LLP:%3lx \n",
2821                                                 GET_ESID(esid),
2822                                                 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT,
2823                                                 llp);
2824                                 }
2825                         } else
2826                                 printf("\n");
2827                 }
2828         }
2829 }
2830 #endif
2831
2832 #ifdef CONFIG_PPC_STD_MMU_32
2833 void dump_segments(void)
2834 {
2835         int i;
2836
2837         printf("sr0-15 =");
2838         for (i = 0; i < 16; ++i)
2839                 printf(" %x", mfsrin(i));
2840         printf("\n");
2841 }
2842 #endif
2843
2844 #ifdef CONFIG_44x
2845 static void dump_tlb_44x(void)
2846 {
2847         int i;
2848
2849         for (i = 0; i < PPC44x_TLB_SIZE; i++) {
2850                 unsigned long w0,w1,w2;
2851                 asm volatile("tlbre  %0,%1,0" : "=r" (w0) : "r" (i));
2852                 asm volatile("tlbre  %0,%1,1" : "=r" (w1) : "r" (i));
2853                 asm volatile("tlbre  %0,%1,2" : "=r" (w2) : "r" (i));
2854                 printf("[%02x] %08x %08x %08x ", i, w0, w1, w2);
2855                 if (w0 & PPC44x_TLB_VALID) {
2856                         printf("V %08x -> %01x%08x %c%c%c%c%c",
2857                                w0 & PPC44x_TLB_EPN_MASK,
2858                                w1 & PPC44x_TLB_ERPN_MASK,
2859                                w1 & PPC44x_TLB_RPN_MASK,
2860                                (w2 & PPC44x_TLB_W) ? 'W' : 'w',
2861                                (w2 & PPC44x_TLB_I) ? 'I' : 'i',
2862                                (w2 & PPC44x_TLB_M) ? 'M' : 'm',
2863                                (w2 & PPC44x_TLB_G) ? 'G' : 'g',
2864                                (w2 & PPC44x_TLB_E) ? 'E' : 'e');
2865                 }
2866                 printf("\n");
2867         }
2868 }
2869 #endif /* CONFIG_44x */
2870
2871 #ifdef CONFIG_PPC_BOOK3E
2872 static void dump_tlb_book3e(void)
2873 {
2874         u32 mmucfg, pidmask, lpidmask;
2875         u64 ramask;
2876         int i, tlb, ntlbs, pidsz, lpidsz, rasz, lrat = 0;
2877         int mmu_version;
2878         static const char *pgsz_names[] = {
2879                 "  1K",
2880                 "  2K",
2881                 "  4K",
2882                 "  8K",
2883                 " 16K",
2884                 " 32K",
2885                 " 64K",
2886                 "128K",
2887                 "256K",
2888                 "512K",
2889                 "  1M",
2890                 "  2M",
2891                 "  4M",
2892                 "  8M",
2893                 " 16M",
2894                 " 32M",
2895                 " 64M",
2896                 "128M",
2897                 "256M",
2898                 "512M",
2899                 "  1G",
2900                 "  2G",
2901                 "  4G",
2902                 "  8G",
2903                 " 16G",
2904                 " 32G",
2905                 " 64G",
2906                 "128G",
2907                 "256G",
2908                 "512G",
2909                 "  1T",
2910                 "  2T",
2911         };
2912
2913         /* Gather some infos about the MMU */
2914         mmucfg = mfspr(SPRN_MMUCFG);
2915         mmu_version = (mmucfg & 3) + 1;
2916         ntlbs = ((mmucfg >> 2) & 3) + 1;
2917         pidsz = ((mmucfg >> 6) & 0x1f) + 1;
2918         lpidsz = (mmucfg >> 24) & 0xf;
2919         rasz = (mmucfg >> 16) & 0x7f;
2920         if ((mmu_version > 1) && (mmucfg & 0x10000))
2921                 lrat = 1;
2922         printf("Book3E MMU MAV=%d.0,%d TLBs,%d-bit PID,%d-bit LPID,%d-bit RA\n",
2923                mmu_version, ntlbs, pidsz, lpidsz, rasz);
2924         pidmask = (1ul << pidsz) - 1;
2925         lpidmask = (1ul << lpidsz) - 1;
2926         ramask = (1ull << rasz) - 1;
2927
2928         for (tlb = 0; tlb < ntlbs; tlb++) {
2929                 u32 tlbcfg;
2930                 int nent, assoc, new_cc = 1;
2931                 printf("TLB %d:\n------\n", tlb);
2932                 switch(tlb) {
2933                 case 0:
2934                         tlbcfg = mfspr(SPRN_TLB0CFG);
2935                         break;
2936                 case 1:
2937                         tlbcfg = mfspr(SPRN_TLB1CFG);
2938                         break;
2939                 case 2:
2940                         tlbcfg = mfspr(SPRN_TLB2CFG);
2941                         break;
2942                 case 3:
2943                         tlbcfg = mfspr(SPRN_TLB3CFG);
2944                         break;
2945                 default:
2946                         printf("Unsupported TLB number !\n");
2947                         continue;
2948                 }
2949                 nent = tlbcfg & 0xfff;
2950                 assoc = (tlbcfg >> 24) & 0xff;
2951                 for (i = 0; i < nent; i++) {
2952                         u32 mas0 = MAS0_TLBSEL(tlb);
2953                         u32 mas1 = MAS1_TSIZE(BOOK3E_PAGESZ_4K);
2954                         u64 mas2 = 0;
2955                         u64 mas7_mas3;
2956                         int esel = i, cc = i;
2957
2958                         if (assoc != 0) {
2959                                 cc = i / assoc;
2960                                 esel = i % assoc;
2961                                 mas2 = cc * 0x1000;
2962                         }
2963
2964                         mas0 |= MAS0_ESEL(esel);
2965                         mtspr(SPRN_MAS0, mas0);
2966                         mtspr(SPRN_MAS1, mas1);
2967                         mtspr(SPRN_MAS2, mas2);
2968                         asm volatile("tlbre  0,0,0" : : : "memory");
2969                         mas1 = mfspr(SPRN_MAS1);
2970                         mas2 = mfspr(SPRN_MAS2);
2971                         mas7_mas3 = mfspr(SPRN_MAS7_MAS3);
2972                         if (assoc && (i % assoc) == 0)
2973                                 new_cc = 1;
2974                         if (!(mas1 & MAS1_VALID))
2975                                 continue;
2976                         if (assoc == 0)
2977                                 printf("%04x- ", i);
2978                         else if (new_cc)
2979                                 printf("%04x-%c", cc, 'A' + esel);
2980                         else
2981                                 printf("    |%c", 'A' + esel);
2982                         new_cc = 0;
2983                         printf(" %016llx %04x %s %c%c AS%c",
2984                                mas2 & ~0x3ffull,
2985                                (mas1 >> 16) & 0x3fff,
2986                                pgsz_names[(mas1 >> 7) & 0x1f],
2987                                mas1 & MAS1_IND ? 'I' : ' ',
2988                                mas1 & MAS1_IPROT ? 'P' : ' ',
2989                                mas1 & MAS1_TS ? '1' : '0');
2990                         printf(" %c%c%c%c%c%c%c",
2991                                mas2 & MAS2_X0 ? 'a' : ' ',
2992                                mas2 & MAS2_X1 ? 'v' : ' ',
2993                                mas2 & MAS2_W  ? 'w' : ' ',
2994                                mas2 & MAS2_I  ? 'i' : ' ',
2995                                mas2 & MAS2_M  ? 'm' : ' ',
2996                                mas2 & MAS2_G  ? 'g' : ' ',
2997                                mas2 & MAS2_E  ? 'e' : ' ');
2998                         printf(" %016llx", mas7_mas3 & ramask & ~0x7ffull);
2999                         if (mas1 & MAS1_IND)
3000                                 printf(" %s\n",
3001                                        pgsz_names[(mas7_mas3 >> 1) & 0x1f]);
3002                         else
3003                                 printf(" U%c%c%c S%c%c%c\n",
3004                                        mas7_mas3 & MAS3_UX ? 'x' : ' ',
3005                                        mas7_mas3 & MAS3_UW ? 'w' : ' ',
3006                                        mas7_mas3 & MAS3_UR ? 'r' : ' ',
3007                                        mas7_mas3 & MAS3_SX ? 'x' : ' ',
3008                                        mas7_mas3 & MAS3_SW ? 'w' : ' ',
3009                                        mas7_mas3 & MAS3_SR ? 'r' : ' ');
3010                 }
3011         }
3012 }
3013 #endif /* CONFIG_PPC_BOOK3E */
3014
3015 static void xmon_init(int enable)
3016 {
3017         if (enable) {
3018                 __debugger = xmon;
3019                 __debugger_ipi = xmon_ipi;
3020                 __debugger_bpt = xmon_bpt;
3021                 __debugger_sstep = xmon_sstep;
3022                 __debugger_iabr_match = xmon_iabr_match;
3023                 __debugger_break_match = xmon_break_match;
3024                 __debugger_fault_handler = xmon_fault_handler;
3025         } else {
3026                 __debugger = NULL;
3027                 __debugger_ipi = NULL;
3028                 __debugger_bpt = NULL;
3029                 __debugger_sstep = NULL;
3030                 __debugger_iabr_match = NULL;
3031                 __debugger_break_match = NULL;
3032                 __debugger_fault_handler = NULL;
3033         }
3034 }
3035
3036 #ifdef CONFIG_MAGIC_SYSRQ
3037 static void sysrq_handle_xmon(int key)
3038 {
3039         /* ensure xmon is enabled */
3040         xmon_init(1);
3041         debugger(get_irq_regs());
3042 }
3043
3044 static struct sysrq_key_op sysrq_xmon_op = {
3045         .handler =      sysrq_handle_xmon,
3046         .help_msg =     "xmon(x)",
3047         .action_msg =   "Entering xmon",
3048 };
3049
3050 static int __init setup_xmon_sysrq(void)
3051 {
3052         register_sysrq_key('x', &sysrq_xmon_op);
3053         return 0;
3054 }
3055 __initcall(setup_xmon_sysrq);
3056 #endif /* CONFIG_MAGIC_SYSRQ */
3057
3058 static int __initdata xmon_early, xmon_off;
3059
3060 static int __init early_parse_xmon(char *p)
3061 {
3062         if (!p || strncmp(p, "early", 5) == 0) {
3063                 /* just "xmon" is equivalent to "xmon=early" */
3064                 xmon_init(1);
3065                 xmon_early = 1;
3066         } else if (strncmp(p, "on", 2) == 0)
3067                 xmon_init(1);
3068         else if (strncmp(p, "off", 3) == 0)
3069                 xmon_off = 1;
3070         else if (strncmp(p, "nobt", 4) == 0)
3071                 xmon_no_auto_backtrace = 1;
3072         else
3073                 return 1;
3074
3075         return 0;
3076 }
3077 early_param("xmon", early_parse_xmon);
3078
3079 void __init xmon_setup(void)
3080 {
3081 #ifdef CONFIG_XMON_DEFAULT
3082         if (!xmon_off)
3083                 xmon_init(1);
3084 #endif
3085         if (xmon_early)
3086                 debugger(NULL);
3087 }
3088
3089 #ifdef CONFIG_SPU_BASE
3090
3091 struct spu_info {
3092         struct spu *spu;
3093         u64 saved_mfc_sr1_RW;
3094         u32 saved_spu_runcntl_RW;
3095         unsigned long dump_addr;
3096         u8 stopped_ok;
3097 };
3098
3099 #define XMON_NUM_SPUS   16      /* Enough for current hardware */
3100
3101 static struct spu_info spu_info[XMON_NUM_SPUS];
3102
3103 void xmon_register_spus(struct list_head *list)
3104 {
3105         struct spu *spu;
3106
3107         list_for_each_entry(spu, list, full_list) {
3108                 if (spu->number >= XMON_NUM_SPUS) {
3109                         WARN_ON(1);
3110                         continue;
3111                 }
3112
3113                 spu_info[spu->number].spu = spu;
3114                 spu_info[spu->number].stopped_ok = 0;
3115                 spu_info[spu->number].dump_addr = (unsigned long)
3116                                 spu_info[spu->number].spu->local_store;
3117         }
3118 }
3119
3120 static void stop_spus(void)
3121 {
3122         struct spu *spu;
3123         int i;
3124         u64 tmp;
3125
3126         for (i = 0; i < XMON_NUM_SPUS; i++) {
3127                 if (!spu_info[i].spu)
3128                         continue;
3129
3130                 if (setjmp(bus_error_jmp) == 0) {
3131                         catch_memory_errors = 1;
3132                         sync();
3133
3134                         spu = spu_info[i].spu;
3135
3136                         spu_info[i].saved_spu_runcntl_RW =
3137                                 in_be32(&spu->problem->spu_runcntl_RW);
3138
3139                         tmp = spu_mfc_sr1_get(spu);
3140                         spu_info[i].saved_mfc_sr1_RW = tmp;
3141
3142                         tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
3143                         spu_mfc_sr1_set(spu, tmp);
3144
3145                         sync();
3146                         __delay(200);
3147
3148                         spu_info[i].stopped_ok = 1;
3149
3150                         printf("Stopped spu %.2d (was %s)\n", i,
3151                                         spu_info[i].saved_spu_runcntl_RW ?
3152                                         "running" : "stopped");
3153                 } else {
3154                         catch_memory_errors = 0;
3155                         printf("*** Error stopping spu %.2d\n", i);
3156                 }
3157                 catch_memory_errors = 0;
3158         }
3159 }
3160
3161 static void restart_spus(void)
3162 {
3163         struct spu *spu;
3164         int i;
3165
3166         for (i = 0; i < XMON_NUM_SPUS; i++) {
3167                 if (!spu_info[i].spu)
3168                         continue;
3169
3170                 if (!spu_info[i].stopped_ok) {
3171                         printf("*** Error, spu %d was not successfully stopped"
3172                                         ", not restarting\n", i);
3173                         continue;
3174                 }
3175
3176                 if (setjmp(bus_error_jmp) == 0) {
3177                         catch_memory_errors = 1;
3178                         sync();
3179
3180                         spu = spu_info[i].spu;
3181                         spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW);
3182                         out_be32(&spu->problem->spu_runcntl_RW,
3183                                         spu_info[i].saved_spu_runcntl_RW);
3184
3185                         sync();
3186                         __delay(200);
3187
3188                         printf("Restarted spu %.2d\n", i);
3189                 } else {
3190                         catch_memory_errors = 0;
3191                         printf("*** Error restarting spu %.2d\n", i);
3192                 }
3193                 catch_memory_errors = 0;
3194         }
3195 }
3196
3197 #define DUMP_WIDTH      23
3198 #define DUMP_VALUE(format, field, value)                                \
3199 do {                                                                    \
3200         if (setjmp(bus_error_jmp) == 0) {                               \
3201                 catch_memory_errors = 1;                                \
3202                 sync();                                                 \
3203                 printf("  %-*s = "format"\n", DUMP_WIDTH,               \
3204                                 #field, value);                         \
3205                 sync();                                                 \
3206                 __delay(200);                                           \
3207         } else {                                                        \
3208                 catch_memory_errors = 0;                                \
3209                 printf("  %-*s = *** Error reading field.\n",           \
3210                                         DUMP_WIDTH, #field);            \
3211         }                                                               \
3212         catch_memory_errors = 0;                                        \
3213 } while (0)
3214
3215 #define DUMP_FIELD(obj, format, field)  \
3216         DUMP_VALUE(format, field, obj->field)
3217
3218 static void dump_spu_fields(struct spu *spu)
3219 {
3220         printf("Dumping spu fields at address %p:\n", spu);
3221
3222         DUMP_FIELD(spu, "0x%x", number);
3223         DUMP_FIELD(spu, "%s", name);
3224         DUMP_FIELD(spu, "0x%lx", local_store_phys);
3225         DUMP_FIELD(spu, "0x%p", local_store);
3226         DUMP_FIELD(spu, "0x%lx", ls_size);
3227         DUMP_FIELD(spu, "0x%x", node);
3228         DUMP_FIELD(spu, "0x%lx", flags);
3229         DUMP_FIELD(spu, "%d", class_0_pending);
3230         DUMP_FIELD(spu, "0x%lx", class_0_dar);
3231         DUMP_FIELD(spu, "0x%lx", class_1_dar);
3232         DUMP_FIELD(spu, "0x%lx", class_1_dsisr);
3233         DUMP_FIELD(spu, "0x%lx", irqs[0]);
3234         DUMP_FIELD(spu, "0x%lx", irqs[1]);
3235         DUMP_FIELD(spu, "0x%lx", irqs[2]);
3236         DUMP_FIELD(spu, "0x%x", slb_replace);
3237         DUMP_FIELD(spu, "%d", pid);
3238         DUMP_FIELD(spu, "0x%p", mm);
3239         DUMP_FIELD(spu, "0x%p", ctx);
3240         DUMP_FIELD(spu, "0x%p", rq);
3241         DUMP_FIELD(spu, "0x%p", timestamp);
3242         DUMP_FIELD(spu, "0x%lx", problem_phys);
3243         DUMP_FIELD(spu, "0x%p", problem);
3244         DUMP_VALUE("0x%x", problem->spu_runcntl_RW,
3245                         in_be32(&spu->problem->spu_runcntl_RW));
3246         DUMP_VALUE("0x%x", problem->spu_status_R,
3247                         in_be32(&spu->problem->spu_status_R));
3248         DUMP_VALUE("0x%x", problem->spu_npc_RW,
3249                         in_be32(&spu->problem->spu_npc_RW));
3250         DUMP_FIELD(spu, "0x%p", priv2);
3251         DUMP_FIELD(spu, "0x%p", pdata);
3252 }
3253
3254 int
3255 spu_inst_dump(unsigned long adr, long count, int praddr)
3256 {
3257         return generic_inst_dump(adr, count, praddr, print_insn_spu);
3258 }
3259
3260 static void dump_spu_ls(unsigned long num, int subcmd)
3261 {
3262         unsigned long offset, addr, ls_addr;
3263
3264         if (setjmp(bus_error_jmp) == 0) {
3265                 catch_memory_errors = 1;
3266                 sync();
3267                 ls_addr = (unsigned long)spu_info[num].spu->local_store;
3268                 sync();
3269                 __delay(200);
3270         } else {
3271                 catch_memory_errors = 0;
3272                 printf("*** Error: accessing spu info for spu %d\n", num);
3273                 return;
3274         }
3275         catch_memory_errors = 0;
3276
3277         if (scanhex(&offset))
3278                 addr = ls_addr + offset;
3279         else
3280                 addr = spu_info[num].dump_addr;
3281
3282         if (addr >= ls_addr + LS_SIZE) {
3283                 printf("*** Error: address outside of local store\n");
3284                 return;
3285         }
3286
3287         switch (subcmd) {
3288         case 'i':
3289                 addr += spu_inst_dump(addr, 16, 1);
3290                 last_cmd = "sdi\n";
3291                 break;
3292         default:
3293                 prdump(addr, 64);
3294                 addr += 64;
3295                 last_cmd = "sd\n";
3296                 break;
3297         }
3298
3299         spu_info[num].dump_addr = addr;
3300 }
3301
3302 static int do_spu_cmd(void)
3303 {
3304         static unsigned long num = 0;
3305         int cmd, subcmd = 0;
3306
3307         cmd = inchar();
3308         switch (cmd) {
3309         case 's':
3310                 stop_spus();
3311                 break;
3312         case 'r':
3313                 restart_spus();
3314                 break;
3315         case 'd':
3316                 subcmd = inchar();
3317                 if (isxdigit(subcmd) || subcmd == '\n')
3318                         termch = subcmd;
3319         case 'f':
3320                 scanhex(&num);
3321                 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) {
3322                         printf("*** Error: invalid spu number\n");
3323                         return 0;
3324                 }
3325
3326                 switch (cmd) {
3327                 case 'f':
3328                         dump_spu_fields(spu_info[num].spu);
3329                         break;
3330                 default:
3331                         dump_spu_ls(num, subcmd);
3332                         break;
3333                 }
3334
3335                 break;
3336         default:
3337                 return -1;
3338         }
3339
3340         return 0;
3341 }
3342 #else /* ! CONFIG_SPU_BASE */
3343 static int do_spu_cmd(void)
3344 {
3345         return -1;
3346 }
3347 #endif