Esempio n. 1
0
void
_initialize_ppcbug_rom (void)
{
  init_ppc_cmds ("lo 0\r", &ppcbug_cmds0, &ppcbug_ops0);
  init_ppc_cmds ("lo 1\r", &ppcbug_cmds1, &ppcbug_ops1);
  init_monitor_ops (&ppcbug_ops0);

  ppcbug_ops0.to_shortname = "ppcbug";
  ppcbug_ops0.to_longname = "PowerPC PPCBug monitor on port 0";
  ppcbug_ops0.to_doc = "Debug via the PowerPC PPCBug monitor using port 0.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  ppcbug_ops0.to_open = ppcbug_open0;

  add_target (&ppcbug_ops0);

  init_monitor_ops (&ppcbug_ops1);

  ppcbug_ops1.to_shortname = "ppcbug1";
  ppcbug_ops1.to_longname = "PowerPC PPCBug monitor on port 1";
  ppcbug_ops1.to_doc = "Debug via the PowerPC PPCBug monitor using port 1.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  ppcbug_ops1.to_open = ppcbug_open1;

  add_target (&ppcbug_ops1);
}
Esempio n. 2
0
void
_initialize_sh3_rom (void)
{
  init_sh3_cmds ();
  init_monitor_ops (&sh3_ops);

  sh3_ops.to_shortname = "sh3";
  sh3_ops.to_longname = "Renesas SH-3 rom monitor";

  sh3_ops.to_doc =
  /* We can download through the parallel port too. */
    "Debug on a Renesas eval board running the SH-3E rom monitor.\n"
    "Specify the serial device it is connected to.\n"
    "If you want to use the parallel port to download to it, specify that\n"
    "as an additional second argument.";

  sh3_ops.to_open = sh3_open;
  sh3_ops.to_close = sh3_close;

  add_target (&sh3_ops);

  /* Setup the SH3e, which has float registers.  */

  init_monitor_ops (&sh3e_ops);

  sh3e_ops.to_shortname = "sh3e";
  sh3e_ops.to_longname = "Renesas SH-3E rom monitor";

  sh3e_ops.to_doc =
  /* We can download through the parallel port too. */
    "Debug on a Renesas eval board running the SH-3E rom monitor.\n"
    "Specify the serial device it is connected to.\n"
    "If you want to use the parallel port to download to it, specify that\n"
    "as an additional second argument.";

  sh3e_ops.to_open = sh3e_open;
  sh3e_ops.to_close = sh3_close;

  add_target (&sh3e_ops);
}
Esempio n. 3
0
void
_initialize_dbug_rom (void)
{
  init_dbug_cmds ();
  init_monitor_ops (&dbug_ops);

  dbug_ops.to_shortname = "dbug";
  dbug_ops.to_longname = "dBUG monitor";
  dbug_ops.to_doc = "Debug via the dBUG monitor.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  dbug_ops.to_open = dbug_open;

  add_target (&dbug_ops);
}
Esempio n. 4
0
void
_initialize_w89k (void)
{
  init_w89k_cmds ();
  init_monitor_ops (&w89k_ops);

  w89k_ops.to_shortname = "w89k";
  w89k_ops.to_longname = "WinBond's debug monitor for the W89k Eval board";
  w89k_ops.to_doc = "Debug on a WinBond W89K eval board.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  w89k_ops.to_open = w89k_open;

  add_target (&w89k_ops);
}
Esempio n. 5
0
void
_initialize_rom68k (void)
{
    init_rom68k_cmds ();
    init_monitor_ops (&rom68k_ops);

    rom68k_ops.to_shortname = "rom68k";
    rom68k_ops.to_longname = "Rom68k debug monitor for the IDP Eval board";
    rom68k_ops.to_doc = "Debug on a Motorola IDP eval board running the ROM68K monitor.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
    rom68k_ops.to_open = rom68k_open;

    add_target (&rom68k_ops);
}
Esempio n. 6
0
void
_initialize_est (void)
{
    init_est_cmds ();
    init_monitor_ops (&est_ops);

    est_ops.to_shortname = "est";
    est_ops.to_longname = "EST background debug monitor";
    est_ops.to_doc = "Debug via the EST BDM.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
    est_ops.to_open = est_open;

    add_target (&est_ops);
}
Esempio n. 7
0
void
_initialize_dink32_rom (void)
{
  dink32_cmds.flags = MO_HEX_PREFIX | MO_GETMEM_NEEDS_RANGE
    | MO_FILL_USES_ADDR | MO_HANDLE_NL | MO_32_REGS_PAIRED
    | MO_SETREG_INTERACTIVE | MO_SETMEM_INTERACTIVE
    | MO_GETMEM_16_BOUNDARY | MO_CLR_BREAK_1_BASED | MO_SREC_ACK
    | MO_SREC_ACK_ROTATE;
  dink32_cmds.init = dink32_inits;
  dink32_cmds.cont = "go +\r";
  dink32_cmds.step = "tr +\r";
  dink32_cmds.set_break = "bp 0x%x\r";
  dink32_cmds.clr_break = "bp %d\r";
#if 0			/* Would need to follow strict alignment rules..  */
  dink32_cmds.fill = "mf %x %x %x\r";
#endif
  dink32_cmds.setmem.cmdb = "mm -b %x\r";
  dink32_cmds.setmem.cmdw = "mm -w %x\r";
  dink32_cmds.setmem.cmdl = "mm %x\r";
  dink32_cmds.setmem.term = " ?  ";
  dink32_cmds.getmem.cmdb = "md %x\r";
  dink32_cmds.getmem.resp_delim = "        ";
  dink32_cmds.setreg.cmd = "rm %s\r";
  dink32_cmds.setreg.term = " ?  ";
  dink32_cmds.getreg.cmd = "rd %s\r";
  dink32_cmds.getreg.resp_delim = ": ";
  dink32_cmds.dump_registers = "rd r\r";
  dink32_cmds.register_pattern = "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)";
  dink32_cmds.supply_register = dink32_supply_register;
  /* S-record download, via "keyboard port".  */
  dink32_cmds.load = "dl -k\r";
  dink32_cmds.loadresp = "Set Input Port : set to Keyboard Port\r";
  dink32_cmds.prompt = "DINK32_603 >>";
  dink32_cmds.line_term = "\r";
  dink32_cmds.target = &dink32_ops;
  dink32_cmds.stopbits = SERIAL_1_STOPBITS;
  dink32_cmds.regnames = dink32_regnames;
  dink32_cmds.magic = MONITOR_OPS_MAGIC;

  init_monitor_ops (&dink32_ops);

  dink32_ops.to_shortname = "dink32";
  dink32_ops.to_longname = "DINK32 monitor";
  dink32_ops.to_doc = "Debug using the DINK32 monitor.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  dink32_ops.to_open = dink32_open;

  add_target (&dink32_ops);
}
Esempio n. 8
0
void
_initialize_remote_hms (void)
{
  init_hms_cmds ();
  init_monitor_ops (&hms_ops);

  hms_ops.to_shortname = "hms";
  hms_ops.to_longname = "Renesas Microsystems H8/300 debug monitor";
  hms_ops.to_doc = "Debug via the HMS monitor.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  hms_ops.to_open = hms_open;
  /* By trial and error I've found that this delay doesn't break things */
  write_dos_tick_delay = 1;
  add_target (&hms_ops);
}
void
_initialize_picobug_rom ()
{
  int i;

  /* Initialize m32r RevC monitor target.  */
  init_picobug_cmds ();
  init_monitor_ops (&picobug_ops);
  picobug_ops.to_shortname = "picobug";
  picobug_ops.to_longname = "picobug monitor";
  picobug_ops.to_doc = "Debug via the picobug monitor.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  picobug_ops.to_open = picobug_open;

  add_target (&picobug_ops);
}
Esempio n. 10
0
static void 
init_op50n_cmds(void)
{
  op50n_cmds.flags =   MO_CLR_BREAK_USES_ADDR /*| MO_GETMEM_READ_SINGLE*/; /* flags */
  op50n_cmds.init =   op50n_inits;			/* Init strings */
  op50n_cmds.cont =   "g\r";			/* continue command */
  op50n_cmds.step =   "t\r";			/* single step */
  op50n_cmds.stop =   "\003.\r";			/* Interrupt char */
  op50n_cmds.set_break =   "b %x\r";			/* set a breakpoint */
  op50n_cmds.clr_break =   "b %x;0\r";			/* clear breakpoint at addr */
  op50n_cmds.clr_all_break =   "bx\r";			/* clear all breakpoints */
  op50n_cmds.fill =   "fx %x s%x %x\r";		/* memory fill cmd (addr, len, val) */
  op50n_cmds.setmem.cmdb =     "sx %x %x\r";		/* setmem.cmdb (addr, value) */
  op50n_cmds.setmem.cmdw =     "sh %x %x\r";		/* setmem.cmdw (addr, value) */
  op50n_cmds.setmem.cmdl =     "s %x %x\r";		/* setmem.cmdl (addr, value) */
  op50n_cmds.setmem.cmdll =     NULL;			/* setmem.cmdll (addr, value) */
  op50n_cmds.setmem.resp_delim =     NULL;			/* setmem.resp_delim */
  op50n_cmds.setmem.term =     NULL;			/* setmem.term */
  op50n_cmds.setmem.term_cmd =     NULL;			/* setmem.term_cmd */
#if 0
  {
    "sx %x\r",			/* getmem.cmdb (addr, len) */
      "sh %x\r",			/* getmem.cmdw (addr, len) */
      "s %x\r",			/* getmem.cmdl (addr, len) */
      NULL,			/* getmem.cmdll (addr, len) */
      " : ",			/* getmem.resp_delim */
      " ",			/* getmem.term */
      ".\r",			/* getmem.term_cmd */
      } ;
#else
  op50n_cmds.getmem.cmdb =     "dx %x s%x\r";		/* getmem.cmdb (addr, len) */
  op50n_cmds.getmem.cmdw =     NULL;			/* getmem.cmdw (addr, len) */
  op50n_cmds.getmem.cmdl =     NULL;			/* getmem.cmdl (addr, len) */
  op50n_cmds.getmem.cmdll =     NULL;			/* getmem.cmdll (addr, len) */
  op50n_cmds.getmem.resp_delim =     " : ";			/* getmem.resp_delim */
  op50n_cmds.getmem.term =     NULL;			/* getmem.term */
  op50n_cmds.getmem.term_cmd =     NULL;			/* getmem.term_cmd */
#endif
  op50n_cmds.setreg.cmd =     "x %s %x\r";		/* setreg.cmd (name, value) */
  op50n_cmds.setreg.resp_delim =     NULL;			/* setreg.resp_delim */
  op50n_cmds.setreg.term =     NULL;			/* setreg.term */
  op50n_cmds.setreg.term_cmd =     NULL;			/* setreg.term_cmd */
  op50n_cmds.getreg.cmd =     "x %s\r";			/* getreg.cmd (name) */
  op50n_cmds.getreg.resp_delim =     "=";			/* getreg.resp_delim */
  op50n_cmds.getreg.term =     " ";			/* getreg.term */
  op50n_cmds.getreg.term_cmd =     ".\r";			/* getreg.term_cmd */
  op50n_cmds.dump_registers =   NULL;				/* dump_registers */
  op50n_cmds.register_pattern =   NULL;				/* register_pattern */
  op50n_cmds.supply_register =   NULL;				/* supply_register */
  op50n_cmds.load_routine =   NULL;				/* load routine */
  op50n_cmds.load =   "r 0\r";			/* download command */
  op50n_cmds.loadresp =   NULL;				/* load response */
  op50n_cmds.prompt =   "\n#";			/* monitor command prompt */
  op50n_cmds.line_term =   "\r";				/* end-of-command delimitor */
  op50n_cmds.cmd_end =   NULL;				/* optional command terminator */
  op50n_cmds.target =   &op50n_ops;			/* target operations */
  op50n_cmds.stopbits =   SERIAL_1_STOPBITS;		/* number of stop bits */
  op50n_cmds.regnames =   op50n_regnames;		/* register names */
  op50n_cmds.magic =   MONITOR_OPS_MAGIC;		/* magic */
};

static void
op50n_open (args, from_tty)
     char *args;
     int from_tty;
{
  monitor_open (args, &op50n_cmds, from_tty);
}

void
_initialize_op50n ()
{
  init_op50n_cmds() ;
  init_monitor_ops (&op50n_ops);

  op50n_ops.to_shortname = "op50n";
  op50n_ops.to_longname = "Oki's debug monitor for the Op50n Eval board";
  op50n_ops.to_doc = "Debug on a Oki OP50N eval board.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  op50n_ops.to_open = op50n_open;

  add_target (&op50n_ops);
}