com.c revision 1.20
1 /*- 2 * Copyright (c) 1991 The Regents of the University of California. 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * from: @(#)com.c 7.5 (Berkeley) 5/16/91 34 * $Id: com.c,v 1.20 1994/03/06 17:18:50 mycroft Exp $ 35 */ 36 37 #include "com.h" 38 #if NCOM > 0 39 /* 40 * COM driver, based on HP dca driver 41 * uses National Semiconductor NS16450/NS16550AF UART 42 */ 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/ioctl.h> 46 #include <sys/select.h> 47 #include <sys/tty.h> 48 #include <sys/proc.h> 49 #include <sys/user.h> 50 #include <sys/conf.h> 51 #include <sys/file.h> 52 #include <sys/uio.h> 53 #include <sys/kernel.h> 54 #include <sys/syslog.h> 55 #include <sys/types.h> 56 57 #include <machine/pio.h> 58 59 #include <i386/isa/isa_device.h> 60 #include <i386/isa/comreg.h> 61 #include <i386/isa/ic/ns16550.h> 62 63 #define cominor(d) 64 65 int comprobe(), comattach(), comintr(), comparam(); 66 void comstart(); 67 68 struct isa_driver comdriver = { 69 comprobe, comattach, "com" 70 }; 71 72 int comsoftCAR; 73 int com_active; 74 int com_hasfifo; 75 int ncom = NCOM; 76 #ifdef COMCONSOLE 77 int comconsole = COMCONSOLE; 78 #else 79 int comconsole = -1; 80 #endif 81 int comconsinit; 82 int comdefaultrate = TTYDEF_SPEED; 83 int commajor; 84 short com_addr[NCOM]; 85 struct tty *com_tty[NCOM]; 86 87 struct speedtab comspeedtab[] = { 88 0, 0, 89 50, COMBRD(50), 90 75, COMBRD(75), 91 110, COMBRD(110), 92 134, COMBRD(134), 93 150, COMBRD(150), 94 200, COMBRD(200), 95 300, COMBRD(300), 96 600, COMBRD(600), 97 1200, COMBRD(1200), 98 1800, COMBRD(1800), 99 2400, COMBRD(2400), 100 4800, COMBRD(4800), 101 9600, COMBRD(9600), 102 19200, COMBRD(19200), 103 38400, COMBRD(38400), 104 57600, COMBRD(57600), 105 -1, -1 106 }; 107 108 extern struct tty *constty; 109 #ifdef KGDB 110 #include <machine/remote-sl.h> 111 112 extern int kgdb_dev; 113 extern int kgdb_rate; 114 extern int kgdb_debug_init; 115 #endif 116 117 #define UNIT(x) (minor(x)) 118 119 comprobe(dev) 120 struct isa_device *dev; 121 { 122 /* force access to id reg */ 123 outb(dev->id_iobase+com_cfcr, 0); 124 outb(dev->id_iobase+com_iir, 0); 125 delay(100); 126 if ((inb(dev->id_iobase+com_iir) & 0x38) == 0) 127 return(8); 128 return(0); 129 } 130 131 132 int 133 comattach(isdp) 134 struct isa_device *isdp; 135 { 136 struct tty *tp; 137 u_char unit; 138 int port = isdp->id_iobase; 139 140 unit = isdp->id_unit; 141 if (unit == comconsole) 142 delay(1000); 143 com_addr[unit] = port; 144 com_active |= 1 << unit; 145 comsoftCAR |= 1 << unit; /* XXX */ 146 147 /* look for a NS 16550AF UART with FIFOs */ 148 outb(port+com_fifo, FIFO_ENABLE|FIFO_RCV_RST|FIFO_XMT_RST|FIFO_TRIGGER_4); 149 delay(100); 150 if ((inb(port+com_iir) & IIR_FIFO_MASK) == IIR_FIFO_MASK) { 151 com_hasfifo |= 1 << unit; 152 printf("com%d: fifo\n", isdp->id_unit); 153 } 154 155 outb(port+com_ier, 0); 156 outb(port+com_mcr, 0 | MCR_IENABLE); 157 #ifdef KGDB 158 if (kgdb_dev == makedev(commajor, unit)) { 159 if (comconsole == unit) 160 kgdb_dev = -1; /* can't debug over console port */ 161 else { 162 (void) cominit(unit, kgdb_rate); 163 if (kgdb_debug_init) { 164 /* 165 * Print prefix of device name, 166 * let kgdb_connect print the rest. 167 */ 168 printf("com%d: ", unit); 169 kgdb_connect(1); 170 } else 171 printf("com%d: kgdb enabled\n", unit); 172 } 173 } 174 #endif 175 /* 176 * Need to reset baud rate, etc. of next print so reset comconsinit. 177 * Also make sure console is always "hardwired" 178 */ 179 if (unit == comconsole) { 180 comconsinit = 0; 181 comsoftCAR |= (1 << unit); 182 } 183 return (1); 184 } 185 186 /* ARGSUSED */ 187 comopen(dev_t dev, int flag, int mode, struct proc *p) 188 { 189 register struct tty *tp; 190 register int unit; 191 int error = 0; 192 193 unit = UNIT(dev); 194 if (unit >= NCOM || (com_active & (1 << unit)) == 0) 195 return (ENXIO); 196 if(!com_tty[unit]) { 197 tp = com_tty[unit] = ttymalloc(); 198 } else 199 tp = com_tty[unit]; 200 tp->t_oproc = comstart; 201 tp->t_param = comparam; 202 tp->t_dev = dev; 203 if ((tp->t_state & TS_ISOPEN) == 0) { 204 tp->t_state |= TS_WOPEN; 205 ttychars(tp); 206 tp->t_iflag = TTYDEF_IFLAG; 207 tp->t_oflag = TTYDEF_OFLAG; 208 tp->t_cflag = TTYDEF_CFLAG; 209 tp->t_lflag = TTYDEF_LFLAG; 210 tp->t_ispeed = tp->t_ospeed = comdefaultrate; 211 comparam(tp, &tp->t_termios); 212 ttsetwater(tp); 213 } else if (tp->t_state&TS_XCLUDE && p->p_ucred->cr_uid != 0) 214 return (EBUSY); 215 (void) spltty(); 216 (void) commctl(dev, MCR_DTR | MCR_RTS, DMSET); 217 if ((comsoftCAR & (1 << unit)) || (commctl(dev, 0, DMGET) & MSR_DCD)) 218 tp->t_state |= TS_CARR_ON; 219 while ((flag&O_NONBLOCK) == 0 && (tp->t_cflag&CLOCAL) == 0 && 220 (tp->t_state & TS_CARR_ON) == 0) { 221 tp->t_state |= TS_WOPEN; 222 if (error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH, 223 ttopen, 0)) 224 break; 225 } 226 (void) spl0(); 227 if (error == 0) 228 error = (*linesw[tp->t_line].l_open)(dev, tp); 229 return (error); 230 } 231 232 /*ARGSUSED*/ 233 comclose(dev, flag, mode, p) 234 dev_t dev; 235 int flag, mode; 236 struct proc *p; 237 { 238 register struct tty *tp; 239 register com; 240 register int unit; 241 242 unit = UNIT(dev); 243 com = com_addr[unit]; 244 tp = com_tty[unit]; 245 (*linesw[tp->t_line].l_close)(tp, flag); 246 outb(com+com_cfcr, inb(com+com_cfcr) & ~CFCR_SBREAK); 247 #ifdef KGDB 248 /* do not disable interrupts if debugging */ 249 if (kgdb_dev != makedev(commajor, unit)) 250 #endif 251 outb(com+com_ier, 0); 252 if (tp->t_cflag&HUPCL || tp->t_state&TS_WOPEN || 253 (tp->t_state&TS_ISOPEN) == 0) 254 (void) commctl(dev, 0, DMSET); 255 ttyclose(tp); 256 #ifdef broken /* session holds a ref to the tty; can't deallocate */ 257 ttyfree(tp); 258 com_tty[unit] = (struct tty *)NULL; 259 #endif 260 return(0); 261 } 262 263 comread(dev, uio, flag) 264 dev_t dev; 265 struct uio *uio; 266 { 267 register struct tty *tp = com_tty[UNIT(dev)]; 268 269 return ((*linesw[tp->t_line].l_read)(tp, uio, flag)); 270 } 271 272 comwrite(dev, uio, flag) 273 dev_t dev; 274 struct uio *uio; 275 { 276 register struct tty *tp = com_tty[UNIT(dev)]; 277 278 return ((*linesw[tp->t_line].l_write)(tp, uio, flag)); 279 } 280 281 comintr(unit) 282 register int unit; 283 { 284 register com; 285 register u_char code; 286 register struct tty *tp; 287 288 com = com_addr[unit]; 289 while (1) { 290 code = inb(com+com_iir); 291 switch (code & IIR_IMASK) { 292 case IIR_NOPEND: 293 return (1); 294 case IIR_RXTOUT: 295 case IIR_RXRDY: 296 tp = com_tty[unit]; 297 /* 298 * Process received bytes. Inline for speed... 299 */ 300 #ifdef KGDB 301 #define RCVBYTE() \ 302 code = inb(com+com_data); \ 303 if ((tp->t_state & TS_ISOPEN) == 0) { \ 304 if (kgdb_dev == makedev(commajor, unit) && \ 305 code == FRAME_END) \ 306 kgdb_connect(0); /* trap into kgdb */ \ 307 } else \ 308 (*linesw[tp->t_line].l_rint)(code, tp) 309 #else 310 #define RCVBYTE() \ 311 code = inb(com+com_data); \ 312 if (tp->t_state & TS_ISOPEN) \ 313 (*linesw[tp->t_line].l_rint)(code, tp) 314 #endif 315 316 RCVBYTE(); 317 318 if (com_hasfifo & (1 << unit)) 319 while ((code = inb(com+com_lsr)) & LSR_RCV_MASK) { 320 if (code == LSR_RXRDY) { 321 RCVBYTE(); 322 } else 323 comeint(unit, code, com); 324 } 325 break; 326 case IIR_TXRDY: 327 tp = com_tty[unit]; 328 tp->t_state &=~ (TS_BUSY|TS_FLUSH); 329 if (tp->t_line) 330 (*linesw[tp->t_line].l_start)(tp); 331 else 332 comstart(tp); 333 break; 334 case IIR_RLS: 335 comeint(unit, inb(com+com_lsr), com); 336 break; 337 default: 338 if (code & IIR_NOPEND) 339 return (1); 340 log(LOG_WARNING, "com%d: weird interrupt: 0x%x\n", 341 unit, code); 342 /* fall through */ 343 case IIR_MLSC: 344 commint(unit, com); 345 break; 346 } 347 } 348 } 349 350 comeint(unit, stat, com) 351 register int unit, stat; 352 register com; 353 { 354 register struct tty *tp; 355 register int c; 356 357 tp = com_tty[unit]; 358 c = inb(com+com_data); 359 if ((tp->t_state & TS_ISOPEN) == 0) { 360 #ifdef KGDB 361 /* we don't care about parity errors */ 362 if (((stat & (LSR_BI|LSR_FE|LSR_PE)) == LSR_PE) && 363 kgdb_dev == makedev(commajor, unit) && c == FRAME_END) 364 kgdb_connect(0); /* trap into kgdb */ 365 #endif 366 return; 367 } 368 if (stat & (LSR_BI | LSR_FE)) 369 c |= TTY_FE; 370 else if (stat & LSR_PE) 371 c |= TTY_PE; 372 else if (stat & LSR_OE) { /* 30 Aug 92*/ 373 c |= TTY_PE; /* Ought to have it's own define... */ 374 log(LOG_WARNING, "com%d: silo overflow\n", unit); 375 } 376 (*linesw[tp->t_line].l_rint)(c, tp); 377 } 378 379 commint(unit, com) 380 register int unit; 381 register com; 382 { 383 register struct tty *tp; 384 register int stat; 385 386 tp = com_tty[unit]; 387 stat = inb(com+com_msr); 388 if ((stat & MSR_DDCD) && (comsoftCAR & (1 << unit)) == 0) { 389 if (stat & MSR_DCD) 390 (void)(*linesw[tp->t_line].l_modem)(tp, 1); 391 else if ((*linesw[tp->t_line].l_modem)(tp, 0) == 0) 392 outb(com+com_mcr, 393 inb(com+com_mcr) & ~(MCR_DTR | MCR_RTS) | MCR_IENABLE); 394 } else if ((stat & MSR_DCTS) && (tp->t_state & TS_ISOPEN) && 395 (tp->t_flags & CRTSCTS)) { 396 /* the line is up and we want to do rts/cts flow control */ 397 if (stat & MSR_CTS) { 398 tp->t_state &=~ TS_TTSTOP; 399 ttstart(tp); 400 } else 401 tp->t_state |= TS_TTSTOP; 402 } 403 } 404 405 comioctl(dev, cmd, data, flag, p) 406 dev_t dev; 407 int cmd; 408 caddr_t data; 409 int flag; 410 struct proc *p; 411 { 412 register struct tty *tp; 413 register int unit = UNIT(dev); 414 register com; 415 register int error; 416 417 tp = com_tty[unit]; 418 error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p); 419 if (error >= 0) 420 return (error); 421 error = ttioctl(tp, cmd, data, flag, p); 422 if (error >= 0) 423 return (error); 424 425 com = com_addr[unit]; 426 switch (cmd) { 427 428 case TIOCSBRK: 429 outb(com+com_cfcr, inb(com+com_cfcr) | CFCR_SBREAK); 430 break; 431 432 case TIOCCBRK: 433 outb(com+com_cfcr, inb(com+com_cfcr) & ~CFCR_SBREAK); 434 break; 435 436 case TIOCSDTR: 437 (void) commctl(dev, MCR_DTR | MCR_RTS, DMBIS); 438 break; 439 440 case TIOCCDTR: 441 (void) commctl(dev, MCR_DTR | MCR_RTS, DMBIC); 442 break; 443 444 case TIOCMSET: 445 (void) commctl(dev, *(int *)data, DMSET); 446 break; 447 448 case TIOCMBIS: 449 (void) commctl(dev, *(int *)data, DMBIS); 450 break; 451 452 case TIOCMBIC: 453 (void) commctl(dev, *(int *)data, DMBIC); 454 break; 455 456 case TIOCMGET: 457 *(int *)data = commctl(dev, 0, DMGET); 458 break; 459 460 default: 461 return (ENOTTY); 462 } 463 return (0); 464 } 465 466 comparam(tp, t) 467 register struct tty *tp; 468 register struct termios *t; 469 { 470 register com; 471 register int cfcr, cflag = t->c_cflag; 472 int unit = UNIT(tp->t_dev); 473 int ospeed = ttspeedtab(t->c_ospeed, comspeedtab); 474 475 /* check requested parameters */ 476 if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed)) 477 return(EINVAL); 478 /* and copy to tty */ 479 tp->t_ispeed = t->c_ispeed; 480 tp->t_ospeed = t->c_ospeed; 481 tp->t_cflag = cflag; 482 483 com = com_addr[unit]; 484 outb(com+com_ier, IER_ERXRDY | IER_ETXRDY | IER_ERLS /*| IER_EMSC*/); 485 if (ospeed == 0) { 486 (void) commctl(unit, 0, DMSET); /* hang up line */ 487 return(0); 488 } 489 outb(com+com_cfcr, inb(com+com_cfcr) | CFCR_DLAB); 490 outb(com+com_data, ospeed & 0xFF); 491 outb(com+com_ier, ospeed >> 8); 492 switch (cflag&CSIZE) { 493 case CS5: 494 cfcr = CFCR_5BITS; break; 495 case CS6: 496 cfcr = CFCR_6BITS; break; 497 case CS7: 498 cfcr = CFCR_7BITS; break; 499 case CS8: 500 cfcr = CFCR_8BITS; break; 501 } 502 if (cflag&PARENB) { 503 cfcr |= CFCR_PENAB; 504 if ((cflag&PARODD) == 0) 505 cfcr |= CFCR_PEVEN; 506 } 507 if (cflag&CSTOPB) 508 cfcr |= CFCR_STOPB; 509 outb(com+com_cfcr, cfcr); 510 511 if (com_hasfifo & (1 << unit)) 512 outb(com+com_fifo, FIFO_ENABLE | FIFO_TRIGGER_4); 513 514 return(0); 515 } 516 517 void 518 comstart(tp) 519 register struct tty *tp; 520 { 521 register com; 522 int s, unit, c; 523 524 unit = UNIT(tp->t_dev); 525 com = com_addr[unit]; 526 s = spltty(); 527 if (tp->t_state & (TS_TIMEOUT|TS_TTSTOP)) 528 goto out; 529 if (tp->t_outq.c_cc <= tp->t_lowat) { 530 if (tp->t_state&TS_ASLEEP) { 531 tp->t_state &= ~TS_ASLEEP; 532 wakeup((caddr_t)&tp->t_outq); 533 } 534 selwakeup(&tp->t_wsel); 535 } 536 if (tp->t_outq.c_cc == 0) 537 goto out; 538 if (inb(com+com_lsr) & LSR_TXRDY) { 539 c = getc(&tp->t_outq); 540 tp->t_state |= TS_BUSY; 541 outb(com+com_data, c); 542 if (com_hasfifo & (1 << unit)) 543 for (c = 1; c < 16 && tp->t_outq.c_cc; ++c) 544 outb(com+com_data, getc(&tp->t_outq)); 545 } 546 out: 547 splx(s); 548 } 549 550 /* 551 * Stop output on a line. 552 */ 553 /*ARGSUSED*/ 554 comstop(tp, flag) 555 register struct tty *tp; 556 { 557 register int s; 558 559 s = spltty(); 560 if (tp->t_state & TS_BUSY) { 561 if ((tp->t_state&TS_TTSTOP)==0) 562 tp->t_state |= TS_FLUSH; 563 } 564 splx(s); 565 } 566 567 commctl(dev, bits, how) 568 dev_t dev; 569 int bits, how; 570 { 571 register com; 572 register int unit; 573 int s; 574 575 unit = UNIT(dev); 576 com = com_addr[unit]; 577 s = spltty(); 578 switch (how) { 579 580 case DMSET: 581 outb(com+com_mcr, bits | MCR_IENABLE); 582 break; 583 584 case DMBIS: 585 outb(com+com_mcr, inb(com+com_mcr) | bits | MCR_IENABLE); 586 break; 587 588 case DMBIC: 589 outb(com+com_mcr, inb(com+com_mcr) & ~bits | MCR_IENABLE); 590 break; 591 592 case DMGET: 593 bits = inb(com+com_msr); 594 break; 595 } 596 (void) splx(s); 597 return(bits); 598 } 599 600 /* 601 * Following are all routines needed for COM to act as console 602 */ 603 #include <dev/cons.h> 604 605 comcnprobe(cp) 606 struct consdev *cp; 607 { 608 int unit; 609 610 /* locate the major number */ 611 for (commajor = 0; commajor < nchrdev; commajor++) 612 if (cdevsw[commajor].d_open == comopen) 613 break; 614 615 /* XXX: ick */ 616 unit = CONUNIT; 617 com_addr[CONUNIT] = CONADDR; 618 619 /* make sure hardware exists? XXX */ 620 621 /* initialize required fields */ 622 cp->cn_dev = makedev(commajor, unit); 623 #ifdef COMCONSOLE 624 cp->cn_pri = CN_REMOTE; /* Force a serial port console */ 625 #else 626 cp->cn_pri = CN_NORMAL; 627 #endif 628 } 629 630 comcninit(cp) 631 struct consdev *cp; 632 { 633 int unit = UNIT(cp->cn_dev); 634 635 cominit(unit, comdefaultrate); 636 comconsole = unit; 637 comconsinit = 1; 638 } 639 640 cominit(unit, rate) 641 int unit, rate; 642 { 643 register int com; 644 int s; 645 short stat; 646 647 #ifdef lint 648 stat = unit; if (stat) return; 649 #endif 650 com = com_addr[unit]; 651 s = splhigh(); 652 outb(com+com_cfcr, CFCR_DLAB); 653 rate = ttspeedtab(comdefaultrate, comspeedtab); 654 outb(com+com_data, rate & 0xFF); 655 outb(com+com_ier, rate >> 8); 656 outb(com+com_cfcr, CFCR_8BITS); 657 outb(com+com_ier, IER_ERXRDY | IER_ETXRDY); 658 outb(com+com_fifo, FIFO_ENABLE|FIFO_RCV_RST|FIFO_XMT_RST|FIFO_TRIGGER_4); 659 stat = inb(com+com_iir); 660 splx(s); 661 } 662 663 comcngetc(dev) 664 { 665 register com = com_addr[UNIT(dev)]; 666 short stat; 667 int c, s; 668 669 #ifdef lint 670 stat = dev; if (stat) return(0); 671 #endif 672 s = splhigh(); 673 while (((stat = inb(com+com_lsr)) & LSR_RXRDY) == 0) 674 ; 675 c = inb(com+com_data); 676 stat = inb(com+com_iir); 677 splx(s); 678 return(c); 679 } 680 681 /* 682 * Console kernel output character routine. 683 */ 684 comcnputc(dev, c) 685 dev_t dev; 686 register int c; 687 { 688 register com = com_addr[UNIT(dev)]; 689 register int timo; 690 short stat; 691 int s = splhigh(); 692 693 #ifdef lint 694 stat = dev; if (stat) return; 695 #endif 696 #ifdef KGDB 697 if (dev != kgdb_dev) 698 #endif 699 if (comconsinit == 0) { 700 (void) cominit(UNIT(dev), comdefaultrate); 701 comconsinit = 1; 702 } 703 /* wait for any pending transmission to finish */ 704 timo = 50000; 705 while (((stat = inb(com+com_lsr)) & LSR_TXRDY) == 0 && --timo) 706 ; 707 outb(com+com_data, c); 708 /* wait for this transmission to complete */ 709 timo = 1500000; 710 while (((stat = inb(com+com_lsr)) & LSR_TXRDY) == 0 && --timo) 711 ; 712 /* clear any interrupts generated by this transmission */ 713 stat = inb(com+com_iir); 714 splx(s); 715 } 716 717 #endif 718
Indexes created Wed Sep 24 05:09:52 GMT 2025