arch/powerpc/xmon/xmon.c

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