gdb/sh3-rom.c

   1 /* Remote target glue for the Hitachi SH-3 ROM monitor.
   2    Copyright 1995, 1996 Free Software Foundation, Inc.
   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,
  19    Boston, MA 02111-1307, USA.  */
  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')
  69             {
  70               if (regname[0] == 'G')
  71                 regno = VBR_REGNUM;
  72               else
  73                 regno = GBR_REGNUM;
  74             }
  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')
  90             {
  91               if (regname[3] == 'H')
  92                 regno = MACH_REGNUM;
  93               else if (regname[3] == 'L')
  94                 regno = MACL_REGNUM;
  95             }
  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'
 108           && regname[4] == '5')
 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 {
 129   if (parallel_in_use)
 130     {
 131       monitor_printf ("pl;s\r");
 132       load_srec (parallel, file, 0, 80, SREC_ALL, hashmark, NULL);
 133       monitor_expect_prompt (NULL, 0);
 134     }
 135   else
 136     {
 137       monitor_printf ("il;s:x\r");
 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 */
 141
 142       load_srec (desc, file, 0, 80, SREC_ALL, hashmark, NULL);
 143
 144       monitor_expect ("\005", NULL, 0);         /* Look for ENQ */
 145       SERIAL_WRITE (desc, "\006", 1);   /* Send ACK */
 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
 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",
 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
 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",
 175   "FPUL", "FPSCR",
 176   "FR0", "FR1", "FR2", "FR3", "FR4", "FR5", "FR6", "FR7",
 177   "FR8", "FR9", "FR10", "FR11", "FR12", "FR13", "FR14", "FR15",
 178   "SSR", "SPC",
 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
 191 static char *sh3_inits[] =
 192 {"\003", NULL};                 /* Exits sub-command mode & download cmds */
 193
 194 static struct monitor_ops sh3_cmds;
 195
 196 static void
 197 init_sh3_cmds (void)
 198 {
 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 */
 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
 258   if (args)
 259     {
 260       char *cursor = serial_port_name = strsave (args);
 261
 262       while (*cursor && *cursor != ' ')
 263         cursor++;
 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
 300   if (args)
 301     {
 302       char *cursor = serial_port_name = strsave (args);
 303
 304       while (*cursor && *cursor != ' ')
 305         cursor++;
 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);
 345   if (parallel_in_use)
 346     {
 347       SERIAL_CLOSE (parallel);
 348       parallel_in_use = 0;
 349     }
 350 }
 351
 352 void
 353 _initialize_sh3_rom ()
 354 {
 355   init_sh3_cmds ();
 356   init_monitor_ops (&sh3_ops);
 357
 358   sh3_ops.to_shortname = "sh3";
 359   sh3_ops.to_longname = "Hitachi SH-3 rom monitor";
 360
 361   sh3_ops.to_doc =
 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
 385   sh3e_ops.to_doc =
 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 }