?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[cris-mirror.git] / arch / cris / arch-v32 / kernel / kgdb.c
blob3d6f516763a5ac024a1da9f801cca0a2f8df25d4
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * arch/cris/arch-v32/kernel/kgdb.c
4 *
5 * CRIS v32 version by Orjan Friberg, Axis Communications AB.
6 *
7 * S390 version
8 * Copyright (C) 1999 IBM Deutschland Entwicklung GmbH, IBM Corporation
9 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
10 *
11 * Originally written by Glenn Engel, Lake Stevens Instrument Division
12 *
13 * Contributed by HP Systems
14 *
15 * Modified for SPARC by Stu Grossman, Cygnus Support.
16 *
17 * Modified for Linux/MIPS (and MIPS in general) by Andreas Busse
18 * Send complaints, suggestions etc. to <andy@waldorf-gmbh.de>
19 *
20 * Copyright (C) 1995 Andreas Busse
21 */
22
23 /* FIXME: Check the documentation. */
24
25 /*
26 * kgdb usage notes:
27 * -----------------
28 *
29 * If you select CONFIG_ETRAX_KGDB in the configuration, the kernel will be
30 * built with different gcc flags: "-g" is added to get debug infos, and
31 * "-fomit-frame-pointer" is omitted to make debugging easier. Since the
32 * resulting kernel will be quite big (approx. > 7 MB), it will be stripped
33 * before compresion. Such a kernel will behave just as usually, except if
34 * given a "debug=<device>" command line option. (Only serial devices are
35 * allowed for <device>, i.e. no printers or the like; possible values are
36 * machine depedend and are the same as for the usual debug device, the one
37 * for logging kernel messages.) If that option is given and the device can be
38 * initialized, the kernel will connect to the remote gdb in trap_init(). The
39 * serial parameters are fixed to 8N1 and 115200 bps, for easyness of
40 * implementation.
41 *
42 * To start a debugging session, start that gdb with the debugging kernel
43 * image (the one with the symbols, vmlinux.debug) named on the command line.
44 * This file will be used by gdb to get symbol and debugging infos about the
45 * kernel. Next, select remote debug mode by
46 * target remote <device>
47 * where <device> is the name of the serial device over which the debugged
48 * machine is connected. Maybe you have to adjust the baud rate by
49 * set remotebaud <rate>
50 * or also other parameters with stty:
51 * shell stty ... </dev/...
52 * If the kernel to debug has already booted, it waited for gdb and now
53 * connects, and you'll see a breakpoint being reported. If the kernel isn't
54 * running yet, start it now. The order of gdb and the kernel doesn't matter.
55 * Another thing worth knowing about in the getting-started phase is how to
56 * debug the remote protocol itself. This is activated with
57 * set remotedebug 1
58 * gdb will then print out each packet sent or received. You'll also get some
59 * messages about the gdb stub on the console of the debugged machine.
60 *
61 * If all that works, you can use lots of the usual debugging techniques on
62 * the kernel, e.g. inspecting and changing variables/memory, setting
63 * breakpoints, single stepping and so on. It's also possible to interrupt the
64 * debugged kernel by pressing C-c in gdb. Have fun! :-)
65 *
66 * The gdb stub is entered (and thus the remote gdb gets control) in the
67 * following situations:
68 *
69 * - If breakpoint() is called. This is just after kgdb initialization, or if
70 * a breakpoint() call has been put somewhere into the kernel source.
71 * (Breakpoints can of course also be set the usual way in gdb.)
72 * In eLinux, we call breakpoint() in init/main.c after IRQ initialization.
73 *
74 * - If there is a kernel exception, i.e. bad_super_trap() or die_if_kernel()
75 * are entered. All the CPU exceptions are mapped to (more or less..., see
76 * the hard_trap_info array below) appropriate signal, which are reported
77 * to gdb. die_if_kernel() is usually called after some kind of access
78 * error and thus is reported as SIGSEGV.
79 *
80 * - When panic() is called. This is reported as SIGABRT.
81 *
82 * - If C-c is received over the serial line, which is treated as
83 * SIGINT.
84 *
85 * Of course, all these signals are just faked for gdb, since there is no
86 * signal concept as such for the kernel. It also isn't possible --obviously--
87 * to set signal handlers from inside gdb, or restart the kernel with a
88 * signal.
89 *
90 * Current limitations:
91 *
92 * - While the kernel is stopped, interrupts are disabled for safety reasons
93 * (i.e., variables not changing magically or the like). But this also
94 * means that the clock isn't running anymore, and that interrupts from the
95 * hardware may get lost/not be served in time. This can cause some device
96 * errors...
97 *
98 * - When single-stepping, only one instruction of the current thread is
99 * executed, but interrupts are allowed for that time and will be serviced
100 * if pending. Be prepared for that.
101 *
102 * - All debugging happens in kernel virtual address space. There's no way to
103 * access physical memory not mapped in kernel space, or to access user
104 * space. A way to work around this is using get_user_long & Co. in gdb
105 * expressions, but only for the current process.
106 *
107 * - Interrupting the kernel only works if interrupts are currently allowed,
108 * and the interrupt of the serial line isn't blocked by some other means
109 * (IPL too high, disabled, ...)
110 *
111 * - The gdb stub is currently not reentrant, i.e. errors that happen therein
112 * (e.g. accessing invalid memory) may not be caught correctly. This could
113 * be removed in future by introducing a stack of struct registers.
114 *
115 */
116
117 /*
118 * To enable debugger support, two things need to happen. One, a
119 * call to kgdb_init() is necessary in order to allow any breakpoints
120 * or error conditions to be properly intercepted and reported to gdb.
121 * Two, a breakpoint needs to be generated to begin communication. This
122 * is most easily accomplished by a call to breakpoint().
123 *
124 * The following gdb commands are supported:
125 *
126 * command function Return value
127 *
128 * g return the value of the CPU registers hex data or ENN
129 * G set the value of the CPU registers OK or ENN
130 *
131 * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
132 * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
133 *
134 * c Resume at current address SNN ( signal NN)
135 * cAA..AA Continue at address AA..AA SNN
136 *
137 * s Step one instruction SNN
138 * sAA..AA Step one instruction from AA..AA SNN
139 *
140 * k kill
141 *
142 * ? What was the last sigval ? SNN (signal NN)
143 *
144 * bBB..BB Set baud rate to BB..BB OK or BNN, then sets
145 * baud rate
146 *
147 * All commands and responses are sent with a packet which includes a
148 * checksum. A packet consists of
149 *
150 * $<packet info>#<checksum>.
151 *
152 * where
153 * <packet info> :: <characters representing the command or response>
154 * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>>
155 *
156 * When a packet is received, it is first acknowledged with either '+' or '-'.
157 * '+' indicates a successful transfer. '-' indicates a failed transfer.
158 *
159 * Example:
160 *
161 * Host: Reply:
162 * $m0,10#2a +$00010203040506070809101112131415#42
163 *
164 */
165
166
167 #include <linux/string.h>
168 #include <linux/signal.h>
169 #include <linux/kernel.h>
170 #include <linux/delay.h>
171 #include <linux/linkage.h>
172 #include <linux/reboot.h>
173
174 #include <asm/setup.h>
175 #include <asm/ptrace.h>
176
177 #include <asm/irq.h>
178 #include <hwregs/reg_map.h>
179 #include <hwregs/reg_rdwr.h>
180 #include <hwregs/intr_vect_defs.h>
181 #include <hwregs/ser_defs.h>
182
183 /* From entry.S. */
184 extern void gdb_handle_exception(void);
185 /* From kgdb_asm.S. */
186 extern void kgdb_handle_exception(void);
187
188 static int kgdb_started = 0;
189
190 /********************************* Register image ****************************/
191
192 typedef
193 struct register_image
194 {
195 /* Offset */
196 unsigned int r0; /* 0x00 */
197 unsigned int r1; /* 0x04 */
198 unsigned int r2; /* 0x08 */
199 unsigned int r3; /* 0x0C */
200 unsigned int r4; /* 0x10 */
201 unsigned int r5; /* 0x14 */
202 unsigned int r6; /* 0x18 */
203 unsigned int r7; /* 0x1C */
204 unsigned int r8; /* 0x20; Frame pointer (if any) */
205 unsigned int r9; /* 0x24 */
206 unsigned int r10; /* 0x28 */
207 unsigned int r11; /* 0x2C */
208 unsigned int r12; /* 0x30 */
209 unsigned int r13; /* 0x34 */
210 unsigned int sp; /* 0x38; R14, Stack pointer */
211 unsigned int acr; /* 0x3C; R15, Address calculation register. */
212
213 unsigned char bz; /* 0x40; P0, 8-bit zero register */
214 unsigned char vr; /* 0x41; P1, Version register (8-bit) */
215 unsigned int pid; /* 0x42; P2, Process ID */
216 unsigned char srs; /* 0x46; P3, Support register select (8-bit) */
217 unsigned short wz; /* 0x47; P4, 16-bit zero register */
218 unsigned int exs; /* 0x49; P5, Exception status */
219 unsigned int eda; /* 0x4D; P6, Exception data address */
220 unsigned int mof; /* 0x51; P7, Multiply overflow register */
221 unsigned int dz; /* 0x55; P8, 32-bit zero register */
222 unsigned int ebp; /* 0x59; P9, Exception base pointer */
223 unsigned int erp; /* 0x5D; P10, Exception return pointer. Contains the PC we are interested in. */
224 unsigned int srp; /* 0x61; P11, Subroutine return pointer */
225 unsigned int nrp; /* 0x65; P12, NMI return pointer */
226 unsigned int ccs; /* 0x69; P13, Condition code stack */
227 unsigned int usp; /* 0x6D; P14, User mode stack pointer */
228 unsigned int spc; /* 0x71; P15, Single step PC */
229 unsigned int pc; /* 0x75; Pseudo register (for the most part set to ERP). */
230
231 } registers;
232
233 typedef
234 struct bp_register_image
235 {
236 /* Support register bank 0. */
237 unsigned int s0_0;
238 unsigned int s1_0;
239 unsigned int s2_0;
240 unsigned int s3_0;
241 unsigned int s4_0;
242 unsigned int s5_0;
243 unsigned int s6_0;
244 unsigned int s7_0;
245 unsigned int s8_0;
246 unsigned int s9_0;
247 unsigned int s10_0;
248 unsigned int s11_0;
249 unsigned int s12_0;
250 unsigned int s13_0;
251 unsigned int s14_0;
252 unsigned int s15_0;
253
254 /* Support register bank 1. */
255 unsigned int s0_1;
256 unsigned int s1_1;
257 unsigned int s2_1;
258 unsigned int s3_1;
259 unsigned int s4_1;
260 unsigned int s5_1;
261 unsigned int s6_1;
262 unsigned int s7_1;
263 unsigned int s8_1;
264 unsigned int s9_1;
265 unsigned int s10_1;
266 unsigned int s11_1;
267 unsigned int s12_1;
268 unsigned int s13_1;
269 unsigned int s14_1;
270 unsigned int s15_1;
271
272 /* Support register bank 2. */
273 unsigned int s0_2;
274 unsigned int s1_2;
275 unsigned int s2_2;
276 unsigned int s3_2;
277 unsigned int s4_2;
278 unsigned int s5_2;
279 unsigned int s6_2;
280 unsigned int s7_2;
281 unsigned int s8_2;
282 unsigned int s9_2;
283 unsigned int s10_2;
284 unsigned int s11_2;
285 unsigned int s12_2;
286 unsigned int s13_2;
287 unsigned int s14_2;
288 unsigned int s15_2;
289
290 /* Support register bank 3. */
291 unsigned int s0_3; /* BP_CTRL */
292 unsigned int s1_3; /* BP_I0_START */
293 unsigned int s2_3; /* BP_I0_END */
294 unsigned int s3_3; /* BP_D0_START */
295 unsigned int s4_3; /* BP_D0_END */
296 unsigned int s5_3; /* BP_D1_START */
297 unsigned int s6_3; /* BP_D1_END */
298 unsigned int s7_3; /* BP_D2_START */
299 unsigned int s8_3; /* BP_D2_END */
300 unsigned int s9_3; /* BP_D3_START */
301 unsigned int s10_3; /* BP_D3_END */
302 unsigned int s11_3; /* BP_D4_START */
303 unsigned int s12_3; /* BP_D4_END */
304 unsigned int s13_3; /* BP_D5_START */
305 unsigned int s14_3; /* BP_D5_END */
306 unsigned int s15_3; /* BP_RESERVED */
307
308 } support_registers;
309
310 enum register_name
311 {
312 R0, R1, R2, R3,
313 R4, R5, R6, R7,
314 R8, R9, R10, R11,
315 R12, R13, SP, ACR,
316
317 BZ, VR, PID, SRS,
318 WZ, EXS, EDA, MOF,
319 DZ, EBP, ERP, SRP,
320 NRP, CCS, USP, SPC,
321 PC,
322
323 S0, S1, S2, S3,
324 S4, S5, S6, S7,
325 S8, S9, S10, S11,
326 S12, S13, S14, S15
327
328 };
329
330 /* The register sizes of the registers in register_name. An unimplemented register
331 is designated by size 0 in this array. */
332 static int register_size[] =
333 {
334 4, 4, 4, 4,
335 4, 4, 4, 4,
336 4, 4, 4, 4,
337 4, 4, 4, 4,
338
339 1, 1, 4, 1,
340 2, 4, 4, 4,
341 4, 4, 4, 4,
342 4, 4, 4, 4,
343
344 4,
345
346 4, 4, 4, 4,
347 4, 4, 4, 4,
348 4, 4, 4, 4,
349 4, 4, 4
350
351 };
352
353 /* Contains the register image of the kernel.
354 (Global so that they can be reached from assembler code.) */
355 registers reg;
356 support_registers sreg;
357
358 /************** Prototypes for local library functions ***********************/
359
360 /* Copy of strcpy from libc. */
361 static char *gdb_cris_strcpy(char *s1, const char *s2);
362
363 /* Copy of strlen from libc. */
364 static int gdb_cris_strlen(const char *s);
365
366 /* Copy of memchr from libc. */
367 static void *gdb_cris_memchr(const void *s, int c, int n);
368
369 /* Copy of strtol from libc. Does only support base 16. */
370 static int gdb_cris_strtol(const char *s, char **endptr, int base);
371
372 /********************** Prototypes for local functions. **********************/
373
374 /* Write a value to a specified register regno in the register image
375 of the current thread. */
376 static int write_register(int regno, char *val);
377
378 /* Read a value from a specified register in the register image. Returns the
379 status of the read operation. The register value is returned in valptr. */
380 static int read_register(char regno, unsigned int *valptr);
381
382 /* Serial port, reads one character. ETRAX 100 specific. from debugport.c */
383 int getDebugChar(void);
384
385 /* Serial port, writes one character. ETRAX 100 specific. from debugport.c */
386 void putDebugChar(int val);
387
388 /* Convert the memory, pointed to by mem into hexadecimal representation.
389 Put the result in buf, and return a pointer to the last character
390 in buf (null). */
391 static char *mem2hex(char *buf, unsigned char *mem, int count);
392
393 /* Put the content of the array, in binary representation, pointed to by buf
394 into memory pointed to by mem, and return a pointer to
395 the character after the last byte written. */
396 static unsigned char *bin2mem(unsigned char *mem, unsigned char *buf, int count);
397
398 /* Await the sequence $<data>#<checksum> and store <data> in the array buffer
399 returned. */
400 static void getpacket(char *buffer);
401
402 /* Send $<data>#<checksum> from the <data> in the array buffer. */
403 static void putpacket(char *buffer);
404
405 /* Build and send a response packet in order to inform the host the
406 stub is stopped. */
407 static void stub_is_stopped(int sigval);
408
409 /* All expected commands are sent from remote.c. Send a response according
410 to the description in remote.c. Not static since it needs to be reached
411 from assembler code. */
412 void handle_exception(int sigval);
413
414 /* Performs a complete re-start from scratch. ETRAX specific. */
415 static void kill_restart(void);
416
417 /******************** Prototypes for global functions. ***********************/
418
419 /* The string str is prepended with the GDB printout token and sent. */
420 void putDebugString(const unsigned char *str, int len);
421
422 /* A static breakpoint to be used at startup. */
423 void breakpoint(void);
424
425 /* Avoid warning as the internal_stack is not used in the C-code. */
426 #define USEDVAR(name) { if (name) { ; } }
427 #define USEDFUN(name) { void (*pf)(void) = (void *)name; USEDVAR(pf) }
428
429 /********************************** Packet I/O ******************************/
430 /* BUFMAX defines the maximum number of characters in
431 inbound/outbound buffers */
432 /* FIXME: How do we know it's enough? */
433 #define BUFMAX 512
434
435 /* Run-length encoding maximum length. Send 64 at most. */
436 #define RUNLENMAX 64
437
438 /* The inbound/outbound buffers used in packet I/O */
439 static char input_buffer[BUFMAX];
440 static char output_buffer[BUFMAX];
441
442 /* Error and warning messages. */
443 enum error_type
444 {
445 SUCCESS, E01, E02, E03, E04, E05, E06, E07, E08
446 };
447
448 static char *error_message[] =
449 {
450 "",
451 "E01 Set current or general thread - H[c,g] - internal error.",
452 "E02 Change register content - P - cannot change read-only register.",
453 "E03 Thread is not alive.", /* T, not used. */
454 "E04 The command is not supported - [s,C,S,!,R,d,r] - internal error.",
455 "E05 Change register content - P - the register is not implemented..",
456 "E06 Change memory content - M - internal error.",
457 "E07 Change register content - P - the register is not stored on the stack",
458 "E08 Invalid parameter"
459 };
460
461 /********************************** Breakpoint *******************************/
462 /* Use an internal stack in the breakpoint and interrupt response routines.
463 FIXME: How do we know the size of this stack is enough?
464 Global so it can be reached from assembler code. */
465 #define INTERNAL_STACK_SIZE 1024
466 char internal_stack[INTERNAL_STACK_SIZE];
467
468 /* Due to the breakpoint return pointer, a state variable is needed to keep
469 track of whether it is a static (compiled) or dynamic (gdb-invoked)
470 breakpoint to be handled. A static breakpoint uses the content of register
471 ERP as it is whereas a dynamic breakpoint requires subtraction with 2
472 in order to execute the instruction. The first breakpoint is static; all
473 following are assumed to be dynamic. */
474 static int dynamic_bp = 0;
475
476 /********************************* String library ****************************/
477 /* Single-step over library functions creates trap loops. */
478
479 /* Copy char s2[] to s1[]. */
480 static char*
481 gdb_cris_strcpy(char *s1, const char *s2)
482 {
483 char *s = s1;
484
485 for (s = s1; (*s++ = *s2++) != '\0'; )
486 ;
487 return s1;
488 }
489
490 /* Find length of s[]. */
491 static int
492 gdb_cris_strlen(const char *s)
493 {
494 const char *sc;
495
496 for (sc = s; *sc != '\0'; sc++)
497 ;
498 return (sc - s);
499 }
500
501 /* Find first occurrence of c in s[n]. */
502 static void*
503 gdb_cris_memchr(const void *s, int c, int n)
504 {
505 const unsigned char uc = c;
506 const unsigned char *su;
507
508 for (su = s; 0 < n; ++su, --n)
509 if (*su == uc)
510 return (void *)su;
511 return NULL;
512 }
513 /******************************* Standard library ****************************/
514 /* Single-step over library functions creates trap loops. */
515 /* Convert string to long. */
516 static int
517 gdb_cris_strtol(const char *s, char **endptr, int base)
518 {
519 char *s1;
520 char *sd;
521 int x = 0;
522
523 for (s1 = (char*)s; (sd = gdb_cris_memchr(hex_asc, *s1, base)) != NULL; ++s1)
524 x = x * base + (sd - hex_asc);
525
526 if (endptr) {
527 /* Unconverted suffix is stored in endptr unless endptr is NULL. */
528 *endptr = s1;
529 }
530
531 return x;
532 }
533
534 /********************************* Register image ****************************/
535
536 /* Write a value to a specified register in the register image of the current
537 thread. Returns status code SUCCESS, E02, E05 or E08. */
538 static int
539 write_register(int regno, char *val)
540 {
541 int status = SUCCESS;
542
543 if (regno >= R0 && regno <= ACR) {
544 /* Consecutive 32-bit registers. */
545 if (hex2bin((unsigned char *)&reg.r0 + (regno - R0) * sizeof(unsigned int),
546 val, sizeof(unsigned int)))
547 status = E08;
548
549 } else if (regno == BZ || regno == VR || regno == WZ || regno == DZ) {
550 /* Read-only registers. */
551 status = E02;
552
553 } else if (regno == PID) {
554 /* 32-bit register. (Even though we already checked SRS and WZ, we cannot
555 combine this with the EXS - SPC write since SRS and WZ have different size.) */
556 if (hex2bin((unsigned char *)&reg.pid, val, sizeof(unsigned int)))
557 status = E08;
558
559 } else if (regno == SRS) {
560 /* 8-bit register. */
561 if (hex2bin((unsigned char *)&reg.srs, val, sizeof(unsigned char)))
562 status = E08;
563
564 } else if (regno >= EXS && regno <= SPC) {
565 /* Consecutive 32-bit registers. */
566 if (hex2bin((unsigned char *)&reg.exs + (regno - EXS) * sizeof(unsigned int),
567 val, sizeof(unsigned int)))
568 status = E08;
569
570 } else if (regno == PC) {
571 /* Pseudo-register. Treat as read-only. */
572 status = E02;
573
574 } else if (regno >= S0 && regno <= S15) {
575 /* 32-bit registers. */
576 if (hex2bin((unsigned char *)&sreg.s0_0 + (reg.srs * 16 * sizeof(unsigned int)) + (regno - S0) * sizeof(unsigned int),
577 val, sizeof(unsigned int)))
578 status = E08;
579 } else {
580 /* Non-existing register. */
581 status = E05;
582 }
583 return status;
584 }
585
586 /* Read a value from a specified register in the register image. Returns the
587 value in the register or -1 for non-implemented registers. */
588 static int
589 read_register(char regno, unsigned int *valptr)
590 {
591 int status = SUCCESS;
592
593 /* We read the zero registers from the register struct (instead of just returning 0)
594 to catch errors. */
595
596 if (regno >= R0 && regno <= ACR) {
597 /* Consecutive 32-bit registers. */
598 *valptr = *(unsigned int *)((char *)&reg.r0 + (regno - R0) * sizeof(unsigned int));
599
600 } else if (regno == BZ || regno == VR) {
601 /* Consecutive 8-bit registers. */
602 *valptr = (unsigned int)(*(unsigned char *)
603 ((char *)&reg.bz + (regno - BZ) * sizeof(char)));
604
605 } else if (regno == PID) {
606 /* 32-bit register. */
607 *valptr = *(unsigned int *)((char *)&reg.pid);
608
609 } else if (regno == SRS) {
610 /* 8-bit register. */
611 *valptr = (unsigned int)(*(unsigned char *)((char *)&reg.srs));
612
613 } else if (regno == WZ) {
614 /* 16-bit register. */
615 *valptr = (unsigned int)(*(unsigned short *)(char *)&reg.wz);
616
617 } else if (regno >= EXS && regno <= PC) {
618 /* Consecutive 32-bit registers. */
619 *valptr = *(unsigned int *)((char *)&reg.exs + (regno - EXS) * sizeof(unsigned int));
620
621 } else if (regno >= S0 && regno <= S15) {
622 /* Consecutive 32-bit registers, located elsewhere. */
623 *valptr = *(unsigned int *)((char *)&sreg.s0_0 + (reg.srs * 16 * sizeof(unsigned int)) + (regno - S0) * sizeof(unsigned int));
624
625 } else {
626 /* Non-existing register. */
627 status = E05;
628 }
629 return status;
630
631 }
632
633 /********************************** Packet I/O ******************************/
634 /* Convert the memory, pointed to by mem into hexadecimal representation.
635 Put the result in buf, and return a pointer to the last character
636 in buf (null). */
637
638 static char *
639 mem2hex(char *buf, unsigned char *mem, int count)
640 {
641 int i;
642 int ch;
643
644 if (mem == NULL) {
645 /* Invalid address, caught by 'm' packet handler. */
646 for (i = 0; i < count; i++) {
647 *buf++ = '0';
648 *buf++ = '0';
649 }
650 } else {
651 /* Valid mem address. */
652 for (i = 0; i < count; i++) {
653 ch = *mem++;
654 buf = hex_byte_pack(buf, ch);
655 }
656 }
657 /* Terminate properly. */
658 *buf = '\0';
659 return buf;
660 }
661
662 /* Same as mem2hex, but puts it in network byte order. */
663 static char *
664 mem2hex_nbo(char *buf, unsigned char *mem, int count)
665 {
666 int i;
667 int ch;
668
669 mem += count - 1;
670 for (i = 0; i < count; i++) {
671 ch = *mem--;
672 buf = hex_byte_pack(buf, ch);
673 }
674
675 /* Terminate properly. */
676 *buf = '\0';
677 return buf;
678 }
679
680 /* Put the content of the array, in binary representation, pointed to by buf
681 into memory pointed to by mem, and return a pointer to the character after
682 the last byte written.
683 Gdb will escape $, #, and the escape char (0x7d). */
684 static unsigned char*
685 bin2mem(unsigned char *mem, unsigned char *buf, int count)
686 {
687 int i;
688 unsigned char *next;
689 for (i = 0; i < count; i++) {
690 /* Check for any escaped characters. Be paranoid and
691 only unescape chars that should be escaped. */
692 if (*buf == 0x7d) {
693 next = buf + 1;
694 if (*next == 0x3 || *next == 0x4 || *next == 0x5D) {
695 /* #, $, ESC */
696 buf++;
697 *buf += 0x20;
698 }
699 }
700 *mem++ = *buf++;
701 }
702 return mem;
703 }
704
705 /* Await the sequence $<data>#<checksum> and store <data> in the array buffer
706 returned. */
707 static void
708 getpacket(char *buffer)
709 {
710 unsigned char checksum;
711 unsigned char xmitcsum;
712 int i;
713 int count;
714 char ch;
715
716 do {
717 while((ch = getDebugChar ()) != '$')
718 /* Wait for the start character $ and ignore all other characters */;
719 checksum = 0;
720 xmitcsum = -1;
721 count = 0;
722 /* Read until a # or the end of the buffer is reached */
723 while (count < BUFMAX) {
724 ch = getDebugChar();
725 if (ch == '#')
726 break;
727 checksum = checksum + ch;
728 buffer[count] = ch;
729 count = count + 1;
730 }
731
732 if (count >= BUFMAX)
733 continue;
734
735 buffer[count] = 0;
736
737 if (ch == '#') {
738 xmitcsum = hex_to_bin(getDebugChar()) << 4;
739 xmitcsum += hex_to_bin(getDebugChar());
740 if (checksum != xmitcsum) {
741 /* Wrong checksum */
742 putDebugChar('-');
743 } else {
744 /* Correct checksum */
745 putDebugChar('+');
746 /* If sequence characters are received, reply with them */
747 if (buffer[2] == ':') {
748 putDebugChar(buffer[0]);
749 putDebugChar(buffer[1]);
750 /* Remove the sequence characters from the buffer */
751 count = gdb_cris_strlen(buffer);
752 for (i = 3; i <= count; i++)
753 buffer[i - 3] = buffer[i];
754 }
755 }
756 }
757 } while (checksum != xmitcsum);
758 }
759
760 /* Send $<data>#<checksum> from the <data> in the array buffer. */
761
762 static void
763 putpacket(char *buffer)
764 {
765 int checksum;
766 int runlen;
767 int encode;
768
769 do {
770 char *src = buffer;
771 putDebugChar('$');
772 checksum = 0;
773 while (*src) {
774 /* Do run length encoding */
775 putDebugChar(*src);
776 checksum += *src;
777 runlen = 0;
778 while (runlen < RUNLENMAX && *src == src[runlen]) {
779 runlen++;
780 }
781 if (runlen > 3) {
782 /* Got a useful amount */
783 putDebugChar ('*');
784 checksum += '*';
785 encode = runlen + ' ' - 4;
786 putDebugChar(encode);
787 checksum += encode;
788 src += runlen;
789 } else {
790 src++;
791 }
792 }
793 putDebugChar('#');
794 putDebugChar(hex_asc_hi(checksum));
795 putDebugChar(hex_asc_lo(checksum));
796 } while(kgdb_started && (getDebugChar() != '+'));
797 }
798
799 /* The string str is prepended with the GDB printout token and sent. Required
800 in traditional implementations. */
801 void
802 putDebugString(const unsigned char *str, int len)
803 {
804 /* Move SPC forward if we are single-stepping. */
805 asm("spchere:");
806 asm("move $spc, $r10");
807 asm("cmp.d spchere, $r10");
808 asm("bne nosstep");
809 asm("nop");
810 asm("move.d spccont, $r10");
811 asm("move $r10, $spc");
812 asm("nosstep:");
813
814 output_buffer[0] = 'O';
815 mem2hex(&output_buffer[1], (unsigned char *)str, len);
816 putpacket(output_buffer);
817
818 asm("spccont:");
819 }
820
821 /********************************** Handle exceptions ************************/
822 /* Build and send a response packet in order to inform the host the
823 stub is stopped. TAAn...:r...;n...:r...;n...:r...;
824 AA = signal number
825 n... = register number (hex)
826 r... = register contents
827 n... = `thread'
828 r... = thread process ID. This is a hex integer.
829 n... = other string not starting with valid hex digit.
830 gdb should ignore this n,r pair and go on to the next.
831 This way we can extend the protocol. */
832 static void
833 stub_is_stopped(int sigval)
834 {
835 char *ptr = output_buffer;
836 unsigned int reg_cont;
837
838 /* Send trap type (converted to signal) */
839
840 *ptr++ = 'T';
841 ptr = hex_byte_pack(ptr, sigval);
842
843 if (((reg.exs & 0xff00) >> 8) == 0xc) {
844
845 /* Some kind of hardware watchpoint triggered. Find which one
846 and determine its type (read/write/access). */
847 int S, bp, trig_bits = 0, rw_bits = 0;
848 int trig_mask = 0;
849 unsigned int *bp_d_regs = &sreg.s3_3;
850 /* In a lot of cases, the stopped data address will simply be EDA.
851 In some cases, we adjust it to match the watched data range.
852 (We don't want to change the actual EDA though). */
853 unsigned int stopped_data_address;
854 /* The S field of EXS. */
855 S = (reg.exs & 0xffff0000) >> 16;
856
857 if (S & 1) {
858 /* Instruction watchpoint. */
859 /* FIXME: Check against, and possibly adjust reported EDA. */
860 } else {
861 /* Data watchpoint. Find the one that triggered. */
862 for (bp = 0; bp < 6; bp++) {
863
864 /* Dx_RD, Dx_WR in the S field of EXS for this BP. */
865 int bitpos_trig = 1 + bp * 2;
866 /* Dx_BPRD, Dx_BPWR in BP_CTRL for this BP. */
867 int bitpos_config = 2 + bp * 4;
868
869 /* Get read/write trig bits for this BP. */
870 trig_bits = (S & (3 << bitpos_trig)) >> bitpos_trig;
871
872 /* Read/write config bits for this BP. */
873 rw_bits = (sreg.s0_3 & (3 << bitpos_config)) >> bitpos_config;
874 if (trig_bits) {
875 /* Sanity check: the BP shouldn't trigger for accesses
876 that it isn't configured for. */
877 if ((rw_bits == 0x1 && trig_bits != 0x1) ||
878 (rw_bits == 0x2 && trig_bits != 0x2))
879 panic("Invalid r/w trigging for this BP");
880
881 /* Mark this BP as trigged for future reference. */
882 trig_mask |= (1 << bp);
883
884 if (reg.eda >= bp_d_regs[bp * 2] &&
885 reg.eda <= bp_d_regs[bp * 2 + 1]) {
886 /* EDA within range for this BP; it must be the one
887 we're looking for. */
888 stopped_data_address = reg.eda;
889 break;
890 }
891 }
892 }
893 if (bp < 6) {
894 /* Found a trigged BP with EDA within its configured data range. */
895 } else if (trig_mask) {
896 /* Something triggered, but EDA doesn't match any BP's range. */
897 for (bp = 0; bp < 6; bp++) {
898 /* Dx_BPRD, Dx_BPWR in BP_CTRL for this BP. */
899 int bitpos_config = 2 + bp * 4;
900
901 /* Read/write config bits for this BP (needed later). */
902 rw_bits = (sreg.s0_3 & (3 << bitpos_config)) >> bitpos_config;
903
904 if (trig_mask & (1 << bp)) {
905 /* EDA within 31 bytes of the configured start address? */
906 if (reg.eda + 31 >= bp_d_regs[bp * 2]) {
907 /* Changing the reported address to match
908 the start address of the first applicable BP. */
909 stopped_data_address = bp_d_regs[bp * 2];
910 break;
911 } else {
912 /* We continue since we might find another useful BP. */
913 printk("EDA doesn't match trigged BP's range");
914 }
915 }
916 }
917 }
918
919 /* No match yet? */
920 BUG_ON(bp >= 6);
921 /* Note that we report the type according to what the BP is configured
922 for (otherwise we'd never report an 'awatch'), not according to how
923 it trigged. We did check that the trigged bits match what the BP is
924 configured for though. */
925 if (rw_bits == 0x1) {
926 /* read */
927 strncpy(ptr, "rwatch", 6);
928 ptr += 6;
929 } else if (rw_bits == 0x2) {
930 /* write */
931 strncpy(ptr, "watch", 5);
932 ptr += 5;
933 } else if (rw_bits == 0x3) {
934 /* access */
935 strncpy(ptr, "awatch", 6);
936 ptr += 6;
937 } else {
938 panic("Invalid r/w bits for this BP.");
939 }
940
941 *ptr++ = ':';
942 /* Note that we don't read_register(EDA, ...) */
943 ptr = mem2hex_nbo(ptr, (unsigned char *)&stopped_data_address, register_size[EDA]);
944 *ptr++ = ';';
945 }
946 }
947 /* Only send PC, frame and stack pointer. */
948 read_register(PC, &reg_cont);
949 ptr = hex_byte_pack(ptr, PC);
950 *ptr++ = ':';
951 ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[PC]);
952 *ptr++ = ';';
953
954 read_register(R8, &reg_cont);
955 ptr = hex_byte_pack(ptr, R8);
956 *ptr++ = ':';
957 ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[R8]);
958 *ptr++ = ';';
959
960 read_register(SP, &reg_cont);
961 ptr = hex_byte_pack(ptr, SP);
962 *ptr++ = ':';
963 ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[SP]);
964 *ptr++ = ';';
965
966 /* Send ERP as well; this will save us an entire register fetch in some cases. */
967 read_register(ERP, &reg_cont);
968 ptr = hex_byte_pack(ptr, ERP);
969 *ptr++ = ':';
970 ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[ERP]);
971 *ptr++ = ';';
972
973 /* null-terminate and send it off */
974 *ptr = 0;
975 putpacket(output_buffer);
976 }
977
978 /* Returns the size of an instruction that has a delay slot. */
979
980 int insn_size(unsigned long pc)
981 {
982 unsigned short opcode = *(unsigned short *)pc;
983 int size = 0;
984
985 switch ((opcode & 0x0f00) >> 8) {
986 case 0x0:
987 case 0x9:
988 case 0xb:
989 size = 2;
990 break;
991 case 0xe:
992 case 0xf:
993 size = 6;
994 break;
995 case 0xd:
996 /* Could be 4 or 6; check more bits. */
997 if ((opcode & 0xff) == 0xff)
998 size = 4;
999 else
1000 size = 6;
1001 break;
1002 default:
1003 panic("Couldn't find size of opcode 0x%x at 0x%lx\n", opcode, pc);
1004 }
1005
1006 return size;
1007 }
1008
1009 void register_fixup(int sigval)
1010 {
1011 /* Compensate for ACR push at the beginning of exception handler. */
1012 reg.sp += 4;
1013
1014 /* Standard case. */
1015 reg.pc = reg.erp;
1016 if (reg.erp & 0x1) {
1017 /* Delay slot bit set. Report as stopped on proper instruction. */
1018 if (reg.spc) {
1019 /* Rely on SPC if set. */
1020 reg.pc = reg.spc;
1021 } else {
1022 /* Calculate the PC from the size of the instruction
1023 that the delay slot we're in belongs to. */
1024 reg.pc += insn_size(reg.erp & ~1) - 1 ;
1025 }
1026 }
1027
1028 if ((reg.exs & 0x3) == 0x0) {
1029 /* Bits 1 - 0 indicate the type of memory operation performed
1030 by the interrupted instruction. 0 means no memory operation,
1031 and EDA is undefined in that case. We zero it to avoid confusion. */
1032 reg.eda = 0;
1033 }
1034
1035 if (sigval == SIGTRAP) {
1036 /* Break 8, single step or hardware breakpoint exception. */
1037
1038 /* Check IDX field of EXS. */
1039 if (((reg.exs & 0xff00) >> 8) == 0x18) {
1040
1041 /* Break 8. */
1042
1043 /* Static (compiled) breakpoints must return to the next instruction
1044 in order to avoid infinite loops (default value of ERP). Dynamic
1045 (gdb-invoked) must subtract the size of the break instruction from
1046 the ERP so that the instruction that was originally in the break
1047 instruction's place will be run when we return from the exception. */
1048 if (!dynamic_bp) {
1049 /* Assuming that all breakpoints are dynamic from now on. */
1050 dynamic_bp = 1;
1051 } else {
1052
1053 /* Only if not in a delay slot. */
1054 if (!(reg.erp & 0x1)) {
1055 reg.erp -= 2;
1056 reg.pc -= 2;
1057 }
1058 }
1059
1060 } else if (((reg.exs & 0xff00) >> 8) == 0x3) {
1061 /* Single step. */
1062 /* Don't fiddle with S1. */
1063
1064 } else if (((reg.exs & 0xff00) >> 8) == 0xc) {
1065
1066 /* Hardware watchpoint exception. */
1067
1068 /* SPC has been updated so that we will get a single step exception
1069 when we return, but we don't want that. */
1070 reg.spc = 0;
1071
1072 /* Don't fiddle with S1. */
1073 }
1074
1075 } else if (sigval == SIGINT) {
1076 /* Nothing special. */
1077 }
1078 }
1079
1080 static void insert_watchpoint(char type, int addr, int len)
1081 {
1082 /* Breakpoint/watchpoint types (GDB terminology):
1083 0 = memory breakpoint for instructions
1084 (not supported; done via memory write instead)
1085 1 = hardware breakpoint for instructions (supported)
1086 2 = write watchpoint (supported)
1087 3 = read watchpoint (supported)
1088 4 = access watchpoint (supported) */
1089
1090 if (type < '1' || type > '4') {
1091 output_buffer[0] = 0;
1092 return;
1093 }
1094
1095 /* Read watchpoints are set as access watchpoints, because of GDB's
1096 inability to deal with pure read watchpoints. */
1097 if (type == '3')
1098 type = '4';
1099
1100 if (type == '1') {
1101 /* Hardware (instruction) breakpoint. */
1102 /* Bit 0 in BP_CTRL holds the configuration for I0. */
1103 if (sreg.s0_3 & 0x1) {
1104 /* Already in use. */
1105 gdb_cris_strcpy(output_buffer, error_message[E04]);
1106 return;
1107 }
1108 /* Configure. */
1109 sreg.s1_3 = addr;
1110 sreg.s2_3 = (addr + len - 1);
1111 sreg.s0_3 |= 1;
1112 } else {
1113 int bp;
1114 unsigned int *bp_d_regs = &sreg.s3_3;
1115
1116 /* The watchpoint allocation scheme is the simplest possible.
1117 For example, if a region is watched for read and
1118 a write watch is requested, a new watchpoint will
1119 be used. Also, if a watch for a region that is already
1120 covered by one or more existing watchpoints, a new
1121 watchpoint will be used. */
1122
1123 /* First, find a free data watchpoint. */
1124 for (bp = 0; bp < 6; bp++) {
1125 /* Each data watchpoint's control registers occupy 2 bits
1126 (hence the 3), starting at bit 2 for D0 (hence the 2)
1127 with 4 bits between for each watchpoint (yes, the 4). */
1128 if (!(sreg.s0_3 & (0x3 << (2 + (bp * 4))))) {
1129 break;
1130 }
1131 }
1132
1133 if (bp > 5) {
1134 /* We're out of watchpoints. */
1135 gdb_cris_strcpy(output_buffer, error_message[E04]);
1136 return;
1137 }
1138
1139 /* Configure the control register first. */
1140 if (type == '3' || type == '4') {
1141 /* Trigger on read. */
1142 sreg.s0_3 |= (1 << (2 + bp * 4));
1143 }
1144 if (type == '2' || type == '4') {
1145 /* Trigger on write. */
1146 sreg.s0_3 |= (2 << (2 + bp * 4));
1147 }
1148
1149 /* Ugly pointer arithmetics to configure the watched range. */
1150 bp_d_regs[bp * 2] = addr;
1151 bp_d_regs[bp * 2 + 1] = (addr + len - 1);
1152 }
1153
1154 /* Set the S1 flag to enable watchpoints. */
1155 reg.ccs |= (1 << (S_CCS_BITNR + CCS_SHIFT));
1156 gdb_cris_strcpy(output_buffer, "OK");
1157 }
1158
1159 static void remove_watchpoint(char type, int addr, int len)
1160 {
1161 /* Breakpoint/watchpoint types:
1162 0 = memory breakpoint for instructions
1163 (not supported; done via memory write instead)
1164 1 = hardware breakpoint for instructions (supported)
1165 2 = write watchpoint (supported)
1166 3 = read watchpoint (supported)
1167 4 = access watchpoint (supported) */
1168 if (type < '1' || type > '4') {
1169 output_buffer[0] = 0;
1170 return;
1171 }
1172
1173 /* Read watchpoints are set as access watchpoints, because of GDB's
1174 inability to deal with pure read watchpoints. */
1175 if (type == '3')
1176 type = '4';
1177
1178 if (type == '1') {
1179 /* Hardware breakpoint. */
1180 /* Bit 0 in BP_CTRL holds the configuration for I0. */
1181 if (!(sreg.s0_3 & 0x1)) {
1182 /* Not in use. */
1183 gdb_cris_strcpy(output_buffer, error_message[E04]);
1184 return;
1185 }
1186 /* Deconfigure. */
1187 sreg.s1_3 = 0;
1188 sreg.s2_3 = 0;
1189 sreg.s0_3 &= ~1;
1190 } else {
1191 int bp;
1192 unsigned int *bp_d_regs = &sreg.s3_3;
1193 /* Try to find a watchpoint that is configured for the
1194 specified range, then check that read/write also matches. */
1195
1196 /* Ugly pointer arithmetic, since I cannot rely on a
1197 single switch (addr) as there may be several watchpoints with
1198 the same start address for example. */
1199
1200 for (bp = 0; bp < 6; bp++) {
1201 if (bp_d_regs[bp * 2] == addr &&
1202 bp_d_regs[bp * 2 + 1] == (addr + len - 1)) {
1203 /* Matching range. */
1204 int bitpos = 2 + bp * 4;
1205 int rw_bits;
1206
1207 /* Read/write bits for this BP. */
1208 rw_bits = (sreg.s0_3 & (0x3 << bitpos)) >> bitpos;
1209
1210 if ((type == '3' && rw_bits == 0x1) ||
1211 (type == '2' && rw_bits == 0x2) ||
1212 (type == '4' && rw_bits == 0x3)) {
1213 /* Read/write matched. */
1214 break;
1215 }
1216 }
1217 }
1218
1219 if (bp > 5) {
1220 /* No watchpoint matched. */
1221 gdb_cris_strcpy(output_buffer, error_message[E04]);
1222 return;
1223 }
1224
1225 /* Found a matching watchpoint. Now, deconfigure it by
1226 both disabling read/write in bp_ctrl and zeroing its
1227 start/end addresses. */
1228 sreg.s0_3 &= ~(3 << (2 + (bp * 4)));
1229 bp_d_regs[bp * 2] = 0;
1230 bp_d_regs[bp * 2 + 1] = 0;
1231 }
1232
1233 /* Note that we don't clear the S1 flag here. It's done when continuing. */
1234 gdb_cris_strcpy(output_buffer, "OK");
1235 }
1236
1237
1238
1239 /* All expected commands are sent from remote.c. Send a response according
1240 to the description in remote.c. */
1241 void
1242 handle_exception(int sigval)
1243 {
1244 /* Avoid warning of not used. */
1245
1246 USEDFUN(handle_exception);
1247 USEDVAR(internal_stack[0]);
1248
1249 register_fixup(sigval);
1250
1251 /* Send response. */
1252 stub_is_stopped(sigval);
1253
1254 for (;;) {
1255 output_buffer[0] = '\0';
1256 getpacket(input_buffer);
1257 switch (input_buffer[0]) {
1258 case 'g':
1259 /* Read registers: g
1260 Success: Each byte of register data is described by two hex digits.
1261 Registers are in the internal order for GDB, and the bytes
1262 in a register are in the same order the machine uses.
1263 Failure: void. */
1264 {
1265 char *buf;
1266 /* General and special registers. */
1267 buf = mem2hex(output_buffer, (char *)&reg, sizeof(registers));
1268 /* Support registers. */
1269 /* -1 because of the null termination that mem2hex adds. */
1270 mem2hex(buf,
1271 (char *)&sreg + (reg.srs * 16 * sizeof(unsigned int)),
1272 16 * sizeof(unsigned int));
1273 break;
1274 }
1275 case 'G':
1276 /* Write registers. GXX..XX
1277 Each byte of register data is described by two hex digits.
1278 Success: OK
1279 Failure: E08. */
1280 /* General and special registers. */
1281 if (hex2bin((char *)&reg, &input_buffer[1], sizeof(registers)))
1282 gdb_cris_strcpy(output_buffer, error_message[E08]);
1283 /* Support registers. */
1284 else if (hex2bin((char *)&sreg + (reg.srs * 16 * sizeof(unsigned int)),
1285 &input_buffer[1] + sizeof(registers),
1286 16 * sizeof(unsigned int)))
1287 gdb_cris_strcpy(output_buffer, error_message[E08]);
1288 else
1289 gdb_cris_strcpy(output_buffer, "OK");
1290 break;
1291
1292 case 'P':
1293 /* Write register. Pn...=r...
1294 Write register n..., hex value without 0x, with value r...,
1295 which contains a hex value without 0x and two hex digits
1296 for each byte in the register (target byte order). P1f=11223344 means
1297 set register 31 to 44332211.
1298 Success: OK
1299 Failure: E02, E05 */
1300 {
1301 char *suffix;
1302 int regno = gdb_cris_strtol(&input_buffer[1], &suffix, 16);
1303 int status;
1304
1305 status = write_register(regno, suffix+1);
1306
1307 switch (status) {
1308 case E02:
1309 /* Do not support read-only registers. */
1310 gdb_cris_strcpy(output_buffer, error_message[E02]);
1311 break;
1312 case E05:
1313 /* Do not support non-existing registers. */
1314 gdb_cris_strcpy(output_buffer, error_message[E05]);
1315 break;
1316 case E08:
1317 /* Invalid parameter. */
1318 gdb_cris_strcpy(output_buffer, error_message[E08]);
1319 break;
1320 default:
1321 /* Valid register number. */
1322 gdb_cris_strcpy(output_buffer, "OK");
1323 break;
1324 }
1325 }
1326 break;
1327
1328 case 'm':
1329 /* Read from memory. mAA..AA,LLLL
1330 AA..AA is the address and LLLL is the length.
1331 Success: XX..XX is the memory content. Can be fewer bytes than
1332 requested if only part of the data may be read. m6000120a,6c means
1333 retrieve 108 byte from base address 6000120a.
1334 Failure: void. */
1335 {
1336 char *suffix;
1337 unsigned char *addr = (unsigned char *)gdb_cris_strtol(&input_buffer[1],
1338 &suffix, 16);
1339 int len = gdb_cris_strtol(suffix+1, 0, 16);
1340
1341 /* Bogus read (i.e. outside the kernel's
1342 segment)? . */
1343 if (!((unsigned int)addr >= 0xc0000000 &&
1344 (unsigned int)addr < 0xd0000000))
1345 addr = NULL;
1346
1347 mem2hex(output_buffer, addr, len);
1348 }
1349 break;
1350
1351 case 'X':
1352 /* Write to memory. XAA..AA,LLLL:XX..XX
1353 AA..AA is the start address, LLLL is the number of bytes, and
1354 XX..XX is the binary data.
1355 Success: OK
1356 Failure: void. */
1357 case 'M':
1358 /* Write to memory. MAA..AA,LLLL:XX..XX
1359 AA..AA is the start address, LLLL is the number of bytes, and
1360 XX..XX is the hexadecimal data.
1361 Success: OK
1362 Failure: E08. */
1363 {
1364 char *lenptr;
1365 char *dataptr;
1366 unsigned char *addr = (unsigned char *)gdb_cris_strtol(&input_buffer[1],
1367 &lenptr, 16);
1368 int len = gdb_cris_strtol(lenptr+1, &dataptr, 16);
1369 if (*lenptr == ',' && *dataptr == ':') {
1370 if (input_buffer[0] == 'M') {
1371 if (hex2bin(addr, dataptr + 1, len))
1372 gdb_cris_strcpy(output_buffer, error_message[E08]);
1373 else
1374 gdb_cris_strcpy(output_buffer, "OK");
1375 } else /* X */ {
1376 bin2mem(addr, dataptr + 1, len);
1377 gdb_cris_strcpy(output_buffer, "OK");
1378 }
1379 } else {
1380 gdb_cris_strcpy(output_buffer, error_message[E06]);
1381 }
1382 }
1383 break;
1384
1385 case 'c':
1386 /* Continue execution. cAA..AA
1387 AA..AA is the address where execution is resumed. If AA..AA is
1388 omitted, resume at the present address.
1389 Success: return to the executing thread.
1390 Failure: will never know. */
1391
1392 if (input_buffer[1] != '\0') {
1393 /* FIXME: Doesn't handle address argument. */
1394 gdb_cris_strcpy(output_buffer, error_message[E04]);
1395 break;
1396 }
1397
1398 /* Before continuing, make sure everything is set up correctly. */
1399
1400 /* Set the SPC to some unlikely value. */
1401 reg.spc = 0;
1402 /* Set the S1 flag to 0 unless some watchpoint is enabled (since setting
1403 S1 to 0 would also disable watchpoints). (Note that bits 26-31 in BP_CTRL
1404 are reserved, so don't check against those). */
1405 if ((sreg.s0_3 & 0x3fff) == 0) {
1406 reg.ccs &= ~(1 << (S_CCS_BITNR + CCS_SHIFT));
1407 }
1408
1409 return;
1410
1411 case 's':
1412 /* Step. sAA..AA
1413 AA..AA is the address where execution is resumed. If AA..AA is
1414 omitted, resume at the present address. Success: return to the
1415 executing thread. Failure: will never know. */
1416
1417 if (input_buffer[1] != '\0') {
1418 /* FIXME: Doesn't handle address argument. */
1419 gdb_cris_strcpy(output_buffer, error_message[E04]);
1420 break;
1421 }
1422
1423 /* Set the SPC to PC, which is where we'll return
1424 (deduced previously). */
1425 reg.spc = reg.pc;
1426
1427 /* Set the S1 (first stacked, not current) flag, which will
1428 kick into action when we rfe. */
1429 reg.ccs |= (1 << (S_CCS_BITNR + CCS_SHIFT));
1430 return;
1431
1432 case 'Z':
1433
1434 /* Insert breakpoint or watchpoint, Ztype,addr,length.
1435 Remote protocol says: A remote target shall return an empty string
1436 for an unrecognized breakpoint or watchpoint packet type. */
1437 {
1438 char *lenptr;
1439 char *dataptr;
1440 int addr = gdb_cris_strtol(&input_buffer[3], &lenptr, 16);
1441 int len = gdb_cris_strtol(lenptr + 1, &dataptr, 16);
1442 char type = input_buffer[1];
1443
1444 insert_watchpoint(type, addr, len);
1445 break;
1446 }
1447
1448 case 'z':
1449 /* Remove breakpoint or watchpoint, Ztype,addr,length.
1450 Remote protocol says: A remote target shall return an empty string
1451 for an unrecognized breakpoint or watchpoint packet type. */
1452 {
1453 char *lenptr;
1454 char *dataptr;
1455 int addr = gdb_cris_strtol(&input_buffer[3], &lenptr, 16);
1456 int len = gdb_cris_strtol(lenptr + 1, &dataptr, 16);
1457 char type = input_buffer[1];
1458
1459 remove_watchpoint(type, addr, len);
1460 break;
1461 }
1462
1463
1464 case '?':
1465 /* The last signal which caused a stop. ?
1466 Success: SAA, where AA is the signal number.
1467 Failure: void. */
1468 output_buffer[0] = 'S';
1469 output_buffer[1] = hex_asc_hi(sigval);
1470 output_buffer[2] = hex_asc_lo(sigval);
1471 output_buffer[3] = 0;
1472 break;
1473
1474 case 'D':
1475 /* Detach from host. D
1476 Success: OK, and return to the executing thread.
1477 Failure: will never know */
1478 putpacket("OK");
1479 return;
1480
1481 case 'k':
1482 case 'r':
1483 /* kill request or reset request.
1484 Success: restart of target.
1485 Failure: will never know. */
1486 kill_restart();
1487 break;
1488
1489 case 'C':
1490 case 'S':
1491 case '!':
1492 case 'R':
1493 case 'd':
1494 /* Continue with signal sig. Csig;AA..AA
1495 Step with signal sig. Ssig;AA..AA
1496 Use the extended remote protocol. !
1497 Restart the target system. R0
1498 Toggle debug flag. d
1499 Search backwards. tAA:PP,MM
1500 Not supported: E04 */
1501
1502 /* FIXME: What's the difference between not supported
1503 and ignored (below)? */
1504 gdb_cris_strcpy(output_buffer, error_message[E04]);
1505 break;
1506
1507 default:
1508 /* The stub should ignore other request and send an empty
1509 response ($#<checksum>). This way we can extend the protocol and GDB
1510 can tell whether the stub it is talking to uses the old or the new. */
1511 output_buffer[0] = 0;
1512 break;
1513 }
1514 putpacket(output_buffer);
1515 }
1516 }
1517
1518 void
1519 kgdb_init(void)
1520 {
1521 reg_intr_vect_rw_mask intr_mask;
1522 reg_ser_rw_intr_mask ser_intr_mask;
1523
1524 /* Configure the kgdb serial port. */
1525 #if defined(CONFIG_ETRAX_KGDB_PORT0)
1526 /* Note: no shortcut registered (not handled by multiple_interrupt).
1527 See entry.S. */
1528 set_exception_vector(SER0_INTR_VECT, kgdb_handle_exception);
1529 /* Enable the ser irq in the global config. */
1530 intr_mask = REG_RD(intr_vect, regi_irq, rw_mask);
1531 intr_mask.ser0 = 1;
1532 REG_WR(intr_vect, regi_irq, rw_mask, intr_mask);
1533
1534 ser_intr_mask = REG_RD(ser, regi_ser0, rw_intr_mask);
1535 ser_intr_mask.dav = regk_ser_yes;
1536 REG_WR(ser, regi_ser0, rw_intr_mask, ser_intr_mask);
1537 #elif defined(CONFIG_ETRAX_KGDB_PORT1)
1538 /* Note: no shortcut registered (not handled by multiple_interrupt).
1539 See entry.S. */
1540 set_exception_vector(SER1_INTR_VECT, kgdb_handle_exception);
1541 /* Enable the ser irq in the global config. */
1542 intr_mask = REG_RD(intr_vect, regi_irq, rw_mask);
1543 intr_mask.ser1 = 1;
1544 REG_WR(intr_vect, regi_irq, rw_mask, intr_mask);
1545
1546 ser_intr_mask = REG_RD(ser, regi_ser1, rw_intr_mask);
1547 ser_intr_mask.dav = regk_ser_yes;
1548 REG_WR(ser, regi_ser1, rw_intr_mask, ser_intr_mask);
1549 #elif defined(CONFIG_ETRAX_KGDB_PORT2)
1550 /* Note: no shortcut registered (not handled by multiple_interrupt).
1551 See entry.S. */
1552 set_exception_vector(SER2_INTR_VECT, kgdb_handle_exception);
1553 /* Enable the ser irq in the global config. */
1554 intr_mask = REG_RD(intr_vect, regi_irq, rw_mask);
1555 intr_mask.ser2 = 1;
1556 REG_WR(intr_vect, regi_irq, rw_mask, intr_mask);
1557
1558 ser_intr_mask = REG_RD(ser, regi_ser2, rw_intr_mask);
1559 ser_intr_mask.dav = regk_ser_yes;
1560 REG_WR(ser, regi_ser2, rw_intr_mask, ser_intr_mask);
1561 #elif defined(CONFIG_ETRAX_KGDB_PORT3)
1562 /* Note: no shortcut registered (not handled by multiple_interrupt).
1563 See entry.S. */
1564 set_exception_vector(SER3_INTR_VECT, kgdb_handle_exception);
1565 /* Enable the ser irq in the global config. */
1566 intr_mask = REG_RD(intr_vect, regi_irq, rw_mask);
1567 intr_mask.ser3 = 1;
1568 REG_WR(intr_vect, regi_irq, rw_mask, intr_mask);
1569
1570 ser_intr_mask = REG_RD(ser, regi_ser3, rw_intr_mask);
1571 ser_intr_mask.dav = regk_ser_yes;
1572 REG_WR(ser, regi_ser3, rw_intr_mask, ser_intr_mask);
1573 #endif
1574
1575 }
1576 /* Performs a complete re-start from scratch. */
1577 static void
1578 kill_restart(void)
1579 {
1580 machine_restart("");
1581 }
1582
1583 /* Use this static breakpoint in the start-up only. */
1584
1585 void
1586 breakpoint(void)
1587 {
1588 kgdb_started = 1;
1589 dynamic_bp = 0; /* This is a static, not a dynamic breakpoint. */
1590 __asm__ volatile ("break 8"); /* Jump to kgdb_handle_breakpoint. */
1591 }
1592
1593 /****************************** End of file **********************************/
CRIS linux kernel tree