gdb/ser-go32.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Remote serial interface for local (hardwired) serial ports for GO32.
  2.    Copyright (C) 1992-2015 Free Software Foundation, Inc.

  4.    Contributed by Nigel Stephens, Algorithmics Ltd. (nigel@algor.co.uk).

  6.    This version uses DPMI interrupts to handle buffered i/o
  7.    without the separate "asynctsr" program.

  9.    This file is part of GDB.

  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.

  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.

  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/>.  */

  24. #include "defs.h"
  25. #include "gdbcmd.h"
  26. #include "serial.h"
  27. /*
  28. * NS16550 UART registers
  29. */

  31. ‌#define COM1ADDR        0x3f8
  32. ‌#define COM2ADDR        0x2f8
  33. ‌#define COM3ADDR        0x3e8
  34. ‌#define COM4ADDR        0x3e0

  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) */

  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% */

  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 */

  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 */


  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 */

  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 */

  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 */

  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

  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

  126. #include <time.h>
  127. #include <dos.h>
  128. #include <go32.h>
  129. #include <dpmi.h>
  130. ‌typedef unsigned long u_long;

  132. /* 16550 rx fifo trigger point */
  133. ‌#define FIFO_TRIGGER        FIFO_TRIGGER_4

  135. /* input buffer size */
  136. ‌#define CBSIZE        4096

  138. ‌#define RAWHZ        18

  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

  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. };

  160. ‌#define COUNT(x) cnts[x]++
  161. #else
  162. ‌#define COUNT(x)
  163. #endif

  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)

  170. /* Original interrupt controller mask register.  */
  171. ‌unsigned char icu_oldmask;

  173. /* Maximum of 8 interrupts (we don't handle the slave icu yet).  */
  174. ‌#define NINTR        8

  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];


  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. };

  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);

  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");


  242. static int
  243. ‌dos_getc (volatile struct dos_ttystate *port)
  244. {
  245.   int c;

  247.   if (port->count == 0)
  248.     return -1;

  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. }


  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. }



  271. static void
  272. ‌dos_comisr (int irq)
  273. {
  274.   struct dos_ttystate *port;
  275.   unsigned char iir, lsr, c;

  277.   disable ();                        /* Paranoia */
  278.   outportb (ICU_OCW2, 0x20);        /* End-Of-Interrupt */
  279. #ifdef DOS_STATS
  280.   ++intrcnt;
  281. #endif

  283.   port = intrupts[irq].port;
  284.   if (!port)
  285.     {
  286.       COUNT (CNT_STRAY);
  287.       return;                        /* not open */
  288.     }

  290.   while (1)
  291.     {
  292.       iir = inb (port, com_iir) & IIR_IMASK;
  293.       switch (iir)
  294.         {

  296.         case IIR_RLS:
  297.           lsr = inb (port, com_lsr);
  298.           goto rx;

  300.         case IIR_RXTOUT:
  301.         case IIR_RXRDY:
  302.           lsr = 0;

  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.                 }

  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;

  330.         case IIR_MLSC:
  331.           /* could be used to flowcontrol Tx */
  332.           port->msr = inb (port, com_msr);
  333.           break;

  335.         case IIR_TXRDY:
  336.           port->txbusy = 0;
  337.           break;

  339.         case IIR_NOPEND:
  340.           /* No more pending interrupts, all done.  */
  341.           return;

  343.         default:
  344.           /* Unexpected interrupt, ignore.  */
  345.           break;
  346.         }
  347.       COUNT (iir);
  348.     }
  349. }

  351. ‌#define ISRNAME(x) dos_comisr##x
  352. ‌#define ISR(x) static void ISRNAME(x)(void) {dos_comisr(x);}

  354. ISR (0) ISR (1) ISR (2) ISR (3) /* OK */
  355. ISR (4) ISR (5) ISR (6) ISR (7) /* OK */

  357. ‌typedef void (*isr_t) (void);

  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.   };



  367. static struct intrupt *
  368. ‌dos_hookirq (unsigned int irq)
  369. {
  370.   struct intrupt *intr;
  371.   unsigned int vec;
  372.   isr_t isr;

  374.   if (irq >= NINTR)
  375.     return 0;

  377.   intr = &intrupts[irq];
  378.   if (intr->inuse)
  379.     return 0;

  381.   vec = 0x08 + irq;
  382.   isr = isrs[irq];

  384.   /* Setup real mode handler.  */
  385.   _go32_dpmi_get_real_mode_interrupt_vector (vec, &intr->old_rmhandler);

  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.     }

  395.   if (_go32_dpmi_set_real_mode_interrupt_vector (vec, &intr->new_rmhandler))
  396.     {
  397.       return 0;
  398.     }

  400.   /* Setup protected mode handler.  */
  401.   _go32_dpmi_get_protected_mode_interrupt_vector (vec, &intr->old_pmhandler);

  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);

  407.   if (_go32_dpmi_set_protected_mode_interrupt_vector (vec,
  408.                                                       &intr->new_pmhandler))
  409.     {
  410.       return 0;
  411.     }

  413.   /* Setup interrupt controller mask.  */
  414.   disable ();
  415.   outportb (ICU_MASK, inportb (ICU_MASK) & ~(1 << irq));
  416.   enable ();

  418.   intr->inuse = 1;
  419.   return intr;
  420. }


  423. static void
  424. ‌dos_unhookirq (struct intrupt *intr)
  425. {
  426.   unsigned int irq, vec;
  427.   unsigned char mask;

  429.   irq = intr - intrupts;
  430.   vec = 0x08 + irq;

  432.   /* Restore old interrupt mask bit.  */
  433.   mask = 1 << irq;
  434.   disable ();
  435.   outportb (ICU_MASK, inportb (ICU_MASK) | (mask & icu_oldmask));
  436.   enable ();

  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);

  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. }



  450. static int
  451. ‌dos_open (struct serial *scb, const char *name)
  452. {
  453.   struct dos_ttystate *port;
  454.   int fd, i;

  456.   if (strncasecmp (name, "/dev/", 5) == 0)
  457.     name += 5;
  458.   else if (strncasecmp (name, "\\dev\\", 5) == 0)
  459.     name += 5;

  461.   if (strlen (name) != 4 || strncasecmp (name, "com", 3) != 0)
  462.     {
  463.       errno = ENOENT;
  464.       return -1;
  465.     }

  467.   if (name[3] < '1' || name[3] > '4')
  468.     {
  469.       errno = ENOENT;
  470.       return -1;
  471.     }

  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.     }

  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;

  498. ok:
  499.   /* Disable all interrupts in chip.  */
  500.   outb (port, com_ier, 0);

  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);

  508.   /* clear pending status reports.  */
  509.   (void) inb (port, com_lsr);
  510.   (void) inb (port, com_msr);

  512.   /* Enable external interrupt gate (to avoid floating IRQ).  */
  513.   outb (port, com_mcr, MCR_IENABLE);

  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.     }

  525.   disable ();

  527.   /* record port */
  528.   port->intrupt->port = port;
  529.   scb->fd = fd;

  531.   /* Clear rx buffer, tx busy flag and overflow count.  */
  532.   port->first = port->count = 0;
  533.   port->txbusy = 0;
  534.   port->oflo = 0;

  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);

  543.   /* Enable all interrupts.  */
  544.   outb (port, com_ier, IER_ETXRDY | IER_ERXRDY | IER_ERLS | IER_EMSC);

  546.   /* Enable DTR & RTS.  */
  547.   outb (port, com_mcr, MCR_DTR | MCR_RTS | MCR_IENABLE);

  549.   enable ();

  551.   return 0;
  552. }


  555. static void
  556. ‌dos_close (struct serial *scb)
  557. {
  558.   struct dos_ttystate *port;
  559.   struct intrupt *intrupt;

  561.   if (!scb)
  562.     return;

  564.   port = &ports[scb->fd];

  566.   if (port->refcnt-- > 1)
  567.     return;

  569.   if (!(intrupt = port->intrupt))
  570.     return;

  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 ();

  580.   /* Unhook handler, and disable interrupt gate.  */
  581.   dos_unhookirq (intrupt);
  582.   outb (port, com_mcr, 0);

  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. }



  597. static int
  598. ‌dos_noop (struct serial *scb)
  599. {
  600.   return 0;
  601. }

  603. static void
  604. ‌dos_raw (struct serial *scb)
  605. {
  606.   /* Always in raw mode.  */
  607. }

  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;

  616.   then = rawclock () + (timeout * RAWHZ);
  617.   while ((c = dos_getc (port)) < 0)
  618.     {
  619.       if (timeout >= 0 && (rawclock () - then) >= 0)
  620.         return SERIAL_TIMEOUT;
  621.     }

  623.   return c;
  624. }


  627. static serial_ttystate
  628. ‌dos_get_tty_state (struct serial *scb)
  629. {
  630.   struct dos_ttystate *port = &ports[scb->fd];
  631.   struct dos_ttystate *state;

  633.   /* Are they asking about a port we opened?  */
  634.   if (port->refcnt <= 0)
  635.     {
  636.       /* We've never heard about this port.  We should fail this call,
  637.          unless they are asking about one of the 3 standard handles,
  638.          in which case we pretend the handle was open by us if it is
  639.          connected to a terminal device.  This is beacuse Unix
  640.          terminals use the serial interface, so GDB expects the
  641.          standard handles to go through here.  */
  642.       if (scb->fd >= 3 || !isatty (scb->fd))
  643.         return NULL;
  644.     }

  646.   state = (struct dos_ttystate *) xmalloc (sizeof *state);
  647.   *state = *port;
  648.   return (serial_ttystate) state;
  649. }

  651. static serial_ttystate
  652. ‌dos_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
  653. {
  654.   struct dos_ttystate *state;

  656.   state = (struct dos_ttystate *) xmalloc (sizeof *state);
  657.   *state = *(struct dos_ttystate *) ttystate;

  659.   return (serial_ttystate) state;
  660. }

  662. static int
  663. ‌dos_set_tty_state (struct serial *scb, serial_ttystate ttystate)
  664. {
  665.   struct dos_ttystate *state;

  667.   state = (struct dos_ttystate *) ttystate;
  668.   dos_setbaudrate (scb, state->baudrate);
  669.   return 0;
  670. }

  672. static int
  673. ‌dos_noflush_set_tty_state (struct serial *scb, serial_ttystate new_ttystate,
  674.                            serial_ttystate old_ttystate)
  675. {
  676.   struct dos_ttystate *state;

  678.   state = (struct dos_ttystate *) new_ttystate;
  679.   dos_setbaudrate (scb, state->baudrate);
  680.   return 0;
  681. }

  683. static int
  684. ‌dos_flush_input (struct serial *scb)
  685. {
  686.   struct dos_ttystate *port = &ports[scb->fd];

  688.   disable ();
  689.   port->first = port->count = 0;
  690.   if (port->fifo)
  691.     outb (port, com_fifo, FIFO_ENABLE | FIFO_RCV_RST | FIFO_TRIGGER);
  692.   enable ();
  693.   return 0;
  694. }

  696. static void
  697. ‌dos_print_tty_state (struct serial *scb, serial_ttystate ttystate,
  698.                      struct ui_file *stream)
  699. {
  700.   /* Nothing to print.  */
  701.   return;
  702. }

  704. static int
  705. ‌dos_baudconv (int rate)
  706. {
  707.   long x, err;

  709.   if (rate <= 0)
  710.     return -1;

  712. ‌#define divrnd(n, q)        (((n) * 2 / (q) + 1) / 2) /* Divide and round off.  */
  713.   x = divrnd (COMTICK, rate);
  714.   if (x <= 0)
  715.     return -1;

  717.   err = divrnd (1000 * COMTICK, x * rate) - 1000;
  718.   if (err < 0)
  719.     err = -err;
  720.   if (err > SPEED_TOLERANCE)
  721.     return -1;
  722. ‌#undef divrnd
  723.   return x;
  724. }


  727. static int
  728. ‌dos_setbaudrate (struct serial *scb, int rate)
  729. {
  730.   struct dos_ttystate *port = &ports[scb->fd];

  732.   if (port->baudrate != rate)
  733.     {
  734.       int x;
  735.       unsigned char cfcr;

  737.       x = dos_baudconv (rate);
  738.       if (x <= 0)
  739.         {
  740.           fprintf_unfiltered (gdb_stderr, "%d: impossible baudrate\n", rate);
  741.           errno = EINVAL;
  742.           return -1;
  743.         }

  745.       disable ();
  746.       cfcr = inb (port, com_cfcr);

  748.       outb (port, com_cfcr, CFCR_DLAB);
  749.       outb (port, com_dlbl, x & 0xff);
  750.       outb (port, com_dlbh, x >> 8);
  751.       outb (port, com_cfcr, cfcr);
  752.       port->baudrate = rate;
  753.       enable ();
  754.     }

  756.   return 0;
  757. }

  759. static int
  760. ‌dos_setstopbits (struct serial *scb, int num)
  761. {
  762.   struct dos_ttystate *port = &ports[scb->fd];
  763.   unsigned char cfcr;

  765.   disable ();
  766.   cfcr = inb (port, com_cfcr);

  768.   switch (num)
  769.     {
  770.     case SERIAL_1_STOPBITS:
  771.       outb (port, com_cfcr, cfcr & ~CFCR_STOPB);
  772.       break;
  773.     case SERIAL_1_AND_A_HALF_STOPBITS:
  774.     case SERIAL_2_STOPBITS:
  775.       outb (port, com_cfcr, cfcr | CFCR_STOPB);
  776.       break;
  777.     default:
  778.       enable ();
  779.       return 1;
  780.     }
  781.   enable ();

  783.   return 0;
  784. }

  786. static int
  787. ‌dos_write (struct serial *scb, const void *buf, size_t count)
  788. {
  789.   volatile struct dos_ttystate *port = &ports[scb->fd];
  790.   size_t fifosize = port->fifo ? 16 : 1;
  791.   long then;
  792.   size_t cnt;
  793.   const char *str = buf;

  795.   while (count > 0)
  796.     {
  797.       /* Send the data, fifosize bytes at a time.  */
  798.       cnt = fifosize > count ? count : fifosize;
  799.       port->txbusy = 1;
  800.       /* Francisco Pastor <fpastor.etra-id@etra.es> says OUTSB messes
  801.          up the communications with UARTs with FIFOs.  */
  802. #ifdef UART_FIFO_WORKS
  803.       outportsb (port->base + com_data, str, cnt);
  804.       str += cnt;
  805.       count -= cnt;
  806. #else
  807.       for ( ; cnt > 0; cnt--, count--)
  808.         outportb (port->base + com_data, *str++);
  809. #endif
  810. #ifdef DOS_STATS
  811.       cnts[CNT_TX] += cnt;
  812. #endif
  813.       /* Wait for transmission to complete (max 1 sec).  */
  814.       then = rawclock () + RAWHZ;
  815.       while (port->txbusy)
  816.         {
  817.           if ((rawclock () - then) >= 0)
  818.             {
  819.               errno = EIO;
  820.               return SERIAL_ERROR;
  821.             }
  822.         }
  823.     }
  824.   return 0;
  825. }


  828. static int
  829. ‌dos_sendbreak (struct serial *scb)
  830. {
  831.   volatile struct dos_ttystate *port = &ports[scb->fd];
  832.   unsigned char cfcr;
  833.   long then;

  835.   cfcr = inb (port, com_cfcr);
  836.   outb (port, com_cfcr, cfcr | CFCR_SBREAK);

  838.   /* 0.25 sec delay */
  839.   then = rawclock () + RAWHZ / 4;
  840.   while ((rawclock () - then) < 0)
  841.     continue;

  843.   outb (port, com_cfcr, cfcr);
  844.   return 0;
  845. }


  848. ‌static const struct serial_ops dos_ops =
  849. {
  850.   "hardwire",
  851.   dos_open,
  852.   dos_close,
  853.   NULL,                                /* fdopen, not implemented */
  854.   dos_readchar,
  855.   dos_write,
  856.   dos_noop,                        /* flush output */
  857.   dos_flush_input,
  858.   dos_sendbreak,
  859.   dos_raw,
  860.   dos_get_tty_state,
  861.   dos_copy_tty_state,
  862.   dos_set_tty_state,
  863.   dos_print_tty_state,
  864.   dos_noflush_set_tty_state,
  865.   dos_setbaudrate,
  866.   dos_setstopbits,
  867.   dos_noop,                        /* Wait for output to drain.  */
  868.   (void (*)(struct serial *, int))NULL        /* Change into async mode.  */
  869. };

  871. int
  872. ‌gdb_pipe (int pdes[2])
  873. {
  874.   /* No support for pipes.  */
  875.   errno = ENOSYS;
  876.   return -1;
  877. }

  879. static void
  880. ‌dos_info (char *arg, int from_tty)
  881. {
  882.   struct dos_ttystate *port;
  883. #ifdef DOS_STATS
  884.   int i;
  885. #endif

  887.   for (port = ports; port < &ports[4]; port++)
  888.     {
  889.       if (port->baudrate == 0)
  890.         continue;
  891.       printf_filtered ("Port:\tCOM%ld (%sactive)\n", (long)(port - ports) + 1,
  892.                        port->intrupt ? "" : "not ");
  893.       printf_filtered ("Addr:\t0x%03x (irq %d)\n", port->base, port->irq);
  894.       printf_filtered ("16550:\t%s\n", port->fifo ? "yes" : "no");
  895.       printf_filtered ("Speed:\t%d baud\n", port->baudrate);
  896.       printf_filtered ("Errs:\tframing %d parity %d overflow %d\n\n",
  897.                        port->ferr, port->perr, port->oflo);
  898.     }

  900. #ifdef DOS_STATS
  901.   printf_filtered ("\nTotal interrupts: %d\n", intrcnt);
  902.   for (i = 0; i < NCNT; i++)
  903.     if (cnts[i])
  904.       printf_filtered ("%s:\t%lu\n", cntnames[i], (unsigned long) cnts[i]);
  905. #endif
  906. }

  908. /* -Wmissing-prototypes */
  909. extern initialize_file_ftype _initialize_ser_dos;

  911. void
  912. ‌_initialize_ser_dos (void)
  913. {
  914.   serial_add_interface (&dos_ops);

  916.   /* Save original interrupt mask register.  */
  917.   icu_oldmask = inportb (ICU_MASK);

  919.   /* Mark fixed motherboard irqs as inuse.  */
  920.   intrupts[0].inuse =                /* timer tick */
  921.     intrupts[1].inuse =                /* keyboard */
  922.     intrupts[2].inuse = 1;        /* slave icu */

  924.   add_setshow_zinteger_cmd ("com1base", class_obscure, &ports[0].base, _("\
  925. Set COM1 base i/o port address."), _("\
  926. Show COM1 base i/o port address."), NULL,
  927.                             NULL,
  928.                             NULL, /* FIXME: i18n: */
  929.                             &setlist, &showlist);

  931.   add_setshow_zinteger_cmd ("com1irq", class_obscure, &ports[0].irq, _("\
  932. Set COM1 interrupt request."), _("\
  933. Show COM1 interrupt request."), NULL,
  934.                             NULL,
  935.                             NULL, /* FIXME: i18n: */
  936.                             &setlist, &showlist);

  938.   add_setshow_zinteger_cmd ("com2base", class_obscure, &ports[1].base, _("\
  939. Set COM2 base i/o port address."), _("\
  940. Show COM2 base i/o port address."), NULL,
  941.                             NULL,
  942.                             NULL, /* FIXME: i18n: */
  943.                             &setlist, &showlist);

  945.   add_setshow_zinteger_cmd ("com2irq", class_obscure, &ports[1].irq, _("\
  946. Set COM2 interrupt request."), _("\
  947. Show COM2 interrupt request."), NULL,
  948.                             NULL,
  949.                             NULL, /* FIXME: i18n: */
  950.                             &setlist, &showlist);

  952.   add_setshow_zinteger_cmd ("com3base", class_obscure, &ports[2].base, _("\
  953. Set COM3 base i/o port address."), _("\
  954. Show COM3 base i/o port address."), NULL,
  955.                             NULL,
  956.                             NULL, /* FIXME: i18n: */
  957.                             &setlist, &showlist);

  959.   add_setshow_zinteger_cmd ("com3irq", class_obscure, &ports[2].irq, _("\
  960. Set COM3 interrupt request."), _("\
  961. Show COM3 interrupt request."), NULL,
  962.                             NULL,
  963.                             NULL, /* FIXME: i18n: */
  964.                             &setlist, &showlist);

  966.   add_setshow_zinteger_cmd ("com4base", class_obscure, &ports[3].base, _("\
  967. Set COM4 base i/o port address."), _("\
  968. Show COM4 base i/o port address."), NULL,
  969.                             NULL,
  970.                             NULL, /* FIXME: i18n: */
  971.                             &setlist, &showlist);

  973.   add_setshow_zinteger_cmd ("com4irq", class_obscure, &ports[3].irq, _("\
  974. Set COM4 interrupt request."), _("\
  975. Show COM4 interrupt request."), NULL,
  976.                             NULL,
  977.                             NULL, /* FIXME: i18n: */
  978.                             &setlist, &showlist);

  980.   add_info ("serial", dos_info,
  981.             _("Print DOS serial port status."));
  982. }