arch/powerpc/xmon/xmon.c

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