1 /* Remote target communications for serial-line targets using SDS' protocol.
3 Copyright 1997, 1998, 1999, 2000, 2001, 2002, 2004 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 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 struct serial
*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. */
150 sds_close (int quitting
)
153 serial_close (sds_desc
);
157 /* Stub for catch_errors. */
160 sds_start_remote (void *dummy
)
163 unsigned char buf
[200];
165 immediate_quit
++; /* Allow user to interrupt it */
167 /* Ack any packet which the remote side has already sent. */
168 serial_write (sds_desc
, "{#*\r\n", 5);
169 serial_write (sds_desc
, "{#}\r\n", 5);
171 while ((c
= readchar (1)) >= 0)
172 printf_unfiltered ("%c", c
);
173 printf_unfiltered ("\n");
185 start_remote (); /* Initialize gdb process mechanisms */
189 /* Open a connection to a remote debugger.
190 NAME is the filename used for communication. */
193 sds_open (char *name
, int from_tty
)
196 error ("To open a remote debug connection, you need to specify what serial\n\
197 device is attached to the remote system (e.g. /dev/ttya).");
199 target_preopen (from_tty
);
201 unpush_target (&sds_ops
);
203 sds_desc
= serial_open (name
);
205 perror_with_name (name
);
209 if (serial_setbaudrate (sds_desc
, baud_rate
))
211 serial_close (sds_desc
);
212 perror_with_name (name
);
217 serial_raw (sds_desc
);
219 /* If there is something sitting in the buffer we might take it as a
220 response to a command, which would be bad. */
221 serial_flush_input (sds_desc
);
225 puts_filtered ("Remote debugging using ");
226 puts_filtered (name
);
227 puts_filtered ("\n");
229 push_target (&sds_ops
); /* Switch to using remote target now */
233 /* Start the remote connection; if error (0), discard this target.
234 In particular, if the user quits, be sure to discard it (we'd be
235 in an inconsistent state otherwise). */
236 if (!catch_errors (sds_start_remote
, NULL
,
237 "Couldn't establish connection to remote target\n",
242 /* This takes a program previously attached to and detaches it. After
243 this is done, GDB can be used to debug some other program. We
244 better not have left any breakpoints in the target program or it'll
245 die when it hits one. */
248 sds_detach (char *args
, int from_tty
)
253 error ("Argument given to \"detach\" when remotely debugging.");
256 /* Tell the remote target to detach. */
263 puts_filtered ("Ending remote debugging.\n");
266 /* Convert hex digit A to a number. */
271 if (a
>= '0' && a
<= '9')
273 else if (a
>= 'a' && a
<= 'f')
276 error ("Reply contains invalid hex digit %d", a
);
280 tob64 (unsigned char *inbuf
, char *outbuf
, int len
)
286 error ("bad length");
289 for (i
= 0; i
< len
; i
+= 3)
291 /* Collect the next three bytes into a number. */
292 sum
= ((long) *inbuf
++) << 16;
293 sum
|= ((long) *inbuf
++) << 8;
294 sum
|= ((long) *inbuf
++);
296 /* Spit out 4 6-bit encodings. */
297 *p
++ = ((sum
>> 18) & 0x3f) + '0';
298 *p
++ = ((sum
>> 12) & 0x3f) + '0';
299 *p
++ = ((sum
>> 6) & 0x3f) + '0';
300 *p
++ = (sum
& 0x3f) + '0';
306 fromb64 (char *inbuf
, char *outbuf
, int len
)
311 error ("bad length");
313 for (i
= 0; i
< len
; i
+= 4)
315 /* Collect 4 6-bit digits. */
316 sum
= (*inbuf
++ - '0') << 18;
317 sum
|= (*inbuf
++ - '0') << 12;
318 sum
|= (*inbuf
++ - '0') << 6;
319 sum
|= (*inbuf
++ - '0');
321 /* Now take the resulting 24-bit number and get three bytes out
323 *outbuf
++ = (sum
>> 16) & 0xff;
324 *outbuf
++ = (sum
>> 8) & 0xff;
325 *outbuf
++ = sum
& 0xff;
328 return (len
/ 4) * 3;
332 /* Tell the remote machine to resume. */
334 static enum target_signal last_sent_signal
= TARGET_SIGNAL_0
;
338 sds_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
340 unsigned char buf
[PBUFSIZ
];
342 last_sent_signal
= siggnal
;
343 last_sent_step
= step
;
345 buf
[0] = (step
? 21 : 20);
346 buf
[1] = 0; /* (should be signal?) */
351 /* Send a message to target to halt it. Target will respond, and send
352 us a message pending notice. */
355 sds_interrupt (int signo
)
357 unsigned char buf
[PBUFSIZ
];
359 /* If this doesn't work, try more severe steps. */
360 signal (signo
, sds_interrupt_twice
);
363 fprintf_unfiltered (gdb_stdlog
, "sds_interrupt called\n");
369 static void (*ofunc
) ();
371 /* The user typed ^C twice. */
374 sds_interrupt_twice (int signo
)
376 signal (signo
, ofunc
);
380 signal (signo
, sds_interrupt
);
383 /* Ask the user what to do when an interrupt is received. */
386 interrupt_query (void)
388 target_terminal_ours ();
390 if (query ("Interrupted while waiting for the program.\n\
391 Give up (and stop debugging it)? "))
393 target_mourn_inferior ();
394 throw_exception (RETURN_QUIT
);
397 target_terminal_inferior ();
400 /* If nonzero, ignore the next kill. */
403 /* Wait until the remote machine stops, then return, storing status in
404 STATUS just as `wait' would. Returns "pid" (though it's not clear
405 what, if anything, that means in the case of this target). */
408 sds_wait (ptid_t ptid
, struct target_waitstatus
*status
)
410 unsigned char buf
[PBUFSIZ
];
413 status
->kind
= TARGET_WAITKIND_EXITED
;
414 status
->value
.integer
= 0;
416 ofunc
= (void (*)()) signal (SIGINT
, sds_interrupt
);
418 signal (SIGINT
, ofunc
);
423 status
->kind
= TARGET_WAITKIND_STOPPED
;
424 return inferior_ptid
;
434 retlen
= sds_send (buf
, 1);
437 fprintf_unfiltered (gdb_stdlog
, "Signals: %02x%02x %02x %02x\n",
442 status
->kind
= TARGET_WAITKIND_STOPPED
;
443 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
448 return inferior_ptid
;
451 static unsigned char sprs
[16];
453 /* Read the remote registers into the block REGS. */
454 /* Currently we just read all the registers, so we don't use regno. */
457 sds_fetch_registers (int regno
)
459 unsigned char buf
[PBUFSIZ
];
461 char *regs
= alloca (DEPRECATED_REGISTER_BYTES
);
463 /* Unimplemented registers read as all bits zero. */
464 memset (regs
, 0, DEPRECATED_REGISTER_BYTES
);
469 retlen
= sds_send (buf
, 3);
471 for (i
= 0; i
< 4 * 6; ++i
)
472 regs
[i
+ 4 * 32 + 8 * 32] = buf
[i
];
473 for (i
= 0; i
< 4 * 4; ++i
)
474 sprs
[i
] = buf
[i
+ 4 * 7];
479 retlen
= sds_send (buf
, 3);
481 for (i
= 0; i
< retlen
; i
++)
484 /* (should warn about reply too short) */
486 for (i
= 0; i
< NUM_REGS
; i
++)
487 supply_register (i
, ®s
[DEPRECATED_REGISTER_BYTE (i
)]);
490 /* Prepare to store registers. Since we may send them all, we have to
491 read out the ones we don't want to change first. */
494 sds_prepare_to_store (void)
496 /* Make sure the entire registers array is valid. */
497 deprecated_read_register_bytes (0, (char *) NULL
, DEPRECATED_REGISTER_BYTES
);
500 /* Store register REGNO, or all registers if REGNO == -1, from the contents
501 of REGISTERS. FIXME: ignores errors. */
504 sds_store_registers (int regno
)
506 unsigned char *p
, buf
[PBUFSIZ
];
509 /* Store all the special-purpose registers. */
515 for (i
= 0; i
< 4 * 6; i
++)
516 *p
++ = deprecated_registers
[i
+ 4 * 32 + 8 * 32];
517 for (i
= 0; i
< 4 * 1; i
++)
519 for (i
= 0; i
< 4 * 4; i
++)
522 sds_send (buf
, p
- buf
);
524 /* Store all the general-purpose registers. */
530 for (i
= 0; i
< 4 * 32; i
++)
531 *p
++ = deprecated_registers
[i
];
533 sds_send (buf
, p
- buf
);
537 /* Write memory data directly to the remote machine. This does not
538 inform the data cache; the data cache uses this. MEMADDR is the
539 address in the remote memory space. MYADDR is the address of the
540 buffer in our space. LEN is the number of bytes.
542 Returns number of bytes transferred, or 0 for error. */
545 sds_write_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
547 int max_buf_size
; /* Max size of packet output buffer */
549 unsigned char buf
[PBUFSIZ
];
553 /* Chop the transfer down if necessary */
560 todo
= min (len
, max_buf_size
);
564 buf
[2] = (int) (memaddr
>> 24) & 0xff;
565 buf
[3] = (int) (memaddr
>> 16) & 0xff;
566 buf
[4] = (int) (memaddr
>> 8) & 0xff;
567 buf
[5] = (int) (memaddr
) & 0xff;
571 for (i
= 0; i
< todo
; i
++)
572 buf
[i
+ 8] = myaddr
[i
];
574 sds_send (buf
, 8 + todo
);
576 /* (should look at result) */
585 /* Read memory data directly from the remote machine. This does not
586 use the data cache; the data cache uses this. MEMADDR is the
587 address in the remote memory space. MYADDR is the address of the
588 buffer in our space. LEN is the number of bytes.
590 Returns number of bytes transferred, or 0 for error. */
593 sds_read_bytes (CORE_ADDR memaddr
, char *myaddr
, int len
)
595 int max_buf_size
; /* Max size of packet output buffer */
597 unsigned char buf
[PBUFSIZ
];
601 /* Chop the transfer down if necessary */
608 todo
= min (len
, max_buf_size
);
612 buf
[2] = (int) (memaddr
>> 24) & 0xff;
613 buf
[3] = (int) (memaddr
>> 16) & 0xff;
614 buf
[4] = (int) (memaddr
>> 8) & 0xff;
615 buf
[5] = (int) (memaddr
) & 0xff;
616 buf
[6] = (int) (todo
>> 8) & 0xff;
617 buf
[7] = (int) (todo
) & 0xff;
620 retlen
= sds_send (buf
, 9);
622 if (retlen
- 2 != todo
)
627 /* Reply describes memory byte by byte. */
629 for (i
= 0; i
< todo
; i
++)
630 myaddr
[i
] = buf
[i
+ 2];
640 /* Read or write LEN bytes from inferior memory at MEMADDR,
641 transferring to or from debugger address MYADDR. Write to inferior
642 if SHOULD_WRITE is nonzero. Returns length of data written or
643 read; 0 for error. TARGET is unused. */
646 sds_xfer_memory (CORE_ADDR memaddr
, char *myaddr
, int len
, int should_write
,
647 struct mem_attrib
*attrib
, struct target_ops
*target
)
652 res
= sds_write_bytes (memaddr
, myaddr
, len
);
654 res
= sds_read_bytes (memaddr
, myaddr
, len
);
661 sds_files_info (struct target_ops
*ignore
)
663 puts_filtered ("Debugging over a serial connection, using SDS protocol.\n");
666 /* Stuff for dealing with the packets which are part of this protocol.
667 See comment at top of file for details. */
669 /* Read a single character from the remote end, masking it down to 7 bits. */
672 readchar (int timeout
)
676 ch
= serial_readchar (sds_desc
, timeout
);
678 if (remote_debug
> 1 && ch
>= 0)
679 fprintf_unfiltered (gdb_stdlog
, "%c(%x)", ch
, ch
);
684 error ("Remote connection closed");
686 perror_with_name ("Remote communication error");
694 /* An SDS-style checksum is a sum of the bytes modulo 253. (Presumably
695 because 253, 254, and 255 are special flags in the protocol.) */
698 compute_checksum (int csum
, char *buf
, int len
)
702 for (i
= 0; i
< len
; ++i
)
703 csum
+= (unsigned char) buf
[i
];
709 /* Send the command in BUF to the remote machine, and read the reply
713 sds_send (unsigned char *buf
, int len
)
715 putmessage (buf
, len
);
717 return getmessage (buf
, 0);
720 /* Send a message to the remote machine. */
723 putmessage (unsigned char *buf
, int len
)
726 unsigned char csum
= 0;
727 char buf2
[PBUFSIZ
], buf3
[PBUFSIZ
];
728 unsigned char header
[3];
731 /* Copy the packet into buffer BUF2, encapsulating it
732 and giving it a checksum. */
734 if (len
> 170) /* Prosanity check */
735 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
739 fprintf_unfiltered (gdb_stdlog
, "Message to send: \"");
740 for (i
= 0; i
< len
; ++i
)
741 fprintf_unfiltered (gdb_stdlog
, "%02x", buf
[i
]);
742 fprintf_unfiltered (gdb_stdlog
, "\"\n");
754 header
[1] = next_msg_id
;
758 csum
= compute_checksum (csum
, buf
, len
);
759 csum
= compute_checksum (csum
, header
+ 1, 2);
763 tob64 (header
, p
, 3);
765 enclen
= tob64 (buf
, buf3
, ((len
+ 2) / 3) * 3);
767 for (i
= 0; i
< enclen
; ++i
)
772 next_msg_id
= (next_msg_id
+ 3) % 245;
774 /* Send it over and over until we get a positive ack. */
781 fprintf_unfiltered (gdb_stdlog
, "Sending encoded: \"%s\"", buf2
);
782 fprintf_unfiltered (gdb_stdlog
,
783 " (Checksum %d, id %d, length %d)\n",
784 header
[0], header
[1], header
[2]);
785 gdb_flush (gdb_stdlog
);
787 if (serial_write (sds_desc
, buf2
, p
- buf2
))
788 perror_with_name ("putmessage: write failed");
794 /* Come here after finding the start of the frame. Collect the rest
795 into BUF. Returns 0 on any error, 1 on success. */
798 read_frame (char *buf
)
807 c
= readchar (sds_timeout
);
813 fputs_filtered ("Timeout in mid-message, retrying\n", gdb_stdlog
);
817 fputs_filtered ("Saw new packet start in middle of old one\n",
819 return 0; /* Start a new packet, count retries */
827 fprintf_unfiltered (gdb_stdlog
, "Received encoded: \"%s\"\n",
833 if (bp
< buf
+ PBUFSIZ
- 1)
840 puts_filtered ("Message too long: ");
842 puts_filtered ("\n");
849 /* Read a packet from the remote machine, with error checking,
850 and store it in BUF. BUF is expected to be of size PBUFSIZ.
851 If FOREVER, wait forever rather than timing out; this is used
852 while the target is executing user code. */
855 getmessage (unsigned char *buf
, int forever
)
860 int val
, i
, len
, csum
;
861 unsigned char header
[3];
862 unsigned char inbuf
[500];
864 strcpy (buf
, "timeout");
868 timeout
= watchdog
> 0 ? watchdog
: -1;
872 timeout
= sds_timeout
;
876 for (tries
= 1; tries
<= MAX_TRIES
; tries
++)
878 /* This can loop forever if the remote side sends us characters
879 continuously, but if it pauses, we'll get a zero from readchar
880 because of timeout. Then we'll count that as a retry. */
882 /* Note that we will only wait forever prior to the start of a packet.
883 After that, we expect characters to arrive at a brisk pace. They
884 should show up within sds_timeout intervals. */
888 c
= readchar (timeout
);
890 if (c
== SERIAL_TIMEOUT
)
892 if (forever
) /* Watchdog went off. Kill the target. */
894 target_mourn_inferior ();
895 error ("Watchdog has expired. Target detached.\n");
898 fputs_filtered ("Timed out.\n", gdb_stdlog
);
902 while (c
!= '$' && c
!= '{');
904 /* We might have seen a "trigraph", a sequence of three characters
905 that indicate various sorts of communication state. */
909 /* Read the other two chars of the trigraph. */
910 c2
= readchar (timeout
);
911 c3
= readchar (timeout
);
913 fprintf_unfiltered (gdb_stdlog
, "Trigraph %c%c%c received\n",
923 val
= read_frame (inbuf
);
927 fromb64 (inbuf
, header
, 4);
928 /* (should check out other bits) */
929 fromb64 (inbuf
+ 4, buf
, strlen (inbuf
) - 4);
934 csum
= compute_checksum (csum
, buf
, len
);
935 csum
= compute_checksum (csum
, header
+ 1, 2);
937 if (csum
!= header
[0])
938 fprintf_unfiltered (gdb_stderr
,
939 "Checksum mismatch: computed %d, received %d\n",
942 if (header
[2] == 0xff)
943 fprintf_unfiltered (gdb_stderr
, "Requesting resend...\n");
947 fprintf_unfiltered (gdb_stdlog
,
948 "... (Got checksum %d, id %d, length %d)\n",
949 header
[0], header
[1], header
[2]);
950 fprintf_unfiltered (gdb_stdlog
, "Message received: \"");
951 for (i
= 0; i
< len
; ++i
)
953 fprintf_unfiltered (gdb_stdlog
, "%02x", (unsigned char) buf
[i
]);
955 fprintf_unfiltered (gdb_stdlog
, "\"\n");
958 /* no ack required? */
962 /* Try the whole thing again. */
964 /* need to do something here */
968 /* We have tried hard enough, and just can't receive the packet. Give up. */
970 printf_unfiltered ("Ignoring packet error, continuing...\n");
977 /* Don't try to do anything to the target. */
983 unpush_target (&sds_ops
);
984 generic_mourn_inferior ();
988 sds_create_inferior (char *exec_file
, char *args
, char **env
)
990 inferior_ptid
= pid_to_ptid (42000);
992 /* Clean up from the last time we were running. */
993 clear_proceed_status ();
995 /* Let the remote process run. */
996 proceed (bfd_get_start_address (exec_bfd
), TARGET_SIGNAL_0
, 0);
1000 sds_load (char *filename
, int from_tty
)
1002 generic_load (filename
, from_tty
);
1004 inferior_ptid
= null_ptid
;
1007 /* The SDS monitor has commands for breakpoint insertion, although it
1008 it doesn't actually manage the breakpoints, it just returns the
1009 replaced instruction back to the debugger. */
1012 sds_insert_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1015 unsigned char *p
, buf
[PBUFSIZ
];
1020 *p
++ = (int) (addr
>> 24) & 0xff;
1021 *p
++ = (int) (addr
>> 16) & 0xff;
1022 *p
++ = (int) (addr
>> 8) & 0xff;
1023 *p
++ = (int) (addr
) & 0xff;
1025 retlen
= sds_send (buf
, p
- buf
);
1027 for (i
= 0; i
< 4; ++i
)
1028 contents_cache
[i
] = buf
[i
+ 2];
1034 sds_remove_breakpoint (CORE_ADDR addr
, char *contents_cache
)
1037 unsigned char *p
, buf
[PBUFSIZ
];
1042 *p
++ = (int) (addr
>> 24) & 0xff;
1043 *p
++ = (int) (addr
>> 16) & 0xff;
1044 *p
++ = (int) (addr
>> 8) & 0xff;
1045 *p
++ = (int) (addr
) & 0xff;
1046 for (i
= 0; i
< 4; ++i
)
1047 *p
++ = contents_cache
[i
];
1049 retlen
= sds_send (buf
, p
- buf
);
1057 sds_ops
.to_shortname
= "sds";
1058 sds_ops
.to_longname
= "Remote serial target with SDS protocol";
1059 sds_ops
.to_doc
= "Use a remote computer via a serial line; using the SDS protocol.\n\
1060 Specify the serial device it is connected to (e.g. /dev/ttya).";
1061 sds_ops
.to_open
= sds_open
;
1062 sds_ops
.to_close
= sds_close
;
1063 sds_ops
.to_detach
= sds_detach
;
1064 sds_ops
.to_resume
= sds_resume
;
1065 sds_ops
.to_wait
= sds_wait
;
1066 sds_ops
.to_fetch_registers
= sds_fetch_registers
;
1067 sds_ops
.to_store_registers
= sds_store_registers
;
1068 sds_ops
.to_prepare_to_store
= sds_prepare_to_store
;
1069 sds_ops
.to_xfer_memory
= sds_xfer_memory
;
1070 sds_ops
.to_files_info
= sds_files_info
;
1071 sds_ops
.to_insert_breakpoint
= sds_insert_breakpoint
;
1072 sds_ops
.to_remove_breakpoint
= sds_remove_breakpoint
;
1073 sds_ops
.to_kill
= sds_kill
;
1074 sds_ops
.to_load
= sds_load
;
1075 sds_ops
.to_create_inferior
= sds_create_inferior
;
1076 sds_ops
.to_mourn_inferior
= sds_mourn
;
1077 sds_ops
.to_stratum
= process_stratum
;
1078 sds_ops
.to_has_all_memory
= 1;
1079 sds_ops
.to_has_memory
= 1;
1080 sds_ops
.to_has_stack
= 1;
1081 sds_ops
.to_has_registers
= 1;
1082 sds_ops
.to_has_execution
= 1;
1083 sds_ops
.to_magic
= OPS_MAGIC
;
1086 /* Put a command string, in args, out to the monitor and display the
1090 sds_command (char *args
, int from_tty
)
1094 unsigned char buf
[1000];
1096 /* Convert hexadecimal chars into a byte buffer. */
1101 buf
[len
++] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
1107 retlen
= sds_send (buf
, len
);
1109 printf_filtered ("Reply is ");
1110 for (i
= 0; i
< retlen
; ++i
)
1112 printf_filtered ("%02x", buf
[i
]);
1114 printf_filtered ("\n");
1118 _initialize_remote_sds (void)
1121 add_target (&sds_ops
);
1123 add_show_from_set (add_set_cmd ("sdstimeout", no_class
,
1124 var_integer
, (char *) &sds_timeout
,
1125 "Set timeout value for sds read.\n", &setlist
),
1128 add_com ("sds", class_obscure
, sds_command
,
1129 "Send a command to the SDS monitor.");