File: /usr/src/linux/arch/sparc/kernel/sparc-stub.c
1 /* $Id: sparc-stub.c,v 1.27 2000/10/03 07:28:49 anton Exp $
2 * sparc-stub.c: KGDB support for the Linux kernel.
3 *
4 * Modifications to run under Linux
5 * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
6 *
7 * This file originally came from the gdb sources, and the
8 * copyright notices have been retained below.
9 */
10
11 /****************************************************************************
12
13 THIS SOFTWARE IS NOT COPYRIGHTED
14
15 HP offers the following for use in the public domain. HP makes no
16 warranty with regard to the software or its performance and the
17 user accepts the software "AS IS" with all faults.
18
19 HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
20 TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
21 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
22
23 ****************************************************************************/
24
25 /****************************************************************************
26 * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
27 *
28 * Module name: remcom.c $
29 * Revision: 1.34 $
30 * Date: 91/03/09 12:29:49 $
31 * Contributor: Lake Stevens Instrument Division$
32 *
33 * Description: low level support for gdb debugger. $
34 *
35 * Considerations: only works on target hardware $
36 *
37 * Written by: Glenn Engel $
38 * ModuleState: Experimental $
39 *
40 * NOTES: See Below $
41 *
42 * Modified for SPARC by Stu Grossman, Cygnus Support.
43 *
44 * This code has been extensively tested on the Fujitsu SPARClite demo board.
45 *
46 * To enable debugger support, two things need to happen. One, a
47 * call to set_debug_traps() is necessary in order to allow any breakpoints
48 * or error conditions to be properly intercepted and reported to gdb.
49 * Two, a breakpoint needs to be generated to begin communication. This
50 * is most easily accomplished by a call to breakpoint(). Breakpoint()
51 * simulates a breakpoint by executing a trap #1.
52 *
53 *************
54 *
55 * The following gdb commands are supported:
56 *
57 * command function Return value
58 *
59 * g return the value of the CPU registers hex data or ENN
60 * G set the value of the CPU registers OK or ENN
61 *
62 * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
63 * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
64 *
65 * c Resume at current address SNN ( signal NN)
66 * cAA..AA Continue at address AA..AA SNN
67 *
68 * s Step one instruction SNN
69 * sAA..AA Step one instruction from AA..AA SNN
70 *
71 * k kill
72 *
73 * ? What was the last sigval ? SNN (signal NN)
74 *
75 * bBB..BB Set baud rate to BB..BB OK or BNN, then sets
76 * baud rate
77 *
78 * All commands and responses are sent with a packet which includes a
79 * checksum. A packet consists of
80 *
81 * $<packet info>#<checksum>.
82 *
83 * where
84 * <packet info> :: <characters representing the command or response>
85 * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>>
86 *
87 * When a packet is received, it is first acknowledged with either '+' or '-'.
88 * '+' indicates a successful transfer. '-' indicates a failed transfer.
89 *
90 * Example:
91 *
92 * Host: Reply:
93 * $m0,10#2a +$00010203040506070809101112131415#42
94 *
95 ****************************************************************************/
96
97 #include <linux/kernel.h>
98 #include <linux/string.h>
99 #include <linux/mm.h>
100 #include <linux/smp.h>
101 #include <linux/smp_lock.h>
102
103 #include <asm/system.h>
104 #include <asm/signal.h>
105 #include <asm/oplib.h>
106 #include <asm/head.h>
107 #include <asm/traps.h>
108 #include <asm/vac-ops.h>
109 #include <asm/kgdb.h>
110 #include <asm/pgalloc.h>
111 #include <asm/pgtable.h>
112 /*
113 *
114 * external low-level support routines
115 */
116
117 extern void putDebugChar(char); /* write a single character */
118 extern char getDebugChar(void); /* read and return a single char */
119
120 /*
121 * BUFMAX defines the maximum number of characters in inbound/outbound buffers
122 * at least NUMREGBYTES*2 are needed for register packets
123 */
124 #define BUFMAX 2048
125
126 static int initialized; /* !0 means we've been initialized */
127
128 static const char hexchars[]="0123456789abcdef";
129
130 #define NUMREGS 72
131
132 /* Number of bytes of registers. */
133 #define NUMREGBYTES (NUMREGS * 4)
134 enum regnames {G0, G1, G2, G3, G4, G5, G6, G7,
135 O0, O1, O2, O3, O4, O5, SP, O7,
136 L0, L1, L2, L3, L4, L5, L6, L7,
137 I0, I1, I2, I3, I4, I5, FP, I7,
138
139 F0, F1, F2, F3, F4, F5, F6, F7,
140 F8, F9, F10, F11, F12, F13, F14, F15,
141 F16, F17, F18, F19, F20, F21, F22, F23,
142 F24, F25, F26, F27, F28, F29, F30, F31,
143 Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR };
144
145
146 extern void trap_low(void); /* In arch/sparc/kernel/entry.S */
147
148 unsigned long get_sun4cpte(unsigned long addr)
149 {
150 unsigned long entry;
151
152 __asm__ __volatile__("\n\tlda [%1] %2, %0\n\t" :
153 "=r" (entry) :
154 "r" (addr), "i" (ASI_PTE));
155 return entry;
156 }
157
158 unsigned long get_sun4csegmap(unsigned long addr)
159 {
160 unsigned long entry;
161
162 __asm__ __volatile__("\n\tlduba [%1] %2, %0\n\t" :
163 "=r" (entry) :
164 "r" (addr), "i" (ASI_SEGMAP));
165 return entry;
166 }
167
168 #if 0
169 /* Have to sort this out. This cannot be done after initialization. */
170 static void flush_cache_all_nop(void) {}
171 #endif
172
173 /* Place where we save old trap entries for restoration */
174 struct tt_entry kgdb_savettable[256];
175 typedef void (*trapfunc_t)(void);
176
177 /* Helper routine for manipulation of kgdb_savettable */
178 static inline void copy_ttentry(struct tt_entry *src, struct tt_entry *dest)
179 {
180 dest->inst_one = src->inst_one;
181 dest->inst_two = src->inst_two;
182 dest->inst_three = src->inst_three;
183 dest->inst_four = src->inst_four;
184 }
185
186 /* Initialize the kgdb_savettable so that debugging can commence */
187 static void eh_init(void)
188 {
189 int i, flags;
190
191 save_and_cli(flags);
192 for(i=0; i < 256; i++)
193 copy_ttentry(&sparc_ttable[i], &kgdb_savettable[i]);
194 restore_flags(flags);
195 }
196
197 /* Install an exception handler for kgdb */
198 static void exceptionHandler(int tnum, trapfunc_t trap_entry)
199 {
200 unsigned long te_addr = (unsigned long) trap_entry;
201 int flags;
202
203 /* We are dorking with a live trap table, all irqs off */
204 save_and_cli(flags);
205
206 /* Make new vector */
207 sparc_ttable[tnum].inst_one =
208 SPARC_BRANCH((unsigned long) te_addr,
209 (unsigned long) &sparc_ttable[tnum].inst_one);
210 sparc_ttable[tnum].inst_two = SPARC_RD_PSR_L0;
211 sparc_ttable[tnum].inst_three = SPARC_NOP;
212 sparc_ttable[tnum].inst_four = SPARC_NOP;
213
214 restore_flags(flags);
215 }
216
217 /* Convert ch from a hex digit to an int */
218 static int
219 hex(unsigned char ch)
220 {
221 if (ch >= 'a' && ch <= 'f')
222 return ch-'a'+10;
223 if (ch >= '0' && ch <= '9')
224 return ch-'0';
225 if (ch >= 'A' && ch <= 'F')
226 return ch-'A'+10;
227 return -1;
228 }
229
230 /* scan for the sequence $<data>#<checksum> */
231 static void
232 getpacket(char *buffer)
233 {
234 unsigned char checksum;
235 unsigned char xmitcsum;
236 int i;
237 int count;
238 unsigned char ch;
239
240 do {
241 /* wait around for the start character, ignore all other characters */
242 while ((ch = (getDebugChar() & 0x7f)) != '$') ;
243
244 checksum = 0;
245 xmitcsum = -1;
246
247 count = 0;
248
249 /* now, read until a # or end of buffer is found */
250 while (count < BUFMAX) {
251 ch = getDebugChar() & 0x7f;
252 if (ch == '#')
253 break;
254 checksum = checksum + ch;
255 buffer[count] = ch;
256 count = count + 1;
257 }
258
259 if (count >= BUFMAX)
260 continue;
261
262 buffer[count] = 0;
263
264 if (ch == '#') {
265 xmitcsum = hex(getDebugChar() & 0x7f) << 4;
266 xmitcsum |= hex(getDebugChar() & 0x7f);
267 if (checksum != xmitcsum)
268 putDebugChar('-'); /* failed checksum */
269 else {
270 putDebugChar('+'); /* successful transfer */
271 /* if a sequence char is present, reply the ID */
272 if (buffer[2] == ':') {
273 putDebugChar(buffer[0]);
274 putDebugChar(buffer[1]);
275 /* remove sequence chars from buffer */
276 count = strlen(buffer);
277 for (i=3; i <= count; i++)
278 buffer[i-3] = buffer[i];
279 }
280 }
281 }
282 } while (checksum != xmitcsum);
283 }
284
285 /* send the packet in buffer. */
286
287 static void
288 putpacket(unsigned char *buffer)
289 {
290 unsigned char checksum;
291 int count;
292 unsigned char ch, recv;
293
294 /* $<packet info>#<checksum>. */
295 do {
296 putDebugChar('$');
297 checksum = 0;
298 count = 0;
299
300 while ((ch = buffer[count])) {
301 putDebugChar(ch);
302 checksum += ch;
303 count += 1;
304 }
305
306 putDebugChar('#');
307 putDebugChar(hexchars[checksum >> 4]);
308 putDebugChar(hexchars[checksum & 0xf]);
309 recv = getDebugChar();
310 } while ((recv & 0x7f) != '+');
311 }
312
313 static char remcomInBuffer[BUFMAX];
314 static char remcomOutBuffer[BUFMAX];
315
316 /* Convert the memory pointed to by mem into hex, placing result in buf.
317 * Return a pointer to the last char put in buf (null), in case of mem fault,
318 * return 0.
319 */
320
321 static unsigned char *
322 mem2hex(char *mem, char *buf, int count)
323 {
324 unsigned char ch;
325
326 while (count-- > 0) {
327 /* This assembler code is basically: ch = *mem++;
328 * except that we use the SPARC/Linux exception table
329 * mechanism (see how "fixup" works in kernel_mna_trap_fault)
330 * to arrange for a "return 0" upon a memory fault
331 */
332 __asm__(
333 "1: ldub [%0], %1
334 inc %0
335 .section .fixup,#alloc,#execinstr
336 .align 4
337 2: retl
338 mov 0, %%o0
339 .section __ex_table, #alloc
340 .align 4
341 .word 1b, 2b
342 .text"
343 : "=r" (mem), "=r" (ch) : "0" (mem));
344 *buf++ = hexchars[ch >> 4];
345 *buf++ = hexchars[ch & 0xf];
346 }
347
348 *buf = 0;
349 return buf;
350 }
351
352 /* convert the hex array pointed to by buf into binary to be placed in mem
353 * return a pointer to the character AFTER the last byte written.
354 */
355 static char *
356 hex2mem(char *buf, char *mem, int count)
357 {
358 int i;
359 unsigned char ch;
360
361 for (i=0; i<count; i++) {
362
363 ch = hex(*buf++) << 4;
364 ch |= hex(*buf++);
365 /* Assembler code is *mem++ = ch; with return 0 on fault */
366 __asm__(
367 "1: stb %1, [%0]
368 inc %0
369 .section .fixup,#alloc,#execinstr
370 .align 4
371 2: retl
372 mov 0, %%o0
373 .section __ex_table, #alloc
374 .align 4
375 .word 1b, 2b
376 .text"
377 : "=r" (mem) : "r" (ch) , "0" (mem));
378 }
379 return mem;
380 }
381
382 /* This table contains the mapping between SPARC hardware trap types, and
383 signals, which are primarily what GDB understands. It also indicates
384 which hardware traps we need to commandeer when initializing the stub. */
385
386 static struct hard_trap_info
387 {
388 unsigned char tt; /* Trap type code for SPARC */
389 unsigned char signo; /* Signal that we map this trap into */
390 } hard_trap_info[] = {
391 {SP_TRAP_SBPT, SIGTRAP}, /* ta 1 - Linux/KGDB software breakpoint */
392 {0, 0} /* Must be last */
393 };
394
395 /* Set up exception handlers for tracing and breakpoints */
396
397 void
398 set_debug_traps(void)
399 {
400 struct hard_trap_info *ht;
401 unsigned long flags;
402
403 save_and_cli(flags);
404 #if 0
405 /* Have to sort this out. This cannot be done after initialization. */
406 BTFIXUPSET_CALL(flush_cache_all, flush_cache_all_nop, BTFIXUPCALL_NOP);
407 #endif
408
409 /* Initialize our copy of the Linux Sparc trap table */
410 eh_init();
411
412 for (ht = hard_trap_info; ht->tt && ht->signo; ht++) {
413 /* Only if it doesn't destroy our fault handlers */
414 if((ht->tt != SP_TRAP_TFLT) &&
415 (ht->tt != SP_TRAP_DFLT))
416 exceptionHandler(ht->tt, trap_low);
417 }
418
419 /* In case GDB is started before us, ack any packets (presumably
420 * "$?#xx") sitting there.
421 *
422 * I've found this code causes more problems than it solves,
423 * so that's why it's commented out. GDB seems to work fine
424 * now starting either before or after the kernel -bwb
425 */
426 #if 0
427 while((c = getDebugChar()) != '$');
428 while((c = getDebugChar()) != '#');
429 c = getDebugChar(); /* eat first csum byte */
430 c = getDebugChar(); /* eat second csum byte */
431 putDebugChar('+'); /* ack it */
432 #endif
433
434 initialized = 1; /* connect! */
435 restore_flags(flags);
436 }
437
438 /* Convert the SPARC hardware trap type code to a unix signal number. */
439
440 static int
441 computeSignal(int tt)
442 {
443 struct hard_trap_info *ht;
444
445 for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
446 if (ht->tt == tt)
447 return ht->signo;
448
449 return SIGHUP; /* default for things we don't know about */
450 }
451
452 /*
453 * While we find nice hex chars, build an int.
454 * Return number of chars processed.
455 */
456
457 static int
458 hexToInt(char **ptr, int *intValue)
459 {
460 int numChars = 0;
461 int hexValue;
462
463 *intValue = 0;
464
465 while (**ptr) {
466 hexValue = hex(**ptr);
467 if (hexValue < 0)
468 break;
469
470 *intValue = (*intValue << 4) | hexValue;
471 numChars ++;
472
473 (*ptr)++;
474 }
475
476 return (numChars);
477 }
478
479 /*
480 * This function does all command processing for interfacing to gdb. It
481 * returns 1 if you should skip the instruction at the trap address, 0
482 * otherwise.
483 */
484
485 extern void breakinst(void);
486
487 void
488 handle_exception (unsigned long *registers)
489 {
490 int tt; /* Trap type */
491 int sigval;
492 int addr;
493 int length;
494 char *ptr;
495 unsigned long *sp;
496
497 /* First, we must force all of the windows to be spilled out */
498
499 asm("save %sp, -64, %sp\n\t"
500 "save %sp, -64, %sp\n\t"
501 "save %sp, -64, %sp\n\t"
502 "save %sp, -64, %sp\n\t"
503 "save %sp, -64, %sp\n\t"
504 "save %sp, -64, %sp\n\t"
505 "save %sp, -64, %sp\n\t"
506 "save %sp, -64, %sp\n\t"
507 "restore\n\t"
508 "restore\n\t"
509 "restore\n\t"
510 "restore\n\t"
511 "restore\n\t"
512 "restore\n\t"
513 "restore\n\t"
514 "restore\n\t");
515
516 lock_kernel();
517 if (registers[PC] == (unsigned long)breakinst) {
518 /* Skip over breakpoint trap insn */
519 registers[PC] = registers[NPC];
520 registers[NPC] += 4;
521 }
522
523 sp = (unsigned long *)registers[SP];
524
525 tt = (registers[TBR] >> 4) & 0xff;
526
527 /* reply to host that an exception has occurred */
528 sigval = computeSignal(tt);
529 ptr = remcomOutBuffer;
530
531 *ptr++ = 'T';
532 *ptr++ = hexchars[sigval >> 4];
533 *ptr++ = hexchars[sigval & 0xf];
534
535 *ptr++ = hexchars[PC >> 4];
536 *ptr++ = hexchars[PC & 0xf];
537 *ptr++ = ':';
538 ptr = mem2hex((char *)®isters[PC], ptr, 4);
539 *ptr++ = ';';
540
541 *ptr++ = hexchars[FP >> 4];
542 *ptr++ = hexchars[FP & 0xf];
543 *ptr++ = ':';
544 ptr = mem2hex((char *) (sp + 8 + 6), ptr, 4); /* FP */
545 *ptr++ = ';';
546
547 *ptr++ = hexchars[SP >> 4];
548 *ptr++ = hexchars[SP & 0xf];
549 *ptr++ = ':';
550 ptr = mem2hex((char *)&sp, ptr, 4);
551 *ptr++ = ';';
552
553 *ptr++ = hexchars[NPC >> 4];
554 *ptr++ = hexchars[NPC & 0xf];
555 *ptr++ = ':';
556 ptr = mem2hex((char *)®isters[NPC], ptr, 4);
557 *ptr++ = ';';
558
559 *ptr++ = hexchars[O7 >> 4];
560 *ptr++ = hexchars[O7 & 0xf];
561 *ptr++ = ':';
562 ptr = mem2hex((char *)®isters[O7], ptr, 4);
563 *ptr++ = ';';
564
565 *ptr++ = 0;
566
567 putpacket(remcomOutBuffer);
568
569 /* XXX We may want to add some features dealing with poking the
570 * XXX page tables, the real ones on the srmmu, and what is currently
571 * XXX loaded in the sun4/sun4c tlb at this point in time. But this
572 * XXX also required hacking to the gdb sources directly...
573 */
574
575 while (1) {
576 remcomOutBuffer[0] = 0;
577
578 getpacket(remcomInBuffer);
579 switch (remcomInBuffer[0]) {
580 case '?':
581 remcomOutBuffer[0] = 'S';
582 remcomOutBuffer[1] = hexchars[sigval >> 4];
583 remcomOutBuffer[2] = hexchars[sigval & 0xf];
584 remcomOutBuffer[3] = 0;
585 break;
586
587 case 'd':
588 /* toggle debug flag */
589 break;
590
591 case 'g': /* return the value of the CPU registers */
592 {
593 ptr = remcomOutBuffer;
594 /* G & O regs */
595 ptr = mem2hex((char *)registers, ptr, 16 * 4);
596 /* L & I regs */
597 ptr = mem2hex((char *) (sp + 0), ptr, 16 * 4);
598 /* Floating point */
599 memset(ptr, '0', 32 * 8);
600 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
601 mem2hex((char *)®isters[Y], (ptr + 32 * 4 * 2), (8 * 4));
602 }
603 break;
604
605 case 'G': /* set the value of the CPU registers - return OK */
606 {
607 unsigned long *newsp, psr;
608
609 psr = registers[PSR];
610
611 ptr = &remcomInBuffer[1];
612 /* G & O regs */
613 hex2mem(ptr, (char *)registers, 16 * 4);
614 /* L & I regs */
615 hex2mem(ptr + 16 * 4 * 2, (char *) (sp + 0), 16 * 4);
616 /* Y, PSR, WIM, TBR, PC, NPC, FPSR, CPSR */
617 hex2mem(ptr + 64 * 4 * 2, (char *)®isters[Y], 8 * 4);
618
619 /* See if the stack pointer has moved. If so,
620 * then copy the saved locals and ins to the
621 * new location. This keeps the window
622 * overflow and underflow routines happy.
623 */
624
625 newsp = (unsigned long *)registers[SP];
626 if (sp != newsp)
627 sp = memcpy(newsp, sp, 16 * 4);
628
629 /* Don't allow CWP to be modified. */
630
631 if (psr != registers[PSR])
632 registers[PSR] = (psr & 0x1f) | (registers[PSR] & ~0x1f);
633
634 strcpy(remcomOutBuffer,"OK");
635 }
636 break;
637
638 case 'm': /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
639 /* Try to read %x,%x. */
640
641 ptr = &remcomInBuffer[1];
642
643 if (hexToInt(&ptr, &addr)
644 && *ptr++ == ','
645 && hexToInt(&ptr, &length)) {
646 if (mem2hex((char *)addr, remcomOutBuffer, length))
647 break;
648
649 strcpy (remcomOutBuffer, "E03");
650 } else {
651 strcpy(remcomOutBuffer,"E01");
652 }
653 break;
654
655 case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
656 /* Try to read '%x,%x:'. */
657
658 ptr = &remcomInBuffer[1];
659
660 if (hexToInt(&ptr, &addr)
661 && *ptr++ == ','
662 && hexToInt(&ptr, &length)
663 && *ptr++ == ':') {
664 if (hex2mem(ptr, (char *)addr, length)) {
665 strcpy(remcomOutBuffer, "OK");
666 } else {
667 strcpy(remcomOutBuffer, "E03");
668 }
669 } else {
670 strcpy(remcomOutBuffer, "E02");
671 }
672 break;
673
674 case 'c': /* cAA..AA Continue at address AA..AA(optional) */
675 /* try to read optional parameter, pc unchanged if no parm */
676
677 ptr = &remcomInBuffer[1];
678 if (hexToInt(&ptr, &addr)) {
679 registers[PC] = addr;
680 registers[NPC] = addr + 4;
681 }
682
683 /* Need to flush the instruction cache here, as we may have deposited a
684 * breakpoint, and the icache probably has no way of knowing that a data ref to
685 * some location may have changed something that is in the instruction cache.
686 */
687 flush_cache_all();
688 unlock_kernel();
689 return;
690
691 /* kill the program */
692 case 'k' : /* do nothing */
693 break;
694 case 'r': /* Reset */
695 asm ("call 0\n\t"
696 "nop\n\t");
697 break;
698 } /* switch */
699
700 /* reply to the request */
701 putpacket(remcomOutBuffer);
702 } /* while(1) */
703 }
704
705 /* This function will generate a breakpoint exception. It is used at the
706 beginning of a program to sync up with a debugger and can be used
707 otherwise as a quick means to stop program execution and "break" into
708 the debugger. */
709
710 void
711 breakpoint(void)
712 {
713 if (!initialized)
714 return;
715
716 /* Again, watch those c-prefixes for ELF kernels */
717 #if defined(__svr4__) || defined(__ELF__)
718 asm(" .globl breakinst
719
720 breakinst: ta 1
721 ");
722 #else
723 asm(" .globl _breakinst
724
725 _breakinst: ta 1
726 ");
727 #endif
728 }
729