![Linus Torvalds](/assets/img/avatar_default.png)
Initial git repository build. I'm not bothering with the full history, even though we have it. We can create a separate "historical" git archive of that later if we want to, and in the meantime it's about 3.2GB when imported into git - space that would just make the early git days unnecessarily complicated, when we don't have a lot of good infrastructure for it. Let it rip!
2085 lines
54 KiB
C
2085 lines
54 KiB
C
/* gdb-stub.c: FRV GDB stub
|
|
*
|
|
* Copyright (C) 2003,4 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
* - Derived from Linux/MIPS version, Copyright (C) 1995 Andreas Busse
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*/
|
|
|
|
/*
|
|
* To enable debugger support, two things need to happen. One, a
|
|
* call to set_debug_traps() is necessary in order to allow any breakpoints
|
|
* or error conditions to be properly intercepted and reported to gdb.
|
|
* Two, a breakpoint needs to be generated to begin communication. This
|
|
* is most easily accomplished by a call to breakpoint(). Breakpoint()
|
|
* simulates a breakpoint by executing a BREAK instruction.
|
|
*
|
|
*
|
|
* The following gdb commands are supported:
|
|
*
|
|
* command function Return value
|
|
*
|
|
* g return the value of the CPU registers hex data or ENN
|
|
* G set the value of the CPU registers OK or ENN
|
|
*
|
|
* mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
|
|
* MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
|
|
*
|
|
* c Resume at current address SNN ( signal NN)
|
|
* cAA..AA Continue at address AA..AA SNN
|
|
*
|
|
* s Step one instruction SNN
|
|
* sAA..AA Step one instruction from AA..AA SNN
|
|
*
|
|
* k kill
|
|
*
|
|
* ? What was the last sigval ? SNN (signal NN)
|
|
*
|
|
* bBB..BB Set baud rate to BB..BB OK or BNN, then sets
|
|
* baud rate
|
|
*
|
|
* All commands and responses are sent with a packet which includes a
|
|
* checksum. A packet consists of
|
|
*
|
|
* $<packet info>#<checksum>.
|
|
*
|
|
* where
|
|
* <packet info> :: <characters representing the command or response>
|
|
* <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>>
|
|
*
|
|
* When a packet is received, it is first acknowledged with either '+' or '-'.
|
|
* '+' indicates a successful transfer. '-' indicates a failed transfer.
|
|
*
|
|
* Example:
|
|
*
|
|
* Host: Reply:
|
|
* $m0,10#2a +$00010203040506070809101112131415#42
|
|
*
|
|
*
|
|
* ==============
|
|
* MORE EXAMPLES:
|
|
* ==============
|
|
*
|
|
* For reference -- the following are the steps that one
|
|
* company took (RidgeRun Inc) to get remote gdb debugging
|
|
* going. In this scenario the host machine was a PC and the
|
|
* target platform was a Galileo EVB64120A MIPS evaluation
|
|
* board.
|
|
*
|
|
* Step 1:
|
|
* First download gdb-5.0.tar.gz from the internet.
|
|
* and then build/install the package.
|
|
*
|
|
* Example:
|
|
* $ tar zxf gdb-5.0.tar.gz
|
|
* $ cd gdb-5.0
|
|
* $ ./configure --target=frv-elf-gdb
|
|
* $ make
|
|
* $ frv-elf-gdb
|
|
*
|
|
* Step 2:
|
|
* Configure linux for remote debugging and build it.
|
|
*
|
|
* Example:
|
|
* $ cd ~/linux
|
|
* $ make menuconfig <go to "Kernel Hacking" and turn on remote debugging>
|
|
* $ make dep; make vmlinux
|
|
*
|
|
* Step 3:
|
|
* Download the kernel to the remote target and start
|
|
* the kernel running. It will promptly halt and wait
|
|
* for the host gdb session to connect. It does this
|
|
* since the "Kernel Hacking" option has defined
|
|
* CONFIG_REMOTE_DEBUG which in turn enables your calls
|
|
* to:
|
|
* set_debug_traps();
|
|
* breakpoint();
|
|
*
|
|
* Step 4:
|
|
* Start the gdb session on the host.
|
|
*
|
|
* Example:
|
|
* $ frv-elf-gdb vmlinux
|
|
* (gdb) set remotebaud 115200
|
|
* (gdb) target remote /dev/ttyS1
|
|
* ...at this point you are connected to
|
|
* the remote target and can use gdb
|
|
* in the normal fasion. Setting
|
|
* breakpoints, single stepping,
|
|
* printing variables, etc.
|
|
*
|
|
*/
|
|
|
|
#include <linux/string.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/signal.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/console.h>
|
|
#include <linux/init.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/nmi.h>
|
|
|
|
#include <asm/pgtable.h>
|
|
#include <asm/system.h>
|
|
#include <asm/gdb-stub.h>
|
|
|
|
#define LEDS(x) do { /* *(u32*)0xe1200004 = ~(x); mb(); */ } while(0)
|
|
|
|
#undef GDBSTUB_DEBUG_PROTOCOL
|
|
|
|
extern void debug_to_serial(const char *p, int n);
|
|
extern void gdbstub_console_write(struct console *co, const char *p, unsigned n);
|
|
|
|
extern volatile uint32_t __break_error_detect[3]; /* ESFR1, ESR15, EAR15 */
|
|
extern struct user_context __break_user_context;
|
|
|
|
struct __debug_amr {
|
|
unsigned long L, P;
|
|
} __attribute__((aligned(8)));
|
|
|
|
struct __debug_mmu {
|
|
struct {
|
|
unsigned long hsr0, pcsr, esr0, ear0, epcr0;
|
|
#ifdef CONFIG_MMU
|
|
unsigned long tplr, tppr, tpxr, cxnr;
|
|
#endif
|
|
} regs;
|
|
|
|
struct __debug_amr iamr[16];
|
|
struct __debug_amr damr[16];
|
|
|
|
#ifdef CONFIG_MMU
|
|
struct __debug_amr tlb[64*2];
|
|
#endif
|
|
};
|
|
|
|
static struct __debug_mmu __debug_mmu;
|
|
|
|
/*
|
|
* BUFMAX defines the maximum number of characters in inbound/outbound buffers
|
|
* at least NUMREGBYTES*2 are needed for register packets
|
|
*/
|
|
#define BUFMAX 2048
|
|
|
|
#define BREAK_INSN 0x801000c0 /* use "break" as bkpt */
|
|
|
|
static const char gdbstub_banner[] = "Linux/FR-V GDB Stub (c) RedHat 2003\n";
|
|
|
|
volatile u8 gdbstub_rx_buffer[PAGE_SIZE] __attribute__((aligned(PAGE_SIZE)));
|
|
volatile u32 gdbstub_rx_inp = 0;
|
|
volatile u32 gdbstub_rx_outp = 0;
|
|
volatile u8 gdbstub_rx_overflow = 0;
|
|
u8 gdbstub_rx_unget = 0;
|
|
|
|
/* set with GDB whilst running to permit step through exceptions */
|
|
extern volatile u32 __attribute__((section(".bss"))) gdbstub_trace_through_exceptions;
|
|
|
|
static char input_buffer[BUFMAX];
|
|
static char output_buffer[BUFMAX];
|
|
|
|
static const char hexchars[] = "0123456789abcdef";
|
|
|
|
static const char *regnames[] = {
|
|
"PSR ", "ISR ", "CCR ", "CCCR",
|
|
"LR ", "LCR ", "PC ", "_stt",
|
|
"sys ", "GR8*", "GNE0", "GNE1",
|
|
"IACH", "IACL",
|
|
"TBR ", "SP ", "FP ", "GR3 ",
|
|
"GR4 ", "GR5 ", "GR6 ", "GR7 ",
|
|
"GR8 ", "GR9 ", "GR10", "GR11",
|
|
"GR12", "GR13", "GR14", "GR15",
|
|
"GR16", "GR17", "GR18", "GR19",
|
|
"GR20", "GR21", "GR22", "GR23",
|
|
"GR24", "GR25", "GR26", "GR27",
|
|
"EFRM", "CURR", "GR30", "BFRM"
|
|
};
|
|
|
|
struct gdbstub_bkpt {
|
|
unsigned long addr; /* address of breakpoint */
|
|
unsigned len; /* size of breakpoint */
|
|
uint32_t originsns[7]; /* original instructions */
|
|
};
|
|
|
|
static struct gdbstub_bkpt gdbstub_bkpts[256];
|
|
|
|
/*
|
|
* local prototypes
|
|
*/
|
|
|
|
static void gdbstub_recv_packet(char *buffer);
|
|
static int gdbstub_send_packet(char *buffer);
|
|
static int gdbstub_compute_signal(unsigned long tbr);
|
|
static int hex(unsigned char ch);
|
|
static int hexToInt(char **ptr, unsigned long *intValue);
|
|
static unsigned char *mem2hex(const void *mem, char *buf, int count, int may_fault);
|
|
static char *hex2mem(const char *buf, void *_mem, int count);
|
|
|
|
/*
|
|
* Convert ch from a hex digit to an int
|
|
*/
|
|
static int hex(unsigned char ch)
|
|
{
|
|
if (ch >= 'a' && ch <= 'f')
|
|
return ch-'a'+10;
|
|
if (ch >= '0' && ch <= '9')
|
|
return ch-'0';
|
|
if (ch >= 'A' && ch <= 'F')
|
|
return ch-'A'+10;
|
|
return -1;
|
|
}
|
|
|
|
void gdbstub_printk(const char *fmt, ...)
|
|
{
|
|
static char buf[1024];
|
|
va_list args;
|
|
int len;
|
|
|
|
/* Emit the output into the temporary buffer */
|
|
va_start(args, fmt);
|
|
len = vsnprintf(buf, sizeof(buf), fmt, args);
|
|
va_end(args);
|
|
debug_to_serial(buf, len);
|
|
}
|
|
|
|
static inline char *gdbstub_strcpy(char *dst, const char *src)
|
|
{
|
|
int loop = 0;
|
|
while ((dst[loop] = src[loop]))
|
|
loop++;
|
|
return dst;
|
|
}
|
|
|
|
static void gdbstub_purge_cache(void)
|
|
{
|
|
asm volatile(" dcef @(gr0,gr0),#1 \n"
|
|
" icei @(gr0,gr0),#1 \n"
|
|
" membar \n"
|
|
" bar \n"
|
|
);
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* scan for the sequence $<data>#<checksum>
|
|
*/
|
|
static void gdbstub_recv_packet(char *buffer)
|
|
{
|
|
unsigned char checksum;
|
|
unsigned char xmitcsum;
|
|
unsigned char ch;
|
|
int count, i, ret, error;
|
|
|
|
for (;;) {
|
|
/* wait around for the start character, ignore all other characters */
|
|
do {
|
|
gdbstub_rx_char(&ch, 0);
|
|
} while (ch != '$');
|
|
|
|
checksum = 0;
|
|
xmitcsum = -1;
|
|
count = 0;
|
|
error = 0;
|
|
|
|
/* now, read until a # or end of buffer is found */
|
|
while (count < BUFMAX) {
|
|
ret = gdbstub_rx_char(&ch, 0);
|
|
if (ret < 0)
|
|
error = ret;
|
|
|
|
if (ch == '#')
|
|
break;
|
|
checksum += ch;
|
|
buffer[count] = ch;
|
|
count++;
|
|
}
|
|
|
|
if (error == -EIO) {
|
|
gdbstub_proto("### GDB Rx Error - Skipping packet ###\n");
|
|
gdbstub_proto("### GDB Tx NAK\n");
|
|
gdbstub_tx_char('-');
|
|
continue;
|
|
}
|
|
|
|
if (count >= BUFMAX || error)
|
|
continue;
|
|
|
|
buffer[count] = 0;
|
|
|
|
/* read the checksum */
|
|
ret = gdbstub_rx_char(&ch, 0);
|
|
if (ret < 0)
|
|
error = ret;
|
|
xmitcsum = hex(ch) << 4;
|
|
|
|
ret = gdbstub_rx_char(&ch, 0);
|
|
if (ret < 0)
|
|
error = ret;
|
|
xmitcsum |= hex(ch);
|
|
|
|
if (error) {
|
|
if (error == -EIO)
|
|
gdbstub_proto("### GDB Rx Error - Skipping packet\n");
|
|
gdbstub_proto("### GDB Tx NAK\n");
|
|
gdbstub_tx_char('-');
|
|
continue;
|
|
}
|
|
|
|
/* check the checksum */
|
|
if (checksum != xmitcsum) {
|
|
gdbstub_proto("### GDB Tx NAK\n");
|
|
gdbstub_tx_char('-'); /* failed checksum */
|
|
continue;
|
|
}
|
|
|
|
gdbstub_proto("### GDB Rx '$%s#%02x' ###\n", buffer, checksum);
|
|
gdbstub_proto("### GDB Tx ACK\n");
|
|
gdbstub_tx_char('+'); /* successful transfer */
|
|
|
|
/* if a sequence char is present, reply the sequence ID */
|
|
if (buffer[2] == ':') {
|
|
gdbstub_tx_char(buffer[0]);
|
|
gdbstub_tx_char(buffer[1]);
|
|
|
|
/* remove sequence chars from buffer */
|
|
count = 0;
|
|
while (buffer[count]) count++;
|
|
for (i=3; i <= count; i++)
|
|
buffer[i - 3] = buffer[i];
|
|
}
|
|
|
|
break;
|
|
}
|
|
} /* end gdbstub_recv_packet() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* send the packet in buffer.
|
|
* - return 0 if successfully ACK'd
|
|
* - return 1 if abandoned due to new incoming packet
|
|
*/
|
|
static int gdbstub_send_packet(char *buffer)
|
|
{
|
|
unsigned char checksum;
|
|
int count;
|
|
unsigned char ch;
|
|
|
|
/* $<packet info>#<checksum> */
|
|
gdbstub_proto("### GDB Tx '%s' ###\n", buffer);
|
|
|
|
do {
|
|
gdbstub_tx_char('$');
|
|
checksum = 0;
|
|
count = 0;
|
|
|
|
while ((ch = buffer[count]) != 0) {
|
|
gdbstub_tx_char(ch);
|
|
checksum += ch;
|
|
count += 1;
|
|
}
|
|
|
|
gdbstub_tx_char('#');
|
|
gdbstub_tx_char(hexchars[checksum >> 4]);
|
|
gdbstub_tx_char(hexchars[checksum & 0xf]);
|
|
|
|
} while (gdbstub_rx_char(&ch,0),
|
|
#ifdef GDBSTUB_DEBUG_PROTOCOL
|
|
ch=='-' && (gdbstub_proto("### GDB Rx NAK\n"),0),
|
|
ch!='-' && ch!='+' && (gdbstub_proto("### GDB Rx ??? %02x\n",ch),0),
|
|
#endif
|
|
ch!='+' && ch!='$');
|
|
|
|
if (ch=='+') {
|
|
gdbstub_proto("### GDB Rx ACK\n");
|
|
return 0;
|
|
}
|
|
|
|
gdbstub_proto("### GDB Tx Abandoned\n");
|
|
gdbstub_rx_unget = ch;
|
|
return 1;
|
|
} /* end gdbstub_send_packet() */
|
|
|
|
/*
|
|
* While we find nice hex chars, build an int.
|
|
* Return number of chars processed.
|
|
*/
|
|
static int hexToInt(char **ptr, unsigned long *_value)
|
|
{
|
|
int count = 0, ch;
|
|
|
|
*_value = 0;
|
|
while (**ptr) {
|
|
ch = hex(**ptr);
|
|
if (ch < 0)
|
|
break;
|
|
|
|
*_value = (*_value << 4) | ((uint8_t) ch & 0xf);
|
|
count++;
|
|
|
|
(*ptr)++;
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* probe an address to see whether it maps to anything
|
|
*/
|
|
static inline int gdbstub_addr_probe(const void *vaddr)
|
|
{
|
|
#ifdef CONFIG_MMU
|
|
unsigned long paddr;
|
|
|
|
asm("lrad %1,%0,#1,#0,#0" : "=r"(paddr) : "r"(vaddr));
|
|
if (!(paddr & xAMPRx_V))
|
|
return 0;
|
|
#endif
|
|
|
|
return 1;
|
|
} /* end gdbstub_addr_probe() */
|
|
|
|
#ifdef CONFIG_MMU
|
|
static unsigned long __saved_dampr, __saved_damlr;
|
|
|
|
static inline unsigned long gdbstub_virt_to_pte(unsigned long vaddr)
|
|
{
|
|
pgd_t *pgd;
|
|
pud_t *pud;
|
|
pmd_t *pmd;
|
|
pte_t *pte;
|
|
unsigned long val, dampr5;
|
|
|
|
pgd = (pgd_t *) __get_DAMLR(3) + pgd_index(vaddr);
|
|
pud = pud_offset(pgd, vaddr);
|
|
pmd = pmd_offset(pud, vaddr);
|
|
|
|
if (pmd_bad(*pmd) || !pmd_present(*pmd))
|
|
return 0;
|
|
|
|
/* make sure dampr5 maps to the correct pmd */
|
|
dampr5 = __get_DAMPR(5);
|
|
val = pmd_val(*pmd);
|
|
__set_DAMPR(5, val | xAMPRx_L | xAMPRx_SS_16Kb | xAMPRx_S | xAMPRx_C | xAMPRx_V);
|
|
|
|
/* now its safe to access pmd */
|
|
pte = (pte_t *)__get_DAMLR(5) + __pte_index(vaddr);
|
|
if (pte_present(*pte))
|
|
val = pte_val(*pte);
|
|
else
|
|
val = 0;
|
|
|
|
/* restore original dampr5 */
|
|
__set_DAMPR(5, dampr5);
|
|
|
|
return val;
|
|
}
|
|
#endif
|
|
|
|
static inline int gdbstub_addr_map(const void *vaddr)
|
|
{
|
|
#ifdef CONFIG_MMU
|
|
unsigned long pte;
|
|
|
|
__saved_dampr = __get_DAMPR(2);
|
|
__saved_damlr = __get_DAMLR(2);
|
|
#endif
|
|
if (gdbstub_addr_probe(vaddr))
|
|
return 1;
|
|
#ifdef CONFIG_MMU
|
|
pte = gdbstub_virt_to_pte((unsigned long) vaddr);
|
|
if (pte) {
|
|
__set_DAMPR(2, pte);
|
|
__set_DAMLR(2, (unsigned long) vaddr & PAGE_MASK);
|
|
return 1;
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static inline void gdbstub_addr_unmap(void)
|
|
{
|
|
#ifdef CONFIG_MMU
|
|
__set_DAMPR(2, __saved_dampr);
|
|
__set_DAMLR(2, __saved_damlr);
|
|
#endif
|
|
}
|
|
|
|
/*
|
|
* access potentially dodgy memory through a potentially dodgy pointer
|
|
*/
|
|
static inline int gdbstub_read_dword(const void *addr, uint32_t *_res)
|
|
{
|
|
unsigned long brr;
|
|
uint32_t res;
|
|
|
|
if (!gdbstub_addr_map(addr))
|
|
return 0;
|
|
|
|
asm volatile(" movgs gr0,brr \n"
|
|
" ld%I2 %M2,%0 \n"
|
|
" movsg brr,%1 \n"
|
|
: "=r"(res), "=r"(brr)
|
|
: "m"(*(uint32_t *) addr));
|
|
*_res = res;
|
|
gdbstub_addr_unmap();
|
|
return likely(!brr);
|
|
}
|
|
|
|
static inline int gdbstub_write_dword(void *addr, uint32_t val)
|
|
{
|
|
unsigned long brr;
|
|
|
|
if (!gdbstub_addr_map(addr))
|
|
return 0;
|
|
|
|
asm volatile(" movgs gr0,brr \n"
|
|
" st%I2 %1,%M2 \n"
|
|
" movsg brr,%0 \n"
|
|
: "=r"(brr)
|
|
: "r"(val), "m"(*(uint32_t *) addr));
|
|
gdbstub_addr_unmap();
|
|
return likely(!brr);
|
|
}
|
|
|
|
static inline int gdbstub_read_word(const void *addr, uint16_t *_res)
|
|
{
|
|
unsigned long brr;
|
|
uint16_t res;
|
|
|
|
if (!gdbstub_addr_map(addr))
|
|
return 0;
|
|
|
|
asm volatile(" movgs gr0,brr \n"
|
|
" lduh%I2 %M2,%0 \n"
|
|
" movsg brr,%1 \n"
|
|
: "=r"(res), "=r"(brr)
|
|
: "m"(*(uint16_t *) addr));
|
|
*_res = res;
|
|
gdbstub_addr_unmap();
|
|
return likely(!brr);
|
|
}
|
|
|
|
static inline int gdbstub_write_word(void *addr, uint16_t val)
|
|
{
|
|
unsigned long brr;
|
|
|
|
if (!gdbstub_addr_map(addr))
|
|
return 0;
|
|
|
|
asm volatile(" movgs gr0,brr \n"
|
|
" sth%I2 %1,%M2 \n"
|
|
" movsg brr,%0 \n"
|
|
: "=r"(brr)
|
|
: "r"(val), "m"(*(uint16_t *) addr));
|
|
gdbstub_addr_unmap();
|
|
return likely(!brr);
|
|
}
|
|
|
|
static inline int gdbstub_read_byte(const void *addr, uint8_t *_res)
|
|
{
|
|
unsigned long brr;
|
|
uint8_t res;
|
|
|
|
if (!gdbstub_addr_map(addr))
|
|
return 0;
|
|
|
|
asm volatile(" movgs gr0,brr \n"
|
|
" ldub%I2 %M2,%0 \n"
|
|
" movsg brr,%1 \n"
|
|
: "=r"(res), "=r"(brr)
|
|
: "m"(*(uint8_t *) addr));
|
|
*_res = res;
|
|
gdbstub_addr_unmap();
|
|
return likely(!brr);
|
|
}
|
|
|
|
static inline int gdbstub_write_byte(void *addr, uint8_t val)
|
|
{
|
|
unsigned long brr;
|
|
|
|
if (!gdbstub_addr_map(addr))
|
|
return 0;
|
|
|
|
asm volatile(" movgs gr0,brr \n"
|
|
" stb%I2 %1,%M2 \n"
|
|
" movsg brr,%0 \n"
|
|
: "=r"(brr)
|
|
: "r"(val), "m"(*(uint8_t *) addr));
|
|
gdbstub_addr_unmap();
|
|
return likely(!brr);
|
|
}
|
|
|
|
static void __gdbstub_console_write(struct console *co, const char *p, unsigned n)
|
|
{
|
|
char outbuf[26];
|
|
int qty;
|
|
|
|
outbuf[0] = 'O';
|
|
|
|
while (n > 0) {
|
|
qty = 1;
|
|
|
|
while (n > 0 && qty < 20) {
|
|
mem2hex(p, outbuf + qty, 2, 0);
|
|
qty += 2;
|
|
if (*p == 0x0a) {
|
|
outbuf[qty++] = '0';
|
|
outbuf[qty++] = 'd';
|
|
}
|
|
p++;
|
|
n--;
|
|
}
|
|
|
|
outbuf[qty] = 0;
|
|
gdbstub_send_packet(outbuf);
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
void debug_to_serial(const char *p, int n)
|
|
{
|
|
gdbstub_console_write(NULL,p,n);
|
|
}
|
|
#endif
|
|
|
|
#ifdef CONFIG_GDBSTUB_CONSOLE
|
|
|
|
static kdev_t gdbstub_console_dev(struct console *con)
|
|
{
|
|
return MKDEV(1,3); /* /dev/null */
|
|
}
|
|
|
|
static struct console gdbstub_console = {
|
|
.name = "gdb",
|
|
.write = gdbstub_console_write, /* in break.S */
|
|
.device = gdbstub_console_dev,
|
|
.flags = CON_PRINTBUFFER,
|
|
.index = -1,
|
|
};
|
|
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* Convert the memory pointed to by mem into hex, placing result in buf.
|
|
* - if successful, return a pointer to the last char put in buf (NUL)
|
|
* - in case of mem fault, return NULL
|
|
* may_fault is non-zero if we are reading from arbitrary memory, but is currently
|
|
* not used.
|
|
*/
|
|
static unsigned char *mem2hex(const void *_mem, char *buf, int count, int may_fault)
|
|
{
|
|
const uint8_t *mem = _mem;
|
|
uint8_t ch[4] __attribute__((aligned(4)));
|
|
|
|
if ((uint32_t)mem&1 && count>=1) {
|
|
if (!gdbstub_read_byte(mem,ch))
|
|
return NULL;
|
|
*buf++ = hexchars[ch[0] >> 4];
|
|
*buf++ = hexchars[ch[0] & 0xf];
|
|
mem++;
|
|
count--;
|
|
}
|
|
|
|
if ((uint32_t)mem&3 && count>=2) {
|
|
if (!gdbstub_read_word(mem,(uint16_t *)ch))
|
|
return NULL;
|
|
*buf++ = hexchars[ch[0] >> 4];
|
|
*buf++ = hexchars[ch[0] & 0xf];
|
|
*buf++ = hexchars[ch[1] >> 4];
|
|
*buf++ = hexchars[ch[1] & 0xf];
|
|
mem += 2;
|
|
count -= 2;
|
|
}
|
|
|
|
while (count>=4) {
|
|
if (!gdbstub_read_dword(mem,(uint32_t *)ch))
|
|
return NULL;
|
|
*buf++ = hexchars[ch[0] >> 4];
|
|
*buf++ = hexchars[ch[0] & 0xf];
|
|
*buf++ = hexchars[ch[1] >> 4];
|
|
*buf++ = hexchars[ch[1] & 0xf];
|
|
*buf++ = hexchars[ch[2] >> 4];
|
|
*buf++ = hexchars[ch[2] & 0xf];
|
|
*buf++ = hexchars[ch[3] >> 4];
|
|
*buf++ = hexchars[ch[3] & 0xf];
|
|
mem += 4;
|
|
count -= 4;
|
|
}
|
|
|
|
if (count>=2) {
|
|
if (!gdbstub_read_word(mem,(uint16_t *)ch))
|
|
return NULL;
|
|
*buf++ = hexchars[ch[0] >> 4];
|
|
*buf++ = hexchars[ch[0] & 0xf];
|
|
*buf++ = hexchars[ch[1] >> 4];
|
|
*buf++ = hexchars[ch[1] & 0xf];
|
|
mem += 2;
|
|
count -= 2;
|
|
}
|
|
|
|
if (count>=1) {
|
|
if (!gdbstub_read_byte(mem,ch))
|
|
return NULL;
|
|
*buf++ = hexchars[ch[0] >> 4];
|
|
*buf++ = hexchars[ch[0] & 0xf];
|
|
}
|
|
|
|
*buf = 0;
|
|
|
|
return buf;
|
|
} /* end mem2hex() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* convert the hex array pointed to by buf into binary to be placed in mem
|
|
* return a pointer to the character AFTER the last byte of buffer consumed
|
|
*/
|
|
static char *hex2mem(const char *buf, void *_mem, int count)
|
|
{
|
|
uint8_t *mem = _mem;
|
|
union {
|
|
uint32_t l;
|
|
uint16_t w;
|
|
uint8_t b[4];
|
|
} ch;
|
|
|
|
if ((u32)mem&1 && count>=1) {
|
|
ch.b[0] = hex(*buf++) << 4;
|
|
ch.b[0] |= hex(*buf++);
|
|
if (!gdbstub_write_byte(mem,ch.b[0]))
|
|
return NULL;
|
|
mem++;
|
|
count--;
|
|
}
|
|
|
|
if ((u32)mem&3 && count>=2) {
|
|
ch.b[0] = hex(*buf++) << 4;
|
|
ch.b[0] |= hex(*buf++);
|
|
ch.b[1] = hex(*buf++) << 4;
|
|
ch.b[1] |= hex(*buf++);
|
|
if (!gdbstub_write_word(mem,ch.w))
|
|
return NULL;
|
|
mem += 2;
|
|
count -= 2;
|
|
}
|
|
|
|
while (count>=4) {
|
|
ch.b[0] = hex(*buf++) << 4;
|
|
ch.b[0] |= hex(*buf++);
|
|
ch.b[1] = hex(*buf++) << 4;
|
|
ch.b[1] |= hex(*buf++);
|
|
ch.b[2] = hex(*buf++) << 4;
|
|
ch.b[2] |= hex(*buf++);
|
|
ch.b[3] = hex(*buf++) << 4;
|
|
ch.b[3] |= hex(*buf++);
|
|
if (!gdbstub_write_dword(mem,ch.l))
|
|
return NULL;
|
|
mem += 4;
|
|
count -= 4;
|
|
}
|
|
|
|
if (count>=2) {
|
|
ch.b[0] = hex(*buf++) << 4;
|
|
ch.b[0] |= hex(*buf++);
|
|
ch.b[1] = hex(*buf++) << 4;
|
|
ch.b[1] |= hex(*buf++);
|
|
if (!gdbstub_write_word(mem,ch.w))
|
|
return NULL;
|
|
mem += 2;
|
|
count -= 2;
|
|
}
|
|
|
|
if (count>=1) {
|
|
ch.b[0] = hex(*buf++) << 4;
|
|
ch.b[0] |= hex(*buf++);
|
|
if (!gdbstub_write_byte(mem,ch.b[0]))
|
|
return NULL;
|
|
}
|
|
|
|
return (char *) buf;
|
|
} /* end hex2mem() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* This table contains the mapping between FRV TBR.TT exception codes,
|
|
* and signals, which are primarily what GDB understands. It also
|
|
* indicates which hardware traps we need to commandeer when
|
|
* initializing the stub.
|
|
*/
|
|
static const struct brr_to_sig_map {
|
|
unsigned long brr_mask; /* BRR bitmask */
|
|
unsigned long tbr_tt; /* TBR.TT code (in BRR.EBTT) */
|
|
unsigned int signo; /* Signal that we map this into */
|
|
} brr_to_sig_map[] = {
|
|
{ BRR_EB, TBR_TT_INSTR_ACC_ERROR, SIGSEGV },
|
|
{ BRR_EB, TBR_TT_ILLEGAL_INSTR, SIGILL },
|
|
{ BRR_EB, TBR_TT_PRIV_INSTR, SIGILL },
|
|
{ BRR_EB, TBR_TT_MP_EXCEPTION, SIGFPE },
|
|
{ BRR_EB, TBR_TT_DATA_ACC_ERROR, SIGSEGV },
|
|
{ BRR_EB, TBR_TT_DATA_STR_ERROR, SIGSEGV },
|
|
{ BRR_EB, TBR_TT_DIVISION_EXCEP, SIGFPE },
|
|
{ BRR_EB, TBR_TT_COMPOUND_EXCEP, SIGSEGV },
|
|
{ BRR_EB, TBR_TT_INTERRUPT_13, SIGALRM }, /* watchdog */
|
|
{ BRR_EB, TBR_TT_INTERRUPT_14, SIGINT }, /* GDB serial */
|
|
{ BRR_EB, TBR_TT_INTERRUPT_15, SIGQUIT }, /* NMI */
|
|
{ BRR_CB, 0, SIGUSR1 },
|
|
{ BRR_TB, 0, SIGUSR2 },
|
|
{ BRR_DBNEx, 0, SIGTRAP },
|
|
{ BRR_DBx, 0, SIGTRAP }, /* h/w watchpoint */
|
|
{ BRR_IBx, 0, SIGTRAP }, /* h/w breakpoint */
|
|
{ BRR_CBB, 0, SIGTRAP },
|
|
{ BRR_SB, 0, SIGTRAP },
|
|
{ BRR_ST, 0, SIGTRAP }, /* single step */
|
|
{ 0, 0, SIGHUP } /* default */
|
|
};
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* convert the FRV BRR register contents into a UNIX signal number
|
|
*/
|
|
static inline int gdbstub_compute_signal(unsigned long brr)
|
|
{
|
|
const struct brr_to_sig_map *map;
|
|
unsigned long tbr = (brr & BRR_EBTT) >> 12;
|
|
|
|
for (map = brr_to_sig_map; map->brr_mask; map++)
|
|
if (map->brr_mask & brr)
|
|
if (!map->tbr_tt || map->tbr_tt == tbr)
|
|
break;
|
|
|
|
return map->signo;
|
|
} /* end gdbstub_compute_signal() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* set a software breakpoint or a hardware breakpoint or watchpoint
|
|
*/
|
|
static int gdbstub_set_breakpoint(unsigned long type, unsigned long addr, unsigned long len)
|
|
{
|
|
unsigned long tmp;
|
|
int bkpt, loop, xloop;
|
|
|
|
union {
|
|
struct {
|
|
unsigned long mask0, mask1;
|
|
};
|
|
uint8_t bytes[8];
|
|
} dbmr;
|
|
|
|
//gdbstub_printk("setbkpt(%ld,%08lx,%ld)\n", type, addr, len);
|
|
|
|
switch (type) {
|
|
/* set software breakpoint */
|
|
case 0:
|
|
if (addr & 3 || len > 7*4)
|
|
return -EINVAL;
|
|
|
|
for (bkpt = 255; bkpt >= 0; bkpt--)
|
|
if (!gdbstub_bkpts[bkpt].addr)
|
|
break;
|
|
if (bkpt < 0)
|
|
return -ENOSPC;
|
|
|
|
for (loop = 0; loop < len/4; loop++)
|
|
if (!gdbstub_read_dword(&((uint32_t *) addr)[loop],
|
|
&gdbstub_bkpts[bkpt].originsns[loop]))
|
|
return -EFAULT;
|
|
|
|
for (loop = 0; loop < len/4; loop++)
|
|
if (!gdbstub_write_dword(&((uint32_t *) addr)[loop],
|
|
BREAK_INSN)
|
|
) {
|
|
/* need to undo the changes if possible */
|
|
for (xloop = 0; xloop < loop; xloop++)
|
|
gdbstub_write_dword(&((uint32_t *) addr)[xloop],
|
|
gdbstub_bkpts[bkpt].originsns[xloop]);
|
|
return -EFAULT;
|
|
}
|
|
|
|
gdbstub_bkpts[bkpt].addr = addr;
|
|
gdbstub_bkpts[bkpt].len = len;
|
|
|
|
#if 0
|
|
gdbstub_printk("Set BKPT[%02x]: %08lx #%d {%04x, %04x} -> { %04x, %04x }\n",
|
|
bkpt,
|
|
gdbstub_bkpts[bkpt].addr,
|
|
gdbstub_bkpts[bkpt].len,
|
|
gdbstub_bkpts[bkpt].originsns[0],
|
|
gdbstub_bkpts[bkpt].originsns[1],
|
|
((uint32_t *) addr)[0],
|
|
((uint32_t *) addr)[1]
|
|
);
|
|
#endif
|
|
return 0;
|
|
|
|
/* set hardware breakpoint */
|
|
case 1:
|
|
if (addr & 3 || len != 4)
|
|
return -EINVAL;
|
|
|
|
if (!(__debug_regs->dcr & DCR_IBE0)) {
|
|
//gdbstub_printk("set h/w break 0: %08lx\n", addr);
|
|
__debug_regs->dcr |= DCR_IBE0;
|
|
asm volatile("movgs %0,ibar0" : : "r"(addr));
|
|
return 0;
|
|
}
|
|
|
|
if (!(__debug_regs->dcr & DCR_IBE1)) {
|
|
//gdbstub_printk("set h/w break 1: %08lx\n", addr);
|
|
__debug_regs->dcr |= DCR_IBE1;
|
|
asm volatile("movgs %0,ibar1" : : "r"(addr));
|
|
return 0;
|
|
}
|
|
|
|
if (!(__debug_regs->dcr & DCR_IBE2)) {
|
|
//gdbstub_printk("set h/w break 2: %08lx\n", addr);
|
|
__debug_regs->dcr |= DCR_IBE2;
|
|
asm volatile("movgs %0,ibar2" : : "r"(addr));
|
|
return 0;
|
|
}
|
|
|
|
if (!(__debug_regs->dcr & DCR_IBE3)) {
|
|
//gdbstub_printk("set h/w break 3: %08lx\n", addr);
|
|
__debug_regs->dcr |= DCR_IBE3;
|
|
asm volatile("movgs %0,ibar3" : : "r"(addr));
|
|
return 0;
|
|
}
|
|
|
|
return -ENOSPC;
|
|
|
|
/* set data read/write/access watchpoint */
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
if ((addr & ~7) != ((addr + len - 1) & ~7))
|
|
return -EINVAL;
|
|
|
|
tmp = addr & 7;
|
|
|
|
memset(dbmr.bytes, 0xff, sizeof(dbmr.bytes));
|
|
for (loop = 0; loop < len; loop++)
|
|
dbmr.bytes[tmp + loop] = 0;
|
|
|
|
addr &= ~7;
|
|
|
|
if (!(__debug_regs->dcr & (DCR_DRBE0|DCR_DWBE0))) {
|
|
//gdbstub_printk("set h/w watchpoint 0 type %ld: %08lx\n", type, addr);
|
|
tmp = type==2 ? DCR_DWBE0 : type==3 ? DCR_DRBE0 : DCR_DRBE0|DCR_DWBE0;
|
|
__debug_regs->dcr |= tmp;
|
|
asm volatile(" movgs %0,dbar0 \n"
|
|
" movgs %1,dbmr00 \n"
|
|
" movgs %2,dbmr01 \n"
|
|
" movgs gr0,dbdr00 \n"
|
|
" movgs gr0,dbdr01 \n"
|
|
: : "r"(addr), "r"(dbmr.mask0), "r"(dbmr.mask1));
|
|
return 0;
|
|
}
|
|
|
|
if (!(__debug_regs->dcr & (DCR_DRBE1|DCR_DWBE1))) {
|
|
//gdbstub_printk("set h/w watchpoint 1 type %ld: %08lx\n", type, addr);
|
|
tmp = type==2 ? DCR_DWBE1 : type==3 ? DCR_DRBE1 : DCR_DRBE1|DCR_DWBE1;
|
|
__debug_regs->dcr |= tmp;
|
|
asm volatile(" movgs %0,dbar1 \n"
|
|
" movgs %1,dbmr10 \n"
|
|
" movgs %2,dbmr11 \n"
|
|
" movgs gr0,dbdr10 \n"
|
|
" movgs gr0,dbdr11 \n"
|
|
: : "r"(addr), "r"(dbmr.mask0), "r"(dbmr.mask1));
|
|
return 0;
|
|
}
|
|
|
|
return -ENOSPC;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
} /* end gdbstub_set_breakpoint() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* clear a breakpoint or watchpoint
|
|
*/
|
|
int gdbstub_clear_breakpoint(unsigned long type, unsigned long addr, unsigned long len)
|
|
{
|
|
unsigned long tmp;
|
|
int bkpt, loop;
|
|
|
|
union {
|
|
struct {
|
|
unsigned long mask0, mask1;
|
|
};
|
|
uint8_t bytes[8];
|
|
} dbmr;
|
|
|
|
//gdbstub_printk("clearbkpt(%ld,%08lx,%ld)\n", type, addr, len);
|
|
|
|
switch (type) {
|
|
/* clear software breakpoint */
|
|
case 0:
|
|
for (bkpt = 255; bkpt >= 0; bkpt--)
|
|
if (gdbstub_bkpts[bkpt].addr == addr && gdbstub_bkpts[bkpt].len == len)
|
|
break;
|
|
if (bkpt < 0)
|
|
return -ENOENT;
|
|
|
|
gdbstub_bkpts[bkpt].addr = 0;
|
|
|
|
for (loop = 0; loop < len/4; loop++)
|
|
if (!gdbstub_write_dword(&((uint32_t *) addr)[loop],
|
|
gdbstub_bkpts[bkpt].originsns[loop]))
|
|
return -EFAULT;
|
|
return 0;
|
|
|
|
/* clear hardware breakpoint */
|
|
case 1:
|
|
if (addr & 3 || len != 4)
|
|
return -EINVAL;
|
|
|
|
#define __get_ibar(X) ({ unsigned long x; asm volatile("movsg ibar"#X",%0" : "=r"(x)); x; })
|
|
|
|
if (__debug_regs->dcr & DCR_IBE0 && __get_ibar(0) == addr) {
|
|
//gdbstub_printk("clear h/w break 0: %08lx\n", addr);
|
|
__debug_regs->dcr &= ~DCR_IBE0;
|
|
asm volatile("movgs gr0,ibar0");
|
|
return 0;
|
|
}
|
|
|
|
if (__debug_regs->dcr & DCR_IBE1 && __get_ibar(1) == addr) {
|
|
//gdbstub_printk("clear h/w break 1: %08lx\n", addr);
|
|
__debug_regs->dcr &= ~DCR_IBE1;
|
|
asm volatile("movgs gr0,ibar1");
|
|
return 0;
|
|
}
|
|
|
|
if (__debug_regs->dcr & DCR_IBE2 && __get_ibar(2) == addr) {
|
|
//gdbstub_printk("clear h/w break 2: %08lx\n", addr);
|
|
__debug_regs->dcr &= ~DCR_IBE2;
|
|
asm volatile("movgs gr0,ibar2");
|
|
return 0;
|
|
}
|
|
|
|
if (__debug_regs->dcr & DCR_IBE3 && __get_ibar(3) == addr) {
|
|
//gdbstub_printk("clear h/w break 3: %08lx\n", addr);
|
|
__debug_regs->dcr &= ~DCR_IBE3;
|
|
asm volatile("movgs gr0,ibar3");
|
|
return 0;
|
|
}
|
|
|
|
return -EINVAL;
|
|
|
|
/* clear data read/write/access watchpoint */
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
if ((addr & ~7) != ((addr + len - 1) & ~7))
|
|
return -EINVAL;
|
|
|
|
tmp = addr & 7;
|
|
|
|
memset(dbmr.bytes, 0xff, sizeof(dbmr.bytes));
|
|
for (loop = 0; loop < len; loop++)
|
|
dbmr.bytes[tmp + loop] = 0;
|
|
|
|
addr &= ~7;
|
|
|
|
#define __get_dbar(X) ({ unsigned long x; asm volatile("movsg dbar"#X",%0" : "=r"(x)); x; })
|
|
#define __get_dbmr0(X) ({ unsigned long x; asm volatile("movsg dbmr"#X"0,%0" : "=r"(x)); x; })
|
|
#define __get_dbmr1(X) ({ unsigned long x; asm volatile("movsg dbmr"#X"1,%0" : "=r"(x)); x; })
|
|
|
|
/* consider DBAR 0 */
|
|
tmp = type==2 ? DCR_DWBE0 : type==3 ? DCR_DRBE0 : DCR_DRBE0|DCR_DWBE0;
|
|
|
|
if ((__debug_regs->dcr & (DCR_DRBE0|DCR_DWBE0)) != tmp ||
|
|
__get_dbar(0) != addr ||
|
|
__get_dbmr0(0) != dbmr.mask0 ||
|
|
__get_dbmr1(0) != dbmr.mask1)
|
|
goto skip_dbar0;
|
|
|
|
//gdbstub_printk("clear h/w watchpoint 0 type %ld: %08lx\n", type, addr);
|
|
__debug_regs->dcr &= ~(DCR_DRBE0|DCR_DWBE0);
|
|
asm volatile(" movgs gr0,dbar0 \n"
|
|
" movgs gr0,dbmr00 \n"
|
|
" movgs gr0,dbmr01 \n"
|
|
" movgs gr0,dbdr00 \n"
|
|
" movgs gr0,dbdr01 \n");
|
|
return 0;
|
|
|
|
skip_dbar0:
|
|
/* consider DBAR 0 */
|
|
tmp = type==2 ? DCR_DWBE1 : type==3 ? DCR_DRBE1 : DCR_DRBE1|DCR_DWBE1;
|
|
|
|
if ((__debug_regs->dcr & (DCR_DRBE1|DCR_DWBE1)) != tmp ||
|
|
__get_dbar(1) != addr ||
|
|
__get_dbmr0(1) != dbmr.mask0 ||
|
|
__get_dbmr1(1) != dbmr.mask1)
|
|
goto skip_dbar1;
|
|
|
|
//gdbstub_printk("clear h/w watchpoint 1 type %ld: %08lx\n", type, addr);
|
|
__debug_regs->dcr &= ~(DCR_DRBE1|DCR_DWBE1);
|
|
asm volatile(" movgs gr0,dbar1 \n"
|
|
" movgs gr0,dbmr10 \n"
|
|
" movgs gr0,dbmr11 \n"
|
|
" movgs gr0,dbdr10 \n"
|
|
" movgs gr0,dbdr11 \n");
|
|
return 0;
|
|
|
|
skip_dbar1:
|
|
return -ENOSPC;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
} /* end gdbstub_clear_breakpoint() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* check a for an internal software breakpoint, and wind the PC back if necessary
|
|
*/
|
|
static void gdbstub_check_breakpoint(void)
|
|
{
|
|
unsigned long addr = __debug_frame->pc - 4;
|
|
int bkpt;
|
|
|
|
for (bkpt = 255; bkpt >= 0; bkpt--)
|
|
if (gdbstub_bkpts[bkpt].addr == addr)
|
|
break;
|
|
if (bkpt >= 0)
|
|
__debug_frame->pc = addr;
|
|
|
|
//gdbstub_printk("alter pc [%d] %08lx\n", bkpt, __debug_frame->pc);
|
|
|
|
} /* end gdbstub_check_breakpoint() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
*
|
|
*/
|
|
static void __attribute__((unused)) gdbstub_show_regs(void)
|
|
{
|
|
uint32_t *reg;
|
|
int loop;
|
|
|
|
gdbstub_printk("\n");
|
|
|
|
gdbstub_printk("Frame: @%p [%s]\n",
|
|
__debug_frame,
|
|
__debug_frame->psr & PSR_S ? "kernel" : "user");
|
|
|
|
reg = (uint32_t *) __debug_frame;
|
|
for (loop = 0; loop < REG__END; loop++) {
|
|
printk("%s %08x", regnames[loop + 0], reg[loop + 0]);
|
|
|
|
if (loop == REG__END - 1 || loop % 5 == 4)
|
|
printk("\n");
|
|
else
|
|
printk(" | ");
|
|
}
|
|
|
|
gdbstub_printk("Process %s (pid: %d)\n", current->comm, current->pid);
|
|
} /* end gdbstub_show_regs() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* dump debugging regs
|
|
*/
|
|
static void __attribute__((unused)) gdbstub_dump_debugregs(void)
|
|
{
|
|
unsigned long x;
|
|
|
|
x = __debug_regs->dcr;
|
|
gdbstub_printk("DCR %08lx ", x);
|
|
|
|
x = __debug_regs->brr;
|
|
gdbstub_printk("BRR %08lx\n", x);
|
|
|
|
gdbstub_printk("IBAR0 %08lx ", __get_ibar(0));
|
|
gdbstub_printk("IBAR1 %08lx ", __get_ibar(1));
|
|
gdbstub_printk("IBAR2 %08lx ", __get_ibar(2));
|
|
gdbstub_printk("IBAR3 %08lx\n", __get_ibar(3));
|
|
|
|
gdbstub_printk("DBAR0 %08lx ", __get_dbar(0));
|
|
gdbstub_printk("DBMR00 %08lx ", __get_dbmr0(0));
|
|
gdbstub_printk("DBMR01 %08lx\n", __get_dbmr1(0));
|
|
|
|
gdbstub_printk("DBAR1 %08lx ", __get_dbar(1));
|
|
gdbstub_printk("DBMR10 %08lx ", __get_dbmr0(1));
|
|
gdbstub_printk("DBMR11 %08lx\n", __get_dbmr1(1));
|
|
|
|
gdbstub_printk("\n");
|
|
} /* end gdbstub_dump_debugregs() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* dump the MMU state into a structure so that it can be accessed with GDB
|
|
*/
|
|
void gdbstub_get_mmu_state(void)
|
|
{
|
|
asm volatile("movsg hsr0,%0" : "=r"(__debug_mmu.regs.hsr0));
|
|
asm volatile("movsg pcsr,%0" : "=r"(__debug_mmu.regs.pcsr));
|
|
asm volatile("movsg esr0,%0" : "=r"(__debug_mmu.regs.esr0));
|
|
asm volatile("movsg ear0,%0" : "=r"(__debug_mmu.regs.ear0));
|
|
asm volatile("movsg epcr0,%0" : "=r"(__debug_mmu.regs.epcr0));
|
|
|
|
/* read the protection / SAT registers */
|
|
__debug_mmu.iamr[0].L = __get_IAMLR(0);
|
|
__debug_mmu.iamr[0].P = __get_IAMPR(0);
|
|
__debug_mmu.iamr[1].L = __get_IAMLR(1);
|
|
__debug_mmu.iamr[1].P = __get_IAMPR(1);
|
|
__debug_mmu.iamr[2].L = __get_IAMLR(2);
|
|
__debug_mmu.iamr[2].P = __get_IAMPR(2);
|
|
__debug_mmu.iamr[3].L = __get_IAMLR(3);
|
|
__debug_mmu.iamr[3].P = __get_IAMPR(3);
|
|
__debug_mmu.iamr[4].L = __get_IAMLR(4);
|
|
__debug_mmu.iamr[4].P = __get_IAMPR(4);
|
|
__debug_mmu.iamr[5].L = __get_IAMLR(5);
|
|
__debug_mmu.iamr[5].P = __get_IAMPR(5);
|
|
__debug_mmu.iamr[6].L = __get_IAMLR(6);
|
|
__debug_mmu.iamr[6].P = __get_IAMPR(6);
|
|
__debug_mmu.iamr[7].L = __get_IAMLR(7);
|
|
__debug_mmu.iamr[7].P = __get_IAMPR(7);
|
|
__debug_mmu.iamr[8].L = __get_IAMLR(8);
|
|
__debug_mmu.iamr[8].P = __get_IAMPR(8);
|
|
__debug_mmu.iamr[9].L = __get_IAMLR(9);
|
|
__debug_mmu.iamr[9].P = __get_IAMPR(9);
|
|
__debug_mmu.iamr[10].L = __get_IAMLR(10);
|
|
__debug_mmu.iamr[10].P = __get_IAMPR(10);
|
|
__debug_mmu.iamr[11].L = __get_IAMLR(11);
|
|
__debug_mmu.iamr[11].P = __get_IAMPR(11);
|
|
__debug_mmu.iamr[12].L = __get_IAMLR(12);
|
|
__debug_mmu.iamr[12].P = __get_IAMPR(12);
|
|
__debug_mmu.iamr[13].L = __get_IAMLR(13);
|
|
__debug_mmu.iamr[13].P = __get_IAMPR(13);
|
|
__debug_mmu.iamr[14].L = __get_IAMLR(14);
|
|
__debug_mmu.iamr[14].P = __get_IAMPR(14);
|
|
__debug_mmu.iamr[15].L = __get_IAMLR(15);
|
|
__debug_mmu.iamr[15].P = __get_IAMPR(15);
|
|
|
|
__debug_mmu.damr[0].L = __get_DAMLR(0);
|
|
__debug_mmu.damr[0].P = __get_DAMPR(0);
|
|
__debug_mmu.damr[1].L = __get_DAMLR(1);
|
|
__debug_mmu.damr[1].P = __get_DAMPR(1);
|
|
__debug_mmu.damr[2].L = __get_DAMLR(2);
|
|
__debug_mmu.damr[2].P = __get_DAMPR(2);
|
|
__debug_mmu.damr[3].L = __get_DAMLR(3);
|
|
__debug_mmu.damr[3].P = __get_DAMPR(3);
|
|
__debug_mmu.damr[4].L = __get_DAMLR(4);
|
|
__debug_mmu.damr[4].P = __get_DAMPR(4);
|
|
__debug_mmu.damr[5].L = __get_DAMLR(5);
|
|
__debug_mmu.damr[5].P = __get_DAMPR(5);
|
|
__debug_mmu.damr[6].L = __get_DAMLR(6);
|
|
__debug_mmu.damr[6].P = __get_DAMPR(6);
|
|
__debug_mmu.damr[7].L = __get_DAMLR(7);
|
|
__debug_mmu.damr[7].P = __get_DAMPR(7);
|
|
__debug_mmu.damr[8].L = __get_DAMLR(8);
|
|
__debug_mmu.damr[8].P = __get_DAMPR(8);
|
|
__debug_mmu.damr[9].L = __get_DAMLR(9);
|
|
__debug_mmu.damr[9].P = __get_DAMPR(9);
|
|
__debug_mmu.damr[10].L = __get_DAMLR(10);
|
|
__debug_mmu.damr[10].P = __get_DAMPR(10);
|
|
__debug_mmu.damr[11].L = __get_DAMLR(11);
|
|
__debug_mmu.damr[11].P = __get_DAMPR(11);
|
|
__debug_mmu.damr[12].L = __get_DAMLR(12);
|
|
__debug_mmu.damr[12].P = __get_DAMPR(12);
|
|
__debug_mmu.damr[13].L = __get_DAMLR(13);
|
|
__debug_mmu.damr[13].P = __get_DAMPR(13);
|
|
__debug_mmu.damr[14].L = __get_DAMLR(14);
|
|
__debug_mmu.damr[14].P = __get_DAMPR(14);
|
|
__debug_mmu.damr[15].L = __get_DAMLR(15);
|
|
__debug_mmu.damr[15].P = __get_DAMPR(15);
|
|
|
|
#ifdef CONFIG_MMU
|
|
do {
|
|
/* read the DAT entries from the TLB */
|
|
struct __debug_amr *p;
|
|
int loop;
|
|
|
|
asm volatile("movsg tplr,%0" : "=r"(__debug_mmu.regs.tplr));
|
|
asm volatile("movsg tppr,%0" : "=r"(__debug_mmu.regs.tppr));
|
|
asm volatile("movsg tpxr,%0" : "=r"(__debug_mmu.regs.tpxr));
|
|
asm volatile("movsg cxnr,%0" : "=r"(__debug_mmu.regs.cxnr));
|
|
|
|
p = __debug_mmu.tlb;
|
|
|
|
/* way 0 */
|
|
asm volatile("movgs %0,tpxr" :: "r"(0 << TPXR_WAY_SHIFT));
|
|
for (loop = 0; loop < 64; loop++) {
|
|
asm volatile("tlbpr %0,gr0,#1,#0" :: "r"(loop << PAGE_SHIFT));
|
|
asm volatile("movsg tplr,%0" : "=r"(p->L));
|
|
asm volatile("movsg tppr,%0" : "=r"(p->P));
|
|
p++;
|
|
}
|
|
|
|
/* way 1 */
|
|
asm volatile("movgs %0,tpxr" :: "r"(1 << TPXR_WAY_SHIFT));
|
|
for (loop = 0; loop < 64; loop++) {
|
|
asm volatile("tlbpr %0,gr0,#1,#0" :: "r"(loop << PAGE_SHIFT));
|
|
asm volatile("movsg tplr,%0" : "=r"(p->L));
|
|
asm volatile("movsg tppr,%0" : "=r"(p->P));
|
|
p++;
|
|
}
|
|
|
|
asm volatile("movgs %0,tplr" :: "r"(__debug_mmu.regs.tplr));
|
|
asm volatile("movgs %0,tppr" :: "r"(__debug_mmu.regs.tppr));
|
|
asm volatile("movgs %0,tpxr" :: "r"(__debug_mmu.regs.tpxr));
|
|
} while(0);
|
|
#endif
|
|
|
|
} /* end gdbstub_get_mmu_state() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* handle event interception and GDB remote protocol processing
|
|
* - on entry:
|
|
* PSR.ET==0, PSR.S==1 and the CPU is in debug mode
|
|
* __debug_frame points to the saved registers
|
|
* __frame points to the kernel mode exception frame, if it was in kernel
|
|
* mode when the break happened
|
|
*/
|
|
void gdbstub(int sigval)
|
|
{
|
|
unsigned long addr, length, loop, dbar, temp, temp2, temp3;
|
|
uint32_t zero;
|
|
char *ptr;
|
|
int flush_cache = 0;
|
|
|
|
LEDS(0x5000);
|
|
|
|
if (sigval < 0) {
|
|
#ifndef CONFIG_GDBSTUB_IMMEDIATE
|
|
/* return immediately if GDB immediate activation option not set */
|
|
return;
|
|
#else
|
|
sigval = SIGINT;
|
|
#endif
|
|
}
|
|
|
|
save_user_regs(&__break_user_context);
|
|
|
|
#if 0
|
|
gdbstub_printk("--> gdbstub() %08x %p %08x %08x\n",
|
|
__debug_frame->pc,
|
|
__debug_frame,
|
|
__debug_regs->brr,
|
|
__debug_regs->bpsr);
|
|
// gdbstub_show_regs();
|
|
#endif
|
|
|
|
LEDS(0x5001);
|
|
|
|
/* if we were interrupted by input on the serial gdbstub serial port,
|
|
* restore the context prior to the interrupt so that we return to that
|
|
* directly
|
|
*/
|
|
temp = (unsigned long) __entry_kerneltrap_table;
|
|
temp2 = (unsigned long) __entry_usertrap_table;
|
|
temp3 = __debug_frame->pc & ~15;
|
|
|
|
if (temp3 == temp + TBR_TT_INTERRUPT_15 ||
|
|
temp3 == temp2 + TBR_TT_INTERRUPT_15
|
|
) {
|
|
asm volatile("movsg pcsr,%0" : "=r"(__debug_frame->pc));
|
|
__debug_frame->psr |= PSR_ET;
|
|
__debug_frame->psr &= ~PSR_S;
|
|
if (__debug_frame->psr & PSR_PS)
|
|
__debug_frame->psr |= PSR_S;
|
|
__debug_regs->brr = (__debug_frame->tbr & TBR_TT) << 12;
|
|
__debug_regs->brr |= BRR_EB;
|
|
sigval = SIGINT;
|
|
}
|
|
|
|
/* handle the decrement timer going off (FR451 only) */
|
|
if (temp3 == temp + TBR_TT_DECREMENT_TIMER ||
|
|
temp3 == temp2 + TBR_TT_DECREMENT_TIMER
|
|
) {
|
|
asm volatile("movgs %0,timerd" :: "r"(10000000));
|
|
asm volatile("movsg pcsr,%0" : "=r"(__debug_frame->pc));
|
|
__debug_frame->psr |= PSR_ET;
|
|
__debug_frame->psr &= ~PSR_S;
|
|
if (__debug_frame->psr & PSR_PS)
|
|
__debug_frame->psr |= PSR_S;
|
|
__debug_regs->brr = (__debug_frame->tbr & TBR_TT) << 12;
|
|
__debug_regs->brr |= BRR_EB;
|
|
sigval = SIGXCPU;;
|
|
}
|
|
|
|
LEDS(0x5002);
|
|
|
|
/* after a BREAK insn, the PC lands on the far side of it */
|
|
if (__debug_regs->brr & BRR_SB)
|
|
gdbstub_check_breakpoint();
|
|
|
|
LEDS(0x5003);
|
|
|
|
/* handle attempts to write console data via GDB "O" commands */
|
|
if (__debug_frame->pc == (unsigned long) gdbstub_console_write + 4) {
|
|
__gdbstub_console_write((struct console *) __debug_frame->gr8,
|
|
(const char *) __debug_frame->gr9,
|
|
(unsigned) __debug_frame->gr10);
|
|
goto done;
|
|
}
|
|
|
|
if (gdbstub_rx_unget) {
|
|
sigval = SIGINT;
|
|
goto packet_waiting;
|
|
}
|
|
|
|
if (!sigval)
|
|
sigval = gdbstub_compute_signal(__debug_regs->brr);
|
|
|
|
LEDS(0x5004);
|
|
|
|
/* send a message to the debugger's user saying what happened if it may
|
|
* not be clear cut (we can't map exceptions onto signals properly)
|
|
*/
|
|
if (sigval != SIGINT && sigval != SIGTRAP && sigval != SIGILL) {
|
|
static const char title[] = "Break ";
|
|
static const char crlf[] = "\r\n";
|
|
unsigned long brr = __debug_regs->brr;
|
|
char hx;
|
|
|
|
ptr = output_buffer;
|
|
*ptr++ = 'O';
|
|
ptr = mem2hex(title, ptr, sizeof(title) - 1,0);
|
|
|
|
hx = hexchars[(brr & 0xf0000000) >> 28];
|
|
*ptr++ = hexchars[hx >> 4]; *ptr++ = hexchars[hx & 0xf];
|
|
hx = hexchars[(brr & 0x0f000000) >> 24];
|
|
*ptr++ = hexchars[hx >> 4]; *ptr++ = hexchars[hx & 0xf];
|
|
hx = hexchars[(brr & 0x00f00000) >> 20];
|
|
*ptr++ = hexchars[hx >> 4]; *ptr++ = hexchars[hx & 0xf];
|
|
hx = hexchars[(brr & 0x000f0000) >> 16];
|
|
*ptr++ = hexchars[hx >> 4]; *ptr++ = hexchars[hx & 0xf];
|
|
hx = hexchars[(brr & 0x0000f000) >> 12];
|
|
*ptr++ = hexchars[hx >> 4]; *ptr++ = hexchars[hx & 0xf];
|
|
hx = hexchars[(brr & 0x00000f00) >> 8];
|
|
*ptr++ = hexchars[hx >> 4]; *ptr++ = hexchars[hx & 0xf];
|
|
hx = hexchars[(brr & 0x000000f0) >> 4];
|
|
*ptr++ = hexchars[hx >> 4]; *ptr++ = hexchars[hx & 0xf];
|
|
hx = hexchars[(brr & 0x0000000f)];
|
|
*ptr++ = hexchars[hx >> 4]; *ptr++ = hexchars[hx & 0xf];
|
|
|
|
ptr = mem2hex(crlf, ptr, sizeof(crlf) - 1, 0);
|
|
*ptr = 0;
|
|
gdbstub_send_packet(output_buffer); /* send it off... */
|
|
}
|
|
|
|
LEDS(0x5005);
|
|
|
|
/* tell the debugger that an exception has occurred */
|
|
ptr = output_buffer;
|
|
|
|
/* Send trap type (converted to signal) */
|
|
*ptr++ = 'T';
|
|
*ptr++ = hexchars[sigval >> 4];
|
|
*ptr++ = hexchars[sigval & 0xf];
|
|
|
|
/* Send Error PC */
|
|
*ptr++ = hexchars[GDB_REG_PC >> 4];
|
|
*ptr++ = hexchars[GDB_REG_PC & 0xf];
|
|
*ptr++ = ':';
|
|
ptr = mem2hex(&__debug_frame->pc, ptr, 4, 0);
|
|
*ptr++ = ';';
|
|
|
|
/*
|
|
* Send frame pointer
|
|
*/
|
|
*ptr++ = hexchars[GDB_REG_FP >> 4];
|
|
*ptr++ = hexchars[GDB_REG_FP & 0xf];
|
|
*ptr++ = ':';
|
|
ptr = mem2hex(&__debug_frame->fp, ptr, 4, 0);
|
|
*ptr++ = ';';
|
|
|
|
/*
|
|
* Send stack pointer
|
|
*/
|
|
*ptr++ = hexchars[GDB_REG_SP >> 4];
|
|
*ptr++ = hexchars[GDB_REG_SP & 0xf];
|
|
*ptr++ = ':';
|
|
ptr = mem2hex(&__debug_frame->sp, ptr, 4, 0);
|
|
*ptr++ = ';';
|
|
|
|
*ptr++ = 0;
|
|
gdbstub_send_packet(output_buffer); /* send it off... */
|
|
|
|
LEDS(0x5006);
|
|
|
|
packet_waiting:
|
|
gdbstub_get_mmu_state();
|
|
|
|
/* wait for input from remote GDB */
|
|
while (1) {
|
|
output_buffer[0] = 0;
|
|
|
|
LEDS(0x5007);
|
|
gdbstub_recv_packet(input_buffer);
|
|
LEDS(0x5600 | input_buffer[0]);
|
|
|
|
switch (input_buffer[0]) {
|
|
/* request repeat of last signal number */
|
|
case '?':
|
|
output_buffer[0] = 'S';
|
|
output_buffer[1] = hexchars[sigval >> 4];
|
|
output_buffer[2] = hexchars[sigval & 0xf];
|
|
output_buffer[3] = 0;
|
|
break;
|
|
|
|
case 'd':
|
|
/* toggle debug flag */
|
|
break;
|
|
|
|
/* return the value of the CPU registers
|
|
* - GR0, GR1, GR2, GR3, GR4, GR5, GR6, GR7,
|
|
* - GR8, GR9, GR10, GR11, GR12, GR13, GR14, GR15,
|
|
* - GR16, GR17, GR18, GR19, GR20, GR21, GR22, GR23,
|
|
* - GR24, GR25, GR26, GR27, GR28, GR29, GR30, GR31,
|
|
* - GR32, GR33, GR34, GR35, GR36, GR37, GR38, GR39,
|
|
* - GR40, GR41, GR42, GR43, GR44, GR45, GR46, GR47,
|
|
* - GR48, GR49, GR50, GR51, GR52, GR53, GR54, GR55,
|
|
* - GR56, GR57, GR58, GR59, GR60, GR61, GR62, GR63,
|
|
* - FP0, FP1, FP2, FP3, FP4, FP5, FP6, FP7,
|
|
* - FP8, FP9, FP10, FP11, FP12, FP13, FP14, FP15,
|
|
* - FP16, FP17, FP18, FP19, FP20, FP21, FP22, FP23,
|
|
* - FP24, FP25, FP26, FP27, FP28, FP29, FP30, FP31,
|
|
* - FP32, FP33, FP34, FP35, FP36, FP37, FP38, FP39,
|
|
* - FP40, FP41, FP42, FP43, FP44, FP45, FP46, FP47,
|
|
* - FP48, FP49, FP50, FP51, FP52, FP53, FP54, FP55,
|
|
* - FP56, FP57, FP58, FP59, FP60, FP61, FP62, FP63,
|
|
* - PC, PSR, CCR, CCCR,
|
|
* - _X132, _X133, _X134
|
|
* - TBR, BRR, DBAR0, DBAR1, DBAR2, DBAR3,
|
|
* - _X141, _X142, _X143, _X144,
|
|
* - LR, LCR
|
|
*/
|
|
case 'g':
|
|
zero = 0;
|
|
ptr = output_buffer;
|
|
|
|
/* deal with GR0, GR1-GR27, GR28-GR31, GR32-GR63 */
|
|
ptr = mem2hex(&zero, ptr, 4, 0);
|
|
|
|
for (loop = 1; loop <= 27; loop++)
|
|
ptr = mem2hex((unsigned long *)__debug_frame + REG_GR(loop),
|
|
ptr, 4, 0);
|
|
temp = (unsigned long) __frame;
|
|
ptr = mem2hex(&temp, ptr, 4, 0);
|
|
ptr = mem2hex((unsigned long *)__debug_frame + REG_GR(29), ptr, 4, 0);
|
|
ptr = mem2hex((unsigned long *)__debug_frame + REG_GR(30), ptr, 4, 0);
|
|
#ifdef CONFIG_MMU
|
|
ptr = mem2hex((unsigned long *)__debug_frame + REG_GR(31), ptr, 4, 0);
|
|
#else
|
|
temp = (unsigned long) __debug_frame;
|
|
ptr = mem2hex(&temp, ptr, 4, 0);
|
|
#endif
|
|
|
|
for (loop = 32; loop <= 63; loop++)
|
|
ptr = mem2hex((unsigned long *)__debug_frame + REG_GR(loop),
|
|
ptr, 4, 0);
|
|
|
|
/* deal with FR0-FR63 */
|
|
for (loop = 0; loop <= 63; loop++)
|
|
ptr = mem2hex((unsigned long *)&__break_user_context +
|
|
__FPMEDIA_FR(loop),
|
|
ptr, 4, 0);
|
|
|
|
/* deal with special registers */
|
|
ptr = mem2hex(&__debug_frame->pc, ptr, 4, 0);
|
|
ptr = mem2hex(&__debug_frame->psr, ptr, 4, 0);
|
|
ptr = mem2hex(&__debug_frame->ccr, ptr, 4, 0);
|
|
ptr = mem2hex(&__debug_frame->cccr, ptr, 4, 0);
|
|
ptr = mem2hex(&zero, ptr, 4, 0);
|
|
ptr = mem2hex(&zero, ptr, 4, 0);
|
|
ptr = mem2hex(&zero, ptr, 4, 0);
|
|
ptr = mem2hex(&__debug_frame->tbr, ptr, 4, 0);
|
|
ptr = mem2hex(&__debug_regs->brr , ptr, 4, 0);
|
|
|
|
asm volatile("movsg dbar0,%0" : "=r"(dbar));
|
|
ptr = mem2hex(&dbar, ptr, 4, 0);
|
|
asm volatile("movsg dbar1,%0" : "=r"(dbar));
|
|
ptr = mem2hex(&dbar, ptr, 4, 0);
|
|
asm volatile("movsg dbar2,%0" : "=r"(dbar));
|
|
ptr = mem2hex(&dbar, ptr, 4, 0);
|
|
asm volatile("movsg dbar3,%0" : "=r"(dbar));
|
|
ptr = mem2hex(&dbar, ptr, 4, 0);
|
|
|
|
asm volatile("movsg scr0,%0" : "=r"(dbar));
|
|
ptr = mem2hex(&dbar, ptr, 4, 0);
|
|
asm volatile("movsg scr1,%0" : "=r"(dbar));
|
|
ptr = mem2hex(&dbar, ptr, 4, 0);
|
|
asm volatile("movsg scr2,%0" : "=r"(dbar));
|
|
ptr = mem2hex(&dbar, ptr, 4, 0);
|
|
asm volatile("movsg scr3,%0" : "=r"(dbar));
|
|
ptr = mem2hex(&dbar, ptr, 4, 0);
|
|
|
|
ptr = mem2hex(&__debug_frame->lr, ptr, 4, 0);
|
|
ptr = mem2hex(&__debug_frame->lcr, ptr, 4, 0);
|
|
|
|
ptr = mem2hex(&__debug_frame->iacc0, ptr, 8, 0);
|
|
|
|
ptr = mem2hex(&__break_user_context.f.fsr[0], ptr, 4, 0);
|
|
|
|
for (loop = 0; loop <= 7; loop++)
|
|
ptr = mem2hex(&__break_user_context.f.acc[loop], ptr, 4, 0);
|
|
|
|
ptr = mem2hex(&__break_user_context.f.accg, ptr, 8, 0);
|
|
|
|
for (loop = 0; loop <= 1; loop++)
|
|
ptr = mem2hex(&__break_user_context.f.msr[loop], ptr, 4, 0);
|
|
|
|
ptr = mem2hex(&__debug_frame->gner0, ptr, 4, 0);
|
|
ptr = mem2hex(&__debug_frame->gner1, ptr, 4, 0);
|
|
|
|
ptr = mem2hex(&__break_user_context.f.fner[0], ptr, 4, 0);
|
|
ptr = mem2hex(&__break_user_context.f.fner[1], ptr, 4, 0);
|
|
|
|
break;
|
|
|
|
/* set the values of the CPU registers */
|
|
case 'G':
|
|
ptr = &input_buffer[1];
|
|
|
|
/* deal with GR0, GR1-GR27, GR28-GR31, GR32-GR63 */
|
|
ptr = hex2mem(ptr, &temp, 4);
|
|
|
|
for (loop = 1; loop <= 27; loop++)
|
|
ptr = hex2mem(ptr, (unsigned long *)__debug_frame + REG_GR(loop),
|
|
4);
|
|
|
|
ptr = hex2mem(ptr, &temp, 4);
|
|
__frame = (struct pt_regs *) temp;
|
|
ptr = hex2mem(ptr, &__debug_frame->gr29, 4);
|
|
ptr = hex2mem(ptr, &__debug_frame->gr30, 4);
|
|
#ifdef CONFIG_MMU
|
|
ptr = hex2mem(ptr, &__debug_frame->gr31, 4);
|
|
#else
|
|
ptr = hex2mem(ptr, &temp, 4);
|
|
#endif
|
|
|
|
for (loop = 32; loop <= 63; loop++)
|
|
ptr = hex2mem(ptr, (unsigned long *)__debug_frame + REG_GR(loop),
|
|
4);
|
|
|
|
/* deal with FR0-FR63 */
|
|
for (loop = 0; loop <= 63; loop++)
|
|
ptr = mem2hex((unsigned long *)&__break_user_context +
|
|
__FPMEDIA_FR(loop),
|
|
ptr, 4, 0);
|
|
|
|
/* deal with special registers */
|
|
ptr = hex2mem(ptr, &__debug_frame->pc, 4);
|
|
ptr = hex2mem(ptr, &__debug_frame->psr, 4);
|
|
ptr = hex2mem(ptr, &__debug_frame->ccr, 4);
|
|
ptr = hex2mem(ptr, &__debug_frame->cccr,4);
|
|
|
|
for (loop = 132; loop <= 140; loop++)
|
|
ptr = hex2mem(ptr, &temp, 4);
|
|
|
|
ptr = hex2mem(ptr, &temp, 4);
|
|
asm volatile("movgs %0,scr0" :: "r"(temp));
|
|
ptr = hex2mem(ptr, &temp, 4);
|
|
asm volatile("movgs %0,scr1" :: "r"(temp));
|
|
ptr = hex2mem(ptr, &temp, 4);
|
|
asm volatile("movgs %0,scr2" :: "r"(temp));
|
|
ptr = hex2mem(ptr, &temp, 4);
|
|
asm volatile("movgs %0,scr3" :: "r"(temp));
|
|
|
|
ptr = hex2mem(ptr, &__debug_frame->lr, 4);
|
|
ptr = hex2mem(ptr, &__debug_frame->lcr, 4);
|
|
|
|
ptr = hex2mem(ptr, &__debug_frame->iacc0, 8);
|
|
|
|
ptr = hex2mem(ptr, &__break_user_context.f.fsr[0], 4);
|
|
|
|
for (loop = 0; loop <= 7; loop++)
|
|
ptr = hex2mem(ptr, &__break_user_context.f.acc[loop], 4);
|
|
|
|
ptr = hex2mem(ptr, &__break_user_context.f.accg, 8);
|
|
|
|
for (loop = 0; loop <= 1; loop++)
|
|
ptr = hex2mem(ptr, &__break_user_context.f.msr[loop], 4);
|
|
|
|
ptr = hex2mem(ptr, &__debug_frame->gner0, 4);
|
|
ptr = hex2mem(ptr, &__debug_frame->gner1, 4);
|
|
|
|
ptr = hex2mem(ptr, &__break_user_context.f.fner[0], 4);
|
|
ptr = hex2mem(ptr, &__break_user_context.f.fner[1], 4);
|
|
|
|
gdbstub_strcpy(output_buffer,"OK");
|
|
break;
|
|
|
|
/* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
|
|
case 'm':
|
|
ptr = &input_buffer[1];
|
|
|
|
if (hexToInt(&ptr, &addr) &&
|
|
*ptr++ == ',' &&
|
|
hexToInt(&ptr, &length)
|
|
) {
|
|
if (mem2hex((char *)addr, output_buffer, length, 1))
|
|
break;
|
|
gdbstub_strcpy (output_buffer, "E03");
|
|
}
|
|
else {
|
|
gdbstub_strcpy(output_buffer,"E01");
|
|
}
|
|
break;
|
|
|
|
/* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
|
|
case 'M':
|
|
ptr = &input_buffer[1];
|
|
|
|
if (hexToInt(&ptr, &addr) &&
|
|
*ptr++ == ',' &&
|
|
hexToInt(&ptr, &length) &&
|
|
*ptr++ == ':'
|
|
) {
|
|
if (hex2mem(ptr, (char *)addr, length)) {
|
|
gdbstub_strcpy(output_buffer, "OK");
|
|
}
|
|
else {
|
|
gdbstub_strcpy(output_buffer, "E03");
|
|
}
|
|
}
|
|
else
|
|
gdbstub_strcpy(output_buffer, "E02");
|
|
|
|
flush_cache = 1;
|
|
break;
|
|
|
|
/* PNN,=RRRRRRRR: Write value R to reg N return OK */
|
|
case 'P':
|
|
ptr = &input_buffer[1];
|
|
|
|
if (!hexToInt(&ptr, &addr) ||
|
|
*ptr++ != '=' ||
|
|
!hexToInt(&ptr, &temp)
|
|
) {
|
|
gdbstub_strcpy(output_buffer, "E01");
|
|
break;
|
|
}
|
|
|
|
temp2 = 1;
|
|
switch (addr) {
|
|
case GDB_REG_GR(0):
|
|
break;
|
|
case GDB_REG_GR(1) ... GDB_REG_GR(63):
|
|
__break_user_context.i.gr[addr - GDB_REG_GR(0)] = temp;
|
|
break;
|
|
case GDB_REG_FR(0) ... GDB_REG_FR(63):
|
|
__break_user_context.f.fr[addr - GDB_REG_FR(0)] = temp;
|
|
break;
|
|
case GDB_REG_PC:
|
|
__break_user_context.i.pc = temp;
|
|
break;
|
|
case GDB_REG_PSR:
|
|
__break_user_context.i.psr = temp;
|
|
break;
|
|
case GDB_REG_CCR:
|
|
__break_user_context.i.ccr = temp;
|
|
break;
|
|
case GDB_REG_CCCR:
|
|
__break_user_context.i.cccr = temp;
|
|
break;
|
|
case GDB_REG_BRR:
|
|
__debug_regs->brr = temp;
|
|
break;
|
|
case GDB_REG_LR:
|
|
__break_user_context.i.lr = temp;
|
|
break;
|
|
case GDB_REG_LCR:
|
|
__break_user_context.i.lcr = temp;
|
|
break;
|
|
case GDB_REG_FSR0:
|
|
__break_user_context.f.fsr[0] = temp;
|
|
break;
|
|
case GDB_REG_ACC(0) ... GDB_REG_ACC(7):
|
|
__break_user_context.f.acc[addr - GDB_REG_ACC(0)] = temp;
|
|
break;
|
|
case GDB_REG_ACCG(0):
|
|
*(uint32_t *) &__break_user_context.f.accg[0] = temp;
|
|
break;
|
|
case GDB_REG_ACCG(4):
|
|
*(uint32_t *) &__break_user_context.f.accg[4] = temp;
|
|
break;
|
|
case GDB_REG_MSR(0) ... GDB_REG_MSR(1):
|
|
__break_user_context.f.msr[addr - GDB_REG_MSR(0)] = temp;
|
|
break;
|
|
case GDB_REG_GNER(0) ... GDB_REG_GNER(1):
|
|
__break_user_context.i.gner[addr - GDB_REG_GNER(0)] = temp;
|
|
break;
|
|
case GDB_REG_FNER(0) ... GDB_REG_FNER(1):
|
|
__break_user_context.f.fner[addr - GDB_REG_FNER(0)] = temp;
|
|
break;
|
|
default:
|
|
temp2 = 0;
|
|
break;
|
|
}
|
|
|
|
if (temp2) {
|
|
gdbstub_strcpy(output_buffer, "OK");
|
|
}
|
|
else {
|
|
gdbstub_strcpy(output_buffer, "E02");
|
|
}
|
|
break;
|
|
|
|
/* cAA..AA Continue at address AA..AA(optional) */
|
|
case 'c':
|
|
/* try to read optional parameter, pc unchanged if no parm */
|
|
ptr = &input_buffer[1];
|
|
if (hexToInt(&ptr, &addr))
|
|
__debug_frame->pc = addr;
|
|
goto done;
|
|
|
|
/* kill the program */
|
|
case 'k' :
|
|
goto done; /* just continue */
|
|
|
|
|
|
/* reset the whole machine (FIXME: system dependent) */
|
|
case 'r':
|
|
break;
|
|
|
|
|
|
/* step to next instruction */
|
|
case 's':
|
|
__debug_regs->dcr |= DCR_SE;
|
|
goto done;
|
|
|
|
/* set baud rate (bBB) */
|
|
case 'b':
|
|
ptr = &input_buffer[1];
|
|
if (!hexToInt(&ptr, &temp)) {
|
|
gdbstub_strcpy(output_buffer,"B01");
|
|
break;
|
|
}
|
|
|
|
if (temp) {
|
|
/* ack before changing speed */
|
|
gdbstub_send_packet("OK");
|
|
gdbstub_set_baud(temp);
|
|
}
|
|
break;
|
|
|
|
/* set breakpoint */
|
|
case 'Z':
|
|
ptr = &input_buffer[1];
|
|
|
|
if (!hexToInt(&ptr,&temp) || *ptr++ != ',' ||
|
|
!hexToInt(&ptr,&addr) || *ptr++ != ',' ||
|
|
!hexToInt(&ptr,&length)
|
|
) {
|
|
gdbstub_strcpy(output_buffer,"E01");
|
|
break;
|
|
}
|
|
|
|
if (temp >= 5) {
|
|
gdbstub_strcpy(output_buffer,"E03");
|
|
break;
|
|
}
|
|
|
|
if (gdbstub_set_breakpoint(temp, addr, length) < 0) {
|
|
gdbstub_strcpy(output_buffer,"E03");
|
|
break;
|
|
}
|
|
|
|
if (temp == 0)
|
|
flush_cache = 1; /* soft bkpt by modified memory */
|
|
|
|
gdbstub_strcpy(output_buffer,"OK");
|
|
break;
|
|
|
|
/* clear breakpoint */
|
|
case 'z':
|
|
ptr = &input_buffer[1];
|
|
|
|
if (!hexToInt(&ptr,&temp) || *ptr++ != ',' ||
|
|
!hexToInt(&ptr,&addr) || *ptr++ != ',' ||
|
|
!hexToInt(&ptr,&length)
|
|
) {
|
|
gdbstub_strcpy(output_buffer,"E01");
|
|
break;
|
|
}
|
|
|
|
if (temp >= 5) {
|
|
gdbstub_strcpy(output_buffer,"E03");
|
|
break;
|
|
}
|
|
|
|
if (gdbstub_clear_breakpoint(temp, addr, length) < 0) {
|
|
gdbstub_strcpy(output_buffer,"E03");
|
|
break;
|
|
}
|
|
|
|
if (temp == 0)
|
|
flush_cache = 1; /* soft bkpt by modified memory */
|
|
|
|
gdbstub_strcpy(output_buffer,"OK");
|
|
break;
|
|
|
|
default:
|
|
gdbstub_proto("### GDB Unsupported Cmd '%s'\n",input_buffer);
|
|
break;
|
|
}
|
|
|
|
/* reply to the request */
|
|
LEDS(0x5009);
|
|
gdbstub_send_packet(output_buffer);
|
|
}
|
|
|
|
done:
|
|
restore_user_regs(&__break_user_context);
|
|
|
|
//gdbstub_dump_debugregs();
|
|
//gdbstub_printk("<-- gdbstub() %08x\n", __debug_frame->pc);
|
|
|
|
/* need to flush the instruction cache before resuming, as we may have
|
|
* deposited a breakpoint, and the icache probably has no way of
|
|
* knowing that a data ref to some location may have changed something
|
|
* that is in the instruction cache. NB: We flush both caches, just to
|
|
* be sure...
|
|
*/
|
|
|
|
/* note: flushing the icache will clobber EAR0 on the FR451 */
|
|
if (flush_cache)
|
|
gdbstub_purge_cache();
|
|
|
|
LEDS(0x5666);
|
|
|
|
} /* end gdbstub() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* initialise the GDB stub
|
|
*/
|
|
void __init gdbstub_init(void)
|
|
{
|
|
#ifdef CONFIG_GDBSTUB_IMMEDIATE
|
|
unsigned char ch;
|
|
int ret;
|
|
#endif
|
|
|
|
gdbstub_printk("%s", gdbstub_banner);
|
|
gdbstub_printk("DCR: %x\n", __debug_regs->dcr);
|
|
|
|
gdbstub_io_init();
|
|
|
|
/* try to talk to GDB (or anyone insane enough to want to type GDB protocol by hand) */
|
|
gdbstub_proto("### GDB Tx ACK\n");
|
|
gdbstub_tx_char('+'); /* 'hello world' */
|
|
|
|
#ifdef CONFIG_GDBSTUB_IMMEDIATE
|
|
gdbstub_printk("GDB Stub waiting for packet\n");
|
|
|
|
/*
|
|
* In case GDB is started before us, ack any packets
|
|
* (presumably "$?#xx") sitting there.
|
|
*/
|
|
do { gdbstub_rx_char(&ch, 0); } while (ch != '$');
|
|
do { gdbstub_rx_char(&ch, 0); } while (ch != '#');
|
|
do { ret = gdbstub_rx_char(&ch, 0); } while (ret != 0); /* eat first csum byte */
|
|
do { ret = gdbstub_rx_char(&ch, 0); } while (ret != 0); /* eat second csum byte */
|
|
|
|
gdbstub_proto("### GDB Tx NAK\n");
|
|
gdbstub_tx_char('-'); /* nak it */
|
|
|
|
#else
|
|
gdbstub_printk("GDB Stub set\n");
|
|
#endif
|
|
|
|
#if 0
|
|
/* send banner */
|
|
ptr = output_buffer;
|
|
*ptr++ = 'O';
|
|
ptr = mem2hex(gdbstub_banner, ptr, sizeof(gdbstub_banner) - 1, 0);
|
|
gdbstub_send_packet(output_buffer);
|
|
#endif
|
|
#if defined(CONFIG_GDBSTUB_CONSOLE) && defined(CONFIG_GDBSTUB_IMMEDIATE)
|
|
register_console(&gdbstub_console);
|
|
#endif
|
|
|
|
} /* end gdbstub_init() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* register the console at a more appropriate time
|
|
*/
|
|
#if defined (CONFIG_GDBSTUB_CONSOLE) && !defined(CONFIG_GDBSTUB_IMMEDIATE)
|
|
static int __init gdbstub_postinit(void)
|
|
{
|
|
printk("registering console\n");
|
|
register_console(&gdbstub_console);
|
|
return 0;
|
|
} /* end gdbstub_postinit() */
|
|
|
|
__initcall(gdbstub_postinit);
|
|
#endif
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* send an exit message to GDB
|
|
*/
|
|
void gdbstub_exit(int status)
|
|
{
|
|
unsigned char checksum;
|
|
int count;
|
|
unsigned char ch;
|
|
|
|
sprintf(output_buffer,"W%02x",status&0xff);
|
|
|
|
gdbstub_tx_char('$');
|
|
checksum = 0;
|
|
count = 0;
|
|
|
|
while ((ch = output_buffer[count]) != 0) {
|
|
gdbstub_tx_char(ch);
|
|
checksum += ch;
|
|
count += 1;
|
|
}
|
|
|
|
gdbstub_tx_char('#');
|
|
gdbstub_tx_char(hexchars[checksum >> 4]);
|
|
gdbstub_tx_char(hexchars[checksum & 0xf]);
|
|
|
|
/* make sure the output is flushed, or else RedBoot might clobber it */
|
|
gdbstub_tx_char('-');
|
|
gdbstub_tx_flush();
|
|
|
|
} /* end gdbstub_exit() */
|
|
|
|
/*****************************************************************************/
|
|
/*
|
|
* GDB wants to call malloc() and free() to allocate memory for calling kernel
|
|
* functions directly from its command line
|
|
*/
|
|
static void *malloc(size_t size) __attribute__((unused));
|
|
static void *malloc(size_t size)
|
|
{
|
|
return kmalloc(size, GFP_ATOMIC);
|
|
}
|
|
|
|
static void free(void *p) __attribute__((unused));
|
|
static void free(void *p)
|
|
{
|
|
kfree(p);
|
|
}
|
|
|
|
static uint32_t ___get_HSR0(void) __attribute__((unused));
|
|
static uint32_t ___get_HSR0(void)
|
|
{
|
|
return __get_HSR(0);
|
|
}
|
|
|
|
static uint32_t ___set_HSR0(uint32_t x) __attribute__((unused));
|
|
static uint32_t ___set_HSR0(uint32_t x)
|
|
{
|
|
__set_HSR(0, x);
|
|
return __get_HSR(0);
|
|
}
|