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