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

Subversion Repositories openrisc_me

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

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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