gdb/ser-unix.c

   1 /* Serial interface for local (hardwired) serial ports on Un*x like systems
   2    Copyright 1992, 1993 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 #include <sys/time.h>
  25
  26 #if !defined (HAVE_TERMIOS) && !defined (HAVE_TERMIO) && !defined (HAVE_SGTTY)
  27 #define HAVE_SGTTY
  28 #endif
  29
  30 #ifdef HAVE_TERMIOS
  31 #include <termios.h>
  32 #include <unistd.h>
  33 #endif
  34 #ifdef HAVE_TERMIO
  35 #include <termio.h>
  36 #endif
  37 #ifdef HAVE_SGTTY
  38 #include <sgtty.h>
  39 #endif
  40
  41 static int hardwire_open PARAMS ((serial_t scb, const char *name));
  42 static void hardwire_raw PARAMS ((serial_t scb));
  43 static int wait_for PARAMS ((serial_t scb, int timeout));
  44 static int hardwire_readchar PARAMS ((serial_t scb, int timeout));
  45 static int rate_to_code PARAMS ((int rate));
  46 static int hardwire_setbaudrate PARAMS ((serial_t scb, int rate));
  47 static int hardwire_write PARAMS ((serial_t scb, const char *str, int len));
  48 static void hardwire_restore PARAMS ((serial_t scb));
  49 static void hardwire_close PARAMS ((serial_t scb));
  50
  51 /* Open up a real live device for serial I/O */
  52
  53 static int
  54 hardwire_open(scb, name)
  55      serial_t scb;
  56      const char *name;
  57 {
  58   scb->fd = open (name, O_RDWR);
  59   if (scb->fd < 0)
  60     return -1;
  61
  62   return 0;
  63 }
  64
  65 static void
  66 hardwire_raw(scb)
  67      serial_t scb;
  68 {
  69 #ifdef HAVE_TERMIOS
  70   struct termios termios;
  71
  72   if (tcgetattr(scb->fd, &termios))
  73     {
  74       fprintf(stderr, "tcgetattr failed: %s\n", safe_strerror(errno));
  75     }
  76
  77   termios.c_iflag = 0;
  78   termios.c_oflag = 0;
  79   termios.c_lflag = 0;
  80   termios.c_cflag &= ~(CSIZE|PARENB);
  81   termios.c_cflag |= CS8;
  82   termios.c_cc[VMIN] = 0;
  83   termios.c_cc[VTIME] = 0;
  84
  85   if (tcsetattr(scb->fd, TCSANOW, &termios))
  86     {
  87       fprintf(stderr, "tcsetattr failed: %s\n", safe_strerror(errno));
  88     }
  89 #endif
  90
  91 #ifdef HAVE_TERMIO
  92   struct termio termio;
  93
  94   if (ioctl (scb->fd, TCGETA, &termio))
  95     {
  96       fprintf(stderr, "TCGETA failed: %s\n", safe_strerror(errno));
  97     }
  98
  99   termio.c_iflag = 0;
 100   termio.c_oflag = 0;
 101   termio.c_lflag = 0;
 102   termio.c_cflag &= ~(CSIZE|PARENB);
 103   termio.c_cflag |= CS8;
 104   termio.c_cc[VMIN] = 0;
 105   termio.c_cc[VTIME] = 0;
 106
 107   if (ioctl (scb->fd, TCSETA, &termio))
 108     {
 109       fprintf(stderr, "TCSETA failed: %s\n", safe_strerror(errno));
 110     }
 111 #endif
 112
 113 #ifdef HAVE_SGTTY
 114   struct sgttyb sgttyb;
 115
 116   if (ioctl (scb->fd, TIOCGETP, &sgttyb))
 117     fprintf(stderr, "TIOCGETP failed: %s\n", safe_strerror(errno));
 118
 119   sgttyb.sg_flags |= RAW | ANYP;
 120   sgttyb.sg_flags &= ~(CBREAK | ECHO);
 121
 122   if (ioctl (scb->fd, TIOCSETP, &sgttyb))
 123     fprintf(stderr, "TIOCSETP failed: %s\n", safe_strerror(errno));
 124 #endif
 125
 126   scb->current_timeout = 0;
 127 }
 128
 129 /* Wait for input on scb, with timeout seconds.  Returns 0 on success,
 130    otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
 131
 132    For termio{s}, we actually just setup VTIME if necessary, and let the
 133    timeout occur in the read() in hardwire_read().
 134  */
 135
 136 static int
 137 wait_for(scb, timeout)
 138      serial_t scb;
 139      int timeout;
 140 {
 141   int numfds;
 142
 143 #ifdef HAVE_SGTTY
 144   struct timeval tv;
 145   fd_set readfds;
 146
 147   FD_ZERO (&readfds);
 148
 149   tv.tv_sec = timeout;
 150   tv.tv_usec = 0;
 151
 152   FD_SET(scb->fd, &readfds);
 153
 154   if (timeout >= 0)
 155     numfds = select(scb->fd+1, &readfds, 0, 0, &tv);
 156   else
 157     numfds = select(scb->fd+1, &readfds, 0, 0, 0);
 158
 159   if (numfds <= 0)
 160     if (numfds == 0)
 161       return SERIAL_TIMEOUT;
 162     else
 163       return SERIAL_ERROR;      /* Got an error from select or poll */
 164
 165   return 0;
 166
 167 #endif  /* HAVE_SGTTY */
 168
 169 #if defined HAVE_TERMIO || defined HAVE_TERMIOS
 170   if (timeout == scb->current_timeout)
 171     return 0;
 172
 173   {
 174 #ifdef HAVE_TERMIOS
 175     struct termios termios;
 176
 177     if (tcgetattr(scb->fd, &termios))
 178       fprintf(stderr, "wait_for() tcgetattr failed: %s\n", safe_strerror(errno));
 179
 180   termios.c_cc[VTIME] = timeout * 10;
 181
 182   if (tcsetattr(scb->fd, TCSANOW, &termios))
 183     fprintf(stderr, "wait_for() tcsetattr failed: %s\n", safe_strerror(errno));
 184 #endif  /* HAVE_TERMIOS */
 185
 186 #ifdef HAVE_TERMIO
 187   struct termio termio;
 188
 189   if (ioctl (scb->fd, TCGETA, &termio))
 190     fprintf(stderr, "wait_for() TCGETA failed: %s\n", safe_strerror(errno));
 191
 192   termio.c_cc[VTIME] = timeout * 10;
 193
 194   if (ioctl (scb->fd, TCSETA, &termio))
 195       fprintf(stderr, "TCSETA failed: %s\n", safe_strerror(errno));
 196 #endif  /* HAVE_TERMIO */
 197
 198     scb->current_timeout = timeout;
 199     return 0;
 200   }
 201 #endif  /* HAVE_TERMIO || HAVE_TERMIOS */
 202 }
 203
 204 /* Read a character with user-specified timeout.  TIMEOUT is number of seconds
 205    to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
 206    char if successful.  Returns -2 if timeout expired, EOF if line dropped
 207    dead, or -3 for any other error (see errno in that case). */
 208
 209 static int
 210 hardwire_readchar(scb, timeout)
 211      serial_t scb;
 212      int timeout;
 213 {
 214   int status;
 215
 216   if (scb->bufcnt-- > 0)
 217     return *scb->bufp++;
 218
 219   status = wait_for(scb, timeout);
 220
 221   if (status < 0)
 222     return status;
 223
 224   scb->bufcnt = read(scb->fd, scb->buf, BUFSIZ);
 225
 226   if (scb->bufcnt <= 0)
 227     if (scb->bufcnt == 0)
 228       return SERIAL_TIMEOUT;    /* 0 chars means timeout [may need to
 229                                    distinguish between EOF & timeouts
 230                                    someday] */
 231     else
 232       return SERIAL_ERROR;      /* Got an error from read */
 233
 234   scb->bufcnt--;
 235   scb->bufp = scb->buf;
 236   return *scb->bufp++;
 237 }
 238
 239 #ifndef B19200
 240 #define B19200 EXTA
 241 #endif
 242
 243 #ifndef B38400
 244 #define B38400 EXTB
 245 #endif
 246
 247 /* Translate baud rates from integers to damn B_codes.  Unix should
 248    have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
 249
 250 static struct
 251 {
 252   int rate;
 253   int code;
 254 }
 255 baudtab[] =
 256 {
 257   {50, B50},
 258   {75, B75},
 259   {110, B110},
 260   {134, B134},
 261   {150, B150},
 262   {200, B200},
 263   {300, B300},
 264   {600, B600},
 265   {1200, B1200},
 266   {1800, B1800},
 267   {2400, B2400},
 268   {4800, B4800},
 269   {9600, B9600},
 270   {19200, B19200},
 271   {38400, B38400},
 272   {-1, -1},
 273 };
 274
 275 static int
 276 rate_to_code(rate)
 277      int rate;
 278 {
 279   int i;
 280
 281   for (i = 0; baudtab[i].rate != -1; i++)
 282     if (rate == baudtab[i].rate)
 283       return baudtab[i].code;
 284
 285   return -1;
 286 }
 287
 288 static int
 289 hardwire_setbaudrate(scb, rate)
 290      serial_t scb;
 291      int rate;
 292 {
 293 #ifdef HAVE_TERMIOS
 294   struct termios termios;
 295
 296   if (tcgetattr (scb->fd, &termios))
 297     return -1;
 298
 299   cfsetospeed (&termios, rate_to_code (rate));
 300   cfsetispeed (&termios, rate_to_code (rate));
 301
 302   if (tcsetattr (scb->fd, TCSANOW, &termios))
 303     return -1;
 304 #endif
 305
 306 #ifdef HAVE_TERMIO
 307   struct termio termio;
 308
 309   if (ioctl (scb->fd, TCGETA, &termio))
 310     return -1;
 311
 312 #ifndef CIBAUD
 313 #define CIBAUD CBAUD
 314 #endif
 315
 316   termio.c_cflag &= ~(CBAUD | CIBAUD);
 317   termio.c_cflag |= rate_to_code (rate);
 318
 319   if (ioctl (scb->fd, TCSETA, &termio))
 320     return -1;
 321 #endif
 322
 323 #ifdef HAVE_SGTTY
 324   struct sgttyb sgttyb;
 325
 326   if (ioctl (scb->fd, TIOCGETP, &sgttyb))
 327     return -1;
 328
 329   sgttyb.sg_ispeed = rate_to_code (rate);
 330   sgttyb.sg_ospeed = rate_to_code (rate);
 331
 332   if (ioctl (scb->fd, TIOCSETP, &sgttyb))
 333     return -1;
 334 #endif
 335   return 0;
 336 }
 337
 338 static int
 339 hardwire_write(scb, str, len)
 340      serial_t scb;
 341      const char *str;
 342      int len;
 343 {
 344   int cc;
 345
 346   while (len > 0)
 347     {
 348       cc = write(scb->fd, str, len);
 349
 350       if (cc < 0)
 351         return 1;
 352       len -= cc;
 353       str += cc;
 354     }
 355   return 0;
 356 }
 357
 358 static void
 359 hardwire_restore(scb)
 360      serial_t scb;
 361 {
 362 }
 363
 364 static void
 365 hardwire_close(scb)
 366      serial_t scb;
 367 {
 368   if (scb->fd < 0)
 369     return;
 370
 371   close(scb->fd);
 372   scb->fd = -1;
 373 }
 374
 375 static struct serial_ops hardwire_ops =
 376 {
 377   "hardwire",
 378   0,
 379   hardwire_open,
 380   hardwire_close,
 381   hardwire_readchar,
 382   hardwire_write,
 383   hardwire_raw,
 384   hardwire_restore,
 385   hardwire_setbaudrate
 386 };
 387
 388 void
 389 _initialize_ser_hardwire ()
 390 {
 391   serial_add_interface (&hardwire_ops);
 392 }