1 /* Remote target communications for serial-line targets using SDS' protocol.
3 Copyright 1997, 1998, 1999, 2000, 2001, 2002 Free Software
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* This interface was written by studying the behavior of the SDS
24 monitor on an ADS 821/860 board, and by consulting the
25 documentation of the monitor that is available on Motorola's web
29 #include "gdb_string.h"
38 #include "gdb-stabs.h"
39 #include "gdbthread.h"
44 #include <sys/types.h>
50 extern void _initialize_remote_sds (void);
52 /* Declarations of local functions. */
54 static int sds_write_bytes (CORE_ADDR
, char *, int);
56 static int sds_read_bytes (CORE_ADDR
, char *, int);
58 static void sds_files_info (struct target_ops
*ignore
);
60 static int sds_xfer_memory (CORE_ADDR
, char *, int, int,
61 struct mem_attrib
*, struct target_ops
*);
63 static void sds_prepare_to_store (void);
65 static void sds_fetch_registers (int);
67 static void sds_resume (ptid_t
, int, enum target_signal
);
69 static int sds_start_remote (void *);
71 static void sds_open (char *, int);
73 static void sds_close (int);
75 static void sds_store_registers (int);
77 static void sds_mourn (void);
79 static void sds_create_inferior (char *, char *, char **);
81 static void sds_load (char *, int);
83 static int getmessage (unsigned char *, int);
85 static int putmessage (unsigned char *, int);
87 static int sds_send (unsigned char *, int);
89 static int readchar (int);
91 static ptid_t
sds_wait (ptid_t
, struct target_waitstatus
*);
93 static void sds_kill (void);
95 static int tohex (int);
97 static int fromhex (int);
99 static void sds_detach (char *, int);
101 static void sds_interrupt (int);
103 static void sds_interrupt_twice (int);
105 static void interrupt_query (void);
107 static int read_frame (char *);
109 static int sds_insert_breakpoint (CORE_ADDR
, char *);
111 static int sds_remove_breakpoint (CORE_ADDR
, char *);
113 static void init_sds_ops (void);
115 static void sds_command (char *args
, int from_tty
);
117 /* Define the target operations vector. */
119 static struct target_ops sds_ops
;
121 /* This was 5 seconds, which is a long time to sit and wait.
122 Unless this is going though some terminal server or multiplexer or
123 other form of hairy serial connection, I would think 2 seconds would
126 static int sds_timeout
= 2;
128 /* Descriptor for I/O to remote machine. Initialize it to NULL so
129 that sds_open knows that we don't have a file open when the program
132 static struct serial
*sds_desc
= NULL
;
134 /* This limit comes from the monitor. */
138 /* Maximum number of bytes to read/write at once. The value here
139 is chosen to fill up a packet (the headers account for the 32). */
140 #define MAXBUFBYTES ((PBUFSIZ-32)/2)
142 static int next_msg_id
;
144 static int just_started
;
146 static int message_pending
;
149 /* Clean up connection to a remote debugger. */
152 sds_close (int quitting
)
155 serial_close (sds_desc
);
159 /* Stub for catch_errors. */
162 sds_start_remote (void *dummy
)
165 unsigned char buf
[200];
167 immediate_quit
++; /* Allow user to interrupt it */
169 /* Ack any packet which the remote side has already sent. */
170 serial_write (sds_desc
, "{#*\r\n", 5);
171 serial_write (sds_desc
, "{#}\r\n", 5);
173 while ((c
= readchar (1)) >= 0)
174 printf_unfiltered ("%c", c
);
175 printf_unfiltered ("\n");
187 start_remote (); /* Initialize gdb process mechanisms */
191 /* Open a connection to a remote debugger.
192 NAME is the filename used for communication. */
195 sds_open (char *name
, int from_tty
)
198 error ("To open a remote debug connection, you need to specify what serial\n\
199 device is attached to the remote system (e.g. /dev/ttya).");
201 target_preopen (from_tty
);
203 unpush_target (&sds_ops
);
205 sds_desc
= serial_open (name
);
207 perror_with_name (name
);
211 if (serial_setbaudrate (sds_desc
, baud_rate
))
213 serial_close (sds_desc
);
214 perror_with_name (name
);
219 serial_raw (sds_desc
);
221 /* If there is something sitting in the buffer we might take it as a
222 response to a command, which would be bad. */
223 serial_flush_input (sds_desc
);
227 puts_filtered ("Remote debugging using ");
228 puts_filtered (name
);
229 puts_filtered ("\n");
231 push_target (&sds_ops
); /* Switch to using remote target now */
235 /* Start the remote connection; if error (0), discard this target.
236 In particular, if the user quits, be sure to discard it (we'd be
237 in an inconsistent state otherwise). */
238 if (!catch_errors (sds_start_remote
, NULL
,
239 "Couldn't establish connection to remote target\n",
244 /* This takes a program previously attached to and detaches it. After
245 this is done, GDB can be used to debug some other program. We
246 better not have left any breakpoints in the target program or it'll
247 die when it hits one. */
250 sds_detach (char *args
, int from_tty
)
255 error ("Argument given to \"detach\" when remotely debugging.");
258 /* Tell the remote target to detach. */
265 puts_filtered ("Ending remote debugging.\n");
268 /* Convert hex digit A to a number. */
273 if (a
>= '0' && a
<= '9')
275 else if (a
>= 'a' && a
<= 'f')
278 error ("Reply contains invalid hex digit %d", a
);
281 /* Convert number NIB to a hex digit. */
289 return 'a' + nib
- 10;
293 tob64 (unsigned char *inbuf
, char *outbuf
, int len
)
299 error ("bad length");
302 for (i
= 0; i
< len
; i
+= 3)
304 /* Collect the next three bytes into a number. */
305 sum
= ((long) *inbuf
++) << 16;
306 sum
|= ((long) *inbuf
++) << 8;
307 sum
|= ((long) *inbuf
++);
309 /* Spit out 4 6-bit encodings. */
310 *p
++ = ((sum
>> 18) & 0x3f) + '0';
311 *p
++ = ((sum
>> 12) & 0x3f) + '0';
312 *p
++ = ((sum
>> 6) & 0x3f) + '0';
313 *p
++ = (sum
& 0x3f) + '0';
319 fromb64 (char *inbuf
, char *outbuf
, int len
)
324 error ("bad length");
326 for (i
= 0; i
< len
; i
+= 4)
328 /* Collect 4 6-bit digits. */
329 sum
= (*inbuf
++ - '0') << 18;
330 sum
|= (*inbuf
++ - '0') << 12;
331 sum
|= (*inbuf
++ - '0') << 6;
332 sum
|= (*inbuf
++ - '0');
334 /* Now take the resulting 24-bit number and get three bytes out
336 *outbuf
++ = (sum
>> 16) & 0xff;
337 *outbuf
++ = (sum
>> 8) & 0xff;
338 *outbuf
++ = sum
& 0xff;
341 return (len
/ 4) * 3;
345 /* Tell the remote machine to resume. */
347 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
351 sds_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
353 unsigned char buf
[PBUFSIZ
];
355 last_sent_signal
= siggnal
;
356 last_sent_step
= step
;
358 buf
[0] = (step
? 21 : 20);
359 buf
[1] = 0; /* (should be signal?) */
364 /* Send a message to target to halt it. Target will respond, and send
365 us a message pending notice. */
368 sds_interrupt (int signo
)
370 unsigned char buf
[PBUFSIZ
];
372 /* If this doesn't work, try more severe steps. */
373 signal (signo
, sds_interrupt_twice
);
376 fprintf_unfiltered (gdb_stdlog
, "sds_interrupt called\n");
382 static void (*ofunc
) ();
384 /* The user typed ^C twice. */
387 sds_interrupt_twice (int signo
)
389 signal (signo
, ofunc
);
393 signal (signo
, sds_interrupt
);
396 /* Ask the user what to do when an interrupt is received. */
399 interrupt_query (void)
401 target_terminal_ours ();
403 if (query ("Interrupted while waiting for the program.\n\
404 Give up (and stop debugging it)? "))
406 target_mourn_inferior ();
407 throw_exception (RETURN_QUIT
);
410 target_terminal_inferior ();
413 /* If nonzero, ignore the next kill. */
416 /* Wait until the remote machine stops, then return, storing status in
417 STATUS just as `wait' would. Returns "pid" (though it's not clear
418 what, if anything, that means in the case of this target). */
421 sds_wait (ptid_t ptid
, struct target_waitstatus
*status
)
423 unsigned char buf
[PBUFSIZ
];
426 status
->kind
= TARGET_WAITKIND_EXITED
;
427 status
->value
.integer
= 0;
429 ofunc
= (void (*)()) signal (SIGINT
, sds_interrupt
);
431 signal (SIGINT
, ofunc
);
436 status
->kind
= TARGET_WAITKIND_STOPPED
;
437 return inferior_ptid
;
447 retlen
= sds_send (buf
, 1);
450 fprintf_unfiltered (gdb_stdlog
, "Signals: %02x%02x %02x %02x\n",
455 status
->kind
= TARGET_WAITKIND_STOPPED
;
456 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
461 return inferior_ptid
;
464 static unsigned char sprs
[16];
466 /* Read the remote registers into the block REGS. */
467 /* Currently we just read all the registers, so we don't use regno. */
470 sds_fetch_registers (int regno
)
472 unsigned char buf
[PBUFSIZ
];
474 char *regs
= alloca (DEPRECATED_REGISTER_BYTES
);
476 /* Unimplemented registers read as all bits zero. */
477 memset (regs
, 0, DEPRECATED_REGISTER_BYTES
);
482 retlen
= sds_send (buf
, 3);
484 for (i
= 0; i
< 4 * 6; ++i
)
485 regs
[i
+ 4 * 32 + 8 * 32] = buf
[i
];
486 for (i
= 0; i
< 4 * 4; ++i
)
487 sprs
[i
] = buf
[i
+ 4 * 7];
492 retlen
= sds_send (buf
, 3);
494 for (i
= 0; i
< retlen
; i
++)
497 /* (should warn about reply too short) */
499 for (i
= 0; i
< NUM_REGS
; i
++)
500 supply_register (i
, ®s
[DEPRECATED_REGISTER_BYTE (i
)]);
503 /* Prepare to store registers. Since we may send them all, we have to
504 read out the ones we don't want to change first. */
507 sds_prepare_to_store (void)
509 /* Make sure the entire registers array is valid. */
510 deprecated_read_register_bytes (0, (char *) NULL
, DEPRECATED_REGISTER_BYTES
);
513 /* Store register REGNO, or all registers if REGNO == -1, from the contents
514 of REGISTERS. FIXME: ignores errors. */
517 sds_store_registers (int regno
)
519 unsigned char *p
, buf
[PBUFSIZ
];
522 /* Store all the special-purpose registers. */
528 for (i
= 0; i
< 4 * 6; i
++)
529 *p
++ = deprecated_registers
[i
+ 4 * 32 + 8 * 32];
530 for (i
= 0; i
< 4 * 1; i
++)
532 for (i
= 0; i
< 4 * 4; i
++)
535 sds_send (buf
, p
- buf
);
537 /* Store all the general-purpose registers. */
543 for (i
= 0; i
< 4 * 32; i
++)
544 *p
++ = deprecated_registers
[i
];
546 sds_send (buf
, p
- buf
);
550 /* Write memory data directly to the remote machine. This does not
551 inform the data cache; the data cache uses this. MEMADDR is the
552 address in the remote memory space. MYADDR is the address of the
553 buffer in our space. LEN is the number of bytes.
555 Returns number of bytes transferred, or 0 for error. */
558 sds_write_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
560 int max_buf_size
; /* Max size of packet output buffer */
562 unsigned char buf
[PBUFSIZ
];
566 /* Chop the transfer down if necessary */
573 todo
= min (len
, max_buf_size
);
577 buf
[2] = (int) (memaddr
>> 24) & 0xff;
578 buf
[3] = (int) (memaddr
>> 16) & 0xff;
579 buf
[4] = (int) (memaddr
>> 8) & 0xff;
580 buf
[5] = (int) (memaddr
) & 0xff;
584 for (i
= 0; i
< todo
; i
++)
585 buf
[i
+ 8] = myaddr
[i
];
587 sds_send (buf
, 8 + todo
);
589 /* (should look at result) */
598 /* Read memory data directly from the remote machine. This does not
599 use the data cache; the data cache uses this. MEMADDR is the
600 address in the remote memory space. MYADDR is the address of the
601 buffer in our space. LEN is the number of bytes.
603 Returns number of bytes transferred, or 0 for error. */
606 sds_read_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
608 int max_buf_size
; /* Max size of packet output buffer */
610 unsigned char buf
[PBUFSIZ
];
614 /* Chop the transfer down if necessary */
621 todo
= min (len
, max_buf_size
);
625 buf
[2] = (int) (memaddr
>> 24) & 0xff;
626 buf
[3] = (int) (memaddr
>> 16) & 0xff;
627 buf
[4] = (int) (memaddr
>> 8) & 0xff;
628 buf
[5] = (int) (memaddr
) & 0xff;
629 buf
[6] = (int) (todo
>> 8) & 0xff;
630 buf
[7] = (int) (todo
) & 0xff;
633 retlen
= sds_send (buf
, 9);
635 if (retlen
- 2 != todo
)
640 /* Reply describes memory byte by byte. */
642 for (i
= 0; i
< todo
; i
++)
643 myaddr
[i
] = buf
[i
+ 2];
653 /* Read or write LEN bytes from inferior memory at MEMADDR,
654 transferring to or from debugger address MYADDR. Write to inferior
655 if SHOULD_WRITE is nonzero. Returns length of data written or
656 read; 0 for error. TARGET is unused. */
659 sds_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int should_write
,
660 struct mem_attrib
*attrib
, struct target_ops
*target
)
665 res
= sds_write_bytes (memaddr
, myaddr
, len
);
667 res
= sds_read_bytes (memaddr
, myaddr
, len
);
674 sds_files_info (struct target_ops
*ignore
)
676 puts_filtered ("Debugging over a serial connection, using SDS protocol.\n");
679 /* Stuff for dealing with the packets which are part of this protocol.
680 See comment at top of file for details. */
682 /* Read a single character from the remote end, masking it down to 7 bits. */
685 readchar (int timeout
)
689 ch
= serial_readchar (sds_desc
, timeout
);
691 if (remote_debug
> 1 && ch
>= 0)
692 fprintf_unfiltered (gdb_stdlog
, "%c(%x)", ch
, ch
);
697 error ("Remote connection closed");
699 perror_with_name ("Remote communication error");
707 /* An SDS-style checksum is a sum of the bytes modulo 253. (Presumably
708 because 253, 254, and 255 are special flags in the protocol.) */
711 compute_checksum (int csum
, char *buf
, int len
)
715 for (i
= 0; i
< len
; ++i
)
716 csum
+= (unsigned char) buf
[i
];
722 /* Send the command in BUF to the remote machine, and read the reply
726 sds_send (unsigned char *buf
, int len
)
728 putmessage (buf
, len
);
730 return getmessage (buf
, 0);
733 /* Send a message to the remote machine. */
736 putmessage (unsigned char *buf
, int len
)
739 unsigned char csum
= 0;
740 char buf2
[PBUFSIZ
], buf3
[PBUFSIZ
];
741 unsigned char header
[3];
744 /* Copy the packet into buffer BUF2, encapsulating it
745 and giving it a checksum. */
747 if (len
> 170) /* Prosanity check */
748 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
752 fprintf_unfiltered (gdb_stdlog
, "Message to send: \"");
753 for (i
= 0; i
< len
; ++i
)
754 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
755 fprintf_unfiltered (gdb_stdlog
, "\"\n");
767 header
[1] = next_msg_id
;
771 csum
= compute_checksum (csum
, buf
, len
);
772 csum
= compute_checksum (csum
, header
+ 1, 2);
776 tob64 (header
, p
, 3);
778 enclen
= tob64 (buf
, buf3
, ((len
+ 2) / 3) * 3);
780 for (i
= 0; i
< enclen
; ++i
)
785 next_msg_id
= (next_msg_id
+ 3) % 245;
787 /* Send it over and over until we get a positive ack. */
794 fprintf_unfiltered (gdb_stdlog
, "Sending encoded: \"%s\"", buf2
);
795 fprintf_unfiltered (gdb_stdlog
,
796 " (Checksum %d, id %d, length %d)\n",
797 header
[0], header
[1], header
[2]);
798 gdb_flush (gdb_stdlog
);
800 if (serial_write (sds_desc
, buf2
, p
- buf2
))
801 perror_with_name ("putmessage: write failed");
807 /* Come here after finding the start of the frame. Collect the rest
808 into BUF. Returns 0 on any error, 1 on success. */
811 read_frame (char *buf
)
820 c
= readchar (sds_timeout
);
826 fputs_filtered ("Timeout in mid-message, retrying\n", gdb_stdlog
);
830 fputs_filtered ("Saw new packet start in middle of old one\n",
832 return 0; /* Start a new packet, count retries */
840 fprintf_unfiltered (gdb_stdlog
, "Received encoded: \"%s\"\n",
846 if (bp
< buf
+ PBUFSIZ
- 1)
853 puts_filtered ("Message too long: ");
855 puts_filtered ("\n");
862 /* Read a packet from the remote machine, with error checking,
863 and store it in BUF. BUF is expected to be of size PBUFSIZ.
864 If FOREVER, wait forever rather than timing out; this is used
865 while the target is executing user code. */
868 getmessage (unsigned char *buf
, int forever
)
873 int val
, i
, len
, csum
;
874 unsigned char header
[3];
875 unsigned char inbuf
[500];
877 strcpy (buf
, "timeout");
881 timeout
= watchdog
> 0 ? watchdog
: -1;
885 timeout
= sds_timeout
;
889 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
891 /* This can loop forever if the remote side sends us characters
892 continuously, but if it pauses, we'll get a zero from readchar
893 because of timeout. Then we'll count that as a retry. */
895 /* Note that we will only wait forever prior to the start of a packet.
896 After that, we expect characters to arrive at a brisk pace. They
897 should show up within sds_timeout intervals. */
901 c
= readchar (timeout
);
903 if (c
== SERIAL_TIMEOUT
)
905 if (forever
) /* Watchdog went off. Kill the target. */
907 target_mourn_inferior ();
908 error ("Watchdog has expired. Target detached.\n");
911 fputs_filtered ("Timed out.\n", gdb_stdlog
);
915 while (c
!= '$' && c
!= '{');
917 /* We might have seen a "trigraph", a sequence of three characters
918 that indicate various sorts of communication state. */
922 /* Read the other two chars of the trigraph. */
923 c2
= readchar (timeout
);
924 c3
= readchar (timeout
);
926 fprintf_unfiltered (gdb_stdlog
, "Trigraph %c%c%c received\n",
936 val
= read_frame (inbuf
);
940 fromb64 (inbuf
, header
, 4);
941 /* (should check out other bits) */
942 fromb64 (inbuf
+ 4, buf
, strlen (inbuf
) - 4);
947 csum
= compute_checksum (csum
, buf
, len
);
948 csum
= compute_checksum (csum
, header
+ 1, 2);
950 if (csum
!= header
[0])
951 fprintf_unfiltered (gdb_stderr
,
952 "Checksum mismatch: computed %d, received %d\n",
955 if (header
[2] == 0xff)
956 fprintf_unfiltered (gdb_stderr
, "Requesting resend...\n");
960 fprintf_unfiltered (gdb_stdlog
,
961 "... (Got checksum %d, id %d, length %d)\n",
962 header
[0], header
[1], header
[2]);
963 fprintf_unfiltered (gdb_stdlog
, "Message received: \"");
964 for (i
= 0; i
< len
; ++i
)
966 fprintf_unfiltered (gdb_stdlog
, "%02x", (unsigned char) buf
[i
]);
968 fprintf_unfiltered (gdb_stdlog
, "\"\n");
971 /* no ack required? */
975 /* Try the whole thing again. */
977 /* need to do something here */
981 /* We have tried hard enough, and just can't receive the packet. Give up. */
983 printf_unfiltered ("Ignoring packet error, continuing...\n");
990 /* Don't try to do anything to the target. */
996 unpush_target (&sds_ops
);
997 generic_mourn_inferior ();
1001 sds_create_inferior (char *exec_file
, char *args
, char **env
)
1003 inferior_ptid
= pid_to_ptid (42000);
1005 /* Clean up from the last time we were running. */
1006 clear_proceed_status ();
1008 /* Let the remote process run. */
1009 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1013 sds_load (char *filename
, int from_tty
)
1015 generic_load (filename
, from_tty
);
1017 inferior_ptid
= null_ptid
;
1020 /* The SDS monitor has commands for breakpoint insertion, although it
1021 it doesn't actually manage the breakpoints, it just returns the
1022 replaced instruction back to the debugger. */
1025 sds_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1028 unsigned char *p
, buf
[PBUFSIZ
];
1033 *p
++ = (int) (addr
>> 24) & 0xff;
1034 *p
++ = (int) (addr
>> 16) & 0xff;
1035 *p
++ = (int) (addr
>> 8) & 0xff;
1036 *p
++ = (int) (addr
) & 0xff;
1038 retlen
= sds_send (buf
, p
- buf
);
1040 for (i
= 0; i
< 4; ++i
)
1041 contents_cache
[i
] = buf
[i
+ 2];
1047 sds_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1050 unsigned char *p
, buf
[PBUFSIZ
];
1055 *p
++ = (int) (addr
>> 24) & 0xff;
1056 *p
++ = (int) (addr
>> 16) & 0xff;
1057 *p
++ = (int) (addr
>> 8) & 0xff;
1058 *p
++ = (int) (addr
) & 0xff;
1059 for (i
= 0; i
< 4; ++i
)
1060 *p
++ = contents_cache
[i
];
1062 retlen
= sds_send (buf
, p
- buf
);
1070 sds_ops
.to_shortname
= "sds";
1071 sds_ops
.to_longname
= "Remote serial target with SDS protocol";
1072 sds_ops
.to_doc
= "Use a remote computer via a serial line; using the SDS protocol.\n\
1073 Specify the serial device it is connected to (e.g. /dev/ttya).";
1074 sds_ops
.to_open
= sds_open
;
1075 sds_ops
.to_close
= sds_close
;
1076 sds_ops
.to_detach
= sds_detach
;
1077 sds_ops
.to_resume
= sds_resume
;
1078 sds_ops
.to_wait
= sds_wait
;
1079 sds_ops
.to_fetch_registers
= sds_fetch_registers
;
1080 sds_ops
.to_store_registers
= sds_store_registers
;
1081 sds_ops
.to_prepare_to_store
= sds_prepare_to_store
;
1082 sds_ops
.to_xfer_memory
= sds_xfer_memory
;
1083 sds_ops
.to_files_info
= sds_files_info
;
1084 sds_ops
.to_insert_breakpoint
= sds_insert_breakpoint
;
1085 sds_ops
.to_remove_breakpoint
= sds_remove_breakpoint
;
1086 sds_ops
.to_kill
= sds_kill
;
1087 sds_ops
.to_load
= sds_load
;
1088 sds_ops
.to_create_inferior
= sds_create_inferior
;
1089 sds_ops
.to_mourn_inferior
= sds_mourn
;
1090 sds_ops
.to_stratum
= process_stratum
;
1091 sds_ops
.to_has_all_memory
= 1;
1092 sds_ops
.to_has_memory
= 1;
1093 sds_ops
.to_has_stack
= 1;
1094 sds_ops
.to_has_registers
= 1;
1095 sds_ops
.to_has_execution
= 1;
1096 sds_ops
.to_magic
= OPS_MAGIC
;
1099 /* Put a command string, in args, out to the monitor and display the
1103 sds_command (char *args
, int from_tty
)
1107 unsigned char buf
[1000];
1109 /* Convert hexadecimal chars into a byte buffer. */
1114 buf
[len
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
1120 retlen
= sds_send (buf
, len
);
1122 printf_filtered ("Reply is ");
1123 for (i
= 0; i
< retlen
; ++i
)
1125 printf_filtered ("%02x", buf
[i
]);
1127 printf_filtered ("\n");
1131 _initialize_remote_sds (void)
1134 add_target (&sds_ops
);
1136 add_show_from_set (add_set_cmd ("sdstimeout", no_class
,
1137 var_integer
, (char *) &sds_timeout
,
1138 "Set timeout value for sds read.\n", &setlist
),
1141 add_com ("sds", class_obscure
, sds_command
,
1142 "Send a command to the SDS monitor.");