arch/powerpc/xmon/xmon.c

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