1 /* Remote debugging interface to m32r and mon2000 ROM monitors for GDB, 2 the GNU debugger. 3 4 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2004 Free Software 5 Foundation, Inc. 6 7 Adapted by Michael Snyder of Cygnus Support. 8 9 This file is part of GDB. 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 2 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program; if not, write to the Free Software 23 Foundation, Inc., 59 Temple Place - Suite 330, 24 Boston, MA 02111-1307, USA. */ 25 26 /* This module defines communication with the Renesas m32r monitor */ 27 28 #include "defs.h" 29 #include "gdbcore.h" 30 #include "target.h" 31 #include "monitor.h" 32 #include "serial.h" 33 #include "symtab.h" 34 #include "command.h" 35 #include "gdbcmd.h" 36 #include "symfile.h" /* for generic load */ 37 #include <time.h> /* for time_t */ 38 #include "gdb_string.h" 39 #include "objfiles.h" /* for ALL_OBJFILES etc. */ 40 #include "inferior.h" /* for write_pc() */ 41 #include <ctype.h> 42 #include "regcache.h" 43 44 /* 45 * All this stuff just to get my host computer's IP address! 46 */ 47 #include <sys/types.h> 48 #include <netdb.h> /* for hostent */ 49 #include <netinet/in.h> /* for struct in_addr */ 50 #if 1 51 #include <arpa/inet.h> /* for inet_ntoa */ 52 #endif 53 54 static char *board_addr; /* user-settable IP address for M32R-EVA */ 55 static char *server_addr; /* user-settable IP address for gdb host */ 56 static char *download_path; /* user-settable path for SREC files */ 57 58 59 /* REGNUM */ 60 #define PSW_REGNUM 16 61 #define SPI_REGNUM 18 62 #define SPU_REGNUM 19 63 #define ACCL_REGNUM 22 64 #define ACCH_REGNUM 23 65 66 67 /* 68 * Function: m32r_load_1 (helper function) 69 */ 70 71 static void 72 m32r_load_section (bfd *abfd, asection *s, void *obj) 73 { 74 unsigned int *data_count = obj; 75 if (s->flags & SEC_LOAD) 76 { 77 bfd_size_type section_size = bfd_section_size (abfd, s); 78 bfd_vma section_base = bfd_section_lma (abfd, s); 79 unsigned int buffer, i; 80 81 *data_count += section_size; 82 83 printf_filtered ("Loading section %s, size 0x%lx lma ", 84 bfd_section_name (abfd, s), section_size); 85 print_address_numeric (section_base, 1, gdb_stdout); 86 printf_filtered ("\n"); 87 gdb_flush (gdb_stdout); 88 monitor_printf ("%s mw\r", paddr_nz (section_base)); 89 for (i = 0; i < section_size; i += 4) 90 { 91 QUIT; 92 monitor_expect (" -> ", NULL, 0); 93 bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4); 94 monitor_printf ("%x\n", buffer); 95 } 96 monitor_expect (" -> ", NULL, 0); 97 monitor_printf ("q\n"); 98 monitor_expect_prompt (NULL, 0); 99 } 100 } 101 102 static int 103 m32r_load_1 (void *dummy) 104 { 105 int data_count = 0; 106 107 bfd_map_over_sections ((bfd *) dummy, m32r_load_section, &data_count); 108 return data_count; 109 } 110 111 /* 112 * Function: m32r_load (an alternate way to load) 113 */ 114 115 static void 116 m32r_load (char *filename, int from_tty) 117 { 118 bfd *abfd; 119 asection *s; 120 unsigned int i, data_count = 0; 121 time_t start_time, end_time; /* for timing of download */ 122 123 if (filename == NULL || filename[0] == 0) 124 filename = get_exec_file (1); 125 126 abfd = bfd_openr (filename, 0); 127 if (!abfd) 128 error ("Unable to open file %s\n", filename); 129 if (bfd_check_format (abfd, bfd_object) == 0) 130 error ("File is not an object file\n"); 131 start_time = time (NULL); 132 #if 0 133 for (s = abfd->sections; s; s = s->next) 134 if (s->flags & SEC_LOAD) 135 { 136 bfd_size_type section_size = bfd_section_size (abfd, s); 137 bfd_vma section_base = bfd_section_vma (abfd, s); 138 unsigned int buffer; 139 140 data_count += section_size; 141 142 printf_filtered ("Loading section %s, size 0x%lx vma ", 143 bfd_section_name (abfd, s), section_size); 144 print_address_numeric (section_base, 1, gdb_stdout); 145 printf_filtered ("\n"); 146 gdb_flush (gdb_stdout); 147 monitor_printf ("%x mw\r", section_base); 148 for (i = 0; i < section_size; i += 4) 149 { 150 monitor_expect (" -> ", NULL, 0); 151 bfd_get_section_contents (abfd, s, (char *) &buffer, i, 4); 152 monitor_printf ("%x\n", buffer); 153 } 154 monitor_expect (" -> ", NULL, 0); 155 monitor_printf ("q\n"); 156 monitor_expect_prompt (NULL, 0); 157 } 158 #else 159 if (!(catch_errors (m32r_load_1, abfd, "Load aborted!\n", RETURN_MASK_ALL))) 160 { 161 monitor_printf ("q\n"); 162 return; 163 } 164 #endif 165 end_time = time (NULL); 166 printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd)); 167 print_transfer_performance (gdb_stdout, data_count, 0, 168 end_time - start_time); 169 170 /* Finally, make the PC point at the start address */ 171 if (exec_bfd) 172 write_pc (bfd_get_start_address (exec_bfd)); 173 174 inferior_ptid = null_ptid; /* No process now */ 175 176 /* This is necessary because many things were based on the PC at the 177 time that we attached to the monitor, which is no longer valid 178 now that we have loaded new code (and just changed the PC). 179 Another way to do this might be to call normal_stop, except that 180 the stack may not be valid, and things would get horribly 181 confused... */ 182 183 clear_symtab_users (); 184 } 185 186 static void 187 m32r_load_gen (char *filename, int from_tty) 188 { 189 generic_load (filename, from_tty); 190 } 191 192 static void m32r_open (char *args, int from_tty); 193 static void mon2000_open (char *args, int from_tty); 194 195 /* This array of registers needs to match the indexes used by GDB. The 196 whole reason this exists is because the various ROM monitors use 197 different names than GDB does, and don't support all the registers 198 either. So, typing "info reg sp" becomes an "A7". */ 199 200 static char *m32r_regnames[] = 201 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 202 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", 203 "psw", "cbr", "spi", "spu", "bpc", "pc", "accl", "acch", 204 }; 205 206 static void 207 m32r_supply_register (char *regname, int regnamelen, char *val, int vallen) 208 { 209 int regno; 210 int num_regs = sizeof (m32r_regnames) / sizeof (m32r_regnames[0]); 211 212 for (regno = 0; regno < num_regs; regno++) 213 if (strncmp (regname, m32r_regnames[regno], regnamelen) == 0) 214 break; 215 216 if (regno >= num_regs) 217 return; /* no match */ 218 219 if (regno == ACCL_REGNUM) 220 { /* special handling for 64-bit acc reg */ 221 monitor_supply_register (ACCH_REGNUM, val); 222 val = strchr (val, ':'); /* skip past ':' to get 2nd word */ 223 if (val != NULL) 224 monitor_supply_register (ACCL_REGNUM, val + 1); 225 } 226 else 227 { 228 monitor_supply_register (regno, val); 229 if (regno == PSW_REGNUM) 230 { 231 unsigned long psw = strtoul (val, NULL, 16); 232 char *zero = "00000000", *one = "00000001"; 233 234 #ifdef SM_REGNUM 235 /* Stack mode bit */ 236 monitor_supply_register (SM_REGNUM, (psw & 0x80) ? one : zero); 237 #endif 238 #ifdef BSM_REGNUM 239 /* Backup stack mode bit */ 240 monitor_supply_register (BSM_REGNUM, (psw & 0x8000) ? one : zero); 241 #endif 242 #ifdef IE_REGNUM 243 /* Interrupt enable bit */ 244 monitor_supply_register (IE_REGNUM, (psw & 0x40) ? one : zero); 245 #endif 246 #ifdef BIE_REGNUM 247 /* Backup interrupt enable bit */ 248 monitor_supply_register (BIE_REGNUM, (psw & 0x4000) ? one : zero); 249 #endif 250 #ifdef COND_REGNUM 251 /* Condition bit (carry etc.) */ 252 monitor_supply_register (COND_REGNUM, (psw & 0x1) ? one : zero); 253 #endif 254 #ifdef CBR_REGNUM 255 monitor_supply_register (CBR_REGNUM, (psw & 0x1) ? one : zero); 256 #endif 257 #ifdef BPC_REGNUM 258 monitor_supply_register (BPC_REGNUM, zero); /* KLUDGE: (???????) */ 259 #endif 260 #ifdef BCARRY_REGNUM 261 monitor_supply_register (BCARRY_REGNUM, zero); /* KLUDGE: (??????) */ 262 #endif 263 } 264 265 if (regno == SPI_REGNUM || regno == SPU_REGNUM) 266 { /* special handling for stack pointer (spu or spi) */ 267 ULONGEST stackmode, psw; 268 regcache_cooked_read_unsigned (current_regcache, PSW_REGNUM, &psw); 269 stackmode = psw & 0x80; 270 271 if (regno == SPI_REGNUM && !stackmode) /* SP == SPI */ 272 monitor_supply_register (SP_REGNUM, val); 273 else if (regno == SPU_REGNUM && stackmode) /* SP == SPU */ 274 monitor_supply_register (SP_REGNUM, val); 275 } 276 } 277 } 278 279 /* m32r RevC board monitor */ 280 281 static struct target_ops m32r_ops; 282 283 static char *m32r_inits[] = { "\r", NULL }; 284 285 static struct monitor_ops m32r_cmds; 286 287 static void 288 init_m32r_cmds (void) 289 { 290 m32r_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST; 291 m32r_cmds.init = m32r_inits; /* Init strings */ 292 m32r_cmds.cont = "go\r"; /* continue command */ 293 m32r_cmds.step = "step\r"; /* single step */ 294 m32r_cmds.stop = NULL; /* interrupt command */ 295 m32r_cmds.set_break = "%x +bp\r"; /* set a breakpoint */ 296 m32r_cmds.clr_break = "%x -bp\r"; /* clear a breakpoint */ 297 m32r_cmds.clr_all_break = "bpoff\r"; /* clear all breakpoints */ 298 m32r_cmds.fill = "%x %x %x fill\r"; /* fill (start length val) */ 299 m32r_cmds.setmem.cmdb = "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */ 300 m32r_cmds.setmem.cmdw = "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */ 301 m32r_cmds.setmem.cmdl = "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */ 302 m32r_cmds.setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */ 303 m32r_cmds.setmem.resp_delim = NULL; /* setmem.resp_delim */ 304 m32r_cmds.setmem.term = NULL; /* setmem.term */ 305 m32r_cmds.setmem.term_cmd = NULL; /* setmem.term_cmd */ 306 m32r_cmds.getmem.cmdb = "%x %x dump\r"; /* getmem.cmdb (addr, len) */ 307 m32r_cmds.getmem.cmdw = NULL; /* getmem.cmdw (addr, len) */ 308 m32r_cmds.getmem.cmdl = NULL; /* getmem.cmdl (addr, len) */ 309 m32r_cmds.getmem.cmdll = NULL; /* getmem.cmdll (addr, len) */ 310 m32r_cmds.getmem.resp_delim = ": "; /* getmem.resp_delim */ 311 m32r_cmds.getmem.term = NULL; /* getmem.term */ 312 m32r_cmds.getmem.term_cmd = NULL; /* getmem.term_cmd */ 313 m32r_cmds.setreg.cmd = "%x to %%%s\r"; /* setreg.cmd (name, value) */ 314 m32r_cmds.setreg.resp_delim = NULL; /* setreg.resp_delim */ 315 m32r_cmds.setreg.term = NULL; /* setreg.term */ 316 m32r_cmds.setreg.term_cmd = NULL; /* setreg.term_cmd */ 317 m32r_cmds.getreg.cmd = NULL; /* getreg.cmd (name) */ 318 m32r_cmds.getreg.resp_delim = NULL; /* getreg.resp_delim */ 319 m32r_cmds.getreg.term = NULL; /* getreg.term */ 320 m32r_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */ 321 m32r_cmds.dump_registers = ".reg\r"; /* dump_registers */ 322 m32r_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)"; /* register_pattern */ 323 m32r_cmds.supply_register = m32r_supply_register; 324 m32r_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */ 325 m32r_cmds.load = NULL; /* download command */ 326 m32r_cmds.loadresp = NULL; /* load response */ 327 m32r_cmds.prompt = "ok "; /* monitor command prompt */ 328 m32r_cmds.line_term = "\r"; /* end-of-line terminator */ 329 m32r_cmds.cmd_end = NULL; /* optional command terminator */ 330 m32r_cmds.target = &m32r_ops; /* target operations */ 331 m32r_cmds.stopbits = SERIAL_1_STOPBITS; /* number of stop bits */ 332 m32r_cmds.regnames = m32r_regnames; /* registers names */ 333 m32r_cmds.magic = MONITOR_OPS_MAGIC; /* magic */ 334 } /* init_m32r_cmds */ 335 336 static void 337 m32r_open (char *args, int from_tty) 338 { 339 monitor_open (args, &m32r_cmds, from_tty); 340 } 341 342 /* Mon2000 monitor (MSA2000 board) */ 343 344 static struct target_ops mon2000_ops; 345 static struct monitor_ops mon2000_cmds; 346 347 static void 348 init_mon2000_cmds (void) 349 { 350 mon2000_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_REGISTER_VALUE_FIRST; 351 mon2000_cmds.init = m32r_inits; /* Init strings */ 352 mon2000_cmds.cont = "go\r"; /* continue command */ 353 mon2000_cmds.step = "step\r"; /* single step */ 354 mon2000_cmds.stop = NULL; /* interrupt command */ 355 mon2000_cmds.set_break = "%x +bp\r"; /* set a breakpoint */ 356 mon2000_cmds.clr_break = "%x -bp\r"; /* clear a breakpoint */ 357 mon2000_cmds.clr_all_break = "bpoff\r"; /* clear all breakpoints */ 358 mon2000_cmds.fill = "%x %x %x fill\r"; /* fill (start length val) */ 359 mon2000_cmds.setmem.cmdb = "%x 1 %x fill\r"; /* setmem.cmdb (addr, value) */ 360 mon2000_cmds.setmem.cmdw = "%x 1 %x fillh\r"; /* setmem.cmdw (addr, value) */ 361 mon2000_cmds.setmem.cmdl = "%x 1 %x fillw\r"; /* setmem.cmdl (addr, value) */ 362 mon2000_cmds.setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */ 363 mon2000_cmds.setmem.resp_delim = NULL; /* setmem.resp_delim */ 364 mon2000_cmds.setmem.term = NULL; /* setmem.term */ 365 mon2000_cmds.setmem.term_cmd = NULL; /* setmem.term_cmd */ 366 mon2000_cmds.getmem.cmdb = "%x %x dump\r"; /* getmem.cmdb (addr, len) */ 367 mon2000_cmds.getmem.cmdw = NULL; /* getmem.cmdw (addr, len) */ 368 mon2000_cmds.getmem.cmdl = NULL; /* getmem.cmdl (addr, len) */ 369 mon2000_cmds.getmem.cmdll = NULL; /* getmem.cmdll (addr, len) */ 370 mon2000_cmds.getmem.resp_delim = ": "; /* getmem.resp_delim */ 371 mon2000_cmds.getmem.term = NULL; /* getmem.term */ 372 mon2000_cmds.getmem.term_cmd = NULL; /* getmem.term_cmd */ 373 mon2000_cmds.setreg.cmd = "%x to %%%s\r"; /* setreg.cmd (name, value) */ 374 mon2000_cmds.setreg.resp_delim = NULL; /* setreg.resp_delim */ 375 mon2000_cmds.setreg.term = NULL; /* setreg.term */ 376 mon2000_cmds.setreg.term_cmd = NULL; /* setreg.term_cmd */ 377 mon2000_cmds.getreg.cmd = NULL; /* getreg.cmd (name) */ 378 mon2000_cmds.getreg.resp_delim = NULL; /* getreg.resp_delim */ 379 mon2000_cmds.getreg.term = NULL; /* getreg.term */ 380 mon2000_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */ 381 mon2000_cmds.dump_registers = ".reg\r"; /* dump_registers */ 382 mon2000_cmds.register_pattern = "\\(\\w+\\) += \\([0-9a-fA-F]+\\b\\)"; /* register_pattern */ 383 mon2000_cmds.supply_register = m32r_supply_register; 384 mon2000_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */ 385 mon2000_cmds.load = NULL; /* download command */ 386 mon2000_cmds.loadresp = NULL; /* load response */ 387 mon2000_cmds.prompt = "Mon2000>"; /* monitor command prompt */ 388 mon2000_cmds.line_term = "\r"; /* end-of-line terminator */ 389 mon2000_cmds.cmd_end = NULL; /* optional command terminator */ 390 mon2000_cmds.target = &mon2000_ops; /* target operations */ 391 mon2000_cmds.stopbits = SERIAL_1_STOPBITS; /* number of stop bits */ 392 mon2000_cmds.regnames = m32r_regnames; /* registers names */ 393 mon2000_cmds.magic = MONITOR_OPS_MAGIC; /* magic */ 394 } /* init_mon2000_cmds */ 395 396 static void 397 mon2000_open (char *args, int from_tty) 398 { 399 monitor_open (args, &mon2000_cmds, from_tty); 400 } 401 402 static void 403 m32r_upload_command (char *args, int from_tty) 404 { 405 bfd *abfd; 406 asection *s; 407 time_t start_time, end_time; /* for timing of download */ 408 int resp_len, data_count = 0; 409 char buf[1024]; 410 struct hostent *hostent; 411 struct in_addr inet_addr; 412 413 /* first check to see if there's an ethernet port! */ 414 monitor_printf ("ust\r"); 415 resp_len = monitor_expect_prompt (buf, sizeof (buf)); 416 if (!strchr (buf, ':')) 417 error ("No ethernet connection!"); 418 419 if (board_addr == 0) 420 { 421 /* scan second colon in the output from the "ust" command */ 422 char *myIPaddress = strchr (strchr (buf, ':') + 1, ':') + 1; 423 424 while (isspace (*myIPaddress)) 425 myIPaddress++; 426 427 if (!strncmp (myIPaddress, "0.0.", 4)) /* empty */ 428 error 429 ("Please use 'set board-address' to set the M32R-EVA board's IP address."); 430 if (strchr (myIPaddress, '(')) 431 *(strchr (myIPaddress, '(')) = '\0'; /* delete trailing junk */ 432 board_addr = xstrdup (myIPaddress); 433 } 434 if (server_addr == 0) 435 { 436 buf[0] = 0; 437 gethostname (buf, sizeof (buf)); 438 if (buf[0] != 0) 439 { 440 hostent = gethostbyname (buf); 441 if (hostent != 0) 442 { 443 #if 1 444 memcpy (&inet_addr.s_addr, hostent->h_addr, 445 sizeof (inet_addr.s_addr)); 446 server_addr = (char *) inet_ntoa (inet_addr); 447 #else 448 server_addr = (char *) inet_ntoa (hostent->h_addr); 449 #endif 450 } 451 } 452 if (server_addr == 0) /* failed? */ 453 error 454 ("Need to know gdb host computer's IP address (use 'set server-address')"); 455 } 456 457 if (args == 0 || args[0] == 0) /* no args: upload the current file */ 458 args = get_exec_file (1); 459 460 if (args[0] != '/' && download_path == 0) 461 { 462 if (current_directory) 463 download_path = xstrdup (current_directory); 464 else 465 error 466 ("Need to know default download path (use 'set download-path')"); 467 } 468 469 start_time = time (NULL); 470 monitor_printf ("uhip %s\r", server_addr); 471 resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ 472 monitor_printf ("ulip %s\r", board_addr); 473 resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ 474 if (args[0] != '/') 475 monitor_printf ("up %s\r", download_path); /* use default path */ 476 else 477 monitor_printf ("up\r"); /* rooted filename/path */ 478 resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ 479 480 if (strrchr (args, '.') && !strcmp (strrchr (args, '.'), ".srec")) 481 monitor_printf ("ul %s\r", args); 482 else /* add ".srec" suffix */ 483 monitor_printf ("ul %s.srec\r", args); 484 resp_len = monitor_expect_prompt (buf, sizeof (buf)); /* parse result? */ 485 486 if (buf[0] == 0 || strstr (buf, "complete") == 0) 487 error 488 ("Upload file not found: %s.srec\nCheck IP addresses and download path.", 489 args); 490 else 491 printf_filtered (" -- Ethernet load complete.\n"); 492 493 end_time = time (NULL); 494 abfd = bfd_openr (args, 0); 495 if (abfd != NULL) 496 { /* Download is done -- print section statistics */ 497 if (bfd_check_format (abfd, bfd_object) == 0) 498 { 499 printf_filtered ("File is not an object file\n"); 500 } 501 for (s = abfd->sections; s; s = s->next) 502 if (s->flags & SEC_LOAD) 503 { 504 bfd_size_type section_size = bfd_section_size (abfd, s); 505 bfd_vma section_base = bfd_section_lma (abfd, s); 506 unsigned int buffer; 507 508 data_count += section_size; 509 510 printf_filtered ("Loading section %s, size 0x%lx lma ", 511 bfd_section_name (abfd, s), section_size); 512 print_address_numeric (section_base, 1, gdb_stdout); 513 printf_filtered ("\n"); 514 gdb_flush (gdb_stdout); 515 } 516 /* Finally, make the PC point at the start address */ 517 write_pc (bfd_get_start_address (abfd)); 518 printf_filtered ("Start address 0x%lx\n", bfd_get_start_address (abfd)); 519 print_transfer_performance (gdb_stdout, data_count, 0, 520 end_time - start_time); 521 } 522 inferior_ptid = null_ptid; /* No process now */ 523 524 /* This is necessary because many things were based on the PC at the 525 time that we attached to the monitor, which is no longer valid 526 now that we have loaded new code (and just changed the PC). 527 Another way to do this might be to call normal_stop, except that 528 the stack may not be valid, and things would get horribly 529 confused... */ 530 531 clear_symtab_users (); 532 } 533 534 void 535 _initialize_m32r_rom (void) 536 { 537 /* Initialize m32r RevC monitor target */ 538 init_m32r_cmds (); 539 init_monitor_ops (&m32r_ops); 540 541 m32r_ops.to_shortname = "m32r"; 542 m32r_ops.to_longname = "m32r monitor"; 543 m32r_ops.to_load = m32r_load_gen; /* monitor lacks a download command */ 544 m32r_ops.to_doc = "Debug via the m32r monitor.\n\ 545 Specify the serial device it is connected to (e.g. /dev/ttya)."; 546 m32r_ops.to_open = m32r_open; 547 add_target (&m32r_ops); 548 549 /* Initialize mon2000 monitor target */ 550 init_mon2000_cmds (); 551 init_monitor_ops (&mon2000_ops); 552 553 mon2000_ops.to_shortname = "mon2000"; 554 mon2000_ops.to_longname = "Mon2000 monitor"; 555 mon2000_ops.to_load = m32r_load_gen; /* monitor lacks a download command */ 556 mon2000_ops.to_doc = "Debug via the Mon2000 monitor.\n\ 557 Specify the serial device it is connected to (e.g. /dev/ttya)."; 558 mon2000_ops.to_open = mon2000_open; 559 add_target (&mon2000_ops); 560 561 add_setshow_string_cmd ("download-path", class_obscure, &download_path, "\ 562 Set the default path for downloadable SREC files.", "\ 563 Show the default path for downloadable SREC files.", "\ 564 Determines the default path for downloadable SREC files.", "\ 565 The default path for downloadable SREC files is %s.", 566 NULL, NULL, &setlist, &showlist); 567 568 add_setshow_string_cmd ("board-address", class_obscure, &board_addr, "\ 569 Set IP address for M32R-EVA target board.", "\ 570 Show IP address for M32R-EVA target board.", "\ 571 Determine the IP address for M32R-EVA target board.", "\ 572 IP address for M32R-EVA target board is %s", 573 NULL, NULL, &setlist, &showlist); 574 575 add_setshow_string_cmd ("server-address", class_obscure, &server_addr, "\ 576 Set IP address for download server (GDB's host computer).", "\ 577 Show IP address for download server (GDB's host computer).", "\ 578 Determine the IP address for download server (GDB's host computer).", "\ 579 IP address for download server (GDB's host computer) is %s.", 580 NULL, NULL, &setlist, &showlist); 581 582 add_com ("upload", class_obscure, m32r_upload_command, 583 "Upload the srec file via the monitor's Ethernet upload capability."); 584 585 add_com ("tload", class_obscure, m32r_load, "test upload command."); 586 } 587