/*
 *	SCCS id	@(#)hk.c	2.1 (Berkeley)	12/21/83
 */

/*
 * RK611/RK0[67] disk driver
 *
 * This driver mimics the 4.1bsd rk driver.
 * It does overlapped seeks, ECC, and bad block handling.
 *
 * salkind@nyu
 */

#include "hk.h"
#if	NHK > 0
#include "param.h"
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/conf.h>
#include <sys/dir.h>
#include <sys/user.h>
#include <sys/uba.h>
#ifndef	INTRLVE
#include <sys/inline.h>
#endif
#include <sys/hkreg.h>
#include <sys/dkbad.h>

#define	NHK7CYL	815
#define	NHK6CYL	411
#define	HK_NSECT	22
#define	HK_NTRAC	3
#define	HK_NSPC		(HK_NTRAC*HK_NSECT)

extern	struct size hk_sizes[];
extern	struct hkdevice *HKADDR;

int	hkpip;		/* DEBUG */
int	hknosval;	/* DEBUG */
#ifdef HKDEBUG
int	hkdebug;
#endif

int	hk_offset[] =
{
	HKAS_P400,	HKAS_M400,	HKAS_P400,	HKAS_M400,
	HKAS_P800,	HKAS_M800,	HKAS_P800,	HKAS_M800,
	HKAS_P1200,	HKAS_M1200,	HKAS_P1200,	HKAS_M1200,
	0,		0,		0,		0,
};

int	hk_type[NHK];
int	hk_cyl[NHK];
char	hk_mntflg[NHK];
char	hk_pack[NHK];

struct hk_softc {
	int	sc_softas;
	int	sc_recal;
} hk;

struct	buf	hktab;
struct	buf	hkutab[NHK];
#ifdef	UCB_DBUFS
struct	buf	rhkbuf[NHK];
#else
struct	buf	rhkbuf;
#endif
#ifdef BADSECT
struct	dkbad	hkbad[NHK];
struct	buf	bhkbuf[NHK];
#endif

#define	hkwait(hkaddr)		while ((hkaddr->hkcs1 & HK_CRDY) == 0)
#define	hkncyl(unit)		(hk_type[unit] ? NHK7CYL : NHK6CYL)

#ifdef	INTRLVE
extern	daddr_t	dkblock();
#endif

void
hkroot()
{
	hkattach(HKADDR, 0);
}

hkattach(addr, unit)
struct hkdevice *addr;
{
	if (unit == 0) {
		HKADDR = addr;
		return(1);
	}
	return(0);
}

hkdsel(unit)
register unit;
{
	register struct hkdevice *hkaddr = HKADDR;

	hk_type[unit] = 0;
	hkaddr->hkcs1 = HK_CCLR;
	hkaddr->hkcs2 = unit;
	hkaddr->hkcs1 = HK_DCLR | HK_GO;
	hkwait(hkaddr);
	if((hkaddr->hkcs2&HKCS2_NED) || (hkaddr->hkds&HKDS_SVAL) == 0) {
		hkaddr->hkcs1 = HK_CCLR;
		hkwait(hkaddr);
		return(-1);
	}
	if((hkaddr->hkcs1&HK_CERR) && (hkaddr->hker&HKER_DTYE)) {
		hk_type[unit] = HK_CDT;
		hkaddr->hkcs1 = HK_CCLR;
		hkwait(hkaddr);
	}

	hk_mntflg[unit] = 1;
	hk_cyl[unit] = -1;
	return(0);
}

hkstrategy(bp)
register struct buf *bp;
{
	register struct buf *dp;
	register unit;
	int s;
	long bn;
	long sz;

	unit = minor(bp->b_dev) & 077;
	sz = (bp->b_bcount + 511) >> 9;
	if ((unit >= (NHK << 3)) || (HKADDR == (struct hkdevice *) NULL)) {
		bp->b_error = ENXIO;
		goto bad;
	}
	if (bp->b_blkno < 0 || (bn = dkblock(bp))+sz > hk_sizes[unit & 07].nblocks) {
		bp->b_error = EINVAL;
		goto bad;
	}
	bp->b_cylin = bn / HK_NSPC + hk_sizes[unit & 07].cyloff;
	unit = dkunit(bp);
	if (hk_mntflg[unit] == 0) {
		/* SHOULD BE DONE AT BOOT TIME */
		if (hkdsel(unit) < 0)
			goto bad;
	}
#ifdef UNIBUS_MAP
	mapalloc(bp);
#endif
	dp = &hkutab[unit];
	s = spl5();
	disksort(dp, bp);
	if (dp->b_active == 0) {
		hkustart(unit);
		if (hktab.b_active == 0)
			hkstart();
	}
	splx(s);
	return;
bad:
	bp->b_flags |= B_ERROR;
	iodone(bp);
}

hkustart(unit)
	int unit;
{
	register struct hkdevice *hkaddr = HKADDR;
	register struct buf *bp, *dp;
	int didie = 0;

	if (unit >= NHK || hk_mntflg[unit] == 0)
		return(0);
#ifdef	HK_DKN
	dk_busy &= ~(1<<(unit + HK_DKN));
#endif
	if (hktab.b_active) {
		hk.sc_softas |= (1 << unit);
		return(0);
	}

	hkaddr->hkcs1 = HK_CCLR;
	hkaddr->hkcs2 = unit;
	hkaddr->hkcs1 = hk_type[unit] | HK_DCLR | HK_GO;
	hkwait(hkaddr);

	dp = &hkutab[unit];
	if ((bp = dp->b_actf) == NULL)
		return(0);
	if (dp->b_active)
		goto done;
	dp->b_active = 1;
	if ((hkaddr->hkds & HKDS_VV) == 0 || hk_pack[unit] == 0) {
		/* SHOULD WARN SYSTEM THAT THIS HAPPENED */
#ifdef BADSECT
		struct buf *bbp = &bhkbuf[unit];
#endif

		hkaddr->hkcs1 = hk_type[unit]|HK_PACK|HK_GO;
		hk_pack[unit]++;
#ifdef BADSECT
		bbp->b_flags = B_READ|B_BUSY|B_PHYS;
		bbp->b_dev = bp->b_dev;
		bbp->b_bcount = sizeof(struct dkbad);
		bbp->b_un.b_addr = (caddr_t)&hkbad[unit];
		bbp->b_blkno = (long)hkncyl(unit)*HK_NSPC - HK_NSECT;
		bbp->b_cylin = hkncyl(unit) - 1;
#ifdef UNIBUS_MAP
		mapalloc(bbp);
#endif
		dp->b_actf = bbp;
		bbp->av_forw = bp;
		bp = bbp;
#endif
		hkwait(hkaddr);
	}
	if ((hkaddr->hkds & HKDS_DREADY) != HKDS_DREADY)
		goto done;
#ifdef	NHK > 1
	if (bp->b_cylin == hk_cyl[unit])
		goto done;
	hkaddr->hkcyl = bp->b_cylin;
	hk_cyl[unit] = bp->b_cylin;
	hkaddr->hkcs1 = hk_type[unit] | HK_IE | HK_SEEK | HK_GO;
	didie = 1;
#ifdef	HK_DKN
	unit += HK_DKN;
	dk_busy |= 1 << unit;
	dk_numb[unit] += 1;
#endif	HK_DKN
	return (didie);
#endif	NHK > 1

done:
	if (dp->b_active != 2) {
		dp->b_forw = NULL;
		if (hktab.b_actf == NULL)
			hktab.b_actf = dp;
		else
			hktab.b_actl->b_forw = dp;
		hktab.b_actl = dp;
		dp->b_active = 2;
	}
	return (didie);
}

hkstart()
{
	register struct buf *bp, *dp;
	register struct hkdevice *hkaddr = HKADDR;
	daddr_t bn;
	int sn, tn, cmd, unit;

loop:
	if ((dp = hktab.b_actf) == NULL)
		return(0);
	if ((bp = dp->b_actf) == NULL) {
		hktab.b_actf = dp->b_forw;
		goto loop;
	}
	hktab.b_active++;
	unit = dkunit(bp);
	bn = dkblock(bp);

	sn = bn % HK_NSPC;
	tn = sn / HK_NSECT;
	sn %= HK_NSECT;
retry:
	hkaddr->hkcs1 = HK_CCLR;
	hkaddr->hkcs2 = unit;
	hkaddr->hkcs1 = hk_type[unit] | HK_DCLR | HK_GO;
	hkwait(hkaddr);

	if ((hkaddr->hkds & HKDS_SVAL) == 0) {
		hknosval++;
		goto nosval;
	}
	if (hkaddr->hkds & HKDS_PIP) {
		hkpip++;
		goto retry;
	}
	if ((hkaddr->hkds&HKDS_DREADY) != HKDS_DREADY) {
		printf("hk%d: not ready", unit);
		if ((hkaddr->hkds&HKDS_DREADY) != HKDS_DREADY) {
			printf("\n");
			hkaddr->hkcs1 = hk_type[unit] | HK_DCLR | HK_GO;
			hkwait(hkaddr);
			hkaddr->hkcs1 = HK_CCLR;
			hkwait(hkaddr);
			hktab.b_active = 0;
			hktab.b_errcnt = 0;
			dp->b_actf = bp->av_forw;
			dp->b_active = 0;
			bp->b_flags |= B_ERROR;
			iodone(bp);
			goto loop;
		}
		else
			printf(" (came back!)\n");
	}
nosval:
	hkaddr->hkcyl = bp->b_cylin;
	hk_cyl[unit] = bp->b_cylin;
	hkaddr->hkda = (tn << 8) + sn;
	hkaddr->hkwc = -(bp->b_bcount >> 1);
	hkaddr->hkba = bp->b_un.b_addr;
	cmd = hk_type[unit] | ((bp->b_xmem & 3) << 8) | HK_IE | HK_GO;
	if (bp->b_flags & B_READ)
		cmd |= HK_READ;
	else
		cmd |= HK_WRITE;
	hkaddr->hkcs1 = cmd;
#ifdef	HK_DKN
	dk_busy |= 1 << (HK_DKN + NHK);
	dk_numb[HK_DKN + NHK] += 1;
	dk_wds[HK_DKN + NHK] += bp->b_bcount >> 6;
#endif
	return(1);
}

hkintr()
{
	register struct hkdevice *hkaddr = HKADDR;
	register struct buf *bp, *dp;
	int unit;
	int as = (hkaddr->hkatt >> 8) | hk.sc_softas;
	int needie = 1;

	hk.sc_softas = 0;
	if (hktab.b_active) {
		dp = hktab.b_actf;
		bp = dp->b_actf;
		unit = dkunit(bp);
#ifdef	HK_DKN
		dk_busy &= ~(1 << (HK_DKN + NHK));
#endif
#ifdef BADSECT
		if (bp->b_flags&B_BAD)
			if (hkecc(bp, CONT))
				return;
#endif
		if (hkaddr->hkcs1 & HK_CERR) {
			int recal;
			u_short ds = hkaddr->hkds;
			u_short cs2 = hkaddr->hkcs2;
			u_short er = hkaddr->hker;
#ifdef HKDEBUG
			if (hkdebug) {
				printf("cs2=%b ds=%b er=%b\n",
				    cs2, HKCS2_BITS, ds, 
				    HKDS_BITS, er, HKER_BITS);
			}
#endif
			if (er & HKER_WLE) {
				printf("hk%d: write locked\n", unit);
				bp->b_flags |= B_ERROR;
			} else if (++hktab.b_errcnt > 28 ||
			    ds&HKDS_HARD || er&HKER_HARD || cs2&HKCS2_HARD) {
hard:
#ifdef	UCB_DEVERR
				harderr(bp, "hk");
				printf("cs2=%b ds=%b er=%b\n",
				    cs2, HKCS2_BITS, ds, 
				    HKDS_BITS, er, HKER_BITS);
#else
				deverror(bp, cs2, er);
#endif
				bp->b_flags |= B_ERROR;
				hk.sc_recal = 0;
			} else if (er & HKER_BSE) {
#ifdef BADSECT
				if (hkecc(bp, BSE))
					return;
				else
#endif
					goto hard;
			} else
				hktab.b_active = 0;
			if (cs2&HKCS2_MDS) {
				hkaddr->hkcs2 = HKCS2_SCLR;
				goto retry;
			}
			recal = 0;
			if (ds&HKDS_DROT || er&(HKER_OPI|HKER_SKI|HKER_UNS) ||
			    (hktab.b_errcnt&07) == 4)
				recal = 1;
#ifdef	UCB_ECC
			if ((er & (HKER_DCK|HKER_ECH)) == HKER_DCK)
				if (hkecc(bp, ECC))
					return;
#endif
			hkaddr->hkcs1 = HK_CCLR;
			hkaddr->hkcs2 = unit;
			hkaddr->hkcs1 = hk_type[unit]|HK_DCLR|HK_GO;
			hkwait(hkaddr);
			if (recal && hktab.b_active == 0) {
				hkaddr->hkcs1 = hk_type[unit]|HK_IE|HK_RECAL|HK_GO;
				hk_cyl[unit] = -1;
				hk.sc_recal = 0;
				goto nextrecal;
			}
		}
retry:
		switch (hk.sc_recal) {

		case 1:
			hkaddr->hkcyl = bp->b_cylin;
			hk_cyl[unit] = bp->b_cylin;
			hkaddr->hkcs1 = hk_type[unit]|HK_IE|HK_SEEK|HK_GO;
			goto nextrecal;
		case 2:
			if (hktab.b_errcnt < 16 ||
			    (bp->b_flags&B_READ) == 0)
				goto donerecal;
			hkaddr->hkatt = hk_offset[hktab.b_errcnt & 017];
			hkaddr->hkcs1 = hk_type[unit]|HK_IE|HK_OFFSET|HK_GO;
			/* fall into ... */
		nextrecal:
			hk.sc_recal++;
			hkwait(hkaddr);
			hktab.b_active = 1;
			return;
		donerecal:
		case 3:
			hk.sc_recal = 0;
			hktab.b_active = 0;
			break;
		}
		if (hktab.b_active) {
			hktab.b_active = 0;
			hktab.b_errcnt = 0;
			hktab.b_actf = dp->b_forw;
			dp->b_active = 0;
			dp->b_errcnt = 0;
			dp->b_actf = bp->av_forw;
			bp->b_resid = -(hkaddr->hkwc << 1);
			iodone(bp);
			if (dp->b_actf)
				if (hkustart(unit))
					needie = 0;
		}
		as &= ~(1<<unit);
	}
	for (unit = 0; as; as >>= 1, unit++)
		if (as & 1) {
			if (unit < NHK && hk_mntflg[unit]) {
				if (hkustart(unit))
					needie = 0;
			} else {
				hkaddr->hkcs1 = HK_CCLR;
				hkaddr->hkcs2 = unit;
				hkaddr->hkcs1 = HK_DCLR | HK_GO;
				hkwait(hkaddr);
				hkaddr->hkcs1 = HK_CCLR;
			}
		}
	if (hktab.b_actf && hktab.b_active == 0)
		if (hkstart())
			needie = 0;
	if (needie)
		hkaddr->hkcs1 = HK_IE;
}

hkread(dev)
dev_t	dev;
{
#ifdef	UCB_DBUFS
	register int unit = (minor(dev) >> 3) & 07;

	if (unit >= NHK)
		u.u_error = ENXIO;
	else
		physio(hkstrategy, &rhkbuf[unit], dev, B_READ);
#else
	physio(hkstrategy, &rhkbuf, dev, B_READ);
#endif
}

hkwrite(dev)
dev_t	dev;
{
#ifdef	UCB_DBUFS
	register int unit = (minor(dev) >> 3) & 07;

	if (unit >= NHK)
		u.u_error = ENXIO;
	else
		physio(hkstrategy, &rhkbuf[unit], dev, B_WRITE);
#else
	physio(hkstrategy, &rhkbuf, dev, B_WRITE);
#endif
}

#ifdef	HK_DUMP
/*
 *  Dump routine for RK06/07
 *  Dumps from dumplo to end of memory/end of disk section for minor(dev).
 *  It uses the UNIBUS map to dump all of memory if there is a UNIBUS map.
 */
#ifdef	UNIBUS_MAP
#define	DBSIZE	(UBPAGE/PGSIZE)		/* unit of transfer, one UBPAGE */
#else
#define DBSIZE	16			/* unit of transfer, same number */
#endif

hkdump(dev)
	dev_t dev;
{
	register struct hkdevice *hkaddr = HKADDR;
	daddr_t	bn, dumpsize;
	long paddr;
	register count;
#ifdef	UNIBUS_MAP
	extern bool_t ubmap;
	register struct ubmap *ubp;
#endif
	int com, cn, tn, sn, unit;

	unit = minor(dev) >> 3;
	if ((bdevsw[major(dev)].d_strategy != hkstrategy)	/* paranoia */
	    || unit >= NHK)
		return(EINVAL);
	dumpsize = hk_sizes[minor(dev)&07].nblocks;
	if ((dumplo < 0) || (dumplo >= dumpsize))
		return(EINVAL);
	dumpsize -= dumplo;

	hkaddr->hkcs1 = HK_CCLR;
	hkwait(hkaddr);
	hkaddr->hkcs2 = unit;
	hkaddr->hkcs1 = hk_type[unit] | HK_DCLR | HK_GO;
	hkwait(hkaddr);
	if ((hkaddr->hkds & HKDS_VV) == 0) {
		hkaddr->hkcs1 = hk_type[unit]|HK_IE|HK_PACK|HK_GO;
		hkwait(hkaddr);
	}
#ifdef	UNIBUS_MAP
	ubp = &UBMAP[0];
#endif
	for (paddr = 0L; dumpsize > 0; dumpsize -= count) {
		count = dumpsize>DBSIZE? DBSIZE: dumpsize;
		bn = dumplo + (paddr >> PGSHIFT);
		cn = (bn/HK_NSPC) + hk_sizes[minor(dev)&07].cyloff;
		sn = bn%HK_NSPC;
		tn = sn/HK_NSECT;
		sn = sn%HK_NSECT;
		hkaddr->hkcyl = cn;
		hkaddr->hkda = (tn << 8) | sn;
		hkaddr->hkwc = -(count << (PGSHIFT-1));
		com = hk_type[unit]|HK_GO|HK_WRITE;
#ifdef	UNIBUS_MAP
		/*
		 *  If UNIBUS_MAP exists, use the map.
		 */
		if (ubmap) {
			ubp->ub_lo = loint(paddr);
			ubp->ub_hi = hiint(paddr);
			hkaddr->hkba = 0;
		} else {
#endif
			/* non UNIBUS map */
			hkaddr->hkba = loint(paddr);
			com |= ((paddr >> 8) & (03 << 8));
#ifdef	UNIBUS_MAP
		}
#endif
		hkaddr->hkcs2 = unit;
		hkaddr->hkcs1 = com;
		hkwait(hkaddr);
		if (hkaddr->hkcs1 & HK_CERR) {
			if (hkaddr->hkcs2 & HKCS2_NEM)
				return(0);	/* made it to end of memory */
			return(EIO);
		}
		paddr += (DBSIZE << PGSHIFT);
	}
	return(0);		/* filled disk minor dev */
}
#endif	HK_DUMP

#ifdef	UCB_ECC
#define	exadr(x,y)	(((long)(x) << 16) | (unsigned)(y))

/*
 * Correct an ECC error and restart the i/o to complete
 * the transfer if necessary.  This is quite complicated because
 * the transfer may be going to an odd memory address base
 * and/or across a page boundary.
 */
hkecc(bp, flag)
register struct	buf *bp;
{
	register struct	hkdevice *hkaddr = HKADDR;
	ubadr_t	addr;
	int npx, wc;
	int cn, tn, sn;
	daddr_t	bn;
	unsigned ndone;
	int cmd;
	int unit;

#ifdef BADSECT
	if (flag == CONT) {
		npx = bp->b_error;
		ndone = npx * PGSIZE;
		wc = ((int)(ndone - bp->b_bcount)) / NBPW;
	} else
#endif
		{
		wc = hkaddr->hkwc;
		ndone = (wc * NBPW) + bp->b_bcount;
		npx = ndone / PGSIZE;
		}
	unit = dkunit(bp);
	bn = dkblock(bp);
	cn = bp->b_cylin - bn / HK_NSPC;
	bn += npx;
	cn += bn / HK_NSPC;
	sn = bn % HK_NSPC;
	tn = sn / HK_NSECT;
	sn %= HK_NSECT;
	hktab.b_active++;

	switch (flag) {
	case ECC:
		{
		register byte;
		int bit;
		long mask;
		ubadr_t bb;
		unsigned o;
#ifdef	UNIBUS_MAP
		struct ubmap *ubp;
#endif
		printf("hk%d%c:  soft ecc sn %D\n",
			unit, 'a' + (minor(bp->b_dev) & 07),
			bp->b_blkno + npx - 1);

		mask = hkaddr->hkecpt;
		byte = hkaddr->hkecps - 1;
		bit = byte & 07;
		byte >>= 3;
		mask <<= bit;
		o = (ndone - PGSIZE) + byte;
		bb = exadr(bp->b_xmem, bp->b_un.b_addr);
		bb += o;
#ifdef	UNIBUS_MAP
		if (bp->b_flags & (B_MAP|B_UBAREMAP))	{
			ubp = UBMAP + ((bb >> 13) & 037);
			bb = exadr(ubp->ub_hi, ubp->ub_lo) + (bb & 017777);
		}
#endif
		/*
		 * Correct until mask is zero or until end of
		 * sector or transfer, whichever comes first.
		 */
		while (byte < PGSIZE && o < bp->b_bcount && mask != 0) {
			putmemc(bb, getmemc(bb) ^ (int)mask);
			byte++;
			o++;
			bb++;
			mask >>= 8;
		}
		if (wc == 0)
			return(0);
		break;
	}

#ifdef BADSECT
	case BSE:
#ifdef HKDEBUG
		if (hkdebug)
			printf("hkecc, BSE: bn %D cn %d tn %d sn %d\n",
				bn, cn, tn, sn);
#endif
		if ((bn = isbad(&hkbad[unit], cn, tn, sn)) < 0)
			return(0);
		bp->b_flags |= B_BAD;
		bp->b_error = npx + 1;
		bn = (long)hkncyl(unit)*HK_NSPC - HK_NSECT - 1 - bn;
		cn = bn/HK_NSPC;
		sn = bn%HK_NSPC;
		tn = sn/HK_NSECT;
		sn %= HK_NSECT;
#ifdef HKDEBUG
		if (hkdebug)
			printf("revector to cn %d tn %d sn %d\n", cn, tn, sn);
#endif
		wc = -(512 / NBPW);
		break;

	case CONT:
		bp->b_flags &= ~B_BAD;
		if (wc == 0)
			return(0);
#ifdef HKDEBUG
		if (hkdebug)
			printf("hkecc, CONT: bn %D cn %d tn %d sn %d\n",
				bn, cn, tn, sn);
#endif
		break;
#endif	BADSECT
	}
	/*
	 * Have to continue the transfer.  Clear the drive
	 * and compute the position where the transfer is to continue.
	 * We have completed npx sectors of the transfer already.
	 */
	hkaddr->hkcs1 = HK_CCLR;
	hkwait(hkaddr);
	hkaddr->hkcs2 = unit;
	hkaddr->hkcs1 = hk_type[unit] | HK_DCLR | HK_GO;
	hkwait(hkaddr);

	addr = exadr(bp->b_xmem, bp->b_un.b_addr);
	addr += ndone;
	hkaddr->hkcyl = cn;
	hkaddr->hkda = (tn << 8) + sn;
	hkaddr->hkwc = wc;
	hkaddr->hkba = (int)addr;
	cmd = hk_type[unit] | ((hiint(addr) & 3) << 8) | HK_IE | HK_GO;
	if (bp->b_flags & B_READ)
		cmd |= HK_READ;
	else
		cmd |= HK_WRITE;
	hkaddr->hkcs1 = cmd;
	hktab.b_errcnt = 0;	/* error has been corrected */
	return (1);
}
#endif	UCB_ECC
#endif	NHK > 0