newlib-cygwin/libgloss/xstormy16/xstormy16_stub.c

838 lines
19 KiB
C

/****************************************************************************
THIS SOFTWARE IS NOT COPYRIGHTED
HP offers the following for use in the public domain. HP makes no
warranty with regard to the software or it's performance and the
user accepts the software "AS IS" with all faults.
HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
****************************************************************************/
/****************************************************************************
* Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
*
* Module name: remcom.c $
* Revision: 1.34 $
* Date: 91/03/09 12:29:49 $
* Contributor: Lake Stevens Instrument Division$
*
* Description: low level support for gdb debugger. $
*
* Considerations: only works on target hardware $
*
* Written by: Glenn Engel $
* ModuleState: Experimental $
*
* NOTES: See Below $
*
* Heavily modified for XStormy16 by Mark Salter, Red Hat.
* Optimisations and 'X' support by Geoff Keating, Red Hat.
*
* 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 trap #1.
*
* Because gdb will sometimes write to the stack area to execute function
* calls, this program cannot rely on using the inferior stack so it uses
* it's own stack area.
*
*************
*
* 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
* XAA..AA,LLLL: Write LLLL binary bytes at address OK or ENN
* AA..AA
*
* 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)
*
* 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
*
****************************************************************************/
/* Local functions:
*/
static void putDebugChar(unsigned ch);
static unsigned char getDebugChar(void);
static void putPacket(unsigned char *);
static void putHex (char c, unsigned long mem_arg, int count);
static unsigned char *getpacket(void);
static void hex2mem(unsigned char *, unsigned long, int);
static int valid_addr_range (unsigned long mem, int count);
static int hexToInt(unsigned char **, long *);
static void prepare_to_step(void);
static void finish_from_step(void);
/* breakpoint opcode */
#define BREAKPOINT_OPCODE 0x0006
/* Error Detection Register */
#define ERR_DETECT_REG (*(volatile unsigned *)0x7f08)
#define UNDEF_INSN_ENA 0x01
#define UNDEF_INSN_FLAG 0x02
#define ODD_ADDR_ENA 0x04
#define ODD_ADDR_FLAG 0x08
#define BAD_ADDR_ENA 0x10
#define BAD_ADDR_FLAG 0x20
#define SER0_IRQ_ENA 0x1000
#define SER0_IRQ_FLAG 0x2000
/*****************************************************************************
* BUFMAX defines the maximum number of characters in inbound/outbound buffers
* at least NUMREGBYTES*2 are needed for register packets
*/
#define BUFMAX 80
static const unsigned char hexchars[]="0123456789abcdef";
#define NUMREGS 17
/* Number of bytes of registers (extra 2 bytes is for 4 byte PC). */
#define NUMREGBYTES ((NUMREGS * 2) + 2)
enum regnames { R0, R1, R2, R3, R4, R5, R6, R7,
R8, R9, R10, R11, R12, R13, R14, R15,
PC };
#define FP R13
#define PSW R14
#define SP R15
struct regs {
int r[16];
long pc;
} registers;
static struct regs orig_registers;
static unsigned char remcomBuffer[BUFMAX];
/* Indicate whether inferior is running. Used to decide whether or not to
send T packet when stub is entered. */
static char is_running;
static inline unsigned char
get_char(unsigned long addr)
{
unsigned int msw, lsw;
unsigned char ret;
msw = addr >> 16;
lsw = addr & 0xffff;
asm("movf.b %0,(%2)\n"
: "=e"(ret) : "d"(msw), "r"(lsw) : "memory");
return ret;
}
static inline void
set_char(unsigned long addr, unsigned int val)
{
unsigned int msw, lsw;
msw = addr >> 16;
lsw = addr & 0xffff;
asm("movf.b (%1),%2\n"
: /* none */ : "d"(msw), "r"(lsw), "e"(val) : "memory" );
}
static inline unsigned int
get_word(unsigned long addr)
{
unsigned int ret, msw, lsw;
msw = addr >> 16;
lsw = addr & 0xffff;
asm("movf.w %0,(%2)\n"
: "=e"(ret) : "d"(msw), "r"(lsw) : "memory" );
return ret;
}
static inline void
set_word(unsigned long addr, unsigned int val)
{
unsigned int msw, lsw;
msw = addr >> 16;
lsw = addr & 0xffff;
asm("movf.w (%1),%2\n"
: /* none */ : "d"(msw), "r"(lsw), "e"(val) : "memory" );
}
static void
assign_regs (struct regs *dest, const struct regs *src)
{
int i;
char *d = (char *)dest, *s = (char *)src;
for (i = 0; i < sizeof (struct regs); i++)
*d++ = *s++;
}
/* Write out a register for a 'T' packet. */
static unsigned char *
putreg (unsigned char *buf, int regnum, void *mem_p, int count)
{
int i;
unsigned char ch;
char *mem = (char *)mem_p;
*buf++ = hexchars[regnum >> 4];
*buf++ = hexchars[regnum % 16];
*buf++ = ':';
for (i=0;i<count;i++)
{
ch = *mem++;
*buf++ = hexchars[ch >> 4];
*buf++ = hexchars[ch % 16];
}
*buf++ = ';';
return(buf);
}
/*
* This function does all command procesing for interfacing to gdb.
*/
void
handle_exception(void)
{
char sigval;
unsigned char *ptr;
long addr, length;
/* reply to host that an exception has occurred */
sigval = 5; /* SIGTRAP is default */
if (ERR_DETECT_REG & UNDEF_INSN_FLAG)
{
ERR_DETECT_REG &= ~UNDEF_INSN_FLAG;
registers.pc -= 2;
if (get_word(registers.pc) != BREAKPOINT_OPCODE)
sigval = 4; /* SIGILL */
}
if (ERR_DETECT_REG & BAD_ADDR_FLAG)
{
ERR_DETECT_REG &= ~BAD_ADDR_FLAG;
sigval = 11; /* SIGSEGV */
}
if (ERR_DETECT_REG & SER0_IRQ_FLAG)
{
unsigned char ch;
ch = getDebugChar();
ERR_DETECT_REG &= ~SER0_IRQ_FLAG;
if (ch != 0x03)
return;
sigval = 2; /* SIGINT */
}
finish_from_step();
/* save original context so it can be restored as a result of
a kill packet. */
if (orig_registers.pc == 0L)
assign_regs (&orig_registers, &registers);
if (is_running)
{
ptr = remcomBuffer;
*ptr++ = 'T'; /* notify gdb with signo, PC, FP and SP */
*ptr++ = hexchars[sigval >> 4];
*ptr++ = hexchars[sigval & 0xf];
ptr = putreg (ptr, PC, &registers.pc, 4);
ptr = putreg (ptr, FP, &registers.r[FP], 2);
ptr = putreg (ptr, SP, &registers.r[SP], 2);
*ptr++ = 0;
putPacket(remcomBuffer);
}
while (1) {
char kind;
ptr = getpacket();
kind = *ptr++;
if (kind == 'M' || kind == 'X')
{
/* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
/* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
if (hexToInt(&ptr,&addr)
&& *(ptr++) == ','
&& hexToInt(&ptr,&length)
&& *(ptr++) == ':')
{
if (valid_addr_range (addr, length))
{
if (kind == 'M')
hex2mem(ptr, addr, length);
else
{
int i;
for (i = 0; i < length; i++)
if (*ptr++ == 0x7d)
set_char (addr++, *ptr++ ^ 0x20);
else
set_char (addr++, ptr[-1]);
}
putPacket ("OK");
}
else
putPacket ("E03");
}
else
putPacket ("E02");
}
else if (kind == 'm')
{
/* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
/* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
if (hexToInt(&ptr,&addr)
&& *(ptr++) == ','
&& hexToInt (&ptr,&length))
{
if (valid_addr_range (addr, length))
putHex (0, addr, length);
else
putPacket ("E03");
}
else
putPacket ("E02");
}
else if (kind == 'R')
{
if (hexToInt (&ptr, &addr))
registers.pc = addr;
putPacket ("OK");
}
else if (kind == '!')
putPacket ("OK");
else if (kind == '?')
putHex ('S', (unsigned long)(unsigned int)&sigval, 1);
else if (kind == 'g')
putHex (0, (unsigned long)(unsigned int)&registers, NUMREGBYTES);
else if (kind == 'P')
{
/* set the value of a single CPU register - return OK */
unsigned long regno;
if (hexToInt (&ptr, &regno)
&& *ptr++ == '='
&& regno < NUMREGS)
{
hex2mem (ptr, (unsigned long)(unsigned int)(registers.r + regno),
regno == PC ? 4 : 2);
putPacket ("OK");
}
else
putPacket ("E01");
}
else if (kind == 'G')
{
/* set the value of the CPU registers - return OK */
hex2mem(ptr, (unsigned long)(unsigned int)&registers, NUMREGBYTES);
putPacket ("OK");
}
else if (kind == 's' || kind == 'c')
{
/* sAA..AA Step one instruction from AA..AA(optional) */
/* cAA..AA Continue from address AA..AA(optional) */
/* try to read optional parameter, pc unchanged if no parm */
is_running = 1;
if (hexToInt(&ptr,&addr))
registers.pc = addr;
if (kind == 's') /* single-stepping */
prepare_to_step();
return;
}
else if (kind == 'k')
{
/* kill the program */
assign_regs (&registers, &orig_registers);
is_running = 0;
putPacket ("");
}
else
/* Unknown code. Return an empty reply message. */
putPacket ("");
}
}
static int
hex (int ch)
{
if ((ch >= '0') && (ch <= '9')) return (ch-'0');
if ((ch >= 'a') && (ch <= 'f')) return (ch-'a'+10);
if ((ch >= 'A') && (ch <= 'F')) return (ch-'A'+10);
return (-1);
}
/* scan for the sequence $<data>#<checksum> */
static unsigned char *
getpacket (void)
{
unsigned char *buffer = &remcomBuffer[0];
unsigned checksum;
int count;
char ch;
while (1)
{
/* wait around for the start character, ignore all other characters */
while (getDebugChar () != '$')
;
checksum = 0;
count = 0;
while ((ch = getDebugChar ()) == '$')
;
/* now, read until a # or end of buffer is found */
while (ch != '#' && count < BUFMAX - 1)
{
checksum = checksum + ch;
buffer[count] = ch;
count = count + 1;
ch = getDebugChar ();
}
buffer[count] = 0;
if (ch == '#')
{
unsigned xmitcsum;
ch = getDebugChar ();
xmitcsum = hex (ch) << 4;
ch = getDebugChar ();
xmitcsum += hex (ch);
/* If one of the above 'hex' calls returns -1, xmitcsum will
have high bits set, and so the test below will fail. */
if ((checksum & 0xFF) != xmitcsum)
putDebugChar ('-'); /* failed checksum */
else
{
putDebugChar ('+'); /* successful transfer */
return &buffer[0];
}
}
}
}
/* send the packet in buffer. */
static void
putPacket (unsigned char *buffer_p)
{
/* $<packet info>#<checksum>. */
do {
unsigned checksum;
unsigned char *buffer = buffer_p;
putDebugChar('$');
checksum = 0;
while (*buffer) {
putDebugChar(*buffer);
checksum += *buffer;
buffer++;
}
putDebugChar('#');
putDebugChar(hexchars[(checksum >> 4) % 16]);
putDebugChar(hexchars[checksum % 16]);
} while (getDebugChar() != '+');
}
/* Convert the memory pointed to by mem into hex, and return it as a packet. */
static void
putHex (char c, unsigned long mem_arg, int count)
{
do {
unsigned long mem = mem_arg;
int i;
unsigned checksum;
putDebugChar('$');
checksum = 0;
if (c)
{
checksum = c;
putDebugChar(c);
}
for (i = 0; i < count; i++)
{
unsigned char c = get_char (mem);
char ch = hexchars[c >> 4];
putDebugChar(ch);
checksum += ch;
ch = hexchars[c % 16];
putDebugChar(ch);
checksum += ch;
mem++;
}
putDebugChar('#');
putDebugChar(hexchars[(checksum >> 4) % 16]);
putDebugChar(hexchars[checksum % 16]);
} while (getDebugChar() != '+');
}
/* Function: gdb_write(char *, int)
Make gdb write n bytes to stdout (not assumed to be null-terminated). */
void
gdb_write (char *data, int len)
{
ERR_DETECT_REG &= ~SER0_IRQ_ENA;
putHex ('O', (unsigned long)(unsigned int)data, len);
ERR_DETECT_REG |= SER0_IRQ_ENA;
}
int
gdb_read (char *buf, int nbytes)
{
int i = 0;
ERR_DETECT_REG &= ~SER0_IRQ_ENA;
for (i = 0; i < nbytes; i++)
{
*(buf + i) = getDebugChar();
if ((*(buf + i) == '\n') || (*(buf + i) == '\r'))
{
(*(buf + i + 1)) = 0;
break;
}
}
ERR_DETECT_REG |= SER0_IRQ_ENA;
return (i);
}
static int
valid_addr_range (unsigned long mem, int count)
{
unsigned long last = mem + count - 1;
if (last < 0x800L)
return 1;
if (mem < 0x7f00L)
return 0;
if (last > 0x7ffffL)
return 0;
return 1;
}
/* 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 written. */
static void
hex2mem (unsigned char *buf, unsigned long mem, int count)
{
int i;
unsigned char ch;
for (i=0;i<count;i++)
{
ch = hex(*buf++) << 4;
ch = ch + hex(*buf++);
set_char (mem++, ch);
}
}
/**********************************************/
/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
/* RETURN NUMBER OF CHARS PROCESSED */
/**********************************************/
static int
hexToInt (unsigned char **ptr, long *intValue)
{
int numChars = 0;
int hexValue;
*intValue = 0;
while (**ptr)
{
hexValue = hex(**ptr);
if (hexValue >=0)
{
*intValue = (*intValue <<4) | (unsigned) hexValue;
numChars ++;
}
else
break;
(*ptr)++;
}
return (numChars);
}
/* Function: opcode_size
Determine number of bytes in full opcode by examining first word.
*/
static int
opcode_size(unsigned int opcode)
{
if ((opcode & 0xff00) == 0)
return 2;
if ((opcode & 0xf800) == 0)
return 4;
if ((opcode & 0xf800) == 0x7800)
return 4;
if ((opcode & 0xf000) == 0xc000)
return 4;
if ((opcode & 0xf100) == 0x2000)
return 4;
if ((opcode & 0xfff0) == 0x30e0)
return 4;
if ((opcode & 0xf008) == 0x6008)
return 4;
if ((opcode & 0xf808) == 0x7008)
return 4;
opcode >>= 8;
if (opcode == 0x0c || opcode == 0x0d || opcode == 0x31)
return 4;
return 2;
}
static struct {
unsigned long addr;
unsigned long addr2;
unsigned int opcode;
unsigned int opcode2;
} stepinfo;
/* Function: prepare_to_step
Called from handle_exception to prepare the user program to single-step.
Places a trap instruction after the target instruction, with special
extra handling for branch instructions.
*/
static void
prepare_to_step(void)
{
unsigned long pc = registers.pc;
unsigned long next_pc, next_pc2;
unsigned int op, op2, sp;
unsigned char op_msb, op_lsb;
int r12;
char r8;
op = get_word(pc);
op_msb = (op >> 8) & 0xff;
op_lsb = op & 0xff;
op2 = get_word(pc + 2);
next_pc = pc + opcode_size(op);
next_pc2 = 0;
if (op_msb == 0)
{
if (op_lsb == 2)
{
/* IRET */
sp = registers.r[SP];
next_pc = *(unsigned *)(sp - 4);
next_pc = (next_pc << 16) | *(unsigned *)(sp - 6);
}
else if (op_lsb == 3)
{
/* RET */
sp = registers.r[SP];
next_pc = *(unsigned *)(sp - 2);
next_pc = (next_pc << 16) | *(unsigned *)(sp - 4);
}
else
{
op2 = op_lsb & 0xf0;
if (op2 && op2 < 0x40)
{
/* {CALLR,BR,ICALLR} Rs */
next_pc = (pc + 2) + (int)registers.r[op_lsb & 0xf];
}
else if (op2 < 0x80 || op2 == 0xa0 || op2 == 0xb0)
{
/* {JMP,ICALL,CALL} Rb,Rs */
next_pc = registers.r[(op_lsb & 0x10) ? 9 : 8];
next_pc = (next_pc << 16) | (unsigned int)registers.r[op_lsb & 0xf];
}
}
}
else if (op_msb < 4)
{
/* {CALLF,JMPF,ICALLF} a24 */
next_pc = ((unsigned long)op2) << 8;
next_pc |= op_lsb;
}
else if (op_msb < 8)
{
if ((op2 & 0xf000) == 0)
{
/* Bx Rd,#imm4,r12 */
/* Bx Rd,Rs,r12 */
r12 = op2 << 4;
r12 >>= 4;
next_pc2 = (pc + 4) + r12;
}
}
else if (op_msb == 0x0c || op_msb == 0x0d || (op_msb & 0xf1) == 0x20 ||
((op_msb >= 0x7c && op_msb <= 0x7f) && (op2 & 0x8000) == 0))
{
/* Bxx Rd,Rs,r12 */
/* Bxx Rd,#imm8,r12 */
/* Bx m8,#imm3,r12 */
/* Bx s8,#imm3,r12 */
r12 = op2 << 4;
r12 >>= 4;
next_pc2 = (pc + 4) + r12;
}
else if ((op_msb & 0xf0) == 0x10)
{
/* {BR,CALLR} r12 */
r12 = (op & 0xffe) << 4;
r12 >>= 4;
next_pc = (pc + 2) + r12;
}
else if ((op_msb & 0xe0) == 0xc0)
{
/* Bxx Rx,#imm16,r8 */
/* TBxx r8 */
r8 = op_lsb;
next_pc2 = next_pc + r8;
}
stepinfo.addr = next_pc;
stepinfo.opcode = get_word(next_pc);
set_word(next_pc, BREAKPOINT_OPCODE);
if (next_pc2)
{
stepinfo.addr2 = next_pc2;
stepinfo.opcode2 = get_word(next_pc2);
set_word(next_pc2, BREAKPOINT_OPCODE);
}
}
/* Function: finish_from_step
Called from handle_exception to finish up when the user program
returns from a single-step. Replaces the instructions that had
been overwritten by breakpoint. */
static void
finish_from_step (void)
{
if (stepinfo.addr) /* anything to do? */
{
set_word(stepinfo.addr, stepinfo.opcode);
stepinfo.addr = 0;
if (stepinfo.addr2)
{
set_word(stepinfo.addr2, stepinfo.opcode2);
stepinfo.addr2 = 0;
}
}
}
/*
* UART support
*/
#define UART0_BASE 0x7f38
#define UART1_BASE 0x7f48
#define UART_CR(base) (*(volatile unsigned char *)(base))
#define UART_RXD(base) (*(volatile unsigned int *)((base) + 2))
#define UART_TXD(base) (*(volatile unsigned int *)((base) + 4))
#define UART_CR_RUN 0x80
#define UART_CR_ERR 0x40
#define UART_CR_BAUD_115k 0x20
#define UART_CR_PARITY 0x10
#define UART_CR_TXEMPTY 0x08
#define UART_CR_TXIEN 0x04
#define UART_CR_RXRDY 0x02
#define UART_CR_RXIEN 0x01
#define DBG_UART UART0_BASE
static void
putDebugChar(unsigned ch)
{
while ((UART_CR(DBG_UART) & UART_CR_TXEMPTY) == 0) ;
UART_TXD(DBG_UART) = ch;
}
static unsigned char
getDebugChar(void)
{
while ((UART_CR(DBG_UART) & UART_CR_RXRDY) == 0) ;
return UART_RXD(DBG_UART);
}
void
uart_init(void)
{
UART_CR(DBG_UART) |= (UART_CR_RUN | UART_CR_RXIEN);
}