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