[unix-history] / usr / src / sys / vax / mba / mt.c

/*	mt.c	4.14	82/10/20	*/

#include "mu.h"
#if NMT > 0
/*
 * TM78/TU78 tape driver
 *
 *	Behavior in complex error situations is uncertain...
 *
 * TODO:
 *	test error recovery
 *	add odd byte count kludge from VMS driver
 *	write dump routine
 */
#include "../h/param.h"
#include "../h/systm.h"
#include "../h/buf.h"
#include "../h/conf.h"
#include "../h/dir.h"
#include "../h/file.h"
#include "../h/user.h"
#include "../h/map.h"
#include "../h/pte.h"
#include "../h/ioctl.h"
#include "../h/mtio.h"
#include "../h/cmap.h"
#include "../h/uio.h"

#include "../vax/cpu.h"
#include "../vaxmba/mbareg.h"
#include "../vaxmba/mbavar.h"
#include "../vaxmba/mtreg.h"

struct	buf	rmtbuf[NMT];
struct	buf	cmtbuf[NMT];

short	mttypes[] =
	{ MBDT_TU78, 0 };
struct	mba_device *mtinfo[NMT];
int	mtattach(), mtslave(), mtustart(), mtstart(), mtndtint(), mtdtint();
struct	mba_driver mtdriver =
    { mtattach, mtslave, mtustart, mtstart, mtdtint, mtndtint,
      mttypes, "mt", "mu", mtinfo };

#define MASKREG(r)	((r) & 0xffff)

/* bits in minor device */
#define	MUUNIT(dev)	(minor(dev)&03)
#define	H_NOREWIND	04
#define	H_6250BPI	08

#define MTUNIT(dev)	(mutomt[MUUNIT(dev)])

#define	INF	(daddr_t)1000000L	/* a block number that wont exist */

struct	mu_softc {
	char	sc_openf;
	char	sc_flags;
	daddr_t	sc_blkno;
	daddr_t	sc_nxrec;
	u_short	sc_erreg;
	u_short	sc_dsreg;
	short	sc_resid;
	short	sc_dens;
	struct	mba_device *sc_mi;
	int	sc_slave;
} mu_softc[NMU];
short	mutomt[NMU];

/*
 * Bits for sc_flags.
 */
#define	H_WRITTEN 1	/* last operation was a write */

char	mtds_bits[] = MTDS_BITS;

/*ARGSUSED*/
mtattach(mi)
	struct mba_device *mi;
{

}

mtslave(mi, ms, sn)
	struct mba_device *mi;
	struct mba_slave *ms;
	int sn;
{
	register struct mu_softc *sc = &mu_softc[ms->ms_unit];
	register struct mtdevice *mtaddr = (struct mtdevice *)mi->mi_drv;
	int s = spl7(), rtn = 0;

	mtaddr->mtas = -1;
	mtaddr->mtncs[sn] = MT_SENSE|MT_GO;
	while (mtaddr->mtas == 0)
		;
	if ((mtaddr->mtner & MTER_INTCODE) == MTER_DONE &&
	    (mtaddr->mtds & MTDS_PRES)) {
		sc->sc_mi = mi;
		sc->sc_slave = sn;
		mutomt[ms->ms_unit] = mi->mi_unit;
		rtn = 1;
	}
	mtaddr->mtas = mtaddr->mtas;
	splx(s);
	return (rtn);
}

mtopen(dev, flag)
	dev_t dev;
	int flag;
{
	register int muunit;
	register struct mba_device *mi;
	register struct mu_softc *sc;
	int olddens, dens;

	muunit = MUUNIT(dev);
	if (muunit >= NMU || (sc = &mu_softc[muunit])->sc_openf ||
	    (mi = mtinfo[MTUNIT(dev)]) == 0 || mi->mi_alive == 0)
		return (ENXIO);
	olddens = sc->sc_dens;
	dens = sc->sc_dens = (minor(dev)&H_6250BPI) ? MT_GCR : 0;
	mtcommand(dev, MT_SENSE, 1);
	sc->sc_dens = olddens;
	if ((sc->sc_dsreg & MTDS_ONL) == 0) {
		uprintf("mu%d: not online\n", muunit);
		return (EIO);
	}
	if ((flag&FWRITE) && (sc->sc_dsreg&MTDS_FPT)) {
		uprintf("mu%d: no write ring\n", muunit);
		return (EIO);
	}
	if ((sc->sc_dsreg & MTDS_BOT) == 0 && (flag&FWRITE) &&
	    dens != sc->sc_dens) {
		uprintf("mu%d: can't change density in mid-tape\n", muunit);
		return (EIO);
	}
	sc->sc_openf = 1;
	sc->sc_blkno = (daddr_t)0;
	sc->sc_nxrec = INF;
	sc->sc_flags = 0;
	sc->sc_dens = dens;
	return (0);
}

mtclose(dev, flag)
	register dev_t dev;
	register flag;
{
	register struct mu_softc *sc = &mu_softc[MUUNIT(dev)];

	if (flag == FWRITE || ((flag&FWRITE) && (sc->sc_flags&H_WRITTEN)))
		mtcommand(dev, MT_CLS|sc->sc_dens, 1);
	if ((minor(dev)&H_NOREWIND) == 0)
		mtcommand(dev, MT_REW, 0);
	sc->sc_openf = 0;
}

mtcommand(dev, com, count)
	dev_t dev;
	int com, count;
{
	register struct buf *bp;
	register int s;

	bp = &cmtbuf[MTUNIT(dev)];
	s = spl5();
	while (bp->b_flags&B_BUSY) {
		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_command = com;
	bp->b_repcnt = count;
	bp->b_blkno = 0;
	mtstrategy(bp);
	if (count == 0)
		return;
	iowait(bp);
	if (bp->b_flags&B_WANTED)
		wakeup((caddr_t)bp);
	bp->b_flags &= B_ERROR;
}

mtstrategy(bp)
	register struct buf *bp;
{
	register struct mba_device *mi = mtinfo[MTUNIT(bp->b_dev)];
	register struct buf *dp;
	register int s;

	bp->av_forw = NULL;
	dp = &mi->mi_tab;
	s = spl5();
	if (dp->b_actf == NULL)
		dp->b_actf = bp;
	else
		dp->b_actl->av_forw = bp;
	dp->b_actl = bp;
	if (dp->b_active == 0)
		mbustart(mi);
	splx(s);
}

mtustart(mi)
	register struct mba_device *mi;
{
	register struct mtdevice *mtaddr =
	    (struct mtdevice *)mi->mi_drv;
	register struct buf *bp = mi->mi_tab.b_actf;
	register struct mu_softc *sc = &mu_softc[MUUNIT(bp->b_dev)];
	daddr_t blkno;

	sc->sc_flags &= ~H_WRITTEN;
	if (sc->sc_openf < 0) {
		bp->b_flags |= B_ERROR;
		return (MBU_NEXT);
	}
	if (bp != &cmtbuf[MTUNIT(bp->b_dev)]) {
		if (bdbtofsb(bp->b_blkno) > sc->sc_nxrec) {
			bp->b_flags |= B_ERROR;
			bp->b_error = ENXIO;
			return (MBU_NEXT);
		}
		if (bdbtofsb(bp->b_blkno) == sc->sc_nxrec &&
		    bp->b_flags&B_READ) {
			bp->b_resid = bp->b_bcount;
			clrbuf(bp);
			return (MBU_NEXT);
		}
		if ((bp->b_flags&B_READ)==0)
			sc->sc_nxrec = bdbtofsb(bp->b_blkno) + 1;
	} else {
		mtaddr->mtncs[MUUNIT(bp->b_dev)] =
			(bp->b_repcnt<<8)|bp->b_command|MT_GO;
		return (MBU_STARTED);
	}
	if ((blkno = sc->sc_blkno) == bdbtofsb(bp->b_blkno)) {
		if (mi->mi_tab.b_errcnt == 2) {
			mtaddr->mtca = MUUNIT(bp->b_dev);
		} else {
			mtaddr->mtbc = bp->b_bcount;
			mtaddr->mtca = (1<<2)|MUUNIT(bp->b_dev);
		}
		return (MBU_DODATA);
	}
	if (blkno < bdbtofsb(bp->b_blkno))
		mtaddr->mtncs[MUUNIT(bp->b_dev)] =
		  (min((unsigned)(bdbtofsb(bp->b_blkno) - blkno), 0377) << 8) |
			MT_SFORW|MT_GO;
	else
		mtaddr->mtncs[MUUNIT(bp->b_dev)] =
		  (min((unsigned)(blkno - bdbtofsb(bp->b_blkno)), 0377) << 8) |
			MT_SREV|MT_GO;
	return (MBU_STARTED);
}

mtstart(mi)
	register struct mba_device *mi;
{
	register struct buf *bp = mi->mi_tab.b_actf;
	register struct mu_softc *sc = &mu_softc[MUUNIT(bp->b_dev)];

	if (bp->b_flags & B_READ)
		if (mi->mi_tab.b_errcnt == 2)
			return(MT_READREV|MT_GO);
		else
			return(MT_READ|MT_GO);
	else
		return(MT_WRITE|sc->sc_dens|MT_GO);
}

mtdtint(mi, mbsr)
	register struct mba_device *mi;
	int mbsr;
{
	register struct mtdevice *mtaddr = (struct mtdevice *)mi->mi_drv;
	register struct buf *bp = mi->mi_tab.b_actf;
	register struct mu_softc *sc;

	/* I'M NOT SURE IF THIS SHOULD ALWAYS BE THE CASE SO FOR NOW... */
	if ((mtaddr->mtca&3) != MUUNIT(bp->b_dev)) {
		printf("mt: wrong unit!\n");
		mtaddr->mtca = MUUNIT(bp->b_dev);
	}
	sc = &mu_softc[MUUNIT(bp->b_dev)];
	sc->sc_erreg = mtaddr->mter;
	if((bp->b_flags & B_READ) == 0)
		sc->sc_flags |= H_WRITTEN;
	switch (sc->sc_erreg & MTER_INTCODE) {
	case MTER_DONE:
	case MTER_LONGREC:
		if (mi->mi_tab.b_errcnt != 2)
			sc->sc_blkno++;
		bp->b_resid = 0;
		break;

	case MTER_NOTCAP:
		printf("mu%d: blank tape\n", MUUNIT(bp->b_dev));
		goto err;

	case MTER_TM:
	case MTER_EOT:
		sc->sc_blkno++;
	err:
		bp->b_resid = bp->b_bcount;
		sc->sc_nxrec = bdbtofsb(bp->b_blkno);
		break;

	case MTER_SHRTREC:
		sc->sc_blkno++;
		if (bp != &rmtbuf[MTUNIT(bp->b_dev)])
			bp->b_flags |= B_ERROR;
		if (mi->mi_tab.b_errcnt == 2)
			bp->b_bcount = bp->b_resid;	/* restore saved value */
		bp->b_resid = bp->b_bcount - mtaddr->mtbc;
		break;

	case MTER_RDOPP:
		mi->mi_tab.b_errcnt = 2;	/* indicate "read opposite" */
		bp->b_resid = bp->b_bcount;	/* save it */
		bp->b_bcount = mtaddr->mtbc;	/* use this instead */
		return(MBD_RETRY);

	case MTER_RETRY:
		mi->mi_tab.b_errcnt = 1;	/* indicate simple retry */
		return(MBD_RETRY);

	case MTER_OFFLINE:
		if (sc->sc_openf > 0) {
			sc->sc_openf = -1;
			printf("mu%d: offline\n", MUUNIT(bp->b_dev));
		}
		bp->b_flags |= B_ERROR;
		break;

	case MTER_FPT:
		printf("mu%d: no write ring\n", MUUNIT(bp->b_dev));
		bp->b_flags |= B_ERROR;
		break;

	default:
		printf("mu%d: hard error bn%d mbsr=%b er=%x ds=%b\n",
		    MUUNIT(bp->b_dev), bp->b_blkno,
		    mbsr, mbsr_bits, sc->sc_erreg,
		    sc->sc_dsreg, mtds_bits);
		bp->b_flags |= B_ERROR;
		mtaddr->mtid = MTID_CLR;		/* reset the TM78 */
		DELAY(250);
		while ((mtaddr->mtid & MTID_RDY) == 0)	/* wait for it */
			;
		return (MBD_DONE);
	}
	/* CHECK FOR MBA ERROR WHEN NO OTHER ERROR INDICATED? */
	return (MBD_DONE);
}

mtndtint(mi)
	register struct mba_device *mi;
{
	register struct mtdevice *mtaddr = (struct mtdevice *)mi->mi_drv;
	register struct buf *bp = mi->mi_tab.b_actf;
	register struct mu_softc *sc;
	int er, fc, unit;

	unit = (mtaddr->mtner >> 8) & 3;
	er = MASKREG(mtaddr->mtner);
	/* WILL THIS OCCUR IF ANOTHER DRIVE COMES ONLINE? */
	if (bp == 0 || unit != MUUNIT(bp->b_dev)) {	/* consistency check */
		if ((er & MTER_INTCODE) != MTER_ONLINE)
			printf("mt: unit %d random interrupt\n", unit);
		return (MBN_SKIP);
	}
	if (bp == 0)
		return (MBN_SKIP);
	fc = (mtaddr->mtncs[unit] >> 8) & 0xff;
	sc = &mu_softc[unit];
	sc->sc_erreg = er;
	sc->sc_resid = fc;
	switch (er & MTER_INTCODE) {
	case MTER_DONE:
		if (bp == &cmtbuf[MTUNIT(bp->b_dev)]) {
	done:
			if (bp->b_command == MT_SENSE)
				sc->sc_dsreg = MASKREG(mtaddr->mtds);
			bp->b_resid = fc;
			return (MBN_DONE);
		}
		/* this is UGLY!  (but is it correct?) */
		if ((fc = bdbtofsb(bp->b_blkno) - sc->sc_blkno) < 0)
			sc->sc_blkno -= MIN(0377, -fc);
		else
			sc->sc_blkno += MIN(0377, fc);
		return (MBN_RETRY);

	case MTER_RWDING:
		return (MBN_SKIP);	/* ignore "rewind started" interrupt */

	case MTER_NOTCAP:
		printf("mu%d: blank tape\n", MUUNIT(bp->b_dev));

	case MTER_TM:
	case MTER_EOT:
	case MTER_LEOT:
		if (sc->sc_blkno > bdbtofsb(bp->b_blkno)) {
			sc->sc_nxrec = bdbtofsb(bp->b_blkno) + fc;
			sc->sc_blkno = sc->sc_nxrec;
		} else {
			sc->sc_blkno = bdbtofsb(bp->b_blkno) - fc;
			sc->sc_nxrec = sc->sc_blkno - 1;
		}
		return (MBN_RETRY);

	case MTER_FPT:
		printf("mu%d: no write ring\n", MUUNIT(bp->b_dev));
		bp->b_flags |= B_ERROR;
		return (MBN_DONE);

	case MTER_OFFLINE:
		if (sc->sc_openf > 0) {
			sc->sc_openf = -1;
			printf("mu%d: offline\n", MUUNIT(bp->b_dev));
		}
		bp->b_flags |= B_ERROR;
		return (MBN_DONE);

	case MTER_BOT:
		if (bp == &cmtbuf[MTUNIT(bp->b_dev)])
			goto done;
		/* FALL THROUGH */

	default:
		printf("mu%d: hard error bn%d er=%o ds=%b\n",
		    MUUNIT(bp->b_dev), bp->b_blkno,
		    sc->sc_erreg, sc->sc_dsreg, mtds_bits);
		mtaddr->mtid = MTID_CLR;		/* reset the TM78 */
		DELAY(250);
		while ((mtaddr->mtid & MTID_RDY) == 0)	/* wait for it */
			;
		bp->b_flags |= B_ERROR;
		return (MBN_DONE);
	}
	/* NOTREACHED */
}

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

	errno = mtphys(dev, uio);
	if (errno)
		return (errno);
	return (physio(mtstrategy, &rmtbuf[MTUNIT(dev)], dev, B_READ, minphys, uio));
}

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

	errno = mtphys(dev, uio);
	if (errno)
		return (errno);
	return (physio(mtstrategy, &rmtbuf[MTUNIT(dev)], dev, B_WRITE, minphys, uio));
}

mtphys(dev, uio)
	dev_t dev;
	struct uio *uio;
{
	register int mtunit;
	register struct mu_softc *sc;
	register struct mba_device *mi;
	daddr_t a;

	mtunit = MTUNIT(dev);
	if (mtunit >= NMT || (mi = mtinfo[mtunit]) == 0 || mi->mi_alive == 0)
		return (ENXIO);
	a = uio->uio_offset >> 9;
	sc = &mu_softc[MUUNIT(dev)];
	sc->sc_blkno = bdbtofsb(a);
	sc->sc_nxrec = bdbtofsb(a)+1;
	return (0);
}

/*ARGSUSED*/
mtioctl(dev, cmd, data, flag)
	dev_t dev;
	int cmd;
	caddr_t data;
	int flag;
{
	register struct mu_softc *sc = &mu_softc[MUUNIT(dev)];
	register struct buf *bp = &cmtbuf[MTUNIT(dev)];
	register callcount;
	register int op;
	int fcount;
	struct mtop *mtop;
	struct mtget *mtget;
	/* we depend of the values and order of the MT codes here */
	static mtops[] =
	{MT_WTM,MT_SFORWF,MT_SREVF,MT_SFORW,MT_SREV,MT_REW,MT_UNLOAD,MT_SENSE};

	switch (cmd) {

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

		case MTWEOF:
			callcount = mtop->mt_count;
			fcount = 1;
			break;

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

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

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

		default:
			return (ENXIO);
		}
		if (callcount <= 0 || fcount <= 0)
			return (EINVAL);
		op = mtops[mtop->mt_op];
		if (op == MT_WTM)
			op |= sc->sc_dens;
		while (--callcount >= 0) {
			register int n;

			do {
				n = MIN(fcount, 0xff);
				mtcommand(dev, op, n);
				fcount -= n;
			} while (fcount);
			if ((mtop->mt_op == MTFSR || mtop->mt_op == MTBSR) &&
			    bp->b_resid)
				return (EIO);
			if (bp->b_flags&B_ERROR)
				break;
		}
		return (geterror(bp));

	case MTIOCGET:
		mtget = (struct mtget *)data;
		mtget->mt_erreg = sc->sc_erreg;
		mtget->mt_resid = sc->sc_resid;
		mtcommand(dev, MT_SENSE, 1);	/* update drive status */
		mtget->mt_dsreg = sc->sc_dsreg;
		mtget->mt_type = MT_ISMT;
		break;

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

#define	DBSIZE	20

mtdump()
{
	register struct mba_device *mi;
	register struct mba_regs *mp;
	int blk, num;
	int start;

	start = 0;
	num = maxfree;
#define	phys(a,b)		((b)((int)(a)&0x7fffffff))
	if (mtinfo[0] == 0)
		return (ENXIO);
	mi = phys(mtinfo[0], struct mba_device *);
	mp = phys(mi->mi_hd, struct mba_hd *)->mh_physmba;
	mp->mba_cr = MBCR_IE;
#if lint
	blk = 0; num = blk; start = num; blk = start;
	return (0);
#endif
#ifdef notyet
	mtaddr = (struct mtdevice *)&mp->mba_drv[mi->mi_drive];
	mtaddr->mttc = MTTC_PDP11|MTTC_1600BPI;
	mtaddr->mtcs1 = MT_DCLR|MT_GO;
	while (num > 0) {
		blk = num > DBSIZE ? DBSIZE : num;
		mtdwrite(start, blk, mtaddr, mp);
		start += blk;
		num -= blk;
	}
	mteof(mtaddr);
	mteof(mtaddr);
	mtwait(mtaddr);
	if (mtaddr->mtds&MTDS_ERR)
		return (EIO);
	mtaddr->mtcs1 = MT_REW|MT_GO;
	return (0);
}

mtdwrite(dbuf, num, mtaddr, mp)
	register dbuf, num;
	register struct mtdevice *mtaddr;
	struct mba_regs *mp;
{
	register struct pte *io;
	register int i;

	mtwait(mtaddr);
	io = mp->mba_map;
	for (i = 0; i < num; i++)
		*(int *)io++ = dbuf++ | PG_V;
	mtaddr->mtfc = -(num*NBPG);
	mp->mba_sr = -1;
	mp->mba_bcr = -(num*NBPG);
	mp->mba_var = 0;
	mtaddr->mtcs1 = MT_WCOM|MT_GO;
}

mtwait(mtaddr)
	struct mtdevice *mtaddr;
{
	register s;

	do
		s = mtaddr->mtds;
	while ((s & MTDS_DRY) == 0);
}

mteof(mtaddr)
	struct mtdevice *mtaddr;
{

	mtwait(mtaddr);
	mtaddr->mtcs1 = MT_WEOF|MT_GO;
#endif notyet
}
#endif
Commit	Line	Data
5a1f132a	1	/* mt.c 4.14 82/10/20 */
83d7e407 BJ	2
	3	#include "mu.h"
	4	#if NMT > 0
	5	/*
	6	* TM78/TU78 tape driver
	7	*
	8	* Behavior in complex error situations is uncertain...
	9	*
	10	* TODO:
	11	* test error recovery
	12	* add odd byte count kludge from VMS driver
	13	* write dump routine
	14	*/
	15	#include "../h/param.h"
	16	#include "../h/systm.h"
	17	#include "../h/buf.h"
	18	#include "../h/conf.h"
	19	#include "../h/dir.h"
	20	#include "../h/file.h"
	21	#include "../h/user.h"
	22	#include "../h/map.h"
	23	#include "../h/pte.h"
83d7e407	24	#include "../h/ioctl.h"
942f05a9	25	#include "../h/mtio.h"
83d7e407	26	#include "../h/cmap.h"
deb8980a	27	#include "../h/uio.h"
83d7e407	28
c895c266 BJ	29	#include "../vax/cpu.h"
	30	#include "../vaxmba/mbareg.h"
	31	#include "../vaxmba/mbavar.h"
	32	#include "../vaxmba/mtreg.h"
83d7e407 BJ	33
	34	struct buf rmtbuf[NMT];
	35	struct buf cmtbuf[NMT];
	36
	37	short mttypes[] =
	38	{ MBDT_TU78, 0 };
	39	struct mba_device *mtinfo[NMT];
	40	int mtattach(), mtslave(), mtustart(), mtstart(), mtndtint(), mtdtint();
	41	struct mba_driver mtdriver =
	42	{ mtattach, mtslave, mtustart, mtstart, mtdtint, mtndtint,
	43	mttypes, "mt", "mu", mtinfo };
	44
	45	#define MASKREG(r) ((r) & 0xffff)
	46
	47	/* bits in minor device */
	48	#define MUUNIT(dev) (minor(dev)&03)
	49	#define H_NOREWIND 04
	50	#define H_6250BPI 08
	51
	52	#define MTUNIT(dev) (mutomt[MUUNIT(dev)])
	53
	54	#define INF (daddr_t)1000000L /* a block number that wont exist */
	55
	56	struct mu_softc {
	57	char sc_openf;
	58	char sc_flags;
	59	daddr_t sc_blkno;
	60	daddr_t sc_nxrec;
	61	u_short sc_erreg;
	62	u_short sc_dsreg;
	63	short sc_resid;
	64	short sc_dens;
	65	struct mba_device *sc_mi;
	66	int sc_slave;
	67	} mu_softc[NMU];
	68	short mutomt[NMU];
	69
	70	/*
	71	* Bits for sc_flags.
	72	*/
	73	#define H_WRITTEN 1 /* last operation was a write */
	74
	75	char mtds_bits[] = MTDS_BITS;
	76
	77	/ARGSUSED/
	78	mtattach(mi)
	79	struct mba_device *mi;
	80	{
a1edc12b	81
83d7e407 BJ	82	}
83d7e407 BJ	83
51250c66	84	mtslave(mi, ms, sn)
83d7e407 BJ	85	struct mba_device *mi;
83d7e407 BJ	86	struct mba_slave *ms;
51250c66	87	int sn;
83d7e407 BJ	88	{
	89	register struct mu_softc *sc = &mu_softc[ms->ms_unit];
	90	register struct mtdevice mtaddr = (struct mtdevice )mi->mi_drv;
	91	int s = spl7(), rtn = 0;
	92
	93	mtaddr->mtas = -1;
51250c66	94	mtaddr->mtncs[sn] = MT_SENSE\|MT_GO;
83d7e407 BJ	95	while (mtaddr->mtas == 0)
	96	;
	97	if ((mtaddr->mtner & MTER_INTCODE) == MTER_DONE &&
	98	(mtaddr->mtds & MTDS_PRES)) {
	99	sc->sc_mi = mi;
51250c66	100	sc->sc_slave = sn;
83d7e407 BJ	101	mutomt[ms->ms_unit] = mi->mi_unit;
	102	rtn = 1;
	103	}
	104	mtaddr->mtas = mtaddr->mtas;
	105	splx(s);
	106	return (rtn);
	107	}
	108
	109	mtopen(dev, flag)
	110	dev_t dev;
	111	int flag;
	112	{
	113	register int muunit;
	114	register struct mba_device *mi;
	115	register struct mu_softc *sc;
	116	int olddens, dens;
	117
	118	muunit = MUUNIT(dev);
	119	if (muunit >= NMU \|\| (sc = &mu_softc[muunit])->sc_openf \|\|
473a2e47 BJ	120	(mi = mtinfo[MTUNIT(dev)]) == 0 \|\| mi->mi_alive == 0)
473a2e47 BJ	121	return (ENXIO);
83d7e407 BJ	122	olddens = sc->sc_dens;
	123	dens = sc->sc_dens = (minor(dev)&H_6250BPI) ? MT_GCR : 0;
	124	mtcommand(dev, MT_SENSE, 1);
	125	sc->sc_dens = olddens;
	126	if ((sc->sc_dsreg & MTDS_ONL) == 0) {
	127	uprintf("mu%d: not online\n", muunit);
473a2e47	128	return (EIO);
83d7e407 BJ	129	}
	130	if ((flag&FWRITE) && (sc->sc_dsreg&MTDS_FPT)) {
	131	uprintf("mu%d: no write ring\n", muunit);
473a2e47	132	return (EIO);
83d7e407 BJ	133	}
	134	if ((sc->sc_dsreg & MTDS_BOT) == 0 && (flag&FWRITE) &&
	135	dens != sc->sc_dens) {
	136	uprintf("mu%d: can't change density in mid-tape\n", muunit);
473a2e47	137	return (EIO);
83d7e407 BJ	138	}
	139	sc->sc_openf = 1;
	140	sc->sc_blkno = (daddr_t)0;
	141	sc->sc_nxrec = INF;
	142	sc->sc_flags = 0;
	143	sc->sc_dens = dens;
473a2e47	144	return (0);
83d7e407 BJ	145	}
	146
	147	mtclose(dev, flag)
	148	register dev_t dev;
	149	register flag;
	150	{
	151	register struct mu_softc *sc = &mu_softc[MUUNIT(dev)];
	152
	153	if (flag == FWRITE \|\| ((flag&FWRITE) && (sc->sc_flags&H_WRITTEN)))
	154	mtcommand(dev, MT_CLS\|sc->sc_dens, 1);
	155	if ((minor(dev)&H_NOREWIND) == 0)
	156	mtcommand(dev, MT_REW, 0);
	157	sc->sc_openf = 0;
	158	}
	159
	160	mtcommand(dev, com, count)
	161	dev_t dev;
	162	int com, count;
	163	{
	164	register struct buf *bp;
2311123d	165	register int s;
83d7e407 BJ	166
83d7e407 BJ	167	bp = &cmtbuf[MTUNIT(dev)];
2311123d	168	s = spl5();
83d7e407 BJ	169	while (bp->b_flags&B_BUSY) {
	170	if(bp->b_repcnt == 0 && (bp->b_flags&B_DONE))
	171	break;
	172	bp->b_flags \|= B_WANTED;
	173	sleep((caddr_t)bp, PRIBIO);
	174	}
	175	bp->b_flags = B_BUSY\|B_READ;
2311123d	176	splx(s);
83d7e407 BJ	177	bp->b_dev = dev;
	178	bp->b_command = com;
	179	bp->b_repcnt = count;
	180	bp->b_blkno = 0;
	181	mtstrategy(bp);
	182	if (count == 0)
	183	return;
	184	iowait(bp);
	185	if (bp->b_flags&B_WANTED)
	186	wakeup((caddr_t)bp);
	187	bp->b_flags &= B_ERROR;
	188	}
	189
	190	mtstrategy(bp)
	191	register struct buf *bp;
	192	{
	193	register struct mba_device *mi = mtinfo[MTUNIT(bp->b_dev)];
	194	register struct buf *dp;
2311123d	195	register int s;
83d7e407 BJ	196
	197	bp->av_forw = NULL;
	198	dp = &mi->mi_tab;
2311123d	199	s = spl5();
83d7e407 BJ	200	if (dp->b_actf == NULL)
	201	dp->b_actf = bp;
	202	else
	203	dp->b_actl->av_forw = bp;
	204	dp->b_actl = bp;
	205	if (dp->b_active == 0)
	206	mbustart(mi);
2311123d	207	splx(s);
83d7e407 BJ	208	}
	209
	210	mtustart(mi)
	211	register struct mba_device *mi;
	212	{
	213	register struct mtdevice *mtaddr =
	214	(struct mtdevice *)mi->mi_drv;
	215	register struct buf *bp = mi->mi_tab.b_actf;
	216	register struct mu_softc *sc = &mu_softc[MUUNIT(bp->b_dev)];
	217	daddr_t blkno;
	218
	219	sc->sc_flags &= ~H_WRITTEN;
	220	if (sc->sc_openf < 0) {
	221	bp->b_flags \|= B_ERROR;
	222	return (MBU_NEXT);
	223	}
	224	if (bp != &cmtbuf[MTUNIT(bp->b_dev)]) {
43d66181	225	if (bdbtofsb(bp->b_blkno) > sc->sc_nxrec) {
83d7e407 BJ	226	bp->b_flags \|= B_ERROR;
	227	bp->b_error = ENXIO;
	228	return (MBU_NEXT);
	229	}
43d66181	230	if (bdbtofsb(bp->b_blkno) == sc->sc_nxrec &&
83d7e407 BJ	231	bp->b_flags&B_READ) {
	232	bp->b_resid = bp->b_bcount;
	233	clrbuf(bp);
	234	return (MBU_NEXT);
	235	}
	236	if ((bp->b_flags&B_READ)==0)
43d66181	237	sc->sc_nxrec = bdbtofsb(bp->b_blkno) + 1;
83d7e407 BJ	238	} else {
	239	mtaddr->mtncs[MUUNIT(bp->b_dev)] =
	240	(bp->b_repcnt<<8)\|bp->b_command\|MT_GO;
	241	return (MBU_STARTED);
	242	}
43d66181	243	if ((blkno = sc->sc_blkno) == bdbtofsb(bp->b_blkno)) {
83d7e407 BJ	244	if (mi->mi_tab.b_errcnt == 2) {
	245	mtaddr->mtca = MUUNIT(bp->b_dev);
	246	} else {
	247	mtaddr->mtbc = bp->b_bcount;
	248	mtaddr->mtca = (1<<2)\|MUUNIT(bp->b_dev);
	249	}
	250	return (MBU_DODATA);
	251	}
43d66181	252	if (blkno < bdbtofsb(bp->b_blkno))
83d7e407	253	mtaddr->mtncs[MUUNIT(bp->b_dev)] =
43d66181	254	(min((unsigned)(bdbtofsb(bp->b_blkno) - blkno), 0377) << 8) \|
155d9ff0	255	MT_SFORW\|MT_GO;
83d7e407 BJ	256	else
83d7e407 BJ	257	mtaddr->mtncs[MUUNIT(bp->b_dev)] =
43d66181	258	(min((unsigned)(blkno - bdbtofsb(bp->b_blkno)), 0377) << 8) \|
155d9ff0	259	MT_SREV\|MT_GO;
83d7e407 BJ	260	return (MBU_STARTED);
	261	}
	262
	263	mtstart(mi)
	264	register struct mba_device *mi;
	265	{
	266	register struct buf *bp = mi->mi_tab.b_actf;
	267	register struct mu_softc *sc = &mu_softc[MUUNIT(bp->b_dev)];
	268
	269	if (bp->b_flags & B_READ)
	270	if (mi->mi_tab.b_errcnt == 2)
	271	return(MT_READREV\|MT_GO);
	272	else
	273	return(MT_READ\|MT_GO);
	274	else
	275	return(MT_WRITE\|sc->sc_dens\|MT_GO);
	276	}
	277
	278	mtdtint(mi, mbsr)
	279	register struct mba_device *mi;
	280	int mbsr;
	281	{
	282	register struct mtdevice mtaddr = (struct mtdevice )mi->mi_drv;
	283	register struct buf *bp = mi->mi_tab.b_actf;
	284	register struct mu_softc *sc;
	285
	286	/* I'M NOT SURE IF THIS SHOULD ALWAYS BE THE CASE SO FOR NOW... */
	287	if ((mtaddr->mtca&3) != MUUNIT(bp->b_dev)) {
	288	printf("mt: wrong unit!\n");
	289	mtaddr->mtca = MUUNIT(bp->b_dev);
	290	}
	291	sc = &mu_softc[MUUNIT(bp->b_dev)];
	292	sc->sc_erreg = mtaddr->mter;
	293	if((bp->b_flags & B_READ) == 0)
	294	sc->sc_flags \|= H_WRITTEN;
	295	switch (sc->sc_erreg & MTER_INTCODE) {
	296	case MTER_DONE:
	297	case MTER_LONGREC:
	298	if (mi->mi_tab.b_errcnt != 2)
	299	sc->sc_blkno++;
	300	bp->b_resid = 0;
	301	break;
	302
	303	case MTER_NOTCAP:
	304	printf("mu%d: blank tape\n", MUUNIT(bp->b_dev));
	305	goto err;
	306
	307	case MTER_TM:
	308	case MTER_EOT:
	309	sc->sc_blkno++;
	310	err:
	311	bp->b_resid = bp->b_bcount;
43d66181	312	sc->sc_nxrec = bdbtofsb(bp->b_blkno);
83d7e407 BJ	313	break;
	314
	315	case MTER_SHRTREC:
	316	sc->sc_blkno++;
	317	if (bp != &rmtbuf[MTUNIT(bp->b_dev)])
	318	bp->b_flags \|= B_ERROR;
	319	if (mi->mi_tab.b_errcnt == 2)
	320	bp->b_bcount = bp->b_resid; /* restore saved value */
	321	bp->b_resid = bp->b_bcount - mtaddr->mtbc;
	322	break;
	323
	324	case MTER_RDOPP:
	325	mi->mi_tab.b_errcnt = 2; /* indicate "read opposite" */
	326	bp->b_resid = bp->b_bcount; /* save it */
	327	bp->b_bcount = mtaddr->mtbc; /* use this instead */
	328	return(MBD_RETRY);
	329
	330	case MTER_RETRY:
	331	mi->mi_tab.b_errcnt = 1; /* indicate simple retry */
	332	return(MBD_RETRY);
	333
	334	case MTER_OFFLINE:
	335	if (sc->sc_openf > 0) {
	336	sc->sc_openf = -1;
	337	printf("mu%d: offline\n", MUUNIT(bp->b_dev));
	338	}
	339	bp->b_flags \|= B_ERROR;
	340	break;
	341
	342	case MTER_FPT:
	343	printf("mu%d: no write ring\n", MUUNIT(bp->b_dev));
	344	bp->b_flags \|= B_ERROR;
	345	break;
	346
	347	default:
	348	printf("mu%d: hard error bn%d mbsr=%b er=%x ds=%b\n",
	349	MUUNIT(bp->b_dev), bp->b_blkno,
	350	mbsr, mbsr_bits, sc->sc_erreg,
	351	sc->sc_dsreg, mtds_bits);
	352	bp->b_flags \|= B_ERROR;
	353	mtaddr->mtid = MTID_CLR; /* reset the TM78 */
	354	DELAY(250);
	355	while ((mtaddr->mtid & MTID_RDY) == 0) /* wait for it */
	356	;
	357	return (MBD_DONE);
	358	}
	359	/* CHECK FOR MBA ERROR WHEN NO OTHER ERROR INDICATED? */
	360	return (MBD_DONE);
	361	}
	362
	363	mtndtint(mi)
	364	register struct mba_device *mi;
	365	{
	366	register struct mtdevice mtaddr = (struct mtdevice )mi->mi_drv;
	367	register struct buf *bp = mi->mi_tab.b_actf;
	368	register struct mu_softc *sc;
	369	int er, fc, unit;
	370
	371	unit = (mtaddr->mtner >> 8) & 3;
	372	er = MASKREG(mtaddr->mtner);
	373	/* WILL THIS OCCUR IF ANOTHER DRIVE COMES ONLINE? */
	374	if (bp == 0 \|\| unit != MUUNIT(bp->b_dev)) { /* consistency check */
	375	if ((er & MTER_INTCODE) != MTER_ONLINE)
	376	printf("mt: unit %d random interrupt\n", unit);
377	return (MBN_SKIP);
378	}
379	if (bp == 0)
380	return (MBN_SKIP);
381	fc = (mtaddr->mtncs[unit] >> 8) & 0xff;
382	sc = &mu_softc[unit];
383	sc->sc_erreg = er;
384	sc->sc_resid = fc;
385	switch (er & MTER_INTCODE) {
386	case MTER_DONE:
387	if (bp == &cmtbuf[MTUNIT(bp->b_dev)]) {
388	done:
389	if (bp->b_command == MT_SENSE)
390	sc->sc_dsreg = MASKREG(mtaddr->mtds);
391	bp->b_resid = fc;
392	return (MBN_DONE);
393	}
394	/* this is UGLY! (but is it correct?) */
43d66181	395	if ((fc = bdbtofsb(bp->b_blkno) - sc->sc_blkno) < 0)
155d9ff0	396	sc->sc_blkno -= MIN(0377, -fc);
83d7e407	397	else
155d9ff0	398	sc->sc_blkno += MIN(0377, fc);
83d7e407 BJ	399	return (MBN_RETRY);
	400
	401	case MTER_RWDING:
	402	return (MBN_SKIP); /* ignore "rewind started" interrupt */
	403
	404	case MTER_NOTCAP:
	405	printf("mu%d: blank tape\n", MUUNIT(bp->b_dev));
	406
	407	case MTER_TM:
	408	case MTER_EOT:
	409	case MTER_LEOT:
43d66181 SL	410	if (sc->sc_blkno > bdbtofsb(bp->b_blkno)) {
43d66181 SL	411	sc->sc_nxrec = bdbtofsb(bp->b_blkno) + fc;
83d7e407 BJ	412	sc->sc_blkno = sc->sc_nxrec;
83d7e407 BJ	413	} else {
43d66181	414	sc->sc_blkno = bdbtofsb(bp->b_blkno) - fc;
83d7e407 BJ	415	sc->sc_nxrec = sc->sc_blkno - 1;
	416	}
	417	return (MBN_RETRY);
	418
	419	case MTER_FPT:
	420	printf("mu%d: no write ring\n", MUUNIT(bp->b_dev));
	421	bp->b_flags \|= B_ERROR;
	422	return (MBN_DONE);
	423
	424	case MTER_OFFLINE:
	425	if (sc->sc_openf > 0) {
	426	sc->sc_openf = -1;
	427	printf("mu%d: offline\n", MUUNIT(bp->b_dev));
	428	}
	429	bp->b_flags \|= B_ERROR;
	430	return (MBN_DONE);
	431
	432	case MTER_BOT:
	433	if (bp == &cmtbuf[MTUNIT(bp->b_dev)])
	434	goto done;
	435	/* FALL THROUGH */
	436
	437	default:
	438	printf("mu%d: hard error bn%d er=%o ds=%b\n",
	439	MUUNIT(bp->b_dev), bp->b_blkno,
	440	sc->sc_erreg, sc->sc_dsreg, mtds_bits);
	441	mtaddr->mtid = MTID_CLR; /* reset the TM78 */
	442	DELAY(250);
	443	while ((mtaddr->mtid & MTID_RDY) == 0) /* wait for it */
	444	;
	445	bp->b_flags \|= B_ERROR;
	446	return (MBN_DONE);
	447	}
	448	/* NOTREACHED */
	449	}
	450
deb8980a	451	mtread(dev, uio)
83d7e407	452	dev_t dev;
deb8980a	453	struct uio *uio;
83d7e407	454	{
23458a62	455	int errno;
83d7e407	456
23458a62 BJ	457	errno = mtphys(dev, uio);
	458	if (errno)
	459	return (errno);
	460	return (physio(mtstrategy, &rmtbuf[MTUNIT(dev)], dev, B_READ, minphys, uio));
83d7e407 BJ	461	}
83d7e407 BJ	462
406ddcbe BJ	463	mtwrite(dev, uio)
	464	dev_t dev;
	465	struct uio *uio;
83d7e407	466	{
23458a62	467	int errno;
83d7e407	468
23458a62 BJ	469	errno = mtphys(dev, uio);
	470	if (errno)
	471	return (errno);
	472	return (physio(mtstrategy, &rmtbuf[MTUNIT(dev)], dev, B_WRITE, minphys, uio));
83d7e407 BJ	473	}
83d7e407 BJ	474
deb8980a	475	mtphys(dev, uio)
83d7e407	476	dev_t dev;
deb8980a	477	struct uio *uio;
83d7e407 BJ	478	{
	479	register int mtunit;
	480	register struct mu_softc *sc;
	481	register struct mba_device *mi;
	482	daddr_t a;
	483
	484	mtunit = MTUNIT(dev);
406ddcbe	485	if (mtunit >= NMT \|\| (mi = mtinfo[mtunit]) == 0 \|\| mi->mi_alive == 0)
deb8980a	486	return (ENXIO);
406ddcbe	487	a = uio->uio_offset >> 9;
83d7e407	488	sc = &mu_softc[MUUNIT(dev)];
43d66181 SL	489	sc->sc_blkno = bdbtofsb(a);
43d66181 SL	490	sc->sc_nxrec = bdbtofsb(a)+1;
deb8980a	491	return (0);
83d7e407 BJ	492	}
	493
	494	/ARGSUSED/
942f05a9	495	mtioctl(dev, cmd, data, flag)
83d7e407 BJ	496	dev_t dev;
83d7e407 BJ	497	int cmd;
942f05a9	498	caddr_t data;
83d7e407 BJ	499	int flag;
	500	{
	501	register struct mu_softc *sc = &mu_softc[MUUNIT(dev)];
	502	register struct buf *bp = &cmtbuf[MTUNIT(dev)];
	503	register callcount;
155d9ff0	504	register int op;
83d7e407	505	int fcount;
942f05a9 SL	506	struct mtop *mtop;
942f05a9 SL	507	struct mtget *mtget;
83d7e407 BJ	508	/* we depend of the values and order of the MT codes here */
	509	static mtops[] =
	510	{MT_WTM,MT_SFORWF,MT_SREVF,MT_SFORW,MT_SREV,MT_REW,MT_UNLOAD,MT_SENSE};
	511
	512	switch (cmd) {
942f05a9 SL	513
942f05a9 SL	514	case MTIOCTOP: /* tape operation */
2e9f5990 BJ	515	mtop = (struct mtop *)data;
2e9f5990 BJ	516	switch (mtop->mt_op) {
942f05a9	517
83d7e407	518	case MTWEOF:
942f05a9	519	callcount = mtop->mt_count;
83d7e407 BJ	520	fcount = 1;
83d7e407 BJ	521	break;
942f05a9	522
83d7e407	523	case MTFSF: case MTBSF:
942f05a9	524	callcount = mtop->mt_count;
83d7e407 BJ	525	fcount = 1;
83d7e407 BJ	526	break;
942f05a9	527
83d7e407 BJ	528	case MTFSR: case MTBSR:
83d7e407 BJ	529	callcount = 1;
942f05a9	530	fcount = mtop->mt_count;
83d7e407	531	break;
942f05a9	532
83d7e407 BJ	533	case MTREW: case MTOFFL:
	534	callcount = 1;
	535	fcount = 1;
	536	break;
942f05a9	537
83d7e407	538	default:
473a2e47	539	return (ENXIO);
83d7e407	540	}
473a2e47 BJ	541	if (callcount <= 0 \|\| fcount <= 0)
473a2e47 BJ	542	return (EINVAL);
942f05a9	543	op = mtops[mtop->mt_op];
83d7e407 BJ	544	if (op == MT_WTM)
	545	op \|= sc->sc_dens;
	546	while (--callcount >= 0) {
	547	register int n;
	548
	549	do {
155d9ff0	550	n = MIN(fcount, 0xff);
83d7e407 BJ	551	mtcommand(dev, op, n);
	552	fcount -= n;
	553	} while (fcount);
942f05a9	554	if ((mtop->mt_op == MTFSR \|\| mtop->mt_op == MTBSR) &&
473a2e47 BJ	555	bp->b_resid)
473a2e47 BJ	556	return (EIO);
83d7e407 BJ	557	if (bp->b_flags&B_ERROR)
	558	break;
	559	}
5a1f132a	560	return (geterror(bp));
942f05a9	561
83d7e407	562	case MTIOCGET:
942f05a9 SL	563	mtget = (struct mtget *)data;
	564	mtget->mt_erreg = sc->sc_erreg;
	565	mtget->mt_resid = sc->sc_resid;
83d7e407	566	mtcommand(dev, MT_SENSE, 1); /* update drive status */
942f05a9 SL	567	mtget->mt_dsreg = sc->sc_dsreg;
942f05a9 SL	568	mtget->mt_type = MT_ISMT;
473a2e47	569	break;
942f05a9	570
83d7e407	571	default:
473a2e47	572	return (ENXIO);
83d7e407	573	}
473a2e47	574	return (0);
83d7e407 BJ	575	}
	576
	577	#define DBSIZE 20
	578
	579	mtdump()
	580	{
	581	register struct mba_device *mi;
	582	register struct mba_regs *mp;
83d7e407 BJ	583	int blk, num;
	584	int start;
	585
	586	start = 0;
	587	num = maxfree;
	588	#define phys(a,b) ((b)((int)(a)&0x7fffffff))
	589	if (mtinfo[0] == 0)
	590	return (ENXIO);
	591	mi = phys(mtinfo[0], struct mba_device *);
	592	mp = phys(mi->mi_hd, struct mba_hd *)->mh_physmba;
	593	mp->mba_cr = MBCR_IE;
155d9ff0	594	#if lint
2e9f5990	595	blk = 0; num = blk; start = num; blk = start;
155d9ff0 SL	596	return (0);
155d9ff0 SL	597	#endif
83d7e407	598	#ifdef notyet
155d9ff0	599	mtaddr = (struct mtdevice *)&mp->mba_drv[mi->mi_drive];
83d7e407 BJ	600	mtaddr->mttc = MTTC_PDP11\|MTTC_1600BPI;
	601	mtaddr->mtcs1 = MT_DCLR\|MT_GO;
	602	while (num > 0) {
	603	blk = num > DBSIZE ? DBSIZE : num;
	604	mtdwrite(start, blk, mtaddr, mp);
	605	start += blk;
	606	num -= blk;
	607	}
	608	mteof(mtaddr);
	609	mteof(mtaddr);
	610	mtwait(mtaddr);
	611	if (mtaddr->mtds&MTDS_ERR)
	612	return (EIO);
	613	mtaddr->mtcs1 = MT_REW\|MT_GO;
	614	return (0);
	615	}
	616
	617	mtdwrite(dbuf, num, mtaddr, mp)
	618	register dbuf, num;
	619	register struct mtdevice *mtaddr;
	620	struct mba_regs *mp;
	621	{
	622	register struct pte *io;
	623	register int i;
	624
	625	mtwait(mtaddr);
	626	io = mp->mba_map;
	627	for (i = 0; i < num; i++)
	628	(int )io++ = dbuf++ \| PG_V;
	629	mtaddr->mtfc = -(num*NBPG);
	630	mp->mba_sr = -1;
	631	mp->mba_bcr = -(num*NBPG);
	632	mp->mba_var = 0;
	633	mtaddr->mtcs1 = MT_WCOM\|MT_GO;
	634	}
	635
	636	mtwait(mtaddr)
	637	struct mtdevice *mtaddr;
	638	{
	639	register s;
	640
	641	do
	642	s = mtaddr->mtds;
	643	while ((s & MTDS_DRY) == 0);
	644	}
	645
	646	mteof(mtaddr)
	647	struct mtdevice *mtaddr;
	648	{
	649
	650	mtwait(mtaddr);
	651	mtaddr->mtcs1 = MT_WEOF\|MT_GO;
	652	#endif notyet
	653	}
	654	#endif