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