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