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