![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to vcc.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 vcc.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 driver ! 5: */ ! 6: #include "../h/param.h" ! 7: #include "../h/file.h" ! 8: #include "../h/ioctl.h" ! 9: #include "../h/tty.h" ! 10: #include "../h/errno.h" ! 11: #include "../h/time.h" ! 12: #include "../h/kernel.h" ! 13: #include "../vba/vioc.h" ! 14: #include "../sna/snadebug.h" ! 15: #ifdef VXPERF ! 16: #include "../vba/scope.h" ! 17: #endif VXPERF ! 18: ! 19: #define CMDquals 0 ! 20: #define RSPquals 1 ! 21: #define UNSquals 2 ! 22: ! 23: long reinit = 0; ! 24: extern struct vcx vcx[] ; ! 25: extern struct tty vx_tty[]; ! 26: struct vcmds v_cmds[NVIOCX] ; ! 27: ! 28: extern char vxtype[]; ! 29: extern char vxbbno; ! 30: extern char vxbopno[]; ! 31: ! 32: #if defined(NVSNA) | defined(NSD) ! 33: extern vbrall(); ! 34: #else ! 35: vbrall() {}; ! 36: #endif ! 37: ! 38: extern struct vxcmd *vobtain(); ! 39: ! 40: #ifdef VX_DEBUG ! 41: #include "../vba/vxdebug.h" ! 42: #endif ! 43: ! 44: /* ! 45: * Write a command out to the VIOC ! 46: */ ! 47: vcmd(n, cmdad) ! 48: register int n ; ! 49: register caddr_t cmdad ; /* command address */ ! 50: { ! 51: ! 52: register struct vcmds *cp ; ! 53: register struct vcx *xp; ! 54: int s ; ! 55: ! 56: s = spl8() ; ! 57: cp = &v_cmds[n] ; ! 58: xp = &vcx[n]; ! 59: if (xp->v_state&V_RESETTING && cmdad != NULL) { ! 60: /* ! 61: * When the vioc is resetting, don't process ! 62: * anything other than LIDENT commands. ! 63: */ ! 64: register struct vxcmd *cp = (struct vxcmd *) ! 65: ((char *)cmdad - sizeof(cp->c_fwd)); ! 66: if (cp->cmd != LIDENT) { ! 67: vrelease(xp, cp); ! 68: return(0); ! 69: } ! 70: } ! 71: if (cmdad != (caddr_t) 0) { ! 72: #ifdef VX_DEBUG ! 73: if ((*((short *)cmdad) == FDTATOX) && (vxdebug & VXVCC)) ! 74: printf("vcmd: FDTATOX queued to VIOC%d\n",n); ! 75: #endif ! 76: cp->cmdbuf[cp->v_fill] = cmdad ; ! 77: if( ++cp->v_fill >= VC_CMDBUFL ) cp->v_fill = 0 ; ! 78: if(cp->v_fill == cp->v_empty) { ! 79: vpanic("vc: CMD Q OVFLO") ; ! 80: vxstreset(n); ! 81: splx(s); ! 82: return(0); ! 83: } ! 84: cp->v_cmdsem++; ! 85: } ! 86: if(cp->v_cmdsem && cp->v_curcnt < vcx[n].v_maxcmd) { ! 87: cp->v_cmdsem--; ! 88: cp->v_curcnt++; ! 89: vinthandl(n, ((V_BSY | CMDquals) << 8) | V_INTR ) ; ! 90: } ! 91: splx(s) ; ! 92: } ! 93: ! 94: /* ! 95: * VIOC acknowledge interrupt. The VIOC has received the new ! 96: * command. If no errors, the new command becomes one of 16 (max) ! 97: * current commands being executed. ! 98: */ ! 99: vackint(n) ! 100: register n ; /* VIOC number */ ! 101: { ! 102: ! 103: register struct vblok *vp ; ! 104: register struct vcmds *cp ; ! 105: register s; ! 106: ! 107: #ifdef VXPERF ! 108: scope_out(5); ! 109: #endif VXPERF ! 110: if (vxtype[n]) { /* Its a BOP */ ! 111: vbrall(n); /* Int. from BOP, port 0 */ ! 112: return; ! 113: } ! 114: s = spl8(); ! 115: vp = VBAS(n) ; ! 116: cp = &v_cmds[n] ; ! 117: if( vp->v_vcid & V_ERR ) { ! 118: register char *resp; ! 119: register i; ! 120: printf ("INTR ERR type = %x VIOC = %x, v_dcd: %lx\n", ! 121: vp->v_vcid & 07, n, vp->v_dcd & 0xff); ! 122: /* resp = (char *)vp + (vp->v_rspoff & 0x7FFF); */ ! 123: resp = (char *)(&vcx[n])->v_mricmd; ! 124: for(i=0; i<16; i++) ! 125: printf("%x ", resp[i]&0xff); ! 126: vpanic( "\nvcc: vackint") ; ! 127: splx(s); ! 128: vxstreset(n); ! 129: return ; ! 130: } else ! 131: if((vp->v_hdwre&017) == CMDquals) { ! 132: #ifdef VX_DEBUG ! 133: if (vxintr4 & VXERR4) { /* causes VIOC INTR ERR 4 */ ! 134: register struct vxcmd *cp1; ! 135: register struct vxcmd *cp0 = (struct vxcmd *) ! 136: ((long)cp->cmdbuf[cp->v_empty] - 4); ! 137: if ((cp0->cmd == XMITDTA) || (cp0->cmd == XMITIMM)) { ! 138: cp1 = vobtain(&vcx[n]); ! 139: *cp1 = *cp0; ! 140: vxintr4 &= ~VXERR4; ! 141: vcmd(n,&cp1->cmd); ! 142: } ! 143: } ! 144: #endif ! 145: cp->v_curcmd[vp->v_vcid & VCMDLEN-1] = cp->cmdbuf[cp->v_empty] ; ! 146: if( ++cp->v_empty >= VC_CMDBUFL ) cp->v_empty = 0 ; ! 147: } ! 148: if( ++cp->v_itrempt >= VC_IQLEN ) cp->v_itrempt = 0 ; ! 149: vintempt(n) ; ! 150: splx(s); ! 151: vcmd(n, 0); /* queue next cmd, if any */ ! 152: } ! 153: ! 154: /* ! 155: * Command Response interrupt. The Vioc has completed ! 156: * a command. The command may now be returned to ! 157: * the appropriate device driver . ! 158: */ ! 159: vcmdrsp(n) ! 160: register n ; ! 161: { ! 162: ! 163: register struct vblok *vp ; ! 164: register struct vcmds *cp ; ! 165: register caddr_t cmd ; ! 166: register char *resp ; ! 167: register k ; ! 168: register int s ; ! 169: ! 170: #ifdef VXPERF ! 171: scope_out(6); ! 172: #endif VXPERF ! 173: if (vxtype[n]) { /* Its a BOP */ ! 174: printf("vcmdrsp: stray interrupt from BOP at VIOC%d...\n",n); ! 175: return; ! 176: } ! 177: s = spl8(); ! 178: vp = VBAS(n) ; ! 179: cp = &v_cmds[n] ; ! 180: resp = (char *)vp; ! 181: resp += vp->v_rspoff & 0x7FFF; ! 182: ! 183: if ( ! 184: #if VX_TESTING ! 185: (vx_test&VX_CMDRESP_DEBUG) == 0 && ! 186: #endif ! 187: (k=resp[1]) & V_UNBSY ) { ! 188: k &= VCMDLEN-1; ! 189: cmd = cp->v_curcmd[k]; ! 190: cp->v_curcmd[k] = (caddr_t)0; ! 191: cp->v_curcnt--; ! 192: k = *((short *)&resp[4]); /* cmd operation code */ ! 193: if((k & 0xFF00) == LIDENT) { /* want hiport number */ ! 194: for(k=0; k<VRESPLEN; k++) ! 195: cmd[k] = resp[k+4]; ! 196: } ! 197: resp[1] = 0; ! 198: vxxint(n, cmd) ; ! 199: if ((&vcx[n])->v_state == V_RESETTING) return; ! 200: } ! 201: else { ! 202: vpanic( "vc, cmdresp debug") ; ! 203: splx(s); ! 204: vxstreset(n); ! 205: return; ! 206: } ! 207: ! 208: vinthandl(n, ( (V_BSY | RSPquals) << 8 ) | V_INTR ) ; ! 209: splx(s); ! 210: ! 211: } ! 212: ! 213: ! 214: /* ! 215: * Unsolicited interrupt. ! 216: */ ! 217: vunsol(n) ! 218: register(n) ; ! 219: { ! 220: ! 221: register struct vblok *vp ; ! 222: register s; ! 223: ! 224: #ifdef VXPERF ! 225: scope_out(1); ! 226: #endif VXPERF ! 227: if (vxtype[n]) { /* Its a BOP */ ! 228: printf("vunsol: stray interrupt from BOP at VIOC%d...\n",n); ! 229: return; ! 230: } ! 231: s = spl8(); ! 232: vp = VBAS(n) ; ! 233: if ( ! 234: #if VX_TESTING ! 235: (vx_test&VX_UNSOL_INT_DEBUG) == 0 && ! 236: #endif ! 237: vp->v_uqual & V_UNBSY) { ! 238: if (vxrint(n)) ! 239: vinthandl(n, ( (V_BSY | UNSquals) << 8 ) | V_INTR ) ; ! 240: splx(s); ! 241: } ! 242: else { ! 243: vpanic("vc: UNSOL INT ERR") ; ! 244: splx(s); ! 245: vxstreset(n); ! 246: } ! 247: } ! 248: ! 249: /* ! 250: * Enqueue an interrupt ! 251: */ ! 252: vinthandl(n, item) ! 253: register int n ; ! 254: register item ; ! 255: { ! 256: ! 257: register struct vcmds *cp ; ! 258: register int empflag = 0 ; ! 259: ! 260: cp = &v_cmds[n] ; ! 261: if( cp->v_itrfill == cp->v_itrempt ) empflag++ ; ! 262: cp->v_itrqueu[cp->v_itrfill] = item ; ! 263: if( ++cp->v_itrfill >= VC_IQLEN ) cp->v_itrfill = 0 ; ! 264: if(cp->v_itrfill == cp->v_itrempt) { ! 265: vpanic( "vc: INT Q OVFLO" ) ; ! 266: vxstreset(n); ! 267: } ! 268: else if( empflag ) vintempt(n) ; ! 269: } ! 270: ! 271: vintempt(n) ! 272: register int n ; ! 273: { ! 274: register struct vcmds *cp ; ! 275: register struct vblok *vp ; ! 276: register short item ; ! 277: register short *intr ; ! 278: ! 279: vp = VBAS(n) ; ! 280: if(vp->v_vioc & V_BSY) return ; ! 281: cp = &v_cmds[n] ; ! 282: if(cp->v_itrempt == cp->v_itrfill) return ; ! 283: item = cp->v_itrqueu[cp->v_itrempt] ; ! 284: intr = (short *)&vp->v_vioc ; ! 285: switch( (item >> 8) & 03 ) { ! 286: ! 287: case CMDquals: /* command */ ! 288: { ! 289: int phys; ! 290: ! 291: if(cp->v_empty == cp->v_fill || vp->v_vcbsy&V_BSY) ! 292: break; ! 293: (&vcx[n])->v_mricmd = (caddr_t)cp->cmdbuf[cp->v_empty]; ! 294: phys = vtoph(0, cp->cmdbuf[cp->v_empty]) ; /* should be a sys address */ ! 295: vp->v_vcp[0] = ((short *)&phys)[0]; ! 296: vp->v_vcp[1] = ((short *)&phys)[1]; ! 297: vp->v_vcbsy = V_BSY ; ! 298: *intr = item ; ! 299: } ! 300: #ifdef VXPERF ! 301: scope_out(4); ! 302: #endif VXPERF ! 303: break ; ! 304: ! 305: case RSPquals: /* command response */ ! 306: *intr = item ; ! 307: #ifdef VXPERF ! 308: scope_out(7); ! 309: #endif VXPERF ! 310: break ; ! 311: ! 312: case UNSquals: /* unsolicited interrupt */ ! 313: vp->v_uqual = 0 ; ! 314: *intr = item ; ! 315: #ifdef VXPERF ! 316: scope_out(2); ! 317: #endif VXPERF ! 318: break ; ! 319: } ! 320: } ! 321: ! 322: ! 323: /* start a reset on a vioc after error (hopefully) */ ! 324: vxstreset(n) ! 325: register n; ! 326: { ! 327: register struct vcx *xp; ! 328: register struct vblok *vp ; ! 329: register struct vxcmd *cp; ! 330: register int j; ! 331: extern int vxinreset(); ! 332: int s ; ! 333: ! 334: s = spl8() ; ! 335: vp = VBAS(n); ! 336: xp = &vcx[n]; ! 337: ! 338: #if VX_TESTING ! 339: vx_test = 0; ! 340: #endif ! 341: if (xp->v_state&V_RESETTING) ! 342: /* ! 343: * Avoid infinite recursion. ! 344: */ ! 345: return; ! 346: ! 347: /* ! 348: * Zero out the vioc structures, mark the vioc as being ! 349: * reset, reinitialize the free command list, reset the vioc ! 350: * and start a timer to check on the progress of the reset. ! 351: */ ! 352: bzero(&v_cmds[n], sizeof(struct vcmds)); ! 353: bzero(xp, sizeof(struct vcx)); ! 354: ! 355: /* ! 356: * Setting V_RESETTING prevents others from issuing ! 357: * commands while allowing currently queued commands to ! 358: * be passed to the VIOC. ! 359: */ ! 360: xp->v_state |= V_RESETTING; ! 361: for(j=0; j<NVCXBUFS; j++) /* init all cmd buffers */ ! 362: { ! 363: cp = &xp->vx_lst[j]; /* index a buffer */ ! 364: cp->c_fwd = &xp->vx_lst[j+1]; /* point to next buf */ ! 365: } ! 366: xp->vx_avail = &xp->vx_lst[0]; /* set idx to 1st free buf */ ! 367: cp->c_fwd = (struct vxcmd *)0; /* mark last buf in free list */ ! 368: ! 369: printf("resetting VIOC %x .. ", n); ! 370: ! 371: vp->v_fault = 0 ; ! 372: vp->v_vioc = V_BSY ; ! 373: vp->v_hdwre = V_RESET ; /* reset interrupt */ ! 374: ! 375: timeout(vxinreset, (caddr_t)n, hz*5); ! 376: splx(s); ! 377: return; ! 378: } ! 379: ! 380: /* continue processing a reset on a vioc after an error (hopefully) */ ! 381: vxinreset(vioc) ! 382: caddr_t vioc; ! 383: { ! 384: register struct vcx *xp; ! 385: register struct vblok *vp ; ! 386: register int n = (int)vioc; ! 387: int s = spl8(); ! 388: printf("vxinreset "); ! 389: ! 390: vp = VBAS(n); ! 391: xp = &vcx[n]; ! 392: ! 393: /* ! 394: * See if the vioc has reset. ! 395: */ ! 396: if (vp->v_fault != VREADY) { ! 397: printf("failed\n"); ! 398: splx(s); ! 399: return; ! 400: } ! 401: ! 402: /* ! 403: * Send a LIDENT to the vioc and mess with carrier flags ! 404: * on parallel printer ports. ! 405: */ ! 406: vxinit(n, 0); ! 407: splx(s); ! 408: } ! 409: ! 410: /* ! 411: * Restore modem control, parameters and restart output. ! 412: * Since the vioc can handle no more then 24 commands at a time ! 413: * and we could generate as many as 48 commands, we must do this in ! 414: * phases, issuing no more then 16 commands at a time. ! 415: */ ! 416: /* finish the reset on the vioc after an error (hopefully) */ ! 417: vxfnreset(n, cp) ! 418: register int n; ! 419: register struct vxcmd *cp; ! 420: { ! 421: register struct vcx *xp; ! 422: register struct vblok *vp ; ! 423: register struct tty *tp; ! 424: register int i; ! 425: register int on; ! 426: extern int vxrestart(); ! 427: int s = spl8(); ! 428: printf("vxfnreset "); ! 429: ! 430: vp = VBAS(n); ! 431: xp = &vcx[n]; ! 432: ! 433: xp->v_loport = cp->par[5]; /* save low port number */ ! 434: xp->v_hiport = cp->par[7];/* VIOC knows high port numbr */ ! 435: vrelease(xp,cp); /* done with this control block */ ! 436: xp->v_nbr = n; /* assign VIOC-X board number */ ! 437: ! 438: xp->v_state &= ~V_RESETTING; ! 439: ! 440: vp->v_vcid = 0; ! 441: ! 442: /* ! 443: * Restore modem information and control. ! 444: */ ! 445: for(i=xp->v_loport; i<=xp->v_hiport; i++) { ! 446: tp = &vx_tty[i+n*16]; ! 447: if (tp->t_state&(TS_ISOPEN|TS_WOPEN)) { ! 448: tp->t_state &= ~TS_CARR_ON; ! 449: vcmodem(tp->t_dev, VMOD_ON); ! 450: if (tp->t_state&TS_CARR_ON) { ! 451: wakeup((caddr_t)&tp->t_canq) ; ! 452: } ! 453: else { ! 454: if(tp->t_state & TS_ISOPEN) { ! 455: ttyflush(tp, FREAD|FWRITE); ! 456: if(tp->t_state&TS_FLUSH) ! 457: wakeup((caddr_t)&tp->t_state) ; ! 458: if((tp->t_flags&NOHANG)==0) { ! 459: gsignal(tp->t_pgrp, SIGHUP) ; ! 460: gsignal(tp->t_pgrp, SIGCONT); ! 461: } ! 462: } ! 463: } ! 464: } ! 465: /* ! 466: * If carrier has changed while we were resetting, ! 467: * take appropriate action. ! 468: */ ! 469: /* ! 470: on = vp->v_dcd & 1<<i; ! 471: if (on && (tp->t_state&TS_CARR_ON) == 0) { ! 472: tp->t_state |= TS_CARR_ON ; ! 473: wakeup((caddr_t)&tp->t_canq) ; ! 474: } else if (!on && tp->t_state&TS_CARR_ON) { ! 475: tp->t_state &= ~TS_CARR_ON ; ! 476: if(tp->t_state & TS_ISOPEN) { ! 477: ttyflush(tp, FREAD|FWRITE); ! 478: if(tp->t_state&TS_FLUSH) ! 479: wakeup((caddr_t)&tp->t_state) ; ! 480: if((tp->t_flags&NOHANG)==0) { ! 481: gsignal(tp->t_pgrp, SIGHUP) ; ! 482: gsignal(tp->t_pgrp, SIGCONT); ! 483: } ! 484: } ! 485: } ! 486: */ ! 487: } ! 488: ! 489: xp->v_state |= V_RESETTING; ! 490: ! 491: timeout(vxrestart, (caddr_t)n, hz); ! 492: splx(s); ! 493: } ! 494: ! 495: /* ! 496: * Restore a particular aspect of the VIOC. ! 497: */ ! 498: vxrestart(vioc) ! 499: caddr_t vioc; ! 500: { ! 501: register struct tty *tp, *tp0; ! 502: register struct vcx *xp; ! 503: register int i, cnt; ! 504: register int n = (int)vioc; ! 505: int s = spl8(); ! 506: ! 507: cnt = n>>8; ! 508: printf("vxrestart %d ",cnt); ! 509: n &= 0xff; ! 510: ! 511: tp0 = &vx_tty[n*16]; ! 512: xp = &vcx[n]; ! 513: ! 514: xp->v_state &= ~V_RESETTING; ! 515: ! 516: for(i=xp->v_loport; i<=xp->v_hiport; i++) { ! 517: tp = tp0 + i; ! 518: if (cnt != 0) { ! 519: tp->t_state &= ~(TS_BUSY|TS_TIMEOUT); ! 520: if(tp->t_state&(TS_ISOPEN|TS_WOPEN)) /* restart pending output */ ! 521: vxstart(tp); ! 522: } else { ! 523: if (tp->t_state&(TS_WOPEN|TS_ISOPEN)) ! 524: vxcparam(tp->t_dev, 0); ! 525: } ! 526: } ! 527: ! 528: if (cnt == 0) { ! 529: xp->v_state |= V_RESETTING; ! 530: timeout(vxrestart, (caddr_t)(n + 1*256), hz); ! 531: } else ! 532: printf("done\n"); ! 533: splx(s); ! 534: } ! 535: ! 536: vxreset(dev) ! 537: dev_t dev; ! 538: { ! 539: vxstreset(minor(dev)>>4); /* completes asynchronously */ ! 540: } ! 541: ! 542: vxfreset(n) ! 543: register int n; ! 544: { ! 545: register struct vblok *vp; ! 546: ! 547: if (n < 0 || n > NVX || VBAS(n) == NULL) ! 548: return(ENODEV); ! 549: vcx[n].v_state &= ~V_RESETTING; ! 550: vxstreset(n); ! 551: return(0); /* completes asynchronously */ ! 552: } ! 553: #endif ! 554:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.