?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix f_flags/f_mode in case of lookup_instantiate_filp() from open(pathname, 3)
[linux-2.6/linux-2.6-openrd.git] / arch / powerpc / xmon / xmon.c
blob4e6152c13764e173aa7811c249c8a359b5a60a5c
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",
1645 ptrLpPaca->gpr5_dword.saved_gpr5);
1646 }
1647 #endif
1648
1649 return;
1650 }
1651
1652 scanhex(&regno);
1653 switch (cmd) {
1654 case 'w':
1655 val = read_spr(regno);
1656 scanhex(&val);
1657 write_spr(regno, val);
1658 /* fall through */
1659 case 'r':
1660 printf("spr %lx = %lx\n", regno, read_spr(regno));
1661 break;
1662 }
1663 scannl();
1664 }
1665
1666 /*
1667 * Stuff for reading and writing memory safely
1668 */
1669 static int
1670 mread(unsigned long adrs, void *buf, int size)
1671 {
1672 volatile int n;
1673 char *p, *q;
1674
1675 n = 0;
1676 if (setjmp(bus_error_jmp) == 0) {
1677 catch_memory_errors = 1;
1678 sync();
1679 p = (char *)adrs;
1680 q = (char *)buf;
1681 switch (size) {
1682 case 2:
1683 *(u16 *)q = *(u16 *)p;
1684 break;
1685 case 4:
1686 *(u32 *)q = *(u32 *)p;
1687 break;
1688 case 8:
1689 *(u64 *)q = *(u64 *)p;
1690 break;
1691 default:
1692 for( ; n < size; ++n) {
1693 *q++ = *p++;
1694 sync();
1695 }
1696 }
1697 sync();
1698 /* wait a little while to see if we get a machine check */
1699 __delay(200);
1700 n = size;
1701 }
1702 catch_memory_errors = 0;
1703 return n;
1704 }
1705
1706 static int
1707 mwrite(unsigned long adrs, void *buf, int size)
1708 {
1709 volatile int n;
1710 char *p, *q;
1711
1712 n = 0;
1713 if (setjmp(bus_error_jmp) == 0) {
1714 catch_memory_errors = 1;
1715 sync();
1716 p = (char *) adrs;
1717 q = (char *) buf;
1718 switch (size) {
1719 case 2:
1720 *(u16 *)p = *(u16 *)q;
1721 break;
1722 case 4:
1723 *(u32 *)p = *(u32 *)q;
1724 break;
1725 case 8:
1726 *(u64 *)p = *(u64 *)q;
1727 break;
1728 default:
1729 for ( ; n < size; ++n) {
1730 *p++ = *q++;
1731 sync();
1732 }
1733 }
1734 sync();
1735 /* wait a little while to see if we get a machine check */
1736 __delay(200);
1737 n = size;
1738 } else {
1739 printf("*** Error writing address %x\n", adrs + n);
1740 }
1741 catch_memory_errors = 0;
1742 return n;
1743 }
1744
1745 static int fault_type;
1746 static int fault_except;
1747 static char *fault_chars[] = { "--", "**", "##" };
1748
1749 static int handle_fault(struct pt_regs *regs)
1750 {
1751 fault_except = TRAP(regs);
1752 switch (TRAP(regs)) {
1753 case 0x200:
1754 fault_type = 0;
1755 break;
1756 case 0x300:
1757 case 0x380:
1758 fault_type = 1;
1759 break;
1760 default:
1761 fault_type = 2;
1762 }
1763
1764 longjmp(bus_error_jmp, 1);
1765
1766 return 0;
1767 }
1768
1769 #define SWAP(a, b, t) ((t) = (a), (a) = (b), (b) = (t))
1770
1771 static void
1772 byterev(unsigned char *val, int size)
1773 {
1774 int t;
1775
1776 switch (size) {
1777 case 2:
1778 SWAP(val[0], val[1], t);
1779 break;
1780 case 4:
1781 SWAP(val[0], val[3], t);
1782 SWAP(val[1], val[2], t);
1783 break;
1784 case 8: /* is there really any use for this? */
1785 SWAP(val[0], val[7], t);
1786 SWAP(val[1], val[6], t);
1787 SWAP(val[2], val[5], t);
1788 SWAP(val[3], val[4], t);
1789 break;
1790 }
1791 }
1792
1793 static int brev;
1794 static int mnoread;
1795
1796 static char *memex_help_string =
1797 "Memory examine command usage:\n"
1798 "m [addr] [flags] examine/change memory\n"
1799 " addr is optional. will start where left off.\n"
1800 " flags may include chars from this set:\n"
1801 " b modify by bytes (default)\n"
1802 " w modify by words (2 byte)\n"
1803 " l modify by longs (4 byte)\n"
1804 " d modify by doubleword (8 byte)\n"
1805 " r toggle reverse byte order mode\n"
1806 " n do not read memory (for i/o spaces)\n"
1807 " . ok to read (default)\n"
1808 "NOTE: flags are saved as defaults\n"
1809 "";
1810
1811 static char *memex_subcmd_help_string =
1812 "Memory examine subcommands:\n"
1813 " hexval write this val to current location\n"
1814 " 'string' write chars from string to this location\n"
1815 " ' increment address\n"
1816 " ^ decrement address\n"
1817 " / increment addr by 0x10. //=0x100, ///=0x1000, etc\n"
1818 " \\ decrement addr by 0x10. \\\\=0x100, \\\\\\=0x1000, etc\n"
1819 " ` clear no-read flag\n"
1820 " ; stay at this addr\n"
1821 " v change to byte mode\n"
1822 " w change to word (2 byte) mode\n"
1823 " l change to long (4 byte) mode\n"
1824 " u change to doubleword (8 byte) mode\n"
1825 " m addr change current addr\n"
1826 " n toggle no-read flag\n"
1827 " r toggle byte reverse flag\n"
1828 " < count back up count bytes\n"
1829 " > count skip forward count bytes\n"
1830 " x exit this mode\n"
1831 "";
1832
1833 static void
1834 memex(void)
1835 {
1836 int cmd, inc, i, nslash;
1837 unsigned long n;
1838 unsigned char val[16];
1839
1840 scanhex((void *)&adrs);
1841 cmd = skipbl();
1842 if (cmd == '?') {
1843 printf(memex_help_string);
1844 return;
1845 } else {
1846 termch = cmd;
1847 }
1848 last_cmd = "m\n";
1849 while ((cmd = skipbl()) != '\n') {
1850 switch( cmd ){
1851 case 'b': size = 1; break;
1852 case 'w': size = 2; break;
1853 case 'l': size = 4; break;
1854 case 'd': size = 8; break;
1855 case 'r': brev = !brev; break;
1856 case 'n': mnoread = 1; break;
1857 case '.': mnoread = 0; break;
1858 }
1859 }
1860 if( size <= 0 )
1861 size = 1;
1862 else if( size > 8 )
1863 size = 8;
1864 for(;;){
1865 if (!mnoread)
1866 n = mread(adrs, val, size);
1867 printf(REG"%c", adrs, brev? 'r': ' ');
1868 if (!mnoread) {
1869 if (brev)
1870 byterev(val, size);
1871 putchar(' ');
1872 for (i = 0; i < n; ++i)
1873 printf("%.2x", val[i]);
1874 for (; i < size; ++i)
1875 printf("%s", fault_chars[fault_type]);
1876 }
1877 putchar(' ');
1878 inc = size;
1879 nslash = 0;
1880 for(;;){
1881 if( scanhex(&n) ){
1882 for (i = 0; i < size; ++i)
1883 val[i] = n >> (i * 8);
1884 if (!brev)
1885 byterev(val, size);
1886 mwrite(adrs, val, size);
1887 inc = size;
1888 }
1889 cmd = skipbl();
1890 if (cmd == '\n')
1891 break;
1892 inc = 0;
1893 switch (cmd) {
1894 case '\'':
1895 for(;;){
1896 n = inchar();
1897 if( n == '\\' )
1898 n = bsesc();
1899 else if( n == '\'' )
1900 break;
1901 for (i = 0; i < size; ++i)
1902 val[i] = n >> (i * 8);
1903 if (!brev)
1904 byterev(val, size);
1905 mwrite(adrs, val, size);
1906 adrs += size;
1907 }
1908 adrs -= size;
1909 inc = size;
1910 break;
1911 case ',':
1912 adrs += size;
1913 break;
1914 case '.':
1915 mnoread = 0;
1916 break;
1917 case ';':
1918 break;
1919 case 'x':
1920 case EOF:
1921 scannl();
1922 return;
1923 case 'b':
1924 case 'v':
1925 size = 1;
1926 break;
1927 case 'w':
1928 size = 2;
1929 break;
1930 case 'l':
1931 size = 4;
1932 break;
1933 case 'u':
1934 size = 8;
1935 break;
1936 case '^':
1937 adrs -= size;
1938 break;
1939 break;
1940 case '/':
1941 if (nslash > 0)
1942 adrs -= 1 << nslash;
1943 else
1944 nslash = 0;
1945 nslash += 4;
1946 adrs += 1 << nslash;
1947 break;
1948 case '\\':
1949 if (nslash < 0)
1950 adrs += 1 << -nslash;
1951 else
1952 nslash = 0;
1953 nslash -= 4;
1954 adrs -= 1 << -nslash;
1955 break;
1956 case 'm':
1957 scanhex((void *)&adrs);
1958 break;
1959 case 'n':
1960 mnoread = 1;
1961 break;
1962 case 'r':
1963 brev = !brev;
1964 break;
1965 case '<':
1966 n = size;
1967 scanhex(&n);
1968 adrs -= n;
1969 break;
1970 case '>':
1971 n = size;
1972 scanhex(&n);
1973 adrs += n;
1974 break;
1975 case '?':
1976 printf(memex_subcmd_help_string);
1977 break;
1978 }
1979 }
1980 adrs += inc;
1981 }
1982 }
1983
1984 static int
1985 bsesc(void)
1986 {
1987 int c;
1988
1989 c = inchar();
1990 switch( c ){
1991 case 'n': c = '\n'; break;
1992 case 'r': c = '\r'; break;
1993 case 'b': c = '\b'; break;
1994 case 't': c = '\t'; break;
1995 }
1996 return c;
1997 }
1998
1999 static void xmon_rawdump (unsigned long adrs, long ndump)
2000 {
2001 long n, m, r, nr;
2002 unsigned char temp[16];
2003
2004 for (n = ndump; n > 0;) {
2005 r = n < 16? n: 16;
2006 nr = mread(adrs, temp, r);
2007 adrs += nr;
2008 for (m = 0; m < r; ++m) {
2009 if (m < nr)
2010 printf("%.2x", temp[m]);
2011 else
2012 printf("%s", fault_chars[fault_type]);
2013 }
2014 n -= r;
2015 if (nr < r)
2016 break;
2017 }
2018 printf("\n");
2019 }
2020
2021 #define isxdigit(c) (('0' <= (c) && (c) <= '9') \
2022 || ('a' <= (c) && (c) <= 'f') \
2023 || ('A' <= (c) && (c) <= 'F'))
2024 static void
2025 dump(void)
2026 {
2027 int c;
2028
2029 c = inchar();
2030 if ((isxdigit(c) && c != 'f' && c != 'd') || c == '\n')
2031 termch = c;
2032 scanhex((void *)&adrs);
2033 if (termch != '\n')
2034 termch = 0;
2035 if (c == 'i') {
2036 scanhex(&nidump);
2037 if (nidump == 0)
2038 nidump = 16;
2039 else if (nidump > MAX_DUMP)
2040 nidump = MAX_DUMP;
2041 adrs += ppc_inst_dump(adrs, nidump, 1);
2042 last_cmd = "di\n";
2043 } else if (c == 'l') {
2044 dump_log_buf();
2045 } else if (c == 'r') {
2046 scanhex(&ndump);
2047 if (ndump == 0)
2048 ndump = 64;
2049 xmon_rawdump(adrs, ndump);
2050 adrs += ndump;
2051 last_cmd = "dr\n";
2052 } else {
2053 scanhex(&ndump);
2054 if (ndump == 0)
2055 ndump = 64;
2056 else if (ndump > MAX_DUMP)
2057 ndump = MAX_DUMP;
2058 prdump(adrs, ndump);
2059 adrs += ndump;
2060 last_cmd = "d\n";
2061 }
2062 }
2063
2064 static void
2065 prdump(unsigned long adrs, long ndump)
2066 {
2067 long n, m, c, r, nr;
2068 unsigned char temp[16];
2069
2070 for (n = ndump; n > 0;) {
2071 printf(REG, adrs);
2072 putchar(' ');
2073 r = n < 16? n: 16;
2074 nr = mread(adrs, temp, r);
2075 adrs += nr;
2076 for (m = 0; m < r; ++m) {
2077 if ((m & (sizeof(long) - 1)) == 0 && m > 0)
2078 putchar(' ');
2079 if (m < nr)
2080 printf("%.2x", temp[m]);
2081 else
2082 printf("%s", fault_chars[fault_type]);
2083 }
2084 for (; m < 16; ++m) {
2085 if ((m & (sizeof(long) - 1)) == 0)
2086 putchar(' ');
2087 printf(" ");
2088 }
2089 printf(" |");
2090 for (m = 0; m < r; ++m) {
2091 if (m < nr) {
2092 c = temp[m];
2093 putchar(' ' <= c && c <= '~'? c: '.');
2094 } else
2095 putchar(' ');
2096 }
2097 n -= r;
2098 for (; m < 16; ++m)
2099 putchar(' ');
2100 printf("|\n");
2101 if (nr < r)
2102 break;
2103 }
2104 }
2105
2106 typedef int (*instruction_dump_func)(unsigned long inst, unsigned long addr);
2107
2108 static int
2109 generic_inst_dump(unsigned long adr, long count, int praddr,
2110 instruction_dump_func dump_func)
2111 {
2112 int nr, dotted;
2113 unsigned long first_adr;
2114 unsigned long inst, last_inst = 0;
2115 unsigned char val[4];
2116
2117 dotted = 0;
2118 for (first_adr = adr; count > 0; --count, adr += 4) {
2119 nr = mread(adr, val, 4);
2120 if (nr == 0) {
2121 if (praddr) {
2122 const char *x = fault_chars[fault_type];
2123 printf(REG" %s%s%s%s\n", adr, x, x, x, x);
2124 }
2125 break;
2126 }
2127 inst = GETWORD(val);
2128 if (adr > first_adr && inst == last_inst) {
2129 if (!dotted) {
2130 printf(" ...\n");
2131 dotted = 1;
2132 }
2133 continue;
2134 }
2135 dotted = 0;
2136 last_inst = inst;
2137 if (praddr)
2138 printf(REG" %.8x", adr, inst);
2139 printf("\t");
2140 dump_func(inst, adr);
2141 printf("\n");
2142 }
2143 return adr - first_adr;
2144 }
2145
2146 static int
2147 ppc_inst_dump(unsigned long adr, long count, int praddr)
2148 {
2149 return generic_inst_dump(adr, count, praddr, print_insn_powerpc);
2150 }
2151
2152 void
2153 print_address(unsigned long addr)
2154 {
2155 xmon_print_symbol(addr, "\t# ", "");
2156 }
2157
2158 void
2159 dump_log_buf(void)
2160 {
2161 const unsigned long size = 128;
2162 unsigned long end, addr;
2163 unsigned char buf[size + 1];
2164
2165 addr = 0;
2166 buf[size] = '\0';
2167
2168 if (setjmp(bus_error_jmp) != 0) {
2169 printf("Unable to lookup symbol __log_buf!\n");
2170 return;
2171 }
2172
2173 catch_memory_errors = 1;
2174 sync();
2175 addr = kallsyms_lookup_name("__log_buf");
2176
2177 if (! addr)
2178 printf("Symbol __log_buf not found!\n");
2179 else {
2180 end = addr + (1 << CONFIG_LOG_BUF_SHIFT);
2181 while (addr < end) {
2182 if (! mread(addr, buf, size)) {
2183 printf("Can't read memory at address 0x%lx\n", addr);
2184 break;
2185 }
2186
2187 printf("%s", buf);
2188
2189 if (strlen(buf) < size)
2190 break;
2191
2192 addr += size;
2193 }
2194 }
2195
2196 sync();
2197 /* wait a little while to see if we get a machine check */
2198 __delay(200);
2199 catch_memory_errors = 0;
2200 }
2201
2202 /*
2203 * Memory operations - move, set, print differences
2204 */
2205 static unsigned long mdest; /* destination address */
2206 static unsigned long msrc; /* source address */
2207 static unsigned long mval; /* byte value to set memory to */
2208 static unsigned long mcount; /* # bytes to affect */
2209 static unsigned long mdiffs; /* max # differences to print */
2210
2211 static void
2212 memops(int cmd)
2213 {
2214 scanhex((void *)&mdest);
2215 if( termch != '\n' )
2216 termch = 0;
2217 scanhex((void *)(cmd == 's'? &mval: &msrc));
2218 if( termch != '\n' )
2219 termch = 0;
2220 scanhex((void *)&mcount);
2221 switch( cmd ){
2222 case 'm':
2223 memmove((void *)mdest, (void *)msrc, mcount);
2224 break;
2225 case 's':
2226 memset((void *)mdest, mval, mcount);
2227 break;
2228 case 'd':
2229 if( termch != '\n' )
2230 termch = 0;
2231 scanhex((void *)&mdiffs);
2232 memdiffs((unsigned char *)mdest, (unsigned char *)msrc, mcount, mdiffs);
2233 break;
2234 }
2235 }
2236
2237 static void
2238 memdiffs(unsigned char *p1, unsigned char *p2, unsigned nb, unsigned maxpr)
2239 {
2240 unsigned n, prt;
2241
2242 prt = 0;
2243 for( n = nb; n > 0; --n )
2244 if( *p1++ != *p2++ )
2245 if( ++prt <= maxpr )
2246 printf("%.16x %.2x # %.16x %.2x\n", p1 - 1,
2247 p1[-1], p2 - 1, p2[-1]);
2248 if( prt > maxpr )
2249 printf("Total of %d differences\n", prt);
2250 }
2251
2252 static unsigned mend;
2253 static unsigned mask;
2254
2255 static void
2256 memlocate(void)
2257 {
2258 unsigned a, n;
2259 unsigned char val[4];
2260
2261 last_cmd = "ml";
2262 scanhex((void *)&mdest);
2263 if (termch != '\n') {
2264 termch = 0;
2265 scanhex((void *)&mend);
2266 if (termch != '\n') {
2267 termch = 0;
2268 scanhex((void *)&mval);
2269 mask = ~0;
2270 if (termch != '\n') termch = 0;
2271 scanhex((void *)&mask);
2272 }
2273 }
2274 n = 0;
2275 for (a = mdest; a < mend; a += 4) {
2276 if (mread(a, val, 4) == 4
2277 && ((GETWORD(val) ^ mval) & mask) == 0) {
2278 printf("%.16x: %.16x\n", a, GETWORD(val));
2279 if (++n >= 10)
2280 break;
2281 }
2282 }
2283 }
2284
2285 static unsigned long mskip = 0x1000;
2286 static unsigned long mlim = 0xffffffff;
2287
2288 static void
2289 memzcan(void)
2290 {
2291 unsigned char v;
2292 unsigned a;
2293 int ok, ook;
2294
2295 scanhex(&mdest);
2296 if (termch != '\n') termch = 0;
2297 scanhex(&mskip);
2298 if (termch != '\n') termch = 0;
2299 scanhex(&mlim);
2300 ook = 0;
2301 for (a = mdest; a < mlim; a += mskip) {
2302 ok = mread(a, &v, 1);
2303 if (ok && !ook) {
2304 printf("%.8x .. ", a);
2305 } else if (!ok && ook)
2306 printf("%.8x\n", a - mskip);
2307 ook = ok;
2308 if (a + mskip < a)
2309 break;
2310 }
2311 if (ook)
2312 printf("%.8x\n", a - mskip);
2313 }
2314
2315 static void proccall(void)
2316 {
2317 unsigned long args[8];
2318 unsigned long ret;
2319 int i;
2320 typedef unsigned long (*callfunc_t)(unsigned long, unsigned long,
2321 unsigned long, unsigned long, unsigned long,
2322 unsigned long, unsigned long, unsigned long);
2323 callfunc_t func;
2324
2325 if (!scanhex(&adrs))
2326 return;
2327 if (termch != '\n')
2328 termch = 0;
2329 for (i = 0; i < 8; ++i)
2330 args[i] = 0;
2331 for (i = 0; i < 8; ++i) {
2332 if (!scanhex(&args[i]) || termch == '\n')
2333 break;
2334 termch = 0;
2335 }
2336 func = (callfunc_t) adrs;
2337 ret = 0;
2338 if (setjmp(bus_error_jmp) == 0) {
2339 catch_memory_errors = 1;
2340 sync();
2341 ret = func(args[0], args[1], args[2], args[3],
2342 args[4], args[5], args[6], args[7]);
2343 sync();
2344 printf("return value is %x\n", ret);
2345 } else {
2346 printf("*** %x exception occurred\n", fault_except);
2347 }
2348 catch_memory_errors = 0;
2349 }
2350
2351 /* Input scanning routines */
2352 int
2353 skipbl(void)
2354 {
2355 int c;
2356
2357 if( termch != 0 ){
2358 c = termch;
2359 termch = 0;
2360 } else
2361 c = inchar();
2362 while( c == ' ' || c == '\t' )
2363 c = inchar();
2364 return c;
2365 }
2366
2367 #define N_PTREGS 44
2368 static char *regnames[N_PTREGS] = {
2369 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
2370 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
2371 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
2372 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
2373 "pc", "msr", "or3", "ctr", "lr", "xer", "ccr",
2374 #ifdef CONFIG_PPC64
2375 "softe",
2376 #else
2377 "mq",
2378 #endif
2379 "trap", "dar", "dsisr", "res"
2380 };
2381
2382 int
2383 scanhex(unsigned long *vp)
2384 {
2385 int c, d;
2386 unsigned long v;
2387
2388 c = skipbl();
2389 if (c == '%') {
2390 /* parse register name */
2391 char regname[8];
2392 int i;
2393
2394 for (i = 0; i < sizeof(regname) - 1; ++i) {
2395 c = inchar();
2396 if (!isalnum(c)) {
2397 termch = c;
2398 break;
2399 }
2400 regname[i] = c;
2401 }
2402 regname[i] = 0;
2403 for (i = 0; i < N_PTREGS; ++i) {
2404 if (strcmp(regnames[i], regname) == 0) {
2405 if (xmon_regs == NULL) {
2406 printf("regs not available\n");
2407 return 0;
2408 }
2409 *vp = ((unsigned long *)xmon_regs)[i];
2410 return 1;
2411 }
2412 }
2413 printf("invalid register name '%%%s'\n", regname);
2414 return 0;
2415 }
2416
2417 /* skip leading "0x" if any */
2418
2419 if (c == '0') {
2420 c = inchar();
2421 if (c == 'x') {
2422 c = inchar();
2423 } else {
2424 d = hexdigit(c);
2425 if (d == EOF) {
2426 termch = c;
2427 *vp = 0;
2428 return 1;
2429 }
2430 }
2431 } else if (c == '$') {
2432 int i;
2433 for (i=0; i<63; i++) {
2434 c = inchar();
2435 if (isspace(c)) {
2436 termch = c;
2437 break;
2438 }
2439 tmpstr[i] = c;
2440 }
2441 tmpstr[i++] = 0;
2442 *vp = 0;
2443 if (setjmp(bus_error_jmp) == 0) {
2444 catch_memory_errors = 1;
2445 sync();
2446 *vp = kallsyms_lookup_name(tmpstr);
2447 sync();
2448 }
2449 catch_memory_errors = 0;
2450 if (!(*vp)) {
2451 printf("unknown symbol '%s'\n", tmpstr);
2452 return 0;
2453 }
2454 return 1;
2455 }
2456
2457 d = hexdigit(c);
2458 if (d == EOF) {
2459 termch = c;
2460 return 0;
2461 }
2462 v = 0;
2463 do {
2464 v = (v << 4) + d;
2465 c = inchar();
2466 d = hexdigit(c);
2467 } while (d != EOF);
2468 termch = c;
2469 *vp = v;
2470 return 1;
2471 }
2472
2473 static void
2474 scannl(void)
2475 {
2476 int c;
2477
2478 c = termch;
2479 termch = 0;
2480 while( c != '\n' )
2481 c = inchar();
2482 }
2483
2484 static int hexdigit(int c)
2485 {
2486 if( '0' <= c && c <= '9' )
2487 return c - '0';
2488 if( 'A' <= c && c <= 'F' )
2489 return c - ('A' - 10);
2490 if( 'a' <= c && c <= 'f' )
2491 return c - ('a' - 10);
2492 return EOF;
2493 }
2494
2495 void
2496 getstring(char *s, int size)
2497 {
2498 int c;
2499
2500 c = skipbl();
2501 do {
2502 if( size > 1 ){
2503 *s++ = c;
2504 --size;
2505 }
2506 c = inchar();
2507 } while( c != ' ' && c != '\t' && c != '\n' );
2508 termch = c;
2509 *s = 0;
2510 }
2511
2512 static char line[256];
2513 static char *lineptr;
2514
2515 static void
2516 flush_input(void)
2517 {
2518 lineptr = NULL;
2519 }
2520
2521 static int
2522 inchar(void)
2523 {
2524 if (lineptr == NULL || *lineptr == 0) {
2525 if (xmon_gets(line, sizeof(line)) == NULL) {
2526 lineptr = NULL;
2527 return EOF;
2528 }
2529 lineptr = line;
2530 }
2531 return *lineptr++;
2532 }
2533
2534 static void
2535 take_input(char *str)
2536 {
2537 lineptr = str;
2538 }
2539
2540
2541 static void
2542 symbol_lookup(void)
2543 {
2544 int type = inchar();
2545 unsigned long addr;
2546 static char tmp[64];
2547
2548 switch (type) {
2549 case 'a':
2550 if (scanhex(&addr))
2551 xmon_print_symbol(addr, ": ", "\n");
2552 termch = 0;
2553 break;
2554 case 's':
2555 getstring(tmp, 64);
2556 if (setjmp(bus_error_jmp) == 0) {
2557 catch_memory_errors = 1;
2558 sync();
2559 addr = kallsyms_lookup_name(tmp);
2560 if (addr)
2561 printf("%s: %lx\n", tmp, addr);
2562 else
2563 printf("Symbol '%s' not found.\n", tmp);
2564 sync();
2565 }
2566 catch_memory_errors = 0;
2567 termch = 0;
2568 break;
2569 }
2570 }
2571
2572
2573 /* Print an address in numeric and symbolic form (if possible) */
2574 static void xmon_print_symbol(unsigned long address, const char *mid,
2575 const char *after)
2576 {
2577 char *modname;
2578 const char *name = NULL;
2579 unsigned long offset, size;
2580
2581 printf(REG, address);
2582 if (setjmp(bus_error_jmp) == 0) {
2583 catch_memory_errors = 1;
2584 sync();
2585 name = kallsyms_lookup(address, &size, &offset, &modname,
2586 tmpstr);
2587 sync();
2588 /* wait a little while to see if we get a machine check */
2589 __delay(200);
2590 }
2591
2592 catch_memory_errors = 0;
2593
2594 if (name) {
2595 printf("%s%s+%#lx/%#lx", mid, name, offset, size);
2596 if (modname)
2597 printf(" [%s]", modname);
2598 }
2599 printf("%s", after);
2600 }
2601
2602 #ifdef CONFIG_PPC_BOOK3S_64
2603 static void dump_slb(void)
2604 {
2605 int i;
2606 unsigned long esid,vsid,valid;
2607 unsigned long llp;
2608
2609 printf("SLB contents of cpu %x\n", smp_processor_id());
2610
2611 for (i = 0; i < mmu_slb_size; i++) {
2612 asm volatile("slbmfee %0,%1" : "=r" (esid) : "r" (i));
2613 asm volatile("slbmfev %0,%1" : "=r" (vsid) : "r" (i));
2614 valid = (esid & SLB_ESID_V);
2615 if (valid | esid | vsid) {
2616 printf("%02d %016lx %016lx", i, esid, vsid);
2617 if (valid) {
2618 llp = vsid & SLB_VSID_LLP;
2619 if (vsid & SLB_VSID_B_1T) {
2620 printf(" 1T ESID=%9lx VSID=%13lx LLP:%3lx \n",
2621 GET_ESID_1T(esid),
2622 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT_1T,
2623 llp);
2624 } else {
2625 printf(" 256M ESID=%9lx VSID=%13lx LLP:%3lx \n",
2626 GET_ESID(esid),
2627 (vsid & ~SLB_VSID_B) >> SLB_VSID_SHIFT,
2628 llp);
2629 }
2630 } else
2631 printf("\n");
2632 }
2633 }
2634 }
2635
2636 static void dump_stab(void)
2637 {
2638 int i;
2639 unsigned long *tmp = (unsigned long *)get_paca()->stab_addr;
2640
2641 printf("Segment table contents of cpu %x\n", smp_processor_id());
2642
2643 for (i = 0; i < PAGE_SIZE/16; i++) {
2644 unsigned long a, b;
2645
2646 a = *tmp++;
2647 b = *tmp++;
2648
2649 if (a || b) {
2650 printf("%03d %016lx ", i, a);
2651 printf("%016lx\n", b);
2652 }
2653 }
2654 }
2655
2656 void dump_segments(void)
2657 {
2658 if (cpu_has_feature(CPU_FTR_SLB))
2659 dump_slb();
2660 else
2661 dump_stab();
2662 }
2663 #endif
2664
2665 #ifdef CONFIG_PPC_STD_MMU_32
2666 void dump_segments(void)
2667 {
2668 int i;
2669
2670 printf("sr0-15 =");
2671 for (i = 0; i < 16; ++i)
2672 printf(" %x", mfsrin(i));
2673 printf("\n");
2674 }
2675 #endif
2676
2677 #ifdef CONFIG_44x
2678 static void dump_tlb_44x(void)
2679 {
2680 int i;
2681
2682 for (i = 0; i < PPC44x_TLB_SIZE; i++) {
2683 unsigned long w0,w1,w2;
2684 asm volatile("tlbre %0,%1,0" : "=r" (w0) : "r" (i));
2685 asm volatile("tlbre %0,%1,1" : "=r" (w1) : "r" (i));
2686 asm volatile("tlbre %0,%1,2" : "=r" (w2) : "r" (i));
2687 printf("[%02x] %08x %08x %08x ", i, w0, w1, w2);
2688 if (w0 & PPC44x_TLB_VALID) {
2689 printf("V %08x -> %01x%08x %c%c%c%c%c",
2690 w0 & PPC44x_TLB_EPN_MASK,
2691 w1 & PPC44x_TLB_ERPN_MASK,
2692 w1 & PPC44x_TLB_RPN_MASK,
2693 (w2 & PPC44x_TLB_W) ? 'W' : 'w',
2694 (w2 & PPC44x_TLB_I) ? 'I' : 'i',
2695 (w2 & PPC44x_TLB_M) ? 'M' : 'm',
2696 (w2 & PPC44x_TLB_G) ? 'G' : 'g',
2697 (w2 & PPC44x_TLB_E) ? 'E' : 'e');
2698 }
2699 printf("\n");
2700 }
2701 }
2702 #endif /* CONFIG_44x */
2703
2704 static void xmon_init(int enable)
2705 {
2706 #ifdef CONFIG_PPC_ISERIES
2707 if (firmware_has_feature(FW_FEATURE_ISERIES))
2708 return;
2709 #endif
2710 if (enable) {
2711 __debugger = xmon;
2712 __debugger_ipi = xmon_ipi;
2713 __debugger_bpt = xmon_bpt;
2714 __debugger_sstep = xmon_sstep;
2715 __debugger_iabr_match = xmon_iabr_match;
2716 __debugger_dabr_match = xmon_dabr_match;
2717 __debugger_fault_handler = xmon_fault_handler;
2718 } else {
2719 __debugger = NULL;
2720 __debugger_ipi = NULL;
2721 __debugger_bpt = NULL;
2722 __debugger_sstep = NULL;
2723 __debugger_iabr_match = NULL;
2724 __debugger_dabr_match = NULL;
2725 __debugger_fault_handler = NULL;
2726 }
2727 xmon_map_scc();
2728 }
2729
2730 #ifdef CONFIG_MAGIC_SYSRQ
2731 static void sysrq_handle_xmon(int key, struct tty_struct *tty)
2732 {
2733 /* ensure xmon is enabled */
2734 xmon_init(1);
2735 debugger(get_irq_regs());
2736 }
2737
2738 static struct sysrq_key_op sysrq_xmon_op =
2739 {
2740 .handler = sysrq_handle_xmon,
2741 .help_msg = "Xmon",
2742 .action_msg = "Entering xmon",
2743 };
2744
2745 static int __init setup_xmon_sysrq(void)
2746 {
2747 #ifdef CONFIG_PPC_ISERIES
2748 if (firmware_has_feature(FW_FEATURE_ISERIES))
2749 return 0;
2750 #endif
2751 register_sysrq_key('x', &sysrq_xmon_op);
2752 return 0;
2753 }
2754 __initcall(setup_xmon_sysrq);
2755 #endif /* CONFIG_MAGIC_SYSRQ */
2756
2757 static int __initdata xmon_early, xmon_off;
2758
2759 static int __init early_parse_xmon(char *p)
2760 {
2761 if (!p || strncmp(p, "early", 5) == 0) {
2762 /* just "xmon" is equivalent to "xmon=early" */
2763 xmon_init(1);
2764 xmon_early = 1;
2765 } else if (strncmp(p, "on", 2) == 0)
2766 xmon_init(1);
2767 else if (strncmp(p, "off", 3) == 0)
2768 xmon_off = 1;
2769 else if (strncmp(p, "nobt", 4) == 0)
2770 xmon_no_auto_backtrace = 1;
2771 else
2772 return 1;
2773
2774 return 0;
2775 }
2776 early_param("xmon", early_parse_xmon);
2777
2778 void __init xmon_setup(void)
2779 {
2780 #ifdef CONFIG_XMON_DEFAULT
2781 if (!xmon_off)
2782 xmon_init(1);
2783 #endif
2784 if (xmon_early)
2785 debugger(NULL);
2786 }
2787
2788 #ifdef CONFIG_SPU_BASE
2789
2790 struct spu_info {
2791 struct spu *spu;
2792 u64 saved_mfc_sr1_RW;
2793 u32 saved_spu_runcntl_RW;
2794 unsigned long dump_addr;
2795 u8 stopped_ok;
2796 };
2797
2798 #define XMON_NUM_SPUS 16 /* Enough for current hardware */
2799
2800 static struct spu_info spu_info[XMON_NUM_SPUS];
2801
2802 void xmon_register_spus(struct list_head *list)
2803 {
2804 struct spu *spu;
2805
2806 list_for_each_entry(spu, list, full_list) {
2807 if (spu->number >= XMON_NUM_SPUS) {
2808 WARN_ON(1);
2809 continue;
2810 }
2811
2812 spu_info[spu->number].spu = spu;
2813 spu_info[spu->number].stopped_ok = 0;
2814 spu_info[spu->number].dump_addr = (unsigned long)
2815 spu_info[spu->number].spu->local_store;
2816 }
2817 }
2818
2819 static void stop_spus(void)
2820 {
2821 struct spu *spu;
2822 int i;
2823 u64 tmp;
2824
2825 for (i = 0; i < XMON_NUM_SPUS; i++) {
2826 if (!spu_info[i].spu)
2827 continue;
2828
2829 if (setjmp(bus_error_jmp) == 0) {
2830 catch_memory_errors = 1;
2831 sync();
2832
2833 spu = spu_info[i].spu;
2834
2835 spu_info[i].saved_spu_runcntl_RW =
2836 in_be32(&spu->problem->spu_runcntl_RW);
2837
2838 tmp = spu_mfc_sr1_get(spu);
2839 spu_info[i].saved_mfc_sr1_RW = tmp;
2840
2841 tmp &= ~MFC_STATE1_MASTER_RUN_CONTROL_MASK;
2842 spu_mfc_sr1_set(spu, tmp);
2843
2844 sync();
2845 __delay(200);
2846
2847 spu_info[i].stopped_ok = 1;
2848
2849 printf("Stopped spu %.2d (was %s)\n", i,
2850 spu_info[i].saved_spu_runcntl_RW ?
2851 "running" : "stopped");
2852 } else {
2853 catch_memory_errors = 0;
2854 printf("*** Error stopping spu %.2d\n", i);
2855 }
2856 catch_memory_errors = 0;
2857 }
2858 }
2859
2860 static void restart_spus(void)
2861 {
2862 struct spu *spu;
2863 int i;
2864
2865 for (i = 0; i < XMON_NUM_SPUS; i++) {
2866 if (!spu_info[i].spu)
2867 continue;
2868
2869 if (!spu_info[i].stopped_ok) {
2870 printf("*** Error, spu %d was not successfully stopped"
2871 ", not restarting\n", i);
2872 continue;
2873 }
2874
2875 if (setjmp(bus_error_jmp) == 0) {
2876 catch_memory_errors = 1;
2877 sync();
2878
2879 spu = spu_info[i].spu;
2880 spu_mfc_sr1_set(spu, spu_info[i].saved_mfc_sr1_RW);
2881 out_be32(&spu->problem->spu_runcntl_RW,
2882 spu_info[i].saved_spu_runcntl_RW);
2883
2884 sync();
2885 __delay(200);
2886
2887 printf("Restarted spu %.2d\n", i);
2888 } else {
2889 catch_memory_errors = 0;
2890 printf("*** Error restarting spu %.2d\n", i);
2891 }
2892 catch_memory_errors = 0;
2893 }
2894 }
2895
2896 #define DUMP_WIDTH 23
2897 #define DUMP_VALUE(format, field, value) \
2898 do { \
2899 if (setjmp(bus_error_jmp) == 0) { \
2900 catch_memory_errors = 1; \
2901 sync(); \
2902 printf(" %-*s = "format"\n", DUMP_WIDTH, \
2903 #field, value); \
2904 sync(); \
2905 __delay(200); \
2906 } else { \
2907 catch_memory_errors = 0; \
2908 printf(" %-*s = *** Error reading field.\n", \
2909 DUMP_WIDTH, #field); \
2910 } \
2911 catch_memory_errors = 0; \
2912 } while (0)
2913
2914 #define DUMP_FIELD(obj, format, field) \
2915 DUMP_VALUE(format, field, obj->field)
2916
2917 static void dump_spu_fields(struct spu *spu)
2918 {
2919 printf("Dumping spu fields at address %p:\n", spu);
2920
2921 DUMP_FIELD(spu, "0x%x", number);
2922 DUMP_FIELD(spu, "%s", name);
2923 DUMP_FIELD(spu, "0x%lx", local_store_phys);
2924 DUMP_FIELD(spu, "0x%p", local_store);
2925 DUMP_FIELD(spu, "0x%lx", ls_size);
2926 DUMP_FIELD(spu, "0x%x", node);
2927 DUMP_FIELD(spu, "0x%lx", flags);
2928 DUMP_FIELD(spu, "%d", class_0_pending);
2929 DUMP_FIELD(spu, "0x%lx", class_0_dar);
2930 DUMP_FIELD(spu, "0x%lx", class_1_dar);
2931 DUMP_FIELD(spu, "0x%lx", class_1_dsisr);
2932 DUMP_FIELD(spu, "0x%lx", irqs[0]);
2933 DUMP_FIELD(spu, "0x%lx", irqs[1]);
2934 DUMP_FIELD(spu, "0x%lx", irqs[2]);
2935 DUMP_FIELD(spu, "0x%x", slb_replace);
2936 DUMP_FIELD(spu, "%d", pid);
2937 DUMP_FIELD(spu, "0x%p", mm);
2938 DUMP_FIELD(spu, "0x%p", ctx);
2939 DUMP_FIELD(spu, "0x%p", rq);
2940 DUMP_FIELD(spu, "0x%p", timestamp);
2941 DUMP_FIELD(spu, "0x%lx", problem_phys);
2942 DUMP_FIELD(spu, "0x%p", problem);
2943 DUMP_VALUE("0x%x", problem->spu_runcntl_RW,
2944 in_be32(&spu->problem->spu_runcntl_RW));
2945 DUMP_VALUE("0x%x", problem->spu_status_R,
2946 in_be32(&spu->problem->spu_status_R));
2947 DUMP_VALUE("0x%x", problem->spu_npc_RW,
2948 in_be32(&spu->problem->spu_npc_RW));
2949 DUMP_FIELD(spu, "0x%p", priv2);
2950 DUMP_FIELD(spu, "0x%p", pdata);
2951 }
2952
2953 int
2954 spu_inst_dump(unsigned long adr, long count, int praddr)
2955 {
2956 return generic_inst_dump(adr, count, praddr, print_insn_spu);
2957 }
2958
2959 static void dump_spu_ls(unsigned long num, int subcmd)
2960 {
2961 unsigned long offset, addr, ls_addr;
2962
2963 if (setjmp(bus_error_jmp) == 0) {
2964 catch_memory_errors = 1;
2965 sync();
2966 ls_addr = (unsigned long)spu_info[num].spu->local_store;
2967 sync();
2968 __delay(200);
2969 } else {
2970 catch_memory_errors = 0;
2971 printf("*** Error: accessing spu info for spu %d\n", num);
2972 return;
2973 }
2974 catch_memory_errors = 0;
2975
2976 if (scanhex(&offset))
2977 addr = ls_addr + offset;
2978 else
2979 addr = spu_info[num].dump_addr;
2980
2981 if (addr >= ls_addr + LS_SIZE) {
2982 printf("*** Error: address outside of local store\n");
2983 return;
2984 }
2985
2986 switch (subcmd) {
2987 case 'i':
2988 addr += spu_inst_dump(addr, 16, 1);
2989 last_cmd = "sdi\n";
2990 break;
2991 default:
2992 prdump(addr, 64);
2993 addr += 64;
2994 last_cmd = "sd\n";
2995 break;
2996 }
2997
2998 spu_info[num].dump_addr = addr;
2999 }
3000
3001 static int do_spu_cmd(void)
3002 {
3003 static unsigned long num = 0;
3004 int cmd, subcmd = 0;
3005
3006 cmd = inchar();
3007 switch (cmd) {
3008 case 's':
3009 stop_spus();
3010 break;
3011 case 'r':
3012 restart_spus();
3013 break;
3014 case 'd':
3015 subcmd = inchar();
3016 if (isxdigit(subcmd) || subcmd == '\n')
3017 termch = subcmd;
3018 case 'f':
3019 scanhex(&num);
3020 if (num >= XMON_NUM_SPUS || !spu_info[num].spu) {
3021 printf("*** Error: invalid spu number\n");
3022 return 0;
3023 }
3024
3025 switch (cmd) {
3026 case 'f':
3027 dump_spu_fields(spu_info[num].spu);
3028 break;
3029 default:
3030 dump_spu_ls(num, subcmd);
3031 break;
3032 }
3033
3034 break;
3035 default:
3036 return -1;
3037 }
3038
3039 return 0;
3040 }
3041 #else /* ! CONFIG_SPU_BASE */
3042 static int do_spu_cmd(void)
3043 {
3044 return -1;
3045 }
3046 #endif
linux 2.6 git repository for openrd