1 /* Remote serial interface for local (hardwired) serial ports for GO32. 2 Copyright (C) 1992-2015 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 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 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 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 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 if (timeout >= 0 && (rawclock () - then) >= 0) 620 return SERIAL_TIMEOUT; 621 } 622 623 return c; 624 } 625 626 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; 632 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 } 645 646 state = (struct dos_ttystate *) xmalloc (sizeof *state); 647 *state = *port; 648 return (serial_ttystate) state; 649 } 650 651 static serial_ttystate 652 dos_copy_tty_state (struct serial *scb, serial_ttystate ttystate) 653 { 654 struct dos_ttystate *state; 655 656 state = (struct dos_ttystate *) xmalloc (sizeof *state); 657 *state = *(struct dos_ttystate *) ttystate; 658 659 return (serial_ttystate) state; 660 } 661 662 static int 663 dos_set_tty_state (struct serial *scb, serial_ttystate ttystate) 664 { 665 struct dos_ttystate *state; 666 667 state = (struct dos_ttystate *) ttystate; 668 dos_setbaudrate (scb, state->baudrate); 669 return 0; 670 } 671 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; 677 678 state = (struct dos_ttystate *) new_ttystate; 679 dos_setbaudrate (scb, state->baudrate); 680 return 0; 681 } 682 683 static int 684 dos_flush_input (struct serial *scb) 685 { 686 struct dos_ttystate *port = &ports[scb->fd]; 687 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 } 695 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 } 703 704 static int 705 dos_baudconv (int rate) 706 { 707 long x, err; 708 709 if (rate <= 0) 710 return -1; 711 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; 716 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 } 725 726 727 static int 728 dos_setbaudrate (struct serial *scb, int rate) 729 { 730 struct dos_ttystate *port = &ports[scb->fd]; 731 732 if (port->baudrate != rate) 733 { 734 int x; 735 unsigned char cfcr; 736 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 } 744 745 disable (); 746 cfcr = inb (port, com_cfcr); 747 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 } 755 756 return 0; 757 } 758 759 static int 760 dos_setstopbits (struct serial *scb, int num) 761 { 762 struct dos_ttystate *port = &ports[scb->fd]; 763 unsigned char cfcr; 764 765 disable (); 766 cfcr = inb (port, com_cfcr); 767 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 (); 782 783 return 0; 784 } 785 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; 794 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 } 826 827 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; 834 835 cfcr = inb (port, com_cfcr); 836 outb (port, com_cfcr, cfcr | CFCR_SBREAK); 837 838 /* 0.25 sec delay */ 839 then = rawclock () + RAWHZ / 4; 840 while ((rawclock () - then) < 0) 841 continue; 842 843 outb (port, com_cfcr, cfcr); 844 return 0; 845 } 846 847 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 }; 870 871 int 872 gdb_pipe (int pdes[2]) 873 { 874 /* No support for pipes. */ 875 errno = ENOSYS; 876 return -1; 877 } 878 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 886 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 } 899 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 } 907 908 /* -Wmissing-prototypes */ 909 extern initialize_file_ftype _initialize_ser_dos; 910 911 void 912 _initialize_ser_dos (void) 913 { 914 serial_add_interface (&dos_ops); 915 916 /* Save original interrupt mask register. */ 917 icu_oldmask = inportb (ICU_MASK); 918 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 */ 923 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); 930 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); 937 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); 944 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); 951 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); 958 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); 965 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); 972 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); 979 980 add_info ("serial", dos_info, 981 _("Print DOS serial port status.")); 982 } 983