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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [ser-unix.c] - Blame information for rev 330

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 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
 
310
    if (get_tty_state (scb, &state))
311
      {
312
        return (-1);
313
      }
314
    else
315
      {
316
        return (ioctl (scb->fd, TIOCSETP, &state.sgttyb));
317
      }
318
  }
319
#endif
320
}
321
 
322
static int
323
hardwire_flush_output (struct serial *scb)
324
{
325
#ifdef HAVE_TERMIOS
326
  return tcflush (scb->fd, TCOFLUSH);
327
#endif
328
 
329
#ifdef HAVE_TERMIO
330
  return ioctl (scb->fd, TCFLSH, 1);
331
#endif
332
 
333
#ifdef HAVE_SGTTY
334
  /* This flushes both input and output, but we can't do better.  */
335
  return ioctl (scb->fd, TIOCFLUSH, 0);
336
#endif
337
}
338
 
339
static int
340
hardwire_flush_input (struct serial *scb)
341
{
342
  ser_base_flush_input (scb);
343
 
344
#ifdef HAVE_TERMIOS
345
  return tcflush (scb->fd, TCIFLUSH);
346
#endif
347
 
348
#ifdef HAVE_TERMIO
349
  return ioctl (scb->fd, TCFLSH, 0);
350
#endif
351
 
352
#ifdef HAVE_SGTTY
353
  /* This flushes both input and output, but we can't do better.  */
354
  return ioctl (scb->fd, TIOCFLUSH, 0);
355
#endif
356
}
357
 
358
static int
359
hardwire_send_break (struct serial *scb)
360
{
361
#ifdef HAVE_TERMIOS
362
  return tcsendbreak (scb->fd, 0);
363
#endif
364
 
365
#ifdef HAVE_TERMIO
366
  return ioctl (scb->fd, TCSBRK, 0);
367
#endif
368
 
369
#ifdef HAVE_SGTTY
370
  {
371
    int status;
372
 
373
    status = ioctl (scb->fd, TIOCSBRK, 0);
374
 
375
    /* Can't use usleep; it doesn't exist in BSD 4.2.  */
376
    /* Note that if this gdb_select() is interrupted by a signal it will not
377
       wait the full length of time.  I think that is OK.  */
378
    gdb_usleep (250000);
379
    status = ioctl (scb->fd, TIOCCBRK, 0);
380
    return status;
381
  }
382
#endif
383
}
384
 
385
static void
386
hardwire_raw (struct serial *scb)
387
{
388
  struct hardwire_ttystate state;
389
 
390
  if (get_tty_state (scb, &state))
391
    fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
392
 
393
#ifdef HAVE_TERMIOS
394
  state.termios.c_iflag = 0;
395
  state.termios.c_oflag = 0;
396
  state.termios.c_lflag = 0;
397
  state.termios.c_cflag &= ~(CSIZE | PARENB);
398
  state.termios.c_cflag |= CLOCAL | CS8;
399
#ifdef CRTSCTS
400
  /* h/w flow control.  */
401
  if (serial_hwflow)
402
    state.termios.c_cflag |= CRTSCTS;
403
  else
404
    state.termios.c_cflag &= ~CRTSCTS;
405
#ifdef CRTS_IFLOW
406
  if (serial_hwflow)
407
    state.termios.c_cflag |= CRTS_IFLOW;
408
  else
409
    state.termios.c_cflag &= ~CRTS_IFLOW;
410
#endif
411
#endif
412
  state.termios.c_cc[VMIN] = 0;
413
  state.termios.c_cc[VTIME] = 0;
414
#endif
415
 
416
#ifdef HAVE_TERMIO
417
  state.termio.c_iflag = 0;
418
  state.termio.c_oflag = 0;
419
  state.termio.c_lflag = 0;
420
  state.termio.c_cflag &= ~(CSIZE | PARENB);
421
  state.termio.c_cflag |= CLOCAL | CS8;
422
  state.termio.c_cc[VMIN] = 0;
423
  state.termio.c_cc[VTIME] = 0;
424
#endif
425
 
426
#ifdef HAVE_SGTTY
427
  state.sgttyb.sg_flags |= RAW | ANYP;
428
  state.sgttyb.sg_flags &= ~(CBREAK | ECHO);
429
#endif
430
 
431
  scb->current_timeout = 0;
432
 
433
  if (set_tty_state (scb, &state))
434
    fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
435
}
436
 
437
/* Wait for input on scb, with timeout seconds.  Returns 0 on success,
438
   otherwise SERIAL_TIMEOUT or SERIAL_ERROR.
439
 
440
   For termio{s}, we actually just setup VTIME if necessary, and let the
441
   timeout occur in the read() in hardwire_read().
442
 */
443
 
444
/* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
445
   ser_base*() until the old TERMIOS/SGTTY/... timer code has been
446
   flushed. . */
447
 
448
/* NOTE: cagney/1999-09-30: Much of the code below is dead.  The only
449
   possible values of the TIMEOUT parameter are ONE and ZERO.
450
   Consequently all the code that tries to handle the possability of
451
   an overflowed timer is unnecessary. */
452
 
453
static int
454
wait_for (struct serial *scb, int timeout)
455
{
456
#ifdef HAVE_SGTTY
457
  while (1)
458
    {
459
      struct timeval tv;
460
      fd_set readfds;
461
      int numfds;
462
 
463
      /* NOTE: Some OS's can scramble the READFDS when the select()
464
         call fails (ex the kernel with Red Hat 5.2).  Initialize all
465
         arguments before each call. */
466
 
467
      tv.tv_sec = timeout;
468
      tv.tv_usec = 0;
469
 
470
      FD_ZERO (&readfds);
471
      FD_SET (scb->fd, &readfds);
472
 
473
      if (timeout >= 0)
474
        numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, &tv);
475
      else
476
        numfds = gdb_select (scb->fd + 1, &readfds, 0, 0, 0);
477
 
478
      if (numfds <= 0)
479
        if (numfds == 0)
480
          return SERIAL_TIMEOUT;
481
        else if (errno == EINTR)
482
          continue;
483
        else
484
          return SERIAL_ERROR;  /* Got an error from select or poll */
485
 
486
      return 0;
487
    }
488
#endif /* HAVE_SGTTY */
489
 
490
#if defined HAVE_TERMIO || defined HAVE_TERMIOS
491
  if (timeout == scb->current_timeout)
492
    return 0;
493
 
494
  scb->current_timeout = timeout;
495
 
496
  {
497
    struct hardwire_ttystate state;
498
 
499
    if (get_tty_state (scb, &state))
500
      fprintf_unfiltered (gdb_stderr, "get_tty_state failed: %s\n", safe_strerror (errno));
501
 
502
#ifdef HAVE_TERMIOS
503
    if (timeout < 0)
504
      {
505
        /* No timeout.  */
506
        state.termios.c_cc[VTIME] = 0;
507
        state.termios.c_cc[VMIN] = 1;
508
      }
509
    else
510
      {
511
        state.termios.c_cc[VMIN] = 0;
512
        state.termios.c_cc[VTIME] = timeout * 10;
513
        if (state.termios.c_cc[VTIME] != timeout * 10)
514
          {
515
 
516
            /* If c_cc is an 8-bit signed character, we can't go
517
               bigger than this.  If it is always unsigned, we could use
518
               25.  */
519
 
520
            scb->current_timeout = 12;
521
            state.termios.c_cc[VTIME] = scb->current_timeout * 10;
522
            scb->timeout_remaining = timeout - scb->current_timeout;
523
          }
524
      }
525
#endif
526
 
527
#ifdef HAVE_TERMIO
528
    if (timeout < 0)
529
      {
530
        /* No timeout.  */
531
        state.termio.c_cc[VTIME] = 0;
532
        state.termio.c_cc[VMIN] = 1;
533
      }
534
    else
535
      {
536
        state.termio.c_cc[VMIN] = 0;
537
        state.termio.c_cc[VTIME] = timeout * 10;
538
        if (state.termio.c_cc[VTIME] != timeout * 10)
539
          {
540
            /* If c_cc is an 8-bit signed character, we can't go
541
               bigger than this.  If it is always unsigned, we could use
542
               25.  */
543
 
544
            scb->current_timeout = 12;
545
            state.termio.c_cc[VTIME] = scb->current_timeout * 10;
546
            scb->timeout_remaining = timeout - scb->current_timeout;
547
          }
548
      }
549
#endif
550
 
551
    if (set_tty_state (scb, &state))
552
      fprintf_unfiltered (gdb_stderr, "set_tty_state failed: %s\n", safe_strerror (errno));
553
 
554
    return 0;
555
  }
556
#endif /* HAVE_TERMIO || HAVE_TERMIOS */
557
}
558
 
559
/* Read a character with user-specified timeout.  TIMEOUT is number of seconds
560
   to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
561
   char if successful.  Returns SERIAL_TIMEOUT if timeout expired, EOF if line
562
   dropped dead, or SERIAL_ERROR for any other error (see errno in that case).  */
563
 
564
/* FIXME: cagney/1999-09-16: Don't replace this with the equivalent
565
   ser_base*() until the old TERMIOS/SGTTY/... timer code has been
566
   flushed. */
567
 
568
/* NOTE: cagney/1999-09-16: This function is not identical to
569
   ser_base_readchar() as part of replacing it with ser_base*()
570
   merging will be required - this code handles the case where read()
571
   times out due to no data while ser_base_readchar() doesn't expect
572
   that. */
573
 
574
static int
575
do_hardwire_readchar (struct serial *scb, int timeout)
576
{
577
  int status, delta;
578
  int detach = 0;
579
 
580
  if (timeout > 0)
581
    timeout++;
582
 
583
  /* We have to be able to keep the GUI alive here, so we break the
584
     original timeout into steps of 1 second, running the "keep the
585
     GUI alive" hook each time through the loop.
586
 
587
     Also, timeout = 0 means to poll, so we just set the delta to 0,
588
     so we will only go through the loop once.  */
589
 
590
  delta = (timeout == 0 ? 0 : 1);
591
  while (1)
592
    {
593
 
594
      /* N.B. The UI may destroy our world (for instance by calling
595
         remote_stop,) in which case we want to get out of here as
596
         quickly as possible.  It is not safe to touch scb, since
597
         someone else might have freed it.  The
598
         deprecated_ui_loop_hook signals that we should exit by
599
         returning 1.  */
600
 
601
      if (deprecated_ui_loop_hook)
602
        detach = deprecated_ui_loop_hook (0);
603
 
604
      if (detach)
605
        return SERIAL_TIMEOUT;
606
 
607
      scb->timeout_remaining = (timeout < 0 ? timeout : timeout - delta);
608
      status = wait_for (scb, delta);
609
 
610
      if (status < 0)
611
        return status;
612
 
613
      status = read (scb->fd, scb->buf, BUFSIZ);
614
 
615
      if (status <= 0)
616
        {
617
          if (status == 0)
618
            {
619
              /* Zero characters means timeout (it could also be EOF, but
620
                 we don't (yet at least) distinguish).  */
621
              if (scb->timeout_remaining > 0)
622
                {
623
                  timeout = scb->timeout_remaining;
624
                  continue;
625
                }
626
              else if (scb->timeout_remaining < 0)
627
                continue;
628
              else
629
                return SERIAL_TIMEOUT;
630
            }
631
          else if (errno == EINTR)
632
            continue;
633
          else
634
            return SERIAL_ERROR;        /* Got an error from read */
635
        }
636
 
637
      scb->bufcnt = status;
638
      scb->bufcnt--;
639
      scb->bufp = scb->buf;
640
      return *scb->bufp++;
641
    }
642
}
643
 
644
static int
645
hardwire_readchar (struct serial *scb, int timeout)
646
{
647
  return generic_readchar (scb, timeout, do_hardwire_readchar);
648
}
649
 
650
 
651
#ifndef B19200
652
#define B19200 EXTA
653
#endif
654
 
655
#ifndef B38400
656
#define B38400 EXTB
657
#endif
658
 
659
/* Translate baud rates from integers to damn B_codes.  Unix should
660
   have outgrown this crap years ago, but even POSIX wouldn't buck it.  */
661
 
662
static struct
663
{
664
  int rate;
665
  int code;
666
}
667
baudtab[] =
668
{
669
  {
670
    50, B50
671
  }
672
  ,
673
  {
674
    75, B75
675
  }
676
  ,
677
  {
678
    110, B110
679
  }
680
  ,
681
  {
682
    134, B134
683
  }
684
  ,
685
  {
686
    150, B150
687
  }
688
  ,
689
  {
690
    200, B200
691
  }
692
  ,
693
  {
694
    300, B300
695
  }
696
  ,
697
  {
698
    600, B600
699
  }
700
  ,
701
  {
702
    1200, B1200
703
  }
704
  ,
705
  {
706
    1800, B1800
707
  }
708
  ,
709
  {
710
    2400, B2400
711
  }
712
  ,
713
  {
714
    4800, B4800
715
  }
716
  ,
717
  {
718
    9600, B9600
719
  }
720
  ,
721
  {
722
    19200, B19200
723
  }
724
  ,
725
  {
726
    38400, B38400
727
  }
728
  ,
729
#ifdef B57600
730
  {
731
    57600, B57600
732
  }
733
  ,
734
#endif
735
#ifdef B115200
736
  {
737
    115200, B115200
738
  }
739
  ,
740
#endif
741
#ifdef B230400
742
  {
743
    230400, B230400
744
  }
745
  ,
746
#endif
747
#ifdef B460800
748
  {
749
    460800, B460800
750
  }
751
  ,
752
#endif
753
  {
754
    -1, -1
755
  }
756
  ,
757
};
758
 
759
static int
760
rate_to_code (int rate)
761
{
762
  int i;
763
 
764
  for (i = 0; baudtab[i].rate != -1; i++)
765
    {
766
      /* test for perfect macth. */
767
      if (rate == baudtab[i].rate)
768
        return baudtab[i].code;
769
      else
770
        {
771
          /* check if it is in between valid values. */
772
          if (rate < baudtab[i].rate)
773
            {
774
              if (i)
775
                {
776
                  warning (_("Invalid baud rate %d.  Closest values are %d and %d."),
777
                            rate, baudtab[i - 1].rate, baudtab[i].rate);
778
                }
779
              else
780
                {
781
                  warning (_("Invalid baud rate %d.  Minimum value is %d."),
782
                            rate, baudtab[0].rate);
783
                }
784
              return -1;
785
            }
786
        }
787
    }
788
 
789
  /* The requested speed was too large. */
790
  warning (_("Invalid baud rate %d.  Maximum value is %d."),
791
            rate, baudtab[i - 1].rate);
792
  return -1;
793
}
794
 
795
static int
796
hardwire_setbaudrate (struct serial *scb, int rate)
797
{
798
  struct hardwire_ttystate state;
799
  int baud_code = rate_to_code (rate);
800
 
801
  if (baud_code < 0)
802
    {
803
      /* The baud rate was not valid.
804
         A warning has already been issued. */
805
      errno = EINVAL;
806
      return -1;
807
    }
808
 
809
  if (get_tty_state (scb, &state))
810
    return -1;
811
 
812
#ifdef HAVE_TERMIOS
813
  cfsetospeed (&state.termios, baud_code);
814
  cfsetispeed (&state.termios, baud_code);
815
#endif
816
 
817
#ifdef HAVE_TERMIO
818
#ifndef CIBAUD
819
#define CIBAUD CBAUD
820
#endif
821
 
822
  state.termio.c_cflag &= ~(CBAUD | CIBAUD);
823
  state.termio.c_cflag |= baud_code;
824
#endif
825
 
826
#ifdef HAVE_SGTTY
827
  state.sgttyb.sg_ispeed = baud_code;
828
  state.sgttyb.sg_ospeed = baud_code;
829
#endif
830
 
831
  return set_tty_state (scb, &state);
832
}
833
 
834
static int
835
hardwire_setstopbits (struct serial *scb, int num)
836
{
837
  struct hardwire_ttystate state;
838
  int newbit;
839
 
840
  if (get_tty_state (scb, &state))
841
    return -1;
842
 
843
  switch (num)
844
    {
845
    case SERIAL_1_STOPBITS:
846
      newbit = 0;
847
      break;
848
    case SERIAL_1_AND_A_HALF_STOPBITS:
849
    case SERIAL_2_STOPBITS:
850
      newbit = 1;
851
      break;
852
    default:
853
      return 1;
854
    }
855
 
856
#ifdef HAVE_TERMIOS
857
  if (!newbit)
858
    state.termios.c_cflag &= ~CSTOPB;
859
  else
860
    state.termios.c_cflag |= CSTOPB;    /* two bits */
861
#endif
862
 
863
#ifdef HAVE_TERMIO
864
  if (!newbit)
865
    state.termio.c_cflag &= ~CSTOPB;
866
  else
867
    state.termio.c_cflag |= CSTOPB;     /* two bits */
868
#endif
869
 
870
#ifdef HAVE_SGTTY
871
  return 0;                      /* sgtty doesn't support this */
872
#endif
873
 
874
  return set_tty_state (scb, &state);
875
}
876
 
877
static void
878
hardwire_close (struct serial *scb)
879
{
880
  if (scb->fd < 0)
881
    return;
882
 
883
  close (scb->fd);
884
  scb->fd = -1;
885
}
886
 
887
 
888
void
889
_initialize_ser_hardwire (void)
890
{
891
  struct serial_ops *ops = XMALLOC (struct serial_ops);
892
 
893
  memset (ops, 0, sizeof (struct serial_ops));
894
  ops->name = "hardwire";
895
  ops->next = 0;
896
  ops->open = hardwire_open;
897
  ops->close = hardwire_close;
898
  /* FIXME: Don't replace this with the equivalent ser_base*() until
899
     the old TERMIOS/SGTTY/... timer code has been flushed. cagney
900
     1999-09-16. */
901
  ops->readchar = hardwire_readchar;
902
  ops->write = ser_base_write;
903
  ops->flush_output = hardwire_flush_output;
904
  ops->flush_input = hardwire_flush_input;
905
  ops->send_break = hardwire_send_break;
906
  ops->go_raw = hardwire_raw;
907
  ops->get_tty_state = hardwire_get_tty_state;
908
  ops->set_tty_state = hardwire_set_tty_state;
909
  ops->print_tty_state = hardwire_print_tty_state;
910
  ops->noflush_set_tty_state = hardwire_noflush_set_tty_state;
911
  ops->setbaudrate = hardwire_setbaudrate;
912
  ops->setstopbits = hardwire_setstopbits;
913
  ops->drain_output = hardwire_drain_output;
914
  ops->async = ser_base_async;
915
  ops->read_prim = ser_unix_read_prim;
916
  ops->write_prim = ser_unix_write_prim;
917
  serial_add_interface (ops);
918
 
919
#ifdef HAVE_TERMIOS
920
#ifdef CRTSCTS
921
  add_setshow_boolean_cmd ("remoteflow", no_class,
922
                           &serial_hwflow, _("\
923
Set use of hardware flow control for remote serial I/O."), _("\
924
Show use of hardware flow control for remote serial I/O."), _("\
925
Enable or disable hardware flow control (RTS/CTS) on the serial port\n\
926
when debugging using remote targets."),
927
                           NULL,
928
                           show_serial_hwflow,
929
                           &setlist, &showlist);
930
#endif
931
#endif
932
}
933
 
934
int
935
ser_unix_read_prim (struct serial *scb, size_t count)
936
{
937
  int status;
938
 
939
  while (1)
940
    {
941
      status = read (scb->fd, scb->buf, count);
942
      if (status != -1 || errno != EINTR)
943
        break;
944
    }
945
  return status;
946
}
947
 
948
int
949
ser_unix_write_prim (struct serial *scb, const void *buf, size_t len)
950
{
951
  /* ??? Historically, GDB has not retried calls to "write" that
952
     result in EINTR.  */
953
  return write (scb->fd, buf, len);
954
}

powered by: WebSVN 2.1.0

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