2 * ppc-stub.c: KGDB support for the Linux kernel.
4 * adapted from arch/sparc/kernel/sparc-stub.c for the PowerPC
5 * some stuff borrowed from Paul Mackerras' xmon
6 * Copyright (C) 1998 Michael AK Tesch (tesch@cs.wisc.edu)
8 * Modifications to run under Linux
9 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
11 * This file originally came from the gdb sources, and the
12 * copyright notices have been retained below.
15 /****************************************************************************
17 THIS SOFTWARE IS NOT COPYRIGHTED
19 HP offers the following for use in the public domain. HP makes no
20 warranty with regard to the software or its performance and the
21 user accepts the software "AS IS" with all faults.
23 HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
24 TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
25 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
27 ****************************************************************************/
29 /****************************************************************************
30 * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
32 * Module name: remcom.c $
34 * Date: 91/03/09 12:29:49 $
35 * Contributor: Lake Stevens Instrument Division$
37 * Description: low level support for gdb debugger. $
39 * Considerations: only works on target hardware $
41 * Written by: Glenn Engel $
42 * ModuleState: Experimental $
46 * Modified for SPARC by Stu Grossman, Cygnus Support.
48 * This code has been extensively tested on the Fujitsu SPARClite demo board.
50 * To enable debugger support, two things need to happen. One, a
51 * call to set_debug_traps() is necessary in order to allow any breakpoints
52 * or error conditions to be properly intercepted and reported to gdb.
53 * Two, a breakpoint needs to be generated to begin communication. This
54 * is most easily accomplished by a call to breakpoint(). Breakpoint()
55 * simulates a breakpoint by executing a trap #1.
59 * The following gdb commands are supported:
61 * command function Return value
63 * g return the value of the CPU registers hex data or ENN
64 * G set the value of the CPU registers OK or ENN
65 * qOffsets Get section offsets. Reply is Text=xxx;Data=yyy;Bss=zzz
67 * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
68 * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
70 * c Resume at current address SNN ( signal NN)
71 * cAA..AA Continue at address AA..AA SNN
73 * s Step one instruction SNN
74 * sAA..AA Step one instruction from AA..AA SNN
78 * ? What was the last sigval ? SNN (signal NN)
80 * bBB..BB Set baud rate to BB..BB OK or BNN, then sets
83 * All commands and responses are sent with a packet which includes a
84 * checksum. A packet consists of
86 * $<packet info>#<checksum>.
89 * <packet info> :: <characters representing the command or response>
90 * <checksum> :: <two hex digits computed as modulo 256 sum of <packetinfo>>
92 * When a packet is received, it is first acknowledged with either '+' or '-'.
93 * '+' indicates a successful transfer. '-' indicates a failed transfer.
98 * $m0,10#2a +$00010203040506070809101112131415#42
100 ****************************************************************************/
102 #include <linux/config.h>
103 #include <linux/kernel.h>
104 #include <linux/string.h>
105 #include <linux/mm.h>
106 #include <linux/smp.h>
107 #include <linux/smp_lock.h>
109 #include <asm/cacheflush.h>
110 #include <asm/system.h>
111 #include <asm/signal.h>
112 #include <asm/kgdb.h>
113 #include <asm/pgtable.h>
114 #include <asm/ptrace.h>
116 void breakinst(void);
119 * BUFMAX defines the maximum number of characters in inbound/outbound buffers
120 * at least NUMREGBYTES*2 are needed for register packets
123 static char remcomInBuffer[BUFMAX];
124 static char remcomOutBuffer[BUFMAX];
126 static int initialized;
127 static int kgdb_active;
128 static int kgdb_started;
129 static u_int fault_jmp_buf[100];
133 static const char hexchars[]="0123456789abcdef";
135 /* Place where we save old trap entries for restoration - sparc*/
136 /* struct tt_entry kgdb_savettable[256]; */
137 /* typedef void (*trapfunc_t)(void); */
139 static void kgdb_fault_handler(struct pt_regs *regs);
140 static int handle_exception (struct pt_regs *regs);
143 /* Install an exception handler for kgdb */
144 static void exceptionHandler(int tnum, unsigned int *tfunc)
146 /* We are dorking with a live trap table, all irqs off */
151 kgdb_setjmp(long *buf)
153 asm ("mflr 0; stw 0,0(%0);"
154 "stw 1,4(%0); stw 2,8(%0);"
155 "mfcr 0; stw 0,12(%0);"
158 /* XXX should save fp regs as well */
162 kgdb_longjmp(long *buf, int val)
166 asm ("lmw 13,16(%0);"
167 "lwz 0,12(%0); mtcrf 0x38,0;"
168 "lwz 0,0(%0); lwz 1,4(%0); lwz 2,8(%0);"
170 : : "r" (buf), "r" (val));
172 /* Convert ch from a hex digit to an int */
174 hex(unsigned char ch)
176 if (ch >= 'a' && ch <= 'f')
178 if (ch >= '0' && ch <= '9')
180 if (ch >= 'A' && ch <= 'F')
185 /* Convert the memory pointed to by mem into hex, placing result in buf.
186 * Return a pointer to the last char put in buf (null), in case of mem fault,
189 static unsigned char *
190 mem2hex(const char *mem, char *buf, int count)
193 unsigned short tmp_s;
196 if (kgdb_setjmp((long*)fault_jmp_buf) == 0) {
197 debugger_fault_handler = kgdb_fault_handler;
199 /* Accessing 16 bit and 32 bit objects in a single
200 ** load instruction is required to avoid bad side
201 ** effects for some IO registers.
204 if ((count == 2) && (((long)mem & 1) == 0)) {
205 tmp_s = *(unsigned short *)mem;
207 *buf++ = hexchars[(tmp_s >> 12) & 0xf];
208 *buf++ = hexchars[(tmp_s >> 8) & 0xf];
209 *buf++ = hexchars[(tmp_s >> 4) & 0xf];
210 *buf++ = hexchars[tmp_s & 0xf];
212 } else if ((count == 4) && (((long)mem & 3) == 0)) {
213 tmp_l = *(unsigned int *)mem;
215 *buf++ = hexchars[(tmp_l >> 28) & 0xf];
216 *buf++ = hexchars[(tmp_l >> 24) & 0xf];
217 *buf++ = hexchars[(tmp_l >> 20) & 0xf];
218 *buf++ = hexchars[(tmp_l >> 16) & 0xf];
219 *buf++ = hexchars[(tmp_l >> 12) & 0xf];
220 *buf++ = hexchars[(tmp_l >> 8) & 0xf];
221 *buf++ = hexchars[(tmp_l >> 4) & 0xf];
222 *buf++ = hexchars[tmp_l & 0xf];
225 while (count-- > 0) {
227 *buf++ = hexchars[ch >> 4];
228 *buf++ = hexchars[ch & 0xf];
233 /* error condition */
235 debugger_fault_handler = 0;
240 /* convert the hex array pointed to by buf into binary to be placed in mem
241 * return a pointer to the character AFTER the last byte written.
244 hex2mem(char *buf, char *mem, int count)
249 unsigned short tmp_s;
254 if (kgdb_setjmp((long*)fault_jmp_buf) == 0) {
255 debugger_fault_handler = kgdb_fault_handler;
257 /* Accessing 16 bit and 32 bit objects in a single
258 ** store instruction is required to avoid bad side
259 ** effects for some IO registers.
262 if ((count == 2) && (((long)mem & 1) == 0)) {
263 tmp_s = hex(*buf++) << 12;
264 tmp_s |= hex(*buf++) << 8;
265 tmp_s |= hex(*buf++) << 4;
266 tmp_s |= hex(*buf++);
268 *(unsigned short *)mem = tmp_s;
271 } else if ((count == 4) && (((long)mem & 3) == 0)) {
272 tmp_l = hex(*buf++) << 28;
273 tmp_l |= hex(*buf++) << 24;
274 tmp_l |= hex(*buf++) << 20;
275 tmp_l |= hex(*buf++) << 16;
276 tmp_l |= hex(*buf++) << 12;
277 tmp_l |= hex(*buf++) << 8;
278 tmp_l |= hex(*buf++) << 4;
279 tmp_l |= hex(*buf++);
281 *(unsigned long *)mem = tmp_l;
285 for (i=0; i<count; i++) {
286 ch = hex(*buf++) << 4;
294 ** Flush the data cache, invalidate the instruction cache.
296 flush_icache_range((int)orig_mem, (int)orig_mem + count - 1);
299 /* error condition */
301 debugger_fault_handler = 0;
306 * While we find nice hex chars, build an int.
307 * Return number of chars processed.
310 hexToInt(char **ptr, int *intValue)
317 if (kgdb_setjmp((long*)fault_jmp_buf) == 0) {
318 debugger_fault_handler = kgdb_fault_handler;
320 hexValue = hex(**ptr);
324 *intValue = (*intValue << 4) | hexValue;
330 /* error condition */
332 debugger_fault_handler = 0;
337 /* scan for the sequence $<data>#<checksum> */
339 getpacket(char *buffer)
341 unsigned char checksum;
342 unsigned char xmitcsum;
348 /* wait around for the start character, ignore all other
350 while ((ch = (getDebugChar() & 0x7f)) != '$') ;
357 /* now, read until a # or end of buffer is found */
358 while (count < BUFMAX) {
359 ch = getDebugChar() & 0x7f;
362 checksum = checksum + ch;
373 xmitcsum = hex(getDebugChar() & 0x7f) << 4;
374 xmitcsum |= hex(getDebugChar() & 0x7f);
375 if (checksum != xmitcsum)
376 putDebugChar('-'); /* failed checksum */
378 putDebugChar('+'); /* successful transfer */
379 /* if a sequence char is present, reply the ID */
380 if (buffer[2] == ':') {
381 putDebugChar(buffer[0]);
382 putDebugChar(buffer[1]);
383 /* remove sequence chars from buffer */
384 count = strlen(buffer);
385 for (i=3; i <= count; i++)
386 buffer[i-3] = buffer[i];
390 } while (checksum != xmitcsum);
393 /* send the packet in buffer. */
394 static void putpacket(unsigned char *buffer)
396 unsigned char checksum;
398 unsigned char ch, recv;
400 /* $<packet info>#<checksum>. */
406 while ((ch = buffer[count])) {
413 putDebugChar(hexchars[checksum >> 4]);
414 putDebugChar(hexchars[checksum & 0xf]);
415 recv = getDebugChar();
416 } while ((recv & 0x7f) != '+');
419 static void kgdb_flush_cache_all(void)
421 flush_instruction_cache();
424 /* Set up exception handlers for tracing and breakpoints
425 * [could be called kgdb_init()]
427 void set_debug_traps(void)
434 /* In case GDB is started before us, ack any packets (presumably
435 * "$?#xx") sitting there.
437 * I've found this code causes more problems than it solves,
438 * so that's why it's commented out. GDB seems to work fine
439 * now starting either before or after the kernel -bwb
442 while((c = getDebugChar()) != '$');
443 while((c = getDebugChar()) != '#');
444 c = getDebugChar(); /* eat first csum byte */
445 c = getDebugChar(); /* eat second csum byte */
446 putDebugChar('+'); /* ack it */
449 debugger_bpt = kgdb_bpt;
450 debugger_sstep = kgdb_sstep;
451 debugger_iabr_match = kgdb_iabr_match;
452 debugger_dabr_match = kgdb_dabr_match;
457 static void kgdb_fault_handler(struct pt_regs *regs)
459 kgdb_longjmp((long*)fault_jmp_buf, 1);
462 int kgdb_bpt(struct pt_regs *regs)
464 return handle_exception(regs);
467 int kgdb_sstep(struct pt_regs *regs)
469 return handle_exception(regs);
472 void kgdb(struct pt_regs *regs)
474 handle_exception(regs);
477 int kgdb_iabr_match(struct pt_regs *regs)
479 printk(KERN_ERR "kgdb doesn't support iabr, what?!?\n");
480 return handle_exception(regs);
483 int kgdb_dabr_match(struct pt_regs *regs)
485 printk(KERN_ERR "kgdb doesn't support dabr, what?!?\n");
486 return handle_exception(regs);
489 /* Convert the hardware trap type code to a unix signal number. */
491 * This table contains the mapping between PowerPC hardware trap types, and
492 * signals, which are primarily what GDB understands.
494 static struct hard_trap_info
496 unsigned int tt; /* Trap type code for powerpc */
497 unsigned char signo; /* Signal that we map this trap into */
498 } hard_trap_info[] = {
499 #if defined(CONFIG_40x)
500 { 0x100, SIGINT }, /* critical input interrupt */
501 { 0x200, SIGSEGV }, /* machine check */
502 { 0x300, SIGSEGV }, /* data storage */
503 { 0x400, SIGBUS }, /* instruction storage */
504 { 0x500, SIGINT }, /* interrupt */
505 { 0x600, SIGBUS }, /* alignment */
506 { 0x700, SIGILL }, /* program */
507 { 0x800, SIGILL }, /* reserved */
508 { 0x900, SIGILL }, /* reserved */
509 { 0xa00, SIGILL }, /* reserved */
510 { 0xb00, SIGILL }, /* reserved */
511 { 0xc00, SIGCHLD }, /* syscall */
512 { 0xd00, SIGILL }, /* reserved */
513 { 0xe00, SIGILL }, /* reserved */
514 { 0xf00, SIGILL }, /* reserved */
519 ** 0x1100 data TLB miss
520 ** 0x1200 instruction TLB miss
522 { 0x2000, SIGTRAP}, /* debug */
524 { 0x200, SIGSEGV }, /* machine check */
525 { 0x300, SIGSEGV }, /* address error (store) */
526 { 0x400, SIGBUS }, /* instruction bus error */
527 { 0x500, SIGINT }, /* interrupt */
528 { 0x600, SIGBUS }, /* alingment */
529 { 0x700, SIGTRAP }, /* breakpoint trap */
530 { 0x800, SIGFPE }, /* fpu unavail */
531 { 0x900, SIGALRM }, /* decrementer */
532 { 0xa00, SIGILL }, /* reserved */
533 { 0xb00, SIGILL }, /* reserved */
534 { 0xc00, SIGCHLD }, /* syscall */
535 { 0xd00, SIGTRAP }, /* single-step/watch */
536 { 0xe00, SIGFPE }, /* fp assist */
538 { 0, 0} /* Must be last */
542 static int computeSignal(unsigned int tt)
544 struct hard_trap_info *ht;
546 for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
550 return SIGHUP; /* default for things we don't know about */
557 * This function does all command processing for interfacing to gdb.
560 handle_exception (struct pt_regs *regs)
568 /* We don't handle user-mode breakpoints. */
572 if (debugger_fault_handler) {
573 debugger_fault_handler(regs);
574 panic("kgdb longjump failed!\n");
577 printk(KERN_ERR "interrupt while in kgdb, returning\n");
585 printk("kgdb: entering handle_exception; trap [0x%x]\n",
586 (unsigned int)regs->trap);
589 kgdb_interruptible(0);
592 mtmsr(msr & ~MSR_EE); /* disable interrupts */
594 if (regs->nip == (unsigned long)breakinst) {
595 /* Skip over breakpoint trap insn */
599 /* reply to host that an exception has occurred */
600 sigval = computeSignal(regs->trap);
601 ptr = remcomOutBuffer;
603 #if defined(CONFIG_40x)
605 *ptr++ = hexchars[sigval >> 4];
606 *ptr++ = hexchars[sigval & 0xf];
609 *ptr++ = hexchars[sigval >> 4];
610 *ptr++ = hexchars[sigval & 0xf];
611 *ptr++ = hexchars[PC_REGNUM >> 4];
612 *ptr++ = hexchars[PC_REGNUM & 0xf];
614 ptr = mem2hex((char *)®s->nip, ptr, 4);
616 *ptr++ = hexchars[SP_REGNUM >> 4];
617 *ptr++ = hexchars[SP_REGNUM & 0xf];
619 ptr = mem2hex(((char *)regs) + SP_REGNUM*4, ptr, 4);
625 putpacket(remcomOutBuffer);
627 printk("remcomOutBuffer: %s\n", remcomOutBuffer);
629 /* XXX We may want to add some features dealing with poking the
630 * XXX page tables, ... (look at sparc-stub.c for more info)
631 * XXX also required hacking to the gdb sources directly...
635 remcomOutBuffer[0] = 0;
637 getpacket(remcomInBuffer);
638 switch (remcomInBuffer[0]) {
639 case '?': /* report most recent signal */
640 remcomOutBuffer[0] = 'S';
641 remcomOutBuffer[1] = hexchars[sigval >> 4];
642 remcomOutBuffer[2] = hexchars[sigval & 0xf];
643 remcomOutBuffer[3] = 0;
646 case 'q': /* this screws up gdb for some reason...*/
648 extern long _start, sdata, __bss_start;
650 ptr = &remcomInBuffer[1];
651 if (strncmp(ptr, "Offsets", 7) != 0)
654 ptr = remcomOutBuffer;
655 sprintf(ptr, "Text=%8.8x;Data=%8.8x;Bss=%8.8x",
656 &_start, &sdata, &__bss_start);
661 /* toggle debug flag */
665 case 'g': /* return the value of the CPU registers.
666 * some of them are non-PowerPC names :(
667 * they are stored in gdb like:
671 * u32 pc, ps, cnd, lr; (ps=msr)
677 ptr = remcomOutBuffer;
678 /* General Purpose Regs */
679 ptr = mem2hex((char *)regs, ptr, 32 * 4);
680 /* Floating Point Regs - FIXME */
681 /*ptr = mem2hex((char *), ptr, 32 * 8);*/
682 for(i=0; i<(32*8*2); i++) { /* 2chars/byte */
686 /* pc, msr, cr, lr, ctr, xer, (mq is unused) */
687 ptr = mem2hex((char *)®s->nip, ptr, 4);
688 ptr = mem2hex((char *)®s->msr, ptr, 4);
689 ptr = mem2hex((char *)®s->ccr, ptr, 4);
690 ptr = mem2hex((char *)®s->link, ptr, 4);
691 ptr = mem2hex((char *)®s->ctr, ptr, 4);
692 ptr = mem2hex((char *)®s->xer, ptr, 4);
696 case 'G': /* set the value of the CPU registers */
698 ptr = &remcomInBuffer[1];
701 * If the stack pointer has moved, you should pray.
702 * (cause only god can help you).
705 /* General Purpose Regs */
706 hex2mem(ptr, (char *)regs, 32 * 4);
708 /* Floating Point Regs - FIXME?? */
709 /*ptr = hex2mem(ptr, ??, 32 * 8);*/
712 /* pc, msr, cr, lr, ctr, xer, (mq is unused) */
713 ptr = hex2mem(ptr, (char *)®s->nip, 4);
714 ptr = hex2mem(ptr, (char *)®s->msr, 4);
715 ptr = hex2mem(ptr, (char *)®s->ccr, 4);
716 ptr = hex2mem(ptr, (char *)®s->link, 4);
717 ptr = hex2mem(ptr, (char *)®s->ctr, 4);
718 ptr = hex2mem(ptr, (char *)®s->xer, 4);
720 strcpy(remcomOutBuffer,"OK");
724 /* don't do anything, yet, just acknowledge */
725 hexToInt(&ptr, &addr);
726 strcpy(remcomOutBuffer,"OK");
729 case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
730 /* Try to read %x,%x. */
732 ptr = &remcomInBuffer[1];
734 if (hexToInt(&ptr, &addr) && *ptr++ == ','
735 && hexToInt(&ptr, &length)) {
736 if (mem2hex((char *)addr, remcomOutBuffer,
739 strcpy(remcomOutBuffer, "E03");
741 strcpy(remcomOutBuffer, "E01");
744 case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
745 /* Try to read '%x,%x:'. */
747 ptr = &remcomInBuffer[1];
749 if (hexToInt(&ptr, &addr) && *ptr++ == ','
750 && hexToInt(&ptr, &length)
752 if (hex2mem(ptr, (char *)addr, length))
753 strcpy(remcomOutBuffer, "OK");
755 strcpy(remcomOutBuffer, "E03");
756 flush_icache_range(addr, addr+length);
758 strcpy(remcomOutBuffer, "E02");
762 case 'k': /* kill the program, actually just continue */
763 case 'c': /* cAA..AA Continue; address AA..AA optional */
764 /* try to read optional parameter, pc unchanged if no parm */
766 ptr = &remcomInBuffer[1];
767 if (hexToInt(&ptr, &addr))
770 /* Need to flush the instruction cache here, as we may have deposited a
771 * breakpoint, and the icache probably has no way of knowing that a data ref to
772 * some location may have changed something that is in the instruction cache.
774 kgdb_flush_cache_all();
775 #if defined(CONFIG_40x)
776 strcpy(remcomOutBuffer, "OK");
777 putpacket(remcomOutBuffer);
781 kgdb_interruptible(1);
785 printk("remcomInBuffer: %s\n", remcomInBuffer);
786 printk("remcomOutBuffer: %s\n", remcomOutBuffer);
791 kgdb_flush_cache_all();
792 #if defined(CONFIG_40x)
794 regs->dbcr0 |= (DBCR0_IDM | DBCR0_IC);
802 printk("remcomInBuffer: %s\n", remcomInBuffer);
803 printk("remcomOutBuffer: %s\n", remcomOutBuffer);
807 case 'r': /* Reset (if user process..exit ???)*/
808 panic("kgdb reset.");
811 if (remcomOutBuffer[0] && kdebug) {
812 printk("remcomInBuffer: %s\n", remcomInBuffer);
813 printk("remcomOutBuffer: %s\n", remcomOutBuffer);
815 /* reply to the request */
816 putpacket(remcomOutBuffer);
820 /* This function will generate a breakpoint exception. It is used at the
821 beginning of a program to sync up with a debugger and can be used
822 otherwise as a quick means to stop program execution and "break" into
829 printk("breakpoint() called b4 kgdb init\n");
833 asm(" .globl breakinst \n\
834 breakinst: .long 0x7d821008");
837 #ifdef CONFIG_KGDB_CONSOLE
838 /* Output string in GDB O-packet format if GDB has connected. If nothing
839 output, returns 0 (caller must then handle output). */
841 kgdb_output_string (const char* s, unsigned int count)
848 count = (count <= (sizeof(buffer) / 2 - 2))
849 ? count : (sizeof(buffer) / 2 - 2);
852 mem2hex (s, &buffer[1], count);