![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ct.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / arch / hp300 / dev|
Return to ct.c CVS log | Up to [Net/2] / Net2 / arch / hp300 / dev |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1990 The Regents of the University of California. ! 3: * All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)ct.c 7.3 (Berkeley) 5/4/91 ! 34: */ ! 35: ! 36: #include "ct.h" ! 37: #if NCT > 0 ! 38: /* ! 39: * CS80 cartridge tape driver (9144, 88140, 9145) ! 40: * ! 41: * Reminder: ! 42: * C_CC bit (character count option) when used in the CS/80 command ! 43: * 'set options' will cause the tape not to stream. ! 44: * ! 45: * TODO: ! 46: * make filesystem compatible ! 47: * make block mode work according to mtio(4) spec. (if possible) ! 48: * merge with cs80 disk driver ! 49: * finish support of 9145 ! 50: */ ! 51: ! 52: #include "param.h" ! 53: #include "buf.h" ! 54: #include "ioctl.h" ! 55: #include "mtio.h" ! 56: #include "tprintf.h" ! 57: #include "proc.h" ! 58: ! 59: #include "ctreg.h" ! 60: #include "device.h" ! 61: ! 62: /* number of eof marks to remember */ ! 63: #define EOFS 128 ! 64: ! 65: int ctinit(), ctstart(), ctgo(), ctintr(); ! 66: struct driver ctdriver = { ! 67: ctinit, "ct", ctstart, ctgo, ctintr, ! 68: }; ! 69: ! 70: struct ct_softc { ! 71: struct hp_device *sc_hd; ! 72: struct ct_iocmd sc_ioc; ! 73: struct ct_rscmd sc_rsc; ! 74: struct ct_stat sc_stat; ! 75: struct ct_ssmcmd sc_ssmc; ! 76: struct ct_srcmd sc_src; ! 77: struct ct_soptcmd sc_soptc; ! 78: struct ct_ulcmd sc_ul; ! 79: struct ct_wfmcmd sc_wfm; ! 80: struct ct_clearcmd sc_clear; ! 81: struct buf *sc_bp; ! 82: int sc_blkno; ! 83: int sc_cmd; ! 84: int sc_resid; ! 85: char *sc_addr; ! 86: int sc_flags; ! 87: short sc_type; ! 88: short sc_punit; ! 89: tpr_t sc_tpr; ! 90: struct devqueue sc_dq; ! 91: int sc_eofp; ! 92: int sc_eofs[EOFS]; ! 93: } ct_softc[NCT]; ! 94: ! 95: /* flags */ ! 96: #define CTF_OPEN 0x01 ! 97: #define CTF_ALIVE 0x02 ! 98: #define CTF_WRT 0x04 ! 99: #define CTF_CMD 0x08 ! 100: #define CTF_IO 0x10 ! 101: #define CTF_BEOF 0x20 ! 102: #define CTF_AEOF 0x40 ! 103: #define CTF_EOT 0x80 ! 104: #define CTF_STATWAIT 0x100 ! 105: #define CTF_CANSTREAM 0x200 ! 106: #define CTF_WRTTN 0x400 ! 107: ! 108: struct ctinfo { ! 109: short hwid; ! 110: short punit; ! 111: char *desc; ! 112: } ctinfo[] = { ! 113: CT7946ID, 1, "7946A", ! 114: CT7912PID, 1, "7912P", ! 115: CT7914PID, 1, "7914P", ! 116: CT9144ID, 0, "9144", ! 117: CT9145ID, 0, "9145", ! 118: }; ! 119: int nctinfo = sizeof(ctinfo) / sizeof(ctinfo[0]); ! 120: ! 121: struct buf cttab[NCT]; ! 122: struct buf ctbuf[NCT]; ! 123: ! 124: #define CT_NOREW 4 ! 125: #define CT_STREAM 8 ! 126: #define UNIT(x) (minor(x) & 3) ! 127: #define ctpunit(x) ((x) & 7) ! 128: ! 129: #ifdef DEBUG ! 130: int ctdebug = 0; ! 131: #define CDB_FILES 0x01 ! 132: #define CT_BSF 0x02 ! 133: #endif ! 134: ! 135: ctinit(hd) ! 136: register struct hp_device *hd; ! 137: { ! 138: register struct ct_softc *sc = &ct_softc[hd->hp_unit]; ! 139: ! 140: sc->sc_hd = hd; ! 141: sc->sc_punit = ctpunit(hd->hp_flags); ! 142: if (ctident(sc, hd) < 0) ! 143: return(0); ! 144: ctreset(sc, hd); ! 145: sc->sc_dq.dq_ctlr = hd->hp_ctlr; ! 146: sc->sc_dq.dq_unit = hd->hp_unit; ! 147: sc->sc_dq.dq_slave = hd->hp_slave; ! 148: sc->sc_dq.dq_driver = &ctdriver; ! 149: sc->sc_flags |= CTF_ALIVE; ! 150: return(1); ! 151: } ! 152: ! 153: ctident(sc, hd) ! 154: register struct ct_softc *sc; ! 155: register struct hp_device *hd; ! 156: { ! 157: struct ct_describe desc; ! 158: u_char stat, cmd[3]; ! 159: char name[7]; ! 160: int id, i; ! 161: ! 162: /* ! 163: * Read device id and verify that: ! 164: * 1. It is a CS80 device ! 165: * 2. It is one of our recognized tape devices ! 166: * 3. It has the proper physical unit number ! 167: */ ! 168: id = hpibid(hd->hp_ctlr, hd->hp_slave); ! 169: if ((id & 0x200) == 0) ! 170: return(-1); ! 171: for (i = 0; i < nctinfo; i++) ! 172: if (id == ctinfo[i].hwid) ! 173: break; ! 174: if (i == nctinfo || sc->sc_punit != ctinfo[i].punit) ! 175: return(-1); ! 176: id = i; ! 177: ! 178: /* ! 179: * Collect device description. ! 180: * Right now we only need this to differentiate 7945 from 7946. ! 181: * Note that we always issue the describe command to unit 0. ! 182: */ ! 183: cmd[0] = C_SUNIT(0); ! 184: cmd[1] = C_SVOL(0); ! 185: cmd[2] = C_DESC; ! 186: hpibsend(hd->hp_ctlr, hd->hp_slave, C_CMD, cmd, sizeof(cmd)); ! 187: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_EXEC, &desc, 37); ! 188: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_QSTAT, &stat, sizeof(stat)); ! 189: bzero(name, sizeof(name)); ! 190: if (!stat) { ! 191: register int n = desc.d_name; ! 192: for (i = 5; i >= 0; i--) { ! 193: name[i] = (n & 0xf) + '0'; ! 194: n >>= 4; ! 195: } ! 196: } ! 197: switch (ctinfo[id].hwid) { ! 198: case CT7946ID: ! 199: if (bcmp(name, "079450", 6) == 0) ! 200: return(-1); /* not really a 7946 */ ! 201: /* fall into... */ ! 202: case CT9144ID: ! 203: case CT9145ID: ! 204: sc->sc_type = CT9144; ! 205: sc->sc_flags |= CTF_CANSTREAM; ! 206: break; ! 207: ! 208: case CT7912PID: ! 209: case CT7914PID: ! 210: sc->sc_type = CT88140; ! 211: break; ! 212: } ! 213: printf("ct%d: %s %stape\n", hd->hp_unit, ctinfo[id].desc, ! 214: (sc->sc_flags & CTF_CANSTREAM) ? "streaming " : " "); ! 215: return(id); ! 216: } ! 217: ! 218: ctreset(sc, hd) ! 219: register struct ct_softc *sc; ! 220: register struct hp_device *hd; ! 221: { ! 222: u_char stat; ! 223: ! 224: sc->sc_clear.unit = C_SUNIT(sc->sc_punit); ! 225: sc->sc_clear.cmd = C_CLEAR; ! 226: hpibsend(hd->hp_ctlr, hd->hp_slave, C_TCMD, &sc->sc_clear, ! 227: sizeof(sc->sc_clear)); ! 228: hpibswait(hd->hp_ctlr, hd->hp_slave); ! 229: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_QSTAT, &stat, sizeof(stat)); ! 230: sc->sc_src.unit = C_SUNIT(CTCTLR); ! 231: sc->sc_src.nop = C_NOP; ! 232: sc->sc_src.cmd = C_SREL; ! 233: sc->sc_src.param = C_REL; ! 234: hpibsend(hd->hp_ctlr, hd->hp_slave, C_CMD, &sc->sc_src, ! 235: sizeof(sc->sc_src)); ! 236: hpibswait(hd->hp_ctlr, hd->hp_slave); ! 237: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_QSTAT, &stat, sizeof(stat)); ! 238: sc->sc_ssmc.unit = C_SUNIT(sc->sc_punit); ! 239: sc->sc_ssmc.cmd = C_SSM; ! 240: sc->sc_ssmc.refm = REF_MASK; ! 241: sc->sc_ssmc.fefm = FEF_MASK; ! 242: sc->sc_ssmc.aefm = AEF_MASK; ! 243: sc->sc_ssmc.iefm = IEF_MASK; ! 244: hpibsend(hd->hp_ctlr, hd->hp_slave, C_CMD, &sc->sc_ssmc, ! 245: sizeof(sc->sc_ssmc)); ! 246: hpibswait(hd->hp_ctlr, hd->hp_slave); ! 247: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_QSTAT, &stat, sizeof(stat)); ! 248: sc->sc_soptc.unit = C_SUNIT(sc->sc_punit); ! 249: sc->sc_soptc.nop = C_NOP; ! 250: sc->sc_soptc.cmd = C_SOPT; ! 251: sc->sc_soptc.opt = C_SPAR; ! 252: hpibsend(hd->hp_ctlr, hd->hp_slave, C_CMD, &sc->sc_soptc, ! 253: sizeof(sc->sc_soptc)); ! 254: hpibswait(hd->hp_ctlr, hd->hp_slave); ! 255: hpibrecv(hd->hp_ctlr, hd->hp_slave, C_QSTAT, &stat, sizeof(stat)); ! 256: } ! 257: ! 258: /*ARGSUSED*/ ! 259: ctopen(dev, flag, type, p) ! 260: dev_t dev; ! 261: int flag, type; ! 262: struct proc *p; ! 263: { ! 264: register struct ct_softc *sc = &ct_softc[UNIT(dev)]; ! 265: u_char stat; ! 266: int cc; ! 267: ! 268: if (UNIT(dev) >= NCT || (sc->sc_flags & CTF_ALIVE) == 0) ! 269: return(ENXIO); ! 270: if (sc->sc_flags & CTF_OPEN) ! 271: return(EBUSY); ! 272: sc->sc_soptc.unit = C_SUNIT(sc->sc_punit); ! 273: sc->sc_soptc.nop = C_NOP; ! 274: sc->sc_soptc.cmd = C_SOPT; ! 275: if ((dev & CT_STREAM) && (sc->sc_flags & CTF_CANSTREAM)) ! 276: sc->sc_soptc.opt = C_SPAR | C_IMRPT; ! 277: else ! 278: sc->sc_soptc.opt = C_SPAR; ! 279: /* ! 280: * Check the return of hpibsend() and hpibswait(). ! 281: * Drive could be loading/unloading a tape. If not checked, ! 282: * driver hangs. ! 283: */ ! 284: cc = hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, ! 285: C_CMD, &sc->sc_soptc, sizeof(sc->sc_soptc)); ! 286: if (cc != sizeof(sc->sc_soptc)) ! 287: return(EBUSY); ! 288: hpibswait(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave); ! 289: cc = hpibrecv(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_QSTAT, ! 290: &stat, sizeof(stat)); ! 291: if (cc != sizeof(stat)) ! 292: return(EBUSY); ! 293: sc->sc_tpr = tprintf_open(p); ! 294: sc->sc_flags |= CTF_OPEN; ! 295: return(0); ! 296: } ! 297: ! 298: /*ARGSUSED*/ ! 299: ctclose(dev, flag) ! 300: dev_t dev; ! 301: { ! 302: register struct ct_softc *sc = &ct_softc[UNIT(dev)]; ! 303: ! 304: if ((sc->sc_flags & (CTF_WRT|CTF_WRTTN)) == (CTF_WRT|CTF_WRTTN) && ! 305: (sc->sc_flags & CTF_EOT) == 0 ) { /* XXX return error if EOT ?? */ ! 306: ctcommand(dev, MTWEOF, 2); ! 307: ctcommand(dev, MTBSR, 1); ! 308: if (sc->sc_eofp == EOFS - 1) ! 309: sc->sc_eofs[EOFS - 1]--; ! 310: else ! 311: sc->sc_eofp--; ! 312: #ifdef DEBUG ! 313: if(ctdebug & CT_BSF) ! 314: printf("ct%d: ctclose backup eofs prt %d blk %d\n", ! 315: UNIT(dev), sc->sc_eofp, sc->sc_eofs[sc->sc_eofp]); ! 316: #endif ! 317: } ! 318: if ((minor(dev) & CT_NOREW) == 0) ! 319: ctcommand(dev, MTREW, 1); ! 320: sc->sc_flags &= ~(CTF_OPEN | CTF_WRT | CTF_WRTTN); ! 321: tprintf_close(sc->sc_tpr); ! 322: #ifdef DEBUG ! 323: if (ctdebug & CDB_FILES) ! 324: printf("ctclose: flags %x\n", sc->sc_flags); ! 325: #endif ! 326: return(0); /* XXX */ ! 327: } ! 328: ! 329: ctcommand(dev, cmd, cnt) ! 330: dev_t dev; ! 331: register int cnt; ! 332: { ! 333: register struct ct_softc *sc = &ct_softc[UNIT(dev)]; ! 334: register struct buf *bp = &ctbuf[UNIT(dev)]; ! 335: register struct buf *nbp = 0; ! 336: ! 337: if (cmd == MTBSF && sc->sc_eofp == EOFS - 1) { ! 338: cnt = sc->sc_eofs[EOFS - 1] - cnt; ! 339: ctcommand(dev, MTREW, 1); ! 340: ctcommand(dev, MTFSF, cnt); ! 341: cnt = 2; ! 342: cmd = MTBSR; ! 343: } ! 344: ! 345: if (cmd == MTBSF && sc->sc_eofp - cnt < 0) { ! 346: cnt = 1; ! 347: cmd = MTREW; ! 348: } ! 349: ! 350: sc->sc_flags |= CTF_CMD; ! 351: sc->sc_bp = bp; ! 352: sc->sc_cmd = cmd; ! 353: bp->b_dev = dev; ! 354: if (cmd == MTFSF) { ! 355: nbp = (struct buf *)geteblk(MAXBSIZE); ! 356: bp->b_un.b_addr = nbp->b_un.b_addr; ! 357: bp->b_bcount = MAXBSIZE; ! 358: } ! 359: again: ! 360: bp->b_flags = B_BUSY; ! 361: if (cmd == MTBSF) { ! 362: sc->sc_blkno = sc->sc_eofs[sc->sc_eofp]; ! 363: sc->sc_eofp--; ! 364: #ifdef DEBUG ! 365: if (ctdebug & CT_BSF) ! 366: printf("ct%d: backup eof pos %d blk %d\n", ! 367: UNIT(dev), sc->sc_eofp, ! 368: sc->sc_eofs[sc->sc_eofp]); ! 369: #endif ! 370: } ! 371: ctstrategy(bp); ! 372: iowait(bp); ! 373: if (--cnt > 0) ! 374: goto again; ! 375: bp->b_flags = 0; ! 376: sc->sc_flags &= ~CTF_CMD; ! 377: if (nbp) ! 378: brelse(nbp); ! 379: } ! 380: ! 381: ctstrategy(bp) ! 382: register struct buf *bp; ! 383: { ! 384: register struct buf *dp; ! 385: register int s, unit; ! 386: ! 387: unit = UNIT(bp->b_dev); ! 388: dp = &cttab[unit]; ! 389: bp->av_forw = NULL; ! 390: s = splbio(); ! 391: if (dp->b_actf == NULL) ! 392: dp->b_actf = bp; ! 393: else ! 394: dp->b_actl->av_forw = bp; ! 395: dp->b_actl = bp; ! 396: if (dp->b_active == 0) { ! 397: dp->b_active = 1; ! 398: ctustart(unit); ! 399: } ! 400: splx(s); ! 401: } ! 402: ! 403: ctustart(unit) ! 404: register int unit; ! 405: { ! 406: register struct ct_softc *sc = &ct_softc[unit]; ! 407: register struct buf *bp; ! 408: ! 409: bp = cttab[unit].b_actf; ! 410: sc->sc_addr = bp->b_un.b_addr; ! 411: sc->sc_resid = bp->b_bcount; ! 412: if (hpibreq(&sc->sc_dq)) ! 413: ctstart(unit); ! 414: } ! 415: ! 416: ctstart(unit) ! 417: register int unit; ! 418: { ! 419: register struct ct_softc *sc = &ct_softc[unit]; ! 420: register struct buf *bp; ! 421: register int i; ! 422: ! 423: bp = cttab[unit].b_actf; ! 424: again: ! 425: if ((sc->sc_flags & CTF_CMD) && sc->sc_bp == bp) { ! 426: switch(sc->sc_cmd) { ! 427: ! 428: case MTFSF: ! 429: bp->b_flags |= B_READ; ! 430: goto mustio; ! 431: ! 432: case MTBSF: ! 433: goto gotaddr; ! 434: ! 435: case MTOFFL: ! 436: sc->sc_blkno = 0; ! 437: sc->sc_ul.unit = C_SUNIT(sc->sc_punit); ! 438: sc->sc_ul.cmd = C_UNLOAD; ! 439: hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, ! 440: C_CMD, &sc->sc_ul, sizeof(sc->sc_ul)); ! 441: break; ! 442: ! 443: case MTWEOF: ! 444: sc->sc_blkno++; ! 445: sc->sc_flags |= CTF_WRT; ! 446: sc->sc_wfm.unit = C_SUNIT(sc->sc_punit); ! 447: sc->sc_wfm.cmd = C_WFM; ! 448: hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, ! 449: C_CMD, &sc->sc_wfm, sizeof(sc->sc_wfm)); ! 450: ctaddeof(unit); ! 451: break; ! 452: ! 453: case MTBSR: ! 454: sc->sc_blkno--; ! 455: goto gotaddr; ! 456: ! 457: case MTFSR: ! 458: sc->sc_blkno++; ! 459: goto gotaddr; ! 460: ! 461: case MTREW: ! 462: sc->sc_blkno = 0; ! 463: #ifdef DEBUG ! 464: if(ctdebug & CT_BSF) ! 465: printf("ct%d: clearing eofs\n", unit); ! 466: #endif ! 467: for (i=0; i<EOFS; i++) ! 468: sc->sc_eofs[i] = 0; ! 469: sc->sc_eofp = 0; ! 470: ! 471: gotaddr: ! 472: sc->sc_ioc.saddr = C_SADDR; ! 473: sc->sc_ioc.addr0 = 0; ! 474: sc->sc_ioc.addr = sc->sc_blkno; ! 475: sc->sc_ioc.unit = C_SUNIT(sc->sc_punit); ! 476: sc->sc_ioc.nop2 = C_NOP; ! 477: sc->sc_ioc.slen = C_SLEN; ! 478: sc->sc_ioc.len = 0; ! 479: sc->sc_ioc.nop3 = C_NOP; ! 480: sc->sc_ioc.cmd = C_READ; ! 481: hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, ! 482: C_CMD, &sc->sc_ioc, sizeof(sc->sc_ioc)); ! 483: break; ! 484: } ! 485: } ! 486: else { ! 487: mustio: ! 488: if ((bp->b_flags & B_READ) && ! 489: sc->sc_flags & (CTF_BEOF|CTF_EOT)) { ! 490: #ifdef DEBUG ! 491: if (ctdebug & CDB_FILES) ! 492: printf("ctstart: before flags %x\n", sc->sc_flags); ! 493: #endif ! 494: if (sc->sc_flags & CTF_BEOF) { ! 495: sc->sc_flags &= ~CTF_BEOF; ! 496: sc->sc_flags |= CTF_AEOF; ! 497: #ifdef DEBUG ! 498: if (ctdebug & CDB_FILES) ! 499: printf("ctstart: after flags %x\n", sc->sc_flags); ! 500: #endif ! 501: } ! 502: bp->b_resid = bp->b_bcount; ! 503: iodone(bp); ! 504: hpibfree(&sc->sc_dq); ! 505: cttab[unit].b_actf = bp = bp->av_forw; ! 506: if (bp == NULL) { ! 507: cttab[unit].b_active = 0; ! 508: return; ! 509: } ! 510: sc->sc_addr = bp->b_un.b_addr; ! 511: sc->sc_resid = bp->b_bcount; ! 512: if (hpibreq(&sc->sc_dq)) ! 513: goto again; ! 514: return; ! 515: } ! 516: sc->sc_flags |= CTF_IO; ! 517: sc->sc_ioc.unit = C_SUNIT(sc->sc_punit); ! 518: sc->sc_ioc.saddr = C_SADDR; ! 519: sc->sc_ioc.addr0 = 0; ! 520: sc->sc_ioc.addr = sc->sc_blkno; ! 521: sc->sc_ioc.nop2 = C_NOP; ! 522: sc->sc_ioc.slen = C_SLEN; ! 523: sc->sc_ioc.len = sc->sc_resid; ! 524: sc->sc_ioc.nop3 = C_NOP; ! 525: if (bp->b_flags & B_READ) ! 526: sc->sc_ioc.cmd = C_READ; ! 527: else { ! 528: sc->sc_ioc.cmd = C_WRITE; ! 529: sc->sc_flags |= (CTF_WRT | CTF_WRTTN); ! 530: } ! 531: hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_CMD, ! 532: &sc->sc_ioc, sizeof(sc->sc_ioc)); ! 533: } ! 534: hpibawait(sc->sc_hd->hp_ctlr); ! 535: } ! 536: ! 537: ctgo(unit) ! 538: register int unit; ! 539: { ! 540: register struct ct_softc *sc = &ct_softc[unit]; ! 541: register struct buf *bp; ! 542: ! 543: bp = cttab[unit].b_actf; ! 544: hpibgo(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_EXEC, ! 545: sc->sc_addr, sc->sc_resid, bp->b_flags & B_READ); ! 546: } ! 547: ! 548: /* ! 549: * Hideous grue to handle EOF/EOT (mostly for reads) ! 550: */ ! 551: cteof(sc, bp) ! 552: register struct ct_softc *sc; ! 553: register struct buf *bp; ! 554: { ! 555: long blks; ! 556: ! 557: /* ! 558: * EOT on a write is an error. ! 559: */ ! 560: if ((bp->b_flags & B_READ) == 0) { ! 561: bp->b_resid = bp->b_bcount; ! 562: bp->b_flags |= B_ERROR; ! 563: bp->b_error = ENOSPC; ! 564: sc->sc_flags |= CTF_EOT; ! 565: return; ! 566: } ! 567: /* ! 568: * Use returned block position to determine how many blocks ! 569: * we really read and update b_resid. ! 570: */ ! 571: blks = sc->sc_stat.c_blk - sc->sc_blkno - 1; ! 572: #ifdef DEBUG ! 573: if (ctdebug & CDB_FILES) ! 574: printf("cteof: bc %d oblk %d nblk %d read %d, resid %d\n", ! 575: bp->b_bcount, sc->sc_blkno, sc->sc_stat.c_blk, ! 576: blks, bp->b_bcount - CTKTOB(blks)); ! 577: #endif ! 578: if (blks == -1) { /* 9145 on EOF does not change sc_stat.c_blk */ ! 579: blks = 0; ! 580: sc->sc_blkno++; ! 581: } ! 582: else { ! 583: sc->sc_blkno = sc->sc_stat.c_blk; ! 584: } ! 585: bp->b_resid = bp->b_bcount - CTKTOB(blks); ! 586: /* ! 587: * If we are at physical EOV or were after an EOF, ! 588: * we are now at logical EOT. ! 589: */ ! 590: if ((sc->sc_stat.c_aef & AEF_EOV) || ! 591: (sc->sc_flags & CTF_AEOF)) { ! 592: sc->sc_flags |= CTF_EOT; ! 593: sc->sc_flags &= ~(CTF_AEOF|CTF_BEOF); ! 594: } ! 595: /* ! 596: * If we were before an EOF or we have just completed a FSF, ! 597: * we are now after EOF. ! 598: */ ! 599: else if ((sc->sc_flags & CTF_BEOF) || ! 600: (sc->sc_flags & CTF_CMD) && sc->sc_cmd == MTFSF) { ! 601: sc->sc_flags |= CTF_AEOF; ! 602: sc->sc_flags &= ~CTF_BEOF; ! 603: } ! 604: /* ! 605: * Otherwise if we read something we are now before EOF ! 606: * (and no longer after EOF). ! 607: */ ! 608: else if (blks) { ! 609: sc->sc_flags |= CTF_BEOF; ! 610: sc->sc_flags &= ~CTF_AEOF; ! 611: } ! 612: /* ! 613: * Finally, if we didn't read anything we just passed an EOF ! 614: */ ! 615: else ! 616: sc->sc_flags |= CTF_AEOF; ! 617: #ifdef DEBUG ! 618: if (ctdebug & CDB_FILES) ! 619: printf("cteof: leaving flags %x\n", sc->sc_flags); ! 620: #endif ! 621: } ! 622: ! 623: ctintr(unit) ! 624: register int unit; ! 625: { ! 626: register struct ct_softc *sc = &ct_softc[unit]; ! 627: register struct buf *bp; ! 628: u_char stat; ! 629: ! 630: bp = cttab[unit].b_actf; ! 631: if (bp == NULL) { ! 632: printf("ct%d: bp == NULL\n", unit); ! 633: return; ! 634: } ! 635: if (sc->sc_flags & CTF_IO) { ! 636: sc->sc_flags &= ~CTF_IO; ! 637: if (hpibustart(sc->sc_hd->hp_ctlr)) ! 638: ctgo(unit); ! 639: return; ! 640: } ! 641: if ((sc->sc_flags & CTF_STATWAIT) == 0) { ! 642: if (hpibpptest(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave) == 0) { ! 643: sc->sc_flags |= CTF_STATWAIT; ! 644: hpibawait(sc->sc_hd->hp_ctlr); ! 645: return; ! 646: } ! 647: } else ! 648: sc->sc_flags &= ~CTF_STATWAIT; ! 649: hpibrecv(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_QSTAT, &stat, 1); ! 650: #ifdef DEBUG ! 651: if (ctdebug & CDB_FILES) ! 652: printf("ctintr: before flags %x\n", sc->sc_flags); ! 653: #endif ! 654: if (stat) { ! 655: sc->sc_rsc.unit = C_SUNIT(sc->sc_punit); ! 656: sc->sc_rsc.cmd = C_STATUS; ! 657: hpibsend(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_CMD, ! 658: &sc->sc_rsc, sizeof(sc->sc_rsc)); ! 659: hpibrecv(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_EXEC, ! 660: &sc->sc_stat, sizeof(sc->sc_stat)); ! 661: hpibrecv(sc->sc_hd->hp_ctlr, sc->sc_hd->hp_slave, C_QSTAT, ! 662: &stat, 1); ! 663: #ifdef DEBUG ! 664: if (ctdebug & CDB_FILES) ! 665: printf("ctintr: return stat 0x%x, A%x F%x blk %d\n", ! 666: stat, sc->sc_stat.c_aef, ! 667: sc->sc_stat.c_fef, sc->sc_stat.c_blk); ! 668: #endif ! 669: if (stat == 0) { ! 670: if (sc->sc_stat.c_aef & (AEF_EOF | AEF_EOV)) { ! 671: cteof(sc, bp); ! 672: ctaddeof(unit); ! 673: goto done; ! 674: } ! 675: if (sc->sc_stat.c_fef & FEF_PF) { ! 676: ctreset(sc, sc->sc_hd); ! 677: ctstart(unit); ! 678: return; ! 679: } ! 680: if (sc->sc_stat.c_fef & FEF_REXMT) { ! 681: ctstart(unit); ! 682: return; ! 683: } ! 684: if (sc->sc_stat.c_aef & 0x5800) { ! 685: if (sc->sc_stat.c_aef & 0x4000) ! 686: tprintf(sc->sc_tpr, ! 687: "ct%d: uninitialized media\n", ! 688: unit); ! 689: if (sc->sc_stat.c_aef & 0x1000) ! 690: tprintf(sc->sc_tpr, ! 691: "ct%d: not ready\n", unit); ! 692: if (sc->sc_stat.c_aef & 0x0800) ! 693: tprintf(sc->sc_tpr, ! 694: "ct%d: write protect\n", unit); ! 695: } else { ! 696: printf("ct%d err: v%d u%d ru%d bn%d, ", ! 697: unit, ! 698: (sc->sc_stat.c_vu>>4)&0xF, ! 699: sc->sc_stat.c_vu&0xF, ! 700: sc->sc_stat.c_pend, ! 701: sc->sc_stat.c_blk); ! 702: printf("R0x%x F0x%x A0x%x I0x%x\n", ! 703: sc->sc_stat.c_ref, ! 704: sc->sc_stat.c_fef, ! 705: sc->sc_stat.c_aef, ! 706: sc->sc_stat.c_ief); ! 707: } ! 708: } else ! 709: printf("ct%d: request status failed\n", unit); ! 710: bp->b_flags |= B_ERROR; ! 711: bp->b_error = EIO; ! 712: goto done; ! 713: } else ! 714: bp->b_resid = 0; ! 715: if (sc->sc_flags & CTF_CMD) { ! 716: switch (sc->sc_cmd) { ! 717: case MTFSF: ! 718: sc->sc_flags &= ~(CTF_BEOF|CTF_AEOF); ! 719: sc->sc_blkno += CTBTOK(sc->sc_resid); ! 720: ctstart(unit); ! 721: return; ! 722: case MTBSF: ! 723: sc->sc_flags &= ~(CTF_AEOF|CTF_BEOF|CTF_EOT); ! 724: break; ! 725: case MTBSR: ! 726: sc->sc_flags &= ~CTF_BEOF; ! 727: if (sc->sc_flags & CTF_EOT) { ! 728: sc->sc_flags |= CTF_AEOF; ! 729: sc->sc_flags &= ~CTF_EOT; ! 730: } else if (sc->sc_flags & CTF_AEOF) { ! 731: sc->sc_flags |= CTF_BEOF; ! 732: sc->sc_flags &= ~CTF_AEOF; ! 733: } ! 734: break; ! 735: case MTWEOF: ! 736: sc->sc_flags &= ~CTF_BEOF; ! 737: if (sc->sc_flags & (CTF_AEOF|CTF_EOT)) { ! 738: sc->sc_flags |= CTF_EOT; ! 739: sc->sc_flags &= ~CTF_AEOF; ! 740: } else ! 741: sc->sc_flags |= CTF_AEOF; ! 742: break; ! 743: case MTREW: ! 744: case MTOFFL: ! 745: sc->sc_flags &= ~(CTF_BEOF|CTF_AEOF|CTF_EOT); ! 746: break; ! 747: } ! 748: } else { ! 749: sc->sc_flags &= ~CTF_AEOF; ! 750: sc->sc_blkno += CTBTOK(sc->sc_resid); ! 751: } ! 752: done: ! 753: #ifdef DEBUG ! 754: if (ctdebug & CDB_FILES) ! 755: printf("ctintr: after flags %x\n", sc->sc_flags); ! 756: #endif ! 757: cttab[unit].b_actf = bp->av_forw; ! 758: iodone(bp); ! 759: hpibfree(&sc->sc_dq); ! 760: if (cttab[unit].b_actf == NULL) { ! 761: cttab[unit].b_active = 0; ! 762: return; ! 763: } ! 764: ctustart(unit); ! 765: } ! 766: ! 767: ctread(dev, uio) ! 768: dev_t dev; ! 769: struct uio *uio; ! 770: { ! 771: register int unit = UNIT(dev); ! 772: ! 773: return(physio(ctstrategy, &ctbuf[unit], dev, B_READ, minphys, uio)); ! 774: } ! 775: ! 776: ctwrite(dev, uio) ! 777: dev_t dev; ! 778: struct uio *uio; ! 779: { ! 780: register int unit = UNIT(dev); ! 781: ! 782: return(physio(ctstrategy, &ctbuf[unit], dev, B_WRITE, minphys, uio)); ! 783: } ! 784: ! 785: /*ARGSUSED*/ ! 786: ctioctl(dev, cmd, data, flag) ! 787: dev_t dev; ! 788: caddr_t data; ! 789: { ! 790: register struct mtop *op; ! 791: register int cnt; ! 792: ! 793: switch (cmd) { ! 794: ! 795: case MTIOCTOP: ! 796: op = (struct mtop *)data; ! 797: switch(op->mt_op) { ! 798: ! 799: case MTWEOF: ! 800: case MTFSF: ! 801: case MTBSR: ! 802: case MTBSF: ! 803: case MTFSR: ! 804: cnt = op->mt_count; ! 805: break; ! 806: ! 807: case MTREW: ! 808: case MTOFFL: ! 809: cnt = 1; ! 810: break; ! 811: ! 812: default: ! 813: return(EINVAL); ! 814: } ! 815: ctcommand(dev, op->mt_op, cnt); ! 816: break; ! 817: ! 818: case MTIOCGET: ! 819: break; ! 820: ! 821: default: ! 822: return(EINVAL); ! 823: } ! 824: return(0); ! 825: } ! 826: ! 827: /*ARGSUSED*/ ! 828: ctdump(dev) ! 829: dev_t dev; ! 830: { ! 831: return(ENXIO); ! 832: } ! 833: ! 834: ctaddeof(unit) ! 835: int unit; ! 836: { ! 837: register struct ct_softc *sc = &ct_softc[unit]; ! 838: ! 839: if (sc->sc_eofp == EOFS - 1) ! 840: sc->sc_eofs[EOFS - 1]++; ! 841: else { ! 842: sc->sc_eofp++; ! 843: if (sc->sc_eofp == EOFS - 1) ! 844: sc->sc_eofs[EOFS - 1] = EOFS; ! 845: else ! 846: /* save blkno */ ! 847: sc->sc_eofs[sc->sc_eofp] = sc->sc_blkno - 1; ! 848: } ! 849: #ifdef DEBUG ! 850: if (ctdebug & CT_BSF) ! 851: printf("ct%d: add eof pos %d blk %d\n", ! 852: unit, sc->sc_eofp, ! 853: sc->sc_eofs[sc->sc_eofp]); ! 854: #endif ! 855: } ! 856: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.