1 /* Remote target communications for serial-line targets using SDS' protocol.
2 Copyright 1997 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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,
19 Boston, MA 02111-1307, USA. */
21 /* This interface was written by studying the behavior of the SDS
22 monitor on an ADS 821/860 board, and by consulting the
23 documentation of the monitor that is available on Motorola's web
27 #include "gdb_string.h"
37 #include "gdb-stabs.h"
38 #include "gdbthread.h"
43 #include <sys/types.h>
49 extern void _initialize_remote_sds (void);
51 /* Declarations of local functions. */
53 static int sds_write_bytes (CORE_ADDR
, char *, int);
55 static int sds_read_bytes (CORE_ADDR
, char *, int);
57 static void sds_files_info (struct target_ops
*ignore
);
59 static int sds_xfer_memory (CORE_ADDR
, char *, int, int, struct target_ops
*);
61 static void sds_prepare_to_store (void);
63 static void sds_fetch_registers (int);
65 static void sds_resume (int, int, enum target_signal
);
67 static int sds_start_remote (PTR
);
69 static void sds_open (char *, int);
71 static void sds_close (int);
73 static void sds_store_registers (int);
75 static void sds_mourn (void);
77 static void sds_create_inferior (char *, char *, char **);
79 static void sds_load (char *, int);
81 static int getmessage (unsigned char *, int);
83 static int putmessage (unsigned char *, int);
85 static int sds_send (unsigned char *, int);
87 static int readchar (int);
89 static int sds_wait (int, struct target_waitstatus
*);
91 static void sds_kill (void);
93 static int tohex (int);
95 static int fromhex (int);
97 static void sds_detach (char *, int);
99 static void sds_interrupt (int);
101 static void sds_interrupt_twice (int);
103 static void interrupt_query (void);
105 static int read_frame (char *);
107 static int sds_insert_breakpoint (CORE_ADDR
, char *);
109 static int sds_remove_breakpoint (CORE_ADDR
, char *);
111 static void init_sds_ops (void);
113 static void sds_command (char *args
, int from_tty
);
115 /* Define the target operations vector. */
117 static struct target_ops sds_ops
;
119 /* This was 5 seconds, which is a long time to sit and wait.
120 Unless this is going though some terminal server or multiplexer or
121 other form of hairy serial connection, I would think 2 seconds would
124 static int sds_timeout
= 2;
126 /* Descriptor for I/O to remote machine. Initialize it to NULL so
127 that sds_open knows that we don't have a file open when the program
130 static serial_t sds_desc
= NULL
;
132 /* This limit comes from the monitor. */
136 /* Maximum number of bytes to read/write at once. The value here
137 is chosen to fill up a packet (the headers account for the 32). */
138 #define MAXBUFBYTES ((PBUFSIZ-32)/2)
140 static int next_msg_id
;
142 static int just_started
;
144 static int message_pending
;
147 /* Clean up connection to a remote debugger. */
151 sds_close (int quitting
)
154 SERIAL_CLOSE (sds_desc
);
158 /* Stub for catch_errors. */
161 sds_start_remote (PTR dummy
)
164 unsigned char buf
[200];
166 immediate_quit
++; /* Allow user to interrupt it */
168 /* Ack any packet which the remote side has already sent. */
169 SERIAL_WRITE (sds_desc
, "{#*\r\n", 5);
170 SERIAL_WRITE (sds_desc
, "{#}\r\n", 5);
172 while ((c
= readchar (1)) >= 0)
173 printf_unfiltered ("%c", c
);
174 printf_unfiltered ("\n");
186 start_remote (); /* Initialize gdb process mechanisms */
190 /* Open a connection to a remote debugger.
191 NAME is the filename used for communication. */
193 static DCACHE
*sds_dcache
;
196 sds_open (char *name
, int from_tty
)
199 error ("To open a remote debug connection, you need to specify what serial\n\
200 device is attached to the remote system (e.g. /dev/ttya).");
202 target_preopen (from_tty
);
204 unpush_target (&sds_ops
);
207 sds_dcache
= dcache_init (sds_read_bytes
, sds_write_bytes
);
209 dcache_invd (sds_dcache
);
211 sds_desc
= SERIAL_OPEN (name
);
213 perror_with_name (name
);
217 if (SERIAL_SETBAUDRATE (sds_desc
, baud_rate
))
219 SERIAL_CLOSE (sds_desc
);
220 perror_with_name (name
);
225 SERIAL_RAW (sds_desc
);
227 /* If there is something sitting in the buffer we might take it as a
228 response to a command, which would be bad. */
229 SERIAL_FLUSH_INPUT (sds_desc
);
233 puts_filtered ("Remote debugging using ");
234 puts_filtered (name
);
235 puts_filtered ("\n");
237 push_target (&sds_ops
); /* Switch to using remote target now */
241 /* Start the remote connection; if error (0), discard this target.
242 In particular, if the user quits, be sure to discard it (we'd be
243 in an inconsistent state otherwise). */
244 if (!catch_errors (sds_start_remote
, NULL
,
245 "Couldn't establish connection to remote target\n",
250 /* This takes a program previously attached to and detaches it. After
251 this is done, GDB can be used to debug some other program. We
252 better not have left any breakpoints in the target program or it'll
253 die when it hits one. */
256 sds_detach (char *args
, int from_tty
)
261 error ("Argument given to \"detach\" when remotely debugging.");
264 /* Tell the remote target to detach. */
271 puts_filtered ("Ending remote debugging.\n");
274 /* Convert hex digit A to a number. */
279 if (a
>= '0' && a
<= '9')
281 else if (a
>= 'a' && a
<= 'f')
284 error ("Reply contains invalid hex digit %d", a
);
287 /* Convert number NIB to a hex digit. */
295 return 'a' + nib
- 10;
299 tob64 (unsigned char *inbuf
, char *outbuf
, int len
)
305 error ("bad length");
308 for (i
= 0; i
< len
; i
+= 3)
310 /* Collect the next three bytes into a number. */
311 sum
= ((long) *inbuf
++) << 16;
312 sum
|= ((long) *inbuf
++) << 8;
313 sum
|= ((long) *inbuf
++);
315 /* Spit out 4 6-bit encodings. */
316 *p
++ = ((sum
>> 18) & 0x3f) + '0';
317 *p
++ = ((sum
>> 12) & 0x3f) + '0';
318 *p
++ = ((sum
>> 6) & 0x3f) + '0';
319 *p
++ = (sum
& 0x3f) + '0';
325 fromb64 (char *inbuf
, char *outbuf
, int len
)
330 error ("bad length");
332 for (i
= 0; i
< len
; i
+= 4)
334 /* Collect 4 6-bit digits. */
335 sum
= (*inbuf
++ - '0') << 18;
336 sum
|= (*inbuf
++ - '0') << 12;
337 sum
|= (*inbuf
++ - '0') << 6;
338 sum
|= (*inbuf
++ - '0');
340 /* Now take the resulting 24-bit number and get three bytes out
342 *outbuf
++ = (sum
>> 16) & 0xff;
343 *outbuf
++ = (sum
>> 8) & 0xff;
344 *outbuf
++ = sum
& 0xff;
347 return (len
/ 4) * 3;
351 /* Tell the remote machine to resume. */
353 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
357 sds_resume (int pid
, int step
, enum target_signal siggnal
)
359 unsigned char buf
[PBUFSIZ
];
361 dcache_invd (sds_dcache
);
363 last_sent_signal
= siggnal
;
364 last_sent_step
= step
;
366 buf
[0] = (step
? 21 : 20);
367 buf
[1] = 0; /* (should be signal?) */
372 /* Send a message to target to halt it. Target will respond, and send
373 us a message pending notice. */
376 sds_interrupt (int signo
)
378 unsigned char buf
[PBUFSIZ
];
380 /* If this doesn't work, try more severe steps. */
381 signal (signo
, sds_interrupt_twice
);
384 fprintf_unfiltered (gdb_stdlog
, "sds_interrupt called\n");
390 static void (*ofunc
) ();
392 /* The user typed ^C twice. */
395 sds_interrupt_twice (int signo
)
397 signal (signo
, ofunc
);
401 signal (signo
, sds_interrupt
);
404 /* Ask the user what to do when an interrupt is received. */
407 interrupt_query (void)
409 target_terminal_ours ();
411 if (query ("Interrupted while waiting for the program.\n\
412 Give up (and stop debugging it)? "))
414 target_mourn_inferior ();
415 return_to_top_level (RETURN_QUIT
);
418 target_terminal_inferior ();
421 /* If nonzero, ignore the next kill. */
424 /* Wait until the remote machine stops, then return, storing status in
425 STATUS just as `wait' would. Returns "pid" (though it's not clear
426 what, if anything, that means in the case of this target). */
429 sds_wait (int pid
, struct target_waitstatus
*status
)
431 unsigned char buf
[PBUFSIZ
];
434 status
->kind
= TARGET_WAITKIND_EXITED
;
435 status
->value
.integer
= 0;
437 ofunc
= (void (*)()) signal (SIGINT
, sds_interrupt
);
439 signal (SIGINT
, ofunc
);
444 status
->kind
= TARGET_WAITKIND_STOPPED
;
455 retlen
= sds_send (buf
, 1);
458 fprintf_unfiltered (gdb_stdlog
, "Signals: %02x%02x %02x %02x\n",
463 status
->kind
= TARGET_WAITKIND_STOPPED
;
464 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
472 static unsigned char sprs
[16];
474 /* Read the remote registers into the block REGS. */
475 /* Currently we just read all the registers, so we don't use regno. */
479 sds_fetch_registers (int regno
)
481 unsigned char buf
[PBUFSIZ
];
483 char regs
[REGISTER_BYTES
];
485 /* Unimplemented registers read as all bits zero. */
486 memset (regs
, 0, REGISTER_BYTES
);
491 retlen
= sds_send (buf
, 3);
493 for (i
= 0; i
< 4 * 6; ++i
)
494 regs
[i
+ 4 * 32 + 8 * 32] = buf
[i
];
495 for (i
= 0; i
< 4 * 4; ++i
)
496 sprs
[i
] = buf
[i
+ 4 * 7];
501 retlen
= sds_send (buf
, 3);
503 for (i
= 0; i
< retlen
; i
++)
506 /* (should warn about reply too short) */
508 for (i
= 0; i
< NUM_REGS
; i
++)
509 supply_register (i
, ®s
[REGISTER_BYTE (i
)]);
512 /* Prepare to store registers. Since we may send them all, we have to
513 read out the ones we don't want to change first. */
516 sds_prepare_to_store (void)
518 /* Make sure the entire registers array is valid. */
519 read_register_bytes (0, (char *) NULL
, REGISTER_BYTES
);
522 /* Store register REGNO, or all registers if REGNO == -1, from the contents
523 of REGISTERS. FIXME: ignores errors. */
526 sds_store_registers (int regno
)
528 unsigned char *p
, buf
[PBUFSIZ
];
531 /* Store all the special-purpose registers. */
537 for (i
= 0; i
< 4 * 6; i
++)
538 *p
++ = registers
[i
+ 4 * 32 + 8 * 32];
539 for (i
= 0; i
< 4 * 1; i
++)
541 for (i
= 0; i
< 4 * 4; i
++)
544 sds_send (buf
, p
- buf
);
546 /* Store all the general-purpose registers. */
552 for (i
= 0; i
< 4 * 32; i
++)
555 sds_send (buf
, p
- buf
);
559 /* Write memory data directly to the remote machine. This does not
560 inform the data cache; the data cache uses this. MEMADDR is the
561 address in the remote memory space. MYADDR is the address of the
562 buffer in our space. LEN is the number of bytes.
564 Returns number of bytes transferred, or 0 for error. */
567 sds_write_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
569 int max_buf_size
; /* Max size of packet output buffer */
571 unsigned char buf
[PBUFSIZ
];
575 /* Chop the transfer down if necessary */
582 todo
= min (len
, max_buf_size
);
586 buf
[2] = (int) (memaddr
>> 24) & 0xff;
587 buf
[3] = (int) (memaddr
>> 16) & 0xff;
588 buf
[4] = (int) (memaddr
>> 8) & 0xff;
589 buf
[5] = (int) (memaddr
) & 0xff;
593 for (i
= 0; i
< todo
; i
++)
594 buf
[i
+ 8] = myaddr
[i
];
596 sds_send (buf
, 8 + todo
);
598 /* (should look at result) */
607 /* Read memory data directly from the remote machine. This does not
608 use the data cache; the data cache uses this. MEMADDR is the
609 address in the remote memory space. MYADDR is the address of the
610 buffer in our space. LEN is the number of bytes.
612 Returns number of bytes transferred, or 0 for error. */
615 sds_read_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
617 int max_buf_size
; /* Max size of packet output buffer */
619 unsigned char buf
[PBUFSIZ
];
623 /* Chop the transfer down if necessary */
630 todo
= min (len
, max_buf_size
);
634 buf
[2] = (int) (memaddr
>> 24) & 0xff;
635 buf
[3] = (int) (memaddr
>> 16) & 0xff;
636 buf
[4] = (int) (memaddr
>> 8) & 0xff;
637 buf
[5] = (int) (memaddr
) & 0xff;
638 buf
[6] = (int) (todo
>> 8) & 0xff;
639 buf
[7] = (int) (todo
) & 0xff;
642 retlen
= sds_send (buf
, 9);
644 if (retlen
- 2 != todo
)
649 /* Reply describes memory byte by byte. */
651 for (i
= 0; i
< todo
; i
++)
652 myaddr
[i
] = buf
[i
+ 2];
662 /* Read or write LEN bytes from inferior memory at MEMADDR,
663 transferring to or from debugger address MYADDR. Write to inferior
664 if SHOULD_WRITE is nonzero. Returns length of data written or
665 read; 0 for error. TARGET is unused. */
669 sds_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int should_write
,
670 struct target_ops
*target
)
672 return dcache_xfer_memory (sds_dcache
, memaddr
, myaddr
, len
, should_write
);
677 sds_files_info (struct target_ops
*ignore
)
679 puts_filtered ("Debugging over a serial connection, using SDS protocol.\n");
682 /* Stuff for dealing with the packets which are part of this protocol.
683 See comment at top of file for details. */
685 /* Read a single character from the remote end, masking it down to 7 bits. */
688 readchar (int timeout
)
692 ch
= SERIAL_READCHAR (sds_desc
, timeout
);
694 if (remote_debug
> 1 && ch
>= 0)
695 fprintf_unfiltered (gdb_stdlog
, "%c(%x)", ch
, ch
);
700 error ("Remote connection closed");
702 perror_with_name ("Remote communication error");
710 /* An SDS-style checksum is a sum of the bytes modulo 253. (Presumably
711 because 253, 254, and 255 are special flags in the protocol.) */
714 compute_checksum (int csum
, char *buf
, int len
)
718 for (i
= 0; i
< len
; ++i
)
719 csum
+= (unsigned char) buf
[i
];
725 /* Send the command in BUF to the remote machine, and read the reply
729 sds_send (unsigned char *buf
, int len
)
731 putmessage (buf
, len
);
733 return getmessage (buf
, 0);
736 /* Send a message to the remote machine. */
739 putmessage (unsigned char *buf
, int len
)
742 unsigned char csum
= 0;
743 char buf2
[PBUFSIZ
], buf3
[PBUFSIZ
];
744 unsigned char header
[3];
747 /* Copy the packet into buffer BUF2, encapsulating it
748 and giving it a checksum. */
750 if (len
> 170) /* Prosanity check */
755 fprintf_unfiltered (gdb_stdlog
, "Message to send: \"");
756 for (i
= 0; i
< len
; ++i
)
757 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
758 fprintf_unfiltered (gdb_stdlog
, "\"\n");
770 header
[1] = next_msg_id
;
774 csum
= compute_checksum (csum
, buf
, len
);
775 csum
= compute_checksum (csum
, header
+ 1, 2);
779 tob64 (header
, p
, 3);
781 enclen
= tob64 (buf
, buf3
, ((len
+ 2) / 3) * 3);
783 for (i
= 0; i
< enclen
; ++i
)
788 next_msg_id
= (next_msg_id
+ 3) % 245;
790 /* Send it over and over until we get a positive ack. */
797 fprintf_unfiltered (gdb_stdlog
, "Sending encoded: \"%s\"", buf2
);
798 fprintf_unfiltered (gdb_stdlog
,
799 " (Checksum %d, id %d, length %d)\n",
800 header
[0], header
[1], header
[2]);
801 gdb_flush (gdb_stdlog
);
803 if (SERIAL_WRITE (sds_desc
, buf2
, p
- buf2
))
804 perror_with_name ("putmessage: write failed");
810 /* Come here after finding the start of the frame. Collect the rest
811 into BUF. Returns 0 on any error, 1 on success. */
814 read_frame (char *buf
)
823 c
= readchar (sds_timeout
);
829 fputs_filtered ("Timeout in mid-message, retrying\n", gdb_stdlog
);
833 fputs_filtered ("Saw new packet start in middle of old one\n",
835 return 0; /* Start a new packet, count retries */
843 fprintf_unfiltered (gdb_stdlog
, "Received encoded: \"%s\"\n",
849 if (bp
< buf
+ PBUFSIZ
- 1)
856 puts_filtered ("Message too long: ");
858 puts_filtered ("\n");
865 /* Read a packet from the remote machine, with error checking,
866 and store it in BUF. BUF is expected to be of size PBUFSIZ.
867 If FOREVER, wait forever rather than timing out; this is used
868 while the target is executing user code. */
871 getmessage (unsigned char *buf
, int forever
)
876 int val
, i
, len
, csum
;
877 unsigned char header
[3];
878 unsigned char inbuf
[500];
880 strcpy (buf
, "timeout");
884 timeout
= watchdog
> 0 ? watchdog
: -1;
888 timeout
= sds_timeout
;
892 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
894 /* This can loop forever if the remote side sends us characters
895 continuously, but if it pauses, we'll get a zero from readchar
896 because of timeout. Then we'll count that as a retry. */
898 /* Note that we will only wait forever prior to the start of a packet.
899 After that, we expect characters to arrive at a brisk pace. They
900 should show up within sds_timeout intervals. */
904 c
= readchar (timeout
);
906 if (c
== SERIAL_TIMEOUT
)
908 if (forever
) /* Watchdog went off. Kill the target. */
910 target_mourn_inferior ();
911 error ("Watchdog has expired. Target detached.\n");
914 fputs_filtered ("Timed out.\n", gdb_stdlog
);
918 while (c
!= '$' && c
!= '{');
920 /* We might have seen a "trigraph", a sequence of three characters
921 that indicate various sorts of communication state. */
925 /* Read the other two chars of the trigraph. */
926 c2
= readchar (timeout
);
927 c3
= readchar (timeout
);
929 fprintf_unfiltered (gdb_stdlog
, "Trigraph %c%c%c received\n",
939 val
= read_frame (inbuf
);
943 fromb64 (inbuf
, header
, 4);
944 /* (should check out other bits) */
945 fromb64 (inbuf
+ 4, buf
, strlen (inbuf
) - 4);
950 csum
= compute_checksum (csum
, buf
, len
);
951 csum
= compute_checksum (csum
, header
+ 1, 2);
953 if (csum
!= header
[0])
954 fprintf_unfiltered (gdb_stderr
,
955 "Checksum mismatch: computed %d, received %d\n",
958 if (header
[2] == 0xff)
959 fprintf_unfiltered (gdb_stderr
, "Requesting resend...\n");
963 fprintf_unfiltered (gdb_stdlog
,
964 "... (Got checksum %d, id %d, length %d)\n",
965 header
[0], header
[1], header
[2]);
966 fprintf_unfiltered (gdb_stdlog
, "Message received: \"");
967 for (i
= 0; i
< len
; ++i
)
969 fprintf_unfiltered (gdb_stdlog
, "%02x", (unsigned char) buf
[i
]);
971 fprintf_unfiltered (gdb_stdlog
, "\"\n");
974 /* no ack required? */
978 /* Try the whole thing again. */
980 /* need to do something here */
983 /* We have tried hard enough, and just can't receive the packet. Give up. */
985 printf_unfiltered ("Ignoring packet error, continuing...\n");
992 /* Don't try to do anything to the target. */
998 unpush_target (&sds_ops
);
999 generic_mourn_inferior ();
1003 sds_create_inferior (char *exec_file
, char *args
, char **env
)
1005 inferior_pid
= 42000;
1007 /* Clean up from the last time we were running. */
1008 clear_proceed_status ();
1010 /* Let the remote process run. */
1011 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1015 sds_load (char *filename
, int from_tty
)
1017 generic_load (filename
, from_tty
);
1022 /* The SDS monitor has commands for breakpoint insertion, although it
1023 it doesn't actually manage the breakpoints, it just returns the
1024 replaced instruction back to the debugger. */
1027 sds_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1030 unsigned char *p
, buf
[PBUFSIZ
];
1035 *p
++ = (int) (addr
>> 24) & 0xff;
1036 *p
++ = (int) (addr
>> 16) & 0xff;
1037 *p
++ = (int) (addr
>> 8) & 0xff;
1038 *p
++ = (int) (addr
) & 0xff;
1040 retlen
= sds_send (buf
, p
- buf
);
1042 for (i
= 0; i
< 4; ++i
)
1043 contents_cache
[i
] = buf
[i
+ 2];
1049 sds_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1052 unsigned char *p
, buf
[PBUFSIZ
];
1057 *p
++ = (int) (addr
>> 24) & 0xff;
1058 *p
++ = (int) (addr
>> 16) & 0xff;
1059 *p
++ = (int) (addr
>> 8) & 0xff;
1060 *p
++ = (int) (addr
) & 0xff;
1061 for (i
= 0; i
< 4; ++i
)
1062 *p
++ = contents_cache
[i
];
1064 retlen
= sds_send (buf
, p
- buf
);
1072 sds_ops
.to_shortname
= "sds";
1073 sds_ops
.to_longname
= "Remote serial target with SDS protocol";
1074 sds_ops
.to_doc
= "Use a remote computer via a serial line; using the SDS protocol.\n\
1075 Specify the serial device it is connected to (e.g. /dev/ttya).";
1076 sds_ops
.to_open
= sds_open
;
1077 sds_ops
.to_close
= sds_close
;
1078 sds_ops
.to_detach
= sds_detach
;
1079 sds_ops
.to_resume
= sds_resume
;
1080 sds_ops
.to_wait
= sds_wait
;
1081 sds_ops
.to_fetch_registers
= sds_fetch_registers
;
1082 sds_ops
.to_store_registers
= sds_store_registers
;
1083 sds_ops
.to_prepare_to_store
= sds_prepare_to_store
;
1084 sds_ops
.to_xfer_memory
= sds_xfer_memory
;
1085 sds_ops
.to_files_info
= sds_files_info
;
1086 sds_ops
.to_insert_breakpoint
= sds_insert_breakpoint
;
1087 sds_ops
.to_remove_breakpoint
= sds_remove_breakpoint
;
1088 sds_ops
.to_kill
= sds_kill
;
1089 sds_ops
.to_load
= sds_load
;
1090 sds_ops
.to_create_inferior
= sds_create_inferior
;
1091 sds_ops
.to_mourn_inferior
= sds_mourn
;
1092 sds_ops
.to_stratum
= process_stratum
;
1093 sds_ops
.to_has_all_memory
= 1;
1094 sds_ops
.to_has_memory
= 1;
1095 sds_ops
.to_has_stack
= 1;
1096 sds_ops
.to_has_registers
= 1;
1097 sds_ops
.to_has_execution
= 1;
1098 sds_ops
.to_magic
= OPS_MAGIC
;
1101 /* Put a command string, in args, out to the monitor and display the
1105 sds_command (char *args
, int from_tty
)
1109 unsigned char buf
[1000];
1111 /* Convert hexadecimal chars into a byte buffer. */
1116 buf
[len
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
1122 retlen
= sds_send (buf
, len
);
1124 printf_filtered ("Reply is ");
1125 for (i
= 0; i
< retlen
; ++i
)
1127 printf_filtered ("%02x", buf
[i
]);
1129 printf_filtered ("\n");
1133 _initialize_remote_sds (void)
1136 add_target (&sds_ops
);
1138 add_show_from_set (add_set_cmd ("sdstimeout", no_class
,
1139 var_integer
, (char *) &sds_timeout
,
1140 "Set timeout value for sds read.\n", &setlist
),
1143 add_com ("sds", class_obscure
, sds_command
,
1144 "Send a command to the SDS monitor.");