arch/frv/kernel/gdb-stub.c

   1 /* gdb-stub.c: FRV GDB stub
   2  *
   3  * Copyright (C) 2003,4 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  * - Derived from Linux/MIPS version, Copyright (C) 1995 Andreas Busse
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version
  10  * 2 of the License, or (at your option) any later version.
  11  */
  12
  13 /*
  14  *  To enable debugger support, two things need to happen.  One, a
  15  *  call to set_debug_traps() is necessary in order to allow any breakpoints
  16  *  or error conditions to be properly intercepted and reported to gdb.
  17  *  Two, a breakpoint needs to be generated to begin communication.  This
  18  *  is most easily accomplished by a call to breakpoint().  Breakpoint()
  19  *  simulates a breakpoint by executing a BREAK instruction.
  20  *
  21  *
  22  *    The following gdb commands are supported:
  23  *
  24  * command          function                               Return value
  25  *
  26  *    g             return the value of the CPU registers  hex data or ENN
  27  *    G             set the value of the CPU registers     OK or ENN
  28  *
  29  *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
  30  *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
  31  *
  32  *    c             Resume at current address              SNN   ( signal NN)
  33  *    cAA..AA       Continue at address AA..AA             SNN
  34  *
  35  *    s             Step one instruction                   SNN
  36  *    sAA..AA       Step one instruction from AA..AA       SNN
  37  *
  38  *    k             kill
  39  *
  40  *    ?             What was the last sigval ?             SNN   (signal NN)
  41  *
  42  *    bBB..BB       Set baud rate to BB..BB                OK or BNN, then sets
  43  *                                                         baud rate
  44  *
  45  * All commands and responses are sent with a packet which includes a
  46  * checksum.  A packet consists of
  47  *
  48  * $<packet info>#<checksum>.
  49  *
  50  * where
  51  * <packet info> :: <characters representing the command or response>
  52  * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
  53  *
  54  * When a packet is received, it is first acknowledged with either '+' or '-'.
  55  * '+' indicates a successful transfer.  '-' indicates a failed transfer.
  56  *
  57  * Example:
  58  *
  59  * Host:                  Reply:
  60  * $m0,10#2a               +$00010203040506070809101112131415#42
  61  *
  62  *
  63  *  ==============
  64  *  MORE EXAMPLES:
  65  *  ==============
  66  *
  67  *  For reference -- the following are the steps that one
  68  *  company took (RidgeRun Inc) to get remote gdb debugging
  69  *  going. In this scenario the host machine was a PC and the
  70  *  target platform was a Galileo EVB64120A MIPS evaluation
  71  *  board.
  72  *
  73  *  Step 1:
  74  *  First download gdb-5.0.tar.gz from the internet.
  75  *  and then build/install the package.
  76  *
  77  *  Example:
  78  *    $ tar zxf gdb-5.0.tar.gz
  79  *    $ cd gdb-5.0
  80  *    $ ./configure --target=frv-elf-gdb
  81  *    $ make
  82  *    $ frv-elf-gdb
  83  *
  84  *  Step 2:
  85  *  Configure linux for remote debugging and build it.
  86  *
  87  *  Example:
  88  *    $ cd ~/linux
  89  *    $ make menuconfig <go to "Kernel Hacking" and turn on remote debugging>
  90  *    $ make dep; make vmlinux
  91  *
  92  *  Step 3:
  93  *  Download the kernel to the remote target and start
  94  *  the kernel running. It will promptly halt and wait
  95  *  for the host gdb session to connect. It does this
  96  *  since the "Kernel Hacking" option has defined
  97  *  CONFIG_REMOTE_DEBUG which in turn enables your calls
  98  *  to:
  99  *     set_debug_traps();
 100  *     breakpoint();
 101  *
 102  *  Step 4:
 103  *  Start the gdb session on the host.
 104  *
 105  *  Example:
 106  *    $ frv-elf-gdb vmlinux
 107  *    (gdb) set remotebaud 115200
 108  *    (gdb) target remote /dev/ttyS1
 109  *    ...at this point you are connected to
 110  *       the remote target and can use gdb
 111  *       in the normal fasion. Setting
 112  *       breakpoints, single stepping,
 113  *       printing variables, etc.
 114  *
 115  */
 116
 117 #include <linux/string.h>
 118 #include <linux/kernel.h>
 119 #include <linux/signal.h>
 120 #include <linux/sched.h>
 121 #include <linux/mm.h>
 122 #include <linux/console.h>
 123 #include <linux/init.h>
 124 #include <linux/slab.h>
 125 #include <linux/nmi.h>
 126
 127 #include <asm/asm-offsets.h>
 128 #include <asm/pgtable.h>
 129 #include <asm/system.h>
 130 #include <asm/gdb-stub.h>
 131
 132 #define LEDS(x) do { /* *(u32*)0xe1200004 = ~(x); mb(); */ } while(0)
 133
 134 #undef GDBSTUB_DEBUG_PROTOCOL
 135
 136 extern void debug_to_serial(const char *p, int n);
 137 extern void gdbstub_console_write(struct console *co, const char *p, unsigned n);
 138
 139 extern volatile uint32_t __break_error_detect[3]; /* ESFR1, ESR15, EAR15 */
 140
 141 struct __debug_amr {
 142         unsigned long L, P;
 143 } __attribute__((aligned(8)));
 144
 145 struct __debug_mmu {
 146         struct {
 147                 unsigned long   hsr0, pcsr, esr0, ear0, epcr0;
 148 #ifdef CONFIG_MMU
 149                 unsigned long   tplr, tppr, tpxr, cxnr;
 150 #endif
 151         } regs;
 152
 153         struct __debug_amr      iamr[16];
 154         struct __debug_amr      damr[16];
 155
 156 #ifdef CONFIG_MMU
 157         struct __debug_amr      tlb[64*2];
 158 #endif
 159 };
 160
 161 static struct __debug_mmu __debug_mmu;
 162
 163 /*
 164  * BUFMAX defines the maximum number of characters in inbound/outbound buffers
 165  * at least NUMREGBYTES*2 are needed for register packets
 166  */
 167 #define BUFMAX 2048
 168
 169 #define BREAK_INSN      0x801000c0      /* use "break" as bkpt */
 170
 171 static const char gdbstub_banner[] = "Linux/FR-V GDB Stub (c) RedHat 2003\n";
 172
 173 volatile u8     gdbstub_rx_buffer[PAGE_SIZE] __attribute__((aligned(PAGE_SIZE)));
 174 volatile u32    gdbstub_rx_inp = 0;
 175 volatile u32    gdbstub_rx_outp = 0;
 176 volatile u8     gdbstub_rx_overflow = 0;
 177 u8              gdbstub_rx_unget = 0;
 178
 179 /* set with GDB whilst running to permit step through exceptions */
 180 extern volatile u32 __attribute__((section(".bss"))) gdbstub_trace_through_exceptions;
 181
 182 static char     input_buffer[BUFMAX];
 183 static char     output_buffer[BUFMAX];
 184
 185 static const char hexchars[] = "0123456789abcdef";
 186
 187 static const char *regnames[] = {
 188         "PSR ", "ISR ", "CCR ", "CCCR",
 189         "LR  ", "LCR ", "PC  ", "_stt",
 190         "sys ", "GR8*", "GNE0", "GNE1",
 191         "IACH", "IACL",
 192         "TBR ", "SP  ", "FP  ", "GR3 ",
 193         "GR4 ", "GR5 ", "GR6 ", "GR7 ",
 194         "GR8 ", "GR9 ", "GR10", "GR11",
 195         "GR12", "GR13", "GR14", "GR15",
 196         "GR16", "GR17", "GR18", "GR19",
 197         "GR20", "GR21", "GR22", "GR23",
 198         "GR24", "GR25", "GR26", "GR27",
 199         "EFRM", "CURR", "GR30", "BFRM"
 200 };
 201
 202 struct gdbstub_bkpt {
 203         unsigned long   addr;           /* address of breakpoint */
 204         unsigned        len;            /* size of breakpoint */
 205         uint32_t        originsns[7];   /* original instructions */
 206 };
 207
 208 static struct gdbstub_bkpt gdbstub_bkpts[256];
 209
 210 /*
 211  * local prototypes
 212  */
 213
 214 static void gdbstub_recv_packet(char *buffer);
 215 static int gdbstub_send_packet(char *buffer);
 216 static int gdbstub_compute_signal(unsigned long tbr);
 217 static int hex(unsigned char ch);
 218 static int hexToInt(char **ptr, unsigned long *intValue);
 219 static unsigned char *mem2hex(const void *mem, char *buf, int count, int may_fault);
 220 static char *hex2mem(const char *buf, void *_mem, int count);
 221
 222 /*
 223  * Convert ch from a hex digit to an int
 224  */
 225 static int hex(unsigned char ch)
 226 {
 227         if (ch >= 'a' && ch <= 'f')
 228                 return ch-'a'+10;
 229         if (ch >= '0' && ch <= '9')
 230                 return ch-'0';
 231         if (ch >= 'A' && ch <= 'F')
 232                 return ch-'A'+10;
 233         return -1;
 234 }
 235
 236 void gdbstub_printk(const char *fmt, ...)
 237 {
 238         static char buf[1024];
 239         va_list args;
 240         int len;
 241
 242         /* Emit the output into the temporary buffer */
 243         va_start(args, fmt);
 244         len = vsnprintf(buf, sizeof(buf), fmt, args);
 245         va_end(args);
 246         debug_to_serial(buf, len);
 247 }
 248
 249 static inline char *gdbstub_strcpy(char *dst, const char *src)
 250 {
 251         int loop = 0;
 252         while ((dst[loop] = src[loop]))
 253                loop++;
 254         return dst;
 255 }
 256
 257 static void gdbstub_purge_cache(void)
 258 {
 259         asm volatile("  dcef    @(gr0,gr0),#1   \n"
 260                      "  icei    @(gr0,gr0),#1   \n"
 261                      "  membar                  \n"
 262                      "  bar                     \n"
 263                      );
 264 }
 265
 266 /*****************************************************************************/
 267 /*
 268  * scan for the sequence $<data>#<checksum>
 269  */
 270 static void gdbstub_recv_packet(char *buffer)
 271 {
 272         unsigned char checksum;
 273         unsigned char xmitcsum;
 274         unsigned char ch;
 275         int count, i, ret, error;
 276
 277         for (;;) {
 278                 /* wait around for the start character, ignore all other characters */
 279                 do {
 280                         gdbstub_rx_char(&ch, 0);
 281                 } while (ch != '$');
 282
 283                 checksum = 0;
 284                 xmitcsum = -1;
 285                 count = 0;
 286                 error = 0;
 287
 288                 /* now, read until a # or end of buffer is found */
 289                 while (count < BUFMAX) {
 290                         ret = gdbstub_rx_char(&ch, 0);
 291                         if (ret < 0)
 292                                 error = ret;
 293
 294                         if (ch == '#')
 295                                 break;
 296                         checksum += ch;
 297                         buffer[count] = ch;
 298                         count++;
 299                 }
 300
 301                 if (error == -EIO) {
 302                         gdbstub_proto("### GDB Rx Error - Skipping packet ###\n");
 303                         gdbstub_proto("### GDB Tx NAK\n");
 304                         gdbstub_tx_char('-');
 305                         continue;
 306                 }
 307
 308                 if (count >= BUFMAX || error)
 309                         continue;
 310
 311                 buffer[count] = 0;
 312
 313                 /* read the checksum */
 314                 ret = gdbstub_rx_char(&ch, 0);
 315                 if (ret < 0)
 316                         error = ret;
 317                 xmitcsum = hex(ch) << 4;
 318
 319                 ret = gdbstub_rx_char(&ch, 0);
 320                 if (ret < 0)
 321                         error = ret;
 322                 xmitcsum |= hex(ch);
 323
 324                 if (error) {
 325                         if (error == -EIO)
 326                                 gdbstub_proto("### GDB Rx Error - Skipping packet\n");
 327                         gdbstub_proto("### GDB Tx NAK\n");
 328                         gdbstub_tx_char('-');
 329                         continue;
 330                 }
 331
 332                 /* check the checksum */
 333                 if (checksum != xmitcsum) {
 334                         gdbstub_proto("### GDB Tx NAK\n");
 335                         gdbstub_tx_char('-');   /* failed checksum */
 336                         continue;
 337                 }
 338
 339                 gdbstub_proto("### GDB Rx '$%s#%02x' ###\n", buffer, checksum);
 340                 gdbstub_proto("### GDB Tx ACK\n");
 341                 gdbstub_tx_char('+'); /* successful transfer */
 342
 343                 /* if a sequence char is present, reply the sequence ID */
 344                 if (buffer[2] == ':') {
 345                         gdbstub_tx_char(buffer[0]);
 346                         gdbstub_tx_char(buffer[1]);
 347
 348                         /* remove sequence chars from buffer */
 349                         count = 0;
 350                         while (buffer[count]) count++;
 351                         for (i=3; i <= count; i++)
 352                                 buffer[i - 3] = buffer[i];
 353                 }
 354
 355                 break;
 356         }
 357 } /* end gdbstub_recv_packet() */
 358
 359 /*****************************************************************************/
 360 /*
 361  * send the packet in buffer.
 362  * - return 0 if successfully ACK'd
 363  * - return 1 if abandoned due to new incoming packet
 364  */
 365 static int gdbstub_send_packet(char *buffer)
 366 {
 367         unsigned char checksum;
 368         int count;
 369         unsigned char ch;
 370
 371         /* $<packet info>#<checksum> */
 372         gdbstub_proto("### GDB Tx '%s' ###\n", buffer);
 373
 374         do {
 375                 gdbstub_tx_char('$');
 376                 checksum = 0;
 377                 count = 0;
 378
 379                 while ((ch = buffer[count]) != 0) {
 380                         gdbstub_tx_char(ch);
 381                         checksum += ch;
 382                         count += 1;
 383                 }
 384
 385                 gdbstub_tx_char('#');
 386                 gdbstub_tx_char(hexchars[checksum >> 4]);
 387                 gdbstub_tx_char(hexchars[checksum & 0xf]);
 388
 389         } while (gdbstub_rx_char(&ch,0),
 390 #ifdef GDBSTUB_DEBUG_PROTOCOL
 391                  ch=='-' && (gdbstub_proto("### GDB Rx NAK\n"),0),
 392                  ch!='-' && ch!='+' && (gdbstub_proto("### GDB Rx ??? %02x\n",ch),0),
 393 #endif
 394                  ch!='+' && ch!='$');
 395
 396         if (ch=='+') {
 397                 gdbstub_proto("### GDB Rx ACK\n");
 398                 return 0;
 399         }
 400
 401         gdbstub_proto("### GDB Tx Abandoned\n");
 402         gdbstub_rx_unget = ch;
 403         return 1;
 404 } /* end gdbstub_send_packet() */
 405
 406 /*
 407  * While we find nice hex chars, build an int.
 408  * Return number of chars processed.
 409  */
 410 static int hexToInt(char **ptr, unsigned long *_value)
 411 {
 412         int count = 0, ch;
 413
 414         *_value = 0;
 415         while (**ptr) {
 416                 ch = hex(**ptr);
 417                 if (ch < 0)
 418                         break;
 419
 420                 *_value = (*_value << 4) | ((uint8_t) ch & 0xf);
 421                 count++;
 422
 423                 (*ptr)++;
 424         }
 425
 426         return count;
 427 }
 428
 429 /*****************************************************************************/
 430 /*
 431  * probe an address to see whether it maps to anything
 432  */
 433 static inline int gdbstub_addr_probe(const void *vaddr)
 434 {
 435 #ifdef CONFIG_MMU
 436         unsigned long paddr;
 437
 438         asm("lrad %1,%0,#1,#0,#0" : "=r"(paddr) : "r"(vaddr));
 439         if (!(paddr & xAMPRx_V))
 440                 return 0;
 441 #endif
 442
 443         return 1;
 444 } /* end gdbstub_addr_probe() */
 445
 446 #ifdef CONFIG_MMU
 447 static unsigned long __saved_dampr, __saved_damlr;
 448
 449 static inline unsigned long gdbstub_virt_to_pte(unsigned long vaddr)
 450 {
 451         pgd_t *pgd;
 452         pud_t *pud;
 453         pmd_t *pmd;
 454         pte_t *pte;
 455         unsigned long val, dampr5;
 456
 457         pgd = (pgd_t *) __get_DAMLR(3) + pgd_index(vaddr);
 458         pud = pud_offset(pgd, vaddr);
 459         pmd = pmd_offset(pud, vaddr);
 460
 461         if (pmd_bad(*pmd) || !pmd_present(*pmd))
 462                 return 0;
 463
 464         /* make sure dampr5 maps to the correct pmd */
 465         dampr5 = __get_DAMPR(5);
 466         val = pmd_val(*pmd);
 467         __set_DAMPR(5, val | xAMPRx_L | xAMPRx_SS_16Kb | xAMPRx_S | xAMPRx_C | xAMPRx_V);
 468
 469         /* now its safe to access pmd */
 470         pte = (pte_t *)__get_DAMLR(5) + __pte_index(vaddr);
 471         if (pte_present(*pte))
 472                 val = pte_val(*pte);
 473         else
 474                 val = 0;
 475
 476         /* restore original dampr5 */
 477         __set_DAMPR(5, dampr5);
 478
 479         return val;
 480 }
 481 #endif
 482
 483 static inline int gdbstub_addr_map(const void *vaddr)
 484 {
 485 #ifdef CONFIG_MMU
 486         unsigned long pte;
 487
 488         __saved_dampr = __get_DAMPR(2);
 489         __saved_damlr = __get_DAMLR(2);
 490 #endif
 491         if (gdbstub_addr_probe(vaddr))
 492                 return 1;
 493 #ifdef CONFIG_MMU
 494         pte = gdbstub_virt_to_pte((unsigned long) vaddr);
 495         if (pte) {
 496                 __set_DAMPR(2, pte);
 497                 __set_DAMLR(2, (unsigned long) vaddr & PAGE_MASK);
 498                 return 1;
 499         }
 500 #endif
 501         return 0;
 502 }
 503
 504 static inline void gdbstub_addr_unmap(void)
 505 {
 506 #ifdef CONFIG_MMU
 507         __set_DAMPR(2, __saved_dampr);
 508         __set_DAMLR(2, __saved_damlr);
 509 #endif
 510 }
 511
 512 /*
 513  * access potentially dodgy memory through a potentially dodgy pointer
 514  */
 515 static inline int gdbstub_read_dword(const void *addr, uint32_t *_res)
 516 {
 517         unsigned long brr;
 518         uint32_t res;
 519
 520         if (!gdbstub_addr_map(addr))
 521                 return 0;
 522
 523         asm volatile("  movgs   gr0,brr \n"
 524                      "  ld%I2   %M2,%0  \n"
 525                      "  movsg   brr,%1  \n"
 526                      : "=r"(res), "=r"(brr)
 527                      : "m"(*(uint32_t *) addr));
 528         *_res = res;
 529         gdbstub_addr_unmap();
 530         return likely(!brr);
 531 }
 532
 533 static inline int gdbstub_write_dword(void *addr, uint32_t val)
 534 {
 535         unsigned long brr;
 536
 537         if (!gdbstub_addr_map(addr))
 538                 return 0;
 539
 540         asm volatile("  movgs   gr0,brr \n"
 541                      "  st%I2   %1,%M2  \n"
 542                      "  movsg   brr,%0  \n"
 543                      : "=r"(brr)
 544                      : "r"(val), "m"(*(uint32_t *) addr));
 545         gdbstub_addr_unmap();
 546         return likely(!brr);
 547 }
 548
 549 static inline int gdbstub_read_word(const void *addr, uint16_t *_res)
 550 {
 551         unsigned long brr;
 552         uint16_t res;
 553
 554         if (!gdbstub_addr_map(addr))
 555                 return 0;
 556
 557         asm volatile("  movgs   gr0,brr \n"
 558                      "  lduh%I2 %M2,%0  \n"
 559                      "  movsg   brr,%1  \n"
 560                      : "=r"(res), "=r"(brr)
 561                      : "m"(*(uint16_t *) addr));
 562         *_res = res;
 563         gdbstub_addr_unmap();
 564         return likely(!brr);
 565 }
 566
 567 static inline int gdbstub_write_word(void *addr, uint16_t val)
 568 {
 569         unsigned long brr;
 570
 571         if (!gdbstub_addr_map(addr))
 572                 return 0;
 573
 574         asm volatile("  movgs   gr0,brr \n"
 575                      "  sth%I2  %1,%M2  \n"
 576                      "  movsg   brr,%0  \n"
 577                      : "=r"(brr)
 578                      : "r"(val), "m"(*(uint16_t *) addr));
 579         gdbstub_addr_unmap();
 580         return likely(!brr);
 581 }
 582
 583 static inline int gdbstub_read_byte(const void *addr, uint8_t *_res)
 584 {
 585         unsigned long brr;
 586         uint8_t res;
 587
 588         if (!gdbstub_addr_map(addr))
 589                 return 0;
 590
 591         asm volatile("  movgs   gr0,brr \n"
 592                      "  ldub%I2 %M2,%0  \n"
 593                      "  movsg   brr,%1  \n"
 594                      : "=r"(res), "=r"(brr)
 595                      : "m"(*(uint8_t *) addr));
 596         *_res = res;
 597         gdbstub_addr_unmap();
 598         return likely(!brr);
 599 }
 600
 601 static inline int gdbstub_write_byte(void *addr, uint8_t val)
 602 {
 603         unsigned long brr;
 604
 605         if (!gdbstub_addr_map(addr))
 606                 return 0;
 607
 608         asm volatile("  movgs   gr0,brr \n"
 609                      "  stb%I2  %1,%M2  \n"
 610                      "  movsg   brr,%0  \n"
 611                      : "=r"(brr)
 612                      : "r"(val), "m"(*(uint8_t *) addr));
 613         gdbstub_addr_unmap();
 614         return likely(!brr);
 615 }
 616
 617 static void __gdbstub_console_write(struct console *co, const char *p, unsigned n)
 618 {
 619         char outbuf[26];
 620         int qty;
 621
 622         outbuf[0] = 'O';
 623
 624         while (n > 0) {
 625                 qty = 1;
 626
 627                 while (n > 0 && qty < 20) {
 628                         mem2hex(p, outbuf + qty, 2, 0);
 629                         qty += 2;
 630                         if (*p == 0x0a) {
 631                                 outbuf[qty++] = '0';
 632                                 outbuf[qty++] = 'd';
 633                         }
 634                         p++;
 635                         n--;
 636                 }
 637
 638                 outbuf[qty] = 0;
 639                 gdbstub_send_packet(outbuf);
 640         }
 641 }
 642
 643 #if 0
 644 void debug_to_serial(const char *p, int n)
 645 {
 646         gdbstub_console_write(NULL,p,n);
 647 }
 648 #endif
 649
 650 #ifdef CONFIG_GDBSTUB_CONSOLE
 651
 652 static kdev_t gdbstub_console_dev(struct console *con)
 653 {
 654         return MKDEV(1,3); /* /dev/null */
 655 }
 656
 657 static struct console gdbstub_console = {
 658         .name   = "gdb",
 659         .write  = gdbstub_console_write,        /* in break.S */
 660         .device = gdbstub_console_dev,
 661         .flags  = CON_PRINTBUFFER,
 662         .index  = -1,
 663 };
 664
 665 #endif
 666
 667 /*****************************************************************************/
 668 /*
 669  * Convert the memory pointed to by mem into hex, placing result in buf.
 670  * - if successful, return a pointer to the last char put in buf (NUL)
 671  * - in case of mem fault, return NULL
 672  * may_fault is non-zero if we are reading from arbitrary memory, but is currently
 673  * not used.
 674  */
 675 static unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fault)
 676 {
 677         const uint8_t *mem = _mem;
 678         uint8_t ch[4] __attribute__((aligned(4)));
 679
 680         if ((uint32_t)mem&1 && count>=1) {
 681                 if (!gdbstub_read_byte(mem,ch))
 682                         return NULL;
 683                 *buf++ = hexchars[ch[0] >> 4];
 684                 *buf++ = hexchars[ch[0] & 0xf];
 685                 mem++;
 686                 count--;
 687         }
 688
 689         if ((uint32_t)mem&3 && count>=2) {
 690                 if (!gdbstub_read_word(mem,(uint16_t *)ch))
 691                         return NULL;
 692                 *buf++ = hexchars[ch[0] >> 4];
 693                 *buf++ = hexchars[ch[0] & 0xf];
 694                 *buf++ = hexchars[ch[1] >> 4];
 695                 *buf++ = hexchars[ch[1] & 0xf];
 696                 mem += 2;
 697                 count -= 2;
 698         }
 699
 700         while (count>=4) {
 701                 if (!gdbstub_read_dword(mem,(uint32_t *)ch))
 702                         return NULL;
 703                 *buf++ = hexchars[ch[0] >> 4];
 704                 *buf++ = hexchars[ch[0] & 0xf];
 705                 *buf++ = hexchars[ch[1] >> 4];
 706                 *buf++ = hexchars[ch[1] & 0xf];
 707                 *buf++ = hexchars[ch[2] >> 4];
 708                 *buf++ = hexchars[ch[2] & 0xf];
 709                 *buf++ = hexchars[ch[3] >> 4];
 710                 *buf++ = hexchars[ch[3] & 0xf];
 711                 mem += 4;
 712                 count -= 4;
 713         }
 714
 715         if (count>=2) {
 716                 if (!gdbstub_read_word(mem,(uint16_t *)ch))
 717                         return NULL;
 718                 *buf++ = hexchars[ch[0] >> 4];
 719                 *buf++ = hexchars[ch[0] & 0xf];
 720                 *buf++ = hexchars[ch[1] >> 4];
 721                 *buf++ = hexchars[ch[1] & 0xf];
 722                 mem += 2;
 723                 count -= 2;
 724         }
 725
 726         if (count>=1) {
 727                 if (!gdbstub_read_byte(mem,ch))
 728                         return NULL;
 729                 *buf++ = hexchars[ch[0] >> 4];
 730                 *buf++ = hexchars[ch[0] & 0xf];
 731         }
 732
 733         *buf = 0;
 734
 735         return buf;
 736 } /* end mem2hex() */
 737
 738 /*****************************************************************************/
 739 /*
 740  * convert the hex array pointed to by buf into binary to be placed in mem
 741  * return a pointer to the character AFTER the last byte of buffer consumed
 742  */
 743 static char *hex2mem(const char *buf, void *_mem, int count)
 744 {
 745         uint8_t *mem = _mem;
 746         union {
 747                 uint32_t l;
 748                 uint16_t w;
 749                 uint8_t  b[4];
 750         } ch;
 751
 752         if ((u32)mem&1 && count>=1) {
 753                 ch.b[0]  = hex(*buf++) << 4;
 754                 ch.b[0] |= hex(*buf++);
 755                 if (!gdbstub_write_byte(mem,ch.b[0]))
 756                         return NULL;
 757                 mem++;
 758                 count--;
 759         }
 760
 761         if ((u32)mem&3 && count>=2) {
 762                 ch.b[0]  = hex(*buf++) << 4;
 763                 ch.b[0] |= hex(*buf++);
 764                 ch.b[1]  = hex(*buf++) << 4;
 765                 ch.b[1] |= hex(*buf++);
 766                 if (!gdbstub_write_word(mem,ch.w))
 767                         return NULL;
 768                 mem += 2;
 769                 count -= 2;
 770         }
 771
 772         while (count>=4) {
 773                 ch.b[0]  = hex(*buf++) << 4;
 774                 ch.b[0] |= hex(*buf++);
 775                 ch.b[1]  = hex(*buf++) << 4;
 776                 ch.b[1] |= hex(*buf++);
 777                 ch.b[2]  = hex(*buf++) << 4;
 778                 ch.b[2] |= hex(*buf++);
 779                 ch.b[3]  = hex(*buf++) << 4;
 780                 ch.b[3] |= hex(*buf++);
 781                 if (!gdbstub_write_dword(mem,ch.l))
 782                         return NULL;
 783                 mem += 4;
 784                 count -= 4;
 785         }
 786
 787         if (count>=2) {
 788                 ch.b[0]  = hex(*buf++) << 4;
 789                 ch.b[0] |= hex(*buf++);
 790                 ch.b[1]  = hex(*buf++) << 4;
 791                 ch.b[1] |= hex(*buf++);
 792                 if (!gdbstub_write_word(mem,ch.w))
 793                         return NULL;
 794                 mem += 2;
 795                 count -= 2;
 796         }
 797
 798         if (count>=1) {
 799                 ch.b[0]  = hex(*buf++) << 4;
 800                 ch.b[0] |= hex(*buf++);
 801                 if (!gdbstub_write_byte(mem,ch.b[0]))
 802                         return NULL;
 803         }
 804
 805         return (char *) buf;
 806 } /* end hex2mem() */
 807
 808 /*****************************************************************************/
 809 /*
 810  * This table contains the mapping between FRV TBR.TT exception codes,
 811  * and signals, which are primarily what GDB understands.  It also
 812  * indicates which hardware traps we need to commandeer when
 813  * initializing the stub.
 814  */
 815 static const struct brr_to_sig_map {
 816         unsigned long   brr_mask;       /* BRR bitmask */
 817         unsigned long   tbr_tt;         /* TBR.TT code (in BRR.EBTT) */
 818         unsigned int    signo;          /* Signal that we map this into */
 819 } brr_to_sig_map[] = {
 820         { BRR_EB,       TBR_TT_INSTR_ACC_ERROR, SIGSEGV         },
 821         { BRR_EB,       TBR_TT_ILLEGAL_INSTR,   SIGILL          },
 822         { BRR_EB,       TBR_TT_PRIV_INSTR,      SIGILL          },
 823         { BRR_EB,       TBR_TT_MP_EXCEPTION,    SIGFPE          },
 824         { BRR_EB,       TBR_TT_DATA_ACC_ERROR,  SIGSEGV         },
 825         { BRR_EB,       TBR_TT_DATA_STR_ERROR,  SIGSEGV         },
 826         { BRR_EB,       TBR_TT_DIVISION_EXCEP,  SIGFPE          },
 827         { BRR_EB,       TBR_TT_COMPOUND_EXCEP,  SIGSEGV         },
 828         { BRR_EB,       TBR_TT_INTERRUPT_13,    SIGALRM         },      /* watchdog */
 829         { BRR_EB,       TBR_TT_INTERRUPT_14,    SIGINT          },      /* GDB serial */
 830         { BRR_EB,       TBR_TT_INTERRUPT_15,    SIGQUIT         },      /* NMI */
 831         { BRR_CB,       0,                      SIGUSR1         },
 832         { BRR_TB,       0,                      SIGUSR2         },
 833         { BRR_DBNEx,    0,                      SIGTRAP         },
 834         { BRR_DBx,      0,                      SIGTRAP         },      /* h/w watchpoint */
 835         { BRR_IBx,      0,                      SIGTRAP         },      /* h/w breakpoint */
 836         { BRR_CBB,      0,                      SIGTRAP         },
 837         { BRR_SB,       0,                      SIGTRAP         },
 838         { BRR_ST,       0,                      SIGTRAP         },      /* single step */
 839         { 0,            0,                      SIGHUP          }       /* default */
 840 };
 841
 842 /*****************************************************************************/
 843 /*
 844  * convert the FRV BRR register contents into a UNIX signal number
 845  */
 846 static inline int gdbstub_compute_signal(unsigned long brr)
 847 {
 848         const struct brr_to_sig_map *map;
 849         unsigned long tbr = (brr & BRR_EBTT) >> 12;
 850
 851         for (map = brr_to_sig_map; map->brr_mask; map++)
 852                 if (map->brr_mask & brr)
 853                         if (!map->tbr_tt || map->tbr_tt == tbr)
 854                                 break;
 855
 856         return map->signo;
 857 } /* end gdbstub_compute_signal() */
 858
 859 /*****************************************************************************/
 860 /*
 861  * set a software breakpoint or a hardware breakpoint or watchpoint
 862  */
 863 static int gdbstub_set_breakpoint(unsigned long type, unsigned long addr, unsigned long len)
 864 {
 865         unsigned long tmp;
 866         int bkpt, loop, xloop;
 867
 868         union {
 869                 struct {
 870                         unsigned long mask0, mask1;
 871                 };
 872                 uint8_t bytes[8];
 873         } dbmr;
 874
 875         //gdbstub_printk("setbkpt(%ld,%08lx,%ld)\n", type, addr, len);
 876
 877         switch (type) {
 878                 /* set software breakpoint */
 879         case 0:
 880                 if (addr & 3 || len > 7*4)
 881                         return -EINVAL;
 882
 883                 for (bkpt = 255; bkpt >= 0; bkpt--)
 884                         if (!gdbstub_bkpts[bkpt].addr)
 885                                 break;
 886                 if (bkpt < 0)
 887                         return -ENOSPC;
 888
 889                 for (loop = 0; loop < len/4; loop++)
 890                         if (!gdbstub_read_dword(&((uint32_t *) addr)[loop],
 891                                                 &gdbstub_bkpts[bkpt].originsns[loop]))
 892                                 return -EFAULT;
 893
 894                 for (loop = 0; loop < len/4; loop++)
 895                         if (!gdbstub_write_dword(&((uint32_t *) addr)[loop],
 896                                                  BREAK_INSN)
 897                             ) {
 898                                 /* need to undo the changes if possible */
 899                                 for (xloop = 0; xloop < loop; xloop++)
 900                                         gdbstub_write_dword(&((uint32_t *) addr)[xloop],
 901                                                             gdbstub_bkpts[bkpt].originsns[xloop]);
 902                                 return -EFAULT;
 903                         }
 904
 905                 gdbstub_bkpts[bkpt].addr = addr;
 906                 gdbstub_bkpts[bkpt].len = len;
 907
 908 #if 0
 909                 gdbstub_printk("Set BKPT[%02x]: %08lx #%d {%04x, %04x} -> { %04x, %04x }\n",
 910                                bkpt,
 911                                gdbstub_bkpts[bkpt].addr,
 912                                gdbstub_bkpts[bkpt].len,
 913                                gdbstub_bkpts[bkpt].originsns[0],
 914                                gdbstub_bkpts[bkpt].originsns[1],
 915                                ((uint32_t *) addr)[0],
 916                                ((uint32_t *) addr)[1]
 917                                );
 918 #endif
 919                 return 0;
 920
 921                 /* set hardware breakpoint */
 922         case 1:
 923                 if (addr & 3 || len != 4)
 924                         return -EINVAL;
 925
 926                 if (!(__debug_regs->dcr & DCR_IBE0)) {
 927                         //gdbstub_printk("set h/w break 0: %08lx\n", addr);
 928                         __debug_regs->dcr |= DCR_IBE0;
 929                         __debug_regs->ibar[0] = addr;
 930                         asm volatile("movgs %0,ibar0" : : "r"(addr));
 931                         return 0;
 932                 }
 933
 934                 if (!(__debug_regs->dcr & DCR_IBE1)) {
 935                         //gdbstub_printk("set h/w break 1: %08lx\n", addr);
 936                         __debug_regs->dcr |= DCR_IBE1;
 937                         __debug_regs->ibar[1] = addr;
 938                         asm volatile("movgs %0,ibar1" : : "r"(addr));
 939                         return 0;
 940                 }
 941
 942                 if (!(__debug_regs->dcr & DCR_IBE2)) {
 943                         //gdbstub_printk("set h/w break 2: %08lx\n", addr);
 944                         __debug_regs->dcr |= DCR_IBE2;
 945                         __debug_regs->ibar[2] = addr;
 946                         asm volatile("movgs %0,ibar2" : : "r"(addr));
 947                         return 0;
 948                 }
 949
 950                 if (!(__debug_regs->dcr & DCR_IBE3)) {
 951                         //gdbstub_printk("set h/w break 3: %08lx\n", addr);
 952                         __debug_regs->dcr |= DCR_IBE3;
 953                         __debug_regs->ibar[3] = addr;
 954                         asm volatile("movgs %0,ibar3" : : "r"(addr));
 955                         return 0;
 956                 }
 957
 958                 return -ENOSPC;
 959
 960                 /* set data read/write/access watchpoint */
 961         case 2:
 962         case 3:
 963         case 4:
 964                 if ((addr & ~7) != ((addr + len - 1) & ~7))
 965                         return -EINVAL;
 966
 967                 tmp = addr & 7;
 968
 969                 memset(dbmr.bytes, 0xff, sizeof(dbmr.bytes));
 970                 for (loop = 0; loop < len; loop++)
 971                         dbmr.bytes[tmp + loop] = 0;
 972
 973                 addr &= ~7;
 974
 975                 if (!(__debug_regs->dcr & (DCR_DRBE0|DCR_DWBE0))) {
 976                         //gdbstub_printk("set h/w watchpoint 0 type %ld: %08lx\n", type, addr);
 977                         tmp = type==2 ? DCR_DWBE0 : type==3 ? DCR_DRBE0 : DCR_DRBE0|DCR_DWBE0;
 978
 979                         __debug_regs->dcr |= tmp;
 980                         __debug_regs->dbar[0] = addr;
 981                         __debug_regs->dbmr[0][0] = dbmr.mask0;
 982                         __debug_regs->dbmr[0][1] = dbmr.mask1;
 983                         __debug_regs->dbdr[0][0] = 0;
 984                         __debug_regs->dbdr[0][1] = 0;
 985
 986                         asm volatile("  movgs   %0,dbar0        \n"
 987                                      "  movgs   %1,dbmr00       \n"
 988                                      "  movgs   %2,dbmr01       \n"
 989                                      "  movgs   gr0,dbdr00      \n"
 990                                      "  movgs   gr0,dbdr01      \n"
 991                                      : : "r"(addr), "r"(dbmr.mask0), "r"(dbmr.mask1));
 992                         return 0;
 993                 }
 994
 995                 if (!(__debug_regs->dcr & (DCR_DRBE1|DCR_DWBE1))) {
 996                         //gdbstub_printk("set h/w watchpoint 1 type %ld: %08lx\n", type, addr);
 997                         tmp = type==2 ? DCR_DWBE1 : type==3 ? DCR_DRBE1 : DCR_DRBE1|DCR_DWBE1;
 998
 999                         __debug_regs->dcr |= tmp;
1000                         __debug_regs->dbar[1] = addr;
1001                         __debug_regs->dbmr[1][0] = dbmr.mask0;
1002                         __debug_regs->dbmr[1][1] = dbmr.mask1;
1003                         __debug_regs->dbdr[1][0] = 0;
1004                         __debug_regs->dbdr[1][1] = 0;
1005
1006                         asm volatile("  movgs   %0,dbar1        \n"
1007                                      "  movgs   %1,dbmr10       \n"
1008                                      "  movgs   %2,dbmr11       \n"
1009                                      "  movgs   gr0,dbdr10      \n"
1010                                      "  movgs   gr0,dbdr11      \n"
1011                                      : : "r"(addr), "r"(dbmr.mask0), "r"(dbmr.mask1));
1012                         return 0;
1013                 }
1014
1015                 return -ENOSPC;
1016
1017         default:
1018                 return -EINVAL;
1019         }
1020
1021 } /* end gdbstub_set_breakpoint() */
1022
1023 /*****************************************************************************/
1024 /*
1025  * clear a breakpoint or watchpoint
1026  */
1027 int gdbstub_clear_breakpoint(unsigned long type, unsigned long addr, unsigned long len)
1028 {
1029         unsigned long tmp;
1030         int bkpt, loop;
1031
1032         union {
1033                 struct {
1034                         unsigned long mask0, mask1;
1035                 };
1036                 uint8_t bytes[8];
1037         } dbmr;
1038
1039         //gdbstub_printk("clearbkpt(%ld,%08lx,%ld)\n", type, addr, len);
1040
1041         switch (type) {
1042                 /* clear software breakpoint */
1043         case 0:
1044                 for (bkpt = 255; bkpt >= 0; bkpt--)
1045                         if (gdbstub_bkpts[bkpt].addr == addr && gdbstub_bkpts[bkpt].len == len)
1046                                 break;
1047                 if (bkpt < 0)
1048                         return -ENOENT;
1049
1050                 gdbstub_bkpts[bkpt].addr = 0;
1051
1052                 for (loop = 0; loop < len/4; loop++)
1053                         if (!gdbstub_write_dword(&((uint32_t *) addr)[loop],
1054                                                  gdbstub_bkpts[bkpt].originsns[loop]))
1055                                 return -EFAULT;
1056                 return 0;
1057
1058                 /* clear hardware breakpoint */
1059         case 1:
1060                 if (addr & 3 || len != 4)
1061                         return -EINVAL;
1062
1063 #define __get_ibar(X) ({ unsigned long x; asm volatile("movsg ibar"#X",%0" : "=r"(x)); x; })
1064
1065                 if (__debug_regs->dcr & DCR_IBE0 && __get_ibar(0) == addr) {
1066                         //gdbstub_printk("clear h/w break 0: %08lx\n", addr);
1067                         __debug_regs->dcr &= ~DCR_IBE0;
1068                         __debug_regs->ibar[0] = 0;
1069                         asm volatile("movgs gr0,ibar0");
1070                         return 0;
1071                 }
1072
1073                 if (__debug_regs->dcr & DCR_IBE1 && __get_ibar(1) == addr) {
1074                         //gdbstub_printk("clear h/w break 1: %08lx\n", addr);
1075                         __debug_regs->dcr &= ~DCR_IBE1;
1076                         __debug_regs->ibar[1] = 0;
1077                         asm volatile("movgs gr0,ibar1");
1078                         return 0;
1079                 }
1080
1081                 if (__debug_regs->dcr & DCR_IBE2 && __get_ibar(2) == addr) {
1082                         //gdbstub_printk("clear h/w break 2: %08lx\n", addr);
1083                         __debug_regs->dcr &= ~DCR_IBE2;
1084                         __debug_regs->ibar[2] = 0;
1085                         asm volatile("movgs gr0,ibar2");
1086                         return 0;
1087                 }
1088
1089                 if (__debug_regs->dcr & DCR_IBE3 && __get_ibar(3) == addr) {
1090                         //gdbstub_printk("clear h/w break 3: %08lx\n", addr);
1091                         __debug_regs->dcr &= ~DCR_IBE3;
1092                         __debug_regs->ibar[3] = 0;
1093                         asm volatile("movgs gr0,ibar3");
1094                         return 0;
1095                 }
1096
1097                 return -EINVAL;
1098
1099                 /* clear data read/write/access watchpoint */
1100         case 2:
1101         case 3:
1102         case 4:
1103                 if ((addr & ~7) != ((addr + len - 1) & ~7))
1104                         return -EINVAL;
1105
1106                 tmp = addr & 7;
1107
1108                 memset(dbmr.bytes, 0xff, sizeof(dbmr.bytes));
1109                 for (loop = 0; loop < len; loop++)
1110                         dbmr.bytes[tmp + loop] = 0;
1111
1112                 addr &= ~7;
1113
1114 #define __get_dbar(X) ({ unsigned long x; asm volatile("movsg dbar"#X",%0" : "=r"(x)); x; })
1115 #define __get_dbmr0(X) ({ unsigned long x; asm volatile("movsg dbmr"#X"0,%0" : "=r"(x)); x; })
1116 #define __get_dbmr1(X) ({ unsigned long x; asm volatile("movsg dbmr"#X"1,%0" : "=r"(x)); x; })
1117
1118                 /* consider DBAR 0 */
1119                 tmp = type==2 ? DCR_DWBE0 : type==3 ? DCR_DRBE0 : DCR_DRBE0|DCR_DWBE0;
1120
1121                 if ((__debug_regs->dcr & (DCR_DRBE0|DCR_DWBE0)) != tmp ||
1122                     __get_dbar(0) != addr ||
1123                     __get_dbmr0(0) != dbmr.mask0 ||
1124                     __get_dbmr1(0) != dbmr.mask1)
1125                         goto skip_dbar0;
1126
1127                 //gdbstub_printk("clear h/w watchpoint 0 type %ld: %08lx\n", type, addr);
1128                 __debug_regs->dcr &= ~(DCR_DRBE0|DCR_DWBE0);
1129                 __debug_regs->dbar[0] = 0;
1130                 __debug_regs->dbmr[0][0] = 0;
1131                 __debug_regs->dbmr[0][1] = 0;
1132                 __debug_regs->dbdr[0][0] = 0;
1133                 __debug_regs->dbdr[0][1] = 0;
1134
1135                 asm volatile("  movgs   gr0,dbar0       \n"
1136                              "  movgs   gr0,dbmr00      \n"
1137                              "  movgs   gr0,dbmr01      \n"
1138                              "  movgs   gr0,dbdr00      \n"
1139                              "  movgs   gr0,dbdr01      \n");
1140                 return 0;
1141
1142         skip_dbar0:
1143                 /* consider DBAR 0 */
1144                 tmp = type==2 ? DCR_DWBE1 : type==3 ? DCR_DRBE1 : DCR_DRBE1|DCR_DWBE1;
1145
1146                 if ((__debug_regs->dcr & (DCR_DRBE1|DCR_DWBE1)) != tmp ||
1147                     __get_dbar(1) != addr ||
1148                     __get_dbmr0(1) != dbmr.mask0 ||
1149                     __get_dbmr1(1) != dbmr.mask1)
1150                         goto skip_dbar1;
1151
1152                 //gdbstub_printk("clear h/w watchpoint 1 type %ld: %08lx\n", type, addr);
1153                 __debug_regs->dcr &= ~(DCR_DRBE1|DCR_DWBE1);
1154                 __debug_regs->dbar[1] = 0;
1155                 __debug_regs->dbmr[1][0] = 0;
1156                 __debug_regs->dbmr[1][1] = 0;
1157                 __debug_regs->dbdr[1][0] = 0;
1158                 __debug_regs->dbdr[1][1] = 0;
1159
1160                 asm volatile("  movgs   gr0,dbar1       \n"
1161                              "  movgs   gr0,dbmr10      \n"
1162                              "  movgs   gr0,dbmr11      \n"
1163                              "  movgs   gr0,dbdr10      \n"
1164                              "  movgs   gr0,dbdr11      \n");
1165                 return 0;
1166
1167         skip_dbar1:
1168                 return -ENOSPC;
1169
1170         default:
1171                 return -EINVAL;
1172         }
1173 } /* end gdbstub_clear_breakpoint() */
1174
1175 /*****************************************************************************/
1176 /*
1177  * check a for an internal software breakpoint, and wind the PC back if necessary
1178  */
1179 static void gdbstub_check_breakpoint(void)
1180 {
1181         unsigned long addr = __debug_frame->pc - 4;
1182         int bkpt;
1183
1184         for (bkpt = 255; bkpt >= 0; bkpt--)
1185                 if (gdbstub_bkpts[bkpt].addr == addr)
1186                         break;
1187         if (bkpt >= 0)
1188                 __debug_frame->pc = addr;
1189
1190         //gdbstub_printk("alter pc [%d] %08lx\n", bkpt, __debug_frame->pc);
1191
1192 } /* end gdbstub_check_breakpoint() */
1193
1194 /*****************************************************************************/
1195 /*
1196  *
1197  */
1198 static void __maybe_unused gdbstub_show_regs(void)
1199 {
1200         unsigned long *reg;
1201         int loop;
1202
1203         gdbstub_printk("\n");
1204
1205         gdbstub_printk("Frame: @%p [%s]\n",
1206                        __debug_frame,
1207                        __debug_frame->psr & PSR_S ? "kernel" : "user");
1208
1209         reg = (unsigned long *) __debug_frame;
1210         for (loop = 0; loop < NR_PT_REGS; loop++) {
1211                 printk("%s %08lx", regnames[loop + 0], reg[loop + 0]);
1212
1213                 if (loop == NR_PT_REGS - 1 || loop % 5 == 4)
1214                         printk("\n");
1215                 else
1216                         printk(" | ");
1217         }
1218
1219         gdbstub_printk("Process %s (pid: %d)\n", current->comm, current->pid);
1220 } /* end gdbstub_show_regs() */
1221
1222 /*****************************************************************************/
1223 /*
1224  * dump debugging regs
1225  */
1226 static void __maybe_unused gdbstub_dump_debugregs(void)
1227 {
1228         gdbstub_printk("DCR    %08lx  ", __debug_status.dcr);
1229         gdbstub_printk("BRR    %08lx\n", __debug_status.brr);
1230
1231         gdbstub_printk("IBAR0  %08lx  ", __get_ibar(0));
1232         gdbstub_printk("IBAR1  %08lx  ", __get_ibar(1));
1233         gdbstub_printk("IBAR2  %08lx  ", __get_ibar(2));
1234         gdbstub_printk("IBAR3  %08lx\n", __get_ibar(3));
1235
1236         gdbstub_printk("DBAR0  %08lx  ", __get_dbar(0));
1237         gdbstub_printk("DBMR00 %08lx  ", __get_dbmr0(0));
1238         gdbstub_printk("DBMR01 %08lx\n", __get_dbmr1(0));
1239
1240         gdbstub_printk("DBAR1  %08lx  ", __get_dbar(1));
1241         gdbstub_printk("DBMR10 %08lx  ", __get_dbmr0(1));
1242         gdbstub_printk("DBMR11 %08lx\n", __get_dbmr1(1));
1243
1244         gdbstub_printk("\n");
1245 } /* end gdbstub_dump_debugregs() */
1246
1247 /*****************************************************************************/
1248 /*
1249  * dump the MMU state into a structure so that it can be accessed with GDB
1250  */
1251 void gdbstub_get_mmu_state(void)
1252 {
1253         asm volatile("movsg hsr0,%0" : "=r"(__debug_mmu.regs.hsr0));
1254         asm volatile("movsg pcsr,%0" : "=r"(__debug_mmu.regs.pcsr));
1255         asm volatile("movsg esr0,%0" : "=r"(__debug_mmu.regs.esr0));
1256         asm volatile("movsg ear0,%0" : "=r"(__debug_mmu.regs.ear0));
1257         asm volatile("movsg epcr0,%0" : "=r"(__debug_mmu.regs.epcr0));
1258
1259         /* read the protection / SAT registers */
1260         __debug_mmu.iamr[0].L  = __get_IAMLR(0);
1261         __debug_mmu.iamr[0].P  = __get_IAMPR(0);
1262         __debug_mmu.iamr[1].L  = __get_IAMLR(1);
1263         __debug_mmu.iamr[1].P  = __get_IAMPR(1);
1264         __debug_mmu.iamr[2].L  = __get_IAMLR(2);
1265         __debug_mmu.iamr[2].P  = __get_IAMPR(2);
1266         __debug_mmu.iamr[3].L  = __get_IAMLR(3);
1267         __debug_mmu.iamr[3].P  = __get_IAMPR(3);
1268         __debug_mmu.iamr[4].L  = __get_IAMLR(4);
1269         __debug_mmu.iamr[4].P  = __get_IAMPR(4);
1270         __debug_mmu.iamr[5].L  = __get_IAMLR(5);
1271         __debug_mmu.iamr[5].P  = __get_IAMPR(5);
1272         __debug_mmu.iamr[6].L  = __get_IAMLR(6);
1273         __debug_mmu.iamr[6].P  = __get_IAMPR(6);
1274         __debug_mmu.iamr[7].L  = __get_IAMLR(7);
1275         __debug_mmu.iamr[7].P  = __get_IAMPR(7);
1276         __debug_mmu.iamr[8].L  = __get_IAMLR(8);
1277         __debug_mmu.iamr[8].P  = __get_IAMPR(8);
1278         __debug_mmu.iamr[9].L  = __get_IAMLR(9);
1279         __debug_mmu.iamr[9].P  = __get_IAMPR(9);
1280         __debug_mmu.iamr[10].L = __get_IAMLR(10);
1281         __debug_mmu.iamr[10].P = __get_IAMPR(10);
1282         __debug_mmu.iamr[11].L = __get_IAMLR(11);
1283         __debug_mmu.iamr[11].P = __get_IAMPR(11);
1284         __debug_mmu.iamr[12].L = __get_IAMLR(12);
1285         __debug_mmu.iamr[12].P = __get_IAMPR(12);
1286         __debug_mmu.iamr[13].L = __get_IAMLR(13);
1287         __debug_mmu.iamr[13].P = __get_IAMPR(13);
1288         __debug_mmu.iamr[14].L = __get_IAMLR(14);
1289         __debug_mmu.iamr[14].P = __get_IAMPR(14);
1290         __debug_mmu.iamr[15].L = __get_IAMLR(15);
1291         __debug_mmu.iamr[15].P = __get_IAMPR(15);
1292
1293         __debug_mmu.damr[0].L  = __get_DAMLR(0);
1294         __debug_mmu.damr[0].P  = __get_DAMPR(0);
1295         __debug_mmu.damr[1].L  = __get_DAMLR(1);
1296         __debug_mmu.damr[1].P  = __get_DAMPR(1);
1297         __debug_mmu.damr[2].L  = __get_DAMLR(2);
1298         __debug_mmu.damr[2].P  = __get_DAMPR(2);
1299         __debug_mmu.damr[3].L  = __get_DAMLR(3);
1300         __debug_mmu.damr[3].P  = __get_DAMPR(3);
1301         __debug_mmu.damr[4].L  = __get_DAMLR(4);
1302         __debug_mmu.damr[4].P  = __get_DAMPR(4);
1303         __debug_mmu.damr[5].L  = __get_DAMLR(5);
1304         __debug_mmu.damr[5].P  = __get_DAMPR(5);
1305         __debug_mmu.damr[6].L  = __get_DAMLR(6);
1306         __debug_mmu.damr[6].P  = __get_DAMPR(6);
1307         __debug_mmu.damr[7].L  = __get_DAMLR(7);
1308         __debug_mmu.damr[7].P  = __get_DAMPR(7);
1309         __debug_mmu.damr[8].L  = __get_DAMLR(8);
1310         __debug_mmu.damr[8].P  = __get_DAMPR(8);
1311         __debug_mmu.damr[9].L  = __get_DAMLR(9);
1312         __debug_mmu.damr[9].P  = __get_DAMPR(9);
1313         __debug_mmu.damr[10].L = __get_DAMLR(10);
1314         __debug_mmu.damr[10].P = __get_DAMPR(10);
1315         __debug_mmu.damr[11].L = __get_DAMLR(11);
1316         __debug_mmu.damr[11].P = __get_DAMPR(11);
1317         __debug_mmu.damr[12].L = __get_DAMLR(12);
1318         __debug_mmu.damr[12].P = __get_DAMPR(12);
1319         __debug_mmu.damr[13].L = __get_DAMLR(13);
1320         __debug_mmu.damr[13].P = __get_DAMPR(13);
1321         __debug_mmu.damr[14].L = __get_DAMLR(14);
1322         __debug_mmu.damr[14].P = __get_DAMPR(14);
1323         __debug_mmu.damr[15].L = __get_DAMLR(15);
1324         __debug_mmu.damr[15].P = __get_DAMPR(15);
1325
1326 #ifdef CONFIG_MMU
1327         do {
1328                 /* read the DAT entries from the TLB */
1329                 struct __debug_amr *p;
1330                 int loop;
1331
1332                 asm volatile("movsg tplr,%0" : "=r"(__debug_mmu.regs.tplr));
1333                 asm volatile("movsg tppr,%0" : "=r"(__debug_mmu.regs.tppr));
1334                 asm volatile("movsg tpxr,%0" : "=r"(__debug_mmu.regs.tpxr));
1335                 asm volatile("movsg cxnr,%0" : "=r"(__debug_mmu.regs.cxnr));
1336
1337                 p = __debug_mmu.tlb;
1338
1339                 /* way 0 */
1340                 asm volatile("movgs %0,tpxr" :: "r"(0 << TPXR_WAY_SHIFT));
1341                 for (loop = 0; loop < 64; loop++) {
1342                         asm volatile("tlbpr %0,gr0,#1,#0" :: "r"(loop << PAGE_SHIFT));
1343                         asm volatile("movsg tplr,%0" : "=r"(p->L));
1344                         asm volatile("movsg tppr,%0" : "=r"(p->P));
1345                         p++;
1346                 }
1347
1348                 /* way 1 */
1349                 asm volatile("movgs %0,tpxr" :: "r"(1 << TPXR_WAY_SHIFT));
1350                 for (loop = 0; loop < 64; loop++) {
1351                         asm volatile("tlbpr %0,gr0,#1,#0" :: "r"(loop << PAGE_SHIFT));
1352                         asm volatile("movsg tplr,%0" : "=r"(p->L));
1353                         asm volatile("movsg tppr,%0" : "=r"(p->P));
1354                         p++;
1355                 }
1356
1357                 asm volatile("movgs %0,tplr" :: "r"(__debug_mmu.regs.tplr));
1358                 asm volatile("movgs %0,tppr" :: "r"(__debug_mmu.regs.tppr));
1359                 asm volatile("movgs %0,tpxr" :: "r"(__debug_mmu.regs.tpxr));
1360         } while(0);
1361 #endif
1362
1363 } /* end gdbstub_get_mmu_state() */
1364
1365 /*****************************************************************************/
1366 /*
1367  * handle event interception and GDB remote protocol processing
1368  * - on entry:
1369  *      PSR.ET==0, PSR.S==1 and the CPU is in debug mode
1370  *      __debug_frame points to the saved registers
1371  *      __frame points to the kernel mode exception frame, if it was in kernel
1372  *      mode when the break happened
1373  */
1374 void gdbstub(int sigval)
1375 {
1376         unsigned long addr, length, loop, dbar, temp, temp2, temp3;
1377         uint32_t zero;
1378         char *ptr;
1379         int flush_cache = 0;
1380
1381         LEDS(0x5000);
1382
1383         if (sigval < 0) {
1384 #ifndef CONFIG_GDBSTUB_IMMEDIATE
1385                 /* return immediately if GDB immediate activation option not set */
1386                 return;
1387 #else
1388                 sigval = SIGINT;
1389 #endif
1390         }
1391
1392         save_user_regs(&__debug_frame0->uc);
1393
1394 #if 0
1395         gdbstub_printk("--> gdbstub() %08x %p %08x %08x\n",
1396                        __debug_frame->pc,
1397                        __debug_frame,
1398                        __debug_regs->brr,
1399                        __debug_regs->bpsr);
1400 //      gdbstub_show_regs();
1401 #endif
1402
1403         LEDS(0x5001);
1404
1405         /* if we were interrupted by input on the serial gdbstub serial port,
1406          * restore the context prior to the interrupt so that we return to that
1407          * directly
1408          */
1409         temp = (unsigned long) __entry_kerneltrap_table;
1410         temp2 = (unsigned long) __entry_usertrap_table;
1411         temp3 = __debug_frame->pc & ~15;
1412
1413         if (temp3 == temp + TBR_TT_INTERRUPT_15 ||
1414             temp3 == temp2 + TBR_TT_INTERRUPT_15
1415             ) {
1416                 asm volatile("movsg pcsr,%0" : "=r"(__debug_frame->pc));
1417                 __debug_frame->psr |= PSR_ET;
1418                 __debug_frame->psr &= ~PSR_S;
1419                 if (__debug_frame->psr & PSR_PS)
1420                         __debug_frame->psr |= PSR_S;
1421                 __debug_status.brr = (__debug_frame->tbr & TBR_TT) << 12;
1422                 __debug_status.brr |= BRR_EB;
1423                 sigval = SIGINT;
1424         }
1425
1426         /* handle the decrement timer going off (FR451 only) */
1427         if (temp3 == temp + TBR_TT_DECREMENT_TIMER ||
1428             temp3 == temp2 + TBR_TT_DECREMENT_TIMER
1429             ) {
1430                 asm volatile("movgs %0,timerd" :: "r"(10000000));
1431                 asm volatile("movsg pcsr,%0" : "=r"(__debug_frame->pc));
1432                 __debug_frame->psr |= PSR_ET;
1433                 __debug_frame->psr &= ~PSR_S;
1434                 if (__debug_frame->psr & PSR_PS)
1435                         __debug_frame->psr |= PSR_S;
1436                 __debug_status.brr = (__debug_frame->tbr & TBR_TT) << 12;
1437                 __debug_status.brr |= BRR_EB;
1438                 sigval = SIGXCPU;
1439         }
1440
1441         LEDS(0x5002);
1442
1443         /* after a BREAK insn, the PC lands on the far side of it */
1444         if (__debug_status.brr & BRR_SB)
1445                 gdbstub_check_breakpoint();
1446
1447         LEDS(0x5003);
1448
1449         /* handle attempts to write console data via GDB "O" commands */
1450         if (__debug_frame->pc == (unsigned long) gdbstub_console_write + 4) {
1451                 __gdbstub_console_write((struct console *) __debug_frame->gr8,
1452                                         (const char *) __debug_frame->gr9,
1453                                         (unsigned) __debug_frame->gr10);
1454                 goto done;
1455         }
1456
1457         if (gdbstub_rx_unget) {
1458                 sigval = SIGINT;
1459                 goto packet_waiting;
1460         }
1461
1462         if (!sigval)
1463                 sigval = gdbstub_compute_signal(__debug_status.brr);
1464
1465         LEDS(0x5004);
1466
1467         /* send a message to the debugger's user saying what happened if it may
1468          * not be clear cut (we can't map exceptions onto signals properly)
1469          */
1470         if (sigval != SIGINT && sigval != SIGTRAP && sigval != SIGILL) {
1471                 static const char title[] = "Break ";
1472                 static const char crlf[] = "\r\n";
1473                 unsigned long brr = __debug_status.brr;
1474                 char hx;
1475
1476                 ptr = output_buffer;
1477                 *ptr++ = 'O';
1478                 ptr = mem2hex(title, ptr, sizeof(title) - 1,0);
1479
1480                 hx = hexchars[(brr & 0xf0000000) >> 28];
1481                 *ptr++ = hexchars[hx >> 4];     *ptr++ = hexchars[hx & 0xf];
1482                 hx = hexchars[(brr & 0x0f000000) >> 24];
1483                 *ptr++ = hexchars[hx >> 4];     *ptr++ = hexchars[hx & 0xf];
1484                 hx = hexchars[(brr & 0x00f00000) >> 20];
1485                 *ptr++ = hexchars[hx >> 4];     *ptr++ = hexchars[hx & 0xf];
1486                 hx = hexchars[(brr & 0x000f0000) >> 16];
1487                 *ptr++ = hexchars[hx >> 4];     *ptr++ = hexchars[hx & 0xf];
1488                 hx = hexchars[(brr & 0x0000f000) >> 12];
1489                 *ptr++ = hexchars[hx >> 4];     *ptr++ = hexchars[hx & 0xf];
1490                 hx = hexchars[(brr & 0x00000f00) >> 8];
1491                 *ptr++ = hexchars[hx >> 4];     *ptr++ = hexchars[hx & 0xf];
1492                 hx = hexchars[(brr & 0x000000f0) >> 4];
1493                 *ptr++ = hexchars[hx >> 4];     *ptr++ = hexchars[hx & 0xf];
1494                 hx = hexchars[(brr & 0x0000000f)];
1495                 *ptr++ = hexchars[hx >> 4];     *ptr++ = hexchars[hx & 0xf];
1496
1497                 ptr = mem2hex(crlf, ptr, sizeof(crlf) - 1, 0);
1498                 *ptr = 0;
1499                 gdbstub_send_packet(output_buffer);     /* send it off... */
1500         }
1501
1502         LEDS(0x5005);
1503
1504         /* tell the debugger that an exception has occurred */
1505         ptr = output_buffer;
1506
1507         /* Send trap type (converted to signal) */
1508         *ptr++ = 'T';
1509         *ptr++ = hexchars[sigval >> 4];
1510         *ptr++ = hexchars[sigval & 0xf];
1511
1512         /* Send Error PC */
1513         *ptr++ = hexchars[GDB_REG_PC >> 4];
1514         *ptr++ = hexchars[GDB_REG_PC & 0xf];
1515         *ptr++ = ':';
1516         ptr = mem2hex(&__debug_frame->pc, ptr, 4, 0);
1517         *ptr++ = ';';
1518
1519         /*
1520          * Send frame pointer
1521          */
1522         *ptr++ = hexchars[GDB_REG_FP >> 4];
1523         *ptr++ = hexchars[GDB_REG_FP & 0xf];
1524         *ptr++ = ':';
1525         ptr = mem2hex(&__debug_frame->fp, ptr, 4, 0);
1526         *ptr++ = ';';
1527
1528         /*
1529          * Send stack pointer
1530          */
1531         *ptr++ = hexchars[GDB_REG_SP >> 4];
1532         *ptr++ = hexchars[GDB_REG_SP & 0xf];
1533         *ptr++ = ':';
1534         ptr = mem2hex(&__debug_frame->sp, ptr, 4, 0);
1535         *ptr++ = ';';
1536
1537         *ptr++ = 0;
1538         gdbstub_send_packet(output_buffer);     /* send it off... */
1539
1540         LEDS(0x5006);
1541
1542  packet_waiting:
1543         gdbstub_get_mmu_state();
1544
1545         /* wait for input from remote GDB */
1546         while (1) {
1547                 output_buffer[0] = 0;
1548
1549                 LEDS(0x5007);
1550                 gdbstub_recv_packet(input_buffer);
1551                 LEDS(0x5600 | input_buffer[0]);
1552
1553                 switch (input_buffer[0]) {
1554                         /* request repeat of last signal number */
1555                 case '?':
1556                         output_buffer[0] = 'S';
1557                         output_buffer[1] = hexchars[sigval >> 4];
1558                         output_buffer[2] = hexchars[sigval & 0xf];
1559                         output_buffer[3] = 0;
1560                         break;
1561
1562                 case 'd':
1563                         /* toggle debug flag */
1564                         break;
1565
1566                         /* return the value of the CPU registers
1567                          * - GR0,  GR1,  GR2,  GR3,  GR4,  GR5,  GR6,  GR7,
1568                          * - GR8,  GR9,  GR10, GR11, GR12, GR13, GR14, GR15,
1569                          * - GR16, GR17, GR18, GR19, GR20, GR21, GR22, GR23,
1570                          * - GR24, GR25, GR26, GR27, GR28, GR29, GR30, GR31,
1571                          * - GR32, GR33, GR34, GR35, GR36, GR37, GR38, GR39,
1572                          * - GR40, GR41, GR42, GR43, GR44, GR45, GR46, GR47,
1573                          * - GR48, GR49, GR50, GR51, GR52, GR53, GR54, GR55,
1574                          * - GR56, GR57, GR58, GR59, GR60, GR61, GR62, GR63,
1575                          * - FP0,  FP1,  FP2,  FP3,  FP4,  FP5,  FP6,  FP7,
1576                          * - FP8,  FP9,  FP10, FP11, FP12, FP13, FP14, FP15,
1577                          * - FP16, FP17, FP18, FP19, FP20, FP21, FP22, FP23,
1578                          * - FP24, FP25, FP26, FP27, FP28, FP29, FP30, FP31,
1579                          * - FP32, FP33, FP34, FP35, FP36, FP37, FP38, FP39,
1580                          * - FP40, FP41, FP42, FP43, FP44, FP45, FP46, FP47,
1581                          * - FP48, FP49, FP50, FP51, FP52, FP53, FP54, FP55,
1582                          * - FP56, FP57, FP58, FP59, FP60, FP61, FP62, FP63,
1583                          * - PC, PSR, CCR, CCCR,
1584                          * - _X132, _X133, _X134
1585                          * - TBR, BRR, DBAR0, DBAR1, DBAR2, DBAR3,
1586                          * - _X141, _X142, _X143, _X144,
1587                          * - LR, LCR
1588                          */
1589                 case 'g':
1590                         zero = 0;
1591                         ptr = output_buffer;
1592
1593                         /* deal with GR0, GR1-GR27, GR28-GR31, GR32-GR63 */
1594                         ptr = mem2hex(&zero, ptr, 4, 0);
1595
1596                         for (loop = 1; loop <= 27; loop++)
1597                                 ptr = mem2hex(&__debug_user_context->i.gr[loop], ptr, 4, 0);
1598                         temp = (unsigned long) __frame;
1599                         ptr = mem2hex(&temp, ptr, 4, 0);
1600                         ptr = mem2hex(&__debug_user_context->i.gr[29], ptr, 4, 0);
1601                         ptr = mem2hex(&__debug_user_context->i.gr[30], ptr, 4, 0);
1602 #ifdef CONFIG_MMU
1603                         ptr = mem2hex(&__debug_user_context->i.gr[31], ptr, 4, 0);
1604 #else
1605                         temp = (unsigned long) __debug_frame;
1606                         ptr = mem2hex(&temp, ptr, 4, 0);
1607 #endif
1608
1609                         for (loop = 32; loop <= 63; loop++)
1610                                 ptr = mem2hex(&__debug_user_context->i.gr[loop], ptr, 4, 0);
1611
1612                         /* deal with FR0-FR63 */
1613                         for (loop = 0; loop <= 63; loop++)
1614                                 ptr = mem2hex(&__debug_user_context->f.fr[loop], ptr, 4, 0);
1615
1616                         /* deal with special registers */
1617                         ptr = mem2hex(&__debug_frame->pc,    ptr, 4, 0);
1618                         ptr = mem2hex(&__debug_frame->psr,   ptr, 4, 0);
1619                         ptr = mem2hex(&__debug_frame->ccr,   ptr, 4, 0);
1620                         ptr = mem2hex(&__debug_frame->cccr,  ptr, 4, 0);
1621                         ptr = mem2hex(&zero, ptr, 4, 0);
1622                         ptr = mem2hex(&zero, ptr, 4, 0);
1623                         ptr = mem2hex(&zero, ptr, 4, 0);
1624                         ptr = mem2hex(&__debug_frame->tbr,   ptr, 4, 0);
1625                         ptr = mem2hex(&__debug_status.brr ,   ptr, 4, 0);
1626
1627                         asm volatile("movsg dbar0,%0" : "=r"(dbar));
1628                         ptr = mem2hex(&dbar, ptr, 4, 0);
1629                         asm volatile("movsg dbar1,%0" : "=r"(dbar));
1630                         ptr = mem2hex(&dbar, ptr, 4, 0);
1631                         asm volatile("movsg dbar2,%0" : "=r"(dbar));
1632                         ptr = mem2hex(&dbar, ptr, 4, 0);
1633                         asm volatile("movsg dbar3,%0" : "=r"(dbar));
1634                         ptr = mem2hex(&dbar, ptr, 4, 0);
1635
1636                         asm volatile("movsg scr0,%0" : "=r"(dbar));
1637                         ptr = mem2hex(&dbar, ptr, 4, 0);
1638                         asm volatile("movsg scr1,%0" : "=r"(dbar));
1639                         ptr = mem2hex(&dbar, ptr, 4, 0);
1640                         asm volatile("movsg scr2,%0" : "=r"(dbar));
1641                         ptr = mem2hex(&dbar, ptr, 4, 0);
1642                         asm volatile("movsg scr3,%0" : "=r"(dbar));
1643                         ptr = mem2hex(&dbar, ptr, 4, 0);
1644
1645                         ptr = mem2hex(&__debug_frame->lr, ptr, 4, 0);
1646                         ptr = mem2hex(&__debug_frame->lcr, ptr, 4, 0);
1647
1648                         ptr = mem2hex(&__debug_frame->iacc0, ptr, 8, 0);
1649
1650                         ptr = mem2hex(&__debug_user_context->f.fsr[0], ptr, 4, 0);
1651
1652                         for (loop = 0; loop <= 7; loop++)
1653                                 ptr = mem2hex(&__debug_user_context->f.acc[loop], ptr, 4, 0);
1654
1655                         ptr = mem2hex(&__debug_user_context->f.accg, ptr, 8, 0);
1656
1657                         for (loop = 0; loop <= 1; loop++)
1658                                 ptr = mem2hex(&__debug_user_context->f.msr[loop], ptr, 4, 0);
1659
1660                         ptr = mem2hex(&__debug_frame->gner0, ptr, 4, 0);
1661                         ptr = mem2hex(&__debug_frame->gner1, ptr, 4, 0);
1662
1663                         ptr = mem2hex(&__debug_user_context->f.fner[0], ptr, 4, 0);
1664                         ptr = mem2hex(&__debug_user_context->f.fner[1], ptr, 4, 0);
1665
1666                         break;
1667
1668                         /* set the values of the CPU registers */
1669                 case 'G':
1670                         ptr = &input_buffer[1];
1671
1672                         /* deal with GR0, GR1-GR27, GR28-GR31, GR32-GR63 */
1673                         ptr = hex2mem(ptr, &temp, 4);
1674
1675                         for (loop = 1; loop <= 27; loop++)
1676                                 ptr = hex2mem(ptr, &__debug_user_context->i.gr[loop], 4);
1677
1678                         ptr = hex2mem(ptr, &temp, 4);
1679                         __frame = (struct pt_regs *) temp;
1680                         ptr = hex2mem(ptr, &__debug_frame->gr29, 4);
1681                         ptr = hex2mem(ptr, &__debug_frame->gr30, 4);
1682 #ifdef CONFIG_MMU
1683                         ptr = hex2mem(ptr, &__debug_frame->gr31, 4);
1684 #else
1685                         ptr = hex2mem(ptr, &temp, 4);
1686 #endif
1687
1688                         for (loop = 32; loop <= 63; loop++)
1689                                 ptr = hex2mem(ptr, &__debug_user_context->i.gr[loop], 4);
1690
1691                         /* deal with FR0-FR63 */
1692                         for (loop = 0; loop <= 63; loop++)
1693                                 ptr = mem2hex(&__debug_user_context->f.fr[loop], ptr, 4, 0);
1694
1695                         /* deal with special registers */
1696                         ptr = hex2mem(ptr, &__debug_frame->pc,  4);
1697                         ptr = hex2mem(ptr, &__debug_frame->psr, 4);
1698                         ptr = hex2mem(ptr, &__debug_frame->ccr, 4);
1699                         ptr = hex2mem(ptr, &__debug_frame->cccr,4);
1700
1701                         for (loop = 132; loop <= 140; loop++)
1702                                 ptr = hex2mem(ptr, &temp, 4);
1703
1704                         ptr = hex2mem(ptr, &temp, 4);
1705                         asm volatile("movgs %0,scr0" :: "r"(temp));
1706                         ptr = hex2mem(ptr, &temp, 4);
1707                         asm volatile("movgs %0,scr1" :: "r"(temp));
1708                         ptr = hex2mem(ptr, &temp, 4);
1709                         asm volatile("movgs %0,scr2" :: "r"(temp));
1710                         ptr = hex2mem(ptr, &temp, 4);
1711                         asm volatile("movgs %0,scr3" :: "r"(temp));
1712
1713                         ptr = hex2mem(ptr, &__debug_frame->lr,  4);
1714                         ptr = hex2mem(ptr, &__debug_frame->lcr, 4);
1715
1716                         ptr = hex2mem(ptr, &__debug_frame->iacc0, 8);
1717
1718                         ptr = hex2mem(ptr, &__debug_user_context->f.fsr[0], 4);
1719
1720                         for (loop = 0; loop <= 7; loop++)
1721                                 ptr = hex2mem(ptr, &__debug_user_context->f.acc[loop], 4);
1722
1723                         ptr = hex2mem(ptr, &__debug_user_context->f.accg, 8);
1724
1725                         for (loop = 0; loop <= 1; loop++)
1726                                 ptr = hex2mem(ptr, &__debug_user_context->f.msr[loop], 4);
1727
1728                         ptr = hex2mem(ptr, &__debug_frame->gner0, 4);
1729                         ptr = hex2mem(ptr, &__debug_frame->gner1, 4);
1730
1731                         ptr = hex2mem(ptr, &__debug_user_context->f.fner[0], 4);
1732                         ptr = hex2mem(ptr, &__debug_user_context->f.fner[1], 4);
1733
1734                         gdbstub_strcpy(output_buffer,"OK");
1735                         break;
1736
1737                         /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
1738                 case 'm':
1739                         ptr = &input_buffer[1];
1740
1741                         if (hexToInt(&ptr, &addr) &&
1742                             *ptr++ == ',' &&
1743                             hexToInt(&ptr, &length)
1744                             ) {
1745                                 if (mem2hex((char *)addr, output_buffer, length, 1))
1746                                         break;
1747                                 gdbstub_strcpy (output_buffer, "E03");
1748                         }
1749                         else {
1750                                 gdbstub_strcpy(output_buffer,"E01");
1751                         }
1752                         break;
1753
1754                         /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
1755                 case 'M':
1756                         ptr = &input_buffer[1];
1757
1758                         if (hexToInt(&ptr, &addr) &&
1759                             *ptr++ == ',' &&
1760                             hexToInt(&ptr, &length) &&
1761                             *ptr++ == ':'
1762                             ) {
1763                                 if (hex2mem(ptr, (char *)addr, length)) {
1764                                         gdbstub_strcpy(output_buffer, "OK");
1765                                 }
1766                                 else {
1767                                         gdbstub_strcpy(output_buffer, "E03");
1768                                 }
1769                         }
1770                         else
1771                                 gdbstub_strcpy(output_buffer, "E02");
1772
1773                         flush_cache = 1;
1774                         break;
1775
1776                         /* PNN,=RRRRRRRR: Write value R to reg N return OK */
1777                 case 'P':
1778                         ptr = &input_buffer[1];
1779
1780                         if (!hexToInt(&ptr, &addr) ||
1781                             *ptr++ != '=' ||
1782                             !hexToInt(&ptr, &temp)
1783                             ) {
1784                                 gdbstub_strcpy(output_buffer, "E01");
1785                                 break;
1786                         }
1787
1788                         temp2 = 1;
1789                         switch (addr) {
1790                         case GDB_REG_GR(0):
1791                                 break;
1792                         case GDB_REG_GR(1) ... GDB_REG_GR(63):
1793                                 __debug_user_context->i.gr[addr - GDB_REG_GR(0)] = temp;
1794                                 break;
1795                         case GDB_REG_FR(0) ... GDB_REG_FR(63):
1796                                 __debug_user_context->f.fr[addr - GDB_REG_FR(0)] = temp;
1797                                 break;
1798                         case GDB_REG_PC:
1799                                 __debug_user_context->i.pc = temp;
1800                                 break;
1801                         case GDB_REG_PSR:
1802                                 __debug_user_context->i.psr = temp;
1803                                 break;
1804                         case GDB_REG_CCR:
1805                                 __debug_user_context->i.ccr = temp;
1806                                 break;
1807                         case GDB_REG_CCCR:
1808                                 __debug_user_context->i.cccr = temp;
1809                                 break;
1810                         case GDB_REG_BRR:
1811                                 __debug_status.brr = temp;
1812                                 break;
1813                         case GDB_REG_LR:
1814                                 __debug_user_context->i.lr = temp;
1815                                 break;
1816                         case GDB_REG_LCR:
1817                                 __debug_user_context->i.lcr = temp;
1818                                 break;
1819                         case GDB_REG_FSR0:
1820                                 __debug_user_context->f.fsr[0] = temp;
1821                                 break;
1822                         case GDB_REG_ACC(0) ... GDB_REG_ACC(7):
1823                                 __debug_user_context->f.acc[addr - GDB_REG_ACC(0)] = temp;
1824                                 break;
1825                         case GDB_REG_ACCG(0):
1826                                 *(uint32_t *) &__debug_user_context->f.accg[0] = temp;
1827                                 break;
1828                         case GDB_REG_ACCG(4):
1829                                 *(uint32_t *) &__debug_user_context->f.accg[4] = temp;
1830                                 break;
1831                         case GDB_REG_MSR(0) ... GDB_REG_MSR(1):
1832                                 __debug_user_context->f.msr[addr - GDB_REG_MSR(0)] = temp;
1833                                 break;
1834                         case GDB_REG_GNER(0) ... GDB_REG_GNER(1):
1835                                 __debug_user_context->i.gner[addr - GDB_REG_GNER(0)] = temp;
1836                                 break;
1837                         case GDB_REG_FNER(0) ... GDB_REG_FNER(1):
1838                                 __debug_user_context->f.fner[addr - GDB_REG_FNER(0)] = temp;
1839                                 break;
1840                         default:
1841                                 temp2 = 0;
1842                                 break;
1843                         }
1844
1845                         if (temp2) {
1846                                 gdbstub_strcpy(output_buffer, "OK");
1847                         }
1848                         else {
1849                                 gdbstub_strcpy(output_buffer, "E02");
1850                         }
1851                         break;
1852
1853                         /* cAA..AA    Continue at address AA..AA(optional) */
1854                 case 'c':
1855                         /* try to read optional parameter, pc unchanged if no parm */
1856                         ptr = &input_buffer[1];
1857                         if (hexToInt(&ptr, &addr))
1858                                 __debug_frame->pc = addr;
1859                         goto done;
1860
1861                         /* kill the program */
1862                 case 'k' :
1863                         goto done;      /* just continue */
1864
1865
1866                         /* reset the whole machine (FIXME: system dependent) */
1867                 case 'r':
1868                         break;
1869
1870
1871                         /* step to next instruction */
1872                 case 's':
1873                         __debug_regs->dcr |= DCR_SE;
1874                         __debug_status.dcr |= DCR_SE;
1875                         goto done;
1876
1877                         /* set baud rate (bBB) */
1878                 case 'b':
1879                         ptr = &input_buffer[1];
1880                         if (!hexToInt(&ptr, &temp)) {
1881                                 gdbstub_strcpy(output_buffer,"B01");
1882                                 break;
1883                         }
1884
1885                         if (temp) {
1886                                 /* ack before changing speed */
1887                                 gdbstub_send_packet("OK");
1888                                 gdbstub_set_baud(temp);
1889                         }
1890                         break;
1891
1892                         /* set breakpoint */
1893                 case 'Z':
1894                         ptr = &input_buffer[1];
1895
1896                         if (!hexToInt(&ptr,&temp) || *ptr++ != ',' ||
1897                             !hexToInt(&ptr,&addr) || *ptr++ != ',' ||
1898                             !hexToInt(&ptr,&length)
1899                             ) {
1900                                 gdbstub_strcpy(output_buffer,"E01");
1901                                 break;
1902                         }
1903
1904                         if (temp >= 5) {
1905                                 gdbstub_strcpy(output_buffer,"E03");
1906                                 break;
1907                         }
1908
1909                         if (gdbstub_set_breakpoint(temp, addr, length) < 0) {
1910                                 gdbstub_strcpy(output_buffer,"E03");
1911                                 break;
1912                         }
1913
1914                         if (temp == 0)
1915                                 flush_cache = 1; /* soft bkpt by modified memory */
1916
1917                         gdbstub_strcpy(output_buffer,"OK");
1918                         break;
1919
1920                         /* clear breakpoint */
1921                 case 'z':
1922                         ptr = &input_buffer[1];
1923
1924                         if (!hexToInt(&ptr,&temp) || *ptr++ != ',' ||
1925                             !hexToInt(&ptr,&addr) || *ptr++ != ',' ||
1926                             !hexToInt(&ptr,&length)
1927                             ) {
1928                                 gdbstub_strcpy(output_buffer,"E01");
1929                                 break;
1930                         }
1931
1932                         if (temp >= 5) {
1933                                 gdbstub_strcpy(output_buffer,"E03");
1934                                 break;
1935                         }
1936
1937                         if (gdbstub_clear_breakpoint(temp, addr, length) < 0) {
1938                                 gdbstub_strcpy(output_buffer,"E03");
1939                                 break;
1940                         }
1941
1942                         if (temp == 0)
1943                                 flush_cache = 1; /* soft bkpt by modified memory */
1944
1945                         gdbstub_strcpy(output_buffer,"OK");
1946                         break;
1947
1948                 default:
1949                         gdbstub_proto("### GDB Unsupported Cmd '%s'\n",input_buffer);
1950                         break;
1951                 }
1952
1953                 /* reply to the request */
1954                 LEDS(0x5009);
1955                 gdbstub_send_packet(output_buffer);
1956         }
1957
1958  done:
1959         restore_user_regs(&__debug_frame0->uc);
1960
1961         //gdbstub_dump_debugregs();
1962         //gdbstub_printk("<-- gdbstub() %08x\n", __debug_frame->pc);
1963
1964         /* need to flush the instruction cache before resuming, as we may have
1965          * deposited a breakpoint, and the icache probably has no way of
1966          * knowing that a data ref to some location may have changed something
1967          * that is in the instruction cache.  NB: We flush both caches, just to
1968          * be sure...
1969          */
1970
1971         /* note: flushing the icache will clobber EAR0 on the FR451 */
1972         if (flush_cache)
1973                 gdbstub_purge_cache();
1974
1975         LEDS(0x5666);
1976
1977 } /* end gdbstub() */
1978
1979 /*****************************************************************************/
1980 /*
1981  * initialise the GDB stub
1982  */
1983 void __init gdbstub_init(void)
1984 {
1985 #ifdef CONFIG_GDBSTUB_IMMEDIATE
1986         unsigned char ch;
1987         int ret;
1988 #endif
1989
1990         gdbstub_printk("%s", gdbstub_banner);
1991
1992         gdbstub_io_init();
1993
1994         /* try to talk to GDB (or anyone insane enough to want to type GDB protocol by hand) */
1995         gdbstub_proto("### GDB Tx ACK\n");
1996         gdbstub_tx_char('+'); /* 'hello world' */
1997
1998 #ifdef CONFIG_GDBSTUB_IMMEDIATE
1999         gdbstub_printk("GDB Stub waiting for packet\n");
2000
2001         /*
2002          * In case GDB is started before us, ack any packets
2003          * (presumably "$?#xx") sitting there.
2004          */
2005         do { gdbstub_rx_char(&ch, 0); } while (ch != '$');
2006         do { gdbstub_rx_char(&ch, 0); } while (ch != '#');
2007         do { ret = gdbstub_rx_char(&ch, 0); } while (ret != 0); /* eat first csum byte */
2008         do { ret = gdbstub_rx_char(&ch, 0); } while (ret != 0); /* eat second csum byte */
2009
2010         gdbstub_proto("### GDB Tx NAK\n");
2011         gdbstub_tx_char('-'); /* nak it */
2012
2013 #else
2014         gdbstub_printk("GDB Stub set\n");
2015 #endif
2016
2017 #if 0
2018         /* send banner */
2019         ptr = output_buffer;
2020         *ptr++ = 'O';
2021         ptr = mem2hex(gdbstub_banner, ptr, sizeof(gdbstub_banner) - 1, 0);
2022         gdbstub_send_packet(output_buffer);
2023 #endif
2024 #if defined(CONFIG_GDBSTUB_CONSOLE) && defined(CONFIG_GDBSTUB_IMMEDIATE)
2025         register_console(&gdbstub_console);
2026 #endif
2027
2028 } /* end gdbstub_init() */
2029
2030 /*****************************************************************************/
2031 /*
2032  * register the console at a more appropriate time
2033  */
2034 #if defined (CONFIG_GDBSTUB_CONSOLE) && !defined(CONFIG_GDBSTUB_IMMEDIATE)
2035 static int __init gdbstub_postinit(void)
2036 {
2037         printk("registering console\n");
2038         register_console(&gdbstub_console);
2039         return 0;
2040 } /* end gdbstub_postinit() */
2041
2042 __initcall(gdbstub_postinit);
2043 #endif
2044
2045 /*****************************************************************************/
2046 /*
2047  * send an exit message to GDB
2048  */
2049 void gdbstub_exit(int status)
2050 {
2051         unsigned char checksum;
2052         int count;
2053         unsigned char ch;
2054
2055         sprintf(output_buffer,"W%02x",status&0xff);
2056
2057         gdbstub_tx_char('$');
2058         checksum = 0;
2059         count = 0;
2060
2061         while ((ch = output_buffer[count]) != 0) {
2062                 gdbstub_tx_char(ch);
2063                 checksum += ch;
2064                 count += 1;
2065         }
2066
2067         gdbstub_tx_char('#');
2068         gdbstub_tx_char(hexchars[checksum >> 4]);
2069         gdbstub_tx_char(hexchars[checksum & 0xf]);
2070
2071         /* make sure the output is flushed, or else RedBoot might clobber it */
2072         gdbstub_tx_char('-');
2073         gdbstub_tx_flush();
2074
2075 } /* end gdbstub_exit() */
2076
2077 /*****************************************************************************/
2078 /*
2079  * GDB wants to call malloc() and free() to allocate memory for calling kernel
2080  * functions directly from its command line
2081  */
2082 static void *malloc(size_t size) __maybe_unused;
2083 static void *malloc(size_t size)
2084 {
2085         return kmalloc(size, GFP_ATOMIC);
2086 }
2087
2088 static void free(void *p) __maybe_unused;
2089 static void free(void *p)
2090 {
2091         kfree(p);
2092 }
2093
2094 static uint32_t ___get_HSR0(void) __maybe_unused;
2095 static uint32_t ___get_HSR0(void)
2096 {
2097         return __get_HSR(0);
2098 }
2099
2100 static uint32_t ___set_HSR0(uint32_t x) __maybe_unused;
2101 static uint32_t ___set_HSR0(uint32_t x)
2102 {
2103         __set_HSR(0, x);
2104         return __get_HSR(0);
2105 }