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