1/* gdb-stub.c: FRV GDB stub 2 * 3 * Copyright (C) 2003,4 Red Hat, Inc. All Rights Reserved. 4 * Written by David Howells (dhowells@redhat.com) 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 135extern void debug_to_serial(const char *p, int n); 136extern void gdbstub_console_write(struct console *co, const char *p, unsigned n); 137 138extern volatile uint32_t __break_error_detect[3]; /* ESFR1, ESR15, EAR15 */ 139 140struct __debug_amr { 141 unsigned long L, P; 142} __attribute__((aligned(8))); 143 144struct __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 160static 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 170static const char gdbstub_banner[] = "Linux/FR-V GDB Stub (c) RedHat 2003\n"; 171 172volatile u8 gdbstub_rx_buffer[PAGE_SIZE] __attribute__((aligned(PAGE_SIZE))); 173volatile u32 gdbstub_rx_inp = 0; 174volatile u32 gdbstub_rx_outp = 0; 175volatile u8 gdbstub_rx_overflow = 0; 176u8 gdbstub_rx_unget = 0; 177 178/* set with GDB whilst running to permit step through exceptions */ 179extern volatile u32 __attribute__((section(".bss"))) gdbstub_trace_through_exceptions; 180 181static char input_buffer[BUFMAX]; 182static char output_buffer[BUFMAX]; 183 184static 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 199struct gdbstub_bkpt { 200 unsigned long addr; /* address of breakpoint */ 201 unsigned len; /* size of breakpoint */ 202 uint32_t originsns[7]; /* original instructions */ 203}; 204 205static struct gdbstub_bkpt gdbstub_bkpts[256]; 206 207/* 208 * local prototypes 209 */ 210 211static void gdbstub_recv_packet(char *buffer); 212static int gdbstub_send_packet(char *buffer); 213static int gdbstub_compute_signal(unsigned long tbr); 214static int hex(unsigned char ch); 215static int hexToInt(char **ptr, unsigned long *intValue); 216static unsigned char *mem2hex(const void *mem, char *buf, int count, int may_fault); 217static char *hex2mem(const char *buf, void *_mem, int count); 218 219/* 220 * Convert ch from a hex digit to an int 221 */ 222static 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 233void 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 246static 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 254static 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 */ 267static 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 */ 362static 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 */ 407static 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 */ 430static 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 444static unsigned long __saved_dampr, __saved_damlr; 445 446static 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 480static 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 501static 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 */ 512static 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 530static 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 546static 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 564static 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 580static 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 598static 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 614static 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 641void 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 649static 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 */ 666static 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 */ 724static 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 */ 796static 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 */ 827static 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 */ 844static 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 */ 1008int 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 */ 1160static 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 */ 1179static 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 */ 1207static 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 */ 1232void 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 */ 1349static 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 */ 1393void 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 */ 2027void __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) 2079static 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 */ 2093void 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 */ 2126static void *malloc(size_t size) __maybe_unused; 2127static void *malloc(size_t size) 2128{ 2129 return kmalloc(size, GFP_ATOMIC); 2130} 2131 2132static void free(void *p) __maybe_unused; 2133static void free(void *p) 2134{ 2135 kfree(p); 2136} 2137 2138static uint32_t ___get_HSR0(void) __maybe_unused; 2139static uint32_t ___get_HSR0(void) 2140{ 2141 return __get_HSR(0); 2142} 2143 2144static uint32_t ___set_HSR0(uint32_t x) __maybe_unused; 2145static uint32_t ___set_HSR0(uint32_t x) 2146{ 2147 __set_HSR(0, x); 2148 return __get_HSR(0); 2149} 2150