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 static struct serial *parallel;
  32 static int parallel_in_use;
  33
  34 static void sh3_open (char *args, int from_tty);
  35
  36 static void
  37 sh3_supply_register (char *regname, int regnamelen, char *val, int vallen)
  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')
  68             {
  69               if (regname[0] == 'G')
  70                 regno = VBR_REGNUM;
  71               else
  72                 regno = GBR_REGNUM;
  73             }
  74           break;
  75         case 'S':
  76           if (regname[1] == 'S' && regname[2] == 'R')
  77             regno = gdbarch_tdep (current_gdbarch)->SSR_REGNUM;
  78           else if (regname[1] == 'P' && regname[2] == 'C')
  79             regno = gdbarch_tdep (current_gdbarch)->SPC_REGNUM;
  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')
  89             {
  90               if (regname[3] == 'H')
  91                 regno = MACH_REGNUM;
  92               else if (regname[3] == 'L')
  93                 regno = MACL_REGNUM;
  94             }
  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'
 107           && regname[4] == '5')
 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
 123 sh3_load (struct serial *desc, char *file, int hashmark)
 124 {
 125   if (parallel_in_use)
 126     {
 127       monitor_printf ("pl;s\r");
 128       load_srec (parallel, file, 0, 80, SREC_ALL, hashmark, NULL);
 129       monitor_expect_prompt (NULL, 0);
 130     }
 131   else
 132     {
 133       monitor_printf ("il;s:x\r");
 134       monitor_expect ("\005", NULL, 0);         /* Look for ENQ */
 135       serial_write (desc, "\006", 1);   /* Send ACK */
 136       monitor_expect ("LO x\r", NULL, 0);       /* Look for filename */
 137
 138       load_srec (desc, file, 0, 80, SREC_ALL, hashmark, NULL);
 139
 140       monitor_expect ("\005", NULL, 0);         /* Look for ENQ */
 141       serial_write (desc, "\006", 1);   /* Send ACK */
 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
 151 static char *sh3_regnames[] =
 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",
 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
 166 static char *sh3e_regnames[] =
 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",
 171   "FPUL", "FPSCR",
 172   "FR0", "FR1", "FR2", "FR3", "FR4", "FR5", "FR6", "FR7",
 173   "FR8", "FR9", "FR10", "FR11", "FR12", "FR13", "FR14", "FR15",
 174   "SSR", "SPC",
 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
 187 static char *sh3_inits[] =
 188 {"\003", NULL};                 /* Exits sub-command mode & download cmds */
 189
 190 static struct monitor_ops sh3_cmds;
 191
 192 static void
 193 init_sh3_cmds (void)
 194 {
 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 */
 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
 247 sh3_open (char *args, int from_tty)
 248 {
 249   char *serial_port_name = args;
 250   char *parallel_port_name = 0;
 251
 252   if (args)
 253     {
 254       char *cursor = serial_port_name = xstrdup (args);
 255
 256       while (*cursor && *cursor != ' ')
 257         cursor++;
 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     {
 273       parallel = serial_open (parallel_port_name);
 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
 287 sh3e_open (char *args, int from_tty)
 288 {
 289   char *serial_port_name = args;
 290   char *parallel_port_name = 0;
 291
 292   if (args)
 293     {
 294       char *cursor = serial_port_name = xstrdup (args);
 295
 296       while (*cursor && *cursor != ' ')
 297         cursor++;
 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     {
 320       parallel = serial_open (parallel_port_name);
 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
 333 sh3_close (int quitting)
 334 {
 335   monitor_close (quitting);
 336   if (parallel_in_use)
 337     {
 338       serial_close (parallel);
 339       parallel_in_use = 0;
 340     }
 341 }
 342
 343 void
 344 _initialize_sh3_rom (void)
 345 {
 346   init_sh3_cmds ();
 347   init_monitor_ops (&sh3_ops);
 348
 349   sh3_ops.to_shortname = "sh3";
 350   sh3_ops.to_longname = "Hitachi SH-3 rom monitor";
 351
 352   sh3_ops.to_doc =
 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"
 356     "If you want to use the parallel port to download to it, specify that\n"
 357     "as an additional second argument.";
 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
 371   sh3e_ops.to_doc =
 372   /* We can download through the parallel port too. */
 373     "Debug on a Hitachi eval board running the SH-3E rom monitor.\n"
 374     "Specify the serial device it is connected to.\n"
 375     "If you want to use the parallel port to download to it, specify that\n"
 376     "as an additional second argument.";
 377
 378   sh3e_ops.to_open = sh3e_open;
 379   sh3e_ops.to_close = sh3_close;
 380
 381   add_target (&sh3e_ops);
 382 }