[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;
#if 0
	case 'S':
	  if (regname[1] == 'S' && regname[2] == 'R')
	    regno = SSR_REGNUM;
	  else if (regname[1] == 'P' && regname[2] == 'C')
	    regno = SPC_REGNUM;
	  break;
#endif
	}
    }
  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;
	}
    }
	
  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, 80, SREC_ALL, hashmark);      
      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, 80, SREC_ALL, hashmark);

      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,
  "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;

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

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

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.  */
  sh_set_processor_type ("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 ()
{
  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);
}
Commit	Line	Data
1480482a	1	/* Remote target glue for the Hitachi SH-3 ROM monitor.
c84e5000	2	Copyright 1995, 1996 Free Software Foundation, Inc.
1480482a SG	3
	4	This file is part of GDB.
	5
	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.
	10
	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.
	15
	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, Boston, MA 02111-1307, USA. */
	19
	20	#include "defs.h"
	21	#include "gdbcore.h"
	22	#include "target.h"
	23	#include "monitor.h"
	24	#include "serial.h"
5c8ba017	25	#include "srec.h"
1480482a	26
c84e5000 SC	27	static serial_t parallel;
	28	static int parallel_in_use;
	29
1480482a SG	30	static void sh3_open PARAMS ((char *args, int from_tty));
	31
	32	static void
	33	sh3_supply_register (regname, regnamelen, val, vallen)
	34	char *regname;
	35	int regnamelen;
	36	char *val;
	37	int vallen;
	38	{
	39	int numregs;
	40	int regno;
	41
	42	numregs = 1;
	43	regno = -1;
	44
	45	if (regnamelen == 2)
00dd4fd9 SS	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	}
1480482a	61	else if (regnamelen == 3)
00dd4fd9 SS	62	{
	63	switch (regname[0])
	64	{
	65	case 'G':
	66	case 'V':
	67	if (regname[1] == 'B' && regname[2] == 'R')
	68	if (regname[0] == 'G')
	69	regno = VBR_REGNUM;
	70	else
	71	regno = GBR_REGNUM;
	72	break;
1480482a	73	#if 0
00dd4fd9 SS	74	case 'S':
	75	if (regname[1] == 'S' && regname[2] == 'R')
	76	regno = SSR_REGNUM;
	77	else if (regname[1] == 'P' && regname[2] == 'C')
	78	regno = SPC_REGNUM;
	79	break;
1480482a	80	#endif
00dd4fd9 SS	81	}
00dd4fd9 SS	82	}
1480482a	83	else if (regnamelen == 4)
00dd4fd9 SS	84	{
	85	switch (regname[0])
	86	{
	87	case 'M':
	88	if (regname[1] == 'A' && regname[2] == 'C')
	89	if (regname[3] == 'H')
	90	regno = MACH_REGNUM;
	91	else if (regname[3] == 'L')
	92	regno = MACL_REGNUM;
	93	break;
	94	case 'R':
	95	if (regname[1] == '0' && regname[2] == '-' && regname[3] == '7')
	96	{
	97	regno = R0_REGNUM;
	98	numregs = 8;
	99	}
	100	}
	101	}
1480482a	102	else if (regnamelen == 5)
00dd4fd9 SS	103	{
	104	if (regname[1] == '8' && regname[2] == '-' && regname[3] == '1'
	105	&& regname[4] =='5')
	106	{
	107	regno = R0_REGNUM + 8;
	108	numregs = 8;
	109	}
	110	}
	111
1480482a SG	112	if (regno >= 0)
	113	while (numregs-- > 0)
	114	val = monitor_supply_register (regno++, val);
	115	}
	116
5c8ba017 SG	117	static void
	118	sh3_load (desc, file, hashmark)
	119	serial_t desc;
	120	char *file;
	121	int hashmark;
	122	{
c84e5000 SC	123	if (parallel_in_use)
	124	{
	125	monitor_printf("pl;s\r");
	126	load_srec (parallel, file, 80, SREC_ALL, hashmark);
	127	monitor_expect_prompt (NULL, 0);
	128	}
	129	else
	130	{
	131	monitor_printf ("il;s:x\r");
	132	monitor_expect ("\005", NULL, 0); /* Look for ENQ */
	133	SERIAL_WRITE (desc, "\006", 1); /* Send ACK */
	134	monitor_expect ("LO x\r", NULL, 0); /* Look for filename */
5c8ba017	135
c84e5000	136	load_srec (desc, file, 80, SREC_ALL, hashmark);
5c8ba017	137
c84e5000 SC	138	monitor_expect ("\005", NULL, 0); /* Look for ENQ */
	139	SERIAL_WRITE (desc, "\006", 1); /* Send ACK */
	140	monitor_expect_prompt (NULL, 0);
	141	}
5c8ba017 SG	142	}
5c8ba017 SG	143
1480482a SG	144	/* This array of registers need to match the indexes used by GDB.
	145	This exists because the various ROM monitors use different strings
	146	than does GDB, and don't necessarily support all the registers
	147	either. So, typing "info reg sp" becomes a "r30". */
	148
	149	static char *sh3_regnames[NUM_REGS] = {
00dd4fd9 SS	150	"R0", "R1", "R2", "R3", "R4", "R5", "R6", "R7",
	151	"R8", "R9", "R10", "R11","R12", "R13", "R14", "R15",
	152	"PC", "PR", "GBR", "VBR","MACH","MACL", "SR",
	153	NULL, NULL,
	154	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	155	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
	156	"R0_BANK0", "R1_BANK0", "R2_BANK0", "R3_BANK0",
	157	"R4_BANK0", "R5_BANK0", "R6_BANK0", "R7_BANK0",
	158	"R0_BANK1", "R1_BANK1", "R2_BANK1", "R3_BANK1",
	159	"R4_BANK1", "R5_BANK1", "R6_BANK1", "R7_BANK1"
	160	};
1480482a SG	161
	162	/* Define the monitor command strings. Since these are passed directly
	163	through to a printf style function, we may include formatting
	164	strings. We also need a CR or LF on the end. */
	165
	166	static struct target_ops sh3_ops;
	167
	168	static char sh3_inits[] = {"\003", NULL}; / Exits sub-command mode & download cmds */
	169
	170	static struct monitor_ops sh3_cmds =
	171	{
283dc598 SG	172	MO_CLR_BREAK_USES_ADDR
283dc598 SG	173	\| MO_GETMEM_READ_SINGLE, /* flags */
1480482a SG	174	sh3_inits, /* monitor init string */
	175	"g\r", /* continue command */
	176	"s\r", /* single step */
	177	"\003", /* Interrupt program */
	178	"b %x\r", /* set a breakpoint */
	179	"b -%x\r", /* clear a breakpoint */
	180	"b -\r", /* clear all breakpoints */
	181	"f %x @%x %x\r", /* fill (start len val) */
	182	{
	183	"m %x %x\r", /* setmem.cmdb (addr, value) */
	184	"m %x %x;w\r", /* setmem.cmdw (addr, value) */
	185	"m %x %x;l\r", /* setmem.cmdl (addr, value) */
	186	NULL, /* setmem.cmdll (addr, value) */
	187	NULL, /* setreg.resp_delim */
	188	NULL, /* setreg.term */
	189	NULL, /* setreg.term_cmd */
	190	},
	191	{
283dc598 SG	192	"m %x\r", /* getmem.cmdb (addr, len) */
	193	"m %x;w\r", /* getmem.cmdw (addr, len) */
	194	"m %x;l\r", /* getmem.cmdl (addr, len) */
1480482a	195	NULL, /* getmem.cmdll (addr, len) */
283dc598 SG	196	"^ [0-9A-F]+ ", /* getmem.resp_delim */
	197	"? ", /* getmem.term */
	198	".\r", /* getmem.term_cmd */
1480482a SG	199	},
	200	{
	201	".%s %x\r", /* setreg.cmd (name, value) */
	202	NULL, /* setreg.resp_delim */
	203	NULL, /* setreg.term */
	204	NULL /* setreg.term_cmd */
	205	},
	206	{
	207	".%s\r", /* getreg.cmd (name) */
	208	"=", /* getreg.resp_delim */
	209	"? ", /* getreg.term */
	210	".\r" /* getreg.term_cmd */
	211	},
	212	"r\r", /* dump_registers */
	213	/* register_pattern */
	214	"\\(\\w+\\)=\\([0-9a-fA-F]+\\( +[0-9a-fA-F]+\\b\\)*\\)",
	215	sh3_supply_register, /* supply_register */
5c8ba017 SG	216	sh3_load, /* load_routine */
5c8ba017 SG	217	NULL, /* download command */
1480482a SG	218	NULL, /* Load response */
	219	"\n:", /* monitor command prompt */
	220	"\r", /* end-of-line terminator */
	221	".\r", /* optional command terminator */
	222	&sh3_ops, /* target operations */
	223	SERIAL_1_STOPBITS, /* number of stop bits */
	224	sh3_regnames, /* registers names */
	225	MONITOR_OPS_MAGIC /* magic */
	226	};
	227
	228	static void
	229	sh3_open (args, from_tty)
	230	char *args;
	231	int from_tty;
	232	{
c84e5000 SC	233	char *serial_port_name = args;
c84e5000 SC	234	char *parallel_port_name = 0;
00dd4fd9	235
c84e5000 SC	236	if (args)
c84e5000 SC	237	{
00dd4fd9	238	char *cursor = serial_port_name = strsave (args);
c84e5000 SC	239
	240	while (cursor && cursor != ' ')
	241	cursor++;
	242
	243	if (*cursor)
	244	*cursor++ = 0;
	245
	246	while (*cursor == ' ')
	247	cursor++;
	248
	249	if (*cursor)
	250	parallel_port_name = cursor;
	251	}
	252
	253	monitor_open (serial_port_name, &sh3_cmds, from_tty);
	254
	255	if (parallel_port_name)
	256	{
	257	parallel = SERIAL_OPEN (parallel_port_name);
00dd4fd9	258
c84e5000	259	if (!parallel)
00dd4fd9 SS	260	perror_with_name ("Unable to open parallel port.");
00dd4fd9 SS	261
c84e5000 SC	262	parallel_in_use = 1;
c84e5000 SC	263	}
00dd4fd9 SS	264
	265	/* If we connected successfully, we know the processor is an SH3. */
	266	sh_set_processor_type ("sh3");
c84e5000 SC	267	}
	268
	269
	270	static void
	271	sh3_close (quitting)
	272	int quitting;
	273	{
	274	monitor_close (quitting);
	275	if (parallel_in_use) {
	276	SERIAL_CLOSE (parallel);
	277	parallel_in_use = 0;
	278	}
1480482a SG	279	}
	280
	281	void
	282	_initialize_sh3 ()
	283	{
	284	init_monitor_ops (&sh3_ops);
	285
	286	sh3_ops.to_shortname = "sh3";
	287	sh3_ops.to_longname = "Hitachi SH-3 rom monitor";
c84e5000 SC	288
	289	sh3_ops.to_doc =
	290	#ifdef _WINDOWS
	291	/* On windows we can talk through the parallel port too. */
	292	"Debug on a Hitachi eval board running the SH-3 rom monitor.\n"
	293	"Specify the serial device it is connected to (e.g. com2).\n"
	294	"If you want to use the parallel port to download to it, specify that\n"
	295	"as the second argument. (e.g. lpt1)";
	296	#else
	297	"Debug on a Hitachi eval board running the SH-3 rom monitor.\n\
1480482a	298	Specify the serial device it is connected to (e.g. /dev/ttya).";
c84e5000 SC	299	#endif
c84e5000 SC	300
1480482a	301	sh3_ops.to_open = sh3_open;
c84e5000	302	sh3_ops.to_close = sh3_close;
1480482a SG	303
	304	add_target (&sh3_ops);
	305	}