?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: make sure initmem is writable on 64-bit
[linux-2.6/mini2440.git] / arch / powerpc / xmon / xmon.c
blob8dfad7d9a0043298867d6b523347c57457e114b8
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 #include <linux/errno.h>
14 #include <linux/sched.h>
15 #include <linux/smp.h>
16 #include <linux/mm.h>
17 #include <linux/reboot.h>
18 #include <linux/delay.h>
19 #include <linux/kallsyms.h>
20 #include <linux/cpumask.h>
21 #include <linux/module.h>
22 #include <linux/sysrq.h>
23 #include <linux/interrupt.h>
24 #include <linux/irq.h>
25 #include <linux/bug.h>
26
27 #include <asm/ptrace.h>
28 #include <asm/string.h>
29 #include <asm/prom.h>
30 #include <asm/machdep.h>
31 #include <asm/xmon.h>
32 #include <asm/processor.h>
33 #include <asm/pgtable.h>
34 #include <asm/mmu.h>
35 #include <asm/mmu_context.h>
36 #include <asm/cputable.h>
37 #include <asm/rtas.h>
38 #include <asm/sstep.h>
39 #include <asm/irq_regs.h>
40 #include <asm/spu.h>
41 #include <asm/spu_priv1.h>
42 #include <asm/firmware.h>
43 #include <asm/setjmp.h>
44 #include <asm/reg.h>
45
46 #ifdef CONFIG_PPC64
47 #include <asm/hvcall.h>
48 #include <asm/paca.h>
49 #endif
50
51 #include "nonstdio.h"
52 #include "dis-asm.h"
53
54 #define scanhex xmon_scanhex
55 #define skipbl xmon_skipbl
56
57 #ifdef CONFIG_SMP
58 static cpumask_t cpus_in_xmon = CPU_MASK_NONE;
59 static unsigned long xmon_taken = 1;
60 static int xmon_owner;
61 static int xmon_gate;
62 #endif /* CONFIG_SMP */
63
64 static unsigned long in_xmon = 0;
65
66 static unsigned long adrs;
67 static int size = 1;
68 #define MAX_DUMP (128 * 1024)
69 static unsigned long ndump = 64;
70 static unsigned long nidump = 16;
71 static unsigned long ncsum = 4096;
72 static int termch;
73 static char tmpstr[128];
74
75 static long bus_error_jmp[JMP_BUF_LEN];
76 static int catch_memory_errors;
77 static long *xmon_fault_jmp[NR_CPUS];
78
79 /* Breakpoint stuff */
80 struct bpt {
81 unsigned long address;
82 unsigned int instr[2];
83 atomic_t ref_count;
84 int enabled;
85 unsigned long pad;
86 };
87
88 /* Bits in bpt.enabled */
89 #define BP_IABR_TE 1 /* IABR translation enabled */
90 #define BP_IABR 2
91 #define BP_TRAP 8
92 #define BP_DABR 0x10
93
94 #define NBPTS 256
95 static struct bpt bpts[NBPTS];
96 static struct bpt dabr;
97 static struct bpt *iabr;
98 static unsigned bpinstr = 0x7fe00008; /* trap */
99
100 #define BP_NUM(bp) ((bp) - bpts + 1)
101
102 /* Prototypes */
103 static int cmds(struct pt_regs *);
104 static int mread(unsigned long, void *, int);
105 static int mwrite(unsigned long, void *, int);
106 static int handle_fault(struct pt_regs *);
107 static void byterev(unsigned char *, int);
108 static void memex(void);
109 static int bsesc(void);
110 static void dump(void);
111 static void prdump(unsigned long, long);
112 static int ppc_inst_dump(unsigned long, long, int);
113 static void backtrace(struct pt_regs *);
114 static void excprint(struct pt_regs *);
115 static void prregs(struct pt_regs *);
116 static void memops(int);
117 static void memlocate(void);
118 static void memzcan(void);
119 static void memdiffs(unsigned char *, unsigned char *, unsigned, unsigned);
120 int skipbl(void);
121 int scanhex(unsigned long *valp);
122 static void scannl(void);
123 static int hexdigit(int);
124 void getstring(char *, int);
125 static void flush_input(void);
126 static int inchar(void);
127 static void take_input(char *);
128 static unsigned long read_spr(int);
129 static void write_spr(int, unsigned long);
130 static void super_regs(void);
131 static void remove_bpts(void);
132 static void insert_bpts(void);
133 static void remove_cpu_bpts(void);
134 static void insert_cpu_bpts(void);
135 static struct bpt *at_breakpoint(unsigned long pc);
136 static struct bpt *in_breakpoint_table(unsigned long pc, unsigned long *offp);
137 static int do_step(struct pt_regs *);
138 static void bpt_cmds(void);
139 static void cacheflush(void);
140 static int cpu_cmd(void);
141 static void csum(void);
142 static void bootcmds(void);
143 static void proccall(void);
144 void dump_segments(void);
145 static void symbol_lookup(void);
146 static void xmon_show_stack(unsigned long sp, unsigned long lr,
147 unsigned long pc);
148 static void xmon_print_symbol(unsigned long address, const char *mid,
149 const char *after);
150 static const char *getvecname(unsigned long vec);
151
152 static int do_spu_cmd(void);
153
154 #ifdef CONFIG_44x
155 static void dump_tlb_44x(void);
156 #endif
157
158 static int xmon_no_auto_backtrace;
159
160 extern void xmon_enter(void);
161 extern void xmon_leave(void);
162
163 #ifdef CONFIG_PPC64
164 #define REG "%.16lx"
165 #define REGS_PER_LINE 4
166 #define LAST_VOLATILE 13
167 #else
168 #define REG "%.8lx"
169 #define REGS_PER_LINE 8
170 #define LAST_VOLATILE 12
171 #endif
172
173 #define GETWORD(v) (((v)[0] << 24) + ((v)[1] << 16) + ((v)[2] << 8) + (v)[3])
174
175 #define isxdigit(c) (('0' <= (c) && (c) <= '9') \
176 || ('a' <= (c) && (c) <= 'f') \
177 || ('A' <= (c) && (c) <= 'F'))
178 #define isalnum(c) (('0' <= (c) && (c) <= '9') \
179 || ('a' <= (c) && (c) <= 'z') \
180 || ('A' <= (c) && (c) <= 'Z'))
181 #define isspace(c) (c == ' ' || c == '\t' || c == 10 || c == 13 || c == 0)
182
183 static char *help_string = "\
184 Commands:\n\
185 b show breakpoints\n\
186 bd set data breakpoint\n\
187 bi set instruction breakpoint\n\
188 bc clear breakpoint\n"
189 #ifdef CONFIG_SMP
190 "\
191 c print cpus stopped in xmon\n\
192 c# try to switch to cpu number h (in hex)\n"
193 #endif
194 "\
195 C checksum\n\
196 d dump bytes\n\
197 di dump instructions\n\
198 df dump float values\n\
199 dd dump double values\n\
200 dr dump stream of raw bytes\n\
201 e print exception information\n\
202 f flush cache\n\
203 la lookup symbol+offset of specified address\n\
204 ls lookup address of specified symbol\n\
205 m examine/change memory\n\
206 mm move a block of memory\n\
207 ms set a block of memory\n\
208 md compare two blocks of memory\n\
209 ml locate a block of memory\n\
210 mz zero a block of memory\n\
211 mi show information about memory allocation\n\
212 p call a procedure\n\
213 r print registers\n\
214 s single step\n"
215 #ifdef CONFIG_SPU_BASE
216 " ss stop execution on all spus\n\
217 sr restore execution on stopped spus\n\
218 sf # dump spu fields for spu # (in hex)\n\
219 sd # dump spu local store for spu # (in hex)\n\
220 sdi # disassemble spu local store for spu # (in hex)\n"
221 #endif
222 " S print special registers\n\
223 t print backtrace\n\
224 x exit monitor and recover\n\
225 X exit monitor and dont recover\n"
226 #ifdef CONFIG_PPC64
227 " u dump segment table or SLB\n"
228 #endif
229 #ifdef CONFIG_PPC_STD_MMU_32
230 " u dump segment registers\n"
231 #endif
232 #ifdef CONFIG_44x
233 " u dump TLB\n"
234 #endif
235 " ? help\n"
236 " zr reboot\n\
237 zh halt\n"
238 ;
239
240 static struct pt_regs *xmon_regs;
241
242 static inline void sync(void)
243 {
244 asm volatile("sync; isync");
245 }
246
247 static inline void store_inst(void *p)
248 {
249 asm volatile ("dcbst 0,%0; sync; icbi 0,%0; isync" : : "r" (p));
250 }
251
252 static inline void cflush(void *p)
253 {
254 asm volatile ("dcbf 0,%0; icbi 0,%0" : : "r" (p));
255 }
256
257 static inline void cinval(void *p)
258 {
259 asm volatile ("dcbi 0,%0; icbi 0,%0" : : "r" (p));
260 }
261
262 /*
263 * Disable surveillance (the service processor watchdog function)
264 * while we are in xmon.
265 * XXX we should re-enable it when we leave. :)
266 */
267 #define SURVEILLANCE_TOKEN 9000
268
269 static inline void disable_surveillance(void)
270 {
271 #ifdef CONFIG_PPC_PSERIES
272 /* Since this can't be a module, args should end up below 4GB. */
273 static struct rtas_args args;
274
275 /*
276 * At this point we have got all the cpus we can into
277 * xmon, so there is hopefully no other cpu calling RTAS
278 * at the moment, even though we don't take rtas.lock.
279 * If we did try to take rtas.lock there would be a
280 * real possibility of deadlock.
281 */
282 args.token = rtas_token("set-indicator");
283 if (args.token == RTAS_UNKNOWN_SERVICE)
284 return;
285 args.nargs = 3;
286 args.nret = 1;
287 args.rets = &args.args[3];
288 args.args[0] = SURVEILLANCE_TOKEN;
289 args.args[1] = 0;
290 args.args[2] = 0;
291 enter_rtas(__pa(&args));
292 #endif /* CONFIG_PPC_PSERIES */
293 }
294
295 #ifdef CONFIG_SMP
296 static int xmon_speaker;
297
298 static void get_output_lock(void)
299 {
300 int me = smp_processor_id() + 0x100;
301 int last_speaker = 0, prev;
302 long timeout;
303
304 if (xmon_speaker == me)
305 return;
306 for (;;) {
307 if (xmon_speaker == 0) {
308 last_speaker = cmpxchg(&xmon_speaker, 0, me);
309 if (last_speaker == 0)
310 return;
311 }
312 timeout = 10000000;
313 while (xmon_speaker == last_speaker) {
314 if (--timeout > 0)
315 continue;
316 /* hostile takeover */
317 prev = cmpxchg(&xmon_speaker, last_speaker, me);
318 if (prev == last_speaker)
319 return;
320 break;
321 }
322 }
323 }
324
325 static void release_output_lock(void)
326 {
327 xmon_speaker = 0;
328 }
329
330 int cpus_are_in_xmon(void)
331 {
332 return !cpus_empty(cpus_in_xmon);
333 }
334 #endif
335
336 static int xmon_core(struct pt_regs *regs, int fromipi)
337 {
338 int cmd = 0;
339 struct bpt *bp;
340 long recurse_jmp[JMP_BUF_LEN];
341 unsigned long offset;
342 unsigned long flags;
343 #ifdef CONFIG_SMP
344 int cpu;
345 int secondary;
346 unsigned long timeout;
347 #endif
348
349 local_irq_save(flags);
350
351 bp = in_breakpoint_table(regs->nip, &offset);
352 if (bp != NULL) {
353 regs->nip = bp->address + offset;
354 atomic_dec(&bp->ref_count);
355 }
356
357 remove_cpu_bpts();
358
359 #ifdef CONFIG_SMP
360 cpu = smp_processor_id();
361 if (cpu_isset(cpu, cpus_in_xmon)) {
362 get_output_lock();
363 excprint(regs);
364 printf("cpu 0x%x: Exception %lx %s in xmon, "
365 "returning to main loop\n",
366 cpu, regs->trap, getvecname(TRAP(regs)));
367 release_output_lock();
368 longjmp(xmon_fault_jmp[cpu], 1);
369 }
370
371 if (setjmp(recurse_jmp) != 0) {
372 if (!in_xmon || !xmon_gate) {
373 get_output_lock();
374 printf("xmon: WARNING: bad recursive fault "
375 "on cpu 0x%x\n", cpu);
376 release_output_lock();
377 goto waiting;
378 }
379 secondary = !(xmon_taken && cpu == xmon_owner);
380 goto cmdloop;
381 }
382
383 xmon_fault_jmp[cpu] = recurse_jmp;
384 cpu_set(cpu, cpus_in_xmon);
385
386 bp = NULL;
387 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF))
388 bp = at_breakpoint(regs->nip);
389 if (bp || (regs->msr & MSR_RI) == 0)
390 fromipi = 0;
391
392 if (!fromipi) {
393 get_output_lock();
394 excprint(regs);
395 if (bp) {
396 printf("cpu 0x%x stopped at breakpoint 0x%x (",
397 cpu, BP_NUM(bp));
398 xmon_print_symbol(regs->nip, " ", ")\n");
399 }
400 if ((regs->msr & MSR_RI) == 0)
401 printf("WARNING: exception is not recoverable, "
402 "can't continue\n");
403 release_output_lock();
404 }
405
406 waiting:
407 secondary = 1;
408 while (secondary && !xmon_gate) {
409 if (in_xmon == 0) {
410 if (fromipi)
411 goto leave;
412 secondary = test_and_set_bit(0, &in_xmon);
413 }
414 barrier();
415 }
416
417 if (!secondary && !xmon_gate) {
418 /* we are the first cpu to come in */
419 /* interrupt other cpu(s) */
420 int ncpus = num_online_cpus();
421
422 xmon_owner = cpu;
423 mb();
424 if (ncpus > 1) {
425 smp_send_debugger_break(MSG_ALL_BUT_SELF);
426 /* wait for other cpus to come in */
427 for (timeout = 100000000; timeout != 0; --timeout) {
428 if (cpus_weight(cpus_in_xmon) >= ncpus)
429 break;
430 barrier();
431 }
432 }
433 remove_bpts();
434 disable_surveillance();
435 /* for breakpoint or single step, print the current instr. */
436 if (bp || TRAP(regs) == 0xd00)
437 ppc_inst_dump(regs->nip, 1, 0);
438 printf("enter ? for help\n");
439 mb();
440 xmon_gate = 1;
441 barrier();
442 }
443
444 cmdloop:
445 while (in_xmon) {
446 if (secondary) {
447 if (cpu == xmon_owner) {
448 if (!test_and_set_bit(0, &xmon_taken)) {
449 secondary = 0;
450 continue;
451 }
452 /* missed it */
453 while (cpu == xmon_owner)
454 barrier();
455 }
456 barrier();
457 } else {
458 cmd = cmds(regs);
459 if (cmd != 0) {
460 /* exiting xmon */
461 insert_bpts();
462 xmon_gate = 0;
463 wmb();
464 in_xmon = 0;
465 break;
466 }
467 /* have switched to some other cpu */
468 secondary = 1;
469 }
470 }
471 leave:
472 cpu_clear(cpu, cpus_in_xmon);
473 xmon_fault_jmp[cpu] = NULL;
474 #else
475 /* UP is simple... */
476 if (in_xmon) {
477 printf("Exception %lx %s in xmon, returning to main loop\n",
478 regs->trap, getvecname(TRAP(regs)));
479 longjmp(xmon_fault_jmp[0], 1);
480 }
481 if (setjmp(recurse_jmp) == 0) {
482 xmon_fault_jmp[0] = recurse_jmp;
483 in_xmon = 1;
484
485 excprint(regs);
486 bp = at_breakpoint(regs->nip);
487 if (bp) {
488 printf("Stopped at breakpoint %x (", BP_NUM(bp));
489 xmon_print_symbol(regs->nip, " ", ")\n");
490 }
491 if ((regs->msr & MSR_RI) == 0)
492 printf("WARNING: exception is not recoverable, "
493 "can't continue\n");
494 remove_bpts();
495 disable_surveillance();
496 /* for breakpoint or single step, print the current instr. */
497 if (bp || TRAP(regs) == 0xd00)
498 ppc_inst_dump(regs->nip, 1, 0);
499 printf("enter ? for help\n");
500 }
501
502 cmd = cmds(regs);
503
504 insert_bpts();
505 in_xmon = 0;
506 #endif
507
508 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF)) {
509 bp = at_breakpoint(regs->nip);
510 if (bp != NULL) {
511 int stepped = emulate_step(regs, bp->instr[0]);
512 if (stepped == 0) {
513 regs->nip = (unsigned long) &bp->instr[0];
514 atomic_inc(&bp->ref_count);
515 } else if (stepped < 0) {
516 printf("Couldn't single-step %s instruction\n",
517 (IS_RFID(bp->instr[0])? "rfid": "mtmsrd"));
518 }
519 }
520 }
521
522 insert_cpu_bpts();
523
524 local_irq_restore(flags);
525
526 return cmd != 'X' && cmd != EOF;
527 }
528
529 int xmon(struct pt_regs *excp)
530 {
531 struct pt_regs regs;
532
533 if (excp == NULL) {
534 ppc_save_regs(&regs);
535 excp = &regs;
536 }
537
538 return xmon_core(excp, 0);
539 }
540 EXPORT_SYMBOL(xmon);
541
542 irqreturn_t xmon_irq(int irq, void *d)
543 {
544 unsigned long flags;
545 local_irq_save(flags);
546 printf("Keyboard interrupt\n");
547 xmon(get_irq_regs());
548 local_irq_restore(flags);
549 return IRQ_HANDLED;
550 }
551
552 static int xmon_bpt(struct pt_regs *regs)
553 {
554 struct bpt *bp;
555 unsigned long offset;
556
557 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF))
558 return 0;
559
560 /* Are we at the trap at bp->instr[1] for some bp? */
561 bp = in_breakpoint_table(regs->nip, &offset);
562 if (bp != NULL && offset == 4) {
563 regs->nip = bp->address + 4;
564 atomic_dec(&bp->ref_count);
565 return 1;
566 }
567
568 /* Are we at a breakpoint? */
569 bp = at_breakpoint(regs->nip);
570 if (!bp)
571 return 0;
572
573 xmon_core(regs, 0);
574
575 return 1;
576 }
577
578 static int xmon_sstep(struct pt_regs *regs)
579 {
580 if (user_mode(regs))
581 return 0;
582 xmon_core(regs, 0);
583 return 1;
584 }
585
586 static int xmon_dabr_match(struct pt_regs *regs)
587 {
588 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF))
589 return 0;
590 if (dabr.enabled == 0)
591 return 0;
592 xmon_core(regs, 0);
593 return 1;
594 }
595
596 static int xmon_iabr_match(struct pt_regs *regs)
597 {
598 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) != (MSR_IR|MSR_SF))
599 return 0;
600 if (iabr == NULL)
601 return 0;
602 xmon_core(regs, 0);
603 return 1;
604 }
605
606 static int xmon_ipi(struct pt_regs *regs)
607 {
608 #ifdef CONFIG_SMP
609 if (in_xmon && !cpu_isset(smp_processor_id(), cpus_in_xmon))
610 xmon_core(regs, 1);
611 #endif
612 return 0;
613 }
614
615 static int xmon_fault_handler(struct pt_regs *regs)
616 {
617 struct bpt *bp;
618 unsigned long offset;
619
620 if (in_xmon && catch_memory_errors)
621 handle_fault(regs); /* doesn't return */
622
623 if ((regs->msr & (MSR_IR|MSR_PR|MSR_SF)) == (MSR_IR|MSR_SF)) {
624 bp = in_breakpoint_table(regs->nip, &offset);
625 if (bp != NULL) {
626 regs->nip = bp->address + offset;
627 atomic_dec(&bp->ref_count);
628 }
629 }
630
631 return 0;
632 }
633
634 static struct bpt *at_breakpoint(unsigned long pc)
635 {
636 int i;
637 struct bpt *bp;
638
639 bp = bpts;
640 for (i = 0; i < NBPTS; ++i, ++bp)
641 if (bp->enabled && pc == bp->address)
642 return bp;
643 return NULL;
644 }
645
646 static struct bpt *in_breakpoint_table(unsigned long nip, unsigned long *offp)
647 {
648 unsigned long off;
649
650 off = nip - (unsigned long) bpts;
651 if (off >= sizeof(bpts))
652 return NULL;
653 off %= sizeof(struct bpt);
654 if (off != offsetof(struct bpt, instr[0])
655 && off != offsetof(struct bpt, instr[1]))
656 return NULL;
657 *offp = off - offsetof(struct bpt, instr[0]);
658 return (struct bpt *) (nip - off);
659 }
660
661 static struct bpt *new_breakpoint(unsigned long a)
662 {
663 struct bpt *bp;
664
665 a &= ~3UL;
666 bp = at_breakpoint(a);
667 if (bp)
668 return bp;
669
670 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
671 if (!bp->enabled && atomic_read(&bp->ref_count) == 0) {
672 bp->address = a;
673 bp->instr[1] = bpinstr;
674 store_inst(&bp->instr[1]);
675 return bp;
676 }
677 }
678
679 printf("Sorry, no free breakpoints. Please clear one first.\n");
680 return NULL;
681 }
682
683 static void insert_bpts(void)
684 {
685 int i;
686 struct bpt *bp;
687
688 bp = bpts;
689 for (i = 0; i < NBPTS; ++i, ++bp) {
690 if ((bp->enabled & (BP_TRAP|BP_IABR)) == 0)
691 continue;
692 if (mread(bp->address, &bp->instr[0], 4) != 4) {
693 printf("Couldn't read instruction at %lx, "
694 "disabling breakpoint there\n", bp->address);
695 bp->enabled = 0;
696 continue;
697 }
698 if (IS_MTMSRD(bp->instr[0]) || IS_RFID(bp->instr[0])) {
699 printf("Breakpoint at %lx is on an mtmsrd or rfid "
700 "instruction, disabling it\n", bp->address);
701 bp->enabled = 0;
702 continue;
703 }
704 store_inst(&bp->instr[0]);
705 if (bp->enabled & BP_IABR)
706 continue;
707 if (mwrite(bp->address, &bpinstr, 4) != 4) {
708 printf("Couldn't write instruction at %lx, "
709 "disabling breakpoint there\n", bp->address);
710 bp->enabled &= ~BP_TRAP;
711 continue;
712 }
713 store_inst((void *)bp->address);
714 }
715 }
716
717 static void insert_cpu_bpts(void)
718 {
719 if (dabr.enabled)
720 set_dabr(dabr.address | (dabr.enabled & 7));
721 if (iabr && cpu_has_feature(CPU_FTR_IABR))
722 mtspr(SPRN_IABR, iabr->address
723 | (iabr->enabled & (BP_IABR|BP_IABR_TE)));
724 }
725
726 static void remove_bpts(void)
727 {
728 int i;
729 struct bpt *bp;
730 unsigned instr;
731
732 bp = bpts;
733 for (i = 0; i < NBPTS; ++i, ++bp) {
734 if ((bp->enabled & (BP_TRAP|BP_IABR)) != BP_TRAP)
735 continue;
736 if (mread(bp->address, &instr, 4) == 4
737 && instr == bpinstr
738 && mwrite(bp->address, &bp->instr, 4) != 4)
739 printf("Couldn't remove breakpoint at %lx\n",
740 bp->address);
741 else
742 store_inst((void *)bp->address);
743 }
744 }
745
746 static void remove_cpu_bpts(void)
747 {
748 set_dabr(0);
749 if (cpu_has_feature(CPU_FTR_IABR))
750 mtspr(SPRN_IABR, 0);
751 }
752
753 /* Command interpreting routine */
754 static char *last_cmd;
755
756 static int
757 cmds(struct pt_regs *excp)
758 {
759 int cmd = 0;
760
761 last_cmd = NULL;
762 xmon_regs = excp;
763
764 if (!xmon_no_auto_backtrace) {
765 xmon_no_auto_backtrace = 1;
766 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
767 }
768
769 for(;;) {
770 #ifdef CONFIG_SMP
771 printf("%x:", smp_processor_id());
772 #endif /* CONFIG_SMP */
773 printf("mon> ");
774 flush_input();
775 termch = 0;
776 cmd = skipbl();
777 if( cmd == '\n' ) {
778 if (last_cmd == NULL)
779 continue;
780 take_input(last_cmd);
781 last_cmd = NULL;
782 cmd = inchar();
783 }
784 switch (cmd) {
785 case 'm':
786 cmd = inchar();
787 switch (cmd) {
788 case 'm':
789 case 's':
790 case 'd':
791 memops(cmd);
792 break;
793 case 'l':
794 memlocate();
795 break;
796 case 'z':
797 memzcan();
798 break;
799 case 'i':
800 show_mem();
801 break;
802 default:
803 termch = cmd;
804 memex();
805 }
806 break;
807 case 'd':
808 dump();
809 break;
810 case 'l':
811 symbol_lookup();
812 break;
813 case 'r':
814 prregs(excp); /* print regs */
815 break;
816 case 'e':
817 excprint(excp);
818 break;
819 case 'S':
820 super_regs();
821 break;
822 case 't':
823 backtrace(excp);
824 break;
825 case 'f':
826 cacheflush();
827 break;
828 case 's':
829 if (do_spu_cmd() == 0)
830 break;
831 if (do_step(excp))
832 return cmd;
833 break;
834 case 'x':
835 case 'X':
836 return cmd;
837 case EOF:
838 printf(" <no input ...>\n");
839 mdelay(2000);
840 return cmd;
841 case '?':
842 xmon_puts(help_string);
843 break;
844 case 'b':
845 bpt_cmds();
846 break;
847 case 'C':
848 csum();
849 break;
850 case 'c':
851 if (cpu_cmd())
852 return 0;
853 break;
854 case 'z':
855 bootcmds();
856 break;
857 case 'p':
858 proccall();
859 break;
860 #ifdef CONFIG_PPC_STD_MMU
861 case 'u':
862 dump_segments();
863 break;
864 #endif
865 #ifdef CONFIG_4xx
866 case 'u':
867 dump_tlb_44x();
868 break;
869 #endif
870 default:
871 printf("Unrecognized command: ");
872 do {
873 if (' ' < cmd && cmd <= '~')
874 putchar(cmd);
875 else
876 printf("\\x%x", cmd);
877 cmd = inchar();
878 } while (cmd != '\n');
879 printf(" (type ? for help)\n");
880 break;
881 }
882 }
883 }
884
885 /*
886 * Step a single instruction.
887 * Some instructions we emulate, others we execute with MSR_SE set.
888 */
889 static int do_step(struct pt_regs *regs)
890 {
891 unsigned int instr;
892 int stepped;
893
894 /* check we are in 64-bit kernel mode, translation enabled */
895 if ((regs->msr & (MSR_SF|MSR_PR|MSR_IR)) == (MSR_SF|MSR_IR)) {
896 if (mread(regs->nip, &instr, 4) == 4) {
897 stepped = emulate_step(regs, instr);
898 if (stepped < 0) {
899 printf("Couldn't single-step %s instruction\n",
900 (IS_RFID(instr)? "rfid": "mtmsrd"));
901 return 0;
902 }
903 if (stepped > 0) {
904 regs->trap = 0xd00 | (regs->trap & 1);
905 printf("stepped to ");
906 xmon_print_symbol(regs->nip, " ", "\n");
907 ppc_inst_dump(regs->nip, 1, 0);
908 return 0;
909 }
910 }
911 }
912 regs->msr |= MSR_SE;
913 return 1;
914 }
915
916 static void bootcmds(void)
917 {
918 int cmd;
919
920 cmd = inchar();
921 if (cmd == 'r')
922 ppc_md.restart(NULL);
923 else if (cmd == 'h')
924 ppc_md.halt();
925 else if (cmd == 'p')
926 ppc_md.power_off();
927 }
928
929 static int cpu_cmd(void)
930 {
931 #ifdef CONFIG_SMP
932 unsigned long cpu;
933 int timeout;
934 int count;
935
936 if (!scanhex(&cpu)) {
937 /* print cpus waiting or in xmon */
938 printf("cpus stopped:");
939 count = 0;
940 for (cpu = 0; cpu < NR_CPUS; ++cpu) {
941 if (cpu_isset(cpu, cpus_in_xmon)) {
942 if (count == 0)
943 printf(" %x", cpu);
944 ++count;
945 } else {
946 if (count > 1)
947 printf("-%x", cpu - 1);
948 count = 0;
949 }
950 }
951 if (count > 1)
952 printf("-%x", NR_CPUS - 1);
953 printf("\n");
954 return 0;
955 }
956 /* try to switch to cpu specified */
957 if (!cpu_isset(cpu, cpus_in_xmon)) {
958 printf("cpu 0x%x isn't in xmon\n", cpu);
959 return 0;
960 }
961 xmon_taken = 0;
962 mb();
963 xmon_owner = cpu;
964 timeout = 10000000;
965 while (!xmon_taken) {
966 if (--timeout == 0) {
967 if (test_and_set_bit(0, &xmon_taken))
968 break;
969 /* take control back */
970 mb();
971 xmon_owner = smp_processor_id();
972 printf("cpu %u didn't take control\n", cpu);
973 return 0;
974 }
975 barrier();
976 }
977 return 1;
978 #else
979 return 0;
980 #endif /* CONFIG_SMP */
981 }
982
983 static unsigned short fcstab[256] = {
984 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf,
985 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
986 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e,
987 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
988 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd,
989 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
990 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c,
991 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
992 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb,
993 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3,
994 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a,
995 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
996 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9,
997 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
998 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738,
999 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
1000 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
1001 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
1002 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
1003 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
1004 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
1005 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
1006 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134,
1007 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
1008 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3,
1009 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
1010 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232,
1011 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
1012 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1,
1013 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
1014 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
1015 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78
1016 };
1017
1018 #define FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff])
1019
1020 static void
1021 csum(void)
1022 {
1023 unsigned int i;
1024 unsigned short fcs;
1025 unsigned char v;
1026
1027 if (!scanhex(&adrs))
1028 return;
1029 if (!scanhex(&ncsum))
1030 return;
1031 fcs = 0xffff;
1032 for (i = 0; i < ncsum; ++i) {
1033 if (mread(adrs+i, &v, 1) == 0) {
1034 printf("csum stopped at %x\n", adrs+i);
1035 break;
1036 }
1037 fcs = FCS(fcs, v);
1038 }
1039 printf("%x\n", fcs);
1040 }
1041
1042 /*
1043 * Check if this is a suitable place to put a breakpoint.
1044 */
1045 static long check_bp_loc(unsigned long addr)
1046 {
1047 unsigned int instr;
1048
1049 addr &= ~3;
1050 if (!is_kernel_addr(addr)) {
1051 printf("Breakpoints may only be placed at kernel addresses\n");
1052 return 0;
1053 }
1054 if (!mread(addr, &instr, sizeof(instr))) {
1055 printf("Can't read instruction at address %lx\n", addr);
1056 return 0;
1057 }
1058 if (IS_MTMSRD(instr) || IS_RFID(instr)) {
1059 printf("Breakpoints may not be placed on mtmsrd or rfid "
1060 "instructions\n");
1061 return 0;
1062 }
1063 return 1;
1064 }
1065
1066 static char *breakpoint_help_string =
1067 "Breakpoint command usage:\n"
1068 "b show breakpoints\n"
1069 "b <addr> [cnt] set breakpoint at given instr addr\n"
1070 "bc clear all breakpoints\n"
1071 "bc <n/addr> clear breakpoint number n or at addr\n"
1072 "bi <addr> [cnt] set hardware instr breakpoint (POWER3/RS64 only)\n"
1073 "bd <addr> [cnt] set hardware data breakpoint\n"
1074 "";
1075
1076 static void
1077 bpt_cmds(void)
1078 {
1079 int cmd;
1080 unsigned long a;
1081 int mode, i;
1082 struct bpt *bp;
1083 const char badaddr[] = "Only kernel addresses are permitted "
1084 "for breakpoints\n";
1085
1086 cmd = inchar();
1087 switch (cmd) {
1088 #ifndef CONFIG_8xx
1089 case 'd': /* bd - hardware data breakpoint */
1090 mode = 7;
1091 cmd = inchar();
1092 if (cmd == 'r')
1093 mode = 5;
1094 else if (cmd == 'w')
1095 mode = 6;
1096 else
1097 termch = cmd;
1098 dabr.address = 0;
1099 dabr.enabled = 0;
1100 if (scanhex(&dabr.address)) {
1101 if (!is_kernel_addr(dabr.address)) {
1102 printf(badaddr);
1103 break;
1104 }
1105 dabr.address &= ~7;
1106 dabr.enabled = mode | BP_DABR;
1107 }
1108 break;
1109
1110 case 'i': /* bi - hardware instr breakpoint */
1111 if (!cpu_has_feature(CPU_FTR_IABR)) {
1112 printf("Hardware instruction breakpoint "
1113 "not supported on this cpu\n");
1114 break;
1115 }
1116 if (iabr) {
1117 iabr->enabled &= ~(BP_IABR | BP_IABR_TE);
1118 iabr = NULL;
1119 }
1120 if (!scanhex(&a))
1121 break;
1122 if (!check_bp_loc(a))
1123 break;
1124 bp = new_breakpoint(a);
1125 if (bp != NULL) {
1126 bp->enabled |= BP_IABR | BP_IABR_TE;
1127 iabr = bp;
1128 }
1129 break;
1130 #endif
1131
1132 case 'c':
1133 if (!scanhex(&a)) {
1134 /* clear all breakpoints */
1135 for (i = 0; i < NBPTS; ++i)
1136 bpts[i].enabled = 0;
1137 iabr = NULL;
1138 dabr.enabled = 0;
1139 printf("All breakpoints cleared\n");
1140 break;
1141 }
1142
1143 if (a <= NBPTS && a >= 1) {
1144 /* assume a breakpoint number */
1145 bp = &bpts[a-1]; /* bp nums are 1 based */
1146 } else {
1147 /* assume a breakpoint address */
1148 bp = at_breakpoint(a);
1149 if (bp == NULL) {
1150 printf("No breakpoint at %x\n", a);
1151 break;
1152 }
1153 }
1154
1155 printf("Cleared breakpoint %x (", BP_NUM(bp));
1156 xmon_print_symbol(bp->address, " ", ")\n");
1157 bp->enabled = 0;
1158 break;
1159
1160 default:
1161 termch = cmd;
1162 cmd = skipbl();
1163 if (cmd == '?') {
1164 printf(breakpoint_help_string);
1165 break;
1166 }
1167 termch = cmd;
1168 if (!scanhex(&a)) {
1169 /* print all breakpoints */
1170 printf(" type address\n");
1171 if (dabr.enabled) {
1172 printf(" data "REG" [", dabr.address);
1173 if (dabr.enabled & 1)
1174 printf("r");
1175 if (dabr.enabled & 2)
1176 printf("w");
1177 printf("]\n");
1178 }
1179 for (bp = bpts; bp < &bpts[NBPTS]; ++bp) {
1180 if (!bp->enabled)
1181 continue;
1182 printf("%2x %s ", BP_NUM(bp),
1183 (bp->enabled & BP_IABR)? "inst": "trap");
1184 xmon_print_symbol(bp->address, " ", "\n");
1185 }
1186 break;
1187 }
1188
1189 if (!check_bp_loc(a))
1190 break;
1191 bp = new_breakpoint(a);
1192 if (bp != NULL)
1193 bp->enabled |= BP_TRAP;
1194 break;
1195 }
1196 }
1197
1198 /* Very cheap human name for vector lookup. */
1199 static
1200 const char *getvecname(unsigned long vec)
1201 {
1202 char *ret;
1203
1204 switch (vec) {
1205 case 0x100: ret = "(System Reset)"; break;
1206 case 0x200: ret = "(Machine Check)"; break;
1207 case 0x300: ret = "(Data Access)"; break;
1208 case 0x380: ret = "(Data SLB Access)"; break;
1209 case 0x400: ret = "(Instruction Access)"; break;
1210 case 0x480: ret = "(Instruction SLB Access)"; break;
1211 case 0x500: ret = "(Hardware Interrupt)"; break;
1212 case 0x600: ret = "(Alignment)"; break;
1213 case 0x700: ret = "(Program Check)"; break;
1214 case 0x800: ret = "(FPU Unavailable)"; break;
1215 case 0x900: ret = "(Decrementer)"; break;
1216 case 0xc00: ret = "(System Call)"; break;
1217 case 0xd00: ret = "(Single Step)"; break;
1218 case 0xf00: ret = "(Performance Monitor)"; break;
1219 case 0xf20: ret = "(Altivec Unavailable)"; break;
1220 case 0x1300: ret = "(Instruction Breakpoint)"; break;
1221 default: ret = "";
1222 }
1223 return ret;
1224 }
1225
1226 static void get_function_bounds(unsigned long pc, unsigned long *startp,
1227 unsigned long *endp)
1228 {
1229 unsigned long size, offset;
1230 const char *name;
1231
1232 *startp = *endp = 0;
1233 if (pc == 0)
1234 return;
1235 if (setjmp(bus_error_jmp) == 0) {
1236 catch_memory_errors = 1;
1237 sync();
1238 name = kallsyms_lookup(pc, &size, &offset, NULL, tmpstr);
1239 if (name != NULL) {
1240 *startp = pc - offset;
1241 *endp = pc - offset + size;
1242 }
1243 sync();
1244 }
1245 catch_memory_errors = 0;
1246 }
1247
1248 static int xmon_depth_to_print = 64;
1249
1250 #define LRSAVE_OFFSET (STACK_FRAME_LR_SAVE * sizeof(unsigned long))
1251 #define MARKER_OFFSET (STACK_FRAME_MARKER * sizeof(unsigned long))
1252
1253 #ifdef __powerpc64__
1254 #define REGS_OFFSET 0x70
1255 #else
1256 #define REGS_OFFSET 16
1257 #endif
1258
1259 static void xmon_show_stack(unsigned long sp, unsigned long lr,
1260 unsigned long pc)
1261 {
1262 unsigned long ip;
1263 unsigned long newsp;
1264 unsigned long marker;
1265 int count = 0;
1266 struct pt_regs regs;
1267
1268 do {
1269 if (sp < PAGE_OFFSET) {
1270 if (sp != 0)
1271 printf("SP (%lx) is in userspace\n", sp);
1272 break;
1273 }
1274
1275 if (!mread(sp + LRSAVE_OFFSET, &ip, sizeof(unsigned long))
1276 || !mread(sp, &newsp, sizeof(unsigned long))) {
1277 printf("Couldn't read stack frame at %lx\n", sp);
1278 break;
1279 }
1280
1281 /*
1282 * For the first stack frame, try to work out if
1283 * LR and/or the saved LR value in the bottommost
1284 * stack frame are valid.
1285 */
1286 if ((pc | lr) != 0) {
1287 unsigned long fnstart, fnend;
1288 unsigned long nextip;
1289 int printip = 1;
1290
1291 get_function_bounds(pc, &fnstart, &fnend);
1292 nextip = 0;
1293 if (newsp > sp)
1294 mread(newsp + LRSAVE_OFFSET, &nextip,
1295 sizeof(unsigned long));
1296 if (lr == ip) {
1297 if (lr < PAGE_OFFSET
1298 || (fnstart <= lr && lr < fnend))
1299 printip = 0;
1300 } else if (lr == nextip) {
1301 printip = 0;
1302 } else if (lr >= PAGE_OFFSET
1303 && !(fnstart <= lr && lr < fnend)) {
1304 printf("[link register ] ");
1305 xmon_print_symbol(lr, " ", "\n");
1306 }
1307 if (printip) {
1308 printf("["REG"] ", sp);
1309 xmon_print_symbol(ip, " ", " (unreliable)\n");
1310 }
1311 pc = lr = 0;
1312
1313 } else {
1314 printf("["REG"] ", sp);
1315 xmon_print_symbol(ip, " ", "\n");
1316 }
1317
1318 /* Look for "regshere" marker to see if this is
1319 an exception frame. */
1320 if (mread(sp + MARKER_OFFSET, &marker, sizeof(unsigned long))
1321 && marker == STACK_FRAME_REGS_MARKER) {
1322 if (mread(sp + REGS_OFFSET, &regs, sizeof(regs))
1323 != sizeof(regs)) {
1324 printf("Couldn't read registers at %lx\n",
1325 sp + REGS_OFFSET);
1326 break;
1327 }
1328 printf("--- Exception: %lx %s at ", regs.trap,
1329 getvecname(TRAP(&regs)));
1330 pc = regs.nip;
1331 lr = regs.link;
1332 xmon_print_symbol(pc, " ", "\n");
1333 }
1334
1335 if (newsp == 0)
1336 break;
1337
1338 sp = newsp;
1339 } while (count++ < xmon_depth_to_print);
1340 }
1341
1342 static void backtrace(struct pt_regs *excp)
1343 {
1344 unsigned long sp;
1345
1346 if (scanhex(&sp))
1347 xmon_show_stack(sp, 0, 0);
1348 else
1349 xmon_show_stack(excp->gpr[1], excp->link, excp->nip);
1350 scannl();
1351 }
1352
1353 static void print_bug_trap(struct pt_regs *regs)
1354 {
1355 #ifdef CONFIG_BUG
1356 const struct bug_entry *bug;
1357 unsigned long addr;
1358
1359 if (regs->msr & MSR_PR)
1360 return; /* not in kernel */
1361 addr = regs->nip; /* address of trap instruction */
1362 if (addr < PAGE_OFFSET)
1363 return;
1364 bug = find_bug(regs->nip);
1365 if (bug == NULL)
1366 return;
1367 if (is_warning_bug(bug))
1368 return;
1369
1370 #ifdef CONFIG_DEBUG_BUGVERBOSE
1371 printf("kernel BUG at %s:%u!\n",
1372 bug->file, bug->line);
1373 #else
1374 printf("kernel BUG at %p!\n", (void *)bug->bug_addr);
1375 #endif
1376 #endif /* CONFIG_BUG */
1377 }
1378
1379 static void excprint(struct pt_regs *fp)
1380 {
1381 unsigned long trap;
1382
1383 #ifdef CONFIG_SMP
1384 printf("cpu 0x%x: ", smp_processor_id());
1385 #endif /* CONFIG_SMP */
1386
1387 trap = TRAP(fp);
1388 printf("Vector: %lx %s at [%lx]\n", fp->trap, getvecname(trap), fp);
1389 printf(" pc: ");
1390 xmon_print_symbol(fp->nip, ": ", "\n");
1391
1392 printf(" lr: ", fp->link);
1393 xmon_print_symbol(fp->link, ": ", "\n");
1394
1395 printf(" sp: %lx\n", fp->gpr[1]);
1396 printf(" msr: %lx\n", fp->msr);
1397
1398 if (trap == 0x300 || trap == 0x380 || trap == 0x600) {
1399 printf(" dar: %lx\n", fp->dar);
1400 if (trap != 0x380)
1401 printf(" dsisr: %lx\n", fp->dsisr);
1402 }
1403
1404 printf(" current = 0x%lx\n", current);
1405 #ifdef CONFIG_PPC64
1406 printf(" paca = 0x%lx\n", get_paca());
1407 #endif
1408 if (current) {
1409 printf(" pid = %ld, comm = %s\n",
1410 current->pid, current->comm);
1411 }
1412
1413 if (trap == 0x700)
1414 print_bug_trap(fp);
1415 }
1416
1417 static void prregs(struct pt_regs *fp)
1418 {
1419 int n, trap;
1420 unsigned long base;
1421 struct pt_regs regs;
1422
1423 if (scanhex(&base)) {
1424 if (setjmp(bus_error_jmp) == 0) {
1425 catch_memory_errors = 1;
1426 sync();
1427 regs = *(struct pt_regs *)base;
1428 sync();
1429 __delay(200);
1430 } else {
1431 catch_memory_errors = 0;
1432 printf("*** Error reading registers from "REG"\n",
1433 base);
1434 return;
1435 }
1436 catch_memory_errors = 0;
1437 fp = &regs;
1438 }
1439
1440 #ifdef CONFIG_PPC64
1441 if (FULL_REGS(fp)) {
1442 for (n = 0; n < 16; ++n)
1443 printf("R%.2ld = "REG" R%.2ld = "REG"\n",
1444 n, fp->gpr[n], n+16, fp->gpr[n+16]);
1445 } else {
1446 for (n = 0; n < 7; ++n)
1447 printf("R%.2ld = "REG" R%.2ld = "REG"\n",
1448 n, fp->gpr[n], n+7, fp->gpr[n+7]);
1449 }
1450 #else
1451 for (n = 0; n < 32; ++n) {
1452 printf("R%.2d = %.8x%s", n, fp->gpr[n],
1453 (n & 3) == 3? "\n": " ");
1454 if (n == 12 && !FULL_REGS(fp)) {
1455 printf("\n");
1456 break;
1457 }
1458 }
1459 #endif
1460 printf("pc = ");
1461 xmon_print_symbol(fp->nip, " ", "\n");
1462 printf("lr = ");
1463 xmon_print_symbol(fp->link, " ", "\n");
1464 printf("msr = "REG" cr = %.8lx\n", fp->msr, fp->ccr);
1465 printf("ctr = "REG" xer = "REG" trap = %4lx\n",
1466 fp->ctr, fp->xer, fp->trap);
1467 trap = TRAP(fp);
1468 if (trap == 0x300 || trap == 0x380 || trap == 0x600)
1469 printf("dar = "REG" dsisr = %.8lx\n", fp->dar, fp->dsisr);
1470 }
1471
1472 static void cacheflush(void)
1473 {
1474 int cmd;
1475 unsigned long nflush;
1476
1477 cmd = inchar();
1478 if (cmd != 'i')
1479 termch = cmd;
1480 scanhex((void *)&adrs);
1481 if (termch != '\n')
1482 termch = 0;
1483 nflush = 1;
1484 scanhex(&nflush);
1485 nflush = (nflush + L1_CACHE_BYTES - 1) / L1_CACHE_BYTES;
1486 if (setjmp(bus_error_jmp) == 0) {
1487 catch_memory_errors = 1;
1488 sync();
1489
1490 if (cmd != 'i') {
1491 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1492 cflush((void *) adrs);
1493 } else {
1494 for (; nflush > 0; --nflush, adrs += L1_CACHE_BYTES)
1495 cinval((void *) adrs);
1496 }
1497 sync();
1498 /* wait a little while to see if we get a machine check */
1499 __delay(200);
1500 }
1501 catch_memory_errors = 0;
1502 }
1503
1504 static unsigned long
1505 read_spr(int n)
1506 {
1507 unsigned int instrs[2];
1508 unsigned long (*code)(void);
1509 unsigned long ret = -1UL;
1510 #ifdef CONFIG_PPC64
1511 unsigned long opd[3];
1512
1513 opd[0] = (unsigned long)instrs;
1514 opd[1] = 0;
1515 opd[2] = 0;
1516 code = (unsigned long (*)(void)) opd;
1517 #else
1518 code = (unsigned long (*)(void)) instrs;
1519 #endif
1520
1521 /* mfspr r3,n; blr */
1522 instrs[0] = 0x7c6002a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1523 instrs[1] = 0x4e800020;
1524 store_inst(instrs);
1525 store_inst(instrs+1);
1526
1527 if (setjmp(bus_error_jmp) == 0) {
1528 catch_memory_errors = 1;
1529 sync();
1530
1531 ret = code();
1532
1533 sync();
1534 /* wait a little while to see if we get a machine check */
1535 __delay(200);
1536 n = size;
1537 }
1538
1539 return ret;
1540 }
1541
1542 static void
1543 write_spr(int n, unsigned long val)
1544 {
1545 unsigned int instrs[2];
1546 unsigned long (*code)(unsigned long);
1547 #ifdef CONFIG_PPC64
1548 unsigned long opd[3];
1549
1550 opd[0] = (unsigned long)instrs;
1551 opd[1] = 0;
1552 opd[2] = 0;
1553 code = (unsigned long (*)(unsigned long)) opd;
1554 #else
1555 code = (unsigned long (*)(unsigned long)) instrs;
1556 #endif
1557
1558 instrs[0] = 0x7c6003a6 + ((n & 0x1F) << 16) + ((n & 0x3e0) << 6);
1559 instrs[1] = 0x4e800020;
1560 store_inst(instrs);
1561 store_inst(instrs+1);
1562
1563 if (setjmp(bus_error_jmp) == 0) {
1564 catch_memory_errors = 1;
1565 sync();
1566
1567 code(val);
1568
1569 sync();
1570 /* wait a little while to see if we get a machine check */
1571 __delay(200);
1572 n = size;
1573 }
1574 }
1575
1576 static unsigned long regno;
1577 extern char exc_prolog;
1578 extern char dec_exc;
1579
1580 static void super_regs(void)
1581 {
1582 int cmd;
1583 unsigned long val;
1584
1585 cmd = skipbl();
1586 if (cmd == '\n') {
1587 unsigned long sp, toc;
1588 asm("mr %0,1" : "=r" (sp) :);
1589 asm("mr %0,2" : "=r" (toc) :);
1590
1591 printf("msr = "REG" sprg0= "REG"\n",
1592 mfmsr(), mfspr(SPRN_SPRG0));
1593 printf("pvr = "REG" sprg1= "REG"\n",
1594 mfspr(SPRN_PVR), mfspr(SPRN_SPRG1));
1595 printf("dec = "REG" sprg2= "REG"\n",
1596 mfspr(SPRN_DEC), mfspr(SPRN_SPRG2));
1597 printf("sp = "REG" sprg3= "REG"\n", sp, mfspr(SPRN_SPRG3));
1598 printf("toc = "REG" dar = "REG"\n", toc, mfspr(SPRN_DAR));
1599 #ifdef CONFIG_PPC_ISERIES
1600 if (firmware_has_feature(FW_FEATURE_ISERIES)) {
1601 struct paca_struct *ptrPaca;
1602 struct lppaca *ptrLpPaca;
1603
1604 /* Dump out relevant Paca data areas. */
1605 printf("Paca: \n");
1606 ptrPaca = get_paca();
1607
1608 printf(" Local Processor Control Area (LpPaca): \n");
1609 ptrLpPaca = ptrPaca->lppaca_ptr;
1610 printf(" Saved Srr0=%.16lx Saved Srr1=%.16lx \n",
1611 ptrLpPaca->saved_srr0, ptrLpPaca->saved_srr1);
1612 printf(" Saved Gpr3=%.16lx Saved Gpr4=%.16lx \n",
1613 ptrLpPaca->saved_gpr3, ptrLpPaca->saved_gpr4);
1614 printf(" Saved Gpr5=%.16lx \n", ptrLpPaca->saved_gpr5);
1615 }
1616 #endif
1617
1618 return;
1619 }
1620
1621 scanhex(&regno);
1622 switch (cmd) {
1623 case 'w':
1624 val = read_spr(regno);
1625 scanhex(&val);
1626 write_spr(regno, val);
1627 /* fall through */
1628 case 'r':
1629 printf("spr %lx = %lx\n", regno, read_spr(regno));
1630 break;
1631 }
1632 scannl();
1633 }
1634
1635 /*
1636 * Stuff for reading and writing memory safely
1637 */
1638 static int
1639 mread(unsigned long adrs, void *buf, int size)
1640 {
1641 volatile int n;
1642 char *p, *q;
1643
1644 n = 0;
1645 if (setjmp(bus_error_jmp) == 0) {
1646 catch_memory_errors = 1;
1647 sync();
1648 p = (char *)adrs;
1649 q = (char *)buf;
1650 switch (size) {
1651 case 2:
1652 *(u16 *)q = *(u16 *)p;
1653 break;
1654 case 4:
1655 *(u32 *)q = *(u32 *)p;
1656 break;
1657 case 8:
1658 *(u64 *)q = *(u64 *)p;
1659 break;
1660 default:
1661 for( ; n < size; ++n) {
1662 *q++ = *p++;
1663 sync();
1664 }
1665 }
1666 sync();
1667 /* wait a little while to see if we get a machine check */
1668 __delay(200);
1669 n = size;
1670 }
1671 catch_memory_errors = 0;
1672 return n;
1673 }
1674
1675 static int
1676 mwrite(unsigned long adrs, void *buf, int size)
1677 {
1678 volatile int n;
1679 char *p, *q;
1680
1681 n = 0;
1682 if (setjmp(bus_error_jmp) == 0) {
1683 catch_memory_errors = 1;
1684 sync();
1685 p = (char *) adrs;
1686 q = (char *) buf;
1687 switch (size) {
1688 case 2:
1689 *(u16 *)p = *(u16 *)q;
1690 break;
1691 case 4:
1692 *(u32 *)p = *(u32 *)q;
1693 break;
1694 case 8:
1695 *(u64 *)p = *(u64 *)q;
1696 break;
1697 default:
1698 for ( ; n < size; ++n) {
1699 *p++ = *q++;
1700 sync();
1701 }
1702 }
1703 sync();
1704 /* wait a little while to see if we get a machine check */
1705 __delay(200);
1706 n = size;
1707 } else {
1708 printf("*** Error writing address %x\n", adrs + n);
1709 }
1710 catch_memory_errors = 0;
1711 return n;
1712 }
1713
1714 static int fault_type;
1715 static int fault_except;
1716 static char *fault_chars[] = { "--", "**", "##" };
1717
1718 static int handle_fault(struct pt_regs *regs)
1719 {
1720 fault_except = TRAP(regs);
1721 switch (TRAP(regs)) {
1722 case 0x200:
1723 fault_type = 0;
1724 break;
1725 case 0x300:
1726 case 0x380:
1727 fault_type = 1;
1728 break;
1729 default:
1730 fault_type = 2;
1731 }
1732
1733 longjmp(bus_error_jmp, 1);
1734
1735 return 0;
1736 }
1737
1738 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
1739
1740 static void
1741 byterev(unsigned char *val, int size)
1742 {
1743 int t;
1744
1745 switch (size) {
1746 case 2:
1747 SWAP(val[0], val[1], t);
1748 break;
1749 case 4:
1750 SWAP(val[0], val[3], t);
1751 SWAP(val[1], val[2], t);
1752 break;
1753 case 8: /* is there really any use for this? */
1754 SWAP(val[0], val[7], t);
1755 SWAP(val[1], val[6], t);
1756 SWAP(val[2], val[5], t);
1757 SWAP(val[3], val[4], t);
1758 break;
1759 }
1760 }
1761
1762 static int brev;
1763 static int mnoread;
1764
1765 static char *memex_help_string =
1766 "Memory examine command usage:\n"
1767 "m [addr] [flags] examine/change memory\n"
1768 " addr is optional. will start where left off.\n"
1769 " flags may include chars from this set:\n"
1770 " b modify by bytes (default)\n"
1771 " w modify by words (2 byte)\n"
1772 " l modify by longs (4 byte)\n"
1773 " d modify by doubleword (8 byte)\n"
1774 " r toggle reverse byte order mode\n"
1775 " n do not read memory (for i/o spaces)\n"
1776 " . ok to read (default)\n"
1777 "NOTE: flags are saved as defaults\n"
1778 "";
1779
1780 static char *memex_subcmd_help_string =
1781 "Memory examine subcommands:\n"
1782 " hexval write this val to current location\n"
1783 " 'string' write chars from string to this location\n"
1784 " ' increment address\n"
1785 " ^ decrement address\n"
1786 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n"
1787 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n"
1788 " ` clear no-read flag\n"
1789 " ; stay at this addr\n"
1790 " v change to byte mode\n"
1791 " w change to word (2 byte) mode\n"
1792 " l change to long (4 byte) mode\n"
1793 " u change to doubleword (8 byte) mode\n"
1794 " m addr change current addr\n"
1795 " n toggle no-read flag\n"
1796 " r toggle byte reverse flag\n"
1797 " < count back up count bytes\n"
1798 " > count skip forward count bytes\n"
1799 " x exit this mode\n"
1800 "";
1801
1802 static void
1803 memex(void)
1804 {
1805 int cmd, inc, i, nslash;
1806 unsigned long n;
1807 unsigned char val[16];
1808
1809 scanhex((void *)&adrs);
1810 cmd = skipbl();
1811 if (cmd == '?') {
1812 printf(memex_help_string);
1813 return;
1814 } else {
1815 termch = cmd;
1816 }
1817 last_cmd = "m\n";
1818 while ((cmd = skipbl()) != '\n') {
1819 switch( cmd ){
1820 case 'b': size = 1; break;
1821 case 'w': size = 2; break;
1822 case 'l': size = 4; break;
1823 case 'd': size = 8; break;
1824 case 'r': brev = !brev; break;
1825 case 'n': mnoread = 1; break;
1826 case '.': mnoread = 0; break;
1827 }
1828 }
1829 if( size <= 0 )
1830 size = 1;
1831 else if( size > 8 )
1832 size = 8;
1833 for(;;){
1834 if (!mnoread)
1835 n = mread(adrs, val, size);
1836 printf(REG"%c", adrs, brev? 'r': ' ');
1837 if (!mnoread) {
1838 if (brev)
1839 byterev(val, size);
1840 putchar(' ');
1841 for (i = 0; i < n; ++i)
1842 printf("%.2x", val[i]);
1843 for (; i < size; ++i)
1844 printf("%s", fault_chars[fault_type]);
1845 }
1846 putchar(' ');
1847 inc = size;
1848 nslash = 0;
1849 for(;;){
1850 if( scanhex(&n) ){
1851 for (i = 0; i < size; ++i)
1852 val[i] = n >> (i * 8);
1853 if (!brev)
1854 byterev(val, size);
1855 mwrite(adrs, val, size);
1856 inc = size;
1857 }
1858 cmd = skipbl();
1859 if (cmd == '\n')
1860 break;
1861 inc = 0;
1862 switch (cmd) {
1863 case '\'':
1864 for(;;){
1865 n = inchar();
1866 if( n == '\\' )
1867 n = bsesc();
1868 else if( n == '\'' )
1869 break;
1870 for (i = 0; i < size; ++i)
1871 val[i] = n >> (i * 8);
1872 if (!brev)
1873 byterev(val, size);
1874 mwrite(adrs, val, size);
1875 adrs += size;
1876 }
1877 adrs -= size;
1878 inc = size;
1879 break;
1880 case ',':
1881 adrs += size;
1882 break;
1883 case '.':
1884 mnoread = 0;
1885 break;
1886 case ';':
1887 break;
1888 case 'x':
1889 case EOF:
1890 scannl();
1891 return;
1892 case 'b':
1893 case 'v':
1894 size = 1;
1895 break;
1896 case 'w':
1897 size = 2;
1898 break;
1899 case 'l':
1900 size = 4;
1901 break;
1902 case 'u':
1903 size = 8;
1904 break;
1905 case '^':
1906 adrs -= size;
1907 break;
1908 break;
1909 case '/':
1910 if (nslash > 0)
1911 adrs -= 1 << nslash;
1912 else
1913 nslash = 0;
1914 nslash += 4;
1915 adrs += 1 << nslash;
1916 break;
1917 case '\\':
1918 if (nslash < 0)
1919 adrs += 1 << -nslash;
1920 else
1921 nslash = 0;
1922 nslash -= 4;
1923 adrs -= 1 << -nslash;
1924 break;
1925 case 'm':
1926 scanhex((void *)&adrs);
1927 break;
1928 case 'n':
1929 mnoread = 1;
1930 break;
1931 case 'r':
1932 brev = !brev;
1933 break;
1934 case '<':
1935 n = size;
1936 scanhex(&n);
1937 adrs -= n;
1938 break;
1939 case '>':
1940 n = size;
1941 scanhex(&n);
1942 adrs += n;
1943 break;
1944 case '?':
1945 printf(memex_subcmd_help_string);
1946 break;
1947 }
1948 }
1949 adrs += inc;
1950 }
1951 }
1952
1953 static int
1954 bsesc(void)
1955 {
1956 int c;
1957
1958 c = inchar();
1959 switch( c ){
1960 case 'n': c = '\n'; break;
1961 case 'r': c = '\r'; break;
1962 case 'b': c = '\b'; break;
1963 case 't': c = '\t'; break;
1964 }
1965 return c;
1966 }
1967
1968 static void xmon_rawdump (unsigned long adrs, long ndump)
1969 {
1970 long n, m, r, nr;
1971 unsigned char temp[16];
1972
1973 for (n = ndump; n > 0;) {
1974 r = n < 16? n: 16;
1975 nr = mread(adrs, temp, r);
1976 adrs += nr;
1977 for (m = 0; m < r; ++m) {
1978 if (m < nr)
1979 printf("%.2x", temp[m]);
1980 else
1981 printf("%s", fault_chars[fault_type]);
1982 }
1983 n -= r;
1984 if (nr < r)
1985 break;
1986 }
1987 printf("\n");
1988 }
1989
1990 #define isxdigit(c) (('0' <= (c) && (c) <= '9') \
1991 || ('a' <= (c) && (c) <= 'f') \
1992 || ('A' <= (c) && (c) <= 'F'))
1993 static void
1994 dump(void)
1995 {
1996 int c;
1997
1998 c = inchar();
1999 if ((isxdigit(c) && c != 'f' && c != 'd') || c == '\n')
2000 termch = c;
2001 scanhex((void *)&adrs);
2002 if (termch != '\n')
2003 termch = 0;
2004 if (c == 'i') {
2005 scanhex(&nidump);
2006 if (nidump == 0)
2007 nidump = 16;
2008 else if (nidump > MAX_DUMP)
2009 nidump = MAX_DUMP;
2010 adrs += ppc_inst_dump(adrs, nidump, 1);
2011 last_cmd = "di\n";
2012 } else if (c == 'r') {
2013 scanhex(&ndump);
2014 if (ndump == 0)
2015 ndump = 64;
2016 xmon_rawdump(adrs, ndump);
2017 adrs += ndump;
2018 last_cmd = "dr\n";
2019 } else {
2020 scanhex(&ndump);
2021 if (ndump == 0)
2022 ndump = 64;
2023 else if (ndump > MAX_DUMP)
2024 ndump = MAX_DUMP;
2025 prdump(adrs, ndump);
2026 adrs += ndump;
2027 last_cmd = "d\n";
2028 }
2029 }
2030
2031 static void
2032 prdump(unsigned long adrs, long ndump)
2033 {
2034 long n, m, c, r, nr;
2035 unsigned char temp[16];
2036
2037 for (n = ndump; n > 0;) {
2038 printf(REG, adrs);
2039 putchar(' ');
2040 r = n < 16? n: 16;
2041 nr = mread(adrs, temp, r);
2042 adrs += nr;
2043 for (m = 0; m < r; ++m) {
2044 if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2045 putchar(' ');
2046 if (m < nr)
2047 printf("%.2x", temp[m]);
2048 else
2049 printf("%s", fault_chars[fault_type]);
2050 }
2051 for (; m < 16; ++m) {
2052 if ((m & (sizeof(long) - 1)) == 0)
2053 putchar(' ');
2054 printf(" ");
2055 }
2056 printf(" |");
2057 for (m = 0; m < r; ++m) {
2058 if (m < nr) {
2059 c = temp[m];
2060 putchar(' ' <= c && c <= '~'? c: '.');
2061 } else
2062 putchar(' ');
2063 }
2064 n -= r;
2065 for (; m < 16; ++m)
2066 putchar(' ');
2067 printf("|\n");
2068 if (nr < r)
2069 break;
2070 }
2071 }
2072
2073 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr);
2074
2075 static int
2076 generic_inst_dump(unsigned long adr, long count, int praddr,
2077 instruction_dump_func dump_func)
2078 {
2079 int nr, dotted;
2080 unsigned long first_adr;
2081 unsigned long inst, last_inst = 0;
2082 unsigned char val[4];
2083
2084 dotted = 0;
2085 for (first_adr = adr; count > 0; --count, adr += 4) {
2086 nr = mread(adr, val, 4);
2087 if (nr == 0) {
2088 if (praddr) {
2089 const char *x = fault_chars[fault_type];
2090 printf(REG" %s%s%s%s\n", adr, x, x, x, x);
2091 }
2092 break;
2093 }
2094 inst = GETWORD(val);
2095 if (adr > first_adr && inst == last_inst) {
2096 if (!dotted) {
2097 printf(" ...\n");
2098 dotted = 1;
2099 }
2100 continue;
2101 }
2102 dotted = 0;
2103 last_inst = inst;
2104 if (praddr)
2105 printf(REG" %.8x", adr, inst);
2106 printf("\t");
2107 dump_func(inst, adr);
2108 printf("\n");
2109 }
2110 return adr - first_adr;
2111 }
2112
2113 static int
2114 ppc_inst_dump(unsigned long adr, long count, int praddr)
2115 {
2116 return generic_inst_dump(adr, count, praddr, print_insn_powerpc);
2117 }
2118
2119 void
2120 print_address(unsigned long addr)
2121 {
2122 xmon_print_symbol(addr, "\t# ", "");
2123 }
2124
2125
2126 /*
2127 * Memory operations - move, set, print differences
2128 */
2129 static unsigned long mdest; /* destination address */
2130 static unsigned long msrc; /* source address */
2131 static unsigned long mval; /* byte value to set memory to */
2132 static unsigned long mcount; /* # bytes to affect */
2133 static unsigned long mdiffs; /* max # differences to print */
2134
2135 static void
2136 memops(int cmd)
2137 {
2138 scanhex((void *)&mdest);
2139 if( termch != '\n' )
2140 termch = 0;
2141 scanhex((void *)(cmd == 's'? &mval: &msrc));
2142 if( termch != '\n' )
2143 termch = 0;
2144 scanhex((void *)&mcount);
2145 switch( cmd ){
2146 case 'm':
2147 memmove((void *)mdest, (void *)msrc, mcount);
2148 break;
2149 case 's':
2150 memset((void *)mdest, mval, mcount);
2151 break;
2152 case 'd':
2153 if( termch != '\n' )
2154 termch = 0;
2155 scanhex((void *)&mdiffs);
2156 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
2157 break;
2158 }
2159 }
2160
2161 static void
2162 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
2163 {
2164 unsigned n, prt;
2165
2166 prt = 0;
2167 for( n = nb; n > 0; --n )
2168 if( *p1++ != *p2++ )
2169 if( ++prt <= maxpr )
2170 printf("%.16x %.2x # %.16x %.2x\n", p1 - 1,
2171 p1[-1], p2 - 1, p2[-1]);
2172 if( prt > maxpr )
2173 printf("Total of %d differences\n", prt);
2174 }
2175
2176 static unsigned mend;
2177 static unsigned mask;
2178
2179 static void
2180 memlocate(void)
2181 {
2182 unsigned a, n;
2183 unsigned char val[4];
2184
2185 last_cmd = "ml";
2186 scanhex((void *)&mdest);
2187 if (termch != '\n') {
2188 termch = 0;
2189 scanhex((void *)&mend);
2190 if (termch != '\n') {
2191 termch = 0;
2192 scanhex((void *)&mval);
2193 mask = ~0;
2194 if (termch != '\n') termch = 0;
2195 scanhex((void *)&mask);
2196 }
2197 }
2198 n = 0;
2199 for (a = mdest; a < mend; a += 4) {
2200 if (mread(a, val, 4) == 4
2201 && ((GETWORD(val) ^ mval) & mask) == 0) {
2202 printf("%.16x: %.16x\n", a, GETWORD(val));
2203 if (++n >= 10)
2204 break;
2205 }
2206 }
2207 }
2208
2209 static unsigned long mskip = 0x1000;
2210 static unsigned long mlim = 0xffffffff;
2211
2212 static void
2213 memzcan(void)
2214 {
2215 unsigned char v;
2216 unsigned a;
2217 int ok, ook;
2218
2219 scanhex(&mdest);
2220 if (termch != '\n') termch = 0;
2221 scanhex(&mskip);
2222 if (termch != '\n') termch = 0;
2223 scanhex(&mlim);
2224 ook = 0;
2225 for (a = mdest; a < mlim; a += mskip) {
2226 ok = mread(a, &v, 1);
2227 if (ok && !ook) {
2228 printf("%.8x .. ", a);
2229 } else if (!ok && ook)
2230 printf("%.8x\n", a - mskip);
2231 ook = ok;
2232 if (a + mskip < a)
2233 break;
2234 }
2235 if (ook)
2236 printf("%.8x\n", a - mskip);
2237 }
2238
2239 static void proccall(void)
2240 {
2241 unsigned long args[8];
2242 unsigned long ret;
2243 int i;
2244 typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
2245 unsigned long, unsigned long, unsigned long,
2246 unsigned long, unsigned long, unsigned long);
2247 callfunc_t func;
2248
2249 if (!scanhex(&adrs))
2250 return;
2251 if (termch != '\n')
2252 termch = 0;
2253 for (i = 0; i < 8; ++i)
2254 args[i] = 0;
2255 for (i = 0; i < 8; ++i) {
2256 if (!scanhex(&args[i]) || termch == '\n')
2257 break;
2258 termch = 0;
2259 }
2260 func = (callfunc_t) adrs;
2261 ret = 0;
2262 if (setjmp(bus_error_jmp) == 0) {
2263 catch_memory_errors = 1;
2264 sync();
2265 ret = func(args[0], args[1], args[2], args[3],
2266 args[4], args[5], args[6], args[7]);
2267 sync();
2268 printf("return value is %x\n", ret);
2269 } else {
2270 printf("*** %x exception occurred\n", fault_except);
2271 }
2272 catch_memory_errors = 0;
2273 }
2274
2275 /* Input scanning routines */
2276 int
2277 skipbl(void)
2278 {
2279 int c;
2280
2281 if( termch != 0 ){
2282 c = termch;
2283 termch = 0;
2284 } else
2285 c = inchar();
2286 while( c == ' ' || c == '\t' )
2287 c = inchar();
2288 return c;
2289 }
2290
2291 #define N_PTREGS 44
2292 static char *regnames[N_PTREGS] = {
2293 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2294 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2295 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2296 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
2297 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
2298 #ifdef CONFIG_PPC64
2299 "softe",
2300 #else
2301 "mq",
2302 #endif
2303 "trap", "dar", "dsisr", "res"
2304 };
2305
2306 int
2307 scanhex(unsigned long *vp)
2308 {
2309 int c, d;
2310 unsigned long v;
2311
2312 c = skipbl();
2313 if (c == '%') {
2314 /* parse register name */
2315 char regname[8];
2316 int i;
2317
2318 for (i = 0; i < sizeof(regname) - 1; ++i) {
2319 c = inchar();
2320 if (!isalnum(c)) {
2321 termch = c;
2322 break;
2323 }
2324 regname[i] = c;
2325 }
2326 regname[i] = 0;
2327 for (i = 0; i < N_PTREGS; ++i) {
2328 if (strcmp(regnames[i], regname) == 0) {
2329 if (xmon_regs == NULL) {
2330 printf("regs not available\n");
2331 return 0;
2332 }
2333 *vp = ((unsigned long *)xmon_regs)[i];
2334 return 1;
2335 }
2336 }
2337 printf("invalid register name '%%%s'\n", regname);
2338 return 0;
2339 }
2340
2341 /* skip leading "0x" if any */
2342
2343 if (c == '0') {
2344 c = inchar();
2345 if (c == 'x') {
2346 c = inchar();
2347 } else {
2348 d = hexdigit(c);
2349 if (d == EOF) {
2350 termch = c;
2351 *vp = 0;
2352 return 1;
2353 }
2354 }
2355 } else if (c == '$') {
2356 int i;
2357 for (i=0; i<63; i++) {
2358 c = inchar();
2359 if (isspace(c)) {
2360 termch = c;
2361 break;
2362 }
2363 tmpstr[i] = c;
2364 }
2365 tmpstr[i++] = 0;
2366 *vp = 0;
2367 if (setjmp(bus_error_jmp) == 0) {
2368 catch_memory_errors = 1;
2369 sync();
2370 *vp = kallsyms_lookup_name(tmpstr);
2371 sync();
2372 }
2373 catch_memory_errors = 0;
2374 if (!(*vp)) {
2375 printf("unknown symbol '%s'\n", tmpstr);
2376 return 0;
2377 }
2378 return 1;
2379 }
2380
2381 d = hexdigit(c);
2382 if (d == EOF) {
2383 termch = c;
2384 return 0;
2385 }
2386 v = 0;
2387 do {
2388 v = (v << 4) + d;
2389 c = inchar();
2390 d = hexdigit(c);
2391 } while (d != EOF);
2392 termch = c;
2393 *vp = v;
2394 return 1;
2395 }
2396
2397 static void
2398 scannl(void)
2399 {
2400 int c;
2401
2402 c = termch;
2403 termch = 0;
2404 while( c != '\n' )
2405 c = inchar();
2406 }
2407
2408 static int hexdigit(int c)
2409 {
2410 if( '0' <= c && c <= '9' )
2411 return c - '0';
2412 if( 'A' <= c && c <= 'F' )
2413 return c - ('A' - 10);
2414 if( 'a' <= c && c <= 'f' )
2415 return c - ('a' - 10);
2416 return EOF;
2417 }
2418
2419 void
2420 getstring(char *s, int size)
2421 {
2422 int c;
2423
2424 c = skipbl();
2425 do {
2426 if( size > 1 ){
2427 *s++ = c;
2428 --size;
2429 }
2430 c = inchar();
2431 } while( c != ' ' && c != '\t' && c != '\n' );
2432 termch = c;
2433 *s = 0;
2434 }
2435
2436 static char line[256];
2437 static char *lineptr;
2438
2439 static void
2440 flush_input(void)
2441 {
2442 lineptr = NULL;
2443 }
2444
2445 static int
2446 inchar(void)
2447 {
2448 if (lineptr == NULL || *lineptr == 0) {
2449 if (xmon_gets(line, sizeof(line)) == NULL) {
2450 lineptr = NULL;
2451 return EOF;
2452 }
2453 lineptr = line;
2454 }
2455 return *lineptr++;
2456 }
2457
2458 static void
2459 take_input(char *str)
2460 {
2461 lineptr = str;
2462 }
2463
2464
2465 static void
2466 symbol_lookup(void)
2467 {
2468 int type = inchar();
2469 unsigned long addr;
2470 static char tmp[64];
2471
2472 switch (type) {
2473 case 'a':
2474 if (scanhex(&addr))
2475 xmon_print_symbol(addr, ": ", "\n");
2476 termch = 0;
2477 break;
2478 case 's':
2479 getstring(tmp, 64);
2480 if (setjmp(bus_error_jmp) == 0) {
2481 catch_memory_errors = 1;
2482 sync();
2483 addr = kallsyms_lookup_name(tmp);
2484 if (addr)
2485 printf("%s: %lx\n", tmp, addr);
2486 else
2487 printf("Symbol '%s' not found.\n", tmp);
2488 sync();
2489 }
2490 catch_memory_errors = 0;
2491 termch = 0;
2492 break;
2493 }
2494 }
2495
2496
2497 /* Print an address in numeric and symbolic form (if possible) */
2498 static void xmon_print_symbol(unsigned long address, const char *mid,
2499 const char *after)
2500 {
2501 char *modname;
2502 const char *name = NULL;
2503 unsigned long offset, size;
2504
2505 printf(REG, address);
2506 if (setjmp(bus_error_jmp) == 0) {
2507 catch_memory_errors = 1;
2508 sync();
2509 name = kallsyms_lookup(address, &size, &offset, &modname,
2510 tmpstr);
2511 sync();
2512 /* wait a little while to see if we get a machine check */
2513 __delay(200);
2514 }
2515
2516 catch_memory_errors = 0;
2517
2518 if (name) {
2519 printf("%s%s+%#lx/%#lx", mid, name, offset, size);
2520 if (modname)
2521 printf(" [%s]", modname);
2522 }
2523 printf("%s", after);
2524 }
2525
2526 #ifdef CONFIG_PPC64
2527 static void dump_slb(void)
2528 {
2529 int i;
2530 unsigned long esid,vsid,valid;
2531 unsigned long llp;
2532
2533 printf("SLB contents of cpu %x\n", smp_processor_id());
2534
2535 for (i = 0; i < mmu_slb_size; i++) {
2536 asm volatile("slbmfee %0,%1" : "=r" (esid) : "r" (i));
2537 asm volatile("slbmfev %0,%1" : "=r" (vsid) : "r" (i));
2538 valid = (esid & SLB_ESID_V);
2539 if (valid | esid | vsid) {
2540 printf("%02d %016lx %016lx", i, esid, vsid);
2541 if (valid) {
2542 llp = vsid & SLB_VSID_LLP;
2543 if (vsid & SLB_VSID_B_1T) {
2544 printf(" 1T ESID=%9lx VSID=%13lx LLP:%3lx \n",
2545 GET_ESID_1T(esid),
2546 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T,
2547 llp);
2548 } else {
2549 printf(" 256M ESID=%9lx VSID=%13lx LLP:%3lx \n",
2550 GET_ESID(esid),
2551 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT,
2552 llp);
2553 }
2554 } else
2555 printf("\n");
2556 }
2557 }
2558 }
2559
2560 static void dump_stab(void)
2561 {
2562 int i;
2563 unsigned long *tmp = (unsigned long *)get_paca()->stab_addr;
2564
2565 printf("Segment table contents of cpu %x\n", smp_processor_id());
2566
2567 for (i = 0; i < PAGE_SIZE/16; i++) {
2568 unsigned long a, b;
2569
2570 a = *tmp++;
2571 b = *tmp++;
2572
2573 if (a || b) {
2574 printf("%03d %016lx ", i, a);
2575 printf("%016lx\n", b);
2576 }
2577 }
2578 }
2579
2580 void dump_segments(void)
2581 {
2582 if (cpu_has_feature(CPU_FTR_SLB))
2583 dump_slb();
2584 else
2585 dump_stab();
2586 }
2587 #endif
2588
2589 #ifdef CONFIG_PPC_STD_MMU_32
2590 void dump_segments(void)
2591 {
2592 int i;
2593
2594 printf("sr0-15 =");
2595 for (i = 0; i < 16; ++i)
2596 printf(" %x", mfsrin(i));
2597 printf("\n");
2598 }
2599 #endif
2600
2601 #ifdef CONFIG_44x
2602 static void dump_tlb_44x(void)
2603 {
2604 int i;
2605
2606 for (i = 0; i < PPC44x_TLB_SIZE; i++) {
2607 unsigned long w0,w1,w2;
2608 asm volatile("tlbre %0,%1,0" : "=r" (w0) : "r" (i));
2609 asm volatile("tlbre %0,%1,1" : "=r" (w1) : "r" (i));
2610 asm volatile("tlbre %0,%1,2" : "=r" (w2) : "r" (i));
2611 printf("[%02x] %08x %08x %08x ", i, w0, w1, w2);
2612 if (w0 & PPC44x_TLB_VALID) {
2613 printf("V %08x -> %01x%08x %c%c%c%c%c",
2614 w0 & PPC44x_TLB_EPN_MASK,
2615 w1 & PPC44x_TLB_ERPN_MASK,
2616 w1 & PPC44x_TLB_RPN_MASK,
2617 (w2 & PPC44x_TLB_W) ? 'W' : 'w',
2618 (w2 & PPC44x_TLB_I) ? 'I' : 'i',
2619 (w2 & PPC44x_TLB_M) ? 'M' : 'm',
2620 (w2 & PPC44x_TLB_G) ? 'G' : 'g',
2621 (w2 & PPC44x_TLB_E) ? 'E' : 'e');
2622 }
2623 printf("\n");
2624 }
2625 }
2626 #endif /* CONFIG_44x */
2627
2628 static void xmon_init(int enable)
2629 {
2630 #ifdef CONFIG_PPC_ISERIES
2631 if (firmware_has_feature(FW_FEATURE_ISERIES))
2632 return;
2633 #endif
2634 if (enable) {
2635 __debugger = xmon;
2636 __debugger_ipi = xmon_ipi;
2637 __debugger_bpt = xmon_bpt;
2638 __debugger_sstep = xmon_sstep;
2639 __debugger_iabr_match = xmon_iabr_match;
2640 __debugger_dabr_match = xmon_dabr_match;
2641 __debugger_fault_handler = xmon_fault_handler;
2642 } else {
2643 __debugger = NULL;
2644 __debugger_ipi = NULL;
2645 __debugger_bpt = NULL;
2646 __debugger_sstep = NULL;
2647 __debugger_iabr_match = NULL;
2648 __debugger_dabr_match = NULL;
2649 __debugger_fault_handler = NULL;
2650 }
2651 xmon_map_scc();
2652 }
2653
2654 #ifdef CONFIG_MAGIC_SYSRQ
2655 static void sysrq_handle_xmon(int key, struct tty_struct *tty)
2656 {
2657 /* ensure xmon is enabled */
2658 xmon_init(1);
2659 debugger(get_irq_regs());
2660 }
2661
2662 static struct sysrq_key_op sysrq_xmon_op =
2663 {
2664 .handler = sysrq_handle_xmon,
2665 .help_msg = "Xmon",
2666 .action_msg = "Entering xmon",
2667 };
2668
2669 static int __init setup_xmon_sysrq(void)
2670 {
2671 #ifdef CONFIG_PPC_ISERIES
2672 if (firmware_has_feature(FW_FEATURE_ISERIES))
2673 return 0;
2674 #endif
2675 register_sysrq_key('x', &sysrq_xmon_op);
2676 return 0;
2677 }
2678 __initcall(setup_xmon_sysrq);
2679 #endif /* CONFIG_MAGIC_SYSRQ */
2680
2681 static int __initdata xmon_early, xmon_off;
2682
2683 static int __init early_parse_xmon(char *p)
2684 {
2685 if (!p || strncmp(p, "early", 5) == 0) {
2686 /* just "xmon" is equivalent to "xmon=early" */
2687 xmon_init(1);
2688 xmon_early = 1;
2689 } else if (strncmp(p, "on", 2) == 0)
2690 xmon_init(1);
2691 else if (strncmp(p, "off", 3) == 0)
2692 xmon_off = 1;
2693 else if (strncmp(p, "nobt", 4) == 0)
2694 xmon_no_auto_backtrace = 1;
2695 else
2696 return 1;
2697
2698 return 0;
2699 }
2700 early_param("xmon", early_parse_xmon);
2701
2702 void __init xmon_setup(void)
2703 {
2704 #ifdef CONFIG_XMON_DEFAULT
2705 if (!xmon_off)
2706 xmon_init(1);
2707 #endif
2708 if (xmon_early)
2709 debugger(NULL);
2710 }
2711
2712 #ifdef CONFIG_SPU_BASE
2713
2714 struct spu_info {
2715 struct spu *spu;
2716 u64 saved_mfc_sr1_RW;
2717 u32 saved_spu_runcntl_RW;
2718 unsigned long dump_addr;
2719 u8 stopped_ok;
2720 };
2721
2722 #define XMON_NUM_SPUS 16 /* Enough for current hardware */
2723
2724 static struct spu_info spu_info[XMON_NUM_SPUS];
2725
2726 void xmon_register_spus(struct list_head *list)
2727 {
2728 struct spu *spu;
2729
2730 list_for_each_entry(spu, list, full_list) {
2731 if (spu->number >= XMON_NUM_SPUS) {
2732 WARN_ON(1);
2733 continue;
2734 }
2735
2736 spu_info[spu->number].spu = spu;
2737 spu_info[spu->number].stopped_ok = 0;
2738 spu_info[spu->number].dump_addr = (unsigned long)
2739 spu_info[spu->number].spu->local_store;
2740 }
2741 }
2742
2743 static void stop_spus(void)
2744 {
2745 struct spu *spu;
2746 int i;
2747 u64 tmp;
2748
2749 for (i = 0; i < XMON_NUM_SPUS; i++) {
2750 if (!spu_info[i].spu)
2751 continue;
2752
2753 if (setjmp(bus_error_jmp) == 0) {
2754 catch_memory_errors = 1;
2755 sync();
2756
2757 spu = spu_info[i].spu;
2758
2759 spu_info[i].saved_spu_runcntl_RW =
2760 in_be32(&spu->problem->spu_runcntl_RW);
2761
2762 tmp = spu_mfc_sr1_get(spu);
2763 spu_info[i].saved_mfc_sr1_RW = tmp;
2764
2765 tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
2766 spu_mfc_sr1_set(spu, tmp);
2767
2768 sync();
2769 __delay(200);
2770
2771 spu_info[i].stopped_ok = 1;
2772
2773 printf("Stopped spu %.2d (was %s)\n", i,
2774 spu_info[i].saved_spu_runcntl_RW ?
2775 "running" : "stopped");
2776 } else {
2777 catch_memory_errors = 0;
2778 printf("*** Error stopping spu %.2d\n", i);
2779 }
2780 catch_memory_errors = 0;
2781 }
2782 }
2783
2784 static void restart_spus(void)
2785 {
2786 struct spu *spu;
2787 int i;
2788
2789 for (i = 0; i < XMON_NUM_SPUS; i++) {
2790 if (!spu_info[i].spu)
2791 continue;
2792
2793 if (!spu_info[i].stopped_ok) {
2794 printf("*** Error, spu %d was not successfully stopped"
2795 ", not restarting\n", i);
2796 continue;
2797 }
2798
2799 if (setjmp(bus_error_jmp) == 0) {
2800 catch_memory_errors = 1;
2801 sync();
2802
2803 spu = spu_info[i].spu;
2804 spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW);
2805 out_be32(&spu->problem->spu_runcntl_RW,
2806 spu_info[i].saved_spu_runcntl_RW);
2807
2808 sync();
2809 __delay(200);
2810
2811 printf("Restarted spu %.2d\n", i);
2812 } else {
2813 catch_memory_errors = 0;
2814 printf("*** Error restarting spu %.2d\n", i);
2815 }
2816 catch_memory_errors = 0;
2817 }
2818 }
2819
2820 #define DUMP_WIDTH 23
2821 #define DUMP_VALUE(format, field, value) \
2822 do { \
2823 if (setjmp(bus_error_jmp) == 0) { \
2824 catch_memory_errors = 1; \
2825 sync(); \
2826 printf(" %-*s = "format"\n", DUMP_WIDTH, \
2827 #field, value); \
2828 sync(); \
2829 __delay(200); \
2830 } else { \
2831 catch_memory_errors = 0; \
2832 printf(" %-*s = *** Error reading field.\n", \
2833 DUMP_WIDTH, #field); \
2834 } \
2835 catch_memory_errors = 0; \
2836 } while (0)
2837
2838 #define DUMP_FIELD(obj, format, field) \
2839 DUMP_VALUE(format, field, obj->field)
2840
2841 static void dump_spu_fields(struct spu *spu)
2842 {
2843 printf("Dumping spu fields at address %p:\n", spu);
2844
2845 DUMP_FIELD(spu, "0x%x", number);
2846 DUMP_FIELD(spu, "%s", name);
2847 DUMP_FIELD(spu, "0x%lx", local_store_phys);
2848 DUMP_FIELD(spu, "0x%p", local_store);
2849 DUMP_FIELD(spu, "0x%lx", ls_size);
2850 DUMP_FIELD(spu, "0x%x", node);
2851 DUMP_FIELD(spu, "0x%lx", flags);
2852 DUMP_FIELD(spu, "%d", class_0_pending);
2853 DUMP_FIELD(spu, "0x%lx", class_0_dar);
2854 DUMP_FIELD(spu, "0x%lx", class_1_dar);
2855 DUMP_FIELD(spu, "0x%lx", class_1_dsisr);
2856 DUMP_FIELD(spu, "0x%lx", irqs[0]);
2857 DUMP_FIELD(spu, "0x%lx", irqs[1]);
2858 DUMP_FIELD(spu, "0x%lx", irqs[2]);
2859 DUMP_FIELD(spu, "0x%x", slb_replace);
2860 DUMP_FIELD(spu, "%d", pid);
2861 DUMP_FIELD(spu, "0x%p", mm);
2862 DUMP_FIELD(spu, "0x%p", ctx);
2863 DUMP_FIELD(spu, "0x%p", rq);
2864 DUMP_FIELD(spu, "0x%p", timestamp);
2865 DUMP_FIELD(spu, "0x%lx", problem_phys);
2866 DUMP_FIELD(spu, "0x%p", problem);
2867 DUMP_VALUE("0x%x", problem->spu_runcntl_RW,
2868 in_be32(&spu->problem->spu_runcntl_RW));
2869 DUMP_VALUE("0x%x", problem->spu_status_R,
2870 in_be32(&spu->problem->spu_status_R));
2871 DUMP_VALUE("0x%x", problem->spu_npc_RW,
2872 in_be32(&spu->problem->spu_npc_RW));
2873 DUMP_FIELD(spu, "0x%p", priv2);
2874 DUMP_FIELD(spu, "0x%p", pdata);
2875 }
2876
2877 int
2878 spu_inst_dump(unsigned long adr, long count, int praddr)
2879 {
2880 return generic_inst_dump(adr, count, praddr, print_insn_spu);
2881 }
2882
2883 static void dump_spu_ls(unsigned long num, int subcmd)
2884 {
2885 unsigned long offset, addr, ls_addr;
2886
2887 if (setjmp(bus_error_jmp) == 0) {
2888 catch_memory_errors = 1;
2889 sync();
2890 ls_addr = (unsigned long)spu_info[num].spu->local_store;
2891 sync();
2892 __delay(200);
2893 } else {
2894 catch_memory_errors = 0;
2895 printf("*** Error: accessing spu info for spu %d\n", num);
2896 return;
2897 }
2898 catch_memory_errors = 0;
2899
2900 if (scanhex(&offset))
2901 addr = ls_addr + offset;
2902 else
2903 addr = spu_info[num].dump_addr;
2904
2905 if (addr >= ls_addr + LS_SIZE) {
2906 printf("*** Error: address outside of local store\n");
2907 return;
2908 }
2909
2910 switch (subcmd) {
2911 case 'i':
2912 addr += spu_inst_dump(addr, 16, 1);
2913 last_cmd = "sdi\n";
2914 break;
2915 default:
2916 prdump(addr, 64);
2917 addr += 64;
2918 last_cmd = "sd\n";
2919 break;
2920 }
2921
2922 spu_info[num].dump_addr = addr;
2923 }
2924
2925 static int do_spu_cmd(void)
2926 {
2927 static unsigned long num = 0;
2928 int cmd, subcmd = 0;
2929
2930 cmd = inchar();
2931 switch (cmd) {
2932 case 's':
2933 stop_spus();
2934 break;
2935 case 'r':
2936 restart_spus();
2937 break;
2938 case 'd':
2939 subcmd = inchar();
2940 if (isxdigit(subcmd) || subcmd == '\n')
2941 termch = subcmd;
2942 case 'f':
2943 scanhex(&num);
2944 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) {
2945 printf("*** Error: invalid spu number\n");
2946 return 0;
2947 }
2948
2949 switch (cmd) {
2950 case 'f':
2951 dump_spu_fields(spu_info[num].spu);
2952 break;
2953 default:
2954 dump_spu_ls(num, subcmd);
2955 break;
2956 }
2957
2958 break;
2959 default:
2960 return -1;
2961 }
2962
2963 return 0;
2964 }
2965 #else /* ! CONFIG_SPU_BASE */
2966 static int do_spu_cmd(void)
2967 {
2968 return -1;
2969 }
2970 #endif
Support for the Chinese Samsung S3C2440 based development boards