Annotation of sys/arch/vax/mscp/mscp_tape.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: mscp_tape.c,v 1.10 2007/06/06 17:15:13 deraadt Exp $ */
! 2: /* $NetBSD: mscp_tape.c,v 1.16 2001/11/13 07:38:28 lukem Exp $ */
! 3: /*
! 4: * Copyright (c) 1996 Ludd, University of Lule}, Sweden.
! 5: * All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: * 3. All advertising materials mentioning features or use of this software
! 16: * must display the following acknowledgement:
! 17: * This product includes software developed at Ludd, University of
! 18: * Lule}, Sweden and its contributors.
! 19: * 4. The name of the author may not be used to endorse or promote products
! 20: * derived from this software without specific prior written permission
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 32: */
! 33:
! 34:
! 35: /*
! 36: * MSCP tape device driver
! 37: */
! 38:
! 39: /*
! 40: * TODO
! 41: * Write status handling code.
! 42: */
! 43:
! 44: #include <sys/cdefs.h>
! 45:
! 46: #include <sys/param.h>
! 47: #include <sys/device.h>
! 48: #include <sys/kernel.h>
! 49: #include <sys/buf.h>
! 50: #include <sys/ioccom.h>
! 51: #include <sys/mtio.h>
! 52: #include <sys/fcntl.h>
! 53: #include <sys/malloc.h>
! 54: #include <sys/systm.h>
! 55: #include <sys/proc.h>
! 56:
! 57: #include <machine/bus.h>
! 58: #include <machine/cpu.h>
! 59:
! 60: #include <arch/vax/mscp/mscp.h>
! 61: #include <arch/vax/mscp/mscpreg.h>
! 62: #include <arch/vax/mscp/mscpvar.h>
! 63:
! 64: /*
! 65: * Drive status, per drive
! 66: */
! 67: struct mt_softc {
! 68: struct device mt_dev; /* Autoconf struct */
! 69: int mt_state; /* open/closed state */
! 70: int mt_hwunit; /* Hardware unit number */
! 71: int mt_inuse; /* Locks the tape drive for others */
! 72: int mt_waswrite; /* Last operation was a write op */
! 73: int mt_serex; /* Got serious exception */
! 74: int mt_ioctlerr; /* Error after last ioctl */
! 75: };
! 76:
! 77: #define MT_OFFLINE 0
! 78: #define MT_ONLINE 1
! 79:
! 80: int mtmatch(struct device *, struct cfdata *, void *);
! 81: void mtattach(struct device *, struct device *, void *);
! 82: void mtdgram(struct device *, struct mscp *, struct mscp_softc *);
! 83: void mtiodone(struct device *, struct buf *);
! 84: int mtonline(struct device *, struct mscp *);
! 85: int mtgotstatus(struct device *, struct mscp *);
! 86: int mtioerror(struct device *, struct mscp *, struct buf *);
! 87: void mtfillin(struct buf *, struct mscp *);
! 88: int mtopen(dev_t, int, int, struct proc *);
! 89: int mtclose(dev_t, int, int, struct proc *);
! 90: void mtstrategy(struct buf *);
! 91: int mtread(dev_t, struct uio *);
! 92: int mtwrite(dev_t, struct uio *);
! 93: int mtioctl(dev_t, int, caddr_t, int, struct proc *);
! 94: int mtdump(dev_t, daddr64_t, caddr_t, size_t);
! 95: int mtcmd(struct mt_softc *, int, int, int);
! 96: void mtcmddone(struct device *, struct mscp *);
! 97: int mt_putonline(struct mt_softc *);
! 98:
! 99: struct mscp_device mt_device = {
! 100: mtdgram,
! 101: mtiodone,
! 102: mtonline,
! 103: mtgotstatus,
! 104: 0,
! 105: mtioerror,
! 106: 0,
! 107: mtfillin,
! 108: mtcmddone,
! 109: };
! 110:
! 111: /* This is not good, should allow more than 4 tapes/device type */
! 112: #define mtunit(dev) (minor(dev) & T_UNIT)
! 113: #define mtnorewind(dev) (dev & T_NOREWIND)
! 114: #define mthdensity(dev) (dev & T_1600BPI)
! 115:
! 116: struct cfattach mt_ca = {
! 117: sizeof(struct mt_softc), (cfmatch_t)mtmatch, mtattach
! 118: };
! 119:
! 120: struct cfdriver mt_cd = {
! 121: NULL, "mt", DV_TAPE
! 122: };
! 123:
! 124: /*
! 125: * More driver definitions, for generic MSCP code.
! 126: */
! 127:
! 128: int
! 129: mtmatch(parent, cf, aux)
! 130: struct device *parent;
! 131: struct cfdata *cf;
! 132: void *aux;
! 133: {
! 134: struct drive_attach_args *da = aux;
! 135: struct mscp *mp = da->da_mp;
! 136:
! 137: if ((da->da_typ & MSCPBUS_TAPE) == 0)
! 138: return 0;
! 139: if (cf->cf_loc[0] != -1 && cf->cf_loc[0] != mp->mscp_unit)
! 140: return 0;
! 141: return 1;
! 142: }
! 143:
! 144: /*
! 145: * The attach routine only checks and prints drive type.
! 146: */
! 147: void
! 148: mtattach(parent, self, aux)
! 149: struct device *parent, *self;
! 150: void *aux;
! 151: {
! 152: struct mt_softc *mt = (void *)self;
! 153: struct drive_attach_args *da = aux;
! 154: struct mscp *mp = da->da_mp;
! 155: struct mscp_softc *mi = (void *)parent;
! 156:
! 157: mt->mt_hwunit = mp->mscp_unit;
! 158: mi->mi_dp[mp->mscp_unit] = self;
! 159:
! 160: disk_printtype(mp->mscp_unit, mp->mscp_guse.guse_mediaid);
! 161: }
! 162:
! 163: /*
! 164: * (Try to) put the drive online. This is done the first time the
! 165: * drive is opened, or if it has fallen offline.
! 166: */
! 167: int
! 168: mt_putonline(mt)
! 169: struct mt_softc *mt;
! 170: {
! 171: struct mscp *mp;
! 172: struct mscp_softc *mi = (struct mscp_softc *)mt->mt_dev.dv_parent;
! 173: volatile int i;
! 174:
! 175: (volatile int)mt->mt_state = MT_OFFLINE;
! 176: mp = mscp_getcp(mi, MSCP_WAIT);
! 177: mp->mscp_opcode = M_OP_ONLINE;
! 178: mp->mscp_unit = mt->mt_hwunit;
! 179: mp->mscp_cmdref = (long)&mt->mt_state;
! 180: *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
! 181:
! 182: /* Poll away */
! 183: i = bus_space_read_2(mi->mi_iot, mi->mi_iph, 0);
! 184: if (tsleep(&mt->mt_state, PRIBIO, "mtonline", 240 * hz))
! 185: return MSCP_FAILED;
! 186:
! 187: if ((volatile int)mt->mt_state != MT_ONLINE)
! 188: return MSCP_FAILED;
! 189:
! 190: return MSCP_DONE;
! 191: }
! 192: /*
! 193: * Open a drive.
! 194: */
! 195: /*ARGSUSED*/
! 196: int
! 197: mtopen(dev, flag, fmt, p)
! 198: dev_t dev;
! 199: int flag, fmt;
! 200: struct proc *p;
! 201: {
! 202: struct mt_softc *mt;
! 203: int unit;
! 204:
! 205: /*
! 206: * Make sure this is a reasonable open request.
! 207: */
! 208: unit = mtunit(dev);
! 209: if (unit >= mt_cd.cd_ndevs)
! 210: return ENXIO;
! 211: mt = mt_cd.cd_devs[unit];
! 212: if (mt == 0)
! 213: return ENXIO;
! 214:
! 215: if (mt->mt_inuse)
! 216: return EBUSY;
! 217: mt->mt_inuse = 1;
! 218:
! 219: if (mt_putonline(mt) == MSCP_FAILED) {
! 220: mt->mt_inuse = 0;
! 221: return EIO;
! 222: }
! 223:
! 224: return 0;
! 225: }
! 226:
! 227: /* ARGSUSED */
! 228: int
! 229: mtclose(dev, flags, fmt, p)
! 230: dev_t dev;
! 231: int flags, fmt;
! 232: struct proc *p;
! 233: {
! 234: int unit = mtunit(dev);
! 235: struct mt_softc *mt = mt_cd.cd_devs[unit];
! 236:
! 237: /*
! 238: * If we just have finished a writing, write EOT marks.
! 239: */
! 240: if ((flags & FWRITE) && mt->mt_waswrite) {
! 241: mtcmd(mt, MTWEOF, 0, 0);
! 242: mtcmd(mt, MTWEOF, 0, 0);
! 243: mtcmd(mt, MTBSR, 1, 0);
! 244: }
! 245: if (mtnorewind(dev) == 0)
! 246: mtcmd(mt, MTREW, 0, 1);
! 247: if (mt->mt_serex)
! 248: mtcmd(mt, -1, 0, 0);
! 249:
! 250: mt->mt_inuse = 0; /* Release the tape */
! 251: return 0;
! 252: }
! 253:
! 254: void
! 255: mtstrategy(bp)
! 256: struct buf *bp;
! 257: {
! 258: int unit;
! 259: struct mt_softc *mt;
! 260: int s;
! 261:
! 262: /*
! 263: * Make sure this is a reasonable drive to use.
! 264: */
! 265: unit = mtunit(bp->b_dev);
! 266: if (unit >= mt_cd.cd_ndevs || (mt = mt_cd.cd_devs[unit]) == NULL) {
! 267: bp->b_error = ENXIO;
! 268: goto bad;
! 269: }
! 270:
! 271: mt->mt_waswrite = bp->b_flags & B_READ ? 0 : 1;
! 272: mscp_strategy(bp, mt->mt_dev.dv_parent);
! 273: return;
! 274:
! 275: bad:
! 276: bp->b_flags |= B_ERROR;
! 277: s = splbio();
! 278: biodone(bp);
! 279: splx(s);
! 280: }
! 281:
! 282: int
! 283: mtread(dev, uio)
! 284: dev_t dev;
! 285: struct uio *uio;
! 286: {
! 287:
! 288: return (physio(mtstrategy, NULL, dev, B_READ, minphys, uio));
! 289: }
! 290:
! 291: int
! 292: mtwrite(dev, uio)
! 293: dev_t dev;
! 294: struct uio *uio;
! 295: {
! 296:
! 297: return (physio(mtstrategy, NULL, dev, B_WRITE, minphys, uio));
! 298: }
! 299:
! 300: void
! 301: mtiodone(usc, bp)
! 302: struct device *usc;
! 303: struct buf *bp;
! 304: {
! 305: int s;
! 306:
! 307: s = splbio();
! 308: biodone(bp);
! 309: splx(s);
! 310: }
! 311:
! 312: /*
! 313: * Fill in drive addresses in a mscp packet waiting for transfer.
! 314: */
! 315: void
! 316: mtfillin(bp, mp)
! 317: struct buf *bp;
! 318: struct mscp *mp;
! 319: {
! 320: int unit = mtunit(bp->b_dev);
! 321: struct mt_softc *mt = mt_cd.cd_devs[unit];
! 322:
! 323: mp->mscp_unit = mt->mt_hwunit;
! 324: if (mt->mt_serex == 2) {
! 325: mp->mscp_modifier = M_MD_CLSEX;
! 326: mt->mt_serex = 0;
! 327: } else
! 328: mp->mscp_modifier = 0;
! 329:
! 330: mp->mscp_seq.seq_bytecount = bp->b_bcount;
! 331: }
! 332:
! 333: /*
! 334: * Handle an error datagram.
! 335: */
! 336: void
! 337: mtdgram(usc, mp, mi)
! 338: struct device *usc;
! 339: struct mscp *mp;
! 340: struct mscp_softc *mi;
! 341: {
! 342: if (mscp_decodeerror(usc == NULL?"unconf mt" : usc->dv_xname, mp, mi))
! 343: return;
! 344: }
! 345:
! 346: /*
! 347: * A drive came on line, make sure it really _is_ on line before
! 348: * trying to use it.
! 349: */
! 350: int
! 351: mtonline(usc, mp)
! 352: struct device *usc;
! 353: struct mscp *mp;
! 354: {
! 355: struct mt_softc *mt = (void *)usc;
! 356:
! 357: wakeup((caddr_t)&mt->mt_state);
! 358: if ((mp->mscp_status & M_ST_MASK) == M_ST_SUCCESS)
! 359: mt->mt_state = MT_ONLINE;
! 360:
! 361: return (MSCP_DONE);
! 362: }
! 363:
! 364: /*
! 365: * We got some (configured) unit's status. Return DONE.
! 366: */
! 367: int
! 368: mtgotstatus(usc, mp)
! 369: struct device *usc;
! 370: struct mscp *mp;
! 371: {
! 372: return (MSCP_DONE);
! 373: }
! 374:
! 375: static char *mt_ioerrs[] = {
! 376: "invalid command", /* 1 M_ST_INVALCMD */
! 377: "command aborted", /* 2 M_ST_ABORTED */
! 378: "unit offline", /* 3 M_ST_OFFLINE */
! 379: "unknown", /* 4 M_ST_AVAILABLE */
! 380: "unknown", /* 5 M_ST_MFMTERR */
! 381: "unit write protected", /* 6 M_ST_WRPROT */
! 382: "compare error", /* 7 M_ST_COMPERR */
! 383: "data error", /* 8 M_ST_DATAERR */
! 384: "host buffer access error", /* 9 M_ST_HOSTBUFERR */
! 385: "controller error", /* 10 M_ST_CTLRERR */
! 386: "drive error", /* 11 M_ST_DRIVEERR */
! 387: "formatter error", /* 12 M_ST_FORMATTERR */
! 388: "BOT encountered", /* 13 M_ST_BOT */
! 389: "tape mark encountered",/* 14 M_ST_TAPEMARK */
! 390: "unknown", /* 15 */
! 391: "record data truncated",/* 16 M_ST_RDTRUNC */
! 392: };
! 393:
! 394: /*
! 395: * An I/O error, may be because of a tapemark encountered.
! 396: * Check that before failing.
! 397: */
! 398: /*ARGSUSED*/
! 399: int
! 400: mtioerror(usc, mp, bp)
! 401: struct device *usc;
! 402: struct mscp *mp;
! 403: struct buf *bp;
! 404: {
! 405: struct mt_softc *mt = (void *)usc;
! 406: int st = mp->mscp_status & M_ST_MASK;
! 407:
! 408: if (mp->mscp_flags & M_EF_SEREX)
! 409: mt->mt_serex = 1;
! 410: if (st == M_ST_TAPEMARK)
! 411: mt->mt_serex = 2;
! 412: else {
! 413: if (st && st < 17)
! 414: printf("%s: error %d (%s)\n", mt->mt_dev.dv_xname, st,
! 415: mt_ioerrs[st-1]);
! 416: else
! 417: printf("%s: error %d\n", mt->mt_dev.dv_xname, st);
! 418: bp->b_flags |= B_ERROR;
! 419: bp->b_error = EROFS;
! 420: }
! 421:
! 422: return (MSCP_DONE);
! 423: }
! 424:
! 425: /*
! 426: * I/O controls.
! 427: */
! 428: int
! 429: mtioctl(dev, cmd, data, flag, p)
! 430: dev_t dev;
! 431: int cmd;
! 432: caddr_t data;
! 433: int flag;
! 434: struct proc *p;
! 435: {
! 436: int unit = mtunit(dev);
! 437: struct mt_softc *mt = mt_cd.cd_devs[unit];
! 438: struct mtop *mtop;
! 439: struct mtget *mtget;
! 440: int error = 0, count;
! 441:
! 442: count = mtop->mt_count;
! 443:
! 444: switch (cmd) {
! 445:
! 446: case MTIOCTOP:
! 447: mtop = (void *)data;
! 448: if (mtop->mt_op == MTWEOF) {
! 449: while (mtop->mt_count-- > 0)
! 450: if ((error = mtcmd(mt, mtop->mt_op, 0, 0)))
! 451: break;
! 452: } else
! 453: error = mtcmd(mt, mtop->mt_op, mtop->mt_count, 0);
! 454:
! 455: case MTIOCGET:
! 456: mtget = (void *)data;
! 457: mtget->mt_type = MT_ISTMSCP;
! 458: /* XXX we need to fill in more fields here */
! 459: break;
! 460:
! 461: default:
! 462: error = ENXIO;
! 463: break;
! 464: }
! 465: return (error);
! 466: }
! 467:
! 468: /*
! 469: * No crash dump support...
! 470: */
! 471: int
! 472: mtdump(dev, blkno, va, size)
! 473: dev_t dev;
! 474: daddr64_t blkno;
! 475: caddr_t va;
! 476: size_t size;
! 477: {
! 478: return -1;
! 479: }
! 480:
! 481: /*
! 482: * Send a command to the tape drive. Wait until the command is
! 483: * finished before returning.
! 484: * This routine must only be called when there are no data transfer
! 485: * active on this device. Can we be sure of this? Or does the ctlr
! 486: * queue up all command packets and take them in sequential order?
! 487: * It sure would be nice if my manual stated this... /ragge
! 488: */
! 489: int
! 490: mtcmd(mt, cmd, count, complete)
! 491: struct mt_softc *mt;
! 492: int cmd, count, complete;
! 493: {
! 494: struct mscp *mp;
! 495: struct mscp_softc *mi = (void *)mt->mt_dev.dv_parent;
! 496: volatile int i;
! 497:
! 498: mp = mscp_getcp(mi, MSCP_WAIT);
! 499:
! 500: mt->mt_ioctlerr = 0;
! 501: mp->mscp_unit = mt->mt_hwunit;
! 502: mp->mscp_cmdref = -1;
! 503: *mp->mscp_addr |= MSCP_OWN | MSCP_INT;
! 504:
! 505: switch (cmd) {
! 506: case MTWEOF:
! 507: mp->mscp_opcode = M_OP_WRITM;
! 508: break;
! 509:
! 510: case MTBSF:
! 511: mp->mscp_modifier = M_MD_REVERSE;
! 512: case MTFSF:
! 513: mp->mscp_opcode = M_OP_POS;
! 514: mp->mscp_seq.seq_buffer = count;
! 515: break;
! 516:
! 517: case MTBSR:
! 518: mp->mscp_modifier = M_MD_REVERSE;
! 519: case MTFSR:
! 520: mp->mscp_opcode = M_OP_POS;
! 521: mp->mscp_modifier |= M_MD_OBJCOUNT;
! 522: mp->mscp_seq.seq_bytecount = count;
! 523: break;
! 524:
! 525: case MTREW:
! 526: mp->mscp_opcode = M_OP_POS;
! 527: mp->mscp_modifier = M_MD_REWIND | M_MD_CLSEX;
! 528: if (complete)
! 529: mp->mscp_modifier |= M_MD_IMMEDIATE;
! 530: mt->mt_serex = 0;
! 531: break;
! 532:
! 533: case MTOFFL:
! 534: mp->mscp_opcode = M_OP_AVAILABLE;
! 535: mp->mscp_modifier = M_MD_UNLOAD | M_MD_CLSEX;
! 536: mt->mt_serex = 0;
! 537: break;
! 538:
! 539: case MTNOP:
! 540: mp->mscp_opcode = M_OP_GETUNITST;
! 541: break;
! 542:
! 543: case -1: /* Clear serious exception only */
! 544: mp->mscp_opcode = M_OP_POS;
! 545: mp->mscp_modifier = M_MD_CLSEX;
! 546: mt->mt_serex = 0;
! 547: break;
! 548:
! 549: default:
! 550: printf("Bad ioctl %x\n", cmd);
! 551: mp->mscp_opcode = M_OP_POS;
! 552: break;
! 553: }
! 554:
! 555: i = bus_space_read_2(mi->mi_iot, mi->mi_iph, 0);
! 556: tsleep(&mt->mt_inuse, PRIBIO, "mtioctl", 0);
! 557: return mt->mt_ioctlerr;
! 558: }
! 559:
! 560: /*
! 561: * Called from bus routines whenever a non-data transfer is finished.
! 562: */
! 563: void
! 564: mtcmddone(usc, mp)
! 565: struct device *usc;
! 566: struct mscp *mp;
! 567: {
! 568: struct mt_softc *mt = (void *)usc;
! 569:
! 570: if (mp->mscp_status) {
! 571: mt->mt_ioctlerr = EIO;
! 572: printf("%s: bad status %x\n", mt->mt_dev.dv_xname,
! 573: mp->mscp_status);
! 574: }
! 575: wakeup(&mt->mt_inuse);
! 576: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to mscp_tape.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / vax / mscp