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