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