Support ATAPI devices without wd devices, based on manuel's code.

2 files changed, 652 insertions, 616 deletions

diff --git a/sys/dev/isa/wdc.c b/sys/dev/isa/wdc.c
index 7349321522d..48094436200 100644
--- a/sys/dev/isa/wdc.c
+++ b/sys/dev/isa/wdc.c
@@ -1,4 +1,4 @@
-/*	$OpenBSD: wdc.c,v 1.18 1997/02/24 05:50:46 niklas Exp $	*/
+/*	$OpenBSD: wdc.c,v 1.19 1997/07/04 17:02:04 downsj Exp $	*/
 /*	$NetBSD: wd.c,v 1.150 1996/05/12 23:54:03 mycroft Exp $ */
 
 /*
@@ -66,7 +66,10 @@
 #include <dev/isa/wdreg.h>
 #include <dev/isa/wdlink.h>
 
+#include "atapibus.h"
+#if NATAPIBUS > 0
 #include <dev/atapi/atapilink.h>
+#endif	/* NATAPIBUS */
 
 #define	WAITTIME	(10 * hz)	/* time to wait for a completion */
 	/* this is a lot for hard drives, but not for cdroms */
@@ -97,23 +100,28 @@ struct cfdriver wdc_cd = {
 	NULL, "wdc", DV_DULL
 };
 
+#if NWD > 0
 int	wdc_ata_intr	__P((struct wdc_softc *,struct wdc_xfer *));
-void	wdcstart	__P((struct wdc_softc *));
 void	wdc_ata_start	__P((struct wdc_softc *,struct wdc_xfer *));
+void	wdc_ata_done	__P((struct wdc_softc *, struct wdc_xfer *));
+__inline static void u_int16_to_string __P((u_int16_t *, char *, size_t));
+#endif	/* NWD */
 int	wait_for_phase	__P((struct wdc_softc *, int));
 int	wait_for_unphase __P((struct wdc_softc *, int));
-void	wdc_atapi_start	__P((struct wdc_softc *,struct wdc_xfer *));
+void	wdcstart	__P((struct wdc_softc *));
 int	wdcreset	__P((struct wdc_softc *));
 void	wdcrestart	__P((void *arg));
 void	wdcunwedge	__P((struct wdc_softc *));
 void	wdctimeout	__P((void *arg));
 int	wdccontrol	__P((struct wd_link *));
-void	wdc_ata_done	__P((struct wdc_softc *, struct wdc_xfer *));
 void	wdc_free_xfer	__P((struct wdc_xfer *));
 void	wdcerror	__P((struct wdc_softc*, char *));
 void	wdcbit_bucket	__P(( struct wdc_softc *, int));
+#if NATAPIBUS > 0
+void	wdc_atapi_start	__P((struct wdc_softc *,struct wdc_xfer *));
 int	wdc_atapi_intr	__P((struct wdc_softc *, struct wdc_xfer *));
 void	wdc_atapi_done	__P((struct wdc_softc *, struct wdc_xfer *));
+#endif	/* NATAPIBUS */
 
 #ifdef ATAPI_DEBUG
 static int wdc_nxfer;
@@ -222,7 +230,9 @@ wdcattach(parent, self, aux)
 {
 	struct wdc_softc *wdc = (void *)self;
 	struct isa_attach_args *ia = aux;
+#if NWD > 0
 	int drive;
+#endif	/* NWD */
 
 	TAILQ_INIT(&wdc->sc_xfer);
 	wdc->sc_drq = ia->ia_drq;
@@ -237,6 +247,7 @@ wdcattach(parent, self, aux)
 	wdc_nxfer = 0;
 #endif
 
+#if NATAPIBUS > 0
 	/*
 	 * Attach an ATAPI bus, if configured.
 	 */
@@ -251,7 +262,8 @@ wdcattach(parent, self, aux)
 	wdc->ab_link->ctlr_link = &(wdc->ctlr_link);
 	wdc->ab_link->ctrl = self->dv_unit;
 	(void)config_found(self, (void *)wdc->ab_link, NULL);
-
+#endif	/* NATAPIBUS */
+#if NWD > 0
 	/*
 	 * Attach standard IDE/ESDI/etc. disks to the controller.
 	 */
@@ -281,13 +293,14 @@ wdcattach(parent, self, aux)
 			if (wdc->sc_drq != DRQUNK) 
 				wdc->d_link[drive]->sc_mode = WDM_DMA;
 			else
-#endif
+#endif	/* NISADMA */
 				wdc->d_link[drive]->sc_mode = 0;
 
 			(void)config_found(self, (void *)wdc->d_link[drive],
 			    wdcprint);
 		}
 	}
+#endif	/* NWD */
 }
 
 /*
@@ -331,17 +344,28 @@ wdcstart(wdc)
 		return;
 	}
 	wdc->sc_flags |= WDCF_ACTIVE;
+#if NATAPIBUS > 0 && NWD > 0
 	if (xfer->c_flags & C_ATAPI) {
 #ifdef ATAPI_DEBUG_WDC
 		printf("wdcstart: atapi\n");
 #endif
-		wdc_atapi_start(wdc,xfer);
-	} else {
-		wdc_ata_start(wdc,xfer);
-	}
+		wdc_atapi_start(wdc, xfer);
+	} else
+		wdc_ata_start(wdc, xfer);
+#else
+#if NATAPIBUS > 0
+#ifdef ATAPI_DEBUG_WDC
+	printf("wdcstart: atapi\n");
+#endif
+	wdc_atapi_start(wdc, xfer);
+#endif	/* NATAPIBUS */
+#if NWD > 0
+	wdc_ata_start(wdc, xfer);
+#endif	/* NWD */
+#endif	/* NATAPIBUS && NWD */
 }
 
-
+#if NWD > 0
 void
 wdc_ata_start(wdc, xfer)
 	struct wdc_softc *wdc;
@@ -568,172 +592,7 @@ wdc_ata_start(wdc, xfer)
 }
 
 int
-wait_for_phase(wdc, wphase)
-	struct wdc_softc *wdc;
-	int wphase;
-{
-	bus_space_tag_t iot = wdc->sc_iot;
-	bus_space_handle_t ioh = wdc->sc_ioh;
-	int i, phase;
-
-	for (i = 20000; i; i--) {
-		phase = (bus_space_read_1(iot, ioh, wd_ireason) &
-		    (WDCI_CMD | WDCI_IN)) |
-		    (bus_space_read_1(iot, ioh, wd_status)
-		    & WDCS_DRQ);
-		if (phase == wphase)
-			break;
-		delay(10);
-	}
-	return (phase);
-}
-
-int
-wait_for_unphase(wdc, wphase)
-	struct wdc_softc *wdc;
-	int wphase;
-{
-	bus_space_tag_t iot = wdc->sc_iot;
-	bus_space_handle_t ioh = wdc->sc_ioh;
-	int i, phase;
-
-	for (i = 20000; i; i--) {
-		phase = (bus_space_read_1(iot, ioh, wd_ireason) &
-		    (WDCI_CMD | WDCI_IN)) |
-		    (bus_space_read_1(iot, ioh, wd_status)
-		    & WDCS_DRQ);
-		if (phase != wphase)
-			break;
-		delay(10);
-	}
-	return (phase);
-}
-
-void
-wdc_atapi_start(wdc, xfer)
-	struct wdc_softc *wdc;
-	struct wdc_xfer *xfer;
-{
-	bus_space_tag_t iot = wdc->sc_iot;
-	bus_space_handle_t ioh = wdc->sc_ioh;
-	struct atapi_command_packet *acp = xfer->atapi_cmd;
-
-#ifdef ATAPI_DEBUG_WDC
-	printf("wdc_atapi_start, acp flags %lx\n",acp->flags);
-#endif
-	if (wdc->sc_errors >= WDIORETRIES) {
-		acp->status |= ERROR;
-		acp->error = bus_space_read_1(iot, ioh, wd_error);
-		wdc_atapi_done(wdc, xfer);
-		return;
-	}
-	if (wait_for_unbusy(wdc) != 0) {
-		if ((wdc->sc_status & WDCS_ERR) == 0) {
-			printf("wdc_atapi_start: not ready, st = %02x\n",
-			    wdc->sc_status);
-			acp->status = ERROR;
-			return;
-		}
-	}
-
-	if (wdccommand((struct wd_link*)xfer->d_link, ATAPI_PACKET_COMMAND,
-	    acp->drive, acp->data_size, 0, 0, 0) != 0) {
-		printf("wdc_atapi_start: can't send atapi paket command\n");
-		acp->status = ERROR;
-		wdc->sc_flags |= WDCF_IRQ_WAIT;
-		return;
-	}
-	if ((acp->flags & (ACAP_DRQ_INTR|ACAP_DRQ_ACCEL)) != ACAP_DRQ_INTR) {
-		if (!(wdc->sc_flags & WDCF_BROKENPOLL)) {
-			int phase = wait_for_phase(wdc, PHASE_CMDOUT);
-
-			if (phase != PHASE_CMDOUT) {
-				printf("wdc_atapi_start: timeout waiting "
-				    "PHASE_CMDOUT, got 0x%x\n", phase);
-
-				/* NEC SUCKS. */
-				wdc->sc_flags |= WDCF_BROKENPOLL;
-			}
-		} else
-			DELAY(10);	/* Simply pray for the data. */
-
-		bus_space_write_raw_multi_2(iot, ioh, wd_data, acp->command,
-		    acp->command_size);
-	}
-	wdc->sc_flags |= WDCF_IRQ_WAIT;
-
-#ifdef ATAPI_DEBUG2
-	printf("wdc_atapi_start: timeout\n");
-#endif
-	timeout(wdctimeout, wdc, WAITTIME);
-	return;
-}
-
-
-/*
- * 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 wdc_xfer *xfer;
-
-	if ((wdc->sc_flags & WDCF_IRQ_WAIT) == 0) {
-		bus_space_tag_t iot = wdc->sc_iot;
-		bus_space_handle_t ioh = wdc->sc_ioh;
-		u_char s;
-#ifdef ATAPI_DEBUG_WDC
-		u_char e, i;
-#endif
-		DELAY(100);
-
-		/* Clear the pending interrupt and abort. */
-		s = bus_space_read_1(iot, ioh, wd_status);
-		if (s != (WDCS_DRDY|WDCS_DSC)) {
-#ifdef ATAPI_DEBUG_WDC
-			e = bus_space_read_1(iot, ioh, wd_error);
-			i = bus_space_read_1(iot, ioh, wd_seccnt);
-
-			printf("wdcintr: inactive controller, "
-			    "punting st=%02x er=%02x irr=%02x\n", s, e, i);
-#else
-			bus_space_read_1(iot, ioh, wd_error);
-			bus_space_read_1(iot, ioh, wd_seccnt);
-#endif
-
-			if (s & WDCS_DRQ) {
-				int len = 256 * bus_space_read_1(iot, ioh,
-				    wd_cyl_hi) +
-				    bus_space_read_1(iot, ioh, wd_cyl_lo);
-#ifdef ATAPI_DEBUG_WDC
-				printf("wdcintr: clearing up %d bytes\n", len);
-#endif
-				wdcbit_bucket(wdc, len);
-			}
-		}
-		return 0;
-	}
-
-	WDDEBUG_PRINT(("wdcintr\n"));
-
-	wdc->sc_flags &= ~WDCF_IRQ_WAIT;
-	xfer = wdc->sc_xfer.tqh_first;
-	if (xfer->c_flags & C_ATAPI) {
-		(void)wdc_atapi_intr(wdc, xfer);
-		return 0;
-	} else {
-		return wdc_ata_intr(wdc, xfer);
-	}
-}
-
-
-int
-wdc_ata_intr(wdc,xfer)
+wdc_ata_intr(wdc, xfer)
 	struct wdc_softc *wdc;
 	struct wdc_xfer *xfer;
 {
@@ -851,245 +710,6 @@ restart:
 	return 1;
 }
 
-int
-wdcreset(wdc)
-	struct wdc_softc *wdc;
-{
-	bus_space_tag_t iot = wdc->sc_iot;
-	bus_space_handle_t ioh = wdc->sc_ioh;
-
-	/* Reset the device. */
-	bus_space_write_1(iot, ioh, wd_ctlr, WDCTL_RST|WDCTL_IDS);
-	delay(1000);
-	bus_space_write_1(iot, ioh, wd_ctlr, WDCTL_IDS);
-	delay(1000);
-	(void) bus_space_read_1(iot, ioh, wd_error);
-	bus_space_write_1(iot, ioh, wd_ctlr, WDCTL_4BIT);
-
-	if (wait_for_unbusy(wdc) < 0) {
-		printf("%s: reset failed\n", wdc->sc_dev.dv_xname);
-		return 1;
-	}
-
-	return 0;
-}
-
-void
-wdcrestart(arg)
-	void *arg;
-{
-	struct wdc_softc *wdc = 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.
- */
-void
-wdcunwedge(wdc)
-	struct wdc_softc *wdc;
-{
-	int unit;
-
-#ifdef ATAPI_DEBUG
-	printf("wdcunwedge\n");
-#endif
-
-	untimeout(wdctimeout, wdc);
-	wdc->sc_flags &= ~WDCF_IRQ_WAIT;
-	(void) wdcreset(wdc);
-
-	/* Schedule recalibrate for all drives on this controller. */
-	for (unit = 0; unit < 2; unit++) {
-		if (!wdc->d_link[unit]) continue;
-		if (wdc->d_link[unit]->sc_state > RECAL)
-			wdc->d_link[unit]->sc_state = RECAL;
-	}
-
-	wdc->sc_flags |= WDCF_ERROR;
-	++wdc->sc_errors;
-
-	/* Wake up in a little bit and restart the operation. */
-	WDDEBUG_PRINT(("wdcrestart from wdcunwedge\n"));
-	wdc->sc_flags &= ~WDCF_ACTIVE;
-	timeout(wdcrestart, wdc, RECOVERYTIME);
-}
-
-int
-wdcwait(wdc, mask)
-	struct wdc_softc *wdc;
-	int mask;
-{
-	bus_space_tag_t iot = wdc->sc_iot;
-	bus_space_handle_t ioh = wdc->sc_ioh;
-	int timeout = 0;
-	u_char status;
-#ifdef WDCNDELAY_DEBUG
-	extern int cold;
-#endif
-
-	WDDEBUG_PRINT(("wdcwait\n"));
-
-	for (;;) {
-		wdc->sc_status = status = bus_space_read_1(iot, ioh,
-		    wd_status);
-		/*
-		 * XXX
-		 * If a single slave ATAPI device is attached, it may
-		 * have released the bus. Select it and try again.
-		 */
-		if (status == 0xff && wdc->sc_flags & WDCF_ONESLAVE) {
-			bus_space_write_1(iot, ioh, wd_sdh,
-			    WDSD_IBM | 0x10);
-			wdc->sc_status = status = bus_space_read_1(iot, ioh,
-			    wd_status);
-		}
-		if ((status & WDCS_BSY) == 0 && (status & mask) == mask)
-			break;
-		if (++timeout > WDCNDELAY) {
-#ifdef ATAPI_DEBUG2
-			printf("wdcwait: timeout, status 0x%x\n", status);
-#endif
-			return -1;
-		}
-		delay(WDCDELAY);
-	}
-	if (status & WDCS_ERR) {
-		wdc->sc_error = bus_space_read_1(iot, ioh, wd_error);
-		return WDCS_ERR;
-	}
-#ifdef WDCNDELAY_DEBUG
-	/* After autoconfig, there should be no long delays. */
-	if (!cold && timeout > WDCNDELAY_DEBUG) {
-		struct wdc_xfer *xfer = wdc->sc_xfer.tqh_first;
-		if (xfer == NULL)
-			printf("%s: warning: busy-wait took %dus\n",
-	    		wdc->sc_dev.dv_xname, WDCDELAY * timeout);
-		else 
-			printf("%s(%s): warning: busy-wait took %dus\n",
-				wdc->sc_dev.dv_xname,
-			    ((struct device*)xfer->d_link->wd_softc)->dv_xname,
-				WDCDELAY * timeout);
-	}
-#endif
-	return 0;
-}
-
-void
-wdctimeout(arg)
-	void *arg;
-{
-	struct wdc_softc *wdc = (struct wdc_softc *)arg;
-	int s;
-
-	WDDEBUG_PRINT(("wdctimeout\n"));
-
-	s = splbio();
-	if ((wdc->sc_flags & WDCF_IRQ_WAIT) != 0) {
-		wdc->sc_flags &= ~WDCF_IRQ_WAIT;
-		wdcerror(wdc, "lost interrupt");
-		wdcunwedge(wdc);
-	} else
-		wdcerror(wdc, "missing untimeout");
-	splx(s);
-}
-
-/*
- * Wait for the drive to become ready and send a command.
- * Return -1 if busy for too long or 0 otherwise.
- * Assumes interrupts are blocked.
- */
-int
-wdccommand(d_link, command, drive, cylin, head, sector, count)
-        struct wd_link *d_link;
-        int command;
-        int drive, cylin, head, sector, count;
-{
-	struct wdc_softc *wdc = (void*)d_link->wdc_softc;
-	bus_space_tag_t iot = wdc->sc_iot;
-	bus_space_handle_t ioh = wdc->sc_ioh;
-        int stat;
-
-	WDDEBUG_PRINT(("wdccommand drive %d\n", drive));
-
-#if defined(DIAGNOSTIC) && defined(WDCDEBUG)
-	if ((wdc->sc_flags & WDCF_ACTIVE) == 0)
-		printf("wdccommand: controler not active (drive %d)\n", drive);
-#endif
-
-        /* Select drive, head, and addressing mode. */
-        bus_space_write_1(iot, ioh, wd_sdh, WDSD_IBM | (drive << 4) | head);
-
-        /* Wait for it to become ready to accept a command. */
-        if (command == WDCC_IDP || d_link->type == BUS)
-                stat = wait_for_unbusy(wdc);
-        else
-                stat = wdcwait(wdc, WDCS_DRDY);
-
-        if (stat < 0) {
-#ifdef ATAPI_DEBUG
-		printf("wdcommand: xfer failed (wait_for_unbusy) status %d\n",
-		    stat);
-#endif
-                return -1;
-	}
-
-        /* Load parameters. */
-        if (d_link->type == DRIVE && d_link->sc_lp->d_type == DTYPE_ST506)
-                bus_space_write_1(iot, ioh, wd_precomp,
-		    d_link->sc_lp->d_precompcyl / 4);
-        else
-                bus_space_write_1(iot, ioh, wd_features, 0);
-        bus_space_write_1(iot, ioh, wd_cyl_lo, cylin);
-        bus_space_write_1(iot, ioh, wd_cyl_hi, cylin >> 8);
-        bus_space_write_1(iot, ioh, wd_sector, sector);
-        bus_space_write_1(iot, ioh, wd_seccnt, count);
-
-        /* Send command. */
-        bus_space_write_1(iot, ioh, wd_command, command);
-
-        return 0;
-}
-
-/*
- * Simplified version of wdccommand().
- */
-int
-wdccommandshort(wdc, drive, command)
-	struct wdc_softc *wdc;
-        int drive;
-        int command;
-{
-	bus_space_tag_t iot = wdc->sc_iot;
-	bus_space_handle_t ioh = wdc->sc_ioh;
-
-	WDDEBUG_PRINT(("wdccommandshort\n"));
-
-#if defined(DIAGNOSTIC) && defined(WDCDEBUG)
-	if ((wdc->sc_flags & WDCF_ACTIVE) == 0)
-		printf("wdccommandshort: controller not active (drive %d)\n",
-		    drive);
-#endif
-
-        /* Select drive. */
-        bus_space_write_1(iot, ioh, wd_sdh, WDSD_IBM|(drive << 4));
-
-        if (wdcwait(wdc, WDCS_DRDY) < 0)
-                return -1;
-
-        bus_space_write_1(iot, ioh, wd_command, command);
-
-	return 0;
-}
-
 void
 wdc_ata_done(wdc, xfer)
 	struct wdc_softc *wdc;
@@ -1127,171 +747,6 @@ wdc_ata_done(wdc, xfer)
 	splx(s);
 }
 
-void
-wdc_exec_xfer(d_link, xfer)
-	struct wd_link *d_link;
-	struct wdc_xfer *xfer;
-{
-	struct wdc_softc *wdc = (struct wdc_softc *)d_link->wdc_softc;
-	int s;
-
-	WDDEBUG_PRINT(("wdc_exec_xfer\n"));
-
-	s = splbio();
-
-	/* insert at the end of command list */
-	TAILQ_INSERT_TAIL(&wdc->sc_xfer,xfer , c_xferchain)
-	WDDEBUG_PRINT(("wdcstart from wdc_exec_xfer, flags %d\n",
-	    wdc->sc_flags));
-	wdcstart(wdc);
-	splx(s);
-}   
-
-struct wdc_xfer *
-wdc_get_xfer(c_link,flags)
-	struct wdc_link *c_link;
-	int flags;
-{
-	struct wdc_xfer *xfer;
-	int s;
-
-	s = splbio();
-	if ((xfer = xfer_free_list.lh_first) != NULL) {
-		LIST_REMOVE(xfer, free_list);
-		splx(s);
-#ifdef DIAGNOSTIC
-		if ((xfer->c_flags & C_INUSE) != 0)
-			panic("wdc_get_xfer: xfer already in use\n");
-#endif
-	} else {
-		splx(s);
-#ifdef ATAPI_DEBUG
-		printf("wdc:making xfer %d\n",wdc_nxfer);
-#endif
-		xfer = malloc(sizeof(*xfer), M_DEVBUF,
-		    ((flags & IDE_NOSLEEP) != 0 ? M_NOWAIT : M_WAITOK));
-		if (xfer == NULL)
-			return 0;
-
-#ifdef DIAGNOSTIC
-		xfer->c_flags &= ~C_INUSE;
-#endif
-#ifdef ATAPI_DEBUG
-		wdc_nxfer++;
-#endif
-	}
-#ifdef DIAGNOSTIC
-	if ((xfer->c_flags & C_INUSE) != 0)
-		panic("wdc_get_xfer: xfer already in use\n");
-#endif
-	bzero(xfer, sizeof(struct wdc_xfer));
-	xfer->c_flags = C_INUSE;
-	xfer->c_link = c_link;
-	return xfer;
-}
-
-void
-wdc_free_xfer(xfer)
-	struct wdc_xfer *xfer;
-{
-	int s;
-
-	s = splbio();
-	xfer->c_flags &= ~C_INUSE;
-	LIST_INSERT_HEAD(&xfer_free_list, xfer, free_list);
-	splx(s);
-}
-
-/*
- * Implement operations needed before read/write.
- * Returns 0 if operation still in progress, 1 if completed.
- */
-int
-wdccontrol(d_link)
-	struct wd_link *d_link;
-{
-	struct wdc_softc *wdc = (void *)d_link->wdc_softc;
-	bus_space_tag_t iot = wdc->sc_iot;
-	bus_space_handle_t ioh = wdc->sc_ioh;
-
-	WDDEBUG_PRINT(("wdccontrol\n"));
-
-	switch (d_link->sc_state) {
-	case RECAL:	/* Set SDH, step rate, do recal. */
-		if (wdccommandshort(wdc, d_link->sc_drive, WDCC_RECAL) != 0) {
-			wderror(d_link, NULL, "wdccontrol: recal failed (1)");
-			goto bad;
-		}
-		d_link->sc_state = RECAL_WAIT;
-		break;
-
-	case RECAL_WAIT:
-		if (wdc->sc_status & WDCS_ERR) {
-			wderror(d_link, NULL, "wdccontrol: recal failed (2)");
-			goto bad;
-		}
-		/* fall through */
-
-	case GEOMETRY:
-		if ((d_link->sc_params.wdp_capabilities & WD_CAP_LBA) != 0)
-			goto multimode;
-		if (wdsetctlr(d_link) != 0) {
-			/* Already printed a message. */
-			goto bad;
-		}
-		d_link->sc_state = GEOMETRY_WAIT;
-		break;
-
-	case GEOMETRY_WAIT:
-		if (wdc->sc_status & WDCS_ERR) {
-			wderror(d_link, NULL, "wdccontrol: geometry failed");
-			goto bad;
-		}
-		/* fall through */
-
-	case MULTIMODE:
-	multimode:
-		if (d_link->sc_mode != WDM_PIOMULTI)
-			goto ready;
-		bus_space_write_1(iot, ioh, wd_seccnt, d_link->sc_multiple);
-		if (wdccommandshort(wdc, d_link->sc_drive,
-		    WDCC_SETMULTI) != 0) {
-			wderror(d_link, NULL,
-			    "wdccontrol: setmulti failed (1)");
-			goto bad;
-		}
-		d_link->sc_state = MULTIMODE_WAIT;
-		break;
-
-	case MULTIMODE_WAIT:
-		if (wdc->sc_status & WDCS_ERR) {
-			wderror(d_link, NULL,
-			    "wdccontrol: setmulti failed (2)");
-			goto bad;
-		}
-		/* fall through */
-
-	case READY:
-	ready:
-		wdc->sc_errors = 0;
-		d_link->sc_state = READY;
-		/*
-		 * The rest of the initialization can be done by normal means.
-		 */
-		return 1;
-
-	bad:
-		wdcunwedge(wdc);
-		return 0;
-	}
-
-	wdc->sc_flags |= WDCF_IRQ_WAIT;
-	timeout(wdctimeout, wdc, WAITTIME);
-	return 0;
-}
-
-__inline static void u_int16_to_string __P((u_int16_t *, char *, size_t));
-
 /* decode IDE strings, stored as if the words are big-endian.  */
 __inline static void
 u_int16_to_string(from, to, cnt)
@@ -1427,17 +882,196 @@ wdc_get_parms(d_link)
 	return 0;
 }
 
+/*
+ * Implement operations needed before read/write.
+ * Returns 0 if operation still in progress, 1 if completed.
+ */
+int
+wdccontrol(d_link)
+	struct wd_link *d_link;
+{
+	struct wdc_softc *wdc = (void *)d_link->wdc_softc;
+	bus_space_tag_t iot = wdc->sc_iot;
+	bus_space_handle_t ioh = wdc->sc_ioh;
+
+	WDDEBUG_PRINT(("wdccontrol\n"));
+
+	switch (d_link->sc_state) {
+	case RECAL:	/* Set SDH, step rate, do recal. */
+		if (wdccommandshort(wdc, d_link->sc_drive, WDCC_RECAL) != 0) {
+			wderror(d_link, NULL, "wdccontrol: recal failed (1)");
+			goto bad;
+		}
+		d_link->sc_state = RECAL_WAIT;
+		break;
+
+	case RECAL_WAIT:
+		if (wdc->sc_status & WDCS_ERR) {
+			wderror(d_link, NULL, "wdccontrol: recal failed (2)");
+			goto bad;
+		}
+		/* fall through */
+
+	case GEOMETRY:
+		if ((d_link->sc_params.wdp_capabilities & WD_CAP_LBA) != 0)
+			goto multimode;
+		if (wdsetctlr(d_link) != 0) {
+			/* Already printed a message. */
+			goto bad;
+		}
+		d_link->sc_state = GEOMETRY_WAIT;
+		break;
+
+	case GEOMETRY_WAIT:
+		if (wdc->sc_status & WDCS_ERR) {
+			wderror(d_link, NULL, "wdccontrol: geometry failed");
+			goto bad;
+		}
+		/* fall through */
+
+	case MULTIMODE:
+	multimode:
+		if (d_link->sc_mode != WDM_PIOMULTI)
+			goto ready;
+		bus_space_write_1(iot, ioh, wd_seccnt, d_link->sc_multiple);
+		if (wdccommandshort(wdc, d_link->sc_drive,
+		    WDCC_SETMULTI) != 0) {
+			wderror(d_link, NULL,
+			    "wdccontrol: setmulti failed (1)");
+			goto bad;
+		}
+		d_link->sc_state = MULTIMODE_WAIT;
+		break;
+
+	case MULTIMODE_WAIT:
+		if (wdc->sc_status & WDCS_ERR) {
+			wderror(d_link, NULL,
+			    "wdccontrol: setmulti failed (2)");
+			goto bad;
+		}
+		/* fall through */
+
+	case READY:
+	ready:
+		wdc->sc_errors = 0;
+		d_link->sc_state = READY;
+		/*
+		 * The rest of the initialization can be done by normal means.
+		 */
+		return 1;
+
+	bad:
+		wdcunwedge(wdc);
+		return 0;
+	}
+
+	wdc->sc_flags |= WDCF_IRQ_WAIT;
+	timeout(wdctimeout, wdc, WAITTIME);
+	return 0;
+}
+#endif	/* NWD */
+
+int
+wait_for_phase(wdc, wphase)
+	struct wdc_softc *wdc;
+	int wphase;
+{
+	bus_space_tag_t iot = wdc->sc_iot;
+	bus_space_handle_t ioh = wdc->sc_ioh;
+	int i, phase;
+
+	for (i = 20000; i; i--) {
+		phase = (bus_space_read_1(iot, ioh, wd_ireason) &
+		    (WDCI_CMD | WDCI_IN)) |
+		    (bus_space_read_1(iot, ioh, wd_status)
+		    & WDCS_DRQ);
+		if (phase == wphase)
+			break;
+		delay(10);
+	}
+	return (phase);
+}
+
+int
+wait_for_unphase(wdc, wphase)
+	struct wdc_softc *wdc;
+	int wphase;
+{
+	bus_space_tag_t iot = wdc->sc_iot;
+	bus_space_handle_t ioh = wdc->sc_ioh;
+	int i, phase;
+
+	for (i = 20000; i; i--) {
+		phase = (bus_space_read_1(iot, ioh, wd_ireason) &
+		    (WDCI_CMD | WDCI_IN)) |
+		    (bus_space_read_1(iot, ioh, wd_status)
+		    & WDCS_DRQ);
+		if (phase != wphase)
+			break;
+		delay(10);
+	}
+	return (phase);
+}
+
+#if NATAPIBUS > 0
 void
-wdcerror(wdc, msg) 
+wdc_atapi_start(wdc, xfer)
 	struct wdc_softc *wdc;
-	char *msg;
+	struct wdc_xfer *xfer;
 {
-	struct wdc_xfer *xfer = wdc->sc_xfer.tqh_first;
-	if (xfer == NULL)
-		printf("%s: %s\n", wdc->sc_dev.dv_xname, msg);
-	else
-		printf("%s(%s): %s\n", wdc->sc_dev.dv_xname, 
-		    ((struct device*)xfer->d_link->wd_softc)->dv_xname, msg);
+	bus_space_tag_t iot = wdc->sc_iot;
+	bus_space_handle_t ioh = wdc->sc_ioh;
+	struct atapi_command_packet *acp = xfer->atapi_cmd;
+
+#ifdef ATAPI_DEBUG_WDC
+	printf("wdc_atapi_start, acp flags %lx\n",acp->flags);
+#endif
+	if (wdc->sc_errors >= WDIORETRIES) {
+		acp->status |= ERROR;
+		acp->error = bus_space_read_1(iot, ioh, wd_error);
+		wdc_atapi_done(wdc, xfer);
+		return;
+	}
+	if (wait_for_unbusy(wdc) != 0) {
+		if ((wdc->sc_status & WDCS_ERR) == 0) {
+			printf("wdc_atapi_start: not ready, st = %02x\n",
+			    wdc->sc_status);
+			acp->status = ERROR;
+			return;
+		}
+	}
+
+	if (wdccommand((struct wd_link*)xfer->d_link, ATAPI_PACKET_COMMAND,
+	    acp->drive, acp->data_size, 0, 0, 0) != 0) {
+		printf("wdc_atapi_start: can't send atapi paket command\n");
+		acp->status = ERROR;
+		wdc->sc_flags |= WDCF_IRQ_WAIT;
+		return;
+	}
+	if ((acp->flags & (ACAP_DRQ_INTR|ACAP_DRQ_ACCEL)) != ACAP_DRQ_INTR) {
+		if (!(wdc->sc_flags & WDCF_BROKENPOLL)) {
+			int phase = wait_for_phase(wdc, PHASE_CMDOUT);
+
+			if (phase != PHASE_CMDOUT) {
+				printf("wdc_atapi_start: timeout waiting "
+				    "PHASE_CMDOUT, got 0x%x\n", phase);
+
+				/* NEC SUCKS. */
+				wdc->sc_flags |= WDCF_BROKENPOLL;
+			}
+		} else
+			DELAY(10);	/* Simply pray for the data. */
+
+		bus_space_write_raw_multi_2(iot, ioh, wd_data, acp->command,
+		    acp->command_size);
+	}
+	wdc->sc_flags |= WDCF_IRQ_WAIT;
+
+#ifdef ATAPI_DEBUG2
+	printf("wdc_atapi_start: timeout\n");
+#endif
+	timeout(wdctimeout, wdc, WAITTIME);
+	return;
 }
 
 int
@@ -1657,29 +1291,6 @@ wdc_atapi_send_command_packet(ab_link, acp)
 	}
 }
 
-
-/* 
- * the bit bucket
- */
-void
-wdcbit_bucket(wdc, size)
-	struct wdc_softc *wdc; 
-	int size;
-{
-	bus_space_tag_t iot = wdc->sc_iot;
-	bus_space_handle_t ioh = wdc->sc_ioh;
-	int i;
-
-	for (i = 0 ; i < size / 2 ; i++) {
-		u_int16_t null; 
-
-		bus_space_read_multi_2(iot, ioh, wd_data, &null, 1);
-	} 
-
-	if (size % 2)
-		bus_space_read_1(iot, ioh, wd_data);
-}
-
 int
 wdc_atapi_intr(wdc, xfer)
 	struct wdc_softc *wdc;
@@ -1859,3 +1470,423 @@ wdc_atapi_done(wdc, xfer)
 
 	splx(s);
 }
+#endif	/* NATAPIBUS */
+
+/*
+ * 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 wdc_xfer *xfer;
+
+	if ((wdc->sc_flags & WDCF_IRQ_WAIT) == 0) {
+		bus_space_tag_t iot = wdc->sc_iot;
+		bus_space_handle_t ioh = wdc->sc_ioh;
+		u_char s;
+#ifdef ATAPI_DEBUG_WDC
+		u_char e, i;
+#endif
+		DELAY(100);
+
+		/* Clear the pending interrupt and abort. */
+		s = bus_space_read_1(iot, ioh, wd_status);
+		if (s != (WDCS_DRDY|WDCS_DSC)) {
+#ifdef ATAPI_DEBUG_WDC
+			e = bus_space_read_1(iot, ioh, wd_error);
+			i = bus_space_read_1(iot, ioh, wd_seccnt);
+
+			printf("wdcintr: inactive controller, "
+			    "punting st=%02x er=%02x irr=%02x\n", s, e, i);
+#else
+			bus_space_read_1(iot, ioh, wd_error);
+			bus_space_read_1(iot, ioh, wd_seccnt);
+#endif
+
+			if (s & WDCS_DRQ) {
+				int len = 256 * bus_space_read_1(iot, ioh,
+				    wd_cyl_hi) +
+				    bus_space_read_1(iot, ioh, wd_cyl_lo);
+#ifdef ATAPI_DEBUG_WDC
+				printf("wdcintr: clearing up %d bytes\n", len);
+#endif
+				wdcbit_bucket(wdc, len);
+			}
+		}
+		return 0;
+	}
+
+	WDDEBUG_PRINT(("wdcintr\n"));
+
+	wdc->sc_flags &= ~WDCF_IRQ_WAIT;
+	xfer = wdc->sc_xfer.tqh_first;
+#if NATAPIBUS > 0 && NWD > 0
+	if (xfer->c_flags & C_ATAPI) {
+		(void)wdc_atapi_intr(wdc, xfer);
+		return 0;
+	} else
+		return wdc_ata_intr(wdc, xfer);
+#else
+#if NATAPIBUS > 0
+	(void)wdc_atapi_intr(wdc, xfer);
+	return 0;
+#endif	/* NATAPIBUS */
+#if NWD > 0
+	return wdc_ata_intr(wdc, xfer);
+#endif	/* NWD */
+#endif	/* NATAPIBUS && NWD */
+}
+
+int
+wdcreset(wdc)
+	struct wdc_softc *wdc;
+{
+	bus_space_tag_t iot = wdc->sc_iot;
+	bus_space_handle_t ioh = wdc->sc_ioh;
+
+	/* Reset the device. */
+	bus_space_write_1(iot, ioh, wd_ctlr, WDCTL_RST|WDCTL_IDS);
+	delay(1000);
+	bus_space_write_1(iot, ioh, wd_ctlr, WDCTL_IDS);
+	delay(1000);
+	(void) bus_space_read_1(iot, ioh, wd_error);
+	bus_space_write_1(iot, ioh, wd_ctlr, WDCTL_4BIT);
+
+	if (wait_for_unbusy(wdc) < 0) {
+		printf("%s: reset failed\n", wdc->sc_dev.dv_xname);
+		return 1;
+	}
+
+	return 0;
+}
+
+void
+wdcrestart(arg)
+	void *arg;
+{
+	struct wdc_softc *wdc = 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.
+ */
+void
+wdcunwedge(wdc)
+	struct wdc_softc *wdc;
+{
+	int unit;
+
+#ifdef ATAPI_DEBUG
+	printf("wdcunwedge\n");
+#endif
+
+	untimeout(wdctimeout, wdc);
+	wdc->sc_flags &= ~WDCF_IRQ_WAIT;
+	(void) wdcreset(wdc);
+
+	/* Schedule recalibrate for all drives on this controller. */
+	for (unit = 0; unit < 2; unit++) {
+		if (!wdc->d_link[unit]) continue;
+		if (wdc->d_link[unit]->sc_state > RECAL)
+			wdc->d_link[unit]->sc_state = RECAL;
+	}
+
+	wdc->sc_flags |= WDCF_ERROR;
+	++wdc->sc_errors;
+
+	/* Wake up in a little bit and restart the operation. */
+	WDDEBUG_PRINT(("wdcrestart from wdcunwedge\n"));
+	wdc->sc_flags &= ~WDCF_ACTIVE;
+	timeout(wdcrestart, wdc, RECOVERYTIME);
+}
+
+int
+wdcwait(wdc, mask)
+	struct wdc_softc *wdc;
+	int mask;
+{
+	bus_space_tag_t iot = wdc->sc_iot;
+	bus_space_handle_t ioh = wdc->sc_ioh;
+	int timeout = 0;
+	u_char status;
+#ifdef WDCNDELAY_DEBUG
+	extern int cold;
+#endif
+
+	WDDEBUG_PRINT(("wdcwait\n"));
+
+	for (;;) {
+		wdc->sc_status = status = bus_space_read_1(iot, ioh,
+		    wd_status);
+		/*
+		 * XXX
+		 * If a single slave ATAPI device is attached, it may
+		 * have released the bus. Select it and try again.
+		 */
+		if (status == 0xff && wdc->sc_flags & WDCF_ONESLAVE) {
+			bus_space_write_1(iot, ioh, wd_sdh,
+			    WDSD_IBM | 0x10);
+			wdc->sc_status = status = bus_space_read_1(iot, ioh,
+			    wd_status);
+		}
+		if ((status & WDCS_BSY) == 0 && (status & mask) == mask)
+			break;
+		if (++timeout > WDCNDELAY) {
+#ifdef ATAPI_DEBUG2
+			printf("wdcwait: timeout, status 0x%x\n", status);
+#endif
+			return -1;
+		}
+		delay(WDCDELAY);
+	}
+	if (status & WDCS_ERR) {
+		wdc->sc_error = bus_space_read_1(iot, ioh, wd_error);
+		return WDCS_ERR;
+	}
+#ifdef WDCNDELAY_DEBUG
+	/* After autoconfig, there should be no long delays. */
+	if (!cold && timeout > WDCNDELAY_DEBUG) {
+		struct wdc_xfer *xfer = wdc->sc_xfer.tqh_first;
+		if (xfer == NULL)
+			printf("%s: warning: busy-wait took %dus\n",
+	    		wdc->sc_dev.dv_xname, WDCDELAY * timeout);
+		else 
+			printf("%s(%s): warning: busy-wait took %dus\n",
+				wdc->sc_dev.dv_xname,
+			    ((struct device*)xfer->d_link->wd_softc)->dv_xname,
+				WDCDELAY * timeout);
+	}
+#endif
+	return 0;
+}
+
+void
+wdctimeout(arg)
+	void *arg;
+{
+	struct wdc_softc *wdc = (struct wdc_softc *)arg;
+	int s;
+
+	WDDEBUG_PRINT(("wdctimeout\n"));
+
+	s = splbio();
+	if ((wdc->sc_flags & WDCF_IRQ_WAIT) != 0) {
+		wdc->sc_flags &= ~WDCF_IRQ_WAIT;
+		wdcerror(wdc, "lost interrupt");
+		wdcunwedge(wdc);
+	} else
+		wdcerror(wdc, "missing untimeout");
+	splx(s);
+}
+
+/*
+ * Wait for the drive to become ready and send a command.
+ * Return -1 if busy for too long or 0 otherwise.
+ * Assumes interrupts are blocked.
+ */
+int
+wdccommand(d_link, command, drive, cylin, head, sector, count)
+        struct wd_link *d_link;
+        int command;
+        int drive, cylin, head, sector, count;
+{
+	struct wdc_softc *wdc = (void*)d_link->wdc_softc;
+	bus_space_tag_t iot = wdc->sc_iot;
+	bus_space_handle_t ioh = wdc->sc_ioh;
+        int stat;
+
+	WDDEBUG_PRINT(("wdccommand drive %d\n", drive));
+
+#if defined(DIAGNOSTIC) && defined(WDCDEBUG)
+	if ((wdc->sc_flags & WDCF_ACTIVE) == 0)
+		printf("wdccommand: controler not active (drive %d)\n", drive);
+#endif
+
+        /* Select drive, head, and addressing mode. */
+        bus_space_write_1(iot, ioh, wd_sdh, WDSD_IBM | (drive << 4) | head);
+
+        /* Wait for it to become ready to accept a command. */
+        if (command == WDCC_IDP || d_link->type == BUS)
+                stat = wait_for_unbusy(wdc);
+        else
+                stat = wdcwait(wdc, WDCS_DRDY);
+
+        if (stat < 0) {
+#ifdef ATAPI_DEBUG
+		printf("wdcommand: xfer failed (wait_for_unbusy) status %d\n",
+		    stat);
+#endif
+                return -1;
+	}
+
+        /* Load parameters. */
+        if (d_link->type == DRIVE && d_link->sc_lp->d_type == DTYPE_ST506)
+                bus_space_write_1(iot, ioh, wd_precomp,
+		    d_link->sc_lp->d_precompcyl / 4);
+        else
+                bus_space_write_1(iot, ioh, wd_features, 0);
+        bus_space_write_1(iot, ioh, wd_cyl_lo, cylin);
+        bus_space_write_1(iot, ioh, wd_cyl_hi, cylin >> 8);
+        bus_space_write_1(iot, ioh, wd_sector, sector);
+        bus_space_write_1(iot, ioh, wd_seccnt, count);
+
+        /* Send command. */
+        bus_space_write_1(iot, ioh, wd_command, command);
+
+        return 0;
+}
+
+/*
+ * Simplified version of wdccommand().
+ */
+int
+wdccommandshort(wdc, drive, command)
+	struct wdc_softc *wdc;
+        int drive;
+        int command;
+{
+	bus_space_tag_t iot = wdc->sc_iot;
+	bus_space_handle_t ioh = wdc->sc_ioh;
+
+	WDDEBUG_PRINT(("wdccommandshort\n"));
+
+#if defined(DIAGNOSTIC) && defined(WDCDEBUG)
+	if ((wdc->sc_flags & WDCF_ACTIVE) == 0)
+		printf("wdccommandshort: controller not active (drive %d)\n",
+		    drive);
+#endif
+
+        /* Select drive. */
+        bus_space_write_1(iot, ioh, wd_sdh, WDSD_IBM|(drive << 4));
+
+        if (wdcwait(wdc, WDCS_DRDY) < 0)
+                return -1;
+
+        bus_space_write_1(iot, ioh, wd_command, command);
+
+	return 0;
+}
+
+void
+wdc_exec_xfer(d_link, xfer)
+	struct wd_link *d_link;
+	struct wdc_xfer *xfer;
+{
+	struct wdc_softc *wdc = (struct wdc_softc *)d_link->wdc_softc;
+	int s;
+
+	WDDEBUG_PRINT(("wdc_exec_xfer\n"));
+
+	s = splbio();
+
+	/* insert at the end of command list */
+	TAILQ_INSERT_TAIL(&wdc->sc_xfer,xfer , c_xferchain)
+	WDDEBUG_PRINT(("wdcstart from wdc_exec_xfer, flags %d\n",
+	    wdc->sc_flags));
+	wdcstart(wdc);
+	splx(s);
+}   
+
+struct wdc_xfer *
+wdc_get_xfer(c_link,flags)
+	struct wdc_link *c_link;
+	int flags;
+{
+	struct wdc_xfer *xfer;
+	int s;
+
+	s = splbio();
+	if ((xfer = xfer_free_list.lh_first) != NULL) {
+		LIST_REMOVE(xfer, free_list);
+		splx(s);
+#ifdef DIAGNOSTIC
+		if ((xfer->c_flags & C_INUSE) != 0)
+			panic("wdc_get_xfer: xfer already in use\n");
+#endif
+	} else {
+		splx(s);
+#ifdef ATAPI_DEBUG
+		printf("wdc:making xfer %d\n",wdc_nxfer);
+#endif
+		xfer = malloc(sizeof(*xfer), M_DEVBUF,
+		    ((flags & IDE_NOSLEEP) != 0 ? M_NOWAIT : M_WAITOK));
+		if (xfer == NULL)
+			return 0;
+
+#ifdef DIAGNOSTIC
+		xfer->c_flags &= ~C_INUSE;
+#endif
+#ifdef ATAPI_DEBUG
+		wdc_nxfer++;
+#endif
+	}
+#ifdef DIAGNOSTIC
+	if ((xfer->c_flags & C_INUSE) != 0)
+		panic("wdc_get_xfer: xfer already in use\n");
+#endif
+	bzero(xfer, sizeof(struct wdc_xfer));
+	xfer->c_flags = C_INUSE;
+	xfer->c_link = c_link;
+	return xfer;
+}
+
+void
+wdc_free_xfer(xfer)
+	struct wdc_xfer *xfer;
+{
+	int s;
+
+	s = splbio();
+	xfer->c_flags &= ~C_INUSE;
+	LIST_INSERT_HEAD(&xfer_free_list, xfer, free_list);
+	splx(s);
+}
+
+void
+wdcerror(wdc, msg) 
+	struct wdc_softc *wdc;
+	char *msg;
+{
+	struct wdc_xfer *xfer = wdc->sc_xfer.tqh_first;
+	if (xfer == NULL)
+		printf("%s: %s\n", wdc->sc_dev.dv_xname, msg);
+	else
+		printf("%s(%s): %s\n", wdc->sc_dev.dv_xname, 
+		    ((struct device*)xfer->d_link->wd_softc)->dv_xname, msg);
+}
+
+/* 
+ * the bit bucket
+ */
+void
+wdcbit_bucket(wdc, size)
+	struct wdc_softc *wdc; 
+	int size;
+{
+	bus_space_tag_t iot = wdc->sc_iot;
+	bus_space_handle_t ioh = wdc->sc_ioh;
+	int i;
+
+	for (i = 0 ; i < size / 2 ; i++) {
+		u_int16_t null; 
+
+		bus_space_read_multi_2(iot, ioh, wd_data, &null, 1);
+	} 
+
+	if (size % 2)
+		bus_space_read_1(iot, ioh, wd_data);
+}
diff --git a/sys/dev/isa/wdlink.h b/sys/dev/isa/wdlink.h
index 66ceb721b31..154902ca047 100644
--- a/sys/dev/isa/wdlink.h
+++ b/sys/dev/isa/wdlink.h
@@ -1,4 +1,4 @@
-/*	$OpenBSD: wdlink.h,v 1.6 1996/11/29 22:55:10 niklas Exp $	*/
+/*	$OpenBSD: wdlink.h,v 1.7 1997/07/04 17:02:04 downsj Exp $	*/
 
 /*
  * Copyright (c) 1994, 1995 Charles M. Hannum.  All rights reserved.
@@ -37,6 +37,8 @@
 /* #undef WDDEBUG */
 /* #undef DIAGNOSTIC */
 
+#include "wd.h"
+
 struct wdc_link {
 	int flags;
 	int openings;
@@ -134,13 +136,16 @@ struct wdc_xfer {
 void	wdc_exec_xfer		__P((struct wd_link *, struct wdc_xfer *));
 struct	wdc_xfer *wdc_get_xfer	__P((struct wdc_link *, int));
 int	wdc_get_parms		__P((struct wd_link *));
+int	wdccommandshort		__P((struct wdc_softc *, int, int));
+int	wdcwait			__P((struct wdc_softc *, int));
+int	wdccommand		__P((struct wd_link *, int, int, int, int, int, int));
+
+#if NWD > 0
 void	wderror			__P((struct wd_link* , struct buf *, char *));
 int	wdsetctlr		__P((struct wd_link *));
 void	wdstart			__P((void *));
 void	wddone			__P((struct wd_link*, struct buf*));
-int	wdccommand		__P((struct wd_link *, int, int, int, int, int, int));
-int	wdccommandshort		__P((struct wdc_softc *, int, int));
-int	wdcwait			__P((struct wdc_softc *, int));
+#endif	/* NWD */
 
 /*
  * ST506 spec says that if READY or SEEKCMPLT go off, then the read or write