Merge branch 'for-2.6.25' of master.kernel.org:/pub/scm/linux/kernel/git/arnd/cell...
[linux-2.6] / arch / sh / kernel / kgdb_stub.c
1 /*
2  * May be copied or modified under the terms of the GNU General Public
3  * License.  See linux/COPYING for more information.
4  *
5  * Contains extracts from code by Glenn Engel, Jim Kingdon,
6  * David Grothe <dave@gcom.com>, Tigran Aivazian <tigran@sco.com>,
7  * Amit S. Kale <akale@veritas.com>,  William Gatliff <bgat@open-widgets.com>,
8  * Ben Lee, Steve Chamberlain and Benoit Miller <fulg@iname.com>.
9  *
10  * This version by Henry Bell <henry.bell@st.com>
11  * Minor modifications by Jeremy Siegel <jsiegel@mvista.com>
12  *
13  * Contains low-level support for remote debug using GDB.
14  *
15  * To enable debugger support, two things need to happen. A call to
16  * set_debug_traps() is necessary in order to allow any breakpoints
17  * or error conditions to be properly intercepted and reported to gdb.
18  * A breakpoint also needs to be generated to begin communication.  This
19  * is most easily accomplished by a call to breakpoint() which does
20  * a trapa if the initialisation phase has been successfully completed.
21  *
22  * In this case, set_debug_traps() is not used to "take over" exceptions;
23  * other kernel code is modified instead to enter the kgdb functions here
24  * when appropriate (see entry.S for breakpoint traps and NMI interrupts,
25  * see traps.c for kernel error exceptions).
26  *
27  * The following gdb commands are supported:
28  *
29  *    Command       Function                               Return value
30  *
31  *    g             return the value of the CPU registers  hex data or ENN
32  *    G             set the value of the CPU registers     OK or ENN
33  *
34  *    mAA..AA,LLLL  Read LLLL bytes at address AA..AA      hex data or ENN
35  *    MAA..AA,LLLL: Write LLLL bytes at address AA.AA      OK or ENN
36  *    XAA..AA,LLLL: Same, but data is binary (not hex)     OK or ENN
37  *
38  *    c             Resume at current address              SNN   ( signal NN)
39  *    cAA..AA       Continue at address AA..AA             SNN
40  *    CNN;          Resume at current address with signal  SNN
41  *    CNN;AA..AA    Resume at address AA..AA with signal   SNN
42  *
43  *    s             Step one instruction                   SNN
44  *    sAA..AA       Step one instruction from AA..AA       SNN
45  *    SNN;          Step one instruction with signal       SNN
46  *    SNNAA..AA     Step one instruction from AA..AA w/NN  SNN
47  *
48  *    k             kill (Detach GDB)
49  *
50  *    d             Toggle debug flag
51  *    D             Detach GDB
52  *
53  *    Hct           Set thread t for operations,           OK or ENN
54  *                  c = 'c' (step, cont), c = 'g' (other
55  *                  operations)
56  *
57  *    qC            Query current thread ID                QCpid
58  *    qfThreadInfo  Get list of current threads (first)    m<id>
59  *    qsThreadInfo   "    "  "     "      "   (subsequent)
60  *    qOffsets      Get section offsets                  Text=x;Data=y;Bss=z
61  *
62  *    TXX           Find if thread XX is alive             OK or ENN
63  *    ?             What was the last sigval ?             SNN   (signal NN)
64  *    O             Output to GDB console
65  *
66  * Remote communication protocol.
67  *
68  *    A debug packet whose contents are <data> is encapsulated for
69  *    transmission in the form:
70  *
71  *       $ <data> # CSUM1 CSUM2
72  *
73  *       <data> must be ASCII alphanumeric and cannot include characters
74  *       '$' or '#'.  If <data> starts with two characters followed by
75  *       ':', then the existing stubs interpret this as a sequence number.
76  *
77  *       CSUM1 and CSUM2 are ascii hex representation of an 8-bit
78  *       checksum of <data>, the most significant nibble is sent first.
79  *       the hex digits 0-9,a-f are used.
80  *
81  *    Receiver responds with:
82  *
83  *       +       - if CSUM is correct and ready for next packet
84  *       -       - if CSUM is incorrect
85  *
86  * Responses can be run-length encoded to save space.  A '*' means that
87  * the next character is an ASCII encoding giving a repeat count which
88  * stands for that many repetitions of the character preceding the '*'.
89  * The encoding is n+29, yielding a printable character where n >=3
90  * (which is where RLE starts to win).  Don't use an n > 126.
91  *
92  * So "0* " means the same as "0000".
93  */
94
95 #include <linux/string.h>
96 #include <linux/kernel.h>
97 #include <linux/sched.h>
98 #include <linux/smp.h>
99 #include <linux/spinlock.h>
100 #include <linux/delay.h>
101 #include <linux/linkage.h>
102 #include <linux/init.h>
103 #include <linux/console.h>
104 #include <linux/sysrq.h>
105 #include <linux/module.h>
106 #include <asm/system.h>
107 #include <asm/cacheflush.h>
108 #include <asm/current.h>
109 #include <asm/signal.h>
110 #include <asm/pgtable.h>
111 #include <asm/ptrace.h>
112 #include <asm/kgdb.h>
113 #include <asm/io.h>
114
115 /* Function pointers for linkage */
116 kgdb_debug_hook_t *kgdb_debug_hook;
117 kgdb_bus_error_hook_t *kgdb_bus_err_hook;
118
119 int (*kgdb_getchar)(void);
120 EXPORT_SYMBOL_GPL(kgdb_getchar);
121 void (*kgdb_putchar)(int);
122 EXPORT_SYMBOL_GPL(kgdb_putchar);
123
124 static void put_debug_char(int c)
125 {
126         if (!kgdb_putchar)
127                 return;
128         (*kgdb_putchar)(c);
129 }
130 static int get_debug_char(void)
131 {
132         if (!kgdb_getchar)
133                 return -1;
134         return (*kgdb_getchar)();
135 }
136
137 /* Num chars in in/out bound buffers, register packets need NUMREGBYTES * 2 */
138 #define BUFMAX 1024
139 #define NUMREGBYTES (MAXREG*4)
140 #define OUTBUFMAX (NUMREGBYTES*2+512)
141
142 enum {
143         R0 = 0, R1,  R2,  R3,   R4,   R5,  R6, R7,
144         R8, R9, R10, R11, R12,  R13,  R14, R15,
145         PC, PR, GBR, VBR, MACH, MACL, SR,
146         /*  */
147         MAXREG
148 };
149
150 static unsigned int registers[MAXREG];
151 struct kgdb_regs trap_registers;
152
153 char kgdb_in_gdb_mode;
154 char in_nmi;                    /* Set during NMI to prevent reentry */
155 int kgdb_nofault;               /* Boolean to ignore bus errs (i.e. in GDB) */
156
157 /* Default values for SCI (can override via kernel args in setup.c) */
158 #ifndef CONFIG_KGDB_DEFPORT
159 #define CONFIG_KGDB_DEFPORT 1
160 #endif
161
162 #ifndef CONFIG_KGDB_DEFBAUD
163 #define CONFIG_KGDB_DEFBAUD 115200
164 #endif
165
166 #if defined(CONFIG_KGDB_DEFPARITY_E)
167 #define CONFIG_KGDB_DEFPARITY 'E'
168 #elif defined(CONFIG_KGDB_DEFPARITY_O)
169 #define CONFIG_KGDB_DEFPARITY 'O'
170 #else /* CONFIG_KGDB_DEFPARITY_N */
171 #define CONFIG_KGDB_DEFPARITY 'N'
172 #endif
173
174 #ifdef CONFIG_KGDB_DEFBITS_7
175 #define CONFIG_KGDB_DEFBITS '7'
176 #else /* CONFIG_KGDB_DEFBITS_8 */
177 #define CONFIG_KGDB_DEFBITS '8'
178 #endif
179
180 /* SCI/UART settings, used in kgdb_console_setup() */
181 int  kgdb_portnum = CONFIG_KGDB_DEFPORT;
182 EXPORT_SYMBOL_GPL(kgdb_portnum);
183 int  kgdb_baud = CONFIG_KGDB_DEFBAUD;
184 EXPORT_SYMBOL_GPL(kgdb_baud);
185 char kgdb_parity = CONFIG_KGDB_DEFPARITY;
186 EXPORT_SYMBOL_GPL(kgdb_parity);
187 char kgdb_bits = CONFIG_KGDB_DEFBITS;
188 EXPORT_SYMBOL_GPL(kgdb_bits);
189
190 /* Jump buffer for setjmp/longjmp */
191 static jmp_buf rem_com_env;
192
193 /* TRA differs sh3/4 */
194 #if defined(CONFIG_CPU_SH3)
195 #define TRA 0xffffffd0
196 #elif defined(CONFIG_CPU_SH4)
197 #define TRA 0xff000020
198 #endif
199
200 /* Macros for single step instruction identification */
201 #define OPCODE_BT(op)         (((op) & 0xff00) == 0x8900)
202 #define OPCODE_BF(op)         (((op) & 0xff00) == 0x8b00)
203 #define OPCODE_BTF_DISP(op)   (((op) & 0x80) ? (((op) | 0xffffff80) << 1) : \
204                               (((op) & 0x7f ) << 1))
205 #define OPCODE_BFS(op)        (((op) & 0xff00) == 0x8f00)
206 #define OPCODE_BTS(op)        (((op) & 0xff00) == 0x8d00)
207 #define OPCODE_BRA(op)        (((op) & 0xf000) == 0xa000)
208 #define OPCODE_BRA_DISP(op)   (((op) & 0x800) ? (((op) | 0xfffff800) << 1) : \
209                               (((op) & 0x7ff) << 1))
210 #define OPCODE_BRAF(op)       (((op) & 0xf0ff) == 0x0023)
211 #define OPCODE_BRAF_REG(op)   (((op) & 0x0f00) >> 8)
212 #define OPCODE_BSR(op)        (((op) & 0xf000) == 0xb000)
213 #define OPCODE_BSR_DISP(op)   (((op) & 0x800) ? (((op) | 0xfffff800) << 1) : \
214                               (((op) & 0x7ff) << 1))
215 #define OPCODE_BSRF(op)       (((op) & 0xf0ff) == 0x0003)
216 #define OPCODE_BSRF_REG(op)   (((op) >> 8) & 0xf)
217 #define OPCODE_JMP(op)        (((op) & 0xf0ff) == 0x402b)
218 #define OPCODE_JMP_REG(op)    (((op) >> 8) & 0xf)
219 #define OPCODE_JSR(op)        (((op) & 0xf0ff) == 0x400b)
220 #define OPCODE_JSR_REG(op)    (((op) >> 8) & 0xf)
221 #define OPCODE_RTS(op)        ((op) == 0xb)
222 #define OPCODE_RTE(op)        ((op) == 0x2b)
223
224 #define SR_T_BIT_MASK           0x1
225 #define STEP_OPCODE             0xc320
226 #define BIOS_CALL_TRAP          0x3f
227
228 /* Exception codes as per SH-4 core manual */
229 #define ADDRESS_ERROR_LOAD_VEC   7
230 #define ADDRESS_ERROR_STORE_VEC  8
231 #define TRAP_VEC                 11
232 #define INVALID_INSN_VEC         12
233 #define INVALID_SLOT_VEC         13
234 #define NMI_VEC                  14
235 #define USER_BREAK_VEC           15
236 #define SERIAL_BREAK_VEC         58
237
238 /* Misc static */
239 static int stepped_address;
240 static short stepped_opcode;
241 static char in_buffer[BUFMAX];
242 static char out_buffer[OUTBUFMAX];
243
244 static void kgdb_to_gdb(const char *s);
245
246 /* Convert ch to hex */
247 static int hex(const char ch)
248 {
249         if ((ch >= 'a') && (ch <= 'f'))
250                 return (ch - 'a' + 10);
251         if ((ch >= '0') && (ch <= '9'))
252                 return (ch - '0');
253         if ((ch >= 'A') && (ch <= 'F'))
254                 return (ch - 'A' + 10);
255         return (-1);
256 }
257
258 /* Convert the memory pointed to by mem into hex, placing result in buf.
259    Returns a pointer to the last char put in buf (null) */
260 static char *mem_to_hex(const char *mem, char *buf, const int count)
261 {
262         int i;
263         int ch;
264         unsigned short s_val;
265         unsigned long l_val;
266
267         /* Check for 16 or 32 */
268         if (count == 2 && ((long) mem & 1) == 0) {
269                 s_val = *(unsigned short *) mem;
270                 mem = (char *) &s_val;
271         } else if (count == 4 && ((long) mem & 3) == 0) {
272                 l_val = *(unsigned long *) mem;
273                 mem = (char *) &l_val;
274         }
275         for (i = 0; i < count; i++) {
276                 ch = *mem++;
277                 *buf++ = highhex(ch);
278                 *buf++ = lowhex(ch);
279         }
280         *buf = 0;
281         return (buf);
282 }
283
284 /* Convert the hex array pointed to by buf into binary, to be placed in mem.
285    Return a pointer to the character after the last byte written */
286 static char *hex_to_mem(const char *buf, char *mem, const int count)
287 {
288         int i;
289         unsigned char ch;
290
291         for (i = 0; i < count; i++) {
292                 ch = hex(*buf++) << 4;
293                 ch = ch + hex(*buf++);
294                 *mem++ = ch;
295         }
296         return (mem);
297 }
298
299 /* While finding valid hex chars, convert to an integer, then return it */
300 static int hex_to_int(char **ptr, int *int_value)
301 {
302         int num_chars = 0;
303         int hex_value;
304
305         *int_value = 0;
306
307         while (**ptr) {
308                 hex_value = hex(**ptr);
309                 if (hex_value >= 0) {
310                         *int_value = (*int_value << 4) | hex_value;
311                         num_chars++;
312                 } else
313                         break;
314                 (*ptr)++;
315         }
316         return num_chars;
317 }
318
319 /*  Copy the binary array pointed to by buf into mem.  Fix $, #,
320     and 0x7d escaped with 0x7d.  Return a pointer to the character
321     after the last byte written. */
322 static char *ebin_to_mem(const char *buf, char *mem, int count)
323 {
324         for (; count > 0; count--, buf++) {
325                 if (*buf == 0x7d)
326                         *mem++ = *(++buf) ^ 0x20;
327                 else
328                         *mem++ = *buf;
329         }
330         return mem;
331 }
332
333 /* Pack a hex byte */
334 static char *pack_hex_byte(char *pkt, int byte)
335 {
336         *pkt++ = hexchars[(byte >> 4) & 0xf];
337         *pkt++ = hexchars[(byte & 0xf)];
338         return pkt;
339 }
340
341 /* Scan for the start char '$', read the packet and check the checksum */
342 static void get_packet(char *buffer, int buflen)
343 {
344         unsigned char checksum;
345         unsigned char xmitcsum;
346         int i;
347         int count;
348         char ch;
349
350         do {
351                 /* Ignore everything until the start character */
352                 while ((ch = get_debug_char()) != '$');
353
354                 checksum = 0;
355                 xmitcsum = -1;
356                 count = 0;
357
358                 /* Now, read until a # or end of buffer is found */
359                 while (count < (buflen - 1)) {
360                         ch = get_debug_char();
361
362                         if (ch == '#')
363                                 break;
364
365                         checksum = checksum + ch;
366                         buffer[count] = ch;
367                         count = count + 1;
368                 }
369
370                 buffer[count] = 0;
371
372                 /* Continue to read checksum following # */
373                 if (ch == '#') {
374                         xmitcsum = hex(get_debug_char()) << 4;
375                         xmitcsum += hex(get_debug_char());
376
377                         /* Checksum */
378                         if (checksum != xmitcsum)
379                                 put_debug_char('-');    /* Failed checksum */
380                         else {
381                                 /* Ack successful transfer */
382                                 put_debug_char('+');
383
384                                 /* If a sequence char is present, reply
385                                    the sequence ID */
386                                 if (buffer[2] == ':') {
387                                         put_debug_char(buffer[0]);
388                                         put_debug_char(buffer[1]);
389
390                                         /* Remove sequence chars from buffer */
391                                         count = strlen(buffer);
392                                         for (i = 3; i <= count; i++)
393                                                 buffer[i - 3] = buffer[i];
394                                 }
395                         }
396                 }
397         }
398         while (checksum != xmitcsum);   /* Keep trying while we fail */
399 }
400
401 /* Send the packet in the buffer with run-length encoding */
402 static void put_packet(char *buffer)
403 {
404         int checksum;
405         char *src;
406         int runlen;
407         int encode;
408
409         do {
410                 src = buffer;
411                 put_debug_char('$');
412                 checksum = 0;
413
414                 /* Continue while we still have chars left */
415                 while (*src) {
416                         /* Check for runs up to 99 chars long */
417                         for (runlen = 1; runlen < 99; runlen++) {
418                                 if (src[0] != src[runlen])
419                                         break;
420                         }
421
422                         if (runlen > 3) {
423                                 /* Got a useful amount, send encoding */
424                                 encode = runlen + ' ' - 4;
425                                 put_debug_char(*src);   checksum += *src;
426                                 put_debug_char('*');    checksum += '*';
427                                 put_debug_char(encode); checksum += encode;
428                                 src += runlen;
429                         } else {
430                                 /* Otherwise just send the current char */
431                                 put_debug_char(*src);   checksum += *src;
432                                 src += 1;
433                         }
434                 }
435
436                 /* '#' Separator, put high and low components of checksum */
437                 put_debug_char('#');
438                 put_debug_char(highhex(checksum));
439                 put_debug_char(lowhex(checksum));
440         }
441         while ((get_debug_char()) != '+');      /* While no ack */
442 }
443
444 /* A bus error has occurred - perform a longjmp to return execution and
445    allow handling of the error */
446 static void kgdb_handle_bus_error(void)
447 {
448         longjmp(rem_com_env, 1);
449 }
450
451 /* Translate SH-3/4 exception numbers to unix-like signal values */
452 static int compute_signal(const int excep_code)
453 {
454         int sigval;
455
456         switch (excep_code) {
457
458         case INVALID_INSN_VEC:
459         case INVALID_SLOT_VEC:
460                 sigval = SIGILL;
461                 break;
462         case ADDRESS_ERROR_LOAD_VEC:
463         case ADDRESS_ERROR_STORE_VEC:
464                 sigval = SIGSEGV;
465                 break;
466
467         case SERIAL_BREAK_VEC:
468         case NMI_VEC:
469                 sigval = SIGINT;
470                 break;
471
472         case USER_BREAK_VEC:
473         case TRAP_VEC:
474                 sigval = SIGTRAP;
475                 break;
476
477         default:
478                 sigval = SIGBUS;        /* "software generated" */
479                 break;
480         }
481
482         return (sigval);
483 }
484
485 /* Make a local copy of the registers passed into the handler (bletch) */
486 static void kgdb_regs_to_gdb_regs(const struct kgdb_regs *regs,
487                                   int *gdb_regs)
488 {
489         gdb_regs[R0] = regs->regs[R0];
490         gdb_regs[R1] = regs->regs[R1];
491         gdb_regs[R2] = regs->regs[R2];
492         gdb_regs[R3] = regs->regs[R3];
493         gdb_regs[R4] = regs->regs[R4];
494         gdb_regs[R5] = regs->regs[R5];
495         gdb_regs[R6] = regs->regs[R6];
496         gdb_regs[R7] = regs->regs[R7];
497         gdb_regs[R8] = regs->regs[R8];
498         gdb_regs[R9] = regs->regs[R9];
499         gdb_regs[R10] = regs->regs[R10];
500         gdb_regs[R11] = regs->regs[R11];
501         gdb_regs[R12] = regs->regs[R12];
502         gdb_regs[R13] = regs->regs[R13];
503         gdb_regs[R14] = regs->regs[R14];
504         gdb_regs[R15] = regs->regs[R15];
505         gdb_regs[PC] = regs->pc;
506         gdb_regs[PR] = regs->pr;
507         gdb_regs[GBR] = regs->gbr;
508         gdb_regs[MACH] = regs->mach;
509         gdb_regs[MACL] = regs->macl;
510         gdb_regs[SR] = regs->sr;
511         gdb_regs[VBR] = regs->vbr;
512 }
513
514 /* Copy local gdb registers back to kgdb regs, for later copy to kernel */
515 static void gdb_regs_to_kgdb_regs(const int *gdb_regs,
516                                   struct kgdb_regs *regs)
517 {
518         regs->regs[R0] = gdb_regs[R0];
519         regs->regs[R1] = gdb_regs[R1];
520         regs->regs[R2] = gdb_regs[R2];
521         regs->regs[R3] = gdb_regs[R3];
522         regs->regs[R4] = gdb_regs[R4];
523         regs->regs[R5] = gdb_regs[R5];
524         regs->regs[R6] = gdb_regs[R6];
525         regs->regs[R7] = gdb_regs[R7];
526         regs->regs[R8] = gdb_regs[R8];
527         regs->regs[R9] = gdb_regs[R9];
528         regs->regs[R10] = gdb_regs[R10];
529         regs->regs[R11] = gdb_regs[R11];
530         regs->regs[R12] = gdb_regs[R12];
531         regs->regs[R13] = gdb_regs[R13];
532         regs->regs[R14] = gdb_regs[R14];
533         regs->regs[R15] = gdb_regs[R15];
534         regs->pc = gdb_regs[PC];
535         regs->pr = gdb_regs[PR];
536         regs->gbr = gdb_regs[GBR];
537         regs->mach = gdb_regs[MACH];
538         regs->macl = gdb_regs[MACL];
539         regs->sr = gdb_regs[SR];
540         regs->vbr = gdb_regs[VBR];
541 }
542
543 /* Calculate the new address for after a step */
544 static short *get_step_address(void)
545 {
546         short op = *(short *) trap_registers.pc;
547         long addr;
548
549         /* BT */
550         if (OPCODE_BT(op)) {
551                 if (trap_registers.sr & SR_T_BIT_MASK)
552                         addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
553                 else
554                         addr = trap_registers.pc + 2;
555         }
556
557         /* BTS */
558         else if (OPCODE_BTS(op)) {
559                 if (trap_registers.sr & SR_T_BIT_MASK)
560                         addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
561                 else
562                         addr = trap_registers.pc + 4;   /* Not in delay slot */
563         }
564
565         /* BF */
566         else if (OPCODE_BF(op)) {
567                 if (!(trap_registers.sr & SR_T_BIT_MASK))
568                         addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
569                 else
570                         addr = trap_registers.pc + 2;
571         }
572
573         /* BFS */
574         else if (OPCODE_BFS(op)) {
575                 if (!(trap_registers.sr & SR_T_BIT_MASK))
576                         addr = trap_registers.pc + 4 + OPCODE_BTF_DISP(op);
577                 else
578                         addr = trap_registers.pc + 4;   /* Not in delay slot */
579         }
580
581         /* BRA */
582         else if (OPCODE_BRA(op))
583                 addr = trap_registers.pc + 4 + OPCODE_BRA_DISP(op);
584
585         /* BRAF */
586         else if (OPCODE_BRAF(op))
587                 addr = trap_registers.pc + 4
588                     + trap_registers.regs[OPCODE_BRAF_REG(op)];
589
590         /* BSR */
591         else if (OPCODE_BSR(op))
592                 addr = trap_registers.pc + 4 + OPCODE_BSR_DISP(op);
593
594         /* BSRF */
595         else if (OPCODE_BSRF(op))
596                 addr = trap_registers.pc + 4
597                     + trap_registers.regs[OPCODE_BSRF_REG(op)];
598
599         /* JMP */
600         else if (OPCODE_JMP(op))
601                 addr = trap_registers.regs[OPCODE_JMP_REG(op)];
602
603         /* JSR */
604         else if (OPCODE_JSR(op))
605                 addr = trap_registers.regs[OPCODE_JSR_REG(op)];
606
607         /* RTS */
608         else if (OPCODE_RTS(op))
609                 addr = trap_registers.pr;
610
611         /* RTE */
612         else if (OPCODE_RTE(op))
613                 addr = trap_registers.regs[15];
614
615         /* Other */
616         else
617                 addr = trap_registers.pc + 2;
618
619         flush_icache_range(addr, addr + 2);
620         return (short *) addr;
621 }
622
623 /* Set up a single-step.  Replace the instruction immediately after the
624    current instruction (i.e. next in the expected flow of control) with a
625    trap instruction, so that returning will cause only a single instruction
626    to be executed. Note that this model is slightly broken for instructions
627    with delay slots (e.g. B[TF]S, BSR, BRA etc), where both the branch
628    and the instruction in the delay slot will be executed. */
629 static void do_single_step(void)
630 {
631         unsigned short *addr = 0;
632
633         /* Determine where the target instruction will send us to */
634         addr = get_step_address();
635         stepped_address = (int)addr;
636
637         /* Replace it */
638         stepped_opcode = *(short *)addr;
639         *addr = STEP_OPCODE;
640
641         /* Flush and return */
642         flush_icache_range((long) addr, (long) addr + 2);
643 }
644
645 /* Undo a single step */
646 static void undo_single_step(void)
647 {
648         /* If we have stepped, put back the old instruction */
649         /* Use stepped_address in case we stopped elsewhere */
650         if (stepped_opcode != 0) {
651                 *(short*)stepped_address = stepped_opcode;
652                 flush_icache_range(stepped_address, stepped_address + 2);
653         }
654         stepped_opcode = 0;
655 }
656
657 /* Send a signal message */
658 static void send_signal_msg(const int signum)
659 {
660         out_buffer[0] = 'S';
661         out_buffer[1] = highhex(signum);
662         out_buffer[2] = lowhex(signum);
663         out_buffer[3] = 0;
664         put_packet(out_buffer);
665 }
666
667 /* Reply that all was well */
668 static void send_ok_msg(void)
669 {
670         strcpy(out_buffer, "OK");
671         put_packet(out_buffer);
672 }
673
674 /* Reply that an error occurred */
675 static void send_err_msg(void)
676 {
677         strcpy(out_buffer, "E01");
678         put_packet(out_buffer);
679 }
680
681 /* Empty message indicates unrecognised command */
682 static void send_empty_msg(void)
683 {
684         put_packet("");
685 }
686
687 /* Read memory due to 'm' message */
688 static void read_mem_msg(void)
689 {
690         char *ptr;
691         int addr;
692         int length;
693
694         /* Jmp, disable bus error handler */
695         if (setjmp(rem_com_env) == 0) {
696
697                 kgdb_nofault = 1;
698
699                 /* Walk through, have m<addr>,<length> */
700                 ptr = &in_buffer[1];
701                 if (hex_to_int(&ptr, &addr) && (*ptr++ == ','))
702                         if (hex_to_int(&ptr, &length)) {
703                                 ptr = 0;
704                                 if (length * 2 > OUTBUFMAX)
705                                         length = OUTBUFMAX / 2;
706                                 mem_to_hex((char *) addr, out_buffer, length);
707                         }
708                 if (ptr)
709                         send_err_msg();
710                 else
711                         put_packet(out_buffer);
712         } else
713                 send_err_msg();
714
715         /* Restore bus error handler */
716         kgdb_nofault = 0;
717 }
718
719 /* Write memory due to 'M' or 'X' message */
720 static void write_mem_msg(int binary)
721 {
722         char *ptr;
723         int addr;
724         int length;
725
726         if (setjmp(rem_com_env) == 0) {
727
728                 kgdb_nofault = 1;
729
730                 /* Walk through, have M<addr>,<length>:<data> */
731                 ptr = &in_buffer[1];
732                 if (hex_to_int(&ptr, &addr) && (*ptr++ == ','))
733                         if (hex_to_int(&ptr, &length) && (*ptr++ == ':')) {
734                                 if (binary)
735                                         ebin_to_mem(ptr, (char*)addr, length);
736                                 else
737                                         hex_to_mem(ptr, (char*)addr, length);
738                                 flush_icache_range(addr, addr + length);
739                                 ptr = 0;
740                                 send_ok_msg();
741                         }
742                 if (ptr)
743                         send_err_msg();
744         } else
745                 send_err_msg();
746
747         /* Restore bus error handler */
748         kgdb_nofault = 0;
749 }
750
751 /* Continue message  */
752 static void continue_msg(void)
753 {
754         /* Try to read optional parameter, PC unchanged if none */
755         char *ptr = &in_buffer[1];
756         int addr;
757
758         if (hex_to_int(&ptr, &addr))
759                 trap_registers.pc = addr;
760 }
761
762 /* Continue message with signal */
763 static void continue_with_sig_msg(void)
764 {
765         int signal;
766         char *ptr = &in_buffer[1];
767         int addr;
768
769         /* Report limitation */
770         kgdb_to_gdb("Cannot force signal in kgdb, continuing anyway.\n");
771
772         /* Signal */
773         hex_to_int(&ptr, &signal);
774         if (*ptr == ';')
775                 ptr++;
776
777         /* Optional address */
778         if (hex_to_int(&ptr, &addr))
779                 trap_registers.pc = addr;
780 }
781
782 /* Step message */
783 static void step_msg(void)
784 {
785         continue_msg();
786         do_single_step();
787 }
788
789 /* Step message with signal */
790 static void step_with_sig_msg(void)
791 {
792         continue_with_sig_msg();
793         do_single_step();
794 }
795
796 /* Send register contents */
797 static void send_regs_msg(void)
798 {
799         kgdb_regs_to_gdb_regs(&trap_registers, registers);
800         mem_to_hex((char *) registers, out_buffer, NUMREGBYTES);
801         put_packet(out_buffer);
802 }
803
804 /* Set register contents - currently can't set other thread's registers */
805 static void set_regs_msg(void)
806 {
807         kgdb_regs_to_gdb_regs(&trap_registers, registers);
808         hex_to_mem(&in_buffer[1], (char *) registers, NUMREGBYTES);
809         gdb_regs_to_kgdb_regs(registers, &trap_registers);
810         send_ok_msg();
811 }
812
813 #ifdef CONFIG_SH_KGDB_CONSOLE
814 /*
815  * Bring up the ports..
816  */
817 static int __init kgdb_serial_setup(void)
818 {
819         struct console dummy;
820         return kgdb_console_setup(&dummy, 0);
821 }
822 #else
823 #define kgdb_serial_setup()     0
824 #endif
825
826 /* The command loop, read and act on requests */
827 static void kgdb_command_loop(const int excep_code, const int trapa_value)
828 {
829         int sigval;
830
831         /* Enter GDB mode (e.g. after detach) */
832         if (!kgdb_in_gdb_mode) {
833                 /* Do serial setup, notify user, issue preemptive ack */
834                 printk(KERN_NOTICE "KGDB: Waiting for GDB\n");
835                 kgdb_in_gdb_mode = 1;
836                 put_debug_char('+');
837         }
838
839         /* Reply to host that an exception has occurred */
840         sigval = compute_signal(excep_code);
841         send_signal_msg(sigval);
842
843         /* TRAP_VEC exception indicates a software trap inserted in place of
844            code by GDB so back up PC by one instruction, as this instruction
845            will later be replaced by its original one.  Do NOT do this for
846            trap 0xff, since that indicates a compiled-in breakpoint which
847            will not be replaced (and we would retake the trap forever) */
848         if ((excep_code == TRAP_VEC) && (trapa_value != (0x3c << 2)))
849                 trap_registers.pc -= 2;
850
851         /* Undo any stepping we may have done */
852         undo_single_step();
853
854         while (1) {
855                 out_buffer[0] = 0;
856                 get_packet(in_buffer, BUFMAX);
857
858                 /* Examine first char of buffer to see what we need to do */
859                 switch (in_buffer[0]) {
860                 case '?':       /* Send which signal we've received */
861                         send_signal_msg(sigval);
862                         break;
863
864                 case 'g':       /* Return the values of the CPU registers */
865                         send_regs_msg();
866                         break;
867
868                 case 'G':       /* Set the value of the CPU registers */
869                         set_regs_msg();
870                         break;
871
872                 case 'm':       /* Read LLLL bytes address AA..AA */
873                         read_mem_msg();
874                         break;
875
876                 case 'M':       /* Write LLLL bytes address AA..AA, ret OK */
877                         write_mem_msg(0);       /* 0 = data in hex */
878                         break;
879
880                 case 'X':       /* Write LLLL bytes esc bin address AA..AA */
881                         if (kgdb_bits == '8')
882                                 write_mem_msg(1); /* 1 = data in binary */
883                         else
884                                 send_empty_msg();
885                         break;
886
887                 case 'C':       /* Continue, signum included, we ignore it */
888                         continue_with_sig_msg();
889                         return;
890
891                 case 'c':       /* Continue at address AA..AA (optional) */
892                         continue_msg();
893                         return;
894
895                 case 'S':       /* Step, signum included, we ignore it */
896                         step_with_sig_msg();
897                         return;
898
899                 case 's':       /* Step one instruction from AA..AA */
900                         step_msg();
901                         return;
902
903                 case 'k':       /* 'Kill the program' with a kernel ? */
904                         break;
905
906                 case 'D':       /* Detach from program, send reply OK */
907                         kgdb_in_gdb_mode = 0;
908                         send_ok_msg();
909                         get_debug_char();
910                         return;
911
912                 default:
913                         send_empty_msg();
914                         break;
915                 }
916         }
917 }
918
919 /* There has been an exception, most likely a breakpoint. */
920 static void handle_exception(struct pt_regs *regs)
921 {
922         int excep_code, vbr_val;
923         int count;
924         int trapa_value = ctrl_inl(TRA);
925
926         /* Copy kernel regs (from stack) */
927         for (count = 0; count < 16; count++)
928                 trap_registers.regs[count] = regs->regs[count];
929         trap_registers.pc = regs->pc;
930         trap_registers.pr = regs->pr;
931         trap_registers.sr = regs->sr;
932         trap_registers.gbr = regs->gbr;
933         trap_registers.mach = regs->mach;
934         trap_registers.macl = regs->macl;
935
936         asm("stc vbr, %0":"=r"(vbr_val));
937         trap_registers.vbr = vbr_val;
938
939         /* Get excode for command loop call, user access */
940         asm("stc r2_bank, %0":"=r"(excep_code));
941
942         /* Act on the exception */
943         kgdb_command_loop(excep_code, trapa_value);
944
945         /* Copy back the (maybe modified) registers */
946         for (count = 0; count < 16; count++)
947                 regs->regs[count] = trap_registers.regs[count];
948         regs->pc = trap_registers.pc;
949         regs->pr = trap_registers.pr;
950         regs->sr = trap_registers.sr;
951         regs->gbr = trap_registers.gbr;
952         regs->mach = trap_registers.mach;
953         regs->macl = trap_registers.macl;
954
955         vbr_val = trap_registers.vbr;
956         asm("ldc %0, vbr": :"r"(vbr_val));
957 }
958
959 asmlinkage void kgdb_handle_exception(unsigned long r4, unsigned long r5,
960                                       unsigned long r6, unsigned long r7,
961                                       struct pt_regs __regs)
962 {
963         struct pt_regs *regs = RELOC_HIDE(&__regs, 0);
964         handle_exception(regs);
965 }
966
967 /* Initialise the KGDB data structures and serial configuration */
968 int __init kgdb_init(void)
969 {
970         in_nmi = 0;
971         kgdb_nofault = 0;
972         stepped_opcode = 0;
973         kgdb_in_gdb_mode = 0;
974
975         if (kgdb_serial_setup() != 0) {
976                 printk(KERN_NOTICE "KGDB: serial setup error\n");
977                 return -1;
978         }
979
980         /* Init ptr to exception handler */
981         kgdb_debug_hook = handle_exception;
982         kgdb_bus_err_hook = kgdb_handle_bus_error;
983
984         /* Enter kgdb now if requested, or just report init done */
985         printk(KERN_NOTICE "KGDB: stub is initialized.\n");
986
987         return 0;
988 }
989
990 /* Make function available for "user messages"; console will use it too. */
991
992 char gdbmsgbuf[BUFMAX];
993 #define MAXOUT ((BUFMAX-2)/2)
994
995 static void kgdb_msg_write(const char *s, unsigned count)
996 {
997         int i;
998         int wcount;
999         char *bufptr;
1000
1001         /* 'O'utput */
1002         gdbmsgbuf[0] = 'O';
1003
1004         /* Fill and send buffers... */
1005         while (count > 0) {
1006                 bufptr = gdbmsgbuf + 1;
1007
1008                 /* Calculate how many this time */
1009                 wcount = (count > MAXOUT) ? MAXOUT : count;
1010
1011                 /* Pack in hex chars */
1012                 for (i = 0; i < wcount; i++)
1013                         bufptr = pack_hex_byte(bufptr, s[i]);
1014                 *bufptr = '\0';
1015
1016                 /* Move up */
1017                 s += wcount;
1018                 count -= wcount;
1019
1020                 /* Write packet */
1021                 put_packet(gdbmsgbuf);
1022         }
1023 }
1024
1025 static void kgdb_to_gdb(const char *s)
1026 {
1027         kgdb_msg_write(s, strlen(s));
1028 }
1029
1030 #ifdef CONFIG_SH_KGDB_CONSOLE
1031 void kgdb_console_write(struct console *co, const char *s, unsigned count)
1032 {
1033         /* Bail if we're not talking to GDB */
1034         if (!kgdb_in_gdb_mode)
1035                 return;
1036
1037         kgdb_msg_write(s, count);
1038 }
1039 #endif
1040
1041 #ifdef CONFIG_KGDB_SYSRQ
1042 static void sysrq_handle_gdb(int key, struct tty_struct *tty)
1043 {
1044         printk("Entering GDB stub\n");
1045         breakpoint();
1046 }
1047
1048 static struct sysrq_key_op sysrq_gdb_op = {
1049         .handler        = sysrq_handle_gdb,
1050         .help_msg       = "Gdb",
1051         .action_msg     = "GDB",
1052 };
1053
1054 static int gdb_register_sysrq(void)
1055 {
1056         printk("Registering GDB sysrq handler\n");
1057         register_sysrq_key('g', &sysrq_gdb_op);
1058         return 0;
1059 }
1060 module_init(gdb_register_sysrq);
1061 #endif