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