gdb/ser-go32.c

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