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