1 /* Remote debugging interface for Densan DVE-R3900 ROM monitor for
3 Copyright 1997 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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. */
29 #include "gdb_string.h"
32 /* Type of function passed to bfd_map_over_sections. */
34 typedef void (*section_map_func) PARAMS ((bfd * abfd, asection * sect, PTR obj));
36 /* Packet escape character used by Densan monitor. */
40 /* Maximum packet size. This is actually smaller than necessary
45 /* External functions. */
47 extern void report_transfer_performance PARAMS ((unsigned long,
50 /* Certain registers are "bitmapped", in that the monitor can only display
51 them or let the user modify them as a series of named bitfields.
52 This structure describes a field in a bitmapped register. */
56 char *prefix; /* string appearing before the value */
57 char *suffix; /* string appearing after the value */
58 char *user_name; /* name used by human when entering field value */
59 int length; /* number of bits in the field */
60 int start; /* starting (least significant) bit number of field */
63 /* Local functions for register manipulation. */
65 static void r3900_supply_register PARAMS ((char *regname, int regnamelen,
66 char *val, int vallen));
67 static void fetch_bad_vaddr PARAMS ((void));
68 static unsigned long fetch_fields PARAMS ((struct bit_field * bf));
69 static void fetch_bitmapped_register PARAMS ((int regno,
70 struct bit_field * bf));
71 static void r3900_fetch_registers PARAMS ((int regno));
72 static void store_bitmapped_register PARAMS ((int regno,
73 struct bit_field * bf));
74 static void r3900_store_registers PARAMS ((int regno));
76 /* Local functions for fast binary loading. */
78 static void write_long PARAMS ((char *buf, long n));
79 static void write_long_le PARAMS ((char *buf, long n));
80 static int debug_readchar PARAMS ((int hex));
81 static void debug_write PARAMS ((unsigned char *buf, int buflen));
82 static void ignore_packet PARAMS ((void));
83 static void send_packet PARAMS ((char type, unsigned char *buf, int buflen,
85 static void process_read_request PARAMS ((unsigned char *buf, int buflen));
86 static void count_section PARAMS ((bfd * abfd, asection * s,
87 unsigned int *section_count));
88 static void load_section PARAMS ((bfd * abfd, asection * s,
89 unsigned int *data_count));
90 static void r3900_load PARAMS ((char *filename, int from_tty));
92 /* Miscellaneous local functions. */
94 static void r3900_open PARAMS ((char *args, int from_tty));
97 /* Pointers to static functions in monitor.c for fetching and storing
98 registers. We can't use these function in certain cases where the Densan
99 monitor acts perversely: for registers that it displays in bit-map
100 format, and those that can't be modified at all. In those cases
101 we have to use our own functions to fetch and store their values. */
103 static void (*orig_monitor_fetch_registers) PARAMS ((int regno));
104 static void (*orig_monitor_store_registers) PARAMS ((int regno));
106 /* Pointer to static function in monitor. for loading programs.
107 We use this function for loading S-records via the serial link. */
109 static void (*orig_monitor_load) PARAMS ((char *file, int from_tty));
111 /* This flag is set if a fast ethernet download should be used. */
113 static int ethernet = 0;
115 /* This array of registers needs to match the indexes used by GDB. The
116 whole reason this exists is because the various ROM monitors use
117 different names than GDB does, and don't support all the registers
120 static char *r3900_regnames[NUM_REGS] =
122 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
123 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
124 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
125 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
130 "B", /* BADVADDR_REGNUM */
131 "Pcause", /* CAUSE_REGNUM */
136 /* Table of register names produced by monitor's register dump command. */
138 static struct reg_entry
286 "BadV", BADVADDR_REGNUM
295 /* The monitor displays the cache register along with the status register,
296 as if they were a single register. So when we want to fetch the
297 status register, parse but otherwise ignore the fields of the
298 cache register that the monitor displays. Register fields that should
299 be ignored have a length of zero in the tables below. */
301 static struct bit_field status_fields[] =
303 /* Status register portion */
304 {"SR[<CU=", " ", "cu", 4, 28},
305 {"RE=", " ", "re", 1, 25},
306 {"BEV=", " ", "bev", 1, 22},
307 {"TS=", " ", "ts", 1, 21},
308 {"Nmi=", " ", "nmi", 1, 20},
309 {"INT=", " ", "int", 6, 10},
310 {"SW=", ">]", "sw", 2, 8},
311 {"[<KUO=", " ", "kuo", 1, 5},
312 {"IEO=", " ", "ieo", 1, 4},
313 {"KUP=", " ", "kup", 1, 3},
314 {"IEP=", " ", "iep", 1, 2},
315 {"KUC=", " ", "kuc", 1, 1},
316 {"IEC=", ">]", "iec", 1, 0},
318 /* Cache register portion (dummy for parsing only) */
319 {"CR[<IalO=", " ", "ialo", 0, 13},
320 {"DalO=", " ", "dalo", 0, 12},
321 {"IalP=", " ", "ialp", 0, 11},
322 {"DalP=", " ", "dalp", 0, 10},
323 {"IalC=", " ", "ialc", 0, 9},
324 {"DalC=", ">] ", "dalc", 0, 8},
326 {NULL, NULL, 0, 0} /* end of table marker */
330 #if 0 /* FIXME: Enable when we add support for modifying cache register. */
331 static struct bit_field cache_fields[] =
333 /* Status register portion (dummy for parsing only) */
334 {"SR[<CU=", " ", "cu", 0, 28},
335 {"RE=", " ", "re", 0, 25},
336 {"BEV=", " ", "bev", 0, 22},
337 {"TS=", " ", "ts", 0, 21},
338 {"Nmi=", " ", "nmi", 0, 20},
339 {"INT=", " ", "int", 0, 10},
340 {"SW=", ">]", "sw", 0, 8},
341 {"[<KUO=", " ", "kuo", 0, 5},
342 {"IEO=", " ", "ieo", 0, 4},
343 {"KUP=", " ", "kup", 0, 3},
344 {"IEP=", " ", "iep", 0, 2},
345 {"KUC=", " ", "kuc", 0, 1},
346 {"IEC=", ">]", "iec", 0, 0},
348 /* Cache register portion */
349 {"CR[<IalO=", " ", "ialo", 1, 13},
350 {"DalO=", " ", "dalo", 1, 12},
351 {"IalP=", " ", "ialp", 1, 11},
352 {"DalP=", " ", "dalp", 1, 10},
353 {"IalC=", " ", "ialc", 1, 9},
354 {"DalC=", ">] ", "dalc", 1, 8},
356 {NULL, NULL, NULL, 0, 0} /* end of table marker */
361 static struct bit_field cause_fields[] =
363 {"<BD=", " ", "bd", 1, 31},
364 {"CE=", " ", "ce", 2, 28},
365 {"IP=", " ", "ip", 6, 10},
366 {"SW=", " ", "sw", 2, 8},
367 {"EC=", ">]", "ec", 5, 2},
369 {NULL, NULL, NULL, 0, 0} /* end of table marker */
373 /* The monitor prints register values in the form
377 We look up the register name in a table, and remove the embedded space in
378 the hex value before passing it to monitor_supply_register. */
381 r3900_supply_register (regname, regnamelen, val, vallen)
392 /* Perform some sanity checks on the register name and value. */
393 if (regnamelen < 2 || regnamelen > 7 || vallen != 9)
396 /* Look up the register name. */
397 for (i = 0; reg_table[i].name != NULL; i++)
399 int rlen = strlen (reg_table[i].name);
400 if (rlen == regnamelen && strncmp (regname, reg_table[i].name, rlen) == 0)
402 regno = reg_table[i].regno;
409 /* Copy the hex value to a buffer and eliminate the embedded space. */
410 for (i = 0, p = valbuf; i < vallen; i++)
415 monitor_supply_register (regno, valbuf);
419 /* Fetch the BadVaddr register. Unlike the other registers, this
420 one can't be modified, and the monitor won't even prompt to let
428 monitor_printf ("xB\r");
429 monitor_expect ("BadV=", NULL, 0);
430 monitor_expect_prompt (buf, sizeof (buf));
431 monitor_supply_register (BADVADDR_REGNUM, buf);
435 /* Read a series of bit fields from the monitor, and return their
436 combined binary value. */
440 struct bit_field *bf;
443 unsigned long val = 0;
446 for (; bf->prefix != NULL; bf++)
448 monitor_expect (bf->prefix, NULL, 0); /* get prefix */
449 monitor_expect (bf->suffix, buf, sizeof (buf)); /* hex value, suffix */
452 bits = strtoul (buf, NULL, 16); /* get field value */
453 bits &= ((1 << bf->length) - 1); /* mask out useless bits */
454 val |= bits << bf->start; /* insert into register */
464 fetch_bitmapped_register (regno, bf)
466 struct bit_field *bf;
469 unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
471 monitor_printf ("x%s\r", r3900_regnames[regno]);
472 val = fetch_fields (bf);
473 monitor_printf (".\r");
474 monitor_expect_prompt (NULL, 0);
476 /* supply register stores in target byte order, so swap here */
478 store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
479 supply_register (regno, regbuf);
484 /* Fetch all registers (if regno is -1), or one register from the
485 monitor. For most registers, we can use the generic monitor_
486 monitor_fetch_registers function. But others are displayed in
487 a very unusual fashion by the monitor, and must be handled specially. */
490 r3900_fetch_registers (regno)
495 case BADVADDR_REGNUM:
499 fetch_bitmapped_register (PS_REGNUM, status_fields);
502 fetch_bitmapped_register (CAUSE_REGNUM, cause_fields);
505 orig_monitor_fetch_registers (regno);
510 /* Write the new value of the bitmapped register to the monitor. */
513 store_bitmapped_register (regno, bf)
515 struct bit_field *bf;
517 unsigned long oldval, newval;
519 /* Fetch the current value of the register. */
520 monitor_printf ("x%s\r", r3900_regnames[regno]);
521 oldval = fetch_fields (bf);
522 newval = read_register (regno);
524 /* To save time, write just the fields that have changed. */
525 for (; bf->prefix != NULL; bf++)
529 unsigned long oldbits, newbits, mask;
531 mask = (1 << bf->length) - 1;
532 oldbits = (oldval >> bf->start) & mask;
533 newbits = (newval >> bf->start) & mask;
534 if (oldbits != newbits)
535 monitor_printf ("%s %lx ", bf->user_name, newbits);
539 monitor_printf (".\r");
540 monitor_expect_prompt (NULL, 0);
545 r3900_store_registers (regno)
551 store_bitmapped_register (PS_REGNUM, status_fields);
554 store_bitmapped_register (CAUSE_REGNUM, cause_fields);
557 orig_monitor_store_registers (regno);
562 /* Write a 4-byte integer to the buffer in big-endian order. */
569 buf[0] = (n >> 24) & 0xff;
570 buf[1] = (n >> 16) & 0xff;
571 buf[2] = (n >> 8) & 0xff;
576 /* Write a 4-byte integer to the buffer in little-endian order. */
579 write_long_le (buf, n)
584 buf[1] = (n >> 8) & 0xff;
585 buf[2] = (n >> 16) & 0xff;
586 buf[3] = (n >> 24) & 0xff;
590 /* Read a character from the monitor. If remote debugging is on,
591 print the received character. If HEX is non-zero, print the
592 character in hexadecimal; otherwise, print it in ASCII. */
599 int c = monitor_readchar ();
601 if (remote_debug > 0)
604 sprintf (buf, "[%02x]", c & 0xff);
612 puts_debug ("Read -->", buf, "<--");
618 /* Send a buffer of characters to the monitor. If remote debugging is on,
619 print the sent buffer in hex. */
622 debug_write (buf, buflen)
628 monitor_write (buf, buflen);
630 if (remote_debug > 0)
634 sprintf (s, "[%02x]", *buf & 0xff);
635 puts_debug ("Sent -->", s, "<--");
642 /* Ignore a packet sent to us by the monitor. It send packets
643 when its console is in "communications interface" mode. A packet
646 start of packet flag (one byte: 0xdc)
647 packet type (one byte)
652 The last two bytes of the data field are a checksum, but we don't
662 /* Ignore lots of trash (messages about section addresses, for example)
663 until we see the start of a packet. */
664 for (len = 0; len < 256; len++)
666 c = debug_readchar (0);
671 error ("Packet header byte not found; %02x seen instead.", c);
673 /* Read the packet type and length. */
674 c = debug_readchar (1); /* type */
676 c = debug_readchar (1); /* low byte of length */
679 c = debug_readchar (1); /* high byte of length */
680 len += (c & 0xff) << 8;
682 /* Ignore the rest of the packet. */
684 c = debug_readchar (1);
688 /* Encapsulate some data into a packet and send it to the monitor.
690 The 'p' packet is a special case. This is a packet we send
691 in response to a read ('r') packet from the monitor. This function
692 appends a one-byte sequence number to the data field of such a packet.
696 send_packet (type, buf, buflen, seq)
701 unsigned char hdr[4];
705 /* If this is a 'p' packet, add one byte for a sequence number. */
709 /* If the buffer has a non-zero length, add two bytes for a checksum. */
713 /* Write the packet header. */
717 hdr[3] = (len >> 8) & 0xff;
718 debug_write (hdr, sizeof (hdr));
722 /* Write the packet data. */
723 debug_write (buf, buflen);
725 /* Write the sequence number if this is a 'p' packet. */
729 debug_write (hdr, 1);
732 /* Write the checksum. */
734 for (i = 0; i < buflen; i++)
736 int tmp = (buf[i] & 0xff);
747 sum += (seq & 0xff) << 8;
749 sum = (sum & 0xffff) + ((sum >> 16) & 0xffff);
750 sum += (sum >> 16) & 1;
753 hdr[0] = (sum >> 8) & 0xff;
755 debug_write (hdr, 2);
760 /* Respond to an expected read request from the monitor by sending
761 data in chunks. Handle all acknowledgements and handshaking packets.
763 The monitor expects a response consisting of a one or more 'p' packets,
764 each followed by a portion of the data requested. The 'p' packet
765 contains only a four-byte integer, the value of which is the number
766 of bytes of data we are about to send. Following the 'p' packet,
767 the monitor expects the data bytes themselves in raw, unpacketized,
768 form, without even a checksum.
772 process_read_request (buf, buflen)
776 unsigned char len[4];
780 /* Discard the read request. FIXME: we have to hope it's for
781 the exact number of bytes we want to send; should check for this. */
784 for (i = chunk = 0, seq = 0; i < buflen; i += chunk, seq++)
786 /* Don't send more than MAXPSIZE bytes at a time. */
788 if (chunk > MAXPSIZE)
791 /* Write a packet containing the number of bytes we are sending. */
792 write_long_le (len, chunk);
793 send_packet ('p', len, sizeof (len), seq);
795 /* Write the data in raw form following the packet. */
796 debug_write (&buf[i], chunk);
798 /* Discard the ACK packet. */
802 /* Send an "end of data" packet. */
803 send_packet ('e', "", 0, 0);
807 /* Count loadable sections (helper function for r3900_load). */
810 count_section (abfd, s, section_count)
813 unsigned int *section_count;
815 if (s->flags & SEC_LOAD && bfd_section_size (abfd, s) != 0)
820 /* Load a single BFD section (helper function for r3900_load).
822 WARNING: this code is filled with assumptions about how
823 the Densan monitor loads programs. The monitor issues
824 packets containing read requests, but rather than respond
825 to them in an general way, we expect them to following
828 For example, we know that the monitor will start loading by
829 issuing an 8-byte read request for the binary file header.
830 We know this is coming and ignore the actual contents
831 of the read request packet.
835 load_section (abfd, s, data_count)
838 unsigned int *data_count;
840 if (s->flags & SEC_LOAD)
842 bfd_size_type section_size = bfd_section_size (abfd, s);
843 bfd_vma section_base = bfd_section_lma (abfd, s);
844 unsigned char *buffer;
845 unsigned char header[8];
847 /* Don't output zero-length sections. */
848 if (section_size == 0)
851 *data_count += section_size;
853 /* Print some fluff about the section being loaded. */
854 printf_filtered ("Loading section %s, size 0x%lx lma ",
855 bfd_section_name (abfd, s), (long) section_size);
856 print_address_numeric (section_base, 1, gdb_stdout);
857 printf_filtered ("\n");
858 gdb_flush (gdb_stdout);
860 /* Write the section header (location and size). */
861 write_long (&header[0], (long) section_base);
862 write_long (&header[4], (long) section_size);
863 process_read_request (header, sizeof (header));
865 /* Read the section contents into a buffer, write it out,
866 then free the buffer. */
867 buffer = (unsigned char *) xmalloc (section_size);
868 bfd_get_section_contents (abfd, s, buffer, 0, section_size);
869 process_read_request (buffer, section_size);
875 /* When the ethernet is used as the console port on the Densan board,
876 we can use the "Rm" command to do a fast binary load. The format
877 of the download data is:
879 number of sections (4 bytes)
880 starting address (4 bytes)
881 repeat for each section:
882 location address (4 bytes)
883 section size (4 bytes)
886 The 4-byte fields are all in big-endian order.
888 Using this command is tricky because we have to put the monitor
889 into a special funky "communications interface" mode, in which
890 it sends and receives packets of data along with the normal prompt.
894 r3900_load (filename, from_tty)
899 unsigned int data_count = 0;
900 time_t start_time, end_time; /* for timing of download */
901 int section_count = 0;
902 unsigned char buffer[8];
904 /* If we are not using the ethernet, use the normal monitor load,
905 which sends S-records over the serial link. */
908 orig_monitor_load (filename, from_tty);
913 if (filename == NULL || filename[0] == 0)
914 filename = get_exec_file (1);
915 abfd = bfd_openr (filename, 0);
917 error ("Unable to open file %s\n", filename);
918 if (bfd_check_format (abfd, bfd_object) == 0)
919 error ("File is not an object file\n");
921 /* Output the "vconsi" command to get the monitor in the communication
922 state where it will accept a load command. This will cause
923 the monitor to emit a packet before each prompt, so ignore the packet. */
924 monitor_printf ("vconsi\r");
926 monitor_expect_prompt (NULL, 0);
928 /* Output the "Rm" (load) command and respond to the subsequent "open"
929 packet by sending an ACK packet. */
930 monitor_printf ("Rm\r");
932 send_packet ('a', "", 0, 0);
934 /* Output the fast load header (number of sections and starting address). */
935 bfd_map_over_sections ((bfd *) abfd, (section_map_func) count_section,
937 write_long (&buffer[0], (long) section_count);
939 write_long (&buffer[4], (long) bfd_get_start_address (exec_bfd));
941 write_long (&buffer[4], 0);
942 process_read_request (buffer, sizeof (buffer));
944 /* Output the section data. */
945 start_time = time (NULL);
946 bfd_map_over_sections (abfd, (section_map_func) load_section, &data_count);
947 end_time = time (NULL);
949 /* Acknowledge the close packet and put the monitor back into
950 "normal" mode so it won't send packets any more. */
952 send_packet ('a', "", 0, 0);
953 monitor_expect_prompt (NULL, 0);
954 monitor_printf ("vconsx\r");
955 monitor_expect_prompt (NULL, 0);
957 /* Print start address and download performance information. */
958 printf_filtered ("Start address 0x%lx\n", (long) bfd_get_start_address (abfd));
959 report_transfer_performance (data_count, start_time, end_time);
961 /* Finally, make the PC point at the start address */
963 write_pc (bfd_get_start_address (exec_bfd));
965 inferior_pid = 0; /* No process now */
967 /* This is necessary because many things were based on the PC at the
968 time that we attached to the monitor, which is no longer valid
969 now that we have loaded new code (and just changed the PC).
970 Another way to do this might be to call normal_stop, except that
971 the stack may not be valid, and things would get horribly
973 clear_symtab_users ();
977 /* Commands to send to the monitor when first connecting:
978 * The bare carriage return forces a prompt from the monitor
979 (monitor doesn't prompt immediately after a reset).
980 * The "vconsx" switches the monitor back to interactive mode
981 in case an aborted download had left it in packet mode.
982 * The "Xtr" command causes subsequent "t" (trace) commands to display
983 the general registers only.
984 * The "Xxr" command does the same thing for the "x" (examine
986 * The "bx" command clears all breakpoints.
989 static char *r3900_inits[] =
990 {"\r", "vconsx\r", "Xtr\r", "Xxr\r", "bx\r", NULL};
991 static char *dummy_inits[] =
994 static struct target_ops r3900_ops;
995 static struct monitor_ops r3900_cmds;
998 r3900_open (args, from_tty)
1005 monitor_open (args, &r3900_cmds, from_tty);
1007 /* We have to handle sending the init strings ourselves, because
1008 the first two strings we send (carriage returns) may not be echoed
1009 by the monitor, but the rest will be. */
1010 monitor_printf_noecho ("\r\r");
1011 for (i = 0; r3900_inits[i] != NULL; i++)
1013 monitor_printf (r3900_inits[i]);
1014 monitor_expect_prompt (NULL, 0);
1017 /* Attempt to determine whether the console device is ethernet or serial.
1018 This will tell us which kind of load to use (S-records over a serial
1019 link, or the Densan fast binary multi-section format over the net). */
1022 monitor_printf ("v\r");
1023 if (monitor_expect ("console device :", NULL, 0) != -1)
1024 if (monitor_expect ("\n", buf, sizeof (buf)) != -1)
1025 if (strstr (buf, "ethernet") != NULL)
1027 monitor_expect_prompt (NULL, 0);
1031 _initialize_r3900_rom ()
1033 r3900_cmds.flags = MO_NO_ECHO_ON_OPEN |
1034 MO_ADDR_BITS_REMOVE |
1035 MO_CLR_BREAK_USES_ADDR |
1036 MO_GETMEM_READ_SINGLE |
1037 MO_PRINT_PROGRAM_OUTPUT;
1039 r3900_cmds.init = dummy_inits;
1040 r3900_cmds.cont = "g\r";
1041 r3900_cmds.step = "t\r";
1042 r3900_cmds.set_break = "b %A\r"; /* COREADDR */
1043 r3900_cmds.clr_break = "b %A,0\r"; /* COREADDR */
1044 r3900_cmds.fill = "fx %A s %x %x\r"; /* COREADDR, len, val */
1046 r3900_cmds.setmem.cmdb = "sx %A %x\r"; /* COREADDR, val */
1047 r3900_cmds.setmem.cmdw = "sh %A %x\r"; /* COREADDR, val */
1048 r3900_cmds.setmem.cmdl = "sw %A %x\r"; /* COREADDR, val */
1050 r3900_cmds.getmem.cmdb = "sx %A\r"; /* COREADDR */
1051 r3900_cmds.getmem.cmdw = "sh %A\r"; /* COREADDR */
1052 r3900_cmds.getmem.cmdl = "sw %A\r"; /* COREADDR */
1053 r3900_cmds.getmem.resp_delim = " : ";
1054 r3900_cmds.getmem.term = " ";
1055 r3900_cmds.getmem.term_cmd = ".\r";
1057 r3900_cmds.setreg.cmd = "x%s %x\r"; /* regname, val */
1059 r3900_cmds.getreg.cmd = "x%s\r"; /* regname */
1060 r3900_cmds.getreg.resp_delim = "=";
1061 r3900_cmds.getreg.term = " ";
1062 r3900_cmds.getreg.term_cmd = ".\r";
1064 r3900_cmds.dump_registers = "x\r";
1065 r3900_cmds.register_pattern =
1066 "\\([a-zA-Z0-9_]+\\) *=\\([0-9a-f]+ [0-9a-f]+\\b\\)";
1067 r3900_cmds.supply_register = r3900_supply_register;
1068 /* S-record download, via "keyboard port". */
1069 r3900_cmds.load = "r0\r";
1070 r3900_cmds.prompt = "#";
1071 r3900_cmds.line_term = "\r";
1072 r3900_cmds.target = &r3900_ops;
1073 r3900_cmds.stopbits = SERIAL_1_STOPBITS;
1074 r3900_cmds.regnames = r3900_regnames;
1075 r3900_cmds.magic = MONITOR_OPS_MAGIC;
1077 init_monitor_ops (&r3900_ops);
1079 r3900_ops.to_shortname = "r3900";
1080 r3900_ops.to_longname = "R3900 monitor";
1081 r3900_ops.to_doc = "Debug using the DVE R3900 monitor.\n\
1082 Specify the serial device it is connected to (e.g. /dev/ttya).";
1083 r3900_ops.to_open = r3900_open;
1085 /* Override the functions to fetch and store registers. But save the
1086 addresses of the default functions, because we will use those functions
1087 for "normal" registers. */
1089 orig_monitor_fetch_registers = r3900_ops.to_fetch_registers;
1090 orig_monitor_store_registers = r3900_ops.to_store_registers;
1091 r3900_ops.to_fetch_registers = r3900_fetch_registers;
1092 r3900_ops.to_store_registers = r3900_store_registers;
1094 /* Override the load function, but save the address of the default
1095 function to use when loading S-records over a serial link. */
1096 orig_monitor_load = r3900_ops.to_load;
1097 r3900_ops.to_load = r3900_load;
1099 add_target (&r3900_ops);