![[BACK]](/icons/back.gif){kind=icon}
Return to ct.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / hp300 / dev|
Return to ct.c CVS log | Up to [local] / sys / arch / hp300 / dev |
1.1 ! nbrk 1: /* $OpenBSD: ct.c,v 1.18 2007/06/06 17:15:11 deraadt Exp $ */
! 2: /* $NetBSD: ct.c,v 1.21 1997/04/02 22:37:23 scottr Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1996, 1997 Jason R. Thorpe. All rights reserved.
! 6: * Copyright (c) 1982, 1990, 1993
! 7: * The Regents of the University of California. All rights reserved.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: * 3. 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 8.2 (Berkeley) 1/12/94
! 34: */
! 35:
! 36: /*
! 37: * CS80 cartridge tape driver (9144, 88140, 9145)
! 38: *
! 39: * Reminder:
! 40: * C_CC bit (character count option) when used in the CS/80 command
! 41: * 'set options' will cause the tape not to stream.
! 42: *
! 43: * TODO:
! 44: * make filesystem compatible
! 45: * make block mode work according to mtio(4) spec. (if possible)
! 46: * merge with cs80 disk driver
! 47: * finish support of 9145
! 48: */
! 49:
! 50: #include <sys/param.h>
! 51: #include <sys/systm.h>
! 52: #include <sys/buf.h>
! 53: #include <sys/conf.h>
! 54: #include <sys/device.h>
! 55: #include <sys/ioctl.h>
! 56: #include <sys/mtio.h>
! 57: #include <sys/proc.h>
! 58:
! 59: #include <hp300/dev/hpibvar.h>
! 60:
! 61: #include <hp300/dev/ctreg.h>
! 62:
! 63: /* number of eof marks to remember */
! 64: #define EOFS 128
! 65:
! 66: struct ct_softc {
! 67: struct device sc_dev;
! 68: int sc_slave; /* HP-IB slave ID */
! 69: int sc_punit; /* physical unit */
! 70: struct ct_iocmd sc_ioc;
! 71: struct ct_rscmd sc_rsc;
! 72: struct ct_stat sc_stat;
! 73: struct ct_ssmcmd sc_ssmc;
! 74: struct ct_srcmd sc_src;
! 75: struct ct_soptcmd sc_soptc;
! 76: struct ct_ulcmd sc_ul;
! 77: struct ct_wfmcmd sc_wfm;
! 78: struct ct_clearcmd sc_clear;
! 79: struct buf sc_tab;
! 80: struct buf *sc_bp;
! 81: struct buf sc_bufstore; /* XXX */
! 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: struct hpibqueue sc_hq; /* entry on hpib job queue */
! 89: int sc_eofp;
! 90: int sc_eofs[EOFS];
! 91: };
! 92:
! 93: /* flags */
! 94: #define CTF_OPEN 0x01
! 95: #define CTF_ALIVE 0x02
! 96: #define CTF_WRT 0x04
! 97: #define CTF_CMD 0x08
! 98: #define CTF_IO 0x10
! 99: #define CTF_BEOF 0x20
! 100: #define CTF_AEOF 0x40
! 101: #define CTF_EOT 0x80
! 102: #define CTF_STATWAIT 0x100
! 103: #define CTF_CANSTREAM 0x200
! 104: #define CTF_WRTTN 0x400
! 105:
! 106: int ctmatch(struct device *, void *, void *);
! 107: void ctattach(struct device *, struct device *, void *);
! 108:
! 109: struct cfattach ct_ca = {
! 110: sizeof(struct ct_softc), ctmatch, ctattach
! 111: };
! 112:
! 113: struct cfdriver ct_cd = {
! 114: NULL, "ct", DV_TAPE
! 115: };
! 116:
! 117: int ctident(struct device *, struct ct_softc *,
! 118: struct hpibbus_attach_args *);
! 119:
! 120: void ctreset(struct ct_softc *);
! 121: void ctaddeof(struct ct_softc *);
! 122: void ctustart(struct ct_softc *);
! 123: void cteof(struct ct_softc *, struct buf *);
! 124: void ctdone(struct ct_softc *, struct buf *);
! 125:
! 126: void ctstart(void *);
! 127: void ctgo(void *);
! 128: void ctintr(void *);
! 129:
! 130: void ctcommand(dev_t, int, int);
! 131:
! 132: cdev_decl(ct);
! 133: bdev_decl(ct);
! 134:
! 135: const struct ctinfo {
! 136: short hwid;
! 137: short punit;
! 138: char *desc;
! 139: } ctinfo[] = {
! 140: { CT7946ID, 1, "7946A" },
! 141: { CT7912PID, 1, "7912P" },
! 142: { CT7914PID, 1, "7914P" },
! 143: { CT9144ID, 0, "9144" },
! 144: { CT9145ID, 0, "9145" },
! 145: };
! 146: int nctinfo = sizeof(ctinfo) / sizeof(ctinfo[0]);
! 147:
! 148: #define CT_NOREW 4
! 149: #define CT_STREAM 8
! 150: #define UNIT(x) (minor(x) & 3)
! 151: #define ctpunit(x) ((x) & 7)
! 152:
! 153: #ifdef DEBUG
! 154: int ctdebug = 0;
! 155: #define CDB_FILES 0x01
! 156: #define CT_BSF 0x02
! 157: #endif
! 158:
! 159: int
! 160: ctmatch(parent, match, aux)
! 161: struct device *parent;
! 162: void *match, *aux;
! 163: {
! 164: struct hpibbus_attach_args *ha = aux;
! 165:
! 166: return (ctident(parent, NULL, ha));
! 167: }
! 168:
! 169: void
! 170: ctattach(parent, self, aux)
! 171: struct device *parent, *self;
! 172: void *aux;
! 173: {
! 174: struct ct_softc *sc = (struct ct_softc *)self;
! 175: struct hpibbus_attach_args *ha = aux;
! 176:
! 177: if (ctident(parent, sc, ha) == 0) {
! 178: /* can't happen */
! 179: printf("\n%s: didn't respond to describe command!\n",
! 180: sc->sc_dev.dv_xname);
! 181: return;
! 182: }
! 183:
! 184: sc->sc_slave = ha->ha_slave;
! 185: sc->sc_punit = ha->ha_punit;
! 186:
! 187: sc->sc_tab.b_actb = &sc->sc_tab.b_actf;
! 188:
! 189: /* Initialize hpib job queue entry. */
! 190: sc->sc_hq.hq_softc = sc;
! 191: sc->sc_hq.hq_slave = sc->sc_slave;
! 192: sc->sc_hq.hq_start = ctstart;
! 193: sc->sc_hq.hq_go = ctgo;
! 194: sc->sc_hq.hq_intr = ctintr;
! 195:
! 196: ctreset(sc);
! 197: sc->sc_flags |= CTF_ALIVE;
! 198: }
! 199:
! 200: int
! 201: ctident(parent, sc, ha)
! 202: struct device *parent;
! 203: struct ct_softc *sc;
! 204: struct hpibbus_attach_args *ha;
! 205: {
! 206: struct cs80_describe desc;
! 207: u_char stat, cmd[3];
! 208: char name[7];
! 209: int i, id, n, type, canstream;
! 210:
! 211: type = canstream = 0;
! 212:
! 213: /* Verify that we have a CS80 device. */
! 214: if ((ha->ha_id & 0x200) == 0)
! 215: return (0);
! 216:
! 217: /* Is it one of the tapes we support? */
! 218: for (id = 0; id < nctinfo; id++)
! 219: if (ha->ha_id == ctinfo[id].hwid &&
! 220: ha->ha_punit == ctinfo[id].punit)
! 221: break;
! 222: if (id == nctinfo)
! 223: return (0);
! 224:
! 225: /*
! 226: * So far, so good. Get drive parameters. Note command
! 227: * is always issued to unit 0.
! 228: */
! 229: bzero(&desc, sizeof(desc));
! 230: stat = 0;
! 231: cmd[0] = C_SUNIT(0);
! 232: cmd[1] = C_SVOL(0);
! 233: cmd[2] = C_DESC;
! 234: hpibsend(parent->dv_unit, ha->ha_slave, C_CMD, cmd, sizeof(cmd));
! 235: hpibrecv(parent->dv_unit, ha->ha_slave, C_EXEC, &desc, sizeof(desc));
! 236: hpibrecv(parent->dv_unit, ha->ha_slave, C_QSTAT, &stat, sizeof(stat));
! 237:
! 238: if (desc.d_name == 0 && stat != 0)
! 239: return (0);
! 240:
! 241: bzero(name, sizeof(name));
! 242: n = desc.d_name;
! 243: for (i = 5; i >= 0; i--) {
! 244: name[i] = (n & 0xf) + '0';
! 245: n >>= 4;
! 246: }
! 247:
! 248: switch (ha->ha_id) {
! 249: case CT7946ID:
! 250: if (bcmp(name, "079450", 6) == 0)
! 251: return (0); /* not really a 7946 */
! 252: /* FALLTHROUGH */
! 253: case CT9144ID:
! 254: case CT9145ID:
! 255: type = CT9144;
! 256: canstream = 1;
! 257: break;
! 258:
! 259: case CT7912PID:
! 260: case CT7914PID:
! 261: type = CT88140;
! 262: break;
! 263: }
! 264:
! 265: if (sc != NULL) {
! 266: sc->sc_type = type;
! 267: sc->sc_flags = canstream ? CTF_CANSTREAM : 0;
! 268: printf(": %s %stape\n", ctinfo[id].desc,
! 269: canstream ? "streaming " : "");
! 270: }
! 271:
! 272: return (1);
! 273: }
! 274:
! 275: void
! 276: ctreset(sc)
! 277: struct ct_softc *sc;
! 278: {
! 279: int ctlr, slave;
! 280: u_char stat;
! 281:
! 282: ctlr = sc->sc_dev.dv_parent->dv_unit;
! 283: slave = sc->sc_slave;
! 284:
! 285: sc->sc_clear.unit = C_SUNIT(sc->sc_punit);
! 286: sc->sc_clear.cmd = C_CLEAR;
! 287: hpibsend(ctlr, slave, C_TCMD, &sc->sc_clear, sizeof(sc->sc_clear));
! 288: hpibswait(ctlr, slave);
! 289: hpibrecv(ctlr, slave, C_QSTAT, &stat, sizeof(stat));
! 290:
! 291: sc->sc_src.unit = C_SUNIT(CTCTLR);
! 292: sc->sc_src.nop = C_NOP;
! 293: sc->sc_src.cmd = C_SREL;
! 294: sc->sc_src.param = C_REL;
! 295: hpibsend(ctlr, slave, C_CMD, &sc->sc_src, sizeof(sc->sc_src));
! 296: hpibswait(ctlr, slave);
! 297: hpibrecv(ctlr, slave, C_QSTAT, &stat, sizeof(stat));
! 298:
! 299: sc->sc_ssmc.unit = C_SUNIT(sc->sc_punit);
! 300: sc->sc_ssmc.cmd = C_SSM;
! 301: sc->sc_ssmc.refm = REF_MASK;
! 302: sc->sc_ssmc.fefm = FEF_MASK;
! 303: sc->sc_ssmc.aefm = AEF_MASK;
! 304: sc->sc_ssmc.iefm = IEF_MASK;
! 305: hpibsend(ctlr, slave, C_CMD, &sc->sc_ssmc, sizeof(sc->sc_ssmc));
! 306: hpibswait(ctlr, slave);
! 307: hpibrecv(ctlr, slave, C_QSTAT, &stat, sizeof(stat));
! 308:
! 309: sc->sc_soptc.unit = C_SUNIT(sc->sc_punit);
! 310: sc->sc_soptc.nop = C_NOP;
! 311: sc->sc_soptc.cmd = C_SOPT;
! 312: sc->sc_soptc.opt = C_SPAR;
! 313: hpibsend(ctlr, slave, C_CMD, &sc->sc_soptc, sizeof(sc->sc_soptc));
! 314: hpibswait(ctlr, slave);
! 315: hpibrecv(ctlr, slave, C_QSTAT, &stat, sizeof(stat));
! 316: }
! 317:
! 318: /*ARGSUSED*/
! 319: int
! 320: ctopen(dev, flag, type, p)
! 321: dev_t dev;
! 322: int flag, type;
! 323: struct proc *p;
! 324: {
! 325: struct ct_softc *sc;
! 326: u_char stat;
! 327: int cc, ctlr, slave;
! 328:
! 329: if (UNIT(dev) >= ct_cd.cd_ndevs ||
! 330: (sc = ct_cd.cd_devs[UNIT(dev)]) == NULL ||
! 331: (sc->sc_flags & CTF_ALIVE) == 0)
! 332: return (ENXIO);
! 333:
! 334: if (sc->sc_flags & CTF_OPEN)
! 335: return (EBUSY);
! 336:
! 337: ctlr = sc->sc_dev.dv_parent->dv_unit;
! 338: slave = sc->sc_slave;
! 339:
! 340: sc->sc_soptc.unit = C_SUNIT(sc->sc_punit);
! 341: sc->sc_soptc.nop = C_NOP;
! 342: sc->sc_soptc.cmd = C_SOPT;
! 343: if ((dev & CT_STREAM) && (sc->sc_flags & CTF_CANSTREAM))
! 344: sc->sc_soptc.opt = C_SPAR | C_IMRPT;
! 345: else
! 346: sc->sc_soptc.opt = C_SPAR;
! 347:
! 348: /*
! 349: * Check the return of hpibsend() and hpibswait().
! 350: * Drive could be loading/unloading a tape. If not checked,
! 351: * driver hangs.
! 352: */
! 353: cc = hpibsend(ctlr, slave, C_CMD, &sc->sc_soptc, sizeof(sc->sc_soptc));
! 354: if (cc != sizeof(sc->sc_soptc))
! 355: return (EBUSY);
! 356:
! 357: hpibswait(ctlr, slave);
! 358: cc = hpibrecv(ctlr, slave, C_QSTAT, &stat, sizeof(stat));
! 359: if (cc != sizeof(stat))
! 360: return(EBUSY);
! 361:
! 362: sc->sc_flags |= CTF_OPEN;
! 363: return(0);
! 364: }
! 365:
! 366: /*ARGSUSED*/
! 367: int
! 368: ctclose(dev, flag, fmt, p)
! 369: dev_t dev;
! 370: int flag, fmt;
! 371: struct proc *p;
! 372: {
! 373: struct ct_softc *sc = ct_cd.cd_devs[UNIT(dev)];
! 374:
! 375: if ((sc->sc_flags & (CTF_WRT|CTF_WRTTN)) == (CTF_WRT|CTF_WRTTN) &&
! 376: (sc->sc_flags & CTF_EOT) == 0 ) { /* XXX return error if EOT ?? */
! 377: ctcommand(dev, MTWEOF, 2);
! 378: ctcommand(dev, MTBSR, 1);
! 379: if (sc->sc_eofp == EOFS - 1)
! 380: sc->sc_eofs[EOFS - 1]--;
! 381: else
! 382: sc->sc_eofp--;
! 383: #ifdef DEBUG
! 384: if(ctdebug & CT_BSF)
! 385: printf("%s: ctclose backup eofs prt %d blk %d\n",
! 386: sc->sc_dev.dv_xname, sc->sc_eofp,
! 387: sc->sc_eofs[sc->sc_eofp]);
! 388: #endif
! 389: }
! 390: if ((minor(dev) & CT_NOREW) == 0)
! 391: ctcommand(dev, MTREW, 1);
! 392: sc->sc_flags &= ~(CTF_OPEN | CTF_WRT | CTF_WRTTN);
! 393: #ifdef DEBUG
! 394: if (ctdebug & CDB_FILES)
! 395: printf("ctclose: flags %x\n", sc->sc_flags);
! 396: #endif
! 397: return(0); /* XXX */
! 398: }
! 399:
! 400: void
! 401: ctcommand(dev, cmd, cnt)
! 402: dev_t dev;
! 403: int cmd;
! 404: int cnt;
! 405: {
! 406: struct ct_softc *sc = ct_cd.cd_devs[UNIT(dev)];
! 407: struct buf *bp = &sc->sc_bufstore;
! 408: struct buf *nbp = 0;
! 409:
! 410: if (cmd == MTBSF && sc->sc_eofp == EOFS - 1) {
! 411: cnt = sc->sc_eofs[EOFS - 1] - cnt;
! 412: ctcommand(dev, MTREW, 1);
! 413: ctcommand(dev, MTFSF, cnt);
! 414: cnt = 2;
! 415: cmd = MTBSR;
! 416: }
! 417:
! 418: if (cmd == MTBSF && sc->sc_eofp - cnt < 0) {
! 419: cnt = 1;
! 420: cmd = MTREW;
! 421: }
! 422:
! 423: sc->sc_flags |= CTF_CMD;
! 424: sc->sc_bp = bp;
! 425: sc->sc_cmd = cmd;
! 426: bp->b_dev = dev;
! 427: if (cmd == MTFSF) {
! 428: nbp = (struct buf *)geteblk(MAXBSIZE);
! 429: bp->b_data = nbp->b_data;
! 430: bp->b_bcount = MAXBSIZE;
! 431: }
! 432:
! 433: while (cnt-- > 0) {
! 434: bp->b_flags = B_BUSY;
! 435: if (cmd == MTBSF) {
! 436: sc->sc_blkno = sc->sc_eofs[sc->sc_eofp];
! 437: sc->sc_eofp--;
! 438: #ifdef DEBUG
! 439: if (ctdebug & CT_BSF)
! 440: printf("%s: backup eof pos %d blk %d\n",
! 441: sc->sc_dev.dv_xname, sc->sc_eofp,
! 442: sc->sc_eofs[sc->sc_eofp]);
! 443: #endif
! 444: }
! 445: ctstrategy(bp);
! 446: biowait(bp);
! 447: }
! 448: bp->b_flags = 0;
! 449: sc->sc_flags &= ~CTF_CMD;
! 450: if (nbp)
! 451: brelse(nbp);
! 452: }
! 453:
! 454: void
! 455: ctstrategy(bp)
! 456: struct buf *bp;
! 457: {
! 458: struct buf *dp;
! 459: int s, unit;
! 460: struct ct_softc *sc;
! 461:
! 462: unit = UNIT(bp->b_dev);
! 463: sc = ct_cd.cd_devs[unit];
! 464:
! 465: dp = &sc->sc_tab;
! 466: bp->b_actf = NULL;
! 467: s = splbio();
! 468: bp->b_actb = dp->b_actb;
! 469: *(dp->b_actb) = bp;
! 470: dp->b_actb = &bp->b_actf;
! 471: if (dp->b_active == 0) {
! 472: dp->b_active = 1;
! 473: ctustart(sc);
! 474: }
! 475: splx(s);
! 476: }
! 477:
! 478: void
! 479: ctustart(sc)
! 480: struct ct_softc *sc;
! 481: {
! 482: struct buf *bp;
! 483:
! 484: bp = sc->sc_tab.b_actf;
! 485: sc->sc_addr = bp->b_data;
! 486: sc->sc_resid = bp->b_bcount;
! 487: if (hpibreq(sc->sc_dev.dv_parent, &sc->sc_hq))
! 488: ctstart(sc);
! 489: }
! 490:
! 491: void
! 492: ctstart(arg)
! 493: void *arg;
! 494: {
! 495: struct ct_softc *sc = arg;
! 496: struct buf *bp;
! 497: int i, ctlr, slave;
! 498:
! 499: ctlr = sc->sc_dev.dv_parent->dv_unit;
! 500: slave = sc->sc_slave;
! 501:
! 502: bp = sc->sc_tab.b_actf;
! 503: if ((sc->sc_flags & CTF_CMD) && sc->sc_bp == bp) {
! 504: switch(sc->sc_cmd) {
! 505: case MTFSF:
! 506: bp->b_flags |= B_READ;
! 507: goto mustio;
! 508:
! 509: case MTBSF:
! 510: goto gotaddr;
! 511:
! 512: case MTOFFL:
! 513: sc->sc_blkno = 0;
! 514: sc->sc_ul.unit = C_SUNIT(sc->sc_punit);
! 515: sc->sc_ul.cmd = C_UNLOAD;
! 516: hpibsend(ctlr, slave, C_CMD, &sc->sc_ul,
! 517: sizeof(sc->sc_ul));
! 518: break;
! 519:
! 520: case MTWEOF:
! 521: sc->sc_blkno++;
! 522: sc->sc_flags |= CTF_WRT;
! 523: sc->sc_wfm.unit = C_SUNIT(sc->sc_punit);
! 524: sc->sc_wfm.cmd = C_WFM;
! 525: hpibsend(ctlr, slave, C_CMD, &sc->sc_wfm,
! 526: sizeof(sc->sc_wfm));
! 527: ctaddeof(sc);
! 528: break;
! 529:
! 530: case MTBSR:
! 531: sc->sc_blkno--;
! 532: goto gotaddr;
! 533:
! 534: case MTFSR:
! 535: sc->sc_blkno++;
! 536: goto gotaddr;
! 537:
! 538: case MTREW:
! 539: sc->sc_blkno = 0;
! 540: #ifdef DEBUG
! 541: if(ctdebug & CT_BSF)
! 542: printf("%s: clearing eofs\n",
! 543: sc->sc_dev.dv_xname);
! 544: #endif
! 545: for (i=0; i<EOFS; i++)
! 546: sc->sc_eofs[i] = 0;
! 547: sc->sc_eofp = 0;
! 548:
! 549: gotaddr:
! 550: sc->sc_ioc.saddr = C_SADDR;
! 551: sc->sc_ioc.addr0 = 0;
! 552: sc->sc_ioc.addr = sc->sc_blkno;
! 553: sc->sc_ioc.unit = C_SUNIT(sc->sc_punit);
! 554: sc->sc_ioc.nop2 = C_NOP;
! 555: sc->sc_ioc.slen = C_SLEN;
! 556: sc->sc_ioc.len = 0;
! 557: sc->sc_ioc.nop3 = C_NOP;
! 558: sc->sc_ioc.cmd = C_READ;
! 559: hpibsend(ctlr, slave, C_CMD, &sc->sc_ioc,
! 560: sizeof(sc->sc_ioc));
! 561: break;
! 562: }
! 563: } else {
! 564: mustio:
! 565: if ((bp->b_flags & B_READ) &&
! 566: sc->sc_flags & (CTF_BEOF|CTF_EOT)) {
! 567: #ifdef DEBUG
! 568: if (ctdebug & CDB_FILES)
! 569: printf("ctstart: before flags %x\n",
! 570: sc->sc_flags);
! 571: #endif
! 572: if (sc->sc_flags & CTF_BEOF) {
! 573: sc->sc_flags &= ~CTF_BEOF;
! 574: sc->sc_flags |= CTF_AEOF;
! 575: #ifdef DEBUG
! 576: if (ctdebug & CDB_FILES)
! 577: printf("ctstart: after flags %x\n",
! 578: sc->sc_flags);
! 579: #endif
! 580: }
! 581: bp->b_resid = bp->b_bcount;
! 582: ctdone(sc, bp);
! 583: return;
! 584: }
! 585: sc->sc_flags |= CTF_IO;
! 586: sc->sc_ioc.unit = C_SUNIT(sc->sc_punit);
! 587: sc->sc_ioc.saddr = C_SADDR;
! 588: sc->sc_ioc.addr0 = 0;
! 589: sc->sc_ioc.addr = sc->sc_blkno;
! 590: sc->sc_ioc.nop2 = C_NOP;
! 591: sc->sc_ioc.slen = C_SLEN;
! 592: sc->sc_ioc.len = sc->sc_resid;
! 593: sc->sc_ioc.nop3 = C_NOP;
! 594: if (bp->b_flags & B_READ)
! 595: sc->sc_ioc.cmd = C_READ;
! 596: else {
! 597: sc->sc_ioc.cmd = C_WRITE;
! 598: sc->sc_flags |= (CTF_WRT | CTF_WRTTN);
! 599: }
! 600: hpibsend(ctlr, slave, C_CMD, &sc->sc_ioc, sizeof(sc->sc_ioc));
! 601: }
! 602: hpibawait(ctlr);
! 603: }
! 604:
! 605: void
! 606: ctgo(arg)
! 607: void *arg;
! 608: {
! 609: struct ct_softc *sc = arg;
! 610: struct buf *bp;
! 611: int rw;
! 612:
! 613: bp = sc->sc_tab.b_actf;
! 614: rw = bp->b_flags & B_READ;
! 615: hpibgo(sc->sc_dev.dv_parent->dv_unit, sc->sc_slave, C_EXEC,
! 616: sc->sc_addr, sc->sc_resid, rw, rw != 0);
! 617: }
! 618:
! 619: /*
! 620: * Hideous grue to handle EOF/EOT (mostly for reads)
! 621: */
! 622: void
! 623: cteof(sc, bp)
! 624: struct ct_softc *sc;
! 625: struct buf *bp;
! 626: {
! 627: long blks;
! 628:
! 629: /*
! 630: * EOT on a write is an error.
! 631: */
! 632: if ((bp->b_flags & B_READ) == 0) {
! 633: bp->b_resid = bp->b_bcount;
! 634: bp->b_flags |= B_ERROR;
! 635: bp->b_error = ENOSPC;
! 636: sc->sc_flags |= CTF_EOT;
! 637: return;
! 638: }
! 639: /*
! 640: * Use returned block position to determine how many blocks
! 641: * we really read and update b_resid.
! 642: */
! 643: blks = sc->sc_stat.c_blk - sc->sc_blkno - 1;
! 644: #ifdef DEBUG
! 645: if (ctdebug & CDB_FILES)
! 646: printf("cteof: bc %ld oblk %d nblk %ld read %ld, resid %ld\n",
! 647: bp->b_bcount, sc->sc_blkno, sc->sc_stat.c_blk,
! 648: blks, bp->b_bcount - CTKTOB(blks));
! 649: #endif
! 650: if (blks == -1) { /* 9145 on EOF does not change sc_stat.c_blk */
! 651: blks = 0;
! 652: sc->sc_blkno++;
! 653: }
! 654: else {
! 655: sc->sc_blkno = sc->sc_stat.c_blk;
! 656: }
! 657: bp->b_resid = bp->b_bcount - CTKTOB(blks);
! 658: /*
! 659: * If we are at physical EOV or were after an EOF,
! 660: * we are now at logical EOT.
! 661: */
! 662: if ((sc->sc_stat.c_aef & AEF_EOV) ||
! 663: (sc->sc_flags & CTF_AEOF)) {
! 664: sc->sc_flags |= CTF_EOT;
! 665: sc->sc_flags &= ~(CTF_AEOF|CTF_BEOF);
! 666: }
! 667: /*
! 668: * If we were before an EOF or we have just completed a FSF,
! 669: * we are now after EOF.
! 670: */
! 671: else if ((sc->sc_flags & CTF_BEOF) ||
! 672: ((sc->sc_flags & CTF_CMD) && sc->sc_cmd == MTFSF)) {
! 673: sc->sc_flags |= CTF_AEOF;
! 674: sc->sc_flags &= ~CTF_BEOF;
! 675: }
! 676: /*
! 677: * Otherwise if we read something we are now before EOF
! 678: * (and no longer after EOF).
! 679: */
! 680: else if (blks) {
! 681: sc->sc_flags |= CTF_BEOF;
! 682: sc->sc_flags &= ~CTF_AEOF;
! 683: }
! 684: /*
! 685: * Finally, if we didn't read anything we just passed an EOF
! 686: */
! 687: else
! 688: sc->sc_flags |= CTF_AEOF;
! 689: #ifdef DEBUG
! 690: if (ctdebug & CDB_FILES)
! 691: printf("cteof: leaving flags %x\n", sc->sc_flags);
! 692: #endif
! 693: }
! 694:
! 695: /* ARGSUSED */
! 696: void
! 697: ctintr(arg)
! 698: void *arg;
! 699: {
! 700: struct ct_softc *sc = arg;
! 701: struct buf *bp;
! 702: u_char stat;
! 703: int ctlr, slave, unit;
! 704:
! 705: ctlr = sc->sc_dev.dv_parent->dv_unit;
! 706: slave = sc->sc_slave;
! 707: unit = sc->sc_dev.dv_unit;
! 708:
! 709: bp = sc->sc_tab.b_actf;
! 710: if (bp == NULL) {
! 711: printf("%s: bp == NULL\n", sc->sc_dev.dv_xname);
! 712: return;
! 713: }
! 714: if (sc->sc_flags & CTF_IO) {
! 715: sc->sc_flags &= ~CTF_IO;
! 716: if (hpibustart(ctlr))
! 717: ctgo(sc);
! 718: return;
! 719: }
! 720: if ((sc->sc_flags & CTF_STATWAIT) == 0) {
! 721: if (hpibpptest(ctlr, slave) == 0) {
! 722: sc->sc_flags |= CTF_STATWAIT;
! 723: hpibawait(ctlr);
! 724: return;
! 725: }
! 726: } else
! 727: sc->sc_flags &= ~CTF_STATWAIT;
! 728: hpibrecv(ctlr, slave, C_QSTAT, &stat, 1);
! 729: #ifdef DEBUG
! 730: if (ctdebug & CDB_FILES)
! 731: printf("ctintr: before flags %x\n", sc->sc_flags);
! 732: #endif
! 733: if (stat) {
! 734: sc->sc_rsc.unit = C_SUNIT(sc->sc_punit);
! 735: sc->sc_rsc.cmd = C_STATUS;
! 736: hpibsend(ctlr, slave, C_CMD, &sc->sc_rsc, sizeof(sc->sc_rsc));
! 737: hpibrecv(ctlr, slave, C_EXEC, &sc->sc_stat,
! 738: sizeof(sc->sc_stat));
! 739: hpibrecv(ctlr, slave, C_QSTAT, &stat, 1);
! 740: #ifdef DEBUG
! 741: if (ctdebug & CDB_FILES)
! 742: printf("ctintr: return stat 0x%x, A%x F%x blk %ld\n",
! 743: stat, sc->sc_stat.c_aef,
! 744: sc->sc_stat.c_fef, sc->sc_stat.c_blk);
! 745: #endif
! 746: if (stat == 0) {
! 747: if (sc->sc_stat.c_aef & (AEF_EOF | AEF_EOV)) {
! 748: cteof(sc, bp);
! 749: ctaddeof(sc);
! 750: goto done;
! 751: }
! 752: if (sc->sc_stat.c_fef & FEF_PF) {
! 753: ctreset(sc);
! 754: ctstart(sc);
! 755: return;
! 756: }
! 757: if (sc->sc_stat.c_fef & FEF_REXMT) {
! 758: ctstart(sc);
! 759: return;
! 760: }
! 761: if (sc->sc_stat.c_aef & 0x5800) {
! 762: if (sc->sc_stat.c_aef & 0x4000)
! 763: printf("%s: uninitialized media\n",
! 764: sc->sc_dev.dv_xname);
! 765: if (sc->sc_stat.c_aef & 0x1000)
! 766: printf("%s: not ready\n",
! 767: sc->sc_dev.dv_xname);
! 768: if (sc->sc_stat.c_aef & 0x0800)
! 769: printf("%s: write protect\n",
! 770: sc->sc_dev.dv_xname);
! 771: } else {
! 772: printf("%s err: v%d u%d ru%d bn%ld, ",
! 773: sc->sc_dev.dv_xname,
! 774: (sc->sc_stat.c_vu>>4)&0xF,
! 775: sc->sc_stat.c_vu&0xF,
! 776: sc->sc_stat.c_pend,
! 777: sc->sc_stat.c_blk);
! 778: printf("R0x%x F0x%x A0x%x I0x%x\n",
! 779: sc->sc_stat.c_ref,
! 780: sc->sc_stat.c_fef,
! 781: sc->sc_stat.c_aef,
! 782: sc->sc_stat.c_ief);
! 783: }
! 784: } else
! 785: printf("%s: request status failed\n",
! 786: sc->sc_dev.dv_xname);
! 787: bp->b_flags |= B_ERROR;
! 788: bp->b_error = EIO;
! 789: goto done;
! 790: } else
! 791: bp->b_resid = 0;
! 792: if (sc->sc_flags & CTF_CMD) {
! 793: switch (sc->sc_cmd) {
! 794: case MTFSF:
! 795: sc->sc_flags &= ~(CTF_BEOF|CTF_AEOF);
! 796: sc->sc_blkno += CTBTOK(sc->sc_resid);
! 797: ctstart(sc);
! 798: return;
! 799: case MTBSF:
! 800: sc->sc_flags &= ~(CTF_AEOF|CTF_BEOF|CTF_EOT);
! 801: break;
! 802: case MTBSR:
! 803: sc->sc_flags &= ~CTF_BEOF;
! 804: if (sc->sc_flags & CTF_EOT) {
! 805: sc->sc_flags |= CTF_AEOF;
! 806: sc->sc_flags &= ~CTF_EOT;
! 807: } else if (sc->sc_flags & CTF_AEOF) {
! 808: sc->sc_flags |= CTF_BEOF;
! 809: sc->sc_flags &= ~CTF_AEOF;
! 810: }
! 811: break;
! 812: case MTWEOF:
! 813: sc->sc_flags &= ~CTF_BEOF;
! 814: if (sc->sc_flags & (CTF_AEOF|CTF_EOT)) {
! 815: sc->sc_flags |= CTF_EOT;
! 816: sc->sc_flags &= ~CTF_AEOF;
! 817: } else
! 818: sc->sc_flags |= CTF_AEOF;
! 819: break;
! 820: case MTREW:
! 821: case MTOFFL:
! 822: sc->sc_flags &= ~(CTF_BEOF|CTF_AEOF|CTF_EOT);
! 823: break;
! 824: }
! 825: } else {
! 826: sc->sc_flags &= ~CTF_AEOF;
! 827: sc->sc_blkno += CTBTOK(sc->sc_resid);
! 828: }
! 829: done:
! 830: #ifdef DEBUG
! 831: if (ctdebug & CDB_FILES)
! 832: printf("ctintr: after flags %x\n", sc->sc_flags);
! 833: #endif
! 834: ctdone(sc, bp);
! 835: }
! 836:
! 837: void
! 838: ctdone(sc, bp)
! 839: struct ct_softc *sc;
! 840: struct buf *bp;
! 841: {
! 842: struct buf *dp;
! 843: int s;
! 844:
! 845: if ((dp = bp->b_actf) != NULL)
! 846: dp->b_actb = bp->b_actb;
! 847: else
! 848: sc->sc_tab.b_actb = bp->b_actb;
! 849: *bp->b_actb = dp;
! 850: s = splbio();
! 851: biodone(bp);
! 852: splx(s);
! 853: hpibfree(sc->sc_dev.dv_parent, &sc->sc_hq);
! 854: if (sc->sc_tab.b_actf == NULL) {
! 855: sc->sc_tab.b_active = 0;
! 856: return;
! 857: }
! 858: ctustart(sc);
! 859: }
! 860:
! 861: int
! 862: ctread(dev, uio, flags)
! 863: dev_t dev;
! 864: struct uio *uio;
! 865: int flags;
! 866: {
! 867: return (physio(ctstrategy, NULL, dev, B_READ, minphys, uio));
! 868: }
! 869:
! 870: int
! 871: ctwrite(dev, uio, flags)
! 872: dev_t dev;
! 873: struct uio *uio;
! 874: int flags;
! 875: {
! 876: /* XXX: check for hardware write-protect? */
! 877: return (physio(ctstrategy, NULL, dev, B_WRITE, minphys, uio));
! 878: }
! 879:
! 880: /*ARGSUSED*/
! 881: int
! 882: ctioctl(dev, cmd, data, flag, p)
! 883: dev_t dev;
! 884: u_long cmd;
! 885: int flag;
! 886: caddr_t data;
! 887: struct proc *p;
! 888: {
! 889: struct mtop *op;
! 890: int cnt;
! 891:
! 892: switch (cmd) {
! 893:
! 894: case MTIOCTOP:
! 895: op = (struct mtop *)data;
! 896: switch(op->mt_op) {
! 897:
! 898: case MTWEOF:
! 899: case MTFSF:
! 900: case MTBSR:
! 901: case MTBSF:
! 902: case MTFSR:
! 903: cnt = op->mt_count;
! 904: break;
! 905:
! 906: case MTREW:
! 907: case MTOFFL:
! 908: cnt = 1;
! 909: break;
! 910:
! 911: default:
! 912: return(EINVAL);
! 913: }
! 914: ctcommand(dev, op->mt_op, cnt);
! 915: break;
! 916:
! 917: case MTIOCGET:
! 918: break;
! 919:
! 920: default:
! 921: return(EINVAL);
! 922: }
! 923: return(0);
! 924: }
! 925:
! 926: /* ARGSUSED */
! 927: int
! 928: ctdump(dev, blkno, va, size)
! 929: dev_t dev;
! 930: daddr64_t blkno;
! 931: caddr_t va;
! 932: size_t size;
! 933: {
! 934:
! 935: return (ENODEV);
! 936: }
! 937:
! 938: void
! 939: ctaddeof(sc)
! 940: struct ct_softc *sc;
! 941: {
! 942:
! 943: if (sc->sc_eofp == EOFS - 1)
! 944: sc->sc_eofs[EOFS - 1]++;
! 945: else {
! 946: sc->sc_eofp++;
! 947: if (sc->sc_eofp == EOFS - 1)
! 948: sc->sc_eofs[EOFS - 1] = EOFS;
! 949: else
! 950: /* save blkno */
! 951: sc->sc_eofs[sc->sc_eofp] = sc->sc_blkno - 1;
! 952: }
! 953: #ifdef DEBUG
! 954: if (ctdebug & CT_BSF)
! 955: printf("%s: add eof pos %d blk %d\n",
! 956: sc->sc_dev.dv_xname, sc->sc_eofp,
! 957: sc->sc_eofs[sc->sc_eofp]);
! 958: #endif
! 959: }