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