gdb/sh3-rom.c

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