Prevent gcc from optimizing a few functions away completly.
[linux-2.6] / arch / mips / kernel / gdb-stub.c
1 /*
2  *  arch/mips/kernel/gdb-stub.c
3  *
4  *  Originally written by Glenn Engel, Lake Stevens Instrument Division
5  *
6  *  Contributed by HP Systems
7  *
8  *  Modified for SPARC by Stu Grossman, Cygnus Support.
9  *
10  *  Modified for Linux/MIPS (and MIPS in general) by Andreas Busse
11  *  Send complaints, suggestions etc. to <andy@waldorf-gmbh.de>
12  *
13  *  Copyright (C) 1995 Andreas Busse
14  *
15  *  Copyright (C) 2003 MontaVista Software Inc.
16  *  Author: Jun Sun, jsun@mvista.com or jsun@junsun.net
17  */
18
19 /*
20  *  To enable debugger support, two things need to happen.  One, a
21  *  call to set_debug_traps() is necessary in order to allow any breakpoints
22  *  or error conditions to be properly intercepted and reported to gdb.
23  *  Two, a breakpoint needs to be generated to begin communication.  This
24  *  is most easily accomplished by a call to breakpoint().  Breakpoint()
25  *  simulates a breakpoint by executing a BREAK instruction.
26  *
27  *
28  *    The following gdb commands are supported:
29  *
30  * command          function                               Return value
31  *
32  *    g             return the value of the CPU registers  hex data or ENN
33  *    G             set the value of the CPU registers     OK or ENN
34  *
35  *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
36  *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
37  *
38  *    c             Resume at current address              SNN   ( signal NN)
39  *    cAA..AA       Continue at address AA..AA             SNN
40  *
41  *    s             Step one instruction                   SNN
42  *    sAA..AA       Step one instruction from AA..AA       SNN
43  *
44  *    k             kill
45  *
46  *    ?             What was the last sigval ?             SNN   (signal NN)
47  *
48  *    bBB..BB       Set baud rate to BB..BB                OK or BNN, then sets
49  *                                                         baud rate
50  *
51  * All commands and responses are sent with a packet which includes a
52  * checksum.  A packet consists of
53  *
54  * $<packet info>#<checksum>.
55  *
56  * where
57  * <packet info> :: <characters representing the command or response>
58  * <checksum>    :: < two hex digits computed as modulo 256 sum of <packetinfo>>
59  *
60  * When a packet is received, it is first acknowledged with either '+' or '-'.
61  * '+' indicates a successful transfer.  '-' indicates a failed transfer.
62  *
63  * Example:
64  *
65  * Host:                  Reply:
66  * $m0,10#2a               +$00010203040506070809101112131415#42
67  *
68  *
69  *  ==============
70  *  MORE EXAMPLES:
71  *  ==============
72  *
73  *  For reference -- the following are the steps that one
74  *  company took (RidgeRun Inc) to get remote gdb debugging
75  *  going. In this scenario the host machine was a PC and the
76  *  target platform was a Galileo EVB64120A MIPS evaluation
77  *  board.
78  *
79  *  Step 1:
80  *  First download gdb-5.0.tar.gz from the internet.
81  *  and then build/install the package.
82  *
83  *  Example:
84  *    $ tar zxf gdb-5.0.tar.gz
85  *    $ cd gdb-5.0
86  *    $ ./configure --target=mips-linux-elf
87  *    $ make
88  *    $ install
89  *    $ which mips-linux-elf-gdb
90  *    /usr/local/bin/mips-linux-elf-gdb
91  *
92  *  Step 2:
93  *  Configure linux for remote debugging and build it.
94  *
95  *  Example:
96  *    $ cd ~/linux
97  *    $ make menuconfig <go to "Kernel Hacking" and turn on remote debugging>
98  *    $ make
99  *
100  *  Step 3:
101  *  Download the kernel to the remote target and start
102  *  the kernel running. It will promptly halt and wait
103  *  for the host gdb session to connect. It does this
104  *  since the "Kernel Hacking" option has defined
105  *  CONFIG_KGDB which in turn enables your calls
106  *  to:
107  *     set_debug_traps();
108  *     breakpoint();
109  *
110  *  Step 4:
111  *  Start the gdb session on the host.
112  *
113  *  Example:
114  *    $ mips-linux-elf-gdb vmlinux
115  *    (gdb) set remotebaud 115200
116  *    (gdb) target remote /dev/ttyS1
117  *    ...at this point you are connected to
118  *       the remote target and can use gdb
119  *       in the normal fasion. Setting
120  *       breakpoints, single stepping,
121  *       printing variables, etc.
122  */
123 #include <linux/config.h>
124 #include <linux/string.h>
125 #include <linux/kernel.h>
126 #include <linux/signal.h>
127 #include <linux/sched.h>
128 #include <linux/mm.h>
129 #include <linux/console.h>
130 #include <linux/init.h>
131 #include <linux/smp.h>
132 #include <linux/spinlock.h>
133 #include <linux/slab.h>
134 #include <linux/reboot.h>
135
136 #include <asm/asm.h>
137 #include <asm/cacheflush.h>
138 #include <asm/mipsregs.h>
139 #include <asm/pgtable.h>
140 #include <asm/system.h>
141 #include <asm/gdb-stub.h>
142 #include <asm/inst.h>
143
144 /*
145  * external low-level support routines
146  */
147
148 extern int putDebugChar(char c);    /* write a single character      */
149 extern char getDebugChar(void);     /* read and return a single char */
150 extern void trap_low(void);
151
152 /*
153  * breakpoint and test functions
154  */
155 extern void breakpoint(void);
156 extern void breakinst(void);
157 extern void async_breakpoint(void);
158 extern void async_breakinst(void);
159 extern void adel(void);
160
161 /*
162  * local prototypes
163  */
164
165 static void getpacket(char *buffer);
166 static void putpacket(char *buffer);
167 static int computeSignal(int tt);
168 static int hex(unsigned char ch);
169 static int hexToInt(char **ptr, int *intValue);
170 static int hexToLong(char **ptr, long *longValue);
171 static unsigned char *mem2hex(char *mem, char *buf, int count, int may_fault);
172 void handle_exception(struct gdb_regs *regs);
173
174 int kgdb_enabled;
175
176 /*
177  * spin locks for smp case
178  */
179 static spinlock_t kgdb_lock = SPIN_LOCK_UNLOCKED;
180 static spinlock_t kgdb_cpulock[NR_CPUS] = { [0 ... NR_CPUS-1] = SPIN_LOCK_UNLOCKED};
181
182 /*
183  * BUFMAX defines the maximum number of characters in inbound/outbound buffers
184  * at least NUMREGBYTES*2 are needed for register packets
185  */
186 #define BUFMAX 2048
187
188 static char input_buffer[BUFMAX];
189 static char output_buffer[BUFMAX];
190 static int initialized; /* !0 means we've been initialized */
191 static int kgdb_started;
192 static const char hexchars[]="0123456789abcdef";
193
194 /* Used to prevent crashes in memory access.  Note that they'll crash anyway if
195    we haven't set up fault handlers yet... */
196 int kgdb_read_byte(unsigned char *address, unsigned char *dest);
197 int kgdb_write_byte(unsigned char val, unsigned char *dest);
198
199 /*
200  * Convert ch from a hex digit to an int
201  */
202 static int hex(unsigned char ch)
203 {
204         if (ch >= 'a' && ch <= 'f')
205                 return ch-'a'+10;
206         if (ch >= '0' && ch <= '9')
207                 return ch-'0';
208         if (ch >= 'A' && ch <= 'F')
209                 return ch-'A'+10;
210         return -1;
211 }
212
213 /*
214  * scan for the sequence $<data>#<checksum>
215  */
216 static void getpacket(char *buffer)
217 {
218         unsigned char checksum;
219         unsigned char xmitcsum;
220         int i;
221         int count;
222         unsigned char ch;
223
224         do {
225                 /*
226                  * wait around for the start character,
227                  * ignore all other characters
228                  */
229                 while ((ch = (getDebugChar() & 0x7f)) != '$') ;
230
231                 checksum = 0;
232                 xmitcsum = -1;
233                 count = 0;
234
235                 /*
236                  * now, read until a # or end of buffer is found
237                  */
238                 while (count < BUFMAX) {
239                         ch = getDebugChar();
240                         if (ch == '#')
241                                 break;
242                         checksum = checksum + ch;
243                         buffer[count] = ch;
244                         count = count + 1;
245                 }
246
247                 if (count >= BUFMAX)
248                         continue;
249
250                 buffer[count] = 0;
251
252                 if (ch == '#') {
253                         xmitcsum = hex(getDebugChar() & 0x7f) << 4;
254                         xmitcsum |= hex(getDebugChar() & 0x7f);
255
256                         if (checksum != xmitcsum)
257                                 putDebugChar('-');      /* failed checksum */
258                         else {
259                                 putDebugChar('+'); /* successful transfer */
260
261                                 /*
262                                  * if a sequence char is present,
263                                  * reply the sequence ID
264                                  */
265                                 if (buffer[2] == ':') {
266                                         putDebugChar(buffer[0]);
267                                         putDebugChar(buffer[1]);
268
269                                         /*
270                                          * remove sequence chars from buffer
271                                          */
272                                         count = strlen(buffer);
273                                         for (i=3; i <= count; i++)
274                                                 buffer[i-3] = buffer[i];
275                                 }
276                         }
277                 }
278         }
279         while (checksum != xmitcsum);
280 }
281
282 /*
283  * send the packet in buffer.
284  */
285 static void putpacket(char *buffer)
286 {
287         unsigned char checksum;
288         int count;
289         unsigned char ch;
290
291         /*
292          * $<packet info>#<checksum>.
293          */
294
295         do {
296                 putDebugChar('$');
297                 checksum = 0;
298                 count = 0;
299
300                 while ((ch = buffer[count]) != 0) {
301                         if (!(putDebugChar(ch)))
302                                 return;
303                         checksum += ch;
304                         count += 1;
305                 }
306
307                 putDebugChar('#');
308                 putDebugChar(hexchars[checksum >> 4]);
309                 putDebugChar(hexchars[checksum & 0xf]);
310
311         }
312         while ((getDebugChar() & 0x7f) != '+');
313 }
314
315
316 /*
317  * Convert the memory pointed to by mem into hex, placing result in buf.
318  * Return a pointer to the last char put in buf (null), in case of mem fault,
319  * return 0.
320  * may_fault is non-zero if we are reading from arbitrary memory, but is currently
321  * not used.
322  */
323 static unsigned char *mem2hex(char *mem, char *buf, int count, int may_fault)
324 {
325         unsigned char ch;
326
327         while (count-- > 0) {
328                 if (kgdb_read_byte(mem++, &ch) != 0)
329                         return 0;
330                 *buf++ = hexchars[ch >> 4];
331                 *buf++ = hexchars[ch & 0xf];
332         }
333
334         *buf = 0;
335
336         return buf;
337 }
338
339 /*
340  * convert the hex array pointed to by buf into binary to be placed in mem
341  * return a pointer to the character AFTER the last byte written
342  * may_fault is non-zero if we are reading from arbitrary memory, but is currently
343  * not used.
344  */
345 static char *hex2mem(char *buf, char *mem, int count, int binary, int may_fault)
346 {
347         int i;
348         unsigned char ch;
349
350         for (i=0; i<count; i++)
351         {
352                 if (binary) {
353                         ch = *buf++;
354                         if (ch == 0x7d)
355                                 ch = 0x20 ^ *buf++;
356                 }
357                 else {
358                         ch = hex(*buf++) << 4;
359                         ch |= hex(*buf++);
360                 }
361                 if (kgdb_write_byte(ch, mem++) != 0)
362                         return 0;
363         }
364
365         return mem;
366 }
367
368 /*
369  * This table contains the mapping between SPARC hardware trap types, and
370  * signals, which are primarily what GDB understands.  It also indicates
371  * which hardware traps we need to commandeer when initializing the stub.
372  */
373 static struct hard_trap_info {
374         unsigned char tt;               /* Trap type code for MIPS R3xxx and R4xxx */
375         unsigned char signo;            /* Signal that we map this trap into */
376 } hard_trap_info[] = {
377         { 6, SIGBUS },                  /* instruction bus error */
378         { 7, SIGBUS },                  /* data bus error */
379         { 9, SIGTRAP },                 /* break */
380         { 10, SIGILL },                 /* reserved instruction */
381 /*      { 11, SIGILL },         */      /* CPU unusable */
382         { 12, SIGFPE },                 /* overflow */
383         { 13, SIGTRAP },                /* trap */
384         { 14, SIGSEGV },                /* virtual instruction cache coherency */
385         { 15, SIGFPE },                 /* floating point exception */
386         { 23, SIGSEGV },                /* watch */
387         { 31, SIGSEGV },                /* virtual data cache coherency */
388         { 0, 0}                         /* Must be last */
389 };
390
391 /* Save the normal trap handlers for user-mode traps. */
392 void *saved_vectors[32];
393
394 /*
395  * Set up exception handlers for tracing and breakpoints
396  */
397 void set_debug_traps(void)
398 {
399         struct hard_trap_info *ht;
400         unsigned long flags;
401         unsigned char c;
402
403         local_irq_save(flags);
404         for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
405                 saved_vectors[ht->tt] = set_except_vector(ht->tt, trap_low);
406
407         putDebugChar('+'); /* 'hello world' */
408         /*
409          * In case GDB is started before us, ack any packets
410          * (presumably "$?#xx") sitting there.
411          */
412         while((c = getDebugChar()) != '$');
413         while((c = getDebugChar()) != '#');
414         c = getDebugChar(); /* eat first csum byte */
415         c = getDebugChar(); /* eat second csum byte */
416         putDebugChar('+'); /* ack it */
417
418         initialized = 1;
419         local_irq_restore(flags);
420 }
421
422 void restore_debug_traps(void)
423 {
424         struct hard_trap_info *ht;
425         unsigned long flags;
426
427         local_irq_save(flags);
428         for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
429                 set_except_vector(ht->tt, saved_vectors[ht->tt]);
430         local_irq_restore(flags);
431 }
432
433 /*
434  * Convert the MIPS hardware trap type code to a Unix signal number.
435  */
436 static int computeSignal(int tt)
437 {
438         struct hard_trap_info *ht;
439
440         for (ht = hard_trap_info; ht->tt && ht->signo; ht++)
441                 if (ht->tt == tt)
442                         return ht->signo;
443
444         return SIGHUP;          /* default for things we don't know about */
445 }
446
447 /*
448  * While we find nice hex chars, build an int.
449  * Return number of chars processed.
450  */
451 static int hexToInt(char **ptr, int *intValue)
452 {
453         int numChars = 0;
454         int hexValue;
455
456         *intValue = 0;
457
458         while (**ptr) {
459                 hexValue = hex(**ptr);
460                 if (hexValue < 0)
461                         break;
462
463                 *intValue = (*intValue << 4) | hexValue;
464                 numChars ++;
465
466                 (*ptr)++;
467         }
468
469         return (numChars);
470 }
471
472 static int hexToLong(char **ptr, long *longValue)
473 {
474         int numChars = 0;
475         int hexValue;
476
477         *longValue = 0;
478
479         while (**ptr) {
480                 hexValue = hex(**ptr);
481                 if (hexValue < 0)
482                         break;
483
484                 *longValue = (*longValue << 4) | hexValue;
485                 numChars ++;
486
487                 (*ptr)++;
488         }
489
490         return numChars;
491 }
492
493
494 #if 0
495 /*
496  * Print registers (on target console)
497  * Used only to debug the stub...
498  */
499 void show_gdbregs(struct gdb_regs * regs)
500 {
501         /*
502          * Saved main processor registers
503          */
504         printk("$0 : %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
505                regs->reg0, regs->reg1, regs->reg2, regs->reg3,
506                regs->reg4, regs->reg5, regs->reg6, regs->reg7);
507         printk("$8 : %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
508                regs->reg8, regs->reg9, regs->reg10, regs->reg11,
509                regs->reg12, regs->reg13, regs->reg14, regs->reg15);
510         printk("$16: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
511                regs->reg16, regs->reg17, regs->reg18, regs->reg19,
512                regs->reg20, regs->reg21, regs->reg22, regs->reg23);
513         printk("$24: %08lx %08lx %08lx %08lx %08lx %08lx %08lx %08lx\n",
514                regs->reg24, regs->reg25, regs->reg26, regs->reg27,
515                regs->reg28, regs->reg29, regs->reg30, regs->reg31);
516
517         /*
518          * Saved cp0 registers
519          */
520         printk("epc  : %08lx\nStatus: %08lx\nCause : %08lx\n",
521                regs->cp0_epc, regs->cp0_status, regs->cp0_cause);
522 }
523 #endif /* dead code */
524
525 /*
526  * We single-step by setting breakpoints. When an exception
527  * is handled, we need to restore the instructions hoisted
528  * when the breakpoints were set.
529  *
530  * This is where we save the original instructions.
531  */
532 static struct gdb_bp_save {
533         unsigned long addr;
534         unsigned int val;
535 } step_bp[2];
536
537 #define BP 0x0000000d  /* break opcode */
538
539 /*
540  * Set breakpoint instructions for single stepping.
541  */
542 static void single_step(struct gdb_regs *regs)
543 {
544         union mips_instruction insn;
545         unsigned long targ;
546         int is_branch, is_cond, i;
547
548         targ = regs->cp0_epc;
549         insn.word = *(unsigned int *)targ;
550         is_branch = is_cond = 0;
551
552         switch (insn.i_format.opcode) {
553         /*
554          * jr and jalr are in r_format format.
555          */
556         case spec_op:
557                 switch (insn.r_format.func) {
558                 case jalr_op:
559                 case jr_op:
560                         targ = *(&regs->reg0 + insn.r_format.rs);
561                         is_branch = 1;
562                         break;
563                 }
564                 break;
565
566         /*
567          * This group contains:
568          * bltz_op, bgez_op, bltzl_op, bgezl_op,
569          * bltzal_op, bgezal_op, bltzall_op, bgezall_op.
570          */
571         case bcond_op:
572                 is_branch = is_cond = 1;
573                 targ += 4 + (insn.i_format.simmediate << 2);
574                 break;
575
576         /*
577          * These are unconditional and in j_format.
578          */
579         case jal_op:
580         case j_op:
581                 is_branch = 1;
582                 targ += 4;
583                 targ >>= 28;
584                 targ <<= 28;
585                 targ |= (insn.j_format.target << 2);
586                 break;
587
588         /*
589          * These are conditional.
590          */
591         case beq_op:
592         case beql_op:
593         case bne_op:
594         case bnel_op:
595         case blez_op:
596         case blezl_op:
597         case bgtz_op:
598         case bgtzl_op:
599         case cop0_op:
600         case cop1_op:
601         case cop2_op:
602         case cop1x_op:
603                 is_branch = is_cond = 1;
604                 targ += 4 + (insn.i_format.simmediate << 2);
605                 break;
606         }
607
608         if (is_branch) {
609                 i = 0;
610                 if (is_cond && targ != (regs->cp0_epc + 8)) {
611                         step_bp[i].addr = regs->cp0_epc + 8;
612                         step_bp[i++].val = *(unsigned *)(regs->cp0_epc + 8);
613                         *(unsigned *)(regs->cp0_epc + 8) = BP;
614                 }
615                 step_bp[i].addr = targ;
616                 step_bp[i].val  = *(unsigned *)targ;
617                 *(unsigned *)targ = BP;
618         } else {
619                 step_bp[0].addr = regs->cp0_epc + 4;
620                 step_bp[0].val  = *(unsigned *)(regs->cp0_epc + 4);
621                 *(unsigned *)(regs->cp0_epc + 4) = BP;
622         }
623 }
624
625 /*
626  *  If asynchronously interrupted by gdb, then we need to set a breakpoint
627  *  at the interrupted instruction so that we wind up stopped with a
628  *  reasonable stack frame.
629  */
630 static struct gdb_bp_save async_bp;
631
632 /*
633  * Swap the interrupted EPC with our asynchronous breakpoint routine.
634  * This is safer than stuffing the breakpoint in-place, since no cache
635  * flushes (or resulting smp_call_functions) are required.  The
636  * assumption is that only one CPU will be handling asynchronous bp's,
637  * and only one can be active at a time.
638  */
639 extern spinlock_t smp_call_lock;
640
641 void set_async_breakpoint(unsigned long *epc)
642 {
643         /* skip breaking into userland */
644         if ((*epc & 0x80000000) == 0)
645                 return;
646
647 #ifdef CONFIG_SMP
648         /* avoid deadlock if someone is make IPC */
649         if (spin_is_locked(&smp_call_lock))
650                 return;
651 #endif
652
653         async_bp.addr = *epc;
654         *epc = (unsigned long)async_breakpoint;
655 }
656
657 void kgdb_wait(void *arg)
658 {
659         unsigned flags;
660         int cpu = smp_processor_id();
661
662         local_irq_save(flags);
663
664         spin_lock(&kgdb_cpulock[cpu]);
665         spin_unlock(&kgdb_cpulock[cpu]);
666
667         local_irq_restore(flags);
668 }
669
670
671 /*
672  * This function does all command processing for interfacing to gdb.  It
673  * returns 1 if you should skip the instruction at the trap address, 0
674  * otherwise.
675  */
676 void handle_exception (struct gdb_regs *regs)
677 {
678         int trap;                       /* Trap type */
679         int sigval;
680         long addr;
681         int length;
682         char *ptr;
683         unsigned long *stack;
684         int i;
685         int bflag = 0;
686
687         kgdb_started = 1;
688
689         /*
690          * acquire the big kgdb spinlock
691          */
692         if (!spin_trylock(&kgdb_lock)) {
693                 /*
694                  * some other CPU has the lock, we should go back to
695                  * receive the gdb_wait IPC
696                  */
697                 return;
698         }
699
700         /*
701          * If we're in async_breakpoint(), restore the real EPC from
702          * the breakpoint.
703          */
704         if (regs->cp0_epc == (unsigned long)async_breakinst) {
705                 regs->cp0_epc = async_bp.addr;
706                 async_bp.addr = 0;
707         }
708
709         /*
710          * acquire the CPU spinlocks
711          */
712         for (i = num_online_cpus()-1; i >= 0; i--)
713                 if (spin_trylock(&kgdb_cpulock[i]) == 0)
714                         panic("kgdb: couldn't get cpulock %d\n", i);
715
716         /*
717          * force other cpus to enter kgdb
718          */
719         smp_call_function(kgdb_wait, NULL, 0, 0);
720
721         /*
722          * If we're in breakpoint() increment the PC
723          */
724         trap = (regs->cp0_cause & 0x7c) >> 2;
725         if (trap == 9 && regs->cp0_epc == (unsigned long)breakinst)
726                 regs->cp0_epc += 4;
727
728         /*
729          * If we were single_stepping, restore the opcodes hoisted
730          * for the breakpoint[s].
731          */
732         if (step_bp[0].addr) {
733                 *(unsigned *)step_bp[0].addr = step_bp[0].val;
734                 step_bp[0].addr = 0;
735
736                 if (step_bp[1].addr) {
737                         *(unsigned *)step_bp[1].addr = step_bp[1].val;
738                         step_bp[1].addr = 0;
739                 }
740         }
741
742         stack = (long *)regs->reg29;                    /* stack ptr */
743         sigval = computeSignal(trap);
744
745         /*
746          * reply to host that an exception has occurred
747          */
748         ptr = output_buffer;
749
750         /*
751          * Send trap type (converted to signal)
752          */
753         *ptr++ = 'T';
754         *ptr++ = hexchars[sigval >> 4];
755         *ptr++ = hexchars[sigval & 0xf];
756
757         /*
758          * Send Error PC
759          */
760         *ptr++ = hexchars[REG_EPC >> 4];
761         *ptr++ = hexchars[REG_EPC & 0xf];
762         *ptr++ = ':';
763         ptr = mem2hex((char *)&regs->cp0_epc, ptr, sizeof(long), 0);
764         *ptr++ = ';';
765
766         /*
767          * Send frame pointer
768          */
769         *ptr++ = hexchars[REG_FP >> 4];
770         *ptr++ = hexchars[REG_FP & 0xf];
771         *ptr++ = ':';
772         ptr = mem2hex((char *)&regs->reg30, ptr, sizeof(long), 0);
773         *ptr++ = ';';
774
775         /*
776          * Send stack pointer
777          */
778         *ptr++ = hexchars[REG_SP >> 4];
779         *ptr++ = hexchars[REG_SP & 0xf];
780         *ptr++ = ':';
781         ptr = mem2hex((char *)&regs->reg29, ptr, sizeof(long), 0);
782         *ptr++ = ';';
783
784         *ptr++ = 0;
785         putpacket(output_buffer);       /* send it off... */
786
787         /*
788          * Wait for input from remote GDB
789          */
790         while (1) {
791                 output_buffer[0] = 0;
792                 getpacket(input_buffer);
793
794                 switch (input_buffer[0])
795                 {
796                 case '?':
797                         output_buffer[0] = 'S';
798                         output_buffer[1] = hexchars[sigval >> 4];
799                         output_buffer[2] = hexchars[sigval & 0xf];
800                         output_buffer[3] = 0;
801                         break;
802
803                 /*
804                  * Detach debugger; let CPU run
805                  */
806                 case 'D':
807                         putpacket(output_buffer);
808                         goto finish_kgdb;
809                         break;
810
811                 case 'd':
812                         /* toggle debug flag */
813                         break;
814
815                 /*
816                  * Return the value of the CPU registers
817                  */
818                 case 'g':
819                         ptr = output_buffer;
820                         ptr = mem2hex((char *)&regs->reg0, ptr, 32*sizeof(long), 0); /* r0...r31 */
821                         ptr = mem2hex((char *)&regs->cp0_status, ptr, 6*sizeof(long), 0); /* cp0 */
822                         ptr = mem2hex((char *)&regs->fpr0, ptr, 32*sizeof(long), 0); /* f0...31 */
823                         ptr = mem2hex((char *)&regs->cp1_fsr, ptr, 2*sizeof(long), 0); /* cp1 */
824                         ptr = mem2hex((char *)&regs->frame_ptr, ptr, 2*sizeof(long), 0); /* frp */
825                         ptr = mem2hex((char *)&regs->cp0_index, ptr, 16*sizeof(long), 0); /* cp0 */
826                         break;
827
828                 /*
829                  * set the value of the CPU registers - return OK
830                  */
831                 case 'G':
832                 {
833                         ptr = &input_buffer[1];
834                         hex2mem(ptr, (char *)&regs->reg0, 32*sizeof(long), 0, 0);
835                         ptr += 32*(2*sizeof(long));
836                         hex2mem(ptr, (char *)&regs->cp0_status, 6*sizeof(long), 0, 0);
837                         ptr += 6*(2*sizeof(long));
838                         hex2mem(ptr, (char *)&regs->fpr0, 32*sizeof(long), 0, 0);
839                         ptr += 32*(2*sizeof(long));
840                         hex2mem(ptr, (char *)&regs->cp1_fsr, 2*sizeof(long), 0, 0);
841                         ptr += 2*(2*sizeof(long));
842                         hex2mem(ptr, (char *)&regs->frame_ptr, 2*sizeof(long), 0, 0);
843                         ptr += 2*(2*sizeof(long));
844                         hex2mem(ptr, (char *)&regs->cp0_index, 16*sizeof(long), 0, 0);
845                         strcpy(output_buffer,"OK");
846                  }
847                 break;
848
849                 /*
850                  * mAA..AA,LLLL  Read LLLL bytes at address AA..AA
851                  */
852                 case 'm':
853                         ptr = &input_buffer[1];
854
855                         if (hexToLong(&ptr, &addr)
856                                 && *ptr++ == ','
857                                 && hexToInt(&ptr, &length)) {
858                                 if (mem2hex((char *)addr, output_buffer, length, 1))
859                                         break;
860                                 strcpy (output_buffer, "E03");
861                         } else
862                                 strcpy(output_buffer,"E01");
863                         break;
864
865                 /*
866                  * XAA..AA,LLLL: Write LLLL escaped binary bytes at address AA.AA
867                  */
868                 case 'X':
869                         bflag = 1;
870                         /* fall through */
871
872                 /*
873                  * MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK
874                  */
875                 case 'M':
876                         ptr = &input_buffer[1];
877
878                         if (hexToLong(&ptr, &addr)
879                                 && *ptr++ == ','
880                                 && hexToInt(&ptr, &length)
881                                 && *ptr++ == ':') {
882                                 if (hex2mem(ptr, (char *)addr, length, bflag, 1))
883                                         strcpy(output_buffer, "OK");
884                                 else
885                                         strcpy(output_buffer, "E03");
886                         }
887                         else
888                                 strcpy(output_buffer, "E02");
889                         break;
890
891                 /*
892                  * cAA..AA    Continue at address AA..AA(optional)
893                  */
894                 case 'c':
895                         /* try to read optional parameter, pc unchanged if no parm */
896
897                         ptr = &input_buffer[1];
898                         if (hexToLong(&ptr, &addr))
899                                 regs->cp0_epc = addr;
900
901                         goto exit_kgdb_exception;
902                         break;
903
904                 /*
905                  * kill the program; let us try to restart the machine
906                  * Reset the whole machine.
907                  */
908                 case 'k':
909                 case 'r':
910                         machine_restart("kgdb restarts machine");
911                         break;
912
913                 /*
914                  * Step to next instruction
915                  */
916                 case 's':
917                         /*
918                          * There is no single step insn in the MIPS ISA, so we
919                          * use breakpoints and continue, instead.
920                          */
921                         single_step(regs);
922                         goto exit_kgdb_exception;
923                         /* NOTREACHED */
924                         break;
925
926                 /*
927                  * Set baud rate (bBB)
928                  * FIXME: Needs to be written
929                  */
930                 case 'b':
931                 {
932 #if 0
933                         int baudrate;
934                         extern void set_timer_3();
935
936                         ptr = &input_buffer[1];
937                         if (!hexToInt(&ptr, &baudrate))
938                         {
939                                 strcpy(output_buffer,"B01");
940                                 break;
941                         }
942
943                         /* Convert baud rate to uart clock divider */
944
945                         switch (baudrate)
946                         {
947                                 case 38400:
948                                         baudrate = 16;
949                                         break;
950                                 case 19200:
951                                         baudrate = 33;
952                                         break;
953                                 case 9600:
954                                         baudrate = 65;
955                                         break;
956                                 default:
957                                         baudrate = 0;
958                                         strcpy(output_buffer,"B02");
959                                         goto x1;
960                         }
961
962                         if (baudrate) {
963                                 putpacket("OK");        /* Ack before changing speed */
964                                 set_timer_3(baudrate); /* Set it */
965                         }
966 #endif
967                 }
968                 break;
969
970                 }                       /* switch */
971
972                 /*
973                  * reply to the request
974                  */
975
976                 putpacket(output_buffer);
977
978         } /* while */
979
980         return;
981
982 finish_kgdb:
983         restore_debug_traps();
984
985 exit_kgdb_exception:
986         /* release locks so other CPUs can go */
987         for (i = num_online_cpus()-1; i >= 0; i--)
988                 spin_unlock(&kgdb_cpulock[i]);
989         spin_unlock(&kgdb_lock);
990
991         __flush_cache_all();
992         return;
993 }
994
995 /*
996  * This function will generate a breakpoint exception.  It is used at the
997  * beginning of a program to sync up with a debugger and can be used
998  * otherwise as a quick means to stop program execution and "break" into
999  * the debugger.
1000  */
1001 void breakpoint(void)
1002 {
1003         if (!initialized)
1004                 return;
1005
1006         __asm__ __volatile__(
1007                         ".globl breakinst\n\t"
1008                         ".set\tnoreorder\n\t"
1009                         "nop\n"
1010                         "breakinst:\tbreak\n\t"
1011                         "nop\n\t"
1012                         ".set\treorder"
1013                         );
1014 }
1015
1016 /* Nothing but the break; don't pollute any registers */
1017 void async_breakpoint(void)
1018 {
1019         __asm__ __volatile__(
1020                         ".globl async_breakinst\n\t"
1021                         ".set\tnoreorder\n\t"
1022                         "nop\n"
1023                         "async_breakinst:\tbreak\n\t"
1024                         "nop\n\t"
1025                         ".set\treorder"
1026                         );
1027 }
1028
1029 void adel(void)
1030 {
1031         __asm__ __volatile__(
1032                         ".globl\tadel\n\t"
1033                         "lui\t$8,0x8000\n\t"
1034                         "lw\t$9,1($8)\n\t"
1035                         );
1036 }
1037
1038 /*
1039  * malloc is needed by gdb client in "call func()", even a private one
1040  * will make gdb happy
1041  */
1042 static void * __attribute_used__ malloc(size_t size)
1043 {
1044         return kmalloc(size, GFP_ATOMIC);
1045 }
1046
1047 static void __attribute_used__ free (void *where)
1048 {
1049         kfree(where);
1050 }
1051
1052 #ifdef CONFIG_GDB_CONSOLE
1053
1054 void gdb_putsn(const char *str, int l)
1055 {
1056         char outbuf[18];
1057
1058         if (!kgdb_started)
1059                 return;
1060
1061         outbuf[0]='O';
1062
1063         while(l) {
1064                 int i = (l>8)?8:l;
1065                 mem2hex((char *)str, &outbuf[1], i, 0);
1066                 outbuf[(i*2)+1]=0;
1067                 putpacket(outbuf);
1068                 str += i;
1069                 l -= i;
1070         }
1071 }
1072
1073 static void gdb_console_write(struct console *con, const char *s, unsigned n)
1074 {
1075         gdb_putsn(s, n);
1076 }
1077
1078 static struct console gdb_console = {
1079         .name   = "gdb",
1080         .write  = gdb_console_write,
1081         .flags  = CON_PRINTBUFFER,
1082         .index  = -1
1083 };
1084
1085 static int __init register_gdb_console(void)
1086 {
1087         register_console(&gdb_console);
1088
1089         return 0;
1090 }
1091
1092 console_initcall(register_gdb_console);
1093
1094 #endif