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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [ser-go32.c] - Blame information for rev 318

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

Line No. Rev Author Line
1 227 jeremybenn
/* Remote serial interface for local (hardwired) serial ports for GO32.
2
   Copyright (C) 1992, 1993, 2000, 2001, 2007, 2008, 2009, 2010
3
   Free Software Foundation, Inc.
4
 
5
   Contributed by Nigel Stephens, Algorithmics Ltd. (nigel@algor.co.uk).
6
 
7
   This version uses DPMI interrupts to handle buffered i/o
8
   without the separate "asynctsr" program.
9
 
10
   This file is part of GDB.
11
 
12
   This program is free software; you can redistribute it and/or modify
13
   it under the terms of the GNU General Public License as published by
14
   the Free Software Foundation; either version 3 of the License, or
15
   (at your option) any later version.
16
 
17
   This program is distributed in the hope that it will be useful,
18
   but WITHOUT ANY WARRANTY; without even the implied warranty of
19
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20
   GNU General Public License for more details.
21
 
22
   You should have received a copy of the GNU General Public License
23
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
24
 
25
#include "defs.h"
26
#include "gdbcmd.h"
27
#include "serial.h"
28
#include "gdb_string.h"
29
 
30
 
31
/*
32
 * NS16550 UART registers
33
 */
34
 
35
#define COM1ADDR        0x3f8
36
#define COM2ADDR        0x2f8
37
#define COM3ADDR        0x3e8
38
#define COM4ADDR        0x3e0
39
 
40
#define com_data        0        /* data register (R/W) */
41
#define com_dlbl        0        /* divisor latch low (W) */
42
#define com_ier         1       /* interrupt enable (W) */
43
#define com_dlbh        1       /* divisor latch high (W) */
44
#define com_iir         2       /* interrupt identification (R) */
45
#define com_fifo        2       /* FIFO control (W) */
46
#define com_lctl        3       /* line control register (R/W) */
47
#define com_cfcr        3       /* line control register (R/W) */
48
#define com_mcr         4       /* modem control register (R/W) */
49
#define com_lsr         5       /* line status register (R/W) */
50
#define com_msr         6       /* modem status register (R/W) */
51
 
52
/*
53
 * Constants for computing 16 bit baud rate divisor (lower byte
54
 * in com_dlbl, upper in com_dlbh) from 1.8432MHz crystal.  Divisor is
55
 * 1.8432 MHz / (16 * X) for X bps.  If the baud rate can't be set
56
 * to within +- (desired_rate*SPEED_TOLERANCE/1000) bps, we fail.
57
 */
58
#define COMTICK         (1843200/16)
59
#define SPEED_TOLERANCE 30      /* thousandths; real == desired +- 3.0% */
60
 
61
/* interrupt enable register */
62
#define IER_ERXRDY      0x1     /* int on rx ready */
63
#define IER_ETXRDY      0x2     /* int on tx ready */
64
#define IER_ERLS        0x4     /* int on line status change */
65
#define IER_EMSC        0x8     /* int on modem status change */
66
 
67
/* interrupt identification register */
68
#define IIR_FIFO_MASK   0xc0    /* set if FIFOs are enabled */
69
#define IIR_IMASK       0xf     /* interrupt cause mask */
70
#define IIR_NOPEND      0x1     /* nothing pending */
71
#define IIR_RLS         0x6     /* receive line status */
72
#define IIR_RXRDY       0x4     /* receive ready */
73
#define IIR_RXTOUT      0xc     /* receive timeout */
74
#define IIR_TXRDY       0x2     /* transmit ready */
75
#define IIR_MLSC        0x0     /* modem status */
76
 
77
 
78
/* fifo control register */
79
#define FIFO_ENABLE     0x01    /* enable fifo */
80
#define FIFO_RCV_RST    0x02    /* reset receive fifo */
81
#define FIFO_XMT_RST    0x04    /* reset transmit fifo */
82
#define FIFO_DMA_MODE   0x08    /* enable dma mode */
83
#define FIFO_TRIGGER_1  0x00    /* trigger at 1 char */
84
#define FIFO_TRIGGER_4  0x40    /* trigger at 4 chars */
85
#define FIFO_TRIGGER_8  0x80    /* trigger at 8 chars */
86
#define FIFO_TRIGGER_14 0xc0    /* trigger at 14 chars */
87
 
88
/* character format control register */
89
#define CFCR_DLAB       0x80    /* divisor latch */
90
#define CFCR_SBREAK     0x40    /* send break */
91
#define CFCR_PZERO      0x30    /* zero parity */
92
#define CFCR_PONE       0x20    /* one parity */
93
#define CFCR_PEVEN      0x10    /* even parity */
94
#define CFCR_PODD       0x00    /* odd parity */
95
#define CFCR_PENAB      0x08    /* parity enable */
96
#define CFCR_STOPB      0x04    /* 2 stop bits */
97
#define CFCR_8BITS      0x03    /* 8 data bits */
98
#define CFCR_7BITS      0x02    /* 7 data bits */
99
#define CFCR_6BITS      0x01    /* 6 data bits */
100
#define CFCR_5BITS      0x00    /* 5 data bits */
101
 
102
/* modem control register */
103
#define MCR_LOOPBACK    0x10    /* loopback */
104
#define MCR_IENABLE     0x08    /* output 2 = int enable */
105
#define MCR_DRS         0x04    /* output 1 = xxx */
106
#define MCR_RTS         0x02    /* enable RTS */
107
#define MCR_DTR         0x01    /* enable DTR */
108
 
109
/* line status register */
110
#define LSR_RCV_FIFO    0x80    /* error in receive fifo */
111
#define LSR_TSRE        0x40    /* transmitter empty */
112
#define LSR_TXRDY       0x20    /* transmitter ready */
113
#define LSR_BI          0x10    /* break detected */
114
#define LSR_FE          0x08    /* framing error */
115
#define LSR_PE          0x04    /* parity error */
116
#define LSR_OE          0x02    /* overrun error */
117
#define LSR_RXRDY       0x01    /* receiver ready */
118
#define LSR_RCV_MASK    0x1f
119
 
120
/* modem status register */
121
#define MSR_DCD         0x80
122
#define MSR_RI          0x40
123
#define MSR_DSR         0x20
124
#define MSR_CTS         0x10
125
#define MSR_DDCD        0x08
126
#define MSR_TERI        0x04
127
#define MSR_DDSR        0x02
128
#define MSR_DCTS        0x01
129
 
130
#include <time.h>
131
#include <dos.h>
132
#include <go32.h>
133
#include <dpmi.h>
134
typedef unsigned long u_long;
135
 
136
/* 16550 rx fifo trigger point */
137
#define FIFO_TRIGGER    FIFO_TRIGGER_4
138
 
139
/* input buffer size */
140
#define CBSIZE  4096
141
 
142
#define RAWHZ   18
143
 
144
#ifdef DOS_STATS
145
#define CNT_RX          16
146
#define CNT_TX          17
147
#define CNT_STRAY       18
148
#define CNT_ORUN        19
149
#define NCNT            20
150
 
151
static int intrcnt;
152
static int cnts[NCNT];
153
static char *cntnames[NCNT] =
154
{
155
  /* h/w interrupt counts. */
156
  "mlsc", "nopend", "txrdy", "?3",
157
  "rxrdy", "?5", "rls", "?7",
158
  "?8", "?9", "?a", "?b",
159
  "rxtout", "?d", "?e", "?f",
160
  /* s/w counts. */
161
  "rxcnt", "txcnt", "stray", "swoflo"
162
};
163
 
164
#define COUNT(x) cnts[x]++
165
#else
166
#define COUNT(x)
167
#endif
168
 
169
/* Main interrupt controller port addresses. */
170
#define ICU_BASE        0x20
171
#define ICU_OCW2        (ICU_BASE + 0)
172
#define ICU_MASK        (ICU_BASE + 1)
173
 
174
/* Original interrupt controller mask register. */
175
unsigned char icu_oldmask;
176
 
177
/* Maximum of 8 interrupts (we don't handle the slave icu yet). */
178
#define NINTR   8
179
 
180
static struct intrupt
181
  {
182
    char inuse;
183
    struct dos_ttystate *port;
184
    _go32_dpmi_seginfo old_rmhandler;
185
    _go32_dpmi_seginfo old_pmhandler;
186
    _go32_dpmi_seginfo new_rmhandler;
187
    _go32_dpmi_seginfo new_pmhandler;
188
    _go32_dpmi_registers regs;
189
  }
190
intrupts[NINTR];
191
 
192
 
193
static struct dos_ttystate
194
  {
195
    int base;
196
    int irq;
197
    int refcnt;
198
    struct intrupt *intrupt;
199
    int fifo;
200
    int baudrate;
201
    unsigned char cbuf[CBSIZE];
202
    unsigned int first;
203
    unsigned int count;
204
    int txbusy;
205
    unsigned char old_mcr;
206
    int ferr;
207
    int perr;
208
    int oflo;
209
    int msr;
210
  }
211
ports[4] =
212
{
213
  {
214
    COM1ADDR, 4, 0, NULL, 0, 0, "", 0, 0, 0, 0, 0, 0, 0, 0
215
  }
216
  ,
217
  {
218
    COM2ADDR, 3, 0, NULL, 0, 0, "", 0, 0, 0, 0, 0, 0, 0, 0
219
  }
220
  ,
221
  {
222
    COM3ADDR, 4, 0, NULL, 0, 0, "", 0, 0, 0, 0, 0, 0, 0, 0
223
  }
224
  ,
225
  {
226
    COM4ADDR, 3, 0, NULL, 0, 0, "", 0, 0, 0, 0, 0, 0, 0, 0
227
  }
228
};
229
 
230
static int dos_open (struct serial *scb, const char *name);
231
static void dos_raw (struct serial *scb);
232
static int dos_readchar (struct serial *scb, int timeout);
233
static int dos_setbaudrate (struct serial *scb, int rate);
234
static int dos_write (struct serial *scb, const char *str, int len);
235
static void dos_close (struct serial *scb);
236
static serial_ttystate dos_get_tty_state (struct serial *scb);
237
static int dos_set_tty_state (struct serial *scb, serial_ttystate state);
238
static int dos_baudconv (int rate);
239
 
240
#define inb(p,a)        inportb((p)->base + (a))
241
#define outb(p,a,v)     outportb((p)->base + (a), (v))
242
#define disable()       asm volatile ("cli");
243
#define enable()        asm volatile ("sti");
244
 
245
 
246
static int
247
dos_getc (volatile struct dos_ttystate *port)
248
{
249
  int c;
250
 
251
  if (port->count == 0)
252
    return -1;
253
 
254
  c = port->cbuf[port->first];
255
  disable ();
256
  port->first = (port->first + 1) & (CBSIZE - 1);
257
  port->count--;
258
  enable ();
259
  return c;
260
}
261
 
262
 
263
static int
264
dos_putc (int c, struct dos_ttystate *port)
265
{
266
  if (port->count >= CBSIZE - 1)
267
    return -1;
268
  port->cbuf[(port->first + port->count) & (CBSIZE - 1)] = c;
269
  port->count++;
270
  return 0;
271
}
272
 
273
 
274
 
275
static void
276
dos_comisr (int irq)
277
{
278
  struct dos_ttystate *port;
279
  unsigned char iir, lsr, c;
280
 
281
  disable ();                   /* Paranoia */
282
  outportb (ICU_OCW2, 0x20);    /* End-Of-Interrupt */
283
#ifdef DOS_STATS
284
  ++intrcnt;
285
#endif
286
 
287
  port = intrupts[irq].port;
288
  if (!port)
289
    {
290
      COUNT (CNT_STRAY);
291
      return;                   /* not open */
292
    }
293
 
294
  while (1)
295
    {
296
      iir = inb (port, com_iir) & IIR_IMASK;
297
      switch (iir)
298
        {
299
 
300
        case IIR_RLS:
301
          lsr = inb (port, com_lsr);
302
          goto rx;
303
 
304
        case IIR_RXTOUT:
305
        case IIR_RXRDY:
306
          lsr = 0;
307
 
308
        rx:
309
          do
310
            {
311
              c = inb (port, com_data);
312
              if (lsr & (LSR_BI | LSR_FE | LSR_PE | LSR_OE))
313
                {
314
                  if (lsr & (LSR_BI | LSR_FE))
315
                    port->ferr++;
316
                  else if (lsr & LSR_PE)
317
                    port->perr++;
318
                  if (lsr & LSR_OE)
319
                    port->oflo++;
320
                }
321
 
322
              if (dos_putc (c, port) < 0)
323
                {
324
                  COUNT (CNT_ORUN);
325
                }
326
              else
327
                {
328
                  COUNT (CNT_RX);
329
                }
330
            }
331
          while ((lsr = inb (port, com_lsr)) & LSR_RXRDY);
332
          break;
333
 
334
        case IIR_MLSC:
335
          /* could be used to flowcontrol Tx */
336
          port->msr = inb (port, com_msr);
337
          break;
338
 
339
        case IIR_TXRDY:
340
          port->txbusy = 0;
341
          break;
342
 
343
        case IIR_NOPEND:
344
          /* no more pending interrupts, all done */
345
          return;
346
 
347
        default:
348
          /* unexpected interrupt, ignore */
349
          break;
350
        }
351
      COUNT (iir);
352
    }
353
}
354
 
355
#define ISRNAME(x) dos_comisr##x
356
#define ISR(x) static void ISRNAME(x)(void) {dos_comisr(x);}
357
 
358
ISR (0) ISR (1) ISR (2) ISR (3) /* OK */
359
ISR (4) ISR (5) ISR (6) ISR (7) /* OK */
360
 
361
typedef void (*isr_t) (void);
362
 
363
static isr_t isrs[NINTR] =
364
  {
365
       ISRNAME (0), ISRNAME (1), ISRNAME (2), ISRNAME (3),
366
       ISRNAME (4), ISRNAME (5), ISRNAME (6), ISRNAME (7)
367
  };
368
 
369
 
370
 
371
static struct intrupt *
372
dos_hookirq (unsigned int irq)
373
{
374
  struct intrupt *intr;
375
  unsigned int vec;
376
  isr_t isr;
377
 
378
  if (irq >= NINTR)
379
    return 0;
380
 
381
  intr = &intrupts[irq];
382
  if (intr->inuse)
383
    return 0;
384
 
385
  vec = 0x08 + irq;
386
  isr = isrs[irq];
387
 
388
  /* setup real mode handler */
389
  _go32_dpmi_get_real_mode_interrupt_vector (vec, &intr->old_rmhandler);
390
 
391
  intr->new_rmhandler.pm_selector = _go32_my_cs ();
392
  intr->new_rmhandler.pm_offset = (u_long) isr;
393
  if (_go32_dpmi_allocate_real_mode_callback_iret (&intr->new_rmhandler,
394
                                                   &intr->regs))
395
    {
396
      return 0;
397
    }
398
 
399
  if (_go32_dpmi_set_real_mode_interrupt_vector (vec, &intr->new_rmhandler))
400
    {
401
      return 0;
402
    }
403
 
404
  /* setup protected mode handler */
405
  _go32_dpmi_get_protected_mode_interrupt_vector (vec, &intr->old_pmhandler);
406
 
407
  intr->new_pmhandler.pm_selector = _go32_my_cs ();
408
  intr->new_pmhandler.pm_offset = (u_long) isr;
409
  _go32_dpmi_allocate_iret_wrapper (&intr->new_pmhandler);
410
 
411
  if (_go32_dpmi_set_protected_mode_interrupt_vector (vec,
412
                                                      &intr->new_pmhandler))
413
    {
414
      return 0;
415
    }
416
 
417
  /* setup interrupt controller mask */
418
  disable ();
419
  outportb (ICU_MASK, inportb (ICU_MASK) & ~(1 << irq));
420
  enable ();
421
 
422
  intr->inuse = 1;
423
  return intr;
424
}
425
 
426
 
427
static void
428
dos_unhookirq (struct intrupt *intr)
429
{
430
  unsigned int irq, vec;
431
  unsigned char mask;
432
 
433
  irq = intr - intrupts;
434
  vec = 0x08 + irq;
435
 
436
  /* restore old interrupt mask bit */
437
  mask = 1 << irq;
438
  disable ();
439
  outportb (ICU_MASK, inportb (ICU_MASK) | (mask & icu_oldmask));
440
  enable ();
441
 
442
  /* remove real mode handler */
443
  _go32_dpmi_set_real_mode_interrupt_vector (vec, &intr->old_rmhandler);
444
  _go32_dpmi_free_real_mode_callback (&intr->new_rmhandler);
445
 
446
  /* remove protected mode handler */
447
  _go32_dpmi_set_protected_mode_interrupt_vector (vec, &intr->old_pmhandler);
448
  _go32_dpmi_free_iret_wrapper (&intr->new_pmhandler);
449
  intr->inuse = 0;
450
}
451
 
452
 
453
 
454
static int
455
dos_open (struct serial *scb, const char *name)
456
{
457
  struct dos_ttystate *port;
458
  int fd, i;
459
 
460
  if (strncasecmp (name, "/dev/", 5) == 0)
461
    name += 5;
462
  else if (strncasecmp (name, "\\dev\\", 5) == 0)
463
    name += 5;
464
 
465
  if (strlen (name) != 4 || strncasecmp (name, "com", 3) != 0)
466
    {
467
      errno = ENOENT;
468
      return -1;
469
    }
470
 
471
  if (name[3] < '1' || name[3] > '4')
472
    {
473
      errno = ENOENT;
474
      return -1;
475
    }
476
 
477
  /* FIXME: this is a Bad Idea (tm)!  One should *never* invent file
478
     handles, since they might be already used by other files/devices.
479
     The Right Way to do this is to create a real handle by dup()'ing
480
     some existing one.  */
481
  fd = name[3] - '1';
482
  port = &ports[fd];
483
  if (port->refcnt++ > 0)
484
    {
485
      /* Device already opened another user.  Just point at it. */
486
      scb->fd = fd;
487
      return 0;
488
    }
489
 
490
  /* force access to ID reg */
491
  outb (port, com_cfcr, 0);
492
  outb (port, com_iir, 0);
493
  for (i = 0; i < 17; i++)
494
    {
495
      if ((inb (port, com_iir) & 0x38) == 0)
496
        goto ok;
497
      (void) inb (port, com_data);      /* clear recv */
498
    }
499
  errno = ENODEV;
500
  return -1;
501
 
502
ok:
503
  /* disable all interrupts in chip */
504
  outb (port, com_ier, 0);
505
 
506
  /* tentatively enable 16550 fifo, and see if it responds */
507
  outb (port, com_fifo,
508
        FIFO_ENABLE | FIFO_RCV_RST | FIFO_XMT_RST | FIFO_TRIGGER);
509
  sleep (1);
510
  port->fifo = ((inb (port, com_iir) & IIR_FIFO_MASK) == IIR_FIFO_MASK);
511
 
512
  /* clear pending status reports. */
513
  (void) inb (port, com_lsr);
514
  (void) inb (port, com_msr);
515
 
516
  /* enable external interrupt gate (to avoid floating IRQ) */
517
  outb (port, com_mcr, MCR_IENABLE);
518
 
519
  /* hook up interrupt handler and initialise icu */
520
  port->intrupt = dos_hookirq (port->irq);
521
  if (!port->intrupt)
522
    {
523
      outb (port, com_mcr, 0);
524
      outb (port, com_fifo, 0);
525
      errno = ENODEV;
526
      return -1;
527
    }
528
 
529
  disable ();
530
 
531
  /* record port */
532
  port->intrupt->port = port;
533
  scb->fd = fd;
534
 
535
  /* clear rx buffer, tx busy flag and overflow count */
536
  port->first = port->count = 0;
537
  port->txbusy = 0;
538
  port->oflo = 0;
539
 
540
  /* set default baud rate and mode: 9600,8,n,1 */
541
  i = dos_baudconv (port->baudrate = 9600);
542
  outb (port, com_cfcr, CFCR_DLAB);
543
  outb (port, com_dlbl, i & 0xff);
544
  outb (port, com_dlbh, i >> 8);
545
  outb (port, com_cfcr, CFCR_8BITS);
546
 
547
  /* enable all interrupts */
548
  outb (port, com_ier, IER_ETXRDY | IER_ERXRDY | IER_ERLS | IER_EMSC);
549
 
550
  /* enable DTR & RTS */
551
  outb (port, com_mcr, MCR_DTR | MCR_RTS | MCR_IENABLE);
552
 
553
  enable ();
554
 
555
  return 0;
556
}
557
 
558
 
559
static void
560
dos_close (struct serial *scb)
561
{
562
  struct dos_ttystate *port;
563
  struct intrupt *intrupt;
564
 
565
  if (!scb)
566
    return;
567
 
568
  port = &ports[scb->fd];
569
 
570
  if (port->refcnt-- > 1)
571
    return;
572
 
573
  if (!(intrupt = port->intrupt))
574
    return;
575
 
576
  /* disable interrupts, fifo, flow control */
577
  disable ();
578
  port->intrupt = 0;
579
  intrupt->port = 0;
580
  outb (port, com_fifo, 0);
581
  outb (port, com_ier, 0);
582
  enable ();
583
 
584
  /* unhook handler, and disable interrupt gate */
585
  dos_unhookirq (intrupt);
586
  outb (port, com_mcr, 0);
587
 
588
  /* Check for overflow errors */
589
  if (port->oflo)
590
    {
591
      fprintf_unfiltered (gdb_stderr,
592
                          "Serial input overruns occurred.\n");
593
      fprintf_unfiltered (gdb_stderr, "This system %s handle %d baud.\n",
594
                          port->fifo ? "cannot" : "needs a 16550 to",
595
                          port->baudrate);
596
    }
597
}
598
 
599
 
600
 
601
static int
602
dos_noop (struct serial *scb)
603
{
604
  return 0;
605
}
606
 
607
static void
608
dos_raw (struct serial *scb)
609
{
610
  /* Always in raw mode */
611
}
612
 
613
static int
614
dos_readchar (struct serial *scb, int timeout)
615
{
616
  struct dos_ttystate *port = &ports[scb->fd];
617
  long then;
618
  int c;
619
 
620
  then = rawclock () + (timeout * RAWHZ);
621
  while ((c = dos_getc (port)) < 0)
622
    {
623
      if (timeout >= 0 && (rawclock () - then) >= 0)
624
        return SERIAL_TIMEOUT;
625
    }
626
 
627
  return c;
628
}
629
 
630
 
631
static serial_ttystate
632
dos_get_tty_state (struct serial *scb)
633
{
634
  struct dos_ttystate *port = &ports[scb->fd];
635
  struct dos_ttystate *state;
636
 
637
  /* Are they asking about a port we opened?  */
638
  if (port->refcnt <= 0)
639
    {
640
      /* We've never heard about this port.  We should fail this call,
641
         unless they are asking about one of the 3 standard handles,
642
         in which case we pretend the handle was open by us if it is
643
         connected to a terminal device.  This is beacuse Unix
644
         terminals use the serial interface, so GDB expects the
645
         standard handles to go through here.  */
646
      if (scb->fd >= 3 || !isatty (scb->fd))
647
        return NULL;
648
    }
649
 
650
  state = (struct dos_ttystate *) xmalloc (sizeof *state);
651
  *state = *port;
652
  return (serial_ttystate) state;
653
}
654
 
655
static int
656
dos_set_tty_state (struct serial *scb, serial_ttystate ttystate)
657
{
658
  struct dos_ttystate *state;
659
 
660
  state = (struct dos_ttystate *) ttystate;
661
  dos_setbaudrate (scb, state->baudrate);
662
  return 0;
663
}
664
 
665
static int
666
dos_noflush_set_tty_state (struct serial *scb, serial_ttystate new_ttystate,
667
                           serial_ttystate old_ttystate)
668
{
669
  struct dos_ttystate *state;
670
 
671
  state = (struct dos_ttystate *) new_ttystate;
672
  dos_setbaudrate (scb, state->baudrate);
673
  return 0;
674
}
675
 
676
static int
677
dos_flush_input (struct serial *scb)
678
{
679
  struct dos_ttystate *port = &ports[scb->fd];
680
  disable ();
681
  port->first = port->count = 0;
682
  if (port->fifo)
683
    outb (port, com_fifo, FIFO_ENABLE | FIFO_RCV_RST | FIFO_TRIGGER);
684
  enable ();
685
  return 0;
686
}
687
 
688
static void
689
dos_print_tty_state (struct serial *scb, serial_ttystate ttystate,
690
                     struct ui_file *stream)
691
{
692
  /* Nothing to print */
693
  return;
694
}
695
 
696
static int
697
dos_baudconv (int rate)
698
{
699
  long x, err;
700
 
701
  if (rate <= 0)
702
    return -1;
703
 
704
#define divrnd(n, q)    (((n) * 2 / (q) + 1) / 2) /* divide and round off */
705
  x = divrnd (COMTICK, rate);
706
  if (x <= 0)
707
    return -1;
708
 
709
  err = divrnd (1000 * COMTICK, x * rate) - 1000;
710
  if (err < 0)
711
    err = -err;
712
  if (err > SPEED_TOLERANCE)
713
    return -1;
714
#undef divrnd
715
  return x;
716
}
717
 
718
 
719
static int
720
dos_setbaudrate (struct serial *scb, int rate)
721
{
722
  struct dos_ttystate *port = &ports[scb->fd];
723
 
724
  if (port->baudrate != rate)
725
    {
726
      int x;
727
      unsigned char cfcr;
728
 
729
      x = dos_baudconv (rate);
730
      if (x <= 0)
731
        {
732
          fprintf_unfiltered (gdb_stderr, "%d: impossible baudrate\n", rate);
733
          errno = EINVAL;
734
          return -1;
735
        }
736
 
737
      disable ();
738
      cfcr = inb (port, com_cfcr);
739
 
740
      outb (port, com_cfcr, CFCR_DLAB);
741
      outb (port, com_dlbl, x & 0xff);
742
      outb (port, com_dlbh, x >> 8);
743
      outb (port, com_cfcr, cfcr);
744
      port->baudrate = rate;
745
      enable ();
746
    }
747
 
748
  return 0;
749
}
750
 
751
static int
752
dos_setstopbits (struct serial *scb, int num)
753
{
754
  struct dos_ttystate *port = &ports[scb->fd];
755
  unsigned char cfcr;
756
 
757
  disable ();
758
  cfcr = inb (port, com_cfcr);
759
 
760
  switch (num)
761
    {
762
    case SERIAL_1_STOPBITS:
763
      outb (port, com_cfcr, cfcr & ~CFCR_STOPB);
764
      break;
765
    case SERIAL_1_AND_A_HALF_STOPBITS:
766
    case SERIAL_2_STOPBITS:
767
      outb (port, com_cfcr, cfcr | CFCR_STOPB);
768
      break;
769
    default:
770
      enable ();
771
      return 1;
772
    }
773
  enable ();
774
 
775
  return 0;
776
}
777
 
778
static int
779
dos_write (struct serial *scb, const char *str, int len)
780
{
781
  volatile struct dos_ttystate *port = &ports[scb->fd];
782
  int fifosize = port->fifo ? 16 : 1;
783
  long then;
784
  int cnt;
785
 
786
  while (len > 0)
787
    {
788
      /* send the data, fifosize bytes at a time */
789
      cnt = fifosize > len ? len : fifosize;
790
      port->txbusy = 1;
791
      /* Francisco Pastor <fpastor.etra-id@etra.es> says OUTSB messes
792
         up the communications with UARTs with FIFOs.  */
793
#ifdef UART_FIFO_WORKS
794
      outportsb (port->base + com_data, str, cnt);
795
      str += cnt;
796
      len -= cnt;
797
#else
798
      for ( ; cnt > 0; cnt--, len--)
799
        outportb (port->base + com_data, *str++);
800
#endif
801
#ifdef DOS_STATS
802
      cnts[CNT_TX] += cnt;
803
#endif
804
      /* wait for transmission to complete (max 1 sec) */
805
      then = rawclock () + RAWHZ;
806
      while (port->txbusy)
807
        {
808
          if ((rawclock () - then) >= 0)
809
            {
810
              errno = EIO;
811
              return SERIAL_ERROR;
812
            }
813
        }
814
    }
815
  return 0;
816
}
817
 
818
 
819
static int
820
dos_sendbreak (struct serial *scb)
821
{
822
  volatile struct dos_ttystate *port = &ports[scb->fd];
823
  unsigned char cfcr;
824
  long then;
825
 
826
  cfcr = inb (port, com_cfcr);
827
  outb (port, com_cfcr, cfcr | CFCR_SBREAK);
828
 
829
  /* 0.25 sec delay */
830
  then = rawclock () + RAWHZ / 4;
831
  while ((rawclock () - then) < 0)
832
    continue;
833
 
834
  outb (port, com_cfcr, cfcr);
835
  return 0;
836
}
837
 
838
 
839
static struct serial_ops dos_ops =
840
{
841
  "hardwire",
842
  0,
843
  dos_open,
844
  dos_close,
845
  dos_readchar,
846
  dos_write,
847
  dos_noop,                     /* flush output */
848
  dos_flush_input,
849
  dos_sendbreak,
850
  dos_raw,
851
  dos_get_tty_state,
852
  dos_set_tty_state,
853
  dos_print_tty_state,
854
  dos_noflush_set_tty_state,
855
  dos_setbaudrate,
856
  dos_setstopbits,
857
  dos_noop,                     /* wait for output to drain */
858
  (void (*)(struct serial *, int))NULL  /* change into async mode */
859
};
860
 
861
 
862
static void
863
dos_info (char *arg, int from_tty)
864
{
865
  struct dos_ttystate *port;
866
#ifdef DOS_STATS
867
  int i;
868
#endif
869
 
870
  for (port = ports; port < &ports[4]; port++)
871
    {
872
      if (port->baudrate == 0)
873
        continue;
874
      printf_filtered ("Port:\tCOM%ld (%sactive)\n", (long)(port - ports) + 1,
875
                       port->intrupt ? "" : "not ");
876
      printf_filtered ("Addr:\t0x%03x (irq %d)\n", port->base, port->irq);
877
      printf_filtered ("16550:\t%s\n", port->fifo ? "yes" : "no");
878
      printf_filtered ("Speed:\t%d baud\n", port->baudrate);
879
      printf_filtered ("Errs:\tframing %d parity %d overflow %d\n\n",
880
                       port->ferr, port->perr, port->oflo);
881
    }
882
 
883
#ifdef DOS_STATS
884
  printf_filtered ("\nTotal interrupts: %d\n", intrcnt);
885
  for (i = 0; i < NCNT; i++)
886
    if (cnts[i])
887
      printf_filtered ("%s:\t%d\n", cntnames[i], cnts[i]);
888
#endif
889
}
890
 
891
 
892
void
893
_initialize_ser_dos (void)
894
{
895
  serial_add_interface (&dos_ops);
896
 
897
  /* Save original interrupt mask register. */
898
  icu_oldmask = inportb (ICU_MASK);
899
 
900
  /* Mark fixed motherboard irqs as inuse. */
901
  intrupts[0].inuse =            /* timer tick */
902
    intrupts[1].inuse =         /* keyboard */
903
    intrupts[2].inuse = 1;      /* slave icu */
904
 
905
  add_setshow_zinteger_cmd ("com1base", class_obscure, &ports[0].base, _("\
906
Set COM1 base i/o port address."), _("\
907
Show COM1 base i/o port address."), NULL,
908
                            NULL,
909
                            NULL, /* FIXME: i18n: */
910
                            &setlist, &showlist);
911
 
912
  add_setshow_zinteger_cmd ("com1irq", class_obscure, &ports[0].irq, _("\
913
Set COM1 interrupt request."), _("\
914
Show COM1 interrupt request."), NULL,
915
                            NULL,
916
                            NULL, /* FIXME: i18n: */
917
                            &setlist, &showlist);
918
 
919
  add_setshow_zinteger_cmd ("com2base", class_obscure, &ports[1].base, _("\
920
Set COM2 base i/o port address."), _("\
921
Show COM2 base i/o port address."), NULL,
922
                            NULL,
923
                            NULL, /* FIXME: i18n: */
924
                            &setlist, &showlist);
925
 
926
  add_setshow_zinteger_cmd ("com2irq", class_obscure, &ports[1].irq, _("\
927
Set COM2 interrupt request."), _("\
928
Show COM2 interrupt request."), NULL,
929
                            NULL,
930
                            NULL, /* FIXME: i18n: */
931
                            &setlist, &showlist);
932
 
933
  add_setshow_zinteger_cmd ("com3base", class_obscure, &ports[2].base, _("\
934
Set COM3 base i/o port address."), _("\
935
Show COM3 base i/o port address."), NULL,
936
                            NULL,
937
                            NULL, /* FIXME: i18n: */
938
                            &setlist, &showlist);
939
 
940
  add_setshow_zinteger_cmd ("com3irq", class_obscure, &ports[2].irq, _("\
941
Set COM3 interrupt request."), _("\
942
Show COM3 interrupt request."), NULL,
943
                            NULL,
944
                            NULL, /* FIXME: i18n: */
945
                            &setlist, &showlist);
946
 
947
  add_setshow_zinteger_cmd ("com4base", class_obscure, &ports[3].base, _("\
948
Set COM4 base i/o port address."), _("\
949
Show COM4 base i/o port address."), NULL,
950
                            NULL,
951
                            NULL, /* FIXME: i18n: */
952
                            &setlist, &showlist);
953
 
954
  add_setshow_zinteger_cmd ("com4irq", class_obscure, &ports[3].irq, _("\
955
Set COM4 interrupt request."), _("\
956
Show COM4 interrupt request."), NULL,
957
                            NULL,
958
                            NULL, /* FIXME: i18n: */
959
                            &setlist, &showlist);
960
 
961
  add_info ("serial", dos_info,
962
            _("Print DOS serial port status."));
963
}

powered by: WebSVN 2.1.0

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