sh: Support for SH-2A 32-bit opcodes.
[linux-2.6/verdex.git] / arch / sh / kernel / kgdb_stub.c
blobffe3e3ee580d6bf85bff97a9bf21ecee850a2a14
1 /*
2 * May be copied or modified under the terms of the GNU General Public
3 * License. See linux/COPYING for more information.
5 * Containes extracts from code by Glenn Engel, Jim Kingdon,
6 * David Grothe <dave@gcom.com>, Tigran Aivazian <tigran@sco.com>,
7 * Amit S. Kale <akale@veritas.com>, William Gatliff <bgat@open-widgets.com>,
8 * Ben Lee, Steve Chamberlain and Benoit Miller <fulg@iname.com>.
10 * This version by Henry Bell <henry.bell@st.com>
11 * Minor modifications by Jeremy Siegel <jsiegel@mvista.com>
13 * Contains low-level support for remote debug using GDB.
15 * To enable debugger support, two things need to happen. A call to
16 * set_debug_traps() is necessary in order to allow any breakpoints
17 * or error conditions to be properly intercepted and reported to gdb.
18 * A breakpoint also needs to be generated to begin communication. This
19 * is most easily accomplished by a call to breakpoint() which does
20 * a trapa if the initialisation phase has been successfully completed.
22 * In this case, set_debug_traps() is not used to "take over" exceptions;
23 * other kernel code is modified instead to enter the kgdb functions here
24 * when appropriate (see entry.S for breakpoint traps and NMI interrupts,
25 * see traps.c for kernel error exceptions).
27 * The following gdb commands are supported:
29 * Command Function Return value
31 * g return the value of the CPU registers hex data or ENN
32 * G set the value of the CPU registers OK or ENN
34 * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
35 * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
36 * XAA..AA,LLLL: Same, but data is binary (not hex) OK or ENN
38 * c Resume at current address SNN ( signal NN)
39 * cAA..AA Continue at address AA..AA SNN
40 * CNN; Resume at current address with signal SNN
41 * CNN;AA..AA Resume at address AA..AA with signal SNN
43 * s Step one instruction SNN
44 * sAA..AA Step one instruction from AA..AA SNN
45 * SNN; Step one instruction with signal SNN
46 * SNNAA..AA Step one instruction from AA..AA w/NN SNN
48 * k kill (Detach GDB)
50 * d Toggle debug flag
51 * D Detach GDB
53 * Hct Set thread t for operations, OK or ENN
54 * c = 'c' (step, cont), c = 'g' (other
55 * operations)
57 * qC Query current thread ID QCpid
58 * qfThreadInfo Get list of current threads (first) m<id>
59 * qsThreadInfo " " " " " (subsequent)
60 * qOffsets Get section offsets Text=x;Data=y;Bss=z
62 * TXX Find if thread XX is alive OK or ENN
63 * ? What was the last sigval ? SNN (signal NN)
64 * O Output to GDB console
66 * Remote communication protocol.
68 * A debug packet whose contents are <data> is encapsulated for
69 * transmission in the form:
71 * $ <data> # CSUM1 CSUM2
73 * <data> must be ASCII alphanumeric and cannot include characters
74 * '$' or '#'. If <data> starts with two characters followed by
75 * ':', then the existing stubs interpret this as a sequence number.
77 * CSUM1 and CSUM2 are ascii hex representation of an 8-bit
78 * checksum of <data>, the most significant nibble is sent first.
79 * the hex digits 0-9,a-f are used.
81 * Receiver responds with:
83 * + - if CSUM is correct and ready for next packet
84 * - - if CSUM is incorrect
86 * Responses can be run-length encoded to save space. A '*' means that
87 * the next character is an ASCII encoding giving a repeat count which
88 * stands for that many repititions of the character preceding the '*'.
89 * The encoding is n+29, yielding a printable character where n >=3
90 * (which is where RLE starts to win). Don't use an n > 126.
92 * So "0* " means the same as "0000".
95 #include <linux/string.h>
96 #include <linux/kernel.h>
97 #include <linux/sched.h>
98 #include <linux/smp.h>
99 #include <linux/spinlock.h>
100 #include <linux/delay.h>
101 #include <linux/linkage.h>
102 #include <linux/init.h>
103 #include <linux/console.h>
104 #include <linux/sysrq.h>
105 #include <asm/system.h>
106 #include <asm/cacheflush.h>
107 #include <asm/current.h>
108 #include <asm/signal.h>
109 #include <asm/pgtable.h>
110 #include <asm/ptrace.h>
111 #include <asm/kgdb.h>
112 #include <asm/io.h>
114 /* Function pointers for linkage */
115 kgdb_debug_hook_t *kgdb_debug_hook;
116 kgdb_bus_error_hook_t *kgdb_bus_err_hook;
118 int (*kgdb_getchar)(void);
119 void (*kgdb_putchar)(int);
121 static void put_debug_char(int c)
123 if (!kgdb_putchar)
124 return;
125 (*kgdb_putchar)(c);
127 static int get_debug_char(void)
129 if (!kgdb_getchar)
130 return -1;
131 return (*kgdb_getchar)();
134 /* Num chars in in/out bound buffers, register packets need NUMREGBYTES * 2 */
135 #define BUFMAX 1024
136 #define NUMREGBYTES (MAXREG*4)
137 #define OUTBUFMAX (NUMREGBYTES*2+512)
139 enum regs {
140 R0 = 0, R1, R2, R3, R4, R5, R6, R7,
141 R8, R9, R10, R11, R12, R13, R14, R15,
142 PC, PR, GBR, VBR, MACH, MACL, SR,
143 /* */
144 MAXREG
147 static unsigned int registers[MAXREG];
148 struct kgdb_regs trap_registers;
150 char kgdb_in_gdb_mode;
151 char in_nmi; /* Set during NMI to prevent reentry */
152 int kgdb_nofault; /* Boolean to ignore bus errs (i.e. in GDB) */
153 int kgdb_enabled = 1; /* Default to enabled, cmdline can disable */
155 /* Exposed for user access */
156 struct task_struct *kgdb_current;
157 unsigned int kgdb_g_imask;
158 int kgdb_trapa_val;
159 int kgdb_excode;
161 /* Default values for SCI (can override via kernel args in setup.c) */
162 #ifndef CONFIG_KGDB_DEFPORT
163 #define CONFIG_KGDB_DEFPORT 1
164 #endif
166 #ifndef CONFIG_KGDB_DEFBAUD
167 #define CONFIG_KGDB_DEFBAUD 115200
168 #endif
170 #if defined(CONFIG_KGDB_DEFPARITY_E)
171 #define CONFIG_KGDB_DEFPARITY 'E'
172 #elif defined(CONFIG_KGDB_DEFPARITY_O)
173 #define CONFIG_KGDB_DEFPARITY 'O'
174 #else /* CONFIG_KGDB_DEFPARITY_N */
175 #define CONFIG_KGDB_DEFPARITY 'N'
176 #endif
178 #ifdef CONFIG_KGDB_DEFBITS_7
179 #define CONFIG_KGDB_DEFBITS '7'
180 #else /* CONFIG_KGDB_DEFBITS_8 */
181 #define CONFIG_KGDB_DEFBITS '8'
182 #endif
184 /* SCI/UART settings, used in kgdb_console_setup() */
185 int kgdb_portnum = CONFIG_KGDB_DEFPORT;
186 int kgdb_baud = CONFIG_KGDB_DEFBAUD;
187 char kgdb_parity = CONFIG_KGDB_DEFPARITY;
188 char kgdb_bits = CONFIG_KGDB_DEFBITS;
190 /* Jump buffer for setjmp/longjmp */
191 static jmp_buf rem_com_env;
193 /* TRA differs sh3/4 */
194 #if defined(CONFIG_CPU_SH3)
195 #define TRA 0xffffffd0
196 #elif defined(CONFIG_CPU_SH4)
197 #define TRA 0xff000020
198 #endif
200 /* Macros for single step instruction identification */
201 #define OPCODE_BT(op) (((op) & 0xff00) == 0x8900)
202 #define OPCODE_BF(op) (((op) & 0xff00) == 0x8b00)
203 #define OPCODE_BTF_DISP(op) (((op) & 0x80) ? (((op) | 0xffffff80) << 1) : \
204 (((op) & 0x7f ) << 1))
205 #define OPCODE_BFS(op) (((op) & 0xff00) == 0x8f00)
206 #define OPCODE_BTS(op) (((op) & 0xff00) == 0x8d00)
207 #define OPCODE_BRA(op) (((op) & 0xf000) == 0xa000)
208 #define OPCODE_BRA_DISP(op) (((op) & 0x800) ? (((op) | 0xfffff800) << 1) : \
209 (((op) & 0x7ff) << 1))
210 #define OPCODE_BRAF(op) (((op) & 0xf0ff) == 0x0023)
211 #define OPCODE_BRAF_REG(op) (((op) & 0x0f00) >> 8)
212 #define OPCODE_BSR(op) (((op) & 0xf000) == 0xb000)
213 #define OPCODE_BSR_DISP(op) (((op) & 0x800) ? (((op) | 0xfffff800) << 1) : \
214 (((op) & 0x7ff) << 1))
215 #define OPCODE_BSRF(op) (((op) & 0xf0ff) == 0x0003)
216 #define OPCODE_BSRF_REG(op) (((op) >> 8) & 0xf)
217 #define OPCODE_JMP(op) (((op) & 0xf0ff) == 0x402b)
218 #define OPCODE_JMP_REG(op) (((op) >> 8) & 0xf)
219 #define OPCODE_JSR(op) (((op) & 0xf0ff) == 0x400b)
220 #define OPCODE_JSR_REG(op) (((op) >> 8) & 0xf)
221 #define OPCODE_RTS(op) ((op) == 0xb)
222 #define OPCODE_RTE(op) ((op) == 0x2b)
224 #define SR_T_BIT_MASK 0x1
225 #define STEP_OPCODE 0xc320
226 #define BIOS_CALL_TRAP 0x3f
228 /* Exception codes as per SH-4 core manual */
229 #define ADDRESS_ERROR_LOAD_VEC 7
230 #define ADDRESS_ERROR_STORE_VEC 8
231 #define TRAP_VEC 11
232 #define INVALID_INSN_VEC 12
233 #define INVALID_SLOT_VEC 13
234 #define NMI_VEC 14
235 #define USER_BREAK_VEC 15
236 #define SERIAL_BREAK_VEC 58
238 /* Misc static */
239 static int stepped_address;
240 static short stepped_opcode;
241 static char in_buffer[BUFMAX];
242 static char out_buffer[OUTBUFMAX];
244 static void kgdb_to_gdb(const char *s);
246 /* Convert ch to hex */
247 static int hex(const char ch)
249 if ((ch >= 'a') && (ch <= 'f'))
250 return (ch - 'a' + 10);
251 if ((ch >= '0') && (ch <= '9'))
252 return (ch - '0');
253 if ((ch >= 'A') && (ch <= 'F'))
254 return (ch - 'A' + 10);
255 return (-1);
258 /* Convert the memory pointed to by mem into hex, placing result in buf.
259 Returns a pointer to the last char put in buf (null) */
260 static char *mem_to_hex(const char *mem, char *buf, const int count)
262 int i;
263 int ch;
264 unsigned short s_val;
265 unsigned long l_val;
267 /* Check for 16 or 32 */
268 if (count == 2 && ((long) mem & 1) == 0) {
269 s_val = *(unsigned short *) mem;
270 mem = (char *) &s_val;
271 } else if (count == 4 && ((long) mem & 3) == 0) {
272 l_val = *(unsigned long *) mem;
273 mem = (char *) &l_val;
275 for (i = 0; i < count; i++) {
276 ch = *mem++;
277 *buf++ = highhex(ch);
278 *buf++ = lowhex(ch);
280 *buf = 0;
281 return (buf);
284 /* Convert the hex array pointed to by buf into binary, to be placed in mem.
285 Return a pointer to the character after the last byte written */
286 static char *hex_to_mem(const char *buf, char *mem, const int count)
288 int i;
289 unsigned char ch;
291 for (i = 0; i < count; i++) {
292 ch = hex(*buf++) << 4;
293 ch = ch + hex(*buf++);
294 *mem++ = ch;
296 return (mem);
299 /* While finding valid hex chars, convert to an integer, then return it */
300 static int hex_to_int(char **ptr, int *int_value)
302 int num_chars = 0;
303 int hex_value;
305 *int_value = 0;
307 while (**ptr) {
308 hex_value = hex(**ptr);
309 if (hex_value >= 0) {
310 *int_value = (*int_value << 4) | hex_value;
311 num_chars++;
312 } else
313 break;
314 (*ptr)++;
316 return num_chars;
319 /* Copy the binary array pointed to by buf into mem. Fix $, #,
320 and 0x7d escaped with 0x7d. Return a pointer to the character
321 after the last byte written. */
322 static char *ebin_to_mem(const char *buf, char *mem, int count)
324 for (; count > 0; count--, buf++) {
325 if (*buf == 0x7d)
326 *mem++ = *(++buf) ^ 0x20;
327 else
328 *mem++ = *buf;
330 return mem;
333 /* Pack a hex byte */
334 static char *pack_hex_byte(char *pkt, int byte)
336 *pkt++ = hexchars[(byte >> 4) & 0xf];
337 *pkt++ = hexchars[(byte & 0xf)];
338 return pkt;
341 /* Scan for the start char '$', read the packet and check the checksum */
342 static void get_packet(char *buffer, int buflen)
344 unsigned char checksum;
345 unsigned char xmitcsum;
346 int i;
347 int count;
348 char ch;
350 do {
351 /* Ignore everything until the start character */
352 while ((ch = get_debug_char()) != '$');
354 checksum = 0;
355 xmitcsum = -1;
356 count = 0;
358 /* Now, read until a # or end of buffer is found */
359 while (count < (buflen - 1)) {
360 ch = get_debug_char();
362 if (ch == '#')
363 break;
365 checksum = checksum + ch;
366 buffer[count] = ch;
367 count = count + 1;
370 buffer[count] = 0;
372 /* Continue to read checksum following # */
373 if (ch == '#') {
374 xmitcsum = hex(get_debug_char()) << 4;
375 xmitcsum += hex(get_debug_char());
377 /* Checksum */
378 if (checksum != xmitcsum)
379 put_debug_char('-'); /* Failed checksum */
380 else {
381 /* Ack successful transfer */
382 put_debug_char('+');
384 /* If a sequence char is present, reply
385 the sequence ID */
386 if (buffer[2] == ':') {
387 put_debug_char(buffer[0]);
388 put_debug_char(buffer[1]);
390 /* Remove sequence chars from buffer */
391 count = strlen(buffer);
392 for (i = 3; i <= count; i++)
393 buffer[i - 3] = buffer[i];
398 while (checksum != xmitcsum); /* Keep trying while we fail */
401 /* Send the packet in the buffer with run-length encoding */
402 static void put_packet(char *buffer)
404 int checksum;
405 char *src;
406 int runlen;
407 int encode;
409 do {
410 src = buffer;
411 put_debug_char('$');
412 checksum = 0;
414 /* Continue while we still have chars left */
415 while (*src) {
416 /* Check for runs up to 99 chars long */
417 for (runlen = 1; runlen < 99; runlen++) {
418 if (src[0] != src[runlen])
419 break;
422 if (runlen > 3) {
423 /* Got a useful amount, send encoding */
424 encode = runlen + ' ' - 4;
425 put_debug_char(*src); checksum += *src;
426 put_debug_char('*'); checksum += '*';
427 put_debug_char(encode); checksum += encode;
428 src += runlen;
429 } else {
430 /* Otherwise just send the current char */
431 put_debug_char(*src); checksum += *src;
432 src += 1;
436 /* '#' Separator, put high and low components of checksum */
437 put_debug_char('#');
438 put_debug_char(highhex(checksum));
439 put_debug_char(lowhex(checksum));
441 while ((get_debug_char()) != '+'); /* While no ack */
444 /* A bus error has occurred - perform a longjmp to return execution and
445 allow handling of the error */
446 static void kgdb_handle_bus_error(void)
448 longjmp(rem_com_env, 1);
451 /* Translate SH-3/4 exception numbers to unix-like signal values */
452 static int compute_signal(const int excep_code)
454 int sigval;
456 switch (excep_code) {
458 case INVALID_INSN_VEC:
459 case INVALID_SLOT_VEC:
460 sigval = SIGILL;
461 break;
462 case ADDRESS_ERROR_LOAD_VEC:
463 case ADDRESS_ERROR_STORE_VEC:
464 sigval = SIGSEGV;
465 break;
467 case SERIAL_BREAK_VEC:
468 case NMI_VEC:
469 sigval = SIGINT;
470 break;
472 case USER_BREAK_VEC:
473 case TRAP_VEC:
474 sigval = SIGTRAP;
475 break;
477 default:
478 sigval = SIGBUS; /* "software generated" */
479 break;
482 return (sigval);
485 /* Make a local copy of the registers passed into the handler (bletch) */
486 static void kgdb_regs_to_gdb_regs(const struct kgdb_regs *regs,
487 int *gdb_regs)
489 gdb_regs[R0] = regs->regs[R0];
490 gdb_regs[R1] = regs->regs[R1];
491 gdb_regs[R2] = regs->regs[R2];
492 gdb_regs[R3] = regs->regs[R3];
493 gdb_regs[R4] = regs->regs[R4];
494 gdb_regs[R5] = regs->regs[R5];
495 gdb_regs[R6] = regs->regs[R6];
496 gdb_regs[R7] = regs->regs[R7];
497 gdb_regs[R8] = regs->regs[R8];
498 gdb_regs[R9] = regs->regs[R9];
499 gdb_regs[R10] = regs->regs[R10];
500 gdb_regs[R11] = regs->regs[R11];
501 gdb_regs[R12] = regs->regs[R12];
502 gdb_regs[R13] = regs->regs[R13];
503 gdb_regs[R14] = regs->regs[R14];
504 gdb_regs[R15] = regs->regs[R15];
505 gdb_regs[PC] = regs->pc;
506 gdb_regs[PR] = regs->pr;
507 gdb_regs[GBR] = regs->gbr;
508 gdb_regs[MACH] = regs->mach;
509 gdb_regs[MACL] = regs->macl;
510 gdb_regs[SR] = regs->sr;
511 gdb_regs[VBR] = regs->vbr;
514 /* Copy local gdb registers back to kgdb regs, for later copy to kernel */
515 static void gdb_regs_to_kgdb_regs(const int *gdb_regs,
516 struct kgdb_regs *regs)
518 regs->regs[R0] = gdb_regs[R0];
519 regs->regs[R1] = gdb_regs[R1];
520 regs->regs[R2] = gdb_regs[R2];
521 regs->regs[R3] = gdb_regs[R3];
522 regs->regs[R4] = gdb_regs[R4];
523 regs->regs[R5] = gdb_regs[R5];
524 regs->regs[R6] = gdb_regs[R6];
525 regs->regs[R7] = gdb_regs[R7];
526 regs->regs[R8] = gdb_regs[R8];
527 regs->regs[R9] = gdb_regs[R9];
528 regs->regs[R10] = gdb_regs[R10];
529 regs->regs[R11] = gdb_regs[R11];
530 regs->regs[R12] = gdb_regs[R12];
531 regs->regs[R13] = gdb_regs[R13];
532 regs->regs[R14] = gdb_regs[R14];
533 regs->regs[R15] = gdb_regs[R15];
534 regs->pc = gdb_regs[PC];
535 regs->pr = gdb_regs[PR];
536 regs->gbr = gdb_regs[GBR];
537 regs->mach = gdb_regs[MACH];
538 regs->macl = gdb_regs[MACL];
539 regs->sr = gdb_regs[SR];
540 regs->vbr = gdb_regs[VBR];
543 /* Calculate the new address for after a step */
544 static short *get_step_address(void)
546 short op = *(short *) trap_registers.pc;
547 long addr;
549 /* BT */
550 if (OPCODE_BT(op)) {
551 if (trap_registers.sr & SR_T_BIT_MASK)
552 addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
553 else
554 addr = trap_registers.pc + 2;
557 /* BTS */
558 else if (OPCODE_BTS(op)) {
559 if (trap_registers.sr & SR_T_BIT_MASK)
560 addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
561 else
562 addr = trap_registers.pc + 4; /* Not in delay slot */
565 /* BF */
566 else if (OPCODE_BF(op)) {
567 if (!(trap_registers.sr & SR_T_BIT_MASK))
568 addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
569 else
570 addr = trap_registers.pc + 2;
573 /* BFS */
574 else if (OPCODE_BFS(op)) {
575 if (!(trap_registers.sr & SR_T_BIT_MASK))
576 addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
577 else
578 addr = trap_registers.pc + 4; /* Not in delay slot */
581 /* BRA */
582 else if (OPCODE_BRA(op))
583 addr = trap_registers.pc + 4 + OPCODE_BRA_DISP(op);
585 /* BRAF */
586 else if (OPCODE_BRAF(op))
587 addr = trap_registers.pc + 4
588 + trap_registers.regs[OPCODE_BRAF_REG(op)];
590 /* BSR */
591 else if (OPCODE_BSR(op))
592 addr = trap_registers.pc + 4 + OPCODE_BSR_DISP(op);
594 /* BSRF */
595 else if (OPCODE_BSRF(op))
596 addr = trap_registers.pc + 4
597 + trap_registers.regs[OPCODE_BSRF_REG(op)];
599 /* JMP */
600 else if (OPCODE_JMP(op))
601 addr = trap_registers.regs[OPCODE_JMP_REG(op)];
603 /* JSR */
604 else if (OPCODE_JSR(op))
605 addr = trap_registers.regs[OPCODE_JSR_REG(op)];
607 /* RTS */
608 else if (OPCODE_RTS(op))
609 addr = trap_registers.pr;
611 /* RTE */
612 else if (OPCODE_RTE(op))
613 addr = trap_registers.regs[15];
615 /* Other */
616 else
617 addr = trap_registers.pc + 2;
619 kgdb_flush_icache_range(addr, addr + 2);
620 return (short *) addr;
623 /* Set up a single-step. Replace the instruction immediately after the
624 current instruction (i.e. next in the expected flow of control) with a
625 trap instruction, so that returning will cause only a single instruction
626 to be executed. Note that this model is slightly broken for instructions
627 with delay slots (e.g. B[TF]S, BSR, BRA etc), where both the branch
628 and the instruction in the delay slot will be executed. */
629 static void do_single_step(void)
631 unsigned short *addr = 0;
633 /* Determine where the target instruction will send us to */
634 addr = get_step_address();
635 stepped_address = (int)addr;
637 /* Replace it */
638 stepped_opcode = *(short *)addr;
639 *addr = STEP_OPCODE;
641 /* Flush and return */
642 kgdb_flush_icache_range((long) addr, (long) addr + 2);
643 return;
646 /* Undo a single step */
647 static void undo_single_step(void)
649 /* If we have stepped, put back the old instruction */
650 /* Use stepped_address in case we stopped elsewhere */
651 if (stepped_opcode != 0) {
652 *(short*)stepped_address = stepped_opcode;
653 kgdb_flush_icache_range(stepped_address, stepped_address + 2);
655 stepped_opcode = 0;
658 /* Send a signal message */
659 static void send_signal_msg(const int signum)
661 out_buffer[0] = 'S';
662 out_buffer[1] = highhex(signum);
663 out_buffer[2] = lowhex(signum);
664 out_buffer[3] = 0;
665 put_packet(out_buffer);
668 /* Reply that all was well */
669 static void send_ok_msg(void)
671 strcpy(out_buffer, "OK");
672 put_packet(out_buffer);
675 /* Reply that an error occurred */
676 static void send_err_msg(void)
678 strcpy(out_buffer, "E01");
679 put_packet(out_buffer);
682 /* Empty message indicates unrecognised command */
683 static void send_empty_msg(void)
685 put_packet("");
688 /* Read memory due to 'm' message */
689 static void read_mem_msg(void)
691 char *ptr;
692 int addr;
693 int length;
695 /* Jmp, disable bus error handler */
696 if (setjmp(rem_com_env) == 0) {
698 kgdb_nofault = 1;
700 /* Walk through, have m<addr>,<length> */
701 ptr = &in_buffer[1];
702 if (hex_to_int(&ptr, &addr) && (*ptr++ == ','))
703 if (hex_to_int(&ptr, &length)) {
704 ptr = 0;
705 if (length * 2 > OUTBUFMAX)
706 length = OUTBUFMAX / 2;
707 mem_to_hex((char *) addr, out_buffer, length);
709 if (ptr)
710 send_err_msg();
711 else
712 put_packet(out_buffer);
713 } else
714 send_err_msg();
716 /* Restore bus error handler */
717 kgdb_nofault = 0;
720 /* Write memory due to 'M' or 'X' message */
721 static void write_mem_msg(int binary)
723 char *ptr;
724 int addr;
725 int length;
727 if (setjmp(rem_com_env) == 0) {
729 kgdb_nofault = 1;
731 /* Walk through, have M<addr>,<length>:<data> */
732 ptr = &in_buffer[1];
733 if (hex_to_int(&ptr, &addr) && (*ptr++ == ','))
734 if (hex_to_int(&ptr, &length) && (*ptr++ == ':')) {
735 if (binary)
736 ebin_to_mem(ptr, (char*)addr, length);
737 else
738 hex_to_mem(ptr, (char*)addr, length);
739 kgdb_flush_icache_range(addr, addr + length);
740 ptr = 0;
741 send_ok_msg();
743 if (ptr)
744 send_err_msg();
745 } else
746 send_err_msg();
748 /* Restore bus error handler */
749 kgdb_nofault = 0;
752 /* Continue message */
753 static void continue_msg(void)
755 /* Try to read optional parameter, PC unchanged if none */
756 char *ptr = &in_buffer[1];
757 int addr;
759 if (hex_to_int(&ptr, &addr))
760 trap_registers.pc = addr;
763 /* Continue message with signal */
764 static void continue_with_sig_msg(void)
766 int signal;
767 char *ptr = &in_buffer[1];
768 int addr;
770 /* Report limitation */
771 kgdb_to_gdb("Cannot force signal in kgdb, continuing anyway.\n");
773 /* Signal */
774 hex_to_int(&ptr, &signal);
775 if (*ptr == ';')
776 ptr++;
778 /* Optional address */
779 if (hex_to_int(&ptr, &addr))
780 trap_registers.pc = addr;
783 /* Step message */
784 static void step_msg(void)
786 continue_msg();
787 do_single_step();
790 /* Step message with signal */
791 static void step_with_sig_msg(void)
793 continue_with_sig_msg();
794 do_single_step();
797 /* Send register contents */
798 static void send_regs_msg(void)
800 kgdb_regs_to_gdb_regs(&trap_registers, registers);
801 mem_to_hex((char *) registers, out_buffer, NUMREGBYTES);
802 put_packet(out_buffer);
805 /* Set register contents - currently can't set other thread's registers */
806 static void set_regs_msg(void)
808 kgdb_regs_to_gdb_regs(&trap_registers, registers);
809 hex_to_mem(&in_buffer[1], (char *) registers, NUMREGBYTES);
810 gdb_regs_to_kgdb_regs(registers, &trap_registers);
811 send_ok_msg();
814 #ifdef CONFIG_SH_KGDB_CONSOLE
816 * Bring up the ports..
818 static int kgdb_serial_setup(void)
820 extern int kgdb_console_setup(struct console *co, char *options);
821 struct console dummy;
823 kgdb_console_setup(&dummy, 0);
825 return 0;
827 #else
828 #define kgdb_serial_setup() 0
829 #endif
831 /* The command loop, read and act on requests */
832 static void kgdb_command_loop(const int excep_code, const int trapa_value)
834 int sigval;
836 if (excep_code == NMI_VEC) {
837 #ifndef CONFIG_KGDB_NMI
838 printk(KERN_NOTICE "KGDB: Ignoring unexpected NMI?\n");
839 return;
840 #else /* CONFIG_KGDB_NMI */
841 if (!kgdb_enabled) {
842 kgdb_enabled = 1;
843 kgdb_init();
845 #endif /* CONFIG_KGDB_NMI */
848 /* Ignore if we're disabled */
849 if (!kgdb_enabled)
850 return;
852 /* Enter GDB mode (e.g. after detach) */
853 if (!kgdb_in_gdb_mode) {
854 /* Do serial setup, notify user, issue preemptive ack */
855 printk(KERN_NOTICE "KGDB: Waiting for GDB\n");
856 kgdb_in_gdb_mode = 1;
857 put_debug_char('+');
860 /* Reply to host that an exception has occurred */
861 sigval = compute_signal(excep_code);
862 send_signal_msg(sigval);
864 /* TRAP_VEC exception indicates a software trap inserted in place of
865 code by GDB so back up PC by one instruction, as this instruction
866 will later be replaced by its original one. Do NOT do this for
867 trap 0xff, since that indicates a compiled-in breakpoint which
868 will not be replaced (and we would retake the trap forever) */
869 if ((excep_code == TRAP_VEC) && (trapa_value != (0x3c << 2)))
870 trap_registers.pc -= instruction_size(trap_registers.pc);
872 /* Undo any stepping we may have done */
873 undo_single_step();
875 while (1) {
876 out_buffer[0] = 0;
877 get_packet(in_buffer, BUFMAX);
879 /* Examine first char of buffer to see what we need to do */
880 switch (in_buffer[0]) {
881 case '?': /* Send which signal we've received */
882 send_signal_msg(sigval);
883 break;
885 case 'g': /* Return the values of the CPU registers */
886 send_regs_msg();
887 break;
889 case 'G': /* Set the value of the CPU registers */
890 set_regs_msg();
891 break;
893 case 'm': /* Read LLLL bytes address AA..AA */
894 read_mem_msg();
895 break;
897 case 'M': /* Write LLLL bytes address AA..AA, ret OK */
898 write_mem_msg(0); /* 0 = data in hex */
899 break;
901 case 'X': /* Write LLLL bytes esc bin address AA..AA */
902 if (kgdb_bits == '8')
903 write_mem_msg(1); /* 1 = data in binary */
904 else
905 send_empty_msg();
906 break;
908 case 'C': /* Continue, signum included, we ignore it */
909 continue_with_sig_msg();
910 return;
912 case 'c': /* Continue at address AA..AA (optional) */
913 continue_msg();
914 return;
916 case 'S': /* Step, signum included, we ignore it */
917 step_with_sig_msg();
918 return;
920 case 's': /* Step one instruction from AA..AA */
921 step_msg();
922 return;
924 case 'k': /* 'Kill the program' with a kernel ? */
925 break;
927 case 'D': /* Detach from program, send reply OK */
928 kgdb_in_gdb_mode = 0;
929 send_ok_msg();
930 get_debug_char();
931 return;
933 default:
934 send_empty_msg();
935 break;
940 /* There has been an exception, most likely a breakpoint. */
941 static void handle_exception(struct pt_regs *regs)
943 int excep_code, vbr_val;
944 int count;
945 int trapa_value = ctrl_inl(TRA);
947 /* Copy kernel regs (from stack) */
948 for (count = 0; count < 16; count++)
949 trap_registers.regs[count] = regs->regs[count];
950 trap_registers.pc = regs->pc;
951 trap_registers.pr = regs->pr;
952 trap_registers.sr = regs->sr;
953 trap_registers.gbr = regs->gbr;
954 trap_registers.mach = regs->mach;
955 trap_registers.macl = regs->macl;
957 asm("stc vbr, %0":"=r"(vbr_val));
958 trap_registers.vbr = vbr_val;
960 /* Get excode for command loop call, user access */
961 asm("stc r2_bank, %0":"=r"(excep_code));
962 kgdb_excode = excep_code;
964 /* Other interesting environment items for reference */
965 asm("stc r6_bank, %0":"=r"(kgdb_g_imask));
966 kgdb_current = current;
967 kgdb_trapa_val = trapa_value;
969 /* Act on the exception */
970 kgdb_command_loop(excep_code, trapa_value);
972 kgdb_current = NULL;
974 /* Copy back the (maybe modified) registers */
975 for (count = 0; count < 16; count++)
976 regs->regs[count] = trap_registers.regs[count];
977 regs->pc = trap_registers.pc;
978 regs->pr = trap_registers.pr;
979 regs->sr = trap_registers.sr;
980 regs->gbr = trap_registers.gbr;
981 regs->mach = trap_registers.mach;
982 regs->macl = trap_registers.macl;
984 vbr_val = trap_registers.vbr;
985 asm("ldc %0, vbr": :"r"(vbr_val));
988 asmlinkage void kgdb_handle_exception(unsigned long r4, unsigned long r5,
989 unsigned long r6, unsigned long r7,
990 struct pt_regs __regs)
992 struct pt_regs *regs = RELOC_HIDE(&__regs, 0);
993 handle_exception(regs);
996 /* Initialise the KGDB data structures and serial configuration */
997 int kgdb_init(void)
999 if (!kgdb_enabled)
1000 return 1;
1002 in_nmi = 0;
1003 kgdb_nofault = 0;
1004 stepped_opcode = 0;
1005 kgdb_in_gdb_mode = 0;
1007 if (kgdb_serial_setup() != 0) {
1008 printk(KERN_NOTICE "KGDB: serial setup error\n");
1009 return -1;
1012 /* Init ptr to exception handler */
1013 kgdb_debug_hook = handle_exception;
1014 kgdb_bus_err_hook = kgdb_handle_bus_error;
1016 /* Enter kgdb now if requested, or just report init done */
1017 printk(KERN_NOTICE "KGDB: stub is initialized.\n");
1019 return 0;
1022 /* Make function available for "user messages"; console will use it too. */
1024 char gdbmsgbuf[BUFMAX];
1025 #define MAXOUT ((BUFMAX-2)/2)
1027 static void kgdb_msg_write(const char *s, unsigned count)
1029 int i;
1030 int wcount;
1031 char *bufptr;
1033 /* 'O'utput */
1034 gdbmsgbuf[0] = 'O';
1036 /* Fill and send buffers... */
1037 while (count > 0) {
1038 bufptr = gdbmsgbuf + 1;
1040 /* Calculate how many this time */
1041 wcount = (count > MAXOUT) ? MAXOUT : count;
1043 /* Pack in hex chars */
1044 for (i = 0; i < wcount; i++)
1045 bufptr = pack_hex_byte(bufptr, s[i]);
1046 *bufptr = '\0';
1048 /* Move up */
1049 s += wcount;
1050 count -= wcount;
1052 /* Write packet */
1053 put_packet(gdbmsgbuf);
1057 static void kgdb_to_gdb(const char *s)
1059 kgdb_msg_write(s, strlen(s));
1062 #ifdef CONFIG_SH_KGDB_CONSOLE
1063 void kgdb_console_write(struct console *co, const char *s, unsigned count)
1065 /* Bail if we're not talking to GDB */
1066 if (!kgdb_in_gdb_mode)
1067 return;
1069 kgdb_msg_write(s, count);
1071 #endif
1073 #ifdef CONFIG_KGDB_SYSRQ
1074 static void sysrq_handle_gdb(int key, struct tty_struct *tty)
1076 printk("Entering GDB stub\n");
1077 breakpoint();
1080 static struct sysrq_key_op sysrq_gdb_op = {
1081 .handler = sysrq_handle_gdb,
1082 .help_msg = "Gdb",
1083 .action_msg = "GDB",
1086 static int gdb_register_sysrq(void)
1088 printk("Registering GDB sysrq handler\n");
1089 register_sysrq_key('g', &sysrq_gdb_op);
1090 return 0;
1092 module_init(gdb_register_sysrq);
1093 #endif