arch/powerpc/xmon/xmon.c

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