[binutils.git] / gdb / w89k-rom.c

/* Remote target glue for the WinBond ROM monitor running on the "Cougar"
   W89k eval board.

   Copyright 1995 Free Software Foundation, Inc.

This file is part of GDB.

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.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "gdbcore.h"
#include "target.h"
#include "monitor.h"
#include "serial.h"
#include "xmodem.h"

static void w89k_open PARAMS ((char *args, int from_tty));

/*
 * this array of registers need to match the indexes used by GDB. The
 * whole reason this exists is cause the various ROM monitors use
 * different strings than GDB does, and doesn't support all the
 * registers either. So, typing "info reg sp" becomes a "r30".
 */

static char *w89k_regnames[NUM_REGS] =
{
  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
  "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
  "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
  "SAR", "PC", NULL, NULL, NULL, "EIEM", "IIR", "IVA",
  "IOR", "IPSW", NULL, NULL, NULL, NULL, NULL,
  NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  "CCR", NULL, NULL, "TR0", "TR1",
};

static void
w89k_supply_register (regname, regnamelen, val, vallen)
     char *regname;
     int regnamelen;
     char *val;
     int vallen;
{
  int numregs;
  int regno;

  numregs = 1;
  regno = -1;

  if (regnamelen == 2)
    switch (regname[0])
      {
      case 'r':
	numregs = 4;
	switch (regname[1])
	  {
	  case '0':
	    regno = R0_REGNUM;
	    break;
	  case '4':
	    regno = R0_REGNUM + 4;
	    break;
	  case '8':
	    regno = R0_REGNUM + 8;
	    break;
	  }
	break;
      case 'P':
	if (regname[1] == 'C')
	  regno = PC_REGNUM;
	break;
      }
  else if (regnamelen == 3)
    switch (regname[0])
      {
      case 'r':
	numregs = 4;
	if (regname[1] == '1' && regname[2] == '2')
	  regno = R0_REGNUM + 12;
	else if (regname[1] == '1' && regname[2] == '6')
	  regno = R0_REGNUM + 16;
	else if (regname[1] == '2' && regname[2] == '0')
	  regno = R0_REGNUM + 20;
	else if (regname[1] == '2' && regname[2] == '4')
	  regno = R0_REGNUM + 24;
	else if (regname[1] == '2' && regname[2] == '8')
	  regno = R0_REGNUM + 28;
	break;
      case 'R':
	if (regname[1] == 'C' && regname[2] == 'R')
	  regno = RCR_REGNUM;
	break;
      case 'C':
	if (regname[1] == 'C' && regname[2] == 'R')
	  regno = CCR_REGNUM;
	break;
      case 'S':
	if (regname[1] == 'A' && regname[2] == 'R')
	  regno = SAR_REGNUM;
	break;
      case 'I':
	if (regname[1] == 'I' && regname[2] == 'R')
	  regno = IIR_REGNUM;
	else if (regname[1] == 'O' && regname[2] == 'R')
	  regno = IOR_REGNUM;
	break;
      case 'T':
	numregs = 4;
	if (regname[1] == 'R')
	  if (regname[2] == '0')
	    regno = TR0_REGNUM;
	  else if (regname[2] == '4')
	    regno = TR0_REGNUM + 4;
	break;
      }
  else if (regnamelen == 4)
    switch (regname[0])
      {
      case 'E':
	if (regname[1] == 'I')
	  if (regname[2] == 'E' && regname[3] == 'M')
	    regno = EIEM_REGNUM;
	break;
      case 'I':
	if (regname[1] == 'P' && regname[2] == 'S' && regname[3] == 'W')
	  regno = IPSW_REGNUM;
	break;
      }
  else if (regnamelen == 5)
    switch (regname[0])
      {
      case 'I':
	if (regname[1] == 'A'
	    && regname[2] == 'O'
	    && regname[3] == 'Q'
	    && regname[4] == 'B')
	  regno = PCOQ_TAIL_REGNUM;
	break;
      }

  if (regno >= 0)
    while (numregs-- > 0)
      val = monitor_supply_register (regno++, val);
}

static int hashmark = 1;	/* flag set by "set hash" */

extern struct monitor_ops w89k_cmds; /* fwd decl */

static void
w89k_load (desc, file, hashmark)
     serial_t desc;
     char *file;
     int hashmark;
{
  bfd *abfd;
  asection *s;
  char *buffer;
  int i;

  buffer = alloca (XMODEM_PACKETSIZE);

  abfd = bfd_openr (file, 0);
  if (!abfd)
    {
      printf_filtered ("Unable to open file %s\n", file);
      return;
    }

  if (bfd_check_format (abfd, bfd_object) == 0)
    {
      printf_filtered ("File is not an object file\n");
      return;
    }
  
  for (s = abfd->sections; s; s = s->next)
    if (s->flags & SEC_LOAD)
      {
	bfd_size_type section_size;

	printf_filtered ("%s\t: 0x%4x .. 0x%4x  ", s->name, s->vma,
			 s->vma + s->_raw_size);
	gdb_flush (gdb_stdout);

	monitor_printf (w89k_cmds.load, s->vma);
	if (w89k_cmds.loadresp)
	  monitor_expect (w89k_cmds.loadresp, NULL, 0);

	xmodem_init_xfer (desc);

	section_size = bfd_section_size (abfd, s);

	for (i = 0; i < section_size; i += XMODEM_DATASIZE)
	  {
	    int numbytes;

	    numbytes = min (XMODEM_DATASIZE, section_size - i);

	    bfd_get_section_contents (abfd, s, buffer + XMODEM_DATAOFFSET, i,
				      numbytes);

	    xmodem_send_packet (desc, buffer, numbytes, hashmark);

	    if (hashmark)
	      {
		putchar_unfiltered ('#');
		gdb_flush (gdb_stdout);
	      }
	  }			/* Per-packet (or S-record) loop */

	xmodem_finish_xfer (desc);

	monitor_expect_prompt (NULL, 0);

	putchar_unfiltered ('\n');
      }				/* Loadable sections */
  
  if (hashmark) 
    putchar_unfiltered ('\n');
}

/*
 * Define the monitor command strings. Since these are passed directly
 * through to a printf style function, we need can include formatting
 * strings. We also need a CR or LF on the end.
 */

static struct target_ops w89k_ops;

static char *w89k_inits[] = {"\n", NULL};

static struct monitor_ops w89k_cmds =
{
  MO_GETMEM_NEEDS_RANGE|MO_FILL_USES_ADDR, /* flags */
  w89k_inits,			/* Init strings */
  "g\n",			/* continue command */
  "t\n",			/* single step */
  "\003",			/* Interrupt char (^C) */
  "bp %x\n",			/* set a breakpoint */
  "bc %x\n",			/* clear a breakpoint */
  "bc *\n",			/* clear all breakpoints */
  "f %x %x %x\n",		/* memory fill cmd */
  {
    "eb %x %x\n",		/* setmem.cmdb (addr, value) */
    "eh %x %x\n",		/* setmem.cmdw (addr, value) */
    "ew %x %x\n",		/* setmem.cmdl (addr, value) */
    NULL,			/* setmem.cmdll (addr, value) */
    NULL,			/* setreg.resp_delim */
    NULL,			/* setreg.term */
    NULL,			/* setreg.term_cmd */
  },
  {
    "db %x %x\n",		/* getmem.cmdb (startaddr, endaddr) */
    "dh %x %x\n",		/* getmem.cmdw (startaddr, endaddr) */
    "dw %x %x\n",		/* getmem.cmdl (startaddr, endaddr) */
    NULL,			/* getmem.cmdll (startaddr, endaddr) */
    "  ",			/* getmem.resp_delim */
    NULL,			/* getmem.term */
    NULL,			/* getmem.term_cmd */
  },
  {
    "r %s %x\n",		/* setreg.cmd (name, value) */
    NULL,			/* setreg.resp_delim */
    NULL,			/* setreg.term */
    NULL,			/* setreg.term_cmd */
  },
  {
    "r %s\n",			/* getreg.cmd (name) */
    "\r",			/* getreg.resp_delim */
    NULL,			/* getreg.term */
    NULL,			/* getreg.term_cmd */
  },
  "r\n",			/* dump_registers */
  "\\(\\w+\\)\\( +[0-9a-fA-F]+\\b\\)+",
  w89k_supply_register,		/* supply_register */
  w89k_load,			/* load routine */
  "u %x\n",			/* download command */
  "\021",			/* load response (^Q) */
  "ROM>",			/* monitor command prompt */
  "\n",				/* end-of-line terminator */
  NULL,				/* optional command terminator */
  &w89k_ops,			/* target operations */
  SERIAL_1_STOPBITS,		/* number of stop bits */
  w89k_regnames,		/* register names */
  MONITOR_OPS_MAGIC		/* magic */
  };

static void
w89k_open(args, from_tty)
     char *args;
     int from_tty;
{
  monitor_open (args, &w89k_cmds, from_tty);
}

void
_initialize_w89k ()
{
  init_monitor_ops (&w89k_ops);

  w89k_ops.to_shortname = "w89k";
  w89k_ops.to_longname = "WinBond's debug monitor for the W89k Eval board";
  w89k_ops.to_doc = "Debug on a WinBond W89K eval board.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  w89k_ops.to_open = w89k_open;

  add_target (&w89k_ops);
}
Commit	Line	Data
50e183a2	1	/* Remote target glue for the WinBond ROM monitor running on the "Cougar"
3da4297e	2	W89k eval board.
50e183a2	3
f8f3659f	4	Copyright 1995 Free Software Foundation, Inc.
50e183a2 RS	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
6c9638b4	20	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
50e183a2	21
e8b73ba7 RS	22	#include "defs.h"
	23	#include "gdbcore.h"
	24	#include "target.h"
	25	#include "monitor.h"
3da4297e	26	#include "serial.h"
5de0c648	27	#include "xmodem.h"
e8b73ba7	28
3da4297e	29	static void w89k_open PARAMS ((char *args, int from_tty));
27e889bf RS	30
	31	/*
	32	* this array of registers need to match the indexes used by GDB. The
	33	* whole reason this exists is cause the various ROM monitors use
	34	* different strings than GDB does, and doesn't support all the
	35	* registers either. So, typing "info reg sp" becomes a "r30".
	36	*/
f8f3659f	37
3da4297e SG	38	static char *w89k_regnames[NUM_REGS] =
	39	{
	40	"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
	41	"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
	42	"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
	43	"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
	44	"SAR", "PC", NULL, NULL, NULL, "EIEM", "IIR", "IVA",
	45	"IOR", "IPSW", NULL, NULL, NULL, NULL, NULL,
	46	NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	47	"CCR", NULL, NULL, "TR0", "TR1",
27e889bf	48	};
e8b73ba7	49
7952bce6 SG	50	static void
	51	w89k_supply_register (regname, regnamelen, val, vallen)
	52	char *regname;
	53	int regnamelen;
	54	char *val;
	55	int vallen;
	56	{
	57	int numregs;
	58	int regno;
	59
	60	numregs = 1;
	61	regno = -1;
	62
	63	if (regnamelen == 2)
	64	switch (regname[0])
	65	{
	66	case 'r':
	67	numregs = 4;
	68	switch (regname[1])
	69	{
	70	case '0':
	71	regno = R0_REGNUM;
	72	break;
	73	case '4':
	74	regno = R0_REGNUM + 4;
	75	break;
	76	case '8':
	77	regno = R0_REGNUM + 8;
	78	break;
	79	}
	80	break;
	81	case 'P':
	82	if (regname[1] == 'C')
	83	regno = PC_REGNUM;
	84	break;
	85	}
	86	else if (regnamelen == 3)
	87	switch (regname[0])
	88	{
	89	case 'r':
	90	numregs = 4;
	91	if (regname[1] == '1' && regname[2] == '2')
	92	regno = R0_REGNUM + 12;
	93	else if (regname[1] == '1' && regname[2] == '6')
	94	regno = R0_REGNUM + 16;
	95	else if (regname[1] == '2' && regname[2] == '0')
	96	regno = R0_REGNUM + 20;
	97	else if (regname[1] == '2' && regname[2] == '4')
	98	regno = R0_REGNUM + 24;
	99	else if (regname[1] == '2' && regname[2] == '8')
	100	regno = R0_REGNUM + 28;
	101	break;
	102	case 'R':
	103	if (regname[1] == 'C' && regname[2] == 'R')
	104	regno = RCR_REGNUM;
	105	break;
	106	case 'C':
	107	if (regname[1] == 'C' && regname[2] == 'R')
	108	regno = CCR_REGNUM;
	109	break;
	110	case 'S':
	111	if (regname[1] == 'A' && regname[2] == 'R')
	112	regno = SAR_REGNUM;
	113	break;
114	case 'I':
115	if (regname[1] == 'I' && regname[2] == 'R')
116	regno = IIR_REGNUM;
117	else if (regname[1] == 'O' && regname[2] == 'R')
118	regno = IOR_REGNUM;
119	break;
120	case 'T':
121	numregs = 4;
122	if (regname[1] == 'R')
123	if (regname[2] == '0')
124	regno = TR0_REGNUM;
125	else if (regname[2] == '4')
126	regno = TR0_REGNUM + 4;
127	break;
128	}
129	else if (regnamelen == 4)
130	switch (regname[0])
131	{
132	case 'E':
133	if (regname[1] == 'I')
134	if (regname[2] == 'E' && regname[3] == 'M')
135	regno = EIEM_REGNUM;
136	break;
137	case 'I':
138	if (regname[1] == 'P' && regname[2] == 'S' && regname[3] == 'W')
139	regno = IPSW_REGNUM;
140	break;
141	}
142	else if (regnamelen == 5)
143	switch (regname[0])
144	{
145	case 'I':
146	if (regname[1] == 'A'
147	&& regname[2] == 'O'
148	&& regname[3] == 'Q'
149	&& regname[4] == 'B')
150	regno = PCOQ_TAIL_REGNUM;
151	break;
152	}
153
154	if (regno >= 0)
155	while (numregs-- > 0)
156	val = monitor_supply_register (regno++, val);
157	}
158
5de0c648 SG	159	static int hashmark = 1; /* flag set by "set hash" */
	160
	161	extern struct monitor_ops w89k_cmds; /* fwd decl */
	162
	163	static void
	164	w89k_load (desc, file, hashmark)
	165	serial_t desc;
	166	char *file;
	167	int hashmark;
	168	{
	169	bfd *abfd;
	170	asection *s;
	171	char *buffer;
	172	int i;
	173
	174	buffer = alloca (XMODEM_PACKETSIZE);
	175
	176	abfd = bfd_openr (file, 0);
	177	if (!abfd)
	178	{
	179	printf_filtered ("Unable to open file %s\n", file);
	180	return;
	181	}
	182
	183	if (bfd_check_format (abfd, bfd_object) == 0)
	184	{
	185	printf_filtered ("File is not an object file\n");
	186	return;
	187	}
	188
	189	for (s = abfd->sections; s; s = s->next)
	190	if (s->flags & SEC_LOAD)
	191	{
	192	bfd_size_type section_size;
	193
	194	printf_filtered ("%s\t: 0x%4x .. 0x%4x ", s->name, s->vma,
	195	s->vma + s->_raw_size);
	196	gdb_flush (gdb_stdout);
	197
	198	monitor_printf (w89k_cmds.load, s->vma);
	199	if (w89k_cmds.loadresp)
	200	monitor_expect (w89k_cmds.loadresp, NULL, 0);
	201
	202	xmodem_init_xfer (desc);
	203
	204	section_size = bfd_section_size (abfd, s);
	205
	206	for (i = 0; i < section_size; i += XMODEM_DATASIZE)
	207	{
	208	int numbytes;
	209
	210	numbytes = min (XMODEM_DATASIZE, section_size - i);
	211
	212	bfd_get_section_contents (abfd, s, buffer + XMODEM_DATAOFFSET, i,
	213	numbytes);
	214
	215	xmodem_send_packet (desc, buffer, numbytes, hashmark);
	216
	217	if (hashmark)
	218	{
	219	putchar_unfiltered ('#');
	220	gdb_flush (gdb_stdout);
	221	}
	222	} /* Per-packet (or S-record) loop */
223
224	xmodem_finish_xfer (desc);
225
226	monitor_expect_prompt (NULL, 0);
227
228	putchar_unfiltered ('\n');
229	} /* Loadable sections */
230
231	if (hashmark)
232	putchar_unfiltered ('\n');
233	}
234
e8b73ba7 RS	235	/*
	236	* Define the monitor command strings. Since these are passed directly
	237	* through to a printf style function, we need can include formatting
	238	* strings. We also need a CR or LF on the end.
	239	*/
	240
3da4297e SG	241	static struct target_ops w89k_ops;
3da4297e SG	242
d8afcce9	243	static char *w89k_inits[] = {"\n", NULL};
1265e2d8 SG	244
	245	static struct monitor_ops w89k_cmds =
	246	{
7952bce6	247	MO_GETMEM_NEEDS_RANGE\|MO_FILL_USES_ADDR, /* flags */
3da4297e	248	w89k_inits, /* Init strings */
d8afcce9 SG	249	"g\n", /* continue command */
	250	"t\n", /* single step */
	251	"\003", /* Interrupt char (^C) */
	252	"bp %x\n", /* set a breakpoint */
	253	"bc %x\n", /* clear a breakpoint */
	254	"bc \n", / clear all breakpoints */
	255	"f %x %x %x\n", /* memory fill cmd */
51d6a954	256	{
d8afcce9 SG	257	"eb %x %x\n", /* setmem.cmdb (addr, value) */
	258	"eh %x %x\n", /* setmem.cmdw (addr, value) */
	259	"ew %x %x\n", /* setmem.cmdl (addr, value) */
3da4297e SG	260	NULL, /* setmem.cmdll (addr, value) */
	261	NULL, /* setreg.resp_delim */
	262	NULL, /* setreg.term */
	263	NULL, /* setreg.term_cmd */
51d6a954 RS	264	},
51d6a954 RS	265	{
d8afcce9 SG	266	"db %x %x\n", /* getmem.cmdb (startaddr, endaddr) */
	267	"dh %x %x\n", /* getmem.cmdw (startaddr, endaddr) */
	268	"dw %x %x\n", /* getmem.cmdl (startaddr, endaddr) */
3da4297e SG	269	NULL, /* getmem.cmdll (startaddr, endaddr) */
	270	" ", /* getmem.resp_delim */
	271	NULL, /* getmem.term */
	272	NULL, /* getmem.term_cmd */
51d6a954	273	},
e6fa5bd6	274	{
d8afcce9	275	"r %s %x\n", /* setreg.cmd (name, value) */
3da4297e SG	276	NULL, /* setreg.resp_delim */
	277	NULL, /* setreg.term */
	278	NULL, /* setreg.term_cmd */
27e889bf RS	279	},
27e889bf RS	280	{
d8afcce9	281	"r %s\n", /* getreg.cmd (name) */
3da4297e SG	282	"\r", /* getreg.resp_delim */
	283	NULL, /* getreg.term */
	284	NULL, /* getreg.term_cmd */
27e889bf	285	},
d8afcce9	286	"r\n", /* dump_registers */
7952bce6 SG	287	"\\(\\w+\\)\\( +[0-9a-fA-F]+\\b\\)+",
7952bce6 SG	288	w89k_supply_register, /* supply_register */
5de0c648	289	w89k_load, /* load routine */
d8afcce9 SG	290	"u %x\n", /* download command */
d8afcce9 SG	291	"\021", /* load response (^Q) */
3da4297e	292	"ROM>", /* monitor command prompt */
d8afcce9	293	"\n", /* end-of-line terminator */
3da4297e SG	294	NULL, /* optional command terminator */
3da4297e SG	295	&w89k_ops, /* target operations */
1265e2d8	296	SERIAL_1_STOPBITS, /* number of stop bits */
3da4297e SG	297	w89k_regnames, /* register names */
	298	MONITOR_OPS_MAGIC /* magic */
	299	};
e8b73ba7	300
4a430794	301	static void
e8b73ba7 RS	302	w89k_open(args, from_tty)
	303	char *args;
	304	int from_tty;
	305	{
1265e2d8	306	monitor_open (args, &w89k_cmds, from_tty);
e8b73ba7 RS	307	}
	308
	309	void
	310	_initialize_w89k ()
	311	{
3da4297e	312	init_monitor_ops (&w89k_ops);
27e889bf	313
3da4297e SG	314	w89k_ops.to_shortname = "w89k";
	315	w89k_ops.to_longname = "WinBond's debug monitor for the W89k Eval board";
	316	w89k_ops.to_doc = "Debug on a WinBond W89K eval board.\n\
	317	Specify the serial device it is connected to (e.g. /dev/ttya).";
	318	w89k_ops.to_open = w89k_open;
	319
	320	add_target (&w89k_ops);
e8b73ba7	321	}