com.c revision 1.22
1 /*- 2 * Copyright (c) 1993, 1994 Charles Hannum. 3 * Copyright (c) 1991 The Regents of the University of California. 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 3. All advertising materials mentioning features or use of this software 15 * must display the following acknowledgement: 16 * This product includes software developed by the University of 17 * California, Berkeley and its contributors. 18 * 4. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * from: @(#)com.c 7.5 (Berkeley) 5/16/91 35 * $Id: com.c,v 1.22 1994/03/12 07:25:16 cgd Exp $ 36 */ 37 38 /* 39 * COM driver, based on HP dca driver 40 * uses National Semiconductor NS16450/NS16550AF UART 41 */ 42 #include "com.h" 43 44 #include <sys/param.h> 45 #include <sys/systm.h> 46 #include <sys/ioctl.h> 47 #include <sys/select.h> 48 #include <sys/tty.h> 49 #include <sys/proc.h> 50 #include <sys/user.h> 51 #include <sys/conf.h> 52 #include <sys/file.h> 53 #include <sys/uio.h> 54 #include <sys/kernel.h> 55 #include <sys/syslog.h> 56 #include <sys/types.h> 57 #include <sys/device.h> 58 59 #include <machine/cpu.h> 60 #include <machine/pio.h> 61 62 #include <i386/isa/isa_device.h> 63 #include <i386/isa/comreg.h> 64 #include <i386/isa/ic/ns16550.h> 65 66 struct com_softc { 67 struct device sc_dev; 68 69 u_short sc_iobase; 70 u_char sc_hwflags; 71 #define COM_HW_MULTI 0x01 72 #define COM_HW_CONFIGBITS COM_HW_MULTI 73 #define COM_HW_FIFO 0x02 74 #define COM_HW_CONSOLE 0x40 75 u_char sc_swflags; 76 #define COM_SW_SOFTCAR 0x01 77 #define COM_SW_CLOCAL 0x02 78 #define COM_SW_CRTSCTS 0x04 79 u_char sc_msr, sc_mcr; 80 } com_softc[NCOM]; 81 /* XXXX should be in com_softc, but not ready for that yet */ 82 struct tty *com_tty[NCOM]; 83 84 int comprobe __P((struct isa_device *)); 85 int comattach __P((struct isa_device *)); 86 int comopen __P((dev_t, int, int, struct proc *)); 87 int comclose __P((dev_t, int, int, struct proc *)); 88 int comintr __P((int)); 89 int comparam __P((struct tty *, struct termios *)); 90 void comstart __P((struct tty *)); 91 92 struct isa_driver comdriver = { 93 comprobe, comattach, "com" 94 }; 95 96 int comdefaultrate = TTYDEF_SPEED; 97 #ifdef COMCONSOLE 98 int comconsole = COMCONSOLE; 99 #else 100 int comconsole = -1; 101 #endif 102 int comconsinit; 103 int commajor; 104 105 #ifdef KGDB 106 #include <machine/remote-sl.h> 107 extern int kgdb_dev; 108 extern int kgdb_rate; 109 extern int kgdb_debug_init; 110 #endif 111 112 #define COMUNIT(x) (minor(x)) 113 114 #define bis(c, b) do { const register u_short com_ad = (c); \ 115 outb(com_ad, inb(com_ad) | (b)); } while(0) 116 #define bic(c, b) do { const register u_short com_ad = (c); \ 117 outb(com_ad, inb(com_ad) & ~(b)); } while(0) 118 119 int 120 comspeed(speed) 121 long speed; 122 { 123 #define divrnd(n, q) (((n)*2/(q)+1)/2) /* divide and round off */ 124 125 int x, err; 126 127 if (speed == 0) 128 return 0; 129 if (speed < 0) 130 return -1; 131 x = divrnd((COM_FREQ / 16), speed); 132 if (x <= 0) 133 return -1; 134 err = divrnd((COM_FREQ / 16) * 1000, speed * x) - 1000; 135 if (err < 0) 136 err = -err; 137 if (err > COM_TOLERANCE) 138 return -1; 139 return x; 140 141 #undef divrnd(n, q) 142 } 143 144 int 145 comprobe1(iobase) 146 u_short iobase; 147 { 148 149 /* force access to id reg */ 150 outb(iobase + com_cfcr, 0); 151 outb(iobase + com_iir, 0); 152 if (inb(iobase + com_iir) & 0x38) 153 return 0; 154 155 return 1; 156 } 157 158 int 159 comprobe(isa_dev) 160 struct isa_device *isa_dev; 161 { 162 struct com_softc *sc = &com_softc[isa_dev->id_unit]; 163 u_short iobase = isa_dev->id_iobase; 164 165 /* XXX HACK */ 166 sprintf(sc->sc_dev.dv_xname, "%s%d", comdriver.name, isa_dev->id_unit); 167 sc->sc_dev.dv_unit = isa_dev->id_unit; 168 169 if (!comprobe1(iobase)) 170 return 0; 171 172 return COM_NPORTS; 173 } 174 175 int 176 comattach(isa_dev) 177 struct isa_device *isa_dev; 178 { 179 int unit = isa_dev->id_unit; 180 struct com_softc *sc = &com_softc[unit]; 181 u_short iobase = isa_dev->id_iobase; 182 struct tty *tp; 183 184 if (unit == comconsole) 185 delay(1000); 186 187 sc->sc_iobase = iobase; 188 sc->sc_hwflags = 0; 189 sc->sc_swflags = 0; 190 191 printf("%s: ", sc->sc_dev.dv_xname); 192 193 /* look for a NS 16550AF UART with FIFOs */ 194 outb(iobase + com_fifo, 195 FIFO_ENABLE | FIFO_RCV_RST | FIFO_XMT_RST | FIFO_TRIGGER_14); 196 delay(100); 197 if ((inb(iobase + com_iir) & IIR_FIFO_MASK) == IIR_FIFO_MASK) 198 if ((inb(iobase + com_fifo) & FIFO_TRIGGER_14) == FIFO_TRIGGER_14) { 199 sc->sc_hwflags |= COM_HW_FIFO; 200 printf("ns16550a, working fifo\n"); 201 } else 202 printf("ns82550 or ns16550, broken fifo\n"); 203 else 204 printf("ns82450 or ns16450, no fifo\n"); 205 outb(iobase + com_fifo, 0); 206 207 /* disable interrupts */ 208 outb(iobase + com_ier, 0); 209 outb(iobase + com_mcr, 0); 210 211 #ifdef KGDB 212 if (kgdb_dev == makedev(commajor, unit)) { 213 if (comconsole == unit) 214 kgdb_dev = -1; /* can't debug over console port */ 215 else { 216 (void) cominit(unit, kgdb_rate); 217 if (kgdb_debug_init) { 218 /* 219 * Print prefix of device name, 220 * let kgdb_connect print the rest. 221 */ 222 printf("%s: ", sc->sc_dev.dv_xname); 223 kgdb_connect(1); 224 } else 225 printf("%s: kgdb enabled\n", 226 sc->sc_dev.dv_xname); 227 } 228 } 229 #endif 230 231 /* 232 * Need to reset baud rate, etc. of next print so reset comconsinit. 233 * Also make sure console is always "hardwired". 234 */ 235 if (unit == comconsole) { 236 comconsinit = 0; 237 sc->sc_hwflags |= COM_HW_CONSOLE; 238 sc->sc_swflags |= COM_SW_SOFTCAR; 239 } 240 } 241 242 int 243 comopen(dev, flag, mode, p) 244 dev_t dev; 245 int flag, mode; 246 struct proc *p; 247 { 248 int unit = COMUNIT(dev); 249 struct com_softc *sc; 250 u_short iobase; 251 struct tty *tp; 252 int s; 253 int error = 0; 254 255 if (unit > NCOM) 256 return ENXIO; 257 sc = &com_softc[unit]; 258 if (!sc->sc_iobase) 259 return ENXIO; 260 261 s = spltty(); 262 263 if (!com_tty[unit]) 264 tp = com_tty[unit] = ttymalloc(); 265 else 266 tp = com_tty[unit]; 267 268 tp->t_oproc = comstart; 269 tp->t_param = comparam; 270 tp->t_dev = dev; 271 if ((tp->t_state & TS_ISOPEN) == 0) { 272 tp->t_state |= TS_WOPEN; 273 ttychars(tp); 274 tp->t_iflag = TTYDEF_IFLAG; 275 tp->t_oflag = TTYDEF_OFLAG; 276 tp->t_cflag = TTYDEF_CFLAG; 277 if (sc->sc_swflags & COM_SW_CLOCAL) 278 tp->t_cflag |= CLOCAL; 279 if (sc->sc_swflags & COM_SW_CRTSCTS) 280 tp->t_cflag |= CRTSCTS; 281 tp->t_lflag = TTYDEF_LFLAG; 282 tp->t_ispeed = tp->t_ospeed = comdefaultrate; 283 comparam(tp, &tp->t_termios); 284 ttsetwater(tp); 285 286 iobase = sc->sc_iobase; 287 /* flush any pending I/O */ 288 if (sc->sc_hwflags & COM_HW_FIFO) 289 outb(iobase + com_fifo, 290 FIFO_ENABLE | FIFO_RCV_RST | FIFO_XMT_RST | 291 FIFO_TRIGGER_8); 292 (void) inb(iobase + com_lsr); 293 (void) inb(iobase + com_data); 294 /* you turn me on, baby */ 295 outb(iobase + com_mcr, 296 sc->sc_mcr = MCR_DTR | MCR_RTS | MCR_IENABLE); 297 outb(iobase + com_ier, 298 IER_ERXRDY | IER_ETXRDY | IER_ERLS | IER_EMSC); 299 300 sc->sc_msr = inb(iobase + com_msr); 301 if (sc->sc_swflags & COM_SW_SOFTCAR || sc->sc_msr & MSR_DCD) 302 tp->t_state |= TS_CARR_ON; 303 else 304 tp->t_state &= ~TS_CARR_ON; 305 } else if (tp->t_state&TS_XCLUDE && p->p_ucred->cr_uid != 0) { 306 splx(s); 307 return EBUSY; 308 } 309 310 /* wait for carrier if necessary */ 311 if ((flag & O_NONBLOCK) == 0) 312 while ((tp->t_cflag & CLOCAL) == 0 && 313 (tp->t_state & TS_CARR_ON) == 0) { 314 tp->t_state |= TS_WOPEN; 315 error = ttysleep(tp, (caddr_t)&tp->t_rawq, 316 TTIPRI | PCATCH, ttopen, 0); 317 if (error) { 318 /* XXX should turn off chip if we're the 319 only waiter */ 320 splx(s); 321 return error; 322 } 323 } 324 splx(s); 325 326 return (*linesw[tp->t_line].l_open)(dev, tp); 327 } 328 329 int 330 comclose(dev, flag, mode, p) 331 dev_t dev; 332 int flag, mode; 333 struct proc *p; 334 { 335 int unit = COMUNIT(dev); 336 struct com_softc *sc = &com_softc[unit]; 337 u_short iobase = sc->sc_iobase; 338 struct tty *tp = com_tty[unit]; 339 340 (*linesw[tp->t_line].l_close)(tp, flag); 341 #ifdef KGDB 342 /* do not disable interrupts if debugging */ 343 if (kgdb_dev != makedev(commajor, unit)) 344 #endif 345 { 346 bic(iobase + com_cfcr, CFCR_SBREAK); 347 outb(iobase + com_ier, 0); 348 if (tp->t_cflag & HUPCL && 349 (sc->sc_swflags & COM_SW_SOFTCAR) == 0) 350 /* XXX perhaps only clear DTR */ 351 outb(iobase + com_mcr, 0); 352 } 353 ttyclose(tp); 354 #ifdef notyet /* XXXX */ 355 if (unit != comconsole) { 356 ttyfree(tp); 357 com_tty[unit] = (struct tty *)NULL; 358 } 359 #endif 360 return 0; 361 } 362 363 int 364 comread(dev, uio, flag) 365 dev_t dev; 366 struct uio *uio; 367 int flag; 368 { 369 struct tty *tp = com_tty[COMUNIT(dev)]; 370 371 return ((*linesw[tp->t_line].l_read)(tp, uio, flag)); 372 } 373 374 int 375 comwrite(dev, uio, flag) 376 dev_t dev; 377 struct uio *uio; 378 int flag; 379 { 380 struct tty *tp = com_tty[COMUNIT(dev)]; 381 382 return ((*linesw[tp->t_line].l_write)(tp, uio, flag)); 383 } 384 385 static u_char 386 tiocm_xxx2mcr(data) 387 int data; 388 { 389 u_char m = 0; 390 391 if (data & TIOCM_DTR) 392 m |= MCR_DTR; 393 if (data & TIOCM_RTS) 394 m |= MCR_RTS; 395 return m; 396 } 397 398 int 399 comioctl(dev, cmd, data, flag, p) 400 dev_t dev; 401 int cmd; 402 caddr_t data; 403 int flag; 404 struct proc *p; 405 { 406 int unit = COMUNIT(dev); 407 struct com_softc *sc = &com_softc[unit]; 408 u_short iobase = sc->sc_iobase; 409 struct tty *tp = com_tty[unit]; 410 int error; 411 412 error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p); 413 if (error >= 0) 414 return error; 415 error = ttioctl(tp, cmd, data, flag, p); 416 if (error >= 0) 417 return error; 418 419 switch (cmd) { 420 case TIOCSBRK: 421 bis(iobase + com_cfcr, CFCR_SBREAK); 422 break; 423 case TIOCCBRK: 424 bic(iobase + com_cfcr, CFCR_SBREAK); 425 break; 426 case TIOCSDTR: 427 outb(iobase + com_mcr, sc->sc_mcr |= (MCR_DTR | MCR_RTS)); 428 break; 429 case TIOCCDTR: 430 outb(iobase + com_mcr, sc->sc_mcr &= ~(MCR_DTR | MCR_RTS)); 431 break; 432 case TIOCMSET: 433 sc->sc_mcr &= ~(MCR_DTR | MCR_RTS); 434 case TIOCMBIS: 435 outb(iobase + com_mcr, 436 sc->sc_mcr |= tiocm_xxx2mcr(*(int *)data)); 437 break; 438 case TIOCMBIC: 439 outb(iobase + com_mcr, 440 sc->sc_mcr &= ~tiocm_xxx2mcr(*(int *)data)); 441 break; 442 case TIOCMGET: { 443 u_char m; 444 int bits = 0; 445 446 m = sc->sc_mcr; 447 if (m & MCR_DTR) 448 bits |= TIOCM_DTR; 449 if (m & MCR_RTS) 450 bits |= TIOCM_RTS; 451 m = sc->sc_msr; 452 if (m & MSR_DCD) 453 bits |= TIOCM_CD; 454 if (m & MSR_CTS) 455 bits |= TIOCM_CTS; 456 if (m & MSR_DSR) 457 bits |= TIOCM_DSR; 458 if (m & (MSR_RI | MSR_TERI)) 459 bits |= TIOCM_RI; 460 if (inb(iobase + com_ier)) 461 bits |= TIOCM_LE; 462 *(int *)data = bits; 463 break; 464 } 465 case TIOCGFLAGS: { 466 int bits = 0; 467 468 if (sc->sc_swflags & COM_SW_SOFTCAR) 469 bits |= TIOCFLAG_SOFTCAR; 470 if (sc->sc_swflags & COM_SW_CLOCAL) 471 bits |= TIOCFLAG_CLOCAL; 472 if (sc->sc_swflags & COM_SW_CRTSCTS) 473 bits |= TIOCFLAG_CRTSCTS; 474 475 *(int *)data = bits; 476 break; 477 } 478 case TIOCSFLAGS: { 479 int userbits, driverbits = 0; 480 481 error = suser(p->p_ucred, &p->p_acflag); 482 if (error != 0) 483 return(EPERM); 484 485 userbits = *(int *)data; 486 if ((userbits & TIOCFLAG_CLOCAL) || 487 (sc->sc_hwflags & COM_HW_CONSOLE)) 488 driverbits |= COM_SW_CLOCAL; 489 if (userbits & TIOCFLAG_CLOCAL) 490 driverbits |= COM_SW_CLOCAL; 491 if (userbits & TIOCFLAG_CRTSCTS) 492 driverbits |= COM_SW_CRTSCTS; 493 494 break; 495 } 496 default: 497 return ENOTTY; 498 } 499 500 return 0; 501 } 502 503 int 504 comparam(tp, t) 505 struct tty *tp; 506 struct termios *t; 507 { 508 struct com_softc *sc = &com_softc[COMUNIT(tp->t_dev)]; 509 u_short iobase = sc->sc_iobase; 510 int ospeed = comspeed(t->c_ospeed); 511 u_char cfcr; 512 int s; 513 514 /* check requested parameters */ 515 if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed)) 516 return EINVAL; 517 518 switch (t->c_cflag & CSIZE) { 519 case CS5: 520 cfcr = CFCR_5BITS; 521 break; 522 case CS6: 523 cfcr = CFCR_6BITS; 524 break; 525 case CS7: 526 cfcr = CFCR_7BITS; 527 break; 528 case CS8: 529 cfcr = CFCR_8BITS; 530 break; 531 } 532 if (t->c_cflag & PARENB) { 533 cfcr |= CFCR_PENAB; 534 if ((t->c_cflag & PARODD) == 0) 535 cfcr |= CFCR_PEVEN; 536 } 537 if (t->c_cflag & CSTOPB) 538 cfcr |= CFCR_STOPB; 539 540 s = spltty(); 541 542 /* and copy to tty */ 543 tp->t_ispeed = t->c_ispeed; 544 tp->t_ospeed = t->c_ospeed; 545 tp->t_cflag = t->c_cflag; 546 547 if (ospeed == 0) 548 outb(iobase + com_mcr, sc->sc_mcr &= ~MCR_DTR); 549 else 550 outb(iobase + com_mcr, sc->sc_mcr |= MCR_DTR); 551 552 outb(iobase + com_cfcr, cfcr | CFCR_DLAB); 553 outb(iobase + com_dlbl, ospeed); 554 outb(iobase + com_dlbh, ospeed>>8); 555 outb(iobase + com_cfcr, cfcr); 556 557 /* When not using CRTSCTS, RTS follows DTR. */ 558 if ((t->c_cflag & CRTSCTS) == 0) { 559 if (sc->sc_mcr & MCR_DTR) { 560 if ((sc->sc_mcr & MCR_RTS) == 0) 561 outb(iobase + com_mcr, sc->sc_mcr |= MCR_RTS); 562 } else { 563 if (sc->sc_mcr & MCR_RTS) 564 outb(iobase + com_mcr, sc->sc_mcr &= ~MCR_RTS); 565 } 566 } 567 568 /* If CTS is off and CRTSCTS is changed, we must toggle TS_TTSTOP. */ 569 if ((sc->sc_msr & MSR_CTS) == 0 && 570 (tp->t_cflag & CRTSCTS) != (t->c_cflag & CRTSCTS)) { 571 if ((t->c_cflag & CRTSCTS) == 0) { 572 tp->t_state &= ~TS_TTSTOP; 573 ttstart(tp); 574 } else 575 tp->t_state |= TS_TTSTOP; 576 } 577 578 splx(s); 579 return 0; 580 } 581 582 void 583 comstart(tp) 584 struct tty *tp; 585 { 586 struct com_softc *sc = &com_softc[COMUNIT(tp->t_dev)]; 587 u_short iobase = sc->sc_iobase; 588 int s; 589 590 s = spltty(); 591 if (tp->t_state & (TS_TTSTOP | TS_BUSY)) 592 goto out; 593 #if 0 /* XXXX I think this is handled adequately by commint() and comparam(). */ 594 if (tp->t_cflag & CRTSCTS && (sc->sc_mcr & MSR_CTS) == 0) 595 goto out; 596 #endif 597 if (tp->t_outq.c_cc <= tp->t_lowat) { 598 if (tp->t_state & TS_ASLEEP) { 599 tp->t_state &= ~TS_ASLEEP; 600 wakeup((caddr_t)&tp->t_outq); 601 } 602 selwakeup(&tp->t_wsel); 603 } 604 if (tp->t_outq.c_cc == 0) 605 goto out; 606 tp->t_state |= TS_BUSY; 607 if ((inb(iobase + com_lsr) & LSR_TXRDY) == 0) 608 goto out; 609 if (sc->sc_hwflags & COM_HW_FIFO) { 610 u_char buffer[16], *cp = buffer; 611 int n = q_to_b(&tp->t_outq, cp, sizeof buffer); 612 do { 613 outb(iobase + com_data, *cp++); 614 } while (--n); 615 } else 616 outb(iobase + com_data, getc(&tp->t_outq)); 617 out: 618 splx(s); 619 } 620 621 /* 622 * Stop output on a line. 623 */ 624 void 625 comstop(tp, flag) 626 struct tty *tp; 627 { 628 int s; 629 630 s = spltty(); 631 if (tp->t_state & TS_BUSY) 632 if ((tp->t_state & TS_TTSTOP) == 0) 633 tp->t_state |= TS_FLUSH; 634 splx(s); 635 } 636 637 static inline void 638 comeint(sc, stat) 639 struct com_softc *sc; 640 int stat; 641 { 642 u_short iobase = sc->sc_iobase; 643 int unit = sc->sc_dev.dv_unit; 644 struct tty *tp = com_tty[unit]; 645 int c; 646 647 c = inb(iobase + com_data); 648 if ((tp->t_state & TS_ISOPEN) == 0) { 649 #ifdef KGDB 650 /* we don't care about parity errors */ 651 if (((stat & (LSR_BI | LSR_FE | LSR_PE)) == LSR_PE) && 652 kgdb_dev == makedev(commajor, unit) && c == FRAME_END) 653 kgdb_connect(0); /* trap into kgdb */ 654 #endif 655 return; 656 } 657 if (stat & (LSR_BI | LSR_FE)) 658 c |= TTY_FE; 659 else if (stat & LSR_PE) 660 c |= TTY_PE; 661 if (stat & LSR_OE) 662 log(LOG_WARNING, "%s: silo overflow\n", sc->sc_dev.dv_xname); 663 /* XXXX put in FIFO and process later */ 664 (*linesw[tp->t_line].l_rint)(c, tp); 665 } 666 667 static inline void 668 commint(sc) 669 struct com_softc *sc; 670 { 671 u_short iobase = sc->sc_iobase; 672 struct tty *tp = com_tty[sc->sc_dev.dv_unit]; 673 u_char msr, delta; 674 675 msr = inb(iobase + com_msr); 676 delta = msr ^ sc->sc_msr; 677 sc->sc_msr = msr; 678 679 if (delta & MSR_DCD && (sc->sc_swflags & COM_SW_SOFTCAR) == 0) { 680 if (msr & MSR_DCD) 681 (void)(*linesw[tp->t_line].l_modem)(tp, 1); 682 else if ((*linesw[tp->t_line].l_modem)(tp, 0) == 0) 683 outb(iobase + com_mcr, 684 sc->sc_mcr &= ~(MCR_DTR | MCR_RTS)); 685 } 686 if (delta & MSR_CTS && tp->t_cflag & CRTSCTS) { 687 /* the line is up and we want to do rts/cts flow control */ 688 if (msr & MSR_CTS) { 689 tp->t_state &= ~TS_TTSTOP; 690 ttstart(tp); 691 } else 692 tp->t_state |= TS_TTSTOP; 693 } 694 } 695 696 int 697 comintr(unit) 698 int unit; 699 { 700 struct com_softc *sc = &com_softc[unit]; 701 u_short iobase = sc->sc_iobase; 702 struct tty *tp; 703 u_char code; 704 705 code = inb(iobase + com_iir) & IIR_IMASK; 706 if (code & IIR_NOPEND) 707 return 0; 708 709 for (;;) { 710 if (code & IIR_RXRDY) { 711 tp = com_tty[sc->sc_dev.dv_unit]; 712 /* XXXX put in FIFO and process later */ 713 while (code = (inb(iobase + com_lsr) & LSR_RCV_MASK)) { 714 if (code == LSR_RXRDY) { 715 code = inb(iobase + com_data); 716 if (tp->t_state & TS_ISOPEN) 717 (*linesw[tp->t_line].l_rint)(code, tp); 718 #ifdef KGDB 719 else { 720 if (kgdb_dev == makedev(commajor, unit) && 721 code == FRAME_END) 722 kgdb_connect(0); 723 } 724 #endif 725 } else 726 comeint(sc, code); 727 } 728 } else if (code == IIR_TXRDY) { 729 tp = com_tty[sc->sc_dev.dv_unit]; 730 tp->t_state &= ~TS_BUSY; 731 if (tp->t_state & TS_FLUSH) 732 tp->t_state &= ~TS_FLUSH; 733 else 734 if (tp->t_line) 735 (*linesw[tp->t_line].l_start)(tp); 736 else 737 comstart(tp); 738 } else if (code == IIR_MLSC) { 739 commint(sc); 740 } else { 741 log(LOG_WARNING, "%s: weird interrupt: iir=0x%02x\n", 742 sc->sc_dev.dv_xname, code); 743 } 744 code = inb(iobase + com_iir) & IIR_IMASK; 745 if (code & IIR_NOPEND) 746 return 1; 747 } 748 } 749 750 /* 751 * Following are all routines needed for COM to act as console 752 */ 753 #include <dev/cons.h> 754 755 comcnprobe(cp) 756 struct consdev *cp; 757 { 758 int unit = CONUNIT; 759 760 if (!comprobe1(CONADDR)) { 761 cp->cn_pri = CN_DEAD; 762 return; 763 } 764 765 /* locate the major number */ 766 for (commajor = 0; commajor < nchrdev; commajor++) 767 if (cdevsw[commajor].d_open == comopen) 768 break; 769 770 com_softc[unit].sc_iobase = CONADDR; 771 772 /* initialize required fields */ 773 cp->cn_dev = makedev(commajor, unit); 774 #ifdef COMCONSOLE 775 cp->cn_pri = CN_REMOTE; /* Force a serial port console */ 776 #else 777 cp->cn_pri = CN_NORMAL; 778 #endif 779 } 780 781 comcninit(cp) 782 struct consdev *cp; 783 { 784 int unit = CONUNIT; 785 786 cominit(unit, comdefaultrate); 787 comconsole = unit; 788 comconsinit = 0; 789 } 790 791 cominit(unit, rate) 792 int unit, rate; 793 { 794 int s = splhigh(); 795 u_short iobase = com_softc[unit].sc_iobase; 796 u_char stat; 797 798 outb(iobase + com_cfcr, CFCR_DLAB); 799 rate = comspeed(comdefaultrate); 800 outb(iobase + com_dlbl, rate); 801 outb(iobase + com_dlbh, rate >> 8); 802 outb(iobase + com_cfcr, CFCR_8BITS); 803 outb(iobase + com_ier, IER_ERXRDY | IER_ETXRDY); 804 outb(iobase + com_fifo, FIFO_ENABLE | FIFO_RCV_RST | FIFO_XMT_RST | FIFO_TRIGGER_4); 805 stat = inb(iobase + com_iir); 806 splx(s); 807 } 808 809 comcngetc(dev) 810 dev_t dev; 811 { 812 int s = splhigh(); 813 u_short iobase = com_softc[COMUNIT(dev)].sc_iobase; 814 u_char stat, c; 815 816 while (((stat = inb(iobase + com_lsr)) & LSR_RXRDY) == 0) 817 ; 818 c = inb(iobase + com_data); 819 stat = inb(iobase + com_iir); 820 splx(s); 821 return c; 822 } 823 824 /* 825 * Console kernel output character routine. 826 */ 827 comcnputc(dev, c) 828 dev_t dev; 829 int c; 830 { 831 int s = splhigh(); 832 u_short iobase = com_softc[COMUNIT(dev)].sc_iobase; 833 u_char stat; 834 register int timo; 835 836 #ifdef KGDB 837 if (dev != kgdb_dev) 838 #endif 839 if (comconsinit == 0) { 840 (void) cominit(COMUNIT(dev), comdefaultrate); 841 comconsinit = 1; 842 } 843 /* wait for any pending transmission to finish */ 844 timo = 50000; 845 while (((stat = inb(iobase + com_lsr)) & LSR_TXRDY) == 0 && --timo) 846 ; 847 outb(iobase + com_data, c); 848 /* wait for this transmission to complete */ 849 timo = 1500000; 850 while (((stat = inb(iobase + com_lsr)) & LSR_TXRDY) == 0 && --timo) 851 ; 852 /* clear any interrupts generated by this transmission */ 853 stat = inb(iobase + com_iir); 854 splx(s); 855 } 856
Indexes created Wed Sep 24 05:09:52 GMT 2025