1 /* Remote debugging interface for Hitachi E7000 ICE, for GDB.
2 Copyright 1993 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Steve Chamberlain for Cygnus.
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
29 #include <sys/types.h>
33 /* The E7000 is an in-circuit emulator for the Hitachi H8/300-H and
34 Hitachi-SH processor. It has serial port and a lan port.
36 The monitor command set makes it difficult to load large ammounts of
37 data over the lan without using ftp - so try not to issue load
38 commands when communicating over ethernet; use the ftpload command.
40 The monitor pauses for a second when dumping srecords to the serial
41 line too, so we use a slower per byte mechanism but without the
42 startup overhead. Even so, it's pretty slow... */
44 int using_tcp
; /* nonzero if using the tcp serial driver */
46 extern struct target_ops e7000_ops
; /* Forward declaration */
52 char *ENQSTRING
= "\005";
55 static int echo_index
;
56 static void e7000_close ();
57 static void e7000_fetch_register ();
58 static void e7000_store_register ();
60 static int timeout
= 5;
62 static void expect
PARAMS ((char *));
63 static void expect_full_prompt
PARAMS (());
64 static void expect_prompt
PARAMS (());
65 static serial_t e7000_desc
;
68 /* Send data to e7000debug. Works just like printf. */
71 printf_e7000debug (va_alist
)
80 pattern
= va_arg (args
, char *);
82 vsprintf (buf
, pattern
, args
);
83 if (SERIAL_WRITE (e7000_desc
, buf
, strlen (buf
)))
84 fprintf (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
86 /* And expect to see it echoed */
95 SERIAL_WRITE (e7000_desc
, b
, 1);
102 SERIAL_WRITE (e7000_desc
, s
, strlen (s
));
105 /* Read a character from the remote system, doing all the fancy timeout
115 c
= SERIAL_READCHAR (e7000_desc
, timeout
);
118 if (c
== SERIAL_TIMEOUT
)
121 return c
; /* Polls shouldn't generate timeout errors */
123 error ("Timeout reading from remote system.");
128 /* Scan input from the remote system, until STRING is found. If DISCARD is
129 non-zero, then discard non-matching input, else print it out.
130 Let the user break out immediately. */
142 c
= readchar (timeout
);
143 if (c
== SERIAL_ERROR
)
145 error ("Serial communication error");
168 /* Keep discarding input until we see the e7000 prompt.
170 The convention for dealing with the prompt is that you
172 o *then* wait for the prompt.
174 Thus the last thing that a procedure does with the serial line
175 will be an expect_prompt(). Exception: e7000_resume does not
176 wait for the prompt, because the terminal is being handed over
177 to the inferior. However, the next thing which happens after that
178 is a e7000_wait which does wait for the prompt.
179 Note that this includes abnormal exit, e.g. error(). This is
180 necessary to prevent getting into states from which we can't
185 #if defined (LOG_FILE)
186 /* This is a convenient place to do this. The idea is to do it often
187 enough that we never lose much data if we terminate abnormally. */
193 expect_full_prompt ()
195 #if defined (LOG_FILE)
196 /* This is a convenient place to do this. The idea is to do it often
197 enough that we never lose much data if we terminate abnormally. */
206 if (ch
>= '0' && ch
<= '9')
208 else if (ch
>= 'A' && ch
<= 'F')
209 return ch
- 'A' + 10;
210 else if (ch
>= 'a' && ch
<= 'f')
211 return ch
- 'a' + 10;
222 int value
= get_hex_digit (*start
);
225 *start
= readchar (timeout
);
226 while ((try = get_hex_digit (*start
)) >= 0)
230 *start
= readchar (timeout
);
235 /* Get N 32-bit words from remote, each preceded by a space,
236 and put them in registers starting at REGNO. */
239 get_hex_regs (n
, regno
)
246 for (i
= 0; i
< n
; i
++)
251 for (j
= 0; j
< 8; j
++)
252 val
= (val
<< 4) + get_hex_digit (j
== 0);
253 supply_register (regno
++, (char *) &val
);
257 /* This is called not only when we first attach, but also when the
258 user types "run" after having attached. */
260 e7000_create_inferior (execfile
, args
, env
)
268 error ("Can't pass arguments to remote E7000DEBUG process");
270 if (execfile
== 0 || exec_bfd
== 0)
271 error ("No exec file specified");
273 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
275 #ifdef CREATE_INFERIOR_HOOK
276 CREATE_INFERIOR_HOOK (0); /* No process-ID */
279 /* The "process" (board) is already stopped awaiting our commands, and
280 the program is already downloaded. We just set its PC and go. */
282 clear_proceed_status ();
284 /* Tell wait_for_inferior that we've started a new process. */
285 init_wait_for_inferior ();
287 /* Set up the "saved terminal modes" of the inferior
288 based on what modes we are starting it with. */
289 target_terminal_init ();
291 /* Install inferior's terminal modes. */
292 target_terminal_inferior ();
294 /* insert_step_breakpoint (); FIXME, do we need this? */
295 proceed ((CORE_ADDR
) entry_pt
, -1, 0); /* Let 'er rip... */
298 /* Open a connection to a remote debugger.
299 NAME is the filename used for communication. */
301 static int baudrate
= 9600;
302 static char dev_name
[100];
304 static char *machine
= "";
305 static char *user
= "";
306 static char *passwd
= "";
307 static char *dir
= "";
309 /* Grab the next token and buy some space for it */
318 while (*p
&& *p
== ' ')
323 while (*p
&& (*p
!= ' ' && *p
!= '\t'))
336 e7000_login (args
, from_tty
)
342 machine
= next (&args
);
344 passwd
= next (&args
);
348 printf ("Set info to %s %s %s %s\n", machine
, user
, passwd
, dir
);
353 error ("Syntax is ftplogin <machine> <user> <passwd> <directory>");
357 /* Start an ftp transfer from the E7000 to a host */
360 e7000_ftp (args
, from_tty
)
364 int oldtimeout
= timeout
;
367 printf_e7000debug ("ftp %s\r", machine
);
368 expect (" Username : ");
369 printf_e7000debug ("%s\r", user
);
370 expect (" Password : ");
371 write_e7000 (passwd
);
373 expect ("success\r");
375 printf_e7000debug ("cd %s\r", dir
);
377 printf_e7000debug ("ll 0;s:%s\r", args
);
379 printf_e7000debug ("bye\r");
382 timeout
= oldtimeout
;
386 e7000_open (args
, from_tty
)
393 target_preopen (from_tty
);
396 n
= sscanf (args
, " %s %d %s", dev_name
, &baudrate
, junk
);
399 if (n
!= 1 && n
!= 2)
400 error ("Bad arguments. Usage:\ttarget e7000 <device> <speed>\n\
401 or \t\ttarget e7000 <host>[:<port>]\n");
403 if (n
== 1 && strchr (dev_name
, ':') == 0)
405 /* Default to normal telnet port */
406 strcat (dev_name
, ":23");
409 push_target (&e7000_ops
);
410 e7000_desc
= SERIAL_OPEN (dev_name
);
414 perror_with_name (dev_name
);
416 using_tcp
= strcmp (e7000_desc
->ops
->name
, "tcp") == 0;
418 SERIAL_SETBAUDRATE (e7000_desc
, baudrate
);
419 SERIAL_RAW (e7000_desc
);
421 /* Hello? Are you there? */
427 printf_unfiltered ("[waiting for e7000...]\n");
428 write_e7000 ("\r\n");
429 c
= SERIAL_READCHAR (e7000_desc
, 3);
430 while (c
!= SERIAL_TIMEOUT
)
433 if (from_tty
&& c
!= '\r')
442 c
= SERIAL_READCHAR (e7000_desc
, 3);
445 putchar_e7000 (CTRLC
);
450 printf_e7000debug ("\r\n");
454 printf_filtered ("Remote %s connected to %s\n", target_shortname
,
459 /* Close out all files and local state before this target loses control. */
462 e7000_close (quitting
)
467 SERIAL_CLOSE (e7000_desc
);
472 /* Terminate the open connection to the remote debugger.
473 Use this when you want to detach and do something else
476 e7000_detach (from_tty
)
479 pop_target (); /* calls e7000_close to do the real work */
481 printf ("Ending remote %s debugging\n", target_shortname
);
484 /* Tell the remote machine to resume. */
487 e7000_resume (pid
, step
, sig
)
492 printf_e7000debug ("S\r");
496 printf_e7000debug ("G\r");
500 /* Read the remote registers into the block REGS.
502 A reg dump looks like:
506 #ifdef GDB_TARGET_IS_H8300
509 ER0 - ER3 %0 %1 %2 %3\n\
510 ER4 - ER7 %4 %5 %6 %7\n\
514 #ifdef GDB_TARGET_IS_SH
515 char *want
= "\n\PC=%16 SR=%22\n\
516 PR=%17 GBR=%18 VBR=%19\n\
518 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
519 R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\
522 char *want_nopc
= "%16 SR=%22\n\
523 PR=%17 GBR=%18 VBR=%19\n\
525 R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\
526 R8-15 %8 %9 %10 %11 %12 %13 %14 %15";
535 int c
= readchar (timeout
);
551 int high
= get_hex_digit (gch ());
552 int low
= get_hex_digit (gch ());
553 return (high
<< 4) + low
;
557 fetch_regs_from_dump (nextchar
, want
)
562 char buf
[MAX_REGISTER_RAW_SIZE
];
564 int thischar
= nextchar();
571 while (thischar
!= '\n')
572 thischar
= nextchar();
573 thischar
= nextchar();
574 while (thischar
== '\r')
575 thischar
= nextchar();
580 while (thischar
== ' ' || thischar
== '\t')
581 thischar
= nextchar();
586 if (*want
== thischar
)
590 thischar
= nextchar();
593 else if (thischar
== ' ')
595 thischar
= nextchar();
598 error("out of sync in fetch registers");
603 /* Got a register command */
634 if (isdigit(want
[0]))
636 if (isdigit(want
[1]))
638 regno
= (want
[0] - '0') * 10 + want
[1] - '0';
643 regno
= want
[0] - '0';
651 store_signed_integer (buf
,
652 REGISTER_RAW_SIZE(regno
),
653 (LONGEST
)get_hex(&thischar
, nextchar
));
654 supply_register (regno
, buf
);
661 e7000_fetch_registers ()
665 printf_e7000debug ("R\r");
666 fetch_regs_from_dump (gch
, want
);
668 /* And supply the extra ones the simulator uses */
669 for (regno
= NUM_REALREGS
; regno
< NUM_REGS
; regno
++)
672 supply_register (regno
, (char *) (&buf
));
676 /* Fetch register REGNO, or all registers if REGNO is -1.
677 Returns errno value. */
681 e7000_fetch_register (regno
)
684 e7000_fetch_registers ();
687 /* Store the remote registers from the contents of the block REGS. */
690 e7000_store_registers ()
694 for (regno
= 0; regno
< NUM_REALREGS
; regno
++)
695 e7000_store_register (regno
);
697 registers_changed ();
700 /* Store register REGNO, or all if REGNO == 0.
701 Return errno value. */
703 e7000_store_register (regno
)
708 e7000_store_registers ();
711 #ifdef GDB_TARGET_IS_H8300
714 printf_e7000debug (".ER%d %x\r", regno
,
715 read_register (regno
));
718 else if (regno
== PC_REGNUM
)
720 printf_e7000debug (".PC %x\r",
721 read_register (regno
));
723 else if (regno
== CCR_REGNUM
)
725 printf_e7000debug (".CCR %x\r",
726 read_register (regno
));
730 #ifdef GDB_TARGET_IS_SH
734 printf_e7000debug (".R%d %x\r", regno
,
735 read_register (regno
));
739 printf_e7000debug (".PC %x\r",
740 read_register (regno
));
743 printf_e7000debug (".SR %x\r",
744 read_register (regno
));
748 printf_e7000debug (".PR %x\r",
749 read_register (regno
));
753 printf_e7000debug (".GBR %x\r",
754 read_register (regno
));
758 printf_e7000debug (".VBR %x\r",
759 read_register (regno
));
763 printf_e7000debug (".MACH %x\r",
764 read_register (regno
));
768 printf_e7000debug (".MACL %x\r",
769 read_register (regno
));
777 /* Get ready to modify the registers array. On machines which store
778 individual registers, this doesn't need to do anything. On machines
779 which store all the registers in one fell swoop, this makes sure
780 that registers contains all the registers from the program being
784 e7000_prepare_to_store ()
786 /* Do nothing, since we can store individual regs */
792 printf ("\tAttached to %s at %d baud.\n",
798 stickbyte (where
, what
)
802 static CONST
char digs
[] = "0123456789ABCDEF";
803 where
[0] = digs
[(what
>> 4) & 0xf];
804 where
[1] = digs
[(what
& 0xf) & 0xf];
808 /* Write a small ammount of memory */
810 write_small (memaddr
, myaddr
, len
)
812 unsigned char *myaddr
;
816 for (i
= 0; i
< len
; i
++)
818 if (((memaddr
+ i
) & 3) == 0
821 /* Can be done with a long word */
822 printf_e7000debug ("m %x %x%02x%02x%02x;l\r",
832 printf_e7000debug ("m %x %x\r", memaddr
+ i
, myaddr
[i
]);
838 /* Write a large ammount of memory, this only works with the serial mode enabled.
853 write_large (memaddr
, myaddr
, len
)
855 unsigned char *myaddr
;
859 #define maxstride 128
862 printf_e7000debug ("il ;s:s\r");
867 for (i
= 0; i
< len
; i
+= stride
)
869 char compose
[maxstride
* 2 + 50];
870 int address
= i
+ memaddr
;
876 if (stride
> maxstride
)
879 compose
[where
++] = 'S';
881 if (address
>= 0xffffff)
885 else if (address
>= 0xffff)
891 compose
[where
++] = alen
- 1 + '0'; /* insert type */
892 check_sum
+= stickbyte (compose
+ where
, alen
+ stride
+ 1); /* Insert length */
897 check_sum
+= stickbyte (compose
+ where
, address
>> (8 * (alen
)));
901 for (j
= 0; j
< stride
; j
++)
903 check_sum
+= stickbyte (compose
+ where
, myaddr
[i
+ j
]);
907 stickbyte (compose
+ where
, ~check_sum
);
910 compose
[where
++] = '\r';
911 SERIAL_WRITE (e7000_desc
, compose
, where
);
912 j
= SERIAL_READCHAR (e7000_desc
, 0);
913 if (j
== SERIAL_TIMEOUT
)
915 /* This is ok - nothing there */
919 /* Hmm, it's trying to tell us something */
921 error ("Error writing memory");
925 printf ("Whats this %d\n", j
);
929 /* Send the trailer record */
930 write_e7000 ("S70500000000FA\r");
931 putchar_e7000 (CTRLZ
);
938 /* Copy LEN bytes of data from debugger memory at MYADDR
939 to inferior's memory at MEMADDR. Returns length moved.
941 Can't use the Srecord load over ethernet, so dont use
945 e7000_write_inferior_memory (memaddr
, myaddr
, len
)
947 unsigned char *myaddr
;
950 if (len
< 16 || using_tcp
)
952 return write_small (memaddr
, myaddr
, len
);
956 return write_large (memaddr
, myaddr
, len
);
960 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
961 at debugger address MYADDR. Returns length moved.
963 Done by requesting an srecord dump from the E7000.
968 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
969 at debugger address MYADDR. Returns length moved.
972 Small transactions we send
980 e7000_read_inferior_memory (memaddr
, myaddr
, len
)
982 unsigned char *myaddr
;
988 /* Starting address of this pass. */
990 if (((memaddr
- 1) + len
) < memaddr
)
996 printf_e7000debug ("m %x;l\r", memaddr
);
998 for (count
= 0; count
< len
; count
+= 4)
1000 /* Suck away the address */
1006 { /* Some kind of error */
1013 /* Now read in the data */
1014 for (i
= 0; i
< 4; i
++)
1017 if (count
+ i
< len
) {
1018 myaddr
[count
+ i
] = b
;
1022 /* Skip the trailing ? and send a . to end and a cr for more */
1025 if (count
+ 4 >= len
)
1026 printf_e7000debug(".\r");
1028 printf_e7000debug("\r");
1036 For large transfers we used to send
1039 d <addr> <endaddr>\r
1042 <ADDR> < D A T A > < ASCII CODE >
1043 000000 5F FD FD FF DF 7F DF FF 01 00 01 00 02 00 08 04 "_..............."
1044 000010 FF D7 FF 7F D7 F1 7F FF 00 05 00 00 08 00 40 00 "..............@."
1045 000020 7F FD FF F7 7F FF FF F7 00 00 00 00 00 00 00 00 "................"
1047 A cost in chars for each transaction of 80 + 5*n-bytes.
1050 Large transactions could be done with the srecord load code, but
1051 there is a pause for a second before dumping starts, which slows the
1056 e7000_read_inferior_memory (memaddr
, myaddr
, len
)
1058 unsigned char *myaddr
;
1064 /* Starting address of this pass. */
1066 if (((memaddr
- 1) + len
) < memaddr
)
1072 printf_e7000debug ("d %x %x\r", memaddr
, memaddr
+ len
- 1);
1077 /* First skip the command */
1089 /* Skip the title line */
1095 /* Skip the address */
1101 /* read in the bytes on the line */
1102 while (c
!= '"' && count
< len
)
1108 myaddr
[count
++] = get_hex (&c
);
1123 fast_but_for_the_pause_e7000_read_inferior_memory (memaddr
, myaddr
, len
)
1131 if (((memaddr
- 1) + len
) < memaddr
)
1137 printf_e7000debug ("is %x@%x:s\r", memaddr
, len
);
1143 error ("Memory read error");
1145 putchar_e7000 (ACK
);
1157 case ENQ
: /* ENQ, at the end */
1161 /* Start of an Srecord */
1166 case '7': /* Termination record, ignore */
1170 /* Header record - ignore it */
1181 alen
= type
- '0' + 1;
1185 addr
= (addr
<< 8) + gbyte ();
1189 for (i
= 0; i
< length
- 1; i
++)
1191 myaddr
[i
+ addr
- memaddr
] = gbyte ();
1193 gbyte (); /* Ignore checksum */
1198 putchar_e7000 (ACK
);
1199 expect ("TOP ADDRESS =");
1200 expect ("END ADDRESS =");
1209 e7000_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
1211 unsigned char *myaddr
;
1214 struct target_ops
*target
; /* ignored */
1218 return e7000_write_inferior_memory( memaddr
, myaddr
, len
);
1222 return e7000_read_inferior_memory( memaddr
, myaddr
, len
);
1227 e7000_kill (args
, from_tty
)
1234 /* Clean up when a program exits.
1236 The program actually lives on in the remote processor's RAM, and may be
1237 run again without a download. Don't leave it full of breakpoint
1241 e7000_mourn_inferior ()
1243 remove_breakpoints ();
1244 unpush_target (&e7000_ops
);
1245 generic_mourn_inferior (); /* Do all the proper things now */
1248 #define MAX_E7000DEBUG_BREAKPOINTS 200
1250 extern int memory_breakpoint_size
;
1251 static CORE_ADDR breakaddr
[MAX_E7000DEBUG_BREAKPOINTS
] =
1255 e7000_insert_breakpoint (addr
, shadow
)
1257 unsigned char *shadow
;
1260 static char nop
[2] =
1263 for (i
= 0; i
<= MAX_E7000DEBUG_BREAKPOINTS
; i
++)
1264 if (breakaddr
[i
] == 0)
1266 breakaddr
[i
] = addr
;
1267 /* Save old contents, and insert a nop in the space */
1268 e7000_read_inferior_memory (addr
, shadow
, 2);
1269 e7000_write_inferior_memory (addr
, nop
, 2);
1270 printf_e7000debug ("B %x\r", addr
);
1275 error("Too many breakpoints ( > %d) for the E7000\n", MAX_E7000DEBUG_BREAKPOINTS
);
1280 e7000_remove_breakpoint (addr
, shadow
)
1282 unsigned char *shadow
;
1286 for (i
= 0; i
< MAX_E7000DEBUG_BREAKPOINTS
; i
++)
1287 if (breakaddr
[i
] == addr
)
1290 printf_e7000debug ("B - %x\r", addr
);
1292 /* Replace the insn under the break */
1293 e7000_write_inferior_memory (addr
, shadow
, 2);
1297 fprintf (stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
1302 /* Put a command string, in args, out to STDBUG. Output from STDBUG is placed
1303 on the users terminal until the prompt is seen. */
1306 e7000_command (args
, fromtty
)
1312 error ("e7000 target not open.");
1315 printf_e7000debug ("\r");
1319 printf_e7000debug ("%s\r", args
);
1322 expect_full_prompt ();
1324 printf_unfiltered ("\n");
1328 e7000_load (args
, fromtty
)
1332 load_target_image (args
, fromtty
);
1336 e7000_drain (args
, fromtty
)
1343 while ((c
= SERIAL_READCHAR (e7000_desc
, 2) != SERIAL_TIMEOUT
))
1345 if (c
> ' ' && c
< 127)
1346 printf ("%c", c
& 0xff);
1348 printf ("<%x>", c
& 0xff);
1357 /* Wait until the remote machine stops, then return,
1358 storing status in STATUS just as `wait' would. */
1361 e7000_wait (pid
, status
)
1369 WSETSTOP ((*status
), 0);
1370 /* Then echo chars until PC= string seen */
1371 gch (); /* Drop cr */
1372 gch (); /* and space */
1375 c
= SERIAL_READCHAR (e7000_desc
, 1);
1381 printf_unfiltered ("[waiting for e7000..]\n");
1388 putchar_e7000 (CTRLC
); /* interrupt the running program */
1392 c
= SERIAL_READCHAR (e7000_desc
, 1);
1395 c
= SERIAL_READCHAR (e7000_desc
, 1);
1420 fetch_regs_from_dump (gch
, want_nopc
);
1422 /* And supply the extra ones the simulator uses */
1423 for (regno
= NUM_REALREGS
; regno
< NUM_REGS
; regno
++)
1426 supply_register (regno
, (char *) &buf
);
1429 expect_full_prompt ();
1430 WSETSTOP ((*status
), SIGTRAP
);
1435 /* Define the target subroutine names */
1437 struct target_ops e7000_ops
=
1440 "Remote Hitachi e7000 target",
1441 "Use a remote Hitachi e7000 ICE connected by a serial line,\n\
1442 or a network connection.\n\
1443 Arguments are the name of the device for the serial line,\n\
1444 the speed to connect at in bits per second.\n\
1446 target e7000 /dev/ttya 9600\n\
1447 target e7000 foobar",
1454 e7000_fetch_register
,
1455 e7000_store_register
,
1456 e7000_prepare_to_store
,
1457 e7000_xfer_inferior_memory
,
1459 e7000_insert_breakpoint
,
1460 e7000_remove_breakpoint
, /* Breakpoints */
1465 0, /* Terminal handling */
1467 e7000_load
, /* load */
1468 0, /* lookup_symbol */
1469 e7000_create_inferior
,
1470 e7000_mourn_inferior
,
1472 0, /* notice_signals */
1479 1, /* all mem, mem, stack, regs, exec */
1481 0, /* Section pointers */
1482 OPS_MAGIC
, /* Always the last thing */
1486 _initialize_remote_e7000 ()
1488 add_target (&e7000_ops
);
1489 add_com ("e7000 <command>", class_obscure
, e7000_command
,
1490 "Send a command to the e7000 monitor.");
1492 add_com ("ftplogin <machine> <name> <passwd> <dir>", class_obscure
, e7000_login
,
1493 "Login to machine and change to directory.");
1495 add_com ("ftpload <file>", class_obscure
, e7000_ftp
,
1496 "Fetch and load a file from previously described place.");
1498 add_com ("drain", class_obscure
, e7000_drain
,
1499 "Drain pending e7000 text buffers.");
1500 add_com ("echo", class_obscure
, e7000_noecho
, "Toggle monitor echo.");