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