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

/* Remote target glue for the Hitachi SH-3 ROM monitor.
   Copyright 1995, 1996, 1997, 1998, 1999, 2000, 2001
   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"
#include "arch-utils.h"
#include "regcache.h"

static struct serial *parallel;
static int parallel_in_use;

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

static void
sh3_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 '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 = gdbarch_tdep (current_gdbarch)->SSR_REGNUM;
	  else if (regname[1] == 'P' && regname[2] == 'C')
	    regno = gdbarch_tdep (current_gdbarch)->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 (struct serial *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[] =
{
  "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[] =
{
  "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 (char *args, int from_tty)
{
  char *serial_port_name = args;
  char *parallel_port_name = 0;

  if (args)
    {
      char *cursor = serial_port_name = xstrdup (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 (char *args, int from_tty)
{
  char *serial_port_name = args;
  char *parallel_port_name = 0;

  if (args)
    {
      char *cursor = serial_port_name = xstrdup (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 (int quitting)
{
  monitor_close (quitting);
  if (parallel_in_use)
    {
      serial_close (parallel);
      parallel_in_use = 0;
    }
}

void
_initialize_sh3_rom (void)
{
  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 =
  /* We can download 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.\n"
    "If you want to use the parallel port to download to it, specify that\n"
    "as an additional second argument.";

  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 =
  /* We can download 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.\n"
    "If you want to use the parallel port to download to it, specify that\n"
    "as an additional second argument.";

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

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