~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/mn10300/kernel/gdb-stub.c

Version: ~ [ linux-5.4 ] ~ [ linux-5.3.13 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.86 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.156 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.203 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.202 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp