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

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

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