[unix-history] / usr / src / sys / tahoestand / vd.c

/*	vd.c	7.10	88/06/14	*/

/*
 * Stand alone driver for the VDDC/SMDE controller 
 */
#include "../machine/mtpr.h"

#include "param.h"
#include "inode.h"
#include "fs.h"
#include "buf.h"
#include "disklabel.h"
#include "saio.h"

#include "../tahoevba/vdreg.h"
#include "../tahoevba/vbaparam.h"

#define	COMPAT_42	1

#define NVD		4		/* controllers */
#define	NDRIVE		8		/* drives per controller */

#define	VDADDR(ctlr)	((struct vddevice *)vdaddrs[ctlr])
long	vdaddrs[NVD] = { 0xffff2000, 0xffff2100, 0xffff2200, 0xffff2300 };

u_char	vdinit[NVD];			/* controller initialized */
u_char	vdtype[NVD];			/* controller type */
u_char	dkconfigured[NVD][NDRIVE];	/* unit configured */
u_char	dkflags[NVD][NDRIVE];		/* unit flags */

static	struct disklabel dklabel[NVD][NDRIVE];	/* pack label */
static	struct mdcb mdcb;
static	struct dcb dcb;
static	char lbuf[DEV_BSIZE];

vdopen(io)
	register struct iob *io;
{
	register int ctlr = io->i_ctlr;
	register struct dkinfo *dk;
	register struct disklabel *lp, *dlp;
	int error;

	if ((u_int)io->i_adapt)
		return (EADAPT);
	if ((u_int)ctlr >= NVD)
		return (ECTLR);
	if (!vdinit[ctlr] && (error = vdreset_ctlr(ctlr, io->i_unit)))
		return (error);
	lp = &dklabel[io->i_ctlr][io->i_unit];
	if (!dkconfigured[io->i_ctlr][io->i_unit]) {
		struct iob tio;

		/*
		 * Read in the pack label.
		 */
		lp->d_secsize = 1024;
		lp->d_nsectors = 72;
		lp->d_ntracks = 24;
		lp->d_ncylinders = 711;
		lp->d_secpercyl = 72*24;
		if (!vdreset_drive(io))
			return (ENXIO);
		tio = *io;
		tio.i_bn = LABELSECTOR;
		tio.i_ma = lbuf;
		tio.i_cc = DEV_BSIZE;
		tio.i_flgs |= F_RDDATA;
		if (vdstrategy(&tio, READ) != DEV_BSIZE)
			return (ERDLAB);
		dlp = (struct disklabel *)(lbuf + LABELOFFSET);
		if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC)
#ifdef COMPAT_42
		{
			printf("dk%d: unlabeled\n", io->i_unit);
			if (error = vdmaptype(io))
				return (error);
		}
#else
			return (EUNLAB);
#endif
		else {
			*lp = *dlp;
			if (!vdreset_drive(io))
				return (ENXIO);
		}
		dkconfigured[io->i_ctlr][io->i_unit] = 1;
	}
	if (io->i_part < 0 || io->i_part >= lp->d_npartitions ||
	    lp->d_partitions[io->i_part].p_size == 0)
		return (EPART);
	io->i_boff =
	    (lp->d_partitions[io->i_part].p_offset * lp->d_secsize) / DEV_BSIZE;
	return (0);
}

/*
 * Reset and initialize the controller.
 */
vdreset_ctlr(ctlr, unit)
	register int ctlr, unit;
{
	register int i;
	register struct vddevice *vdaddr = VDADDR(ctlr);

	if (badaddr(vdaddr, 2)) {
		printf("vd%d: %x: invalid csr\n", ctlr, vdaddr);
		return (ENXIO);
	}
	/* probe further to find what kind of controller it is */
	vdaddr->vdreset = 0xffffffff;
	DELAY(1000000);
	if (vdaddr->vdreset != 0xffffffff) {
		vdtype[ctlr] = VDTYPE_VDDC;
		DELAY(1000000);
	} else {
		vdtype[ctlr] = VDTYPE_SMDE;
		vdaddr->vdrstclr = 0;
		DELAY(3000000);
		vdaddr->vdcsr =  0;
		vdaddr->vdtcf_mdcb = AM_ENPDA;
		vdaddr->vdtcf_dcb = AM_ENPDA;
		vdaddr->vdtcf_trail = AM_ENPDA;
		vdaddr->vdtcf_data = AM_ENPDA;
		vdaddr->vdccf = CCF_SEN | CCF_DER | CCF_STS |
		    XMD_32BIT | BSZ_16WRD |
		    CCF_ENP | CCF_EPE | CCF_EDE | CCF_ECE | CCF_ERR;
	}
	if (!vdcmd(ctlr, 0, VDOP_INIT, 10) ||
	    !vdcmd(ctlr, 0, VDOP_DIAG, 10)) {
		vderror(unit, dcb.opcode == VDOP_INIT ? "init" : "diag", &dcb);
		return (EIO);
	}
	vdinit[ctlr] = 1;
	for (i = NDRIVE - 1; i >= 0; i--)
		dkconfigured[ctlr][i] = 0;
	return (0);
}

/*
 * Reset and configure a drive's parameters.
 */
vdreset_drive(io)
	register struct iob *io;
{
	register int ctlr = io->i_ctlr, slave = io->i_unit;
	register struct disklabel *lp = &dklabel[io->i_ctlr][io->i_unit];
	register struct vddevice *vdaddr = VDADDR(ctlr);
	int pass = 0, type = vdtype[ctlr], error;
	int devflags = dkflags[ctlr][slave];		/* starts with 0 */

again:
	dcb.opcode = VDOP_CONFIG;		/* command */
	dcb.intflg = DCBINT_NONE;
	dcb.nxtdcb = (struct dcb *)0;	/* end of chain */
	dcb.operrsta = 0;
	dcb.devselect = slave | devflags;
	dcb.trail.rstrail.ncyl = lp->d_ncylinders;
	dcb.trail.rstrail.nsurfaces = lp->d_ntracks;
	if (type == VDTYPE_SMDE) {
		dcb.trailcnt = sizeof (struct treset) / sizeof (long);
		dcb.trail.rstrail.nsectors = lp->d_nsectors;
		dcb.trail.rstrail.slip_sec = lp->d_trackskew;
		dcb.trail.rstrail.recovery = VDRF_NORMAL;
	} else
		dcb.trailcnt = 2;	/* XXX */
	mdcb.mdcb_head = &dcb;
	mdcb.mdcb_status = 0;
	VDGO(vdaddr, (u_long)&mdcb, type);
	if (!vdpoll(vdaddr, &dcb, 10, type)) {
		if (pass++ != 0) {
			printf(" during drive configuration.\n");
			return (0);
		}
		VDRESET(vdaddr, type);
		if (error = vdreset_ctlr(ctlr, io->i_unit))
			return (error);
		goto again;
	}
	if ((dcb.operrsta & VDERR_HARD) == 0) {		/* success */
		dkflags[ctlr][slave] = devflags;
		return (1);
	}
	if (devflags == 0) {
		devflags = VD_ESDI;
		goto again;
	}
	if (type == VDTYPE_SMDE && (vdaddr->vdstatus[slave] & STA_US) == 0) {
		printf("dk%d: nonexistent drive\n", io->i_unit);
		return (0);
	}
	if ((dcb.operrsta & (DCBS_OCYL|DCBS_NRDY)) == 0) {
		vderror(io->i_unit, "config", &dcb);
		return (0);
	}
	devflags = 0;
	if (pass++)			/* give up */
		return (0);
	/*
	 * Try to spin up drive with remote command.
	 */
	if (!vdcmd(ctlr, 0, VDOP_START, 62)) {
		vderror(io->i_unit, "start", &dcb);
		return (0);
	}
	DELAY(62000000);
	goto again;
}

vdcmd(ctlr, unit, cmd, time)
	register int ctlr;
	int unit, cmd, time;
{
	register struct vddevice *vdaddr = VDADDR(ctlr);

	dcb.opcode = cmd;
	dcb.intflg = DCBINT_NONE;
	dcb.nxtdcb = (struct dcb *)0;	/* end of chain */
	dcb.operrsta  = 0;
	dcb.devselect = unit | dkflags[ctlr][unit];
	dcb.trailcnt = 0;
	mdcb.mdcb_head = &dcb;
	mdcb.mdcb_status = 0;
	VDGO(vdaddr, (u_long)&mdcb, vdtype[ctlr]);
	if (!vdpoll(vdaddr, &dcb, time, vdtype[ctlr]))
		_stop(" during initialization operation.\n");
	return ((dcb.operrsta & VDERR_HARD) == 0);
}

vdstrategy(io, cmd)
	register struct iob *io;
	int cmd;
{
	register struct disklabel *lp;
	int ctlr, cn, tn, sn, slave, retries = 0;
	daddr_t bn;
	struct vddevice *vdaddr;

	if (io->i_cc == 0 || io->i_cc > 65535) {
		printf("dk%d: invalid transfer size %d\n", io->i_unit,
		    io->i_cc);
		io->i_error = EIO;
		return (-1);
	}
	lp = &dklabel[io->i_ctlr][io->i_unit];
	bn = io->i_bn * (DEV_BSIZE / lp->d_secsize);
	cn = bn / lp->d_secpercyl;
	sn = bn % lp->d_secpercyl;
	tn = sn / lp->d_nsectors;
	sn = sn % lp->d_nsectors;

top:
	dcb.opcode = (cmd == READ ? VDOP_RD : VDOP_WD);
	dcb.intflg = DCBINT_NONE;
	dcb.nxtdcb = (struct dcb *)0;	/* end of chain */
	dcb.operrsta  = 0;
	ctlr = io->i_ctlr;
	slave = io->i_unit;
	dcb.devselect = slave | dkflags[ctlr][slave];
	dcb.trailcnt = sizeof (struct trrw) / sizeof (int);
	dcb.trail.rwtrail.memadr = (u_long)io->i_ma; 
	dcb.trail.rwtrail.wcount = (io->i_cc + 1) / sizeof (short);
	dcb.trail.rwtrail.disk.cylinder = cn;
	dcb.trail.rwtrail.disk.track = tn;
	dcb.trail.rwtrail.disk.sector = sn;
	mdcb.mdcb_head = &dcb;
	mdcb.mdcb_status = 0;
	vdaddr = VDADDR(ctlr);
	VDGO(vdaddr, (u_long)&mdcb, vdtype[ctlr]);
	if (!vdpoll(vdaddr, &dcb, 60, vdtype[ctlr]))
		_stop(" during i/o operation.\n");
	if (dcb.operrsta & VDERR_HARD) {
		if (retries++ == 0 && vdreset_ctlr(ctlr, io->i_unit) == 0 &&
		    vdreset_drive(io))
			goto top;
		vderror(io->i_unit, cmd == READ ? "read" : "write", &dcb);
		io->i_error = EIO;
		return (-1);
	}
	mtpr(PADC, 0);
	return (io->i_cc);
}

vderror(unit, cmd, dcb)
	int unit;
	char *cmd;
	struct dcb *dcb;
{

	printf("dk%d: %s error; status %b", unit, cmd,
	    dcb->operrsta, VDERRBITS);
	if (dcb->err_code)
		printf(", code %x", dcb->err_code);
	printf("\n");
}

/*
 * Poll controller until operation
 * completes or timeout expires.
 */
vdpoll(vdaddr, dcb, t, type)
	register struct vddevice *vdaddr;
	register struct dcb *dcb;
	register int t, type;
{

	t *= 1000;
	for (;;) {
		uncache(&dcb->operrsta);
		if (dcb->operrsta & (DCBS_DONE|DCBS_ABORT))
			break;
		if (--t <= 0) {
			printf("vd: controller timeout");
			VDABORT(vdaddr, type);
			DELAY(30000);
			uncache(&dcb->operrsta);
			return (0);
		}
		DELAY(1000);
	}
	if (type == VDTYPE_SMDE) {
		for (;;) {
			uncache(&vdaddr->vdcsr);
			if ((vdaddr->vdcsr & CS_GO) == 0)
				break;
			DELAY(50);
		}
		DELAY(300);
		uncache(&dcb->err_code);
	}
	DELAY(200);
	uncache(&dcb->operrsta);
	return (1);
}

#ifdef COMPAT_42
struct	dkcompat {
	int	nsectors;		/* sectors per track */
	int	ntracks;		/* tracks per cylinder */
	int	ncylinders;		/* cylinders per drive */
	int	secsize;		/* sector size */
#define	NPART	2
	int	poff[NPART];		/* [a+b] for bootstrapping */
} dkcompat[] = {
	{ 64, 20,  842,  512, 0, 61440 },	/* 2361a eagle */
	{ 48, 24,  711,  512, 0, 61056 },	/* xsd */
	{ 44, 20,  842,  512, 0, 52800 },	/* eagle */
	{ 64, 10,  823,  512, 0, 38400 },	/* fuji 360 */
	{ 32, 24,  711,  512, 0, 40704 },	/* xfd */
	{ 32, 19,  823,  512, 0, 40128 },	/* smd */
	{ 32, 10,  823,  512, 0, 19200 },	/* fsd */
	{ 18, 15, 1224, 1024, 0, 21600 },	/* mxd */
};
#define	NDKCOMPAT	(sizeof (dkcompat) / sizeof (dkcompat[0]))

/*
 * Identify and configure drive from above table
 * by trying to read the last sector until a description
 * is found for which we're successful.
 */
vdmaptype(io)
	struct iob *io;
{
	register struct disklabel *lp = &dklabel[io->i_ctlr][io->i_unit];
	register struct dkcompat *dp;
	int i, ctlr, slave, type;
	struct vddevice *vdaddr;

	ctlr = io->i_ctlr;
	slave = io->i_unit;
	vdaddr = VDADDR(ctlr);
	type = vdtype[ctlr];
	for (dp = dkcompat; dp < &dkcompat[NDKCOMPAT]; dp++) {
		if (type == VDTYPE_VDDC && dp->nsectors != 32)
			continue;
		lp->d_nsectors = dp->nsectors;
		lp->d_ntracks = dp->ntracks;
		lp->d_ncylinders = dp->ncylinders;
		lp->d_secsize = dp->secsize;
		if (!vdreset_drive(io))		/* set drive parameters */
			return (EIO);
		dcb.opcode = VDOP_RD;
		dcb.intflg = DCBINT_NONE;
		dcb.nxtdcb = (struct dcb *)0;	/* end of chain */
		dcb.devselect = slave | dkflags[ctlr][slave];
		dcb.operrsta = 0;
		dcb.trailcnt = sizeof (struct trrw) / sizeof (long);
		dcb.trail.rwtrail.memadr = (u_long)lbuf; 
		dcb.trail.rwtrail.wcount = lp->d_secsize / sizeof (short);
		dcb.trail.rwtrail.disk.cylinder = dp->ncylinders - 2;
		dcb.trail.rwtrail.disk.track = dp->ntracks - 1;
		dcb.trail.rwtrail.disk.sector = dp->nsectors - 1;
		mdcb.mdcb_head = &dcb;
		mdcb.mdcb_status = 0;
		VDGO(vdaddr, (u_long)&mdcb, type);
		if (!vdpoll(vdaddr, &dcb, 60, type))
			_stop(" during i/o operation.\n");
		if (dcb.operrsta & VDERR_HARD)
			continue;
		/* simulate necessary parts of disk label */
		lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
		lp->d_secperunit = lp->d_secpercyl * lp->d_ncylinders;
		lp->d_npartitions = NPART;
		for (i = 0; i < NPART; i++) {
			lp->d_partitions[i].p_offset = dp->poff[i];
			lp->d_partitions[i].p_size =
			    lp->d_secperunit - dp->poff[i];
		}
		return (0);
	}
	printf("dk%d: unknown drive type\n", io->i_unit);
	return (ENXIO);
}
#endif
Commit	Line	Data
7fa7373f C	1	/* vd.c 7.10 88/06/14 */
	2
	3	/*
	4	* Stand alone driver for the VDDC/SMDE controller
	5	*/
	6	#include "../machine/mtpr.h"
	7
	8	#include "param.h"
	9	#include "inode.h"
	10	#include "fs.h"
	11	#include "buf.h"
	12	#include "disklabel.h"
	13	#include "saio.h"
	14
	15	#include "../tahoevba/vdreg.h"
	16	#include "../tahoevba/vbaparam.h"
	17
	18	#define COMPAT_42 1
	19
	20	#define NVD 4 /* controllers */
	21	#define NDRIVE 8 /* drives per controller */
	22
	23	#define VDADDR(ctlr) ((struct vddevice *)vdaddrs[ctlr])
	24	long vdaddrs[NVD] = { 0xffff2000, 0xffff2100, 0xffff2200, 0xffff2300 };
	25
	26	u_char vdinit[NVD]; /* controller initialized */
	27	u_char vdtype[NVD]; /* controller type */
	28	u_char dkconfigured[NVD][NDRIVE]; /* unit configured */
	29	u_char dkflags[NVD][NDRIVE]; /* unit flags */
	30
	31	static struct disklabel dklabel[NVD][NDRIVE]; /* pack label */
	32	static struct mdcb mdcb;
	33	static struct dcb dcb;
	34	static char lbuf[DEV_BSIZE];
	35
	36	vdopen(io)
	37	register struct iob *io;
	38	{
	39	register int ctlr = io->i_ctlr;
	40	register struct dkinfo *dk;
	41	register struct disklabel lp, dlp;
	42	int error;
	43
	44	if ((u_int)io->i_adapt)
	45	return (EADAPT);
	46	if ((u_int)ctlr >= NVD)
	47	return (ECTLR);
	48	if (!vdinit[ctlr] && (error = vdreset_ctlr(ctlr, io->i_unit)))
	49	return (error);
	50	lp = &dklabel[io->i_ctlr][io->i_unit];
	51	if (!dkconfigured[io->i_ctlr][io->i_unit]) {
	52	struct iob tio;
	53
	54	/*
	55	* Read in the pack label.
	56	*/
	57	lp->d_secsize = 1024;
	58	lp->d_nsectors = 72;
	59	lp->d_ntracks = 24;
	60	lp->d_ncylinders = 711;
	61	lp->d_secpercyl = 72*24;
	62	if (!vdreset_drive(io))
	63	return (ENXIO);
	64	tio = *io;
65	tio.i_bn = LABELSECTOR;
66	tio.i_ma = lbuf;
67	tio.i_cc = DEV_BSIZE;
68	tio.i_flgs \|= F_RDDATA;
69	if (vdstrategy(&tio, READ) != DEV_BSIZE)
70	return (ERDLAB);
71	dlp = (struct disklabel *)(lbuf + LABELOFFSET);
72	if (dlp->d_magic != DISKMAGIC \|\| dlp->d_magic2 != DISKMAGIC)
73	#ifdef COMPAT_42
74	{
75	printf("dk%d: unlabeled\n", io->i_unit);
76	if (error = vdmaptype(io))
77	return (error);
78	}
79	#else
80	return (EUNLAB);
81	#endif
82	else {
83	lp = dlp;
84	if (!vdreset_drive(io))
85	return (ENXIO);
86	}
87	dkconfigured[io->i_ctlr][io->i_unit] = 1;
88	}
89	if (io->i_part < 0 \|\| io->i_part >= lp->d_npartitions \|\|
90	lp->d_partitions[io->i_part].p_size == 0)
91	return (EPART);
92	io->i_boff =
93	(lp->d_partitions[io->i_part].p_offset * lp->d_secsize) / DEV_BSIZE;
94	return (0);
95	}
96
97	/*
98	* Reset and initialize the controller.
99	*/
100	vdreset_ctlr(ctlr, unit)
101	register int ctlr, unit;
102	{
103	register int i;
104	register struct vddevice *vdaddr = VDADDR(ctlr);
105
106	if (badaddr(vdaddr, 2)) {
107	printf("vd%d: %x: invalid csr\n", ctlr, vdaddr);
108	return (ENXIO);
109	}
110	/* probe further to find what kind of controller it is */
111	vdaddr->vdreset = 0xffffffff;
112	DELAY(1000000);
113	if (vdaddr->vdreset != 0xffffffff) {
114	vdtype[ctlr] = VDTYPE_VDDC;
115	DELAY(1000000);
116	} else {
117	vdtype[ctlr] = VDTYPE_SMDE;
118	vdaddr->vdrstclr = 0;
119	DELAY(3000000);
120	vdaddr->vdcsr = 0;
121	vdaddr->vdtcf_mdcb = AM_ENPDA;
122	vdaddr->vdtcf_dcb = AM_ENPDA;
123	vdaddr->vdtcf_trail = AM_ENPDA;
124	vdaddr->vdtcf_data = AM_ENPDA;
125	vdaddr->vdccf = CCF_SEN \| CCF_DER \| CCF_STS \|
126	XMD_32BIT \| BSZ_16WRD \|
127	CCF_ENP \| CCF_EPE \| CCF_EDE \| CCF_ECE \| CCF_ERR;
128	}
129	if (!vdcmd(ctlr, 0, VDOP_INIT, 10) \|\|
130	!vdcmd(ctlr, 0, VDOP_DIAG, 10)) {
131	vderror(unit, dcb.opcode == VDOP_INIT ? "init" : "diag", &dcb);
132	return (EIO);
133	}
134	vdinit[ctlr] = 1;
135	for (i = NDRIVE - 1; i >= 0; i--)
136	dkconfigured[ctlr][i] = 0;
137	return (0);
138	}
139
140	/*
141	* Reset and configure a drive's parameters.
142	*/
143	vdreset_drive(io)
144	register struct iob *io;
145	{
146	register int ctlr = io->i_ctlr, slave = io->i_unit;
147	register struct disklabel *lp = &dklabel[io->i_ctlr][io->i_unit];
148	register struct vddevice *vdaddr = VDADDR(ctlr);
149	int pass = 0, type = vdtype[ctlr], error;
150	int devflags = dkflags[ctlr][slave]; /* starts with 0 */
151
152	again:
153	dcb.opcode = VDOP_CONFIG; /* command */
154	dcb.intflg = DCBINT_NONE;
155	dcb.nxtdcb = (struct dcb )0; / end of chain */
156	dcb.operrsta = 0;
157	dcb.devselect = slave \| devflags;
158	dcb.trail.rstrail.ncyl = lp->d_ncylinders;
159	dcb.trail.rstrail.nsurfaces = lp->d_ntracks;
160	if (type == VDTYPE_SMDE) {
161	dcb.trailcnt = sizeof (struct treset) / sizeof (long);
162	dcb.trail.rstrail.nsectors = lp->d_nsectors;
163	dcb.trail.rstrail.slip_sec = lp->d_trackskew;
164	dcb.trail.rstrail.recovery = VDRF_NORMAL;
165	} else
166	dcb.trailcnt = 2; /* XXX */
167	mdcb.mdcb_head = &dcb;
168	mdcb.mdcb_status = 0;
169	VDGO(vdaddr, (u_long)&mdcb, type);
170	if (!vdpoll(vdaddr, &dcb, 10, type)) {
171	if (pass++ != 0) {
172	printf(" during drive configuration.\n");
173	return (0);
174	}
175	VDRESET(vdaddr, type);
176	if (error = vdreset_ctlr(ctlr, io->i_unit))
177	return (error);
178	goto again;
179	}
180	if ((dcb.operrsta & VDERR_HARD) == 0) { /* success */
181	dkflags[ctlr][slave] = devflags;
182	return (1);
183	}
184	if (devflags == 0) {
185	devflags = VD_ESDI;
186	goto again;
187	}
188	if (type == VDTYPE_SMDE && (vdaddr->vdstatus[slave] & STA_US) == 0) {
189	printf("dk%d: nonexistent drive\n", io->i_unit);
190	return (0);
191	}
192	if ((dcb.operrsta & (DCBS_OCYL\|DCBS_NRDY)) == 0) {
193	vderror(io->i_unit, "config", &dcb);
194	return (0);
195	}
196	devflags = 0;
197	if (pass++) /* give up */
198	return (0);
199	/*
200	* Try to spin up drive with remote command.
201	*/
202	if (!vdcmd(ctlr, 0, VDOP_START, 62)) {
203	vderror(io->i_unit, "start", &dcb);
204	return (0);
205	}
206	DELAY(62000000);
207	goto again;
208	}
209
210	vdcmd(ctlr, unit, cmd, time)
211	register int ctlr;
212	int unit, cmd, time;
213	{
214	register struct vddevice *vdaddr = VDADDR(ctlr);
215
216	dcb.opcode = cmd;
217	dcb.intflg = DCBINT_NONE;
218	dcb.nxtdcb = (struct dcb )0; / end of chain */
219	dcb.operrsta = 0;
220	dcb.devselect = unit \| dkflags[ctlr][unit];
221	dcb.trailcnt = 0;
222	mdcb.mdcb_head = &dcb;
223	mdcb.mdcb_status = 0;
224	VDGO(vdaddr, (u_long)&mdcb, vdtype[ctlr]);
225	if (!vdpoll(vdaddr, &dcb, time, vdtype[ctlr]))
226	_stop(" during initialization operation.\n");
227	return ((dcb.operrsta & VDERR_HARD) == 0);
228	}
229
230	vdstrategy(io, cmd)
231	register struct iob *io;
232	int cmd;
233	{
234	register struct disklabel *lp;
235	int ctlr, cn, tn, sn, slave, retries = 0;
236	daddr_t bn;
237	struct vddevice *vdaddr;
238
239	if (io->i_cc == 0 \|\| io->i_cc > 65535) {
240	printf("dk%d: invalid transfer size %d\n", io->i_unit,
241	io->i_cc);
242	io->i_error = EIO;
243	return (-1);
244	}
245	lp = &dklabel[io->i_ctlr][io->i_unit];
246	bn = io->i_bn * (DEV_BSIZE / lp->d_secsize);
247	cn = bn / lp->d_secpercyl;
248	sn = bn % lp->d_secpercyl;
249	tn = sn / lp->d_nsectors;
250	sn = sn % lp->d_nsectors;
251
252	top:
253	dcb.opcode = (cmd == READ ? VDOP_RD : VDOP_WD);
254	dcb.intflg = DCBINT_NONE;
255	dcb.nxtdcb = (struct dcb )0; / end of chain */
256	dcb.operrsta = 0;
257	ctlr = io->i_ctlr;
258	slave = io->i_unit;
259	dcb.devselect = slave \| dkflags[ctlr][slave];
260	dcb.trailcnt = sizeof (struct trrw) / sizeof (int);
261	dcb.trail.rwtrail.memadr = (u_long)io->i_ma;
262	dcb.trail.rwtrail.wcount = (io->i_cc + 1) / sizeof (short);
263	dcb.trail.rwtrail.disk.cylinder = cn;
264	dcb.trail.rwtrail.disk.track = tn;
265	dcb.trail.rwtrail.disk.sector = sn;
266	mdcb.mdcb_head = &dcb;
267	mdcb.mdcb_status = 0;
268	vdaddr = VDADDR(ctlr);
269	VDGO(vdaddr, (u_long)&mdcb, vdtype[ctlr]);
270	if (!vdpoll(vdaddr, &dcb, 60, vdtype[ctlr]))
271	_stop(" during i/o operation.\n");
272	if (dcb.operrsta & VDERR_HARD) {
273	if (retries++ == 0 && vdreset_ctlr(ctlr, io->i_unit) == 0 &&
274	vdreset_drive(io))
275	goto top;
276	vderror(io->i_unit, cmd == READ ? "read" : "write", &dcb);
277	io->i_error = EIO;
278	return (-1);
279	}
280	mtpr(PADC, 0);
281	return (io->i_cc);
282	}
283
284	vderror(unit, cmd, dcb)
285	int unit;
286	char *cmd;
287	struct dcb *dcb;
288	{
289
290	printf("dk%d: %s error; status %b", unit, cmd,
291	dcb->operrsta, VDERRBITS);
292	if (dcb->err_code)
293	printf(", code %x", dcb->err_code);
294	printf("\n");
295	}
296
297	/*
298	* Poll controller until operation
299	* completes or timeout expires.
300	*/
301	vdpoll(vdaddr, dcb, t, type)
302	register struct vddevice *vdaddr;
303	register struct dcb *dcb;
304	register int t, type;
305	{
306
307	t *= 1000;
308	for (;;) {
309	uncache(&dcb->operrsta);
310	if (dcb->operrsta & (DCBS_DONE\|DCBS_ABORT))
311	break;
312	if (--t <= 0) {
313	printf("vd: controller timeout");
314	VDABORT(vdaddr, type);
315	DELAY(30000);
316	uncache(&dcb->operrsta);
317	return (0);
318	}
319	DELAY(1000);
320	}
321	if (type == VDTYPE_SMDE) {
322	for (;;) {
323	uncache(&vdaddr->vdcsr);
324	if ((vdaddr->vdcsr & CS_GO) == 0)
325	break;
326	DELAY(50);
327	}
328	DELAY(300);
329	uncache(&dcb->err_code);
330	}
331	DELAY(200);
332	uncache(&dcb->operrsta);
333	return (1);
334	}
335
336	#ifdef COMPAT_42
337	struct dkcompat {
338	int nsectors; /* sectors per track */
339	int ntracks; /* tracks per cylinder */
340	int ncylinders; /* cylinders per drive */
341	int secsize; /* sector size */
342	#define NPART 2
343	int poff[NPART]; /* [a+b] for bootstrapping */
344	} dkcompat[] = {
345	{ 64, 20, 842, 512, 0, 61440 }, /* 2361a eagle */
346	{ 48, 24, 711, 512, 0, 61056 }, /* xsd */
347	{ 44, 20, 842, 512, 0, 52800 }, /* eagle */
348	{ 64, 10, 823, 512, 0, 38400 }, /* fuji 360 */
349	{ 32, 24, 711, 512, 0, 40704 }, /* xfd */
350	{ 32, 19, 823, 512, 0, 40128 }, /* smd */
351	{ 32, 10, 823, 512, 0, 19200 }, /* fsd */
352	{ 18, 15, 1224, 1024, 0, 21600 }, /* mxd */
353	};
354	#define NDKCOMPAT (sizeof (dkcompat) / sizeof (dkcompat[0]))
355
356	/*
357	* Identify and configure drive from above table
358	* by trying to read the last sector until a description
359	* is found for which we're successful.
360	*/
361	vdmaptype(io)
362	struct iob *io;
363	{
364	register struct disklabel *lp = &dklabel[io->i_ctlr][io->i_unit];
365	register struct dkcompat *dp;
366	int i, ctlr, slave, type;
367	struct vddevice *vdaddr;
368
369	ctlr = io->i_ctlr;
370	slave = io->i_unit;
371	vdaddr = VDADDR(ctlr);
372	type = vdtype[ctlr];
373	for (dp = dkcompat; dp < &dkcompat[NDKCOMPAT]; dp++) {
374	if (type == VDTYPE_VDDC && dp->nsectors != 32)
375	continue;
376	lp->d_nsectors = dp->nsectors;
377	lp->d_ntracks = dp->ntracks;
378	lp->d_ncylinders = dp->ncylinders;
379	lp->d_secsize = dp->secsize;
380	if (!vdreset_drive(io)) /* set drive parameters */
381	return (EIO);
382	dcb.opcode = VDOP_RD;
383	dcb.intflg = DCBINT_NONE;
384	dcb.nxtdcb = (struct dcb )0; / end of chain */
385	dcb.devselect = slave \| dkflags[ctlr][slave];
386	dcb.operrsta = 0;
387	dcb.trailcnt = sizeof (struct trrw) / sizeof (long);
388	dcb.trail.rwtrail.memadr = (u_long)lbuf;
389	dcb.trail.rwtrail.wcount = lp->d_secsize / sizeof (short);
390	dcb.trail.rwtrail.disk.cylinder = dp->ncylinders - 2;
391	dcb.trail.rwtrail.disk.track = dp->ntracks - 1;
392	dcb.trail.rwtrail.disk.sector = dp->nsectors - 1;
393	mdcb.mdcb_head = &dcb;
394	mdcb.mdcb_status = 0;
395	VDGO(vdaddr, (u_long)&mdcb, type);
396	if (!vdpoll(vdaddr, &dcb, 60, type))
397	_stop(" during i/o operation.\n");
398	if (dcb.operrsta & VDERR_HARD)
399	continue;
400	/* simulate necessary parts of disk label */
401	lp->d_secpercyl = lp->d_nsectors * lp->d_ntracks;
402	lp->d_secperunit = lp->d_secpercyl * lp->d_ncylinders;
403	lp->d_npartitions = NPART;
404	for (i = 0; i < NPART; i++) {
405	lp->d_partitions[i].p_offset = dp->poff[i];
406	lp->d_partitions[i].p_size =
407	lp->d_secperunit - dp->poff[i];
408	}
409	return (0);
410	}
411	printf("dk%d: unknown drive type\n", io->i_unit);
412	return (ENXIO);
413	}
414	#endif