tahoe/vba/cy.c

/*	cy.c	1.6	86/01/27	*/

#include "yc.h"
#if NCY > 0
/*
 * Cipher Tapemaster driver.
 */
int	cydebug = 0;
#define	dlog	if (cydebug) log

#include "../tahoe/mtpr.h"
#include "../tahoe/pte.h"

#include "param.h"
#include "systm.h"
#include "vm.h"
#include "buf.h"
#include "file.h"
#include "dir.h"
#include "user.h"
#include "proc.h"
#include "signal.h"
#include "uio.h"
#include "ioctl.h"
#include "mtio.h"
#include "errno.h"
#include "cmap.h"
#include "kernel.h"
#include "syslog.h"

#include "../tahoevba/vbavar.h"
#define	CYERROR
#include "../tahoevba/cyreg.h"

/*
 * There is a ccybuf per tape controller.
 * It is used as the token to pass to the internal routines
 * to execute tape ioctls, and also acts as a lock on the slaves
 * on the controller, since there is only one per controller.
 * In particular, when the tape is rewinding on close we release
 * the user process but any further attempts to use the tape drive
 * before the rewind completes will hang waiting for ccybuf.
 */
struct	buf ccybuf[NCY];

/*
 * Raw tape operations use rcybuf.  The driver notices when
 * rcybuf is being used and allows the user program to contine
 * after errors and read records not of the standard length.
 */
struct	buf rcybuf[NCY];

int	cyprobe(), cyslave(), cyattach();
struct	buf ycutab[NYC];
short	yctocy[NYC];
struct	vba_ctlr *cyminfo[NCY];
struct	vba_device *ycdinfo[NYC];
long	cystd[] = { 0 };
struct	vba_driver cydriver =
   { cyprobe, cyslave, cyattach, 0, cystd, "yc", ycdinfo, "cy", cyminfo };

/* bits in minor device */
#define	YCUNIT(dev)	(minor(dev)&03)
#define	CYUNIT(dev)	(yctocy[YCUNIT(dev)])
#define	T_NOREWIND	0x04
#define	T_1600BPI	0x08
#define	T_3200BPI	0x10

#define	INF	1000000L		/* close to infinity */
#define	CYMAXIO	(32*NBPG)		/* max i/o size */

/*
 * Software state and shared command areas per controller.
 *
 * The i/o buffer must be defined statically to insure
 * it's address will fit in 20-bits (YECH!!!!!!!!!!!!!!)
 */
struct cy_softc {
	struct	pte *cy_map;	/* pte's for mapped buffer i/o */
	caddr_t	cy_utl;		/* mapped virtual address */
	int	cy_bs;		/* controller's buffer size */
	char	cy_buf[CYMAXIO];/* intermediate buffer */
	struct	cyscp *cy_scp;	/* system configuration block address */
	struct	cyccb cy_ccb;	/* channel control block */
	struct	cyscb cy_scb;	/* system configuration block */
	struct	cytpb cy_tpb;	/* tape parameter block */
	struct	cytpb cy_nop;	/* nop parameter block for cyintr */
} cy_softc[NCY];

/*
 * Software state per tape transport.
 */
struct	yc_softc {
	char	yc_openf;	/* lock against multiple opens */
	char	yc_lastiow;	/* last operation was a write */
	short	yc_tact;	/* timeout is active */
	long	yc_timo;	/* time until timeout expires */
	u_short	yc_control;	/* copy of last tpcb.tpcontrol */
	u_short	yc_status;	/* copy of last tpcb.tpstatus */
	u_short	yc_resid;	/* copy of last bc */
	u_short	yc_dens;	/* prototype control word with density info */
	struct	tty *yc_ttyp;	/* user's tty for errors */
	daddr_t	yc_blkno;	/* block number, for block device tape */
	daddr_t	yc_nxrec;	/* position of end of tape, if known */
} yc_softc[NYC];

/*
 * States for vm->um_tab.b_active, the per controller state flag.
 * This is used to sequence control in the driver.
 */
#define	SSEEK	1		/* seeking */
#define	SIO	2		/* doing seq i/o */
#define	SCOM	3		/* sending control command */
#define	SREW	4		/* sending a rewind */
#define	SERASE	5		/* erase inter-record gap */
#define	SERASED	6		/* erased inter-record gap */

/* there's no way to figure these out dynamically? -- yech */
struct	cyscp *cyscp[] =
    { (struct cyscp *)0xc0000c06, (struct cyscp *)0xc0000c16 };
#define	NCYSCP	(sizeof (cyscp) / sizeof (cyscp[0]))

cyprobe(reg, vm)
	caddr_t reg;
	struct vba_ctlr *vm;
{
	register br, cvec;			/* must be r12, r11 */
	struct cy_softc *cy;

	if (badcyaddr(reg+1))
		return (0);
	if (vm->um_ctlr > NCYSCP || cyscp[vm->um_ctlr] == 0)	/* XXX */
		return (0);					/* XXX */
	cy_softc[vm->um_ctlr].cy_scp = cyscp[vm->um_ctlr];	/* XXX */
	/*
	 * Tapemaster controller must have interrupt handler
	 * disable interrupt, so we'll just kludge things
	 * (stupid multibus non-vectored interrupt crud).
	 */
	br = 0x13, cvec = 0x80;					/* XXX */
	return (sizeof (struct cyccb));
}

/*
 * Check to see if a drive is attached to a controller.
 * Since we can only tell that a drive is there if a tape is loaded and
 * the drive is placed online, we always indicate the slave is present.
 */
cyslave(vi, addr)
	struct vba_device *vi;
	caddr_t addr;
{

#ifdef lint
	vi = vi; addr = addr;
#endif
	return (1);
}

cyattach(vi)
	struct vba_device *vi;
{
	register struct cy_softc *cy;
	int ctlr = vi->ui_mi->um_ctlr;

	yctocy[vi->ui_unit] = ctlr;
	cy = &cy_softc[ctlr];
	if (cy->cy_bs == 0 && cyinit(ctlr)) {
		uncache(&cy->cy_tpb.tpcount);
		cy->cy_bs = htoms(cy->cy_tpb.tpcount);
		printf("cy%d: %dkb buffer\n", ctlr, cy->cy_bs/1024);
		/*
		 * Setup nop parameter block for clearing interrupts.
		 */
		cy->cy_nop.tpcmd = CY_NOP;
		cy->cy_nop.tpcontrol = 0;
		/*
		 * Allocate page tables.
		 */
		vbmapalloc(btoc(CYMAXIO)+1, &cy->cy_map, &cy->cy_utl);
	}
}

/*
 * Initialize the controller after a controller reset or
 * during autoconfigure.  All of the system control blocks
 * are initialized and the controller is asked to configure
 * itself for later use.
 */
cyinit(ctlr)
	int ctlr;
{
	register struct cy_softc *cy = &cy_softc[ctlr];
	register caddr_t addr = cyminfo[ctlr]->um_addr;
	register int *pte;

	/*
	 * Initialize the system configuration pointer.
	 */
	/* make kernel writable */
	pte = (int *)vtopte((struct proc *)0, btop(cy->cy_scp));
	*pte &= ~PG_PROT; *pte |= PG_KW;
	mtpr(TBIS, cy->cy_scp);
	/* load the correct values in the scp */
	cy->cy_scp->csp_buswidth = CSP_16BITS;
	cyldmba(cy->cy_scp->csp_scb, (caddr_t)&cy->cy_scb);
	/* put it back to read-only */
	*pte &= ~PG_PROT; *pte |= PG_KR;
	mtpr(TBIS, cy->cy_scp);

	/*
	 * Init system configuration block.
	 */
	cy->cy_scb.csb_fixed = 0x3;
	/* set pointer to the channel control block */
	cyldmba(cy->cy_scb.csb_ccb, (caddr_t)&cy->cy_ccb);

	/*
	 * Initialize the chanel control block.
	 */
	cy->cy_ccb.cbcw = CBCW_CLRINT;
	cy->cy_ccb.cbgate = GATE_OPEN;
	/* set pointer to the tape parameter block */
	cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb);

	/*
	 * Issue a nop cmd and get the internal buffer size for buffered i/o.
	 */
	cy->cy_tpb.tpcmd = CY_NOP;
	cy->cy_tpb.tpcontrol = CYCW_16BITS;
	cy->cy_ccb.cbgate = GATE_CLOSED;
	CY_GO(addr);
	if (cywait(&cy->cy_ccb) || (cy->cy_tpb.tpstatus&CYS_ERR)) {
		uncache(&cy->cy_tpb.tpstatus);
		printf("cy%d: timeout or err during init, status=%b\n", ctlr,
		    cy->cy_tpb.tpstatus, CYS_BITS);
		return (0);
	}
	cy->cy_tpb.tpcmd = CY_CONFIG;
	cy->cy_tpb.tpcontrol = CYCW_16BITS;
	cy->cy_ccb.cbgate = GATE_CLOSED;
	CY_GO(addr);
	if (cywait(&cy->cy_ccb) || (cy->cy_tpb.tpstatus&CYS_ERR)) {
		uncache(&cy->cy_tpb.tpstatus);
		printf("cy%d: configuration failure, status=%b\n", ctlr,
		    cy->cy_tpb.tpstatus, CYS_BITS);
		return (0);
	}
	return (1);
}

int	cytimer();
/*
 * Open the device.  Tapes are unique open
 * devices, so we refuse if it is already open.
 * We also check that a tape is available, and
 * don't block waiting here; if you want to wait
 * for a tape you should timeout in user code.
 */
cyopen(dev, flag)
	dev_t dev;
	register int flag;
{
	register int ycunit;
	register struct vba_device *vi;
	register struct yc_softc *yc;
	int s;

	ycunit = YCUNIT(dev);
	if (ycunit >= NYC || (vi = ycdinfo[ycunit]) == 0 || vi->ui_alive == 0)
		return (ENXIO);
	if ((yc = &yc_softc[ycunit])->yc_openf)
		return (EBUSY);
#define	PACKUNIT(vi) \
    (((vi->ui_slave&1)<<11)|((vi->ui_slave&2)<<9)|((vi->ui_slave&4)>>2))
	/* no way to select density */
	yc->yc_dens = PACKUNIT(vi)|CYCW_IE|CYCW_16BITS;
	cycommand(dev, CY_SENSE, 1);
	if ((yc->yc_status&CYS_OL) == 0) {	/* not on-line */
		uprintf("yc%d: not online\n", ycunit);
		return (ENXIO);
	}
	if ((flag&FWRITE) && (yc->yc_status&CYS_WP)) {
		uprintf("yc%d: no write ring\n", ycunit);
		return (ENXIO);
	}
	yc->yc_openf = 1;
	yc->yc_blkno = (daddr_t)0;
	yc->yc_nxrec = INF;
	yc->yc_lastiow = 0;
	yc->yc_ttyp = u.u_ttyp;
	s = splclock();
	if (yc->yc_tact == 0) {
		yc->yc_timo = INF;
		yc->yc_tact = 1;
		timeout(cytimer, (caddr_t)dev, 5*hz);
	}
	splx(s);
	return (0);
}

/*
 * Close tape device.
 *
 * If tape was open for writing or last operation was a write,
 * then write two EOF's and backspace over the last one.
 * Unless this is a non-rewinding special file, rewind the tape.
 * Make the tape available to others.
 */
cyclose(dev, flag)
	dev_t dev;
	register int flag;
{
	register struct yc_softc *yc = &yc_softc[YCUNIT(dev)];

	if (flag == FWRITE || (flag&FWRITE) && yc->yc_lastiow) {
		cycommand(dev, CY_WEOF, 2);
		cycommand(dev, CY_SREV, 1);
	}
	if ((minor(dev)&T_NOREWIND) == 0)
		/*
		 * 0 count means don't hang waiting for rewind complete
		 * rather ccybuf stays busy until the operation completes
		 * preventing further opens from completing by preventing
		 * a CY_SENSE from completing.
		 */
		cycommand(dev, CY_REW, 0);
	yc->yc_openf = 0;
}

/*
 * Execute a command on the tape drive a specified number of times.
 */
cycommand(dev, com, count)
	dev_t dev;
	int com, count;
{
	register int unit = CYUNIT(dev);
	register struct buf *bp;
	int s;

	bp = &ccybuf[CYUNIT(dev)];
	s = spl3();
	dlog(LOG_INFO, "cycommand(%o, %x, %d), b_flags %x\n",
	    dev, com, count, bp->b_flags);
	while (bp->b_flags&B_BUSY) {
		/*
		 * This special check is because B_BUSY never
		 * gets cleared in the non-waiting rewind case.
		 */
		if (bp->b_repcnt == 0 && (bp->b_flags&B_DONE))
			break;
		bp->b_flags |= B_WANTED;
		sleep((caddr_t)bp, PRIBIO);
	}
	bp->b_flags = B_BUSY|B_READ;
	splx(s);
	bp->b_dev = dev;
	bp->b_repcnt = count;
	bp->b_command = com;
	bp->b_blkno = 0;
	cystrategy(bp);
	/*
	 * In case of rewind from close; don't wait.
	 * This is the only case where count can be 0.
	 */
	if (count == 0)
		return;
	iowait(bp);
	if (bp->b_flags&B_WANTED)
		wakeup((caddr_t)bp);
	bp->b_flags &= B_ERROR;
}

cystrategy(bp)
	register struct buf *bp;
{
	int ycunit = YCUNIT(bp->b_dev);
	register struct vba_ctlr *vm;
	register struct buf *dp;
	int s;

	/*
	 * Put transfer at end of unit queue.
	 */
	dlog(LOG_INFO, "cystrategy(%o, %x)\n", bp->b_dev, bp->b_command);
	dp = &ycutab[ycunit];
	bp->av_forw = NULL;
	vm = ycdinfo[ycunit]->ui_mi;
	/* BEGIN GROT */
	if (bp == &rcybuf[CYUNIT(bp->b_dev)]) {
		if (bp->b_bcount > CYMAXIO) {
			uprintf("cy%d: i/o size too large\n", vm->um_ctlr);
			bp->b_error = EIO;
			bp->b_resid = bp->b_bcount;
			bp->b_flags |= B_ERROR;
			iodone(bp);
			return;
		}
		vbasetup(bp, CYMAXIO);
	}
	/* END GROT */
	s = spl3();
	if (dp->b_actf == NULL) {
		dp->b_actf = bp;
		/*
		 * Transport not already active...
		 * put at end of controller queue.
		 */
		 dp->b_forw = NULL;
		 if (vm->um_tab.b_actf == NULL)
			vm->um_tab.b_actf = dp;
		else
			vm->um_tab.b_actl->b_forw = dp;
	} else
		dp->b_actl->av_forw = bp;
	dp->b_actl = bp;
	/*
	 * If the controller is not busy, get it going.
	 */
	if (vm->um_tab.b_active == 0)
		cystart(vm);
	splx(s);
}

/*
 * Start activity on a cy controller.
 */
cystart(vm)
	register struct vba_ctlr *vm;
{
	register struct buf *bp, *dp;
	register struct yc_softc *yc;
	register struct cy_softc *cy;
	register struct vba_device *vi;
	int ycunit;
	daddr_t blkno;

	dlog(LOG_INFO, "cystart()\n");
	/*
	 * Look for an idle transport on the controller.
	 */
loop:
	if ((dp = vm->um_tab.b_actf) == NULL)
		return;
	if ((bp = dp->b_actf) == NULL) {
		vm->um_tab.b_actf = dp->b_forw;
		goto loop;
	}
	ycunit = YCUNIT(bp->b_dev);
	yc = &yc_softc[ycunit];
	cy = &cy_softc[CYUNIT(bp->b_dev)];
	/*
	 * Default is that last command was NOT a write command;
	 * if we do a write command we will notice this in cyintr().
	 */
	yc->yc_lastiow = 0;
	if (yc->yc_openf < 0 ||
	    (bp->b_command != CY_SENSE && (cy->cy_tpb.tpstatus&CYS_OL) == 0)) {
		/*
		 * Have had a hard error on a non-raw tape
		 * or the tape unit is now unavailable (e.g.
		 * taken off line).
		 */
		dlog(LOG_INFO, "openf %d command %x status %b\n",
		    yc->yc_openf, bp->b_command, cy->cy_tpb.tpstatus, CYS_BITS);
		bp->b_flags |= B_ERROR;
		goto next;
	}
	if (bp == &ccybuf[CYUNIT(bp->b_dev)]) {
		/*
		 * Execute control operation with the specified count.
		 *
		 * Set next state; give 5 minutes to complete
		 * rewind or file mark search, or 10 seconds per
		 * iteration (minimum 60 seconds and max 5 minutes)
		 * to complete other ops.
		 */
		if (bp->b_command == CY_REW) {
			vm->um_tab.b_active = SREW;
			yc->yc_timo = 5*60;
		} else {
			vm->um_tab.b_active = SCOM;
			yc->yc_timo = imin(imax(10*(int)bp->b_repcnt,60),5*60);
		}
		cy->cy_tpb.tprec = htoms(bp->b_repcnt);
		goto dobpcmd;
	}
	/*
	 * The following checks handle boundary cases for operation
	 * on no-raw tapes.  On raw tapes the initialization of
	 * yc->yc_nxrec by cyphys causes them to be skipped normally
	 * (except in the case of retries).
	 */
	if (bdbtofsb(bp->b_blkno) > yc->yc_nxrec) {
		/*
		 * Can't read past known end-of-file.
		 */
		bp->b_flags |= B_ERROR;
		bp->b_error = ENXIO;
		goto next;
	}
	if (bdbtofsb(bp->b_blkno) == yc->yc_nxrec && bp->b_flags&B_READ) {
		/*
		 * Reading at end of file returns 0 bytes.
		 */
		bp->b_resid = bp->b_bcount;
		clrbuf(bp);
		goto next;
	}
	if ((bp->b_flags&B_READ) == 0)
		/*
		 * Writing sets EOF.
		 */
		yc->yc_nxrec = bdbtofsb(bp->b_blkno) + 1;
	if ((blkno = yc->yc_blkno) == bdbtofsb(bp->b_blkno)) {
		caddr_t addr;
		int cmd;

		/*
		 * Choose the appropriate i/o command based on the
		 * transfer size and the controller's internal buffer.
		 * If we're retrying a read on a raw device because
		 * the original try was a buffer request which failed
		 * due to a record length error, then we force the use
		 * of the raw controller read (YECH!!!!).
		 */
		if (bp->b_flags&B_READ) {
			if (bp->b_bcount > cy->cy_bs || bp->b_errcnt)
				cmd = CY_RCOM;
			else
				cmd = CY_BRCOM;
		} else {
			/*
			 * On write error retries erase the
			 * inter-record gap before rewriting.
			 */
			if (vm->um_tab.b_errcnt &&
			    vm->um_tab.b_active != SERASED) {
				vm->um_tab.b_active = SERASE;
				bp->b_command = CY_ERASE;
				yc->yc_timo = 60;
				goto dobpcmd;
			}
			cmd = (bp->b_bcount > cy->cy_bs) ? CY_WCOM : CY_BWCOM;
		}
		vm->um_tab.b_active = SIO;
		addr = (caddr_t)vbastart(bp, cy->cy_buf,
		    (long *)cy->cy_map, cy->cy_utl);
		cy->cy_tpb.tpcmd = cmd;
		cy->cy_tpb.tpcontrol = yc->yc_dens;
		if (cmd == CY_RCOM || cmd == CY_WCOM)
			cy->cy_tpb.tpcontrol |= CYCW_LOCK;
		cy->cy_tpb.tpstatus = 0;
		cy->cy_tpb.tpcount = 0;
		cyldmba(cy->cy_tpb.tpdata, (caddr_t)addr);
		cy->cy_tpb.tprec = 0;
		cy->cy_tpb.tpsize = htoms(bp->b_bcount);
		cyldmba(cy->cy_tpb.tplink, (caddr_t)0);
		do
			uncache(&cy->cy_ccb.cbgate);
		while (cy->cy_ccb.cbgate == GATE_CLOSED);
		cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb);
		cy->cy_ccb.cbcw = CBCW_IE;
		cy->cy_ccb.cbgate = GATE_CLOSED;
		dlog(LOG_INFO, "CY_GO(%x) cmd %x control %x size %d\n",
		    vm->um_addr, cy->cy_tpb.tpcmd, cy->cy_tpb.tpcontrol,
		    htoms(cy->cy_tpb.tpsize));
		CY_GO(vm->um_addr);
		return;
	}
	/*
	 * Tape positioned incorrectly; set to seek forwards
	 * or backwards to the correct spot.  This happens
	 * for raw tapes only on error retries.
	 */
	vm->um_tab.b_active = SSEEK;
	if (blkno < bdbtofsb(bp->b_blkno)) {
		bp->b_command = CY_SFORW;
		cy->cy_tpb.tprec = htoms(bdbtofsb(bp->b_blkno) - blkno);
	} else {
		bp->b_command = CY_SREV;
		cy->cy_tpb.tprec = htoms(blkno - bdbtofsb(bp->b_blkno));
	}
	yc->yc_timo = imin(imax(10 * htoms(cy->cy_tpb.tprec), 60), 5*60);
dobpcmd:
	/*
	 * Do the command in bp.  Reverse direction commands
	 * are indicated by having CYCW_REV or'd into their
	 * value.  For these we must set the appropriate bit
	 * in the control field.
	 */
	if (bp->b_command&CYCW_REV) {
		cy->cy_tpb.tpcmd = bp->b_command &~ CYCW_REV;
		cy->cy_tpb.tpcontrol = yc->yc_dens | CYCW_REV;
	} else {
		cy->cy_tpb.tpcmd = bp->b_command;
		cy->cy_tpb.tpcontrol = yc->yc_dens;
	}
	cy->cy_tpb.tpstatus = 0;
	cy->cy_tpb.tpcount = 0;
	cyldmba(cy->cy_tpb.tplink, (caddr_t)0);
	do
		uncache(&cy->cy_ccb.cbgate);
	while (cy->cy_ccb.cbgate == GATE_CLOSED);
	cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb);
	cy->cy_ccb.cbcw = CBCW_IE;
	cy->cy_ccb.cbgate = GATE_CLOSED;
	dlog(LOG_INFO, "CY_GO(%x) cmd %x control %x rec %d\n",
	    vm->um_addr, cy->cy_tpb.tpcmd, cy->cy_tpb.tpcontrol,
	    htoms(cy->cy_tpb.tprec));
	CY_GO(vm->um_addr);
	return;
next:
	/*
	 * Done with this operation due to error or the
	 * fact that it doesn't do anything.  Release VERSAbus
	 * resource (if any), dequeue the transfer and continue
	 * processing this slave.
	 */
	if (bp == &rcybuf[CYUNIT(bp->b_dev)])
		vbadone(bp, cy->cy_buf, (long *)cy->cy_map, cy->cy_utl);
	vm->um_tab.b_errcnt = 0;
	dp->b_actf = bp->av_forw;
	iodone(bp);
	goto loop;
}

/*
 * Cy interrupt routine.
 */
cyintr(cipher)
	int cipher;
{
	struct buf *dp;
	register struct buf *bp;
	register struct vba_ctlr *vm = cyminfo[cipher];
	register struct cy_softc *cy;
	register struct yc_softc *yc;
	int cyunit, err;
	register state;

	dlog(LOG_INFO, "cyintr(%d)\n", cipher);
	/*
	 * First, turn off the interrupt from the controller
	 * (device uses Multibus non-vectored interrupts...yech).
	 */
	cy = &cy_softc[vm->um_ctlr];
	cy->cy_ccb.cbcw = CBCW_CLRINT;
	cyldmba(cy->cy_ccb.cbtpb, &cy->cy_nop);
	cy->cy_ccb.cbgate = GATE_CLOSED;
	CY_GO(vm->um_addr);
	if ((dp = vm->um_tab.b_actf) == NULL) {
		dlog(LOG_ERR, "cy%d: stray interrupt", vm->um_ctlr);
		return;
	}
	bp = dp->b_actf;
	cyunit = CYUNIT(bp->b_dev);
	cy = &cy_softc[cyunit];
	cyuncachetpb(cy);
	/*
	 * If last command was a rewind and tape is
	 * still moving, wait for the operation to complete.
	 */
	if (vm->um_tab.b_active == SREW) {
		vm->um_tab.b_active = SCOM;
		if ((cy->cy_tpb.tpstatus&CYS_RDY) == 0) {
			yc->yc_timo = 5*60;	/* 5 minutes */
			return;
		}
	}
	/*
	 * An operation completed...record status.
	 */
	yc = &yc_softc[YCUNIT(bp->b_dev)];
	yc->yc_timo = INF;
	yc->yc_control = cy->cy_tpb.tpcontrol;
	yc->yc_status = cy->cy_tpb.tpstatus;
	yc->yc_resid = bp->b_bcount - htoms(cy->cy_tpb.tpcount);
	dlog(LOG_INFO, "cmd %x control %b status %b resid %d\n",
	    cy->cy_tpb.tpcmd, yc->yc_control, CYCW_BITS,
	    yc->yc_status, CYS_BITS, yc->yc_resid);
	if ((bp->b_flags&B_READ) == 0)
		yc->yc_lastiow = 1;
	state = vm->um_tab.b_active;
	vm->um_tab.b_active = 0;
	/*
	 * Check for errors.
	 */
	if (cy->cy_tpb.tpstatus&CYS_ERR) {
		err = cy->cy_tpb.tpstatus&CYS_ERR;
		dlog(LOG_INFO, "error %d\n", err);
		/*
		 * If we hit the end of tape file, update our position.
		 */
		if (err == CYER_FM) {
			yc->yc_status |= CYS_FM;
			state = SCOM;		/* force completion */
			cyseteof(bp);		/* set blkno and nxrec */
			goto opdone;
		}
		/*
		 * Fix up errors which occur due to backspacing over
		 * the beginning of the tape.
		 */
		if (err == CYER_BOT && cy->cy_tpb.tpcontrol&CYCW_REV) {
			yc->yc_status |= CYS_BOT;
			goto ignoreerr;
		}
		/*
		 * If we were reading raw tape and the only error was that the
		 * record was too long, then we don't consider this an error.
		 */
		if (bp == &rcybuf[cyunit] && (bp->b_flags&B_READ) &&
		    err == CYER_STROBE) {
			/*
			 * Retry reads once with the command changed to
			 * a raw read (if possible).  Setting b_errcnt
			 * here causes cystart (above) to force a CY_RCOM.
			 */
			if (bp->b_errcnt++ != 0)
				goto ignoreerr;
			yc->yc_blkno++;
			goto opcont;
		}
		/*
		 * If error is not hard, and this was an i/o operation
		 * retry up to 8 times.
		 */
		if (((1<<err)&CYER_SOFT) && state == SIO) {
			if (++vm->um_tab.b_errcnt < 7) {
				yc->yc_blkno++;
				goto opcont;
			}
		} else
			/*
			 * Hard or non-i/o errors on non-raw tape
			 * cause it to close.
			 */
			if (yc->yc_openf>0 && bp != &rcybuf[cyunit])
				yc->yc_openf = -1;
		/*
		 * Couldn't recover from error.
		 */
		tprintf(yc->yc_ttyp,
		    "yc%d: hard error bn%d status=%b", YCUNIT(bp->b_dev),
		    bp->b_blkno, yc->yc_status, CYS_BITS);
		if (err < NCYERROR)
			tprintf(yc->yc_ttyp, ", %s", cyerror[err]);
		tprintf(yc->yc_ttyp, "\n");
		bp->b_flags |= B_ERROR;
		goto opdone;
	}
	/*
	 * Advance tape control FSM.
	 */
ignoreerr:
	/*
	 * If we hit a tape mark update our position.
	 */
	if (yc->yc_status&CYS_FM && bp->b_flags&B_READ) {
		cyseteof(bp);
		goto opdone;
	}
	switch (state) {

	case SIO:
		/*
		 * Read/write increments tape block number.
		 */
		yc->yc_blkno++;
		goto opdone;

	case SCOM:
		/*
		 * For forward/backward space record update current position.
		 */
		if (bp == &ccybuf[CYUNIT(bp->b_dev)]) switch (bp->b_command) {

		case CY_SFORW:
			yc->yc_blkno -= bp->b_repcnt;
			break;

		case CY_SREV:
			yc->yc_blkno += bp->b_repcnt;
			break;
		}
		goto opdone;

	case SSEEK:
		yc->yc_blkno = bdbtofsb(bp->b_blkno);
		goto opcont;

	case SERASE:
		/*
		 * Completed erase of the inter-record gap due to a
		 * write error; now retry the write operation.
		 */
		vm->um_tab.b_active = SERASED;
		goto opcont;
	}

opdone:
	/*
	 * Reset error count and remove from device queue.
	 */
	vm->um_tab.b_errcnt = 0;
	dp->b_actf = bp->av_forw;
	/*
	 * Save resid and release resources.
	 */
	bp->b_resid = bp->b_bcount - htoms(cy->cy_tpb.tpcount);
	if (bp == &rcybuf[CYUNIT(bp->b_dev)])
		vbadone(bp, cy->cy_buf, (long *)cy->cy_map, cy->cy_utl);
	iodone(bp);
	/*
	 * Circulate slave to end of controller
	 * queue to give other slaves a chance.
	 */
	vm->um_tab.b_actf = dp->b_forw;
	if (dp->b_actf) {
		dp->b_forw = NULL;
		if (vm->um_tab.b_actf == NULL)
			vm->um_tab.b_actf = dp;
		else
			vm->um_tab.b_actl->b_forw = dp;
	}
	if (vm->um_tab.b_actf == 0)
		return;
opcont:
	cystart(vm);
}

cytimer(dev)
	int dev;
{
	register struct yc_softc *yc = &yc_softc[YCUNIT(dev)];
	int s;

	if (yc->yc_timo != INF && (yc->yc_timo -= 5) < 0) {
		printf("yc%d: lost interrupt\n", YCUNIT(dev));
		yc->yc_timo = INF;
		s = spl3();
		cyintr(CYUNIT(dev));
		splx(s);
	}
	timeout(cytimer, (caddr_t)dev, 5*hz);
}

cyseteof(bp)
	register struct buf *bp;
{
	register int cyunit = CYUNIT(bp->b_dev);
	register struct cy_softc *cy = &cy_softc[cyunit];
	register struct yc_softc *yc = &yc_softc[YCUNIT(bp->b_dev)];

	if (bp == &ccybuf[cyunit]) {
		if (yc->yc_blkno > bdbtofsb(bp->b_blkno)) {
			/* reversing */
			yc->yc_nxrec = bdbtofsb(bp->b_blkno) -
			    htoms(cy->cy_tpb.tpcount);
			yc->yc_blkno = yc->yc_nxrec;
		} else {
			yc->yc_blkno = bdbtofsb(bp->b_blkno) +
			    htoms(cy->cy_tpb.tpcount);
			yc->yc_nxrec = yc->yc_blkno - 1;
		}
		return;
	}
	/* eof on read */
	yc->yc_nxrec = bdbtofsb(bp->b_blkno);
}

cyread(dev, uio)
	dev_t dev;
	struct uio *uio;
{
	int errno;

	errno = cyphys(dev, uio);
	if (errno)
		return (errno);
	return (physio(cystrategy, &rcybuf[CYUNIT(dev)], dev, B_READ, minphys, uio));
}

cywrite(dev, uio)
	dev_t dev;
	struct uio *uio;
{
	int errno;

	errno = cyphys(dev, uio);
	if (errno)
		return (errno);
	return (physio(cystrategy, &rcybuf[CYUNIT(dev)], dev, B_WRITE, minphys, uio));
}

/*
 * Check that a raw device exits.
 * If it does, set up the yc_blkno and yc_nxrec
 * so that the tape will appear positioned correctly.
 */
cyphys(dev, uio)
	dev_t dev;
	struct uio *uio;
{
	register int ycunit = YCUNIT(dev);
	register daddr_t a;
	register struct yc_softc *yc;
	register struct vba_device *vi;

	if (ycunit >= NYC || (vi = ycdinfo[ycunit]) == 0 || vi->ui_alive == 0)
		return (ENXIO);
	yc = &yc_softc[ycunit];
	a = bdbtofsb(uio->uio_offset >> DEV_BSHIFT);
	yc->yc_blkno = a;
	yc->yc_nxrec = a + 1;
	return (0);
}

/*ARGSUSED*/
cyioctl(dev, cmd, data, flag)
	caddr_t data;
	dev_t dev;
{
	int ycunit = YCUNIT(dev);
	register struct yc_softc *yc = &yc_softc[ycunit];
	register struct buf *bp = &ccybuf[CYUNIT(dev)];
	register callcount;
	int fcount, op;
	struct mtop *mtop;
	struct mtget *mtget;
	/* we depend of the values and order of the MT codes here */
	static cyops[] =
	{CY_WEOF,CY_SFORW,CY_SREV,CY_SFORW,CY_SREV,CY_REW,CY_OFFL,CY_SENSE};

	switch (cmd) {

	case MTIOCTOP:	/* tape operation */
		mtop = (struct mtop *)data;
		switch (op = mtop->mt_op) {

		case MTWEOF:
		case MTFSR: case MTBSR:
		case MTFSF: case MTBSF:
			callcount = mtop->mt_count;
			fcount = 1;
			break;

		case MTREW: case MTOFFL: case MTNOP:
			callcount = 1;
			fcount = 1;
			break;

		default:
			return (ENXIO);
		}
		if (callcount <= 0 || fcount <= 0)
			return (EINVAL);
		while (--callcount >= 0) {
			/*
			 * Gagh, this controller is the pits...
			 */
			if (op == MTFSF || op == MTBSF) {
				do
					cycommand(dev, cyops[op], 1);
				while ((bp->b_flags&B_ERROR) == 0 &&
				 (yc->yc_status&(CYS_EOT|CYS_BOT|CYS_FM)) == 0);
			} else
				cycommand(dev, cyops[op], fcount);
			if ((bp->b_flags&B_ERROR) ||
			    (yc->yc_status&(CYS_BOT|CYS_EOT)))
				break;
		}
		bp->b_resid = callcount + 1;
		return (geterror(bp));

	case MTIOCGET:
		cycommand(dev, CY_SENSE, 1);
		mtget = (struct mtget *)data;
		mtget->mt_dsreg = yc->yc_status;
		mtget->mt_erreg = yc->yc_control;
		mtget->mt_resid = yc->yc_resid;
		mtget->mt_type = MT_ISCY;
		break;

	default:
		return (ENXIO);
	}
	return (0);
}

/*
 * Poll until the controller is ready.
 */
cywait(cp)
	register struct cyccb *cp;
{
	register int i = 5000;

	uncache(&cp->cbgate);
	while (i-- > 0 && cp->cbgate == GATE_CLOSED) {
		DELAY(1000);
		uncache(&cp->cbgate);
	}
	return (i <= 0);
}

/*
 * Load a 20 bit pointer into an i/o register.
 */
cyldmba(wreg, value)
	short *wreg;
	caddr_t value;
{
	register int v = (int)value;
	register caddr_t reg = (caddr_t)wreg;

	*reg++ = v;
	*reg++ = v >> 8;
	*reg++ = 0;
	*reg = (v&0xf0000) >> 12;
}

/*
 * Unconditionally reset all controllers to their initial state.
 */
cyreset(vba)
	int vba;
{
	register caddr_t addr;
	register int ctlr;

	for (ctlr = 0; ctlr < NCY; ctlr++)
		if (cyminfo[ctlr] && cyminfo[ctlr]->um_vbanum == vba) {
			addr = cyminfo[ctlr]->um_addr;
			CY_RESET(addr);
			if (!cyinit(ctlr)) {
				printf("cy%d: reset failed\n", ctlr);
				cyminfo[ctlr] = NULL;
			}
		}
}

cyuncachetpb(cy)
	struct cy_softc *cy;
{
	register long *lp = (long *)&cy->cy_tpb;
	register int i;

	for (i = 0; i < howmany(sizeof (struct cytpb), sizeof (long)); i++)
		uncache(lp++);
}

/*
 * Dump routine.
 */
cydump(dev)
	dev_t dev;
{
	register struct cy_softc *cy;
	register int bs, num, start;
	register caddr_t addr;
	int unit = CYUNIT(dev), ctlr, error;

	if (unit >= NCY || cyminfo[unit] == 0 ||
	    (cy = &cy_softc[unit])->cy_bs == 0 || YCUNIT(dev) >= NYC)
		return (ENXIO);
	if (cywait(&cy->cy_ccb))
		return (EFAULT);
#define	phys(a)	((caddr_t)((int)(a)&~0xc0000000))
	addr = phys(cyminfo[ctlr]->um_addr);
	num = maxfree, start = NBPG*2;
	while (num > 0) {
		bs = num > btoc(CYMAXIO) ? btoc(CYMAXIO) : num;
		error = cydwrite(cy, start, bs, addr);
		if (error)
			return (error);
		start += bs, num -= bs;
	}
	cyweof(cy, addr);
	cyweof(cy, addr);
	uncache(&cy->cy_tpb);
	if (cy->cy_tpb.tpstatus&CYS_ERR)
		return (EIO);
	cyrewind(cy, addr);
	return (0);
}

cydwrite(cy, pf, npf, addr)
	register struct cy_softc *cy;
	int pf, npf;
	caddr_t addr;
{

	cy->cy_tpb.tpcmd = CY_WCOM;
	cy->cy_tpb.tpcontrol = CYCW_LOCK|CYCW_25IPS|CYCW_16BITS;
	cy->cy_tpb.tpstatus = 0;
	cy->cy_tpb.tpsize = htoms(npf*NBPG);
	cyldmba(cy->cy_tpb.tplink, (caddr_t)0);
	cyldmba(cy->cy_tpb.tpdata, (caddr_t)(pf*NBPG));
	cyldmba(cy->cy_ccb.cbtpb, (caddr_t)&cy->cy_tpb);
	cy->cy_ccb.cbgate = GATE_CLOSED;
	CY_GO(addr);
	if (cywait(&cy->cy_ccb))
		return (EFAULT);
	uncache(&cy->cy_tpb);
	if (cy->cy_tpb.tpstatus&CYS_ERR)
		return (EIO);
	return (0);
}

cyweof(cy, addr)
	register struct cy_softc *cy;
	caddr_t addr;
{

	cy->cy_tpb.tpcmd = CY_WEOF;
	cy->cy_tpb.tpcount = htoms(1);
	cy->cy_ccb.cbgate = GATE_CLOSED;
	CY_GO(addr);
	(void) cywait(&cy->cy_ccb);
}

cyrewind(cy, addr)
	register struct cy_softc *cy;
	caddr_t addr;
{

	cy->cy_tpb.tpcmd = CY_REW;
	cy->cy_tpb.tpcount = htoms(1);
	cy->cy_ccb.cbgate = GATE_CLOSED;
	CY_GO(addr);
	(void) cywait(&cy->cy_ccb);
}
#endif