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