[deliverable/binutils-gdb.git] / gdb / sh3-rom.c

/* Remote target glue for the Hitachi SH-3 ROM monitor.
   Copyright 1995, 1996 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 "srec.h"

static serial_t parallel;
static int parallel_in_use;

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

static void
sh3_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 'S':
	  if (regname[1] == 'R')
	    regno = SR_REGNUM;
	  break;
	case 'P':
	  if (regname[1] == 'C')
	    regno = PC_REGNUM;
	  else if (regname[1] == 'R')
	    regno = PR_REGNUM;
	  break;
	}
    }
  else if (regnamelen == 3)
    {
      switch (regname[0])
	{
	case 'G':
	case 'V':
	  if (regname[1] == 'B' && regname[2] == 'R')
	    {
	      if (regname[0] == 'G')
		regno = VBR_REGNUM;
	      else
		regno = GBR_REGNUM;
	    }
	  break;
	case 'S':
	  if (regname[1] == 'S' && regname[2] == 'R')
	    regno = SSR_REGNUM;
	  else if (regname[1] == 'P' && regname[2] == 'C')
	    regno = SPC_REGNUM;
	  break;
	}
    }
  else if (regnamelen == 4)
    {
      switch (regname[0])
	{
	case 'M':
	  if (regname[1] == 'A' && regname[2] == 'C')
	    {
	      if (regname[3] == 'H')
		regno = MACH_REGNUM;
	      else if (regname[3] == 'L')
		regno = MACL_REGNUM;
	    }
	  break;
	case 'R':
	  if (regname[1] == '0' && regname[2] == '-' && regname[3] == '7')
	    {
	      regno = R0_REGNUM;
	      numregs = 8;
	    }
	}
    }
  else if (regnamelen == 5)
    {
      if (regname[1] == '8' && regname[2] == '-' && regname[3] == '1'
	  && regname[4] == '5')
	{
	  regno = R0_REGNUM + 8;
	  numregs = 8;
	}
    }
  else if (regnamelen == 17)
    {
    }

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

static void
sh3_load (desc, file, hashmark)
     serial_t desc;
     char *file;
     int hashmark;
{
  if (parallel_in_use)
    {
      monitor_printf ("pl;s\r");
      load_srec (parallel, file, 0, 80, SREC_ALL, hashmark, NULL);
      monitor_expect_prompt (NULL, 0);
    }
  else
    {
      monitor_printf ("il;s:x\r");
      monitor_expect ("\005", NULL, 0);		/* Look for ENQ */
      SERIAL_WRITE (desc, "\006", 1);	/* Send ACK */
      monitor_expect ("LO x\r", NULL, 0);	/* Look for filename */

      load_srec (desc, file, 0, 80, SREC_ALL, hashmark, NULL);

      monitor_expect ("\005", NULL, 0);		/* Look for ENQ */
      SERIAL_WRITE (desc, "\006", 1);	/* Send ACK */
      monitor_expect_prompt (NULL, 0);
    }
}

/* This array of registers need to match the indexes used by GDB.
   This exists because the various ROM monitors use different strings
   than does GDB, and don't necessarily support all the registers
   either. So, typing "info reg sp" becomes a "r30".  */

static char *sh3_regnames[NUM_REGS] =
{
  "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
  "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
  "PC", "PR", "GBR", "VBR", "MACH", "MACL", "SR",
  NULL, NULL,
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
  "SSR", "SPC",
  "R0_BANK0", "R1_BANK0", "R2_BANK0", "R3_BANK0",
  "R4_BANK0", "R5_BANK0", "R6_BANK0", "R7_BANK0",
  "R0_BANK1", "R1_BANK1", "R2_BANK1", "R3_BANK1",
  "R4_BANK1", "R5_BANK1", "R6_BANK1", "R7_BANK1"
};

static char *sh3e_regnames[NUM_REGS] =
{
  "R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
  "R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
  "PC", "PR", "GBR", "VBR", "MACH", "MACL", "SR",
  "FPUL", "FPSCR",
  "FR0", "FR1", "FR2", "FR3", "FR4", "FR5", "FR6", "FR7",
  "FR8", "FR9", "FR10", "FR11", "FR12", "FR13", "FR14", "FR15",
  "SSR", "SPC",
  "R0_BANK0", "R1_BANK0", "R2_BANK0", "R3_BANK0",
  "R4_BANK0", "R5_BANK0", "R6_BANK0", "R7_BANK0",
  "R0_BANK1", "R1_BANK1", "R2_BANK1", "R3_BANK1",
  "R4_BANK1", "R5_BANK1", "R6_BANK1", "R7_BANK1"
};

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

static struct target_ops sh3_ops, sh3e_ops;

static char *sh3_inits[] =
{"\003", NULL};			/* Exits sub-command mode & download cmds */

static struct monitor_ops sh3_cmds;

static void
init_sh3_cmds (void)
{
  sh3_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_GETMEM_READ_SINGLE;	/* flags */
  sh3_cmds.init = sh3_inits;	/* monitor init string */
  sh3_cmds.cont = "g\r";	/* continue command */
  sh3_cmds.step = "s\r";	/* single step */
  sh3_cmds.stop = "\003";	/* Interrupt program */
  sh3_cmds.set_break = "b %x\r";	/* set a breakpoint */
  sh3_cmds.clr_break = "b -%x\r";	/* clear a breakpoint */
  sh3_cmds.clr_all_break = "b -\r";	/* clear all breakpoints */
  sh3_cmds.fill = "f %x @%x %x\r";	/* fill (start len val) */
  sh3_cmds.setmem.cmdb = "m %x %x\r";	/* setmem.cmdb (addr, value) */
  sh3_cmds.setmem.cmdw = "m %x %x;w\r";		/* setmem.cmdw (addr, value) */
  sh3_cmds.setmem.cmdl = "m %x %x;l\r";		/* setmem.cmdl (addr, value) */
  sh3_cmds.setmem.cmdll = NULL;	/* setmem.cmdll (addr, value) */
  sh3_cmds.setmem.resp_delim = NULL;	/* setreg.resp_delim */
  sh3_cmds.setmem.term = NULL;	/* setreg.term */
  sh3_cmds.setmem.term_cmd = NULL;	/* setreg.term_cmd */
  sh3_cmds.getmem.cmdb = "m %x\r";	/* getmem.cmdb (addr, len) */
  sh3_cmds.getmem.cmdw = "m %x;w\r";	/* getmem.cmdw (addr, len) */
  sh3_cmds.getmem.cmdl = "m %x;l\r";	/* getmem.cmdl (addr, len) */
  sh3_cmds.getmem.cmdll = NULL;	/* getmem.cmdll (addr, len) */
  sh3_cmds.getmem.resp_delim = "^ [0-9A-F]+ ";	/* getmem.resp_delim */
  sh3_cmds.getmem.term = "? ";	/* getmem.term */
  sh3_cmds.getmem.term_cmd = ".\r";	/* getmem.term_cmd */
  sh3_cmds.setreg.cmd = ".%s %x\r";	/* setreg.cmd (name, value) */
  sh3_cmds.setreg.resp_delim = NULL;	/* setreg.resp_delim */
  sh3_cmds.setreg.term = NULL;	/* setreg.term */
  sh3_cmds.setreg.term_cmd = NULL;	/* setreg.term_cmd */
  sh3_cmds.getreg.cmd = ".%s\r";	/* getreg.cmd (name) */
  sh3_cmds.getreg.resp_delim = "=";	/* getreg.resp_delim */
  sh3_cmds.getreg.term = "? ";	/* getreg.term */
  sh3_cmds.getreg.term_cmd = ".\r";	/* getreg.term_cmd */
  sh3_cmds.dump_registers = "r\r";	/* dump_registers */
  sh3_cmds.register_pattern = "\\(\\w+\\)=\\([0-9a-fA-F]+\\( +[0-9a-fA-F]+\\b\\)*\\)";
  sh3_cmds.supply_register = sh3_supply_register;	/* supply_register */
  sh3_cmds.load_routine = sh3_load;	/* load_routine */
  sh3_cmds.load = NULL;		/* download command */
  sh3_cmds.loadresp = NULL;	/* Load response */
  sh3_cmds.prompt = "\n:";	/* monitor command prompt */
  sh3_cmds.line_term = "\r";	/* end-of-line terminator */
  sh3_cmds.cmd_end = ".\r";	/* optional command terminator */
  sh3_cmds.target = &sh3_ops;	/* target operations */
  sh3_cmds.stopbits = SERIAL_1_STOPBITS;	/* number of stop bits */
  sh3_cmds.regnames = sh3_regnames;	/* registers names */
  sh3_cmds.magic = MONITOR_OPS_MAGIC;	/* magic */
}				/* init_sh3_cmds */

/* This monitor structure is identical except for a couple slots, so
   we will fill it in from the base structure when needed.  */

static struct monitor_ops sh3e_cmds;

static void
sh3_open (args, from_tty)
     char *args;
     int from_tty;
{
  char *serial_port_name = args;
  char *parallel_port_name = 0;

  if (args)
    {
      char *cursor = serial_port_name = strsave (args);

      while (*cursor && *cursor != ' ')
	cursor++;

      if (*cursor)
	*cursor++ = 0;

      while (*cursor == ' ')
	cursor++;

      if (*cursor)
	parallel_port_name = cursor;
    }

  monitor_open (serial_port_name, &sh3_cmds, from_tty);

  if (parallel_port_name)
    {
      parallel = SERIAL_OPEN (parallel_port_name);

      if (!parallel)
	perror_with_name ("Unable to open parallel port.");

      parallel_in_use = 1;
    }

  /* If we connected successfully, we know the processor is an SH3.  */
  set_architecture_from_arch_mach (bfd_arch_sh, bfd_mach_sh3);
}


static void
sh3e_open (args, from_tty)
     char *args;
     int from_tty;
{
  char *serial_port_name = args;
  char *parallel_port_name = 0;

  if (args)
    {
      char *cursor = serial_port_name = strsave (args);

      while (*cursor && *cursor != ' ')
	cursor++;

      if (*cursor)
	*cursor++ = 0;

      while (*cursor == ' ')
	cursor++;

      if (*cursor)
	parallel_port_name = cursor;
    }

  /* Set up the SH-3E monitor commands structure.  */

  memcpy (&sh3e_cmds, &sh3_cmds, sizeof (struct monitor_ops));

  sh3e_cmds.target = &sh3e_ops;
  sh3e_cmds.regnames = sh3e_regnames;

  monitor_open (serial_port_name, &sh3e_cmds, from_tty);

  if (parallel_port_name)
    {
      parallel = SERIAL_OPEN (parallel_port_name);

      if (!parallel)
	perror_with_name ("Unable to open parallel port.");

      parallel_in_use = 1;
    }

  /* If we connected successfully, we know the processor is an SH3E.  */
  set_architecture_from_arch_mach (bfd_arch_sh, bfd_mach_sh3);
}

static void
sh3_close (quitting)
     int quitting;
{
  monitor_close (quitting);
  if (parallel_in_use)
    {
      SERIAL_CLOSE (parallel);
      parallel_in_use = 0;
    }
}

void
_initialize_sh3_rom ()
{
  init_sh3_cmds ();
  init_monitor_ops (&sh3_ops);

  sh3_ops.to_shortname = "sh3";
  sh3_ops.to_longname = "Hitachi SH-3 rom monitor";

  sh3_ops.to_doc =
#ifdef _WINDOWS
  /* On windows we can talk through the parallel port too. */
    "Debug on a Hitachi eval board running the SH-3 rom monitor.\n"
    "Specify the serial device it is connected to (e.g. com2).\n"
    "If you want to use the parallel port to download to it, specify that\n"
    "as the second argument. (e.g. lpt1)";
#else
    "Debug on a Hitachi eval board running the SH-3 rom monitor.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
#endif

  sh3_ops.to_open = sh3_open;
  sh3_ops.to_close = sh3_close;

  add_target (&sh3_ops);

  /* Setup the SH3e, which has float registers.  */

  init_monitor_ops (&sh3e_ops);

  sh3e_ops.to_shortname = "sh3e";
  sh3e_ops.to_longname = "Hitachi SH-3E rom monitor";

  sh3e_ops.to_doc =
#ifdef _WINDOWS
  /* On windows we can talk through the parallel port too. */
    "Debug on a Hitachi eval board running the SH-3E rom monitor.\n"
    "Specify the serial device it is connected to (e.g. com2).\n"
    "If you want to use the parallel port to download to it, specify that\n"
    "as the second argument. (e.g. lpt1)";
#else
    "Debug on a Hitachi eval board running the SH-3E rom monitor.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
#endif

  sh3e_ops.to_open = sh3e_open;
  sh3e_ops.to_close = sh3_close;

  add_target (&sh3e_ops);
}
Commit	Line	Data
c906108c SS	1	/* Remote target glue for the Hitachi SH-3 ROM monitor.
	2	Copyright 1995, 1996 Free Software Foundation, Inc.
	3
c5aa993b	4	This file is part of GDB.
c906108c	5
c5aa993b JM	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
c906108c	10
c5aa993b JM	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
c906108c	15
c5aa993b JM	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
c906108c SS	20
	21	#include "defs.h"
	22	#include "gdbcore.h"
	23	#include "target.h"
	24	#include "monitor.h"
	25	#include "serial.h"
	26	#include "srec.h"
	27
	28	static serial_t parallel;
	29	static int parallel_in_use;
	30
	31	static void sh3_open PARAMS ((char *args, int from_tty));
	32
	33	static void
	34	sh3_supply_register (regname, regnamelen, val, vallen)
	35	char *regname;
	36	int regnamelen;
	37	char *val;
	38	int vallen;
	39	{
	40	int numregs;
	41	int regno;
	42
	43	numregs = 1;
	44	regno = -1;
	45
	46	if (regnamelen == 2)
	47	{
	48	switch (regname[0])
	49	{
	50	case 'S':
	51	if (regname[1] == 'R')
	52	regno = SR_REGNUM;
	53	break;
	54	case 'P':
	55	if (regname[1] == 'C')
	56	regno = PC_REGNUM;
	57	else if (regname[1] == 'R')
	58	regno = PR_REGNUM;
	59	break;
	60	}
	61	}
	62	else if (regnamelen == 3)
	63	{
	64	switch (regname[0])
	65	{
	66	case 'G':
	67	case 'V':
	68	if (regname[1] == 'B' && regname[2] == 'R')
7a292a7a SS	69	{
	70	if (regname[0] == 'G')
	71	regno = VBR_REGNUM;
	72	else
	73	regno = GBR_REGNUM;
	74	}
c906108c SS	75	break;
	76	case 'S':
	77	if (regname[1] == 'S' && regname[2] == 'R')
	78	regno = SSR_REGNUM;
	79	else if (regname[1] == 'P' && regname[2] == 'C')
	80	regno = SPC_REGNUM;
	81	break;
	82	}
	83	}
	84	else if (regnamelen == 4)
	85	{
	86	switch (regname[0])
	87	{
	88	case 'M':
	89	if (regname[1] == 'A' && regname[2] == 'C')
7a292a7a SS	90	{
	91	if (regname[3] == 'H')
	92	regno = MACH_REGNUM;
	93	else if (regname[3] == 'L')
	94	regno = MACL_REGNUM;
	95	}
c906108c SS	96	break;
	97	case 'R':
	98	if (regname[1] == '0' && regname[2] == '-' && regname[3] == '7')
	99	{
	100	regno = R0_REGNUM;
	101	numregs = 8;
	102	}
	103	}
	104	}
	105	else if (regnamelen == 5)
	106	{
	107	if (regname[1] == '8' && regname[2] == '-' && regname[3] == '1'
c5aa993b	108	&& regname[4] == '5')
c906108c SS	109	{
	110	regno = R0_REGNUM + 8;
	111	numregs = 8;
	112	}
	113	}
	114	else if (regnamelen == 17)
	115	{
	116	}
	117
	118	if (regno >= 0)
	119	while (numregs-- > 0)
	120	val = monitor_supply_register (regno++, val);
	121	}
	122
	123	static void
	124	sh3_load (desc, file, hashmark)
	125	serial_t desc;
	126	char *file;
	127	int hashmark;
	128	{
c5aa993b	129	if (parallel_in_use)
c906108c	130	{
c5aa993b	131	monitor_printf ("pl;s\r");
c906108c SS	132	load_srec (parallel, file, 0, 80, SREC_ALL, hashmark, NULL);
	133	monitor_expect_prompt (NULL, 0);
	134	}
c5aa993b	135	else
c906108c SS	136	{
c906108c SS	137	monitor_printf ("il;s:x\r");
c5aa993b JM	138	monitor_expect ("\005", NULL, 0); /* Look for ENQ */
	139	SERIAL_WRITE (desc, "\006", 1); /* Send ACK */
	140	monitor_expect ("LO x\r", NULL, 0); /* Look for filename */
c906108c SS	141
	142	load_srec (desc, file, 0, 80, SREC_ALL, hashmark, NULL);
	143
c5aa993b JM	144	monitor_expect ("\005", NULL, 0); /* Look for ENQ */
c5aa993b JM	145	SERIAL_WRITE (desc, "\006", 1); /* Send ACK */
c906108c SS	146	monitor_expect_prompt (NULL, 0);
	147	}
	148	}
	149
	150	/* This array of registers need to match the indexes used by GDB.
	151	This exists because the various ROM monitors use different strings
	152	than does GDB, and don't necessarily support all the registers
	153	either. So, typing "info reg sp" becomes a "r30". */
	154
c5aa993b JM	155	static char *sh3_regnames[NUM_REGS] =
	156	{
	157	"R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
	158	"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
	159	"PC", "PR", "GBR", "VBR", "MACH", "MACL", "SR",
c906108c SS	160	NULL, NULL,
	161	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	162	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	163	"SSR", "SPC",
	164	"R0_BANK0", "R1_BANK0", "R2_BANK0", "R3_BANK0",
	165	"R4_BANK0", "R5_BANK0", "R6_BANK0", "R7_BANK0",
	166	"R0_BANK1", "R1_BANK1", "R2_BANK1", "R3_BANK1",
	167	"R4_BANK1", "R5_BANK1", "R6_BANK1", "R7_BANK1"
	168	};
	169
c5aa993b JM	170	static char *sh3e_regnames[NUM_REGS] =
	171	{
	172	"R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
	173	"R8", "R9", "R10", "R11", "R12", "R13", "R14", "R15",
	174	"PC", "PR", "GBR", "VBR", "MACH", "MACL", "SR",
c906108c SS	175	"FPUL", "FPSCR",
	176	"FR0", "FR1", "FR2", "FR3", "FR4", "FR5", "FR6", "FR7",
	177	"FR8", "FR9", "FR10", "FR11", "FR12", "FR13", "FR14", "FR15",
c5aa993b	178	"SSR", "SPC",
c906108c SS	179	"R0_BANK0", "R1_BANK0", "R2_BANK0", "R3_BANK0",
	180	"R4_BANK0", "R5_BANK0", "R6_BANK0", "R7_BANK0",
	181	"R0_BANK1", "R1_BANK1", "R2_BANK1", "R3_BANK1",
	182	"R4_BANK1", "R5_BANK1", "R6_BANK1", "R7_BANK1"
	183	};
	184
	185	/* Define the monitor command strings. Since these are passed directly
	186	through to a printf style function, we may include formatting
	187	strings. We also need a CR or LF on the end. */
	188
	189	static struct target_ops sh3_ops, sh3e_ops;
	190
c5aa993b JM	191	static char *sh3_inits[] =
c5aa993b JM	192	{"\003", NULL}; /* Exits sub-command mode & download cmds */
c906108c	193
c5aa993b	194	static struct monitor_ops sh3_cmds;
c906108c	195
c5aa993b JM	196	static void
c5aa993b JM	197	init_sh3_cmds (void)
c906108c	198	{
c5aa993b JM	199	sh3_cmds.flags = MO_CLR_BREAK_USES_ADDR \| MO_GETMEM_READ_SINGLE; /* flags */
	200	sh3_cmds.init = sh3_inits; /* monitor init string */
	201	sh3_cmds.cont = "g\r"; /* continue command */
	202	sh3_cmds.step = "s\r"; /* single step */
	203	sh3_cmds.stop = "\003"; /* Interrupt program */
	204	sh3_cmds.set_break = "b %x\r"; /* set a breakpoint */
	205	sh3_cmds.clr_break = "b -%x\r"; /* clear a breakpoint */
	206	sh3_cmds.clr_all_break = "b -\r"; /* clear all breakpoints */
	207	sh3_cmds.fill = "f %x @%x %x\r"; /* fill (start len val) */
	208	sh3_cmds.setmem.cmdb = "m %x %x\r"; /* setmem.cmdb (addr, value) */
	209	sh3_cmds.setmem.cmdw = "m %x %x;w\r"; /* setmem.cmdw (addr, value) */
	210	sh3_cmds.setmem.cmdl = "m %x %x;l\r"; /* setmem.cmdl (addr, value) */
	211	sh3_cmds.setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */
	212	sh3_cmds.setmem.resp_delim = NULL; /* setreg.resp_delim */
	213	sh3_cmds.setmem.term = NULL; /* setreg.term */
	214	sh3_cmds.setmem.term_cmd = NULL; /* setreg.term_cmd */
	215	sh3_cmds.getmem.cmdb = "m %x\r"; /* getmem.cmdb (addr, len) */
	216	sh3_cmds.getmem.cmdw = "m %x;w\r"; /* getmem.cmdw (addr, len) */
	217	sh3_cmds.getmem.cmdl = "m %x;l\r"; /* getmem.cmdl (addr, len) */
	218	sh3_cmds.getmem.cmdll = NULL; /* getmem.cmdll (addr, len) */
	219	sh3_cmds.getmem.resp_delim = "^ [0-9A-F]+ "; /* getmem.resp_delim */
	220	sh3_cmds.getmem.term = "? "; /* getmem.term */
	221	sh3_cmds.getmem.term_cmd = ".\r"; /* getmem.term_cmd */
	222	sh3_cmds.setreg.cmd = ".%s %x\r"; /* setreg.cmd (name, value) */
	223	sh3_cmds.setreg.resp_delim = NULL; /* setreg.resp_delim */
	224	sh3_cmds.setreg.term = NULL; /* setreg.term */
	225	sh3_cmds.setreg.term_cmd = NULL; /* setreg.term_cmd */
	226	sh3_cmds.getreg.cmd = ".%s\r"; /* getreg.cmd (name) */
	227	sh3_cmds.getreg.resp_delim = "="; /* getreg.resp_delim */
	228	sh3_cmds.getreg.term = "? "; /* getreg.term */
	229	sh3_cmds.getreg.term_cmd = ".\r"; /* getreg.term_cmd */
	230	sh3_cmds.dump_registers = "r\r"; /* dump_registers */
	231	sh3_cmds.register_pattern = "\\(\\w+\\)=\\([0-9a-fA-F]+\\( +[0-9a-fA-F]+\\b\\)*\\)";
	232	sh3_cmds.supply_register = sh3_supply_register; /* supply_register */
	233	sh3_cmds.load_routine = sh3_load; /* load_routine */
	234	sh3_cmds.load = NULL; /* download command */
	235	sh3_cmds.loadresp = NULL; /* Load response */
	236	sh3_cmds.prompt = "\n:"; /* monitor command prompt */
	237	sh3_cmds.line_term = "\r"; /* end-of-line terminator */
	238	sh3_cmds.cmd_end = ".\r"; /* optional command terminator */
	239	sh3_cmds.target = &sh3_ops; /* target operations */
	240	sh3_cmds.stopbits = SERIAL_1_STOPBITS; /* number of stop bits */
	241	sh3_cmds.regnames = sh3_regnames; /* registers names */
	242	sh3_cmds.magic = MONITOR_OPS_MAGIC; /* magic */
	243	} /* init_sh3_cmds */
c906108c SS	244
	245	/* This monitor structure is identical except for a couple slots, so
	246	we will fill it in from the base structure when needed. */
	247
	248	static struct monitor_ops sh3e_cmds;
	249
	250	static void
	251	sh3_open (args, from_tty)
	252	char *args;
	253	int from_tty;
	254	{
	255	char *serial_port_name = args;
	256	char *parallel_port_name = 0;
	257
c5aa993b	258	if (args)
c906108c SS	259	{
	260	char *cursor = serial_port_name = strsave (args);
	261
	262	while (cursor && cursor != ' ')
c5aa993b	263	cursor++;
c906108c SS	264
	265	if (*cursor)
	266	*cursor++ = 0;
	267
	268	while (*cursor == ' ')
	269	cursor++;
	270
	271	if (*cursor)
	272	parallel_port_name = cursor;
	273	}
	274
	275	monitor_open (serial_port_name, &sh3_cmds, from_tty);
	276
	277	if (parallel_port_name)
	278	{
	279	parallel = SERIAL_OPEN (parallel_port_name);
	280
	281	if (!parallel)
	282	perror_with_name ("Unable to open parallel port.");
	283
	284	parallel_in_use = 1;
	285	}
	286
	287	/* If we connected successfully, we know the processor is an SH3. */
	288	set_architecture_from_arch_mach (bfd_arch_sh, bfd_mach_sh3);
	289	}
	290
	291
	292	static void
	293	sh3e_open (args, from_tty)
	294	char *args;
	295	int from_tty;
	296	{
	297	char *serial_port_name = args;
	298	char *parallel_port_name = 0;
	299
c5aa993b	300	if (args)
c906108c SS	301	{
	302	char *cursor = serial_port_name = strsave (args);
	303
	304	while (cursor && cursor != ' ')
c5aa993b	305	cursor++;
c906108c SS	306
	307	if (*cursor)
	308	*cursor++ = 0;
	309
	310	while (*cursor == ' ')
	311	cursor++;
	312
	313	if (*cursor)
	314	parallel_port_name = cursor;
	315	}
	316
	317	/* Set up the SH-3E monitor commands structure. */
	318
	319	memcpy (&sh3e_cmds, &sh3_cmds, sizeof (struct monitor_ops));
	320
	321	sh3e_cmds.target = &sh3e_ops;
	322	sh3e_cmds.regnames = sh3e_regnames;
	323
	324	monitor_open (serial_port_name, &sh3e_cmds, from_tty);
	325
	326	if (parallel_port_name)
	327	{
	328	parallel = SERIAL_OPEN (parallel_port_name);
	329
	330	if (!parallel)
	331	perror_with_name ("Unable to open parallel port.");
	332
	333	parallel_in_use = 1;
	334	}
	335
	336	/* If we connected successfully, we know the processor is an SH3E. */
	337	set_architecture_from_arch_mach (bfd_arch_sh, bfd_mach_sh3);
	338	}
	339
	340	static void
	341	sh3_close (quitting)
	342	int quitting;
	343	{
	344	monitor_close (quitting);
c5aa993b JM	345	if (parallel_in_use)
	346	{
	347	SERIAL_CLOSE (parallel);
	348	parallel_in_use = 0;
	349	}
c906108c SS	350	}
	351
	352	void
	353	_initialize_sh3_rom ()
	354	{
c5aa993b	355	init_sh3_cmds ();
c906108c SS	356	init_monitor_ops (&sh3_ops);
	357
	358	sh3_ops.to_shortname = "sh3";
	359	sh3_ops.to_longname = "Hitachi SH-3 rom monitor";
	360
c5aa993b	361	sh3_ops.to_doc =
c906108c SS	362	#ifdef _WINDOWS
	363	/* On windows we can talk through the parallel port too. */
	364	"Debug on a Hitachi eval board running the SH-3 rom monitor.\n"
	365	"Specify the serial device it is connected to (e.g. com2).\n"
	366	"If you want to use the parallel port to download to it, specify that\n"
	367	"as the second argument. (e.g. lpt1)";
	368	#else
	369	"Debug on a Hitachi eval board running the SH-3 rom monitor.\n\
	370	Specify the serial device it is connected to (e.g. /dev/ttya).";
	371	#endif
	372
	373	sh3_ops.to_open = sh3_open;
	374	sh3_ops.to_close = sh3_close;
	375
	376	add_target (&sh3_ops);
	377
	378	/* Setup the SH3e, which has float registers. */
	379
	380	init_monitor_ops (&sh3e_ops);
	381
	382	sh3e_ops.to_shortname = "sh3e";
	383	sh3e_ops.to_longname = "Hitachi SH-3E rom monitor";
	384
c5aa993b	385	sh3e_ops.to_doc =
c906108c SS	386	#ifdef _WINDOWS
	387	/* On windows we can talk through the parallel port too. */
	388	"Debug on a Hitachi eval board running the SH-3E rom monitor.\n"
	389	"Specify the serial device it is connected to (e.g. com2).\n"
	390	"If you want to use the parallel port to download to it, specify that\n"
	391	"as the second argument. (e.g. lpt1)";
	392	#else
	393	"Debug on a Hitachi eval board running the SH-3E rom monitor.\n\
	394	Specify the serial device it is connected to (e.g. /dev/ttya).";
	395	#endif
	396
	397	sh3e_ops.to_open = sh3e_open;
	398	sh3e_ops.to_close = sh3_close;
	399
	400	add_target (&sh3e_ops);
	401	}