Merge git://git.kernel.org/pub/scm/linux/kernel/git/sam/kbuild-next
[linux-2.6] / arch / mn10300 / kernel / gdb-stub.c
1 /* MN10300 GDB stub
2  *
3  * Originally written by Glenn Engel, Lake Stevens Instrument Division
4  *
5  * Contributed by HP Systems
6  *
7  * Modified for SPARC by Stu Grossman, Cygnus Support.
8  *
9  * Modified for Linux/MIPS (and MIPS in general) by Andreas Busse
10  * Send complaints, suggestions etc. to <andy@waldorf-gmbh.de>
11  *
12  * Copyright (C) 1995 Andreas Busse
13  *
14  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
15  * Modified for Linux/mn10300 by David Howells <dhowells@redhat.com>
16  */
17
18 /*
19  *  To enable debugger support, two things need to happen.  One, a
20  *  call to set_debug_traps() is necessary in order to allow any breakpoints
21  *  or error conditions to be properly intercepted and reported to gdb.
22  *  Two, a breakpoint needs to be generated to begin communication.  This
23  *  is most easily accomplished by a call to breakpoint().  Breakpoint()
24  *  simulates a breakpoint by executing a BREAK instruction.
25  *
26  *
27  *    The following gdb commands are supported:
28  *
29  * command          function                               Return value
30  *
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
33  *
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  *
37  *    c             Resume at current address              SNN   ( signal NN)
38  *    cAA..AA       Continue at address AA..AA             SNN
39  *
40  *    s             Step one instruction                   SNN
41  *    sAA..AA       Step one instruction from AA..AA       SNN
42  *
43  *    k             kill
44  *
45  *    ?             What was the last sigval ?             SNN   (signal NN)
46  *
47  *    bBB..BB       Set baud rate to BB..BB                OK or BNN, then sets
48  *                                                         baud rate
49  *
50  * All commands and responses are sent with a packet which includes a
51  * checksum.  A packet consists of
52  *
53  * $<packet info>#<checksum>.
54  *
55  * where
56  * <packet info> :: <characters representing the command or response>
57  * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
58  *
59  * When a packet is received, it is first acknowledged with either '+' or '-'.
60  * '+' indicates a successful transfer.  '-' indicates a failed transfer.
61  *
62  * Example:
63  *
64  * Host:                  Reply:
65  * $m0,10#2a               +$00010203040506070809101112131415#42
66  *
67  *
68  *  ==============
69  *  MORE EXAMPLES:
70  *  ==============
71  *
72  *  For reference -- the following are the steps that one
73  *  company took (RidgeRun Inc) to get remote gdb debugging
74  *  going. In this scenario the host machine was a PC and the
75  *  target platform was a Galileo EVB64120A MIPS evaluation
76  *  board.
77  *
78  *  Step 1:
79  *  First download gdb-5.0.tar.gz from the internet.
80  *  and then build/install the package.
81  *
82  *  Example:
83  *    $ tar zxf gdb-5.0.tar.gz
84  *    $ cd gdb-5.0
85  *    $ ./configure --target=am33_2.0-linux-gnu
86  *    $ make
87  *    $ install
88  *    am33_2.0-linux-gnu-gdb
89  *
90  *  Step 2:
91  *  Configure linux for remote debugging and build it.
92  *
93  *  Example:
94  *    $ cd ~/linux
95  *    $ make menuconfig <go to "Kernel Hacking" and turn on remote debugging>
96  *    $ make dep; make vmlinux
97  *
98  *  Step 3:
99  *  Download the kernel to the remote target and start
100  *  the kernel running. It will promptly halt and wait
101  *  for the host gdb session to connect. It does this
102  *  since the "Kernel Hacking" option has defined
103  *  CONFIG_REMOTE_DEBUG which in turn enables your calls
104  *  to:
105  *     set_debug_traps();
106  *     breakpoint();
107  *
108  *  Step 4:
109  *  Start the gdb session on the host.
110  *
111  *  Example:
112  *    $ am33_2.0-linux-gnu-gdb vmlinux
113  *    (gdb) set remotebaud 115200
114  *    (gdb) target remote /dev/ttyS1
115  *    ...at this point you are connected to
116  *       the remote target and can use gdb
117  *       in the normal fasion. Setting
118  *       breakpoints, single stepping,
119  *       printing variables, etc.
120  *
121  */
122
123 #include <linux/string.h>
124 #include <linux/kernel.h>
125 #include <linux/signal.h>
126 #include <linux/sched.h>
127 #include <linux/mm.h>
128 #include <linux/console.h>
129 #include <linux/init.h>
130 #include <linux/bug.h>
131
132 #include <asm/pgtable.h>
133 #include <asm/system.h>
134 #include <asm/gdb-stub.h>
135 #include <asm/exceptions.h>
136 #include <asm/cacheflush.h>
137 #include <asm/serial-regs.h>
138 #include <asm/busctl-regs.h>
139 #include <asm/unit/leds.h>
140 #include <asm/unit/serial.h>
141
142 /* define to use F7F7 rather than FF which is subverted by JTAG debugger */
143 #undef GDBSTUB_USE_F7F7_AS_BREAKPOINT
144
145 /*
146  * BUFMAX defines the maximum number of characters in inbound/outbound buffers
147  * at least NUMREGBYTES*2 are needed for register packets
148  */
149 #define BUFMAX 2048
150
151 static const char gdbstub_banner[] =
152         "Linux/MN10300 GDB Stub (c) RedHat 2007\n";
153
154 u8      gdbstub_rx_buffer[PAGE_SIZE] __attribute__((aligned(PAGE_SIZE)));
155 u32     gdbstub_rx_inp;
156 u32     gdbstub_rx_outp;
157 u8      gdbstub_busy;
158 u8      gdbstub_rx_overflow;
159 u8      gdbstub_rx_unget;
160
161 static u8       gdbstub_flush_caches;
162 static char     input_buffer[BUFMAX];
163 static char     output_buffer[BUFMAX];
164 static char     trans_buffer[BUFMAX];
165
166 struct gdbstub_bkpt {
167         u8      *addr;          /* address of breakpoint */
168         u8      len;            /* size of breakpoint */
169         u8      origbytes[7];   /* original bytes */
170 };
171
172 static struct gdbstub_bkpt gdbstub_bkpts[256];
173
174 /*
175  * local prototypes
176  */
177 static void getpacket(char *buffer);
178 static int putpacket(char *buffer);
179 static int computeSignal(enum exception_code excep);
180 static int hex(unsigned char ch);
181 static int hexToInt(char **ptr, int *intValue);
182 static unsigned char *mem2hex(const void *mem, char *buf, int count,
183                               int may_fault);
184 static const char *hex2mem(const char *buf, void *_mem, int count,
185                            int may_fault);
186
187 /*
188  * Convert ch from a hex digit to an int
189  */
190 static int hex(unsigned char ch)
191 {
192         if (ch >= 'a' && ch <= 'f')
193                 return ch - 'a' + 10;
194         if (ch >= '0' && ch <= '9')
195                 return ch - '0';
196         if (ch >= 'A' && ch <= 'F')
197                 return ch - 'A' + 10;
198         return -1;
199 }
200
201 #ifdef CONFIG_GDBSTUB_DEBUGGING
202
203 void debug_to_serial(const char *p, int n)
204 {
205         __debug_to_serial(p, n);
206         /* gdbstub_console_write(NULL, p, n); */
207 }
208
209 void gdbstub_printk(const char *fmt, ...)
210 {
211         va_list args;
212         int len;
213
214         /* Emit the output into the temporary buffer */
215         va_start(args, fmt);
216         len = vsnprintf(trans_buffer, sizeof(trans_buffer), fmt, args);
217         va_end(args);
218         debug_to_serial(trans_buffer, len);
219 }
220
221 #endif
222
223 static inline char *gdbstub_strcpy(char *dst, const char *src)
224 {
225         int loop = 0;
226         while ((dst[loop] = src[loop]))
227                loop++;
228         return dst;
229 }
230
231 /*
232  * scan for the sequence $<data>#<checksum>
233  */
234 static void getpacket(char *buffer)
235 {
236         unsigned char checksum;
237         unsigned char xmitcsum;
238         unsigned char ch;
239         int count, i, ret, error;
240
241         for (;;) {
242                 /*
243                  * wait around for the start character,
244                  * ignore all other characters
245                  */
246                 do {
247                         gdbstub_io_rx_char(&ch, 0);
248                 } while (ch != '$');
249
250                 checksum = 0;
251                 xmitcsum = -1;
252                 count = 0;
253                 error = 0;
254
255                 /*
256                  * now, read until a # or end of buffer is found
257                  */
258                 while (count < BUFMAX) {
259                         ret = gdbstub_io_rx_char(&ch, 0);
260                         if (ret < 0)
261                                 error = ret;
262
263                         if (ch == '#')
264                                 break;
265                         checksum += ch;
266                         buffer[count] = ch;
267                         count++;
268                 }
269
270                 if (error == -EIO) {
271                         gdbstub_proto("### GDB Rx Error - Skipping packet"
272                                       " ###\n");
273                         gdbstub_proto("### GDB Tx NAK\n");
274                         gdbstub_io_tx_char('-');
275                         continue;
276                 }
277
278                 if (count >= BUFMAX || error)
279                         continue;
280
281                 buffer[count] = 0;
282
283                 /* read the checksum */
284                 ret = gdbstub_io_rx_char(&ch, 0);
285                 if (ret < 0)
286                         error = ret;
287                 xmitcsum = hex(ch) << 4;
288
289                 ret = gdbstub_io_rx_char(&ch, 0);
290                 if (ret < 0)
291                         error = ret;
292                 xmitcsum |= hex(ch);
293
294                 if (error) {
295                         if (error == -EIO)
296                                 gdbstub_io("### GDB Rx Error -"
297                                            " Skipping packet\n");
298                         gdbstub_io("### GDB Tx NAK\n");
299                         gdbstub_io_tx_char('-');
300                         continue;
301                 }
302
303                 /* check the checksum */
304                 if (checksum != xmitcsum) {
305                         gdbstub_io("### GDB Tx NAK\n");
306                         gdbstub_io_tx_char('-');        /* failed checksum */
307                         continue;
308                 }
309
310                 gdbstub_proto("### GDB Rx '$%s#%02x' ###\n", buffer, checksum);
311                 gdbstub_io("### GDB Tx ACK\n");
312                 gdbstub_io_tx_char('+'); /* successful transfer */
313
314                 /*
315                  * if a sequence char is present,
316                  * reply the sequence ID
317                  */
318                 if (buffer[2] == ':') {
319                         gdbstub_io_tx_char(buffer[0]);
320                         gdbstub_io_tx_char(buffer[1]);
321
322                         /*
323                          * remove sequence chars from buffer
324                          */
325                         count = 0;
326                         while (buffer[count])
327                                 count++;
328                         for (i = 3; i <= count; i++)
329                                 buffer[i - 3] = buffer[i];
330                 }
331
332                 break;
333         }
334 }
335
336 /*
337  * send the packet in buffer.
338  * - return 0 if successfully ACK'd
339  * - return 1 if abandoned due to new incoming packet
340  */
341 static int putpacket(char *buffer)
342 {
343         unsigned char checksum;
344         unsigned char ch;
345         int count;
346
347         /*
348          * $<packet info>#<checksum>.
349          */
350         gdbstub_proto("### GDB Tx $'%s'#?? ###\n", buffer);
351
352         do {
353                 gdbstub_io_tx_char('$');
354                 checksum = 0;
355                 count = 0;
356
357                 while ((ch = buffer[count]) != 0) {
358                         gdbstub_io_tx_char(ch);
359                         checksum += ch;
360                         count += 1;
361                 }
362
363                 gdbstub_io_tx_char('#');
364                 gdbstub_io_tx_char(hex_asc_hi(checksum));
365                 gdbstub_io_tx_char(hex_asc_lo(checksum));
366
367         } while (gdbstub_io_rx_char(&ch, 0),
368                  ch == '-' && (gdbstub_io("### GDB Rx NAK\n"), 0),
369                  ch != '-' && ch != '+' &&
370                  (gdbstub_io("### GDB Rx ??? %02x\n", ch), 0),
371                  ch != '+' && ch != '$');
372
373         if (ch == '+') {
374                 gdbstub_io("### GDB Rx ACK\n");
375                 return 0;
376         }
377
378         gdbstub_io("### GDB Tx Abandoned\n");
379         gdbstub_rx_unget = ch;
380         return 1;
381 }
382
383 /*
384  * While we find nice hex chars, build an int.
385  * Return number of chars processed.
386  */
387 static int hexToInt(char **ptr, int *intValue)
388 {
389         int numChars = 0;
390         int hexValue;
391
392         *intValue = 0;
393
394         while (**ptr) {
395                 hexValue = hex(**ptr);
396                 if (hexValue < 0)
397                         break;
398
399                 *intValue = (*intValue << 4) | hexValue;
400                 numChars++;
401
402                 (*ptr)++;
403         }
404
405         return (numChars);
406 }
407
408 /*
409  * We single-step by setting breakpoints. When an exception
410  * is handled, we need to restore the instructions hoisted
411  * when the breakpoints were set.
412  *
413  * This is where we save the original instructions.
414  */
415 static struct gdb_bp_save {
416         u8      *addr;
417         u8      opcode[2];
418 } step_bp[2];
419
420 static const unsigned char gdbstub_insn_sizes[256] =
421 {
422         /* 1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
423         1, 3, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3, /* 0 */
424         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 1 */
425         2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, /* 2 */
426         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, /* 3 */
427         1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, /* 4 */
428         1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, /* 5 */
429         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6 */
430         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 7 */
431         2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* 8 */
432         2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* 9 */
433         2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* a */
434         2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* b */
435         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 2, /* c */
436         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* d */
437         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* e */
438         0, 2, 2, 2, 2, 2, 2, 4, 0, 3, 0, 4, 0, 6, 7, 1  /* f */
439 };
440
441 static int __gdbstub_mark_bp(u8 *addr, int ix)
442 {
443         if (addr < (u8 *) 0x70000000UL)
444                 return 0;
445         /* 70000000-7fffffff: vmalloc area */
446         if (addr < (u8 *) 0x80000000UL)
447                 goto okay;
448         if (addr < (u8 *) 0x8c000000UL)
449                 return 0;
450         /* 8c000000-93ffffff: SRAM, SDRAM */
451         if (addr < (u8 *) 0x94000000UL)
452                 goto okay;
453         return 0;
454
455 okay:
456         if (gdbstub_read_byte(addr + 0, &step_bp[ix].opcode[0]) < 0 ||
457             gdbstub_read_byte(addr + 1, &step_bp[ix].opcode[1]) < 0)
458                 return 0;
459
460         step_bp[ix].addr = addr;
461         return 1;
462 }
463
464 static inline void __gdbstub_restore_bp(void)
465 {
466 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
467         if (step_bp[0].addr) {
468                 gdbstub_write_byte(step_bp[0].opcode[0], step_bp[0].addr + 0);
469                 gdbstub_write_byte(step_bp[0].opcode[1], step_bp[0].addr + 1);
470         }
471         if (step_bp[1].addr) {
472                 gdbstub_write_byte(step_bp[1].opcode[0], step_bp[1].addr + 0);
473                 gdbstub_write_byte(step_bp[1].opcode[1], step_bp[1].addr + 1);
474         }
475 #else
476         if (step_bp[0].addr)
477                 gdbstub_write_byte(step_bp[0].opcode[0], step_bp[0].addr + 0);
478         if (step_bp[1].addr)
479                 gdbstub_write_byte(step_bp[1].opcode[0], step_bp[1].addr + 0);
480 #endif
481
482         gdbstub_flush_caches = 1;
483
484         step_bp[0].addr         = NULL;
485         step_bp[0].opcode[0]    = 0;
486         step_bp[0].opcode[1]    = 0;
487         step_bp[1].addr         = NULL;
488         step_bp[1].opcode[0]    = 0;
489         step_bp[1].opcode[1]    = 0;
490 }
491
492 /*
493  * emulate single stepping by means of breakpoint instructions
494  */
495 static int gdbstub_single_step(struct pt_regs *regs)
496 {
497         unsigned size;
498         uint32_t x;
499         uint8_t cur, *pc, *sp;
500
501         step_bp[0].addr         = NULL;
502         step_bp[0].opcode[0]    = 0;
503         step_bp[0].opcode[1]    = 0;
504         step_bp[1].addr         = NULL;
505         step_bp[1].opcode[0]    = 0;
506         step_bp[1].opcode[1]    = 0;
507         x = 0;
508
509         pc = (u8 *) regs->pc;
510         sp = (u8 *) (regs + 1);
511         if (gdbstub_read_byte(pc, &cur) < 0)
512                 return -EFAULT;
513
514         gdbstub_bkpt("Single Step from %p { %02x }\n", pc, cur);
515
516         gdbstub_flush_caches = 1;
517
518         size = gdbstub_insn_sizes[cur];
519         if (size > 0) {
520                 if (!__gdbstub_mark_bp(pc + size, 0))
521                         goto fault;
522         } else {
523                 switch (cur) {
524                         /* Bxx (d8,PC) */
525                 case 0xc0:
526                 case 0xc1:
527                 case 0xc2:
528                 case 0xc3:
529                 case 0xc4:
530                 case 0xc5:
531                 case 0xc6:
532                 case 0xc7:
533                 case 0xc8:
534                 case 0xc9:
535                 case 0xca:
536                         if (gdbstub_read_byte(pc + 1, (u8 *) &x) < 0)
537                                 goto fault;
538                         if (!__gdbstub_mark_bp(pc + 2, 0))
539                                 goto fault;
540                         if ((x < 0 || x > 2) &&
541                             !__gdbstub_mark_bp(pc + (s8) x, 1))
542                                 goto fault;
543                         break;
544
545                         /* LXX (d8,PC) */
546                 case 0xd0:
547                 case 0xd1:
548                 case 0xd2:
549                 case 0xd3:
550                 case 0xd4:
551                 case 0xd5:
552                 case 0xd6:
553                 case 0xd7:
554                 case 0xd8:
555                 case 0xd9:
556                 case 0xda:
557                         if (!__gdbstub_mark_bp(pc + 1, 0))
558                                 goto fault;
559                         if (regs->pc != regs->lar &&
560                             !__gdbstub_mark_bp((u8 *) regs->lar, 1))
561                                 goto fault;
562                         break;
563
564                         /* SETLB - loads the next for bytes into the LIR
565                          * register */
566                 case 0xdb:
567                         if (!__gdbstub_mark_bp(pc + 1, 0))
568                                 goto fault;
569                         break;
570
571                         /* JMP (d16,PC) or CALL (d16,PC) */
572                 case 0xcc:
573                 case 0xcd:
574                         if (gdbstub_read_byte(pc + 1, ((u8 *) &x) + 0) < 0 ||
575                             gdbstub_read_byte(pc + 2, ((u8 *) &x) + 1) < 0)
576                                 goto fault;
577                         if (!__gdbstub_mark_bp(pc + (s16) x, 0))
578                                 goto fault;
579                         break;
580
581                         /* JMP (d32,PC) or CALL (d32,PC) */
582                 case 0xdc:
583                 case 0xdd:
584                         if (gdbstub_read_byte(pc + 1, ((u8 *) &x) + 0) < 0 ||
585                             gdbstub_read_byte(pc + 2, ((u8 *) &x) + 1) < 0 ||
586                             gdbstub_read_byte(pc + 3, ((u8 *) &x) + 2) < 0 ||
587                             gdbstub_read_byte(pc + 4, ((u8 *) &x) + 3) < 0)
588                                 goto fault;
589                         if (!__gdbstub_mark_bp(pc + (s32) x, 0))
590                                 goto fault;
591                         break;
592
593                         /* RETF */
594                 case 0xde:
595                         if (!__gdbstub_mark_bp((u8 *) regs->mdr, 0))
596                                 goto fault;
597                         break;
598
599                         /* RET */
600                 case 0xdf:
601                         if (gdbstub_read_byte(pc + 2, (u8 *) &x) < 0)
602                                 goto fault;
603                         sp += (s8)x;
604                         if (gdbstub_read_byte(sp + 0, ((u8 *) &x) + 0) < 0 ||
605                             gdbstub_read_byte(sp + 1, ((u8 *) &x) + 1) < 0 ||
606                             gdbstub_read_byte(sp + 2, ((u8 *) &x) + 2) < 0 ||
607                             gdbstub_read_byte(sp + 3, ((u8 *) &x) + 3) < 0)
608                                 goto fault;
609                         if (!__gdbstub_mark_bp((u8 *) x, 0))
610                                 goto fault;
611                         break;
612
613                 case 0xf0:
614                         if (gdbstub_read_byte(pc + 1, &cur) < 0)
615                                 goto fault;
616
617                         if (cur >= 0xf0 && cur <= 0xf7) {
618                                 /* JMP (An) / CALLS (An) */
619                                 switch (cur & 3) {
620                                 case 0: x = regs->a0; break;
621                                 case 1: x = regs->a1; break;
622                                 case 2: x = regs->a2; break;
623                                 case 3: x = regs->a3; break;
624                                 }
625                                 if (!__gdbstub_mark_bp((u8 *) x, 0))
626                                         goto fault;
627                         } else if (cur == 0xfc) {
628                                 /* RETS */
629                                 if (gdbstub_read_byte(
630                                             sp + 0, ((u8 *) &x) + 0) < 0 ||
631                                     gdbstub_read_byte(
632                                             sp + 1, ((u8 *) &x) + 1) < 0 ||
633                                     gdbstub_read_byte(
634                                             sp + 2, ((u8 *) &x) + 2) < 0 ||
635                                     gdbstub_read_byte(
636                                             sp + 3, ((u8 *) &x) + 3) < 0)
637                                         goto fault;
638                                 if (!__gdbstub_mark_bp((u8 *) x, 0))
639                                         goto fault;
640                         } else if (cur == 0xfd) {
641                                 /* RTI */
642                                 if (gdbstub_read_byte(
643                                             sp + 4, ((u8 *) &x) + 0) < 0 ||
644                                     gdbstub_read_byte(
645                                             sp + 5, ((u8 *) &x) + 1) < 0 ||
646                                     gdbstub_read_byte(
647                                             sp + 6, ((u8 *) &x) + 2) < 0 ||
648                                     gdbstub_read_byte(
649                                             sp + 7, ((u8 *) &x) + 3) < 0)
650                                         goto fault;
651                                 if (!__gdbstub_mark_bp((u8 *) x, 0))
652                                         goto fault;
653                         } else {
654                                 if (!__gdbstub_mark_bp(pc + 2, 0))
655                                         goto fault;
656                         }
657
658                         break;
659
660                         /* potential 3-byte conditional branches */
661                 case 0xf8:
662                         if (gdbstub_read_byte(pc + 1, &cur) < 0)
663                                 goto fault;
664                         if (!__gdbstub_mark_bp(pc + 3, 0))
665                                 goto fault;
666
667                         if (cur >= 0xe8 && cur <= 0xeb) {
668                                 if (gdbstub_read_byte(
669                                             pc + 2, ((u8 *) &x) + 0) < 0)
670                                         goto fault;
671                                 if ((x < 0 || x > 3) &&
672                                     !__gdbstub_mark_bp(pc + (s8) x, 1))
673                                         goto fault;
674                         }
675                         break;
676
677                 case 0xfa:
678                         if (gdbstub_read_byte(pc + 1, &cur) < 0)
679                                 goto fault;
680
681                         if (cur == 0xff) {
682                                 /* CALLS (d16,PC) */
683                                 if (gdbstub_read_byte(
684                                             pc + 2, ((u8 *) &x) + 0) < 0 ||
685                                     gdbstub_read_byte(
686                                             pc + 3, ((u8 *) &x) + 1) < 0)
687                                         goto fault;
688                                 if (!__gdbstub_mark_bp(pc + (s16) x, 0))
689                                         goto fault;
690                         } else {
691                                 if (!__gdbstub_mark_bp(pc + 4, 0))
692                                         goto fault;
693                         }
694                         break;
695
696                 case 0xfc:
697                         if (gdbstub_read_byte(pc + 1, &cur) < 0)
698                                 goto fault;
699                         if (cur == 0xff) {
700                                 /* CALLS (d32,PC) */
701                                 if (gdbstub_read_byte(
702                                             pc + 2, ((u8 *) &x) + 0) < 0 ||
703                                     gdbstub_read_byte(
704                                             pc + 3, ((u8 *) &x) + 1) < 0 ||
705                                     gdbstub_read_byte(
706                                             pc + 4, ((u8 *) &x) + 2) < 0 ||
707                                     gdbstub_read_byte(
708                                             pc + 5, ((u8 *) &x) + 3) < 0)
709                                         goto fault;
710                                 if (!__gdbstub_mark_bp(
711                                             pc + (s32) x, 0))
712                                         goto fault;
713                         } else {
714                                 if (!__gdbstub_mark_bp(
715                                             pc + 6, 0))
716                                         goto fault;
717                         }
718                         break;
719
720                 }
721         }
722
723         gdbstub_bkpt("Step: %02x at %p; %02x at %p\n",
724                      step_bp[0].opcode[0], step_bp[0].addr,
725                      step_bp[1].opcode[0], step_bp[1].addr);
726
727         if (step_bp[0].addr) {
728 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
729                 if (gdbstub_write_byte(0xF7, step_bp[0].addr + 0) < 0 ||
730                     gdbstub_write_byte(0xF7, step_bp[0].addr + 1) < 0)
731                         goto fault;
732 #else
733                 if (gdbstub_write_byte(0xFF, step_bp[0].addr + 0) < 0)
734                         goto fault;
735 #endif
736         }
737
738         if (step_bp[1].addr) {
739 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
740                 if (gdbstub_write_byte(0xF7, step_bp[1].addr + 0) < 0 ||
741                     gdbstub_write_byte(0xF7, step_bp[1].addr + 1) < 0)
742                         goto fault;
743 #else
744                 if (gdbstub_write_byte(0xFF, step_bp[1].addr + 0) < 0)
745                         goto fault;
746 #endif
747         }
748
749         return 0;
750
751  fault:
752         /* uh-oh - silly address alert, try and restore things */
753         __gdbstub_restore_bp();
754         return -EFAULT;
755 }
756
757 #ifdef CONFIG_GDBSTUB_CONSOLE
758
759 void gdbstub_console_write(struct console *con, const char *p, unsigned n)
760 {
761         static const char gdbstub_cr[] = { 0x0d };
762         char outbuf[26];
763         int qty;
764         u8 busy;
765
766         busy = gdbstub_busy;
767         gdbstub_busy = 1;
768
769         outbuf[0] = 'O';
770
771         while (n > 0) {
772                 qty = 1;
773
774                 while (n > 0 && qty < 20) {
775                         mem2hex(p, outbuf + qty, 2, 0);
776                         qty += 2;
777                         if (*p == 0x0a) {
778                                 mem2hex(gdbstub_cr, outbuf + qty, 2, 0);
779                                 qty += 2;
780                         }
781                         p++;
782                         n--;
783                 }
784
785                 outbuf[qty] = 0;
786                 putpacket(outbuf);
787         }
788
789         gdbstub_busy = busy;
790 }
791
792 static kdev_t gdbstub_console_dev(struct console *con)
793 {
794         return MKDEV(1, 3); /* /dev/null */
795 }
796
797 static struct console gdbstub_console = {
798         .name   = "gdb",
799         .write  = gdbstub_console_write,
800         .device = gdbstub_console_dev,
801         .flags  = CON_PRINTBUFFER,
802         .index  = -1,
803 };
804
805 #endif
806
807 /*
808  * Convert the memory pointed to by mem into hex, placing result in buf.
809  * - if successful, return a pointer to the last char put in buf (NUL)
810  * - in case of mem fault, return NULL
811  * may_fault is non-zero if we are reading from arbitrary memory, but is
812  * currently not used.
813  */
814 static
815 unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fault)
816 {
817         const u8 *mem = _mem;
818         u8 ch[4];
819
820         if ((u32) mem & 1 && count >= 1) {
821                 if (gdbstub_read_byte(mem, ch) != 0)
822                         return 0;
823                 buf = pack_hex_byte(buf, ch[0]);
824                 mem++;
825                 count--;
826         }
827
828         if ((u32) mem & 3 && count >= 2) {
829                 if (gdbstub_read_word(mem, ch) != 0)
830                         return 0;
831                 buf = pack_hex_byte(buf, ch[0]);
832                 buf = pack_hex_byte(buf, ch[1]);
833                 mem += 2;
834                 count -= 2;
835         }
836
837         while (count >= 4) {
838                 if (gdbstub_read_dword(mem, ch) != 0)
839                         return 0;
840                 buf = pack_hex_byte(buf, ch[0]);
841                 buf = pack_hex_byte(buf, ch[1]);
842                 buf = pack_hex_byte(buf, ch[2]);
843                 buf = pack_hex_byte(buf, ch[3]);
844                 mem += 4;
845                 count -= 4;
846         }
847
848         if (count >= 2) {
849                 if (gdbstub_read_word(mem, ch) != 0)
850                         return 0;
851                 buf = pack_hex_byte(buf, ch[0]);
852                 buf = pack_hex_byte(buf, ch[1]);
853                 mem += 2;
854                 count -= 2;
855         }
856
857         if (count >= 1) {
858                 if (gdbstub_read_byte(mem, ch) != 0)
859                         return 0;
860                 buf = pack_hex_byte(buf, ch[0]);
861         }
862
863         *buf = 0;
864         return buf;
865 }
866
867 /*
868  * convert the hex array pointed to by buf into binary to be placed in mem
869  * return a pointer to the character AFTER the last byte written
870  * may_fault is non-zero if we are reading from arbitrary memory, but is
871  * currently not used.
872  */
873 static
874 const char *hex2mem(const char *buf, void *_mem, int count, int may_fault)
875 {
876         u8 *mem = _mem;
877         union {
878                 u32 val;
879                 u8 b[4];
880         } ch;
881
882         if ((u32) mem & 1 && count >= 1) {
883                 ch.b[0]  = hex(*buf++) << 4;
884                 ch.b[0] |= hex(*buf++);
885                 if (gdbstub_write_byte(ch.val, mem) != 0)
886                         return 0;
887                 mem++;
888                 count--;
889         }
890
891         if ((u32) mem & 3 && count >= 2) {
892                 ch.b[0]  = hex(*buf++) << 4;
893                 ch.b[0] |= hex(*buf++);
894                 ch.b[1]  = hex(*buf++) << 4;
895                 ch.b[1] |= hex(*buf++);
896                 if (gdbstub_write_word(ch.val, mem) != 0)
897                         return 0;
898                 mem += 2;
899                 count -= 2;
900         }
901
902         while (count >= 4) {
903                 ch.b[0]  = hex(*buf++) << 4;
904                 ch.b[0] |= hex(*buf++);
905                 ch.b[1]  = hex(*buf++) << 4;
906                 ch.b[1] |= hex(*buf++);
907                 ch.b[2]  = hex(*buf++) << 4;
908                 ch.b[2] |= hex(*buf++);
909                 ch.b[3]  = hex(*buf++) << 4;
910                 ch.b[3] |= hex(*buf++);
911                 if (gdbstub_write_dword(ch.val, mem) != 0)
912                         return 0;
913                 mem += 4;
914                 count -= 4;
915         }
916
917         if (count >= 2) {
918                 ch.b[0]  = hex(*buf++) << 4;
919                 ch.b[0] |= hex(*buf++);
920                 ch.b[1]  = hex(*buf++) << 4;
921                 ch.b[1] |= hex(*buf++);
922                 if (gdbstub_write_word(ch.val, mem) != 0)
923                         return 0;
924                 mem += 2;
925                 count -= 2;
926         }
927
928         if (count >= 1) {
929                 ch.b[0]  = hex(*buf++) << 4;
930                 ch.b[0] |= hex(*buf++);
931                 if (gdbstub_write_byte(ch.val, mem) != 0)
932                         return 0;
933         }
934
935         return buf;
936 }
937
938 /*
939  * This table contains the mapping between MN10300 exception codes, and
940  * signals, which are primarily what GDB understands.  It also indicates
941  * which hardware traps we need to commandeer when initializing the stub.
942  */
943 static const struct excep_to_sig_map {
944         enum exception_code     excep;  /* MN10300 exception code */
945         unsigned char           signo;  /* Signal that we map this into */
946 } excep_to_sig_map[] = {
947         { EXCEP_ITLBMISS,       SIGSEGV         },
948         { EXCEP_DTLBMISS,       SIGSEGV         },
949         { EXCEP_TRAP,           SIGTRAP         },
950         { EXCEP_ISTEP,          SIGTRAP         },
951         { EXCEP_IBREAK,         SIGTRAP         },
952         { EXCEP_OBREAK,         SIGTRAP         },
953         { EXCEP_UNIMPINS,       SIGILL          },
954         { EXCEP_UNIMPEXINS,     SIGILL          },
955         { EXCEP_MEMERR,         SIGSEGV         },
956         { EXCEP_MISALIGN,       SIGSEGV         },
957         { EXCEP_BUSERROR,       SIGBUS          },
958         { EXCEP_ILLINSACC,      SIGSEGV         },
959         { EXCEP_ILLDATACC,      SIGSEGV         },
960         { EXCEP_IOINSACC,       SIGSEGV         },
961         { EXCEP_PRIVINSACC,     SIGSEGV         },
962         { EXCEP_PRIVDATACC,     SIGSEGV         },
963         { EXCEP_FPU_DISABLED,   SIGFPE          },
964         { EXCEP_FPU_UNIMPINS,   SIGFPE          },
965         { EXCEP_FPU_OPERATION,  SIGFPE          },
966         { EXCEP_WDT,            SIGALRM         },
967         { EXCEP_NMI,            SIGQUIT         },
968         { EXCEP_IRQ_LEVEL0,     SIGINT          },
969         { EXCEP_IRQ_LEVEL1,     SIGINT          },
970         { EXCEP_IRQ_LEVEL2,     SIGINT          },
971         { EXCEP_IRQ_LEVEL3,     SIGINT          },
972         { EXCEP_IRQ_LEVEL4,     SIGINT          },
973         { EXCEP_IRQ_LEVEL5,     SIGINT          },
974         { EXCEP_IRQ_LEVEL6,     SIGINT          },
975         { 0, 0}
976 };
977
978 /*
979  * convert the MN10300 exception code into a UNIX signal number
980  */
981 static int computeSignal(enum exception_code excep)
982 {
983         const struct excep_to_sig_map *map;
984
985         for (map = excep_to_sig_map; map->signo; map++)
986                 if (map->excep == excep)
987                         return map->signo;
988
989         return SIGHUP; /* default for things we don't know about */
990 }
991
992 static u32 gdbstub_fpcr, gdbstub_fpufs_array[32];
993
994 /*
995  *
996  */
997 static void gdbstub_store_fpu(void)
998 {
999 #ifdef CONFIG_FPU
1000
1001         asm volatile(
1002                 "or %2,epsw\n"
1003 #ifdef CONFIG_MN10300_PROC_MN103E010
1004                 "nop\n"
1005                 "nop\n"
1006 #endif
1007                 "mov %1, a1\n"
1008                 "fmov fs0,  (a1+)\n"
1009                 "fmov fs1,  (a1+)\n"
1010                 "fmov fs2,  (a1+)\n"
1011                 "fmov fs3,  (a1+)\n"
1012                 "fmov fs4,  (a1+)\n"
1013                 "fmov fs5,  (a1+)\n"
1014                 "fmov fs6,  (a1+)\n"
1015                 "fmov fs7,  (a1+)\n"
1016                 "fmov fs8,  (a1+)\n"
1017                 "fmov fs9,  (a1+)\n"
1018                 "fmov fs10, (a1+)\n"
1019                 "fmov fs11, (a1+)\n"
1020                 "fmov fs12, (a1+)\n"
1021                 "fmov fs13, (a1+)\n"
1022                 "fmov fs14, (a1+)\n"
1023                 "fmov fs15, (a1+)\n"
1024                 "fmov fs16, (a1+)\n"
1025                 "fmov fs17, (a1+)\n"
1026                 "fmov fs18, (a1+)\n"
1027                 "fmov fs19, (a1+)\n"
1028                 "fmov fs20, (a1+)\n"
1029                 "fmov fs21, (a1+)\n"
1030                 "fmov fs22, (a1+)\n"
1031                 "fmov fs23, (a1+)\n"
1032                 "fmov fs24, (a1+)\n"
1033                 "fmov fs25, (a1+)\n"
1034                 "fmov fs26, (a1+)\n"
1035                 "fmov fs27, (a1+)\n"
1036                 "fmov fs28, (a1+)\n"
1037                 "fmov fs29, (a1+)\n"
1038                 "fmov fs30, (a1+)\n"
1039                 "fmov fs31, (a1+)\n"
1040                 "fmov fpcr, %0\n"
1041                 : "=d"(gdbstub_fpcr)
1042                 : "g" (&gdbstub_fpufs_array), "i"(EPSW_FE)
1043                 : "a1"
1044                 );
1045 #endif
1046 }
1047
1048 /*
1049  *
1050  */
1051 static void gdbstub_load_fpu(void)
1052 {
1053 #ifdef CONFIG_FPU
1054
1055         asm volatile(
1056                 "or %1,epsw\n"
1057 #ifdef CONFIG_MN10300_PROC_MN103E010
1058                 "nop\n"
1059                 "nop\n"
1060 #endif
1061                 "mov %0, a1\n"
1062                 "fmov (a1+), fs0\n"
1063                 "fmov (a1+), fs1\n"
1064                 "fmov (a1+), fs2\n"
1065                 "fmov (a1+), fs3\n"
1066                 "fmov (a1+), fs4\n"
1067                 "fmov (a1+), fs5\n"
1068                 "fmov (a1+), fs6\n"
1069                 "fmov (a1+), fs7\n"
1070                 "fmov (a1+), fs8\n"
1071                 "fmov (a1+), fs9\n"
1072                 "fmov (a1+), fs10\n"
1073                 "fmov (a1+), fs11\n"
1074                 "fmov (a1+), fs12\n"
1075                 "fmov (a1+), fs13\n"
1076                 "fmov (a1+), fs14\n"
1077                 "fmov (a1+), fs15\n"
1078                 "fmov (a1+), fs16\n"
1079                 "fmov (a1+), fs17\n"
1080                 "fmov (a1+), fs18\n"
1081                 "fmov (a1+), fs19\n"
1082                 "fmov (a1+), fs20\n"
1083                 "fmov (a1+), fs21\n"
1084                 "fmov (a1+), fs22\n"
1085                 "fmov (a1+), fs23\n"
1086                 "fmov (a1+), fs24\n"
1087                 "fmov (a1+), fs25\n"
1088                 "fmov (a1+), fs26\n"
1089                 "fmov (a1+), fs27\n"
1090                 "fmov (a1+), fs28\n"
1091                 "fmov (a1+), fs29\n"
1092                 "fmov (a1+), fs30\n"
1093                 "fmov (a1+), fs31\n"
1094                 "fmov %2, fpcr\n"
1095                 :
1096                 : "g" (&gdbstub_fpufs_array), "i"(EPSW_FE), "d"(gdbstub_fpcr)
1097                 : "a1"
1098         );
1099 #endif
1100 }
1101
1102 /*
1103  * set a software breakpoint
1104  */
1105 int gdbstub_set_breakpoint(u8 *addr, int len)
1106 {
1107         int bkpt, loop, xloop;
1108
1109 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
1110         len = (len + 1) & ~1;
1111 #endif
1112
1113         gdbstub_bkpt("setbkpt(%p,%d)\n", addr, len);
1114
1115         for (bkpt = 255; bkpt >= 0; bkpt--)
1116                 if (!gdbstub_bkpts[bkpt].addr)
1117                         break;
1118         if (bkpt < 0)
1119                 return -ENOSPC;
1120
1121         for (loop = 0; loop < len; loop++)
1122                 if (gdbstub_read_byte(&addr[loop],
1123                                       &gdbstub_bkpts[bkpt].origbytes[loop]
1124                                       ) < 0)
1125                         return -EFAULT;
1126
1127         gdbstub_flush_caches = 1;
1128
1129 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
1130         for (loop = 0; loop < len; loop++)
1131                 if (gdbstub_write_byte(0xF7, &addr[loop]) < 0)
1132                         goto restore;
1133 #else
1134         for (loop = 0; loop < len; loop++)
1135                 if (gdbstub_write_byte(0xFF, &addr[loop]) < 0)
1136                         goto restore;
1137 #endif
1138
1139         gdbstub_bkpts[bkpt].addr = addr;
1140         gdbstub_bkpts[bkpt].len = len;
1141
1142         gdbstub_bkpt("Set BKPT[%02x]: %p-%p {%02x%02x%02x%02x%02x%02x%02x}\n",
1143                      bkpt,
1144                      gdbstub_bkpts[bkpt].addr,
1145                      gdbstub_bkpts[bkpt].addr + gdbstub_bkpts[bkpt].len - 1,
1146                      gdbstub_bkpts[bkpt].origbytes[0],
1147                      gdbstub_bkpts[bkpt].origbytes[1],
1148                      gdbstub_bkpts[bkpt].origbytes[2],
1149                      gdbstub_bkpts[bkpt].origbytes[3],
1150                      gdbstub_bkpts[bkpt].origbytes[4],
1151                      gdbstub_bkpts[bkpt].origbytes[5],
1152                      gdbstub_bkpts[bkpt].origbytes[6]
1153                      );
1154
1155         return 0;
1156
1157 restore:
1158         for (xloop = 0; xloop < loop; xloop++)
1159                 gdbstub_write_byte(gdbstub_bkpts[bkpt].origbytes[xloop],
1160                                    addr + xloop);
1161         return -EFAULT;
1162 }
1163
1164 /*
1165  * clear a software breakpoint
1166  */
1167 int gdbstub_clear_breakpoint(u8 *addr, int len)
1168 {
1169         int bkpt, loop;
1170
1171 #ifdef GDBSTUB_USE_F7F7_AS_BREAKPOINT
1172         len = (len + 1) & ~1;
1173 #endif
1174
1175         gdbstub_bkpt("clearbkpt(%p,%d)\n", addr, len);
1176
1177         for (bkpt = 255; bkpt >= 0; bkpt--)
1178                 if (gdbstub_bkpts[bkpt].addr == addr &&
1179                     gdbstub_bkpts[bkpt].len == len)
1180                         break;
1181         if (bkpt < 0)
1182                 return -ENOENT;
1183
1184         gdbstub_bkpts[bkpt].addr = NULL;
1185
1186         gdbstub_flush_caches = 1;
1187
1188         for (loop = 0; loop < len; loop++)
1189                 if (gdbstub_write_byte(gdbstub_bkpts[bkpt].origbytes[loop],
1190                                        addr + loop) < 0)
1191                         return -EFAULT;
1192
1193         return 0;
1194 }
1195
1196 /*
1197  * This function does all command processing for interfacing to gdb
1198  * - returns 1 if the exception should be skipped, 0 otherwise.
1199  */
1200 static int gdbstub(struct pt_regs *regs, enum exception_code excep)
1201 {
1202         unsigned long *stack;
1203         unsigned long epsw, mdr;
1204         uint32_t zero, ssp;
1205         uint8_t broke;
1206         char *ptr;
1207         int sigval;
1208         int addr;
1209         int length;
1210         int loop;
1211
1212         if (excep == EXCEP_FPU_DISABLED)
1213                 return 0;
1214
1215         gdbstub_flush_caches = 0;
1216
1217         mn10300_set_gdbleds(1);
1218
1219         asm volatile("mov mdr,%0" : "=d"(mdr));
1220         asm volatile("mov epsw,%0" : "=d"(epsw));
1221         asm volatile("mov %0,epsw"
1222                      :: "d"((epsw & ~EPSW_IM) | EPSW_IE | EPSW_IM_1));
1223
1224         gdbstub_store_fpu();
1225
1226 #ifdef CONFIG_GDBSTUB_IMMEDIATE
1227         /* skip the initial pause loop */
1228         if (regs->pc == (unsigned long) __gdbstub_pause)
1229                 regs->pc = (unsigned long) start_kernel;
1230 #endif
1231
1232         /* if we were single stepping, restore the opcodes hoisted for the
1233          * breakpoint[s] */
1234         broke = 0;
1235         if ((step_bp[0].addr && step_bp[0].addr == (u8 *) regs->pc) ||
1236             (step_bp[1].addr && step_bp[1].addr == (u8 *) regs->pc))
1237                 broke = 1;
1238
1239         __gdbstub_restore_bp();
1240
1241         if (gdbstub_rx_unget) {
1242                 sigval = SIGINT;
1243                 if (gdbstub_rx_unget != 3)
1244                         goto packet_waiting;
1245                 gdbstub_rx_unget = 0;
1246         }
1247
1248         stack = (unsigned long *) regs->sp;
1249         sigval = broke ? SIGTRAP : computeSignal(excep);
1250
1251         /* send information about a BUG() */
1252         if (!user_mode(regs) && excep == EXCEP_SYSCALL15) {
1253                 const struct bug_entry *bug;
1254
1255                 bug = find_bug(regs->pc);
1256                 if (bug)
1257                         goto found_bug;
1258                 length = snprintf(trans_buffer, sizeof(trans_buffer),
1259                                   "BUG() at address %lx\n", regs->pc);
1260                 goto send_bug_pkt;
1261
1262         found_bug:
1263                 length = snprintf(trans_buffer, sizeof(trans_buffer),
1264                                   "BUG() at address %lx (%s:%d)\n",
1265                                   regs->pc, bug->file, bug->line);
1266
1267         send_bug_pkt:
1268                 ptr = output_buffer;
1269                 *ptr++ = 'O';
1270                 ptr = mem2hex(trans_buffer, ptr, length, 0);
1271                 *ptr = 0;
1272                 putpacket(output_buffer);
1273
1274                 regs->pc -= 2;
1275                 sigval = SIGABRT;
1276         } else if (regs->pc == (unsigned long) __gdbstub_bug_trap) {
1277                 regs->pc = regs->mdr;
1278                 sigval = SIGABRT;
1279         }
1280
1281         /*
1282          * send a message to the debugger's user saying what happened if it may
1283          * not be clear cut (we can't map exceptions onto signals properly)
1284          */
1285         if (sigval != SIGINT && sigval != SIGTRAP && sigval != SIGILL) {
1286                 static const char title[] = "Excep ", tbcberr[] = "BCBERR ";
1287                 static const char crlf[] = "\r\n";
1288                 char hx;
1289                 u32 bcberr = BCBERR;
1290
1291                 ptr = output_buffer;
1292                 *ptr++ = 'O';
1293                 ptr = mem2hex(title, ptr, sizeof(title) - 1, 0);
1294
1295                 hx = hex_asc_hi(excep >> 8);
1296                 ptr = pack_hex_byte(ptr, hx);
1297                 hx = hex_asc_lo(excep >> 8);
1298                 ptr = pack_hex_byte(ptr, hx);
1299                 hx = hex_asc_hi(excep);
1300                 ptr = pack_hex_byte(ptr, hx);
1301                 hx = hex_asc_lo(excep);
1302                 ptr = pack_hex_byte(ptr, hx);
1303
1304                 ptr = mem2hex(crlf, ptr, sizeof(crlf) - 1, 0);
1305                 *ptr = 0;
1306                 putpacket(output_buffer);       /* send it off... */
1307
1308                 /* BCBERR */
1309                 ptr = output_buffer;
1310                 *ptr++ = 'O';
1311                 ptr = mem2hex(tbcberr, ptr, sizeof(tbcberr) - 1, 0);
1312
1313                 hx = hex_asc_hi(bcberr >> 24);
1314                 ptr = pack_hex_byte(ptr, hx);
1315                 hx = hex_asc_lo(bcberr >> 24);
1316                 ptr = pack_hex_byte(ptr, hx);
1317                 hx = hex_asc_hi(bcberr >> 16);
1318                 ptr = pack_hex_byte(ptr, hx);
1319                 hx = hex_asc_lo(bcberr >> 16);
1320                 ptr = pack_hex_byte(ptr, hx);
1321                 hx = hex_asc_hi(bcberr >> 8);
1322                 ptr = pack_hex_byte(ptr, hx);
1323                 hx = hex_asc_lo(bcberr >> 8);
1324                 ptr = pack_hex_byte(ptr, hx);
1325                 hx = hex_asc_hi(bcberr);
1326                 ptr = pack_hex_byte(ptr, hx);
1327                 hx = hex_asc_lo(bcberr);
1328                 ptr = pack_hex_byte(ptr, hx);
1329
1330                 ptr = mem2hex(crlf, ptr, sizeof(crlf) - 1, 0);
1331                 *ptr = 0;
1332                 putpacket(output_buffer);       /* send it off... */
1333         }
1334
1335         /*
1336          * tell the debugger that an exception has occurred
1337          */
1338         ptr = output_buffer;
1339
1340         /*
1341          * Send trap type (converted to signal)
1342          */
1343         *ptr++ = 'T';
1344         ptr = pack_hex_byte(ptr, sigval);
1345
1346         /*
1347          * Send Error PC
1348          */
1349         ptr = pack_hex_byte(ptr, GDB_REGID_PC);
1350         *ptr++ = ':';
1351         ptr = mem2hex(&regs->pc, ptr, 4, 0);
1352         *ptr++ = ';';
1353
1354         /*
1355          * Send frame pointer
1356          */
1357         ptr = pack_hex_byte(ptr, GDB_REGID_FP);
1358         *ptr++ = ':';
1359         ptr = mem2hex(&regs->a3, ptr, 4, 0);
1360         *ptr++ = ';';
1361
1362         /*
1363          * Send stack pointer
1364          */
1365         ssp = (unsigned long) (regs + 1);
1366         ptr = pack_hex_byte(ptr, GDB_REGID_SP);
1367         *ptr++ = ':';
1368         ptr = mem2hex(&ssp, ptr, 4, 0);
1369         *ptr++ = ';';
1370
1371         *ptr++ = 0;
1372         putpacket(output_buffer);       /* send it off... */
1373
1374 packet_waiting:
1375         /*
1376          * Wait for input from remote GDB
1377          */
1378         while (1) {
1379                 output_buffer[0] = 0;
1380                 getpacket(input_buffer);
1381
1382                 switch (input_buffer[0]) {
1383                         /* request repeat of last signal number */
1384                 case '?':
1385                         output_buffer[0] = 'S';
1386                         output_buffer[1] = hex_asc_hi(sigval);
1387                         output_buffer[2] = hex_asc_lo(sigval);
1388                         output_buffer[3] = 0;
1389                         break;
1390
1391                 case 'd':
1392                         /* toggle debug flag */
1393                         break;
1394
1395                         /*
1396                          * Return the value of the CPU registers
1397                          */
1398                 case 'g':
1399                         zero = 0;
1400                         ssp = (u32) (regs + 1);
1401                         ptr = output_buffer;
1402                         ptr = mem2hex(&regs->d0, ptr, 4, 0);
1403                         ptr = mem2hex(&regs->d1, ptr, 4, 0);
1404                         ptr = mem2hex(&regs->d2, ptr, 4, 0);
1405                         ptr = mem2hex(&regs->d3, ptr, 4, 0);
1406                         ptr = mem2hex(&regs->a0, ptr, 4, 0);
1407                         ptr = mem2hex(&regs->a1, ptr, 4, 0);
1408                         ptr = mem2hex(&regs->a2, ptr, 4, 0);
1409                         ptr = mem2hex(&regs->a3, ptr, 4, 0);
1410
1411                         ptr = mem2hex(&ssp, ptr, 4, 0);         /* 8 */
1412                         ptr = mem2hex(&regs->pc, ptr, 4, 0);
1413                         ptr = mem2hex(&regs->mdr, ptr, 4, 0);
1414                         ptr = mem2hex(&regs->epsw, ptr, 4, 0);
1415                         ptr = mem2hex(&regs->lir, ptr, 4, 0);
1416                         ptr = mem2hex(&regs->lar, ptr, 4, 0);
1417                         ptr = mem2hex(&regs->mdrq, ptr, 4, 0);
1418
1419                         ptr = mem2hex(&regs->e0, ptr, 4, 0);    /* 15 */
1420                         ptr = mem2hex(&regs->e1, ptr, 4, 0);
1421                         ptr = mem2hex(&regs->e2, ptr, 4, 0);
1422                         ptr = mem2hex(&regs->e3, ptr, 4, 0);
1423                         ptr = mem2hex(&regs->e4, ptr, 4, 0);
1424                         ptr = mem2hex(&regs->e5, ptr, 4, 0);
1425                         ptr = mem2hex(&regs->e6, ptr, 4, 0);
1426                         ptr = mem2hex(&regs->e7, ptr, 4, 0);
1427
1428                         ptr = mem2hex(&ssp, ptr, 4, 0);
1429                         ptr = mem2hex(&regs, ptr, 4, 0);
1430                         ptr = mem2hex(&regs->sp, ptr, 4, 0);
1431                         ptr = mem2hex(&regs->mcrh, ptr, 4, 0);  /* 26 */
1432                         ptr = mem2hex(&regs->mcrl, ptr, 4, 0);
1433                         ptr = mem2hex(&regs->mcvf, ptr, 4, 0);
1434
1435                         ptr = mem2hex(&gdbstub_fpcr, ptr, 4, 0); /* 29 - FPCR */
1436                         ptr = mem2hex(&zero, ptr, 4, 0);
1437                         ptr = mem2hex(&zero, ptr, 4, 0);
1438                         for (loop = 0; loop < 32; loop++)
1439                                 ptr = mem2hex(&gdbstub_fpufs_array[loop],
1440                                               ptr, 4, 0); /* 32 - FS0-31 */
1441
1442                         break;
1443
1444                         /*
1445                          * set the value of the CPU registers - return OK
1446                          */
1447                 case 'G':
1448                 {
1449                         const char *ptr;
1450
1451                         ptr = &input_buffer[1];
1452                         ptr = hex2mem(ptr, &regs->d0, 4, 0);
1453                         ptr = hex2mem(ptr, &regs->d1, 4, 0);
1454                         ptr = hex2mem(ptr, &regs->d2, 4, 0);
1455                         ptr = hex2mem(ptr, &regs->d3, 4, 0);
1456                         ptr = hex2mem(ptr, &regs->a0, 4, 0);
1457                         ptr = hex2mem(ptr, &regs->a1, 4, 0);
1458                         ptr = hex2mem(ptr, &regs->a2, 4, 0);
1459                         ptr = hex2mem(ptr, &regs->a3, 4, 0);
1460
1461                         ptr = hex2mem(ptr, &ssp, 4, 0);         /* 8 */
1462                         ptr = hex2mem(ptr, &regs->pc, 4, 0);
1463                         ptr = hex2mem(ptr, &regs->mdr, 4, 0);
1464                         ptr = hex2mem(ptr, &regs->epsw, 4, 0);
1465                         ptr = hex2mem(ptr, &regs->lir, 4, 0);
1466                         ptr = hex2mem(ptr, &regs->lar, 4, 0);
1467                         ptr = hex2mem(ptr, &regs->mdrq, 4, 0);
1468
1469                         ptr = hex2mem(ptr, &regs->e0, 4, 0);    /* 15 */
1470                         ptr = hex2mem(ptr, &regs->e1, 4, 0);
1471                         ptr = hex2mem(ptr, &regs->e2, 4, 0);
1472                         ptr = hex2mem(ptr, &regs->e3, 4, 0);
1473                         ptr = hex2mem(ptr, &regs->e4, 4, 0);
1474                         ptr = hex2mem(ptr, &regs->e5, 4, 0);
1475                         ptr = hex2mem(ptr, &regs->e6, 4, 0);
1476                         ptr = hex2mem(ptr, &regs->e7, 4, 0);
1477
1478                         ptr = hex2mem(ptr, &ssp, 4, 0);
1479                         ptr = hex2mem(ptr, &zero, 4, 0);
1480                         ptr = hex2mem(ptr, &regs->sp, 4, 0);
1481                         ptr = hex2mem(ptr, &regs->mcrh, 4, 0);  /* 26 */
1482                         ptr = hex2mem(ptr, &regs->mcrl, 4, 0);
1483                         ptr = hex2mem(ptr, &regs->mcvf, 4, 0);
1484
1485                         ptr = hex2mem(ptr, &zero, 4, 0);        /* 29 - FPCR */
1486                         ptr = hex2mem(ptr, &zero, 4, 0);
1487                         ptr = hex2mem(ptr, &zero, 4, 0);
1488                         for (loop = 0; loop < 32; loop++)     /* 32 - FS0-31 */
1489                                 ptr = hex2mem(ptr, &zero, 4, 0);
1490
1491 #if 0
1492                         /*
1493                          * See if the stack pointer has moved. If so, then copy
1494                          * the saved locals and ins to the new location.
1495                          */
1496                         unsigned long *newsp = (unsigned long *) registers[SP];
1497                         if (sp != newsp)
1498                                 sp = memcpy(newsp, sp, 16 * 4);
1499 #endif
1500
1501                         gdbstub_strcpy(output_buffer, "OK");
1502                 }
1503                 break;
1504
1505                 /*
1506                  * mAA..AA,LLLL  Read LLLL bytes at address AA..AA
1507                  */
1508                 case 'm':
1509                         ptr = &input_buffer[1];
1510
1511                         if (hexToInt(&ptr, &addr) &&
1512                             *ptr++ == ',' &&
1513                             hexToInt(&ptr, &length)
1514                             ) {
1515                                 if (mem2hex((char *) addr, output_buffer,
1516                                             length, 1))
1517                                         break;
1518                                 gdbstub_strcpy(output_buffer, "E03");
1519                         } else {
1520                                 gdbstub_strcpy(output_buffer, "E01");
1521                         }
1522                         break;
1523
1524                         /*
1525                          * MAA..AA,LLLL: Write LLLL bytes at address AA.AA
1526                          * return OK
1527                          */
1528                 case 'M':
1529                         ptr = &input_buffer[1];
1530
1531                         if (hexToInt(&ptr, &addr) &&
1532                             *ptr++ == ',' &&
1533                             hexToInt(&ptr, &length) &&
1534                             *ptr++ == ':'
1535                             ) {
1536                                 if (hex2mem(ptr, (char *) addr, length, 1))
1537                                         gdbstub_strcpy(output_buffer, "OK");
1538                                 else
1539                                         gdbstub_strcpy(output_buffer, "E03");
1540
1541                                 gdbstub_flush_caches = 1;
1542                         } else {
1543                                 gdbstub_strcpy(output_buffer, "E02");
1544                         }
1545                         break;
1546
1547                         /*
1548                          * cAA..AA    Continue at address AA..AA(optional)
1549                          */
1550                 case 'c':
1551                         /* try to read optional parameter, pc unchanged if no
1552                          * parm */
1553
1554                         ptr = &input_buffer[1];
1555                         if (hexToInt(&ptr, &addr))
1556                                 regs->pc = addr;
1557                         goto done;
1558
1559                         /*
1560                          * kill the program
1561                          */
1562                 case 'k' :
1563                         goto done;      /* just continue */
1564
1565                         /*
1566                          * Reset the whole machine (FIXME: system dependent)
1567                          */
1568                 case 'r':
1569                         break;
1570
1571                         /*
1572                          * Step to next instruction
1573                          */
1574                 case 's':
1575                         /*
1576                          * using the T flag doesn't seem to perform single
1577                          * stepping (it seems to wind up being caught by the
1578                          * JTAG unit), so we have to use breakpoints and
1579                          * continue instead.
1580                          */
1581                         if (gdbstub_single_step(regs) < 0)
1582                                 /* ignore any fault error for now */
1583                                 gdbstub_printk("unable to set single-step"
1584                                                " bp\n");
1585                         goto done;
1586
1587                         /*
1588                          * Set baud rate (bBB)
1589                          */
1590                 case 'b':
1591                         do {
1592                                 int baudrate;
1593
1594                                 ptr = &input_buffer[1];
1595                                 if (!hexToInt(&ptr, &baudrate)) {
1596                                         gdbstub_strcpy(output_buffer, "B01");
1597                                         break;
1598                                 }
1599
1600                                 if (baudrate) {
1601                                         /* ACK before changing speed */
1602                                         putpacket("OK");
1603                                         gdbstub_io_set_baud(baudrate);
1604                                 }
1605                         } while (0);
1606                         break;
1607
1608                         /*
1609                          * Set breakpoint
1610                          */
1611                 case 'Z':
1612                         ptr = &input_buffer[1];
1613
1614                         if (!hexToInt(&ptr, &loop) || *ptr++ != ',' ||
1615                             !hexToInt(&ptr, &addr) || *ptr++ != ',' ||
1616                             !hexToInt(&ptr, &length)
1617                             ) {
1618                                 gdbstub_strcpy(output_buffer, "E01");
1619                                 break;
1620                         }
1621
1622                         /* only support software breakpoints */
1623                         gdbstub_strcpy(output_buffer, "E03");
1624                         if (loop != 0 ||
1625                             length < 1 ||
1626                             length > 7 ||
1627                             (unsigned long) addr < 4096)
1628                                 break;
1629
1630                         if (gdbstub_set_breakpoint((u8 *) addr, length) < 0)
1631                                 break;
1632
1633                         gdbstub_strcpy(output_buffer, "OK");
1634                         break;
1635
1636                         /*
1637                          * Clear breakpoint
1638                          */
1639                 case 'z':
1640                         ptr = &input_buffer[1];
1641
1642                         if (!hexToInt(&ptr, &loop) || *ptr++ != ',' ||
1643                             !hexToInt(&ptr, &addr) || *ptr++ != ',' ||
1644                             !hexToInt(&ptr, &length)
1645                             ) {
1646                                 gdbstub_strcpy(output_buffer, "E01");
1647                                 break;
1648                         }
1649
1650                         /* only support software breakpoints */
1651                         gdbstub_strcpy(output_buffer, "E03");
1652                         if (loop != 0 ||
1653                             length < 1 ||
1654                             length > 7 ||
1655                             (unsigned long) addr < 4096)
1656                                 break;
1657
1658                         if (gdbstub_clear_breakpoint((u8 *) addr, length) < 0)
1659                                 break;
1660
1661                         gdbstub_strcpy(output_buffer, "OK");
1662                         break;
1663
1664                 default:
1665                         gdbstub_proto("### GDB Unsupported Cmd '%s'\n",
1666                                       input_buffer);
1667                         break;
1668                 }
1669
1670                 /* reply to the request */
1671                 putpacket(output_buffer);
1672         }
1673
1674 done:
1675         /*
1676          * Need to flush the instruction cache here, as we may
1677          * have deposited a breakpoint, and the icache probably
1678          * has no way of knowing that a data ref to some location
1679          * may have changed something that is in the instruction
1680          * cache.
1681          * NB: We flush both caches, just to be sure...
1682          */
1683         if (gdbstub_flush_caches)
1684                 gdbstub_purge_cache();
1685
1686         gdbstub_load_fpu();
1687         mn10300_set_gdbleds(0);
1688         if (excep == EXCEP_NMI)
1689                 NMICR = NMICR_NMIF;
1690
1691         touch_softlockup_watchdog();
1692
1693         local_irq_restore(epsw);
1694         return 1;
1695 }
1696
1697 /*
1698  * handle event interception
1699  */
1700 asmlinkage int gdbstub_intercept(struct pt_regs *regs,
1701                                  enum exception_code excep)
1702 {
1703         static u8 notfirst = 1;
1704         int ret;
1705
1706         if (gdbstub_busy)
1707                 gdbstub_printk("--> gdbstub reentered itself\n");
1708         gdbstub_busy = 1;
1709
1710         if (notfirst) {
1711                 unsigned long mdr;
1712                 asm("mov mdr,%0" : "=d"(mdr));
1713
1714                 gdbstub_entry(
1715                         "--> gdbstub_intercept(%p,%04x) [MDR=%lx PC=%lx]\n",
1716                         regs, excep, mdr, regs->pc);
1717
1718                 gdbstub_entry(
1719                         "PC:  %08lx EPSW:  %08lx  SSP: %08lx mode: %s\n",
1720                         regs->pc, regs->epsw, (unsigned long) &ret,
1721                         user_mode(regs) ? "User" : "Super");
1722                 gdbstub_entry(
1723                         "d0:  %08lx   d1:  %08lx   d2: %08lx   d3: %08lx\n",
1724                         regs->d0, regs->d1, regs->d2, regs->d3);
1725                 gdbstub_entry(
1726                         "a0:  %08lx   a1:  %08lx   a2: %08lx   a3: %08lx\n",
1727                         regs->a0, regs->a1, regs->a2, regs->a3);
1728                 gdbstub_entry(
1729                         "e0:  %08lx   e1:  %08lx   e2: %08lx   e3: %08lx\n",
1730                         regs->e0, regs->e1, regs->e2, regs->e3);
1731                 gdbstub_entry(
1732                         "e4:  %08lx   e5:  %08lx   e6: %08lx   e7: %08lx\n",
1733                         regs->e4, regs->e5, regs->e6, regs->e7);
1734                 gdbstub_entry(
1735                         "lar: %08lx   lir: %08lx  mdr: %08lx  usp: %08lx\n",
1736                         regs->lar, regs->lir, regs->mdr, regs->sp);
1737                 gdbstub_entry(
1738                         "cvf: %08lx   crl: %08lx  crh: %08lx  drq: %08lx\n",
1739                         regs->mcvf, regs->mcrl, regs->mcrh, regs->mdrq);
1740                 gdbstub_entry(
1741                         "threadinfo=%p task=%p)\n",
1742                         current_thread_info(), current);
1743         } else {
1744                 notfirst = 1;
1745         }
1746
1747         ret = gdbstub(regs, excep);
1748
1749         gdbstub_entry("<-- gdbstub_intercept()\n");
1750         gdbstub_busy = 0;
1751         return ret;
1752 }
1753
1754 /*
1755  * handle the GDB stub itself causing an exception
1756  */
1757 asmlinkage void gdbstub_exception(struct pt_regs *regs,
1758                                   enum exception_code excep)
1759 {
1760         unsigned long mdr;
1761
1762         asm("mov mdr,%0" : "=d"(mdr));
1763         gdbstub_entry("--> gdbstub exception({%p},%04x) [MDR=%lx]\n",
1764                       regs, excep, mdr);
1765
1766         while ((unsigned long) regs == 0xffffffff) {}
1767
1768         /* handle guarded memory accesses where we know it might fault */
1769         if (regs->pc == (unsigned) gdbstub_read_byte_guard) {
1770                 regs->pc = (unsigned) gdbstub_read_byte_cont;
1771                 goto fault;
1772         }
1773
1774         if (regs->pc == (unsigned) gdbstub_read_word_guard) {
1775                 regs->pc = (unsigned) gdbstub_read_word_cont;
1776                 goto fault;
1777         }
1778
1779         if (regs->pc == (unsigned) gdbstub_read_dword_guard) {
1780                 regs->pc = (unsigned) gdbstub_read_dword_cont;
1781                 goto fault;
1782         }
1783
1784         if (regs->pc == (unsigned) gdbstub_write_byte_guard) {
1785                 regs->pc = (unsigned) gdbstub_write_byte_cont;
1786                 goto fault;
1787         }
1788
1789         if (regs->pc == (unsigned) gdbstub_write_word_guard) {
1790                 regs->pc = (unsigned) gdbstub_write_word_cont;
1791                 goto fault;
1792         }
1793
1794         if (regs->pc == (unsigned) gdbstub_write_dword_guard) {
1795                 regs->pc = (unsigned) gdbstub_write_dword_cont;
1796                 goto fault;
1797         }
1798
1799         gdbstub_printk("\n### GDB stub caused an exception ###\n");
1800
1801         /* something went horribly wrong */
1802         console_verbose();
1803         show_registers(regs);
1804
1805         panic("GDB Stub caused an unexpected exception - can't continue\n");
1806
1807         /* we caught an attempt by the stub to access silly memory */
1808 fault:
1809         gdbstub_entry("<-- gdbstub exception() = EFAULT\n");
1810         regs->d0 = -EFAULT;
1811         return;
1812 }
1813
1814 /*
1815  * send an exit message to GDB
1816  */
1817 void gdbstub_exit(int status)
1818 {
1819         unsigned char checksum;
1820         unsigned char ch;
1821         int count;
1822
1823         gdbstub_busy = 1;
1824         output_buffer[0] = 'W';
1825         output_buffer[1] = hex_asc_hi(status);
1826         output_buffer[2] = hex_asc_lo(status);
1827         output_buffer[3] = 0;
1828
1829         gdbstub_io_tx_char('$');
1830         checksum = 0;
1831         count = 0;
1832
1833         while ((ch = output_buffer[count]) != 0) {
1834                 gdbstub_io_tx_char(ch);
1835                 checksum += ch;
1836                 count += 1;
1837         }
1838
1839         gdbstub_io_tx_char('#');
1840         gdbstub_io_tx_char(hex_asc_hi(checksum));
1841         gdbstub_io_tx_char(hex_asc_lo(checksum));
1842
1843         /* make sure the output is flushed, or else RedBoot might clobber it */
1844         gdbstub_io_tx_flush();
1845
1846         gdbstub_busy = 0;
1847 }
1848
1849 /*
1850  * initialise the GDB stub
1851  */
1852 asmlinkage void __init gdbstub_init(void)
1853 {
1854 #ifdef CONFIG_GDBSTUB_IMMEDIATE
1855         unsigned char ch;
1856         int ret;
1857 #endif
1858
1859         gdbstub_busy = 1;
1860
1861         printk(KERN_INFO "%s", gdbstub_banner);
1862
1863         gdbstub_io_init();
1864
1865         gdbstub_entry("--> gdbstub_init\n");
1866
1867         /* try to talk to GDB (or anyone insane enough to want to type GDB
1868          * protocol by hand) */
1869         gdbstub_io("### GDB Tx ACK\n");
1870         gdbstub_io_tx_char('+'); /* 'hello world' */
1871
1872 #ifdef CONFIG_GDBSTUB_IMMEDIATE
1873         gdbstub_printk("GDB Stub waiting for packet\n");
1874
1875         /* in case GDB is started before us, ACK any packets that are already
1876          * sitting there (presumably "$?#xx")
1877          */
1878         do { gdbstub_io_rx_char(&ch, 0); } while (ch != '$');
1879         do { gdbstub_io_rx_char(&ch, 0); } while (ch != '#');
1880         /* eat first csum byte */
1881         do { ret = gdbstub_io_rx_char(&ch, 0); } while (ret != 0);
1882         /* eat second csum byte */
1883         do { ret = gdbstub_io_rx_char(&ch, 0); } while (ret != 0);
1884
1885         gdbstub_io("### GDB Tx NAK\n");
1886         gdbstub_io_tx_char('-'); /* NAK it */
1887
1888 #else
1889         printk("GDB Stub ready\n");
1890 #endif
1891
1892         gdbstub_busy = 0;
1893         gdbstub_entry("<-- gdbstub_init\n");
1894 }
1895
1896 /*
1897  * register the console at a more appropriate time
1898  */
1899 #ifdef CONFIG_GDBSTUB_CONSOLE
1900 static int __init gdbstub_postinit(void)
1901 {
1902         printk(KERN_NOTICE "registering console\n");
1903         register_console(&gdbstub_console);
1904         return 0;
1905 }
1906
1907 __initcall(gdbstub_postinit);
1908 #endif
1909
1910 /*
1911  * handle character reception on GDB serial port
1912  * - jump into the GDB stub if BREAK is detected on the serial line
1913  */
1914 asmlinkage void gdbstub_rx_irq(struct pt_regs *regs, enum exception_code excep)
1915 {
1916         char ch;
1917         int ret;
1918
1919         gdbstub_entry("--> gdbstub_rx_irq\n");
1920
1921         do {
1922                 ret = gdbstub_io_rx_char(&ch, 1);
1923                 if (ret != -EIO && ret != -EAGAIN) {
1924                         if (ret != -EINTR)
1925                                 gdbstub_rx_unget = ch;
1926                         gdbstub(regs, excep);
1927                 }
1928         } while (ret != -EAGAIN);
1929
1930         gdbstub_entry("<-- gdbstub_rx_irq\n");
1931 }