arch/powerpc/xmon/xmon.c

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