![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to nvcx.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / vba|
Return to nvcx.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / sys / vba |
1.1 ! root 1: #include "vx.h" ! 2: #if NVX > 0 ! 3: /* ! 4: * VIOC-X driver ! 5: */ ! 6: ! 7: #include "../h/param.h" ! 8: #include "../h/ioctl.h" ! 9: #include "../h/tty.h" ! 10: #include "../h/dir.h" ! 11: #include "../h/user.h" ! 12: #include "../h/map.h" ! 13: #include "../machine/pte.h" ! 14: #include "../h/buf.h" ! 15: #include "../vba/vbavar.h" ! 16: #include "../h/conf.h" ! 17: #include "../h/file.h" ! 18: #include "../h/uio.h" ! 19: #include "../vba/vioc.h" ! 20: #ifdef VXPERF ! 21: #include "../vba/scope.h" ! 22: #endif VXPERF ! 23: ! 24: #include "vbsc.h" ! 25: #if NVBSC > 0 ! 26: #include "../bsc/bscio.h" ! 27: #include "../bsc/bsc.h" ! 28: char bscport[NVXPORTS]; ! 29: long bscno = 0; ! 30: extern struct bsc bsc[]; ! 31: #endif ! 32: ! 33: #define RSPquals 1 ! 34: ! 35: struct vcx vcx[NVIOCX]; ! 36: struct tty vx_tty[NVXPORTS]; ! 37: extern struct vcmds v_cmds[]; ! 38: struct vba_device *vxinfo[NVIOCX]; ! 39: ! 40: int vxstart(); ! 41: int ttrstrt(); ! 42: caddr_t vtoph(); ! 43: struct vxcmd *vobtain(); ! 44: ! 45: /* ! 46: * Driver information for auto-configuration stuff. ! 47: * (not tested and probably should be changed) ! 48: */ ! 49: int vxprobe(), vxattach(), vxrint(); ! 50: long vxstd[] = { 0 }; ! 51: struct vba_driver vxdriver = ! 52: { vxprobe, 0, vxattach, 0, vxstd, "VIOC ", vxinfo }; ! 53: ! 54: char vxtype[NVIOCX]; /* 0: viox-x/vioc-b; 1: vioc-bop */ ! 55: char vxbopno[NVIOCX]; /* BOP board no. if indicated by vxtype[] */ ! 56: char vxbbno = -1; ! 57: short vbtbl = -1; ! 58: int vx_cnt = NVXPORTS; /* needed by vmstat/iostat */ ! 59: extern vbrall(); ! 60: ! 61: vxprobe(reg) ! 62: caddr_t reg; ! 63: { ! 64: register int br, cvec; ! 65: register struct vblok *vp = (struct vblok *)reg; ! 66: ! 67: #ifdef lint ! 68: br = 0; cvec = br; br = cvec; ! 69: #endif ! 70: ! 71: if (badaddr(vp, 1)) ! 72: return(0); ! 73: vp->v_fault = 0; ! 74: vp->v_vioc = V_BSY; ! 75: vp->v_hdwre = V_RESET; /* reset interrupt */ ! 76: ! 77: DELAY(4000000); ! 78: if (vp->v_fault != VREADY) ! 79: return(0); ! 80: return(1); ! 81: } ! 82: ! 83: vxattach(ui) ! 84: register struct vba_device *ui; ! 85: { ! 86: VIOCBAS[ui->ui_unit] = ui->ui_addr; ! 87: vxinit(ui->ui_unit, 1); ! 88: } ! 89: ! 90: /* ! 91: * Open a VX line. ! 92: */ ! 93: vxopen(dev, flag) ! 94: { ! 95: register struct tty *tp; /* pointer to tty struct for port */ ! 96: register struct vcx *xp; /* pointer to VIOC-X info/cmd buffer */ ! 97: register int d; /* minor device number */ ! 98: register int error; ! 99: ! 100: d = minor(dev); /* get minor device number */ ! 101: if (d >= NVXPORTS) /* validate minor device number */ ! 102: return(ENXIO); /* set errno to indicate bad port # */ ! 103: tp = &vx_tty[d]; /* index the tty structure for port */ ! 104: ! 105: xp = &vcx[d>>4]; /* index VIOC-X info/cmd area */ ! 106: d &= 017; ! 107: ! 108: /* ! 109: * If we are resetting the VIOC, wait until the LIDENT has ! 110: * completed. ! 111: */ ! 112: while (xp->v_state&V_RESETTING) ! 113: sleep((caddr_t)&xp->v_state); ! 114: ! 115: if (xp->v_hiport == xp->v_loport || /* no ports on this board */ ! 116: d < xp->v_loport || d > xp->v_hiport)/* not in the range of ports */ ! 117: return(ENXIO); /* bad minor device number */ ! 118: ! 119: if (isprinter(xp, d)) ! 120: /* ! 121: * Printers have different semantics than tty ports. ! 122: * They have a fixed output transliteration, no read, ! 123: * only one process may open them at a time, they always ! 124: * have carrier and processes cannot be attached to them. ! 125: */ ! 126: if (tp->t_state&TS_ISOPEN) ! 127: return(EBUSY); ! 128: ! 129: if ((tp->t_state&(TS_ISOPEN|TS_WOPEN))==0){/* is device already open? */ ! 130: ttychars(tp); /* set default control chars */ ! 131: tp->t_addr = (caddr_t)xp;/* store addr of VIOC-X info */ ! 132: tp->t_oproc = vxstart; /* store address of startup routine */ ! 133: tp->t_dev = dev; /* store major/minor device numbers */ ! 134: if (tp->t_ispeed == 0) {/* if no default speeds set them */ ! 135: tp->t_ispeed = SSPEED;/* default input baud */ ! 136: tp->t_ospeed = SSPEED;/* default output baud */ ! 137: tp->t_flags |= (ODDP|EVENP|ECHO); /* default modes */ ! 138: } ! 139: vxparam(dev); /* set parameters for this port */ ! 140: } ! 141: /* ! 142: * If already open for exclusive use open fails unless caller is root. ! 143: */ ! 144: if (tp->t_state&TS_XCLUDE && u.u_uid!=0) ! 145: return(EBUSY); /* device is busy, sorry */ ! 146: ! 147: d = spl8(); ! 148: tp->t_state |= TS_WOPEN; /* mark device as waiting for open */ ! 149: /* ! 150: * Check for carrier ! 151: */ ! 152: if (vcmodem(dev, VMOD_ON)) ! 153: tp->t_state |= TS_CARR_ON; ! 154: else ! 155: tp->t_state &= ~TS_CARR_ON; ! 156: while ((tp->t_state&TS_CARR_ON) == 0) { ! 157: tp->t_state |= TS_WOPEN; ! 158: sleep(&tp->t_canq, TTIPRI); ! 159: } ! 160: error = (*linesw[tp->t_line].l_open)(dev, tp);/*let tty.c finish open */ ! 161: splx(d); ! 162: return(error); ! 163: } ! 164: ! 165: /* ! 166: * Close a VX line. ! 167: */ ! 168: vxclose(dev, flag) ! 169: dev_t dev; ! 170: int flag; ! 171: { ! 172: register int d = minor(dev); ! 173: register struct tty *tp = &vx_tty[d]; ! 174: register int s = spl8(); ! 175: register int error; ! 176: ! 177: error = (*linesw[tp->t_line].l_close)(tp); ! 178: if ((tp->t_state&TS_ISOPEN) && (tp->t_state&TS_HUPCLS)) { ! 179: register int flags = tp->t_flags; ! 180: ! 181: /* ! 182: ** Turn off echo to prevent infinite flushing ! 183: ** Flush output queue then turn off clear to send. ! 184: ** Always restore flags so line disipline will not change. ! 185: */ ! 186: tp->t_flags &= ~ECHO; ! 187: ttywait(tp); ! 188: tp->t_flags = flags; ! 189: vcmodem(dev, VMOD_OFF); ! 190: } ! 191: while ((tp->t_state&TS_FLUSH) && (tp->t_state&TS_BUSY)) ! 192: sleep((caddr_t)&tp->t_state, TTOPRI); ! 193: ttyclose(tp); /* let tty.c finish the close */ ! 194: splx(s); ! 195: return(error); ! 196: } ! 197: ! 198: /* ! 199: * Read from a VX line. ! 200: */ ! 201: vxread(dev, uio) ! 202: dev_t dev; ! 203: struct uio *uio; ! 204: { ! 205: register int d = minor(dev); ! 206: register struct tty *tp = &vx_tty[d]; ! 207: register struct vcx *xp = &vcx[d>>4]; ! 208: ! 209: d &= 0xf; ! 210: if (isprinter(xp, d)) ! 211: return(ENODEV); ! 212: return(*linesw[tp->t_line].l_read)(tp, uio); ! 213: } ! 214: ! 215: /* ! 216: * Write on a VX line. ! 217: */ ! 218: vxwrite(dev, uio) ! 219: dev_t dev; ! 220: struct uio *uio; ! 221: { ! 222: register int d = minor(dev); ! 223: register struct tty *tp = &vx_tty[d]; ! 224: ! 225: return(*linesw[tp->t_line].l_write)(tp, uio); ! 226: } ! 227: ! 228: /* ! 229: * VIOCX unsolicited interrupt. ! 230: */ ! 231: vxrint(n) ! 232: int n; /* mux number */ ! 233: { ! 234: register struct tty *tp; ! 235: register struct vcx *xp; ! 236: register short *sp; ! 237: register int i; ! 238: register unsigned int c; ! 239: register int port; ! 240: struct tty *tp0; ! 241: struct vblok *kp; ! 242: short *savsilo; ! 243: struct silo { ! 244: char data; ! 245: unsigned char port; ! 246: }; ! 247: ! 248: kp = VBAS(n); ! 249: xp = &vcx[n]; ! 250: #if VX_TESTING ! 251: c = kp->v_uqual&037; ! 252: if (vx_test&VX_PROC_ERR_DEBUG) ! 253: c = 2; ! 254: else if (vx_test&VX_UQUAL_ERR_DEBUG) ! 255: c = 5; ! 256: switch (c) { ! 257: #else ! 258: switch (kp->v_uqual&037) { ! 259: #endif ! 260: case 0: ! 261: break; ! 262: case 2: ! 263: printf(" ERR NBR %x\n", kp->v_ustat); ! 264: if (kp->v_ustat == 0x40) { ! 265: printf("VIOC %x lost some read data\n", n); ! 266: return(0); ! 267: } ! 268: vpanic("vc: VC PROC ERR"); ! 269: vxstreset(n); ! 270: return(0); ! 271: case 3: ! 272: vcmintr(n); ! 273: return(1); ! 274: case 4: ! 275: return(1); ! 276: default: ! 277: printf(" ERR NBR %x\n", kp->v_uqual); ! 278: vpanic("vc: VC UQUAL ERR"); ! 279: vxstreset(n); ! 280: return(0); ! 281: } ! 282: ! 283: /* ! 284: * Get the address of the silo in VIOC common memory. ! 285: */ ! 286: sp = (short *)((char *)kp + *(short *)kp->v_usdata); ! 287: ! 288: nextsilo: ! 289: ! 290: /* ! 291: * See if the number of characters is reasonable. ! 292: */ ! 293: i = *(savsilo = sp); ! 294: if (i > xp->v_silosiz) { ! 295: printf("vx: %d exceeds silo size\n", i); ! 296: i = xp->v_silosiz; ! 297: } ! 298: ! 299: /* ! 300: * Drain the silo. ! 301: */ ! 302: tp0 = &vx_tty[n<<4]; ! 303: for (sp++; i > 0; i--, sp++) { ! 304: port = ((struct silo *)sp)->port&017; ! 305: if (port < xp->v_loport || port > xp->v_hiport) ! 306: /* ! 307: * Not a valid port. ! 308: */ ! 309: continue; ! 310: ! 311: tp = tp0 + port; ! 312: if ((tp->t_state&TS_ISOPEN) == 0) ! 313: /* ! 314: * Nobody is listening. ! 315: */ ! 316: continue; ! 317: ! 318: /* ! 319: * Fetch the character from vioc memory. ! 320: */ ! 321: c = ((struct silo *)sp)->data; ! 322: ! 323: switch (((struct silo *)sp)->port&(PERROR|FERROR)) { ! 324: case PERROR: ! 325: case PERROR|FERROR: ! 326: if ((tp->t_flags&(EVENP|ODDP)) == EVENP || ! 327: (tp->t_flags&(EVENP|ODDP)) == ODDP) ! 328: continue; ! 329: if (!(((struct silo *)sp)->port&FERROR)) ! 330: break; ! 331: ! 332: case FERROR: ! 333: if (tp->t_flags&RAW) ! 334: c = 0; ! 335: else ! 336: c = tp->t_intrc; ! 337: } ! 338: (*linesw[tp->t_line].l_rint)(c, tp); ! 339: } ! 340: *savsilo = 0; ! 341: return(1); ! 342: } ! 343: ! 344: /* ! 345: * stty/gtty for VX. ! 346: */ ! 347: vxioctl(dev, cmd, data, flag) ! 348: int dev; /* major, minor device numbers */ ! 349: int cmd; /* command */ ! 350: caddr_t data; ! 351: int flag; ! 352: { ! 353: register int d = minor(dev); ! 354: register struct tty *tp = &vx_tty[d]; ! 355: register int error; ! 356: ! 357: switch (cmd) { ! 358: case VCMANUAL: ! 359: case VCGRS232: ! 360: case VCSRS232: ! 361: /* ! 362: * Intercept device specific commands. ! 363: */ ! 364: return(vcumodem(dev, cmd, data, flag)); ! 365: default: ! 366: break; ! 367: } ! 368: ! 369: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag); ! 370: if (error == 0) ! 371: return(error); ! 372: if ((error = ttioctl(tp, cmd, data, flag)) >= 0) ! 373: { ! 374: if (cmd==TIOCSETP||cmd==TIOCSETN) ! 375: vxparam(dev); ! 376: return(error); ! 377: } else ! 378: return(ENOTTY); ! 379: } ! 380: ! 381: vxparam(dev) ! 382: dev_t dev; ! 383: { ! 384: vxcparam(dev, 1); ! 385: } ! 386: ! 387: /* ! 388: * Set parameters from open or stty into the VX hardware ! 389: * registers. ! 390: */ ! 391: vxcparam(dev, wait) ! 392: dev_t dev; /* major, minor device numbers */ ! 393: int wait; /* nonzero if we should wait for finish */ ! 394: { ! 395: register struct tty *tp; ! 396: register struct vcx *xp; ! 397: register struct vxcmd *cp; ! 398: register int s = spl8(); ! 399: ! 400: tp = &vx_tty[minor(dev)]; /* pointer to tty structure for port */ ! 401: xp = (struct vcx *)tp->t_addr; /* pointer to VIOCX info/cmd buffer */ ! 402: ! 403: cp = vobtain(xp); ! 404: cp->cmd = LPARAX; /* set command to "load parameters" */ ! 405: cp->par[1] = minor(dev)&017; /* port number */ ! 406: ! 407: /* ! 408: * Check for XON/XOFF flow control. ! 409: */ ! 410: cp->par[2] = (tp->t_flags&RAW)? 0 : tp->t_startc; /* XON char */ ! 411: cp->par[3] = (tp->t_flags&RAW)? 0 : tp->t_stopc; /* XOFF char */ ! 412: ! 413: if (tp->t_flags&(RAW|LITOUT) || ! 414: (tp->t_flags&(EVENP|ODDP)) == (EVENP|ODDP)) { ! 415: cp->par[4] = 0xc0; /* 8 bits of data */ ! 416: cp->par[7] = 0; /* no parity */ ! 417: } else { ! 418: cp->par[4] = 0x40; /* 7 bits of data */ ! 419: if ((tp->t_flags&(EVENP|ODDP)) == ODDP) ! 420: cp->par[7] = 1; /* odd parity */ ! 421: else if ((tp->t_flags&(EVENP|ODDP)) == EVENP) ! 422: cp->par[7] = 3; /* even parity */ ! 423: else ! 424: cp->par[7] = 0; /* no parity */ ! 425: } ! 426: cp->par[5] = (tp->t_stopbits == 0) ? 4 : tp->t_stopbits; ! 427: if (tp->t_ospeed == EXTA || tp->t_ospeed == EXTB) ! 428: cp->par[6] = 19; /* 19200 BAUD */ ! 429: else ! 430: cp->par[6] = tp->t_ospeed; ! 431: ! 432: if (vcmd(xp->v_nbr, &cp->cmd) && wait) ! 433: sleep(cp, TTIPRI); ! 434: splx(s); ! 435: } ! 436: ! 437: /* ! 438: * VIOCX command response interrupt. ! 439: * For transmission, restart output to any active port. ! 440: * For all other commands, just clean up. ! 441: * This routine is called with spl8 from vcmdrsp(). ! 442: */ ! 443: vxxint(n, cp) ! 444: register int n; /* VIOC number */ ! 445: register struct vxcmd *cp; /* command structure */ ! 446: { ! 447: register struct vxmit *vp, *pvp; ! 448: register struct tty *tp; ! 449: register struct vcx *xp; ! 450: register struct tty *hp; ! 451: register int port; ! 452: ! 453: xp = &vcx[n]; ! 454: cp = (struct vxcmd *)((long *)cp-1); ! 455: #if NVBSC > 0 ! 456: switch (cp->cmd) { ! 457: case MDMCTL1: case HUNTMD1: case LPARAX1: ! 458: vrelease(xp, cp); ! 459: wakeup(cp); ! 460: return; ! 461: } ! 462: #endif ! 463: switch (cp->cmd&0xff00) { ! 464: case LIDENT: /* initialization complete */ ! 465: if (xp->v_state&V_RESETTING) ! 466: vxfnreset(n, cp); ! 467: cp->cmd++; ! 468: return; ! 469: case XMITDTA: case XMITIMM: ! 470: break; ! 471: case LPARAX: ! 472: wakeup(cp); ! 473: case FDTATOX: ! 474: default: /* MDMCTL or FDTATOX */ ! 475: vrelease(xp, cp); ! 476: return; ! 477: } ! 478: for (vp = (struct vxmit *)(cp->par + (cp->cmd&07)*sizvxmit); ! 479: vp >= (struct vxmit *)cp->par; ! 480: vp = (struct vxmit *) ((char *)vp - sizvxmit)) { ! 481: tp = &vx_tty[(vp->line&017)+(n<<4)]; ! 482: ! 483: #if NVBSC > 0 ! 484: port = vp->line; ! 485: if (tp->t_line == LDISP) { ! 486: vrelease(xp, cp); ! 487: /* ! 488: * Call bsctxd with logical bscport no; 0,1..4,5. ! 489: * v_xmtcnt was set to BISYNC ctlr no in vxinit(). ! 490: */ ! 491: bsctxd((xp->v_xmtcnt*NBSC)+port); ! 492: return; ! 493: } ! 494: if (bscport[(n<<4)+port] == BISYNC) { ! 495: printf("\nvxxint: int. after line closed. (cmd:%lx)", ! 496: cp->cmd&0xff); ! 497: vrelease(xp, cp); ! 498: return; ! 499: } ! 500: #endif ! 501: pvp = vp; ! 502: tp->t_state &= ~TS_BUSY; ! 503: if (tp->t_state&TS_FLUSH) { ! 504: tp->t_state &= ~TS_FLUSH; ! 505: wakeup((caddr_t)&tp->t_state); ! 506: } ! 507: else ! 508: ndflush(&tp->t_outq, vp->bcount+1); ! 509: } ! 510: xp->v_xmtcnt--; ! 511: vrelease(xp, cp); ! 512: vp = pvp; ! 513: vxstart(tp); ! 514: return; ! 515: } ! 516: ! 517: /* ! 518: * Start (restart) transmission on the given VX line. ! 519: */ ! 520: vxstart(tp) ! 521: register struct tty *tp; ! 522: { ! 523: register short nch; ! 524: register struct vcx *xp; ! 525: register char *outb; ! 526: register full = 0; ! 527: int s, port; ! 528: ! 529: s = spl8(); ! 530: port = minor(tp->t_dev)&017; ! 531: xp = (struct vcx *)tp->t_addr; ! 532: if (!(tp->t_state&(TS_TIMEOUT|TS_BUSY|TS_TTSTOP))) { ! 533: if (tp->t_outq.c_cc <= TTLOWAT(tp)) { ! 534: if (tp->t_state&TS_ASLEEP) { ! 535: tp->t_state &= ~TS_ASLEEP; ! 536: wakeup((caddr_t)&tp->t_outq); ! 537: } ! 538: if (tp->t_wsel) { ! 539: selwakeup(tp->t_wsel, tp->t_state&TS_WCOLL); ! 540: tp->t_wsel = 0; ! 541: tp->t_state &= ~TS_WCOLL; ! 542: } ! 543: } ! 544: if (tp->t_outq.c_cc == 0) { ! 545: splx(s); ! 546: return(0); ! 547: } ! 548: #ifdef VXPERF ! 549: scope_out(3); ! 550: #endif VXPERF ! 551: if (!(tp->t_flags&(RAW|LITOUT))) ! 552: full = 0200; ! 553: if ((nch = ndqb(&tp->t_outq, full)) == 0) { ! 554: if (full) { ! 555: nch = getc(&tp->t_outq); ! 556: timeout(ttrstrt, (caddr_t)tp, (nch&0177) +6); ! 557: tp->t_state |= TS_TIMEOUT; ! 558: full = 0; ! 559: } ! 560: } else { ! 561: outb = (char *)tp->t_outq.c_cf; ! 562: tp->t_state |= TS_BUSY; ! 563: vsend(xp, port, outb, nch); ! 564: } ! 565: } ! 566: splx(s); ! 567: return; ! 568: } ! 569: ! 570: /* ! 571: * Stop output on a line. ! 572: */ ! 573: vxstop(tp) ! 574: register struct tty *tp; ! 575: { ! 576: register int s; ! 577: ! 578: s = spl8(); ! 579: if (tp->t_state&TS_BUSY) { ! 580: if ((tp->t_state&TS_TTSTOP)==0) { ! 581: tp->t_state |= TS_FLUSH; ! 582: } ! 583: } ! 584: splx(s); ! 585: } ! 586: ! 587: /* ! 588: * VIOCX Initialization. Makes free lists of command buffers. ! 589: * Resets all viocx's. Issues a LIDENT command to each ! 590: * viocx which establishes interrupt vectors and logical ! 591: * port numbers. ! 592: */ ! 593: vxinit(i, wait) ! 594: register int i; ! 595: int wait; ! 596: { ! 597: register struct vcx *xp; /* ptr to VIOC-X info/cmd buffer */ ! 598: register struct vblok *kp; /* pointer to VIOC-X control block */ ! 599: register struct vxcmd *cp; /* pointer to a command buffer */ ! 600: register char *resp; /* pointer to response buffer */ ! 601: register int j, ix; ! 602: register struct vcmds *cpp; ! 603: char type; ! 604: #if NVBSC > 0 ! 605: register struct bsc *bp; /* bsc change */ ! 606: #endif ! 607: ! 608: /* ! 609: * Only initialize once. ! 610: */ ! 611: if (vbtbl) { ! 612: for (j = 0;j < NVIOCX; j++) ! 613: vxbopno[j] = (char)-1; ! 614: vbtbl = 0; ! 615: } ! 616: ! 617: kp = VBAS(i); /* get base adr of cntl blok for VIOC */ ! 618: xp = &vcx[i]; /* index info/command buffers */ ! 619: ! 620: cpp = &v_cmds[i]; ! 621: type = kp->v_ident; ! 622: vxtype[i] = 0; /* Type is VIOC-X */ ! 623: switch (type) { ! 624: case PVIOCX: ! 625: case VIOCX: ! 626: printf("WARNING: Old vioc no longer supported.\n"); ! 627: xp->v_loport = xp->v_hiport = 0; ! 628: return; ! 629: ! 630: case NWVIOCX: ! 631: case NPVIOCX: ! 632: xp->v_vers = V_NEW; ! 633: xp->v_silosiz = kp->v_maxsilo; ! 634: /* ! 635: * Initialize the port types. ! 636: */ ! 637: for (j = 0; j < 16; j++) ! 638: xp->vx_type[j] = kp->v_portyp[j]; ! 639: break; ! 640: ! 641: case VIOCB: /* old f/w, Bisync board */ ! 642: if (wait) { /* Just boot up */ ! 643: if (bscno >= NVBSC) { ! 644: printf("\nVIOCB no%ld is not configured in software", bscno); ! 645: break; ! 646: } ! 647: if (bscno >= MXVIOC_B) { ! 648: printf("\nvxinit: exceed max no of VIOC-B:%ld", ! 649: MXVIOC_B); ! 650: break; ! 651: } ! 652: } ! 653: printf("(kp:%lx)(xp:%lx): %lx---%x OLD VIOC-B, ", ! 654: (long)kp, (long)xp,(int)kp->v_ident, ! 655: (int)kp->v_fault); ! 656: xp->v_vers = V_OLD; ! 657: ! 658: if (wait) /* Use v_xmtcnt to */ ! 659: xp->v_xmtcnt = (char)bscno; /* save VIOC-B ctlrno */ ! 660: else ! 661: bscno = (long)xp->v_xmtcnt&0x7f; ! 662: ! 663: bp = &bsc[0+(bscno*4)]; ! 664: for (ix = 0; ix < 4; ix++, bp++) ! 665: bp->b_devregs = (caddr_t)xp; ! 666: bscno++; ! 667: bscport[(i<<4)+0] = BISYNC; ! 668: bscport[(i<<4)+1] = BISYNC; ! 669: bscport[(i<<4)+2] = BISYNC; ! 670: bscport[(i<<4)+3] = BISYNC; ! 671: printf(" Bisync initialized\n"); ! 672: break; ! 673: ! 674: case NWVIOCB: /* new f/w, Bisync board */ ! 675: if (wait) { /* Just boot up */ ! 676: if (bscno >= NVBSC) { ! 677: printf("\nVIOCB no%ld is not configured in software", bscno); ! 678: break; ! 679: } ! 680: if (bscno >= MXVIOC_B) { ! 681: printf("\nvxinit: exceed max no of VIOC-B:%ld", ! 682: MXVIOC_B); ! 683: break; ! 684: } ! 685: } ! 686: xp->v_vers = V_NEW; ! 687: xp->v_silosiz = kp->v_maxsilo; ! 688: ! 689: if (wait) /* Use v_xmtcnt to */ ! 690: xp->v_xmtcnt = (char)bscno; /* save VIOC-B ctlrno */ ! 691: else ! 692: bscno = (long)xp->v_xmtcnt&0x7f; ! 693: ! 694: bp = &bsc[bscno*4]; ! 695: for (ix = 0; ix < 4; ix++, bp++) ! 696: bp->b_devregs = (caddr_t)xp; ! 697: bscno++; ! 698: bscport[(i<<4)+0] = BISYNC; ! 699: bscport[(i<<4)+1] = BISYNC; ! 700: bscport[(i<<4)+2] = BISYNC; ! 701: bscport[(i<<4)+3] = BISYNC; ! 702: printf(" Bisync initialized\n"); ! 703: break; ! 704: ! 705: case VBOPID: /* VIOC-BOP */ ! 706: if (vxtype[i] == 0) { /* don't increment if already seen */ ! 707: vxbbno++; ! 708: vxtype[i] = 1; ! 709: vxbopno[i] = vxbbno; ! 710: } ! 711: printf(" VIOC-BOP initialized\n"); ! 712: ! 713: default: ! 714: return; /* Not a viocx type */ ! 715: } ! 716: xp->v_nbr = -1; /* no number for it yet */ ! 717: xp->v_maxcmd = xp->v_vers == V_NEW ? 23 : 3; ! 718: ! 719: for (j = 0; j < NVCXBUFS; j++) {/* init all cmd buffers */ ! 720: cp = &xp->vx_lst[j]; /* index a buffer */ ! 721: cp->c_fwd = &xp->vx_lst[j+1]; /* point to next buf */ ! 722: } ! 723: xp->vx_avail = &xp->vx_lst[0]; /* set idx to 1st free buf */ ! 724: cp->c_fwd = (struct vxcmd *)0; /* mark last buf in free list */ ! 725: ! 726: /* ! 727: * Assures proper state when reinit. in case of INT. ERR ! 728: */ ! 729: cpp->v_cmdsem = cpp->v_curcnt = cpp->v_fill = 0; ! 730: cpp->v_empty = cpp->v_itrfill = cpp->v_itrempt = 0; ! 731: ! 732: cp = vobtain(xp); /* grap the control block */ ! 733: cp->cmd = LIDENT; /* set command type */ ! 734: cp->par[0] = i * 4 + VCVECT; /* ack vector */ ! 735: cp->par[1] = cp->par[0] + 1; /* cmd resp vector */ ! 736: cp->par[3] = cp->par[0] + 2; /* unsol intr vector */ ! 737: cp->par[4] = 15; /* max ports, no longer used */ ! 738: cp->par[5] = 0; /* set 1st port number */ ! 739: vcmd(i, &cp->cmd); /* initialize the VIOC-X */ ! 740: if (!wait) ! 741: return; ! 742: ! 743: while (cp->cmd == LIDENT) /* wait for command completion */ ! 744: ; ! 745: ! 746: /* ! 747: * Calculate address of response buffer. ! 748: */ ! 749: resp = (char *)kp; ! 750: resp += kp->v_rspoff&0x3FFF; ! 751: ! 752: if (resp[0] != 0 && (resp[0]&0177) != 3) { /* did init work? */ ! 753: vrelease(xp, cp); /* init failed */ ! 754: return; /* try next VIOC-X */ ! 755: } ! 756: ! 757: xp->v_loport = cp->par[5]; /* save low port number */ ! 758: xp->v_hiport = cp->par[7]; /* VIOC knows high port numbr */ ! 759: vrelease(xp, cp); /* done with this control block */ ! 760: xp->v_nbr = i; /* assign VIOC-X board number */ ! 761: } ! 762: ! 763: /* ! 764: * Obtain a command buffer. ! 765: */ ! 766: struct vxcmd * ! 767: vobtain(xp) ! 768: register struct vcx *xp; ! 769: { ! 770: register struct vxcmd *p; ! 771: register int s; ! 772: ! 773: s = spl8(); ! 774: p = xp->vx_avail; ! 775: if (p == (struct vxcmd *)0) { ! 776: vpanic("vx: no buffs"); ! 777: vxstreset(xp - vcx); ! 778: splx(s); ! 779: return(vobtain(xp)); /* guaranteed to work this time */ ! 780: } ! 781: xp->vx_avail = (xp->vx_avail)->c_fwd; ! 782: splx(s); ! 783: return((struct vxcmd *)p); ! 784: } ! 785: ! 786: /* ! 787: * Release a command buffer. ! 788: */ ! 789: vrelease(xp, cp) ! 790: register struct vcx *xp; ! 791: register struct vxcmd *cp; ! 792: { ! 793: register int s = spl8(); ! 794: ! 795: cp->c_fwd = xp->vx_avail; ! 796: xp->vx_avail = cp; ! 797: splx(s); ! 798: } ! 799: ! 800: /* ! 801: * Arrange for "cnt" bytes from "addr" to be written to port number ! 802: * "port" on VIOC described by "xp". ! 803: */ ! 804: vsend(xp, port, addr, cnt) ! 805: register struct vcx *xp;/* points to vioc control structure for this port */ ! 806: int port; /* port number to get the data */ ! 807: caddr_t addr; /* beginning address of the block */ ! 808: register int cnt; /* size of the block of characters */ ! 809: { ! 810: register struct vxcmd *cp; ! 811: register struct vxmit *mp; ! 812: register int i; ! 813: register char *src, *dst; ! 814: ! 815: /* ! 816: * Get a command. ! 817: */ ! 818: cp = vobtain(xp); ! 819: ! 820: /* ! 821: * Fill out the port information. ! 822: */ ! 823: mp = (struct vxmit *)cp->par; ! 824: mp->bcount = cnt-1; ! 825: mp->line = port; ! 826: ! 827: if (cnt <= 6) { ! 828: /* ! 829: * If small enough, we can give the data directly to ! 830: * the vioc, eliminating the need for DMA. ! 831: */ ! 832: cp->cmd = XMITIMM; ! 833: src = addr; ! 834: i = cnt; ! 835: } else { ! 836: /* ! 837: * Get the physical address of the block to DMA. ! 838: */ ! 839: cp->cmd = XMITDTA; ! 840: addr = vtoph(0, (caddr_t)addr); ! 841: src = (char *)&addr; ! 842: i = sizeof(addr); ! 843: } ! 844: ! 845: /* ! 846: * Copy the data or address into the command. ! 847: */ ! 848: dst = mp->ostream; ! 849: while (--i >= 0) ! 850: *dst++ = *src++; ! 851: ! 852: xp->v_xmtcnt++; ! 853: vcmd(xp->v_nbr, (char *)&cp->cmd); ! 854: return; ! 855: } ! 856: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.