arch/cris/arch-v10/kernel/kgdb.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*!**************************************************************************
   3 *!
   4 *! FILE NAME  : kgdb.c
   5 *!
   6 *! DESCRIPTION: Implementation of the gdb stub with respect to ETRAX 100.
   7 *!              It is a mix of arch/m68k/kernel/kgdb.c and cris_stub.c.
   8 *!
   9 *!---------------------------------------------------------------------------
  10 *! HISTORY
  11 *!
  12 *! DATE         NAME            CHANGES
  13 *! ----         ----            -------
  14 *! Apr 26 1999  Hendrik Ruijter Initial version.
  15 *! May  6 1999  Hendrik Ruijter Removed call to strlen in libc and removed
  16 *!                              struct assignment as it generates calls to
  17 *!                              memcpy in libc.
  18 *! Jun 17 1999  Hendrik Ruijter Added gdb 4.18 support. 'X', 'qC' and 'qL'.
  19 *! Jul 21 1999  Bjorn Wesen     eLinux port
  20 *!
  21 *!---------------------------------------------------------------------------
  22 *!
  23 *! (C) Copyright 1999, Axis Communications AB, LUND, SWEDEN
  24 *!
  25 *!**************************************************************************/
  26 /* @(#) cris_stub.c 1.3 06/17/99 */
  27
  28 /*
  29  *  kgdb usage notes:
  30  *  -----------------
  31  *
  32  * If you select CONFIG_ETRAX_KGDB in the configuration, the kernel will be
  33  * built with different gcc flags: "-g" is added to get debug infos, and
  34  * "-fomit-frame-pointer" is omitted to make debugging easier. Since the
  35  * resulting kernel will be quite big (approx. > 7 MB), it will be stripped
  36  * before compresion. Such a kernel will behave just as usually, except if
  37  * given a "debug=<device>" command line option. (Only serial devices are
  38  * allowed for <device>, i.e. no printers or the like; possible values are
  39  * machine depedend and are the same as for the usual debug device, the one
  40  * for logging kernel messages.) If that option is given and the device can be
  41  * initialized, the kernel will connect to the remote gdb in trap_init(). The
  42  * serial parameters are fixed to 8N1 and 115200 bps, for easyness of
  43  * implementation.
  44  *
  45  * To start a debugging session, start that gdb with the debugging kernel
  46  * image (the one with the symbols, vmlinux.debug) named on the command line.
  47  * This file will be used by gdb to get symbol and debugging infos about the
  48  * kernel. Next, select remote debug mode by
  49  *    target remote <device>
  50  * where <device> is the name of the serial device over which the debugged
  51  * machine is connected. Maybe you have to adjust the baud rate by
  52  *    set remotebaud <rate>
  53  * or also other parameters with stty:
  54  *    shell stty ... </dev/...
  55  * If the kernel to debug has already booted, it waited for gdb and now
  56  * connects, and you'll see a breakpoint being reported. If the kernel isn't
  57  * running yet, start it now. The order of gdb and the kernel doesn't matter.
  58  * Another thing worth knowing about in the getting-started phase is how to
  59  * debug the remote protocol itself. This is activated with
  60  *    set remotedebug 1
  61  * gdb will then print out each packet sent or received. You'll also get some
  62  * messages about the gdb stub on the console of the debugged machine.
  63  *
  64  * If all that works, you can use lots of the usual debugging techniques on
  65  * the kernel, e.g. inspecting and changing variables/memory, setting
  66  * breakpoints, single stepping and so on. It's also possible to interrupt the
  67  * debugged kernel by pressing C-c in gdb. Have fun! :-)
  68  *
  69  * The gdb stub is entered (and thus the remote gdb gets control) in the
  70  * following situations:
  71  *
  72  *  - If breakpoint() is called. This is just after kgdb initialization, or if
  73  *    a breakpoint() call has been put somewhere into the kernel source.
  74  *    (Breakpoints can of course also be set the usual way in gdb.)
  75  *    In eLinux, we call breakpoint() in init/main.c after IRQ initialization.
  76  *
  77  *  - If there is a kernel exception, i.e. bad_super_trap() or die_if_kernel()
  78  *    are entered. All the CPU exceptions are mapped to (more or less..., see
  79  *    the hard_trap_info array below) appropriate signal, which are reported
  80  *    to gdb. die_if_kernel() is usually called after some kind of access
  81  *    error and thus is reported as SIGSEGV.
  82  *
  83  *  - When panic() is called. This is reported as SIGABRT.
  84  *
  85  *  - If C-c is received over the serial line, which is treated as
  86  *    SIGINT.
  87  *
  88  * Of course, all these signals are just faked for gdb, since there is no
  89  * signal concept as such for the kernel. It also isn't possible --obviously--
  90  * to set signal handlers from inside gdb, or restart the kernel with a
  91  * signal.
  92  *
  93  * Current limitations:
  94  *
  95  *  - While the kernel is stopped, interrupts are disabled for safety reasons
  96  *    (i.e., variables not changing magically or the like). But this also
  97  *    means that the clock isn't running anymore, and that interrupts from the
  98  *    hardware may get lost/not be served in time. This can cause some device
  99  *    errors...
 100  *
 101  *  - When single-stepping, only one instruction of the current thread is
 102  *    executed, but interrupts are allowed for that time and will be serviced
 103  *    if pending. Be prepared for that.
 104  *
 105  *  - All debugging happens in kernel virtual address space. There's no way to
 106  *    access physical memory not mapped in kernel space, or to access user
 107  *    space. A way to work around this is using get_user_long & Co. in gdb
 108  *    expressions, but only for the current process.
 109  *
 110  *  - Interrupting the kernel only works if interrupts are currently allowed,
 111  *    and the interrupt of the serial line isn't blocked by some other means
 112  *    (IPL too high, disabled, ...)
 113  *
 114  *  - The gdb stub is currently not reentrant, i.e. errors that happen therein
 115  *    (e.g. accessing invalid memory) may not be caught correctly. This could
 116  *    be removed in future by introducing a stack of struct registers.
 117  *
 118  */
 119
 120 /*
 121  *  To enable debugger support, two things need to happen.  One, a
 122  *  call to kgdb_init() is necessary in order to allow any breakpoints
 123  *  or error conditions to be properly intercepted and reported to gdb.
 124  *  Two, a breakpoint needs to be generated to begin communication.  This
 125  *  is most easily accomplished by a call to breakpoint().
 126  *
 127  *    The following gdb commands are supported:
 128  *
 129  * command          function                               Return value
 130  *
 131  *    g             return the value of the CPU registers  hex data or ENN
 132  *    G             set the value of the CPU registers     OK or ENN
 133  *
 134  *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
 135  *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
 136  *
 137  *    c             Resume at current address              SNN   ( signal NN)
 138  *    cAA..AA       Continue at address AA..AA             SNN
 139  *
 140  *    s             Step one instruction                   SNN
 141  *    sAA..AA       Step one instruction from AA..AA       SNN
 142  *
 143  *    k             kill
 144  *
 145  *    ?             What was the last sigval ?             SNN   (signal NN)
 146  *
 147  *    bBB..BB       Set baud rate to BB..BB                OK or BNN, then sets
 148  *                                                         baud rate
 149  *
 150  * All commands and responses are sent with a packet which includes a
 151  * checksum.  A packet consists of
 152  *
 153  * $<packet info>#<checksum>.
 154  *
 155  * where
 156  * <packet info> :: <characters representing the command or response>
 157  * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
 158  *
 159  * When a packet is received, it is first acknowledged with either '+' or '-'.
 160  * '+' indicates a successful transfer.  '-' indicates a failed transfer.
 161  *
 162  * Example:
 163  *
 164  * Host:                  Reply:
 165  * $m0,10#2a               +$00010203040506070809101112131415#42
 166  *
 167  */
 168
 169
 170 #include <linux/string.h>
 171 #include <linux/signal.h>
 172 #include <linux/kernel.h>
 173 #include <linux/delay.h>
 174 #include <linux/linkage.h>
 175 #include <linux/reboot.h>
 176
 177 #include <asm/setup.h>
 178 #include <asm/ptrace.h>
 179
 180 #include <arch/svinto.h>
 181 #include <asm/irq.h>
 182
 183 static int kgdb_started = 0;
 184
 185 /********************************* Register image ****************************/
 186 /* Use the order of registers as defined in "AXIS ETRAX CRIS Programmer's
 187    Reference", p. 1-1, with the additional register definitions of the
 188    ETRAX 100LX in cris-opc.h.
 189    There are 16 general 32-bit registers, R0-R15, where R14 is the stack
 190    pointer, SP, and R15 is the program counter, PC.
 191    There are 16 special registers, P0-P15, where three of the unimplemented
 192    registers, P0, P4 and P8, are reserved as zero-registers. A read from
 193    any of these registers returns zero and a write has no effect. */
 194
 195 typedef
 196 struct register_image
 197 {
 198         /* Offset */
 199         unsigned int     r0;   /* 0x00 */
 200         unsigned int     r1;   /* 0x04 */
 201         unsigned int     r2;   /* 0x08 */
 202         unsigned int     r3;   /* 0x0C */
 203         unsigned int     r4;   /* 0x10 */
 204         unsigned int     r5;   /* 0x14 */
 205         unsigned int     r6;   /* 0x18 */
 206         unsigned int     r7;   /* 0x1C */
 207         unsigned int     r8;   /* 0x20 Frame pointer */
 208         unsigned int     r9;   /* 0x24 */
 209         unsigned int    r10;   /* 0x28 */
 210         unsigned int    r11;   /* 0x2C */
 211         unsigned int    r12;   /* 0x30 */
 212         unsigned int    r13;   /* 0x34 */
 213         unsigned int     sp;   /* 0x38 Stack pointer */
 214         unsigned int     pc;   /* 0x3C Program counter */
 215
 216         unsigned char    p0;   /* 0x40 8-bit zero-register */
 217         unsigned char    vr;   /* 0x41 Version register */
 218
 219         unsigned short   p4;   /* 0x42 16-bit zero-register */
 220         unsigned short  ccr;   /* 0x44 Condition code register */
 221
 222         unsigned int    mof;   /* 0x46 Multiply overflow register */
 223
 224         unsigned int     p8;   /* 0x4A 32-bit zero-register */
 225         unsigned int    ibr;   /* 0x4E Interrupt base register */
 226         unsigned int    irp;   /* 0x52 Interrupt return pointer */
 227         unsigned int    srp;   /* 0x56 Subroutine return pointer */
 228         unsigned int    bar;   /* 0x5A Breakpoint address register */
 229         unsigned int   dccr;   /* 0x5E Double condition code register */
 230         unsigned int    brp;   /* 0x62 Breakpoint return pointer (pc in caller) */
 231         unsigned int    usp;   /* 0x66 User mode stack pointer */
 232 } registers;
 233
 234 /* Serial port, reads one character. ETRAX 100 specific. from debugport.c */
 235 int getDebugChar (void);
 236
 237 /* Serial port, writes one character. ETRAX 100 specific. from debugport.c */
 238 void putDebugChar (int val);
 239
 240 void enableDebugIRQ (void);
 241
 242 /******************** Prototypes for global functions. ***********************/
 243
 244 /* The string str is prepended with the GDB printout token and sent. */
 245 void putDebugString (const unsigned char *str, int length); /* used by etrax100ser.c */
 246
 247 /* The hook for both static (compiled) and dynamic breakpoints set by GDB.
 248    ETRAX 100 specific. */
 249 void handle_breakpoint (void);                          /* used by irq.c */
 250
 251 /* The hook for an interrupt generated by GDB. ETRAX 100 specific. */
 252 void handle_interrupt (void);                           /* used by irq.c */
 253
 254 /* A static breakpoint to be used at startup. */
 255 void breakpoint (void);                                 /* called by init/main.c */
 256
 257 /* From osys_int.c, executing_task contains the number of the current
 258    executing task in osys. Does not know of object-oriented threads. */
 259 extern unsigned char executing_task;
 260
 261 /* The number of characters used for a 64 bit thread identifier. */
 262 #define HEXCHARS_IN_THREAD_ID 16
 263
 264 /********************************** Packet I/O ******************************/
 265 /* BUFMAX defines the maximum number of characters in
 266    inbound/outbound buffers */
 267 #define BUFMAX 512
 268
 269 /* Run-length encoding maximum length. Send 64 at most. */
 270 #define RUNLENMAX 64
 271
 272 /* The inbound/outbound buffers used in packet I/O */
 273 static char remcomInBuffer[BUFMAX];
 274 static char remcomOutBuffer[BUFMAX];
 275
 276 /* Error and warning messages. */
 277 enum error_type
 278 {
 279         SUCCESS, E01, E02, E03, E04, E05, E06, E07, E08
 280 };
 281 static char *error_message[] =
 282 {
 283         "",
 284         "E01 Set current or general thread - H[c,g] - internal error.",
 285         "E02 Change register content - P - cannot change read-only register.",
 286         "E03 Thread is not alive.", /* T, not used. */
 287         "E04 The command is not supported - [s,C,S,!,R,d,r] - internal error.",
 288         "E05 Change register content - P - the register is not implemented..",
 289         "E06 Change memory content - M - internal error.",
 290         "E07 Change register content - P - the register is not stored on the stack",
 291         "E08 Invalid parameter"
 292 };
 293 /********************************* Register image ****************************/
 294 /* Use the order of registers as defined in "AXIS ETRAX CRIS Programmer's
 295    Reference", p. 1-1, with the additional register definitions of the
 296    ETRAX 100LX in cris-opc.h.
 297    There are 16 general 32-bit registers, R0-R15, where R14 is the stack
 298    pointer, SP, and R15 is the program counter, PC.
 299    There are 16 special registers, P0-P15, where three of the unimplemented
 300    registers, P0, P4 and P8, are reserved as zero-registers. A read from
 301    any of these registers returns zero and a write has no effect. */
 302 enum register_name
 303 {
 304         R0,  R1,   R2,  R3,
 305         R4,  R5,   R6,  R7,
 306         R8,  R9,   R10, R11,
 307         R12, R13,  SP,  PC,
 308         P0,  VR,   P2,  P3,
 309         P4,  CCR,  P6,  MOF,
 310         P8,  IBR,  IRP, SRP,
 311         BAR, DCCR, BRP, USP
 312 };
 313
 314 /* The register sizes of the registers in register_name. An unimplemented register
 315    is designated by size 0 in this array. */
 316 static int register_size[] =
 317 {
 318         4, 4, 4, 4,
 319         4, 4, 4, 4,
 320         4, 4, 4, 4,
 321         4, 4, 4, 4,
 322         1, 1, 0, 0,
 323         2, 2, 0, 4,
 324         4, 4, 4, 4,
 325         4, 4, 4, 4
 326 };
 327
 328 /* Contains the register image of the executing thread in the assembler
 329    part of the code in order to avoid horrible addressing modes. */
 330 registers cris_reg;
 331
 332 /* FIXME: Should this be used? Delete otherwise. */
 333 /* Contains the assumed consistency state of the register image. Uses the
 334    enum error_type for state information. */
 335 static int consistency_status = SUCCESS;
 336
 337 /********************************** Handle exceptions ************************/
 338 /* The variable cris_reg contains the register image associated with the
 339    current_thread_c variable. It is a complete register image created at
 340    entry. The reg_g contains a register image of a task where the general
 341    registers are taken from the stack and all special registers are taken
 342    from the executing task. It is associated with current_thread_g and used
 343    in order to provide access mainly for 'g', 'G' and 'P'.
 344 */
 345
 346 /********************************** Breakpoint *******************************/
 347 /* Use an internal stack in the breakpoint and interrupt response routines */
 348 #define INTERNAL_STACK_SIZE 1024
 349 char internal_stack[INTERNAL_STACK_SIZE];
 350
 351 /* Due to the breakpoint return pointer, a state variable is needed to keep
 352    track of whether it is a static (compiled) or dynamic (gdb-invoked)
 353    breakpoint to be handled. A static breakpoint uses the content of register
 354    BRP as it is whereas a dynamic breakpoint requires subtraction with 2
 355    in order to execute the instruction. The first breakpoint is static. */
 356 static unsigned char __used is_dyn_brkp;
 357
 358 /********************************* String library ****************************/
 359 /* Single-step over library functions creates trap loops. */
 360
 361 /* Copy char s2[] to s1[]. */
 362 static char*
 363 gdb_cris_strcpy (char *s1, const char *s2)
 364 {
 365         char *s = s1;
 366
 367         for (s = s1; (*s++ = *s2++) != '\0'; )
 368                 ;
 369         return (s1);
 370 }
 371
 372 /* Find length of s[]. */
 373 static int
 374 gdb_cris_strlen (const char *s)
 375 {
 376         const char *sc;
 377
 378         for (sc = s; *sc != '\0'; sc++)
 379                 ;
 380         return (sc - s);
 381 }
 382
 383 /* Find first occurrence of c in s[n]. */
 384 static void*
 385 gdb_cris_memchr (const void *s, int c, int n)
 386 {
 387         const unsigned char uc = c;
 388         const unsigned char *su;
 389
 390         for (su = s; 0 < n; ++su, --n)
 391                 if (*su == uc)
 392                         return ((void *)su);
 393         return (NULL);
 394 }
 395 /******************************* Standard library ****************************/
 396 /* Single-step over library functions creates trap loops. */
 397 /* Convert string to long. */
 398 static int
 399 gdb_cris_strtol (const char *s, char **endptr, int base)
 400 {
 401         char *s1;
 402         char *sd;
 403         int x = 0;
 404
 405         for (s1 = (char*)s; (sd = gdb_cris_memchr(hex_asc, *s1, base)) != NULL; ++s1)
 406                 x = x * base + (sd - hex_asc);
 407
 408         if (endptr)
 409         {
 410                 /* Unconverted suffix is stored in endptr unless endptr is NULL. */
 411                 *endptr = s1;
 412         }
 413
 414         return x;
 415 }
 416
 417 /********************************** Packet I/O ******************************/
 418
 419 /* Convert the memory, pointed to by mem into hexadecimal representation.
 420    Put the result in buf, and return a pointer to the last character
 421    in buf (null). */
 422
 423 static char *
 424 mem2hex(char *buf, unsigned char *mem, int count)
 425 {
 426         int i;
 427         int ch;
 428
 429         if (mem == NULL) {
 430                 /* Bogus read from m0. FIXME: What constitutes a valid address? */
 431                 for (i = 0; i < count; i++) {
 432                         *buf++ = '0';
 433                         *buf++ = '0';
 434                 }
 435         } else {
 436                 /* Valid mem address. */
 437                 for (i = 0; i < count; i++) {
 438                         ch = *mem++;
 439                         buf = hex_byte_pack(buf, ch);
 440                 }
 441         }
 442
 443         /* Terminate properly. */
 444         *buf = '\0';
 445         return (buf);
 446 }
 447
 448 /* Put the content of the array, in binary representation, pointed to by buf
 449    into memory pointed to by mem, and return a pointer to the character after
 450    the last byte written.
 451    Gdb will escape $, #, and the escape char (0x7d). */
 452 static unsigned char*
 453 bin2mem (unsigned char *mem, unsigned char *buf, int count)
 454 {
 455         int i;
 456         unsigned char *next;
 457         for (i = 0; i < count; i++) {
 458                 /* Check for any escaped characters. Be paranoid and
 459                    only unescape chars that should be escaped. */
 460                 if (*buf == 0x7d) {
 461                         next = buf + 1;
 462                         if (*next == 0x3 || *next == 0x4 || *next == 0x5D) /* #, $, ESC */
 463                                 {
 464                                         buf++;
 465                                         *buf += 0x20;
 466                                 }
 467                 }
 468                 *mem++ = *buf++;
 469         }
 470         return (mem);
 471 }
 472
 473 /* Await the sequence $<data>#<checksum> and store <data> in the array buffer
 474    returned. */
 475 static void
 476 getpacket (char *buffer)
 477 {
 478         unsigned char checksum;
 479         unsigned char xmitcsum;
 480         int i;
 481         int count;
 482         char ch;
 483         do {
 484                 while ((ch = getDebugChar ()) != '$')
 485                         /* Wait for the start character $ and ignore all other characters */;
 486                 checksum = 0;
 487                 xmitcsum = -1;
 488                 count = 0;
 489                 /* Read until a # or the end of the buffer is reached */
 490                 while (count < BUFMAX - 1) {
 491                         ch = getDebugChar ();
 492                         if (ch == '#')
 493                                 break;
 494                         checksum = checksum + ch;
 495                         buffer[count] = ch;
 496                         count = count + 1;
 497                 }
 498                 buffer[count] = '\0';
 499
 500                 if (ch == '#') {
 501                         xmitcsum = hex_to_bin(getDebugChar()) << 4;
 502                         xmitcsum += hex_to_bin(getDebugChar());
 503                         if (checksum != xmitcsum) {
 504                                 /* Wrong checksum */
 505                                 putDebugChar ('-');
 506                         }
 507                         else {
 508                                 /* Correct checksum */
 509                                 putDebugChar ('+');
 510                                 /* If sequence characters are received, reply with them */
 511                                 if (buffer[2] == ':') {
 512                                         putDebugChar (buffer[0]);
 513                                         putDebugChar (buffer[1]);
 514                                         /* Remove the sequence characters from the buffer */
 515                                         count = gdb_cris_strlen (buffer);
 516                                         for (i = 3; i <= count; i++)
 517                                                 buffer[i - 3] = buffer[i];
 518                                 }
 519                         }
 520                 }
 521         } while (checksum != xmitcsum);
 522 }
 523
 524 /* Send $<data>#<checksum> from the <data> in the array buffer. */
 525
 526 static void
 527 putpacket(char *buffer)
 528 {
 529         int checksum;
 530         int runlen;
 531         int encode;
 532
 533         do {
 534                 char *src = buffer;
 535                 putDebugChar ('$');
 536                 checksum = 0;
 537                 while (*src) {
 538                         /* Do run length encoding */
 539                         putDebugChar (*src);
 540                         checksum += *src;
 541                         runlen = 0;
 542                         while (runlen < RUNLENMAX && *src == src[runlen]) {
 543                                 runlen++;
 544                         }
 545                         if (runlen > 3) {
 546                                 /* Got a useful amount */
 547                                 putDebugChar ('*');
 548                                 checksum += '*';
 549                                 encode = runlen + ' ' - 4;
 550                                 putDebugChar (encode);
 551                                 checksum += encode;
 552                                 src += runlen;
 553                         }
 554                         else {
 555                                 src++;
 556                         }
 557                 }
 558                 putDebugChar('#');
 559                 putDebugChar(hex_asc_hi(checksum));
 560                 putDebugChar(hex_asc_lo(checksum));
 561         } while(kgdb_started && (getDebugChar() != '+'));
 562 }
 563
 564 /* The string str is prepended with the GDB printout token and sent. Required
 565    in traditional implementations. */
 566 void
 567 putDebugString (const unsigned char *str, int length)
 568 {
 569         remcomOutBuffer[0] = 'O';
 570         mem2hex(&remcomOutBuffer[1], (unsigned char *)str, length);
 571         putpacket(remcomOutBuffer);
 572 }
 573
 574 /********************************* Register image ****************************/
 575 /* Write a value to a specified register in the register image of the current
 576    thread. Returns status code SUCCESS, E02, E05 or E08. */
 577 static int
 578 write_register (int regno, char *val)
 579 {
 580         int status = SUCCESS;
 581         registers *current_reg = &cris_reg;
 582
 583         if (regno >= R0 && regno <= PC) {
 584                 /* 32-bit register with simple offset. */
 585                 if (hex2bin((unsigned char *)current_reg + regno * sizeof(unsigned int),
 586                             val, sizeof(unsigned int)))
 587                         status = E08;
 588         }
 589         else if (regno == P0 || regno == VR || regno == P4 || regno == P8) {
 590                 /* Do not support read-only registers. */
 591                 status = E02;
 592         }
 593         else if (regno == CCR) {
 594                 /* 16 bit register with complex offset. (P4 is read-only, P6 is not implemented,
 595                    and P7 (MOF) is 32 bits in ETRAX 100LX. */
 596                 if (hex2bin((unsigned char *)&(current_reg->ccr) + (regno-CCR) * sizeof(unsigned short),
 597                             val, sizeof(unsigned short)))
 598                         status = E08;
 599         }
 600         else if (regno >= MOF && regno <= USP) {
 601                 /* 32 bit register with complex offset.  (P8 has been taken care of.) */
 602                 if (hex2bin((unsigned char *)&(current_reg->ibr) + (regno-IBR) * sizeof(unsigned int),
 603                             val, sizeof(unsigned int)))
 604                         status = E08;
 605         }
 606         else {
 607                 /* Do not support nonexisting or unimplemented registers (P2, P3, and P6). */
 608                 status = E05;
 609         }
 610         return status;
 611 }
 612
 613 /* Read a value from a specified register in the register image. Returns the
 614    value in the register or -1 for non-implemented registers.
 615    Should check consistency_status after a call which may be E05 after changes
 616    in the implementation. */
 617 static int
 618 read_register (char regno, unsigned int *valptr)
 619 {
 620         registers *current_reg = &cris_reg;
 621
 622         if (regno >= R0 && regno <= PC) {
 623                 /* 32-bit register with simple offset. */
 624                 *valptr = *(unsigned int *)((char *)current_reg + regno * sizeof(unsigned int));
 625                 return SUCCESS;
 626         }
 627         else if (regno == P0 || regno == VR) {
 628                 /* 8 bit register with complex offset. */
 629                 *valptr = (unsigned int)(*(unsigned char *)
 630                                          ((char *)&(current_reg->p0) + (regno-P0) * sizeof(char)));
 631                 return SUCCESS;
 632         }
 633         else if (regno == P4 || regno == CCR) {
 634                 /* 16 bit register with complex offset. */
 635                 *valptr = (unsigned int)(*(unsigned short *)
 636                                          ((char *)&(current_reg->p4) + (regno-P4) * sizeof(unsigned short)));
 637                 return SUCCESS;
 638         }
 639         else if (regno >= MOF && regno <= USP) {
 640                 /* 32 bit register with complex offset. */
 641                 *valptr = *(unsigned int *)((char *)&(current_reg->p8)
 642                                             + (regno-P8) * sizeof(unsigned int));
 643                 return SUCCESS;
 644         }
 645         else {
 646                 /* Do not support nonexisting or unimplemented registers (P2, P3, and P6). */
 647                 consistency_status = E05;
 648                 return E05;
 649         }
 650 }
 651
 652 /********************************** Handle exceptions ************************/
 653 /* Build and send a response packet in order to inform the host the
 654    stub is stopped. TAAn...:r...;n...:r...;n...:r...;
 655                     AA = signal number
 656                     n... = register number (hex)
 657                     r... = register contents
 658                     n... = `thread'
 659                     r... = thread process ID.  This is a hex integer.
 660                     n... = other string not starting with valid hex digit.
 661                     gdb should ignore this n,r pair and go on to the next.
 662                     This way we can extend the protocol. */
 663 static void
 664 stub_is_stopped(int sigval)
 665 {
 666         char *ptr = remcomOutBuffer;
 667         int regno;
 668
 669         unsigned int reg_cont;
 670         int status;
 671
 672         /* Send trap type (converted to signal) */
 673
 674         *ptr++ = 'T';
 675         ptr = hex_byte_pack(ptr, sigval);
 676
 677         /* Send register contents. We probably only need to send the
 678          * PC, frame pointer and stack pointer here. Other registers will be
 679          * explicitly asked for. But for now, send all.
 680          */
 681
 682         for (regno = R0; regno <= USP; regno++) {
 683                 /* Store n...:r...; for the registers in the buffer. */
 684
 685                 status = read_register (regno, &reg_cont);
 686
 687                 if (status == SUCCESS) {
 688                         ptr = hex_byte_pack(ptr, regno);
 689                         *ptr++ = ':';
 690
 691                         ptr = mem2hex(ptr, (unsigned char *)&reg_cont,
 692                                       register_size[regno]);
 693                         *ptr++ = ';';
 694                 }
 695
 696         }
 697
 698         /* null-terminate and send it off */
 699
 700         *ptr = 0;
 701
 702         putpacket (remcomOutBuffer);
 703 }
 704
 705 /* Performs a complete re-start from scratch. */
 706 static void
 707 kill_restart (void)
 708 {
 709         machine_restart("");
 710 }
 711
 712 /* All expected commands are sent from remote.c. Send a response according
 713    to the description in remote.c. */
 714 void
 715 handle_exception (int sigval)
 716 {
 717         /* Send response. */
 718
 719         stub_is_stopped (sigval);
 720
 721         for (;;) {
 722                 remcomOutBuffer[0] = '\0';
 723                 getpacket (remcomInBuffer);
 724                 switch (remcomInBuffer[0]) {
 725                         case 'g':
 726                                 /* Read registers: g
 727                                    Success: Each byte of register data is described by two hex digits.
 728                                    Registers are in the internal order for GDB, and the bytes
 729                                    in a register  are in the same order the machine uses.
 730                                    Failure: void. */
 731
 732                                 mem2hex(remcomOutBuffer, (char *)&cris_reg, sizeof(registers));
 733                                 break;
 734
 735                         case 'G':
 736                                 /* Write registers. GXX..XX
 737                                    Each byte of register data  is described by two hex digits.
 738                                    Success: OK
 739                                    Failure: E08. */
 740                                 if (hex2bin((char *)&cris_reg, &remcomInBuffer[1], sizeof(registers)))
 741                                         gdb_cris_strcpy (remcomOutBuffer, error_message[E08]);
 742                                 else
 743                                         gdb_cris_strcpy (remcomOutBuffer, "OK");
 744                                 break;
 745
 746                         case 'P':
 747                                 /* Write register. Pn...=r...
 748                                    Write register n..., hex value without 0x, with value r...,
 749                                    which contains a hex value without 0x and two hex digits
 750                                    for each byte in the register (target byte order). P1f=11223344 means
 751                                    set register 31 to 44332211.
 752                                    Success: OK
 753                                    Failure: E02, E05, E08 */
 754                                 {
 755                                         char *suffix;
 756                                         int regno = gdb_cris_strtol (&remcomInBuffer[1], &suffix, 16);
 757                                         int status;
 758                                         status = write_register (regno, suffix+1);
 759
 760                                         switch (status) {
 761                                                 case E02:
 762                                                         /* Do not support read-only registers. */
 763                                                         gdb_cris_strcpy (remcomOutBuffer, error_message[E02]);
 764                                                         break;
 765                                                 case E05:
 766                                                         /* Do not support non-existing registers. */
 767                                                         gdb_cris_strcpy (remcomOutBuffer, error_message[E05]);
 768                                                         break;
 769                                                 case E07:
 770                                                         /* Do not support non-existing registers on the stack. */
 771                                                         gdb_cris_strcpy (remcomOutBuffer, error_message[E07]);
 772                                                         break;
 773                                                 case E08:
 774                                                         /* Invalid parameter. */
 775                                                         gdb_cris_strcpy (remcomOutBuffer, error_message[E08]);
 776                                                         break;
 777                                                 default:
 778                                                         /* Valid register number. */
 779                                                         gdb_cris_strcpy (remcomOutBuffer, "OK");
 780                                                         break;
 781                                         }
 782                                 }
 783                                 break;
 784
 785                         case 'm':
 786                                 /* Read from memory. mAA..AA,LLLL
 787                                    AA..AA is the address and LLLL is the length.
 788                                    Success: XX..XX is the memory content.  Can be fewer bytes than
 789                                    requested if only part of the data may be read. m6000120a,6c means
 790                                    retrieve 108 byte from base address 6000120a.
 791                                    Failure: void. */
 792                                 {
 793                                         char *suffix;
 794                                         unsigned char *addr = (unsigned char *)gdb_cris_strtol(&remcomInBuffer[1],
 795                                                                                                &suffix, 16);                                        int length = gdb_cris_strtol(suffix+1, 0, 16);
 796
 797                                         mem2hex(remcomOutBuffer, addr, length);
 798                                 }
 799                                 break;
 800
 801                         case 'X':
 802                                 /* Write to memory. XAA..AA,LLLL:XX..XX
 803                                    AA..AA is the start address,  LLLL is the number of bytes, and
 804                                    XX..XX is the binary data.
 805                                    Success: OK
 806                                    Failure: void. */
 807                         case 'M':
 808                                 /* Write to memory. MAA..AA,LLLL:XX..XX
 809                                    AA..AA is the start address,  LLLL is the number of bytes, and
 810                                    XX..XX is the hexadecimal data.
 811                                    Success: OK
 812                                    Failure: E08. */
 813                                 {
 814                                         char *lenptr;
 815                                         char *dataptr;
 816                                         unsigned char *addr = (unsigned char *)gdb_cris_strtol(&remcomInBuffer[1],
 817                                                                                       &lenptr, 16);
 818                                         int length = gdb_cris_strtol(lenptr+1, &dataptr, 16);
 819                                         if (*lenptr == ',' && *dataptr == ':') {
 820                                                 if (remcomInBuffer[0] == 'M') {
 821                                                         if (hex2bin(addr, dataptr + 1, length))
 822                                                                 gdb_cris_strcpy (remcomOutBuffer, error_message[E08]);
 823                                                         else
 824                                                                 gdb_cris_strcpy (remcomOutBuffer, "OK");
 825                                                 } else /* X */ {
 826                                                         bin2mem(addr, dataptr + 1, length);
 827                                                         gdb_cris_strcpy (remcomOutBuffer, "OK");
 828                                                 }
 829                                         } else {
 830                                                 gdb_cris_strcpy (remcomOutBuffer, error_message[E06]);
 831                                         }
 832                                 }
 833                                 break;
 834
 835                         case 'c':
 836                                 /* Continue execution. cAA..AA
 837                                    AA..AA is the address where execution is resumed. If AA..AA is
 838                                    omitted, resume at the present address.
 839                                    Success: return to the executing thread.
 840                                    Failure: will never know. */
 841                                 if (remcomInBuffer[1] != '\0') {
 842                                         cris_reg.pc = gdb_cris_strtol (&remcomInBuffer[1], 0, 16);
 843                                 }
 844                                 enableDebugIRQ();
 845                                 return;
 846
 847                         case 's':
 848                                 /* Step. sAA..AA
 849                                    AA..AA is the address where execution is resumed. If AA..AA is
 850                                    omitted, resume at the present address. Success: return to the
 851                                    executing thread. Failure: will never know.
 852
 853                                    Should never be invoked. The single-step is implemented on
 854                                    the host side. If ever invoked, it is an internal error E04. */
 855                                 gdb_cris_strcpy (remcomOutBuffer, error_message[E04]);
 856                                 putpacket (remcomOutBuffer);
 857                                 return;
 858
 859                         case '?':
 860                                 /* The last signal which caused a stop. ?
 861                                    Success: SAA, where AA is the signal number.
 862                                    Failure: void. */
 863                                 remcomOutBuffer[0] = 'S';
 864                                 remcomOutBuffer[1] = hex_asc_hi(sigval);
 865                                 remcomOutBuffer[2] = hex_asc_lo(sigval);
 866                                 remcomOutBuffer[3] = 0;
 867                                 break;
 868
 869                         case 'D':
 870                                 /* Detach from host. D
 871                                    Success: OK, and return to the executing thread.
 872                                    Failure: will never know */
 873                                 putpacket ("OK");
 874                                 return;
 875
 876                         case 'k':
 877                         case 'r':
 878                                 /* kill request or reset request.
 879                                    Success: restart of target.
 880                                    Failure: will never know. */
 881                                 kill_restart ();
 882                                 break;
 883
 884                         case 'C':
 885                         case 'S':
 886                         case '!':
 887                         case 'R':
 888                         case 'd':
 889                                 /* Continue with signal sig. Csig;AA..AA
 890                                    Step with signal sig. Ssig;AA..AA
 891                                    Use the extended remote protocol. !
 892                                    Restart the target system. R0
 893                                    Toggle debug flag. d
 894                                    Search backwards. tAA:PP,MM
 895                                    Not supported: E04 */
 896                                 gdb_cris_strcpy (remcomOutBuffer, error_message[E04]);
 897                                 break;
 898
 899                         default:
 900                                 /* The stub should ignore other request and send an empty
 901                                    response ($#<checksum>). This way we can extend the protocol and GDB
 902                                    can tell whether the stub it is talking to uses the old or the new. */
 903                                 remcomOutBuffer[0] = 0;
 904                                 break;
 905                 }
 906                 putpacket(remcomOutBuffer);
 907         }
 908 }
 909
 910 /********************************** Breakpoint *******************************/
 911 /* The hook for both a static (compiled) and a dynamic breakpoint set by GDB.
 912    An internal stack is used by the stub. The register image of the caller is
 913    stored in the structure register_image.
 914    Interactive communication with the host is handled by handle_exception and
 915    finally the register image is restored. */
 916
 917 void kgdb_handle_breakpoint(void);
 918
 919 asm ("\n"
 920 "  .global kgdb_handle_breakpoint\n"
 921 "kgdb_handle_breakpoint:\n"
 922 ";;\n"
 923 ";; Response to the break-instruction\n"
 924 ";;\n"
 925 ";; Create a register image of the caller\n"
 926 ";;\n"
 927 "  move     $dccr,[cris_reg+0x5E] ; Save the flags in DCCR before disable interrupts\n"
 928 "  di                        ; Disable interrupts\n"
 929 "  move.d   $r0,[cris_reg]        ; Save R0\n"
 930 "  move.d   $r1,[cris_reg+0x04]   ; Save R1\n"
 931 "  move.d   $r2,[cris_reg+0x08]   ; Save R2\n"
 932 "  move.d   $r3,[cris_reg+0x0C]   ; Save R3\n"
 933 "  move.d   $r4,[cris_reg+0x10]   ; Save R4\n"
 934 "  move.d   $r5,[cris_reg+0x14]   ; Save R5\n"
 935 "  move.d   $r6,[cris_reg+0x18]   ; Save R6\n"
 936 "  move.d   $r7,[cris_reg+0x1C]   ; Save R7\n"
 937 "  move.d   $r8,[cris_reg+0x20]   ; Save R8\n"
 938 "  move.d   $r9,[cris_reg+0x24]   ; Save R9\n"
 939 "  move.d   $r10,[cris_reg+0x28]  ; Save R10\n"
 940 "  move.d   $r11,[cris_reg+0x2C]  ; Save R11\n"
 941 "  move.d   $r12,[cris_reg+0x30]  ; Save R12\n"
 942 "  move.d   $r13,[cris_reg+0x34]  ; Save R13\n"
 943 "  move.d   $sp,[cris_reg+0x38]   ; Save SP (R14)\n"
 944 ";; Due to the old assembler-versions BRP might not be recognized\n"
 945 "  .word 0xE670              ; move brp,$r0\n"
 946 "  subq     2,$r0             ; Set to address of previous instruction.\n"
 947 "  move.d   $r0,[cris_reg+0x3c]   ; Save the address in PC (R15)\n"
 948 "  clear.b  [cris_reg+0x40]      ; Clear P0\n"
 949 "  move     $vr,[cris_reg+0x41]   ; Save special register P1\n"
 950 "  clear.w  [cris_reg+0x42]      ; Clear P4\n"
 951 "  move     $ccr,[cris_reg+0x44]  ; Save special register CCR\n"
 952 "  move     $mof,[cris_reg+0x46]  ; P7\n"
 953 "  clear.d  [cris_reg+0x4A]      ; Clear P8\n"
 954 "  move     $ibr,[cris_reg+0x4E]  ; P9,\n"
 955 "  move     $irp,[cris_reg+0x52]  ; P10,\n"
 956 "  move     $srp,[cris_reg+0x56]  ; P11,\n"
 957 "  move     $bar,[cris_reg+0x5A]  ; P12,\n"
 958 "                            ; P13, register DCCR already saved\n"
 959 ";; Due to the old assembler-versions BRP might not be recognized\n"
 960 "  .word 0xE670              ; move brp,r0\n"
 961 ";; Static (compiled) breakpoints must return to the next instruction in order\n"
 962 ";; to avoid infinite loops. Dynamic (gdb-invoked) must restore the instruction\n"
 963 ";; in order to execute it when execution is continued.\n"
 964 "  test.b   [is_dyn_brkp]    ; Is this a dynamic breakpoint?\n"
 965 "  beq      is_static         ; No, a static breakpoint\n"
 966 "  nop\n"
 967 "  subq     2,$r0              ; rerun the instruction the break replaced\n"
 968 "is_static:\n"
 969 "  moveq    1,$r1\n"
 970 "  move.b   $r1,[is_dyn_brkp] ; Set the state variable to dynamic breakpoint\n"
 971 "  move.d   $r0,[cris_reg+0x62]    ; Save the return address in BRP\n"
 972 "  move     $usp,[cris_reg+0x66]   ; USP\n"
 973 ";;\n"
 974 ";; Handle the communication\n"
 975 ";;\n"
 976 "  move.d   internal_stack+1020,$sp ; Use the internal stack which grows upward\n"
 977 "  moveq    5,$r10                   ; SIGTRAP\n"
 978 "  jsr      handle_exception       ; Interactive routine\n"
 979 ";;\n"
 980 ";; Return to the caller\n"
 981 ";;\n"
 982 "   move.d  [cris_reg],$r0         ; Restore R0\n"
 983 "   move.d  [cris_reg+0x04],$r1    ; Restore R1\n"
 984 "   move.d  [cris_reg+0x08],$r2    ; Restore R2\n"
 985 "   move.d  [cris_reg+0x0C],$r3    ; Restore R3\n"
 986 "   move.d  [cris_reg+0x10],$r4    ; Restore R4\n"
 987 "   move.d  [cris_reg+0x14],$r5    ; Restore R5\n"
 988 "   move.d  [cris_reg+0x18],$r6    ; Restore R6\n"
 989 "   move.d  [cris_reg+0x1C],$r7    ; Restore R7\n"
 990 "   move.d  [cris_reg+0x20],$r8    ; Restore R8\n"
 991 "   move.d  [cris_reg+0x24],$r9    ; Restore R9\n"
 992 "   move.d  [cris_reg+0x28],$r10   ; Restore R10\n"
 993 "   move.d  [cris_reg+0x2C],$r11   ; Restore R11\n"
 994 "   move.d  [cris_reg+0x30],$r12   ; Restore R12\n"
 995 "   move.d  [cris_reg+0x34],$r13   ; Restore R13\n"
 996 ";;\n"
 997 ";; FIXME: Which registers should be restored?\n"
 998 ";;\n"
 999 "   move.d  [cris_reg+0x38],$sp    ; Restore SP (R14)\n"
1000 "   move    [cris_reg+0x56],$srp   ; Restore the subroutine return pointer.\n"
1001 "   move    [cris_reg+0x5E],$dccr  ; Restore DCCR\n"
1002 "   move    [cris_reg+0x66],$usp   ; Restore USP\n"
1003 "   jump    [cris_reg+0x62]       ; A jump to the content in register BRP works.\n"
1004 "   nop                       ;\n"
1005 "\n");
1006
1007 /* The hook for an interrupt generated by GDB. An internal stack is used
1008    by the stub. The register image of the caller is stored in the structure
1009    register_image. Interactive communication with the host is handled by
1010    handle_exception and finally the register image is restored. Due to the
1011    old assembler which does not recognise the break instruction and the
1012    breakpoint return pointer hex-code is used. */
1013
1014 void kgdb_handle_serial(void);
1015
1016 asm ("\n"
1017 "  .global kgdb_handle_serial\n"
1018 "kgdb_handle_serial:\n"
1019 ";;\n"
1020 ";; Response to a serial interrupt\n"
1021 ";;\n"
1022 "\n"
1023 "  move     $dccr,[cris_reg+0x5E] ; Save the flags in DCCR\n"
1024 "  di                        ; Disable interrupts\n"
1025 "  move.d   $r0,[cris_reg]        ; Save R0\n"
1026 "  move.d   $r1,[cris_reg+0x04]   ; Save R1\n"
1027 "  move.d   $r2,[cris_reg+0x08]   ; Save R2\n"
1028 "  move.d   $r3,[cris_reg+0x0C]   ; Save R3\n"
1029 "  move.d   $r4,[cris_reg+0x10]   ; Save R4\n"
1030 "  move.d   $r5,[cris_reg+0x14]   ; Save R5\n"
1031 "  move.d   $r6,[cris_reg+0x18]   ; Save R6\n"
1032 "  move.d   $r7,[cris_reg+0x1C]   ; Save R7\n"
1033 "  move.d   $r8,[cris_reg+0x20]   ; Save R8\n"
1034 "  move.d   $r9,[cris_reg+0x24]   ; Save R9\n"
1035 "  move.d   $r10,[cris_reg+0x28]  ; Save R10\n"
1036 "  move.d   $r11,[cris_reg+0x2C]  ; Save R11\n"
1037 "  move.d   $r12,[cris_reg+0x30]  ; Save R12\n"
1038 "  move.d   $r13,[cris_reg+0x34]  ; Save R13\n"
1039 "  move.d   $sp,[cris_reg+0x38]   ; Save SP (R14)\n"
1040 "  move     $irp,[cris_reg+0x3c]  ; Save the address in PC (R15)\n"
1041 "  clear.b  [cris_reg+0x40]      ; Clear P0\n"
1042 "  move     $vr,[cris_reg+0x41]   ; Save special register P1,\n"
1043 "  clear.w  [cris_reg+0x42]      ; Clear P4\n"
1044 "  move     $ccr,[cris_reg+0x44]  ; Save special register CCR\n"
1045 "  move     $mof,[cris_reg+0x46]  ; P7\n"
1046 "  clear.d  [cris_reg+0x4A]      ; Clear P8\n"
1047 "  move     $ibr,[cris_reg+0x4E]  ; P9,\n"
1048 "  move     $irp,[cris_reg+0x52]  ; P10,\n"
1049 "  move     $srp,[cris_reg+0x56]  ; P11,\n"
1050 "  move     $bar,[cris_reg+0x5A]  ; P12,\n"
1051 "                            ; P13, register DCCR already saved\n"
1052 ";; Due to the old assembler-versions BRP might not be recognized\n"
1053 "  .word 0xE670              ; move brp,r0\n"
1054 "  move.d   $r0,[cris_reg+0x62]   ; Save the return address in BRP\n"
1055 "  move     $usp,[cris_reg+0x66]  ; USP\n"
1056 "\n"
1057 ";; get the serial character (from debugport.c) and check if it is a ctrl-c\n"
1058 "\n"
1059 "  jsr getDebugChar\n"
1060 "  cmp.b 3, $r10\n"
1061 "  bne goback\n"
1062 "  nop\n"
1063 "\n"
1064 "  move.d  [cris_reg+0x5E], $r10                ; Get DCCR\n"
1065 "  btstq           8, $r10                      ; Test the U-flag.\n"
1066 "  bmi     goback\n"
1067 "  nop\n"
1068 "\n"
1069 ";;\n"
1070 ";; Handle the communication\n"
1071 ";;\n"
1072 "  move.d   internal_stack+1020,$sp ; Use the internal stack\n"
1073 "  moveq    2,$r10                   ; SIGINT\n"
1074 "  jsr      handle_exception       ; Interactive routine\n"
1075 "\n"
1076 "goback:\n"
1077 ";;\n"
1078 ";; Return to the caller\n"
1079 ";;\n"
1080 "   move.d  [cris_reg],$r0         ; Restore R0\n"
1081 "   move.d  [cris_reg+0x04],$r1    ; Restore R1\n"
1082 "   move.d  [cris_reg+0x08],$r2    ; Restore R2\n"
1083 "   move.d  [cris_reg+0x0C],$r3    ; Restore R3\n"
1084 "   move.d  [cris_reg+0x10],$r4    ; Restore R4\n"
1085 "   move.d  [cris_reg+0x14],$r5    ; Restore R5\n"
1086 "   move.d  [cris_reg+0x18],$r6    ; Restore R6\n"
1087 "   move.d  [cris_reg+0x1C],$r7    ; Restore R7\n"
1088 "   move.d  [cris_reg+0x20],$r8    ; Restore R8\n"
1089 "   move.d  [cris_reg+0x24],$r9    ; Restore R9\n"
1090 "   move.d  [cris_reg+0x28],$r10   ; Restore R10\n"
1091 "   move.d  [cris_reg+0x2C],$r11   ; Restore R11\n"
1092 "   move.d  [cris_reg+0x30],$r12   ; Restore R12\n"
1093 "   move.d  [cris_reg+0x34],$r13   ; Restore R13\n"
1094 ";;\n"
1095 ";; FIXME: Which registers should be restored?\n"
1096 ";;\n"
1097 "   move.d  [cris_reg+0x38],$sp    ; Restore SP (R14)\n"
1098 "   move    [cris_reg+0x56],$srp   ; Restore the subroutine return pointer.\n"
1099 "   move    [cris_reg+0x5E],$dccr  ; Restore DCCR\n"
1100 "   move    [cris_reg+0x66],$usp   ; Restore USP\n"
1101 "   reti                      ; Return from the interrupt routine\n"
1102 "   nop\n"
1103 "\n");
1104
1105 /* Use this static breakpoint in the start-up only. */
1106
1107 void
1108 breakpoint(void)
1109 {
1110         kgdb_started = 1;
1111         is_dyn_brkp = 0;     /* This is a static, not a dynamic breakpoint. */
1112         __asm__ volatile ("break 8"); /* Jump to handle_breakpoint. */
1113 }
1114
1115 /* initialize kgdb. doesn't break into the debugger, but sets up irq and ports */
1116
1117 void
1118 kgdb_init(void)
1119 {
1120         /* could initialize debug port as well but it's done in head.S already... */
1121
1122         /* breakpoint handler is now set in irq.c */
1123         set_int_vector(8, kgdb_handle_serial);
1124
1125         enableDebugIRQ();
1126 }
1127
1128 /****************************** End of file **********************************/