xref: /src/sys/dev/ata/wd.c

/*	$NetBSD: wd.c,v 1.132 1995/03/23 11:33:32 mycroft Exp $	*/

/*
 * Copyright (c) 1994, 1995 Charles Hannum.  All rights reserved.
 *
 * DMA and multi-sector PIO handling are derived from code contributed by
 * Onno van der Linden.
 *
 * 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 Charles Hannum.
 * 4. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * 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.
 *
 *	@(#)wd.c	7.2 (Berkeley) 5/9/91
 */

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

#include <sys/param.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/buf.h>
#include <sys/uio.h>
#include <sys/malloc.h>
#include <sys/device.h>
#include <sys/disklabel.h>
#include <sys/disk.h>
#include <sys/syslog.h>
#ifdef INSTRUMENT
#include <sys/dkstat.h>
#endif

#include <vm/vm.h>

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

#include <i386/isa/isavar.h>
#include <dev/isa/wdreg.h>

#define WDCNDELAY	100000	/* delay = 100us; so 10s for a controller state change */
#define WDCDELAY	100

#define	WAITTIME	(4 * hz)	/* time to wait for a completion */
#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	10
#endif

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

#define	WDUNIT(dev)			DISKUNIT(dev)
#define	WDPART(dev)			DISKPART(dev)
#define	MAKEWDDEV(maj, unit, part)	MAKEDISKDEV(maj, unit, part)

#define	WDLABELDEV(dev)	(MAKEWDDEV(major(dev), WDUNIT(dev), RAW_PART))

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

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

	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 transferring */
	int sc_nbytes;		/* number of bytes currently transferring */

	int sc_drive;		/* physical unit number */
	int sc_state;		/* control state */
#define	RECAL		0		/* recalibrate */
#define	RECAL_WAIT	1		/* done recalibrating */
#define	GEOMETRY	2		/* upload geometry */
#define	GEOMETRY_WAIT	3		/* done uploading geometry */
#define	MULTIMODE	4		/* set multiple mode */
#define	MULTIMODE_WAIT	5		/* done setting multiple mode */
#define	OPEN		6		/* done with open */
	int sc_mode;		/* transfer mode */
#define	WDM_PIOSINGLE	0		/* single-sector PIO */
#define	WDM_PIOMULTI	1		/* multi-sector PIO */
#define	WDM_DMA		2		/* DMA */
	int sc_multiple;	/* multiple for WDM_PIOMULTI */
	int sc_flags;		/* drive characteistics found */
#define	WDF_LOCKED	0x01
#define	WDF_WANTED	0x02
#define	WDF_WLABEL	0x04		/* label is writable */
#define	WDF_LABELLING	0x08		/* writing label */
#define	WDF_LOADED	0x10
#define	WDF_32BIT	0x20		/* can do 32-bit transfer */

	struct wdparams sc_params; /* ESDI/IDE drive/controller parameters */
	daddr_t	sc_badsect[127];	/* 126 plus trailing -1 marker */

	TAILQ_ENTRY(wd_softc) sc_drivechain;
	struct buf sc_q;
};

struct wdc_softc {
	struct device sc_dev;
	struct intrhand sc_ih;

	int sc_iobase;		/* I/O port base */
	int sc_drq;		/* DMA channel */

	TAILQ_HEAD(drivehead, wd_softc) sc_drives;
	int sc_flags;
#define	WDCF_ACTIVE	0x01	/* controller is active */
#define	WDCF_SINGLE	0x02	/* sector at a time mode */
#define	WDCF_ERROR	0x04	/* processing a disk error */
#define	WDCF_WANTED	0x08	/* XXX locking for wd_get_parms() */
	int sc_errors;		/* count of errors during current transfer */
	u_char sc_status;	/* copy of status register */
	u_char sc_error;	/* copy of error register */
};

int wdcprobe __P((struct device *, void *, void *));
void wdcattach __P((struct device *, struct device *, void *));

struct cfdriver wdccd = {
	NULL, "wdc", wdcprobe, wdcattach, DV_DULL, sizeof(struct wdc_softc)
};

int wdprobe __P((struct device *, void *, void *));
void wdattach __P((struct device *, struct device *, void *));

struct cfdriver wdcd = {
	NULL, "wd", wdprobe, wdattach, DV_DISK, sizeof(struct wd_softc)
};

void wdgetdisklabel __P((struct wd_softc *));
int wd_get_parms __P((struct wd_softc *));
void wdstrategy __P((struct buf *));
void wdstart __P((struct wd_softc *));

struct dkdriver wddkdriver = { wdstrategy };

void wdfinish __P((struct wd_softc *, struct buf *));
int wdcintr __P((struct wdc_softc *));
static void wdcstart __P((struct wdc_softc *));
static int wdcommand __P((struct wd_softc *, int, int, int, int, int));
static int wdcommandshort __P((struct wdc_softc *, int, int));
static int wdcontrol __P((struct wd_softc *));
static int wdsetctlr __P((struct wd_softc *));
static void bad144intern __P((struct wd_softc *));
static int wdcreset __P((struct wdc_softc *));
static void wdcrestart __P((void *arg));
static void wdcunwedge __P((struct wdc_softc *));
static void wdctimeout __P((void *arg));
static void wderror __P((void *, struct buf *, char *));
int wdcwait __P((struct wdc_softc *, int));
/* ST506 spec says that if READY or SEEKCMPLT go off, then the read or write
   command is aborted. */
#define	wait_for_drq(d)		wdcwait(d, WDCS_DRDY | WDCS_DSC | WDCS_DRQ)
#define	wait_for_ready(d)	wdcwait(d, WDCS_DRDY | WDCS_DSC)
#define	wait_for_unbusy(d)	wdcwait(d, 0)

/*
 * Probe for controller.
 */
int
wdcprobe(parent, match, aux)
	struct device *parent;
	void *match, *aux;
{
	struct wdc_softc *wdc = match;
	struct isa_attach_args *ia = aux;
	int iobase;

	wdc->sc_iobase = iobase = ia->ia_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;
	}

	outb(iobase+wd_sdh, WDSD_IBM | 0);

	/* Wait for controller to become ready. */
	if (wait_for_unbusy(wdc) < 0)
		return 0;

	/* Send command. */
	outb(iobase+wd_command, WDCC_DIAGNOSE);

	/* Wait for command to complete. */
	if (wait_for_unbusy(wdc) < 0)
		return 0;

	ia->ia_iosize = 8;
	ia->ia_msize = 0;
	return 1;
}

struct wdc_attach_args {
	int wa_drive;
};

int
wdprint(aux, wdc)
	void *aux;
	char *wdc;
{
	struct wdc_attach_args *wa = aux;

	if (!wdc)
		printf(" drive %d", wa->wa_drive);
	return QUIET;
}

void
wdcattach(parent, self, aux)
	struct device *parent, *self;
	void *aux;
{
	struct wdc_softc *wdc = (void *)self;
	struct isa_attach_args *ia = aux;
	struct wdc_attach_args wa;

	TAILQ_INIT(&wdc->sc_drives);
	wdc->sc_drq = ia->ia_drq;

	printf("\n");

	wdc->sc_ih.ih_fun = wdcintr;
	wdc->sc_ih.ih_arg = wdc;
	wdc->sc_ih.ih_level = IPL_BIO;
	intr_establish(ia->ia_irq, IST_EDGE, &wdc->sc_ih);

	for (wa.wa_drive = 0; wa.wa_drive < 2; wa.wa_drive++)
		(void)config_found(self, (void *)&wa, wdprint);
}

int
wdprobe(parent, match, aux)
	struct device *parent;
	void *match, *aux;
{
	struct wdc_softc *wdc = (void *)parent;
	struct cfdata *cf = match;
	struct wdc_attach_args *wa = aux;
	int drive = wa->wa_drive;

	if (cf->cf_loc[0] != -1 && cf->cf_loc[0] != drive)
		return 0;

	if (wdcommandshort(wdc, drive, WDCC_RECAL) != 0 ||
	    wait_for_ready(wdc) != 0)
		return 0;

	return 1;
}

void
wdattach(parent, self, aux)
	struct device *parent, *self;
	void *aux;
{
	struct wd_softc *wd = (void *)self;
	struct wdc_softc *wdc = (void *)parent;
	struct wdc_attach_args *wa = aux;
	int i, blank;

	wd->sc_drive = wa->wa_drive;

	wd_get_parms(wd);
	printf(": %dMB, %d cyl, %d head, %d sec, %d bytes/sec <",
	    wd->sc_params.wdp_cylinders *
	    (wd->sc_params.wdp_heads * wd->sc_params.wdp_sectors) /
	    (1048576 / DEV_BSIZE),
	    wd->sc_params.wdp_cylinders,
	    wd->sc_params.wdp_heads,
	    wd->sc_params.wdp_sectors,
	    DEV_BSIZE);
	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");

	if ((wd->sc_params.wdp_capabilities & WD_CAP_DMA) != 0 &&
	    wdc->sc_drq != DRQUNK) {
		wd->sc_mode = WDM_DMA;
	} else if (wd->sc_params.wdp_maxmulti > 1) {
		wd->sc_mode = WDM_PIOMULTI;
		wd->sc_multiple = min(wd->sc_params.wdp_maxmulti, 16);
	} else {
		wd->sc_mode = WDM_PIOSINGLE;
		wd->sc_multiple = 1;
	}

	printf("%s: using", wd->sc_dev.dv_xname);
	if (wd->sc_mode == WDM_DMA)
		printf(" dma transfers,");
	else
		printf(" %d-sector %d-bit pio transfers,",
		    wd->sc_multiple, (wd->sc_flags & WDF_32BIT) == 0 ? 16 : 32);
	if ((wd->sc_params.wdp_capabilities & WD_CAP_LBA) != 0)
		printf(" lba addressing\n");
	else
		printf(" chs addressing\n");

	wd->sc_dk.dk_driver = &wddkdriver;
}

/*
 * 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 wd_softc *wd;	/* disk unit to do the IO */
	int unit = WDUNIT(bp->b_dev);
	int s;

	/* Valid unit, controller, and request?  */
	if (unit >= wdcd.cd_ndevs ||
	    (wd = wdcd.cd_devs[unit]) == 0 ||
	    bp->b_blkno < 0 ||
	    (bp->b_bcount % wd->sc_dk.dk_label.d_secsize) != 0 ||
	    (bp->b_bcount / wd->sc_dk.dk_label.d_secsize) >= (1 << NBBY)) {
		bp->b_error = EINVAL;
		goto bad;
	}

#if 0
	/* "Soft" write protect check. */
	if ((wd->sc_flags & WDF_WRITEPROT) && (bp->b_flags & B_READ) == 0) {
		bp->b_error = EROFS;
		goto bad;
	}
#endif

	/* If it's a null transfer, return immediately. */
	if (bp->b_bcount == 0)
		goto done;

	/*
	 * Do bounds checking, adjust transfer. if error, process.
	 * If end of partition, just return.
	 */
	if (bounds_check_with_label(bp, &wd->sc_dk.dk_label,
	    (wd->sc_flags & (WDF_WLABEL|WDF_LABELLING)) != 0) <= 0)
		goto done;

	/* Don't bother doing rotational optimization. */
	bp->b_cylin = 0;

	/* Queue transfer on drive, activate drive and controller if idle. */
	s = splbio();
	disksort(&wd->sc_q, bp);
	if (!wd->sc_q.b_active)
		wdstart(wd);		/* Start drive. */
#if 0
	else {
		struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
		if ((wdc->sc_flags & (WDCF_ACTIVE|WDCF_ERROR)) == 0) {
			printf("wdstrategy: controller inactive\n");
			wdcstart(wdc);
		}
	}
#endif
	splx(s);
	return;

bad:
	bp->b_flags |= B_ERROR;
done:
	/* Toss transfer; we're done early. */
	biodone(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.
 */
void
wdstart(wd)
	struct wd_softc *wd;
{
	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
	int active = wdc->sc_drives.tqh_first != 0;

	/* Link onto controller queue. */
	wd->sc_q.b_active = 1;
	TAILQ_INSERT_TAIL(&wdc->sc_drives, wd, sc_drivechain);

	/* If controller not already active, start it. */
	if (!active)
		wdcstart(wdc);
}

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_dev.dv_unit);
#endif
	wdc->sc_flags &= ~(WDCF_SINGLE | WDCF_ERROR);
	wdc->sc_errors = 0;
	/*
	 * Move this drive to the end of the queue to give others a `fair'
	 * chance.
	 */
	if (wd->sc_drivechain.tqe_next) {
		TAILQ_REMOVE(&wdc->sc_drives, wd, sc_drivechain);
		if (bp->b_actf) {
			TAILQ_INSERT_TAIL(&wdc->sc_drives, wd, sc_drivechain);
		} else
			wd->sc_q.b_active = 0;
	}
	bp->b_resid = wd->sc_bcount;
	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;
	int nblks;

	/*
	 * XXX
	 * This is a kluge.  See comments in wd_get_parms().
	 */
	if ((wdc->sc_flags & WDCF_WANTED) != 0) {
		wdc->sc_flags &= ~WDCF_WANTED;
		wakeup(wdc);
		return;
	}

loop:
	/* Is there a drive for the controller to do a transfer with? */
	wd = wdc->sc_drives.tqh_first;
	if (wd == NULL)
		return;

	/* Is there a transfer to this drive?  If not, deactivate drive. */
	bp = wd->sc_q.b_actf;
	if (bp == NULL) {
		TAILQ_REMOVE(&wdc->sc_drives, wd, sc_drivechain);
		wd->sc_q.b_active = 0;
		goto loop;
	}

	if (wdc->sc_errors >= WDIORETRIES) {
		wderror(wd, bp, "hard error");
		bp->b_error = EIO;
		bp->b_flags |= B_ERROR;
		wdfinish(wd, bp);
		goto loop;
	}

	/* Do control operations specially. */
	if (wd->sc_state < OPEN) {
		/*
		 * Actually, we want to be careful not to mess with the control
		 * state if the device is currently busy, but we can assume
		 * that we never get to this point if that's the case.
		 */
		if (wdcontrol(wd) == 0) {
			/* The drive is busy.  Wait. */
			return;
		}
	}

	/*
	 * WDCF_ERROR is set by wdcunwedge() and wdcintr() when an error is
	 * encountered.  If we are in multi-sector mode, then we switch to
	 * single-sector mode and retry the operation from the start.
	 */
	if (wdc->sc_flags & WDCF_ERROR) {
		wdc->sc_flags &= ~WDCF_ERROR;
		if ((wdc->sc_flags & WDCF_SINGLE) == 0) {
			wdc->sc_flags |= WDCF_SINGLE;
			wd->sc_skip = 0;
		}
	}

	lp = &wd->sc_dk.dk_label;

	if (wd->sc_skip == 0) {
		int part = WDPART(bp->b_dev);
		daddr_t blkno;

#ifdef WDDEBUG
		printf("\n%s: wdcstart %s %d@%d; map ", wd->sc_dev.dv_xname,
		    (bp->b_flags & B_READ) ? "read" : "write", bp->b_bcount,
		    bp->b_blkno);
#endif
		wd->sc_bcount = bp->b_bcount;
		blkno = bp->b_blkno;
		if (part != RAW_PART)
			blkno += lp->d_partitions[part].p_offset;
		wd->sc_blkno = blkno / (lp->d_secsize / DEV_BSIZE);
#ifdef INSTRUMENT
		dk_busy |= (1 << wd->sc_dev.dv_unit);
		dk_wds[wd->sc_dev.dv_unit] += bp->b_bcount >> 6;
#endif
	} else {
#ifdef WDDEBUG
		printf(" %d)%x", wd->sc_skip, inb(wd->sc_iobase+wd_altsts));
#endif
	}

	/* If starting a multisector transfer, or doing single transfers. */
	if (wd->sc_skip == 0 || (wdc->sc_flags & WDCF_SINGLE) != 0 ||
	    wd->sc_mode == WDM_DMA) {
		daddr_t blkno = wd->sc_blkno;
		long cylin, head, sector;
		int command;

		if ((wdc->sc_flags & WDCF_SINGLE) != 0)
			nblks = 1;
		else if (wd->sc_mode != WDM_DMA)
			nblks = wd->sc_bcount / lp->d_secsize;
		else
			nblks = min(wd->sc_bcount / lp->d_secsize, 8);

		/* Check for bad sectors and adjust transfer, if necessary. */
		if ((lp->d_flags & D_BADSECT) != 0
#ifdef B_FORMAT
		    && (bp->b_flags & B_FORMAT) == 0
#endif
		    ) {
			long blkdiff;
			int i;

			for (i = 0; (blkdiff = wd->sc_badsect[i]) != -1; i++) {
				blkdiff -= blkno;
				if (blkdiff < 0)
					continue;
				if (blkdiff == 0) {
					/* Replace current block of transfer. */
					blkno =
					    lp->d_secperunit - lp->d_nsectors - i - 1;
				}
				if (blkdiff < nblks) {
					/* Bad block inside transfer. */
					wdc->sc_flags |= WDCF_SINGLE;
					nblks = 1;
				}
				break;
			}
			/* Tranfer is okay now. */
		}

		if ((wd->sc_params.wdp_capabilities & WD_CAP_LBA) != 0) {
			sector = (blkno >> 0) & 0xff;
			cylin = (blkno >> 8) & 0xffff;
			head = (blkno >> 24) & 0xf;
			head |= WDSD_LBA;
		} else {
			sector = blkno % lp->d_nsectors;
			sector++;	/* Sectors begin with 1, not 0. */
			blkno /= lp->d_nsectors;
			head = blkno % lp->d_ntracks;
			blkno /= lp->d_ntracks;
			cylin = blkno;
			head |= WDSD_CHS;
		}

#ifdef INSTRUMENT
		++dk_seek[wd->sc_dev.dv_unit];
		++dk_xfer[wd->sc_dev.dv_unit];
#endif

		if (wd->sc_mode == WDM_PIOSINGLE ||
		    (wdc->sc_flags & WDCF_SINGLE) != 0)
			wd->sc_nblks = 1;
		else if (wd->sc_mode == WDM_PIOMULTI)
			wd->sc_nblks = min(nblks, wd->sc_multiple);
		else
			wd->sc_nblks = nblks;
		wd->sc_nbytes = wd->sc_nblks * lp->d_secsize;

#ifdef B_FORMAT
		if (bp->b_flags & B_FORMAT) {
			sector = lp->d_gap3;
			nblks = lp->d_nsectors;
			command = WDCC_FORMAT;
		} else
#endif
		switch (wd->sc_mode) {
		case WDM_DMA:
			command = (bp->b_flags & B_READ) ?
			    WDCC_READDMA : WDCC_WRITEDMA;
			isa_dmastart(bp->b_flags & B_READ,
			    bp->b_data + wd->sc_skip,
			    wd->sc_nbytes, wdc->sc_drq);
			break;
		case WDM_PIOMULTI:
			command = (bp->b_flags & B_READ) ?
			    WDCC_READMULTI : WDCC_WRITEMULTI;
			break;
		case WDM_PIOSINGLE:
			command = (bp->b_flags & B_READ) ?
			    WDCC_READ : WDCC_WRITE;
			break;
		}

		/* Initiate command! */
		if (wdcommand(wd, command, cylin, head, sector, nblks) != 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_data, inb(wd->sc_iobase+wd_altsts));
#endif
	} else if (wd->sc_nblks > 1) {
		nblks = wd->sc_bcount / lp->d_secsize;
		if (wd->sc_nblks > nblks) {
			wd->sc_nblks = nblks;
			wd->sc_nbytes = wd->sc_bcount;
		}
	}

	/* If this was a write and not using DMA, push the data. */
	if (wd->sc_mode != WDM_DMA &&
	    (bp->b_flags & B_READ) == 0) {
		if (wait_for_drq(wdc) < 0) {
			wderror(wd, NULL, "wdcstart: timeout waiting for drq");
			wdcunwedge(wdc);
			return;
		}

		/* Then send it! */
		if ((wd->sc_flags & WDF_32BIT) == 0)
			outsw(wdc->sc_iobase+wd_data, bp->b_data + wd->sc_skip,
			    wd->sc_nbytes >> 1);
		else
			outsl(wdc->sc_iobase+wd_data, bp->b_data + wd->sc_skip,
			    wd->sc_nbytes >> 2);
	}

	wdc->sc_flags |= WDCF_ACTIVE;
	timeout(wdctimeout, wdc, WAITTIME);
}

/*
 * 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
wdcintr(wdc)
	struct wdc_softc *wdc;
{
	struct wd_softc *wd;
	struct buf *bp;

	if ((wdc->sc_flags & WDCF_ACTIVE) == 0) {
		/* Clear the pending interrupt. */
		(void) inb(wdc->sc_iobase+wd_status);
		return 0;
	}

	wdc->sc_flags &= ~WDCF_ACTIVE;
	untimeout(wdctimeout, wdc);

	wd = wdc->sc_drives.tqh_first;
	bp = wd->sc_q.b_actf;

#ifdef WDDEBUG
	printf("I%d ", ctrlr);
#endif

	if (wait_for_unbusy(wdc) < 0) {
		wderror(wd, NULL, "wdcintr: timeout waiting for unbusy");
		wdc->sc_status |= WDCS_ERR;	/* XXX */
	}

	/* Is it not a transfer, but a control operation? */
	if (wd->sc_state < OPEN) {
		if (wdcontrol(wd) == 0) {
			/* The drive is busy.  Wait. */
			return 1;
		}
		wdcstart(wdc);
		return 1;
	}

	if (wd->sc_mode == WDM_DMA)
		isa_dmadone(bp->b_flags & B_READ, bp->b_data + wd->sc_skip,
		    wd->sc_nbytes, wdc->sc_drq);

	/* Have we an error? */
	if (wdc->sc_status & WDCS_ERR) {
	lose:
#ifdef WDDEBUG
		wderror(wd, NULL, "wdcintr");
#endif
		if ((wdc->sc_flags & WDCF_SINGLE) == 0) {
			wdc->sc_flags |= WDCF_ERROR;
			goto restart;
		}

#ifdef B_FORMAT
		if (bp->b_flags & B_FORMAT)
			goto bad;
#endif

		if (++wdc->sc_errors < WDIORETRIES)
			goto restart;
		wderror(wd, bp, "hard error");

	bad:
		bp->b_error = EIO;
		bp->b_flags |= B_ERROR;
		goto done;
	}

	if (wdc->sc_status & WDCS_CORR)
		wderror(wd, bp, "soft ecc");

	/* If this was a read and not using DMA, fetch the data. */
	if (wd->sc_mode != WDM_DMA &&
	    (bp->b_flags & B_READ) != 0) {
		if ((wdc->sc_status & (WDCS_DRDY | WDCS_DSC | WDCS_DRQ))
		    != (WDCS_DRDY | WDCS_DSC | WDCS_DRQ)) {
			wderror(wd, NULL, "wdcintr: read intr before drq");
			wdcunwedge(wdc);
			return 1;
		}

		/* Suck in data. */
		if ((wd->sc_flags & WDF_32BIT) == 0)
			insw(wdc->sc_iobase+wd_data, bp->b_data + wd->sc_skip,
			    wd->sc_nbytes >> 1);
		else
			insl(wdc->sc_iobase+wd_data, bp->b_data + wd->sc_skip,
			    wd->sc_nbytes >> 2);
	}

	/* If we encountered any abnormalities, flag it as a soft error. */
	if (wdc->sc_errors) {
		wderror(wd, bp, "soft error");
		wdc->sc_errors = 0;
	}

	/* Ready for the next block, if any. */
	wd->sc_blkno += wd->sc_nblks;
	wd->sc_skip += wd->sc_nbytes;
	wd->sc_bcount -= wd->sc_nbytes;

	/* 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. */
	wdcstart(wdc);

	return 1;
}

int
wdlockwait(wd)
	struct wd_softc *wd;
{
	int error;

	while ((wd->sc_flags & WDF_LOCKED) != 0) {
		wd->sc_flags |= WDF_WANTED;
		if ((error = tsleep(wd, PRIBIO | PCATCH, "wdlck", 0)) != 0)
			return error;
	}
	return 0;
}

void
wdunlock(wd)
	struct wd_softc *wd;
{

	wd->sc_flags &= ~WDF_LOCKED;
	if ((wd->sc_flags & WDF_WANTED) != 0) {
		wd->sc_flags &= ~WDF_WANTED;
		wakeup(wd);
	}
}

/*
 * Initialize a drive.
 */
int
wdopen(dev, flag, fmt)
	dev_t dev;
	int flag, fmt;
{
	int error;
	int unit, part;
	struct wd_softc *wd;

	unit = WDUNIT(dev);
	if (unit >= wdcd.cd_ndevs)
		return ENXIO;
	wd = wdcd.cd_devs[unit];
	if (wd == 0)
		return ENXIO;

	part = WDPART(dev);

	if (error = wdlockwait(wd))
		return error;

	if (wd->sc_dk.dk_openmask != 0) {
		/*
		 * If any partition is open, but the disk has been invalidated,
		 * disallow further opens.
		 */
		if ((wd->sc_flags & WDF_LOADED) == 0)
			return ENXIO;
	} else {
		wd->sc_flags |= WDF_LOCKED;

		if ((wd->sc_flags & WDF_LOADED) == 0) {
			wd->sc_flags |= WDF_LOADED;

			/* Load the physical device parameters. */
			if (wd_get_parms(wd) != 0) {
				error = ENXIO;
				goto bad2;
			}

			/* Load the partition info if not already loaded. */
			wdgetdisklabel(wd);
		}

		wdunlock(wd);
	}

	/* Check that the partition exists. */
	if (part != RAW_PART &&
	    (part >= wd->sc_dk.dk_label.d_npartitions ||
	     wd->sc_dk.dk_label.d_partitions[part].p_fstype == FS_UNUSED)) {
		error = ENXIO;
		goto bad;
	}

	/* Insure only one open at a time. */
	switch (fmt) {
	case S_IFCHR:
		wd->sc_dk.dk_copenmask |= (1 << part);
		break;
	case S_IFBLK:
		wd->sc_dk.dk_bopenmask |= (1 << part);
		break;
	}
	wd->sc_dk.dk_openmask = wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;

	return 0;

bad2:
	wd->sc_flags &= ~WDF_LOADED;

bad:
	if (wd->sc_dk.dk_openmask == 0) {
		wdunlock(wd);
	}

	return error;
}

void
wdgetdisklabel(wd)
	struct wd_softc *wd;
{
	char *errstring;

	bzero(&wd->sc_dk.dk_label, sizeof(struct disklabel));
	bzero(&wd->sc_dk.dk_cpulabel, sizeof(struct cpu_disklabel));

	wd->sc_dk.dk_label.d_secsize = DEV_BSIZE;
	wd->sc_dk.dk_label.d_ntracks = wd->sc_params.wdp_heads;
	wd->sc_dk.dk_label.d_nsectors = wd->sc_params.wdp_sectors;
	wd->sc_dk.dk_label.d_ncylinders = wd->sc_params.wdp_cylinders;
	wd->sc_dk.dk_label.d_secpercyl =
	    wd->sc_dk.dk_label.d_ntracks * wd->sc_dk.dk_label.d_nsectors;

#if 0
	strncpy(wd->sc_dk.dk_label.d_typename, "ST506 disk", 16);
	wd->sc_dk.dk_label.d_type = DTYPE_ST506;
#endif
	strncpy(wd->sc_dk.dk_label.d_packname, wd->sc_params.wdp_model, 16);
	wd->sc_dk.dk_label.d_secperunit =
	    wd->sc_dk.dk_label.d_secpercyl * wd->sc_dk.dk_label.d_ncylinders;
	wd->sc_dk.dk_label.d_rpm = 3600;
	wd->sc_dk.dk_label.d_interleave = 1;
	wd->sc_dk.dk_label.d_flags = 0;

	wd->sc_dk.dk_label.d_partitions[RAW_PART].p_offset = 0;
	wd->sc_dk.dk_label.d_partitions[RAW_PART].p_size =
	    wd->sc_dk.dk_label.d_secperunit *
	    (wd->sc_dk.dk_label.d_secsize / DEV_BSIZE);
	wd->sc_dk.dk_label.d_partitions[RAW_PART].p_fstype = FS_UNUSED;
	wd->sc_dk.dk_label.d_npartitions = RAW_PART + 1;

	wd->sc_dk.dk_label.d_magic = DISKMAGIC;
	wd->sc_dk.dk_label.d_magic2 = DISKMAGIC;
	wd->sc_dk.dk_label.d_checksum = dkcksum(&wd->sc_dk.dk_label);

	wd->sc_badsect[0] = -1;

	if (wd->sc_state > RECAL)
		wd->sc_state = RECAL;
	errstring = readdisklabel(MAKEWDDEV(0, wd->sc_dev.dv_unit, RAW_PART),
	    wdstrategy, &wd->sc_dk.dk_label, &wd->sc_dk.dk_cpulabel);
	if (errstring) {
		/*
		 * This probably happened because the drive's default
		 * geometry doesn't match the DOS geometry.  We
		 * assume the DOS geometry is now in the label and try
		 * again.  XXX This is a kluge.
		 */
		if (wd->sc_state > GEOMETRY)
			wd->sc_state = GEOMETRY;
		errstring = readdisklabel(MAKEWDDEV(0, wd->sc_dev.dv_unit, RAW_PART),
		    wdstrategy, &wd->sc_dk.dk_label, &wd->sc_dk.dk_cpulabel);
	}
	if (errstring) {
		printf("%s: %s\n", wd->sc_dev.dv_xname, errstring);
		return;
	}

	if (wd->sc_state > GEOMETRY)
		wd->sc_state = GEOMETRY;
	if ((wd->sc_dk.dk_label.d_flags & D_BADSECT) != 0)
		bad144intern(wd);
}

/*
 * Implement operations other than read/write.
 * Called from wdcstart or wdcintr 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(wd)
	struct wd_softc *wd;
{
	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;

	switch (wd->sc_state) {
	case RECAL:			/* Set SDH, step rate, do recal. */
		if (wdcommandshort(wdc, wd->sc_drive, WDCC_RECAL) != 0) {
			wderror(wd, NULL, "wdcontrol: recal failed (1)");
			goto bad;
		}
		wd->sc_state = RECAL_WAIT;
		break;

	case RECAL_WAIT:
		if (wdc->sc_status & WDCS_ERR) {
			wderror(wd, NULL, "wdcontrol: recal failed (2)");
			goto bad;
		}
		/* fall through */
	case GEOMETRY:
		if ((wd->sc_params.wdp_capabilities & WD_CAP_LBA) != 0)
			goto multimode;
		if (wdsetctlr(wd) != 0) {
			/* Already printed a message. */
			goto bad;
		}
		wd->sc_state = GEOMETRY_WAIT;
		break;

	case GEOMETRY_WAIT:
		if (wdc->sc_status & WDCS_ERR) {
			wderror(wd, NULL, "wdcontrol: geometry failed");
			goto bad;
		}
		/* fall through */
	case MULTIMODE:
	multimode:
		if (wd->sc_mode != WDM_PIOMULTI)
			goto open;
		outb(wdc->sc_iobase+wd_seccnt, wd->sc_multiple);
		if (wdcommandshort(wdc, wd->sc_drive, WDCC_SETMULTI) != 0) {
			wderror(wd, NULL, "wdcontrol: setmulti failed (1)");
			goto bad;
		}
		wd->sc_state = MULTIMODE_WAIT;
		break;

	case MULTIMODE_WAIT:
		if (wdc->sc_status & WDCS_ERR) {
			wderror(wd, NULL, "wdcontrol: setmulti failed (2)");
			goto bad;
		}
		/* fall through */
	case OPEN:
	open:
		wdc->sc_errors = 0;
		wd->sc_state = OPEN;
		/*
		 * The rest of the initialization can be done by normal means.
		 */
		return 1;

	bad:
		wdcunwedge(wdc);
		return 0;
	}

	wdc->sc_flags |= WDCF_ACTIVE;
	timeout(wdctimeout, wdc, WAITTIME);
	return 0;
}

/*
 * 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, command, cylin, head, sector, count)
	struct wd_softc *wd;
	int command;
	int cylin, head, sector, count;
{
	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
	int iobase = wdc->sc_iobase;
	int stat;

	/* Select drive, head, and addressing mode. */
	outb(iobase+wd_sdh, WDSD_IBM | (wd->sc_drive << 4) | head);

	/* Wait for it to become ready to accept a command. */
	if (command == WDCC_IDP)
		stat = wait_for_unbusy(wdc);
	else
		stat = wdcwait(wdc, WDCS_DRDY);
	if (stat < 0)
		return -1;

	/* Load parameters. */
	if (wd->sc_dk.dk_label.d_type == DTYPE_ST506)
		outb(iobase+wd_precomp, wd->sc_dk.dk_label.d_precompcyl / 4);
	else
		outb(iobase+wd_features, 0);
	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. */
	outb(iobase+wd_command, command);

	return 0;
}

int
wdcommandshort(wdc, drive, command)
	struct wdc_softc *wdc;
	int drive;
	int command;
{
	int iobase = wdc->sc_iobase;

	/* Select drive. */
	outb(iobase+wd_sdh, WDSD_IBM | (drive << 4));

	if (wdcwait(wdc, WDCS_DRDY) < 0)
		return -1;

	outb(iobase+wd_command, command);

	return 0;
}

/*
 * Issue IDP 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_dev.dv_unit, wd->sc_drive,
	    wd->sc_dk.dk_label.d_ncylinders, wd->sc_dk.dk_label.d_ntracks,
	    wd->sc_dk.dk_label.d_nsectors);
#endif

	if (wdcommand(wd, WDCC_IDP, wd->sc_dk.dk_label.d_ncylinders,
	    wd->sc_dk.dk_label.d_ntracks - 1, 0, wd->sc_dk.dk_label.d_nsectors)
	    != 0) {
		wderror(wd, NULL, "wdsetctlr: geometry upload failed");
		return -1;
	}

	return 0;
}

/*
 * Issue IDENTIFY to drive to ask it what it is.
 */
int
wd_get_parms(wd)
	struct wd_softc *wd;
{
	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
	int i;
	char tb[DEV_BSIZE];
	int s, error;

	/*
	 * XXX
	 * The locking done here, not to mention the length of time it may
	 * keep the rest of the system suspended, is a kluge.  This should be
	 * rewritten to set up a transfer and queue it through wdstart().
	 */

	s = splbio();

	while ((wdc->sc_flags & WDCF_ACTIVE) != 0) {
		wdc->sc_flags |= WDCF_WANTED;
		if ((error = tsleep(wdc, PRIBIO | PCATCH, "wdprm", 0)) != 0) {
			splx(s);
			return error;
		}
	}

	if (wdcommandshort(wdc, wd->sc_drive, WDCC_IDENTIFY) != 0 ||
	    wait_for_drq(wdc) != 0) {
		/*
		 * We `know' there's a drive here; just assume it's old.
		 */
		strncpy(wd->sc_dk.dk_label.d_typename, "ST506",
		    sizeof wd->sc_dk.dk_label.d_typename);
		wd->sc_dk.dk_label.d_type = DTYPE_ST506;

		strncpy(wd->sc_params.wdp_model, "unknown",
		    sizeof wd->sc_params.wdp_model);
		wd->sc_params.wdp_config = WD_CFG_FIXED;
		wd->sc_params.wdp_cylinders = 1024;
		wd->sc_params.wdp_heads = 8;
		wd->sc_params.wdp_sectors = 17;
		wd->sc_params.wdp_maxmulti = 0;
		wd->sc_params.wdp_usedmovsd = 0;
		wd->sc_params.wdp_capabilities = 0;
	} else {
		strncpy(wd->sc_dk.dk_label.d_typename, "ESDI/IDE",
		    sizeof wd->sc_dk.dk_label.d_typename);
		wd->sc_dk.dk_label.d_type = DTYPE_ESDI;

		/* Obtain parameters. */
		insw(wdc->sc_iobase+wd_data, tb, sizeof(tb) / sizeof(short));
		bcopy(tb, &wd->sc_params, sizeof(struct wdparams));

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

#if 0
	printf("gc %x cyl %d trk %d sec %d type %d sz %d model %s\n",
	    wp->wdp_config, wp->wdp_cylinders, wp->wdp_heads, wp->wdp_sectors,
	    wp->wdp_buftype, wp->wdp_bufsize, wp->wdp_model);
#endif

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

	wdcstart(wdc);

	splx(s);
	return 0;
}

int
wdclose(dev, flag, fmt)
	dev_t dev;
	int flag, fmt;
{
	struct wd_softc *wd = wdcd.cd_devs[WDUNIT(dev)];
	int part = WDPART(dev);
	int s;

	switch (fmt) {
	case S_IFCHR:
		wd->sc_dk.dk_copenmask &= ~(1 << part);
		break;
	case S_IFBLK:
		wd->sc_dk.dk_bopenmask &= ~(1 << part);
		break;
	}
	wd->sc_dk.dk_openmask = wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;

	if (wd->sc_dk.dk_openmask == 0) {
		/*
		 * If we're closing the last partition, nobody else could be
		 * holding the lock, so don't bother to check.
		 */
		wd->sc_flags |= WDF_LOCKED;

#if 0
		s = splbio();
		while (...) {
			wd->sc_flags |= WDF_WAITING;
			if ((error = tsleep(wd, PRIBIO | PCATCH, "wdcls", 0)) != 0)
				return error;
		}
		splx(s);
#endif

		wdunlock(wd);
	}

	return 0;
}

int
wdioctl(dev, cmd, addr, flag, p)
	dev_t dev;
	u_long cmd;
	caddr_t addr;
	int flag;
	struct proc *p;
{
	struct wd_softc *wd = wdcd.cd_devs[WDUNIT(dev)];
	int error;

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

	switch (cmd) {
	case DIOCSBAD:
		if ((flag & FWRITE) == 0)
			return EBADF;
		wd->sc_dk.dk_cpulabel.bad = *(struct dkbad *)addr;
		wd->sc_dk.dk_label.d_flags |= D_BADSECT;
		bad144intern(wd);
		return 0;

	case DIOCGDINFO:
		*(struct disklabel *)addr = wd->sc_dk.dk_label;
		return 0;

	case DIOCGPART:
		((struct partinfo *)addr)->disklab = &wd->sc_dk.dk_label;
		((struct partinfo *)addr)->part =
		    &wd->sc_dk.dk_label.d_partitions[WDPART(dev)];
		return 0;

	case DIOCWDINFO:
	case DIOCSDINFO:
		if ((flag & FWRITE) == 0)
			return EBADF;

		if (error = wdlockwait(wd))
			return error;
		wd->sc_flags |= WDF_LOCKED | WDF_LABELLING;

		error = setdisklabel(&wd->sc_dk.dk_label,
		    (struct disklabel *)addr, /*wd->sc_dk.dk_openmask : */0,
		    &wd->sc_dk.dk_cpulabel);
		if (error == 0) {
			if (wd->sc_state > GEOMETRY)
				wd->sc_state = GEOMETRY;
			if (cmd == DIOCWDINFO)
				error = writedisklabel(WDLABELDEV(dev),
				    wdstrategy, &wd->sc_dk.dk_label,
				    &wd->sc_dk.dk_cpulabel);
		}

		wd->sc_flags &= ~WDF_LABELLING;
		wdunlock(wd);
		return error;

	case DIOCWLABEL:
		if ((flag & FWRITE) == 0)
			return EBADF;
		if (*(int *)addr)
			wd->sc_flags |= WDF_WLABEL;
		else
			wd->sc_flags &= ~WDF_WLABEL;
		return 0;

#ifdef notyet
	case DIOCGDINFOP:
		*(struct disklabel **)addr = &wd->sc_dk.dk_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_dk.dk_label.d_secsize;
		auio.uio_procp = p;
		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;
{
	struct wd_softc *wd;
	int part;
	int size;

	if (wdopen(dev, 0, S_IFBLK) != 0)
		return -1;
	wd = wdcd.cd_devs[WDUNIT(dev)];
	part = WDPART(dev);
	if (wd->sc_dk.dk_label.d_partitions[part].p_fstype != FS_SWAP)
		size = -1;
	else
		size = wd->sc_dk.dk_label.d_partitions[part].p_size;
	if (wdclose(dev, 0, S_IFBLK) != 0)
		return -1;
	return 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;
	struct disklabel *lp;
	int unit, part;
	long rblkno, nblks;
	char *addr;
	static wddoingadump = 0;
	extern caddr_t CADDR1;
	extern pt_entry_t *CMAP1;

	if (wddoingadump)
		return EFAULT;
	wddoingadump = 1;

	unit = WDUNIT(dev);
	/* Check for acceptable drive number. */
	if (unit >= wdcd.cd_ndevs)
		return ENXIO;
	wd = wdcd.cd_devs[unit];
	/* Was it ever initialized? */
	if (wd == 0 || wd->sc_state < OPEN)
		return ENXIO;

	wdc = (void *)wd->sc_dev.dv_parent;
	addr = (char *)0;	/* starting address */
	lp = &wd->sc_dk.dk_label;
	part = WDPART(dev);

	/* Convert to disk sectors. */
	rblkno = lp->d_partitions[part].p_offset + dumplo;
	nblks = min(ctob(physmem) / lp->d_secsize,
		    lp->d_partitions[part].p_size - dumplo);

	/* Check transfer bounds against partition size. */
	if (dumplo < 0 || nblks <= 0)
		return EINVAL;

	/* Recalibrate. */
	if (wdcommandshort(wdc, wd->sc_drive, WDCC_RECAL) != 0 ||
	    wait_for_ready(wdc) != 0 || wdsetctlr(wd) != 0 ||
	    wait_for_ready(wdc) != 0) {
		wderror(wd, NULL, "wddump: recal failed");
		return EIO;
	}

	while (nblks > 0) {
		long blkno;
		long cylin, head, sector;

		blkno = rblkno;

		if ((lp->d_flags & D_BADSECT) != 0) {
			long blkdiff;
			int i;

			for (i = 0; (blkdiff = wd->sc_badsect[i]) != -1; i++) {
				blkdiff -= blkno;
				if (blkdiff < 0)
					continue;
				if (blkdiff == 0) {
					/* Replace current block of transfer. */
					blkno =
					    lp->d_secperunit - lp->d_nsectors - i - 1;
				}
				break;
			}
			/* Tranfer is okay now. */
		}

		if ((wd->sc_params.wdp_capabilities & WD_CAP_LBA) != 0) {
			sector = (blkno >> 0) & 0xff;
			cylin = (blkno >> 8) & 0xffff;
			head = (blkno >> 24) & 0xf;
			head |= WDSD_LBA;
		} else {
			sector = blkno % lp->d_nsectors;
			sector++;	/* Sectors begin with 1, not 0. */
			blkno /= lp->d_nsectors;
			head = blkno % lp->d_ntracks;
			blkno /= lp->d_ntracks;
			cylin = blkno;
			head |= WDSD_CHS;
		}

#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, WDCC_WRITE, cylin, head, sector, 1) != 0 ||
		    wait_for_drq(wdc) != 0) {
			wderror(wd, NULL, "wddump: write failed");
			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
		*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 ", nblks / (1048576 / DEV_BSIZE));

		/* Update block count. */
		nblks--;
		rblkno++;
		(int)addr += DEV_BSIZE;
	}

	return 0;
}

/*
 * Internalize the bad sector table.
 */
void
bad144intern(wd)
	struct wd_softc *wd;
{
	struct dkbad *bt = &wd->sc_dk.dk_cpulabel.bad;
	struct disklabel *lp = &wd->sc_dk.dk_label;
	int i = 0;

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

static int
wdcreset(wdc)
	struct wdc_softc *wdc;
{
	int 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(arg)
	void *arg;
{
	struct wdc_softc *wdc = (struct wdc_softc *)arg;
	int s;

	s = splbio();
	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 unit;

	untimeout(wdctimeout, wdc);
	(void) wdcreset(wdc);

	/* Schedule recalibrate for all drives on this controller. */
	for (unit = 0; unit < wdcd.cd_ndevs; unit++) {
		struct wd_softc *wd = wdcd.cd_devs[unit];
		if (!wd || (void *)wd->sc_dev.dv_parent != wdc)
			continue;
		if (wd->sc_state > RECAL)
			wd->sc_state = RECAL;
	}

	wdc->sc_flags |= WDCF_ERROR;
	++wdc->sc_errors;

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

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

	for (;;) {
		wdc->sc_status = status = inb(iobase+wd_status);
		if ((status & WDCS_BSY) == 0 && (status & mask) == mask)
			break;
		if (++timeout > WDCNDELAY)
			return -1;
		delay(WDCDELAY);
	}
	if (status & WDCS_ERR) {
		wdc->sc_error = inb(iobase+wd_error);
		return WDCS_ERR;
	}
#ifdef WDCNDELAY_DEBUG
	/* After autoconfig, there should be no long delays. */
	if (!cold && timeout > WDCNDELAY_DEBUG)
		printf("%s: warning: busy-wait took %dus\n",
		    wdc->sc_dev.dv_xname, WDCDELAY * timeout);
#endif
	return 0;
}

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

	s = splbio();
	if ((wdc->sc_flags & WDCF_ACTIVE) != 0) {
		wdc->sc_flags &= ~WDCF_ACTIVE;
		wderror(wdc, NULL, "lost interrupt");
		wdcunwedge(wdc);
	} else
		wderror(wdc, NULL, "missing untimeout");
	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 / DEV_BSIZE,
		    &wd->sc_dk.dk_label);
		printf("\n");
	} 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);
}