![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ds.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv8dc / sys / dev|
Return to ds.c CVS log | Up to [Research Unix] / researchv8dc / sys / dev |
1.1 ! root 1: /* 5-29-84 dsrelease checks for zombie state or even death */ ! 2: /* dsclose() shuts down device */ ! 3: /* DSWAIT added */ ! 4: /* 5-25-84 process pointer saved in dsopen for dsintr() */ ! 5: /* vsunlock must then be duplicated using correct process structure */ ! 6: /* the interrelation of dsstart-sleeping, dsintr, and dscleanup ! 7: needs to be cleaned up ! 8: Probably dscleanup should not call wakeup */ ! 9: ! 10: ! 11: #include "ds.h" ! 12: # if NDS > 0 ! 13: ! 14: /* ! 15: * DSC System 200 driver ! 16: * via DSC dma11. ! 17: * vax 4.1bsd version ! 18: */ ! 19: ! 20: #include "../h/param.h" ! 21: #include "../h/systm.h" ! 22: #include "../h/mount.h" ! 23: #include "../h/dir.h" ! 24: #include "../h/user.h" ! 25: #include "../h/pte.h" ! 26: #include "../h/map.h" ! 27: #include "../h/buf.h" ! 28: #include "../h/ubareg.h" ! 29: #include "../h/ubavar.h" ! 30: #include "../h/conf.h" ! 31: #include "../h/proc.h" ! 32: #include "../h/file.h" ! 33: #include "../h/vmmac.h" ! 34: ! 35: #include "../h/dsreg.h" ! 36: #include "../h/dsc.h" ! 37: ! 38: /* ! 39: * THESE ARE SITE-SPECIFIC ! 40: * ! 41: * starting base for the ! 42: * d/a and a/d converters, ! 43: * for setting up sequence ram. ! 44: */ ! 45: ! 46: /* ! 47: * reset device ! 48: */ ! 49: # define RESETDEV bit(4) ! 50: # define dsseq(sc, reg, conv, dir) \ ! 51: (sc->c_ascseq[reg] = conv | ((dir & 01) << 6)) ! 52: ! 53: /* ! 54: * ds flags ! 55: */ ! 56: # define DS_CLOSED 0 ! 57: # define DS_OPEN bit(0) ! 58: # define DS_IDLE bit(1) ! 59: # define DS_NDSK bit(2) ! 60: # define DS_MON bit(3) ! 61: # define DS_BRD bit(4) ! 62: # define DS_READ bit(5) ! 63: # define DS_WRITE bit(6) ! 64: ! 65: ! 66: # define DSPRI (PZERO+1) ! 67: /* ! 68: * Redundant book-keeping ! 69: * to help avoid page-wise overlap of buffers ! 70: * remember that this device is both asynchronous and ! 71: * uses user-supplied buffers ! 72: */ ! 73: struct dspageinfo { ! 74: int firstunit, ! 75: lastunit; /* in units of CLSIZE*NBPG, i.e. 1024 */ ! 76: }; ! 77: /* ! 78: * relevant information ! 79: * about the dma and asc ! 80: */ ! 81: struct ds_softc { ! 82: short c_dmacsr; /* copy of dma csr */ ! 83: short c_asccsr; /* copy of asc csr */ ! 84: short c_ascflags; /* initial asc flags */ ! 85: short c_ascsrt; /* sampling rate */ ! 86: short c_ascseq[8]; ! 87: int c_flags; /* internal flags */ ! 88: int c_errs; /* errors, returned via ioctl */ ! 89: int c_bufno; /* dsubinfo/buffer */ ! 90: int c_outbufno; ! 91: int c_uid; /* user id */ ! 92: short c_pid; /* process id */ ! 93: struct proc *c_procp; /* process structure pointer */ ! 94: int c_ubinfo[NDSB]; /* uba info */ ! 95: struct dspageinfo c_pageinfo[NDSB]; ! 96: struct buf c_dsb[NDSB]; /* buffer list */ ! 97: struct buf *c_ibp, *c_obp; /* buffer list pointers */ ! 98: int c_nbytes; /* total # of bytes xferred since reset */ ! 99: int c_to_idle; /* total # times idle flag set */ ! 100: int c_to_active; /* total # times idle flag cleared */ ! 101: } ds_softc[NDS]; ! 102: ! 103: int dsprobe(), dsattach(), dsintr(); ! 104: ! 105: struct uba_device *dsdinfo[NDS]; ! 106: struct uba_ctlr dsctlr[NDS], *dscinfo[NDS]; /* dsattach() sets dscinfo to point to this */ ! 107: ! 108: u_short dsstd[] = { ! 109: 0165400, 0 ! 110: }; ! 111: ! 112: struct uba_driver dsdriver = { ! 113: dsprobe, 0, dsattach, 0, dsstd, "ds", dsdinfo, "ds", dscinfo ! 114: }; ! 115: int dsdebug; ! 116: ! 117: /* ! 118: * all this just to generate ! 119: * an interrupt; rather ! 120: * involved isn't it? ! 121: */ ! 122: dsprobe(reg) ! 123: caddr_t reg; ! 124: { ! 125: register int br, cvec; /* value-result */ ! 126: register struct dsdevice *dsaddr; ! 127: int dummy; ! 128: ! 129: # ifdef lint ! 130: br = 0; cvec = br; br = cvec; ! 131: # endif lint ! 132: ! 133: dsaddr = (struct dsdevice *) reg; ! 134: ! 135: dsaddr->dmacsr = 0; ! 136: dsaddr->dmacls = 0; ! 137: dsaddr->ascseq[0] = DABASE+0 | ((DA & 01) << 6); ! 138: dsaddr->ascseq[0] |= LAST_SEQ; /* last sequence register */ ! 139: dsaddr->ascsrt = 0100; ! 140: dsaddr->dmacsr = DMA_IE; ! 141: dsaddr->asccsr = ASC_RUN | ASC_IE; ! 142: ! 143: DELAY(40000); ! 144: /* ! 145: * now shut everything down. ! 146: * too bad we have to duplicate ! 147: * the code from dsinit but to ! 148: * call dsinit we need to give ! 149: * it a unit. ! 150: */ ! 151: ! 152: dsaddr->dmacls = 0; ! 153: dummy = dsaddr->dmasar; /* clears sar flag */ ! 154: dsaddr->dmaclr = 0; ! 155: ! 156: dummy = dsaddr->ascrst; ! 157: dsaddr->ascrst = 0; ! 158: ! 159: return(1); ! 160: } ! 161: ! 162: dsattach(ui) ! 163: struct uba_device *ui; ! 164: { ! 165: register struct uba_ctlr *um; ! 166: register int unit; ! 167: register int i; ! 168: ! 169: unit = ui->ui_unit; ! 170: ! 171: um = &dsctlr[unit]; ! 172: dscinfo[unit] = um; ! 173: ui->ui_ctlr = unit; ! 174: ui->ui_mi = um; ! 175: um->um_driver = ui->ui_driver; ! 176: um->um_ctlr = unit; ! 177: um->um_ubanum = ui->ui_ubanum; ! 178: um->um_alive = 1; ! 179: um->um_intr = ui->ui_intr; ! 180: um->um_addr = ui->ui_addr; ! 181: um->um_hd = ui->ui_hd; ! 182: ds_softc[unit].c_flags = DS_IDLE; ! 183: for(i=0;i<NDSB;i++) ! 184: ds_softc[unit].c_dsb[i].b_flags &= ~B_BUSY; ! 185: } ! 186: ! 187: /* ARGSUSED */ ! 188: dsopen(dev, flag) ! 189: dev_t dev; ! 190: { ! 191: register struct dsdevice *dsaddr; ! 192: register struct uba_device *ui; ! 193: register struct ds_softc *sc; ! 194: register int unit, i; ! 195: register struct buf *bp; ! 196: int dummy; ! 197: ! 198: if ((unit = (minor(dev) & ~RESETDEV)) >= NDS) ! 199: goto bad; ! 200: ! 201: if ((ui = dsdinfo[unit]) == NULL) ! 202: goto bad; ! 203: ! 204: if (ui->ui_alive == 0) ! 205: goto bad; ! 206: ! 207: sc = &ds_softc[ui->ui_unit]; ! 208: dsaddr = (struct dsdevice *)ui->ui_addr; ! 209: ! 210: if(dsdebug)printf("dsopen: unit %d, flag %x\n",unit,flag); ! 211: if (dsaddr->dmacsr & DMA_OFL) { ! 212: u.u_error = ENXIO; ! 213: return; ! 214: } ! 215: ! 216: /* ! 217: * if this is the reset device ! 218: * then just do a reset and return. ! 219: */ ! 220: if (minor(dev) & RESETDEV) { ! 221: /* ! 222: * if the converters are in use then ! 223: * only the current user or root can ! 224: * do a reset. ! 225: */ ! 226: if (sc->c_flags & DS_OPEN) { ! 227: if ((sc->c_uid != u.u_ruid) && (u.u_uid != 0)) { ! 228: u.u_error = ENXIO; ! 229: return; ! 230: } ! 231: } ! 232: ds_softc[unit].c_flags = DS_CLOSED | DS_IDLE; ! 233: dscleanup(unit); ! 234: printf("ds%d: reset\n",unit); ! 235: return; ! 236: } ! 237: ! 238: /* ! 239: * only one person can use it at a time ! 240: * and it can't be opened for both reading and writing ! 241: */ ! 242: if (sc->c_flags & DS_OPEN || (flag & (FREAD|FWRITE)) == (FREAD|FWRITE)) { ! 243: bad: u.u_error = ENXIO; ! 244: return; ! 245: } ! 246: ! 247: /* ! 248: * initialize ! 249: */ ! 250: ! 251: ! 252: /* set defaults and initial conditions in ds_softc */ ! 253: sc->c_flags = DS_IDLE; ! 254: sc->c_errs = 0; ! 255: ! 256: sc->c_nbytes = sc->c_to_idle = sc->c_to_active = 0; ! 257: ! 258: sc->c_ascflags = (flag & FWRITE ? ASC_PLAY : ASC_RECORD) | ASC_HZ04; ! 259: sc->c_ascseq[0] = ( ! 260: (flag & FWRITE) ? ! 261: (DABASE+0 | (DA << 6)) : (ADBASE+0 | (AD << 6)) ! 262: ) | LAST_SEQ; ! 263: sc->c_ascsrt = 399; ! 264: ! 265: ! 266: sc->c_uid = u.u_ruid; ! 267: sc->c_pid = u.u_procp->p_pid; ! 268: sc->c_procp = u.u_procp; ! 269: if(dsdebug)printf("pid %d %d, flag %x stat %x\n", ! 270: sc->c_pid,sc->c_procp->p_pid,sc->c_procp->p_stat); ! 271: sc->c_flags |= DS_OPEN | (flag & FREAD ? DS_READ : DS_WRITE); ! 272: u.u_procp->p_flag |= SPHYSIO; ! 273: dsaddr->dmacsr = 0; ! 274: dummy = dsaddr->dmasar; ! 275: } ! 276: ! 277: /* ARGSUSED */ ! 278: dsclose(dev, flag) { ! 279: register int unit; ! 280: register struct dsdevice *dsaddr; ! 281: register struct uba_device *ui; ! 282: register struct ds_softc *sc; ! 283: ! 284: unit = minor(dev) & ~RESETDEV; ! 285: sc = &ds_softc[unit]; ! 286: ui = dsdinfo[unit]; ! 287: dsaddr = (struct dsdevice *)ui->ui_addr; ! 288: if(dsdebug)printf("X"); ! 289: if (sc->c_outbufno != sc->c_bufno && ! 290: sc->c_errs == 0 && !(sc->c_flags & DS_IDLE)) ! 291: tsleep((caddr_t)&ds_softc[unit], DSPRI,0); ! 292: dsaddr->asccsr = 0; ! 293: ds_softc[unit].c_flags = DS_CLOSED | DS_IDLE; ! 294: dscleanup(unit); ! 295: u.u_procp->p_flag &= ~ SPHYSIO; ! 296: if(dsdebug){ ! 297: printf("to_active %d, to_idle %d, c_nbytes %d\n", ! 298: sc->c_to_active, ! 299: sc->c_to_idle, ! 300: sc->c_nbytes); ! 301: printf("c_ascseq[0] %x\n",sc->c_ascseq[0]); ! 302: dsdb(dsaddr); ! 303: } ! 304: } ! 305: ! 306: /* ! 307: * ! 308: * Using u.u_count, u.u_base, each buffer header is set up. ! 309: * The converters only need the base address of the buffer and the word ! 310: * count. ! 311: * ! 312: */ ! 313: dsstart(dev, rw) ! 314: register dev_t dev; ! 315: { ! 316: register struct dsdevice *dsaddr; ! 317: register struct uba_device *ui; ! 318: register struct ds_softc *sc; ! 319: register struct buf *bp; ! 320: register int unit, c, bufno, ps; ! 321: int dummy,i, count; ! 322: caddr_t base; ! 323: int bits; ! 324: ! 325: if(dsdebug)printf("S"); ! 326: ! 327: unit = minor(dev) & ~RESETDEV; ! 328: sc = &ds_softc[unit]; ! 329: ui = dsdinfo[unit]; ! 330: dsaddr = (struct dsdevice *)ui->ui_addr; ! 331: ! 332: /* ! 333: * check user access rights to buffer ! 334: */ ! 335: if (useracc(u.u_base, u.u_count, rw==B_READ?B_WRITE:B_READ) == NULL) { ! 336: u.u_error = EFAULT; ! 337: return; ! 338: } ! 339: ! 340: if (sc->c_errs) { ! 341: u.u_error = EIO; ! 342: return; ! 343: } ! 344: ! 345: ! 346: /* ! 347: * Get a buffer for each 64K block ! 348: * point each device buffer somewhere into ! 349: * the user's buffer ! 350: */ ! 351: /* NOTE that in order to get reasonable performance, ! 352: * buffer lengths (initial u.u_count) must be either ! 353: * less than 64K or sufficiently greater than a multiple ! 354: * of 64K. ! 355: */ ! 356: base = u.u_base; ! 357: count = u.u_count; ! 358: while(count > 0) { ! 359: ! 360: if(dsdebug)printf("LT "); ! 361: ! 362: /* ! 363: * no hardware buffers left, sleep till interrupt ! 364: * wakes us up ! 365: */ ! 366: ! 367: ! 368: ps = spl6(); ! 369: if ((sc->c_dmacsr = dsaddr->dmacsr) & DMA_SFL) { ! 370: register ts; ! 371: if(dsdebug)printf("s"); ! 372: ts = tsleep((caddr_t) &ds_softc[unit], DSPRI, 0); ! 373: if(dsdebug)printf("w"); ! 374: switch(ts) { ! 375: case TS_SIG: ! 376: u.u_error = EINTR; ! 377: /* stop dsc, if active */ ! 378: dsaddr->asccsr = dummy = 0; ! 379: dscleanup(unit); ! 380: return; ! 381: case TS_OK: ! 382: if ((sc->c_dmacsr = dsaddr->dmacsr) & DMA_SFL) { ! 383: u.u_error = EIO; ! 384: printf("ds%d still full after tsleep\n",unit); ! 385: dscleanup(unit); ! 386: return; ! 387: } ! 388: /* I don't think this allows for a clean dsclose() ! 389: in all cases */ ! 390: if((sc->c_flags & DS_CLOSED) || ! 391: !(sc->c_flags & DS_OPEN)){ ! 392: if(dsdebug) ! 393: printf("ds: wakeup unopen\n"); ! 394: u.u_error = EIO; ! 395: dscleanup(unit); ! 396: return; ! 397: } ! 398: break; ! 399: default: ! 400: printf("ds: %x from tsleep\n",ts); ! 401: dscleanup(unit); ! 402: u.u_error = EIO; ! 403: return; ! 404: } ! 405: } ! 406: ! 407: splx(ps); ! 408: ! 409: ! 410: ps = spl6(); ! 411: ! 412: /* ! 413: * If device is IDLE (initial read/write, or datalate condition ! 414: * has been detected in dsintr()), (re)initialize dsc ! 415: */ ! 416: ! 417: if (sc->c_flags & DS_IDLE) { ! 418: ! 419: if(dsdebug) ! 420: printf("I1 "); ! 421: dsaddr->asccsr = sc->c_asccsr = sc->c_ascflags; ! 422: dummy = dsaddr->ascrst; ! 423: dsaddr->asccsr = (sc->c_asccsr |= ASC_IE); ! 424: dsaddr->ascsrt = sc->c_ascsrt; ! 425: {register j, i = 0; ! 426: do { ! 427: dsaddr->ascseq[i] = sc->c_ascseq[i]; ! 428: j = i++; ! 429: } while(!(sc->c_ascseq[j] & LAST_SEQ) && i<8); ! 430: } ! 431: dsaddr->dmacsr = sc->c_dmacsr = 0; ! 432: dsaddr->dmacls = 0; ! 433: dummy = dsaddr->dmasar; /* clears sfl flag */ ! 434: dsaddr->dmawc = -1; ! 435: dsaddr->dmacsr = sc->c_dmacsr = (DMA_IE | DMA_CHN ! 436: | (rw == B_READ ? DMA_W2M : 0) ); ! 437: ! 438: sc->c_bufno = sc->c_outbufno = 0; ! 439: sc->c_ibp = sc->c_obp = &sc->c_dsb[0]; /* correct? */ ! 440: ! 441: } ! 442: ! 443: ! 444: /* get next device buffer and set it up */ ! 445: bp = sc->c_ibp++; ! 446: if (sc->c_ibp > &sc->c_dsb[NDSB-1]) ! 447: sc->c_ibp = &sc->c_dsb[0]; ! 448: ! 449: /* hopefully redundant check against going to fast */ ! 450: if(bp->b_flags & B_BUSY){ ! 451: printf("dsstart: about to set up BUSY buffer!\n"); ! 452: u.u_error = EIO; ! 453: return; ! 454: } ! 455: ! 456: ! 457: c = MIN(count, 1024*64); ! 458: bp->b_un.b_addr = base; ! 459: bp->b_error = 0; ! 460: bp->b_proc = u.u_procp; ! 461: bp->b_dev = dev; ! 462: bp->b_blkno = sc->c_bufno; ! 463: bp->b_bcount = c; ! 464: bufno = sc->c_bufno % NDSB; ! 465: ! 466: /* the page computations should be relative to param.h defs */ ! 467: ! 468: sc->c_pageinfo[bufno].firstunit = (int)base >> 10; ! 469: sc->c_pageinfo[bufno].lastunit=(((int)base+c+1023)>>10)-1; ! 470: ! 471: for(i=0;i<NDSB;i++) ! 472: if((sc->c_dsb[i].b_flags & B_BUSY) ! 473: && ! 474: (!(sc->c_pageinfo[bufno].firstunit > ! 475: sc->c_pageinfo[i].lastunit) ! 476: && ! 477: !(sc->c_pageinfo[bufno].lastunit < ! 478: sc->c_pageinfo[i].firstunit))) { ! 479: printf("ds: buf %d overlaps %d\n",i,bufno); ! 480: u.u_error=EIO; ! 481: return; ! 482: } ! 483: ! 484: /* lock the buffer and send it off */ ! 485: ! 486: bp->b_flags = B_BUSY | B_PHYS | rw; ! 487: if(dsdebug)printf("lk%d %x %d ",bufno,base,c); ! 488: dslock(base, (int) c); /* fasten seat belts */ ! 489: ! 490: sc->c_ubinfo[bufno] = ubasetup(ui->ui_ubanum, bp, UBA_WANTBDP); ! 491: ! 492: dsaddr->dmablr = ~ (c >> 1); ! 493: dsaddr->dmasax = (sc->c_ubinfo[bufno] >> 16) & 03; ! 494: dsaddr->dmasar = sc->c_ubinfo[bufno]; ! 495: ! 496: sc->c_bufno++; ! 497: ! 498: /* ! 499: * start the dsc, if necessary ! 500: */ ! 501: if(sc->c_flags & DS_IDLE){ ! 502: if(dsdebug)printf("I2 "); ! 503: sc->c_flags &= ~DS_IDLE; ! 504: ++sc->c_to_active; ! 505: dsaddr->asccsr = (sc->c_asccsr |= ASC_RUN); ! 506: } ! 507: ! 508: splx(ps); ! 509: ! 510: base += c; ! 511: count -= c; ! 512: if(dsdebug)printf("LB%x",u.u_error); ! 513: } ! 514: ! 515: u.u_count = count; ! 516: } ! 517: dsdb(dsaddr) ! 518: register struct dsdevice *dsaddr; ! 519: { ! 520: printf("dmacsr %b\n", dsaddr->dmacsr, DMA_BITS); ! 521: printf("asccsr %b\n", dsaddr->asccsr, ASC_BITS); ! 522: printf("dmawc %o\t", dsaddr->dmawc); ! 523: printf("dmablr %o\n", dsaddr->dmablr); ! 524: printf("dmaac %o\t", dsaddr->dmaac); ! 525: printf("dmasar %o\n", dsaddr->dmasar); ! 526: printf("dmaacx %o\t", dsaddr->dmaacx); ! 527: printf("dmasax %o\n", dsaddr->dmasax); ! 528: printf("ascsrt(decimal) %d\n", dsaddr->ascsrt); ! 529: printf("ascseq[0] %o\n", dsaddr->ascseq[0]); ! 530: } ! 531: /* ! 532: * this is where the real work is done. we copy any device registers that ! 533: * we will be looking at to decrease the amount of traffic on the ds 200 ! 534: * bus. ! 535: * ! 536: */ ! 537: dsintr(dev) ! 538: dev_t dev; ! 539: { ! 540: register struct dsdevice *dsaddr; ! 541: register struct uba_device *ui; ! 542: register struct ds_softc *sc; ! 543: register struct buf *bp; ! 544: register int bufno; ! 545: register int i; ! 546: int unit, dummy; ! 547: ! 548: unit = minor(dev) & ~RESETDEV; ! 549: sc = &ds_softc[unit]; ! 550: ui = dsdinfo[unit]; ! 551: ! 552: dsaddr = (struct dsdevice *) dsdinfo[unit]->ui_addr; ! 553: ! 554: sc->c_dmacsr = dsaddr->dmacsr; ! 555: ! 556: dsaddr->dmacls = 0; ! 557: if(dsdebug)printf("i"); ! 558: if (sc->c_flags & DS_IDLE) { ! 559: printf("ds%d: interrupt while idle\n", unit); ! 560: return; ! 561: } ! 562: ! 563: if (sc->c_dmacsr & DMA_ERR) { ! 564: if(dsdebug)printf("e"); ! 565: sc->c_asccsr = (sc->c_dmacsr & DMA_XIN ? dsaddr->asccsr : 0); ! 566: dsaddr->asccsr = dummy = 0; ! 567: ! 568: dsaddr->dmacsr = (sc->c_dmacsr &= ~DMA_CHN); ! 569: if ((sc->c_dmacsr & (DMA_XER|DMA_UBA|DMA_AMPE|DMA_XBA)) ! 570: || (sc->c_asccsr & (ASC_BA|ASC_DCN|ASC_DNP))) { ! 571: ++sc->c_errs; ! 572: printf("ds%d error: asccsr=%b dmacsr=%b\n", ! 573: unit, sc->c_asccsr, ASC_BITS, ! 574: sc->c_dmacsr, DMA_BITS); ! 575: } else ! 576: sc->c_nbytes += sc->c_obp->b_bcount; ! 577: /* the above may be wrong, since DLT interrupt seems to occur ! 578: * separately from (and later than) DMA completion ! 579: * interrupt */ ! 580: dscleanup(unit); ! 581: return; ! 582: } ! 583: ! 584: /* ! 585: * get current buffer and release it ! 586: */ ! 587: ! 588: bp = sc->c_obp++; ! 589: if (sc->c_obp > &sc->c_dsb[NDSB-1]) ! 590: sc->c_obp = &sc->c_dsb[0]; ! 591: ! 592: sc->c_outbufno++; ! 593: if(dsdebug)printf("b "); ! 594: dsrelease(sc, ui, bp); ! 595: ! 596: /* ! 597: * update byte count. ! 598: */ ! 599: ! 600: sc->c_nbytes += bp->b_bcount; ! 601: ! 602: wakeup((caddr_t) &ds_softc[unit]); ! 603: } ! 604: ! 605: /* ! 606: * release resources, if any, associated with a buffer ! 607: */ ! 608: dsrelease(sc, ui, bp) ! 609: register struct ds_softc *sc; ! 610: struct uba_device *ui; ! 611: register struct buf *bp; ! 612: { ! 613: register int ps; ! 614: register struct pte *pte; ! 615: register int npf; ! 616: int bufno; ! 617: ! 618: bufno = bp->b_blkno % NDSB; ! 619: if(dsdebug)printf("R%d ",bufno); ! 620: /* ! 621: * release uba resources ! 622: * and memory resources if process seems healthy ! 623: */ ! 624: ps = spl6(); ! 625: ! 626: if (bp->b_flags & B_BUSY) { ! 627: if(dsdebug)printf("%x %d ",bp->b_un.b_addr,bp->b_bcount); ! 628: ubarelse(ui->ui_ubanum, &sc->c_ubinfo[bufno]); ! 629: ! 630: /* we can't call vsunlock() because u.u_procp may be ! 631: different */ ! 632: if( !(sc->c_pid == sc->c_procp->p_pid) || ! 633: (sc->c_procp->p_flag & SWEXIT) || ! 634: (sc->c_procp->p_stat == SZOMB)){ ! 635: /* process is dying or dead */ ! 636: /* exit() will release memory (does it unlock???) */ ! 637: /* but will not release uba resources */ ! 638: printf(" REL pid %d %d flag %x stat %x ",sc->c_pid, ! 639: sc->c_procp->p_pid,sc->c_procp->p_flag, ! 640: sc->c_procp->p_stat); ! 641: sc->c_flags |= DS_CLOSED; ! 642: } ! 643: else { ! 644: pte = vtopte(sc->c_procp,btop(bp->b_un.b_addr)); ! 645: npf = btoc(bp->b_bcount + ((int)(bp->b_un.b_addr)&CLOFSET)); ! 646: if(dsdebug)printf("U%x %d ",pte->pg_pfnum,npf); ! 647: while(npf > 0) { ! 648: munlock(pte->pg_pfnum); ! 649: if(sc->c_ascflags & ASC_RECORD) ! 650: pte->pg_m = 1; /* memory written */ ! 651: pte += CLSIZE; ! 652: npf -= CLSIZE; ! 653: } ! 654: } ! 655: ! 656: bp->b_flags = 0; /* better than resetting B_BUSY */ ! 657: } ! 658: ! 659: splx(ps); ! 660: } ! 661: ! 662: /* ! 663: * release all buffers and do general cleanup ! 664: */ ! 665: dscleanup(unit) ! 666: int unit; ! 667: { ! 668: register struct dsdevice *dsaddr; ! 669: register struct uba_device *ui; ! 670: register struct ds_softc *sc; ! 671: register struct buf *bp; ! 672: int dummy; ! 673: ! 674: unit = (unit & ~RESETDEV); ! 675: sc = &ds_softc[unit]; ! 676: ui = dsdinfo[unit]; ! 677: dsaddr = (struct dsdevice *) dsdinfo[unit]->ui_addr; ! 678: ! 679: if(dsdebug)printf("C "); ! 680: if (!(sc->c_flags & DS_IDLE)) ! 681: ++sc->c_to_idle; ! 682: sc->c_flags |= DS_IDLE; ! 683: ! 684: dsaddr->asccsr = dummy = 0; ! 685: dummy = dsaddr->ascrst; ! 686: dsaddr->dmacsr = dummy = 0; ! 687: dummy = dsaddr->dmasar; ! 688: ! 689: for (bp = &(sc->c_dsb[0]); bp < &(sc->c_dsb[NDSB]); ++bp) ! 690: dsrelease(sc, ui, bp); ! 691: ! 692: ! 693: /* if called from dsintr while dsstart is sleeping */ ! 694: ! 695: wakeup((caddr_t) &ds_softc[unit]); ! 696: } ! 697: ! 698: /* ! 699: * a/d conversion ! 700: */ ! 701: dsread(dev) ! 702: dev_t dev; ! 703: { ! 704: dsstart(dev, B_READ); /* writes on disk */ ! 705: } ! 706: ! 707: /* ! 708: * d/a conversion ! 709: */ ! 710: dswrite(dev) ! 711: dev_t dev; ! 712: { ! 713: dsstart(dev, B_WRITE); /* reads from disk */ ! 714: } ! 715: ! 716: /* ARGSUSED */ ! 717: dsioctl(dev, cmd, addr, flag) ! 718: dev_t dev; ! 719: caddr_t addr; ! 720: { ! 721: register struct dsdevice *dsaddr; ! 722: register struct ds_softc *sc; ! 723: register struct ds_seq *dq; ! 724: register struct ds_err *de; ! 725: register struct ds_trans *dt; ! 726: struct uba_device *ui; ! 727: struct ds_seq ds_seq; ! 728: struct ds_err ds_err; ! 729: struct ds_trans ds_trans; ! 730: int unit; ! 731: int flts; ! 732: int i; ! 733: int iarg[2]; ! 734: ! 735: if (minor(dev) & RESETDEV) { ! 736: u.u_error = EINVAL; ! 737: return; ! 738: } ! 739: unit = minor(dev) & ~RESETDEV; ! 740: ! 741: sc = &ds_softc[unit]; ! 742: ui = dsdinfo[unit]; ! 743: dsaddr = (struct dsdevice *) ui->ui_addr; ! 744: ! 745: switch (cmd) { ! 746: /* set sample rate */ ! 747: case DSRATE: ! 748: ! 749: if (copyin(addr, (caddr_t) iarg, (unsigned) sizeof(int))) { ! 750: u.u_error = EFAULT; ! 751: return; ! 752: } ! 753: sc->c_ascsrt = 4000000/iarg[0] - 1; ! 754: break; ! 755: ! 756: case DS08KHZ: ! 757: sc->c_ascflags &= ~ ASC_HZMSK; ! 758: sc->c_ascflags |= ASC_HZ08; /* set 8kHz filter */ ! 759: break; ! 760: ! 761: case DS04KHZ: ! 762: sc->c_ascflags &= ~ ASC_HZMSK; ! 763: sc->c_ascflags |= ASC_HZ04; /* set 4kHz filter */ ! 764: break; ! 765: ! 766: ! 767: ! 768: case DSBYPAS: ! 769: sc->c_ascflags &= ~ ASC_HZMSK; ! 770: sc->c_ascflags |= ASC_BYPASS; /* set bypass */ ! 771: break; ! 772: ! 773: /* fetch errors */ ! 774: case DSERRS: ! 775: de = &ds_err; ! 776: de->dma_csr = sc->c_dmacsr; ! 777: de->asc_csr = sc->c_asccsr; ! 778: de->errors = sc->c_errs; ! 779: if (copyout((caddr_t) de, addr, (unsigned) sizeof(struct ds_err))) { ! 780: u.u_error = EFAULT; ! 781: return; ! 782: } ! 783: break; ! 784: ! 785: /* fetch transition counts */ ! 786: case DSTRANS: ! 787: dt = &ds_trans; ! 788: dt->to_idle = sc->c_to_idle; ! 789: dt->to_active = sc->c_to_active; ! 790: if (copyout((caddr_t) dt, addr, sizeof(struct ds_trans))) { ! 791: u.u_error = EFAULT; ! 792: return; ! 793: } ! 794: break; ! 795: ! 796: /* how many samples actually converted */ ! 797: case DSDONE: ! 798: if (copyout((caddr_t) sc->c_nbytes, addr, (unsigned) sizeof(int))) { ! 799: u.u_error = EFAULT; ! 800: return; ! 801: } ! 802: break; ! 803: ! 804: case DSSTEREO: ! 805: while(!sc->c_flags & DS_IDLE); ! 806: if (sc->c_flags & DS_READ) { ! 807: dsseq(sc, 0, ADBASE, AD); ! 808: dsseq(sc, 1, ADBASE+1 | LAST_SEQ, AD); ! 809: } else { ! 810: dsseq(sc, 0, DABASE, DA); ! 811: dsseq(sc, 1, DABASE+1 | LAST_SEQ, DA); ! 812: } ! 813: break; ! 814: ! 815: case DSMONO: ! 816: while(!sc->c_flags & DS_IDLE); ! 817: if (sc->c_flags & DS_READ) ! 818: dsseq(sc, 0, ADBASE | LAST_SEQ, AD); ! 819: else ! 820: dsseq(sc, 0, DABASE | LAST_SEQ, DA); ! 821: break; ! 822: ! 823: case DSRESET: ! 824: /* not adequate */ ! 825: sc->c_flags = DS_CLOSED | DS_IDLE; ! 826: dscleanup(unit); ! 827: break; ! 828: ! 829: case DSDEBUG: ! 830: dsdebug = 1 - dsdebug; ! 831: break; ! 832: case DSWAIT: ! 833: while(sc->c_outbufno != sc->c_bufno ! 834: && !(sc->c_flags & DS_IDLE)) ! 835: tsleep((caddr_t)&ds_softc[unit],DSPRI,0); ! 836: break; ! 837: ! 838: default: ! 839: u.u_error = ENOTTY; ! 840: break; ! 841: } ! 842: } ! 843: ! 844: ! 845: /* ! 846: * zero uba vector. ! 847: * shut off converters. ! 848: * set error bit. ! 849: */ ! 850: dsreset(uban) { ! 851: register struct uba_device *ui; ! 852: register struct ds_softc *sc; ! 853: register int ds; ! 854: ! 855: for (ds = 0; ds < NDS; ds++) { ! 856: if ((ui = dsdinfo[ds]) == NULL) ! 857: continue; ! 858: if (ui->ui_alive == 0) ! 859: continue; ! 860: if (ui->ui_ubanum != uban) ! 861: continue; ! 862: ! 863: printf(" ds%d", ds); ! 864: ! 865: sc = &ds_softc[ds]; ! 866: ! 867: /* ! 868: * release unibus resources ! 869: */ ! 870: sc->c_flags = DS_CLOSED | DS_IDLE; ! 871: dscleanup(ds); ! 872: } ! 873: } ! 874: /* ! 875: equivalent to vslock() from vmmem.c ! 876: inserted differently here for debugging convenience only. ! 877: */ ! 878: dslock(base, count) ! 879: caddr_t base; ! 880: { ! 881: register unsigned v; ! 882: register int npf; ! 883: register struct pte *pte; ! 884: ! 885: u.u_procp->p_flag |= SDLYU; ! 886: v = btop(base); ! 887: pte = vtopte(u.u_procp, v); ! 888: npf = btoc(count + ((int)base & CLOFSET)); ! 889: if(dsdebug)printf("Lk %x %d ",pte->pg_pfnum,npf); ! 890: while (npf > 0) { ! 891: if (pte->pg_v) ! 892: mlock(pte->pg_pfnum); ! 893: else ! 894: if (fubyte((caddr_t)ctob(v)) < 0) ! 895: panic("vslock"); ! 896: pte += CLSIZE; ! 897: v += CLSIZE; ! 898: npf -= CLSIZE; ! 899: } ! 900: u.u_procp->p_flag &= ~SDLYU; ! 901: } ! 902: # endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.