]>
Commit | Line | Data |
---|---|---|
4a9cbbe8 WD |
1 | /* taken from arch/ppc/kernel/ppc-stub.c */ |
2 | ||
3 | /**************************************************************************** | |
4 | ||
5 | THIS SOFTWARE IS NOT COPYRIGHTED | |
6 | ||
7 | HP offers the following for use in the public domain. HP makes no | |
8 | warranty with regard to the software or its performance and the | |
9 | user accepts the software "AS IS" with all faults. | |
10 | ||
11 | HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD | |
12 | TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES | |
13 | OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. | |
14 | ||
15 | ****************************************************************************/ | |
16 | ||
17 | /**************************************************************************** | |
18 | * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $ | |
19 | * | |
20 | * Module name: remcom.c $ | |
21 | * Revision: 1.34 $ | |
22 | * Date: 91/03/09 12:29:49 $ | |
23 | * Contributor: Lake Stevens Instrument Division$ | |
24 | * | |
25 | * Description: low level support for gdb debugger. $ | |
26 | * | |
27 | * Considerations: only works on target hardware $ | |
28 | * | |
29 | * Written by: Glenn Engel $ | |
30 | * ModuleState: Experimental $ | |
31 | * | |
32 | * NOTES: See Below $ | |
33 | * | |
34 | * Modified for SPARC by Stu Grossman, Cygnus Support. | |
35 | * | |
36 | * This code has been extensively tested on the Fujitsu SPARClite demo board. | |
37 | * | |
38 | * To enable debugger support, two things need to happen. One, a | |
39 | * call to set_debug_traps() is necessary in order to allow any breakpoints | |
40 | * or error conditions to be properly intercepted and reported to gdb. | |
41 | * Two, a breakpoint needs to be generated to begin communication. This | |
42 | * is most easily accomplished by a call to breakpoint(). Breakpoint() | |
43 | * simulates a breakpoint by executing a trap #1. | |
44 | * | |
45 | ************* | |
46 | * | |
47 | * The following gdb commands are supported: | |
48 | * | |
49 | * command function Return value | |
50 | * | |
51 | * g return the value of the CPU registers hex data or ENN | |
52 | * G set the value of the CPU registers OK or ENN | |
53 | * qOffsets Get section offsets. Reply is Text=xxx;Data=yyy;Bss=zzz | |
54 | * | |
55 | * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN | |
56 | * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN | |
57 | * | |
58 | * c Resume at current address SNN ( signal NN) | |
59 | * cAA..AA Continue at address AA..AA SNN | |
60 | * | |
61 | * s Step one instruction SNN | |
62 | * sAA..AA Step one instruction from AA..AA SNN | |
63 | * | |
64 | * k kill | |
65 | * | |
66 | * ? What was the last sigval ? SNN (signal NN) | |
67 | * | |
68 | * bBB..BB Set baud rate to BB..BB OK or BNN, then sets | |
69 | * baud rate | |
70 | * | |
71 | * All commands and responses are sent with a packet which includes a | |
72 | * checksum. A packet consists of | |
73 | * | |
74 | * $<packet info>#<checksum>. | |
75 | * | |
76 | * where | |
77 | * <packet info> :: <characters representing the command or response> | |
78 | * <checksum> :: <two hex digits computed as modulo 256 sum of <packetinfo>> | |
79 | * | |
80 | * When a packet is received, it is first acknowledged with either '+' or '-'. | |
81 | * '+' indicates a successful transfer. '-' indicates a failed transfer. | |
82 | * | |
83 | * Example: | |
84 | * | |
85 | * Host: Reply: | |
86 | * $m0,10#2a +$00010203040506070809101112131415#42 | |
87 | * | |
88 | ****************************************************************************/ | |
89 | ||
90 | #include <common.h> | |
91 | ||
92 | #include <kgdb.h> | |
93 | #include <command.h> | |
94 | ||
4a9cbbe8 WD |
95 | #undef KGDB_DEBUG |
96 | ||
97 | /* | |
98 | * BUFMAX defines the maximum number of characters in inbound/outbound buffers | |
99 | */ | |
100 | #define BUFMAX 1024 | |
101 | static char remcomInBuffer[BUFMAX]; | |
102 | static char remcomOutBuffer[BUFMAX]; | |
103 | static char remcomRegBuffer[BUFMAX]; | |
104 | ||
105 | static int initialized = 0; | |
106 | static int kgdb_active = 0, first_entry = 1; | |
107 | static struct pt_regs entry_regs; | |
cc3843e3 | 108 | static long error_jmp_buf[BUFMAX/2]; |
4a9cbbe8 WD |
109 | static int longjmp_on_fault = 0; |
110 | #ifdef KGDB_DEBUG | |
111 | static int kdebug = 1; | |
112 | #endif | |
113 | ||
114 | static const char hexchars[]="0123456789abcdef"; | |
115 | ||
116 | /* Convert ch from a hex digit to an int */ | |
117 | static int | |
118 | hex(unsigned char ch) | |
119 | { | |
120 | if (ch >= 'a' && ch <= 'f') | |
121 | return ch-'a'+10; | |
122 | if (ch >= '0' && ch <= '9') | |
123 | return ch-'0'; | |
124 | if (ch >= 'A' && ch <= 'F') | |
125 | return ch-'A'+10; | |
126 | return -1; | |
127 | } | |
128 | ||
129 | /* Convert the memory pointed to by mem into hex, placing result in buf. | |
130 | * Return a pointer to the last char put in buf (null). | |
131 | */ | |
132 | static unsigned char * | |
133 | mem2hex(char *mem, char *buf, int count) | |
134 | { | |
135 | unsigned char ch; | |
136 | ||
137 | longjmp_on_fault = 1; | |
138 | while (count-- > 0) { | |
139 | ch = *mem++; | |
140 | *buf++ = hexchars[ch >> 4]; | |
141 | *buf++ = hexchars[ch & 0xf]; | |
142 | } | |
143 | *buf = 0; | |
144 | longjmp_on_fault = 0; | |
77ddac94 | 145 | return (unsigned char *)buf; |
4a9cbbe8 WD |
146 | } |
147 | ||
148 | /* convert the hex array pointed to by buf into binary to be placed in mem | |
149 | * return a pointer to the character AFTER the last byte fetched from buf. | |
150 | */ | |
151 | static char * | |
152 | hex2mem(char *buf, char *mem, int count) | |
153 | { | |
154 | int i, hexValue; | |
155 | unsigned char ch; | |
156 | char *mem_start = mem; | |
157 | ||
158 | longjmp_on_fault = 1; | |
159 | for (i=0; i<count; i++) { | |
160 | if ((hexValue = hex(*buf++)) < 0) | |
161 | kgdb_error(KGDBERR_NOTHEXDIG); | |
162 | ch = hexValue << 4; | |
163 | if ((hexValue = hex(*buf++)) < 0) | |
164 | kgdb_error(KGDBERR_NOTHEXDIG); | |
165 | ch |= hexValue; | |
166 | *mem++ = ch; | |
167 | } | |
168 | kgdb_flush_cache_range((void *)mem_start, (void *)(mem - 1)); | |
169 | longjmp_on_fault = 0; | |
170 | ||
171 | return buf; | |
172 | } | |
173 | ||
174 | /* | |
175 | * While we find nice hex chars, build an int. | |
176 | * Return number of chars processed. | |
177 | */ | |
178 | static int | |
179 | hexToInt(char **ptr, int *intValue) | |
180 | { | |
181 | int numChars = 0; | |
182 | int hexValue; | |
183 | ||
184 | *intValue = 0; | |
185 | ||
186 | longjmp_on_fault = 1; | |
187 | while (**ptr) { | |
188 | hexValue = hex(**ptr); | |
189 | if (hexValue < 0) | |
190 | break; | |
191 | ||
192 | *intValue = (*intValue << 4) | hexValue; | |
193 | numChars ++; | |
194 | ||
195 | (*ptr)++; | |
196 | } | |
197 | longjmp_on_fault = 0; | |
198 | ||
199 | return (numChars); | |
200 | } | |
201 | ||
202 | /* scan for the sequence $<data>#<checksum> */ | |
203 | static void | |
204 | getpacket(char *buffer) | |
205 | { | |
206 | unsigned char checksum; | |
207 | unsigned char xmitcsum; | |
208 | int i; | |
209 | int count; | |
210 | unsigned char ch; | |
211 | ||
212 | do { | |
213 | /* wait around for the start character, ignore all other | |
214 | * characters */ | |
215 | while ((ch = (getDebugChar() & 0x7f)) != '$') { | |
216 | #ifdef KGDB_DEBUG | |
217 | if (kdebug) | |
218 | putc(ch); | |
219 | #endif | |
220 | ; | |
221 | } | |
222 | ||
223 | checksum = 0; | |
224 | xmitcsum = -1; | |
225 | ||
226 | count = 0; | |
227 | ||
228 | /* now, read until a # or end of buffer is found */ | |
229 | while (count < BUFMAX) { | |
230 | ch = getDebugChar() & 0x7f; | |
231 | if (ch == '#') | |
232 | break; | |
233 | checksum = checksum + ch; | |
234 | buffer[count] = ch; | |
235 | count = count + 1; | |
236 | } | |
237 | ||
238 | if (count >= BUFMAX) | |
239 | continue; | |
240 | ||
241 | buffer[count] = 0; | |
242 | ||
243 | if (ch == '#') { | |
244 | xmitcsum = hex(getDebugChar() & 0x7f) << 4; | |
245 | xmitcsum |= hex(getDebugChar() & 0x7f); | |
246 | if (checksum != xmitcsum) | |
247 | putDebugChar('-'); /* failed checksum */ | |
248 | else { | |
249 | putDebugChar('+'); /* successful transfer */ | |
250 | /* if a sequence char is present, reply the ID */ | |
251 | if (buffer[2] == ':') { | |
252 | putDebugChar(buffer[0]); | |
253 | putDebugChar(buffer[1]); | |
254 | /* remove sequence chars from buffer */ | |
255 | count = strlen(buffer); | |
256 | for (i=3; i <= count; i++) | |
257 | buffer[i-3] = buffer[i]; | |
258 | } | |
259 | } | |
260 | } | |
261 | } while (checksum != xmitcsum); | |
262 | } | |
263 | ||
264 | /* send the packet in buffer. */ | |
265 | static void | |
266 | putpacket(unsigned char *buffer) | |
267 | { | |
268 | unsigned char checksum; | |
269 | int count; | |
270 | unsigned char ch, recv; | |
271 | ||
272 | /* $<packet info>#<checksum>. */ | |
273 | do { | |
274 | putDebugChar('$'); | |
275 | checksum = 0; | |
276 | count = 0; | |
277 | ||
278 | while ((ch = buffer[count])) { | |
279 | putDebugChar(ch); | |
280 | checksum += ch; | |
281 | count += 1; | |
282 | } | |
283 | ||
284 | putDebugChar('#'); | |
285 | putDebugChar(hexchars[checksum >> 4]); | |
286 | putDebugChar(hexchars[checksum & 0xf]); | |
287 | recv = getDebugChar(); | |
288 | } while ((recv & 0x7f) != '+'); | |
289 | } | |
290 | ||
291 | /* | |
292 | * This function does all command processing for interfacing to gdb. | |
293 | */ | |
294 | static int | |
295 | handle_exception (struct pt_regs *regs) | |
296 | { | |
297 | int addr; | |
298 | int length; | |
299 | char *ptr; | |
300 | kgdb_data kd; | |
301 | int i; | |
302 | ||
303 | if (!initialized) { | |
304 | printf("kgdb: exception before kgdb is initialized! huh?\n"); | |
305 | return (0); | |
306 | } | |
307 | ||
308 | /* probably should check which exception occured as well */ | |
309 | if (longjmp_on_fault) { | |
310 | longjmp_on_fault = 0; | |
cc3843e3 | 311 | kgdb_longjmp(error_jmp_buf, KGDBERR_MEMFAULT); |
4a9cbbe8 WD |
312 | panic("kgdb longjump failed!\n"); |
313 | } | |
314 | ||
315 | if (kgdb_active) { | |
316 | printf("kgdb: unexpected exception from within kgdb\n"); | |
317 | return (0); | |
318 | } | |
319 | kgdb_active = 1; | |
320 | ||
321 | kgdb_interruptible(0); | |
322 | ||
323 | printf("kgdb: handle_exception; trap [0x%x]\n", kgdb_trap(regs)); | |
324 | ||
cc3843e3 | 325 | if (kgdb_setjmp(error_jmp_buf) != 0) |
4a9cbbe8 WD |
326 | panic("kgdb: error or fault in entry init!\n"); |
327 | ||
328 | kgdb_enter(regs, &kd); | |
329 | ||
330 | if (first_entry) { | |
331 | /* | |
332 | * the first time we enter kgdb, we save the processor | |
333 | * state so that we can return to the monitor if the | |
334 | * remote end quits gdb (or at least, tells us to quit | |
335 | * with the 'k' packet) | |
336 | */ | |
337 | entry_regs = *regs; | |
338 | first_entry = 0; | |
339 | } | |
340 | ||
341 | ptr = remcomOutBuffer; | |
342 | ||
343 | *ptr++ = 'T'; | |
344 | ||
345 | *ptr++ = hexchars[kd.sigval >> 4]; | |
346 | *ptr++ = hexchars[kd.sigval & 0xf]; | |
347 | ||
348 | for (i = 0; i < kd.nregs; i++) { | |
349 | kgdb_reg *rp = &kd.regs[i]; | |
350 | ||
351 | *ptr++ = hexchars[rp->num >> 4]; | |
352 | *ptr++ = hexchars[rp->num & 0xf]; | |
353 | *ptr++ = ':'; | |
77ddac94 | 354 | ptr = (char *)mem2hex((char *)&rp->val, ptr, 4); |
4a9cbbe8 WD |
355 | *ptr++ = ';'; |
356 | } | |
357 | ||
358 | *ptr = 0; | |
359 | ||
360 | #ifdef KGDB_DEBUG | |
361 | if (kdebug) | |
362 | printf("kgdb: remcomOutBuffer: %s\n", remcomOutBuffer); | |
363 | #endif | |
364 | ||
77ddac94 | 365 | putpacket((unsigned char *)&remcomOutBuffer); |
4a9cbbe8 WD |
366 | |
367 | while (1) { | |
368 | volatile int errnum; | |
369 | ||
370 | remcomOutBuffer[0] = 0; | |
371 | ||
372 | getpacket(remcomInBuffer); | |
373 | ptr = &remcomInBuffer[1]; | |
374 | ||
375 | #ifdef KGDB_DEBUG | |
376 | if (kdebug) | |
377 | printf("kgdb: remcomInBuffer: %s\n", remcomInBuffer); | |
378 | #endif | |
379 | ||
cc3843e3 | 380 | errnum = kgdb_setjmp(error_jmp_buf); |
4a9cbbe8 WD |
381 | |
382 | if (errnum == 0) switch (remcomInBuffer[0]) { | |
383 | ||
384 | case '?': /* report most recent signal */ | |
385 | remcomOutBuffer[0] = 'S'; | |
386 | remcomOutBuffer[1] = hexchars[kd.sigval >> 4]; | |
387 | remcomOutBuffer[2] = hexchars[kd.sigval & 0xf]; | |
388 | remcomOutBuffer[3] = 0; | |
389 | break; | |
390 | ||
391 | #ifdef KGDB_DEBUG | |
392 | case 'd': | |
393 | /* toggle debug flag */ | |
394 | kdebug ^= 1; | |
395 | break; | |
396 | #endif | |
397 | ||
398 | case 'g': /* return the value of the CPU registers. */ | |
399 | length = kgdb_getregs(regs, remcomRegBuffer, BUFMAX); | |
400 | mem2hex(remcomRegBuffer, remcomOutBuffer, length); | |
401 | break; | |
402 | ||
403 | case 'G': /* set the value of the CPU registers */ | |
404 | length = strlen(ptr); | |
405 | if ((length & 1) != 0) kgdb_error(KGDBERR_BADPARAMS); | |
406 | hex2mem(ptr, remcomRegBuffer, length/2); | |
407 | kgdb_putregs(regs, remcomRegBuffer, length/2); | |
408 | strcpy(remcomOutBuffer,"OK"); | |
409 | break; | |
410 | ||
411 | case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */ | |
412 | /* Try to read %x,%x. */ | |
413 | ||
414 | if (hexToInt(&ptr, &addr) | |
415 | && *ptr++ == ',' | |
416 | && hexToInt(&ptr, &length)) { | |
417 | mem2hex((char *)addr, remcomOutBuffer, length); | |
418 | } else { | |
419 | kgdb_error(KGDBERR_BADPARAMS); | |
420 | } | |
421 | break; | |
422 | ||
423 | case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */ | |
424 | /* Try to read '%x,%x:'. */ | |
425 | ||
426 | if (hexToInt(&ptr, &addr) | |
427 | && *ptr++ == ',' | |
428 | && hexToInt(&ptr, &length) | |
429 | && *ptr++ == ':') { | |
430 | hex2mem(ptr, (char *)addr, length); | |
431 | strcpy(remcomOutBuffer, "OK"); | |
432 | } else { | |
433 | kgdb_error(KGDBERR_BADPARAMS); | |
434 | } | |
435 | break; | |
436 | ||
437 | ||
438 | case 'k': /* kill the program, actually return to monitor */ | |
439 | kd.extype = KGDBEXIT_KILL; | |
440 | *regs = entry_regs; | |
441 | first_entry = 1; | |
442 | goto doexit; | |
443 | ||
444 | case 'C': /* CSS continue with signal SS */ | |
445 | *ptr = '\0'; /* ignore the signal number for now */ | |
446 | /* fall through */ | |
447 | ||
448 | case 'c': /* cAA..AA Continue; address AA..AA optional */ | |
449 | /* try to read optional parameter, pc unchanged if no parm */ | |
450 | kd.extype = KGDBEXIT_CONTINUE; | |
451 | ||
452 | if (hexToInt(&ptr, &addr)) { | |
453 | kd.exaddr = addr; | |
454 | kd.extype |= KGDBEXIT_WITHADDR; | |
455 | } | |
456 | ||
457 | goto doexit; | |
458 | ||
459 | case 'S': /* SSS single step with signal SS */ | |
460 | *ptr = '\0'; /* ignore the signal number for now */ | |
461 | /* fall through */ | |
462 | ||
463 | case 's': | |
464 | kd.extype = KGDBEXIT_SINGLE; | |
465 | ||
466 | if (hexToInt(&ptr, &addr)) { | |
467 | kd.exaddr = addr; | |
468 | kd.extype |= KGDBEXIT_WITHADDR; | |
469 | } | |
470 | ||
471 | doexit: | |
472 | /* Need to flush the instruction cache here, as we may have deposited a | |
473 | * breakpoint, and the icache probably has no way of knowing that a data ref to | |
474 | * some location may have changed something that is in the instruction cache. | |
475 | */ | |
476 | kgdb_flush_cache_all(); | |
477 | kgdb_exit(regs, &kd); | |
478 | kgdb_active = 0; | |
479 | kgdb_interruptible(1); | |
480 | return (1); | |
481 | ||
482 | case 'r': /* Reset (if user process..exit ???)*/ | |
483 | panic("kgdb reset."); | |
484 | break; | |
485 | ||
486 | case 'P': /* Pr=v set reg r to value v (r and v are hex) */ | |
487 | if (hexToInt(&ptr, &addr) | |
488 | && *ptr++ == '=' | |
489 | && ((length = strlen(ptr)) & 1) == 0) { | |
490 | hex2mem(ptr, remcomRegBuffer, length/2); | |
491 | kgdb_putreg(regs, addr, | |
492 | remcomRegBuffer, length/2); | |
493 | strcpy(remcomOutBuffer,"OK"); | |
494 | } else { | |
495 | kgdb_error(KGDBERR_BADPARAMS); | |
496 | } | |
497 | break; | |
498 | } /* switch */ | |
499 | ||
500 | if (errnum != 0) | |
501 | sprintf(remcomOutBuffer, "E%02d", errnum); | |
502 | ||
503 | #ifdef KGDB_DEBUG | |
504 | if (kdebug) | |
505 | printf("kgdb: remcomOutBuffer: %s\n", remcomOutBuffer); | |
506 | #endif | |
507 | ||
508 | /* reply to the request */ | |
77ddac94 | 509 | putpacket((unsigned char *)&remcomOutBuffer); |
4a9cbbe8 WD |
510 | |
511 | } /* while(1) */ | |
512 | } | |
513 | ||
514 | /* | |
515 | * kgdb_init must be called *after* the | |
516 | * monitor is relocated into ram | |
517 | */ | |
518 | void | |
519 | kgdb_init(void) | |
520 | { | |
521 | kgdb_serial_init(); | |
522 | debugger_exception_handler = handle_exception; | |
523 | initialized = 1; | |
524 | ||
525 | putDebugStr("kgdb ready\n"); | |
526 | puts("ready\n"); | |
527 | } | |
528 | ||
529 | void | |
530 | kgdb_error(int errnum) | |
531 | { | |
532 | longjmp_on_fault = 0; | |
cc3843e3 | 533 | kgdb_longjmp(error_jmp_buf, errnum); |
4a9cbbe8 WD |
534 | panic("kgdb_error: longjmp failed!\n"); |
535 | } | |
536 | ||
537 | /* Output string in GDB O-packet format if GDB has connected. If nothing | |
538 | output, returns 0 (caller must then handle output). */ | |
539 | int | |
540 | kgdb_output_string (const char* s, unsigned int count) | |
541 | { | |
542 | char buffer[512]; | |
543 | ||
544 | count = (count <= (sizeof(buffer) / 2 - 2)) | |
545 | ? count : (sizeof(buffer) / 2 - 2); | |
546 | ||
547 | buffer[0] = 'O'; | |
548 | mem2hex ((char *)s, &buffer[1], count); | |
77ddac94 | 549 | putpacket((unsigned char *)&buffer); |
4a9cbbe8 WD |
550 | |
551 | return 1; | |
552 | } | |
553 | ||
554 | void | |
555 | breakpoint(void) | |
556 | { | |
557 | if (!initialized) { | |
558 | printf("breakpoint() called b4 kgdb init\n"); | |
559 | return; | |
560 | } | |
561 | ||
562 | kgdb_breakpoint(0, 0); | |
563 | } | |
564 | ||
565 | int | |
566 | do_kgdb(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]) | |
567 | { | |
568 | printf("Entering KGDB mode via exception handler...\n\n"); | |
569 | kgdb_breakpoint(argc - 1, argv + 1); | |
570 | printf("\nReturned from KGDB mode\n"); | |
571 | return 0; | |
572 | } | |
573 | ||
0d498393 | 574 | U_BOOT_CMD( |
6d0f6bcf | 575 | kgdb, CONFIG_SYS_MAXARGS, 1, do_kgdb, |
2fb2604d | 576 | "enter gdb remote debug mode", |
8bde7f77 WD |
577 | "[arg0 arg1 .. argN]\n" |
578 | " - executes a breakpoint so that kgdb mode is\n" | |
579 | " entered via the exception handler. To return\n" | |
580 | " to the monitor, the remote gdb debugger must\n" | |
581 | " execute a \"continue\" or \"quit\" command.\n" | |
582 | "\n" | |
583 | " if a program is loaded by the remote gdb, any args\n" | |
584 | " passed to the kgdb command are given to the loaded\n" | |
585 | " program if it is executed (see the \"hello_world\"\n" | |
586 | " example program in the U-Boot examples directory)." | |
587 | ); |