home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gdb-4.12-src.lha / GNU / src / amiga / gdb-4.12 / gdb / remote-e7000.c < prev    next >
C/C++ Source or Header  |  1994-02-03  |  33KB  |  1,697 lines
  1. /* Remote debugging interface for Hitachi E7000 ICE, for GDB
  2.    Copyright 1993 Free Software Foundation, Inc.
  3.    Contributed by Cygnus Support. 
  4.  
  5.    Written by Steve Chamberlain for Cygnus Support.
  6.  
  7.    This file is part of GDB.
  8.  
  9.    This program is free software; you can redistribute it and/or modify
  10.    it under the terms of the GNU General Public License as published by
  11.    the Free Software Foundation; either version 2 of the License, or
  12.    (at your option) any later version.
  13.  
  14.    This program is distributed in the hope that it will be useful,
  15.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.    GNU General Public License for more details.
  18.  
  19.    You should have received a copy of the GNU General Public License
  20.    along with this program; if not, write to the Free Software
  21.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  22.  
  23.  
  24. #include "defs.h"
  25. #include "gdbcore.h"
  26. #include "target.h"
  27. #include "wait.h"
  28. #include <varargs.h>
  29. #include <signal.h>
  30. #include <string.h>
  31. #include <sys/types.h>
  32. #include "serial.h"
  33.  
  34.  
  35. /* The E7000 is an in-circuit emulator for the Hitachi H8/300-H and
  36. Hitachi-SH processor.  It has serial port and a lan port.  
  37.  
  38. The monitor command set makes it difficult to load large ammounts of
  39. data over the lan without using ftp - so try not to issue load
  40. commands when communicating over ethernet; use the ftpload command.
  41.  
  42. The monitor pauses for a second when dumping srecords to the serial
  43. line too, so we use a slower per byte mechanism but without the
  44. startup overhead.  Even so, it's pretty slow... */
  45.  
  46. int using_tcp; /* nonzero if using the tcp serial driver */
  47.  
  48. extern struct target_ops e7000_ops;    /* Forward declaration */
  49. #define CTRLC 0x03
  50. #define ENQ  0x05
  51. #define ACK  0x06
  52. #define CTRLZ 0x1a
  53.  
  54. char *ENQSTRING = "\005";
  55.  
  56. int echo;
  57. int ctrl_c;
  58. static void e7000_close ();
  59. static void e7000_fetch_register ();
  60. static void e7000_store_register ();
  61.  
  62. static int timeout = 5;
  63.  
  64. static void expect PARAMS ((char *));
  65. static void expect_full_prompt PARAMS (());
  66. static void expect_prompt PARAMS (());
  67. static serial_t e7000_desc;
  68.  
  69.  
  70. /* Send data to e7000debug.  Works just like printf. */
  71. #if 0
  72. static void
  73. printf_e7000debug (va_alist)
  74.      va_dcl
  75. {
  76.   va_list args;
  77.   char *pattern;
  78.   char buf[200];
  79.  
  80.   va_start (args);
  81.  
  82.   pattern = va_arg (args, char *);
  83.  
  84.   vsprintf (buf, pattern, args);
  85. #else
  86.  
  87. static void
  88. printf_e7000debug(a,b,c,d,e)
  89.   {
  90.     char buf[200];
  91.     sprintf(buf, a,b,c,d,e);
  92. #endif
  93.   if (SERIAL_WRITE (e7000_desc, buf, strlen (buf)))
  94.     fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
  95.  
  96.   /* And expect to see it echoed */
  97.   expect (buf);
  98. }
  99.  
  100. static void
  101. putchar_e7000 (x)
  102. {
  103.   char b[1];
  104.   b[0] = x;
  105.   SERIAL_WRITE (e7000_desc, b, 1);
  106. }
  107.  
  108. static void
  109. write_e7000 (s)
  110.      char *s;
  111. {
  112.   SERIAL_WRITE (e7000_desc, s, strlen (s));
  113. }
  114.  
  115. /* Read a character from the remote system, doing all the fancy timeout
  116.    stuff.  */
  117.  
  118. static int
  119. readchar (timeout)
  120.      int timeout;
  121. {
  122.   int c;
  123.   do
  124.     {
  125.       c = SERIAL_READCHAR (e7000_desc, timeout);
  126.     }
  127.   while (c > 127);
  128.   if (c == SERIAL_TIMEOUT)
  129.     {
  130.       if (timeout == 0)
  131.     return c;        /* Polls shouldn't generate timeout errors */
  132.  
  133.       error ("Timeout reading from remote system.");
  134.     }
  135.   return c;
  136. }
  137.  
  138.  
  139. /* Scan input from the remote system, until STRING is found.  If DISCARD is
  140.    non-zero, then discard non-matching input, else print it out.
  141.    Let the user break out immediately.  */
  142. static void
  143. expect (string)
  144.      char *string;
  145. {
  146.   char *p = string;
  147.   int c;
  148.  
  149.   while (1)
  150.  
  151.     {
  152.       c = readchar (timeout);
  153.  
  154.       notice_quit ();
  155.       if (quit_flag == 1) 
  156.     {
  157.       if (ctrl_c) {
  158.         putchar_e7000(CTRLC);
  159.         ctrl_c -- ;
  160.       }
  161.       else 
  162.         {
  163.           quit();
  164.         }
  165.     }
  166.       
  167.       if (c == SERIAL_ERROR)
  168.     {
  169.       error ("Serial communication error");
  170.     }
  171.       if (echo)
  172.     {
  173.       if (c != '\r')
  174.         putchar (c);
  175.       fflush (stdout);
  176.     }
  177.       if (c == *p++)
  178.     {
  179.       if (*p == '\0')
  180.         {
  181.           return;
  182.         }
  183.     }
  184.       else
  185.     {
  186.       p = string;
  187.     }
  188.     }
  189. }
  190.  
  191. /* Keep discarding input until we see the e7000 prompt.
  192.  
  193.    The convention for dealing with the prompt is that you
  194.    o give your command
  195.    o *then* wait for the prompt.
  196.  
  197.    Thus the last thing that a procedure does with the serial line
  198.    will be an expect_prompt().  Exception:  e7000_resume does not
  199.    wait for the prompt, because the terminal is being handed over
  200.    to the inferior.  However, the next thing which happens after that
  201.    is a e7000_wait which does wait for the prompt.
  202.    Note that this includes abnormal exit, e.g. error().  This is
  203.    necessary to prevent getting into states from which we can't
  204.    recover.  */
  205. static void
  206. expect_prompt ()
  207. {
  208.   expect (":");
  209. }
  210. static void
  211. expect_full_prompt ()
  212. {
  213.   expect ("\n:");
  214. }
  215.  
  216. static int
  217. get_hex_digit (ch)
  218. {
  219.   if (ch >= '0' && ch <= '9')
  220.     return ch - '0';
  221.   else if (ch >= 'A' && ch <= 'F')
  222.     return ch - 'A' + 10;
  223.   else if (ch >= 'a' && ch <= 'f')
  224.     return ch - 'a' + 10;
  225.   return -1;
  226.  
  227. }
  228.  
  229.  
  230.  
  231. static int
  232. get_hex (start)
  233.      int *start;
  234. {
  235.   int value = get_hex_digit (*start);
  236.   int try;
  237.  
  238.   *start = readchar (timeout);
  239.   while ((try = get_hex_digit (*start)) >= 0)
  240.     {
  241.       value <<= 4;
  242.       value += try;
  243.       *start = readchar (timeout);
  244.     }
  245.   return value;
  246. }
  247.  
  248. /* Get N 32-bit words from remote, each preceded by a space,
  249.    and put them in registers starting at REGNO.  */
  250.  
  251. static void
  252. get_hex_regs (n, regno)
  253.      int n;
  254.      int regno;
  255. {
  256.   long val;
  257.   int i;
  258.  
  259.   for (i = 0; i < n; i++)
  260.     {
  261.       int j;
  262.  
  263.       val = 0;
  264.       for (j = 0; j < 8; j++)
  265.     val = (val << 4) + get_hex_digit (j == 0);
  266.       supply_register (regno++, (char *) &val);
  267.     }
  268. }
  269.  
  270. /* This is called not only when we first attach, but also when the
  271.    user types "run" after having attached.  */
  272. static void
  273. e7000_create_inferior (execfile, args, env)
  274.      char *execfile;
  275.      char *args;
  276.      char **env;
  277. {
  278.   int entry_pt;
  279.  
  280.   if (args && *args)
  281.     error ("Can't pass arguments to remote E7000DEBUG process");
  282.  
  283.   if (execfile == 0 || exec_bfd == 0)
  284.     error ("No exec file specified");
  285.  
  286.   entry_pt = (int) bfd_get_start_address (exec_bfd);
  287.  
  288. #ifdef CREATE_INFERIOR_HOOK
  289.   CREATE_INFERIOR_HOOK (0);    /* No process-ID */
  290. #endif
  291.  
  292.   /* The "process" (board) is already stopped awaiting our commands, and
  293.      the program is already downloaded.  We just set its PC and go.  */
  294.  
  295.   clear_proceed_status ();
  296.  
  297.   /* Tell wait_for_inferior that we've started a new process.  */
  298.   init_wait_for_inferior ();
  299.  
  300.   /* Set up the "saved terminal modes" of the inferior
  301.      based on what modes we are starting it with.  */
  302.   target_terminal_init ();
  303.  
  304.   /* Install inferior's terminal modes.  */
  305.   target_terminal_inferior ();
  306.  
  307.   /* insert_step_breakpoint ();  FIXME, do we need this?  */
  308.   proceed ((CORE_ADDR) entry_pt, -1, 0);    /* Let 'er rip... */
  309. }
  310.  
  311. /* Open a connection to a remote debugger.
  312.    NAME is the filename used for communication.  */
  313.  
  314. static int baudrate = 9600;
  315. static char dev_name[100];
  316.  
  317. static char *machine = "";
  318. static char *user = "";
  319. static char *passwd = "";
  320. static char *dir = "";
  321.  
  322. /* Grab the next token and buy some space for it */
  323. static char *
  324. next (ptr)
  325.      char **ptr;
  326. {
  327.   char *p = *ptr;
  328.   char *s;
  329.   char *r;
  330.   int l = 0;
  331.   while (*p && *p == ' ')
  332.     {
  333.       p++;
  334.     }
  335.   s = p;
  336.   while (*p && (*p != ' ' && *p != '\t'))
  337.     {
  338.       l++;
  339.       p++;
  340.     }
  341.   r = xmalloc (l + 1);
  342.   memcpy (r, s, l);
  343.   r[l] = 0;
  344.   *ptr = p;
  345.   return r;
  346. }
  347.  
  348. static
  349. e7000_login (args, from_tty)
  350.      char *args;
  351.      int from_tty;
  352. {
  353.   if (args)
  354.     {
  355.       machine = next (&args);
  356.       user = next (&args);
  357.       passwd = next (&args);
  358.       dir = next (&args);
  359.       if (from_tty)
  360.     {
  361.       printf ("Set info to %s %s %s %s\n", machine, user, passwd, dir);
  362.     }
  363.     }
  364.   else
  365.     {
  366.       error ("Syntax is ftplogin <machine> <user> <passwd> <directory>");
  367.     }
  368. }
  369.  
  370. /* Start an ftp transfer from the E7000 to a host */
  371.  
  372. static
  373. e7000_ftp (args, from_tty)
  374.      char *args;
  375.      int from_tty;
  376. {
  377.   int oldtimeout = timeout;
  378.   timeout = 10;
  379.   printf_e7000debug ("ftp %s\r", machine);
  380.   expect (" Username : ");
  381.   printf_e7000debug ("%s\r", user);
  382.   expect (" Password : ");
  383.   write_e7000 (passwd);