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