NetBSD/sys/dev/ata/wd.c

/*	$NetBSD: wd.c,v 1.102 1994/11/03 22:56:06 mycroft Exp $	*/

/*
 * 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.
 *
 *	@(#)wd.c	7.2 (Berkeley) 5/9/91
 */

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

#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/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 <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	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 states.  Used to initialize drive.
 */
#define	CLOSED		0		/* disk is closed */
#define	RECAL		1		/* recalibrate */
#define	RECAL_WAIT	2		/* done recalibrating */
#define	GEOMETRY	3		/* upload geometry */
#define	GEOMETRY_WAIT	4		/* done uploading geometry */
#define	OPEN		5		/* done with open */

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

	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_drive;	/* physical unit number */
	char	sc_state;	/* control state */
	
	u_char	sc_flags;	/* drive characteistics found */
#define	WDF_BSDLABEL	0x01	/* has a BSD disk label */
#define	WDF_BADSECT	0x02	/* has a bad144 badsector table */
#define	WDF_WRITEPROT	0x04	/* manual unit write protect */
#define	WDF_WLABEL	0x08	/* label is writable */
	TAILQ_ENTRY(wd_softc) sc_drivechain;
	struct buf sc_q;
	struct wdparams sc_params; /* ESDI/IDE drive/controller parameters */
	long	sc_badsect[127];	/* 126 plus trailing -1 marker */
};

struct wdc_softc {
	struct device sc_dev;
	struct intrhand sc_ih;

	u_char	sc_flags;
#define	WDCF_ACTIVE	0x00001	/* controller is active */
#define	WDCF_SINGLE	0x00004	/* sector at a time mode */
#define	WDCF_ERROR	0x00008	/* processing a disk error */
	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_errors;	/* count of errors during current transfer */
	TAILQ_HEAD(drivehead, wd_softc) sc_drives;
};

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 wd_softc), 1
};

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

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

void wdfinish __P((struct wd_softc *, struct buf *));
static void wdstart __P((struct wd_softc *));
int wdcintr __P((void *));
static void wdcstart __P((struct wdc_softc *));
static int wdcommand __P((struct wd_softc *, int, int, int, int, int));
static int wdcontrol __P((struct wd_softc *));
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((void *arg));
static void wdcunwedge __P((struct wdc_softc *));
static void wdctimeout __P((void *arg));
void wddisksort __P((struct buf *, struct buf *));
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_READY | WDCS_SEEKCMPLT | 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(parent, match, aux)
	struct device *parent;
	void *match, *aux;
{
	struct wdc_softc *wdc = match;
	struct isa_attach_args *ia = aux;
	struct wd_softc *wd;
	u_short 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;
	}

	/*
	 * 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_drive = 0;
	wd->sc_dev.dv_unit = 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;

	free(wd, M_TEMP);
	ia->ia_iosize = 8;
	ia->ia_msize = 0;
	return 1;

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

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);

	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, &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 wd_softc *wd = match;
	struct cfdata *cf = wd->sc_dev.dv_cfdata;
	struct wdc_attach_args *wa = aux;
	int drive = wa->wa_drive;

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

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

	return 1;
}

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

	if (wd->sc_params.wdp_heads == 0)
		printf(": (unknown size) <");
	else
		printf(": %dMB %d cyl, %d head, %d sec, %d bytes/sec <",
		    wd->sc_dk.dk_label.d_ncylinders *
		    wd->sc_dk.dk_label.d_secpercyl /
		    (1048576 / wd->sc_dk.dk_label.d_secsize),
		    wd->sc_dk.dk_label.d_ncylinders,
		    wd->sc_dk.dk_label.d_ntracks,
		    wd->sc_dk.dk_label.d_nsectors,
		    wd->sc_dk.dk_label.d_secsize);
	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");
	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 lunit = WDUNIT(bp->b_dev);
	int s;
    
	/* Valid unit, controller, and request?  */
	if (lunit >= wdcd.cd_ndevs ||
	    (wd = wdcd.cd_devs[lunit]) == 0 ||
	    bp->b_blkno < 0 ||
	    (bp->b_bcount % DEV_BSIZE) != 0 ||
	    (bp->b_bcount / DEV_BSIZE) >= (1 << NBBY)) {
		bp->b_error = EINVAL;
		goto bad;
	}
    
	/* "Soft" write protect check. */
	if ((wd->sc_flags & WDF_WRITEPROT) && (bp->b_flags & B_READ) == 0) {
		bp->b_error = EROFS;
		goto bad;
	}
    
	/* If it's a null transfer, return immediately. */
	if (bp->b_bcount == 0)
		goto done;

	/* Have partitions and want to use them? */
	if (WDPART(bp->b_dev) != RAW_PART) {
		if ((wd->sc_flags & WDF_BSDLABEL) == 0) {
			bp->b_error = EIO;
			goto bad;
		}
		/*
		 * 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) != 0) <= 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. */
	s = splbio();
	wddisksort(&wd->sc_q, bp);
	if (!wd->sc_q.b_active)
		wdstart(wd);		/* Start drive. */
#ifdef DIAGNOSTIC
	else {
		struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
		if ((wdc->sc_flags & WDCF_ACTIVE) == 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);
}

/*
 * 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 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;
	/*
	 * 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) {
		wd->sc_mskip = 0;
		/*
		 * ...then 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;
	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;

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;
	}

	/* Mark the controller active and set a timeout. */
	if (wdc->sc_flags & WDCF_ACTIVE)
		untimeout(wdctimeout, wdc);
	else
		wdc->sc_flags |= WDCF_ACTIVE;
	timeout(wdctimeout, wdc, WAITTIME);
    
	/* 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.
		 */
		(void) wdcontrol(wd);
		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 = wd->sc_mskip = 0;
		}
	}

	if (wd->sc_skip == 0) {
#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;
#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 (wd->sc_mskip == 0) {
		wd->sc_mbcount = wd->sc_bcount;
		/* If multi-sector, try to cluster. */
		if ((wdc->sc_flags & WDCF_SINGLE) == 0) {
			struct buf *oldbp, *nextbp;
			oldbp = bp;
			nextbp = bp->b_actf;
			oldbp->b_flags |= B_XXX;
			while (nextbp && oldbp->b_dev == nextbp->b_dev &&
			    nextbp->b_blkno ==
			    (oldbp->b_blkno + (oldbp->b_bcount / wd->sc_dk.dk_label.d_secsize)) &&
			    (oldbp->b_flags & B_READ) == (nextbp->b_flags & B_READ)) {
				if ((wd->sc_mbcount + nextbp->b_bcount) / wd->sc_dk.dk_label.d_secsize >= 240)
					break;
				wd->sc_mbcount += nextbp->b_bcount; 
				nextbp->b_flags |= B_XXX;
				oldbp = nextbp;
				nextbp = nextbp->b_actf;
			}
		}
	}
    
	/* If starting a multisector transfer, or doing single transfers. */
	if (wd->sc_mskip == 0 || (wdc->sc_flags & WDCF_SINGLE)) {
		struct disklabel *lp;
		long blkno, nblks;
		long cylin, head, sector;
		int command;

		lp = &wd->sc_dk.dk_label;
		blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE) + wd->sc_skip;
		if (WDPART(bp->b_dev) != RAW_PART)
			blkno += lp->d_partitions[WDPART(bp->b_dev)].p_offset;
		if (wdc->sc_flags & WDCF_SINGLE)
			nblks = 1;
		else
			nblks = howmany(wd->sc_mbcount, lp->d_secsize);

		/*
		 * 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
		    ) {
			long blkdiff;
			int i;

			for (i = 0; (blkdiff = wd->sc_badsect[i]) != -1; i++) {
				blkdiff -= blkno;
				if (blkdiff < 0)
					continue;
				if (blkdiff >= nblks)
					break;
				if (blkdiff == 0) {
					/* Replace current block of transfer. */
					blkno =
					    lp->d_secperunit - lp->d_nsectors - i - 1;
					if (wdc->sc_flags & WDCF_SINGLE)
						break;
				} else {
					/* If clustered, try unclustering. */
					if (wd->sc_mbcount > wd->sc_bcount) {
						nblks = howmany(wd->sc_bcount, lp->d_secsize);
						if (blkdiff >= nblks) {
							/* Unclustering was enough. */
							wd->sc_mbcount = wd->sc_bcount;
							break;
						}
					}
					/* Bad block inside transfer. */
				}
				/* Force single-sector mode. */
				wd->sc_mbcount = wd->sc_bcount;
				wdc->sc_flags |= WDCF_SINGLE;
				nblks = 1;
			}
			/* Tranfer is okay now. */
		}

		cylin = blkno / lp->d_secpercyl;
		head = (blkno % lp->d_secpercyl) / lp->d_nsectors;
		sector = blkno % lp->d_nsectors;
		sector++;	/* Sectors begin with 1, not 0. */

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

#ifdef B_FORMAT
		if (bp->b_flags & B_FORMAT) {
			sector = lp->d_gap3;
			nblks = lp->d_nsectors;
			command = WDCC_FORMAT;
		} else
#endif
			command =
			    (bp->b_flags & B_READ) ? WDCC_READ : WDCC_WRITE;
	
		/* Initiate command! */
		if (wdcommand(wd, cylin, head, sector, nblks, 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_data, inb(wd->sc_iobase+wd_altsts));
#endif
	}

	/* 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_data + 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
wdcintr(arg)
	void *arg;
{
	struct wdc_softc *wdc = arg;
	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;
	}

	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))
			wdcstart(wdc);
		return 1;
	}

	wdc->sc_flags &= ~WDCF_ACTIVE;
	untimeout(wdctimeout, wdc);
    
	/* 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_ECCCOR)
		wderror(wd, bp, "soft ecc");
    
	/* If this was a read, fetch the data. */
	if (bp->b_flags & B_READ) {
		/* Ready to receive data? */
		if ((wdc->sc_status & (WDCS_READY | WDCS_SEEKCMPLT | WDCS_DRQ))
		    != (WDCS_READY | WDCS_SEEKCMPLT | WDCS_DRQ)) {
			wderror(wd, NULL, "wdcintr: read intr before drq");
			wdcunwedge(wdc);
			return 1;
		}

		/* Suck in data. */
		insw(wdc->sc_iobase+wd_data,
		    bp->b_data + wd->sc_skip * DEV_BSIZE, 
		    DEV_BSIZE / sizeof(short));
	}
    
	/* 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_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. */
	wdcstart(wdc);

	return 1;
}

/*
 * Initialize a drive.
 */
int
wdopen(dev, flag, fmt, p)
	dev_t dev;
	int flag, fmt;
	struct proc *p;
{
	int lunit;
	struct wd_softc *wd;
	int part = WDPART(dev);
	struct partition *pp;
	char *msg;
	int error;
    
	lunit = WDUNIT(dev);
	if (lunit >= wdcd.cd_ndevs)
		return ENXIO;
	wd = wdcd.cd_devs[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_dk.dk_label, sizeof(wd->sc_dk.dk_label));
		wd->sc_dk.dk_label.d_type = DTYPE_ST506;
		wd->sc_dk.dk_label.d_ncylinders = 1024;
		wd->sc_dk.dk_label.d_secsize = DEV_BSIZE;
		wd->sc_dk.dk_label.d_ntracks = 8;
		wd->sc_dk.dk_label.d_nsectors = 17;
		wd->sc_dk.dk_label.d_secpercyl = 17*8;
		wd->sc_dk.dk_label.d_secperunit = 17*8*1024;
		wd->sc_state = RECAL;

		/* Read label using "raw" partition. */
		msg = readdisklabel(WDLABELDEV(dev), wdstrategy,
		    &wd->sc_dk.dk_label, &wd->sc_dk.dk_cpulabel);
		if (msg) {
			/*
			 * 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;
			msg = readdisklabel(WDLABELDEV(dev), wdstrategy,
			    &wd->sc_dk.dk_label, &wd->sc_dk.dk_cpulabel);
		}
		if (msg) {
			log(LOG_WARNING, "%s: cannot find label (%s)\n",
			    wd->sc_dev.dv_xname, msg);
			if (part != RAW_PART)
				return EINVAL;	/* XXX needs translation */
		} else {
			if (wd->sc_state > GEOMETRY)
				wd->sc_state = GEOMETRY;
			wd->sc_flags |= WDF_BSDLABEL;
			wd->sc_flags &= ~WDF_WRITEPROT;
			if (wd->sc_dk.dk_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_dk.dk_openmask & (1 << part)) == 0 && part != RAW_PART) {
		int start, end;
	
		pp = &wd->sc_dk.dk_label.d_partitions[part];
		start = pp->p_offset;
		end = pp->p_offset + pp->p_size;
		for (pp = wd->sc_dk.dk_label.d_partitions;
		    pp < &wd->sc_dk.dk_label.d_partitions[wd->sc_dk.dk_label.d_npartitions];
		    pp++) {
			if (pp->p_offset + pp->p_size <= start ||
			    pp->p_offset >= end)
				continue;
			if (pp - wd->sc_dk.dk_label.d_partitions == RAW_PART)
				continue;
			if (wd->sc_dk.dk_openmask & (1 << (pp - wd->sc_dk.dk_label.d_partitions)))
				log(LOG_WARNING,
				    "%s%c: overlaps open partition (%c)\n",
				    wd->sc_dev.dv_xname, part + 'a',
				    pp - wd->sc_dk.dk_label.d_partitions + 'a');
		}
	}
	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;

bad:
	return error;
}

/*
 * 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 restore. */
		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_WAIT;
		return 0;

	case RECAL_WAIT:
		if (wdc->sc_status & WDCS_ERR) {
			wderror(wd, NULL, "wdcontrol: recal failed");
			wdcunwedge(wdc);
			return 0;
		}
		/* fall through */
	case GEOMETRY:
		if (wdsetctlr(wd) != 0) {
			/* Already printed a message. */
			wdcunwedge(wdc);
			return 0;
		}
		wd->sc_state = GEOMETRY_WAIT;
		return 0;

	case GEOMETRY_WAIT:
		if (wdc->sc_status & WDCS_ERR) {
			wderror(wd, NULL, "wdcontrol: geometry failed");
			wdcunwedge(wdc);
			return 0;
		}

		wdc->sc_errors = 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;
    
	/* Select drive. */
	iobase = wdc->sc_iobase;
	outb(iobase+wd_sdh, WDSD_IBM | (wd->sc_drive << 4) | head);

	/* Wait for it to become ready to accept a command. */
	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_dk.dk_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_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, wd->sc_dk.dk_label.d_ncylinders,
	    wd->sc_dk.dk_label.d_ntracks - 1, 0, wd->sc_dk.dk_label.d_nsectors,
	    WDCC_IDC) != 0) {
		wderror(wd, NULL, "wdsetctlr: wdcommand 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_dk.dk_label.d_typename, "ST506",
		    sizeof wd->sc_dk.dk_label.d_typename);
		strncpy(wd->sc_params.wdp_model, "Unknown Type",
		    sizeof wd->sc_params.wdp_model);
		wd->sc_dk.dk_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_dk.dk_label.d_typename, "ESDI/IDE",
		    sizeof wd->sc_dk.dk_label.d_typename);
		wd->sc_dk.dk_label.d_type = DTYPE_ESDI;
		bcopy(wp->wdp_model+20, wd->sc_dk.dk_label.d_packname, 14-1);

		/* Update disklabel given drive information. */
		wd->sc_dk.dk_label.d_ncylinders =
		    wp->wdp_fixedcyl + wp->wdp_removcyl /*+- 1*/;
		wd->sc_dk.dk_label.d_secsize = DEV_BSIZE;
		wd->sc_dk.dk_label.d_ntracks = wp->wdp_heads;
		wd->sc_dk.dk_label.d_nsectors = wp->wdp_sectors;
		wd->sc_dk.dk_label.d_secpercyl =
		    wd->sc_dk.dk_label.d_ntracks * wd->sc_dk.dk_label.d_nsectors;
		wd->sc_dk.dk_label.d_partitions[1].p_size =
		    wd->sc_dk.dk_label.d_secpercyl * wp->wdp_sectors;
		wd->sc_dk.dk_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_dk.dk_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, fmt;
{
	struct wd_softc *wd = wdcd.cd_devs[WDUNIT(dev)];
	int part = WDPART(dev);
    
	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;
}

int
wdioctl(dev, cmd, addr, flag, p)
	dev_t dev;
	u_long cmd;
	caddr_t addr;
	int flag;
	struct proc *p;
{
	int lunit = WDUNIT(dev);
	struct wd_softc *wd = wdcd.cd_devs[lunit];
	int error;
    
	switch (cmd) {
	case DIOCSBAD:
		if ((flag & FWRITE) == 0)
			return EBADF;
		wd->sc_dk.dk_cpulabel.bad = *(struct dkbad *)addr;
		wd->sc_flags |= WDF_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 DIOCSDINFO:
		if ((flag & FWRITE) == 0)
			return EBADF;
		error = setdisklabel(&wd->sc_dk.dk_label,
		    (struct disklabel *)addr,
		    /*(wd->sc_flags & WDF_BSDLABEL) ? wd->sc_dk.dk_openmask : */0,
		    &wd->sc_dk.dk_cpulabel);
		if (error == 0) {
			wd->sc_flags |= WDF_BSDLABEL;
			if (wd->sc_state > GEOMETRY)
				wd->sc_state = GEOMETRY;
		}
		return error;
	
	case DIOCWLABEL:
		wd->sc_flags &= ~WDF_WRITEPROT;
		if ((flag & FWRITE) == 0)
			return EBADF;
		if (*(int *)addr)
			wd->sc_flags |= WDF_WLABEL;
		else
			wd->sc_flags &= ~WDF_WLABEL;
		return 0;
	
	case DIOCWDINFO:
		wd->sc_flags &= ~WDF_WRITEPROT;
		if ((flag & FWRITE) == 0)
			return EBADF;
		error = setdisklabel(&wd->sc_dk.dk_label,
		    (struct disklabel *)addr,
		    /*(wd->sc_flags & WDF_BSDLABEL) ? wd->sc_dk.dk_openmask : */0,
		    &wd->sc_dk.dk_cpulabel);
		if (error == 0) {
			wd->sc_flags |= WDF_BSDLABEL;
			if (wd->sc_state > GEOMETRY)
				wd->sc_state = GEOMETRY;
	    
			/* Simulate opening partition 0 so write succeeds. */
			wd->sc_dk.dk_openmask |= (1 << 0);	/* XXX */
			error = writedisklabel(WDLABELDEV(dev), wdstrategy,
			    &wd->sc_dk.dk_label, &wd->sc_dk.dk_cpulabel);
			wd->sc_dk.dk_openmask =
			    wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
		}
		return error;
	
#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;
{
	int lunit = WDUNIT(dev), part = WDPART(dev);
	struct wd_softc *wd;
    
	if (lunit >= wdcd.cd_ndevs)
		return -1;
	wd = wdcd.cd_devs[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, RAW_PART), 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_dk.dk_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, blkno;
	long cylin, head, sector;
	long secpertrk, secpercyl, nblocks;
	char *addr;
	static wddoingadump = 0;
	extern caddr_t CADDR1;
	extern pt_entry_t *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 >= wdcd.cd_ndevs)
		return ENXIO;
	wd = wdcd.cd_devs[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_dk.dk_label.d_secsize;
    
	secpertrk = wd->sc_dk.dk_label.d_nsectors;
	secpercyl = wd->sc_dk.dk_label.d_secpercyl;
	part = WDPART(dev);
	nblocks = wd->sc_dk.dk_label.d_partitions[part].p_size;
	blkoff = wd->sc_dk.dk_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 ||
	    wait_for_ready(wdc) != 0) {
		wderror(wd, NULL, "wddump: recal failed");
		return EIO;
	}
    
	blkno = dumplo + blkoff;
	while (num > 0) {
		/* Compute disk address. */
		cylin = blkno / secpercyl;
		head = (blkno % secpercyl) / secpertrk;
		sector = blkno % secpertrk;
	
		if (wd->sc_flags & WDF_BADSECT) {
			long newblk;
			int i;

			for (i = 0; wd->sc_badsect[i] != -1; i++) {
				if (blkno < wd->sc_badsect[i]) {
					/* Sorted list, passed our block by. */
					break;
				} else if (blkno == wd->sc_badsect[i]) {
					newblk =
					    wd->sc_dk.dk_label.d_secperunit -
					    wd->sc_dk.dk_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
		*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--;
		blkno++;
		(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;
{
	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;
{
	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(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 lunit;

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

	/* Schedule recalibrate for all drives on this controller. */
	for (lunit = 0; lunit < wdcd.cd_ndevs; lunit++) {
		struct wd_softc *wd = wdcd.cd_devs[lunit];
		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;
{
	u_short 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_BUSY) == 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();
	wderror(wdc, NULL, "lost interrupt");
	wdcunwedge(wdc);
	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_dk.dk_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);
}