1 /* $NetBSD: mfc.c,v 1.35 2004/04/25 06:23:41 matt Exp $ */ 2 3 /* 4 * Copyright (c) 1982, 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 32 #include "opt_kgdb.h" 33 34 /* 35 * Copyright (c) 1994 Michael L. Hitch 36 * 37 * Redistribution and use in source and binary forms, with or without 38 * modification, are permitted provided that the following conditions 39 * are met: 40 * 1. Redistributions of source code must retain the above copyright 41 * notice, this list of conditions and the following disclaimer. 42 * 2. Redistributions in binary form must reproduce the above copyright 43 * notice, this list of conditions and the following disclaimer in the 44 * documentation and/or other materials provided with the distribution. 45 * 46 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 47 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 48 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 49 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 50 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 51 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 52 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 53 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 54 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 55 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 56 */ 57 58 #include "opt_kgdb.h" 59 60 #include <sys/cdefs.h> 61 __KERNEL_RCSID(0, "$NetBSD: mfc.c,v 1.35 2004/04/25 06:23:41 matt Exp $"); 62 63 #include <sys/param.h> 64 #include <sys/systm.h> 65 #include <sys/kernel.h> 66 #include <sys/device.h> 67 #include <sys/tty.h> 68 #include <sys/proc.h> 69 #include <sys/file.h> 70 #include <sys/malloc.h> 71 #include <sys/uio.h> 72 #include <sys/kernel.h> 73 #include <sys/syslog.h> 74 #include <sys/queue.h> 75 #include <sys/conf.h> 76 #include <machine/cpu.h> 77 #include <amiga/amiga/device.h> 78 #include <amiga/amiga/isr.h> 79 #include <amiga/amiga/custom.h> 80 #include <amiga/amiga/cia.h> 81 #include <amiga/amiga/cc.h> 82 #include <amiga/dev/zbusvar.h> 83 84 #include <dev/cons.h> 85 86 #include "mfcs.h" 87 88 #ifndef SEROBUF_SIZE 89 #define SEROBUF_SIZE 128 90 #endif 91 #ifndef SERIBUF_SIZE 92 #define SERIBUF_SIZE 1024 93 #endif 94 95 #define splser() spl6() 96 97 /* 98 * 68581 DUART registers 99 */ 100 struct mfc_regs { 101 volatile u_char du_mr1a; 102 #define du_mr2a du_mr1a 103 u_char pad0; 104 volatile u_char du_csra; 105 #define du_sra du_csra 106 u_char pad2; 107 volatile u_char du_cra; 108 u_char pad4; 109 volatile u_char du_tba; 110 #define du_rba du_tba 111 u_char pad6; 112 volatile u_char du_acr; 113 #define du_ipcr du_acr 114 u_char pad8; 115 volatile u_char du_imr; 116 #define du_isr du_imr 117 u_char pad10; 118 volatile u_char du_ctur; 119 #define du_cmsb du_ctur 120 u_char pad12; 121 volatile u_char du_ctlr; 122 #define du_clsb du_ctlr 123 u_char pad14; 124 volatile u_char du_mr1b; 125 #define du_mr2b du_mr1b 126 u_char pad16; 127 volatile u_char du_csrb; 128 #define du_srb du_csrb 129 u_char pad18; 130 volatile u_char du_crb; 131 u_char pad20; 132 volatile u_char du_tbb; 133 #define du_rbb du_tbb 134 u_char pad22; 135 volatile u_char du_ivr; 136 u_char pad24; 137 volatile u_char du_opcr; 138 #define du_ip du_opcr 139 u_char pad26; 140 volatile u_char du_btst; 141 #define du_strc du_btst 142 u_char pad28; 143 volatile u_char du_btrst; 144 #define du_stpc du_btrst 145 u_char pad30; 146 }; 147 148 /* 149 * 68681 DUART serial port registers 150 */ 151 struct duart_regs { 152 volatile u_char ch_mr1; 153 #define ch_mr2 ch_mr1 154 u_char pad0; 155 volatile u_char ch_csr; 156 #define ch_sr ch_csr 157 u_char pad1; 158 volatile u_char ch_cr; 159 u_char pad2; 160 volatile u_char ch_tb; 161 #define ch_rb ch_tb 162 u_char pad3; 163 }; 164 165 struct mfc_softc { 166 struct device sc_dev; 167 struct isr sc_isr; 168 struct mfc_regs *sc_regs; 169 u_long clk_frq; 170 u_short ct_val; 171 u_char ct_usecnt; 172 u_char imask; 173 u_char mfc_iii; 174 u_char last_ip; 175 }; 176 177 #if NMFCS > 0 178 struct mfcs_softc { 179 struct device sc_dev; 180 struct tty *sc_tty; 181 struct duart_regs *sc_duart; 182 struct mfc_regs *sc_regs; 183 struct mfc_softc *sc_mfc; 184 int swflags; 185 long flags; /* XXX */ 186 #define CT_USED 1 /* CT in use */ 187 u_short *rptr, *wptr, incnt, ovfl; 188 u_short inbuf[SERIBUF_SIZE]; 189 char *ptr, *end; 190 char outbuf[SEROBUF_SIZE]; 191 struct vbl_node vbl_node; 192 }; 193 #endif 194 195 #if NMFCP > 0 196 struct mfcp_softc { 197 }; 198 #endif 199 200 struct mfc_args { 201 struct zbus_args zargs; 202 char *subdev; 203 char unit; 204 }; 205 206 int mfcprint(void *auxp, const char *); 207 void mfcattach(struct device *, struct device *, void *); 208 int mfcmatch(struct device *, struct cfdata *, void *); 209 210 #if NMFCS > 0 211 int mfcsmatch(struct device *, struct cfdata *, void *); 212 void mfcsattach(struct device *, struct device *, void *); 213 int mfcsparam( struct tty *, struct termios *); 214 int mfcshwiflow(struct tty *, int); 215 void mfcsstart(struct tty *); 216 int mfcsmctl(dev_t, int, int); 217 void mfcsxintr(int); 218 void mfcseint(int, int); 219 void mfcsmint(register int); 220 #endif 221 222 #if NMFCP > 0 223 void mfcpattach(struct device *, struct device *, void *); 224 int mfcpmatch(struct device *, struct cfdata *, void *); 225 #endif 226 int mfcintr(void *); 227 228 CFATTACH_DECL(mfc, sizeof(struct mfc_softc), 229 mfcmatch, mfcattach, NULL, NULL); 230 231 #if NMFCS > 0 232 CFATTACH_DECL(mfcs, sizeof(struct mfcs_softc), 233 mfcsmatch, mfcsattach, NULL, NULL); 234 235 extern struct cfdriver mfcs_cd; 236 #endif 237 238 #if NMFCP > 0 239 CFATTACH_DECL(mfcp, sizeof(struct mfcp_softc), 240 mfcpmatch, mfcpattach, NULL, NULL); 241 #endif 242 243 dev_type_open(mfcsopen); 244 dev_type_close(mfcsclose); 245 dev_type_read(mfcsread); 246 dev_type_write(mfcswrite); 247 dev_type_ioctl(mfcsioctl); 248 dev_type_stop(mfcsstop); 249 dev_type_tty(mfcstty); 250 dev_type_poll(mfcspoll); 251 252 const struct cdevsw mfcs_cdevsw = { 253 mfcsopen, mfcsclose, mfcsread, mfcswrite, mfcsioctl, 254 mfcsstop, mfcstty, mfcspoll, nommap, ttykqfilter, D_TTY 255 }; 256 257 int mfcs_active; 258 int mfcsdefaultrate = 38400 /*TTYDEF_SPEED*/; 259 #define SWFLAGS(dev) (sc->swflags | (((dev) & 0x80) == 0 ? TIOCFLAG_SOFTCAR : 0)) 260 261 #ifdef notyet 262 /* 263 * MultiFaceCard III, II+ (not supported yet), and 264 * SerialMaster 500+ (not supported yet) 265 * baud rate tables for BRG set 1 [not used yet] 266 */ 267 268 const struct speedtab mfcs3speedtab1[] = { 269 { 0, 0 }, 270 { 100, 0x00 }, 271 { 220, 0x11 }, 272 { 600, 0x44 }, 273 { 1200, 0x55 }, 274 { 2400, 0x66 }, 275 { 4800, 0x88 }, 276 { 9600, 0x99 }, 277 { 19200, 0xbb }, 278 { 115200, 0xcc }, 279 { -1, -1 } 280 }; 281 282 /* 283 * MultiFaceCard II, I, and SerialMaster 500 284 * baud rate tables for BRG set 1 [not used yet] 285 */ 286 287 const struct speedtab mfcs2speedtab1[] = { 288 { 0, 0 }, 289 { 50, 0x00 }, 290 { 110, 0x11 }, 291 { 300, 0x44 }, 292 { 600, 0x55 }, 293 { 1200, 0x66 }, 294 { 2400, 0x88 }, 295 { 4800, 0x99 }, 296 { 9600, 0xbb }, 297 { 38400, 0xcc }, 298 { -1, -1 } 299 }; 300 #endif 301 302 /* 303 * MultiFaceCard III, II+ (not supported yet), and 304 * SerialMaster 500+ (not supported yet) 305 * baud rate tables for BRG set 2 306 */ 307 308 const struct speedtab mfcs3speedtab2[] = { 309 { 0, 0 }, 310 { 150, 0x00 }, 311 { 200, 0x11 }, 312 { 300, 0x33 }, 313 { 600, 0x44 }, 314 { 1200, 0x55 }, 315 { 2400, 0x66 }, 316 { 4800, 0x88 }, 317 { 9600, 0x99 }, 318 { 19200, 0xbb }, 319 { 38400, 0xcc }, 320 { -1, -1 } 321 }; 322 323 /* 324 * MultiFaceCard II, I, and SerialMaster 500 325 * baud rate tables for BRG set 2 326 */ 327 328 const struct speedtab mfcs2speedtab2[] = { 329 { 0, 0 }, 330 { 75, 0x00 }, 331 { 100, 0x11 }, 332 { 150, 0x33 }, 333 { 300, 0x44 }, 334 { 600, 0x55 }, 335 { 1200, 0x66 }, 336 { 2400, 0x88 }, 337 { 4800, 0x99 }, 338 { 9600, 0xbb }, 339 { 19200, 0xcc }, 340 { -1, -1 } 341 }; 342 343 /* 344 * if we are an bsc/Alf Data MultFaceCard (I, II, and III) 345 */ 346 int 347 mfcmatch(struct device *pdp, struct cfdata *cfp, void *auxp) 348 { 349 struct zbus_args *zap; 350 351 zap = auxp; 352 if (zap->manid == 2092 && 353 (zap->prodid == 16 || zap->prodid == 17 || zap->prodid == 18)) 354 355 return(1); 356 return(0); 357 } 358 359 void 360 mfcattach(struct device *pdp, struct device *dp, void *auxp) 361 { 362 struct mfc_softc *scc; 363 struct zbus_args *zap; 364 struct mfc_args ma; 365 int unit; 366 struct mfc_regs *rp; 367 368 zap = auxp; 369 370 printf ("\n"); 371 372 scc = (struct mfc_softc *)dp; 373 unit = scc->sc_dev.dv_unit; 374 scc->sc_regs = rp = zap->va; 375 if (zap->prodid == 18) 376 scc->mfc_iii = 3; 377 scc->clk_frq = scc->mfc_iii ? 230400 : 115200; 378 379 rp->du_opcr = 0x00; /* configure output port? */ 380 rp->du_btrst = 0x0f; /* clear modem lines */ 381 rp->du_ivr = 0; /* IVR */ 382 rp->du_imr = 0; /* IMR */ 383 rp->du_acr = 0xe0; /* baud rate generate set 2 */ 384 rp->du_ctur = 0; 385 rp->du_ctlr = 4; 386 rp->du_csra = 0xcc; /* clock select = 38400 */ 387 rp->du_cra = 0x10; /* reset mode register ptr */ 388 rp->du_cra = 0x20; 389 rp->du_cra = 0x30; 390 rp->du_cra = 0x40; 391 rp->du_mr1a = 0x93; /* MRA1 */ 392 rp->du_mr2a = 0x17; /* MRA2 */ 393 rp->du_csrb = 0xcc; /* clock select = 38400 */ 394 rp->du_crb = 0x10; /* reset mode register ptr */ 395 rp->du_crb = 0x20; 396 rp->du_crb = 0x30; 397 rp->du_crb = 0x40; 398 rp->du_mr1b = 0x93; /* MRB1 */ 399 rp->du_mr2b = 0x17; /* MRB2 */ 400 rp->du_cra = 0x05; /* enable A Rx & Tx */ 401 rp->du_crb = 0x05; /* enable B Rx & Tx */ 402 403 scc->sc_isr.isr_intr = mfcintr; 404 scc->sc_isr.isr_arg = scc; 405 scc->sc_isr.isr_ipl = 6; 406 add_isr(&scc->sc_isr); 407 408 /* configure ports */ 409 bcopy(zap, &ma.zargs, sizeof(struct zbus_args)); 410 ma.subdev = "mfcs"; 411 ma.unit = unit * 2; 412 config_found(dp, &ma, mfcprint); 413 ma.unit = unit * 2 + 1; 414 config_found(dp, &ma, mfcprint); 415 ma.subdev = "mfcp"; 416 ma.unit = unit; 417 config_found(dp, &ma, mfcprint); 418 } 419 420 /* 421 * 422 */ 423 int 424 mfcsmatch(struct device *pdp, struct cfdata *cfp, void *auxp) 425 { 426 struct mfc_args *ma; 427 428 ma = auxp; 429 if (strcmp(ma->subdev, "mfcs") == 0) 430 return (1); 431 return (0); 432 } 433 434 void 435 mfcsattach(struct device *pdp, struct device *dp, void *auxp) 436 { 437 int unit; 438 struct mfcs_softc *sc; 439 struct mfc_softc *scc; 440 struct mfc_args *ma; 441 struct mfc_regs *rp; 442 443 sc = (struct mfcs_softc *) dp; 444 scc = (struct mfc_softc *) pdp; 445 ma = auxp; 446 447 if (dp) { 448 printf (": input fifo %d output fifo %d\n", SERIBUF_SIZE, 449 SEROBUF_SIZE); 450 alloc_sicallback(); 451 } 452 453 unit = ma->unit; 454 mfcs_active |= 1 << unit; 455 sc->rptr = sc->wptr = sc->inbuf; 456 sc->sc_mfc = scc; 457 sc->sc_regs = rp = scc->sc_regs; 458 sc->sc_duart = (struct duart_regs *) ((unit & 1) ? &rp->du_mr1b : 459 &rp->du_mr1a); 460 /* 461 * should have only one vbl routine to handle all ports? 462 */ 463 sc->vbl_node.function = (void (*) (void *)) mfcsmint; 464 sc->vbl_node.data = (void *) unit; 465 add_vbl_function(&sc->vbl_node, 1, (void *) unit); 466 } 467 468 /* 469 * print diag if pnp is NULL else just extra 470 */ 471 int 472 mfcprint(void *auxp, const char *pnp) 473 { 474 if (pnp == NULL) 475 return(UNCONF); 476 return(QUIET); 477 } 478 479 int 480 mfcsopen(dev_t dev, int flag, int mode, struct proc *p) 481 { 482 struct tty *tp; 483 struct mfcs_softc *sc; 484 int unit, error, s; 485 486 error = 0; 487 unit = dev & 0x1f; 488 489 if (unit >= mfcs_cd.cd_ndevs || (mfcs_active & (1 << unit)) == 0) 490 return (ENXIO); 491 sc = mfcs_cd.cd_devs[unit]; 492 493 s = spltty(); 494 495 if (sc->sc_tty) 496 tp = sc->sc_tty; 497 else { 498 tp = sc->sc_tty = ttymalloc(); 499 tty_attach(tp); 500 } 501 502 tp->t_oproc = (void (*) (struct tty *)) mfcsstart; 503 tp->t_param = mfcsparam; 504 tp->t_dev = dev; 505 tp->t_hwiflow = mfcshwiflow; 506 507 if ((tp->t_state & TS_ISOPEN) == 0 && tp->t_wopen == 0) { 508 ttychars(tp); 509 if (tp->t_ispeed == 0) { 510 /* 511 * only when cleared do we reset to defaults. 512 */ 513 tp->t_iflag = TTYDEF_IFLAG; 514 tp->t_oflag = TTYDEF_OFLAG; 515 tp->t_cflag = TTYDEF_CFLAG; 516 tp->t_lflag = TTYDEF_LFLAG; 517 tp->t_ispeed = tp->t_ospeed = mfcsdefaultrate; 518 } 519 /* 520 * do these all the time 521 */ 522 if (sc->swflags & TIOCFLAG_CLOCAL) 523 tp->t_cflag |= CLOCAL; 524 if (sc->swflags & TIOCFLAG_CRTSCTS) 525 tp->t_cflag |= CRTSCTS; 526 if (sc->swflags & TIOCFLAG_MDMBUF) 527 tp->t_cflag |= MDMBUF; 528 mfcsparam(tp, &tp->t_termios); 529 ttsetwater(tp); 530 531 (void)mfcsmctl(dev, TIOCM_DTR | TIOCM_RTS, DMSET); 532 if ((SWFLAGS(dev) & TIOCFLAG_SOFTCAR) || 533 (mfcsmctl(dev, 0, DMGET) & TIOCM_CD)) 534 tp->t_state |= TS_CARR_ON; 535 else 536 tp->t_state &= ~TS_CARR_ON; 537 } else if (tp->t_state & TS_XCLUDE && p->p_ucred->cr_uid != 0) { 538 splx(s); 539 return(EBUSY); 540 } 541 542 /* 543 * if NONBLOCK requested, ignore carrier 544 */ 545 if (flag & O_NONBLOCK) 546 goto done; 547 548 /* 549 * block waiting for carrier 550 */ 551 while ((tp->t_state & TS_CARR_ON) == 0 && (tp->t_cflag & CLOCAL) == 0) { 552 tp->t_wopen++; 553 error = ttysleep(tp, (caddr_t)&tp->t_rawq, 554 TTIPRI | PCATCH, ttopen, 0); 555 tp->t_wopen--; 556 if (error) { 557 splx(s); 558 return(error); 559 } 560 } 561 done: 562 /* This is a way to handle lost XON characters */ 563 if ((flag & O_TRUNC) && (tp->t_state & TS_TTSTOP)) { 564 tp->t_state &= ~TS_TTSTOP; 565 ttstart (tp); 566 } 567 568 splx(s); 569 /* 570 * Reset the tty pointer, as there could have been a dialout 571 * use of the tty with a dialin open waiting. 572 */ 573 tp->t_dev = dev; 574 return tp->t_linesw->l_open(dev, tp); 575 } 576 577 /*ARGSUSED*/ 578 int 579 mfcsclose(dev_t dev, int flag, int mode, struct proc *p) 580 { 581 struct tty *tp; 582 int unit; 583 struct mfcs_softc *sc = mfcs_cd.cd_devs[dev & 31]; 584 struct mfc_softc *scc= sc->sc_mfc; 585 586 unit = dev & 31; 587 588 tp = sc->sc_tty; 589 tp->t_linesw->l_close(tp, flag); 590 sc->sc_duart->ch_cr = 0x70; /* stop break */ 591 592 scc->imask &= ~(0x7 << ((unit & 1) * 4)); 593 scc->sc_regs->du_imr = scc->imask; 594 if (sc->flags & CT_USED) { 595 --scc->ct_usecnt; 596 sc->flags &= ~CT_USED; 597 } 598 599 /* 600 * If the device is closed, it's close, no matter whether we deal with 601 * modem control signals nor not. 602 */ 603 #if 0 604 if (tp->t_cflag & HUPCL || tp->t_wopen != 0 || 605 (tp->t_state & TS_ISOPEN) == 0) 606 #endif 607 (void) mfcsmctl(dev, 0, DMSET); 608 ttyclose(tp); 609 #if not_yet 610 if (tp != &mfcs_cons) { 611 remove_vbl_function(&sc->vbl_node); 612 ttyfree(tp); 613 sc->sc_tty = (struct tty *) NULL; 614 } 615 #endif 616 return (0); 617 } 618 619 int 620 mfcsread(dev_t dev, struct uio *uio, int flag) 621 { 622 struct mfcs_softc *sc = mfcs_cd.cd_devs[dev & 31]; 623 struct tty *tp = sc->sc_tty; 624 if (tp == NULL) 625 return(ENXIO); 626 return tp->t_linesw->l_read(tp, uio, flag); 627 } 628 629 int 630 mfcswrite(dev_t dev, struct uio *uio, int flag) 631 { 632 struct mfcs_softc *sc = mfcs_cd.cd_devs[dev & 31]; 633 struct tty *tp = sc->sc_tty; 634 635 if (tp == NULL) 636 return(ENXIO); 637 return tp->t_linesw->l_write(tp, uio, flag); 638 } 639 640 int 641 mfcspoll(dev_t dev, int events, struct proc *p) 642 { 643 struct mfcs_softc *sc = mfcs_cd.cd_devs[dev & 31]; 644 struct tty *tp = sc->sc_tty; 645 646 if (tp == NULL) 647 return(ENXIO); 648 return ((*tp->t_linesw->l_poll)(tp, events, p)); 649 } 650 651 struct tty * 652 mfcstty(dev_t dev) 653 { 654 struct mfcs_softc *sc = mfcs_cd.cd_devs[dev & 31]; 655 656 return (sc->sc_tty); 657 } 658 659 int 660 mfcsioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p) 661 { 662 register struct tty *tp; 663 register int error; 664 struct mfcs_softc *sc = mfcs_cd.cd_devs[dev & 31]; 665 666 tp = sc->sc_tty; 667 if (!tp) 668 return ENXIO; 669 670 error = tp->t_linesw->l_ioctl(tp, cmd, data, flag, p); 671 if (error != EPASSTHROUGH) 672 return(error); 673 674 error = ttioctl(tp, cmd, data, flag, p); 675 if (error != EPASSTHROUGH) 676 return(error); 677 678 switch (cmd) { 679 case TIOCSBRK: 680 sc->sc_duart->ch_cr = 0x60; /* start break */ 681 break; 682 683 case TIOCCBRK: 684 sc->sc_duart->ch_cr = 0x70; /* stop break */ 685 break; 686 687 case TIOCSDTR: 688 (void) mfcsmctl(dev, TIOCM_DTR | TIOCM_RTS, DMBIS); 689 break; 690 691 case TIOCCDTR: 692 (void) mfcsmctl(dev, TIOCM_DTR | TIOCM_RTS, DMBIC); 693 break; 694 695 case TIOCMSET: 696 (void) mfcsmctl(dev, *(int *) data, DMSET); 697 break; 698 699 case TIOCMBIS: 700 (void) mfcsmctl(dev, *(int *) data, DMBIS); 701 break; 702 703 case TIOCMBIC: 704 (void) mfcsmctl(dev, *(int *) data, DMBIC); 705 break; 706 707 case TIOCMGET: 708 *(int *)data = mfcsmctl(dev, 0, DMGET); 709 break; 710 case TIOCGFLAGS: 711 *(int *)data = SWFLAGS(dev); 712 break; 713 case TIOCSFLAGS: 714 error = suser(p->p_ucred, &p->p_acflag); 715 if (error != 0) 716 return(EPERM); 717 718 sc->swflags = *(int *)data; 719 sc->swflags &= /* only allow valid flags */ 720 (TIOCFLAG_SOFTCAR | TIOCFLAG_CLOCAL | TIOCFLAG_CRTSCTS); 721 /* XXXX need to change duart parameters? */ 722 break; 723 default: 724 return(EPASSTHROUGH); 725 } 726 727 return(0); 728 } 729 730 int 731 mfcsparam(struct tty *tp, struct termios *t) 732 { 733 int cflag, unit, ospeed; 734 struct mfcs_softc *sc = mfcs_cd.cd_devs[tp->t_dev & 31]; 735 struct mfc_softc *scc= sc->sc_mfc; 736 737 cflag = t->c_cflag; 738 unit = tp->t_dev & 31; 739 if (sc->flags & CT_USED) { 740 --scc->ct_usecnt; 741 sc->flags &= ~CT_USED; 742 } 743 ospeed = ttspeedtab(t->c_ospeed, scc->mfc_iii ? mfcs3speedtab2 : 744 mfcs2speedtab2); 745 746 /* 747 * If Baud Rate Generator can't generate requested speed, 748 * try to use the counter/timer. 749 */ 750 if (ospeed < 0 && (scc->clk_frq % t->c_ospeed) == 0) { 751 ospeed = scc->clk_frq / t->c_ospeed; /* divisor */ 752 if (scc->ct_usecnt > 0 && scc->ct_val != ospeed) 753 ospeed = -1; 754 else { 755 scc->sc_regs->du_ctur = ospeed >> 8; 756 scc->sc_regs->du_ctlr = ospeed; 757 scc->ct_val = ospeed; 758 ++scc->ct_usecnt; 759 sc->flags |= CT_USED; 760 ospeed = 0xdd; 761 } 762 } 763 /* XXXX 68681 duart could handle split speeds */ 764 if (ospeed < 0 || (t->c_ispeed && t->c_ispeed != t->c_ospeed)) 765 return(EINVAL); 766 767 /* XXXX handle parity, character size, stop bits, flow control */ 768 769 /* 770 * copy to tty 771 */ 772 tp->t_ispeed = t->c_ispeed; 773 tp->t_ospeed = t->c_ospeed; 774 tp->t_cflag = cflag; 775 776 /* 777 * enable interrupts 778 */ 779 scc->imask |= (0x2 << ((unit & 1) * 4)) | 0x80; 780 scc->sc_regs->du_imr = scc->imask; 781 #if defined(DEBUG) && 0 782 printf("mfcsparam: speed %d => %x ct %d imask %x cflag %x\n", 783 t->c_ospeed, ospeed, scc->ct_val, scc->imask, cflag); 784 #endif 785 if (ospeed == 0) 786 (void)mfcsmctl(tp->t_dev, 0, DMSET); /* hang up line */ 787 else { 788 /* 789 * (re)enable DTR 790 * and set baud rate. (8 bit mode) 791 */ 792 (void)mfcsmctl(tp->t_dev, TIOCM_DTR | TIOCM_RTS, DMSET); 793 sc->sc_duart->ch_csr = ospeed; 794 } 795 return(0); 796 } 797 798 int 799 mfcshwiflow(struct tty *tp, int flag) 800 { 801 struct mfcs_softc *sc = mfcs_cd.cd_devs[tp->t_dev & 31]; 802 int unit = tp->t_dev & 1; 803 804 if (flag) 805 sc->sc_regs->du_btrst = 1 << unit; 806 else 807 sc->sc_regs->du_btst = 1 << unit; 808 return 1; 809 } 810 811 void 812 mfcsstart(struct tty *tp) 813 { 814 int cc, s, unit; 815 struct mfcs_softc *sc = mfcs_cd.cd_devs[tp->t_dev & 31]; 816 struct mfc_softc *scc= sc->sc_mfc; 817 818 if ((tp->t_state & TS_ISOPEN) == 0) 819 return; 820 821 unit = tp->t_dev & 1; 822 823 s = splser(); 824 if (tp->t_state & (TS_TIMEOUT | TS_TTSTOP)) 825 goto out; 826 827 cc = tp->t_outq.c_cc; 828 if (cc <= tp->t_lowat) { 829 if (tp->t_state & TS_ASLEEP) { 830 tp->t_state &= ~TS_ASLEEP; 831 wakeup((caddr_t) & tp->t_outq); 832 } 833 selwakeup(&tp->t_wsel); 834 } 835 if (cc == 0 || (tp->t_state & TS_BUSY)) 836 goto out; 837 838 /* 839 * We only do bulk transfers if using CTSRTS flow control, not for 840 * (probably sloooow) ixon/ixoff devices. 841 */ 842 if ((tp->t_cflag & CRTSCTS) == 0) 843 cc = 1; 844 845 /* 846 * Limit the amount of output we do in one burst 847 * to prevent hogging the CPU. 848 */ 849 if (cc > SEROBUF_SIZE) 850 cc = SEROBUF_SIZE; 851 cc = q_to_b(&tp->t_outq, sc->outbuf, cc); 852 if (cc > 0) { 853 tp->t_state |= TS_BUSY; 854 855 sc->ptr = sc->outbuf; 856 sc->end = sc->outbuf + cc; 857 858 /* 859 * Get first character out, then have TBE-interrupts blow out 860 * further characters, until buffer is empty, and TS_BUSY gets 861 * cleared. 862 */ 863 sc->sc_duart->ch_tb = *sc->ptr++; 864 scc->imask |= 1 << (unit * 4); 865 sc->sc_regs->du_imr = scc->imask; 866 } 867 out: 868 splx(s); 869 } 870 871 /* 872 * Stop output on a line. 873 */ 874 /*ARGSUSED*/ 875 void 876 mfcsstop(struct tty *tp, int flag) 877 { 878 int s; 879 880 s = splser(); 881 if (tp->t_state & TS_BUSY) { 882 if ((tp->t_state & TS_TTSTOP) == 0) 883 tp->t_state |= TS_FLUSH; 884 } 885 splx(s); 886 } 887 888 int 889 mfcsmctl(dev_t dev, int bits, int how) 890 { 891 int unit, s; 892 u_char ub = 0; 893 struct mfcs_softc *sc = mfcs_cd.cd_devs[dev & 31]; 894 895 unit = dev & 1; 896 897 /* 898 * convert TIOCM* mask into CIA mask 899 * which is active low 900 */ 901 if (how != DMGET) { 902 /* 903 * need to save current state of DTR & RTS ? 904 */ 905 if (bits & TIOCM_DTR) 906 ub |= 0x04 << unit; 907 if (bits & TIOCM_RTS) 908 ub |= 0x01 << unit; 909 } 910 s = splser(); 911 switch (how) { 912 case DMSET: 913 sc->sc_regs->du_btst = ub; 914 sc->sc_regs->du_btrst = ub ^ (0x05 << unit); 915 break; 916 917 case DMBIC: 918 sc->sc_regs->du_btrst = ub; 919 ub = ~sc->sc_regs->du_ip; 920 break; 921 922 case DMBIS: 923 sc->sc_regs->du_btst = ub; 924 ub = ~sc->sc_regs->du_ip; 925 break; 926 927 case DMGET: 928 ub = ~sc->sc_regs->du_ip; 929 break; 930 } 931 (void)splx(s); 932 933 /* XXXX should keep DTR & RTS states in softc? */ 934 bits = TIOCM_DTR | TIOCM_RTS; 935 if (ub & (1 << unit)) 936 bits |= TIOCM_CTS; 937 if (ub & (4 << unit)) 938 bits |= TIOCM_DSR; 939 if (ub & (0x10 << unit)) 940 bits |= TIOCM_CD; 941 /* XXXX RI is not supported on all boards */ 942 if (sc->sc_regs->pad26 & (1 << unit)) 943 bits |= TIOCM_RI; 944 945 return(bits); 946 } 947 948 /* 949 * Level 6 interrupt processing for the MultiFaceCard 68681 DUART 950 */ 951 952 int 953 mfcintr(void *arg) 954 { 955 struct mfc_softc *scc = arg; 956 struct mfcs_softc *sc; 957 struct mfc_regs *regs; 958 struct tty *tp; 959 int istat, unit; 960 u_short c; 961 962 regs = scc->sc_regs; 963 istat = regs->du_isr & scc->imask; 964 if (istat == 0) 965 return (0); 966 unit = scc->sc_dev.dv_unit * 2; 967 if (istat & 0x02) { /* channel A receive interrupt */ 968 sc = mfcs_cd.cd_devs[unit]; 969 while (1) { 970 c = regs->du_sra << 8; 971 if ((c & 0x0100) == 0) 972 break; 973 c |= regs->du_rba; 974 if (sc->incnt == SERIBUF_SIZE) 975 ++sc->ovfl; 976 else { 977 *sc->wptr++ = c; 978 if (sc->wptr == sc->inbuf + SERIBUF_SIZE) 979 sc->wptr = sc->inbuf; 980 ++sc->incnt; 981 if (sc->incnt > SERIBUF_SIZE - 16) 982 regs->du_btrst = 1; 983 } 984 if (c & 0x1000) 985 regs->du_cra = 0x40; 986 } 987 } 988 if (istat & 0x20) { /* channel B receive interrupt */ 989 sc = mfcs_cd.cd_devs[unit + 1]; 990 while (1) { 991 c = regs->du_srb << 8; 992 if ((c & 0x0100) == 0) 993 break; 994 c |= regs->du_rbb; 995 if (sc->incnt == SERIBUF_SIZE) 996 ++sc->ovfl; 997 else { 998 *sc->wptr++ = c; 999 if (sc->wptr == sc->inbuf + SERIBUF_SIZE) 1000 sc->wptr = sc->inbuf; 1001 ++sc->incnt; 1002 if (sc->incnt > SERIBUF_SIZE - 16) 1003 regs->du_btrst = 2; 1004 } 1005 if (c & 0x1000) 1006 regs->du_crb = 0x40; 1007 } 1008 } 1009 if (istat & 0x01) { /* channel A transmit interrupt */ 1010 sc = mfcs_cd.cd_devs[unit]; 1011 tp = sc->sc_tty; 1012 if (sc->ptr == sc->end) { 1013 tp->t_state &= ~(TS_BUSY | TS_FLUSH); 1014 scc->imask &= ~0x01; 1015 regs->du_imr = scc->imask; 1016 add_sicallback (tp->t_linesw ? 1017 (sifunc_t)tp->t_linesw->l_start 1018 : (sifunc_t)mfcsstart, tp, NULL); 1019 1020 } 1021 else 1022 regs->du_tba = *sc->ptr++; 1023 } 1024 if (istat & 0x10) { /* channel B transmit interrupt */ 1025 sc = mfcs_cd.cd_devs[unit + 1]; 1026 tp = sc->sc_tty; 1027 if (sc->ptr == sc->end) { 1028 tp->t_state &= ~(TS_BUSY | TS_FLUSH); 1029 scc->imask &= ~0x10; 1030 regs->du_imr = scc->imask; 1031 add_sicallback (tp->t_linesw ? 1032 (sifunc_t)tp->t_linesw->l_start 1033 : (sifunc_t)mfcsstart, tp, NULL); 1034 } 1035 else 1036 regs->du_tbb = *sc->ptr++; 1037 } 1038 if (istat & 0x80) { /* input port change interrupt */ 1039 c = regs->du_ipcr; 1040 printf ("%s: ipcr %02x", scc->sc_dev.dv_xname, c); 1041 } 1042 return(1); 1043 } 1044 1045 void 1046 mfcsxintr(int unit) 1047 { 1048 int s1, s2, ovfl; 1049 struct mfcs_softc *sc = mfcs_cd.cd_devs[unit]; 1050 struct tty *tp = sc->sc_tty; 1051 1052 /* 1053 * Make sure we're not interrupted by another 1054 * vbl, but allow level6 ints 1055 */ 1056 s1 = spltty(); 1057 1058 /* 1059 * pass along any acumulated information 1060 * while input is not blocked 1061 */ 1062 while (sc->incnt && (tp->t_state & TS_TBLOCK) == 0) { 1063 /* 1064 * no collision with ser_fastint() 1065 */ 1066 mfcseint(unit, *sc->rptr++); 1067 1068 ovfl = 0; 1069 /* lock against mfcs_fastint() */ 1070 s2 = splser(); 1071 --sc->incnt; 1072 if (sc->rptr == sc->inbuf + SERIBUF_SIZE) 1073 sc->rptr = sc->inbuf; 1074 if (sc->ovfl != 0) { 1075 ovfl = sc->ovfl; 1076 sc->ovfl = 0; 1077 } 1078 splx(s2); 1079 if (ovfl != 0) 1080 log(LOG_WARNING, "%s: %d buffer overflow!\n", 1081 sc->sc_dev.dv_xname, ovfl); 1082 } 1083 if (sc->incnt == 0 && (tp->t_state & TS_TBLOCK) == 0) { 1084 sc->sc_regs->du_btst = 1 << unit; /* XXXX */ 1085 } 1086 splx(s1); 1087 } 1088 1089 void 1090 mfcseint(int unit, int stat) 1091 { 1092 struct mfcs_softc *sc = mfcs_cd.cd_devs[unit]; 1093 struct tty *tp; 1094 u_char ch; 1095 int c; 1096 1097 tp = sc->sc_tty; 1098 ch = stat & 0xff; 1099 c = ch; 1100 1101 if ((tp->t_state & TS_ISOPEN) == 0) { 1102 #ifdef KGDB 1103 extern const struct cdevsw ser_cdevsw; 1104 int maj; 1105 1106 /* we don't care about parity errors */ 1107 maj = cdevsw_lookup_major(&ser_cdevsw); 1108 if (kgdb_dev == makedev(maj, unit) && c == FRAME_END) 1109 kgdb_connect(0); /* trap into kgdb */ 1110 #endif 1111 return; 1112 } 1113 1114 /* 1115 * Check for break and (if enabled) parity error. 1116 */ 1117 if (stat & 0xc000) 1118 c |= TTY_FE; 1119 else if (stat & 0x2000) 1120 c |= TTY_PE; 1121 1122 if (stat & 0x1000) 1123 log(LOG_WARNING, "%s: fifo overflow\n", 1124 ((struct mfcs_softc *)mfcs_cd.cd_devs[unit])->sc_dev.dv_xname); 1125 1126 tp->t_linesw->l_rint(c, tp); 1127 } 1128 1129 /* 1130 * This interrupt is periodically invoked in the vertical blank 1131 * interrupt. It's used to keep track of the modem control lines 1132 * and (new with the fast_int code) to move accumulated data 1133 * up into the tty layer. 1134 */ 1135 void 1136 mfcsmint(int unit) 1137 { 1138 struct tty *tp; 1139 struct mfcs_softc *sc = mfcs_cd.cd_devs[unit]; 1140 u_char stat, last, istat; 1141 1142 tp = sc->sc_tty; 1143 if (!tp) 1144 return; 1145 1146 if ((tp->t_state & TS_ISOPEN) == 0 && tp->t_wopen == 0) { 1147 sc->rptr = sc->wptr = sc->inbuf; 1148 sc->incnt = 0; 1149 return; 1150 } 1151 /* 1152 * empty buffer 1153 */ 1154 mfcsxintr(unit); 1155 1156 stat = ~sc->sc_regs->du_ip; 1157 last = sc->sc_mfc->last_ip; 1158 sc->sc_mfc->last_ip = stat; 1159 1160 /* 1161 * check whether any interesting signal changed state 1162 */ 1163 istat = stat ^ last; 1164 1165 if ((istat & (0x10 << (unit & 1))) && /* CD changed */ 1166 (SWFLAGS(tp->t_dev) & TIOCFLAG_SOFTCAR) == 0) { 1167 if (stat & (0x10 << (unit & 1))) 1168 tp->t_linesw->l_modem(tp, 1); 1169 else if (tp->t_linesw->l_modem(tp, 0) == 0) { 1170 sc->sc_regs->du_btrst = 0x0a << (unit & 1); 1171 } 1172 } 1173 } 1174