gdb/sh3-rom.c

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