initial import of NetBSD tree

1 files changed, 1189 insertions, 0 deletions

diff --git a/sys/dev/isa/fd.c b/sys/dev/isa/fd.c
new file mode 100644
index 00000000000..5a46d1b3147
--- /dev/null
+++ b/sys/dev/isa/fd.c
@@ -0,0 +1,1189 @@
+/*	$NetBSD: fd.c,v 1.79 1995/08/21 06:56:14 mycroft Exp $	*/
+
+/*-
+ * Copyright (c) 1993, 1994, 1995 Charles Hannum.
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Don Ahn.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by the University of
+ *	California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)fd.c	7.4 (Berkeley) 5/25/91
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/conf.h>
+#include <sys/file.h>
+#include <sys/ioctl.h>
+#include <sys/device.h>
+#include <sys/disklabel.h>
+#include <sys/dkstat.h>
+#include <sys/disk.h>
+#include <sys/buf.h>
+#include <sys/uio.h>
+#include <sys/syslog.h>
+#include <sys/queue.h>
+
+#include <machine/cpu.h>
+#include <machine/pio.h>
+
+#include <dev/isa/isavar.h>
+#include <dev/isa/isadmavar.h>
+#include <i386/isa/fdreg.h>
+
+#include <dev/ic/mc146818reg.h>			/* for NVRAM access */
+#include <i386/isa/nvram.h>
+
+#define FDUNIT(dev)	(minor(dev) / 8)
+#define FDTYPE(dev)	(minor(dev) % 8)
+
+#define b_cylin b_resid
+
+enum fdc_state {
+	DEVIDLE = 0,
+	MOTORWAIT,
+	DOSEEK,
+	SEEKWAIT,
+	SEEKTIMEDOUT,
+	SEEKCOMPLETE,
+	DOIO,
+	IOCOMPLETE,
+	IOTIMEDOUT,
+	DORESET,
+	RESETCOMPLETE,
+	RESETTIMEDOUT,
+	DORECAL,
+	RECALWAIT,
+	RECALTIMEDOUT,
+	RECALCOMPLETE,
+};
+
+/* software state, per controller */
+struct fdc_softc {
+	struct device sc_dev;		/* boilerplate */
+	struct isadev sc_id;
+	void *sc_ih;
+
+	int sc_iobase;
+	int sc_drq;
+
+	struct fd_softc *sc_fd[4];	/* pointers to children */
+	TAILQ_HEAD(drivehead, fd_softc) sc_drives;
+	enum fdc_state sc_state;
+	int sc_errors;			/* number of retries so far */
+	u_char sc_status[7];		/* copy of registers */
+};
+
+/* controller driver configuration */
+int fdcprobe __P((struct device *, void *, void *));
+#ifdef NEWCONFIG
+void fdcforceintr __P((void *));
+#endif
+void fdcattach __P((struct device *, struct device *, void *));
+
+struct cfdriver fdccd = {
+	NULL, "fdc", fdcprobe, fdcattach, DV_DULL, sizeof(struct fdc_softc)
+};
+
+/*
+ * Floppies come in various flavors, e.g., 1.2MB vs 1.44MB; here is how
+ * we tell them apart.
+ */
+struct fd_type {
+	int	sectrac;	/* sectors per track */
+	int	heads;		/* number of heads */
+	int	seccyl;		/* sectors per cylinder */
+	int	secsize;	/* size code for sectors */
+	int	datalen;	/* data len when secsize = 0 */
+	int	steprate;	/* step rate and head unload time */
+	int	gap1;		/* gap len between sectors */
+	int	gap2;		/* formatting gap */
+	int	tracks;		/* total num of tracks */
+	int	size;		/* size of disk in sectors */
+	int	step;		/* steps per cylinder */
+	int	rate;		/* transfer speed code */
+	char	*name;
+};
+
+/* The order of entries in the following table is important -- BEWARE! */
+struct fd_type fd_types[] = {
+        { 18,2,36,2,0xff,0xcf,0x1b,0x6c,80,2880,1,FDC_500KBPS,"1.44MB"    }, /* 1.44MB diskette */
+        { 15,2,30,2,0xff,0xdf,0x1b,0x54,80,2400,1,FDC_500KBPS, "1.2MB"    }, /* 1.2 MB AT-diskettes */
+        {  9,2,18,2,0xff,0xdf,0x23,0x50,40, 720,2,FDC_300KBPS, "360KB/AT" }, /* 360kB in 1.2MB drive */
+        {  9,2,18,2,0xff,0xdf,0x2a,0x50,40, 720,1,FDC_250KBPS, "360KB/PC" }, /* 360kB PC diskettes */
+        {  9,2,18,2,0xff,0xdf,0x2a,0x50,80,1440,1,FDC_250KBPS, "720KB"    }, /* 3.5" 720kB diskette */
+        {  9,2,18,2,0xff,0xdf,0x23,0x50,80,1440,1,FDC_300KBPS, "720KB/x"  }, /* 720kB in 1.2MB drive */
+        {  9,2,18,2,0xff,0xdf,0x2a,0x50,40, 720,2,FDC_250KBPS, "360KB/x"  }, /* 360kB in 720kB drive */
+};
+
+/* software state, per disk (with up to 4 disks per ctlr) */
+struct fd_softc {
+	struct device sc_dev;
+	struct dkdevice sc_dk;
+
+	struct fd_type *sc_deftype;	/* default type descriptor */
+	struct fd_type *sc_type;	/* current type descriptor */
+
+	daddr_t	sc_blkno;	/* starting block number */
+	int sc_bcount;		/* byte count left */
+	int sc_skip;		/* bytes already transferred */
+	int sc_nblks;		/* number of blocks currently tranferring */
+	int sc_nbytes;		/* number of bytes currently tranferring */
+
+	int sc_drive;		/* physical unit number */
+	int sc_flags;
+#define	FD_OPEN		0x01		/* it's open */
+#define	FD_MOTOR	0x02		/* motor should be on */
+#define	FD_MOTOR_WAIT	0x04		/* motor coming up */
+	int sc_cylin;		/* where we think the head is */
+
+	TAILQ_ENTRY(fd_softc) sc_drivechain;
+	int sc_ops;		/* I/O ops since last switch */
+	struct buf sc_q;	/* head of buf chain */
+};
+
+/* floppy driver configuration */
+int fdprobe __P((struct device *, void *, void *));
+void fdattach __P((struct device *, struct device *, void *));
+
+struct cfdriver fdcd = {
+	NULL, "fd", fdprobe, fdattach, DV_DISK, sizeof(struct fd_softc)
+};
+
+void fdgetdisklabel __P((struct fd_softc *));
+int fd_get_parms __P((struct fd_softc *));
+void fdstrategy __P((struct buf *));
+void fdstart __P((struct fd_softc *));
+
+struct dkdriver fddkdriver = { fdstrategy };
+
+struct fd_type *fd_nvtotype __P((char *, int, int));
+void fd_set_motor __P((struct fdc_softc *fdc, int reset));
+void fd_motor_off __P((void *arg));
+void fd_motor_on __P((void *arg));
+int fdcresult __P((struct fdc_softc *fdc));
+int out_fdc __P((int iobase, u_char x));
+void fdcstart __P((struct fdc_softc *fdc));
+void fdcstatus __P((struct device *dv, int n, char *s));
+void fdctimeout __P((void *arg));
+void fdcpseudointr __P((void *arg));
+int fdcintr __P((void *));
+void fdcretry __P((struct fdc_softc *fdc));
+void fdfinish __P((struct fd_softc *fd, struct buf *bp));
+
+int
+fdcprobe(parent, match, aux)
+	struct device *parent;
+	void *match, *aux;
+{
+	register struct isa_attach_args *ia = aux;
+	int iobase = ia->ia_iobase;
+
+	/* reset */
+	outb(iobase + fdout, 0);
+	delay(100);
+	outb(iobase + fdout, FDO_FRST);
+
+	/* see if it can handle a command */
+	if (out_fdc(iobase, NE7CMD_SPECIFY) < 0)
+		return 0;
+	out_fdc(iobase, 0xdf);
+	out_fdc(iobase, 2);
+
+#ifdef NEWCONFIG
+	if (iobase == IOBASEUNK || ia->ia_drq == DRQUNK)
+		return 0;
+
+	if (ia->ia_irq == IRQUNK) {
+		ia->ia_irq = isa_discoverintr(fdcforceintr, aux);
+		if (ia->ia_irq == IRQNONE)
+			return 0;
+
+		/* reset it again */
+		outb(iobase + fdout, 0);
+		delay(100);
+		outb(iobase + fdout, FDO_FRST);
+	}
+#endif
+
+	ia->ia_iosize = FDC_NPORT;
+	ia->ia_msize = 0;
+	return 1;
+}
+
+#ifdef NEWCONFIG
+void
+fdcforceintr(aux)
+	void *aux;
+{
+	struct isa_attach_args *ia = aux;
+	int iobase = ia->ia_iobase;
+
+	/* the motor is off; this should generate an error with or
+	   without a disk drive present */
+	out_fdc(iobase, NE7CMD_SEEK);
+	out_fdc(iobase, 0);
+	out_fdc(iobase, 0);
+}
+#endif
+
+/*
+ * Arguments passed between fdcattach and fdprobe.
+ */
+struct fdc_attach_args {
+	int fa_drive;
+	struct fd_type *fa_deftype;
+};
+
+/*
+ * Print the location of a disk drive (called just before attaching the
+ * the drive).  If `fdc' is not NULL, the drive was found but was not
+ * in the system config file; print the drive name as well.
+ * Return QUIET (config_find ignores this if the device was configured) to
+ * avoid printing `fdN not configured' messages.
+ */
+int
+fdprint(aux, fdc)
+	void *aux;
+	char *fdc;
+{
+	register struct fdc_attach_args *fa = aux;
+
+	if (!fdc)
+		printf(" drive %d", fa->fa_drive);
+	return QUIET;
+}
+
+void
+fdcattach(parent, self, aux)
+	struct device *parent, *self;
+	void *aux;
+{
+	struct fdc_softc *fdc = (void *)self;
+	struct isa_attach_args *ia = aux;
+	struct fdc_attach_args fa;
+	int type;
+
+	fdc->sc_iobase = ia->ia_iobase;
+	fdc->sc_drq = ia->ia_drq;
+	fdc->sc_state = DEVIDLE;
+	TAILQ_INIT(&fdc->sc_drives);
+
+	printf("\n");
+
+#ifdef NEWCONFIG
+	at_setup_dmachan(fdc->sc_drq, FDC_MAXIOSIZE);
+	isa_establish(&fdc->sc_id, &fdc->sc_dev);
+#endif
+	fdc->sc_ih = isa_intr_establish(ia->ia_irq, ISA_IST_EDGE, ISA_IPL_BIO,
+	    fdcintr, fdc);
+
+	/*
+	 * The NVRAM info only tells us about the first two disks on the
+	 * `primary' floppy controller.
+	 */
+	if (fdc->sc_dev.dv_unit == 0)
+		type = mc146818_read(NULL, NVRAM_DISKETTE); /* XXX softc */
+	else
+		type = -1;
+
+	/* physical limit: four drives per controller. */
+	for (fa.fa_drive = 0; fa.fa_drive < 4; fa.fa_drive++) {
+		if (type >= 0 && fa.fa_drive < 2)
+			fa.fa_deftype = fd_nvtotype(fdc->sc_dev.dv_xname,
+			    type, fa.fa_drive);
+		else
+			fa.fa_deftype = NULL;		/* unknown */
+		(void)config_found(self, (void *)&fa, fdprint);
+	}
+}
+
+int
+fdprobe(parent, match, aux)
+	struct device *parent;
+	void *match, *aux;
+{
+	struct fdc_softc *fdc = (void *)parent;
+	struct cfdata *cf = match;
+	struct fdc_attach_args *fa = aux;
+	int drive = fa->fa_drive;
+	int iobase = fdc->sc_iobase;
+	int n;
+
+	if (cf->cf_loc[0] != -1 && cf->cf_loc[0] != drive)
+		return 0;
+	/*
+	 * XXX
+	 * This is to work around some odd interactions between this driver
+	 * and SMC Ethernet cards.
+	 */
+	if (cf->cf_loc[0] == -1 && drive >= 2)
+		return 0;
+
+	/* select drive and turn on motor */
+	outb(iobase + fdout, drive | FDO_FRST | FDO_MOEN(drive));
+	/* wait for motor to spin up */
+	delay(250000);
+	out_fdc(iobase, NE7CMD_RECAL);
+	out_fdc(iobase, drive);
+	/* wait for recalibrate */
+	delay(2000000);
+	out_fdc(iobase, NE7CMD_SENSEI);
+	n = fdcresult(fdc);
+#ifdef FD_DEBUG
+	{
+		int i;
+		printf("fdprobe: status");
+		for (i = 0; i < n; i++)
+			printf(" %x", fdc->sc_status[i]);
+		printf("\n");
+	}
+#endif
+	if (n != 2 || (fdc->sc_status[0] & 0xf8) != 0x20)
+		return 0;
+	/* turn off motor */
+	outb(iobase + fdout, FDO_FRST);
+
+	return 1;
+}
+
+/*
+ * Controller is working, and drive responded.  Attach it.
+ */
+void
+fdattach(parent, self, aux)
+	struct device *parent, *self;
+	void *aux;
+{
+	struct fdc_softc *fdc = (void *)parent;
+	struct fd_softc *fd = (void *)self;
+	struct fdc_attach_args *fa = aux;
+	struct fd_type *type = fa->fa_deftype;
+	int drive = fa->fa_drive;
+
+	/* XXX Allow `flags' to override device type? */
+
+	if (type)
+		printf(": %s %d cyl, %d head, %d sec\n", type->name,
+		    type->tracks, type->heads, type->sectrac);
+	else
+		printf(": density unknown\n");
+
+	fd->sc_cylin = -1;
+	fd->sc_drive = drive;
+	fd->sc_deftype = type;
+	fdc->sc_fd[drive] = fd;
+	fd->sc_dk.dk_driver = &fddkdriver;
+#ifdef NEWCONFIG
+	/* XXX Need to do some more fiddling with sc_dk. */
+	dk_establish(&fd->sc_dk, &fd->sc_dev);
+#endif
+}
+
+/*
+ * Translate nvram type into internal data structure.  Return NULL for
+ * none/unknown/unusable.
+ */
+struct fd_type *
+fd_nvtotype(fdc, nvraminfo, drive)
+	char *fdc;
+	int nvraminfo, drive;
+{
+	int type;
+
+	type = (drive == 0 ? nvraminfo : nvraminfo << 4) & 0xf0;
+	switch (type) {
+	case NVRAM_DISKETTE_NONE:
+		return NULL;
+	case NVRAM_DISKETTE_12M:
+		return &fd_types[1];
+	case NVRAM_DISKETTE_TYPE5:
+	case NVRAM_DISKETTE_TYPE6:
+		/* XXX We really ought to handle 2.88MB format. */
+	case NVRAM_DISKETTE_144M:
+		return &fd_types[0];
+	case NVRAM_DISKETTE_360K:
+		return &fd_types[3];
+	case NVRAM_DISKETTE_720K:
+		return &fd_types[4];
+	default:
+		printf("%s: drive %d: unknown device type 0x%x\n",
+		    fdc, drive, type);
+		return NULL;
+	}
+}
+
+inline struct fd_type *
+fd_dev_to_type(fd, dev)
+	struct fd_softc *fd;
+	dev_t dev;
+{
+	int type = FDTYPE(dev);
+
+	if (type > (sizeof(fd_types) / sizeof(fd_types[0])))
+		return NULL;
+	return type ? &fd_types[type - 1] : fd->sc_deftype;
+}
+
+void
+fdstrategy(bp)
+	register struct buf *bp;	/* IO operation to perform */
+{
+	struct fd_softc *fd;
+	int unit = FDUNIT(bp->b_dev);
+	int sz;
+ 	int s;
+
+	/* Valid unit, controller, and request? */
+	if (unit >= fdcd.cd_ndevs ||
+	    (fd = fdcd.cd_devs[unit]) == 0 ||
+	    bp->b_blkno < 0 ||
+	    (bp->b_bcount % FDC_BSIZE) != 0) {
+		bp->b_error = EINVAL;
+		goto bad;
+	}
+
+	/* If it's a null transfer, return immediately. */
+	if (bp->b_bcount == 0)
+		goto done;
+
+	sz = howmany(bp->b_bcount, FDC_BSIZE);
+
+	if (bp->b_blkno + sz > fd->sc_type->size) {
+		sz = fd->sc_type->size - bp->b_blkno;
+		if (sz == 0) {
+			/* If exactly at end of disk, return EOF. */
+			bp->b_resid = bp->b_bcount;
+			goto done;
+		}
+		if (sz < 0) {
+			/* If past end of disk, return EINVAL. */
+			bp->b_error = EINVAL;
+			goto bad;
+		}
+		/* Otherwise, truncate request. */
+		bp->b_bcount = sz << DEV_BSHIFT;
+	}
+
+ 	bp->b_cylin = bp->b_blkno / (FDC_BSIZE / DEV_BSIZE) / fd->sc_type->seccyl;
+
+#ifdef FD_DEBUG
+	printf("fdstrategy: b_blkno %d b_bcount %d blkno %d cylin %d sz %d\n",
+	    bp->b_blkno, bp->b_bcount, fd->sc_blkno, bp->b_cylin, sz);
+#endif
+
+	/* Queue transfer on drive, activate drive and controller if idle. */
+	s = splbio();
+	disksort(&fd->sc_q, bp);
+	untimeout(fd_motor_off, fd); /* a good idea */
+	if (!fd->sc_q.b_active)
+		fdstart(fd);
+#ifdef DIAGNOSTIC
+	else {
+		struct fdc_softc *fdc = (void *)fd->sc_dev.dv_parent;
+		if (fdc->sc_state == DEVIDLE) {
+			printf("fdstrategy: controller inactive\n");
+			fdcstart(fdc);
+		}
+	}
+#endif
+	splx(s);
+	return;
+
+bad:
+	bp->b_flags |= B_ERROR;
+done:
+	/* Toss transfer; we're done early. */
+	biodone(bp);
+}
+
+void
+fdstart(fd)
+	struct fd_softc *fd;
+{
+	struct fdc_softc *fdc = (void *)fd->sc_dev.dv_parent;
+	int active = fdc->sc_drives.tqh_first != 0;
+
+	/* Link into controller queue. */
+	fd->sc_q.b_active = 1;
+	TAILQ_INSERT_TAIL(&fdc->sc_drives, fd, sc_drivechain);
+
+	/* If controller not already active, start it. */
+	if (!active)
+		fdcstart(fdc);
+}
+
+void
+fdfinish(fd, bp)
+	struct fd_softc *fd;
+	struct buf *bp;
+{
+	struct fdc_softc *fdc = (void *)fd->sc_dev.dv_parent;
+
+	/*
+	 * Move this drive to the end of the queue to give others a `fair'
+	 * chance.  We only force a switch if N operations are completed while
+	 * another drive is waiting to be serviced, since there is a long motor
+	 * startup delay whenever we switch.
+	 */
+	if (fd->sc_drivechain.tqe_next && ++fd->sc_ops >= 8) {
+		fd->sc_ops = 0;
+		TAILQ_REMOVE(&fdc->sc_drives, fd, sc_drivechain);
+		if (bp->b_actf) {
+			TAILQ_INSERT_TAIL(&fdc->sc_drives, fd, sc_drivechain);
+		} else
+			fd->sc_q.b_active = 0;
+	}
+	bp->b_resid = fd->sc_bcount;
+	fd->sc_skip = 0;
+	fd->sc_q.b_actf = bp->b_actf;
+	biodone(bp);
+	/* turn off motor 5s from now */
+	timeout(fd_motor_off, fd, 5 * hz);
+	fdc->sc_state = DEVIDLE;
+}
+
+int
+fdread(dev, uio)
+	dev_t dev;
+	struct uio *uio;
+{
+
+	return (physio(fdstrategy, NULL, dev, B_READ, minphys, uio));
+}
+
+int
+fdwrite(dev, uio)
+	dev_t dev;
+	struct uio *uio;
+{
+
+	return (physio(fdstrategy, NULL, dev, B_WRITE, minphys, uio));
+}
+
+void
+fd_set_motor(fdc, reset)
+	struct fdc_softc *fdc;
+	int reset;
+{
+	struct fd_softc *fd;
+	u_char status;
+	int n;
+
+	if (fd = fdc->sc_drives.tqh_first)
+		status = fd->sc_drive;
+	else
+		status = 0;
+	if (!reset)
+		status |= FDO_FRST | FDO_FDMAEN;
+	for (n = 0; n < 4; n++)
+		if ((fd = fdc->sc_fd[n]) && (fd->sc_flags & FD_MOTOR))
+			status |= FDO_MOEN(n);
+	outb(fdc->sc_iobase + fdout, status);
+}
+
+void
+fd_motor_off(arg)
+	void *arg;
+{
+	struct fd_softc *fd = arg;
+	int s;
+
+	s = splbio();
+	fd->sc_flags &= ~(FD_MOTOR | FD_MOTOR_WAIT);
+	fd_set_motor((struct fdc_softc *)fd->sc_dev.dv_parent, 0);
+	splx(s);
+}
+
+void
+fd_motor_on(arg)
+	void *arg;
+{
+	struct fd_softc *fd = arg;
+	struct fdc_softc *fdc = (void *)fd->sc_dev.dv_parent;
+	int s;
+
+	s = splbio();
+	fd->sc_flags &= ~FD_MOTOR_WAIT;
+	if ((fdc->sc_drives.tqh_first == fd) && (fdc->sc_state == MOTORWAIT))
+		(void) fdcintr(fdc);
+	splx(s);
+}
+
+int
+fdcresult(fdc)
+	struct fdc_softc *fdc;
+{
+	int iobase = fdc->sc_iobase;
+	u_char i;
+	int j = 100000,
+	    n = 0;
+
+	for (; j; j--) {
+		i = inb(iobase + fdsts) & (NE7_DIO | NE7_RQM | NE7_CB);
+		if (i == NE7_RQM)
+			return n;
+		if (i == (NE7_DIO | NE7_RQM | NE7_CB)) {
+			if (n >= sizeof(fdc->sc_status)) {
+				log(LOG_ERR, "fdcresult: overrun\n");
+				return -1;
+			}
+			fdc->sc_status[n++] = inb(iobase + fddata);
+		}
+	}
+	log(LOG_ERR, "fdcresult: timeout\n");
+	return -1;
+}
+
+int
+out_fdc(iobase, x)
+	int iobase;
+	u_char x;
+{
+	int i = 100000;
+
+	while ((inb(iobase + fdsts) & NE7_DIO) && i-- > 0);
+	if (i <= 0)
+		return -1;
+	while ((inb(iobase + fdsts) & NE7_RQM) == 0 && i-- > 0);
+	if (i <= 0)
+		return -1;
+	outb(iobase + fddata, x);
+	return 0;
+}
+
+int
+Fdopen(dev, flags)
+	dev_t dev;
+	int flags;
+{
+ 	int unit;
+	struct fd_softc *fd;
+	struct fd_type *type;
+
+	unit = FDUNIT(dev);
+	if (unit >= fdcd.cd_ndevs)
+		return ENXIO;
+	fd = fdcd.cd_devs[unit];
+	if (fd == 0)
+		return ENXIO;
+	type = fd_dev_to_type(fd, dev);
+	if (type == NULL)
+		return ENXIO;
+
+	if ((fd->sc_flags & FD_OPEN) != 0 &&
+	    fd->sc_type != type)
+		return EBUSY;
+
+	fd->sc_type = type;
+	fd->sc_cylin = -1;
+	fd->sc_flags |= FD_OPEN;
+
+	return 0;
+}
+
+int
+fdclose(dev, flags)
+	dev_t dev;
+	int flags;
+{
+	struct fd_softc *fd = fdcd.cd_devs[FDUNIT(dev)];
+
+	fd->sc_flags &= ~FD_OPEN;
+	return 0;
+}
+
+void
+fdcstart(fdc)
+	struct fdc_softc *fdc;
+{
+
+#ifdef DIAGNOSTIC
+	/* only got here if controller's drive queue was inactive; should
+	   be in idle state */
+	if (fdc->sc_state != DEVIDLE) {
+		printf("fdcstart: not idle\n");
+		return;
+	}
+#endif
+	(void) fdcintr(fdc);
+}
+
+void
+fdcstatus(dv, n, s)
+	struct device *dv;
+	int n;
+	char *s;
+{
+	struct fdc_softc *fdc = (void *)dv->dv_parent;
+	int iobase = fdc->sc_iobase;
+
+	if (n == 0) {
+		out_fdc(fdc->sc_iobase, NE7CMD_SENSEI);
+		(void) fdcresult(fdc);
+		n = 2;
+	}
+
+	printf("%s: %s", dv->dv_xname, s);
+
+	switch (n) {
+	case 0:
+		printf("\n");
+		break;
+	case 2:
+		printf(" (st0 %b cyl %d)\n",
+		    fdc->sc_status[0], NE7_ST0BITS,
+		    fdc->sc_status[1]);
+		break;
+	case 7:
+		printf(" (st0 %b st1 %b st2 %b cyl %d head %d sec %d)\n",
+		    fdc->sc_status[0], NE7_ST0BITS,
+		    fdc->sc_status[1], NE7_ST1BITS,
+		    fdc->sc_status[2], NE7_ST2BITS,
+		    fdc->sc_status[3], fdc->sc_status[4], fdc->sc_status[5]);
+		break;
+#ifdef DIAGNOSTIC
+	default:
+		printf("\nfdcstatus: weird size");
+		break;
+#endif
+	}
+}
+
+void
+fdctimeout(arg)
+	void *arg;
+{
+	struct fdc_softc *fdc = arg;
+	struct fd_softc *fd = fdc->sc_drives.tqh_first;
+	int s;
+
+	s = splbio();
+	fdcstatus(&fd->sc_dev, 0, "timeout");
+
+	if (fd->sc_q.b_actf)
+		fdc->sc_state++;
+	else
+		fdc->sc_state = DEVIDLE;
+
+	(void) fdcintr(fdc);
+	splx(s);
+}
+
+void
+fdcpseudointr(arg)
+	void *arg;
+{
+	int s;
+
+	/* Just ensure it has the right spl. */
+	s = splbio();
+	(void) fdcintr(arg);
+	splx(s);
+}
+
+int
+fdcintr(arg)
+	void *arg;
+{
+	struct fdc_softc *fdc = arg;
+#define	st0	fdc->sc_status[0]
+#define	cyl	fdc->sc_status[1]
+	struct fd_softc *fd;
+	struct buf *bp;
+	int iobase = fdc->sc_iobase;
+	int read, head, trac, sec, i, s, nblks;
+	struct fd_type *type;
+
+loop:
+	/* Is there a drive for the controller to do a transfer with? */
+	fd = fdc->sc_drives.tqh_first;
+	if (fd == NULL) {
+		fdc->sc_state = DEVIDLE;
+ 		return 1;
+	}
+
+	/* Is there a transfer to this drive?  If not, deactivate drive. */
+	bp = fd->sc_q.b_actf;
+	if (bp == NULL) {
+		fd->sc_ops = 0;
+		TAILQ_REMOVE(&fdc->sc_drives, fd, sc_drivechain);
+		fd->sc_q.b_active = 0;
+		goto loop;
+	}
+
+	switch (fdc->sc_state) {
+	case DEVIDLE:
+		fdc->sc_errors = 0;
+		fd->sc_skip = 0;
+		fd->sc_bcount = bp->b_bcount;
+		fd->sc_blkno = bp->b_blkno / (FDC_BSIZE / DEV_BSIZE);
+		untimeout(fd_motor_off, fd);
+		if ((fd->sc_flags & FD_MOTOR_WAIT) != 0) {
+			fdc->sc_state = MOTORWAIT;
+			return 1;
+		}
+		if ((fd->sc_flags & FD_MOTOR) == 0) {
+			/* Turn on the motor, being careful about pairing. */
+			struct fd_softc *ofd = fdc->sc_fd[fd->sc_drive ^ 1];
+			if (ofd && ofd->sc_flags & FD_MOTOR) {
+				untimeout(fd_motor_off, ofd);
+				ofd->sc_flags &= ~(FD_MOTOR | FD_MOTOR_WAIT);
+			}
+			fd->sc_flags |= FD_MOTOR | FD_MOTOR_WAIT;
+			fd_set_motor(fdc, 0);
+			fdc->sc_state = MOTORWAIT;
+			/* Allow .25s for motor to stabilize. */
+			timeout(fd_motor_on, fd, hz / 4);
+			return 1;
+		}
+		/* Make sure the right drive is selected. */
+		fd_set_motor(fdc, 0);
+
+		/* fall through */
+	case DOSEEK:
+	doseek:
+		if (fd->sc_cylin == bp->b_cylin)
+			goto doio;
+
+		out_fdc(iobase, NE7CMD_SPECIFY);/* specify command */
+		out_fdc(iobase, fd->sc_type->steprate);
+		out_fdc(iobase, 6);		/* XXX head load time == 6ms */
+
+		out_fdc(iobase, NE7CMD_SEEK);	/* seek function */
+		out_fdc(iobase, fd->sc_drive);	/* drive number */
+		out_fdc(iobase, bp->b_cylin * fd->sc_type->step);
+
+		fd->sc_cylin = -1;
+		fdc->sc_state = SEEKWAIT;
+		timeout(fdctimeout, fdc, 4 * hz);
+		return 1;
+
+	case DOIO:
+	doio:
+		type = fd->sc_type;
+		sec = fd->sc_blkno % type->seccyl;
+		nblks = type->seccyl - sec;
+		nblks = min(nblks, fd->sc_bcount / FDC_BSIZE);
+		nblks = min(nblks, FDC_MAXIOSIZE / FDC_BSIZE);
+		fd->sc_nblks = nblks;
+		fd->sc_nbytes = nblks * FDC_BSIZE;
+		head = sec / type->sectrac;
+		sec -= head * type->sectrac;
+#ifdef DIAGNOSTIC
+		{int block;
+		 block = (fd->sc_cylin * type->heads + head) * type->sectrac + sec;
+		 if (block != fd->sc_blkno) {
+			 printf("fdcintr: block %d != blkno %d\n", block, fd->sc_blkno);
+#ifdef DDB
+			 Debugger();
+#endif
+		 }}
+#endif
+		read = bp->b_flags & B_READ;
+#ifdef NEWCONFIG
+		at_dma(read, bp->b_data + fd->sc_skip, fd->sc_nbytes,
+		    fdc->sc_drq);
+#else
+		isa_dmastart(read, bp->b_data + fd->sc_skip, fd->sc_nbytes,
+		    fdc->sc_drq);
+#endif
+		outb(iobase + fdctl, type->rate);
+#ifdef FD_DEBUG
+		printf("fdcintr: %s drive %d track %d head %d sec %d nblks %d\n",
+		    read ? "read" : "write", fd->sc_drive, fd->sc_cylin, head,
+		    sec, nblks);
+#endif
+		if (read)
+			out_fdc(iobase, NE7CMD_READ);	/* READ */
+		else
+			out_fdc(iobase, NE7CMD_WRITE);	/* WRITE */
+		out_fdc(iobase, (head << 2) | fd->sc_drive);
+		out_fdc(iobase, fd->sc_cylin);		/* track */
+		out_fdc(iobase, head);
+		out_fdc(iobase, sec + 1);		/* sector +1 */
+		out_fdc(iobase, type->secsize);		/* sector size */
+		out_fdc(iobase, type->sectrac);		/* sectors/track */
+		out_fdc(iobase, type->gap1);		/* gap1 size */
+		out_fdc(iobase, type->datalen);		/* data length */
+		fdc->sc_state = IOCOMPLETE;
+		/* allow 2 seconds for operation */
+		timeout(fdctimeout, fdc, 2 * hz);
+		return 1;				/* will return later */
+
+	case SEEKWAIT:
+		untimeout(fdctimeout, fdc);
+		fdc->sc_state = SEEKCOMPLETE;
+		/* allow 1/50 second for heads to settle */
+		timeout(fdcpseudointr, fdc, hz / 50);
+		return 1;
+
+	case SEEKCOMPLETE:
+		/* Make sure seek really happened. */
+		out_fdc(iobase, NE7CMD_SENSEI);
+		if (fdcresult(fdc) != 2 || (st0 & 0xf8) != 0x20 ||
+		    cyl != bp->b_cylin * fd->sc_type->step) {
+#ifdef FD_DEBUG
+			fdcstatus(&fd->sc_dev, 2, "seek failed");
+#endif
+			fdcretry(fdc);
+			goto loop;
+		}
+		fd->sc_cylin = bp->b_cylin;
+		goto doio;
+
+	case IOTIMEDOUT:
+#ifdef NEWCONFIG
+		at_dma_abort(fdc->sc_drq);
+#else
+		isa_dmaabort(fdc->sc_drq);
+#endif
+	case SEEKTIMEDOUT:
+	case RECALTIMEDOUT:
+	case RESETTIMEDOUT:
+		fdcretry(fdc);
+		goto loop;
+
+	case IOCOMPLETE: /* IO DONE, post-analyze */
+		untimeout(fdctimeout, fdc);
+		if (fdcresult(fdc) != 7 || (st0 & 0xf8) != 0) {
+#ifdef NEWCONFIG
+			at_dma_abort(fdc->sc_drq);
+#else
+			isa_dmaabort(fdc->sc_drq);
+#endif
+#ifdef FD_DEBUG
+			fdcstatus(&fd->sc_dev, 7, bp->b_flags & B_READ ?
+			    "read failed" : "write failed");
+			printf("blkno %d nblks %d\n",
+			    fd->sc_blkno, fd->sc_nblks);
+#endif
+			fdcretry(fdc);
+			goto loop;
+		}
+#ifdef NEWCONFIG
+		at_dma_terminate(fdc->sc_drq);
+#else
+		read = bp->b_flags & B_READ;
+		isa_dmadone(read, bp->b_data + fd->sc_skip, fd->sc_nbytes,
+		    fdc->sc_drq);
+#endif
+		if (fdc->sc_errors) {
+			diskerr(bp, "fd", "soft error", LOG_PRINTF,
+			    fd->sc_skip / FDC_BSIZE, (struct disklabel *)NULL);
+			printf("\n");
+			fdc->sc_errors = 0;
+		}
+		fd->sc_blkno += fd->sc_nblks;
+		fd->sc_skip += fd->sc_nbytes;
+		fd->sc_bcount -= fd->sc_nbytes;
+		if (fd->sc_bcount > 0) {
+			bp->b_cylin = fd->sc_blkno / fd->sc_type->seccyl;
+			goto doseek;
+		}
+		fdfinish(fd, bp);
+		goto loop;
+
+	case DORESET:
+		/* try a reset, keep motor on */
+		fd_set_motor(fdc, 1);
+		delay(100);
+		fd_set_motor(fdc, 0);
+		fdc->sc_state = RESETCOMPLETE;
+		timeout(fdctimeout, fdc, hz / 2);
+		return 1;			/* will return later */
+
+	case RESETCOMPLETE:
+		untimeout(fdctimeout, fdc);
+		/* clear the controller output buffer */
+		for (i = 0; i < 4; i++) {
+			out_fdc(iobase, NE7CMD_SENSEI);
+			(void) fdcresult(fdc);
+		}
+
+		/* fall through */
+	case DORECAL:
+		out_fdc(iobase, NE7CMD_RECAL);	/* recalibrate function */
+		out_fdc(iobase, fd->sc_drive);
+		fdc->sc_state = RECALWAIT;
+		timeout(fdctimeout, fdc, 5 * hz);
+		return 1;			/* will return later */
+
+	case RECALWAIT:
+		untimeout(fdctimeout, fdc);
+		fdc->sc_state = RECALCOMPLETE;
+		/* allow 1/30 second for heads to settle */
+		timeout(fdcpseudointr, fdc, hz / 30);
+		return 1;			/* will return later */
+
+	case RECALCOMPLETE:
+		out_fdc(iobase, NE7CMD_SENSEI);
+		if (fdcresult(fdc) != 2 || (st0 & 0xf8) != 0x20 || cyl != 0) {
+#ifdef FD_DEBUG
+			fdcstatus(&fd->sc_dev, 2, "recalibrate failed");
+#endif
+			fdcretry(fdc);
+			goto loop;
+		}
+		fd->sc_cylin = 0;
+		goto doseek;
+
+	case MOTORWAIT:
+		if (fd->sc_flags & FD_MOTOR_WAIT)
+			return 1;		/* time's not up yet */
+		goto doseek;
+
+	default:
+		fdcstatus(&fd->sc_dev, 0, "stray interrupt");
+		return 1;
+	}
+#ifdef DIAGNOSTIC
+	panic("fdcintr: impossible");
+#endif
+#undef	st0
+#undef	cyl
+}
+
+void
+fdcretry(fdc)
+	struct fdc_softc *fdc;
+{
+	struct fd_softc *fd;
+	struct buf *bp;
+
+	fd = fdc->sc_drives.tqh_first;
+	bp = fd->sc_q.b_actf;
+
+	switch (fdc->sc_errors) {
+	case 0:
+		/* try again */
+		fdc->sc_state = SEEKCOMPLETE;
+		break;
+
+	case 1: case 2: case 3:
+		/* didn't work; try recalibrating */
+		fdc->sc_state = DORECAL;
+		break;
+
+	case 4:
+		/* still no go; reset the bastard */
+		fdc->sc_state = DORESET;
+		break;
+
+	default:
+		diskerr(bp, "fd", "hard error", LOG_PRINTF,
+		    fd->sc_skip / FDC_BSIZE, (struct disklabel *)NULL);
+		printf(" (st0 %b st1 %b st2 %b cyl %d head %d sec %d)\n",
+		    fdc->sc_status[0], NE7_ST0BITS,
+		    fdc->sc_status[1], NE7_ST1BITS,
+		    fdc->sc_status[2], NE7_ST2BITS,
+		    fdc->sc_status[3], fdc->sc_status[4], fdc->sc_status[5]);
+
+		bp->b_flags |= B_ERROR;
+		bp->b_error = EIO;
+		fdfinish(fd, bp);
+	}
+	fdc->sc_errors++;
+}
+
+int
+fdsize(dev)
+	dev_t dev;
+{
+
+	/* Swapping to floppies would not make sense. */
+	return -1;
+}
+
+int
+fddump(dev, blkno, va, size)
+	dev_t dev;
+	daddr_t blkno;
+	caddr_t va;
+	size_t size;
+{
+
+	/* Not implemented. */
+	return ENXIO;
+}
+
+int
+fdioctl(dev, cmd, addr, flag)
+	dev_t dev;
+	u_long cmd;
+	caddr_t addr;
+	int flag;
+{
+	struct fd_softc *fd = fdcd.cd_devs[FDUNIT(dev)];
+	struct disklabel buffer;
+	int error;
+
+	switch (cmd) {
+	case DIOCGDINFO:
+		bzero(&buffer, sizeof(buffer));
+
+		buffer.d_secpercyl = fd->sc_type->seccyl;
+		buffer.d_type = DTYPE_FLOPPY;
+		buffer.d_secsize = FDC_BSIZE;
+
+		if (readdisklabel(dev, fdstrategy, &buffer, NULL) != NULL)
+			return EINVAL;
+
+		*(struct disklabel *)addr = buffer;
+		return 0;
+
+	case DIOCWLABEL:
+		if ((flag & FWRITE) == 0)
+			return EBADF;
+		/* XXX do something */
+		return 0;
+
+	case DIOCWDINFO:
+		if ((flag & FWRITE) == 0)
+			return EBADF;
+
+		error = setdisklabel(&buffer, (struct disklabel *)addr, 0, NULL);
+		if (error)
+			return error;
+
+		error = writedisklabel(dev, fdstrategy, &buffer, NULL);
+		return error;
+
+	default:
+		return ENOTTY;
+	}
+
+#ifdef DIAGNOSTIC
+	panic("fdioctl: impossible");
+#endif
+}