NetBSD/sys/dev/ata/wd.c

/*
 * Copyright (c) 1994 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
 * William Jolitz.
 *
 * 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.
 *
 *	from: @(#)wd.c	7.2 (Berkeley) 5/9/91
 *	$Id: wd.c,v 1.67 1994/03/10 21:52:10 mycroft Exp $
 */

#define	INSTRUMENT	/* instrumentation stuff by Brad Parker */

#include "wd.h"
#if NWDC > 0

#include <sys/param.h>
#include <sys/dkbad.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/conf.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/disklabel.h>
#include <sys/buf.h>
#include <sys/uio.h>
#include <sys/malloc.h>
#include <sys/device.h>
#include <sys/syslog.h>
#ifdef INSTRUMENT
#include <sys/dkstat.h>
#endif

#include <vm/vm.h>

#include <machine/cpu.h>
#include <machine/cpufunc.h>
#include <machine/pio.h>

#include <i386/isa/isa.h>
#include <i386/isa/isa_device.h>
#include <i386/isa/icu.h>
#include <i386/isa/wdreg.h>

#define WDCNDELAY	100000	/* delay = 100us; so 10s for a controller state change */
#define WDCDELAY	100
#define	RECOVERYTIME	hz/2	/* time to recover from an error */

#if 0
/* If you enable this, it will report any delays more than 100us * N long. */
#define WDCNDELAY_DEBUG	50
#endif

#define	WDIORETRIES	5	/* number of retries before giving up */

#define WDUNIT(dev)	((minor(dev) & 0xf8) >> 3)
#define WDPART(dev)	((minor(dev) & 0x07)     )
#define makewddev(maj, unit, part)	(makedev(maj, ((unit << 3) + part)))
#define WDRAW	3		/* 'd' partition isn't a partition! */

#define b_cylin	b_resid		/* cylinder number for doing IO to */
				/* shares an entry in the buf struct */

/*
 * Drive states.  Used to initialize drive.
 */
#define	CLOSED		0		/* disk is closed */
#define	WANTOPEN	1		/* open requested, not started */
#define	RECAL		2		/* doing restore */
#define	OPEN		3		/* done with open */

/*
 * Drive status.
 */
struct wd_softc {
	struct device sc_dev;

	long	sc_bcount;	/* byte count left */
	long	sc_mbcount;	/* total byte count left */
	short	sc_skip;	/* blocks already transferred */
	short	sc_mskip;	/* blocks already transferred for multi */
	char	sc_unit;	/* physical unit number */
	char	sc_lunit;	/* logical unit number */
	char	sc_state;	/* control state */
	
	u_long  sc_copenpart;   /* character units open on this drive */
	u_long  sc_bopenpart;   /* block units open on this drive */
	u_long  sc_openpart;    /* all units open on this drive */
	short	sc_wlabel;	/* label writable? */
	short	sc_flags;	/* drive characteistics found */
#define	WDF_SINGLE	0x00004	/* sector at a time mode */
#define	WDF_ERROR	0x00008	/* processing a disk error */
#define	WDF_BSDLABEL	0x00010	/* has a BSD disk label */
#define	WDF_BADSECT	0x00020	/* has a bad144 badsector table */
#define	WDF_WRITEPROT	0x00040	/* manual unit write protect */
	struct buf sc_q;
	struct wdparams sc_params; /* ESDI/IDE drive/controller parameters */
	struct disklabel sc_label;	/* device configuration data */
	struct cpu_disklabel sc_cpulabel;
	long	sc_badsect[127];	/* 126 plus trailing -1 marker */
} *wd_softc[NWD];

struct wdc_softc {
	struct device sc_dev;

	struct buf sc_q;
	u_char	sc_status;	/* copy of status register */
	u_char	sc_error;	/* copy of error register */
	u_short	sc_iobase;	/* i/o port base */
	int	sc_timeout;	/* timeout counter */
} wdc_softc[NWDC];

int wdcprobe(), wdcattach(), wdprobe(), wdattach(), wdintr();

struct	isa_driver wdcdriver = {
	wdcprobe, wdcattach, "wdc",
};

struct	isa_driver wddriver = {
	wdprobe, wdattach, "wd",
};

void wdfinish __P((struct wd_softc *, struct buf *));
static void wdstart __P((struct wd_softc *));
static void wdcstart __P((struct wdc_softc *));
static int wdcommand __P((struct wd_softc *, int, int, int, int, int));
static int wdcontrol __P((struct buf *));
static int wdsetctlr __P((struct wd_softc *));
static int wdgetctlr __P((struct wd_softc *));
static void bad144intern __P((struct wd_softc *));
static int wdcreset __P((struct wdc_softc *));
static void wdcrestart __P((struct wdc_softc *));
static void wdcunwedge __P((struct wdc_softc *));
static void wdctimeout __P((struct wdc_softc *));
void wddisksort __P((struct buf *, struct buf *));
static void wderror __P((void *, struct buf *, char *));
int wdcwait __P((struct wdc_softc *, int));
#define	wait_for_drq(d)		wdcwait(d, WDCS_DRQ)
#define	wait_for_ready(d)	wdcwait(d, WDCS_READY | WDCS_SEEKCMPLT)
#define	wait_for_unbusy(d)	wdcwait(d, 0)

/*
 * Probe for controller.
 */
int
wdcprobe(dev)
	struct isa_device *dev;
{
	struct wd_softc *wd;
	struct wdc_softc *wdc;
	u_short iobase;

	if (dev->id_unit >= NWDC)
		return 0;
	wdc = &wdc_softc[dev->id_unit];

	/* XXX HACK */
	sprintf(wdc->sc_dev.dv_xname, "%s%d", wdcdriver.name, dev->id_unit);
	wdc->sc_dev.dv_unit = dev->id_unit;

	wdc->sc_iobase = iobase = dev->id_iobase;

	/* Check if we have registers that work. */
	outb(iobase+wd_error, 0x5a);	/* Error register not writable. */
	outb(iobase+wd_cyl_lo, 0xa5);	/* But all of cyllo are implemented. */
	if (inb(iobase+wd_error) == 0x5a || inb(iobase+wd_cyl_lo) != 0xa5)
		return 0;

	if (wdcreset(wdc) != 0) {
		delay(500000);
		if (wdcreset(wdc) != 0)
			return 0;
	}

	/*
	 * XXX wdcommand() accepts a wd_softc, so we have to make it one.
	 */
	wd = (void *)malloc(sizeof(struct wd_softc), M_TEMP, M_NOWAIT);
	bzero(wd, sizeof(struct wd_softc));
	wd->sc_unit = 0;
	wd->sc_lunit = 0;
	wd->sc_dev.dv_parent = (void *)wdc;

	/* Execute a controller only command. */
	if (wdcommand(wd, 0, 0, 0, 0, WDCC_DIAGNOSE) != 0 ||
	    wait_for_unbusy(wdc) != 0)
		goto lose;

	wdctimeout(wdc);

	free(wd, M_TEMP);
	return 8;

lose:
	free(wd, M_TEMP);
	return 0;
}

int
wdcattach(dev)
	struct isa_device *dev;
{
}

int
wdprobe(dev)
	struct isa_device *dev;
{

	return 1;
}

/*
 * Called for the controller too.  Attach each drive if possible.
 */
int
wdattach(dev)
	struct isa_device *dev;
{
	int lunit;
	struct wd_softc *wd;
	struct wdc_softc *wdc;
	int i, blank;

	if (dev->id_masunit >= NWDC)
		return 0;
    
	lunit = dev->id_unit;
	if (lunit == -1) {
		printf("%s: cannot support unit ?\n", wdc->sc_dev.dv_xname);
		return 0;
	}
	if (lunit >= NWD)
		return 0;
	
	wdc = &wdc_softc[dev->id_masunit];

	wd_softc[lunit] = wd =
	    (void *)malloc(sizeof(struct wd_softc), M_TEMP, M_NOWAIT);
	bzero(wd, sizeof(struct wd_softc));
	wd->sc_unit = dev->id_physid;
	wd->sc_lunit = lunit;

	/* XXX HACK */
	sprintf(wd->sc_dev.dv_xname, "%s%d", wddriver.name, dev->id_unit);
	wd->sc_dev.dv_unit = dev->id_unit;
	wd->sc_dev.dv_parent = (void *)wdc;

	if (wdgetctlr(wd) != 0)
		return 0;

	printf("%s at %s targ %d: ", wd->sc_dev.dv_xname, wdc->sc_dev.dv_xname,
	    dev->id_physid);
	if (wd->sc_params.wdp_heads == 0)
		printf("(unknown size) <");
	else
		printf("%dMB %d cyl, %d head, %d sec <",
		    wd->sc_label.d_ncylinders * wd->sc_label.d_secpercyl /
		    (1048576 / DEV_BSIZE),
		    wd->sc_label.d_ncylinders, wd->sc_label.d_ntracks,
		    wd->sc_label.d_nsectors);
	for (i = blank = 0; i < sizeof(wd->sc_params.wdp_model); i++) {
		char c = wd->sc_params.wdp_model[i];
		if (c == '\0')
			break;
		if (c != ' ') {
			if (blank)
				printf(" %c", c);
			else
				printf("%c", c);
			blank = 0;
		} else
			blank = 1;
	}
	printf(">\n");

	return 1;
}

/*
 * Read/write routine for a buffer.  Finds the proper unit, range checks
 * arguments, and schedules the transfer.  Does not wait for the transfer to
 * complete.  Multi-page transfers are supported.  All I/O requests must be a
 * multiple of a sector in length.
 */
void
wdstrategy(bp)
	struct buf *bp;
{
	struct buf *dp;
	struct wd_softc *wd;	/* disk unit to do the IO */
	struct wdc_softc *wdc;
	int lunit = WDUNIT(bp->b_dev);
	int s;
    
	/* Valid unit, controller, and request?  */
	if (lunit >= NWD || bp->b_blkno < 0 ||
	    howmany(bp->b_bcount, DEV_BSIZE) >= (1 << NBBY) ||
	    (wd = wd_softc[lunit]) == 0) {
		bp->b_error = EINVAL;
		bp->b_flags |= B_ERROR;
		goto done;
	}
    
	/* "Soft" write protect check. */
	if ((wd->sc_flags & WDF_WRITEPROT) && (bp->b_flags & B_READ) == 0) {
		bp->b_error = EROFS;
		bp->b_flags |= B_ERROR;
		goto done;
	}
    
	/* Have partitions and want to use them? */
	if ((wd->sc_flags & WDF_BSDLABEL) != 0 && WDPART(bp->b_dev) != WDRAW) {
		/*
		 * Do bounds checking, adjust transfer. if error, process.
		 * If end of partition, just return.
		 */
		if (bounds_check_with_label(bp, &wd->sc_label,
		    wd->sc_wlabel) <= 0)
			goto done;
		/* Otherwise, process transfer request. */
	}
    
	/* Don't bother doing rotational optimization. */
	bp->b_cylin = 0;

	/* Queue transfer on drive, activate drive and controller if idle. */
	dp = &wd->sc_q;
	s = splbio();
	wddisksort(dp, bp);
	if (dp->b_active == 0)
		wdstart(wd);		/* Start drive. */
	wdc = (void *)wd->sc_dev.dv_parent;
	if (wdc->sc_q.b_active == 0)
		wdcstart(wdc);		/* Start controller. */
	splx(s);
	return;
    
done:
	/* Toss transfer; we're done early. */
	biodone(bp);
}

/*
 * Need to skip over multitransfer bufs.
 */
void
wddisksort(dp, bp)
	struct buf *dp, *bp;
{
	struct buf *ap;

	while ((ap = dp->b_actf) && ap->b_flags & B_XXX)
		dp = ap;
	disksort(dp, bp);
}

/*
 * Routine to queue a command to the controller.  The unit's request is linked
 * into the active list for the controller.  If the controller is idle, the
 * transfer is started.
 */
static void
wdstart(wd)
	struct wd_softc *wd;
{
	struct buf *dp;
	struct wdc_softc *wdc;

	dp = &wd->sc_q;
    
	/* Unit already active? */
	if (dp->b_active)
		return;
	/* Anything to start? */
	if (dp->b_actf == NULL)
		return;	
    
	/* Link onto controller queue. */
	dp->b_forw = NULL;
	wdc = (void *)wd->sc_dev.dv_parent;
	if (wdc->sc_q.b_forw == NULL)
		wdc->sc_q.b_forw = dp;
	else
		wdc->sc_q.b_actl->b_forw = dp;
	wdc->sc_q.b_actl = dp;
    
	/* Mark the drive unit as busy. */
	dp->b_active = 1;
}

void
wdfinish(wd, bp)
	struct wd_softc *wd;
	struct buf *bp;
{
	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;

#ifdef INSTRUMENT
	dk_busy &= ~(1 << wd->sc_unit);
#endif
	wd->sc_flags &= ~(WDF_SINGLE | WDF_ERROR);
	wdc->sc_q.b_errcnt = 0;
	/*
	 * If this is the only buf or the last buf in the transfer (taking into
	 * account any residual, in case we erred)...
	 */
	wd->sc_mbcount -= wd->sc_bcount;
	if (wd->sc_mbcount == 0) {
		/*
		 * ...then move this drive to the end of the queue to give
		 * others a `fair' chance.
		 */
		wdc->sc_q.b_forw = wd->sc_q.b_forw;
		wd->sc_mskip = 0;
		wd->sc_q.b_active = 0;
		if (wd->sc_q.b_actf)
			wdstart(wd);
	}
	bp->b_resid = wd->sc_bcount;
	bp->b_flags &= ~B_XXX;
	wd->sc_skip = 0;
	wd->sc_q.b_actf = bp->b_actf;
	biodone(bp);
}

/*
 * Controller startup routine.  This does the calculation, and starts a
 * single-sector read or write operation.  Called to start a transfer, or from
 * the interrupt routine to continue a multi-sector transfer.
 * RESTRICTIONS:
 * 1.	The transfer length must be an exact multiple of the sector size.
 */
static void
wdcstart(wdc)
	struct wdc_softc *wdc;
{
	struct wd_softc *wd;	/* disk unit for IO */
	struct buf *bp;
	struct disklabel *lp;
	struct buf *dp;
	long blknum, cylin, head, sector;
	long secpertrk, secpercyl;
	int xfrblknum;
	int lunit;

loop:
	/* Is there a drive for the controller to do a transfer with? */
	dp = wdc->sc_q.b_forw;
	if (dp == NULL) {
		wdc->sc_q.b_active = 0;
		return;
	}
    
	/* Is there a transfer to this drive?  If not, deactivate drive. */
	bp = dp->b_actf;
	if (bp == NULL) {
		dp->b_active = 0;
		wdc->sc_q.b_forw = dp->b_forw;
		goto loop;
	}
    
	/* Obtain controller and drive information */
	lunit = WDUNIT(bp->b_dev);
	wd = wd_softc[lunit];

	if (wdc->sc_q.b_errcnt >= WDIORETRIES) {
		wderror(wd, bp, "hard error");
		bp->b_error = EIO;
		bp->b_flags |= B_ERROR;
		wdfinish(wd, bp);
		goto loop;
	}
    
	/* Clear any pending timeout, just in case. */
	wdc->sc_timeout = 0;

	/* If not really a transfer, do control operations specially. */
	if (wd->sc_state < OPEN) {
		(void) wdcontrol(bp);
		return;
	}

	/*
	 * WDF_ERROR is set by wdcunwedge() and wdintr() when an error is
	 * encountered *only* in multi-sector mode.  We switch to single-sector
	 * mode and retry the operation from the start.
	 */
	if (wd->sc_flags & WDF_ERROR) {
		/* Switch to single-sector mode. */
		wd->sc_flags &= ~WDF_ERROR;
		wd->sc_flags |= WDF_SINGLE;
		wd->sc_skip = 0;
		wd->sc_mskip = 0;
	}

	/* Calculate transfer details. */
	blknum = bp->b_blkno + wd->sc_skip;
#ifdef WDDEBUG
	if (wd->sc_skip == 0)
		printf("\nwdcstart %d: %s %d@%d; map ", lunit,
		    (bp->b_flags & B_READ) ? "read" : "write", bp->b_bcount,
		    blknum);
	else
		printf(" %d)%x", wd->sc_skip, inb(wd->sc_iobase+wd_altsts));
#endif
	if (wd->sc_skip == 0)
		wd->sc_bcount = bp->b_bcount;
	if (wd->sc_mskip == 0) {
		struct buf *oldbp, *nextbp;
		oldbp = bp;
		nextbp = bp->b_actf;
		wd->sc_mbcount = wd->sc_bcount;
		oldbp->b_flags |= B_XXX;
		while (nextbp && (oldbp->b_flags & WDF_SINGLE) == 0 &&
		    oldbp->b_dev == nextbp->b_dev && nextbp->b_blkno ==
		    (oldbp->b_blkno + (oldbp->b_bcount / DEV_BSIZE)) &&
		    (oldbp->b_flags & B_READ) == (nextbp->b_flags & B_READ)) {
			if ((wd->sc_mbcount + nextbp->b_bcount) / DEV_BSIZE >= 240)
				break;
			wd->sc_mbcount += nextbp->b_bcount; 
			nextbp->b_flags |= B_XXX;
			oldbp = nextbp;
			nextbp = nextbp->b_actf;
		}
	}
    
	lp = &wd->sc_label;
	secpertrk = lp->d_nsectors;
	secpercyl = lp->d_secpercyl;
	if ((wd->sc_flags & WDF_BSDLABEL) != 0 && WDPART(bp->b_dev) != WDRAW)
		blknum += lp->d_partitions[WDPART(bp->b_dev)].p_offset;
	cylin = blknum / secpercyl;
	head = (blknum % secpercyl) / secpertrk;
	sector = blknum % secpertrk;
    
	/*
	 * Check for bad sectors if we have them, and not formatting.  Only do
	 * this in single-sector mode, or when starting a multiple-sector
	 * transfer.
	 */
	if ((wd->sc_flags & WDF_BADSECT) &&
#ifdef B_FORMAT
	    (bp->b_flags & B_FORMAT) == 0 &&
#endif
	    (wd->sc_mskip == 0 || (wd->sc_flags & WDF_SINGLE))) {

		long blkchk, blkend, blknew;
		int i;

		blkend = blknum + howmany(wd->sc_mbcount, DEV_BSIZE) - 1;
		for (i = 0; (blkchk = wd->sc_badsect[i]) != -1; i++) {
			if (blkchk > blkend)
				break;	/* Transfer is completely OK; done. */
			if (blkchk == blknum) {
				blknew =
				    lp->d_secperunit - lp->d_nsectors - i - 1;
				cylin = blknew / secpercyl;
				head = (blknew % secpercyl) / secpertrk;
				sector = blknew % secpertrk;
				wd->sc_flags |= WDF_SINGLE;
				/* Found and replaced first blk of transfer; done. */
				break;
			} else if (blkchk > blknum) {
				wd->sc_flags |= WDF_SINGLE;
				break;	/* Bad block inside transfer; done. */
			}
		}
	}
	if (wd->sc_flags & WDF_SINGLE) {
		wd->sc_mbcount = wd->sc_bcount;
		wd->sc_mskip = wd->sc_skip;
	}

#ifdef WDDEBUG
	printf("c%d h%d s%d ", cylin, head, sector);
#endif

	sector++;	/* Sectors begin with 1, not 0. */
    
	wdc->sc_q.b_active = 1;		/* Mark controller active. */
    
#ifdef INSTRUMENT
	if (wd->sc_skip == 0) {
		dk_busy |= 1 << wd->sc_lunit;
		dk_wds[wd->sc_lunit] += bp->b_bcount >> 6;
	}
#endif

	/* If starting a multisector transfer, or doing single transfers. */
	if (wd->sc_mskip == 0 || (wd->sc_flags & WDF_SINGLE)) {
		int command, count;

#ifdef INSTRUMENT
		++dk_seek[wd->sc_lunit];
		++dk_xfer[wd->sc_lunit];
#endif

#ifdef B_FORMAT
		if (bp->b_flags & B_FORMAT) {
			sector = lp->d_gap3;
			count = lp->d_nsectors;
			command = WDCC_FORMAT;
		} else {
			if (wd->sc_flags & WDF_SINGLE)
				count = 1;
			else
				count = howmany(wd->sc_mbcount, DEV_BSIZE);
			command =
			    (bp->b_flags & B_READ) ? WDCC_READ : WDCC_WRITE;
		}
#else
		if (wd->sc_flags & WDF_SINGLE)
			count = 1;
		else
			count = howmany(wd->sc_mbcount, DEV_BSIZE);
		command = (bp->b_flags & B_READ) ? WDCC_READ : WDCC_WRITE;
#endif
	
		/* Initiate command! */
		if (wdcommand(wd, cylin, head, sector, count, command) != 0) {
			wderror(wd, NULL,
			    "wdcstart: timeout waiting for unbusy");
			wdcunwedge(wdc);
			return;
		}
#ifdef WDDEBUG
		printf("sector %d cylin %d head %d addr %x sts %x\n", sector,
		    cylin, head, bp->b_un.b_addr, inb(wd->sc_iobase+wd_altsts));
#endif
	}
    
	wdc->sc_timeout = 4;

	/* If this is a read operation, just go away until it's done. */
	if (bp->b_flags & B_READ)
		return;
    
	if (wait_for_drq(wdc) < 0) {
		wderror(wd, NULL, "wdcstart: timeout waiting for drq");
		wdcunwedge(wdc);
		return;
	}

	/* Then send it! */
	outsw(wdc->sc_iobase+wd_data, bp->b_un.b_addr + wd->sc_skip * DEV_BSIZE,
	    DEV_BSIZE / sizeof(short));
}

/*
 * Interrupt routine for the controller.  Acknowledge the interrupt, check for
 * errors on the current operation, mark it done if necessary, and start the
 * next request.  Also check for a partially done transfer, and continue with
 * the next chunk if so.
 */
int
wdintr(ctrlr)
	int ctrlr;
{
	struct wdc_softc *wdc = &wdc_softc[ctrlr];
	struct wd_softc *wd;
	struct buf *bp;

	/* Clear the pending interrupt. */
	(void) inb(wdc->sc_iobase+wd_status);

	if (!wdc->sc_q.b_active) {
		printf("%s: extra interrupt\n", wdc->sc_dev.dv_xname);
		return 0;
	}
    
	bp = wdc->sc_q.b_forw->b_actf;
	wd = wd_softc[WDUNIT(bp->b_dev)];
	wdc->sc_timeout = 0;
    
#ifdef WDDEBUG
	printf("I%d ", ctrlr);
#endif

	if (wait_for_unbusy(wdc) < 0) {
		wderror(wd, NULL, "wdintr: timeout waiting for unbusy");
		wdc->sc_status |= WDCS_ERR;	/* XXX */
	}
    
	/* Is it not a transfer, but a control operation? */
	if (wd->sc_state < OPEN) {
		wdc->sc_q.b_active = 0;
		if (wdcontrol(bp))
			wdcstart(wdc);
		return 1;
	}
    
	/* Have we an error? */
	if (wdc->sc_status & (WDCS_ERR | WDCS_ECCCOR)) {
	lose:
#ifdef WDDEBUG
		wderror(wd, NULL, "wdintr");
#endif
		if ((wd->sc_flags & WDF_SINGLE) == 0) {
			wd->sc_flags |= WDF_ERROR;
			goto restart;
		}
#ifdef B_FORMAT
		if (bp->b_flags & B_FORMAT) {
			bp->b_error = EIO;
			bp->b_flags |= B_ERROR;
			goto done;
		}
#endif
	
		/* Error or error correction? */
		if (wdc->sc_status & WDCS_ERR) {
			if (++wdc->sc_q.b_errcnt >= WDIORETRIES) {
				wderror(wd, bp, "hard error");
				bp->b_error = EIO;
				bp->b_flags |= B_ERROR;	/* Flag the error. */
				goto done;
			} else
				goto restart;
		} else
			wderror(wd, bp, "soft ecc");
	}
    
	/* If this was a read, fetch the data. */
	if (bp->b_flags & B_READ) {
		/* Ready to receive data? */
		if (wait_for_drq(wdc) != 0) {
			wderror(wd, NULL, "wdintr: read error detected late");
			wdcunwedge(wdc);
			return 1;
		}

		/* Suck in data. */
		insw(wdc->sc_iobase+wd_data,
		    bp->b_un.b_addr + wd->sc_skip * DEV_BSIZE, 
		    DEV_BSIZE / sizeof(short));
	}
    
	/* If we encountered any abnormalities, flag it as a soft error. */
	if (wdc->sc_q.b_errcnt) {
		wderror(wd, bp, "soft error");
		wdc->sc_q.b_errcnt = 0;
	}
    
	/* Ready for the next block, if any. */
	wd->sc_skip++;
	wd->sc_mskip++;
	wd->sc_bcount -= DEV_BSIZE;
	wd->sc_mbcount -= DEV_BSIZE;

	/* See if more to transfer. */
	if (wd->sc_bcount > 0)
		goto restart;

done:
	/* Done with this transfer, with or without error. */
	wdfinish(wd, bp);

restart:
	/* Start the next transfer, if any. */
	wdc->sc_q.b_active = 0;
	wdcstart(wdc);

	return 1;
}

/*
 * Initialize a drive.
 */
int
wdopen(dev, flag, fmt, p)
	dev_t dev;
	int flag;
	int fmt;
	struct proc *p;
{
	int lunit;
	struct wd_softc *wd;
	int part = WDPART(dev), mask = 1 << part;
	struct partition *pp;
	char *msg;
    
	lunit = WDUNIT(dev);
	if (lunit >= NWD)
		return ENXIO;
	wd = wd_softc[lunit];
	if (wd == 0)
		return ENXIO;
    
	if ((wd->sc_flags & WDF_BSDLABEL) == 0) {
		wd->sc_flags |= WDF_WRITEPROT;
		wd->sc_q.b_actf = NULL;

		/*
		 * Use the default sizes until we've read the label, or longer
		 * if there isn't one there.
		 */
		bzero(&wd->sc_label, sizeof(wd->sc_label));
		wd->sc_label.d_type = DTYPE_ST506;
		wd->sc_label.d_ncylinders = 1024;
		wd->sc_label.d_secsize = DEV_BSIZE;
		wd->sc_label.d_ntracks = 8;
		wd->sc_label.d_nsectors = 17;
		wd->sc_label.d_secpercyl = 17*8;
		wd->sc_label.d_secperunit = 17*8*1024;
		wd->sc_state = WANTOPEN;

		/* Read label using "raw" partition. */
#ifdef notdef
		/* wdsetctlr(wd); */	/* Maybe do this TIH */
		msg = readdisklabel(makewddev(major(dev), WDUNIT(dev), WDRAW),
		    wdstrategy, &wd->sc_label, &wd->sc_cpulabel);
		wdsetctlr(wd);
#endif
		if (msg = readdisklabel(makewddev(major(dev), WDUNIT(dev),
		    WDRAW), wdstrategy, &wd->sc_label, &wd->sc_cpulabel)) {
			log(LOG_WARNING, "%s: cannot find label (%s)\n",
			    wd->sc_dev.dv_xname, msg);
			if (part != WDRAW)
				return EINVAL;	/* XXX needs translation */
		} else {
			wdsetctlr(wd);
			wd->sc_flags |= WDF_BSDLABEL;
			wd->sc_flags &= ~WDF_WRITEPROT;
			if (wd->sc_label.d_flags & D_BADSECT)
				wd->sc_flags |= WDF_BADSECT;
		}
	}

	if (wd->sc_flags & WDF_BADSECT)
		bad144intern(wd);

	/*
	 * Warn if a partition is opened that overlaps another partition which
	 * is open unless one is the "raw" partition (whole disk).
	 */
	if ((wd->sc_openpart & mask) == 0 && part != WDRAW) {
		int start, end;
	
		pp = &wd->sc_label.d_partitions[part];
		start = pp->p_offset;
		end = pp->p_offset + pp->p_size;
		for (pp = wd->sc_label.d_partitions;
		    pp < &wd->sc_label.d_partitions[wd->sc_label.d_npartitions];
		    pp++) {
			if (pp->p_offset + pp->p_size <= start ||
			    pp->p_offset >= end)
				continue;
			if (pp - wd->sc_label.d_partitions == WDRAW)
				continue;
			if (wd->sc_openpart & (1 << (pp - wd->sc_label.d_partitions)))
				log(LOG_WARNING,
				    "%s%c: overlaps open partition (%c)\n",
				    wd->sc_dev.dv_xname, part + 'a',
				    pp - wd->sc_label.d_partitions + 'a');
		}
	}
	if (part >= wd->sc_label.d_npartitions && part != WDRAW)
		return ENXIO;
    
	/* Insure only one open at a time. */
	switch (fmt) {
	case S_IFCHR:
		wd->sc_copenpart |= mask;
		break;
	case S_IFBLK:
		wd->sc_bopenpart |= mask;
		break;
	}
	wd->sc_openpart = wd->sc_copenpart | wd->sc_bopenpart;

	return 0;
}

/*
 * Implement operations other than read/write.
 * Called from wdcstart or wdintr during opens and formats.
 * Uses finite-state-machine to track progress of operation in progress.
 * Returns 0 if operation still in progress, 1 if completed.
 */
static int
wdcontrol(bp)
	struct buf *bp;
{
	struct wd_softc *wd = wd_softc[WDUNIT(bp->b_dev)];
	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
    
	switch (wd->sc_state) {
	case WANTOPEN:			/* Set SDH, step rate, do restore. */
	tryagainrecal:
		wdgetctlr(wd);		/* XXX Is this necessary? */
		wdc->sc_q.b_active = 1;
		if (wdcommand(wd, 0, 0, 0, 0, WDCC_RESTORE | WD_STEP) != 0) {
			wderror(wd, NULL, "wdcontrol: wdcommand failed");
			wdcunwedge(wdc);
			return 0;
		}
		wd->sc_state = RECAL;
		return 0;

	case RECAL:
		if (wdc->sc_status & WDCS_ERR || wdsetctlr(wd) != 0) {
			wderror(wd, NULL, "wdcontrol: recal failed");
			wdcunwedge(wdc);
			return 0;
		}
		wdc->sc_q.b_errcnt = 0;
		wd->sc_state = OPEN;
		/*
		 * The rest of the initialization can be done by normal means.
		 */
		return 1;
	}

#ifdef DIAGNOSTIC
	panic("wdcontrol: impossible");
#endif
}

/*
 * Send a command and wait uninterruptibly until controller is finished.
 * Return -1 if controller busy for too long, otherwise return non-zero if
 * error.  Intended for brief controller commands at critical points.
 * Assumes interrupts are blocked.
 */
static int
wdcommand(wd, cylin, head, sector, count, cmd)
	struct wd_softc *wd;
	int cylin, head, sector, count;
	int cmd;
{
	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
	int stat;
	u_short iobase;
    
	/* Controller ready for command? */
	if (wait_for_unbusy(wdc) < 0)
		return -1;

	/* Select drive. */
	iobase = wdc->sc_iobase;
	outb(iobase+wd_sdh, WDSD_IBM | (wd->sc_unit << 4) | head);
	if (cmd == WDCC_DIAGNOSE || cmd == WDCC_IDC)
		stat = wait_for_unbusy(wdc);
	else
		stat = wdcwait(wdc, WDCS_READY);
	if (stat < 0)
		return -1;
    
	/* Load parameters. */
	outb(iobase+wd_precomp, wd->sc_label.d_precompcyl / 4);
	outb(iobase+wd_cyl_lo, cylin);
	outb(iobase+wd_cyl_hi, cylin >> 8);
	outb(iobase+wd_sector, sector);
	outb(iobase+wd_seccnt, count);

	/* Send command, await results. */
	outb(iobase+wd_command, cmd);

	return 0;
}

/*
 * Issue IDC to drive to tell it just what geometry it is to be.
 */
static int
wdsetctlr(wd)
	struct wd_softc *wd;
{
	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;

#ifdef WDDEBUG
	printf("wd(%d,%d) C%dH%dS%d\n", wd->sc_ctrlr, wd->sc_unit,
	    wd->sc_label.d_ncylinders, wd->sc_label.d_ntracks,
	    wd->sc_label.d_nsectors);
#endif
    
	if (wdcommand(wd, wd->sc_label.d_ncylinders, wd->sc_label.d_ntracks - 1,
	    0, wd->sc_label.d_nsectors, WDCC_IDC) != 0 ||
	    wdcwait(wdc, WDCS_READY) != 0) {
		wderror(wd, NULL, "wdsetctlr: failed");
		return -1;
	}
	return 0;
}

/*
 * Issue READP to drive to ask it what it is.
 */
static int
wdgetctlr(wd)
	struct wd_softc *wd;
{
	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
	int i;
	char tb[DEV_BSIZE];
	struct wdparams *wp;
    
	if (wdcommand(wd, 0, 0, 0, 0, WDCC_READP) != 0 ||
	    wait_for_drq(wdc) != 0) {
		/*
		 * If WDCC_READP fails then we might have an old drive so we
		 * try a seek to 0; if that passes then the drive is there but
		 * it's OLD AND KRUSTY.
		 */
		if (wdcommand(wd, 0, 0, 0, 0, WDCC_RESTORE | WD_STEP) != 0 ||
		    wait_for_ready(wdc) != 0)
			return -1;

		strncpy(wd->sc_label.d_typename, "ST506",
		    sizeof wd->sc_label.d_typename);
		strncpy(wd->sc_params.wdp_model, "Unknown Type",
		    sizeof wd->sc_params.wdp_model);
		wd->sc_label.d_type = DTYPE_ST506;
	} else {
		/* Obtain parameters. */
		wp = &wd->sc_params;
		insw(wdc->sc_iobase+wd_data, tb, sizeof(tb) / sizeof(short));
		bcopy(tb, wp, sizeof(struct wdparams));

		/* Shuffle string byte order. */
		for (i = 0; i < sizeof(wp->wdp_model); i += 2) {
			u_short *p;
			p = (u_short *)(wp->wdp_model + i);
			*p = ntohs(*p);
		}

		strncpy(wd->sc_label.d_typename, "ESDI/IDE",
		    sizeof wd->sc_label.d_typename);
		wd->sc_label.d_type = DTYPE_ESDI;
		bcopy(wp->wdp_model+20, wd->sc_label.d_packname, 14-1);

		/* Update disklabel given drive information. */
		wd->sc_label.d_ncylinders =
		    wp->wdp_fixedcyl + wp->wdp_removcyl /*+- 1*/;
		wd->sc_label.d_ntracks = wp->wdp_heads;
		wd->sc_label.d_nsectors = wp->wdp_sectors;
		wd->sc_label.d_secpercyl =
		    wd->sc_label.d_ntracks * wd->sc_label.d_nsectors;
		wd->sc_label.d_partitions[1].p_size =
		    wd->sc_label.d_secpercyl * wp->wdp_sectors;
		wd->sc_label.d_partitions[1].p_offset = 0;
	}

#if 0
	printf("gc %x cyl %d trk %d sec %d type %d sz %d model %s\n",
	    wp->wdp_config, wp->wdp_fixedcyl + wp->wdp_removcyl, wp->wdp_heads,
	    wp->wdp_sectors, wp->wdp_cntype, wp->wdp_cnsbsz, wp->wdp_model);
#endif
    
	wd->sc_label.d_subtype |= DSTYPE_GEOMETRY;
    
	/* XXX sometimes possibly needed */
	(void) inb(wdc->sc_iobase+wd_status);

	return 0;
}

int
wdclose(dev, flag, fmt)
	dev_t dev;
	int flag;
	int fmt;
{
	struct wd_softc *wd = wd_softc[WDUNIT(dev)];
	int part = WDPART(dev), mask = 1 << part;
    
	switch (fmt) {
	case S_IFCHR:
		wd->sc_copenpart &= ~mask;
		break;
	case S_IFBLK:
		wd->sc_bopenpart &= ~mask;
		break;
	}
	wd->sc_openpart = wd->sc_copenpart | wd->sc_bopenpart;

	return 0;
}

int
wdioctl(dev, cmd, addr, flag, p)
	dev_t dev;
	int cmd;
	caddr_t addr;
	int flag;
	struct proc *p;
{
	int lunit = WDUNIT(dev);
	struct wd_softc *wd = wd_softc[lunit];
	int error;
    
	switch (cmd) {
	case DIOCSBAD:
		if ((flag & FWRITE) == 0)
			return EBADF;
		wd->sc_cpulabel.bad = *(struct dkbad *)addr;
		bad144intern(wd);
		return 0;

	case DIOCGDINFO:
		*(struct disklabel *)addr = wd->sc_label;
		return 0;
	
	case DIOCGPART:
		((struct partinfo *)addr)->disklab = &wd->sc_label;
		((struct partinfo *)addr)->part =
		    &wd->sc_label.d_partitions[WDPART(dev)];
		return 0;
	
	case DIOCSDINFO:
		if ((flag & FWRITE) == 0)
			return EBADF;
		error = setdisklabel(&wd->sc_label,
		    (struct disklabel *)addr,
		    /*(wd->sc_flags & WDF_BSDLABEL) ? wd->sc_openpart : */0,
		    &wd->sc_cpulabel);
		if (error == 0) {
			wd->sc_flags |= WDF_BSDLABEL;
			wdsetctlr(wd);
		}
		return error;
	
	case DIOCWLABEL:
		wd->sc_flags &= ~WDF_WRITEPROT;
		if ((flag & FWRITE) == 0)
			return EBADF;
		wd->sc_wlabel = *(int *)addr;
		return 0;
	
	case DIOCWDINFO:
		wd->sc_flags &= ~WDF_WRITEPROT;
		if ((flag & FWRITE) == 0)
			return EBADF;
		error = setdisklabel(&wd->sc_label,
		    (struct disklabel *)addr,
		    /*(wd->sc_flags & WDF_BSDLABEL) ? wd->sc_openpart :*/0,
		    &wd->sc_cpulabel);
		if (error == 0) {
			int wlab;
	    
			wd->sc_flags |= WDF_BSDLABEL;
			wdsetctlr(wd);
	    
			/* Simulate opening partition 0 so write succeeds. */
			wd->sc_openpart |= (1 << 0);	    /* XXX */
			wlab = wd->sc_wlabel;
			wd->sc_wlabel = 1;
			error = writedisklabel(dev, wdstrategy, &wd->sc_label,
			    &wd->sc_cpulabel);
			wd->sc_openpart = wd->sc_copenpart | wd->sc_bopenpart;
			wd->sc_wlabel = wlab;
		}
		return error;
	
#ifdef notyet
	case DIOCGDINFOP:
		*(struct disklabel **)addr = &wd->sc_label;
		return 0;
	
	case DIOCWFORMAT:
		if ((flag & FWRITE) == 0)
			return EBADF;
	{
		register struct format_op *fop;
		struct iovec aiov;
		struct uio auio;
	    
		fop = (struct format_op *)addr;
		aiov.iov_base = fop->df_buf;
		aiov.iov_len = fop->df_count;
		auio.uio_iov = &aiov;
		auio.uio_iovcnt = 1;
		auio.uio_resid = fop->df_count;
		auio.uio_segflg = 0;
		auio.uio_offset =
		    fop->df_startblk * wd->sc_label.d_secsize;
		error = physio(wdformat, NULL, dev, B_WRITE, minphys,
		    &auio);
		fop->df_count -= auio.uio_resid;
		fop->df_reg[0] = wdc->sc_status;
		fop->df_reg[1] = wdc->sc_error;
		return error;
	}
#endif
	
	default:
		return ENOTTY;
	}

#ifdef DIAGNOSTIC
	panic("wdioctl: impossible");
#endif
}

#ifdef B_FORMAT
int
wdformat(struct buf *bp)
{

	bp->b_flags |= B_FORMAT;
	return wdstrategy(bp);
}
#endif

int
wdsize(dev)
	dev_t dev;
{
	int lunit = WDUNIT(dev), part = WDPART(dev);
	struct wd_softc *wd;
    
	if (lunit >= NWD)
		return -1;
	wd = wd_softc[lunit];
	if (wd == 0)
		return -1;
    
	if (wd->sc_state < OPEN || (wd->sc_flags & WDF_BSDLABEL) == 0) {
		int val;
		val = wdopen(makewddev(major(dev), lunit, WDRAW), FREAD,
		    S_IFBLK, 0);
		/* XXX Clear the open flag? */
		if (val != 0)
			return -1;
	}
    
	if ((wd->sc_flags & (WDF_WRITEPROT | WDF_BSDLABEL)) != WDF_BSDLABEL)
		return -1;

	return (int)wd->sc_label.d_partitions[part].p_size;
}

/*
 * Dump core after a system crash.
 */
int
wddump(dev)
	dev_t dev;
{
	struct wd_softc *wd;	/* disk unit to do the IO */
	struct wdc_softc *wdc;
	long num;		/* number of sectors to write */
	int lunit, part;
	long blkoff, blknum;
	long cylin, head, sector;
	long secpertrk, secpercyl, nblocks;
	char *addr;
	static wddoingadump = 0;
	extern caddr_t CADDR1;
	extern struct pte *CMAP1;
	
	addr = (char *)0;	/* starting address */
    
#if DO_NOT_KNOW_HOW
	/* Toss any characters present prior to dump, ie. non-blocking getc. */
	while (cngetc())
		;
#endif

	lunit = WDUNIT(dev);
	/* Check for acceptable drive number. */
	if (lunit >= NWD)
		return ENXIO;
	wd = wd_softc[lunit];
	/* Was it ever initialized? */
	if (wd == 0 || wd->sc_state < OPEN || wd->sc_flags & WDF_WRITEPROT)
		return ENXIO;

	wdc = (void *)wd->sc_dev.dv_parent;

	/* Convert to disk sectors. */
	num = ctob(physmem) / wd->sc_label.d_secsize;
    
	secpertrk = wd->sc_label.d_nsectors;
	secpercyl = wd->sc_label.d_secpercyl;
	part = WDPART(dev);
	nblocks = wd->sc_label.d_partitions[part].p_size;
	blkoff = wd->sc_label.d_partitions[part].p_offset;
    
	/*printf("part %x, nblocks %d, dumplo %d, num %d\n", part, nblocks,
	    dumplo, num);*/
    
	/* Check transfer bounds against partition size. */
	if (dumplo < 0 || dumplo + num > nblocks)
		return EINVAL;

	if (wddoingadump)
		return EFAULT;
	wddoingadump = 1;

	/* Recalibrate. */
	if (wdcommand(wd, 0, 0, 0, 0, WDCC_RESTORE | WD_STEP) != 0 ||
	    wait_for_ready(wdc) != 0 || wdsetctlr(wd) != 0) {
		wderror(wd, NULL, "wddump: recal failed");
		return EIO;
	}
    
	blknum = dumplo + blkoff;
	while (num > 0) {
		/* Compute disk address. */
		cylin = blknum / secpercyl;
		head = (blknum % secpercyl) / secpertrk;
		sector = blknum % secpertrk;
	
		if (wd->sc_flags & WDF_BADSECT) {
			long newblk;
			int i;

			for (i = 0; wd->sc_badsect[i] != -1; i++) {
				if (blknum < wd->sc_badsect[i]) {
					/* Sorted list, passed our block by. */
					break;
				} else if (blknum == wd->sc_badsect[i]) {
					newblk = wd->sc_label.d_secperunit -
						wd->sc_label.d_nsectors - i - 1;
					cylin = newblk / secpercyl;
					head = (newblk % secpercyl) / secpertrk;
					sector = newblk % secpertrk;
					/* Found and replaced; done. */
					break;
				}
			}
		}
		sector++;		/* origin 1 */
	    
#ifdef notdef
		/* Let's just talk about this first. */
		printf("cylin %d, head %d, sector %d, addr 0x%x", cylin, head,
		    sector, addr);
#endif
		if (wdcommand(wd, cylin, head, sector, 1, WDCC_WRITE) != 0) {
			wderror(wd, NULL, "wddump: wdcommand failed");
			return EIO;
		}
		if (wait_for_drq(wdc) != 0) {
			wderror(wd, NULL, "wddump: timeout waiting for drq");
			return EIO;
		}
	
#ifdef notdef	/* Cannot use this since this address was mapped differently. */
		pmap_enter(kernel_pmap, CADDR1, trunc_page(addr), VM_PROT_READ, TRUE);
#else
		*(int *)CMAP1 = PG_V | PG_KW | ctob((long)addr);
		tlbflush();
#endif
	
		outsw(wdc->sc_iobase+wd_data, CADDR1 + ((int)addr & PGOFSET),
		    DEV_BSIZE / sizeof(short));
	
		/* Check data request (should be done). */
		if (wait_for_ready(wdc) != 0) {
			wderror(wd, NULL, "wddump: timeout waiting for ready");
			return EIO;
		}
		if (wdc->sc_status & WDCS_DRQ) {
			wderror(wd, NULL, "wddump: extra drq");
			return EIO;
		}
	
		if ((unsigned)addr % 1048576 == 0)
			printf("%d ", num / (1048576 / DEV_BSIZE));

		/* Update block count. */
		num--;
		blknum++;
		(int)addr += DEV_BSIZE;
	
#if DO_NOT_KNOW_HOW
		/* Operator aborting dump? non-blocking getc() */
		if (cngetc())
			return EINTR;
#endif
	}
	return 0;
}

/*
 * Internalize the bad sector table.
 */
void
bad144intern(wd)
	struct wd_softc *wd;
{
	int i;

	if ((wd->sc_flags & WDF_BADSECT) == 0)
		return;

	for (i = 0; i < 127; i++)
		wd->sc_badsect[i] = -1;
	for (i = 0; i < 126; i++) {
		if (wd->sc_cpulabel.bad.bt_bad[i].bt_cyl == 0xffff)
			break;
		wd->sc_badsect[i] =
		    wd->sc_cpulabel.bad.bt_bad[i].bt_cyl *
		    wd->sc_label.d_secpercyl +
		    (wd->sc_cpulabel.bad.bt_bad[i].bt_trksec >> 8) *
			wd->sc_label.d_nsectors +
		    (wd->sc_cpulabel.bad.bt_bad[i].bt_trksec & 0x00ff);
	}
}

static int
wdcreset(wdc)
	struct wdc_softc *wdc;
{
	u_short iobase = wdc->sc_iobase;

	/* Reset the device. */
	outb(iobase+wd_ctlr, WDCTL_RST | WDCTL_IDS);
	delay(1000);
	outb(iobase+wd_ctlr, WDCTL_IDS);
	delay(1000);
	(void) inb(iobase+wd_error);
	outb(iobase+wd_ctlr, WDCTL_4BIT);

	if (wait_for_unbusy(wdc) < 0) {
		printf("%s: reset failed\n", wdc->sc_dev.dv_xname);
		return 1;
	}

	return 0;
}

static void
wdcrestart(wdc)
	struct wdc_softc *wdc;
{
	int s = splbio();

	wdc->sc_q.b_active = 0;
	wdcstart(wdc);
	splx(s);
}

/*
 * Unwedge the controller after an unexpected error.  We do this by resetting
 * it, marking all drives for recalibration, and stalling the queue for a short
 * period to give the reset time to finish.
 * NOTE: We use a timeout here, so this routine must not be called during
 * autoconfig or dump.
 */
static void
wdcunwedge(wdc)
	struct wdc_softc *wdc;
{
	int lunit;

	wdc->sc_timeout = 0;
	(void) wdcreset(wdc);

	/* Schedule recalibrate for all drives on this controller. */
	for (lunit = 0; lunit < NWD; lunit++) {
		struct wd_softc *wd = wd_softc[lunit];
		if (!wd || (void *)wd->sc_dev.dv_parent != wdc)
			continue;
		if (wd->sc_state > WANTOPEN)
			wd->sc_state = WANTOPEN;
		if (wd->sc_q.b_active && (wd->sc_flags & WDF_SINGLE) == 0)
			wd->sc_flags |= WDF_ERROR;
	}

	++wdc->sc_q.b_errcnt;

	/* Wake up in a little bit and restart the operation. */
	timeout((timeout_t)wdcrestart, (caddr_t)wdc, RECOVERYTIME);
}

int
wdcwait(wdc, mask)
	struct wdc_softc *wdc;
	int mask;
{
	u_short iobase = wdc->sc_iobase;
	int timeout = 0;
	u_char status;

	for (;;) {
		wdc->sc_status = status = inb(iobase+wd_altsts);
		if ((status & WDCS_BUSY) == 0 && (status & mask) == mask)
			break;
		if (++timeout > WDCNDELAY)
			return -1;
		delay(WDCDELAY);
	}
	if (status & WDCS_ERR)
		wdc->sc_error = inb(iobase+wd_error);
#ifdef WDCNDELAY_DEBUG
	if (timeout > WDCNDELAY_DEBUG)
		printf("%s: busy-wait took %dus\n", wdc->sc_dev.dv_xname,
		    WDCDELAY * timeout);
#endif
	return status & WDCS_ERR;
}

static void
wdctimeout(wdc)
	struct wdc_softc *wdc;
{
	int s = splbio();

	if (wdc->sc_timeout && --wdc->sc_timeout == 0) {
		wderror(wdc, NULL, "lost interrupt");
		wdcunwedge(wdc);
	}
	timeout((timeout_t)wdctimeout, (caddr_t)wdc, hz);
	splx(s);
}

static void
wderror(dev, bp, msg)
	void *dev;
	struct buf *bp;
	char *msg;
{
	struct wd_softc *wd = dev;
	struct wdc_softc *wdc = dev;

	if (bp)
		diskerr(bp, "wd", msg, LOG_PRINTF, wd->sc_skip, &wd->sc_label);
	else
		printf("%s: %s: status %b error %b\n", wdc->sc_dev.dv_xname,
		    msg, wdc->sc_status, WDCS_BITS, wdc->sc_error, WDERR_BITS);
}

#endif /* NWDC > 0 */