![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoevba|
Return to vx.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / tahoevba |
1.1 ! root 1: /* ! 2: * Copyright (c) 1988 Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * This code is derived from software contributed to Berkeley by ! 6: * Computer Consoles Inc. ! 7: * ! 8: * Redistribution is only permitted until one year after the first shipment ! 9: * of 4.4BSD by the Regents. Otherwise, redistribution and use in source and ! 10: * binary forms are permitted provided that: (1) source distributions retain ! 11: * this entire copyright notice and comment, and (2) distributions including ! 12: * binaries display the following acknowledgement: This product includes ! 13: * software developed by the University of California, Berkeley and its ! 14: * contributors'' in the documentation or other materials provided with the ! 15: * distribution and in all advertising materials mentioning features or use ! 16: * of this software. Neither the name of the University nor the names of ! 17: * its contributors may be used to endorse or promote products derived from ! 18: * this software without specific prior written permission. ! 19: * THIS SOFTWARE IS PROVIDED AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED ! 20: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF ! 21: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. ! 22: * ! 23: * @(#)vx.c 7.11 (Berkeley) 6/28/90 ! 24: */ ! 25: ! 26: #include "vx.h" ! 27: #if NVX > 0 ! 28: /* ! 29: * VIOC-X driver ! 30: */ ! 31: #ifdef VXPERF ! 32: #define DOSCOPE ! 33: #endif ! 34: ! 35: #include "param.h" ! 36: #include "ioctl.h" ! 37: #include "tty.h" ! 38: #include "user.h" ! 39: #include "map.h" ! 40: #include "buf.h" ! 41: #include "conf.h" ! 42: #include "file.h" ! 43: #include "proc.h" ! 44: #include "vm.h" ! 45: #include "kernel.h" ! 46: #include "syslog.h" ! 47: ! 48: #include "../tahoe/pte.h" ! 49: ! 50: #include "../tahoevba/vbavar.h" ! 51: #include "../tahoevba/vbaparam.h" ! 52: #include "../tahoevba/vxreg.h" ! 53: #include "../tahoevba/scope.h" ! 54: ! 55: #ifdef VX_DEBUG ! 56: long vxintr4 = 0; ! 57: #define VXERR4 1 ! 58: #define VXNOBUF 2 ! 59: long vxdebug = 0; ! 60: #define VXVCM 1 ! 61: #define VXVCC 2 ! 62: #define VXVCX 4 ! 63: #endif ! 64: ! 65: /* ! 66: * Interrupt type bits passed to vinthandl(). ! 67: */ ! 68: #define CMDquals 0 /* command completed interrupt */ ! 69: #define RSPquals 1 /* command response interrupt */ ! 70: #define UNSquals 2 /* unsolicited interrupt */ ! 71: ! 72: #define VXUNIT(n) ((n) >> 4) ! 73: #define VXPORT(n) ((n) & 0xf) ! 74: ! 75: struct tty vx_tty[NVX*16]; ! 76: #ifndef lint ! 77: int nvx = NVX*16; ! 78: #endif ! 79: int vxstart(), ttrstrt(); ! 80: struct vxcmd *vobtain(), *nextcmd(); ! 81: ! 82: /* ! 83: * Driver information for auto-configuration stuff. ! 84: */ ! 85: int vxprobe(), vxattach(), vxrint(); ! 86: struct vba_device *vxinfo[NVX]; ! 87: long vxstd[] = { 0 }; ! 88: struct vba_driver vxdriver = ! 89: { vxprobe, 0, vxattach, 0, vxstd, "vx", vxinfo }; ! 90: ! 91: struct vx_softc { ! 92: struct vxdevice *vs_addr; /* H/W address */ ! 93: u_char vs_type; /* 0: viox-x/vioc-b, 1: vioc-bop */ ! 94: u_char vs_bop; /* bop board # for vioc-bop's */ ! 95: u_char vs_loport; /* low port nbr */ ! 96: u_char vs_hiport; /* high port nbr */ ! 97: u_short vs_nbr; /* viocx number */ ! 98: u_short vs_maxcmd; /* max number of concurrent cmds */ ! 99: u_short vs_silosiz; /* silo size */ ! 100: short vs_vers; /* vioc/pvioc version */ ! 101: #define VXV_OLD 0 /* PVIOCX | VIOCX */ ! 102: #define VXV_NEW 1 /* NPVIOCX | NVIOCX */ ! 103: short vs_state; /* controller state */ ! 104: #define VXS_READY 0 /* ready for commands */ ! 105: #define VXS_RESET 1 /* in process of reseting */ ! 106: u_short vs_softCAR; /* soft carrier */ ! 107: u_int vs_ivec; /* interrupt vector base */ ! 108: caddr_t vs_mricmd; /* most recent issued cmd */ ! 109: /* The remaining fields are zeroed on reset... */ ! 110: #define vs_zero vs_xmtcnt ! 111: int vs_xmtcnt; /* xmit commands pending */ ! 112: struct vxcmd *vs_avail;/* next available command buffer */ ! 113: struct vxcmd *vs_build; ! 114: struct vxcmd vs_lst[NVCXBUFS]; ! 115: struct vcmds vs_cmds; ! 116: } vx_softc[NVX]; ! 117: ! 118: struct speedtab vxspeedtab[] = { ! 119: EXTA, V19200, ! 120: EXTB, V19200, ! 121: 19200, V19200, ! 122: 9600, 13, ! 123: 4800, 12, ! 124: 2400, 11, ! 125: 1800, 10, ! 126: 1200, 9, ! 127: 600, 8, ! 128: 300, 7, ! 129: 200, 6, ! 130: 150, 5, ! 131: 134, 4, ! 132: 110, 3, ! 133: 75, 2, ! 134: 50, 1, ! 135: 0, 0, ! 136: -1, -1, ! 137: }; ! 138: ! 139: vxprobe(reg, vi) ! 140: caddr_t reg; ! 141: struct vba_device *vi; ! 142: { ! 143: register int br, cvec; /* must be r12, r11 */ ! 144: register struct vxdevice *vp; ! 145: register struct vx_softc *vs; ! 146: struct pte *dummypte; ! 147: ! 148: #ifdef lint ! 149: br = 0; cvec = br; br = cvec; ! 150: vackint(0); vunsol(0); vcmdrsp(0); ! 151: #ifdef VX_DEBUG ! 152: vxfreset(0); ! 153: #endif ! 154: #endif /* lint */ ! 155: /* ! 156: * If on an HCX-9, the device has a 32-bit address, ! 157: * and we receive that address so we can set up a map. ! 158: * On VERSAbus devices, the address is 24-bit, and is ! 159: * already mapped (into vmem[]) by autoconf. ! 160: */ ! 161: if (!(reg >= vmem && reg < &vmem[ctob(VBIOSIZE)]) && /* XXX */ ! 162: !vbmemalloc(16, reg, &dummypte, ®)) { ! 163: printf("vx%d: vbmemalloc failed.\n", vi->ui_unit); ! 164: return(0); ! 165: } ! 166: vp = (struct vxdevice *)reg; ! 167: if (badaddr((caddr_t)vp, 1)) ! 168: return (0); ! 169: vp->v_fault = 0; ! 170: vp->v_vioc = V_BSY; ! 171: vp->v_hdwre = V_RESET; /* reset interrupt */ ! 172: DELAY(4000000); ! 173: if (vp->v_fault != VXF_READY) ! 174: return (0); ! 175: vs = &vx_softc[vi->ui_unit]; ! 176: #ifdef notdef ! 177: /* ! 178: * Align vioc interrupt vector base to 4 vector ! 179: * boundary and fitting in 8 bits (is this necessary, ! 180: * wish we had documentation). ! 181: */ ! 182: if ((vi->ui_hd->vh_lastiv -= 3) > 0xff) ! 183: vi->ui_hd->vh_lastiv = 0xff; ! 184: vs->vs_ivec = vi->ui_hd->vh_lastiv = vi->ui_hd->vh_lastiv &~ 0x3; ! 185: #else ! 186: vs->vs_ivec = 0x40+vi->ui_unit*4; ! 187: #endif ! 188: br = 0x18, cvec = vs->vs_ivec; /* XXX */ ! 189: return (sizeof (struct vxdevice)); ! 190: } ! 191: ! 192: vxattach(vi) ! 193: register struct vba_device *vi; ! 194: { ! 195: register struct vx_softc *vs = &vx_softc[vi->ui_unit]; ! 196: ! 197: vs->vs_softCAR = vi->ui_flags; ! 198: vs->vs_addr = (struct vxdevice *)vi->ui_addr; ! 199: vxinit(vi->ui_unit, 1); ! 200: } ! 201: ! 202: /* ! 203: * Open a VX line. ! 204: */ ! 205: /*ARGSUSED*/ ! 206: vxopen(dev, flag) ! 207: dev_t dev; ! 208: int flag; ! 209: { ! 210: register struct tty *tp; /* pointer to tty struct for port */ ! 211: register struct vx_softc *vs; ! 212: register struct vba_device *vi; ! 213: int unit, vx, s, error = 0; ! 214: int vxparam(); ! 215: ! 216: unit = minor(dev); ! 217: vx = VXUNIT(unit); ! 218: if (vx >= NVX || (vi = vxinfo[vx])== 0 || vi->ui_alive == 0) ! 219: return (ENXIO); ! 220: vs = &vx_softc[vx]; ! 221: tp = &vx_tty[unit]; ! 222: unit = VXPORT(unit); ! 223: if (tp->t_state&TS_XCLUDE && u.u_uid != 0) ! 224: return (EBUSY); ! 225: if (unit < vs->vs_loport || unit > vs->vs_hiport) ! 226: return (ENXIO); ! 227: tp->t_addr = (caddr_t)vs; ! 228: tp->t_oproc = vxstart; ! 229: tp->t_param = vxparam; ! 230: tp->t_dev = dev; ! 231: s = spl8(); ! 232: if ((tp->t_state&TS_ISOPEN) == 0) { ! 233: tp->t_state |= TS_WOPEN; ! 234: ttychars(tp); ! 235: if (tp->t_ispeed == 0) { ! 236: tp->t_iflag = TTYDEF_IFLAG; ! 237: tp->t_oflag = TTYDEF_OFLAG; ! 238: tp->t_lflag = TTYDEF_LFLAG; ! 239: tp->t_cflag = TTYDEF_CFLAG; ! 240: tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED; ! 241: } ! 242: vxparam(tp, &tp->t_termios); ! 243: ttsetwater(tp); ! 244: } ! 245: vcmodem(dev, VMOD_ON); ! 246: while (!(flag&O_NONBLOCK) && !(tp->t_cflag&CLOCAL) && ! 247: (tp->t_state&TS_CARR_ON) == 0) { ! 248: tp->t_state |= TS_WOPEN; ! 249: if (error = ttysleep(tp, (caddr_t)&tp->t_rawq, TTIPRI | PCATCH, ! 250: ttopen, 0)) ! 251: break; ! 252: } ! 253: if (error == 0) ! 254: error = (*linesw[tp->t_line].l_open)(dev,tp); ! 255: splx(s); ! 256: return (error); ! 257: } ! 258: ! 259: /* ! 260: * Close a VX line. ! 261: */ ! 262: /*ARGSUSED*/ ! 263: vxclose(dev, flag) ! 264: dev_t dev; ! 265: int flag; ! 266: { ! 267: register struct tty *tp; ! 268: int unit, s, error = 0; ! 269: ! 270: unit = minor(dev); ! 271: tp = &vx_tty[unit]; ! 272: s = spl8(); ! 273: (*linesw[tp->t_line].l_close)(tp); ! 274: if (tp->t_cflag & HUPCL || (tp->t_state & TS_ISOPEN) == 0) ! 275: vcmodem(dev, VMOD_OFF); ! 276: /* wait for the last response */ ! 277: while (tp->t_state&TS_FLUSH && error == 0) ! 278: error = tsleep((caddr_t)&tp->t_state, TTOPRI | PCATCH, ! 279: ttclos, 0); ! 280: splx(s); ! 281: if (error) ! 282: return (error); ! 283: return (ttyclose(tp)); ! 284: } ! 285: ! 286: /* ! 287: * Read from a VX line. ! 288: */ ! 289: vxread(dev, uio, flag) ! 290: dev_t dev; ! 291: struct uio *uio; ! 292: { ! 293: struct tty *tp = &vx_tty[minor(dev)]; ! 294: ! 295: return ((*linesw[tp->t_line].l_read)(tp, uio, flag)); ! 296: } ! 297: ! 298: /* ! 299: * write on a VX line ! 300: */ ! 301: vxwrite(dev, uio, flag) ! 302: dev_t dev; ! 303: struct uio *uio; ! 304: { ! 305: register struct tty *tp = &vx_tty[minor(dev)]; ! 306: ! 307: return ((*linesw[tp->t_line].l_write)(tp, uio, flag)); ! 308: } ! 309: ! 310: /* ! 311: * VIOCX unsolicited interrupt. ! 312: */ ! 313: vxrint(vx) ! 314: register vx; ! 315: { ! 316: register struct tty *tp, *tp0; ! 317: register struct vxdevice *addr; ! 318: register struct vx_softc *vs; ! 319: struct vba_device *vi; ! 320: register int nc, c; ! 321: register struct silo { ! 322: u_char data, port; ! 323: } *sp; ! 324: short *osp; ! 325: int overrun = 0; ! 326: ! 327: vi = vxinfo[vx]; ! 328: if (vi == 0 || vi->ui_alive == 0) ! 329: return; ! 330: addr = (struct vxdevice *)vi->ui_addr; ! 331: switch (addr->v_uqual&037) { ! 332: case 0: ! 333: break; ! 334: case 2: ! 335: if (addr->v_ustat == VP_SILO_OFLOW) ! 336: log(LOG_ERR, "vx%d: input silo overflow\n", vx); ! 337: else { ! 338: printf("vx%d: vc proc err, ustat %x\n", ! 339: vx, addr->v_ustat); ! 340: vxstreset(vx); ! 341: } ! 342: return; ! 343: case 3: ! 344: vcmintr(vx); ! 345: return; ! 346: case 4: ! 347: return; ! 348: default: ! 349: printf("vx%d: vc uqual err, uqual %x\n", vx, addr->v_uqual); ! 350: vxstreset(vx); ! 351: return; ! 352: } ! 353: vs = &vx_softc[vx]; ! 354: if (vs->vs_vers == VXV_NEW) ! 355: sp = (struct silo *)((caddr_t)addr + *(short *)addr->v_usdata); ! 356: else ! 357: sp = (struct silo *)((caddr_t)addr+VX_SILO+(addr->v_usdata[0]<<6)); ! 358: nc = *(osp = (short *)sp); ! 359: if (nc == 0) ! 360: return; ! 361: if (vs->vs_vers == VXV_NEW && nc > vs->vs_silosiz) { ! 362: printf("vx%d: %d exceeds silo size\n", nc); ! 363: nc = vs->vs_silosiz; ! 364: } ! 365: tp0 = &vx_tty[vx*16]; ! 366: sp = (struct silo *)(((short *)sp)+1); ! 367: for (; nc > 0; nc--, sp = (struct silo *)(((short *)sp)+1)) { ! 368: c = sp->port & 017; ! 369: if (vs->vs_loport > c || c > vs->vs_hiport) ! 370: continue; ! 371: tp = tp0 + c; ! 372: if( (tp->t_state&TS_ISOPEN) == 0) { ! 373: wakeup((caddr_t)&tp->t_rawq); ! 374: continue; ! 375: } ! 376: c = sp->data&((tp->t_cflag&CSIZE)==CS8 ? 0xff : 0x7f); ! 377: if ((sp->port&VX_RO) == VX_RO && !overrun) { ! 378: log(LOG_ERR, "vx%d: receiver overrun\n", vi->ui_unit); ! 379: overrun = 1; ! 380: continue; ! 381: } ! 382: if (sp->port&VX_PE) ! 383: c |= TTY_PE; ! 384: if (sp->port&VX_FE) ! 385: c |= TTY_FE; ! 386: (*linesw[tp->t_line].l_rint)(c, tp); ! 387: } ! 388: *osp = 0; ! 389: } ! 390: ! 391: /* ! 392: * Ioctl for VX. ! 393: */ ! 394: vxioctl(dev, cmd, data, flag) ! 395: dev_t dev; ! 396: caddr_t data; ! 397: { ! 398: register struct tty *tp; ! 399: int error; ! 400: ! 401: tp = &vx_tty[minor(dev)]; ! 402: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag); ! 403: if (error >= 0) ! 404: return (error); ! 405: error = ttioctl(tp, cmd, data, flag); ! 406: if (error >= 0) ! 407: return (error); ! 408: return (ENOTTY); ! 409: } ! 410: ! 411: vxparam(tp, t) ! 412: struct tty *tp; ! 413: struct termios *t; ! 414: { ! 415: ! 416: return (vxcparam(tp, t, 1)); ! 417: } ! 418: ! 419: /* ! 420: * Set parameters from open or stty into the VX hardware ! 421: * registers. ! 422: */ ! 423: vxcparam(tp, t, wait) ! 424: struct tty *tp; ! 425: struct termios *t; ! 426: int wait; ! 427: { ! 428: register struct vx_softc *vs; ! 429: register struct vxcmd *cp; ! 430: int s, error = 0; ! 431: int speedcode = ttspeedtab(t->c_ospeed, vxspeedtab); ! 432: ! 433: if (speedcode < 0 || (t->c_ispeed != t->c_ospeed && t->c_ispeed)) ! 434: return (EINVAL); ! 435: vs = (struct vx_softc *)tp->t_addr; ! 436: cp = vobtain(vs); ! 437: s = spl8(); ! 438: /* ! 439: * Construct ``load parameters'' command block ! 440: * to setup baud rates, xon-xoff chars, parity, ! 441: * and stop bits for the specified port. ! 442: */ ! 443: cp->cmd = VXC_LPARAX; ! 444: cp->par[1] = VXPORT(minor(tp->t_dev)); ! 445: /* ! 446: * note: if the hardware does flow control, ^V doesn't work ! 447: * to escape ^S ! 448: */ ! 449: if (t->c_iflag&IXON) { ! 450: if (t->c_cc[VSTART] == _POSIX_VDISABLE) ! 451: cp->par[2] = 0; ! 452: else ! 453: cp->par[2] = t->c_cc[VSTART]; ! 454: if (t->c_cc[VSTOP] == _POSIX_VDISABLE) ! 455: cp->par[3] = 0; ! 456: else ! 457: cp->par[3] = t->c_cc[VSTOP]; ! 458: } else ! 459: cp->par[2] = cp->par[3] = 0; ! 460: #ifdef notnow ! 461: switch (t->c_cflag & CSIZE) { /* XXX */ ! 462: case CS8: ! 463: #endif ! 464: cp->par[4] = BITS8; /* 8 bits of data */ ! 465: #ifdef notnow ! 466: break; ! 467: case CS7: ! 468: cp->par[4] = BITS7; /* 7 bits of data */ ! 469: break; ! 470: case CS6: ! 471: cp->par[4] = BITS6; /* 6 bits of data */ ! 472: break; ! 473: case CS5: ! 474: cp->par[4] = BITS5; /* 5 bits of data */ ! 475: break; ! 476: } ! 477: if ((t->c_cflag & PARENB) == 0) /* XXX */ ! 478: #endif ! 479: cp->par[7] = VNOPARITY; /* no parity */ ! 480: #ifdef notnow ! 481: else if (t->c_cflag&PARODD) ! 482: cp->par[7] = VODDP; /* odd parity */ ! 483: else ! 484: cp->par[7] = VEVENP; /* even parity */ ! 485: #endif ! 486: cp->par[5] = (t->c_cflag&CSTOPB) ? VSTOP2 : VSTOP1; ! 487: cp->par[6] = speedcode; ! 488: if (vcmd((int)vs->vs_nbr, (caddr_t)&cp->cmd) && wait) ! 489: error = tsleep((caddr_t)cp, TTIPRI | PCATCH, ttyout, 0); ! 490: if ((t->c_ospeed)==0) { ! 491: tp->t_cflag |= HUPCL; ! 492: vcmodem(tp->t_dev, VMOD_OFF); ! 493: } ! 494: splx(s); ! 495: return (error); ! 496: } ! 497: ! 498: /* ! 499: * VIOCX command response interrupt. ! 500: * For transmission, restart output to any active port. ! 501: * For all other commands, just clean up. ! 502: */ ! 503: vxxint(vx, cp) ! 504: register int vx; ! 505: register struct vxcmd *cp; ! 506: { ! 507: register struct vxmit *vp; ! 508: register struct tty *tp, *tp0; ! 509: register struct vx_softc *vs; ! 510: ! 511: vs = &vx_softc[vx]; ! 512: cp = (struct vxcmd *)((long *)cp-1); ! 513: ! 514: switch (cp->cmd&0xff00) { ! 515: ! 516: case VXC_LIDENT: /* initialization complete */ ! 517: if (vs->vs_state == VXS_RESET) { ! 518: vxfnreset(vx, cp); ! 519: vinthandl(vx, ((V_BSY|RSPquals) << 8)|V_INTR); ! 520: } ! 521: cp->cmd++; ! 522: return; ! 523: ! 524: case VXC_XMITDTA: ! 525: case VXC_XMITIMM: ! 526: break; ! 527: ! 528: case VXC_LPARAX: ! 529: wakeup((caddr_t)cp); ! 530: /* fall thru... */ ! 531: default: /* VXC_MDMCTL or VXC_FDTATOX */ ! 532: vrelease(vs, cp); ! 533: if (vs->vs_state == VXS_RESET) ! 534: vinthandl(vx, ((V_BSY|RSPquals) << 8)|V_INTR); ! 535: return; ! 536: } ! 537: tp0 = &vx_tty[vx*16]; ! 538: vp = (struct vxmit *)(cp->par + (cp->cmd & 07)*sizeof (struct vxmit)); ! 539: for (; vp >= (struct vxmit *)cp->par; vp--) { ! 540: tp = tp0 + (vp->line & 017); ! 541: tp->t_state &= ~TS_BUSY; ! 542: if (tp->t_state & TS_FLUSH) { ! 543: tp->t_state &= ~TS_FLUSH; ! 544: wakeup((caddr_t)&tp->t_state); ! 545: } else ! 546: ndflush(&tp->t_outq, vp->bcount+1); ! 547: } ! 548: vrelease(vs, cp); ! 549: if (vs->vs_vers == VXV_NEW) ! 550: (*linesw[tp->t_line].l_start)(tp); ! 551: else { ! 552: tp0 = &vx_tty[vx*16 + vs->vs_hiport]; ! 553: for(tp = &vx_tty[vx*16 + vs->vs_loport]; tp <= tp0; tp++) ! 554: (*linesw[tp->t_line].l_start)(tp); ! 555: if ((cp = nextcmd(vs)) != NULL) { /* command to send? */ ! 556: vs->vs_xmtcnt++; ! 557: (void) vcmd(vx, (caddr_t)&cp->cmd); ! 558: } ! 559: } ! 560: vs->vs_xmtcnt--; ! 561: } ! 562: ! 563: /* ! 564: * Force out partial XMIT command after timeout ! 565: */ ! 566: vxforce(vs) ! 567: register struct vx_softc *vs; ! 568: { ! 569: register struct vxcmd *cp; ! 570: int s; ! 571: ! 572: s = spl8(); ! 573: if ((cp = nextcmd(vs)) != NULL) { ! 574: vs->vs_xmtcnt++; ! 575: (void) vcmd((int)vs->vs_nbr, (caddr_t)&cp->cmd); ! 576: } ! 577: splx(s); ! 578: } ! 579: ! 580: /* ! 581: * Start (restart) transmission on the given VX line. ! 582: */ ! 583: vxstart(tp) ! 584: register struct tty *tp; ! 585: { ! 586: register short n; ! 587: register struct vx_softc *vs; ! 588: int s, port; ! 589: ! 590: s = spl8(); ! 591: port = VXPORT(minor(tp->t_dev)); ! 592: vs = (struct vx_softc *)tp->t_addr; ! 593: if ((tp->t_state&(TS_TIMEOUT|TS_BUSY|TS_TTSTOP)) == 0) { ! 594: if (tp->t_outq.c_cc <= tp->t_lowat) { ! 595: if (tp->t_state&TS_ASLEEP) { ! 596: tp->t_state &= ~TS_ASLEEP; ! 597: wakeup((caddr_t)&tp->t_outq); ! 598: } ! 599: if (tp->t_wsel) { ! 600: selwakeup(tp->t_wsel, tp->t_state & TS_WCOLL); ! 601: tp->t_wsel = 0; ! 602: tp->t_state &= ~TS_WCOLL; ! 603: } ! 604: } ! 605: if (tp->t_outq.c_cc == 0) { ! 606: splx(s); ! 607: return; ! 608: } ! 609: scope_out(3); ! 610: if (1 || !(tp->t_oflag&OPOST)) /* XXX */ ! 611: n = ndqb(&tp->t_outq, 0); ! 612: else { ! 613: n = ndqb(&tp->t_outq, 0200); ! 614: if (n == 0) { ! 615: n = getc(&tp->t_outq); ! 616: timeout(ttrstrt, (caddr_t)tp, (n&0177)+6); ! 617: tp->t_state |= TS_TIMEOUT; ! 618: n = 0; ! 619: } ! 620: } ! 621: if (n) { ! 622: tp->t_state |= TS_BUSY; ! 623: vsetq(vs, port, (char *)tp->t_outq.c_cf, n); ! 624: } ! 625: } ! 626: splx(s); ! 627: } ! 628: ! 629: /* ! 630: * Stop output on a line. ! 631: */ ! 632: vxstop(tp) ! 633: register struct tty *tp; ! 634: { ! 635: int s; ! 636: ! 637: s = spl8(); ! 638: if (tp->t_state&TS_BUSY) ! 639: if ((tp->t_state&TS_TTSTOP) == 0) ! 640: tp->t_state |= TS_FLUSH; ! 641: splx(s); ! 642: } ! 643: ! 644: static int vxbbno = -1; ! 645: /* ! 646: * VIOCX Initialization. Makes free lists of command buffers. ! 647: * Resets all viocx's. Issues a LIDENT command to each ! 648: * viocx to establish interrupt vectors and logical port numbers. ! 649: */ ! 650: vxinit(vx, wait) ! 651: register int vx; ! 652: int wait; ! 653: { ! 654: register struct vx_softc *vs; ! 655: register struct vxdevice *addr; ! 656: register struct vxcmd *cp; ! 657: register char *resp; ! 658: register int j; ! 659: char type, *typestring; ! 660: ! 661: vs = &vx_softc[vx]; ! 662: addr = vs->vs_addr; ! 663: type = addr->v_ident; ! 664: vs->vs_vers = (type&VXT_NEW) ? VXV_NEW : VXV_OLD; ! 665: if (vs->vs_vers == VXV_NEW) ! 666: vs->vs_silosiz = addr->v_maxsilo; ! 667: switch (type) { ! 668: ! 669: case VXT_VIOCX: ! 670: case VXT_VIOCX|VXT_NEW: ! 671: typestring = "VIOC-X"; ! 672: /* set soft carrier for printer ports */ ! 673: for (j = 0; j < 16; j++) ! 674: if (vs->vs_softCAR & (1 << j) || ! 675: addr->v_portyp[j] == VXT_PARALLEL) { ! 676: vs->vs_softCAR |= 1 << j; ! 677: addr->v_dcd |= 1 << j; ! 678: } ! 679: break; ! 680: ! 681: case VXT_PVIOCX: ! 682: case VXT_PVIOCX|VXT_NEW: ! 683: typestring = "VIOC-X (old connector panel)"; ! 684: break; ! 685: case VXT_VIOCBOP: /* VIOC-BOP */ ! 686: vs->vs_type = 1; ! 687: vs->vs_bop = ++vxbbno; ! 688: printf("VIOC-BOP no. %d at %x\n", vs->vs_bop, addr); ! 689: goto unsup; ! 690: default: ! 691: printf("vx%d: unknown type %x\n", vx, type); ! 692: unsup: ! 693: vxinfo[vx]->ui_alive = 0; ! 694: return; ! 695: } ! 696: vs->vs_nbr = vx; /* assign board number */ ! 697: vs->vs_maxcmd = (vs->vs_vers == VXV_NEW) ? 24 : 4; ! 698: /* ! 699: * Initialize all cmd buffers by linking them ! 700: * into a free list. ! 701: */ ! 702: for (j = 0; j < NVCXBUFS; j++) { ! 703: cp = &vs->vs_lst[j]; ! 704: cp->c_fwd = &vs->vs_lst[j+1]; ! 705: } ! 706: vs->vs_avail = &vs->vs_lst[0]; /* set idx to 1st free buf */ ! 707: cp->c_fwd = (struct vxcmd *)0; /* mark last buf in free list */ ! 708: ! 709: /* ! 710: * Establish the interrupt vectors and define the port numbers. ! 711: */ ! 712: cp = vobtain(vs); ! 713: cp->cmd = VXC_LIDENT; ! 714: cp->par[0] = vs->vs_ivec; /* ack vector */ ! 715: cp->par[1] = cp->par[0]+1; /* cmd resp vector */ ! 716: cp->par[3] = cp->par[0]+2; /* unsol intr vector */ ! 717: cp->par[4] = 15; /* max ports, no longer used */ ! 718: cp->par[5] = 0; /* set 1st port number */ ! 719: (void) vcmd(vx, (caddr_t)&cp->cmd); ! 720: if (!wait) ! 721: return; ! 722: ! 723: for (j = 0; cp->cmd == VXC_LIDENT && j < 4000000; j++) ! 724: ; ! 725: if (j >= 4000000) ! 726: printf("vx%d: didn't respond to LIDENT\n", vx); ! 727: ! 728: /* calculate address of response buffer */ ! 729: resp = (char *)addr + (addr->v_rspoff&0x3fff); ! 730: if (resp[0] != 0 && (resp[0]&0177) != 3) { ! 731: vrelease(vs, cp); /* init failed */ ! 732: return; ! 733: } ! 734: vs->vs_loport = cp->par[5]; ! 735: vs->vs_hiport = cp->par[7]; ! 736: printf("vx%d: %s%s, ports %d-%d\n", vx, ! 737: (vs->vs_vers == VXV_NEW) ? "" : "old ", typestring, ! 738: vs->vs_loport, vs->vs_hiport); ! 739: vrelease(vs, cp); ! 740: } ! 741: ! 742: /* ! 743: * Obtain a command buffer ! 744: */ ! 745: struct vxcmd * ! 746: vobtain(vs) ! 747: register struct vx_softc *vs; ! 748: { ! 749: register struct vxcmd *p; ! 750: int s; ! 751: ! 752: s = spl8(); ! 753: p = vs->vs_avail; ! 754: if (p == (struct vxcmd *)0) { ! 755: #ifdef VX_DEBUG ! 756: if (vxintr4&VXNOBUF) ! 757: vxintr4 &= ~VXNOBUF; ! 758: #endif ! 759: printf("vx%d: no buffers\n", vs->vs_nbr); ! 760: vxstreset(vs->vs_nbr); ! 761: splx(s); ! 762: return (vobtain(vs)); ! 763: } ! 764: vs->vs_avail = p->c_fwd; ! 765: splx(s); ! 766: return ((struct vxcmd *)p); ! 767: } ! 768: ! 769: /* ! 770: * Release a command buffer ! 771: */ ! 772: vrelease(vs, cp) ! 773: register struct vx_softc *vs; ! 774: register struct vxcmd *cp; ! 775: { ! 776: int s; ! 777: ! 778: #ifdef VX_DEBUG ! 779: if (vxintr4&VXNOBUF) ! 780: return; ! 781: #endif ! 782: s = spl8(); ! 783: cp->c_fwd = vs->vs_avail; ! 784: vs->vs_avail = cp; ! 785: splx(s); ! 786: } ! 787: ! 788: struct vxcmd * ! 789: nextcmd(vs) ! 790: register struct vx_softc *vs; ! 791: { ! 792: register struct vxcmd *cp; ! 793: int s; ! 794: ! 795: s = spl8(); ! 796: cp = vs->vs_build; ! 797: vs->vs_build = (struct vxcmd *)0; ! 798: splx(s); ! 799: return (cp); ! 800: } ! 801: ! 802: /* ! 803: * Assemble transmits into a multiple command; ! 804: * up to 8 transmits to 8 lines can be assembled together ! 805: * (on PVIOCX only). ! 806: */ ! 807: vsetq(vs, line, addr, n) ! 808: register struct vx_softc *vs; ! 809: caddr_t addr; ! 810: { ! 811: register struct vxcmd *cp; ! 812: register struct vxmit *mp; ! 813: ! 814: /* ! 815: * Grab a new command buffer or append ! 816: * to the current one being built. ! 817: */ ! 818: cp = vs->vs_build; ! 819: if (cp == (struct vxcmd *)0) { ! 820: cp = vobtain(vs); ! 821: vs->vs_build = cp; ! 822: cp->cmd = VXC_XMITDTA; ! 823: } else { ! 824: if ((cp->cmd & 07) == 07 || vs->vs_vers == VXV_NEW) { ! 825: printf("vx%d: setq overflow\n", vs-vx_softc); ! 826: vxstreset((int)vs->vs_nbr); ! 827: return; ! 828: } ! 829: cp->cmd++; ! 830: } ! 831: /* ! 832: * Select the next vxmit buffer and copy the ! 833: * characters into the buffer (if there's room ! 834: * and the device supports ``immediate mode'', ! 835: * or store an indirect pointer to the data. ! 836: */ ! 837: mp = (struct vxmit *)(cp->par + (cp->cmd & 07)*sizeof (struct vxmit)); ! 838: mp->bcount = n-1; ! 839: mp->line = line; ! 840: if (vs->vs_vers == VXV_NEW && n <= sizeof (mp->ostream)) { ! 841: cp->cmd = VXC_XMITIMM; ! 842: bcopy(addr, mp->ostream, (unsigned)n); ! 843: } else { ! 844: /* get system address of clist block */ ! 845: addr = (caddr_t)vtoph((struct proc *)0, (unsigned)addr); ! 846: bcopy((caddr_t)&addr, mp->ostream, sizeof (addr)); ! 847: } ! 848: /* ! 849: * We send the data immediately if a VIOCX, ! 850: * the command buffer is full, or if we've nothing ! 851: * currently outstanding. If we don't send it, ! 852: * set a timeout to force the data to be sent soon. ! 853: */ ! 854: if (vs->vs_vers == VXV_NEW || (cp->cmd & 07) == 7 || ! 855: vs->vs_xmtcnt == 0) { ! 856: vs->vs_xmtcnt++; ! 857: (void) vcmd((int)vs->vs_nbr, (char *)&cp->cmd); ! 858: vs->vs_build = 0; ! 859: } else ! 860: timeout(vxforce, (caddr_t)vs, 3); ! 861: } ! 862: ! 863: /* ! 864: * Write a command out to the VIOC ! 865: */ ! 866: vcmd(vx, cmdad) ! 867: register int vx; ! 868: register caddr_t cmdad; ! 869: { ! 870: register struct vcmds *cp; ! 871: register struct vx_softc *vs = &vx_softc[vx]; ! 872: int s; ! 873: ! 874: s = spl8(); ! 875: /* ! 876: * When the vioc is resetting, don't process ! 877: * anything other than VXC_LIDENT commands. ! 878: */ ! 879: if (vs->vs_state == VXS_RESET && cmdad != NULL) { ! 880: struct vxcmd *vcp = (struct vxcmd *)(cmdad-sizeof (vcp->c_fwd)); ! 881: ! 882: if (vcp->cmd != VXC_LIDENT) { ! 883: vrelease(vs, vcp); ! 884: return (0); ! 885: } ! 886: } ! 887: cp = &vs->vs_cmds; ! 888: if (cmdad != (caddr_t)0) { ! 889: cp->cmdbuf[cp->v_fill] = cmdad; ! 890: if (++cp->v_fill >= VC_CMDBUFL) ! 891: cp->v_fill = 0; ! 892: if (cp->v_fill == cp->v_empty) { ! 893: printf("vx%d: cmd q overflow\n", vx); ! 894: vxstreset(vx); ! 895: splx(s); ! 896: return (0); ! 897: } ! 898: cp->v_cmdsem++; ! 899: } ! 900: if (cp->v_cmdsem && cp->v_curcnt < vs->vs_maxcmd) { ! 901: cp->v_cmdsem--; ! 902: cp->v_curcnt++; ! 903: vinthandl(vx, ((V_BSY|CMDquals) << 8)|V_INTR); ! 904: } ! 905: splx(s); ! 906: return (1); ! 907: } ! 908: ! 909: /* ! 910: * VIOC acknowledge interrupt. The VIOC has received the new ! 911: * command. If no errors, the new command becomes one of 16 (max) ! 912: * current commands being executed. ! 913: */ ! 914: vackint(vx) ! 915: register vx; ! 916: { ! 917: register struct vxdevice *vp; ! 918: register struct vcmds *cp; ! 919: struct vx_softc *vs; ! 920: int s; ! 921: ! 922: scope_out(5); ! 923: vs = &vx_softc[vx]; ! 924: if (vs->vs_type) /* Its a BOP */ ! 925: return; ! 926: s = spl8(); ! 927: vp = vs->vs_addr; ! 928: cp = &vs->vs_cmds; ! 929: if (vp->v_vcid&V_ERR) { ! 930: register char *resp; ! 931: register i; ! 932: ! 933: printf("vx%d: ackint error type %x v_dcd %x\n", vx, ! 934: vp->v_vcid & 07, vp->v_dcd & 0xff); ! 935: resp = (char *)vs->vs_mricmd; ! 936: for (i = 0; i < 16; i++) ! 937: printf("%x ", resp[i]&0xff); ! 938: printf("\n"); ! 939: splx(s); ! 940: vxstreset(vx); ! 941: return; ! 942: } ! 943: if ((vp->v_hdwre&017) == CMDquals) { ! 944: #ifdef VX_DEBUG ! 945: if (vxintr4 & VXERR4) { /* causes VIOC INTR ERR 4 */ ! 946: struct vxcmd *cp1, *cp0; ! 947: ! 948: cp0 = (struct vxcmd *) ! 949: ((caddr_t)cp->cmdbuf[cp->v_empty]-sizeof (cp0->c_fwd)); ! 950: if (cp0->cmd == VXC_XMITDTA || cp0->cmd == VXC_XMITIMM) { ! 951: cp1 = vobtain(vs); ! 952: *cp1 = *cp0; ! 953: vxintr4 &= ~VXERR4; ! 954: (void) vcmd(vx, &cp1->cmd); ! 955: } ! 956: } ! 957: #endif ! 958: cp->v_curcmd[vp->v_vcid & VCMDLEN-1] = cp->cmdbuf[cp->v_empty]; ! 959: if (++cp->v_empty >= VC_CMDBUFL) ! 960: cp->v_empty = 0; ! 961: } ! 962: if (++cp->v_itrempt >= VC_IQLEN) ! 963: cp->v_itrempt = 0; ! 964: vintempt(vx); ! 965: splx(s); ! 966: (void) vcmd(vx, (caddr_t)0); /* queue next cmd, if any */ ! 967: } ! 968: ! 969: /* ! 970: * Command Response interrupt. The Vioc has completed ! 971: * a command. The command may now be returned to ! 972: * the appropriate device driver. ! 973: */ ! 974: vcmdrsp(vx) ! 975: register vx; ! 976: { ! 977: register struct vxdevice *vp; ! 978: register struct vcmds *cp; ! 979: register caddr_t cmd; ! 980: register struct vx_softc *vs; ! 981: register char *resp; ! 982: register k; ! 983: register int s; ! 984: ! 985: scope_out(6); ! 986: vs = &vx_softc[vx]; ! 987: if (vs->vs_type) { /* Its a BOP */ ! 988: printf("vx%d: vcmdrsp interrupt\n", vx); ! 989: return; ! 990: } ! 991: s = spl8(); ! 992: vp = vs->vs_addr; ! 993: cp = &vs->vs_cmds; ! 994: resp = (char *)vp + (vp->v_rspoff&0x7fff); ! 995: if (((k = resp[1])&V_UNBSY) == 0) { ! 996: printf("vx%d: cmdresp debug\n", vx); ! 997: splx(s); ! 998: vxstreset(vx); ! 999: return; ! 1000: } ! 1001: k &= VCMDLEN-1; ! 1002: cmd = cp->v_curcmd[k]; ! 1003: cp->v_curcmd[k] = (caddr_t)0; ! 1004: cp->v_curcnt--; ! 1005: k = *((short *)&resp[4]); /* cmd operation code */ ! 1006: if ((k&0xff00) == VXC_LIDENT) /* want hiport number */ ! 1007: for (k = 0; k < VRESPLEN; k++) ! 1008: cmd[k] = resp[k+4]; ! 1009: resp[1] = 0; ! 1010: vxxint(vx, (struct vxcmd *)cmd); ! 1011: if (vs->vs_state == VXS_READY) ! 1012: vinthandl(vx, ((V_BSY|RSPquals) << 8)|V_INTR); ! 1013: splx(s); ! 1014: } ! 1015: ! 1016: /* ! 1017: * Unsolicited interrupt. ! 1018: */ ! 1019: vunsol(vx) ! 1020: register vx; ! 1021: { ! 1022: register struct vxdevice *vp; ! 1023: struct vx_softc *vs; ! 1024: int s; ! 1025: ! 1026: scope_out(1); ! 1027: vs = &vx_softc[vx]; ! 1028: if (vs->vs_type) { /* Its a BOP */ ! 1029: printf("vx%d: vunsol from BOP\n", vx); ! 1030: return; ! 1031: } ! 1032: s = spl8(); ! 1033: vp = vs->vs_addr; ! 1034: if (vp->v_uqual&V_UNBSY) { ! 1035: vxrint(vx); ! 1036: vinthandl(vx, ((V_BSY|UNSquals) << 8)|V_INTR); ! 1037: #ifdef notdef ! 1038: } else { ! 1039: printf("vx%d: unsolicited interrupt error\n", vx); ! 1040: splx(s); ! 1041: vxstreset(vx); ! 1042: #endif ! 1043: } ! 1044: splx(s); ! 1045: } ! 1046: ! 1047: /* ! 1048: * Enqueue an interrupt. ! 1049: */ ! 1050: vinthandl(vx, item) ! 1051: register int vx; ! 1052: register item; ! 1053: { ! 1054: register struct vcmds *cp; ! 1055: int empty; ! 1056: ! 1057: cp = &vx_softc[vx].vs_cmds; ! 1058: empty = (cp->v_itrfill == cp->v_itrempt); ! 1059: cp->v_itrqueu[cp->v_itrfill] = item; ! 1060: if (++cp->v_itrfill >= VC_IQLEN) ! 1061: cp->v_itrfill = 0; ! 1062: if (cp->v_itrfill == cp->v_itrempt) { ! 1063: printf("vx%d: interrupt q overflow\n", vx); ! 1064: vxstreset(vx); ! 1065: } else if (empty) ! 1066: vintempt(vx); ! 1067: } ! 1068: ! 1069: vintempt(vx) ! 1070: int vx; ! 1071: { ! 1072: register struct vcmds *cp; ! 1073: register struct vxdevice *vp; ! 1074: register struct vx_softc *vs; ! 1075: register short item; ! 1076: register short *intr; ! 1077: ! 1078: vs = &vx_softc[vx]; ! 1079: vp = vs->vs_addr; ! 1080: if (vp->v_vioc&V_BSY) ! 1081: return; ! 1082: cp = &vs->vs_cmds; ! 1083: if (cp->v_itrempt == cp->v_itrfill) ! 1084: return; ! 1085: item = cp->v_itrqueu[cp->v_itrempt]; ! 1086: intr = (short *)&vp->v_vioc; ! 1087: switch ((item >> 8)&03) { ! 1088: ! 1089: case CMDquals: { /* command */ ! 1090: int phys; ! 1091: ! 1092: if (cp->v_empty == cp->v_fill || vp->v_vcbsy&V_BSY) ! 1093: break; ! 1094: vs->vs_mricmd = (caddr_t)cp->cmdbuf[cp->v_empty]; ! 1095: phys = vtoph((struct proc *)0, ! 1096: (unsigned)cp->cmdbuf[cp->v_empty]); ! 1097: vp->v_vcp[0] = ((short *)&phys)[0]; ! 1098: vp->v_vcp[1] = ((short *)&phys)[1]; ! 1099: vp->v_vcbsy = V_BSY; ! 1100: *intr = item; ! 1101: scope_out(4); ! 1102: break; ! 1103: } ! 1104: ! 1105: case RSPquals: /* command response */ ! 1106: *intr = item; ! 1107: scope_out(7); ! 1108: break; ! 1109: ! 1110: case UNSquals: /* unsolicited interrupt */ ! 1111: vp->v_uqual = 0; ! 1112: *intr = item; ! 1113: scope_out(2); ! 1114: break; ! 1115: } ! 1116: } ! 1117: ! 1118: /* ! 1119: * Start a reset on a vioc after error (hopefully) ! 1120: */ ! 1121: vxstreset(vx) ! 1122: register int vx; ! 1123: { ! 1124: register struct vx_softc *vs; ! 1125: register struct vxdevice *vp; ! 1126: register struct vxcmd *cp; ! 1127: register int j; ! 1128: extern int vxinreset(); ! 1129: int s; ! 1130: ! 1131: vs = &vx_softc[vx]; ! 1132: s = spl8(); ! 1133: if (vs->vs_state == VXS_RESET) { /* avoid recursion */ ! 1134: splx(s); ! 1135: return; ! 1136: } ! 1137: vp = vs->vs_addr; ! 1138: /* ! 1139: * Zero out the vioc structures, mark the vioc as being ! 1140: * reset, reinitialize the free command list, reset the vioc ! 1141: * and start a timer to check on the progress of the reset. ! 1142: */ ! 1143: bzero((caddr_t)&vs->vs_zero, ! 1144: (unsigned)((caddr_t)(vs + 1) - (caddr_t)&vs->vs_zero)); ! 1145: ! 1146: /* ! 1147: * Setting VXS_RESET prevents others from issuing ! 1148: * commands while allowing currently queued commands to ! 1149: * be passed to the VIOC. ! 1150: */ ! 1151: vs->vs_state = VXS_RESET; ! 1152: /* init all cmd buffers */ ! 1153: for (j = 0; j < NVCXBUFS; j++) { ! 1154: cp = &vs->vs_lst[j]; ! 1155: cp->c_fwd = &vs->vs_lst[j+1]; ! 1156: } ! 1157: vs->vs_avail = &vs->vs_lst[0]; ! 1158: cp->c_fwd = (struct vxcmd *)0; ! 1159: printf("vx%d: reset...", vx); ! 1160: vp->v_fault = 0; ! 1161: vp->v_vioc = V_BSY; ! 1162: vp->v_hdwre = V_RESET; /* generate reset interrupt */ ! 1163: timeout(vxinreset, (caddr_t)vx, hz*5); ! 1164: splx(s); ! 1165: } ! 1166: ! 1167: /* continue processing a reset on a vioc after an error (hopefully) */ ! 1168: vxinreset(vx) ! 1169: int vx; ! 1170: { ! 1171: register struct vxdevice *vp; ! 1172: int s = spl8(); ! 1173: ! 1174: vp = vx_softc[vx].vs_addr; ! 1175: /* ! 1176: * See if the vioc has reset. ! 1177: */ ! 1178: if (vp->v_fault != VXF_READY) { ! 1179: printf(" vxreset failed\n"); ! 1180: splx(s); ! 1181: return; ! 1182: } ! 1183: /* ! 1184: * Send a LIDENT to the vioc and mess with carrier flags ! 1185: * on parallel printer ports. ! 1186: */ ! 1187: vxinit(vx, 0); ! 1188: splx(s); ! 1189: } ! 1190: ! 1191: /* ! 1192: * Finish the reset on the vioc after an error (hopefully). ! 1193: * ! 1194: * Restore modem control, parameters and restart output. ! 1195: * Since the vioc can handle no more then 24 commands at a time ! 1196: * and we could generate as many as 48 commands, we must do this in ! 1197: * phases, issuing no more then 16 commands at a time. ! 1198: */ ! 1199: vxfnreset(vx, cp) ! 1200: register int vx; ! 1201: register struct vxcmd *cp; ! 1202: { ! 1203: register struct vx_softc *vs; ! 1204: register struct vxdevice *vp; ! 1205: register struct tty *tp, *tp0; ! 1206: register int i; ! 1207: #ifdef notdef ! 1208: register int on; ! 1209: #endif ! 1210: extern int vxrestart(); ! 1211: int s = spl8(); ! 1212: ! 1213: vs = &vx_softc[vx]; ! 1214: vrelease(vs, cp); ! 1215: vs->vs_state = VXS_READY; ! 1216: ! 1217: vp = vs->vs_addr; ! 1218: vp->v_vcid = 0; ! 1219: ! 1220: /* ! 1221: * Restore modem information and control. ! 1222: */ ! 1223: tp0 = &vx_tty[vx*16]; ! 1224: for (i = vs->vs_loport; i <= vs->vs_hiport; i++) { ! 1225: tp = tp0 + i; ! 1226: if (tp->t_state&(TS_ISOPEN|TS_WOPEN)) { ! 1227: tp->t_state &= ~TS_CARR_ON; ! 1228: vcmodem(tp->t_dev, VMOD_ON); ! 1229: if (tp->t_state&TS_CARR_ON) ! 1230: (void)(*linesw[tp->t_line].l_modem)(tp, 1); ! 1231: else if (tp->t_state & TS_ISOPEN) ! 1232: (void)(*linesw[tp->t_line].l_modem)(tp, 0); ! 1233: } ! 1234: #ifdef notdef ! 1235: /* ! 1236: * If carrier has changed while we were resetting, ! 1237: * take appropriate action. ! 1238: */ ! 1239: on = vp->v_dcd & 1<<i; ! 1240: if (on && (tp->t_state&TS_CARR_ON) == 0) ! 1241: (void)(*linesw[tp->t_line].l_modem)(tp, 1); ! 1242: else if (!on && tp->t_state&TS_CARR_ON) ! 1243: (void)(*linesw[tp->t_line].l_modem)(tp, 0); ! 1244: #endif ! 1245: } ! 1246: vs->vs_state = VXS_RESET; ! 1247: timeout(vxrestart, (caddr_t)vx, hz); ! 1248: splx(s); ! 1249: } ! 1250: ! 1251: /* ! 1252: * Restore a particular aspect of the VIOC. ! 1253: */ ! 1254: vxrestart(vx) ! 1255: int vx; ! 1256: { ! 1257: register struct tty *tp, *tp0; ! 1258: register struct vx_softc *vs; ! 1259: register int i, count; ! 1260: int s = spl8(); ! 1261: ! 1262: count = vx >> 8; ! 1263: vx &= 0xff; ! 1264: vs = &vx_softc[vx]; ! 1265: vs->vs_state = VXS_READY; ! 1266: tp0 = &vx_tty[vx*16]; ! 1267: for (i = vs->vs_loport; i <= vs->vs_hiport; i++) { ! 1268: tp = tp0 + i; ! 1269: if (count != 0) { ! 1270: tp->t_state &= ~(TS_BUSY|TS_TIMEOUT); ! 1271: if (tp->t_state&(TS_ISOPEN|TS_WOPEN)) ! 1272: vxstart(tp); /* restart pending output */ ! 1273: } else { ! 1274: if (tp->t_state&(TS_WOPEN|TS_ISOPEN)) ! 1275: vxcparam(tp, &tp->t_termios, 0); ! 1276: } ! 1277: } ! 1278: if (count == 0) { ! 1279: vs->vs_state = VXS_RESET; ! 1280: timeout(vxrestart, (caddr_t)(vx + 1*256), hz); ! 1281: } else ! 1282: printf(" vx reset done\n"); ! 1283: splx(s); ! 1284: } ! 1285: ! 1286: vxreset(dev) ! 1287: dev_t dev; ! 1288: { ! 1289: ! 1290: vxstreset((int)VXUNIT(minor(dev))); /* completes asynchronously */ ! 1291: } ! 1292: ! 1293: #ifdef VX_DEBUG ! 1294: vxfreset(vx) ! 1295: register int vx; ! 1296: { ! 1297: struct vba_device *vi; ! 1298: ! 1299: if ((unsigned)vx > NVX || (vi = vxinfo[vx]) == 0 || vi->ui_addr == 0) ! 1300: return (ENODEV); ! 1301: vx_softc[vx].vs_state = VXS_READY; ! 1302: vxstreset(vx); ! 1303: return (0); /* completes asynchronously */ ! 1304: } ! 1305: #endif ! 1306: ! 1307: vcmodem(dev, flag) ! 1308: dev_t dev; ! 1309: { ! 1310: struct tty *tp; ! 1311: register struct vxcmd *cp; ! 1312: register struct vx_softc *vs; ! 1313: register struct vxdevice *kp; ! 1314: register port; ! 1315: int unit; ! 1316: ! 1317: unit = minor(dev); ! 1318: tp = &vx_tty[unit]; ! 1319: vs = (struct vx_softc *)tp->t_addr; ! 1320: if (vs->vs_state != VXS_READY) ! 1321: return; ! 1322: cp = vobtain(vs); ! 1323: kp = vs->vs_addr; ! 1324: ! 1325: port = VXPORT(unit); ! 1326: /* ! 1327: * Issue MODEM command ! 1328: */ ! 1329: cp->cmd = VXC_MDMCTL; ! 1330: if (flag == VMOD_ON) { ! 1331: if (vs->vs_softCAR & (1 << port)) { ! 1332: cp->par[0] = V_MANUAL | V_DTR_ON | V_RTS; ! 1333: kp->v_dcd |= (1 << port); ! 1334: } else ! 1335: cp->par[0] = V_AUTO | V_DTR_ON; ! 1336: } else ! 1337: cp->par[0] = V_DTR_OFF; ! 1338: cp->par[1] = port; ! 1339: (void) vcmd((int)vs->vs_nbr, (caddr_t)&cp->cmd); ! 1340: if ((kp->v_dcd | vs->vs_softCAR) & (1 << port) && flag == VMOD_ON) ! 1341: tp->t_state |= TS_CARR_ON; ! 1342: } ! 1343: ! 1344: /* ! 1345: * VCMINTR called when an unsolicited interrupt occurs signaling ! 1346: * some change of modem control state. ! 1347: */ ! 1348: vcmintr(vx) ! 1349: register vx; ! 1350: { ! 1351: register struct vxdevice *kp; ! 1352: register struct tty *tp; ! 1353: register port; ! 1354: register struct vx_softc *vs; ! 1355: ! 1356: vs = &vx_softc[vx]; ! 1357: kp = vs->vs_addr; ! 1358: port = kp->v_usdata[0] & 017; ! 1359: tp = &vx_tty[vx*16+port]; ! 1360: ! 1361: if (kp->v_ustat & DCD_ON) ! 1362: (void)(*linesw[tp->t_line].l_modem)(tp, 1); ! 1363: else if ((kp->v_ustat & DCD_OFF) && ! 1364: ((vs->vs_softCAR & (1 << port))) == 0 && ! 1365: (*linesw[tp->t_line].l_modem)(tp, 0) == 0) { ! 1366: register struct vcmds *cp; ! 1367: register struct vxcmd *cmdp; ! 1368: ! 1369: /* clear all pending transmits */ ! 1370: if (tp->t_state&(TS_BUSY|TS_FLUSH) && ! 1371: vs->vs_vers == VXV_NEW) { ! 1372: int i, cmdfound = 0; ! 1373: ! 1374: cp = &vs->vs_cmds; ! 1375: for (i = cp->v_empty; i != cp->v_fill; ) { ! 1376: cmdp = (struct vxcmd *)((long *)cp->cmdbuf[i]-1); ! 1377: if ((cmdp->cmd == VXC_XMITDTA || ! 1378: cmdp->cmd == VXC_XMITIMM) && ! 1379: ((struct vxmit *)cmdp->par)->line == port) { ! 1380: cmdfound++; ! 1381: cmdp->cmd = VXC_FDTATOX; ! 1382: cmdp->par[1] = port; ! 1383: } ! 1384: if (++i >= VC_CMDBUFL) ! 1385: i = 0; ! 1386: } ! 1387: if (cmdfound) ! 1388: tp->t_state &= ~(TS_BUSY|TS_FLUSH); ! 1389: /* cmd is already in vioc, have to flush it */ ! 1390: else { ! 1391: cmdp = vobtain(vs); ! 1392: cmdp->cmd = VXC_FDTATOX; ! 1393: cmdp->par[1] = port; ! 1394: (void) vcmd(vx, (caddr_t)&cmdp->cmd); ! 1395: } ! 1396: } ! 1397: } else if ((kp->v_ustat&BRK_CHR) && (tp->t_state&TS_ISOPEN)) { ! 1398: (*linesw[tp->t_line].l_rint)(TTY_FE, tp); ! 1399: return; ! 1400: } ! 1401: } ! 1402: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.