Home | History | Annotate | Line # | Download | only in ata
wd.c revision 1.104
      1  1.104  mycroft /*	$NetBSD: wd.c,v 1.104 1994/11/04 19:02:06 mycroft Exp $	*/
      2  1.100      cgd 
      3   1.11  deraadt /*
      4   1.41  mycroft  * Copyright (c) 1994 Charles Hannum.
      5    1.1      cgd  * Copyright (c) 1990 The Regents of the University of California.
      6    1.1      cgd  * All rights reserved.
      7    1.1      cgd  *
      8    1.1      cgd  * This code is derived from software contributed to Berkeley by
      9    1.1      cgd  * William Jolitz.
     10    1.1      cgd  *
     11    1.1      cgd  * Redistribution and use in source and binary forms, with or without
     12    1.1      cgd  * modification, are permitted provided that the following conditions
     13    1.1      cgd  * are met:
     14    1.1      cgd  * 1. Redistributions of source code must retain the above copyright
     15    1.1      cgd  *    notice, this list of conditions and the following disclaimer.
     16    1.1      cgd  * 2. Redistributions in binary form must reproduce the above copyright
     17    1.1      cgd  *    notice, this list of conditions and the following disclaimer in the
     18    1.1      cgd  *    documentation and/or other materials provided with the distribution.
     19    1.1      cgd  * 3. All advertising materials mentioning features or use of this software
     20    1.1      cgd  *    must display the following acknowledgement:
     21    1.1      cgd  *	This product includes software developed by the University of
     22    1.1      cgd  *	California, Berkeley and its contributors.
     23    1.1      cgd  * 4. Neither the name of the University nor the names of its contributors
     24    1.1      cgd  *    may be used to endorse or promote products derived from this software
     25    1.1      cgd  *    without specific prior written permission.
     26    1.1      cgd  *
     27    1.1      cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     28    1.1      cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     29    1.1      cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     30    1.1      cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     31    1.1      cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     32    1.1      cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     33    1.1      cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     34    1.1      cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     35    1.1      cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     36    1.1      cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     37    1.1      cgd  * SUCH DAMAGE.
     38    1.1      cgd  *
     39  1.100      cgd  *	@(#)wd.c	7.2 (Berkeley) 5/9/91
     40    1.1      cgd  */
     41    1.1      cgd 
     42   1.46  mycroft #define	INSTRUMENT	/* instrumentation stuff by Brad Parker */
     43    1.1      cgd 
     44   1.29  mycroft #include <sys/param.h>
     45   1.29  mycroft #include <sys/dkbad.h>
     46   1.29  mycroft #include <sys/systm.h>
     47   1.43  mycroft #include <sys/kernel.h>
     48   1.29  mycroft #include <sys/conf.h>
     49   1.29  mycroft #include <sys/file.h>
     50   1.29  mycroft #include <sys/stat.h>
     51   1.29  mycroft #include <sys/ioctl.h>
     52   1.29  mycroft #include <sys/buf.h>
     53   1.29  mycroft #include <sys/uio.h>
     54   1.29  mycroft #include <sys/malloc.h>
     55   1.64  mycroft #include <sys/device.h>
     56   1.94  mycroft #include <sys/disklabel.h>
     57   1.94  mycroft #include <sys/disk.h>
     58   1.29  mycroft #include <sys/syslog.h>
     59    1.3  deraadt #ifdef INSTRUMENT
     60   1.29  mycroft #include <sys/dkstat.h>
     61    1.3  deraadt #endif
     62   1.29  mycroft 
     63   1.29  mycroft #include <vm/vm.h>
     64   1.29  mycroft 
     65   1.29  mycroft #include <machine/cpu.h>
     66   1.29  mycroft #include <machine/pio.h>
     67   1.29  mycroft 
     68   1.74  mycroft #include <i386/isa/isavar.h>
     69   1.29  mycroft #include <i386/isa/wdreg.h>
     70    1.1      cgd 
     71   1.41  mycroft #define WDCNDELAY	100000	/* delay = 100us; so 10s for a controller state change */
     72   1.41  mycroft #define WDCDELAY	100
     73   1.98  mycroft 
     74   1.98  mycroft #define	WAITTIME	(4 * hz)	/* time to wait for a completion */
     75   1.98  mycroft #define	RECOVERYTIME	(hz / 2)	/* time to recover from an error */
     76   1.19  deraadt 
     77   1.89  mycroft #if 0
     78   1.64  mycroft /* If you enable this, it will report any delays more than 100us * N long. */
     79   1.69  mycroft #define WDCNDELAY_DEBUG	10
     80   1.51  mycroft #endif
     81   1.23  deraadt 
     82   1.21  deraadt #define	WDIORETRIES	5	/* number of retries before giving up */
     83    1.1      cgd 
     84   1.92      cgd #define	WDUNIT(dev)			DISKUNIT(dev)
     85   1.92      cgd #define	WDPART(dev)			DISKPART(dev)
     86   1.92      cgd #define	MAKEWDDEV(maj, unit, part)	MAKEDISKDEV(maj, unit, part)
     87   1.92      cgd 
     88   1.92      cgd #define	WDLABELDEV(dev)	(MAKEWDDEV(major(dev), WDUNIT(dev), RAW_PART))
     89    1.1      cgd 
     90    1.1      cgd #define b_cylin	b_resid		/* cylinder number for doing IO to */
     91    1.1      cgd 				/* shares an entry in the buf struct */
     92    1.1      cgd 
     93    1.1      cgd /*
     94    1.1      cgd  * Drive states.  Used to initialize drive.
     95    1.1      cgd  */
     96   1.64  mycroft #define	CLOSED		0		/* disk is closed */
     97   1.69  mycroft #define	RECAL		1		/* recalibrate */
     98   1.69  mycroft #define	RECAL_WAIT	2		/* done recalibrating */
     99   1.69  mycroft #define	GEOMETRY	3		/* upload geometry */
    100   1.69  mycroft #define	GEOMETRY_WAIT	4		/* done uploading geometry */
    101   1.69  mycroft #define	OPEN		5		/* done with open */
    102    1.1      cgd 
    103    1.1      cgd /*
    104   1.37  mycroft  * Drive status.
    105    1.1      cgd  */
    106   1.64  mycroft struct wd_softc {
    107   1.64  mycroft 	struct device sc_dev;
    108   1.93  mycroft 	struct dkdevice sc_dk;
    109    1.9  deraadt 
    110   1.64  mycroft 	long	sc_bcount;	/* byte count left */
    111   1.64  mycroft 	long	sc_mbcount;	/* total byte count left */
    112   1.64  mycroft 	short	sc_skip;	/* blocks already transferred */
    113   1.64  mycroft 	short	sc_mskip;	/* blocks already transferred for multi */
    114   1.74  mycroft 	char	sc_drive;	/* physical unit number */
    115   1.64  mycroft 	char	sc_state;	/* control state */
    116   1.64  mycroft 
    117   1.93  mycroft 	u_char	sc_flags;	/* drive characteistics found */
    118   1.93  mycroft #define	WDF_BSDLABEL	0x01	/* has a BSD disk label */
    119   1.93  mycroft #define	WDF_BADSECT	0x02	/* has a bad144 badsector table */
    120   1.93  mycroft #define	WDF_WRITEPROT	0x04	/* manual unit write protect */
    121   1.93  mycroft #define	WDF_WLABEL	0x08	/* label is writable */
    122   1.78  mycroft 	TAILQ_ENTRY(wd_softc) sc_drivechain;
    123   1.64  mycroft 	struct buf sc_q;
    124   1.64  mycroft 	struct wdparams sc_params; /* ESDI/IDE drive/controller parameters */
    125   1.64  mycroft 	long	sc_badsect[127];	/* 126 plus trailing -1 marker */
    126   1.74  mycroft };
    127   1.64  mycroft 
    128   1.64  mycroft struct wdc_softc {
    129   1.64  mycroft 	struct device sc_dev;
    130   1.76  mycroft 	struct intrhand sc_ih;
    131   1.64  mycroft 
    132   1.69  mycroft 	u_char	sc_flags;
    133   1.78  mycroft #define	WDCF_ACTIVE	0x00001	/* controller is active */
    134   1.69  mycroft #define	WDCF_SINGLE	0x00004	/* sector at a time mode */
    135   1.69  mycroft #define	WDCF_ERROR	0x00008	/* processing a disk error */
    136   1.64  mycroft 	u_char	sc_status;	/* copy of status register */
    137   1.64  mycroft 	u_char	sc_error;	/* copy of error register */
    138   1.64  mycroft 	u_short	sc_iobase;	/* i/o port base */
    139   1.78  mycroft 	int	sc_errors;	/* count of errors during current transfer */
    140   1.78  mycroft 	TAILQ_HEAD(drivehead, wd_softc) sc_drives;
    141   1.74  mycroft };
    142    1.3  deraadt 
    143  1.102  mycroft int wdcprobe __P((struct device *, void *, void *));
    144  1.102  mycroft void wdcattach __P((struct device *, struct device *, void *));
    145    1.3  deraadt 
    146   1.74  mycroft struct cfdriver wdccd = {
    147  1.102  mycroft 	NULL, "wdc", wdcprobe, wdcattach, DV_DULL, sizeof(struct wd_softc), 1
    148    1.1      cgd };
    149    1.1      cgd 
    150  1.102  mycroft int wdprobe __P((struct device *, void *, void *));
    151  1.102  mycroft void wdattach __P((struct device *, struct device *, void *));
    152  1.102  mycroft void wdstrategy __P((struct buf *));
    153  1.102  mycroft 
    154   1.74  mycroft struct cfdriver wdcd = {
    155   1.74  mycroft 	NULL, "wd", wdprobe, wdattach, DV_DISK, sizeof(struct wd_softc)
    156   1.65  mycroft };
    157  1.102  mycroft struct dkdriver wddkdriver = { wdstrategy };
    158   1.65  mycroft 
    159   1.64  mycroft void wdfinish __P((struct wd_softc *, struct buf *));
    160   1.64  mycroft static void wdstart __P((struct wd_softc *));
    161  1.103  mycroft int wdcintr __P((struct wdc_softc *));
    162   1.64  mycroft static void wdcstart __P((struct wdc_softc *));
    163   1.64  mycroft static int wdcommand __P((struct wd_softc *, int, int, int, int, int));
    164   1.69  mycroft static int wdcontrol __P((struct wd_softc *));
    165   1.64  mycroft static int wdsetctlr __P((struct wd_softc *));
    166   1.64  mycroft static int wdgetctlr __P((struct wd_softc *));
    167   1.64  mycroft static void bad144intern __P((struct wd_softc *));
    168   1.64  mycroft static int wdcreset __P((struct wdc_softc *));
    169   1.81      cgd static void wdcrestart __P((void *arg));
    170   1.64  mycroft static void wdcunwedge __P((struct wdc_softc *));
    171   1.81      cgd static void wdctimeout __P((void *arg));
    172   1.63  mycroft void wddisksort __P((struct buf *, struct buf *));
    173   1.64  mycroft static void wderror __P((void *, struct buf *, char *));
    174   1.64  mycroft int wdcwait __P((struct wdc_softc *, int));
    175   1.87  mycroft /* ST506 spec says that if READY or SEEKCMPLT go off, then the read or write
    176   1.87  mycroft    command is aborted. */
    177   1.87  mycroft #define	wait_for_drq(d)		wdcwait(d, WDCS_READY | WDCS_SEEKCMPLT | WDCS_DRQ)
    178   1.64  mycroft #define	wait_for_ready(d)	wdcwait(d, WDCS_READY | WDCS_SEEKCMPLT)
    179   1.64  mycroft #define	wait_for_unbusy(d)	wdcwait(d, 0)
    180    1.1      cgd 
    181    1.1      cgd /*
    182    1.1      cgd  * Probe for controller.
    183    1.1      cgd  */
    184    1.1      cgd int
    185  1.102  mycroft wdcprobe(parent, match, aux)
    186  1.102  mycroft 	struct device *parent;
    187  1.102  mycroft 	void *match, *aux;
    188    1.1      cgd {
    189  1.102  mycroft 	struct wdc_softc *wdc = match;
    190   1.74  mycroft 	struct isa_attach_args *ia = aux;
    191   1.64  mycroft 	struct wd_softc *wd;
    192   1.64  mycroft 	u_short iobase;
    193    1.1      cgd 
    194   1.74  mycroft 	wdc->sc_iobase = iobase = ia->ia_iobase;
    195   1.64  mycroft 
    196   1.64  mycroft 	/* Check if we have registers that work. */
    197   1.64  mycroft 	outb(iobase+wd_error, 0x5a);	/* Error register not writable. */
    198   1.64  mycroft 	outb(iobase+wd_cyl_lo, 0xa5);	/* But all of cyllo are implemented. */
    199   1.64  mycroft 	if (inb(iobase+wd_error) == 0x5a || inb(iobase+wd_cyl_lo) != 0xa5)
    200   1.64  mycroft 		return 0;
    201    1.3  deraadt 
    202   1.64  mycroft 	if (wdcreset(wdc) != 0) {
    203   1.64  mycroft 		delay(500000);
    204   1.64  mycroft 		if (wdcreset(wdc) != 0)
    205   1.64  mycroft 			return 0;
    206   1.64  mycroft 	}
    207    1.1      cgd 
    208   1.64  mycroft 	/*
    209   1.64  mycroft 	 * XXX wdcommand() accepts a wd_softc, so we have to make it one.
    210   1.64  mycroft 	 */
    211   1.64  mycroft 	wd = (void *)malloc(sizeof(struct wd_softc), M_TEMP, M_NOWAIT);
    212   1.64  mycroft 	bzero(wd, sizeof(struct wd_softc));
    213   1.74  mycroft 	wd->sc_drive = 0;
    214   1.74  mycroft 	wd->sc_dev.dv_unit = 0;
    215   1.64  mycroft 	wd->sc_dev.dv_parent = (void *)wdc;
    216   1.64  mycroft 
    217   1.64  mycroft 	/* Execute a controller only command. */
    218   1.64  mycroft 	if (wdcommand(wd, 0, 0, 0, 0, WDCC_DIAGNOSE) != 0 ||
    219   1.64  mycroft 	    wait_for_unbusy(wdc) != 0)
    220   1.64  mycroft 		goto lose;
    221    1.3  deraadt 
    222   1.64  mycroft 	free(wd, M_TEMP);
    223   1.74  mycroft 	ia->ia_iosize = 8;
    224   1.74  mycroft 	ia->ia_msize = 0;
    225   1.74  mycroft 	return 1;
    226    1.1      cgd 
    227   1.64  mycroft lose:
    228   1.64  mycroft 	free(wd, M_TEMP);
    229   1.37  mycroft 	return 0;
    230   1.66  mycroft }
    231   1.66  mycroft 
    232   1.74  mycroft struct wdc_attach_args {
    233   1.74  mycroft 	int wa_drive;
    234   1.74  mycroft };
    235   1.74  mycroft 
    236   1.66  mycroft int
    237   1.74  mycroft wdprint(aux, wdc)
    238   1.74  mycroft 	void *aux;
    239   1.74  mycroft 	char *wdc;
    240   1.74  mycroft {
    241   1.74  mycroft 	struct wdc_attach_args *wa = aux;
    242   1.74  mycroft 
    243   1.74  mycroft 	if (!wdc)
    244   1.74  mycroft 		printf(" drive %d", wa->wa_drive);
    245   1.74  mycroft 	return QUIET;
    246   1.66  mycroft }
    247   1.66  mycroft 
    248   1.74  mycroft void
    249   1.74  mycroft wdcattach(parent, self, aux)
    250   1.74  mycroft 	struct device *parent, *self;
    251   1.74  mycroft 	void *aux;
    252   1.66  mycroft {
    253   1.74  mycroft 	struct wdc_softc *wdc = (void *)self;
    254   1.76  mycroft 	struct isa_attach_args *ia = aux;
    255   1.74  mycroft 	struct wdc_attach_args wa;
    256   1.67  mycroft 
    257  1.102  mycroft 	TAILQ_INIT(&wdc->sc_drives);
    258  1.102  mycroft 
    259   1.74  mycroft 	printf("\n");
    260   1.74  mycroft 
    261   1.76  mycroft 	wdc->sc_ih.ih_fun = wdcintr;
    262   1.76  mycroft 	wdc->sc_ih.ih_arg = wdc;
    263   1.76  mycroft 	wdc->sc_ih.ih_level = IPL_BIO;
    264   1.76  mycroft 	intr_establish(ia->ia_irq, &wdc->sc_ih);
    265  1.102  mycroft 
    266  1.102  mycroft 	for (wa.wa_drive = 0; wa.wa_drive < 2; wa.wa_drive++)
    267  1.102  mycroft 		(void)config_found(self, (void *)&wa, wdprint);
    268    1.1      cgd }
    269    1.1      cgd 
    270    1.1      cgd int
    271  1.102  mycroft wdprobe(parent, match, aux)
    272  1.102  mycroft 	struct device *parent;
    273  1.102  mycroft 	void *match, *aux;
    274   1.74  mycroft {
    275  1.102  mycroft 	struct wd_softc *wd = match;
    276   1.74  mycroft 	struct cfdata *cf = wd->sc_dev.dv_cfdata;
    277   1.74  mycroft 	struct wdc_attach_args *wa = aux;
    278   1.74  mycroft 	int drive = wa->wa_drive;
    279    1.3  deraadt 
    280  1.102  mycroft 	if (cf->cf_loc[0] != -1 && cf->cf_loc[0] != drive)
    281   1.11  deraadt 		return 0;
    282    1.3  deraadt 
    283   1.74  mycroft 	wd->sc_drive = drive;
    284   1.64  mycroft 
    285   1.74  mycroft 	if (wdgetctlr(wd) != 0)
    286   1.74  mycroft 		return 0;
    287   1.64  mycroft 
    288   1.74  mycroft 	return 1;
    289   1.74  mycroft }
    290   1.64  mycroft 
    291   1.74  mycroft void
    292   1.74  mycroft wdattach(parent, self, aux)
    293   1.74  mycroft 	struct device *parent, *self;
    294   1.74  mycroft 	void *aux;
    295   1.74  mycroft {
    296   1.74  mycroft 	struct wd_softc *wd = (void *)self;
    297   1.74  mycroft 	int i, blank;
    298   1.56  mycroft 
    299   1.64  mycroft 	if (wd->sc_params.wdp_heads == 0)
    300   1.74  mycroft 		printf(": (unknown size) <");
    301   1.56  mycroft 	else
    302   1.93  mycroft 		printf(": %dMB %d cyl, %d head, %d sec, %d bytes/sec <",
    303   1.93  mycroft 		    wd->sc_dk.dk_label.d_ncylinders *
    304   1.93  mycroft 		    wd->sc_dk.dk_label.d_secpercyl /
    305   1.93  mycroft 		    (1048576 / wd->sc_dk.dk_label.d_secsize),
    306   1.93  mycroft 		    wd->sc_dk.dk_label.d_ncylinders,
    307   1.93  mycroft 		    wd->sc_dk.dk_label.d_ntracks,
    308   1.93  mycroft 		    wd->sc_dk.dk_label.d_nsectors,
    309   1.93  mycroft 		    wd->sc_dk.dk_label.d_secsize);
    310   1.64  mycroft 	for (i = blank = 0; i < sizeof(wd->sc_params.wdp_model); i++) {
    311   1.64  mycroft 		char c = wd->sc_params.wdp_model[i];
    312   1.56  mycroft 		if (c == '\0')
    313   1.56  mycroft 			break;
    314   1.56  mycroft 		if (c != ' ') {
    315   1.56  mycroft 			if (blank)
    316   1.56  mycroft 				printf(" %c", c);
    317   1.56  mycroft 			else
    318   1.56  mycroft 				printf("%c", c);
    319   1.56  mycroft 			blank = 0;
    320   1.56  mycroft 		} else
    321   1.56  mycroft 			blank = 1;
    322   1.56  mycroft 	}
    323   1.56  mycroft 	printf(">\n");
    324  1.102  mycroft 	wd->sc_dk.dk_driver = &wddkdriver;
    325    1.1      cgd }
    326    1.1      cgd 
    327   1.64  mycroft /*
    328   1.64  mycroft  * Read/write routine for a buffer.  Finds the proper unit, range checks
    329   1.64  mycroft  * arguments, and schedules the transfer.  Does not wait for the transfer to
    330   1.64  mycroft  * complete.  Multi-page transfers are supported.  All I/O requests must be a
    331   1.64  mycroft  * multiple of a sector in length.
    332    1.1      cgd  */
    333   1.64  mycroft void
    334   1.55  mycroft wdstrategy(bp)
    335   1.55  mycroft 	struct buf *bp;
    336    1.1      cgd {
    337   1.64  mycroft 	struct wd_softc *wd;	/* disk unit to do the IO */
    338   1.51  mycroft 	int lunit = WDUNIT(bp->b_dev);
    339   1.37  mycroft 	int s;
    340    1.3  deraadt 
    341   1.64  mycroft 	/* Valid unit, controller, and request?  */
    342   1.85  mycroft 	if (lunit >= wdcd.cd_ndevs ||
    343   1.85  mycroft 	    (wd = wdcd.cd_devs[lunit]) == 0 ||
    344   1.85  mycroft 	    bp->b_blkno < 0 ||
    345   1.85  mycroft 	    (bp->b_bcount % DEV_BSIZE) != 0 ||
    346   1.85  mycroft 	    (bp->b_bcount / DEV_BSIZE) >= (1 << NBBY)) {
    347    1.1      cgd 		bp->b_error = EINVAL;
    348   1.93  mycroft 		goto bad;
    349    1.1      cgd 	}
    350    1.3  deraadt 
    351   1.64  mycroft 	/* "Soft" write protect check. */
    352   1.64  mycroft 	if ((wd->sc_flags & WDF_WRITEPROT) && (bp->b_flags & B_READ) == 0) {
    353    1.1      cgd 		bp->b_error = EROFS;
    354   1.93  mycroft 		goto bad;
    355    1.1      cgd 	}
    356    1.3  deraadt 
    357   1.93  mycroft 	/* If it's a null transfer, return immediately. */
    358   1.93  mycroft 	if (bp->b_bcount == 0)
    359   1.93  mycroft 		goto done;
    360   1.93  mycroft 
    361   1.64  mycroft 	/* Have partitions and want to use them? */
    362   1.93  mycroft 	if (WDPART(bp->b_dev) != RAW_PART) {
    363   1.93  mycroft 		if ((wd->sc_flags & WDF_BSDLABEL) == 0) {
    364   1.93  mycroft 			bp->b_error = EIO;
    365   1.93  mycroft 			goto bad;
    366   1.93  mycroft 		}
    367    1.1      cgd 		/*
    368   1.64  mycroft 		 * Do bounds checking, adjust transfer. if error, process.
    369   1.64  mycroft 		 * If end of partition, just return.
    370    1.1      cgd 		 */
    371   1.93  mycroft 		if (bounds_check_with_label(bp, &wd->sc_dk.dk_label,
    372   1.93  mycroft 		    (wd->sc_flags & WDF_WLABEL) != 0) <= 0)
    373    1.1      cgd 			goto done;
    374   1.64  mycroft 		/* Otherwise, process transfer request. */
    375    1.1      cgd 	}
    376    1.3  deraadt 
    377   1.64  mycroft 	/* Don't bother doing rotational optimization. */
    378   1.38  mycroft 	bp->b_cylin = 0;
    379   1.38  mycroft 
    380   1.64  mycroft 	/* Queue transfer on drive, activate drive and controller if idle. */
    381    1.1      cgd 	s = splbio();
    382   1.78  mycroft 	wddisksort(&wd->sc_q, bp);
    383   1.78  mycroft 	if (!wd->sc_q.b_active)
    384   1.64  mycroft 		wdstart(wd);		/* Start drive. */
    385   1.78  mycroft #ifdef DIAGNOSTIC
    386   1.80  mycroft 	else {
    387   1.80  mycroft 		struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
    388   1.80  mycroft 		if ((wdc->sc_flags & WDCF_ACTIVE) == 0) {
    389   1.80  mycroft 			printf("wdstrategy: controller inactive\n");
    390   1.80  mycroft 			wdcstart(wdc);
    391   1.80  mycroft 		}
    392   1.78  mycroft 	}
    393   1.78  mycroft #endif
    394    1.1      cgd 	splx(s);
    395   1.64  mycroft 	return;
    396    1.3  deraadt 
    397   1.93  mycroft bad:
    398   1.93  mycroft 	bp->b_flags |= B_ERROR;
    399    1.1      cgd done:
    400   1.64  mycroft 	/* Toss transfer; we're done early. */
    401    1.1      cgd 	biodone(bp);
    402    1.1      cgd }
    403    1.1      cgd 
    404    1.1      cgd /*
    405   1.49  mycroft  * Need to skip over multitransfer bufs.
    406   1.49  mycroft  */
    407   1.49  mycroft void
    408   1.55  mycroft wddisksort(dp, bp)
    409   1.55  mycroft 	struct buf *dp, *bp;
    410   1.49  mycroft {
    411   1.55  mycroft 	struct buf *ap;
    412   1.49  mycroft 
    413   1.49  mycroft 	while ((ap = dp->b_actf) && ap->b_flags & B_XXX)
    414   1.49  mycroft 		dp = ap;
    415   1.49  mycroft 	disksort(dp, bp);
    416   1.49  mycroft }
    417   1.49  mycroft 
    418   1.49  mycroft /*
    419   1.64  mycroft  * Routine to queue a command to the controller.  The unit's request is linked
    420   1.64  mycroft  * into the active list for the controller.  If the controller is idle, the
    421   1.64  mycroft  * transfer is started.
    422    1.1      cgd  */
    423    1.1      cgd static void
    424   1.64  mycroft wdstart(wd)
    425   1.64  mycroft 	struct wd_softc *wd;
    426    1.1      cgd {
    427   1.78  mycroft 	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
    428   1.78  mycroft 	int active = wdc->sc_drives.tqh_first != 0;
    429   1.64  mycroft 
    430   1.64  mycroft 	/* Link onto controller queue. */
    431   1.78  mycroft 	wd->sc_q.b_active = 1;
    432   1.78  mycroft 	TAILQ_INSERT_TAIL(&wdc->sc_drives, wd, sc_drivechain);
    433    1.3  deraadt 
    434   1.78  mycroft 	/* If controller not already active, start it. */
    435   1.78  mycroft 	if (!active)
    436   1.78  mycroft 		wdcstart(wdc);
    437    1.1      cgd }
    438    1.1      cgd 
    439   1.64  mycroft void
    440   1.64  mycroft wdfinish(wd, bp)
    441   1.64  mycroft 	struct wd_softc *wd;
    442   1.64  mycroft 	struct buf *bp;
    443   1.64  mycroft {
    444   1.64  mycroft 	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
    445   1.64  mycroft 
    446   1.64  mycroft #ifdef INSTRUMENT
    447   1.95  mycroft 	dk_busy &= ~(1 << wd->sc_dev.dv_unit);
    448   1.64  mycroft #endif
    449   1.69  mycroft 	wdc->sc_flags &= ~(WDCF_SINGLE | WDCF_ERROR);
    450   1.78  mycroft 	wdc->sc_errors = 0;
    451   1.64  mycroft 	/*
    452   1.64  mycroft 	 * If this is the only buf or the last buf in the transfer (taking into
    453   1.64  mycroft 	 * account any residual, in case we erred)...
    454   1.64  mycroft 	 */
    455   1.64  mycroft 	wd->sc_mbcount -= wd->sc_bcount;
    456   1.64  mycroft 	if (wd->sc_mbcount == 0) {
    457   1.78  mycroft 		wd->sc_mskip = 0;
    458   1.64  mycroft 		/*
    459   1.64  mycroft 		 * ...then move this drive to the end of the queue to give
    460   1.64  mycroft 		 * others a `fair' chance.
    461   1.64  mycroft 		 */
    462   1.78  mycroft 		if (wd->sc_drivechain.tqe_next) {
    463   1.78  mycroft 			TAILQ_REMOVE(&wdc->sc_drives, wd, sc_drivechain);
    464   1.78  mycroft 			if (bp->b_actf) {
    465   1.78  mycroft 				TAILQ_INSERT_TAIL(&wdc->sc_drives, wd,
    466   1.78  mycroft 				    sc_drivechain);
    467   1.78  mycroft 			} else
    468   1.78  mycroft 				wd->sc_q.b_active = 0;
    469   1.78  mycroft 		}
    470   1.64  mycroft 	}
    471   1.64  mycroft 	bp->b_resid = wd->sc_bcount;
    472   1.64  mycroft 	bp->b_flags &= ~B_XXX;
    473   1.64  mycroft 	wd->sc_skip = 0;
    474   1.64  mycroft 	wd->sc_q.b_actf = bp->b_actf;
    475   1.64  mycroft 	biodone(bp);
    476   1.64  mycroft }
    477   1.64  mycroft 
    478    1.1      cgd /*
    479   1.64  mycroft  * Controller startup routine.  This does the calculation, and starts a
    480   1.64  mycroft  * single-sector read or write operation.  Called to start a transfer, or from
    481   1.64  mycroft  * the interrupt routine to continue a multi-sector transfer.
    482    1.1      cgd  * RESTRICTIONS:
    483    1.1      cgd  * 1.	The transfer length must be an exact multiple of the sector size.
    484    1.1      cgd  */
    485    1.1      cgd static void
    486   1.64  mycroft wdcstart(wdc)
    487   1.64  mycroft 	struct wdc_softc *wdc;
    488    1.1      cgd {
    489   1.64  mycroft 	struct wd_softc *wd;	/* disk unit for IO */
    490   1.64  mycroft 	struct buf *bp;
    491   1.64  mycroft 
    492    1.1      cgd loop:
    493   1.64  mycroft 	/* Is there a drive for the controller to do a transfer with? */
    494   1.78  mycroft 	wd = wdc->sc_drives.tqh_first;
    495   1.78  mycroft 	if (wd == NULL)
    496    1.1      cgd 		return;
    497    1.3  deraadt 
    498   1.64  mycroft 	/* Is there a transfer to this drive?  If not, deactivate drive. */
    499   1.78  mycroft 	bp = wd->sc_q.b_actf;
    500    1.1      cgd 	if (bp == NULL) {
    501   1.78  mycroft 		TAILQ_REMOVE(&wdc->sc_drives, wd, sc_drivechain);
    502   1.78  mycroft 		wd->sc_q.b_active = 0;
    503    1.1      cgd 		goto loop;
    504    1.1      cgd 	}
    505    1.3  deraadt 
    506   1.78  mycroft 	if (wdc->sc_errors >= WDIORETRIES) {
    507   1.64  mycroft 		wderror(wd, bp, "hard error");
    508   1.64  mycroft 		bp->b_error = EIO;
    509   1.64  mycroft 		bp->b_flags |= B_ERROR;
    510   1.64  mycroft 		wdfinish(wd, bp);
    511   1.64  mycroft 		goto loop;
    512   1.64  mycroft 	}
    513   1.78  mycroft 
    514   1.78  mycroft 	/* Mark the controller active and set a timeout. */
    515   1.99  mycroft 	if (wdc->sc_flags & WDCF_ACTIVE)
    516   1.99  mycroft 		untimeout(wdctimeout, wdc);
    517   1.99  mycroft 	else
    518   1.99  mycroft 		wdc->sc_flags |= WDCF_ACTIVE;
    519   1.98  mycroft 	timeout(wdctimeout, wdc, WAITTIME);
    520   1.69  mycroft 
    521   1.69  mycroft 	/* Do control operations specially. */
    522   1.64  mycroft 	if (wd->sc_state < OPEN) {
    523   1.69  mycroft 		/*
    524   1.69  mycroft 		 * Actually, we want to be careful not to mess with the control
    525   1.69  mycroft 		 * state if the device is currently busy, but we can assume
    526   1.69  mycroft 		 * that we never get to this point if that's the case.
    527   1.69  mycroft 		 */
    528   1.69  mycroft 		(void) wdcontrol(wd);
    529    1.1      cgd 		return;
    530    1.1      cgd 	}
    531   1.64  mycroft 
    532   1.64  mycroft 	/*
    533   1.76  mycroft 	 * WDCF_ERROR is set by wdcunwedge() and wdcintr() when an error is
    534   1.69  mycroft 	 * encountered.  If we are in multi-sector mode, then we switch to
    535   1.69  mycroft 	 * single-sector mode and retry the operation from the start.
    536   1.64  mycroft 	 */
    537   1.69  mycroft 	if (wdc->sc_flags & WDCF_ERROR) {
    538   1.69  mycroft 		wdc->sc_flags &= ~WDCF_ERROR;
    539   1.69  mycroft 		if ((wdc->sc_flags & WDCF_SINGLE) == 0) {
    540   1.69  mycroft 			wdc->sc_flags |= WDCF_SINGLE;
    541   1.95  mycroft 			wd->sc_skip = wd->sc_mskip = 0;
    542   1.69  mycroft 		}
    543   1.64  mycroft 	}
    544   1.64  mycroft 
    545   1.95  mycroft 	if (wd->sc_skip == 0) {
    546   1.44  mycroft #ifdef WDDEBUG
    547   1.95  mycroft 		printf("\n%s: wdcstart %s %d@%d; map ", wd->sc_dev.dv_xname,
    548   1.37  mycroft 		    (bp->b_flags & B_READ) ? "read" : "write", bp->b_bcount,
    549   1.95  mycroft 		    bp->b_blkno);
    550   1.95  mycroft #endif
    551   1.95  mycroft 		wd->sc_bcount = bp->b_bcount;
    552   1.95  mycroft #ifdef INSTRUMENT
    553   1.95  mycroft 		dk_busy |= (1 << wd->sc_dev.dv_unit);
    554   1.95  mycroft 		dk_wds[wd->sc_dev.dv_unit] += bp->b_bcount >> 6;
    555   1.95  mycroft #endif
    556   1.95  mycroft 	} else {
    557   1.95  mycroft #ifdef WDDEBUG
    558   1.64  mycroft 		printf(" %d)%x", wd->sc_skip, inb(wd->sc_iobase+wd_altsts));
    559    1.1      cgd #endif
    560   1.95  mycroft 	}
    561   1.95  mycroft 
    562   1.64  mycroft 	if (wd->sc_mskip == 0) {
    563   1.64  mycroft 		wd->sc_mbcount = wd->sc_bcount;
    564   1.95  mycroft 		/* If multi-sector, try to cluster. */
    565   1.95  mycroft 		if ((wdc->sc_flags & WDCF_SINGLE) == 0) {
    566   1.95  mycroft 			struct buf *oldbp, *nextbp;
    567   1.95  mycroft 			oldbp = bp;
    568   1.95  mycroft 			nextbp = bp->b_actf;
    569   1.95  mycroft 			oldbp->b_flags |= B_XXX;
    570   1.95  mycroft 			while (nextbp && oldbp->b_dev == nextbp->b_dev &&
    571   1.95  mycroft 			    nextbp->b_blkno ==
    572   1.95  mycroft 			    (oldbp->b_blkno + (oldbp->b_bcount / wd->sc_dk.dk_label.d_secsize)) &&
    573   1.95  mycroft 			    (oldbp->b_flags & B_READ) == (nextbp->b_flags & B_READ)) {
    574   1.95  mycroft 				if ((wd->sc_mbcount + nextbp->b_bcount) / wd->sc_dk.dk_label.d_secsize >= 240)
    575   1.95  mycroft 					break;
    576   1.95  mycroft 				wd->sc_mbcount += nextbp->b_bcount;
    577   1.95  mycroft 				nextbp->b_flags |= B_XXX;
    578   1.95  mycroft 				oldbp = nextbp;
    579   1.95  mycroft 				nextbp = nextbp->b_actf;
    580   1.95  mycroft 			}
    581    1.3  deraadt 		}
    582    1.3  deraadt 	}
    583    1.3  deraadt 
    584   1.95  mycroft 	/* If starting a multisector transfer, or doing single transfers. */
    585   1.95  mycroft 	if (wd->sc_mskip == 0 || (wdc->sc_flags & WDCF_SINGLE)) {
    586   1.95  mycroft 		struct disklabel *lp;
    587   1.95  mycroft 		long blkno, nblks;
    588   1.95  mycroft 		long cylin, head, sector;
    589   1.95  mycroft 		int command;
    590   1.95  mycroft 
    591   1.95  mycroft 		lp = &wd->sc_dk.dk_label;
    592   1.95  mycroft 		blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE) + wd->sc_skip;
    593   1.95  mycroft 		if (WDPART(bp->b_dev) != RAW_PART)
    594   1.95  mycroft 			blkno += lp->d_partitions[WDPART(bp->b_dev)].p_offset;
    595   1.95  mycroft 		if (wdc->sc_flags & WDCF_SINGLE)
    596   1.95  mycroft 			nblks = 1;
    597   1.95  mycroft 		else
    598   1.95  mycroft 			nblks = howmany(wd->sc_mbcount, lp->d_secsize);
    599   1.95  mycroft 
    600   1.95  mycroft 		/*
    601   1.95  mycroft 		 * Check for bad sectors if we have them, and not formatting.  Only do
    602   1.95  mycroft 		 * this in single-sector mode, or when starting a multiple-sector
    603   1.95  mycroft 		 * transfer.
    604   1.95  mycroft 		 */
    605   1.95  mycroft 		if ((wd->sc_flags & WDF_BADSECT)
    606   1.44  mycroft #ifdef B_FORMAT
    607   1.95  mycroft 		    && (bp->b_flags & B_FORMAT) == 0
    608    1.3  deraadt #endif
    609   1.95  mycroft 		    ) {
    610   1.95  mycroft 			long blkdiff;
    611   1.95  mycroft 			int i;
    612   1.95  mycroft 
    613   1.95  mycroft 			for (i = 0; (blkdiff = wd->sc_badsect[i]) != -1; i++) {
    614   1.95  mycroft 				blkdiff -= blkno;
    615   1.95  mycroft 				if (blkdiff < 0)
    616   1.95  mycroft 					continue;
    617   1.95  mycroft 				if (blkdiff >= nblks)
    618   1.95  mycroft 					break;
    619   1.95  mycroft 				if (blkdiff == 0) {
    620   1.95  mycroft 					/* Replace current block of transfer. */
    621   1.95  mycroft 					blkno =
    622   1.95  mycroft 					    lp->d_secperunit - lp->d_nsectors - i - 1;
    623   1.95  mycroft 					if (wdc->sc_flags & WDCF_SINGLE)
    624   1.95  mycroft 						break;
    625   1.95  mycroft 				} else {
    626   1.95  mycroft 					/* If clustered, try unclustering. */
    627   1.95  mycroft 					if (wd->sc_mbcount > wd->sc_bcount) {
    628   1.95  mycroft 						nblks = howmany(wd->sc_bcount, lp->d_secsize);
    629   1.95  mycroft 						if (blkdiff >= nblks) {
    630   1.95  mycroft 							/* Unclustering was enough. */
    631   1.95  mycroft 							wd->sc_mbcount = wd->sc_bcount;
    632   1.95  mycroft 							break;
    633   1.95  mycroft 						}
    634   1.95  mycroft 					}
    635   1.95  mycroft 					/* Bad block inside transfer. */
    636   1.95  mycroft 				}
    637   1.95  mycroft 				/* Force single-sector mode. */
    638   1.95  mycroft 				wd->sc_mbcount = wd->sc_bcount;
    639   1.69  mycroft 				wdc->sc_flags |= WDCF_SINGLE;
    640   1.95  mycroft 				nblks = 1;
    641    1.3  deraadt 			}
    642   1.95  mycroft 			/* Tranfer is okay now. */
    643    1.3  deraadt 		}
    644    1.1      cgd 
    645   1.95  mycroft 		cylin = blkno / lp->d_secpercyl;
    646   1.95  mycroft 		head = (blkno % lp->d_secpercyl) / lp->d_nsectors;
    647   1.95  mycroft 		sector = blkno % lp->d_nsectors;
    648   1.95  mycroft 		sector++;	/* Sectors begin with 1, not 0. */
    649   1.51  mycroft 
    650   1.64  mycroft #ifdef INSTRUMENT
    651   1.74  mycroft 		++dk_seek[wd->sc_dev.dv_unit];
    652   1.74  mycroft 		++dk_xfer[wd->sc_dev.dv_unit];
    653   1.64  mycroft #endif
    654    1.1      cgd 
    655   1.37  mycroft #ifdef B_FORMAT
    656    1.1      cgd 		if (bp->b_flags & B_FORMAT) {
    657   1.60  mycroft 			sector = lp->d_gap3;
    658   1.95  mycroft 			nblks = lp->d_nsectors;
    659   1.60  mycroft 			command = WDCC_FORMAT;
    660   1.95  mycroft 		} else
    661   1.95  mycroft #endif
    662   1.60  mycroft 			command =
    663   1.60  mycroft 			    (bp->b_flags & B_READ) ? WDCC_READ : WDCC_WRITE;
    664    1.3  deraadt 
    665   1.64  mycroft 		/* Initiate command! */
    666   1.95  mycroft 		if (wdcommand(wd, cylin, head, sector, nblks, command) != 0) {
    667   1.64  mycroft 			wderror(wd, NULL,
    668   1.64  mycroft 			    "wdcstart: timeout waiting for unbusy");
    669   1.64  mycroft 			wdcunwedge(wdc);
    670   1.64  mycroft 			return;
    671   1.51  mycroft 		}
    672   1.44  mycroft #ifdef WDDEBUG
    673   1.37  mycroft 		printf("sector %d cylin %d head %d addr %x sts %x\n", sector,
    674   1.84  mycroft 		    cylin, head, bp->b_data, inb(wd->sc_iobase+wd_altsts));
    675    1.1      cgd #endif
    676    1.1      cgd 	}
    677   1.78  mycroft 
    678   1.64  mycroft 	/* If this is a read operation, just go away until it's done. */
    679   1.60  mycroft 	if (bp->b_flags & B_READ)
    680    1.3  deraadt 		return;
    681    1.3  deraadt 
    682   1.64  mycroft 	if (wait_for_drq(wdc) < 0) {
    683   1.64  mycroft 		wderror(wd, NULL, "wdcstart: timeout waiting for drq");
    684   1.64  mycroft 		wdcunwedge(wdc);
    685   1.64  mycroft 		return;
    686   1.19  deraadt 	}
    687   1.60  mycroft 
    688   1.64  mycroft 	/* Then send it! */
    689   1.84  mycroft 	outsw(wdc->sc_iobase+wd_data, bp->b_data + wd->sc_skip * DEV_BSIZE,
    690   1.44  mycroft 	    DEV_BSIZE / sizeof(short));
    691    1.1      cgd }
    692    1.1      cgd 
    693   1.64  mycroft /*
    694   1.64  mycroft  * Interrupt routine for the controller.  Acknowledge the interrupt, check for
    695   1.64  mycroft  * errors on the current operation, mark it done if necessary, and start the
    696   1.64  mycroft  * next request.  Also check for a partially done transfer, and continue with
    697   1.64  mycroft  * the next chunk if so.
    698    1.1      cgd  */
    699   1.64  mycroft int
    700  1.103  mycroft wdcintr(wdc)
    701  1.103  mycroft 	struct wdc_softc *wdc;
    702    1.1      cgd {
    703   1.64  mycroft 	struct wd_softc *wd;
    704   1.64  mycroft 	struct buf *bp;
    705   1.59  mycroft 
    706   1.87  mycroft 	if ((wdc->sc_flags & WDCF_ACTIVE) == 0) {
    707   1.87  mycroft 		/* Clear the pending interrupt. */
    708   1.87  mycroft 		(void) inb(wdc->sc_iobase+wd_status);
    709   1.64  mycroft 		return 0;
    710   1.87  mycroft 	}
    711   1.78  mycroft 
    712   1.78  mycroft 	wd = wdc->sc_drives.tqh_first;
    713   1.78  mycroft 	bp = wd->sc_q.b_actf;
    714   1.78  mycroft 
    715   1.44  mycroft #ifdef WDDEBUG
    716    1.3  deraadt 	printf("I%d ", ctrlr);
    717    1.1      cgd #endif
    718   1.13  deraadt 
    719   1.64  mycroft 	if (wait_for_unbusy(wdc) < 0) {
    720   1.76  mycroft 		wderror(wd, NULL, "wdcintr: timeout waiting for unbusy");
    721   1.64  mycroft 		wdc->sc_status |= WDCS_ERR;	/* XXX */
    722   1.27      cgd 	}
    723    1.3  deraadt 
    724   1.64  mycroft 	/* Is it not a transfer, but a control operation? */
    725   1.64  mycroft 	if (wd->sc_state < OPEN) {
    726   1.69  mycroft 		if (wdcontrol(wd))
    727   1.64  mycroft 			wdcstart(wdc);
    728   1.64  mycroft 		return 1;
    729    1.1      cgd 	}
    730   1.78  mycroft 
    731   1.78  mycroft 	wdc->sc_flags &= ~WDCF_ACTIVE;
    732   1.98  mycroft 	untimeout(wdctimeout, wdc);
    733    1.3  deraadt 
    734   1.64  mycroft 	/* Have we an error? */
    735   1.96  mycroft 	if (wdc->sc_status & WDCS_ERR) {
    736   1.51  mycroft 	lose:
    737   1.44  mycroft #ifdef WDDEBUG
    738   1.76  mycroft 		wderror(wd, NULL, "wdcintr");
    739    1.1      cgd #endif
    740   1.69  mycroft 		if ((wdc->sc_flags & WDCF_SINGLE) == 0) {
    741   1.69  mycroft 			wdc->sc_flags |= WDCF_ERROR;
    742   1.64  mycroft 			goto restart;
    743    1.1      cgd 		}
    744   1.96  mycroft 
    745    1.1      cgd #ifdef B_FORMAT
    746   1.96  mycroft 		if (bp->b_flags & B_FORMAT)
    747   1.96  mycroft 			goto bad;
    748    1.1      cgd #endif
    749    1.3  deraadt 
    750   1.96  mycroft 		if (++wdc->sc_errors < WDIORETRIES)
    751   1.96  mycroft 			goto restart;
    752   1.96  mycroft 		wderror(wd, bp, "hard error");
    753   1.96  mycroft 
    754   1.96  mycroft 	bad:
    755   1.96  mycroft 		bp->b_error = EIO;
    756   1.96  mycroft 		bp->b_flags |= B_ERROR;
    757   1.96  mycroft 		goto done;
    758    1.1      cgd 	}
    759   1.96  mycroft 
    760   1.96  mycroft 	if (wdc->sc_status & WDCS_ECCCOR)
    761   1.96  mycroft 		wderror(wd, bp, "soft ecc");
    762    1.3  deraadt 
    763   1.64  mycroft 	/* If this was a read, fetch the data. */
    764   1.64  mycroft 	if (bp->b_flags & B_READ) {
    765   1.64  mycroft 		/* Ready to receive data? */
    766   1.87  mycroft 		if ((wdc->sc_status & (WDCS_READY | WDCS_SEEKCMPLT | WDCS_DRQ))
    767   1.87  mycroft 		    != (WDCS_READY | WDCS_SEEKCMPLT | WDCS_DRQ)) {
    768   1.87  mycroft 			wderror(wd, NULL, "wdcintr: read intr before drq");
    769   1.64  mycroft 			wdcunwedge(wdc);
    770   1.64  mycroft 			return 1;
    771   1.27      cgd 		}
    772   1.27      cgd 
    773   1.64  mycroft 		/* Suck in data. */
    774   1.64  mycroft 		insw(wdc->sc_iobase+wd_data,
    775   1.84  mycroft 		    bp->b_data + wd->sc_skip * DEV_BSIZE,
    776   1.64  mycroft 		    DEV_BSIZE / sizeof(short));
    777   1.64  mycroft 	}
    778   1.64  mycroft 
    779   1.64  mycroft 	/* If we encountered any abnormalities, flag it as a soft error. */
    780   1.78  mycroft 	if (wdc->sc_errors) {
    781   1.64  mycroft 		wderror(wd, bp, "soft error");
    782   1.78  mycroft 		wdc->sc_errors = 0;
    783    1.1      cgd 	}
    784    1.3  deraadt 
    785   1.64  mycroft 	/* Ready for the next block, if any. */
    786   1.64  mycroft 	wd->sc_skip++;
    787   1.64  mycroft 	wd->sc_mskip++;
    788   1.64  mycroft 	wd->sc_bcount -= DEV_BSIZE;
    789   1.64  mycroft 	wd->sc_mbcount -= DEV_BSIZE;
    790   1.64  mycroft 
    791   1.64  mycroft 	/* See if more to transfer. */
    792   1.64  mycroft 	if (wd->sc_bcount > 0)
    793   1.64  mycroft 		goto restart;
    794   1.64  mycroft 
    795   1.64  mycroft done:
    796   1.64  mycroft 	/* Done with this transfer, with or without error. */
    797   1.64  mycroft 	wdfinish(wd, bp);
    798   1.64  mycroft 
    799   1.64  mycroft restart:
    800   1.64  mycroft 	/* Start the next transfer, if any. */
    801   1.64  mycroft 	wdcstart(wdc);
    802    1.1      cgd 
    803   1.64  mycroft 	return 1;
    804    1.1      cgd }
    805    1.1      cgd 
    806    1.1      cgd /*
    807    1.1      cgd  * Initialize a drive.
    808    1.1      cgd  */
    809    1.1      cgd int
    810   1.55  mycroft wdopen(dev, flag, fmt, p)
    811   1.55  mycroft 	dev_t dev;
    812   1.93  mycroft 	int flag, fmt;
    813   1.55  mycroft 	struct proc *p;
    814    1.1      cgd {
    815   1.54  mycroft 	int lunit;
    816   1.64  mycroft 	struct wd_softc *wd;
    817   1.93  mycroft 	int part = WDPART(dev);
    818    1.3  deraadt 	struct partition *pp;
    819    1.1      cgd 	char *msg;
    820   1.93  mycroft 	int error;
    821    1.3  deraadt 
    822   1.51  mycroft 	lunit = WDUNIT(dev);
    823   1.74  mycroft 	if (lunit >= wdcd.cd_ndevs)
    824   1.37  mycroft 		return ENXIO;
    825   1.74  mycroft 	wd = wdcd.cd_devs[lunit];
    826   1.64  mycroft 	if (wd == 0)
    827   1.37  mycroft 		return ENXIO;
    828    1.3  deraadt 
    829   1.64  mycroft 	if ((wd->sc_flags & WDF_BSDLABEL) == 0) {
    830   1.64  mycroft 		wd->sc_flags |= WDF_WRITEPROT;
    831   1.64  mycroft 		wd->sc_q.b_actf = NULL;
    832    1.1      cgd 
    833    1.1      cgd 		/*
    834   1.64  mycroft 		 * Use the default sizes until we've read the label, or longer
    835   1.64  mycroft 		 * if there isn't one there.
    836    1.1      cgd 		 */
    837   1.93  mycroft 		bzero(&wd->sc_dk.dk_label, sizeof(wd->sc_dk.dk_label));
    838   1.93  mycroft 		wd->sc_dk.dk_label.d_type = DTYPE_ST506;
    839   1.93  mycroft 		wd->sc_dk.dk_label.d_ncylinders = 1024;
    840   1.93  mycroft 		wd->sc_dk.dk_label.d_secsize = DEV_BSIZE;
    841   1.93  mycroft 		wd->sc_dk.dk_label.d_ntracks = 8;
    842   1.93  mycroft 		wd->sc_dk.dk_label.d_nsectors = 17;
    843   1.93  mycroft 		wd->sc_dk.dk_label.d_secpercyl = 17*8;
    844   1.93  mycroft 		wd->sc_dk.dk_label.d_secperunit = 17*8*1024;
    845   1.69  mycroft 		wd->sc_state = RECAL;
    846    1.1      cgd 
    847   1.64  mycroft 		/* Read label using "raw" partition. */
    848   1.93  mycroft 		msg = readdisklabel(WDLABELDEV(dev), wdstrategy,
    849   1.93  mycroft 		    &wd->sc_dk.dk_label, &wd->sc_dk.dk_cpulabel);
    850   1.72  mycroft 		if (msg) {
    851   1.72  mycroft 			/*
    852   1.72  mycroft 			 * This probably happened because the drive's default
    853   1.72  mycroft 			 * geometry doesn't match the DOS geometry.  We
    854   1.72  mycroft 			 * assume the DOS geometry is now in the label and try
    855   1.72  mycroft 			 * again.  XXX This is a kluge.
    856   1.72  mycroft 			 */
    857   1.72  mycroft 			if (wd->sc_state > GEOMETRY)
    858   1.72  mycroft 				wd->sc_state = GEOMETRY;
    859   1.86  mycroft 			msg = readdisklabel(WDLABELDEV(dev), wdstrategy,
    860   1.93  mycroft 			    &wd->sc_dk.dk_label, &wd->sc_dk.dk_cpulabel);
    861   1.72  mycroft 		}
    862   1.72  mycroft 		if (msg) {
    863   1.64  mycroft 			log(LOG_WARNING, "%s: cannot find label (%s)\n",
    864   1.64  mycroft 			    wd->sc_dev.dv_xname, msg);
    865   1.86  mycroft 			if (part != RAW_PART)
    866   1.46  mycroft 				return EINVAL;	/* XXX needs translation */
    867    1.1      cgd 		} else {
    868   1.69  mycroft 			if (wd->sc_state > GEOMETRY)
    869   1.69  mycroft 				wd->sc_state = GEOMETRY;
    870   1.64  mycroft 			wd->sc_flags |= WDF_BSDLABEL;
    871   1.64  mycroft 			wd->sc_flags &= ~WDF_WRITEPROT;
    872   1.93  mycroft 			if (wd->sc_dk.dk_label.d_flags & D_BADSECT)
    873   1.64  mycroft 				wd->sc_flags |= WDF_BADSECT;
    874    1.1      cgd 		}
    875    1.3  deraadt 	}
    876    1.3  deraadt 
    877   1.64  mycroft 	if (wd->sc_flags & WDF_BADSECT)
    878   1.64  mycroft 		bad144intern(wd);
    879    1.1      cgd 
    880    1.3  deraadt 	/*
    881   1.60  mycroft 	 * Warn if a partition is opened that overlaps another partition which
    882   1.60  mycroft 	 * is open unless one is the "raw" partition (whole disk).
    883    1.3  deraadt 	 */
    884   1.94  mycroft 	if ((wd->sc_dk.dk_openmask & (1 << part)) == 0 && part != RAW_PART) {
    885   1.46  mycroft 		int start, end;
    886    1.3  deraadt 
    887   1.93  mycroft 		pp = &wd->sc_dk.dk_label.d_partitions[part];
    888    1.3  deraadt 		start = pp->p_offset;
    889    1.3  deraadt 		end = pp->p_offset + pp->p_size;
    890   1.93  mycroft 		for (pp = wd->sc_dk.dk_label.d_partitions;
    891   1.93  mycroft 		    pp < &wd->sc_dk.dk_label.d_partitions[wd->sc_dk.dk_label.d_npartitions];
    892   1.44  mycroft 		    pp++) {
    893   1.44  mycroft 			if (pp->p_offset + pp->p_size <= start ||
    894   1.44  mycroft 			    pp->p_offset >= end)
    895    1.3  deraadt 				continue;
    896   1.93  mycroft 			if (pp - wd->sc_dk.dk_label.d_partitions == RAW_PART)
    897    1.3  deraadt 				continue;
    898   1.94  mycroft 			if (wd->sc_dk.dk_openmask & (1 << (pp - wd->sc_dk.dk_label.d_partitions)))
    899    1.3  deraadt 				log(LOG_WARNING,
    900   1.64  mycroft 				    "%s%c: overlaps open partition (%c)\n",
    901   1.64  mycroft 				    wd->sc_dev.dv_xname, part + 'a',
    902   1.93  mycroft 				    pp - wd->sc_dk.dk_label.d_partitions + 'a');
    903    1.3  deraadt 		}
    904    1.1      cgd 	}
    905   1.93  mycroft 	if (part != RAW_PART &&
    906   1.93  mycroft 	    (part >= wd->sc_dk.dk_label.d_npartitions ||
    907   1.93  mycroft 	     wd->sc_dk.dk_label.d_partitions[part].p_fstype == FS_UNUSED)) {
    908   1.93  mycroft 		error = ENXIO;
    909   1.93  mycroft 		goto bad;
    910   1.93  mycroft 	}
    911    1.3  deraadt 
    912   1.64  mycroft 	/* Insure only one open at a time. */
    913    1.3  deraadt 	switch (fmt) {
    914    1.3  deraadt 	case S_IFCHR:
    915   1.94  mycroft 		wd->sc_dk.dk_copenmask |= (1 << part);
    916    1.3  deraadt 		break;
    917    1.3  deraadt 	case S_IFBLK:
    918   1.94  mycroft 		wd->sc_dk.dk_bopenmask |= (1 << part);
    919    1.3  deraadt 		break;
    920    1.3  deraadt 	}
    921   1.94  mycroft 	wd->sc_dk.dk_openmask = wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
    922   1.60  mycroft 
    923   1.37  mycroft 	return 0;
    924   1.93  mycroft 
    925   1.93  mycroft bad:
    926   1.93  mycroft 	return error;
    927    1.1      cgd }
    928    1.1      cgd 
    929    1.1      cgd /*
    930    1.1      cgd  * Implement operations other than read/write.
    931   1.76  mycroft  * Called from wdcstart or wdcintr during opens and formats.
    932    1.1      cgd  * Uses finite-state-machine to track progress of operation in progress.
    933    1.1      cgd  * Returns 0 if operation still in progress, 1 if completed.
    934    1.1      cgd  */
    935    1.1      cgd static int
    936   1.69  mycroft wdcontrol(wd)
    937   1.69  mycroft 	struct wd_softc *wd;
    938    1.1      cgd {
    939   1.64  mycroft 	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
    940    1.3  deraadt 
    941   1.64  mycroft 	switch (wd->sc_state) {
    942   1.69  mycroft 	case RECAL:			/* Set SDH, step rate, do restore. */
    943   1.64  mycroft 		if (wdcommand(wd, 0, 0, 0, 0, WDCC_RESTORE | WD_STEP) != 0) {
    944   1.64  mycroft 			wderror(wd, NULL, "wdcontrol: wdcommand failed");
    945   1.64  mycroft 			wdcunwedge(wdc);
    946   1.64  mycroft 			return 0;
    947   1.21  deraadt 		}
    948   1.69  mycroft 		wd->sc_state = RECAL_WAIT;
    949   1.37  mycroft 		return 0;
    950   1.55  mycroft 
    951   1.69  mycroft 	case RECAL_WAIT:
    952   1.69  mycroft 		if (wdc->sc_status & WDCS_ERR) {
    953   1.64  mycroft 			wderror(wd, NULL, "wdcontrol: recal failed");
    954   1.64  mycroft 			wdcunwedge(wdc);
    955   1.64  mycroft 			return 0;
    956    1.1      cgd 		}
    957   1.69  mycroft 		/* fall through */
    958   1.69  mycroft 	case GEOMETRY:
    959   1.69  mycroft 		if (wdsetctlr(wd) != 0) {
    960   1.69  mycroft 			/* Already printed a message. */
    961   1.69  mycroft 			wdcunwedge(wdc);
    962   1.69  mycroft 			return 0;
    963   1.69  mycroft 		}
    964   1.69  mycroft 		wd->sc_state = GEOMETRY_WAIT;
    965   1.69  mycroft 		return 0;
    966   1.69  mycroft 
    967   1.69  mycroft 	case GEOMETRY_WAIT:
    968   1.69  mycroft 		if (wdc->sc_status & WDCS_ERR) {
    969   1.69  mycroft 			wderror(wd, NULL, "wdcontrol: geometry failed");
    970   1.69  mycroft 			wdcunwedge(wdc);
    971   1.69  mycroft 			return 0;
    972   1.69  mycroft 		}
    973   1.69  mycroft 
    974   1.78  mycroft 		wdc->sc_errors = 0;
    975   1.64  mycroft 		wd->sc_state = OPEN;
    976    1.1      cgd 		/*
    977   1.63  mycroft 		 * The rest of the initialization can be done by normal means.
    978    1.1      cgd 		 */
    979   1.37  mycroft 		return 1;
    980    1.1      cgd 	}
    981    1.1      cgd 
    982   1.60  mycroft #ifdef DIAGNOSTIC
    983   1.60  mycroft 	panic("wdcontrol: impossible");
    984   1.60  mycroft #endif
    985    1.1      cgd }
    986    1.1      cgd 
    987    1.1      cgd /*
    988   1.64  mycroft  * Send a command and wait uninterruptibly until controller is finished.
    989   1.64  mycroft  * Return -1 if controller busy for too long, otherwise return non-zero if
    990   1.64  mycroft  * error.  Intended for brief controller commands at critical points.
    991   1.64  mycroft  * Assumes interrupts are blocked.
    992    1.1      cgd  */
    993    1.1      cgd static int
    994   1.64  mycroft wdcommand(wd, cylin, head, sector, count, cmd)
    995   1.64  mycroft 	struct wd_softc *wd;
    996   1.60  mycroft 	int cylin, head, sector, count;
    997   1.55  mycroft 	int cmd;
    998    1.3  deraadt {
    999   1.64  mycroft 	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
   1000   1.60  mycroft 	int stat;
   1001   1.64  mycroft 	u_short iobase;
   1002    1.3  deraadt 
   1003   1.64  mycroft 	/* Select drive. */
   1004   1.64  mycroft 	iobase = wdc->sc_iobase;
   1005   1.74  mycroft 	outb(iobase+wd_sdh, WDSD_IBM | (wd->sc_drive << 4) | head);
   1006   1.90  mycroft 
   1007   1.90  mycroft 	/* Wait for it to become ready to accept a command. */
   1008   1.60  mycroft 	if (cmd == WDCC_DIAGNOSE || cmd == WDCC_IDC)
   1009   1.64  mycroft 		stat = wait_for_unbusy(wdc);
   1010   1.60  mycroft 	else
   1011   1.64  mycroft 		stat = wdcwait(wdc, WDCS_READY);
   1012   1.60  mycroft 	if (stat < 0)
   1013   1.60  mycroft 		return -1;
   1014    1.3  deraadt 
   1015   1.64  mycroft 	/* Load parameters. */
   1016   1.93  mycroft 	outb(iobase+wd_precomp, wd->sc_dk.dk_label.d_precompcyl / 4);
   1017   1.64  mycroft 	outb(iobase+wd_cyl_lo, cylin);
   1018   1.64  mycroft 	outb(iobase+wd_cyl_hi, cylin >> 8);
   1019   1.64  mycroft 	outb(iobase+wd_sector, sector);
   1020   1.64  mycroft 	outb(iobase+wd_seccnt, count);
   1021   1.60  mycroft 
   1022   1.64  mycroft 	/* Send command, await results. */
   1023   1.64  mycroft 	outb(iobase+wd_command, cmd);
   1024   1.40  mycroft 
   1025   1.64  mycroft 	return 0;
   1026    1.1      cgd }
   1027    1.1      cgd 
   1028    1.1      cgd /*
   1029   1.64  mycroft  * Issue IDC to drive to tell it just what geometry it is to be.
   1030    1.1      cgd  */
   1031    1.1      cgd static int
   1032   1.64  mycroft wdsetctlr(wd)
   1033   1.64  mycroft 	struct wd_softc *wd;
   1034    1.3  deraadt {
   1035   1.64  mycroft 	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
   1036   1.63  mycroft 
   1037   1.44  mycroft #ifdef WDDEBUG
   1038   1.74  mycroft 	printf("wd(%d,%d) C%dH%dS%d\n", wd->sc_ctrlr, wd->sc_drive,
   1039   1.93  mycroft 	    wd->sc_dk.dk_label.d_ncylinders, wd->sc_dk.dk_label.d_ntracks,
   1040   1.93  mycroft 	    wd->sc_dk.dk_label.d_nsectors);
   1041   1.44  mycroft #endif
   1042    1.3  deraadt 
   1043   1.93  mycroft 	if (wdcommand(wd, wd->sc_dk.dk_label.d_ncylinders,
   1044   1.93  mycroft 	    wd->sc_dk.dk_label.d_ntracks - 1, 0, wd->sc_dk.dk_label.d_nsectors,
   1045   1.93  mycroft 	    WDCC_IDC) != 0) {
   1046   1.69  mycroft 		wderror(wd, NULL, "wdsetctlr: wdcommand failed");
   1047   1.51  mycroft 		return -1;
   1048   1.57  mycroft 	}
   1049   1.69  mycroft 
   1050   1.60  mycroft 	return 0;
   1051    1.1      cgd }
   1052    1.1      cgd 
   1053    1.1      cgd /*
   1054   1.64  mycroft  * Issue READP to drive to ask it what it is.
   1055    1.1      cgd  */
   1056    1.1      cgd static int
   1057   1.64  mycroft wdgetctlr(wd)
   1058   1.64  mycroft 	struct wd_softc *wd;
   1059    1.3  deraadt {
   1060   1.64  mycroft 	struct wdc_softc *wdc = (void *)wd->sc_dev.dv_parent;
   1061   1.63  mycroft 	int i;
   1062    1.1      cgd 	char tb[DEV_BSIZE];
   1063    1.1      cgd 	struct wdparams *wp;
   1064    1.3  deraadt 
   1065   1.64  mycroft 	if (wdcommand(wd, 0, 0, 0, 0, WDCC_READP) != 0 ||
   1066   1.64  mycroft 	    wait_for_drq(wdc) != 0) {
   1067   1.60  mycroft 		/*
   1068   1.64  mycroft 		 * If WDCC_READP fails then we might have an old drive so we
   1069   1.64  mycroft 		 * try a seek to 0; if that passes then the drive is there but
   1070   1.64  mycroft 		 * it's OLD AND KRUSTY.
   1071   1.60  mycroft 		 */
   1072   1.64  mycroft 		if (wdcommand(wd, 0, 0, 0, 0, WDCC_RESTORE | WD_STEP) != 0 ||
   1073   1.64  mycroft 		    wait_for_ready(wdc) != 0)
   1074   1.60  mycroft 			return -1;
   1075   1.60  mycroft 
   1076   1.93  mycroft 		strncpy(wd->sc_dk.dk_label.d_typename, "ST506",
   1077   1.93  mycroft 		    sizeof wd->sc_dk.dk_label.d_typename);
   1078   1.64  mycroft 		strncpy(wd->sc_params.wdp_model, "Unknown Type",
   1079   1.64  mycroft 		    sizeof wd->sc_params.wdp_model);
   1080   1.93  mycroft 		wd->sc_dk.dk_label.d_type = DTYPE_ST506;
   1081   1.60  mycroft 	} else {
   1082   1.64  mycroft 		/* Obtain parameters. */
   1083   1.64  mycroft 		wp = &wd->sc_params;
   1084   1.64  mycroft 		insw(wdc->sc_iobase+wd_data, tb, sizeof(tb) / sizeof(short));
   1085   1.13  deraadt 		bcopy(tb, wp, sizeof(struct wdparams));
   1086   1.13  deraadt 
   1087   1.64  mycroft 		/* Shuffle string byte order. */
   1088   1.37  mycroft 		for (i = 0; i < sizeof(wp->wdp_model); i += 2) {
   1089   1.13  deraadt 			u_short *p;
   1090   1.37  mycroft 			p = (u_short *)(wp->wdp_model + i);
   1091   1.13  deraadt 			*p = ntohs(*p);
   1092   1.13  deraadt 		}
   1093   1.13  deraadt 
   1094   1.93  mycroft 		strncpy(wd->sc_dk.dk_label.d_typename, "ESDI/IDE",
   1095   1.93  mycroft 		    sizeof wd->sc_dk.dk_label.d_typename);
   1096   1.93  mycroft 		wd->sc_dk.dk_label.d_type = DTYPE_ESDI;
   1097   1.93  mycroft 		bcopy(wp->wdp_model+20, wd->sc_dk.dk_label.d_packname, 14-1);
   1098   1.13  deraadt 
   1099   1.64  mycroft 		/* Update disklabel given drive information. */
   1100   1.93  mycroft 		wd->sc_dk.dk_label.d_ncylinders =
   1101   1.44  mycroft 		    wp->wdp_fixedcyl + wp->wdp_removcyl /*+- 1*/;
   1102   1.97  mycroft 		wd->sc_dk.dk_label.d_secsize = DEV_BSIZE;
   1103   1.93  mycroft 		wd->sc_dk.dk_label.d_ntracks = wp->wdp_heads;
   1104   1.93  mycroft 		wd->sc_dk.dk_label.d_nsectors = wp->wdp_sectors;
   1105   1.93  mycroft 		wd->sc_dk.dk_label.d_secpercyl =
   1106   1.93  mycroft 		    wd->sc_dk.dk_label.d_ntracks * wd->sc_dk.dk_label.d_nsectors;
   1107   1.93  mycroft 		wd->sc_dk.dk_label.d_partitions[1].p_size =
   1108   1.93  mycroft 		    wd->sc_dk.dk_label.d_secpercyl * wp->wdp_sectors;
   1109   1.93  mycroft 		wd->sc_dk.dk_label.d_partitions[1].p_offset = 0;
   1110    1.8  deraadt 	}
   1111   1.13  deraadt 
   1112   1.13  deraadt #if 0
   1113   1.37  mycroft 	printf("gc %x cyl %d trk %d sec %d type %d sz %d model %s\n",
   1114   1.37  mycroft 	    wp->wdp_config, wp->wdp_fixedcyl + wp->wdp_removcyl, wp->wdp_heads,
   1115   1.37  mycroft 	    wp->wdp_sectors, wp->wdp_cntype, wp->wdp_cnsbsz, wp->wdp_model);
   1116   1.13  deraadt #endif
   1117   1.13  deraadt 
   1118   1.93  mycroft 	wd->sc_dk.dk_label.d_subtype |= DSTYPE_GEOMETRY;
   1119    1.3  deraadt 
   1120    1.1      cgd 	/* XXX sometimes possibly needed */
   1121   1.64  mycroft 	(void) inb(wdc->sc_iobase+wd_status);
   1122   1.63  mycroft 
   1123   1.37  mycroft 	return 0;
   1124    1.1      cgd }
   1125    1.1      cgd 
   1126    1.1      cgd int
   1127   1.55  mycroft wdclose(dev, flag, fmt)
   1128   1.55  mycroft 	dev_t dev;
   1129   1.93  mycroft 	int flag, fmt;
   1130    1.1      cgd {
   1131   1.74  mycroft 	struct wd_softc *wd = wdcd.cd_devs[WDUNIT(dev)];
   1132   1.93  mycroft 	int part = WDPART(dev);
   1133    1.3  deraadt 
   1134    1.3  deraadt 	switch (fmt) {
   1135    1.3  deraadt 	case S_IFCHR:
   1136   1.94  mycroft 		wd->sc_dk.dk_copenmask &= ~(1 << part);
   1137    1.3  deraadt 		break;
   1138    1.3  deraadt 	case S_IFBLK:
   1139   1.94  mycroft 		wd->sc_dk.dk_bopenmask &= ~(1 << part);
   1140    1.3  deraadt 		break;
   1141    1.3  deraadt 	}
   1142   1.94  mycroft 	wd->sc_dk.dk_openmask = wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
   1143   1.60  mycroft 
   1144   1.37  mycroft 	return 0;
   1145    1.1      cgd }
   1146    1.1      cgd 
   1147    1.1      cgd int
   1148   1.55  mycroft wdioctl(dev, cmd, addr, flag, p)
   1149   1.55  mycroft 	dev_t dev;
   1150  1.101      cgd 	u_long cmd;
   1151   1.55  mycroft 	caddr_t addr;
   1152   1.55  mycroft 	int flag;
   1153   1.55  mycroft 	struct proc *p;
   1154    1.1      cgd {
   1155   1.51  mycroft 	int lunit = WDUNIT(dev);
   1156   1.74  mycroft 	struct wd_softc *wd = wdcd.cd_devs[lunit];
   1157   1.54  mycroft 	int error;
   1158    1.3  deraadt 
   1159    1.1      cgd 	switch (cmd) {
   1160    1.1      cgd 	case DIOCSBAD:
   1161    1.3  deraadt 		if ((flag & FWRITE) == 0)
   1162   1.54  mycroft 			return EBADF;
   1163   1.93  mycroft 		wd->sc_dk.dk_cpulabel.bad = *(struct dkbad *)addr;
   1164   1.93  mycroft 		wd->sc_flags |= WDF_BADSECT;
   1165   1.64  mycroft 		bad144intern(wd);
   1166   1.54  mycroft 		return 0;
   1167    1.1      cgd 
   1168    1.1      cgd 	case DIOCGDINFO:
   1169   1.93  mycroft 		*(struct disklabel *)addr = wd->sc_dk.dk_label;
   1170   1.54  mycroft 		return 0;
   1171    1.3  deraadt 
   1172    1.3  deraadt 	case DIOCGPART:
   1173   1.93  mycroft 		((struct partinfo *)addr)->disklab = &wd->sc_dk.dk_label;
   1174    1.3  deraadt 		((struct partinfo *)addr)->part =
   1175   1.93  mycroft 		    &wd->sc_dk.dk_label.d_partitions[WDPART(dev)];
   1176   1.54  mycroft 		return 0;
   1177    1.3  deraadt 
   1178    1.3  deraadt 	case DIOCSDINFO:
   1179    1.3  deraadt 		if ((flag & FWRITE) == 0)
   1180   1.54  mycroft 			return EBADF;
   1181   1.93  mycroft 		error = setdisklabel(&wd->sc_dk.dk_label,
   1182   1.54  mycroft 		    (struct disklabel *)addr,
   1183   1.94  mycroft 		    /*(wd->sc_flags & WDF_BSDLABEL) ? wd->sc_dk.dk_openmask : */0,
   1184   1.93  mycroft 		    &wd->sc_dk.dk_cpulabel);
   1185    1.3  deraadt 		if (error == 0) {
   1186   1.64  mycroft 			wd->sc_flags |= WDF_BSDLABEL;
   1187   1.69  mycroft 			if (wd->sc_state > GEOMETRY)
   1188   1.69  mycroft 				wd->sc_state = GEOMETRY;
   1189    1.1      cgd 		}
   1190   1.54  mycroft 		return error;
   1191    1.3  deraadt 
   1192   1.44  mycroft 	case DIOCWLABEL:
   1193   1.64  mycroft 		wd->sc_flags &= ~WDF_WRITEPROT;
   1194    1.3  deraadt 		if ((flag & FWRITE) == 0)
   1195   1.54  mycroft 			return EBADF;
   1196   1.93  mycroft 		if (*(int *)addr)
   1197   1.93  mycroft 			wd->sc_flags |= WDF_WLABEL;
   1198   1.93  mycroft 		else
   1199   1.93  mycroft 			wd->sc_flags &= ~WDF_WLABEL;
   1200   1.54  mycroft 		return 0;
   1201    1.3  deraadt 
   1202   1.44  mycroft 	case DIOCWDINFO:
   1203   1.64  mycroft 		wd->sc_flags &= ~WDF_WRITEPROT;
   1204    1.3  deraadt 		if ((flag & FWRITE) == 0)
   1205   1.54  mycroft 			return EBADF;
   1206   1.93  mycroft 		error = setdisklabel(&wd->sc_dk.dk_label,
   1207   1.37  mycroft 		    (struct disklabel *)addr,
   1208   1.94  mycroft 		    /*(wd->sc_flags & WDF_BSDLABEL) ? wd->sc_dk.dk_openmask : */0,
   1209   1.93  mycroft 		    &wd->sc_dk.dk_cpulabel);
   1210   1.54  mycroft 		if (error == 0) {
   1211   1.64  mycroft 			wd->sc_flags |= WDF_BSDLABEL;
   1212   1.69  mycroft 			if (wd->sc_state > GEOMETRY)
   1213   1.69  mycroft 				wd->sc_state = GEOMETRY;
   1214    1.3  deraadt 
   1215   1.64  mycroft 			/* Simulate opening partition 0 so write succeeds. */
   1216   1.94  mycroft 			wd->sc_dk.dk_openmask |= (1 << 0);	/* XXX */
   1217   1.86  mycroft 			error = writedisklabel(WDLABELDEV(dev), wdstrategy,
   1218   1.93  mycroft 			    &wd->sc_dk.dk_label, &wd->sc_dk.dk_cpulabel);
   1219   1.94  mycroft 			wd->sc_dk.dk_openmask =
   1220   1.94  mycroft 			    wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
   1221    1.3  deraadt 		}
   1222   1.54  mycroft 		return error;
   1223    1.3  deraadt 
   1224    1.1      cgd #ifdef notyet
   1225    1.1      cgd 	case DIOCGDINFOP:
   1226   1.93  mycroft 		*(struct disklabel **)addr = &wd->sc_dk.dk_label;
   1227   1.54  mycroft 		return 0;
   1228    1.3  deraadt 
   1229    1.1      cgd 	case DIOCWFORMAT:
   1230    1.1      cgd 		if ((flag & FWRITE) == 0)
   1231   1.54  mycroft 			return EBADF;
   1232   1.54  mycroft 	{
   1233   1.54  mycroft 		register struct format_op *fop;
   1234   1.54  mycroft 		struct iovec aiov;
   1235   1.54  mycroft 		struct uio auio;
   1236    1.3  deraadt 
   1237   1.54  mycroft 		fop = (struct format_op *)addr;
   1238   1.54  mycroft 		aiov.iov_base = fop->df_buf;
   1239   1.54  mycroft 		aiov.iov_len = fop->df_count;
   1240   1.54  mycroft 		auio.uio_iov = &aiov;
   1241   1.54  mycroft 		auio.uio_iovcnt = 1;
   1242   1.54  mycroft 		auio.uio_resid = fop->df_count;
   1243   1.54  mycroft 		auio.uio_segflg = 0;
   1244   1.54  mycroft 		auio.uio_offset =
   1245   1.93  mycroft 		    fop->df_startblk * wd->sc_dk.dk_label.d_secsize;
   1246   1.83       pk 		auio.uio_procp = p;
   1247   1.64  mycroft 		error = physio(wdformat, NULL, dev, B_WRITE, minphys,
   1248   1.64  mycroft 		    &auio);
   1249   1.54  mycroft 		fop->df_count -= auio.uio_resid;
   1250   1.64  mycroft 		fop->df_reg[0] = wdc->sc_status;
   1251   1.64  mycroft 		fop->df_reg[1] = wdc->sc_error;
   1252   1.54  mycroft 		return error;
   1253   1.54  mycroft 	}
   1254    1.1      cgd #endif
   1255    1.3  deraadt 
   1256    1.1      cgd 	default:
   1257   1.54  mycroft 		return ENOTTY;
   1258    1.1      cgd 	}
   1259   1.54  mycroft 
   1260   1.54  mycroft #ifdef DIAGNOSTIC
   1261   1.54  mycroft 	panic("wdioctl: impossible");
   1262   1.54  mycroft #endif
   1263    1.1      cgd }
   1264    1.1      cgd 
   1265   1.44  mycroft #ifdef B_FORMAT
   1266    1.1      cgd int
   1267    1.1      cgd wdformat(struct buf *bp)
   1268    1.1      cgd {
   1269   1.44  mycroft 
   1270    1.1      cgd 	bp->b_flags |= B_FORMAT;
   1271   1.37  mycroft 	return wdstrategy(bp);
   1272    1.1      cgd }
   1273    1.1      cgd #endif
   1274    1.1      cgd 
   1275    1.1      cgd int
   1276   1.55  mycroft wdsize(dev)
   1277   1.55  mycroft 	dev_t dev;
   1278    1.1      cgd {
   1279   1.51  mycroft 	int lunit = WDUNIT(dev), part = WDPART(dev);
   1280   1.64  mycroft 	struct wd_softc *wd;
   1281    1.3  deraadt 
   1282   1.74  mycroft 	if (lunit >= wdcd.cd_ndevs)
   1283   1.37  mycroft 		return -1;
   1284   1.74  mycroft 	wd = wdcd.cd_devs[lunit];
   1285   1.64  mycroft 	if (wd == 0)
   1286   1.37  mycroft 		return -1;
   1287    1.3  deraadt 
   1288   1.64  mycroft 	if (wd->sc_state < OPEN || (wd->sc_flags & WDF_BSDLABEL) == 0) {
   1289    1.3  deraadt 		int val;
   1290   1.92      cgd 		val = wdopen(MAKEWDDEV(major(dev), lunit, RAW_PART), FREAD,
   1291   1.44  mycroft 		    S_IFBLK, 0);
   1292   1.55  mycroft 		/* XXX Clear the open flag? */
   1293    1.3  deraadt 		if (val != 0)
   1294   1.37  mycroft 			return -1;
   1295    1.3  deraadt 	}
   1296    1.3  deraadt 
   1297   1.64  mycroft 	if ((wd->sc_flags & (WDF_WRITEPROT | WDF_BSDLABEL)) != WDF_BSDLABEL)
   1298   1.37  mycroft 		return -1;
   1299   1.46  mycroft 
   1300   1.93  mycroft 	return (int)wd->sc_dk.dk_label.d_partitions[part].p_size;
   1301    1.1      cgd }
   1302    1.1      cgd 
   1303   1.64  mycroft /*
   1304   1.64  mycroft  * Dump core after a system crash.
   1305   1.64  mycroft  */
   1306    1.1      cgd int
   1307   1.55  mycroft wddump(dev)
   1308   1.55  mycroft 	dev_t dev;
   1309    1.1      cgd {
   1310   1.64  mycroft 	struct wd_softc *wd;	/* disk unit to do the IO */
   1311   1.64  mycroft 	struct wdc_softc *wdc;
   1312   1.64  mycroft 	long num;		/* number of sectors to write */
   1313   1.64  mycroft 	int lunit, part;
   1314   1.93  mycroft 	long blkoff, blkno;
   1315   1.63  mycroft 	long cylin, head, sector;
   1316   1.60  mycroft 	long secpertrk, secpercyl, nblocks;
   1317    1.1      cgd 	char *addr;
   1318   1.46  mycroft 	static wddoingadump = 0;
   1319    1.1      cgd 	extern caddr_t CADDR1;
   1320   1.88  mycroft 	extern pt_entry_t *CMAP1;
   1321   1.30       ws 
   1322   1.64  mycroft 	addr = (char *)0;	/* starting address */
   1323    1.3  deraadt 
   1324   1.16  deraadt #if DO_NOT_KNOW_HOW
   1325   1.64  mycroft 	/* Toss any characters present prior to dump, ie. non-blocking getc. */
   1326   1.16  deraadt 	while (cngetc())
   1327    1.1      cgd 		;
   1328   1.16  deraadt #endif
   1329   1.60  mycroft 
   1330   1.51  mycroft 	lunit = WDUNIT(dev);
   1331   1.64  mycroft 	/* Check for acceptable drive number. */
   1332   1.74  mycroft 	if (lunit >= wdcd.cd_ndevs)
   1333   1.37  mycroft 		return ENXIO;
   1334   1.74  mycroft 	wd = wdcd.cd_devs[lunit];
   1335   1.64  mycroft 	/* Was it ever initialized? */
   1336   1.64  mycroft 	if (wd == 0 || wd->sc_state < OPEN || wd->sc_flags & WDF_WRITEPROT)
   1337   1.37  mycroft 		return ENXIO;
   1338   1.46  mycroft 
   1339   1.64  mycroft 	wdc = (void *)wd->sc_dev.dv_parent;
   1340   1.64  mycroft 
   1341   1.64  mycroft 	/* Convert to disk sectors. */
   1342   1.93  mycroft 	num = ctob(physmem) / wd->sc_dk.dk_label.d_secsize;
   1343    1.3  deraadt 
   1344   1.93  mycroft 	secpertrk = wd->sc_dk.dk_label.d_nsectors;
   1345   1.93  mycroft 	secpercyl = wd->sc_dk.dk_label.d_secpercyl;
   1346   1.64  mycroft 	part = WDPART(dev);
   1347   1.93  mycroft 	nblocks = wd->sc_dk.dk_label.d_partitions[part].p_size;
   1348   1.93  mycroft 	blkoff = wd->sc_dk.dk_label.d_partitions[part].p_offset;
   1349    1.3  deraadt 
   1350   1.60  mycroft 	/*printf("part %x, nblocks %d, dumplo %d, num %d\n", part, nblocks,
   1351   1.51  mycroft 	    dumplo, num);*/
   1352   1.60  mycroft 
   1353   1.64  mycroft 	/* Check transfer bounds against partition size. */
   1354   1.46  mycroft 	if (dumplo < 0 || dumplo + num > nblocks)
   1355   1.37  mycroft 		return EINVAL;
   1356   1.60  mycroft 
   1357   1.60  mycroft 	if (wddoingadump)
   1358   1.60  mycroft 		return EFAULT;
   1359    1.3  deraadt 	wddoingadump = 1;
   1360   1.60  mycroft 
   1361   1.60  mycroft 	/* Recalibrate. */
   1362   1.64  mycroft 	if (wdcommand(wd, 0, 0, 0, 0, WDCC_RESTORE | WD_STEP) != 0 ||
   1363   1.69  mycroft 	    wait_for_ready(wdc) != 0 || wdsetctlr(wd) != 0 ||
   1364   1.69  mycroft 	    wait_for_ready(wdc) != 0) {
   1365   1.64  mycroft 		wderror(wd, NULL, "wddump: recal failed");
   1366   1.51  mycroft 		return EIO;
   1367   1.63  mycroft 	}
   1368    1.3  deraadt 
   1369   1.93  mycroft 	blkno = dumplo + blkoff;
   1370    1.1      cgd 	while (num > 0) {
   1371   1.64  mycroft 		/* Compute disk address. */
   1372   1.93  mycroft 		cylin = blkno / secpercyl;
   1373   1.93  mycroft 		head = (blkno % secpercyl) / secpertrk;
   1374   1.93  mycroft 		sector = blkno % secpertrk;
   1375    1.3  deraadt 
   1376   1.64  mycroft 		if (wd->sc_flags & WDF_BADSECT) {
   1377    1.3  deraadt 			long newblk;
   1378    1.3  deraadt 			int i;
   1379    1.3  deraadt 
   1380   1.64  mycroft 			for (i = 0; wd->sc_badsect[i] != -1; i++) {
   1381   1.93  mycroft 				if (blkno < wd->sc_badsect[i]) {
   1382   1.64  mycroft 					/* Sorted list, passed our block by. */
   1383   1.44  mycroft 					break;
   1384   1.93  mycroft 				} else if (blkno == wd->sc_badsect[i]) {
   1385   1.93  mycroft 					newblk =
   1386   1.93  mycroft 					    wd->sc_dk.dk_label.d_secperunit -
   1387   1.93  mycroft 					    wd->sc_dk.dk_label.d_nsectors -
   1388   1.93  mycroft 					    i - 1;
   1389    1.3  deraadt 					cylin = newblk / secpercyl;
   1390    1.3  deraadt 					head = (newblk % secpercyl) / secpertrk;
   1391    1.3  deraadt 					sector = newblk % secpertrk;
   1392   1.64  mycroft 					/* Found and replaced; done. */
   1393    1.3  deraadt 					break;
   1394    1.3  deraadt 				}
   1395    1.1      cgd 			}
   1396    1.3  deraadt 		}
   1397    1.1      cgd 		sector++;		/* origin 1 */
   1398    1.3  deraadt 
   1399    1.1      cgd #ifdef notdef
   1400   1.64  mycroft 		/* Let's just talk about this first. */
   1401   1.60  mycroft 		printf("cylin %d, head %d, sector %d, addr 0x%x", cylin, head,
   1402   1.60  mycroft 		    sector, addr);
   1403    1.1      cgd #endif
   1404   1.64  mycroft 		if (wdcommand(wd, cylin, head, sector, 1, WDCC_WRITE) != 0) {
   1405   1.64  mycroft 			wderror(wd, NULL, "wddump: wdcommand failed");
   1406   1.63  mycroft 			return EIO;
   1407   1.63  mycroft 		}
   1408   1.64  mycroft 		if (wait_for_drq(wdc) != 0) {
   1409   1.64  mycroft 			wderror(wd, NULL, "wddump: timeout waiting for drq");
   1410   1.51  mycroft 			return EIO;
   1411   1.63  mycroft 		}
   1412    1.3  deraadt 
   1413   1.64  mycroft #ifdef notdef	/* Cannot use this since this address was mapped differently. */
   1414   1.46  mycroft 		pmap_enter(kernel_pmap, CADDR1, trunc_page(addr), VM_PROT_READ, TRUE);
   1415   1.46  mycroft #else
   1416   1.88  mycroft 		*CMAP1 = PG_V | PG_KW | ctob((long)addr);
   1417   1.46  mycroft 		tlbflush();
   1418   1.46  mycroft #endif
   1419   1.46  mycroft 
   1420   1.64  mycroft 		outsw(wdc->sc_iobase+wd_data, CADDR1 + ((int)addr & PGOFSET),
   1421   1.51  mycroft 		    DEV_BSIZE / sizeof(short));
   1422    1.3  deraadt 
   1423   1.13  deraadt 		/* Check data request (should be done). */
   1424   1.64  mycroft 		if (wait_for_ready(wdc) != 0) {
   1425   1.64  mycroft 			wderror(wd, NULL, "wddump: timeout waiting for ready");
   1426   1.63  mycroft 			return EIO;
   1427   1.63  mycroft 		}
   1428   1.64  mycroft 		if (wdc->sc_status & WDCS_DRQ) {
   1429   1.64  mycroft 			wderror(wd, NULL, "wddump: extra drq");
   1430   1.37  mycroft 			return EIO;
   1431   1.63  mycroft 		}
   1432    1.3  deraadt 
   1433   1.46  mycroft 		if ((unsigned)addr % 1048576 == 0)
   1434   1.46  mycroft 			printf("%d ", num / (1048576 / DEV_BSIZE));
   1435    1.1      cgd 
   1436   1.64  mycroft 		/* Update block count. */
   1437    1.1      cgd 		num--;
   1438   1.93  mycroft 		blkno++;
   1439   1.46  mycroft 		(int)addr += DEV_BSIZE;
   1440    1.3  deraadt 
   1441   1.16  deraadt #if DO_NOT_KNOW_HOW
   1442   1.64  mycroft 		/* Operator aborting dump? non-blocking getc() */
   1443   1.16  deraadt 		if (cngetc())
   1444   1.37  mycroft 			return EINTR;
   1445   1.16  deraadt #endif
   1446    1.1      cgd 	}
   1447   1.37  mycroft 	return 0;
   1448    1.1      cgd }
   1449    1.3  deraadt 
   1450    1.3  deraadt /*
   1451    1.3  deraadt  * Internalize the bad sector table.
   1452    1.3  deraadt  */
   1453    1.3  deraadt void
   1454   1.64  mycroft bad144intern(wd)
   1455   1.64  mycroft 	struct wd_softc *wd;
   1456    1.3  deraadt {
   1457   1.98  mycroft 	struct dkbad *bt = &wd->sc_dk.dk_cpulabel.bad;
   1458   1.98  mycroft 	struct disklabel *lp = &wd->sc_dk.dk_label;
   1459   1.98  mycroft 	int i = 0;
   1460   1.55  mycroft 
   1461   1.98  mycroft 	for (; i < 126; i++) {
   1462   1.98  mycroft 		if (bt->bt_bad[i].bt_cyl == 0xffff)
   1463   1.55  mycroft 			break;
   1464   1.64  mycroft 		wd->sc_badsect[i] =
   1465   1.98  mycroft 		    bt->bt_bad[i].bt_cyl * lp->d_secpercyl +
   1466   1.98  mycroft 		    (bt->bt_bad[i].bt_trksec >> 8) * lp->d_nsectors +
   1467   1.98  mycroft 		    (bt->bt_bad[i].bt_trksec & 0xff);
   1468    1.3  deraadt 	}
   1469   1.98  mycroft 	for (; i < 127; i++)
   1470   1.98  mycroft 		wd->sc_badsect[i] = -1;
   1471    1.3  deraadt }
   1472    1.3  deraadt 
   1473   1.27      cgd static int
   1474   1.64  mycroft wdcreset(wdc)
   1475   1.64  mycroft 	struct wdc_softc *wdc;
   1476   1.21  deraadt {
   1477   1.64  mycroft 	u_short iobase = wdc->sc_iobase;
   1478   1.21  deraadt 
   1479   1.64  mycroft 	/* Reset the device. */
   1480   1.64  mycroft 	outb(iobase+wd_ctlr, WDCTL_RST | WDCTL_IDS);
   1481   1.61  mycroft 	delay(1000);
   1482   1.64  mycroft 	outb(iobase+wd_ctlr, WDCTL_IDS);
   1483   1.61  mycroft 	delay(1000);
   1484   1.64  mycroft 	(void) inb(iobase+wd_error);
   1485   1.64  mycroft 	outb(iobase+wd_ctlr, WDCTL_4BIT);
   1486   1.64  mycroft 
   1487   1.64  mycroft 	if (wait_for_unbusy(wdc) < 0) {
   1488   1.64  mycroft 		printf("%s: reset failed\n", wdc->sc_dev.dv_xname);
   1489   1.64  mycroft 		return 1;
   1490   1.64  mycroft 	}
   1491   1.64  mycroft 
   1492   1.64  mycroft 	return 0;
   1493   1.64  mycroft }
   1494   1.64  mycroft 
   1495   1.64  mycroft static void
   1496   1.81      cgd wdcrestart(arg)
   1497   1.81      cgd 	void *arg;
   1498   1.64  mycroft {
   1499   1.81      cgd 	struct wdc_softc *wdc = (struct wdc_softc *)arg;
   1500   1.98  mycroft 	int s;
   1501   1.64  mycroft 
   1502   1.98  mycroft 	s = splbio();
   1503   1.64  mycroft 	wdcstart(wdc);
   1504   1.64  mycroft 	splx(s);
   1505   1.64  mycroft }
   1506   1.64  mycroft 
   1507   1.64  mycroft /*
   1508   1.64  mycroft  * Unwedge the controller after an unexpected error.  We do this by resetting
   1509   1.64  mycroft  * it, marking all drives for recalibration, and stalling the queue for a short
   1510   1.64  mycroft  * period to give the reset time to finish.
   1511   1.64  mycroft  * NOTE: We use a timeout here, so this routine must not be called during
   1512   1.64  mycroft  * autoconfig or dump.
   1513   1.64  mycroft  */
   1514   1.64  mycroft static void
   1515   1.64  mycroft wdcunwedge(wdc)
   1516   1.64  mycroft 	struct wdc_softc *wdc;
   1517   1.64  mycroft {
   1518   1.64  mycroft 	int lunit;
   1519   1.64  mycroft 
   1520   1.98  mycroft 	untimeout(wdctimeout, wdc);
   1521   1.64  mycroft 	(void) wdcreset(wdc);
   1522   1.21  deraadt 
   1523   1.64  mycroft 	/* Schedule recalibrate for all drives on this controller. */
   1524   1.74  mycroft 	for (lunit = 0; lunit < wdcd.cd_ndevs; lunit++) {
   1525   1.74  mycroft 		struct wd_softc *wd = wdcd.cd_devs[lunit];
   1526   1.64  mycroft 		if (!wd || (void *)wd->sc_dev.dv_parent != wdc)
   1527   1.64  mycroft 			continue;
   1528   1.69  mycroft 		if (wd->sc_state > RECAL)
   1529   1.69  mycroft 			wd->sc_state = RECAL;
   1530   1.64  mycroft 	}
   1531   1.64  mycroft 
   1532   1.69  mycroft 	wdc->sc_flags |= WDCF_ERROR;
   1533   1.78  mycroft 	++wdc->sc_errors;
   1534   1.64  mycroft 
   1535   1.64  mycroft 	/* Wake up in a little bit and restart the operation. */
   1536   1.82  mycroft 	timeout(wdcrestart, wdc, RECOVERYTIME);
   1537   1.40  mycroft }
   1538   1.40  mycroft 
   1539   1.40  mycroft int
   1540   1.64  mycroft wdcwait(wdc, mask)
   1541   1.64  mycroft 	struct wdc_softc *wdc;
   1542   1.49  mycroft 	int mask;
   1543   1.40  mycroft {
   1544   1.64  mycroft 	u_short iobase = wdc->sc_iobase;
   1545   1.40  mycroft 	int timeout = 0;
   1546   1.63  mycroft 	u_char status;
   1547   1.87  mycroft 	extern int cold;
   1548   1.40  mycroft 
   1549   1.40  mycroft 	for (;;) {
   1550   1.87  mycroft 		wdc->sc_status = status = inb(iobase+wd_status);
   1551   1.63  mycroft 		if ((status & WDCS_BUSY) == 0 && (status & mask) == mask)
   1552   1.54  mycroft 			break;
   1553   1.40  mycroft 		if (++timeout > WDCNDELAY)
   1554   1.40  mycroft 			return -1;
   1555   1.61  mycroft 		delay(WDCDELAY);
   1556   1.21  deraadt 	}
   1557   1.87  mycroft 	if (status & WDCS_ERR) {
   1558   1.64  mycroft 		wdc->sc_error = inb(iobase+wd_error);
   1559   1.87  mycroft 		return WDCS_ERR;
   1560   1.87  mycroft 	}
   1561   1.23  deraadt #ifdef WDCNDELAY_DEBUG
   1562   1.87  mycroft 	/* After autoconfig, there should be no long delays. */
   1563   1.87  mycroft 	if (!cold && timeout > WDCNDELAY_DEBUG)
   1564   1.87  mycroft 		printf("%s: warning: busy-wait took %dus\n",
   1565   1.73  mycroft 		    wdc->sc_dev.dv_xname, WDCDELAY * timeout);
   1566   1.23  deraadt #endif
   1567   1.87  mycroft 	return 0;
   1568   1.27      cgd }
   1569   1.27      cgd 
   1570   1.60  mycroft static void
   1571   1.81      cgd wdctimeout(arg)
   1572   1.81      cgd 	void *arg;
   1573   1.27      cgd {
   1574   1.81      cgd 	struct wdc_softc *wdc = (struct wdc_softc *)arg;
   1575   1.98  mycroft 	int s;
   1576   1.27      cgd 
   1577   1.98  mycroft 	s = splbio();
   1578   1.98  mycroft 	wderror(wdc, NULL, "lost interrupt");
   1579   1.98  mycroft 	wdcunwedge(wdc);
   1580   1.55  mycroft 	splx(s);
   1581   1.63  mycroft }
   1582   1.63  mycroft 
   1583   1.63  mycroft static void
   1584   1.64  mycroft wderror(dev, bp, msg)
   1585   1.64  mycroft 	void *dev;
   1586   1.63  mycroft 	struct buf *bp;
   1587   1.63  mycroft 	char *msg;
   1588   1.63  mycroft {
   1589   1.64  mycroft 	struct wd_softc *wd = dev;
   1590   1.64  mycroft 	struct wdc_softc *wdc = dev;
   1591   1.64  mycroft 
   1592   1.63  mycroft 	if (bp)
   1593   1.93  mycroft 		diskerr(bp, "wd", msg, LOG_PRINTF, wd->sc_skip,
   1594   1.93  mycroft 		    &wd->sc_dk.dk_label);
   1595   1.63  mycroft 	else
   1596   1.64  mycroft 		printf("%s: %s: status %b error %b\n", wdc->sc_dev.dv_xname,
   1597   1.64  mycroft 		    msg, wdc->sc_status, WDCS_BITS, wdc->sc_error, WDERR_BITS);
   1598   1.21  deraadt }
   1599