1 /* $NetBSD: ser.c,v 1.75 2006/10/01 20:31:49 elad Exp $ */ 2 3 /* 4 * Copyright (c) 1982, 1986, 1990 The Regents of the University of California. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * @(#)ser.c 7.12 (Berkeley) 6/27/91 32 */ 33 /* 34 * XXX This file needs major cleanup it will never service more than one 35 * XXX unit. 36 */ 37 38 #include "opt_amigacons.h" 39 #include "opt_ddb.h" 40 #include "opt_kgdb.h" 41 42 #include <sys/cdefs.h> 43 __KERNEL_RCSID(0, "$NetBSD: ser.c,v 1.75 2006/10/01 20:31:49 elad Exp $"); 44 45 #include <sys/param.h> 46 #include <sys/systm.h> 47 #include <sys/ioctl.h> 48 #include <sys/device.h> 49 #include <sys/tty.h> 50 #include <sys/proc.h> 51 #include <sys/file.h> 52 #include <sys/malloc.h> 53 #include <sys/uio.h> 54 #include <sys/kernel.h> 55 #include <sys/syslog.h> 56 #include <sys/queue.h> 57 #include <sys/conf.h> 58 #include <sys/kauth.h> 59 #include <machine/cpu.h> 60 #include <amiga/amiga/device.h> 61 #include <amiga/dev/serreg.h> 62 #include <amiga/amiga/custom.h> 63 #include <amiga/amiga/cia.h> 64 #include <amiga/amiga/cc.h> 65 66 #include <dev/cons.h> 67 68 #include "ser.h" 69 #if NSER > 0 70 71 void serattach(struct device *, struct device *, void *); 72 int sermatch(struct device *, struct cfdata *, void *); 73 74 struct ser_softc { 75 struct device dev; 76 struct tty *ser_tty; 77 }; 78 79 CFATTACH_DECL(ser, sizeof(struct ser_softc), 80 sermatch, serattach, NULL, NULL); 81 82 extern struct cfdriver ser_cd; 83 84 dev_type_open(seropen); 85 dev_type_close(serclose); 86 dev_type_read(serread); 87 dev_type_write(serwrite); 88 dev_type_ioctl(serioctl); 89 dev_type_stop(serstop); 90 dev_type_tty(sertty); 91 dev_type_poll(serpoll); 92 93 const struct cdevsw ser_cdevsw = { 94 seropen, serclose, serread, serwrite, serioctl, 95 serstop, sertty, serpoll, nommap, ttykqfilter, D_TTY 96 }; 97 98 #ifndef SEROBUF_SIZE 99 #define SEROBUF_SIZE 32 100 #endif 101 #ifndef SERIBUF_SIZE 102 #define SERIBUF_SIZE 512 103 #endif 104 105 #define splser() spl5() 106 107 void serstart(struct tty *); 108 void ser_shutdown(struct ser_softc *); 109 int serparam(struct tty *, struct termios *); 110 void serintr(void); 111 int serhwiflow(struct tty *, int); 112 int sermctl(dev_t dev, int, int); 113 void ser_fastint(void); 114 void sereint(int); 115 static void ser_putchar(struct tty *, u_short); 116 void ser_outintr(void); 117 void sercnprobe(struct consdev *); 118 void sercninit(struct consdev *); 119 void serinit(int); 120 int sercngetc(dev_t dev); 121 void sercnputc(dev_t, int); 122 void sercnpollc(dev_t, int); 123 124 int nser = NSER; 125 #ifdef SERCONSOLE 126 int serconsole = 0; 127 #else 128 int serconsole = -1; 129 #endif 130 int serconsinit; 131 int serdefaultrate = TTYDEF_SPEED; 132 int serswflags; 133 134 struct vbl_node ser_vbl_node; 135 struct tty ser_cons; 136 struct tty *ser_tty; 137 138 static u_short serbuf[SERIBUF_SIZE]; 139 static u_short *sbrpt = serbuf; 140 static u_short *sbwpt = serbuf; 141 static u_short sbcnt; 142 static u_short sbovfl; 143 static u_char serdcd; 144 145 /* 146 * Since this UART is not particularly bright (to put it nicely), we'll 147 * have to do parity stuff on our own. This table contains the 8th bit 148 * in 7bit character mode, for even parity. If you want odd parity, 149 * flip the bit. (for generation of the table, see genpar.c) 150 */ 151 152 u_char even_parity[] = { 153 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 154 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 155 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 156 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 157 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 158 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 159 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 160 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 161 }; 162 163 /* 164 * Since we don't get interrupts for changes on the modem control line, 165 * we'll have to fake them by comparing current settings to the settings 166 * we remembered on last invocation. 167 */ 168 169 u_char last_ciab_pra; 170 171 extern struct tty *constty; 172 173 extern int ser_open_speed; /* current speed of open serial device */ 174 175 #ifdef KGDB 176 #include <machine/remote-sl.h> 177 178 extern dev_t kgdb_dev; 179 extern int kgdb_rate; 180 extern int kgdb_debug_init; 181 #endif 182 183 #ifdef DEBUG 184 long fifoin[17]; 185 long fifoout[17]; 186 long serintrcount[16]; 187 long sermintcount[16]; 188 #endif 189 190 void sermint(register int unit); 191 192 int 193 sermatch(struct device *pdp, struct cfdata *cfp, void *auxp) 194 { 195 static int ser_matched = 0; 196 static int ser_matched_real = 0; 197 198 /* Allow only once instance. */ 199 if (matchname("ser", (char *)auxp) == 0) 200 return(0); 201 202 if (amiga_realconfig) { 203 if (ser_matched_real) 204 return(0); 205 ser_matched_real = 1; 206 } else { 207 if (serconsole != 0) 208 return(0); 209 210 if (ser_matched != 0) 211 return(0); 212 213 ser_matched = 1; 214 } 215 return(1); 216 } 217 218 219 void 220 serattach(struct device *pdp, struct device *dp, void *auxp) 221 { 222 struct ser_softc *sc; 223 struct tty *tp; 224 u_short ir; 225 226 sc = (struct ser_softc *)dp; 227 228 ir = custom.intenar; 229 if (serconsole == 0) 230 DELAY(100000); 231 232 ser_vbl_node.function = (void (*) (void *)) sermint; 233 add_vbl_function(&ser_vbl_node, SER_VBL_PRIORITY, (void *) 0); 234 #ifdef KGDB 235 if (kgdb_dev == makedev(cdevsw_lookup_major(&ser_cdevsw), 0)) { 236 if (serconsole == 0) 237 kgdb_dev = NODEV; /* can't debug over console port */ 238 else { 239 (void) serinit(kgdb_rate); 240 serconsinit = 1; /* don't re-init in serputc */ 241 if (kgdb_debug_init == 0) 242 printf(" kgdb enabled\n"); 243 else { 244 /* 245 * Print prefix of device name, 246 * let kgdb_connect print the rest. 247 */ 248 printf("ser0: "); 249 kgdb_connect(1); 250 } 251 } 252 } 253 #endif 254 /* 255 * Need to reset baud rate, etc. of next print so reset serconsinit. 256 */ 257 if (0 == serconsole) 258 serconsinit = 0; 259 260 tp = ttymalloc(); 261 tp->t_oproc = (void (*) (struct tty *)) serstart; 262 tp->t_param = serparam; 263 tp->t_hwiflow = serhwiflow; 264 tty_attach(tp); 265 sc->ser_tty = ser_tty = tp; 266 267 if (dp) 268 printf(": input fifo %d output fifo %d\n", SERIBUF_SIZE, 269 SEROBUF_SIZE); 270 } 271 272 273 /* ARGSUSED */ 274 int 275 seropen(dev_t dev, int flag, int mode, struct lwp *l) 276 { 277 struct ser_softc *sc; 278 struct tty *tp; 279 int unit, error, s, s2; 280 281 error = 0; 282 unit = SERUNIT(dev); 283 284 if (unit >= ser_cd.cd_ndevs) 285 return (ENXIO); 286 287 sc = ser_cd.cd_devs[unit]; 288 if (sc == 0) 289 return (ENXIO); 290 291 /* XXX com.c: insert KGDB check here */ 292 293 /* XXX ser.c had: s = spltty(); */ 294 295 tp = sc->ser_tty; 296 297 if (kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_OPEN, tp)) 298 return (EBUSY); 299 300 s = spltty(); 301 302 /* 303 * If this is a first open... 304 */ 305 306 if ((tp->t_state & TS_ISOPEN) == 0 && tp->t_wopen == 0) { 307 struct termios t; 308 309 tp->t_dev = dev; 310 311 s2 = splser(); 312 /* 313 * XXX here: hw enable, 314 */ 315 last_ciab_pra = ciab.pra; 316 317 splx(s2); 318 t.c_ispeed = 0; 319 320 /* XXX serconsolerate? */ 321 t.c_ospeed = TTYDEF_SPEED; 322 t.c_cflag = TTYDEF_CFLAG; 323 324 if (serswflags & TIOCFLAG_CLOCAL) 325 t.c_cflag |= CLOCAL; 326 if (serswflags & TIOCFLAG_CRTSCTS) 327 t.c_cflag |= CRTSCTS; 328 if (serswflags & TIOCFLAG_MDMBUF) 329 t.c_cflag |= MDMBUF; 330 331 /* Make sure serparam() will do something. */ 332 tp->t_ospeed = 0; 333 serparam(tp, &t); 334 tp->t_iflag = TTYDEF_IFLAG; 335 tp->t_oflag = TTYDEF_OFLAG; 336 tp->t_lflag = TTYDEF_LFLAG; 337 ttychars(tp); 338 ttsetwater(tp); 339 340 s2 = splser(); 341 (void)sermctl(dev, TIOCM_DTR, DMSET); 342 /* clear input ring */ 343 sbrpt = sbwpt = serbuf; 344 sbcnt = 0; 345 splx(s2); 346 } 347 348 splx(s); 349 350 error = ttyopen(tp, DIALOUT(dev), flag & O_NONBLOCK); 351 if (error) 352 goto bad; 353 354 error = tp->t_linesw->l_open(dev, tp); 355 if (error) 356 goto bad; 357 358 return (0); 359 360 bad: 361 if (!(tp->t_state & TS_ISOPEN) && tp->t_wopen == 0) { 362 ser_shutdown(sc); 363 } 364 365 return (error); 366 } 367 368 /*ARGSUSED*/ 369 int 370 serclose(dev_t dev, int flag, int mode, struct lwp *l) 371 { 372 struct ser_softc *sc; 373 struct tty *tp; 374 375 sc = ser_cd.cd_devs[0]; 376 tp = ser_tty; 377 378 /* XXX This is for cons.c, according to com.c */ 379 if (!(tp->t_state & TS_ISOPEN)) 380 return (0); 381 382 tp->t_linesw->l_close(tp, flag); 383 ttyclose(tp); 384 385 if (!(tp->t_state & TS_ISOPEN) && tp->t_wopen == 0) { 386 ser_shutdown(sc); 387 } 388 return (0); 389 } 390 391 void 392 ser_shutdown(struct ser_softc *sc) 393 { 394 struct tty *tp = sc->ser_tty; 395 int s; 396 397 s = splser(); 398 399 custom.adkcon = ADKCONF_UARTBRK; /* clear break */ 400 #if 0 /* XXX fix: #ifdef KGDB */ 401 /* 402 * do not disable interrupts if debugging 403 */ 404 if (dev != kgdb_dev) 405 #endif 406 custom.intena = INTF_RBF | INTF_TBE; /* disable interrupts */ 407 custom.intreq = INTF_RBF | INTF_TBE; /* clear intr request */ 408 409 /* 410 * If HUPCL is not set, leave DTR unchanged. 411 */ 412 if (tp->t_cflag & HUPCL) { 413 (void)sermctl(tp->t_dev, TIOCM_DTR, DMBIC); 414 /* 415 * Idea from dev/ic/com.c: 416 * sleep a bit so that other side will notice, even if we 417 * reopen immediately. 418 */ 419 (void) tsleep(tp, TTIPRI, ttclos, hz); 420 } 421 422 #if not_yet 423 if (tp != &ser_cons) { 424 remove_vbl_function(&ser_vbl_node); 425 ttyfree(tp); 426 ser_tty = (struct tty *) NULL; 427 } 428 #endif 429 ser_open_speed = tp->t_ispeed; 430 return; 431 } 432 433 int 434 serread(dev_t dev, struct uio *uio, int flag) 435 { 436 /* ARGSUSED */ 437 438 return ser_tty->t_linesw->l_read(ser_tty, uio, flag); 439 } 440 441 int 442 serwrite(dev_t dev, struct uio *uio, int flag) 443 { 444 /* ARGSUSED */ 445 446 return ser_tty->t_linesw->l_write(ser_tty, uio, flag); 447 } 448 449 int 450 serpoll(dev_t dev, int events, struct lwp *l) 451 { 452 /* ARGSUSED */ 453 454 return ser_tty->t_linesw->l_poll(ser_tty, events, l); 455 } 456 457 struct tty * 458 sertty(dev_t dev) 459 { 460 /* ARGSUSED */ 461 462 return (ser_tty); 463 } 464 465 /* 466 * We don't do any processing of data here, so we store the raw code 467 * obtained from the uart register. In theory, 110kBaud gives you 468 * 11kcps, so 16k buffer should be more than enough, interrupt 469 * latency of 1s should never happen, or something is seriously 470 * wrong.. 471 * buffers moved to above seropen() -is 472 */ 473 474 /* 475 * This is a replacement for the lack of a hardware fifo. 32k should be 476 * enough (there's only one unit anyway, so this is not going to 477 * accumulate). 478 */ 479 void 480 ser_fastint(void) 481 { 482 /* 483 * We're at RBE-level, which is higher than VBL-level which is used 484 * to periodically transmit contents of this buffer up one layer, 485 * so no spl-raising is necessary. 486 */ 487 u_short code; 488 489 /* 490 * This register contains both data and status bits! 491 */ 492 code = custom.serdatr; 493 494 /* 495 * Use SERDATF_RBF instead of INTF_RBF; they're equivalent, but 496 * we save one (slow) custom chip access. 497 */ 498 if ((code & SERDATRF_RBF) == 0) 499 return; 500 501 /* 502 * clear interrupt 503 */ 504 custom.intreq = INTF_RBF; 505 506 /* 507 * check for buffer overflow. 508 */ 509 if (sbcnt == SERIBUF_SIZE) { 510 ++sbovfl; 511 return; 512 } 513 /* 514 * store in buffer 515 */ 516 *sbwpt++ = code; 517 if (sbwpt == serbuf + SERIBUF_SIZE) 518 sbwpt = serbuf; 519 ++sbcnt; 520 if (sbcnt > SERIBUF_SIZE - 20) 521 CLRRTS(ciab.pra); /* drop RTS if buffer almost full */ 522 } 523 524 525 void 526 serintr(void) 527 { 528 int s1, s2, ovfl; 529 struct tty *tp = ser_tty; 530 531 /* 532 * Make sure we're not interrupted by another 533 * vbl, but allow level5 ints 534 */ 535 s1 = spltty(); 536 537 /* 538 * pass along any acumulated information 539 */ 540 while (sbcnt > 0 && (tp->t_state & TS_TBLOCK) == 0) { 541 /* 542 * no collision with ser_fastint() 543 */ 544 sereint(*sbrpt++); 545 546 ovfl = 0; 547 /* lock against ser_fastint() */ 548 s2 = splser(); 549 sbcnt--; 550 if (sbrpt == serbuf + SERIBUF_SIZE) 551 sbrpt = serbuf; 552 if (sbovfl != 0) { 553 ovfl = sbovfl; 554 sbovfl = 0; 555 } 556 splx(s2); 557 if (ovfl != 0) 558 log(LOG_WARNING, "ser0: %d ring buffer overflows.\n", 559 ovfl); 560 } 561 s2 = splser(); 562 if (sbcnt == 0 && (tp->t_state & TS_TBLOCK) == 0) 563 SETRTS(ciab.pra); /* start accepting data again */ 564 splx(s2); 565 splx(s1); 566 } 567 568 void 569 sereint(int stat) 570 { 571 static int break_in_progress = 0; 572 struct tty *tp; 573 u_char ch; 574 int c; 575 576 tp = ser_tty; 577 ch = stat & 0xff; 578 c = ch; 579 580 if ((tp->t_state & TS_ISOPEN) == 0) { 581 #ifdef KGDB 582 int maj; 583 584 /* we don't care about parity errors */ 585 maj = cdevsw_lookup_major(&ser_cdevsw); 586 if (kgdb_dev == makedev(maj, 0) && c == FRAME_END) 587 kgdb_connect(0); /* trap into kgdb */ 588 #endif 589 return; 590 } 591 592 /* 593 * Check for break and (if enabled) parity error. 594 */ 595 if ((stat & 0x1ff) == 0) { 596 if (break_in_progress) 597 return; 598 599 c = TTY_FE; 600 break_in_progress = 1; 601 #ifdef DDB 602 if (serconsole == 0) { 603 extern int db_active; 604 605 if (!db_active) { 606 console_debugger(); 607 return; 608 } 609 } 610 #endif 611 } else { 612 break_in_progress = 0; 613 if ((tp->t_cflag & PARENB) && 614 (((ch >> 7) + even_parity[ch & 0x7f] 615 + !!(tp->t_cflag & PARODD)) & 1)) 616 c |= TTY_PE; 617 } 618 619 if (stat & SERDATRF_OVRUN) 620 log(LOG_WARNING, "ser0: silo overflow\n"); 621 622 tp->t_linesw->l_rint(c, tp); 623 } 624 625 /* 626 * This interrupt is periodically invoked in the vertical blank 627 * interrupt. It's used to keep track of the modem control lines 628 * and (new with the fast_int code) to move accumulated data 629 * up into the tty layer. 630 */ 631 void 632 sermint(int unit) 633 { 634 struct tty *tp; 635 u_char stat, last, istat; 636 637 tp = ser_tty; 638 if (!tp) 639 return; 640 641 /* 642 if ((tp->t_state & TS_ISOPEN) == 0 || tp->t_wopen == 0) { 643 sbrpt = sbwpt = serbuf; 644 return; 645 } 646 */ 647 /* 648 * empty buffer 649 */ 650 serintr(); 651 652 stat = ciab.pra; 653 last = last_ciab_pra; 654 last_ciab_pra = stat; 655 656 /* 657 * check whether any interesting signal changed state 658 */ 659 istat = stat ^ last; 660 661 if (istat & serdcd) { 662 tp->t_linesw->l_modem(tp, ISDCD(stat)); 663 } 664 665 if ((istat & CIAB_PRA_CTS) && (tp->t_state & TS_ISOPEN) && 666 (tp->t_cflag & CRTSCTS)) { 667 #if 0 668 /* the line is up and we want to do rts/cts flow control */ 669 if (ISCTS(stat)) { 670 tp->t_state &= ~TS_TTSTOP; 671 ttstart(tp); 672 /* cause tbe-int if we were stuck there */ 673 custom.intreq = INTF_SETCLR | INTF_TBE; 674 } else 675 tp->t_state |= TS_TTSTOP; 676 #else 677 /* do this on hardware level, not with tty driver */ 678 if (ISCTS(stat)) { 679 tp->t_state &= ~TS_TTSTOP; 680 /* cause TBE interrupt */ 681 custom.intreq = INTF_SETCLR | INTF_TBE; 682 } 683 #endif 684 } 685 } 686 687 int 688 serioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct lwp *l) 689 { 690 register struct tty *tp; 691 register int error; 692 693 tp = ser_tty; 694 if (!tp) 695 return ENXIO; 696 697 error = tp->t_linesw->l_ioctl(tp, cmd, data, flag, l); 698 if (error != EPASSTHROUGH) 699 return(error); 700 701 error = ttioctl(tp, cmd, data, flag, l); 702 if (error != EPASSTHROUGH) 703 return(error); 704 705 switch (cmd) { 706 case TIOCSBRK: 707 custom.adkcon = ADKCONF_SETCLR | ADKCONF_UARTBRK; 708 break; 709 710 case TIOCCBRK: 711 custom.adkcon = ADKCONF_UARTBRK; 712 break; 713 714 case TIOCSDTR: 715 (void) sermctl(dev, TIOCM_DTR, DMBIS); 716 break; 717 718 case TIOCCDTR: 719 (void) sermctl(dev, TIOCM_DTR, DMBIC); 720 break; 721 722 case TIOCMSET: 723 (void) sermctl(dev, *(int *) data, DMSET); 724 break; 725 726 case TIOCMBIS: 727 (void) sermctl(dev, *(int *) data, DMBIS); 728 break; 729 730 case TIOCMBIC: 731 (void) sermctl(dev, *(int *) data, DMBIC); 732 break; 733 734 case TIOCMGET: 735 *(int *)data = sermctl(dev, 0, DMGET); 736 break; 737 case TIOCGFLAGS: 738 *(int *)data = serswflags; 739 break; 740 case TIOCSFLAGS: 741 error = kauth_authorize_device_tty(l->l_cred, 742 KAUTH_DEVICE_TTY_PRIVSET, tp); 743 if (error != 0) 744 return(EPERM); 745 746 serswflags = *(int *)data; 747 serswflags &= /* only allow valid flags */ 748 (TIOCFLAG_SOFTCAR | TIOCFLAG_CLOCAL | TIOCFLAG_CRTSCTS); 749 break; 750 default: 751 return(EPASSTHROUGH); 752 } 753 754 return(0); 755 } 756 757 int 758 serparam(struct tty *tp, struct termios *t) 759 { 760 int cflag, ospeed = 0; 761 762 if (t->c_ospeed > 0) { 763 if (t->c_ospeed < 110) 764 return(EINVAL); 765 ospeed = SERBRD(t->c_ospeed); 766 } 767 768 if (t->c_ispeed && t->c_ispeed != t->c_ospeed) 769 return(EINVAL); 770 771 if (serswflags & TIOCFLAG_SOFTCAR || serconsole == 0) { 772 t->c_cflag = (t->c_cflag & ~HUPCL) | CLOCAL; 773 } 774 775 /* if no changes, dont do anything. com.c explains why. */ 776 if (tp->t_ospeed == t->c_ospeed && 777 tp->t_cflag == t->c_cflag) 778 return (0); 779 780 cflag = t->c_cflag; 781 782 if (cflag & (CLOCAL | MDMBUF)) 783 serdcd = 0; 784 else 785 serdcd = CIAB_PRA_CD; 786 787 /* TODO: support multiple flow control protocols like com.c */ 788 789 /* 790 * copy to tty 791 */ 792 tp->t_ispeed = t->c_ispeed; 793 tp->t_ospeed = t->c_ospeed; 794 tp->t_cflag = cflag; 795 ser_open_speed = tp->t_ispeed; 796 797 /* 798 * enable interrupts 799 */ 800 custom.intena = INTF_SETCLR | INTF_RBF | INTF_TBE; 801 last_ciab_pra = ciab.pra; 802 803 if (t->c_ospeed == 0) 804 (void)sermctl(tp->t_dev, 0, DMSET); /* hang up line */ 805 else { 806 /* 807 * (re)enable DTR 808 * and set baud rate. (8 bit mode) 809 */ 810 (void)sermctl(tp->t_dev, TIOCM_DTR, DMSET); 811 custom.serper = (0 << 15) | ospeed; 812 } 813 (void)tp->t_linesw->l_modem(tp, ISDCD(last_ciab_pra)); 814 815 return(0); 816 } 817 818 int serhwiflow(struct tty *tp, int flag) 819 { 820 #if 0 821 printf ("serhwiflow %d\n", flag); 822 #endif 823 if (flag) 824 CLRRTS(ciab.pra); 825 else 826 SETRTS(ciab.pra); 827 return 1; 828 } 829 830 static void 831 ser_putchar(struct tty *tp, u_short c) 832 { 833 if ((tp->t_cflag & CSIZE) == CS7 || (tp->t_cflag & PARENB)) 834 c &= 0x7f; 835 836 /* 837 * handle parity if necessary 838 */ 839 if (tp->t_cflag & PARENB) { 840 if (even_parity[c]) 841 c |= 0x80; 842 if (tp->t_cflag & PARODD) 843 c ^= 0x80; 844 } 845 /* 846 * add stop bit(s) 847 */ 848 if (tp->t_cflag & CSTOPB) 849 c |= 0x300; 850 else 851 c |= 0x100; 852 853 custom.serdat = c; 854 } 855 856 857 static u_char ser_outbuf[SEROBUF_SIZE]; 858 static u_char *sob_ptr = ser_outbuf, *sob_end = ser_outbuf; 859 860 void 861 ser_outintr(void) 862 { 863 struct tty *tp; 864 int s; 865 866 tp = ser_tty; 867 s = spltty(); 868 869 if (tp == 0) 870 goto out; 871 872 if ((custom.intreqr & INTF_TBE) == 0) 873 goto out; 874 875 /* 876 * clear interrupt 877 */ 878 custom.intreq = INTF_TBE; 879 880 if (sob_ptr == sob_end) { 881 tp->t_state &= ~(TS_BUSY | TS_FLUSH); 882 if (tp->t_linesw) 883 tp->t_linesw->l_start(tp); 884 else 885 serstart(tp); 886 goto out; 887 } 888 889 /* 890 * Do hardware flow control here. if the CTS line goes down, don't 891 * transmit anything. That way, we'll be restarted by the periodic 892 * interrupt when CTS comes back up. 893 */ 894 if (ISCTS(ciab.pra)) 895 ser_putchar(tp, *sob_ptr++); 896 else 897 CLRCTS(last_ciab_pra); /* Remember that CTS is off */ 898 out: 899 splx(s); 900 } 901 902 void 903 serstart(struct tty *tp) 904 { 905 int cc, s, hiwat; 906 #ifdef DIAGNOSTIC 907 int unit; 908 #endif 909 910 hiwat = 0; 911 912 if ((tp->t_state & TS_ISOPEN) == 0) 913 return; 914 915 #ifdef DIAGNOSTIC 916 unit = SERUNIT(tp->t_dev); 917 if (unit) 918 panic("serstart: unit is %d", unit); 919 #endif 920 921 s = spltty(); 922 if (tp->t_state & (TS_TIMEOUT | TS_TTSTOP)) 923 goto out; 924 925 cc = tp->t_outq.c_cc; 926 if (cc <= tp->t_lowat) { 927 if (tp->t_state & TS_ASLEEP) { 928 tp->t_state &= ~TS_ASLEEP; 929 wakeup((caddr_t) & tp->t_outq); 930 } 931 selwakeup(&tp->t_wsel); 932 } 933 if (cc == 0 || (tp->t_state & TS_BUSY)) 934 goto out; 935 936 /* 937 * We only do bulk transfers if using CTSRTS flow control, not for 938 * (probably sloooow) ixon/ixoff devices. 939 */ 940 if ((tp->t_cflag & CRTSCTS) == 0) 941 cc = 1; 942 943 /* 944 * Limit the amount of output we do in one burst 945 * to prevent hogging the CPU. 946 */ 947 if (cc > SEROBUF_SIZE) { 948 hiwat++; 949 cc = SEROBUF_SIZE; 950 } 951 cc = q_to_b(&tp->t_outq, ser_outbuf, cc); 952 if (cc > 0) { 953 tp->t_state |= TS_BUSY; 954 955 sob_ptr = ser_outbuf; 956 sob_end = ser_outbuf + cc; 957 958 /* 959 * Get first character out, then have TBE-interrupts blow out 960 * further characters, until buffer is empty, and TS_BUSY gets 961 * cleared. 962 */ 963 ser_putchar(tp, *sob_ptr++); 964 } 965 out: 966 splx(s); 967 } 968 969 /* 970 * Stop output on a line. 971 */ 972 /*ARGSUSED*/ 973 void 974 serstop(struct tty *tp, int flag) 975 { 976 int s; 977 978 s = spltty(); 979 if (tp->t_state & TS_BUSY) { 980 if ((tp->t_state & TS_TTSTOP) == 0) 981 tp->t_state |= TS_FLUSH; 982 } 983 splx(s); 984 } 985 986 int 987 sermctl(dev_t dev, int bits, int how) 988 { 989 int s; 990 u_char ub = 0; 991 992 /* 993 * convert TIOCM* mask into CIA mask 994 * which is active low 995 */ 996 if (how != DMGET) { 997 ub = 0; 998 if (bits & TIOCM_DTR) 999 ub |= CIAB_PRA_DTR; 1000 if (bits & TIOCM_RTS) 1001 ub |= CIAB_PRA_RTS; 1002 if (bits & TIOCM_CTS) 1003 ub |= CIAB_PRA_CTS; 1004 if (bits & TIOCM_CD) 1005 ub |= CIAB_PRA_CD; 1006 if (bits & TIOCM_RI) 1007 ub |= CIAB_PRA_SEL; /* collision with /dev/par ! */ 1008 if (bits & TIOCM_DSR) 1009 ub |= CIAB_PRA_DSR; 1010 } 1011 s = spltty(); 1012 switch (how) { 1013 case DMSET: 1014 /* invert and set */ 1015 ciab.pra = ~ub; 1016 break; 1017 1018 case DMBIC: 1019 ciab.pra |= ub; 1020 ub = ~ciab.pra; 1021 break; 1022 1023 case DMBIS: 1024 ciab.pra &= ~ub; 1025 ub = ~ciab.pra; 1026 break; 1027 1028 case DMGET: 1029 ub = ~ciab.pra; 1030 break; 1031 } 1032 (void)splx(s); 1033 1034 bits = 0; 1035 if (ub & CIAB_PRA_DTR) 1036 bits |= TIOCM_DTR; 1037 if (ub & CIAB_PRA_RTS) 1038 bits |= TIOCM_RTS; 1039 if (ub & CIAB_PRA_CTS) 1040 bits |= TIOCM_CTS; 1041 if (ub & CIAB_PRA_CD) 1042 bits |= TIOCM_CD; 1043 if (ub & CIAB_PRA_SEL) 1044 bits |= TIOCM_RI; 1045 if (ub & CIAB_PRA_DSR) 1046 bits |= TIOCM_DSR; 1047 1048 return(bits); 1049 } 1050 1051 /* 1052 * Following are all routines needed for SER to act as console 1053 */ 1054 void 1055 sercnprobe(struct consdev *cp) 1056 { 1057 int maj, unit; 1058 #ifdef KGDB 1059 extern const struct cdevsw ctty_cdevsw; 1060 #endif 1061 1062 /* locate the major number */ 1063 maj = cdevsw_lookup_major(&ser_cdevsw); 1064 1065 1066 unit = CONUNIT; /* XXX: ick */ 1067 1068 /* 1069 * initialize required fields 1070 */ 1071 cp->cn_dev = makedev(maj, unit); 1072 if (serconsole == unit) 1073 cp->cn_pri = CN_REMOTE; 1074 else 1075 cp->cn_pri = CN_NORMAL; 1076 #ifdef KGDB 1077 /* XXX */ 1078 if (cdevsw_lookup(kgdb_dev) == &ctty_cdevsw) 1079 kgdb_dev = makedev(maj, minor(kgdb_dev)); 1080 #endif 1081 } 1082 1083 void 1084 sercninit(struct consdev *cp) 1085 { 1086 int unit; 1087 1088 unit = SERUNIT(cp->cn_dev); 1089 1090 serinit(serdefaultrate); 1091 serconsole = unit; 1092 serconsinit = 1; 1093 } 1094 1095 void 1096 serinit(int rate) 1097 { 1098 int s; 1099 1100 s = splser(); 1101 /* 1102 * might want to fiddle with the CIA later ??? 1103 */ 1104 custom.serper = (rate>=110 ? SERBRD(rate) : 0); 1105 splx(s); 1106 } 1107 1108 int 1109 sercngetc(dev_t dev) 1110 { 1111 u_short stat; 1112 int c, s; 1113 1114 s = splser(); 1115 /* 1116 * poll 1117 */ 1118 while (((stat = custom.serdatr & 0xffff) & SERDATRF_RBF) == 0) 1119 ; 1120 1121 c = stat & 0xff; 1122 /* 1123 * clear interrupt 1124 */ 1125 custom.intreq = INTF_RBF; 1126 splx(s); 1127 1128 return(c); 1129 } 1130 1131 /* 1132 * Console kernel output character routine. 1133 */ 1134 void 1135 sercnputc(dev_t dev, int c) 1136 { 1137 register int timo; 1138 int s; 1139 1140 s = splhigh(); 1141 1142 if (serconsinit == 0) { 1143 (void)serinit(serdefaultrate); 1144 serconsinit = 1; 1145 } 1146 1147 /* 1148 * wait for any pending transmission to finish 1149 */ 1150 timo = 50000; 1151 while (!(custom.serdatr & SERDATRF_TBE) && --timo); 1152 1153 /* 1154 * transmit char. 1155 */ 1156 custom.serdat = (c & 0xff) | 0x100; 1157 1158 /* 1159 * wait for this transmission to complete 1160 */ 1161 timo = 1500000; 1162 while (!(custom.serdatr & SERDATRF_TBE) && --timo) 1163 ; 1164 1165 /* 1166 * Wait for the device (my vt100..) to process the data, since we 1167 * don't do flow-control with cnputc 1168 */ 1169 for (timo = 0; timo < 30000; timo++) 1170 ; 1171 1172 /* 1173 * We set TBE so that ser_outintr() is called right after to check 1174 * whether there still are chars to process. 1175 * We used to clear this, but it hung the tty output if the kernel 1176 * output a char while userland did on the same serial port. 1177 */ 1178 custom.intreq = INTF_SETCLR | INTF_TBE; 1179 splx(s); 1180 } 1181 1182 void 1183 sercnpollc(dev_t dev, int on) 1184 { 1185 } 1186 #endif 1187