arch/ppc/kernel/ppc-stub.c

   1 /*
   2  * ppc-stub.c:  KGDB support for the Linux kernel.
   3  *
   4  * adapted from arch/sparc/kernel/sparc-stub.c for the PowerPC
   5  * some stuff borrowed from Paul Mackerras' xmon
   6  * Copyright (C) 1998 Michael AK Tesch (tesch@cs.wisc.edu)
   7  *
   8  * Modifications to run under Linux
   9  * Copyright (C) 1995 David S. Miller (davem@caip.rutgers.edu)
  10  *
  11  * This file originally came from the gdb sources, and the
  12  * copyright notices have been retained below.
  13  */
  14
  15 /****************************************************************************
  16
  17                 THIS SOFTWARE IS NOT COPYRIGHTED
  18
  19    HP offers the following for use in the public domain.  HP makes no
  20    warranty with regard to the software or its performance and the
  21    user accepts the software "AS IS" with all faults.
  22
  23    HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
  24    TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  25    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  26
  27 ****************************************************************************/
  28
  29 /****************************************************************************
  30  *  Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
  31  *
  32  *  Module name: remcom.c $
  33  *  Revision: 1.34 $
  34  *  Date: 91/03/09 12:29:49 $
  35  *  Contributor:     Lake Stevens Instrument Division$
  36  *
  37  *  Description:     low level support for gdb debugger. $
  38  *
  39  *  Considerations:  only works on target hardware $
  40  *
  41  *  Written by:      Glenn Engel $
  42  *  ModuleState:     Experimental $
  43  *
  44  *  NOTES:           See Below $
  45  *
  46  *  Modified for SPARC by Stu Grossman, Cygnus Support.
  47  *
  48  *  This code has been extensively tested on the Fujitsu SPARClite demo board.
  49  *
  50  *  To enable debugger support, two things need to happen.  One, a
  51  *  call to set_debug_traps() is necessary in order to allow any breakpoints
  52  *  or error conditions to be properly intercepted and reported to gdb.
  53  *  Two, a breakpoint needs to be generated to begin communication.  This
  54  *  is most easily accomplished by a call to breakpoint().  Breakpoint()
  55  *  simulates a breakpoint by executing a trap #1.
  56  *
  57  *************
  58  *
  59  *    The following gdb commands are supported:
  60  *
  61  * command          function                      Return value
  62  *
  63  *    g             return the value of the CPU registers  hex data or ENN
  64  *    G             set the value of the CPU registers     OK or ENN
  65  *    qOffsets      Get section offsets.  Reply is Text=xxx;Data=yyy;Bss=zzz
  66  *
  67  *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
  68  *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
  69  *
  70  *    c             Resume at current address              SNN   ( signal NN)
  71  *    cAA..AA       Continue at address AA..AA             SNN
  72  *
  73  *    s             Step one instruction                   SNN
  74  *    sAA..AA       Step one instruction from AA..AA       SNN
  75  *
  76  *    k             kill
  77  *
  78  *    ?             What was the last sigval ?             SNN   (signal NN)
  79  *
  80  *    bBB..BB       Set baud rate to BB..BB                OK or BNN, then sets
  81  *                                                         baud rate
  82  *
  83  * All commands and responses are sent with a packet which includes a
  84  * checksum.  A packet consists of
  85  *
  86  * $<packet info>#<checksum>.
  87  *
  88  * where
  89  * <packet info> :: <characters representing the command or response>
  90  * <checksum>    :: <two hex digits computed as modulo 256 sum of <packetinfo>>
  91  *
  92  * When a packet is received, it is first acknowledged with either '+' or '-'.
  93  * '+' indicates a successful transfer.  '-' indicates a failed transfer.
  94  *
  95  * Example:
  96  *
  97  * Host:                  Reply:
  98  * $m0,10#2a               +$00010203040506070809101112131415#42
  99  *
 100  ****************************************************************************/
 101
 102 #include <linux/config.h>
 103 #include <linux/kernel.h>
 104 #include <linux/string.h>
 105 #include <linux/mm.h>
 106 #include <linux/smp.h>
 107 #include <linux/smp_lock.h>
 108 #include <linux/init.h>
 109 #include <linux/sysrq.h>
 110
 111 #include <asm/cacheflush.h>
 112 #include <asm/system.h>
 113 #include <asm/signal.h>
 114 #include <asm/kgdb.h>
 115 #include <asm/pgtable.h>
 116 #include <asm/ptrace.h>
 117
 118 void breakinst(void);
 119
 120 /*
 121  * BUFMAX defines the maximum number of characters in inbound/outbound buffers
 122  * at least NUMREGBYTES*2 are needed for register packets
 123  */
 124 #define BUFMAX 2048
 125 static char remcomInBuffer[BUFMAX];
 126 static char remcomOutBuffer[BUFMAX];
 127
 128 static int initialized;
 129 static int kgdb_active;
 130 static int kgdb_started;
 131 static u_int fault_jmp_buf[100];
 132 static int kdebug;
 133
 134
 135 static const char hexchars[]="0123456789abcdef";
 136
 137 /* Place where we save old trap entries for restoration - sparc*/
 138 /* struct tt_entry kgdb_savettable[256]; */
 139 /* typedef void (*trapfunc_t)(void); */
 140
 141 static void kgdb_fault_handler(struct pt_regs *regs);
 142 static int handle_exception (struct pt_regs *regs);
 143
 144 #if 0
 145 /* Install an exception handler for kgdb */
 146 static void exceptionHandler(int tnum, unsigned int *tfunc)
 147 {
 148         /* We are dorking with a live trap table, all irqs off */
 149 }
 150 #endif
 151
 152 int
 153 kgdb_setjmp(long *buf)
 154 {
 155         asm ("mflr 0; stw 0,0(%0);"
 156              "stw 1,4(%0); stw 2,8(%0);"
 157              "mfcr 0; stw 0,12(%0);"
 158              "stmw 13,16(%0)"
 159              : : "r" (buf));
 160         /* XXX should save fp regs as well */
 161         return 0;
 162 }
 163 void
 164 kgdb_longjmp(long *buf, int val)
 165 {
 166         if (val == 0)
 167                 val = 1;
 168         asm ("lmw 13,16(%0);"
 169              "lwz 0,12(%0); mtcrf 0x38,0;"
 170              "lwz 0,0(%0); lwz 1,4(%0); lwz 2,8(%0);"
 171              "mtlr 0; mr 3,%1"
 172              : : "r" (buf), "r" (val));
 173 }
 174 /* Convert ch from a hex digit to an int */
 175 static int
 176 hex(unsigned char ch)
 177 {
 178         if (ch >= 'a' && ch <= 'f')
 179                 return ch-'a'+10;
 180         if (ch >= '0' && ch <= '9')
 181                 return ch-'0';
 182         if (ch >= 'A' && ch <= 'F')
 183                 return ch-'A'+10;
 184         return -1;
 185 }
 186
 187 /* Convert the memory pointed to by mem into hex, placing result in buf.
 188  * Return a pointer to the last char put in buf (null), in case of mem fault,
 189  * return 0.
 190  */
 191 static unsigned char *
 192 mem2hex(const char *mem, char *buf, int count)
 193 {
 194         unsigned char ch;
 195         unsigned short tmp_s;
 196         unsigned long tmp_l;
 197
 198         if (kgdb_setjmp((long*)fault_jmp_buf) == 0) {
 199                 debugger_fault_handler = kgdb_fault_handler;
 200
 201                 /* Accessing 16 bit and 32 bit objects in a single
 202                 ** load instruction is required to avoid bad side
 203                 ** effects for some IO registers.
 204                 */
 205
 206                 if ((count == 2) && (((long)mem & 1) == 0)) {
 207                         tmp_s = *(unsigned short *)mem;
 208                         mem += 2;
 209                         *buf++ = hexchars[(tmp_s >> 12) & 0xf];
 210                         *buf++ = hexchars[(tmp_s >> 8) & 0xf];
 211                         *buf++ = hexchars[(tmp_s >> 4) & 0xf];
 212                         *buf++ = hexchars[tmp_s & 0xf];
 213
 214                 } else if ((count == 4) && (((long)mem & 3) == 0)) {
 215                         tmp_l = *(unsigned int *)mem;
 216                         mem += 4;
 217                         *buf++ = hexchars[(tmp_l >> 28) & 0xf];
 218                         *buf++ = hexchars[(tmp_l >> 24) & 0xf];
 219                         *buf++ = hexchars[(tmp_l >> 20) & 0xf];
 220                         *buf++ = hexchars[(tmp_l >> 16) & 0xf];
 221                         *buf++ = hexchars[(tmp_l >> 12) & 0xf];
 222                         *buf++ = hexchars[(tmp_l >> 8) & 0xf];
 223                         *buf++ = hexchars[(tmp_l >> 4) & 0xf];
 224                         *buf++ = hexchars[tmp_l & 0xf];
 225
 226                 } else {
 227                         while (count-- > 0) {
 228                                 ch = *mem++;
 229                                 *buf++ = hexchars[ch >> 4];
 230                                 *buf++ = hexchars[ch & 0xf];
 231                         }
 232                 }
 233
 234         } else {
 235                 /* error condition */
 236         }
 237         debugger_fault_handler = NULL;
 238         *buf = 0;
 239         return buf;
 240 }
 241
 242 /* convert the hex array pointed to by buf into binary to be placed in mem
 243  * return a pointer to the character AFTER the last byte written.
 244 */
 245 static char *
 246 hex2mem(char *buf, char *mem, int count)
 247 {
 248         unsigned char ch;
 249         int i;
 250         char *orig_mem;
 251         unsigned short tmp_s;
 252         unsigned long tmp_l;
 253
 254         orig_mem = mem;
 255
 256         if (kgdb_setjmp((long*)fault_jmp_buf) == 0) {
 257                 debugger_fault_handler = kgdb_fault_handler;
 258
 259                 /* Accessing 16 bit and 32 bit objects in a single
 260                 ** store instruction is required to avoid bad side
 261                 ** effects for some IO registers.
 262                 */
 263
 264                 if ((count == 2) && (((long)mem & 1) == 0)) {
 265                         tmp_s = hex(*buf++) << 12;
 266                         tmp_s |= hex(*buf++) << 8;
 267                         tmp_s |= hex(*buf++) << 4;
 268                         tmp_s |= hex(*buf++);
 269
 270                         *(unsigned short *)mem = tmp_s;
 271                         mem += 2;
 272
 273                 } else if ((count == 4) && (((long)mem & 3) == 0)) {
 274                         tmp_l = hex(*buf++) << 28;
 275                         tmp_l |= hex(*buf++) << 24;
 276                         tmp_l |= hex(*buf++) << 20;
 277                         tmp_l |= hex(*buf++) << 16;
 278                         tmp_l |= hex(*buf++) << 12;
 279                         tmp_l |= hex(*buf++) << 8;
 280                         tmp_l |= hex(*buf++) << 4;
 281                         tmp_l |= hex(*buf++);
 282
 283                         *(unsigned long *)mem = tmp_l;
 284                         mem += 4;
 285
 286                 } else {
 287                         for (i=0; i<count; i++) {
 288                                 ch = hex(*buf++) << 4;
 289                                 ch |= hex(*buf++);
 290                                 *mem++ = ch;
 291                         }
 292                 }
 293
 294
 295                 /*
 296                 ** Flush the data cache, invalidate the instruction cache.
 297                 */
 298                 flush_icache_range((int)orig_mem, (int)orig_mem + count - 1);
 299
 300         } else {
 301                 /* error condition */
 302         }
 303         debugger_fault_handler = NULL;
 304         return mem;
 305 }
 306
 307 /*
 308  * While we find nice hex chars, build an int.
 309  * Return number of chars processed.
 310  */
 311 static int
 312 hexToInt(char **ptr, int *intValue)
 313 {
 314         int numChars = 0;
 315         int hexValue;
 316
 317         *intValue = 0;
 318
 319         if (kgdb_setjmp((long*)fault_jmp_buf) == 0) {
 320                 debugger_fault_handler = kgdb_fault_handler;
 321                 while (**ptr) {
 322                         hexValue = hex(**ptr);
 323                         if (hexValue < 0)
 324                                 break;
 325
 326                         *intValue = (*intValue << 4) | hexValue;
 327                         numChars ++;
 328
 329                         (*ptr)++;
 330                 }
 331         } else {
 332                 /* error condition */
 333         }
 334         debugger_fault_handler = NULL;
 335
 336         return (numChars);
 337 }
 338
 339 /* scan for the sequence $<data>#<checksum> */
 340 static void
 341 getpacket(char *buffer)
 342 {
 343         unsigned char checksum;
 344         unsigned char xmitcsum;
 345         int i;
 346         int count;
 347         unsigned char ch;
 348
 349         do {
 350                 /* wait around for the start character, ignore all other
 351                  * characters */
 352                 while ((ch = (getDebugChar() & 0x7f)) != '$') ;
 353
 354                 checksum = 0;
 355                 xmitcsum = -1;
 356
 357                 count = 0;
 358
 359                 /* now, read until a # or end of buffer is found */
 360                 while (count < BUFMAX) {
 361                         ch = getDebugChar() & 0x7f;
 362                         if (ch == '#')
 363                                 break;
 364                         checksum = checksum + ch;
 365                         buffer[count] = ch;
 366                         count = count + 1;
 367                 }
 368
 369                 if (count >= BUFMAX)
 370                         continue;
 371
 372                 buffer[count] = 0;
 373
 374                 if (ch == '#') {
 375                         xmitcsum = hex(getDebugChar() & 0x7f) << 4;
 376                         xmitcsum |= hex(getDebugChar() & 0x7f);
 377                         if (checksum != xmitcsum)
 378                                 putDebugChar('-');      /* failed checksum */
 379                         else {
 380                                 putDebugChar('+'); /* successful transfer */
 381                                 /* if a sequence char is present, reply the ID */
 382                                 if (buffer[2] == ':') {
 383                                         putDebugChar(buffer[0]);
 384                                         putDebugChar(buffer[1]);
 385                                         /* remove sequence chars from buffer */
 386                                         count = strlen(buffer);
 387                                         for (i=3; i <= count; i++)
 388                                                 buffer[i-3] = buffer[i];
 389                                 }
 390                         }
 391                 }
 392         } while (checksum != xmitcsum);
 393 }
 394
 395 /* send the packet in buffer. */
 396 static void putpacket(unsigned char *buffer)
 397 {
 398         unsigned char checksum;
 399         int count;
 400         unsigned char ch, recv;
 401
 402         /* $<packet info>#<checksum>. */
 403         do {
 404                 putDebugChar('$');
 405                 checksum = 0;
 406                 count = 0;
 407
 408                 while ((ch = buffer[count])) {
 409                         putDebugChar(ch);
 410                         checksum += ch;
 411                         count += 1;
 412                 }
 413
 414                 putDebugChar('#');
 415                 putDebugChar(hexchars[checksum >> 4]);
 416                 putDebugChar(hexchars[checksum & 0xf]);
 417                 recv = getDebugChar();
 418         } while ((recv & 0x7f) != '+');
 419 }
 420
 421 static void kgdb_flush_cache_all(void)
 422 {
 423         flush_instruction_cache();
 424 }
 425
 426 /* Set up exception handlers for tracing and breakpoints
 427  * [could be called kgdb_init()]
 428  */
 429 void set_debug_traps(void)
 430 {
 431 #if 0
 432         unsigned char c;
 433
 434         save_and_cli(flags);
 435
 436         /* In case GDB is started before us, ack any packets (presumably
 437          * "$?#xx") sitting there.
 438          *
 439          * I've found this code causes more problems than it solves,
 440          * so that's why it's commented out.  GDB seems to work fine
 441          * now starting either before or after the kernel   -bwb
 442          */
 443
 444         while((c = getDebugChar()) != '$');
 445         while((c = getDebugChar()) != '#');
 446         c = getDebugChar(); /* eat first csum byte */
 447         c = getDebugChar(); /* eat second csum byte */
 448         putDebugChar('+'); /* ack it */
 449 #endif
 450         debugger = kgdb;
 451         debugger_bpt = kgdb_bpt;
 452         debugger_sstep = kgdb_sstep;
 453         debugger_iabr_match = kgdb_iabr_match;
 454         debugger_dabr_match = kgdb_dabr_match;
 455
 456         initialized = 1;
 457 }
 458
 459 static void kgdb_fault_handler(struct pt_regs *regs)
 460 {
 461         kgdb_longjmp((long*)fault_jmp_buf, 1);
 462 }
 463
 464 int kgdb_bpt(struct pt_regs *regs)
 465 {
 466         return handle_exception(regs);
 467 }
 468
 469 int kgdb_sstep(struct pt_regs *regs)
 470 {
 471         return handle_exception(regs);
 472 }
 473
 474 void kgdb(struct pt_regs *regs)
 475 {
 476         handle_exception(regs);
 477 }
 478
 479 int kgdb_iabr_match(struct pt_regs *regs)
 480 {
 481         printk(KERN_ERR "kgdb doesn't support iabr, what?!?\n");
 482         return handle_exception(regs);
 483 }
 484
 485 int kgdb_dabr_match(struct pt_regs *regs)
 486 {
 487         printk(KERN_ERR "kgdb doesn't support dabr, what?!?\n");
 488         return handle_exception(regs);
 489 }
 490
 491 /* Convert the hardware trap type code to a unix signal number. */
 492 /*
 493  * This table contains the mapping between PowerPC hardware trap types, and
 494  * signals, which are primarily what GDB understands.
 495  */
 496 static struct hard_trap_info
 497 {
 498         unsigned int tt;                /* Trap type code for powerpc */
 499         unsigned char signo;            /* Signal that we map this trap into */
 500 } hard_trap_info[] = {
 501 #if defined(CONFIG_40x) || defined(CONFIG_BOOKE)
 502         { 0x100, SIGINT  },             /* critical input interrupt */
 503         { 0x200, SIGSEGV },             /* machine check */
 504         { 0x300, SIGSEGV },             /* data storage */
 505         { 0x400, SIGBUS  },             /* instruction storage */
 506         { 0x500, SIGINT  },             /* interrupt */
 507         { 0x600, SIGBUS  },             /* alignment */
 508         { 0x700, SIGILL  },             /* program */
 509         { 0x800, SIGILL  },             /* reserved */
 510         { 0x900, SIGILL  },             /* reserved */
 511         { 0xa00, SIGILL  },             /* reserved */
 512         { 0xb00, SIGILL  },             /* reserved */
 513         { 0xc00, SIGCHLD },             /* syscall */
 514         { 0xd00, SIGILL  },             /* reserved */
 515         { 0xe00, SIGILL  },             /* reserved */
 516         { 0xf00, SIGILL  },             /* reserved */
 517         /*
 518         ** 0x1000  PIT
 519         ** 0x1010  FIT
 520         ** 0x1020  watchdog
 521         ** 0x1100  data TLB miss
 522         ** 0x1200  instruction TLB miss
 523         */
 524         { 0x2002, SIGTRAP},             /* debug */
 525 #else
 526         { 0x200, SIGSEGV },             /* machine check */
 527         { 0x300, SIGSEGV },             /* address error (store) */
 528         { 0x400, SIGBUS },              /* instruction bus error */
 529         { 0x500, SIGINT },              /* interrupt */
 530         { 0x600, SIGBUS },              /* alingment */
 531         { 0x700, SIGTRAP },             /* breakpoint trap */
 532         { 0x800, SIGFPE },              /* fpu unavail */
 533         { 0x900, SIGALRM },             /* decrementer */
 534         { 0xa00, SIGILL },              /* reserved */
 535         { 0xb00, SIGILL },              /* reserved */
 536         { 0xc00, SIGCHLD },             /* syscall */
 537         { 0xd00, SIGTRAP },             /* single-step/watch */
 538         { 0xe00, SIGFPE },              /* fp assist */
 539 #endif
 540         { 0, 0}                         /* Must be last */
 541
 542 };
 543
 544 static int computeSignal(unsigned int tt)
 545 {
 546         struct hard_trap_info *ht;
 547
 548         for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
 549                 if (ht->tt == tt)
 550                         return ht->signo;
 551
 552         return SIGHUP; /* default for things we don't know about */
 553 }
 554
 555 #define PC_REGNUM 64
 556 #define SP_REGNUM 1
 557
 558 /*
 559  * This function does all command processing for interfacing to gdb.
 560  */
 561 static int
 562 handle_exception (struct pt_regs *regs)
 563 {
 564         int sigval;
 565         int addr;
 566         int length;
 567         char *ptr;
 568         unsigned int msr;
 569
 570         /* We don't handle user-mode breakpoints. */
 571         if (user_mode(regs))
 572                 return 0;
 573
 574         if (debugger_fault_handler) {
 575                 debugger_fault_handler(regs);
 576                 panic("kgdb longjump failed!\n");
 577         }
 578         if (kgdb_active) {
 579                 printk(KERN_ERR "interrupt while in kgdb, returning\n");
 580                 return 0;
 581         }
 582
 583         kgdb_active = 1;
 584         kgdb_started = 1;
 585
 586 #ifdef KGDB_DEBUG
 587         printk("kgdb: entering handle_exception; trap [0x%x]\n",
 588                         (unsigned int)regs->trap);
 589 #endif
 590
 591         kgdb_interruptible(0);
 592         lock_kernel();
 593         msr = mfmsr();
 594         mtmsr(msr & ~MSR_EE);   /* disable interrupts */
 595
 596         if (regs->nip == (unsigned long)breakinst) {
 597                 /* Skip over breakpoint trap insn */
 598                 regs->nip += 4;
 599         }
 600
 601         /* reply to host that an exception has occurred */
 602         sigval = computeSignal(regs->trap);
 603         ptr = remcomOutBuffer;
 604
 605         *ptr++ = 'T';
 606         *ptr++ = hexchars[sigval >> 4];
 607         *ptr++ = hexchars[sigval & 0xf];
 608         *ptr++ = hexchars[PC_REGNUM >> 4];
 609         *ptr++ = hexchars[PC_REGNUM & 0xf];
 610         *ptr++ = ':';
 611         ptr = mem2hex((char *)&regs->nip, ptr, 4);
 612         *ptr++ = ';';
 613         *ptr++ = hexchars[SP_REGNUM >> 4];
 614         *ptr++ = hexchars[SP_REGNUM & 0xf];
 615         *ptr++ = ':';
 616         ptr = mem2hex(((char *)regs) + SP_REGNUM*4, ptr, 4);
 617         *ptr++ = ';';
 618         *ptr++ = 0;
 619
 620         putpacket(remcomOutBuffer);
 621         if (kdebug)
 622                 printk("remcomOutBuffer: %s\n", remcomOutBuffer);
 623
 624         /* XXX We may want to add some features dealing with poking the
 625          * XXX page tables, ... (look at sparc-stub.c for more info)
 626          * XXX also required hacking to the gdb sources directly...
 627          */
 628
 629         while (1) {
 630                 remcomOutBuffer[0] = 0;
 631
 632                 getpacket(remcomInBuffer);
 633                 switch (remcomInBuffer[0]) {
 634                 case '?': /* report most recent signal */
 635                         remcomOutBuffer[0] = 'S';
 636                         remcomOutBuffer[1] = hexchars[sigval >> 4];
 637                         remcomOutBuffer[2] = hexchars[sigval & 0xf];
 638                         remcomOutBuffer[3] = 0;
 639                         break;
 640 #if 0
 641                 case 'q': /* this screws up gdb for some reason...*/
 642                 {
 643                         extern long _start, sdata, __bss_start;
 644
 645                         ptr = &remcomInBuffer[1];
 646                         if (strncmp(ptr, "Offsets", 7) != 0)
 647                                 break;
 648
 649                         ptr = remcomOutBuffer;
 650                         sprintf(ptr, "Text=%8.8x;Data=%8.8x;Bss=%8.8x",
 651                                 &_start, &sdata, &__bss_start);
 652                         break;
 653                 }
 654 #endif
 655                 case 'd':
 656                         /* toggle debug flag */
 657                         kdebug ^= 1;
 658                         break;
 659
 660                 case 'g':       /* return the value of the CPU registers.
 661                                  * some of them are non-PowerPC names :(
 662                                  * they are stored in gdb like:
 663                                  * struct {
 664                                  *     u32 gpr[32];
 665                                  *     f64 fpr[32];
 666                                  *     u32 pc, ps, cnd, lr; (ps=msr)
 667                                  *     u32 cnt, xer, mq;
 668                                  * }
 669                                  */
 670                 {
 671                         int i;
 672                         ptr = remcomOutBuffer;
 673                         /* General Purpose Regs */
 674                         ptr = mem2hex((char *)regs, ptr, 32 * 4);
 675                         /* Floating Point Regs - FIXME */
 676                         /*ptr = mem2hex((char *), ptr, 32 * 8);*/
 677                         for(i=0; i<(32*8*2); i++) { /* 2chars/byte */
 678                                 ptr[i] = '0';
 679                         }
 680                         ptr += 32*8*2;
 681                         /* pc, msr, cr, lr, ctr, xer, (mq is unused) */
 682                         ptr = mem2hex((char *)&regs->nip, ptr, 4);
 683                         ptr = mem2hex((char *)&regs->msr, ptr, 4);
 684                         ptr = mem2hex((char *)&regs->ccr, ptr, 4);
 685                         ptr = mem2hex((char *)&regs->link, ptr, 4);
 686                         ptr = mem2hex((char *)&regs->ctr, ptr, 4);
 687                         ptr = mem2hex((char *)&regs->xer, ptr, 4);
 688                 }
 689                         break;
 690
 691                 case 'G': /* set the value of the CPU registers */
 692                 {
 693                         ptr = &remcomInBuffer[1];
 694
 695                         /*
 696                          * If the stack pointer has moved, you should pray.
 697                          * (cause only god can help you).
 698                          */
 699
 700                         /* General Purpose Regs */
 701                         hex2mem(ptr, (char *)regs, 32 * 4);
 702
 703                         /* Floating Point Regs - FIXME?? */
 704                         /*ptr = hex2mem(ptr, ??, 32 * 8);*/
 705                         ptr += 32*8*2;
 706
 707                         /* pc, msr, cr, lr, ctr, xer, (mq is unused) */
 708                         ptr = hex2mem(ptr, (char *)&regs->nip, 4);
 709                         ptr = hex2mem(ptr, (char *)&regs->msr, 4);
 710                         ptr = hex2mem(ptr, (char *)&regs->ccr, 4);
 711                         ptr = hex2mem(ptr, (char *)&regs->link, 4);
 712                         ptr = hex2mem(ptr, (char *)&regs->ctr, 4);
 713                         ptr = hex2mem(ptr, (char *)&regs->xer, 4);
 714
 715                         strcpy(remcomOutBuffer,"OK");
 716                 }
 717                         break;
 718                 case 'H':
 719                         /* don't do anything, yet, just acknowledge */
 720                         hexToInt(&ptr, &addr);
 721                         strcpy(remcomOutBuffer,"OK");
 722                         break;
 723
 724                 case 'm':       /* mAA..AA,LLLL  Read LLLL bytes at address AA..AA */
 725                                 /* Try to read %x,%x.  */
 726
 727                         ptr = &remcomInBuffer[1];
 728
 729                         if (hexToInt(&ptr, &addr) && *ptr++ == ','
 730                                         && hexToInt(&ptr, &length)) {
 731                                 if (mem2hex((char *)addr, remcomOutBuffer,
 732                                                         length))
 733                                         break;
 734                                 strcpy(remcomOutBuffer, "E03");
 735                         } else
 736                                 strcpy(remcomOutBuffer, "E01");
 737                         break;
 738
 739                 case 'M': /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
 740                         /* Try to read '%x,%x:'.  */
 741
 742                         ptr = &remcomInBuffer[1];
 743
 744                         if (hexToInt(&ptr, &addr) && *ptr++ == ','
 745                                         && hexToInt(&ptr, &length)
 746                                         && *ptr++ == ':') {
 747                                 if (hex2mem(ptr, (char *)addr, length))
 748                                         strcpy(remcomOutBuffer, "OK");
 749                                 else
 750                                         strcpy(remcomOutBuffer, "E03");
 751                                 flush_icache_range(addr, addr+length);
 752                         } else
 753                                 strcpy(remcomOutBuffer, "E02");
 754                         break;
 755
 756
 757                 case 'k': /* kill the program, actually just continue */
 758                 case 'c': /* cAA..AA  Continue; address AA..AA optional */
 759                         /* try to read optional parameter, pc unchanged if no parm */
 760
 761                         ptr = &remcomInBuffer[1];
 762                         if (hexToInt(&ptr, &addr))
 763                                 regs->nip = addr;
 764
 765 /* Need to flush the instruction cache here, as we may have deposited a
 766  * breakpoint, and the icache probably has no way of knowing that a data ref to
 767  * some location may have changed something that is in the instruction cache.
 768  */
 769                         kgdb_flush_cache_all();
 770                         mtmsr(msr);
 771
 772                         kgdb_interruptible(1);
 773                         unlock_kernel();
 774                         kgdb_active = 0;
 775                         if (kdebug) {
 776                                 printk("remcomInBuffer: %s\n", remcomInBuffer);
 777                                 printk("remcomOutBuffer: %s\n", remcomOutBuffer);
 778                         }
 779                         return 1;
 780
 781                 case 's':
 782                         kgdb_flush_cache_all();
 783 #if defined(CONFIG_40x) || defined(CONFIG_BOOKE)
 784                         mtspr(SPRN_DBCR0, mfspr(SPRN_DBCR0) | DBCR0_IC);
 785                         regs->msr |= MSR_DE;
 786 #else
 787                         regs->msr |= MSR_SE;
 788 #endif
 789                         unlock_kernel();
 790                         kgdb_active = 0;
 791                         if (kdebug) {
 792                                 printk("remcomInBuffer: %s\n", remcomInBuffer);
 793                                 printk("remcomOutBuffer: %s\n", remcomOutBuffer);
 794                         }
 795                         return 1;
 796
 797                 case 'r':               /* Reset (if user process..exit ???)*/
 798                         panic("kgdb reset.");
 799                         break;
 800                 }                       /* switch */
 801                 if (remcomOutBuffer[0] && kdebug) {
 802                         printk("remcomInBuffer: %s\n", remcomInBuffer);
 803                         printk("remcomOutBuffer: %s\n", remcomOutBuffer);
 804                 }
 805                 /* reply to the request */
 806                 putpacket(remcomOutBuffer);
 807         } /* while(1) */
 808 }
 809
 810 /* This function will generate a breakpoint exception.  It is used at the
 811    beginning of a program to sync up with a debugger and can be used
 812    otherwise as a quick means to stop program execution and "break" into
 813    the debugger. */
 814
 815 void
 816 breakpoint(void)
 817 {
 818         if (!initialized) {
 819                 printk("breakpoint() called b4 kgdb init\n");
 820                 return;
 821         }
 822
 823         asm("   .globl breakinst        \n\
 824              breakinst: .long 0x7d821008");
 825 }
 826
 827 #ifdef CONFIG_KGDB_CONSOLE
 828 /* Output string in GDB O-packet format if GDB has connected. If nothing
 829    output, returns 0 (caller must then handle output). */
 830 int
 831 kgdb_output_string (const char* s, unsigned int count)
 832 {
 833         char buffer[512];
 834
 835         if (!kgdb_started)
 836                 return 0;
 837
 838         count = (count <= (sizeof(buffer) / 2 - 2))
 839                 ? count : (sizeof(buffer) / 2 - 2);
 840
 841         buffer[0] = 'O';
 842         mem2hex (s, &buffer[1], count);
 843         putpacket(buffer);
 844
 845         return 1;
 846 }
 847 #endif
 848
 849 static void sysrq_handle_gdb(int key, struct pt_regs *pt_regs,
 850                              struct tty_struct *tty)
 851 {
 852         printk("Entering GDB stub\n");
 853         breakpoint();
 854 }
 855 static struct sysrq_key_op sysrq_gdb_op = {
 856         .handler        = sysrq_handle_gdb,
 857         .help_msg       = "Gdb",
 858         .action_msg     = "GDB",
 859 };
 860
 861 static int gdb_register_sysrq(void)
 862 {
 863         printk("Registering GDB sysrq handler\n");
 864         register_sysrq_key('g', &sysrq_gdb_op);
 865         return 0;
 866 }
 867 module_init(gdb_register_sysrq);