home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 9 / FreshFishVol9-CD2.bin / bbs / gnu / gdb-4.14-src.lha / gdb-4.14 / gdb / ser-unix.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-02  |  15.2 KB  |  685 lines
  1. /* Serial interface for local (hardwired) serial ports on Un*x like systems
  2.    Copyright 1992, 1993, 1994 Free Software Foundation, Inc.
  3.  
  4. This file is part of GDB.
  5.  
  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.
  10.  
  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.
  15.  
  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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20. #include "defs.h"
  21. #include "serial.h"
  22. #include <fcntl.h>
  23. #include <sys/types.h>
  24.  
  25. #if !defined (HAVE_TERMIOS) && !defined (HAVE_TERMIO) && !defined (HAVE_SGTTY)
  26. #define HAVE_SGTTY
  27. #endif
  28.  
  29. #ifdef HAVE_TERMIOS
  30. #include <termios.h>
  31. #include <unistd.h>
  32.  
  33. struct hardwire_ttystate
  34. {
  35.   struct termios termios;
  36. };
  37. #endif /* termios */
  38.  
  39. #ifdef HAVE_TERMIO
  40. #include <termio.h>
  41.  
  42. /* It is believed that all systems which have added job control to SVR3
  43.    (e.g. sco) have also added termios.  Even if not, trying to figure out
  44.    all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
  45.    bewildering.  So we don't attempt it.  */
  46.  
  47. struct hardwire_ttystate
  48. {
  49.   struct termio termio;
  50. };
  51. #endif /* termio */
  52.  
  53. #ifdef HAVE_SGTTY
  54. /* Needed for the code which uses select().  We would include <sys/select.h>
  55.    too if it existed on all systems.  */
  56. #include <sys/time.h>
  57.  
  58. #include <sgtty.h>
  59.  
  60. struct hardwire_ttystate
  61. {
  62.   struct sgttyb sgttyb;
  63.   struct tchars tc;
  64.   struct ltchars ltc;
  65.   /* Line discipline flags.  */
  66.   int lmode;
  67. };
  68. #endif /* sgtty */
  69.  
  70. static int hardwire_open PARAMS ((serial_t scb, const char *name));
  71. static void hardwire_raw PARAMS ((serial_t scb));
  72. static int wait_for PARAMS ((serial_t scb, int timeout));
  73. static int hardwire_readchar PARAMS ((serial_t scb, int timeout));
  74. static int rate_to_code PARAMS ((int rate));
  75. static int hardwire_setbaudrate PARAMS ((serial_t scb, int rate));
  76. static int hardwire_write PARAMS ((serial_t scb, const char *str, int len));
  77. /* FIXME: static void hardwire_restore PARAMS ((serial_t scb)); */
  78. static void hardwire_close PARAMS ((serial_t scb));
  79. static int get_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate *state));
  80. static int set_tty_state PARAMS ((serial_t scb, struct hardwire_ttystate *state));
  81. static serial_ttystate hardwire_get_tty_state PARAMS ((serial_t scb));
  82. static int hardwire_set_tty_state PARAMS ((serial_t scb, serial_ttystate state));
  83.  
  84. /* Open up a real live device for serial I/O */
  85.  
  86. static int
  87. hardwire_open(scb, name)
  88.      serial_t scb;
  89.      const char *name;
  90. {
  91.   scb->fd = open (name, O_RDWR);
  92.   if (scb->fd < 0)
  93.     return -1;
  94.  
  95.   return 0;
  96. }
  97.  
  98. static int
  99. get_tty_state(scb, state)
  100.      serial_t scb;
  101.      struct hardwire_ttystate *state;
  102. {
  103. #ifdef HAVE_TERMIOS
  104.   extern int errno;
  105.  
  106.   if (tcgetattr(scb->fd, &state->termios) < 0)
  107.     return -1;
  108.  
  109.   return 0;
  110. #endif
  111.  
  112. #ifdef HAVE_TERMIO
  113.   if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
  114.     return -1;
  115.   return 0;
  116. #endif
  117.  
  118. #ifdef HAVE_SGTTY
  119.   if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
  120.     return -1;
  121.   if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
  122.     return -1;
  123.   if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
  124.     return -1;
  125.   if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
  126.     return -1;
  127.  
  128.   return 0;
  129. #endif
  130. }
  131.  
  132. static int
  133. set_tty_state(scb, state)
  134.      serial_t scb;
  135.      struct hardwire_ttystate *state;
  136. {
  137. #ifdef HAVE_TERMIOS
  138.   if (tcsetattr(scb->fd, TCSANOW, &state->termios) < 0)
  139.     return -1;
  140.  
  141.   return 0;
  142. #endif
  143.  
  144. #ifdef HAVE_TERMIO
  145.   if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
  146.     return -1;
  147.   return 0;
  148. #endif
  149.  
  150. #ifdef HAVE_SGTTY
  151.   if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
  152.     return -1;
  153.   if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
  154.     return -1;
  155.   if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
  156.     return -1;
  157.   if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
  158.     return -1;
  159.  
  160.   return 0;
  161. #endif
  162. }
  163.  
  164. static serial_ttystate
  165. hardwire_get_tty_state(scb)
  166.      serial_t scb;
  167. {
  168.   struct hardwire_ttystate *state;
  169.  
  170.   state = (struct hardwire_ttystate *)xmalloc(sizeof *state);
  171.  
  172.   if (get_tty_state(scb, state))
  173.     return NULL;
  174.  
  175.   return (serial_ttystate)state;
  176. }
  177.  
  178. static int
  179. hardwire_set_tty_state(scb, ttystate)
  180.      serial_t scb;
  181.      serial_ttystate ttystate;
  182. {
  183.   struct hardwire_ttystate *state;
  184.  
  185.   state = (struct hardwire_ttystate *)ttystate;
  186.  
  187.   return set_tty_state(scb, state);
  188. }
  189.  
  190. static int
  191. hardwire_noflush_set_tty_state (scb, new_ttystate, old_ttystate)
  192.      serial_t scb;
  193.      serial_ttystate new_ttystate;
  194.      serial_ttystate old_ttystate;
  195. {
  196.   struct hardwire_ttystate new_state;
  197.   struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
  198.  
  199.   new_state = *(struct hardwire_ttystate *)new_ttystate;
  200.  
  201.   /* Don't change in or out of raw mode; we don't want to flush input.
  202.      termio and termios have no such restriction; for them flushing input
  203.      is separate from setting the attributes.  */
  204.  
  205. #ifdef HAVE_SGTTY
  206.   if (state->sgttyb.sg_flags & RAW)
  207.     new_state.sgttyb.sg_flags |= RAW;
  208.   else
  209.     new_state.sgttyb.sg_flags &= ~RAW;
  210.  
  211.   /* I'm not sure whether this is necessary; the manpage just mentions
  212.      RAW not CBREAK.  */
  213.   if (state->sgttyb.sg_flags & CBREAK)
  214.     new_state.sgttyb.sg_flags |= CBREAK;
  215.   else
  216.     new_state.sgttyb.sg_flags &= ~CBREAK;
  217. #endif
  218.  
  219.   return set_tty_state (scb, &new_state);
  220. }
  221.  
  222. static void
  223. hardwire_print_tty_state (scb, ttystate)
  224.      serial_t scb;
  225.      serial_ttystate ttystate;
  226. {
  227.   struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
  228.   int i;
  229.  
  230. #ifdef HAVE_TERMIOS
  231.   printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
  232.            state->termios.c_iflag, state->termios.c_oflag);
  233.   printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x\n",
  234.            state->termios.c_cflag, state->termios.c_lflag);
  235. #if 0
  236.   /* This not in POSIX, and is not really documented by those systems
  237.      which have it (at least not Sun).  */
  238.   printf_filtered ("c_line = 0x%x.\n", state->termios.c_line);
  239. #endif
  240.   printf_filtered ("c_cc: ");
  241.   for (i = 0; i < NCCS; i += 1)
  242.     printf_filtered ("0x%x ", state->termios.c_cc[i]);
  243.   printf_filtered ("\n");
  244. #endif
  245.  
  246. #ifdef HAVE_TERMIO
  247.   printf_filtered ("c_iflag = 0x%x, c_oflag = 0x%x,\n",
  248.            state->termio.c_iflag, state->termio.c_oflag);
  249.   printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
  250.            state->termio.c_cflag, state->termio.c_lflag,
  251.            state->termio.c_line);
  252.   printf_filtered ("c_cc: ");
  253.   for (i = 0; i < NCC; i += 1)
  254.     printf_filtered ("0x%x ", state->termio.c_cc[i]);
  255.   printf_filtered ("\n");
  256. #endif
  257.  
  258. #ifdef HAVE_SGTTY
  259.   printf_filtered ("sgttyb.sg_flags = 0x%x.\n", state->sgttyb.sg_flags);
  260.  
  261.   printf_filtered ("tchars: ");
  262.   for (i = 0; i < (int)sizeof (struct tchars); i++)
  263.     printf_filtered ("0x%x ", ((unsigned char *)&state->tc)[i]);
  264.   printf_filtered ("\n");
  265.  
  266.   printf_filtered ("ltchars: ");
  267.   for (i = 0; i < (int)sizeof (struct ltchars); i++)
  268.     printf_filtered ("0x%x ", ((unsigned char *)&state->ltc)[i]);
  269.   printf_filtered ("\n");
  270.  
  271.   printf_filtered ("lmode:  0x%x\n", state->lmode);
  272. #endif
  273. }
  274.  
  275. static int
  276. hardwire_flush_output (scb)
  277.      serial_t scb;
  278. {
  279. #ifdef HAVE_TERMIOS
  280.   return tcflush (scb->fd, TCOFLUSH);
  281. #endif
  282.  
  283. #ifdef HAVE_TERMIO
  284.   return ioctl (scb->fd, TCFLSH, 1);
  285. #endif
  286.  
  287. #ifdef HAVE_SGTTY
  288.   /* This flushes both input and output, but we can't do better.  */
  289.   return ioctl (scb->fd, TIOCFLUSH, 0);
  290. #endif  
  291. }
  292.  
  293. static int
  294. hardwire_flush_input (scb)
  295.      serial_t scb;
  296. {
  297. #ifdef HAVE_TERMIOS
  298.   return tcflush (scb->fd, TCIFLUSH);
  299. #endif
  300.  
  301. #ifdef HAVE_TERMIO
  302.   return ioctl (scb->fd, TCFLSH, 0);
  303. #endif
  304.  
  305. #ifdef HAVE_SGTTY
  306.   /* This flushes both input and output, but we can't do better.  */
  307.   return ioctl (scb->fd, TIOCFLUSH, 0);
  308. #endif  
  309. }
  310.  
  311. static int
  312. hardwire_send_break (scb)
  313.      serial_t scb;
  314. {
  315. #ifdef HAVE_TERMIOS
  316.   return tcsendbreak (scb->fd, 0);
  317. #endif
  318.  
  319. #ifdef HAVE_TERMIO
  320.   return ioctl (scb->fd, TCSBRK, 0);
  321. #endif
  322.  
  323. #ifdef HAVE_SGTTY
  324.   {
  325.     int status;
  326.     struct timeval timeout;
  327.  
  328.     status = ioctl (scb->fd, TIOCSBRK, 0);
  329.  
  330.     /* Can't use usleep; it doesn't exist in BSD 4.2.  */
  331.     /* Note that if this select() is interrupted by a signal it will not wait
  332.        the full length of time.  I think that is OK.  */
  333.     timeout.tv_sec = 0;
  334.     timeout.tv_usec = 250000;
  335.     select (0, 0, 0, 0, &timeout);
  336.     status = ioctl (scb->fd, TIOCCBRK, 0);
  337.     return status;
  338.   }
  339. #endif  
  340. }
  341.  
  342. static void
  343. hardwire_raw(scb)
  344.      serial_t scb;
  345. {
  346.   struct hardwire_ttystate state;
  347.  
  348.   if (get_tty_state(scb, &state))
  349.     fprintf_unfiltered(gdb_stderr, "get_tty_state failed: %s\n", safe_strerror(errno));
  350.  
  351. #ifdef HAVE_TERMIOS
  352.   state.termios.c_iflag = 0;
  353.   state.termios.c_oflag = 0;
  354.   state.termios.c_lflag = 0;
  355.   state.termios.c_cflag &= ~(CSIZE|PARENB);
  356.   state.termios.c_cflag |= CLOCAL | CS8;
  357.   state.termios.c_cc[VMIN] = 0;
  358.   state.termios.c_cc[VTIME] = 0;
  359. #endif
  360.  
  361. #ifdef HAVE_TERMIO
  362.   state.termio.c_iflag = 0;
  363.   state.termio.c_oflag = 0;
  364.   state.termio.c_lflag = 0;
  365.   state.termio.c_cflag &= ~(CSIZE|PARENB);
  366.   state.termio.c_cflag |= CLOCAL | CS8;
  367.   state.termio.c_cc[VMIN] = 0;
  368.   state.termio.c_cc[VTIME] = 0;
  369. #endif
  370.  
  371. #ifdef HAVE_SGTTY
  372.   state.sgttyb.sg_flags |= RAW | ANYP;
  373.   state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
  374. #endif
  375.  
  376.   scb->current_timeout = 0;
  377.  
  378.   if (set_tty_state (scb, &state))
  379.     fprintf_unfiltered(gdb_stderr, "set_tty_state failed: %s\n", safe_strerror(errno));
  380. }
  381.  
  382. /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
  383.    otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
  384.  
  385.    For termio{s}, we actually just setup VTIME if necessary, and let the
  386.    timeout occur in the read() in hardwire_read().
  387.  */
  388.  
  389. static int
  390. wait_for(scb, timeout)
  391.      serial_t scb;
  392.      int timeout;
  393. {
  394.   scb->timeout_remaining = 0;
  395.  
  396. #ifdef HAVE_SGTTY
  397.   {
  398.     struct timeval tv;
  399.     fd_set readfds;
  400.  
  401.     FD_ZERO (&readfds);
  402.  
  403.     tv.tv_sec = timeout;
  404.     tv.tv_usec = 0;
  405.  
  406.     FD_SET(scb->fd, &readfds);
  407.  
  408.     while (1)
  409.       {
  410.     int numfds;
  411.  
  412.     if (timeout >= 0)
  413.       numfds = select(scb->fd+1, &readfds, 0, 0, &tv);
  414.     else
  415.       numfds = select(scb->fd+1, &readfds, 0, 0, 0);
  416.  
  417.     if (numfds <= 0)
  418.       if (numfds == 0)
  419.         return SERIAL_TIMEOUT;
  420.       else if (errno == EINTR)
  421.         continue;
  422.       else
  423.         return SERIAL_ERROR;    /* Got an error from select or poll */
  424.  
  425.     return 0;
  426.       }
  427.   }
  428. #endif    /* HAVE_SGTTY */
  429.  
  430. #if defined HAVE_TERMIO || defined HAVE_TERMIOS
  431.   if (timeout == scb->current_timeout)
  432.     return 0;
  433.  
  434.   scb->current_timeout = timeout;
  435.  
  436.   {
  437.     struct hardwire_ttystate state;
  438.  
  439.     if (get_tty_state(scb, &state))
  440.       fprintf_unfiltered(gdb_stderr, "get_tty_state failed: %s\n", safe_strerror(errno));
  441.  
  442. #ifdef HAVE_TERMIOS
  443.     if (timeout < 0)
  444.       {
  445.     /* No timeout.  */
  446.     state.termios.c_cc[VTIME] = 0;
  447.     state.termios.c_cc[VMIN] = 1;
  448.       }
  449.     else
  450.       {
  451.     state.termios.c_cc[VMIN] = 0;
  452.     state.termios.c_cc[VTIME] = timeout * 10;
  453.     if (state.termios.c_cc[VTIME] != timeout * 10)
  454.       {
  455.  
  456.         /* If c_cc is an 8-bit signed character, we can't go 
  457.            bigger than this.  If it is always unsigned, we could use
  458.            25.  */
  459.  
  460.         scb->current_timeout = 12;
  461.         state.termios.c_cc[VTIME] = scb->current_timeout * 10;
  462.         scb->timeout_remaining = timeout - scb->current_timeout;
  463.       }
  464.       }
  465. #endif
  466.  
  467. #ifdef HAVE_TERMIO
  468.     if (timeout < 0)
  469.       {
  470.     /* No timeout.  */
  471.     state.termio.c_cc[VTIME] = 0;
  472.     state.termio.c_cc[VMIN] = 1;
  473.       }
  474.     else
  475.       {
  476.     state.termio.c_cc[VMIN] = 0;
  477.     state.termio.c_cc[VTIME] = timeout * 10;
  478.     if (state.termio.c_cc[VTIME] != timeout * 10)
  479.       {
  480.         /* If c_cc is an 8-bit signed character, we can't go 
  481.            bigger than this.  If it is always unsigned, we could use
  482.            25.  */
  483.  
  484.         scb->current_timeout = 12;
  485.         state.termio.c_cc[VTIME] = scb->current_timeout * 10;
  486.         scb->timeout_remaining = timeout - scb->current_timeout;
  487.       }
  488.       }
  489. #endif
  490.  
  491.     if (set_tty_state (scb, &state))
  492.       fprintf_unfiltered(gdb_stderr, "set_tty_state failed: %s\n", safe_strerror(errno));
  493.  
  494.     return 0;
  495.   }
  496. #endif    /* HAVE_TERMIO || HAVE_TERMIOS */
  497. }
  498.  
  499. /* Read a character with user-specified timeout.  TIMEOUT is number of seconds
  500.    to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
  501.    char if successful.  Returns SERIAL_TIMEOUT if timeout expired, EOF if line
  502.    dropped dead, or SERIAL_ERROR for any other error (see errno in that case).  */
  503.  
  504. static int
  505. hardwire_readchar(scb, timeout)
  506.      serial_t scb;
  507.      int timeout;
  508. {
  509.   int status;
  510.  
  511.   if (scb->bufcnt-- > 0)
  512.     return *scb->bufp++;
  513.  
  514.   while (1)
  515.     {
  516.       status = wait_for (scb, timeout);
  517.  
  518.       if (status < 0)
  519.     return status;
  520.  
  521.       scb->bufcnt = read (scb->fd, scb->buf, BUFSIZ);
  522.  
  523.       if (scb->bufcnt <= 0)
  524.     {
  525.       if (scb->bufcnt == 0)
  526.         {
  527.           /* Zero characters means timeout (it could also be EOF, but
  528.          we don't (yet at least) distinguish).  */
  529.           if (scb->timeout_remaining > 0)
  530.         {
  531.           timeout = scb->timeout_remaining;
  532.           continue;
  533.         }
  534.           else
  535.         return SERIAL_TIMEOUT;
  536.         }
  537.       else if (errno == EINTR)
  538.         continue;
  539.       else
  540.         return SERIAL_ERROR;    /* Got an error from read */
  541.     }
  542.  
  543.       scb->bufcnt--;
  544.       scb->bufp = scb->buf;
  545.       return *scb->bufp++;
  546.     }
  547. }
  548.  
  549. #ifndef B19200
  550. #define B19200 EXTA
  551. #endif
  552.  
  553. #ifndef B38400
  554. #define B38400 EXTB
  555. #endif
  556.  
  557. /* Translate baud rates from integers to damn B_codes.  Unix should
  558.    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
  559.  
  560. static struct
  561. {
  562.   int rate;
  563.   int code;
  564. }
  565. baudtab[] =
  566. {
  567.   {50, B50},
  568.   {75, B75},
  569.   {110, B110},
  570.   {134, B134},
  571.   {150, B150},
  572.   {200, B200},
  573.   {300, B300},
  574.   {600, B600},
  575.   {1200, B1200},
  576.   {1800, B1800},
  577.   {2400, B2400},
  578.   {4800, B4800},
  579.   {9600, B9600},
  580.   {19200, B19200},
  581.   {38400, B38400},
  582.   {-1, -1},
  583. };
  584.  
  585. static int 
  586. rate_to_code(rate)
  587.      int rate;
  588. {
  589.   int i;
  590.  
  591.   for (i = 0; baudtab[i].rate != -1; i++)
  592.     if (rate == baudtab[i].rate)  
  593.       return baudtab[i].code;
  594.  
  595.   return -1;
  596. }
  597.  
  598. static int
  599. hardwire_setbaudrate(scb, rate)
  600.      serial_t scb;
  601.      int rate;
  602. {
  603.   struct hardwire_ttystate state;
  604.  
  605.   if (get_tty_state(scb, &state))
  606.     return -1;
  607.  
  608. #ifdef HAVE_TERMIOS
  609.   cfsetospeed (&state.termios, rate_to_code (rate));
  610.   cfsetispeed (&state.termios, rate_to_code (rate));
  611. #endif
  612.  
  613. #ifdef HAVE_TERMIO
  614. #ifndef CIBAUD
  615. #define CIBAUD CBAUD
  616. #endif
  617.  
  618.   state.termio.c_cflag &= ~(CBAUD | CIBAUD);
  619.   state.termio.c_cflag |= rate_to_code (rate);
  620. #endif
  621.  
  622. #ifdef HAVE_SGTTY
  623.   state.sgttyb.sg_ispeed = rate_to_code (rate);
  624.   state.sgttyb.sg_ospeed = rate_to_code (rate);
  625. #endif
  626.  
  627.   return set_tty_state (scb, &state);
  628. }
  629.  
  630. static int
  631. hardwire_write(scb, str, len)
  632.      serial_t scb;
  633.      const char *str;
  634.      int len;
  635. {
  636.   int cc;
  637.  
  638.   while (len > 0)
  639.     {
  640.       cc = write(scb->fd, str, len);
  641.  
  642.       if (cc < 0)
  643.     return 1;
  644.       len -= cc;
  645.       str += cc;
  646.     }
  647.   return 0;
  648. }
  649.  
  650. static void
  651. hardwire_close(scb)
  652.      serial_t scb;
  653. {
  654.   if (scb->fd < 0)
  655.     return;
  656.  
  657.   close(scb->fd);
  658.   scb->fd = -1;
  659. }
  660.  
  661. static struct serial_ops hardwire_ops =
  662. {
  663.   "hardwire",
  664.   0,
  665.   hardwire_open,
  666.   hardwire_close,
  667.   hardwire_readchar,
  668.   hardwire_write,
  669.   hardwire_flush_output,
  670.   hardwire_flush_input,
  671.   hardwire_send_break,
  672.   hardwire_raw,
  673.   hardwire_get_tty_state,
  674.   hardwire_set_tty_state,
  675.   hardwire_print_tty_state,
  676.   hardwire_noflush_set_tty_state,
  677.   hardwire_setbaudrate,
  678. };
  679.  
  680. void
  681. _initialize_ser_hardwire ()
  682. {
  683.   serial_add_interface (&hardwire_ops);
  684. }
  685.