Home | History | Annotate | Line # | Download | only in dev
mt.c revision 1.3
      1 /*	$NetBSD: mt.c,v 1.3 1996/02/14 02:44:40 thorpej Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1992, The University of Utah and
      5  * the Computer Systems Laboratory at the University of Utah (CSL).
      6  * All rights reserved.
      7  *
      8  * Permission to use, copy, modify and distribute this software is hereby
      9  * granted provided that (1) source code retains these copyright, permission,
     10  * and disclaimer notices, and (2) redistributions including binaries
     11  * reproduce the notices in supporting documentation, and (3) all advertising
     12  * materials mentioning features or use of this software display the following
     13  * acknowledgement: ``This product includes software developed by the
     14  * Computer Systems Laboratory at the University of Utah.''
     15  *
     16  * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
     17  * IS" CONDITION.  THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
     18  * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
     19  *
     20  * CSL requests users of this software to return to csl-dist (at) cs.utah.edu any
     21  * improvements that they make and grant CSL redistribution rights.
     22  *
     23  *	Utah $Hdr: mt.c 1.8 95/09/12$
     24  */
     25 /*	@(#)mt.c	3.9	90/07/10	mt Xinu
     26  *
     27  * Magnetic tape driver (7974a, 7978a/b, 7979a, 7980a, 7980xc)
     28  * Original version contributed by Mt. Xinu.
     29  * Modified for 4.4BSD by Mark Davies and Andrew Vignaux, Department of
     30  * Computer Science, Victoria University of Wellington
     31  */
     32 #include "mt.h"
     33 #if NMT > 0
     34 
     35 #include <sys/param.h>
     36 #include <sys/systm.h>
     37 #include <sys/buf.h>
     38 #include <sys/ioctl.h>
     39 #include <sys/mtio.h>
     40 #include <sys/file.h>
     41 #include <sys/proc.h>
     42 #include <sys/errno.h>
     43 #include <sys/syslog.h>
     44 #include <sys/tty.h>
     45 #include <sys/kernel.h>
     46 #include <sys/tprintf.h>
     47 
     48 #include <hp300/dev/device.h>
     49 #include <hp300/dev/hpibvar.h>
     50 #include <hp300/dev/mtreg.h>
     51 
     52 
     53 struct	mtinfo {
     54 	u_short	hwid;
     55 	char	*desc;
     56 } mtinfo[] = {
     57 	MT7978ID,	"7978",
     58 	MT7979AID,	"7979A",
     59 	MT7980ID,	"7980",
     60 	MT7974AID,	"7974A",
     61 };
     62 int	nmtinfo = sizeof(mtinfo) / sizeof(mtinfo[0]);
     63 
     64 struct	mt_softc {
     65 	struct	hp_device *sc_hd;
     66 	short	sc_hpibno;	/* logical HPIB this slave it attached to */
     67 	short	sc_slave;	/* HPIB slave address (0-6) */
     68 	short	sc_flags;	/* see below */
     69 	u_char	sc_lastdsj;	/* place for DSJ in mtreaddsj() */
     70 	u_char	sc_lastecmd;	/* place for End Command in mtreaddsj() */
     71 	short	sc_recvtimeo;	/* count of hpibsend timeouts to prevent hang */
     72 	short	sc_statindex;	/* index for next sc_stat when MTF_STATTIMEO */
     73 	struct	mt_stat sc_stat;/* status bytes last read from device */
     74 	short	sc_density;	/* current density of tape (mtio.h format) */
     75 	short	sc_type;	/* tape drive model (hardware IDs) */
     76 	struct	devqueue sc_dq;	/* HPIB device queue member */
     77 	tpr_t	sc_ttyp;
     78 } mt_softc[NMT];
     79 struct	buf mttab[NMT];
     80 struct  buf mtbuf[NMT];
     81 
     82 #ifdef DEBUG
     83 int	mtdebug = 0;
     84 #define	dlog	if (mtdebug) log
     85 #else
     86 #define	dlog	if (0) log
     87 #endif
     88 
     89 #define	UNIT(x)		(minor(x) & 3)
     90 
     91 #define B_CMD		B_XXX		/* command buf instead of data */
     92 #define	b_cmd		b_blkno		/* blkno holds cmd when B_CMD */
     93 
     94 int	mtmatch(), mtintr();
     95 void	mtattach(), mtustart(), mtstart(), mtgo(), mtstrategy();
     96 struct	driver mtdriver = {
     97 	mtmatch, mtattach, "mt", (int (*)()) mtstart, (int (*)()) mtgo, mtintr,
     98 };
     99 
    100 int
    101 mtmatch(hd)
    102 	register struct hp_device *hd;
    103 {
    104 	register int unit;
    105 	register int hpibno = hd->hp_ctlr;
    106 	register int slave = hd->hp_slave;
    107 	register struct mt_softc *sc = &mt_softc[hd->hp_unit];
    108 	register int id;
    109 	register struct buf *bp;
    110 
    111 	sc->sc_hd = hd;
    112 
    113 	for (bp = mttab; bp < &mttab[NMT]; bp++)
    114 		bp->b_actb = &bp->b_actf;
    115 	unit = hpibid(hpibno, slave);
    116 	for (id = 0; id < nmtinfo; id++)
    117 		if (unit == mtinfo[id].hwid)
    118 			return (1);
    119 	return (0);			/* not a known HP magtape */
    120 }
    121 
    122 void
    123 mtattach(hd)
    124 	register struct hp_device *hd;
    125 {
    126 	register int unit;
    127 	register int hpibno = hd->hp_ctlr;
    128 	register int slave = hd->hp_slave;
    129 	register struct mt_softc *sc;
    130 	register int id;
    131 	register struct buf *bp;
    132 
    133 	/* XXX Ick. */
    134 	unit = hpibid(hpibno, slave);
    135 	for (id = 0; id < nmtinfo; id++)
    136 		if (unit == mtinfo[id].hwid)
    137 			break;
    138 
    139 	unit = hd->hp_unit;
    140 	sc = &mt_softc[unit];
    141 	sc->sc_type = mtinfo[id].hwid;
    142 	printf(": %s tape\n", mtinfo[id].desc);
    143 
    144 	sc->sc_hpibno = hpibno;
    145 	sc->sc_slave = slave;
    146 	sc->sc_flags = MTF_EXISTS;
    147 	sc->sc_dq.dq_softc = sc;
    148 	sc->sc_dq.dq_ctlr = hpibno;
    149 	sc->sc_dq.dq_unit = unit;
    150 	sc->sc_dq.dq_slave = slave;
    151 	sc->sc_dq.dq_driver = &mtdriver;
    152 }
    153 
    154 /*
    155  * Perform a read of "Device Status Jump" register and update the
    156  * status if necessary.  If status is read, the given "ecmd" is also
    157  * performed, unless "ecmd" is zero.  Returns DSJ value, -1 on failure
    158  * and -2 on "temporary" failure.
    159  */
    160 mtreaddsj(unit, ecmd)
    161 	register int unit;
    162 	int ecmd;
    163 {
    164 	register struct mt_softc *sc = &mt_softc[unit];
    165 	int retval;
    166 
    167 	if (sc->sc_flags & MTF_STATTIMEO)
    168 		goto getstats;
    169 	retval = hpibrecv(sc->sc_hpibno,
    170 			  (sc->sc_flags & MTF_DSJTIMEO) ? -1 : sc->sc_slave,
    171 			  MTT_DSJ, &(sc->sc_lastdsj), 1);
    172 	sc->sc_flags &= ~MTF_DSJTIMEO;
    173 	if (retval != 1) {
    174 		dlog(LOG_DEBUG, "mt%d can't hpibrecv DSJ\n", unit);
    175 		if (sc->sc_recvtimeo == 0)
    176 			sc->sc_recvtimeo = hz;
    177 		if (--sc->sc_recvtimeo == 0)
    178 			return (-1);
    179 		if (retval == 0)
    180 			sc->sc_flags |= MTF_DSJTIMEO;
    181 		return (-2);
    182 	}
    183 	sc->sc_recvtimeo = 0;
    184 	sc->sc_statindex = 0;
    185 	dlog(LOG_DEBUG, "mt%d readdsj: 0x%x\n", unit, sc->sc_lastdsj);
    186 	sc->sc_lastecmd = ecmd;
    187 	switch (sc->sc_lastdsj) {
    188 	    case 0:
    189 		if (ecmd & MTE_DSJ_FORCE)
    190 			break;
    191 		return (0);
    192 
    193 	    case 2:
    194 		sc->sc_lastecmd = MTE_COMPLETE;
    195 	    case 1:
    196 		break;
    197 
    198 	    default:
    199 		log(LOG_ERR, "mt%d readdsj: DSJ 0x%x\n", unit, sc->sc_lastdsj);
    200 		return (-1);
    201 	}
    202     getstats:
    203 	retval = hpibrecv(sc->sc_hpibno,
    204 			  (sc->sc_flags & MTF_STATCONT) ? -1 : sc->sc_slave,
    205 			  MTT_STAT, ((char *)&(sc->sc_stat)) + sc->sc_statindex,
    206 			  sizeof(sc->sc_stat) - sc->sc_statindex);
    207 	sc->sc_flags &= ~(MTF_STATTIMEO | MTF_STATCONT);
    208 	if (retval != sizeof(sc->sc_stat) - sc->sc_statindex) {
    209 		if (sc->sc_recvtimeo == 0)
    210 			sc->sc_recvtimeo = hz;
    211 		if (--sc->sc_recvtimeo != 0) {
    212 			if (retval >= 0) {
    213 				sc->sc_statindex += retval;
    214 				sc->sc_flags |= MTF_STATCONT;
    215 			}
    216 			sc->sc_flags |= MTF_STATTIMEO;
    217 			return (-2);
    218 		}
    219 		log(LOG_ERR, "mt%d readdsj: can't read status\n", unit);
    220 		return (-1);
    221 	}
    222 	sc->sc_recvtimeo = 0;
    223 	sc->sc_statindex = 0;
    224 	dlog(LOG_DEBUG, "mt%d readdsj: status is %x %x %x %x %x %x\n", unit,
    225 		sc->sc_stat1, sc->sc_stat2, sc->sc_stat3,
    226 		sc->sc_stat4, sc->sc_stat5, sc->sc_stat6);
    227 	if (sc->sc_lastecmd)
    228 		(void) hpibsend(sc->sc_hpibno, sc->sc_slave,
    229 				MTL_ECMD, &(sc->sc_lastecmd), 1);
    230 	return ((int) sc->sc_lastdsj);
    231 }
    232 
    233 mtopen(dev, flag, mode, p)
    234 	dev_t dev;
    235 	int flag, mode;
    236 	struct proc *p;
    237 {
    238 	register int unit = UNIT(dev);
    239 	register struct mt_softc *sc = &mt_softc[unit];
    240 	register int req_den;
    241 	int error;
    242 
    243 	dlog(LOG_DEBUG, "mt%d open: flags 0x%x\n", unit, sc->sc_flags);
    244 	if (unit >= NMT || (sc->sc_flags & MTF_EXISTS) == 0)
    245 		return (ENXIO);
    246 	if (sc->sc_flags & MTF_OPEN)
    247 		return (EBUSY);
    248 	sc->sc_flags |= MTF_OPEN;
    249 	sc->sc_ttyp = tprintf_open(p);
    250 	if ((sc->sc_flags & MTF_ALIVE) == 0) {
    251 		error = mtcommand(dev, MTRESET, 0);
    252 		if (error != 0 || (sc->sc_flags & MTF_ALIVE) == 0)
    253 			goto errout;
    254 		if ((sc->sc_stat1 & (SR1_BOT | SR1_ONLINE)) == SR1_ONLINE)
    255 			(void) mtcommand(dev, MTREW, 0);
    256 	}
    257 	for (;;) {
    258 		if ((error = mtcommand(dev, MTNOP, 0)) != 0)
    259 			goto errout;
    260 		if (!(sc->sc_flags & MTF_REW))
    261 			break;
    262 		if (tsleep((caddr_t) &lbolt, PCATCH | (PZERO + 1), "mt", 0) != 0) {
    263 			error = EINTR;
    264 			goto errout;
    265 		}
    266 	}
    267 	if ((flag & FWRITE) && (sc->sc_stat1 & SR1_RO)) {
    268 		error = EROFS;
    269 		goto errout;
    270 	}
    271 	if (!(sc->sc_stat1 & SR1_ONLINE)) {
    272 		uprintf("%s: not online\n", sc->sc_hd->hp_xname);
    273 		error = EIO;
    274 		goto errout;
    275 	}
    276 	/*
    277 	 * Select density:
    278 	 *  - find out what density the drive is set to
    279 	 *	(i.e. the density of the current tape)
    280 	 *  - if we are going to write
    281 	 *    - if we're not at the beginning of the tape
    282 	 *      - complain if we want to change densities
    283 	 *    - otherwise, select the mtcommand to set the density
    284 	 *
    285 	 * If the drive doesn't support it then don't change the recorded
    286 	 * density.
    287 	 *
    288 	 * The original MOREbsd code had these additional conditions
    289 	 * for the mid-tape change
    290 	 *
    291 	 *	req_den != T_BADBPI &&
    292 	 *	sc->sc_density != T_6250BPI
    293 	 *
    294 	 * which suggests that it would be possible to write multiple
    295 	 * densities if req_den == T_BAD_BPI or the current tape
    296 	 * density was 6250.  Testing of our 7980 suggests that the
    297 	 * device cannot change densities mid-tape.
    298 	 *
    299 	 * ajv (at) comp.vuw.ac.nz
    300 	 */
    301 	sc->sc_density = (sc->sc_stat2 & SR2_6250) ? T_6250BPI : (
    302 			 (sc->sc_stat3 & SR3_1600) ? T_1600BPI : (
    303 			 (sc->sc_stat3 & SR3_800) ? T_800BPI : -1));
    304 	req_den = (dev & T_DENSEL);
    305 
    306 	if (flag & FWRITE) {
    307 		if (!(sc->sc_stat1 & SR1_BOT)) {
    308 			if (sc->sc_density != req_den) {
    309 				uprintf("%s: can't change density mid-tape\n",
    310 				    sc->sc_hd->hp_xname);
    311 				error = EIO;
    312 				goto errout;
    313 			}
    314 		}
    315 		else {
    316 			int mtset_density =
    317 			    (req_den == T_800BPI  ? MTSET800BPI : (
    318 			     req_den == T_1600BPI ? MTSET1600BPI : (
    319 			     req_den == T_6250BPI ? MTSET6250BPI : (
    320 			     sc->sc_type == MT7980ID
    321 						  ? MTSET6250DC
    322 						  : MTSET6250BPI))));
    323 			if (mtcommand(dev, mtset_density, 0) == 0)
    324 				sc->sc_density = req_den;
    325 		}
    326 	}
    327 	return (0);
    328 errout:
    329 	sc->sc_flags &= ~MTF_OPEN;
    330 	return (error);
    331 }
    332 
    333 mtclose(dev, flag)
    334 	dev_t dev;
    335 	int flag;
    336 {
    337 	register struct mt_softc *sc = &mt_softc[UNIT(dev)];
    338 
    339 	if (sc->sc_flags & MTF_WRT) {
    340 		(void) mtcommand(dev, MTWEOF, 2);
    341 		(void) mtcommand(dev, MTBSF, 0);
    342 	}
    343 	if ((minor(dev) & T_NOREWIND) == 0)
    344 		(void) mtcommand(dev, MTREW, 0);
    345 	sc->sc_flags &= ~MTF_OPEN;
    346 	tprintf_close(sc->sc_ttyp);
    347 	return (0);
    348 }
    349 
    350 mtcommand(dev, cmd, cnt)
    351 	dev_t dev;
    352 	int cmd;
    353 	int cnt;
    354 {
    355 	register struct buf *bp = &mtbuf[UNIT(dev)];
    356 	int error = 0;
    357 
    358 #if 1
    359 	if (bp->b_flags & B_BUSY)
    360 		return (EBUSY);
    361 #endif
    362 	bp->b_cmd = cmd;
    363 	bp->b_dev = dev;
    364 	do {
    365 		bp->b_flags = B_BUSY | B_CMD;
    366 		mtstrategy(bp);
    367 		iowait(bp);
    368 		if (bp->b_flags & B_ERROR) {
    369 			error = (int) (unsigned) bp->b_error;
    370 			break;
    371 		}
    372 	} while (--cnt > 0);
    373 #if 0
    374 	bp->b_flags = 0 /*&= ~B_BUSY*/;
    375 #else
    376 	bp->b_flags &= ~B_BUSY;
    377 #endif
    378 	return (error);
    379 }
    380 
    381 /*
    382  * Only thing to check here is for legal record lengths (writes only).
    383  */
    384 void
    385 mtstrategy(bp)
    386 	register struct buf *bp;
    387 {
    388 	register struct mt_softc *sc;
    389 	register struct buf *dp;
    390 	register int unit;
    391 	register int s;
    392 
    393 	unit = UNIT(bp->b_dev);
    394 	sc = &mt_softc[unit];
    395 	dlog(LOG_DEBUG, "mt%d strategy\n", unit);
    396 	if ((bp->b_flags & (B_CMD | B_READ)) == 0) {
    397 #define WRITE_BITS_IGNORED	8
    398 #if 0
    399 		if (bp->b_bcount & ((1 << WRITE_BITS_IGNORED) - 1)) {
    400 			tprintf(sc->sc_ttyp,
    401 				"%s: write record must be multiple of %d\n",
    402 				sc->sc_hd->hp_xname, 1 << WRITE_BITS_IGNORED);
    403 			goto error;
    404 		}
    405 #endif
    406 		s = 16 * 1024;
    407 		if (sc->sc_stat2 & SR2_LONGREC) {
    408 			switch (sc->sc_density) {
    409 			    case T_1600BPI:
    410 				s = 32 * 1024;
    411 				break;
    412 
    413 			    case T_6250BPI:
    414 			    case T_BADBPI:
    415 				s = 60 * 1024;
    416 				break;
    417 			}
    418 		}
    419 		if (bp->b_bcount > s) {
    420 			tprintf(sc->sc_ttyp,
    421 				"%s: write record (%d) too big: limit (%d)\n",
    422 				sc->sc_hd->hp_xname, bp->b_bcount, s);
    423 	    error:
    424 			bp->b_flags |= B_ERROR;
    425 			bp->b_error = EIO;
    426 			iodone(bp);
    427 			return;
    428 		}
    429 	}
    430 	dp = &mttab[unit];
    431 	bp->b_actf = NULL;
    432 	s = splbio();
    433 	bp->b_actb = dp->b_actb;
    434 	*dp->b_actb = bp;
    435 	dp->b_actb = &bp->b_actf;
    436 	if (dp->b_active == 0) {
    437 		dp->b_active = 1;
    438 		mtustart(unit);
    439 	}
    440 	splx(s);
    441 }
    442 
    443 void
    444 mtustart(unit)
    445 	register int unit;
    446 {
    447 
    448 	dlog(LOG_DEBUG, "mt%d ustart\n", unit);
    449 	if (hpibreq(&(mt_softc[unit].sc_dq)))
    450 		mtstart(unit);
    451 }
    452 
    453 #define hpibppclear(unit) \
    454         { hpib_softc[unit].sc_flags &= ~HPIBF_PPOLL; }
    455 
    456 void
    457 spl_mtintr(arg)
    458 	void *arg;
    459 {
    460 	struct mt_softc *sc = arg;
    461 	int s = splbio();
    462 
    463 	hpibppclear(sc->sc_hpibno);
    464 	mtintr(sc);
    465 	(void) splx(s);
    466 }
    467 
    468 void
    469 spl_mtstart(unit)
    470 	int unit;
    471 {
    472 	int s = splbio();
    473 
    474 	mtstart(unit);
    475 	(void) splx(s);
    476 }
    477 
    478 void
    479 mtstart(unit)
    480 	register int unit;
    481 {
    482 	register struct mt_softc *sc = &mt_softc[unit];
    483 	register struct buf *bp, *dp;
    484 	short	cmdcount = 1;
    485 	u_char	cmdbuf[2];
    486 
    487 	dlog(LOG_DEBUG, "mt%d start\n", unit);
    488 	sc->sc_flags &= ~MTF_WRT;
    489 	bp = mttab[unit].b_actf;
    490 	if ((sc->sc_flags & MTF_ALIVE) == 0 &&
    491 	    ((bp->b_flags & B_CMD) == 0 || bp->b_cmd != MTRESET))
    492 		goto fatalerror;
    493 
    494 	if (sc->sc_flags & MTF_REW) {
    495 		if (!hpibpptest(sc->sc_hpibno, sc->sc_slave))
    496 			goto stillrew;
    497 		switch (mtreaddsj(unit, MTE_DSJ_FORCE|MTE_COMPLETE|MTE_IDLE)) {
    498 		    case 0:
    499 		    case 1:
    500 		stillrew:
    501 			if ((sc->sc_stat1 & SR1_BOT) ||
    502 			    !(sc->sc_stat1 & SR1_ONLINE)) {
    503 				sc->sc_flags &= ~MTF_REW;
    504 				break;
    505 			}
    506 		    case -2:
    507 			/*
    508 			 * -2 means "timeout" reading DSJ, which is probably
    509 			 * temporary.  This is considered OK when doing a NOP,
    510 			 * but not otherwise.
    511 			 */
    512 			if (sc->sc_flags & (MTF_DSJTIMEO | MTF_STATTIMEO)) {
    513 				timeout(spl_mtstart, (void *)unit, hz >> 5);
    514 				return;
    515 			}
    516 		    case 2:
    517 			if (bp->b_cmd != MTNOP || !(bp->b_flags & B_CMD)) {
    518 				bp->b_error = EBUSY;
    519 				goto errdone;
    520 			}
    521 			goto done;
    522 
    523 		    default:
    524 			goto fatalerror;
    525 		}
    526 	}
    527 	if (bp->b_flags & B_CMD) {
    528 		if (sc->sc_flags & MTF_PASTEOT) {
    529 			switch(bp->b_cmd) {
    530 			    case MTFSF:
    531 			    case MTWEOF:
    532 			    case MTFSR:
    533 				bp->b_error = ENOSPC;
    534 				goto errdone;
    535 
    536 			    case MTBSF:
    537 			    case MTOFFL:
    538 			    case MTBSR:
    539 			    case MTREW:
    540 				sc->sc_flags &= ~(MTF_PASTEOT | MTF_ATEOT);
    541 				break;
    542 			}
    543 		}
    544 		switch(bp->b_cmd) {
    545 		    case MTFSF:
    546 			if (sc->sc_flags & MTF_HITEOF)
    547 				goto done;
    548 			cmdbuf[0] = MTTC_FSF;
    549 			break;
    550 
    551 		    case MTBSF:
    552 			if (sc->sc_flags & MTF_HITBOF)
    553 				goto done;
    554 			cmdbuf[0] = MTTC_BSF;
    555 			break;
    556 
    557 		    case MTOFFL:
    558 			sc->sc_flags |= MTF_REW;
    559 			cmdbuf[0] = MTTC_REWOFF;
    560 			break;
    561 
    562 		    case MTWEOF:
    563 			cmdbuf[0] = MTTC_WFM;
    564 			break;
    565 
    566 		    case MTBSR:
    567 			cmdbuf[0] = MTTC_BSR;
    568 			break;
    569 
    570 		    case MTFSR:
    571 			cmdbuf[0] = MTTC_FSR;
    572 			break;
    573 
    574 		    case MTREW:
    575 			sc->sc_flags |= MTF_REW;
    576 			cmdbuf[0] = MTTC_REW;
    577 			break;
    578 
    579 		    case MTNOP:
    580 			/*
    581 			 * NOP is supposed to set status bits.
    582 			 * Force readdsj to do it.
    583 			 */
    584 			switch (mtreaddsj(unit,
    585 				    MTE_DSJ_FORCE | MTE_COMPLETE | MTE_IDLE)) {
    586 			    default:
    587 				goto done;
    588 
    589 			    case -1:
    590 				/*
    591 				 * If this fails, perform a device clear
    592 				 * to fix any protocol problems and (most
    593 				 * likely) get the status.
    594 				 */
    595 				bp->b_cmd = MTRESET;
    596 				break;
    597 
    598 			    case -2:
    599 				timeout(spl_mtstart, (void *)unit, hz >> 5);
    600 				return;
    601 			}
    602 
    603 		    case MTRESET:
    604 			/*
    605 			 * 1) selected device clear (send with "-2" secondary)
    606 			 * 2) set timeout, then wait for "service request"
    607 			 * 3) interrupt will read DSJ (and END COMPLETE-IDLE)
    608 			 */
    609 			if (hpibsend(sc->sc_hpibno, sc->sc_slave, -2, NULL, 0)){
    610 				log(LOG_ERR, "mt%d can't reset\n", unit);
    611 				goto fatalerror;
    612 			}
    613 			timeout(spl_mtintr, (void *)sc, 4 * hz);
    614 			hpibawait(sc->sc_hpibno, sc->sc_slave);
    615 			return;
    616 
    617 		    case MTSET800BPI:
    618 			cmdbuf[0] = MTTC_800;
    619 			break;
    620 
    621 		    case MTSET1600BPI:
    622 			cmdbuf[0] = MTTC_1600;
    623 			break;
    624 
    625 		    case MTSET6250BPI:
    626 			cmdbuf[0] = MTTC_6250;
    627 			break;
    628 
    629 		    case MTSET6250DC:
    630 			cmdbuf[0] = MTTC_DC6250;
    631 			break;
    632 		}
    633 	} else {
    634 		if (sc->sc_flags & MTF_PASTEOT) {
    635 			bp->b_error = ENOSPC;
    636 			goto errdone;
    637 		}
    638 		if (bp->b_flags & B_READ) {
    639 			sc->sc_flags |= MTF_IO;
    640 			cmdbuf[0] = MTTC_READ;
    641 		} else {
    642 			sc->sc_flags |= MTF_WRT | MTF_IO;
    643 			cmdbuf[0] = MTTC_WRITE;
    644 			cmdbuf[1] = (bp->b_bcount + ((1 << WRITE_BITS_IGNORED) - 1)) >> WRITE_BITS_IGNORED;
    645 			cmdcount = 2;
    646 		}
    647 	}
    648 	if (hpibsend(sc->sc_hpibno, sc->sc_slave, MTL_TCMD, cmdbuf, cmdcount)
    649 	    == cmdcount) {
    650 		if (sc->sc_flags & MTF_REW)
    651 			goto done;
    652 		hpibawait(sc->sc_hpibno);
    653 		return;
    654 	}
    655 fatalerror:
    656 	/*
    657 	 * If anything fails, the drive is probably hosed, so mark it not
    658 	 * "ALIVE" (but it EXISTS and is OPEN or we wouldn't be here, and
    659 	 * if, last we heard, it was REWinding, remember that).
    660 	 */
    661 	sc->sc_flags &= MTF_EXISTS | MTF_OPEN | MTF_REW;
    662 	bp->b_error = EIO;
    663 errdone:
    664 	bp->b_flags |= B_ERROR;
    665 done:
    666 	sc->sc_flags &= ~(MTF_HITEOF | MTF_HITBOF);
    667 	iodone(bp);
    668 	if (dp = bp->b_actf)
    669 		dp->b_actb = bp->b_actb;
    670 	else
    671 		mttab[unit].b_actb = bp->b_actb;
    672 	*bp->b_actb = dp;
    673 	hpibfree(&(sc->sc_dq));
    674 	if ((bp = dp) == NULL)
    675 		mttab[unit].b_active = 0;
    676 	else
    677 		mtustart(unit);
    678 }
    679 
    680 /*
    681  * The Utah code had a bug which meant that the driver was unable to read.
    682  * "rw" was initialized to bp->b_flags & B_READ before "bp" was initialized.
    683  *   -- ajv (at) comp.vuw.ac.nz
    684  */
    685 void
    686 mtgo(unit)
    687 	register int unit;
    688 {
    689 	register struct mt_softc *sc = &mt_softc[unit];
    690 	register struct buf *bp;
    691 	int rw;
    692 
    693 	dlog(LOG_DEBUG, "mt%d go\n", unit);
    694 	bp = mttab[unit].b_actf;
    695 	rw = bp->b_flags & B_READ;
    696 	hpibgo(sc->sc_hpibno, sc->sc_slave, rw ? MTT_READ : MTL_WRITE,
    697 	       bp->b_un.b_addr, bp->b_bcount, rw, rw != 0);
    698 }
    699 
    700 int
    701 mtintr(arg)
    702 	void *arg;
    703 {
    704 	register struct mt_softc *sc = arg;
    705 	register struct buf *bp, *dp;
    706 	register int i;
    707 	int unit = sc->sc_hd->hp_unit;
    708 	u_char	cmdbuf[4];
    709 
    710 	bp = mttab[unit].b_actf;
    711 	if (bp == NULL) {
    712 		log(LOG_ERR, "mt%d intr: bp == NULL\n", unit);
    713 		return;
    714 	}
    715 	dlog(LOG_DEBUG, "mt%d intr\n", unit);
    716 	/*
    717 	 * Some operation completed.  Read status bytes and report errors.
    718 	 * Clear EOF flags here `cause they're set once on specific conditions
    719 	 * below when a command succeeds.
    720 	 * A DSJ of 2 always means keep waiting.  If the command was READ
    721 	 * (and we're in data DMA phase) stop data transfer first.
    722 	 */
    723 	sc->sc_flags &= ~(MTF_HITEOF | MTF_HITBOF);
    724 	if ((bp->b_flags & (B_CMD|B_READ)) == B_READ &&
    725 	    !(sc->sc_flags & (MTF_IO | MTF_STATTIMEO | MTF_DSJTIMEO))){
    726 		cmdbuf[0] = MTE_STOP;
    727 		(void) hpibsend(sc->sc_hpibno, sc->sc_slave, MTL_ECMD,cmdbuf,1);
    728 	}
    729 	switch (mtreaddsj(unit, 0)) {
    730 	    case 0:
    731 		break;
    732 
    733 	    case 1:
    734 		/*
    735 		 * If we're in the middle of a READ/WRITE and have yet to
    736 		 * start the data transfer, a DSJ of one should terminate it.
    737 		 */
    738 		sc->sc_flags &= ~MTF_IO;
    739 		break;
    740 
    741 	    case 2:
    742 		(void) hpibawait(sc->sc_hpibno);
    743 		return;
    744 
    745 	    case -2:
    746 		/*
    747 		 * -2 means that the drive failed to respond quickly enough
    748 		 * to the request for DSJ.  It's probably just "busy" figuring
    749 		 * it out and will know in a little bit...
    750 		 */
    751 		timeout(spl_mtintr, (void *)sc, hz >> 5);
    752 		return;
    753 
    754 	    default:
    755 		log(LOG_ERR, "mt%d intr: can't get drive stat\n", unit);
    756 		goto error;
    757 	}
    758 	if (sc->sc_stat1 & (SR1_ERR | SR1_REJECT)) {
    759 		i = sc->sc_stat4 & SR4_ERCLMASK;
    760 		log(LOG_ERR, "%s: %s error, retry %d, SR2/3 %x/%x, code %d\n",
    761 			sc->sc_hd->hp_xname, i == SR4_DEVICE ? "device" :
    762 			(i == SR4_PROTOCOL ? "protocol" :
    763 			(i == SR4_SELFTEST ? "selftest" : "unknown")),
    764 			sc->sc_stat4 & SR4_RETRYMASK, sc->sc_stat2,
    765 			sc->sc_stat3, sc->sc_stat5);
    766 
    767 		if ((bp->b_flags & B_CMD) && bp->b_cmd == MTRESET)
    768 			untimeout(spl_mtintr, (void *)sc);
    769 		if (sc->sc_stat3 & SR3_POWERUP)
    770 			sc->sc_flags &= MTF_OPEN | MTF_EXISTS;
    771 		goto error;
    772 	}
    773 	/*
    774 	 * Report and clear any soft errors.
    775 	 */
    776 	if (sc->sc_stat1 & SR1_SOFTERR) {
    777 		log(LOG_WARNING, "%s: soft error, retry %d\n",
    778 			sc->sc_hd->hp_xname, sc->sc_stat4 & SR4_RETRYMASK);
    779 		sc->sc_stat1 &= ~SR1_SOFTERR;
    780 	}
    781 	/*
    782 	 * We've initiated a read or write, but haven't actually started to
    783 	 * DMA the data yet.  At this point, the drive's ready.
    784 	 */
    785 	if (sc->sc_flags & MTF_IO) {
    786 		sc->sc_flags &= ~MTF_IO;
    787 		if (hpibustart(sc->sc_hpibno))
    788 			mtgo(unit);
    789 		return;
    790 	}
    791 	/*
    792 	 * Check for End Of Tape - we're allowed to hit EOT and then write (or
    793 	 * read) one more record.  If we get here and have not already hit EOT,
    794 	 * return ENOSPC to inform the process that it's hit it.  If we get
    795 	 * here and HAVE already hit EOT, don't allow any more operations that
    796 	 * move the tape forward.
    797 	 */
    798 	if (sc->sc_stat1 & SR1_EOT) {
    799 		if (sc->sc_flags & MTF_ATEOT)
    800 			sc->sc_flags |= MTF_PASTEOT;
    801 		else {
    802 			bp->b_flags |= B_ERROR;
    803 			bp->b_error = ENOSPC;
    804 			sc->sc_flags |= MTF_ATEOT;
    805 		}
    806 	}
    807 	/*
    808 	 * If a motion command was being executed, check for Tape Marks.
    809 	 * If we were doing data, make sure we got the right amount, and
    810 	 * check for hitting tape marks on reads.
    811 	 */
    812 	if (bp->b_flags & B_CMD) {
    813 		if (sc->sc_stat1 & SR1_EOF) {
    814 			if (bp->b_cmd == MTFSR)
    815 				sc->sc_flags |= MTF_HITEOF;
    816 			if (bp->b_cmd == MTBSR)
    817 				sc->sc_flags |= MTF_HITBOF;
    818 		}
    819 		if (bp->b_cmd == MTRESET) {
    820 			untimeout(spl_mtintr, (void *)sc);
    821 			sc->sc_flags |= MTF_ALIVE;
    822 		}
    823 	} else {
    824 		i = hpibrecv(sc->sc_hpibno, sc->sc_slave, MTT_BCNT, cmdbuf, 2);
    825 		if (i != 2) {
    826 			log(LOG_ERR, "mt%d intr: can't get xfer length\n");
    827 			goto error;
    828 		}
    829 		i = (int) *((u_short *) cmdbuf);
    830 		if (i <= bp->b_bcount) {
    831 			if (i == 0)
    832 				sc->sc_flags |= MTF_HITEOF;
    833 			bp->b_resid = bp->b_bcount - i;
    834 			dlog(LOG_DEBUG, "mt%d intr: bcount %d, resid %d\n",
    835 				unit, bp->b_bcount, bp->b_resid);
    836 		} else {
    837 			tprintf(sc->sc_ttyp,
    838 				"%s: record (%d) larger than wanted (%d)\n",
    839 				sc->sc_hd->hp_xname, i, bp->b_bcount);
    840     error:
    841 			sc->sc_flags &= ~MTF_IO;
    842 			bp->b_error = EIO;
    843 			bp->b_flags |= B_ERROR;
    844 		}
    845 	}
    846 	/*
    847 	 * The operation is completely done.
    848 	 * Let the drive know with an END command.
    849 	 */
    850 	cmdbuf[0] = MTE_COMPLETE | MTE_IDLE;
    851 	(void) hpibsend(sc->sc_hpibno, sc->sc_slave, MTL_ECMD, cmdbuf, 1);
    852 	bp->b_flags &= ~B_CMD;
    853 	iodone(bp);
    854 	if (dp = bp->b_actf)
    855 		dp->b_actb = bp->b_actb;
    856 	else
    857 		mttab[unit].b_actb = bp->b_actb;
    858 	*bp->b_actb = dp;
    859 	hpibfree(&(sc->sc_dq));
    860 #if 0
    861 	if (bp /*mttab[unit].b_actf*/ == NULL)
    862 #else
    863 	if (mttab[unit].b_actf == NULL)
    864 #endif
    865 		mttab[unit].b_active = 0;
    866 	else
    867 		mtustart(unit);
    868 }
    869 
    870 mtread(dev, uio)
    871 	dev_t dev;
    872 	struct uio *uio;
    873 {
    874 	return(physio(mtstrategy, &mtbuf[UNIT(dev)], dev, B_READ, minphys, uio));
    875 }
    876 
    877 mtwrite(dev, uio)
    878 	dev_t dev;
    879 	struct uio *uio;
    880 {
    881 	return(physio(mtstrategy, &mtbuf[UNIT(dev)], dev, B_WRITE, minphys, uio));
    882 }
    883 
    884 mtioctl(dev, cmd, data, flag)
    885 	dev_t dev;
    886 	u_long cmd;
    887 	caddr_t data;
    888 	int flag;
    889 {
    890 	register struct mtop *op;
    891 	int cnt;
    892 
    893 	switch (cmd) {
    894 	    case MTIOCTOP:
    895 		op = (struct mtop *)data;
    896 		switch(op->mt_op) {
    897 		    case MTWEOF:
    898 		    case MTFSF:
    899 		    case MTBSR:
    900 		    case MTBSF:
    901 		    case MTFSR:
    902 			cnt = op->mt_count;
    903 			break;
    904 
    905 		    case MTOFFL:
    906 		    case MTREW:
    907 		    case MTNOP:
    908 			cnt = 0;
    909 			break;
    910 
    911 		    default:
    912 			return (EINVAL);
    913 		}
    914 		return (mtcommand(dev, op->mt_op, cnt));
    915 
    916 	    case MTIOCGET:
    917 		break;
    918 
    919 	    default:
    920 		return (EINVAL);
    921 	}
    922 	return (0);
    923 }
    924 
    925 /*ARGSUSED*/
    926 mtdump(dev)
    927 	dev_t dev;
    928 {
    929 	return(ENXIO);
    930 }
    931 
    932 #endif /* NMT > 0 */
    933