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