OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [ser-unix.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Serial interface for local (hardwired) serial ports on Un*x like systems
2
 
3
   Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2003,
4
   2004, 2005, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5
 
6
   This file is part of GDB.
7
 
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 3 of the License, or
11
   (at your option) any later version.
12
 
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.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include "defs.h"
22
#include "serial.h"
23
#include "ser-base.h"
24
#include "ser-unix.h"
25
 
26
#include <fcntl.h>
27
#include <sys/types.h>
28
#include "terminal.h"
29
#include <sys/socket.h>
30
#include <sys/time.h>
31
 
32
#include "gdb_select.h"
33
#include "gdb_string.h"
34
#include "gdbcmd.h"
35
 
36
#ifdef HAVE_TERMIOS
37
 
38
struct hardwire_ttystate
39
  {
40
    struct termios termios;
41
  };
42
 
43
#ifdef CRTSCTS
44
/* Boolean to explicitly enable or disable h/w flow control.  */
45
static int serial_hwflow;
46
static void
47
show_serial_hwflow (struct ui_file *file, int from_tty,
48
                    struct cmd_list_element *c, const char *value)
49
{
50
  fprintf_filtered (file, _("Hardware flow control is %s.\n"), value);
51
}
52
#endif
53
 
54
#endif /* termios */
55
 
56
#ifdef HAVE_TERMIO
57
 
58
/* It is believed that all systems which have added job control to SVR3
59
   (e.g. sco) have also added termios.  Even if not, trying to figure out
60
   all the variations (TIOCGPGRP vs. TCGETPGRP, etc.) would be pretty
61
   bewildering.  So we don't attempt it.  */
62
 
63
struct hardwire_ttystate
64
  {
65
    struct termio termio;
66
  };
67
#endif /* termio */
68
 
69
#ifdef HAVE_SGTTY
70
struct hardwire_ttystate
71
  {
72
    struct sgttyb sgttyb;
73
    struct tchars tc;
74
    struct ltchars ltc;
75
    /* Line discipline flags.  */
76
    int lmode;
77
  };
78
#endif /* sgtty */
79
 
80
static int hardwire_open (struct serial *scb, const char *name);
81
static void hardwire_raw (struct serial *scb);
82
static int wait_for (struct serial *scb, int timeout);
83
static int hardwire_readchar (struct serial *scb, int timeout);
84
static int do_hardwire_readchar (struct serial *scb, int timeout);
85
static int rate_to_code (int rate);
86
static int hardwire_setbaudrate (struct serial *scb, int rate);
87
static void hardwire_close (struct serial *scb);
88
static int get_tty_state (struct serial *scb,
89
                          struct hardwire_ttystate * state);
90
static int set_tty_state (struct serial *scb,
91
                          struct hardwire_ttystate * state);
92
static serial_ttystate hardwire_get_tty_state (struct serial *scb);
93
static int hardwire_set_tty_state (struct serial *scb, serial_ttystate state);
94
static int hardwire_noflush_set_tty_state (struct serial *, serial_ttystate,
95
                                           serial_ttystate);
96
static void hardwire_print_tty_state (struct serial *, serial_ttystate,
97
                                      struct ui_file *);
98
static int hardwire_drain_output (struct serial *);
99
static int hardwire_flush_output (struct serial *);
100
static int hardwire_flush_input (struct serial *);
101
static int hardwire_send_break (struct serial *);
102
static int hardwire_setstopbits (struct serial *, int);
103
 
104
void _initialize_ser_hardwire (void);
105
 
106
/* Open up a real live device for serial I/O */
107
 
108
static int
109
hardwire_open (struct serial *scb, const char *name)
110
{
111
  scb->fd = open (name, O_RDWR);
112
  if (scb->fd < 0)
113
    return -1;
114
 
115
  return 0;
116
}
117
 
118
static int
119
get_tty_state (struct serial *scb, struct hardwire_ttystate *state)
120
{
121
#ifdef HAVE_TERMIOS
122
  if (tcgetattr (scb->fd, &state->termios) < 0)
123
    return -1;
124
 
125
  return 0;
126
#endif
127
 
128
#ifdef HAVE_TERMIO
129
  if (ioctl (scb->fd, TCGETA, &state->termio) < 0)
130
    return -1;
131
  return 0;
132
#endif
133
 
134
#ifdef HAVE_SGTTY
135
  if (ioctl (scb->fd, TIOCGETP, &state->sgttyb) < 0)
136
    return -1;
137
  if (ioctl (scb->fd, TIOCGETC, &state->tc) < 0)
138
    return -1;
139
  if (ioctl (scb->fd, TIOCGLTC, &state->ltc) < 0)
140
    return -1;
141
  if (ioctl (scb->fd, TIOCLGET, &state->lmode) < 0)
142
    return -1;
143
 
144
  return 0;
145
#endif
146
}
147
 
148
static int
149
set_tty_state (struct serial *scb, struct hardwire_ttystate *state)
150
{
151
#ifdef HAVE_TERMIOS
152
  if (tcsetattr (scb->fd, TCSANOW, &state->termios) < 0)
153
    return -1;
154
 
155
  return 0;
156
#endif
157
 
158
#ifdef HAVE_TERMIO
159
  if (ioctl (scb->fd, TCSETA, &state->termio) < 0)
160
    return -1;
161
  return 0;
162
#endif
163
 
164
#ifdef HAVE_SGTTY
165
  if (ioctl (scb->fd, TIOCSETN, &state->sgttyb) < 0)
166
    return -1;
167
  if (ioctl (scb->fd, TIOCSETC, &state->tc) < 0)
168
    return -1;
169
  if (ioctl (scb->fd, TIOCSLTC, &state->ltc) < 0)
170
    return -1;
171
  if (ioctl (scb->fd, TIOCLSET, &state->lmode) < 0)
172
    return -1;
173
 
174
  return 0;
175
#endif
176
}
177
 
178
static serial_ttystate
179
hardwire_get_tty_state (struct serial *scb)
180
{
181
  struct hardwire_ttystate *state;
182
 
183
  state = (struct hardwire_ttystate *) xmalloc (sizeof *state);
184
 
185
  if (get_tty_state (scb, state))
186
    return NULL;
187
 
188
  return (serial_ttystate) state;
189
}
190
 
191
static int
192
hardwire_set_tty_state (struct serial *scb, serial_ttystate ttystate)
193
{
194
  struct hardwire_ttystate *state;
195
 
196
  state = (struct hardwire_ttystate *) ttystate;
197
 
198
  return set_tty_state (scb, state);
199
}
200
 
201
static int
202
hardwire_noflush_set_tty_state (struct serial *scb,
203
                                serial_ttystate new_ttystate,
204
                                serial_ttystate old_ttystate)
205
{
206
  struct hardwire_ttystate new_state;
207
#ifdef HAVE_SGTTY
208
  struct hardwire_ttystate *state = (struct hardwire_ttystate *) old_ttystate;
209
#endif
210
 
211
  new_state = *(struct hardwire_ttystate *) new_ttystate;
212
 
213
  /* Don't change in or out of raw mode; we don't want to flush input.
214
     termio and termios have no such restriction; for them flushing input
215
     is separate from setting the attributes.  */
216
 
217
#ifdef HAVE_SGTTY
218
  if (state->sgttyb.sg_flags & RAW)
219
    new_state.sgttyb.sg_flags |= RAW;
220
  else
221
    new_state.sgttyb.sg_flags &= ~RAW;
222
 
223
  /* I'm not sure whether this is necessary; the manpage just mentions
224
     RAW not CBREAK.  */
225
  if (state->sgttyb.sg_flags & CBREAK)
226
    new_state.sgttyb.sg_flags |= CBREAK;
227
  else
228
    new_state.sgttyb.sg_flags &= ~CBREAK;
229
#endif
230
 
231
  return set_tty_state (scb, &new_state);
232
}
233
 
234
static void
235
hardwire_print_tty_state (struct serial *scb,
236
                          serial_ttystate ttystate,
237
                          struct ui_file *stream)
238
{
239
  struct hardwire_ttystate *state = (struct hardwire_ttystate *) ttystate;
240
  int i;
241
 
242
#ifdef HAVE_TERMIOS
243
  fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
244
                    (int) state->termios.c_iflag,
245
                    (int) state->termios.c_oflag);
246
  fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x\n",
247
                    (int) state->termios.c_cflag,
248
                    (int) state->termios.c_lflag);
249
#if 0
250
  /* This not in POSIX, and is not really documented by those systems
251
     which have it (at least not Sun).  */
252
  fprintf_filtered (stream, "c_line = 0x%x.\n", state->termios.c_line);
253
#endif
254
  fprintf_filtered (stream, "c_cc: ");
255
  for (i = 0; i < NCCS; i += 1)
256
    fprintf_filtered (stream, "0x%x ", state->termios.c_cc[i]);
257
  fprintf_filtered (stream, "\n");
258
#endif
259
 
260
#ifdef HAVE_TERMIO
261
  fprintf_filtered (stream, "c_iflag = 0x%x, c_oflag = 0x%x,\n",
262
                    state->termio.c_iflag, state->termio.c_oflag);
263
  fprintf_filtered (stream, "c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
264
                    state->termio.c_cflag, state->termio.c_lflag,
265
                    state->termio.c_line);
266
  fprintf_filtered (stream, "c_cc: ");
267
  for (i = 0; i < NCC; i += 1)
268
    fprintf_filtered (stream, "0x%x ", state->termio.c_cc[i]);
269
  fprintf_filtered (stream, "\n");
270
#endif
271
 
272
#ifdef HAVE_SGTTY
273
  fprintf_filtered (stream, "sgttyb.sg_flags = 0x%x.\n",
274
                    state->sgttyb.sg_flags);
275
 
276
  fprintf_filtered (stream, "tchars: ");
277
  for (i = 0; i < (int) sizeof (struct tchars); i++)
278
    fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->tc)[i]);
279
  fprintf_filtered (stream, "\n");
280
 
281
  fprintf_filtered (stream, "ltchars: ");
282
  for (i = 0; i < (int) sizeof (struct ltchars); i++)
283
    fprintf_filtered (stream, "0x%x ", ((unsigned char *) &state->ltc)[i]);
284
  fprintf_filtered (stream, "\n");
285
 
286
  fprintf_filtered (stream, "lmode:  0x%x\n", state->lmode);
287
#endif
288
}
289
 
290
/* Wait for the output to drain away, as opposed to flushing (discarding) it */
291
 
292
static int
293
hardwire_drain_output (struct serial *scb)
294
{
295
#ifdef HAVE_TERMIOS
296
  return tcdrain (scb->fd);
297
#endif
298
 
299
#ifdef HAVE_TERMIO
300
  return ioctl (scb->fd, TCSBRK, 1);
301
#endif
302
 
303
#ifdef HAVE_SGTTY
304
  /* Get the current state and then restore it using TIOCSETP,
305
     which should cause the output to drain and pending input
306
     to be discarded. */
307
  {
308
    struct hardwire_ttystate state;
309
    if (get_tty_state (scb, &state))
310
      {
311
        return (-1);
312
      }
313
    else
314
      {
315
        return (ioctl (scb->fd, TIOCSETP, &state.sgttyb));
316
      }
317
  }
318
#endif
319
}
320
 
321
static int
322
hardwire_flush_output (struct serial *scb)
323
{
324
#ifdef HAVE_TERMIOS
325
  return tcflush (scb->fd, TCOFLUSH);
326
#endif
327
 
328
#ifdef HAVE_TERMIO
329
  return ioctl (scb->fd, TCFLSH, 1);
330
#endif
331
 
332
#ifdef HAVE_SGTTY
333
  /* This flushes both input and output, but we can't do better.  */
334
  return ioctl (scb->fd, TIOCFLUSH, 0);
335
#endif
336
}
337
 
338
static int
339
hardwire_flush_input (struct serial *scb)
340
{
341
  ser_base_flush_input (scb);
342
 
343
#ifdef HAVE_TERMIOS
344
  return tcflush (scb->fd, TCIFLUSH);
345
#endif
346
 
347
#ifdef HAVE_TERMIO
348
  return ioctl (scb->fd, TCFLSH, 0);
349
#endif
350
 
351
#ifdef HAVE_SGTTY
352
  /* This flushes both input and output, but we can't do better.  */
353
  return ioctl (scb->fd, TIOCFLUSH, 0);
354
#endif
355
}
356
 
357
static int
358
hardwire_send_break (struct serial *scb)
359
{
360
#ifdef HAVE_TERMIOS
361
  return tcsendbreak (scb->fd, 0);
362
#endif
363
 
364
#ifdef HAVE_TERMIO
365
  return ioctl (scb->fd, TCSBRK, 0);
366
#endif
367
 
368
#ifdef HAVE_SGTTY
369
  {
370
    int status;
371
 
372
    status = ioctl (scb->fd, TIOCSBRK, 0);
373
 
374
    /* Can't use usleep; it doesn't exist in BSD 4.2.  */
375
    /* Note that if this gdb_select() is interrupted by a signal it will not
376
       wait the full length of time.  I think that is OK.  */
377
    gdb_usleep (250000);
378
    status = ioctl (scb->fd, TIOCCBRK, 0);
379
    return status;
380
  }
381
#endif
382
}
383
 
384
static void
385
hardwire_raw (struct serial *scb)
386
{
387
  struct hardwire_ttystate state;
388
 
389
  if (get_tty_state (scb, &state))
390
    fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
391
 
392
#ifdef HAVE_TERMIOS
393
  state.termios.c_iflag = 0;
394
  state.termios.c_oflag = 0;
395
  state.termios.c_lflag = 0;
396
  state.termios.c_cflag &= ~(CSIZE | PARENB);
397
  state.termios.c_cflag |= CLOCAL | CS8;
398
#ifdef CRTSCTS
399
  /* h/w flow control.  */
400
  if (serial_hwflow)
401
    state.termios.c_cflag |= CRTSCTS;
402
  else
403
    state.termios.c_cflag &= ~CRTSCTS;
404
#ifdef CRTS_IFLOW
405
  if (serial_hwflow)
406
    state.termios.c_cflag |= CRTS_IFLOW;
407
  else
408
    state.termios.c_cflag &= ~CRTS_IFLOW;
409
#endif
410
#endif
411
  state.termios.c_cc[VMIN] = 0;
412
  state.termios.c_cc[VTIME] = 0;
413
#endif
414
 
415
#ifdef HAVE_TERMIO
416
  state.termio.c_iflag = 0;
417
  state.termio.c_oflag = 0;
418
  state.termio.c_lflag = 0;
419
  state.termio.c_cflag &= ~(CSIZE | PARENB);
420
  state.termio.c_cflag |= CLOCAL | CS8;
421
  state.termio.c_cc[VMIN] = 0;
422
  state.termio.c_cc[VTIME] = 0;
423
#endif
424
 
425
#ifdef HAVE_SGTTY
426
  state.sgttyb.sg_flags |= RAW | ANYP;
427
  state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
428
#endif
429
 
430
  scb->current_timeout = 0;
431
 
432
  if (set_tty_state (scb, &state))
433
    fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
434
}
435
 
436
/* Wait for input on scb, with timeout seconds.  Returns 0 on success,
437
   otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
438
 
439
   For termio{s}, we actually just setup VTIME if necessary, and let the
440
   timeout occur in the read() in hardwire_read().
441
 */
442
 
443
/* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
444
   ser_base*() until the old TERMIOS/SGTTY/... timer code has been
445
   flushed. . */
446
 
447
/* NOTE: cagney/1999-09-30: Much of the code below is dead.  The only
448
   possible values of the TIMEOUT parameter are ONE and ZERO.
449
   Consequently all the code that tries to handle the possability of
450
   an overflowed timer is unnecessary. */
451
 
452
static int
453
wait_for (struct serial *scb, int timeout)
454
{
455
#ifdef HAVE_SGTTY
456
  while (1)
457
    {
458
      struct timeval tv;
459
      fd_set readfds;
460
      int numfds;
461
 
462
      /* NOTE: Some OS's can scramble the READFDS when the select()
463
         call fails (ex the kernel with Red Hat 5.2).  Initialize all
464
         arguments before each call. */
465
 
466
      tv.tv_sec = timeout;
467
      tv.tv_usec = 0;
468
 
469
      FD_ZERO (&readfds);
470
      FD_SET (scb->fd, &readfds);
471
 
472
      if (timeout >= 0)
473
        numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, &tv);
474
      else
475
        numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, 0);
476
 
477
      if (numfds <= 0)
478
        if (numfds == 0)
479
          return SERIAL_TIMEOUT;
480
        else if (errno == EINTR)
481
          continue;
482
        else
483
          return SERIAL_ERROR;  /* Got an error from select or poll */
484
 
485
      return 0;
486
    }
487
#endif /* HAVE_SGTTY */
488
 
489
#if defined HAVE_TERMIO || defined HAVE_TERMIOS
490
  if (timeout == scb->current_timeout)
491
    return 0;
492
 
493
  scb->current_timeout = timeout;
494
 
495
  {
496
    struct hardwire_ttystate state;
497
 
498
    if (get_tty_state (scb, &state))
499
      fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
500
 
501
#ifdef HAVE_TERMIOS
502
    if (timeout < 0)
503
      {
504
        /* No timeout.  */
505
        state.termios.c_cc[VTIME] = 0;
506
        state.termios.c_cc[VMIN] = 1;
507
      }
508
    else
509
      {
510
        state.termios.c_cc[VMIN] = 0;
511
        state.termios.c_cc[VTIME] = timeout * 10;
512
        if (state.termios.c_cc[VTIME] != timeout * 10)
513
          {
514
 
515
            /* If c_cc is an 8-bit signed character, we can't go
516
               bigger than this.  If it is always unsigned, we could use
517
               25.  */
518
 
519
            scb->current_timeout = 12;
520
            state.termios.c_cc[VTIME] = scb->current_timeout * 10;
521
            scb->timeout_remaining = timeout - scb->current_timeout;
522
          }
523
      }
524
#endif
525
 
526
#ifdef HAVE_TERMIO
527
    if (timeout < 0)
528
      {
529
        /* No timeout.  */
530
        state.termio.c_cc[VTIME] = 0;
531
        state.termio.c_cc[VMIN] = 1;
532
      }
533
    else
534
      {
535
        state.termio.c_cc[VMIN] = 0;
536
        state.termio.c_cc[VTIME] = timeout * 10;
537
        if (state.termio.c_cc[VTIME] != timeout * 10)
538
          {
539
            /* If c_cc is an 8-bit signed character, we can't go
540
               bigger than this.  If it is always unsigned, we could use
541
               25.  */
542
 
543
            scb->current_timeout = 12;
544
            state.termio.c_cc[VTIME] = scb->current_timeout * 10;
545
            scb->timeout_remaining = timeout - scb->current_timeout;
546
          }
547
      }
548
#endif
549
 
550
    if (set_tty_state (scb, &state))
551
      fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
552
 
553
    return 0;
554
  }
555
#endif /* HAVE_TERMIO || HAVE_TERMIOS */
556
}
557
 
558
/* Read a character with user-specified timeout.  TIMEOUT is number of seconds
559
   to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
560
   char if successful.  Returns SERIAL_TIMEOUT if timeout expired, EOF if line
561
   dropped dead, or SERIAL_ERROR for any other error (see errno in that case).  */
562
 
563
/* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
564
   ser_base*() until the old TERMIOS/SGTTY/... timer code has been
565
   flushed. */
566
 
567
/* NOTE: cagney/1999-09-16: This function is not identical to
568
   ser_base_readchar() as part of replacing it with ser_base*()
569
   merging will be required - this code handles the case where read()
570
   times out due to no data while ser_base_readchar() doesn't expect
571
   that. */
572
 
573
static int
574
do_hardwire_readchar (struct serial *scb, int timeout)
575
{
576
  int status, delta;
577
  int detach = 0;
578
 
579
  if (timeout > 0)
580
    timeout++;
581
 
582
  /* We have to be able to keep the GUI alive here, so we break the
583
     original timeout into steps of 1 second, running the "keep the
584
     GUI alive" hook each time through the loop.
585
 
586
     Also, timeout = 0 means to poll, so we just set the delta to 0,
587
     so we will only go through the loop once.  */
588
 
589
  delta = (timeout == 0 ? 0 : 1);
590
  while (1)
591
    {
592
 
593
      /* N.B. The UI may destroy our world (for instance by calling
594
         remote_stop,) in which case we want to get out of here as
595
         quickly as possible.  It is not safe to touch scb, since
596
         someone else might have freed it.  The
597
         deprecated_ui_loop_hook signals that we should exit by
598
         returning 1.  */
599
 
600
      if (deprecated_ui_loop_hook)
601
        detach = deprecated_ui_loop_hook (0);
602
 
603
      if (detach)
604
        return SERIAL_TIMEOUT;
605
 
606
      scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
607
      status = wait_for (scb, delta);
608
 
609
      if (status < 0)
610
        return status;
611
 
612
      status = read (scb->fd, scb->buf, BUFSIZ);
613
 
614
      if (status <= 0)
615
        {
616
          if (status == 0)
617
            {
618
              /* Zero characters means timeout (it could also be EOF, but
619
                 we don't (yet at least) distinguish).  */
620
              if (scb->timeout_remaining > 0)
621
                {
622
                  timeout = scb->timeout_remaining;
623
                  continue;
624
                }
625
              else if (scb->timeout_remaining < 0)
626
                continue;
627
              else
628
                return SERIAL_TIMEOUT;
629
            }
630
          else if (errno == EINTR)
631
            continue;
632
          else
633
            return SERIAL_ERROR;        /* Got an error from read */
634
        }
635
 
636
      scb->bufcnt = status;
637
      scb->bufcnt--;
638
      scb->bufp = scb->buf;
639
      return *scb->bufp++;
640
    }
641
}
642
 
643
static int
644
hardwire_readchar (struct serial *scb, int timeout)
645
{
646
  return generic_readchar (scb, timeout, do_hardwire_readchar);
647
}
648
 
649
 
650
#ifndef B19200
651
#define B19200 EXTA
652
#endif
653
 
654
#ifndef B38400
655
#define B38400 EXTB
656
#endif
657
 
658
/* Translate baud rates from integers to damn B_codes.  Unix should
659
   have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
660
 
661
static struct
662
{
663
  int rate;
664
  int code;
665
}
666
baudtab[] =
667
{
668
  {
669
    50, B50
670
  }
671
  ,
672
  {
673
    75, B75
674
  }
675
  ,
676
  {
677
    110, B110
678
  }
679
  ,
680
  {
681
    134, B134
682
  }
683
  ,
684
  {
685
    150, B150
686
  }
687
  ,
688
  {
689
    200, B200
690
  }
691
  ,
692
  {
693
    300, B300
694
  }
695
  ,
696
  {
697
    600, B600
698
  }
699
  ,
700
  {
701
    1200, B1200
702
  }
703
  ,
704
  {
705
    1800, B1800
706
  }
707
  ,
708
  {
709
    2400, B2400
710
  }
711
  ,
712
  {
713
    4800, B4800
714
  }
715
  ,
716
  {
717
    9600, B9600
718
  }
719
  ,
720
  {
721
    19200, B19200
722
  }
723
  ,
724
  {
725
    38400, B38400
726
  }
727
  ,
728
#ifdef B57600
729
  {
730
    57600, B57600
731
  }
732
  ,
733
#endif
734
#ifdef B115200
735
  {
736
    115200, B115200
737
  }
738
  ,
739
#endif
740
#ifdef B230400
741
  {
742
    230400, B230400
743
  }
744
  ,
745
#endif
746
#ifdef B460800
747
  {
748
    460800, B460800
749
  }
750
  ,
751
#endif
752
  {
753
    -1, -1
754
  }
755
  ,
756
};
757
 
758
static int
759
rate_to_code (int rate)
760
{
761
  int i;
762
 
763
  for (i = 0; baudtab[i].rate != -1; i++)
764
    {
765
      /* test for perfect macth. */
766
      if (rate == baudtab[i].rate)
767
        return baudtab[i].code;
768
      else
769
        {
770
          /* check if it is in between valid values. */
771
          if (rate < baudtab[i].rate)
772
            {
773
              if (i)
774
                {
775
                  warning (_("Invalid baud rate %d.  Closest values are %d and %d."),
776
                            rate, baudtab[i - 1].rate, baudtab[i].rate);
777
                }
778
              else
779
                {
780
                  warning (_("Invalid baud rate %d.  Minimum value is %d."),
781
                            rate, baudtab[0].rate);
782
                }
783
              return -1;
784
            }
785
        }
786
    }
787
 
788
  /* The requested speed was too large. */
789
  warning (_("Invalid baud rate %d.  Maximum value is %d."),
790
            rate, baudtab[i - 1].rate);
791
  return -1;
792
}
793
 
794
static int
795
hardwire_setbaudrate (struct serial *scb, int rate)
796
{
797
  struct hardwire_ttystate state;
798
  int baud_code = rate_to_code (rate);
799
 
800
  if (baud_code < 0)
801
    {
802
      /* The baud rate was not valid.
803
         A warning has already been issued. */
804
      errno = EINVAL;
805
      return -1;
806
    }
807
 
808
  if (get_tty_state (scb, &state))
809
    return -1;
810
 
811
#ifdef HAVE_TERMIOS
812
  cfsetospeed (&state.termios, baud_code);
813
  cfsetispeed (&state.termios, baud_code);
814
#endif
815
 
816
#ifdef HAVE_TERMIO
817
#ifndef CIBAUD
818
#define CIBAUD CBAUD
819
#endif
820
 
821
  state.termio.c_cflag &= ~(CBAUD | CIBAUD);
822
  state.termio.c_cflag |= baud_code;
823
#endif
824
 
825
#ifdef HAVE_SGTTY
826
  state.sgttyb.sg_ispeed = baud_code;
827
  state.sgttyb.sg_ospeed = baud_code;
828
#endif
829
 
830
  return set_tty_state (scb, &state);
831
}
832
 
833
static int
834
hardwire_setstopbits (struct serial *scb, int num)
835
{
836
  struct hardwire_ttystate state;
837
  int newbit;
838
 
839
  if (get_tty_state (scb, &state))
840
    return -1;
841
 
842
  switch (num)
843
    {
844
    case SERIAL_1_STOPBITS:
845
      newbit = 0;
846
      break;
847
    case SERIAL_1_AND_A_HALF_STOPBITS:
848
    case SERIAL_2_STOPBITS:
849
      newbit = 1;
850
      break;
851
    default:
852
      return 1;
853
    }
854
 
855
#ifdef HAVE_TERMIOS
856
  if (!newbit)
857
    state.termios.c_cflag &= ~CSTOPB;
858
  else
859
    state.termios.c_cflag |= CSTOPB;    /* two bits */
860
#endif
861
 
862
#ifdef HAVE_TERMIO
863
  if (!newbit)
864
    state.termio.c_cflag &= ~CSTOPB;
865
  else
866
    state.termio.c_cflag |= CSTOPB;     /* two bits */
867
#endif
868
 
869
#ifdef HAVE_SGTTY
870
  return 0;                      /* sgtty doesn't support this */
871
#endif
872
 
873
  return set_tty_state (scb, &state);
874
}
875
 
876
static void
877
hardwire_close (struct serial *scb)
878
{
879
  if (scb->fd < 0)
880
    return;
881
 
882
  close (scb->fd);
883
  scb->fd = -1;
884
}
885
 
886
 
887
void
888
_initialize_ser_hardwire (void)
889
{
890
  struct serial_ops *ops = XMALLOC (struct serial_ops);
891
  memset (ops, 0, sizeof (struct serial_ops));
892
  ops->name = "hardwire";
893
  ops->next = 0;
894
  ops->open = hardwire_open;
895
  ops->close = hardwire_close;
896
  /* FIXME: Don't replace this with the equivalent ser_base*() until
897
     the old TERMIOS/SGTTY/... timer code has been flushed. cagney
898
     1999-09-16. */
899
  ops->readchar = hardwire_readchar;
900
  ops->write = ser_base_write;
901
  ops->flush_output = hardwire_flush_output;
902
  ops->flush_input = hardwire_flush_input;
903
  ops->send_break = hardwire_send_break;
904
  ops->go_raw = hardwire_raw;
905
  ops->get_tty_state = hardwire_get_tty_state;
906
  ops->set_tty_state = hardwire_set_tty_state;
907
  ops->print_tty_state = hardwire_print_tty_state;
908
  ops->noflush_set_tty_state = hardwire_noflush_set_tty_state;
909
  ops->setbaudrate = hardwire_setbaudrate;
910
  ops->setstopbits = hardwire_setstopbits;
911
  ops->drain_output = hardwire_drain_output;
912
  ops->async = ser_base_async;
913
  ops->read_prim = ser_unix_read_prim;
914
  ops->write_prim = ser_unix_write_prim;
915
  serial_add_interface (ops);
916
 
917
#ifdef HAVE_TERMIOS
918
#ifdef CRTSCTS
919
  add_setshow_boolean_cmd ("remoteflow", no_class,
920
                           &serial_hwflow, _("\
921
Set use of hardware flow control for remote serial I/O."), _("\
922
Show use of hardware flow control for remote serial I/O."), _("\
923
Enable or disable hardware flow control (RTS/CTS) on the serial port\n\
924
when debugging using remote targets."),
925
                           NULL,
926
                           show_serial_hwflow,
927
                           &setlist, &showlist);
928
#endif
929
#endif
930
}
931
 
932
int
933
ser_unix_read_prim (struct serial *scb, size_t count)
934
{
935
  int status;
936
 
937
  while (1)
938
    {
939
      status = read (scb->fd, scb->buf, count);
940
      if (status != -1 || errno != EINTR)
941
        break;
942
    }
943
  return status;
944
}
945
 
946
int
947
ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
948
{
949
  /* ??? Historically, GDB has not retried calls to "write" that
950
     result in EINTR.  */
951
  return write (scb->fd, buf, len);
952
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.