Home | History | Annotate | Line # | Download | only in ata
wd.c revision 1.337.2.11
      1  1.337.2.11        ad /*	$NetBSD: wd.c,v 1.337.2.11 2007/10/23 20:06:54 ad Exp $ */
      2       1.181    bouyer 
      3       1.181    bouyer /*
      4       1.218    bouyer  * Copyright (c) 1998, 2001 Manuel Bouyer.  All rights reserved.
      5       1.181    bouyer  *
      6       1.181    bouyer  * Redistribution and use in source and binary forms, with or without
      7       1.181    bouyer  * modification, are permitted provided that the following conditions
      8       1.181    bouyer  * are met:
      9       1.181    bouyer  * 1. Redistributions of source code must retain the above copyright
     10       1.181    bouyer  *	notice, this list of conditions and the following disclaimer.
     11       1.181    bouyer  * 2. Redistributions in binary form must reproduce the above copyright
     12       1.181    bouyer  *	notice, this list of conditions and the following disclaimer in the
     13       1.181    bouyer  *	documentation and/or other materials provided with the distribution.
     14       1.181    bouyer  * 3. All advertising materials mentioning features or use of this software
     15       1.181    bouyer  *	must display the following acknowledgement:
     16       1.181    bouyer  *  This product includes software developed by Manuel Bouyer.
     17       1.181    bouyer  * 4. The name of the author may not be used to endorse or promote products
     18       1.181    bouyer  *	derived from this software without specific prior written permission.
     19       1.181    bouyer  *
     20       1.181    bouyer  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
     21       1.181    bouyer  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
     22       1.181    bouyer  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
     23       1.259       dsl  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
     24       1.181    bouyer  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
     25       1.181    bouyer  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     26       1.181    bouyer  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     27       1.181    bouyer  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     28       1.181    bouyer  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     29       1.181    bouyer  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     30       1.181    bouyer  */
     31       1.100       cgd 
     32       1.178   mycroft /*-
     33       1.280   mycroft  * Copyright (c) 1998, 2003, 2004 The NetBSD Foundation, Inc.
     34       1.178   mycroft  * All rights reserved.
     35       1.119   mycroft  *
     36       1.178   mycroft  * This code is derived from software contributed to The NetBSD Foundation
     37       1.178   mycroft  * by Charles M. Hannum and by Onno van der Linden.
     38       1.168       cgd  *
     39       1.113   mycroft  * Redistribution and use in source and binary forms, with or without
     40       1.113   mycroft  * modification, are permitted provided that the following conditions
     41       1.113   mycroft  * are met:
     42       1.113   mycroft  * 1. Redistributions of source code must retain the above copyright
     43       1.113   mycroft  *    notice, this list of conditions and the following disclaimer.
     44       1.113   mycroft  * 2. Redistributions in binary form must reproduce the above copyright
     45       1.113   mycroft  *    notice, this list of conditions and the following disclaimer in the
     46       1.113   mycroft  *    documentation and/or other materials provided with the distribution.
     47       1.113   mycroft  * 3. All advertising materials mentioning features or use of this software
     48       1.113   mycroft  *    must display the following acknowledgement:
     49       1.178   mycroft  *        This product includes software developed by the NetBSD
     50       1.178   mycroft  *        Foundation, Inc. and its contributors.
     51       1.178   mycroft  * 4. Neither the name of The NetBSD Foundation nor the names of its
     52       1.178   mycroft  *    contributors may be used to endorse or promote products derived
     53       1.178   mycroft  *    from this software without specific prior written permission.
     54       1.113   mycroft  *
     55       1.178   mycroft  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     56       1.178   mycroft  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     57       1.178   mycroft  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     58       1.178   mycroft  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     59       1.178   mycroft  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     60       1.178   mycroft  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     61       1.178   mycroft  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     62       1.178   mycroft  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     63       1.178   mycroft  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     64       1.178   mycroft  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     65       1.178   mycroft  * POSSIBILITY OF SUCH DAMAGE.
     66         1.1       cgd  */
     67       1.215     lukem 
     68       1.215     lukem #include <sys/cdefs.h>
     69  1.337.2.11        ad __KERNEL_RCSID(0, "$NetBSD: wd.c,v 1.337.2.11 2007/10/23 20:06:54 ad Exp $");
     70         1.1       cgd 
     71   1.337.2.2        ad #include "opt_ata.h"
     72       1.181    bouyer 
     73       1.166  explorer #include "rnd.h"
     74       1.166  explorer 
     75        1.29   mycroft #include <sys/param.h>
     76        1.29   mycroft #include <sys/systm.h>
     77        1.43   mycroft #include <sys/kernel.h>
     78        1.29   mycroft #include <sys/conf.h>
     79        1.29   mycroft #include <sys/file.h>
     80        1.29   mycroft #include <sys/stat.h>
     81        1.29   mycroft #include <sys/ioctl.h>
     82        1.29   mycroft #include <sys/buf.h>
     83       1.296      yamt #include <sys/bufq.h>
     84        1.29   mycroft #include <sys/uio.h>
     85        1.29   mycroft #include <sys/malloc.h>
     86        1.64   mycroft #include <sys/device.h>
     87        1.94   mycroft #include <sys/disklabel.h>
     88        1.94   mycroft #include <sys/disk.h>
     89        1.29   mycroft #include <sys/syslog.h>
     90       1.149  christos #include <sys/proc.h>
     91       1.196     enami #include <sys/vnode.h>
     92       1.166  explorer #if NRND > 0
     93       1.165  explorer #include <sys/rnd.h>
     94       1.166  explorer #endif
     95        1.29   mycroft 
     96  1.337.2.11        ad #include <sys/intr.h>
     97  1.337.2.11        ad #include <sys/bus.h>
     98       1.237   thorpej 
     99       1.181    bouyer #include <dev/ata/atareg.h>
    100       1.181    bouyer #include <dev/ata/atavar.h>
    101       1.181    bouyer #include <dev/ata/wdvar.h>
    102       1.181    bouyer #include <dev/ic/wdcreg.h>
    103       1.186      kenh #include <sys/ataio.h>
    104       1.163    bouyer #include "locators.h"
    105         1.1       cgd 
    106       1.330   thorpej #include <prop/proplib.h>
    107       1.330   thorpej 
    108       1.258      matt #define	LBA48_THRESHOLD		(0xfffffff)	/* 128GB / DEV_BSIZE */
    109       1.258      matt 
    110       1.189    bouyer #define	WDIORETRIES_SINGLE 4	/* number of retries before single-sector */
    111       1.181    bouyer #define	WDIORETRIES	5	/* number of retries before giving up */
    112       1.181    bouyer #define	RECOVERYTIME hz/2	/* time to wait before retrying a cmd */
    113        1.23   deraadt 
    114       1.181    bouyer #define	WDUNIT(dev)		DISKUNIT(dev)
    115       1.181    bouyer #define	WDPART(dev)		DISKPART(dev)
    116       1.196     enami #define	WDMINOR(unit, part)	DISKMINOR(unit, part)
    117        1.92       cgd #define	MAKEWDDEV(maj, unit, part)	MAKEDISKDEV(maj, unit, part)
    118        1.92       cgd 
    119        1.92       cgd #define	WDLABELDEV(dev)	(MAKEWDDEV(major(dev), WDUNIT(dev), RAW_PART))
    120         1.1       cgd 
    121       1.181    bouyer #define DEBUG_INTR   0x01
    122       1.181    bouyer #define DEBUG_XFERS  0x02
    123       1.181    bouyer #define DEBUG_STATUS 0x04
    124       1.181    bouyer #define DEBUG_FUNCS  0x08
    125       1.181    bouyer #define DEBUG_PROBE  0x10
    126       1.289   thorpej #ifdef ATADEBUG
    127       1.298     perry int wdcdebug_wd_mask = 0x0;
    128       1.289   thorpej #define ATADEBUG_PRINT(args, level) \
    129       1.181    bouyer 	if (wdcdebug_wd_mask & (level)) \
    130       1.181    bouyer 		printf args
    131       1.163    bouyer #else
    132       1.289   thorpej #define ATADEBUG_PRINT(args, level)
    133       1.163    bouyer #endif
    134       1.181    bouyer 
    135       1.259       dsl int	wdprobe(struct device *, struct cfdata *, void *);
    136       1.259       dsl void	wdattach(struct device *, struct device *, void *);
    137       1.259       dsl int	wddetach(struct device *, int);
    138       1.259       dsl int	wdactivate(struct device *, enum devact);
    139       1.259       dsl int	wdprint(void *, char *);
    140       1.259       dsl void	wdperror(const struct wd_softc *);
    141       1.102   mycroft 
    142       1.228   thorpej CFATTACH_DECL(wd, sizeof(struct wd_softc),
    143       1.229   thorpej     wdprobe, wdattach, wddetach, wdactivate);
    144       1.147   thorpej 
    145       1.167   thorpej extern struct cfdriver wd_cd;
    146       1.108   mycroft 
    147       1.225   gehenna dev_type_open(wdopen);
    148       1.225   gehenna dev_type_close(wdclose);
    149       1.225   gehenna dev_type_read(wdread);
    150       1.225   gehenna dev_type_write(wdwrite);
    151       1.225   gehenna dev_type_ioctl(wdioctl);
    152       1.225   gehenna dev_type_strategy(wdstrategy);
    153       1.225   gehenna dev_type_dump(wddump);
    154       1.225   gehenna dev_type_size(wdsize);
    155       1.225   gehenna 
    156       1.225   gehenna const struct bdevsw wd_bdevsw = {
    157       1.225   gehenna 	wdopen, wdclose, wdstrategy, wdioctl, wddump, wdsize, D_DISK
    158       1.225   gehenna };
    159       1.225   gehenna 
    160       1.225   gehenna const struct cdevsw wd_cdevsw = {
    161       1.225   gehenna 	wdopen, wdclose, wdread, wdwrite, wdioctl,
    162       1.231  jdolecek 	nostop, notty, nopoll, nommap, nokqfilter, D_DISK
    163       1.225   gehenna };
    164       1.225   gehenna 
    165       1.185      kenh /*
    166       1.185      kenh  * Glue necessary to hook WDCIOCCOMMAND into physio
    167       1.185      kenh  */
    168       1.185      kenh 
    169       1.185      kenh struct wd_ioctl {
    170       1.185      kenh 	LIST_ENTRY(wd_ioctl) wi_list;
    171       1.185      kenh 	struct buf wi_bp;
    172       1.185      kenh 	struct uio wi_uio;
    173       1.185      kenh 	struct iovec wi_iov;
    174       1.186      kenh 	atareq_t wi_atareq;
    175       1.185      kenh 	struct wd_softc *wi_softc;
    176       1.185      kenh };
    177       1.185      kenh 
    178       1.185      kenh LIST_HEAD(, wd_ioctl) wi_head;
    179       1.185      kenh 
    180       1.259       dsl struct	wd_ioctl *wi_find(struct buf *);
    181       1.259       dsl void	wi_free(struct wd_ioctl *);
    182       1.259       dsl struct	wd_ioctl *wi_get(void);
    183       1.259       dsl void	wdioctlstrategy(struct buf *);
    184       1.259       dsl 
    185       1.259       dsl void  wdgetdefaultlabel(struct wd_softc *, struct disklabel *);
    186       1.259       dsl void  wdgetdisklabel(struct wd_softc *);
    187       1.259       dsl void  wdstart(void *);
    188       1.259       dsl void  __wdstart(struct wd_softc*, struct buf *);
    189       1.259       dsl void  wdrestart(void *);
    190       1.272   thorpej void  wddone(void *);
    191       1.259       dsl int   wd_get_params(struct wd_softc *, u_int8_t, struct ataparams *);
    192       1.286   mycroft int   wd_standby(struct wd_softc *, int);
    193       1.276    bouyer int   wd_flushcache(struct wd_softc *, int);
    194       1.259       dsl void  wd_shutdown(void *);
    195       1.108   mycroft 
    196       1.259       dsl int   wd_getcache(struct wd_softc *, int *);
    197       1.259       dsl int   wd_setcache(struct wd_softc *, int);
    198       1.248    bouyer 
    199       1.294   thorpej struct dkdriver wddkdriver = { wdstrategy, minphys };
    200        1.65   mycroft 
    201       1.170       leo #ifdef HAS_BAD144_HANDLING
    202       1.259       dsl static void bad144intern(struct wd_softc *);
    203       1.170       leo #endif
    204         1.1       cgd 
    205       1.239   thorpej #define	WD_QUIRK_SPLIT_MOD15_WRITE	0x0001	/* must split certain writes */
    206       1.295    bouyer #define	WD_QUIRK_FORCE_LBA48		0x0002	/* must use LBA48 commands */
    207       1.239   thorpej 
    208       1.327     lukem #define	WD_QUIRK_FMT "\20\1SPLIT_MOD15_WRITE\2FORCE_LBA48"
    209       1.327     lukem 
    210       1.239   thorpej /*
    211       1.239   thorpej  * Quirk table for IDE drives.  Put more-specific matches first, since
    212       1.239   thorpej  * a simple globbing routine is used for matching.
    213       1.239   thorpej  */
    214       1.239   thorpej static const struct wd_quirk {
    215       1.239   thorpej 	const char *wdq_match;		/* inquiry pattern to match */
    216       1.239   thorpej 	int wdq_quirks;			/* drive quirks */
    217       1.239   thorpej } wd_quirk_table[] = {
    218       1.239   thorpej 	/*
    219       1.239   thorpej 	 * Some Seagate S-ATA drives have a PHY which can get confused
    220       1.239   thorpej 	 * with the way data is packetized by some S-ATA controllers.
    221       1.239   thorpej 	 *
    222       1.246     mason 	 * The work-around is to split in two any write transfer whose
    223       1.239   thorpej 	 * sector count % 15 == 1 (assuming 512 byte sectors).
    224       1.239   thorpej 	 *
    225       1.239   thorpej 	 * XXX This is an incomplete list.  There are at least a couple
    226       1.239   thorpej 	 * XXX more model numbers.  If you have trouble with such transfers
    227       1.239   thorpej 	 * XXX (8K is the most common) on Seagate S-ATA drives, please
    228       1.269    keihan 	 * XXX notify thorpej (at) NetBSD.org.
    229       1.239   thorpej 	 */
    230       1.239   thorpej 	{ "ST3120023AS",
    231       1.247  explorer 	  WD_QUIRK_SPLIT_MOD15_WRITE },
    232       1.247  explorer 	{ "ST380023AS",
    233       1.239   thorpej 	  WD_QUIRK_SPLIT_MOD15_WRITE },
    234       1.239   thorpej 
    235       1.295    bouyer 	/*
    236       1.306    bouyer 	 * These seagate drives seems to have issue addressing sector 0xfffffff
    237       1.295    bouyer 	 * (aka LBA48_THRESHOLD) in LBA mode. The workaround is to force
    238       1.295    bouyer 	 * LBA48
    239       1.306    bouyer 	 * Note that we can't just change the code to always use LBA48 for
    240       1.306    bouyer 	 * sector 0xfffffff, because this would break valid and working
    241       1.306    bouyer 	 * setups using LBA48 drives on non-LBA48-capable controllers
    242       1.306    bouyer 	 * (and it's hard to get a list of such controllers)
    243       1.295    bouyer 	 */
    244       1.326  gendalia 	{ "ST3160021A*",
    245       1.326  gendalia 	  WD_QUIRK_FORCE_LBA48 },
    246       1.334    bouyer 	{ "ST3160811A*",
    247       1.334    bouyer 	  WD_QUIRK_FORCE_LBA48 },
    248       1.324    bouyer 	{ "ST3160812A*",
    249       1.324    bouyer 	  WD_QUIRK_FORCE_LBA48 },
    250       1.304    bouyer 	{ "ST3160023A*",
    251       1.304    bouyer 	  WD_QUIRK_FORCE_LBA48 },
    252       1.305   dsainty 	{ "ST3160827A*",
    253       1.305   dsainty 	  WD_QUIRK_FORCE_LBA48 },
    254       1.311       riz 	/* Attempt to catch all seagate drives larger than 200GB */
    255       1.325    bouyer 	{ "ST3[2-9][0-9][0-9][0-9][0-9][0-9][A-Z]*",
    256       1.295    bouyer 	  WD_QUIRK_FORCE_LBA48 },
    257       1.239   thorpej 	{ NULL,
    258       1.239   thorpej 	  0 }
    259       1.239   thorpej };
    260       1.239   thorpej 
    261       1.239   thorpej static const struct wd_quirk *
    262       1.239   thorpej wd_lookup_quirks(const char *name)
    263       1.239   thorpej {
    264       1.239   thorpej 	const struct wd_quirk *wdq;
    265       1.239   thorpej 	const char *estr;
    266       1.239   thorpej 
    267       1.239   thorpej 	for (wdq = wd_quirk_table; wdq->wdq_match != NULL; wdq++) {
    268       1.239   thorpej 		/*
    269       1.239   thorpej 		 * We only want exact matches (which include matches
    270       1.239   thorpej 		 * against globbing characters).
    271       1.239   thorpej 		 */
    272       1.239   thorpej 		if (pmatch(name, wdq->wdq_match, &estr) == 2)
    273       1.239   thorpej 			return (wdq);
    274       1.239   thorpej 	}
    275       1.239   thorpej 	return (NULL);
    276       1.239   thorpej }
    277       1.239   thorpej 
    278         1.1       cgd int
    279       1.335  christos wdprobe(struct device *parent, struct cfdata *match, void *aux)
    280         1.1       cgd {
    281       1.216    bouyer 	struct ata_device *adev = aux;
    282       1.167   thorpej 
    283       1.216    bouyer 	if (adev == NULL)
    284       1.181    bouyer 		return 0;
    285       1.216    bouyer 	if (adev->adev_bustype->bustype_type != SCSIPI_BUSTYPE_ATA)
    286        1.64   mycroft 		return 0;
    287       1.181    bouyer 
    288       1.263    bouyer 	if (match->cf_loc[ATA_HLCF_DRIVE] != ATA_HLCF_DRIVE_DEFAULT &&
    289       1.263    bouyer 	    match->cf_loc[ATA_HLCF_DRIVE] != adev->adev_drv_data->drive)
    290        1.74   mycroft 		return 0;
    291        1.74   mycroft 	return 1;
    292        1.74   mycroft }
    293        1.64   mycroft 
    294        1.74   mycroft void
    295       1.335  christos wdattach(struct device *parent, struct device *self, void *aux)
    296        1.74   mycroft {
    297        1.74   mycroft 	struct wd_softc *wd = (void *)self;
    298       1.216    bouyer 	struct ata_device *adev= aux;
    299        1.74   mycroft 	int i, blank;
    300       1.301  christos 	char tbuf[41], pbuf[9], c, *p, *q;
    301       1.239   thorpej 	const struct wd_quirk *wdq;
    302       1.289   thorpej 	ATADEBUG_PRINT(("wdattach\n"), DEBUG_FUNCS | DEBUG_PROBE);
    303        1.56   mycroft 
    304   1.337.2.5        ad 	callout_init(&wd->sc_restart_ch, 0);
    305       1.312      yamt 	bufq_alloc(&wd->sc_q, BUFQ_DISK_DEFAULT_STRAT, BUFQ_SORT_RAWBLOCK);
    306       1.292  drochner #ifdef WD_SOFTBADSECT
    307       1.241   darrenr 	SLIST_INIT(&wd->sc_bslist);
    308       1.292  drochner #endif
    309       1.217    bouyer 	wd->atabus = adev->adev_bustype;
    310       1.216    bouyer 	wd->openings = adev->adev_openings;
    311       1.235    simonb 	wd->drvp = adev->adev_drv_data;
    312       1.270   thorpej 
    313       1.270   thorpej 	wd->drvp->drv_done = wddone;
    314       1.181    bouyer 	wd->drvp->drv_softc = &wd->sc_dev;
    315       1.181    bouyer 
    316       1.253   thorpej 	aprint_naive("\n");
    317       1.253   thorpej 
    318       1.181    bouyer 	/* read our drive info */
    319       1.261   mycroft 	if (wd_get_params(wd, AT_WAIT, &wd->sc_params) != 0) {
    320       1.253   thorpej 		aprint_error("\n%s: IDENTIFY failed\n", wd->sc_dev.dv_xname);
    321       1.181    bouyer 		return;
    322       1.181    bouyer 	}
    323       1.163    bouyer 
    324       1.301  christos 	for (blank = 0, p = wd->sc_params.atap_model, q = tbuf, i = 0;
    325       1.181    bouyer 	    i < sizeof(wd->sc_params.atap_model); i++) {
    326       1.135   mycroft 		c = *p++;
    327       1.135   mycroft 		if (c == '\0')
    328       1.135   mycroft 			break;
    329       1.135   mycroft 		if (c != ' ') {
    330       1.135   mycroft 			if (blank) {
    331       1.135   mycroft 				*q++ = ' ';
    332       1.135   mycroft 				blank = 0;
    333       1.135   mycroft 			}
    334       1.135   mycroft 			*q++ = c;
    335       1.135   mycroft 		} else
    336       1.135   mycroft 			blank = 1;
    337       1.195     enami 	}
    338       1.135   mycroft 	*q++ = '\0';
    339       1.135   mycroft 
    340       1.301  christos 	aprint_normal(": <%s>\n", tbuf);
    341       1.113   mycroft 
    342       1.301  christos 	wdq = wd_lookup_quirks(tbuf);
    343       1.239   thorpej 	if (wdq != NULL)
    344       1.239   thorpej 		wd->sc_quirks = wdq->wdq_quirks;
    345       1.239   thorpej 
    346       1.327     lukem 	if (wd->sc_quirks != 0) {
    347       1.327     lukem 		char sbuf[sizeof(WD_QUIRK_FMT) + 64];
    348       1.327     lukem 		bitmask_snprintf(wd->sc_quirks, WD_QUIRK_FMT,
    349       1.327     lukem 		    sbuf, sizeof(sbuf));
    350       1.327     lukem 		aprint_normal("%s: quirks %s\n", wd->sc_dev.dv_xname, sbuf);
    351       1.327     lukem 	}
    352       1.327     lukem 
    353       1.181    bouyer 	if ((wd->sc_params.atap_multi & 0xff) > 1) {
    354       1.181    bouyer 		wd->sc_multi = wd->sc_params.atap_multi & 0xff;
    355       1.113   mycroft 	} else {
    356       1.181    bouyer 		wd->sc_multi = 1;
    357       1.113   mycroft 	}
    358       1.113   mycroft 
    359       1.336        ad 	aprint_verbose("%s: drive supports %d-sector PIO transfers,",
    360       1.184    bouyer 	    wd->sc_dev.dv_xname, wd->sc_multi);
    361       1.172   mycroft 
    362       1.220  christos 	/* 48-bit LBA addressing */
    363       1.268      yamt 	if ((wd->sc_params.atap_cmd2_en & ATA_CMD2_LBA48) != 0)
    364       1.220  christos 		wd->sc_flags |= WDF_LBA48;
    365       1.220  christos 
    366       1.172   mycroft 	/* Prior to ATA-4, LBA was optional. */
    367       1.181    bouyer 	if ((wd->sc_params.atap_capabilities1 & WDC_CAP_LBA) != 0)
    368       1.181    bouyer 		wd->sc_flags |= WDF_LBA;
    369       1.174   mycroft #if 0
    370       1.172   mycroft 	/* ATA-4 requires LBA. */
    371       1.181    bouyer 	if (wd->sc_params.atap_ataversion != 0xffff &&
    372       1.181    bouyer 	    wd->sc_params.atap_ataversion >= WDC_VER_ATA4)
    373       1.181    bouyer 		wd->sc_flags |= WDF_LBA;
    374       1.174   mycroft #endif
    375       1.172   mycroft 
    376       1.220  christos 	if ((wd->sc_flags & WDF_LBA48) != 0) {
    377       1.336        ad 		aprint_verbose(" LBA48 addressing\n");
    378       1.220  christos 		wd->sc_capacity =
    379       1.220  christos 		    ((u_int64_t) wd->sc_params.__reserved6[11] << 48) |
    380       1.220  christos 		    ((u_int64_t) wd->sc_params.__reserved6[10] << 32) |
    381       1.220  christos 		    ((u_int64_t) wd->sc_params.__reserved6[9]  << 16) |
    382       1.220  christos 		    ((u_int64_t) wd->sc_params.__reserved6[8]  << 0);
    383       1.220  christos 	} else if ((wd->sc_flags & WDF_LBA) != 0) {
    384       1.336        ad 		aprint_verbose(" LBA addressing\n");
    385       1.181    bouyer 		wd->sc_capacity =
    386       1.318       abs 		    ((u_int64_t)wd->sc_params.atap_capacity[1] << 16) |
    387       1.181    bouyer 		    wd->sc_params.atap_capacity[0];
    388       1.172   mycroft 	} else {
    389       1.336        ad 		aprint_verbose(" chs addressing\n");
    390       1.181    bouyer 		wd->sc_capacity =
    391       1.181    bouyer 		    wd->sc_params.atap_cylinders *
    392       1.181    bouyer 		    wd->sc_params.atap_heads *
    393       1.181    bouyer 		    wd->sc_params.atap_sectors;
    394       1.172   mycroft 	}
    395       1.240      fvdl 	format_bytes(pbuf, sizeof(pbuf), wd->sc_capacity * DEV_BSIZE);
    396       1.253   thorpej 	aprint_normal("%s: %s, %d cyl, %d head, %d sec, "
    397       1.240      fvdl 	    "%d bytes/sect x %llu sectors\n",
    398       1.260    bouyer 	    self->dv_xname, pbuf,
    399       1.260    bouyer 	    (wd->sc_flags & WDF_LBA) ? (int)(wd->sc_capacity /
    400       1.260    bouyer 		(wd->sc_params.atap_heads * wd->sc_params.atap_sectors)) :
    401       1.260    bouyer 		wd->sc_params.atap_cylinders,
    402       1.201     enami 	    wd->sc_params.atap_heads, wd->sc_params.atap_sectors,
    403       1.240      fvdl 	    DEV_BSIZE, (unsigned long long)wd->sc_capacity);
    404       1.201     enami 
    405       1.289   thorpej 	ATADEBUG_PRINT(("%s: atap_dmatiming_mimi=%d, atap_dmatiming_recom=%d\n",
    406       1.181    bouyer 	    self->dv_xname, wd->sc_params.atap_dmatiming_mimi,
    407       1.181    bouyer 	    wd->sc_params.atap_dmatiming_recom), DEBUG_PROBE);
    408       1.181    bouyer 	/*
    409       1.181    bouyer 	 * Initialize and attach the disk structure.
    410       1.181    bouyer 	 */
    411       1.332   thorpej 	/* we fill in dk_info later */
    412   1.337.2.8        ad 	disk_init(&wd->sc_dk, wd->sc_dev.dv_xname, &wddkdriver);
    413       1.181    bouyer 	disk_attach(&wd->sc_dk);
    414       1.181    bouyer 	wd->sc_wdc_bio.lp = wd->sc_dk.dk_label;
    415       1.196     enami 	wd->sc_sdhook = shutdownhook_establish(wd_shutdown, wd);
    416       1.196     enami 	if (wd->sc_sdhook == NULL)
    417       1.253   thorpej 		aprint_error("%s: WARNING: unable to establish shutdown hook\n",
    418       1.259       dsl 		    wd->sc_dev.dv_xname);
    419       1.166  explorer #if NRND > 0
    420       1.193  explorer 	rnd_attach_source(&wd->rnd_source, wd->sc_dev.dv_xname,
    421       1.193  explorer 			  RND_TYPE_DISK, 0);
    422       1.166  explorer #endif
    423       1.294   thorpej 
    424       1.294   thorpej 	/* Discover wedges on this disk. */
    425       1.294   thorpej 	dkwedge_discover(&wd->sc_dk);
    426       1.196     enami }
    427       1.196     enami 
    428       1.196     enami int
    429       1.335  christos wdactivate(struct device *self, enum devact act)
    430       1.196     enami {
    431       1.196     enami 	int rv = 0;
    432       1.196     enami 
    433       1.196     enami 	switch (act) {
    434       1.196     enami 	case DVACT_ACTIVATE:
    435       1.196     enami 		rv = EOPNOTSUPP;
    436       1.196     enami 		break;
    437       1.196     enami 
    438       1.196     enami 	case DVACT_DEACTIVATE:
    439       1.196     enami 		/*
    440       1.196     enami 		 * Nothing to do; we key off the device's DVF_ACTIVATE.
    441       1.196     enami 		 */
    442       1.196     enami 		break;
    443       1.196     enami 	}
    444       1.196     enami 	return (rv);
    445       1.196     enami }
    446       1.196     enami 
    447       1.196     enami int
    448       1.335  christos wddetach(struct device *self, int flags)
    449       1.196     enami {
    450       1.196     enami 	struct wd_softc *sc = (struct wd_softc *)self;
    451       1.213  drochner 	int s, bmaj, cmaj, i, mn;
    452       1.196     enami 
    453       1.196     enami 	/* locate the major number */
    454       1.225   gehenna 	bmaj = bdevsw_lookup_major(&wd_bdevsw);
    455       1.225   gehenna 	cmaj = cdevsw_lookup_major(&wd_cdevsw);
    456       1.196     enami 
    457       1.286   mycroft 	/* Nuke the vnodes for any open instances. */
    458       1.286   mycroft 	for (i = 0; i < MAXPARTITIONS; i++) {
    459       1.321   thorpej 		mn = WDMINOR(device_unit(self), i);
    460       1.286   mycroft 		vdevgone(bmaj, mn, mn, VBLK);
    461       1.286   mycroft 		vdevgone(cmaj, mn, mn, VCHR);
    462       1.286   mycroft 	}
    463       1.286   mycroft 
    464       1.294   thorpej 	/* Delete all of our wedges. */
    465       1.294   thorpej 	dkwedge_delall(&sc->sc_dk);
    466       1.294   thorpej 
    467       1.196     enami 	s = splbio();
    468       1.196     enami 
    469       1.259       dsl 	/* Kill off any queued buffers. */
    470       1.312      yamt 	bufq_drain(sc->sc_q);
    471       1.224   hannken 
    472       1.312      yamt 	bufq_free(sc->sc_q);
    473       1.285    bouyer 	sc->atabus->ata_killpending(sc->drvp);
    474       1.196     enami 
    475       1.196     enami 	splx(s);
    476       1.196     enami 
    477       1.196     enami 	/* Detach disk. */
    478       1.196     enami 	disk_detach(&sc->sc_dk);
    479       1.196     enami 
    480       1.292  drochner #ifdef WD_SOFTBADSECT
    481       1.282    bouyer 	/* Clean out the bad sector list */
    482       1.282    bouyer 	while (!SLIST_EMPTY(&sc->sc_bslist)) {
    483       1.282    bouyer 		void *head = SLIST_FIRST(&sc->sc_bslist);
    484       1.282    bouyer 		SLIST_REMOVE_HEAD(&sc->sc_bslist, dbs_next);
    485       1.282    bouyer 		free(head, M_TEMP);
    486       1.282    bouyer 	}
    487       1.282    bouyer 	sc->sc_bscount = 0;
    488       1.292  drochner #endif
    489       1.282    bouyer 
    490       1.196     enami 	/* Get rid of the shutdown hook. */
    491       1.196     enami 	if (sc->sc_sdhook != NULL)
    492       1.196     enami 		shutdownhook_disestablish(sc->sc_sdhook);
    493       1.196     enami 
    494       1.196     enami #if NRND > 0
    495       1.196     enami 	/* Unhook the entropy source. */
    496       1.196     enami 	rnd_detach_source(&sc->rnd_source);
    497       1.196     enami #endif
    498       1.196     enami 
    499       1.284    bouyer 	sc->drvp->drive_flags = 0; /* no drive any more here */
    500       1.283    bouyer 
    501       1.196     enami 	return (0);
    502         1.1       cgd }
    503         1.1       cgd 
    504        1.64   mycroft /*
    505       1.135   mycroft  * Read/write routine for a buffer.  Validates the arguments and schedules the
    506       1.135   mycroft  * transfer.  Does not wait for the transfer to complete.
    507         1.1       cgd  */
    508        1.64   mycroft void
    509       1.259       dsl wdstrategy(struct buf *bp)
    510         1.1       cgd {
    511       1.209   thorpej 	struct wd_softc *wd = device_lookup(&wd_cd, WDUNIT(bp->b_dev));
    512       1.202   thorpej 	struct disklabel *lp = wd->sc_dk.dk_label;
    513       1.202   thorpej 	daddr_t blkno;
    514   1.337.2.7        ad 	int s;
    515       1.202   thorpej 
    516       1.289   thorpej 	ATADEBUG_PRINT(("wdstrategy (%s)\n", wd->sc_dev.dv_xname),
    517       1.182    bouyer 	    DEBUG_XFERS);
    518       1.259       dsl 
    519       1.135   mycroft 	/* Valid request?  */
    520       1.135   mycroft 	if (bp->b_blkno < 0 ||
    521       1.202   thorpej 	    (bp->b_bcount % lp->d_secsize) != 0 ||
    522       1.202   thorpej 	    (bp->b_bcount / lp->d_secsize) >= (1 << NBBY)) {
    523   1.337.2.7        ad 		bp->b_error = EINVAL;
    524   1.337.2.3        ad 		goto done;
    525         1.1       cgd 	}
    526       1.259       dsl 
    527       1.135   mycroft 	/* If device invalidated (e.g. media change, door open), error. */
    528       1.181    bouyer 	if ((wd->sc_flags & WDF_LOADED) == 0) {
    529   1.337.2.7        ad 		bp->b_error = EIO;
    530   1.337.2.3        ad 		goto done;
    531       1.135   mycroft 	}
    532       1.135   mycroft 
    533        1.93   mycroft 	/* If it's a null transfer, return immediately. */
    534        1.93   mycroft 	if (bp->b_bcount == 0)
    535        1.93   mycroft 		goto done;
    536        1.93   mycroft 
    537       1.128   mycroft 	/*
    538       1.128   mycroft 	 * Do bounds checking, adjust transfer. if error, process.
    539       1.128   mycroft 	 * If end of partition, just return.
    540       1.128   mycroft 	 */
    541       1.240      fvdl 	if (WDPART(bp->b_dev) == RAW_PART) {
    542       1.240      fvdl 		if (bounds_check_with_mediasize(bp, DEV_BSIZE,
    543       1.240      fvdl 		    wd->sc_capacity) <= 0)
    544       1.240      fvdl 			goto done;
    545       1.240      fvdl 	} else {
    546       1.252   thorpej 		if (bounds_check_with_label(&wd->sc_dk, bp,
    547       1.240      fvdl 		    (wd->sc_flags & (WDF_WLABEL|WDF_LABELLING)) != 0) <= 0)
    548       1.240      fvdl 			goto done;
    549       1.240      fvdl 	}
    550       1.202   thorpej 
    551       1.202   thorpej 	/*
    552       1.202   thorpej 	 * Now convert the block number to absolute and put it in
    553       1.202   thorpej 	 * terms of the device's logical block size.
    554       1.202   thorpej 	 */
    555       1.202   thorpej 	if (lp->d_secsize >= DEV_BSIZE)
    556       1.202   thorpej 		blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);
    557       1.202   thorpej 	else
    558       1.202   thorpej 		blkno = bp->b_blkno * (DEV_BSIZE / lp->d_secsize);
    559       1.202   thorpej 
    560       1.202   thorpej 	if (WDPART(bp->b_dev) != RAW_PART)
    561       1.202   thorpej 		blkno += lp->d_partitions[WDPART(bp->b_dev)].p_offset;
    562       1.202   thorpej 
    563       1.202   thorpej 	bp->b_rawblkno = blkno;
    564       1.202   thorpej 
    565       1.292  drochner #ifdef WD_SOFTBADSECT
    566       1.241   darrenr 	/*
    567       1.241   darrenr 	 * If the transfer about to be attempted contains only a block that
    568       1.241   darrenr 	 * is known to be bad then return an error for the transfer without
    569       1.241   darrenr 	 * even attempting to start a transfer up under the premis that we
    570       1.241   darrenr 	 * will just end up doing more retries for a transfer that will end
    571       1.241   darrenr 	 * up failing again.
    572       1.241   darrenr 	 * XXX:SMP - mutex required to protect with DIOCBSFLUSH
    573       1.241   darrenr 	 */
    574       1.241   darrenr 	if (__predict_false(!SLIST_EMPTY(&wd->sc_bslist))) {
    575       1.241   darrenr 		struct disk_badsectors *dbs;
    576       1.278   mycroft 		daddr_t maxblk = blkno + (bp->b_bcount >> DEV_BSHIFT) - 1;
    577       1.241   darrenr 
    578       1.241   darrenr 		SLIST_FOREACH(dbs, &wd->sc_bslist, dbs_next)
    579       1.243   darrenr 			if ((dbs->dbs_min <= blkno && blkno <= dbs->dbs_max) ||
    580       1.245   darrenr 			    (dbs->dbs_min <= maxblk && maxblk <= dbs->dbs_max)){
    581       1.245   darrenr 				bp->b_error = EIO;
    582   1.337.2.7        ad 				goto done;
    583       1.245   darrenr 			}
    584       1.241   darrenr 	}
    585       1.292  drochner #endif
    586       1.241   darrenr 
    587        1.64   mycroft 	/* Queue transfer on drive, activate drive and controller if idle. */
    588         1.1       cgd 	s = splbio();
    589       1.312      yamt 	BUFQ_PUT(wd->sc_q, bp);
    590       1.163    bouyer 	wdstart(wd);
    591         1.1       cgd 	splx(s);
    592        1.64   mycroft 	return;
    593         1.1       cgd done:
    594        1.64   mycroft 	/* Toss transfer; we're done early. */
    595   1.337.2.7        ad 	bp->b_resid = bp->b_bcount;
    596   1.337.2.7        ad 	biodone(bp);
    597         1.1       cgd }
    598         1.1       cgd 
    599         1.1       cgd /*
    600       1.135   mycroft  * Queue a drive for I/O.
    601         1.1       cgd  */
    602       1.108   mycroft void
    603       1.259       dsl wdstart(void *arg)
    604         1.1       cgd {
    605       1.163    bouyer 	struct wd_softc *wd = arg;
    606       1.200   thorpej 	struct buf *bp = NULL;
    607       1.163    bouyer 
    608       1.289   thorpej 	ATADEBUG_PRINT(("wdstart %s\n", wd->sc_dev.dv_xname),
    609       1.182    bouyer 	    DEBUG_XFERS);
    610       1.181    bouyer 	while (wd->openings > 0) {
    611       1.163    bouyer 
    612       1.163    bouyer 		/* Is there a buf for us ? */
    613       1.312      yamt 		if ((bp = BUFQ_GET(wd->sc_q)) == NULL)
    614       1.200   thorpej 			return;
    615       1.259       dsl 
    616       1.259       dsl 		/*
    617       1.163    bouyer 		 * Make the command. First lock the device
    618       1.163    bouyer 		 */
    619       1.181    bouyer 		wd->openings--;
    620       1.181    bouyer 
    621       1.181    bouyer 		wd->retries = 0;
    622       1.181    bouyer 		__wdstart(wd, bp);
    623       1.181    bouyer 	}
    624       1.181    bouyer }
    625       1.181    bouyer 
    626       1.239   thorpej static void
    627       1.239   thorpej wd_split_mod15_write(struct buf *bp)
    628       1.239   thorpej {
    629       1.239   thorpej 	struct buf *obp = bp->b_private;
    630       1.239   thorpej 	struct wd_softc *sc = wd_cd.cd_devs[DISKUNIT(obp->b_dev)];
    631       1.239   thorpej 
    632   1.337.2.7        ad 	if (__predict_false(bp->b_error != 0)) {
    633       1.239   thorpej 		/*
    634       1.239   thorpej 		 * Propagate the error.  If this was the first half of
    635       1.239   thorpej 		 * the original transfer, make sure to account for that
    636       1.239   thorpej 		 * in the residual.
    637       1.239   thorpej 		 */
    638       1.239   thorpej 		if (bp->b_data == obp->b_data)
    639       1.239   thorpej 			bp->b_resid += bp->b_bcount;
    640       1.239   thorpej 		goto done;
    641       1.239   thorpej 	}
    642       1.239   thorpej 
    643       1.239   thorpej 	/*
    644       1.239   thorpej 	 * If this was the second half of the transfer, we're all done!
    645       1.239   thorpej 	 */
    646       1.239   thorpej 	if (bp->b_data != obp->b_data)
    647       1.239   thorpej 		goto done;
    648       1.239   thorpej 
    649       1.239   thorpej 	/*
    650       1.239   thorpej 	 * Advance the pointer to the second half and issue that command
    651       1.239   thorpej 	 * using the same opening.
    652       1.239   thorpej 	 */
    653   1.337.2.9        ad 	bp->b_flags = obp->b_flags;
    654   1.337.2.9        ad 	bp->b_oflags = obp->b_oflags;
    655   1.337.2.9        ad 	bp->b_cflags = obp->b_cflags;
    656       1.337  christos 	bp->b_data = (char *)bp->b_data + bp->b_bcount;
    657       1.239   thorpej 	bp->b_blkno += (bp->b_bcount / 512);
    658       1.239   thorpej 	bp->b_rawblkno += (bp->b_bcount / 512);
    659       1.239   thorpej 	__wdstart(sc, bp);
    660       1.239   thorpej 	return;
    661       1.239   thorpej 
    662       1.239   thorpej  done:
    663   1.337.2.7        ad 	obp->b_error = bp->b_error;
    664   1.337.2.7        ad 	obp->b_resid = bp->b_resid;
    665       1.316      yamt 	putiobuf(bp);
    666   1.337.2.7        ad 	biodone(obp);
    667       1.239   thorpej 	sc->openings++;
    668       1.239   thorpej 	/* wddone() will call wdstart() */
    669       1.239   thorpej }
    670       1.239   thorpej 
    671       1.181    bouyer void
    672       1.259       dsl __wdstart(struct wd_softc *wd, struct buf *bp)
    673       1.181    bouyer {
    674       1.202   thorpej 
    675       1.239   thorpej 	/*
    676       1.239   thorpej 	 * Deal with the "split mod15 write" quirk.  We just divide the
    677       1.239   thorpej 	 * transfer in two, doing the first half and then then second half
    678       1.239   thorpej 	 * with the same command opening.
    679       1.239   thorpej 	 *
    680       1.239   thorpej 	 * Note we MUST do this here, because we can't let insertion
    681       1.239   thorpej 	 * into the bufq cause the transfers to be re-merged.
    682       1.239   thorpej 	 */
    683       1.239   thorpej 	if (__predict_false((wd->sc_quirks & WD_QUIRK_SPLIT_MOD15_WRITE) != 0 &&
    684       1.239   thorpej 			    (bp->b_flags & B_READ) == 0 &&
    685       1.239   thorpej 			    bp->b_bcount > 512 &&
    686       1.239   thorpej 			    ((bp->b_bcount / 512) % 15) == 1)) {
    687       1.239   thorpej 		struct buf *nbp;
    688       1.239   thorpej 
    689       1.239   thorpej 		/* already at splbio */
    690   1.337.2.9        ad 		nbp = getiobuf(NULL, false);
    691       1.239   thorpej 		if (__predict_false(nbp == NULL)) {
    692       1.239   thorpej 			/* No memory -- fail the iop. */
    693   1.337.2.7        ad 			bp->b_error = ENOMEM;
    694   1.337.2.7        ad 			bp->b_resid = bp->b_bcount;
    695   1.337.2.7        ad 			biodone(bp);
    696       1.239   thorpej 			wd->openings++;
    697       1.239   thorpej 			return;
    698       1.239   thorpej 		}
    699       1.239   thorpej 
    700       1.239   thorpej 		nbp->b_error = 0;
    701       1.239   thorpej 		nbp->b_proc = bp->b_proc;
    702       1.239   thorpej 		nbp->b_dev = bp->b_dev;
    703       1.239   thorpej 
    704       1.239   thorpej 		nbp->b_bcount = bp->b_bcount / 2;
    705       1.239   thorpej 		nbp->b_bufsize = bp->b_bcount / 2;
    706       1.239   thorpej 		nbp->b_data = bp->b_data;
    707       1.239   thorpej 
    708       1.239   thorpej 		nbp->b_blkno = bp->b_blkno;
    709       1.239   thorpej 		nbp->b_rawblkno = bp->b_rawblkno;
    710       1.239   thorpej 
    711   1.337.2.9        ad 		nbp->b_flags = bp->b_flags;
    712   1.337.2.9        ad 		nbp->b_oflags = bp->b_oflags;
    713   1.337.2.9        ad 		nbp->b_cflags = bp->b_cflags;
    714       1.239   thorpej 		nbp->b_iodone = wd_split_mod15_write;
    715       1.239   thorpej 
    716       1.239   thorpej 		/* Put ptr to orig buf in b_private and use new buf */
    717       1.239   thorpej 		nbp->b_private = bp;
    718       1.273      yamt 
    719       1.273      yamt 		BIO_COPYPRIO(nbp, bp);
    720       1.273      yamt 
    721       1.239   thorpej 		bp = nbp;
    722       1.239   thorpej 	}
    723       1.239   thorpej 
    724       1.202   thorpej 	wd->sc_wdc_bio.blkno = bp->b_rawblkno;
    725       1.181    bouyer 	wd->sc_wdc_bio.blkdone =0;
    726       1.181    bouyer 	wd->sc_bp = bp;
    727       1.181    bouyer 	/*
    728       1.181    bouyer 	 * If we're retrying, retry in single-sector mode. This will give us
    729       1.181    bouyer 	 * the sector number of the problem, and will eventually allow the
    730       1.184    bouyer 	 * transfer to succeed.
    731       1.181    bouyer 	 */
    732       1.279   mycroft 	if (wd->retries >= WDIORETRIES_SINGLE)
    733       1.181    bouyer 		wd->sc_wdc_bio.flags = ATA_SINGLE;
    734       1.181    bouyer 	else
    735       1.181    bouyer 		wd->sc_wdc_bio.flags = 0;
    736       1.295    bouyer 	if (wd->sc_flags & WDF_LBA48 &&
    737       1.295    bouyer 	    (wd->sc_wdc_bio.blkno > LBA48_THRESHOLD ||
    738       1.295    bouyer 	    (wd->sc_quirks & WD_QUIRK_FORCE_LBA48) != 0))
    739       1.220  christos 		wd->sc_wdc_bio.flags |= ATA_LBA48;
    740       1.181    bouyer 	if (wd->sc_flags & WDF_LBA)
    741       1.181    bouyer 		wd->sc_wdc_bio.flags |= ATA_LBA;
    742       1.181    bouyer 	if (bp->b_flags & B_READ)
    743       1.181    bouyer 		wd->sc_wdc_bio.flags |= ATA_READ;
    744       1.181    bouyer 	wd->sc_wdc_bio.bcount = bp->b_bcount;
    745       1.181    bouyer 	wd->sc_wdc_bio.databuf = bp->b_data;
    746       1.181    bouyer 	/* Instrumentation. */
    747       1.181    bouyer 	disk_busy(&wd->sc_dk);
    748       1.217    bouyer 	switch (wd->atabus->ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
    749       1.288   thorpej 	case ATACMD_TRY_AGAIN:
    750       1.203   thorpej 		callout_reset(&wd->sc_restart_ch, hz, wdrestart, wd);
    751       1.181    bouyer 		break;
    752       1.288   thorpej 	case ATACMD_QUEUED:
    753       1.288   thorpej 	case ATACMD_COMPLETE:
    754       1.181    bouyer 		break;
    755       1.181    bouyer 	default:
    756       1.217    bouyer 		panic("__wdstart: bad return code from ata_bio()");
    757       1.181    bouyer 	}
    758       1.181    bouyer }
    759       1.181    bouyer 
    760       1.181    bouyer void
    761       1.259       dsl wddone(void *v)
    762       1.181    bouyer {
    763       1.181    bouyer 	struct wd_softc *wd = v;
    764       1.181    bouyer 	struct buf *bp = wd->sc_bp;
    765       1.221      yamt 	const char *errmsg;
    766   1.337.2.7        ad 	int do_perror = 0;
    767       1.289   thorpej 	ATADEBUG_PRINT(("wddone %s\n", wd->sc_dev.dv_xname),
    768       1.182    bouyer 	    DEBUG_XFERS);
    769  1.337.2.10        ad 	int nblks;
    770       1.181    bouyer 
    771       1.214     bjh21 	if (bp == NULL)
    772       1.214     bjh21 		return;
    773       1.181    bouyer 	bp->b_resid = wd->sc_wdc_bio.bcount;
    774       1.181    bouyer 	switch (wd->sc_wdc_bio.error) {
    775       1.181    bouyer 	case ERR_DMA:
    776       1.221      yamt 		errmsg = "DMA error";
    777       1.181    bouyer 		goto retry;
    778       1.181    bouyer 	case ERR_DF:
    779       1.221      yamt 		errmsg = "device fault";
    780       1.181    bouyer 		goto retry;
    781       1.181    bouyer 	case TIMEOUT:
    782       1.221      yamt 		errmsg = "device timeout";
    783       1.181    bouyer 		goto retry;
    784       1.281    bouyer 	case ERR_RESET:
    785       1.281    bouyer 		errmsg = "channel reset";
    786       1.281    bouyer 		goto retry2;
    787       1.181    bouyer 	case ERROR:
    788       1.181    bouyer 		/* Don't care about media change bits */
    789       1.181    bouyer 		if (wd->sc_wdc_bio.r_error != 0 &&
    790       1.181    bouyer 		    (wd->sc_wdc_bio.r_error & ~(WDCE_MC | WDCE_MCR)) == 0)
    791       1.181    bouyer 			goto noerror;
    792       1.221      yamt 		errmsg = "error";
    793       1.221      yamt 		do_perror = 1;
    794  1.337.2.10        ad 		if (wd->sc_wdc_bio.r_error & WDCE_IDNF &&
    795  1.337.2.10        ad 		    (wd->sc_quirks & WD_QUIRK_FORCE_LBA48) == 0) {
    796  1.337.2.10        ad 			nblks = wd->sc_wdc_bio.bcount /
    797  1.337.2.10        ad 			    wd->sc_dk.dk_label->d_secsize;
    798  1.337.2.10        ad 			/*
    799  1.337.2.10        ad 			 * If we get a "id not found" when crossing the
    800  1.337.2.10        ad 			 * LBA48_THRESHOLD, and the drive is larger than
    801  1.337.2.10        ad 			 * 128GB, then we can assume the drive has the
    802  1.337.2.10        ad 			 * LBA48 bug and we switch to LBA48.
    803  1.337.2.10        ad 			 */
    804  1.337.2.10        ad 			if (wd->sc_wdc_bio.blkno <= LBA48_THRESHOLD &&
    805  1.337.2.10        ad 			    wd->sc_wdc_bio.blkno + nblks > LBA48_THRESHOLD &&
    806  1.337.2.10        ad 			    wd->sc_capacity > LBA48_THRESHOLD + 1) {
    807  1.337.2.10        ad 				errmsg = "LBA48 bug";
    808  1.337.2.10        ad 				wd->sc_quirks |= WD_QUIRK_FORCE_LBA48;
    809  1.337.2.10        ad 				do_perror = 0;
    810  1.337.2.10        ad 				goto retry2;
    811  1.337.2.10        ad 			}
    812  1.337.2.10        ad 		}
    813       1.181    bouyer retry:		/* Just reset and retry. Can we do more ? */
    814       1.293    bouyer 		(*wd->atabus->ata_reset_drive)(wd->drvp, AT_RST_NOCMD);
    815       1.281    bouyer retry2:
    816       1.221      yamt 		diskerr(bp, "wd", errmsg, LOG_PRINTF,
    817       1.181    bouyer 		    wd->sc_wdc_bio.blkdone, wd->sc_dk.dk_label);
    818       1.221      yamt 		if (wd->retries < WDIORETRIES)
    819  1.337.2.10        ad 			printf(", retrying");
    820  1.337.2.10        ad 		printf("\n");
    821       1.221      yamt 		if (do_perror)
    822       1.221      yamt 			wdperror(wd);
    823       1.221      yamt 		if (wd->retries < WDIORETRIES) {
    824       1.221      yamt 			wd->retries++;
    825       1.203   thorpej 			callout_reset(&wd->sc_restart_ch, RECOVERYTIME,
    826       1.203   thorpej 			    wdrestart, wd);
    827       1.181    bouyer 			return;
    828       1.181    bouyer 		}
    829       1.241   darrenr 
    830       1.292  drochner #ifdef WD_SOFTBADSECT
    831       1.241   darrenr 		/*
    832       1.241   darrenr 		 * Not all errors indicate a failed block but those that do,
    833       1.241   darrenr 		 * put the block on the bad-block list for the device.  Only
    834       1.241   darrenr 		 * do this for reads because the drive should do it for writes,
    835       1.241   darrenr 		 * itself, according to Manuel.
    836       1.241   darrenr 		 */
    837       1.242    dogcow 		if ((bp->b_flags & B_READ) &&
    838       1.241   darrenr 		    ((wd->drvp->ata_vers >= 4 && wd->sc_wdc_bio.r_error & 64) ||
    839       1.242    dogcow 	     	     (wd->drvp->ata_vers < 4 && wd->sc_wdc_bio.r_error & 192))) {
    840       1.241   darrenr 			struct disk_badsectors *dbs;
    841       1.241   darrenr 
    842       1.241   darrenr 			dbs = malloc(sizeof *dbs, M_TEMP, M_WAITOK);
    843       1.241   darrenr 			dbs->dbs_min = bp->b_rawblkno;
    844       1.278   mycroft 			dbs->dbs_max = dbs->dbs_min + (bp->b_bcount >> DEV_BSHIFT) - 1;
    845       1.241   darrenr 			microtime(&dbs->dbs_failedat);
    846       1.241   darrenr 			SLIST_INSERT_HEAD(&wd->sc_bslist, dbs, dbs_next);
    847       1.243   darrenr 			wd->sc_bscount++;
    848       1.241   darrenr 		}
    849       1.292  drochner #endif
    850   1.337.2.7        ad 		bp->b_error = EIO;
    851       1.181    bouyer 		break;
    852       1.181    bouyer 	case NOERROR:
    853       1.181    bouyer noerror:	if ((wd->sc_wdc_bio.flags & ATA_CORR) || wd->retries > 0)
    854       1.181    bouyer 			printf("%s: soft error (corrected)\n",
    855       1.181    bouyer 			    wd->sc_dev.dv_xname);
    856       1.197     enami 		break;
    857       1.197     enami 	case ERR_NODEV:
    858   1.337.2.7        ad 		bp->b_error = EIO;
    859       1.197     enami 		break;
    860        1.64   mycroft 	}
    861       1.232       mrg 	disk_unbusy(&wd->sc_dk, (bp->b_bcount - bp->b_resid),
    862       1.232       mrg 	    (bp->b_flags & B_READ));
    863       1.181    bouyer #if NRND > 0
    864       1.181    bouyer 	rnd_add_uint32(&wd->rnd_source, bp->b_blkno);
    865       1.181    bouyer #endif
    866       1.239   thorpej 	/* XXX Yuck, but we don't want to increment openings in this case */
    867   1.337.2.9        ad 	if (__predict_false(bp->b_iodone == wd_split_mod15_write))
    868   1.337.2.7        ad 		biodone(bp);
    869       1.239   thorpej 	else {
    870   1.337.2.7        ad 		biodone(bp);
    871       1.239   thorpej 		wd->openings++;
    872       1.239   thorpej 	}
    873       1.181    bouyer 	wdstart(wd);
    874       1.181    bouyer }
    875       1.181    bouyer 
    876       1.181    bouyer void
    877       1.259       dsl wdrestart(void *v)
    878       1.181    bouyer {
    879       1.181    bouyer 	struct wd_softc *wd = v;
    880       1.181    bouyer 	struct buf *bp = wd->sc_bp;
    881       1.181    bouyer 	int s;
    882       1.289   thorpej 	ATADEBUG_PRINT(("wdrestart %s\n", wd->sc_dev.dv_xname),
    883       1.182    bouyer 	    DEBUG_XFERS);
    884       1.181    bouyer 
    885       1.181    bouyer 	s = splbio();
    886       1.181    bouyer 	__wdstart(v, bp);
    887       1.181    bouyer 	splx(s);
    888       1.141   mycroft }
    889       1.141   mycroft 
    890       1.141   mycroft int
    891       1.335  christos wdread(dev_t dev, struct uio *uio, int flags)
    892       1.141   mycroft {
    893       1.141   mycroft 
    894       1.289   thorpej 	ATADEBUG_PRINT(("wdread\n"), DEBUG_XFERS);
    895       1.141   mycroft 	return (physio(wdstrategy, NULL, dev, B_READ, minphys, uio));
    896       1.141   mycroft }
    897       1.141   mycroft 
    898       1.141   mycroft int
    899       1.335  christos wdwrite(dev_t dev, struct uio *uio, int flags)
    900       1.141   mycroft {
    901       1.141   mycroft 
    902       1.289   thorpej 	ATADEBUG_PRINT(("wdwrite\n"), DEBUG_XFERS);
    903       1.141   mycroft 	return (physio(wdstrategy, NULL, dev, B_WRITE, minphys, uio));
    904        1.64   mycroft }
    905        1.64   mycroft 
    906         1.1       cgd int
    907       1.335  christos wdopen(dev_t dev, int flag, int fmt, struct lwp *l)
    908         1.1       cgd {
    909       1.135   mycroft 	struct wd_softc *wd;
    910       1.208   thorpej 	int part, error;
    911       1.163    bouyer 
    912       1.289   thorpej 	ATADEBUG_PRINT(("wdopen\n"), DEBUG_FUNCS);
    913       1.208   thorpej 	wd = device_lookup(&wd_cd, WDUNIT(dev));
    914       1.158        pk 	if (wd == NULL)
    915       1.208   thorpej 		return (ENXIO);
    916       1.187   thorpej 
    917       1.319   thorpej 	if (! device_is_active(&wd->sc_dev))
    918       1.283    bouyer 		return (ENODEV);
    919       1.283    bouyer 
    920       1.294   thorpej 	part = WDPART(dev);
    921       1.294   thorpej 
    922   1.337.2.8        ad 	mutex_enter(&wd->sc_dk.dk_openlock);
    923       1.294   thorpej 
    924       1.294   thorpej 	/*
    925       1.294   thorpej 	 * If there are wedges, and this is not RAW_PART, then we
    926       1.294   thorpej 	 * need to fail.
    927       1.294   thorpej 	 */
    928       1.294   thorpej 	if (wd->sc_dk.dk_nwedges != 0 && part != RAW_PART) {
    929       1.294   thorpej 		error = EBUSY;
    930       1.294   thorpej 		goto bad1;
    931       1.294   thorpej 	}
    932       1.294   thorpej 
    933       1.187   thorpej 	/*
    934       1.187   thorpej 	 * If this is the first open of this device, add a reference
    935       1.187   thorpej 	 * to the adapter.
    936       1.187   thorpej 	 */
    937       1.187   thorpej 	if (wd->sc_dk.dk_openmask == 0 &&
    938       1.217    bouyer 	    (error = wd->atabus->ata_addref(wd->drvp)) != 0)
    939       1.294   thorpej 		goto bad1;
    940         1.3   deraadt 
    941       1.109   mycroft 	if (wd->sc_dk.dk_openmask != 0) {
    942       1.109   mycroft 		/*
    943       1.109   mycroft 		 * If any partition is open, but the disk has been invalidated,
    944       1.109   mycroft 		 * disallow further opens.
    945       1.109   mycroft 		 */
    946       1.181    bouyer 		if ((wd->sc_flags & WDF_LOADED) == 0) {
    947       1.136   mycroft 			error = EIO;
    948       1.294   thorpej 			goto bad2;
    949       1.136   mycroft 		}
    950       1.109   mycroft 	} else {
    951       1.181    bouyer 		if ((wd->sc_flags & WDF_LOADED) == 0) {
    952       1.181    bouyer 			wd->sc_flags |= WDF_LOADED;
    953       1.108   mycroft 
    954       1.108   mycroft 			/* Load the physical device parameters. */
    955       1.183    bouyer 			wd_get_params(wd, AT_WAIT, &wd->sc_params);
    956       1.108   mycroft 
    957       1.108   mycroft 			/* Load the partition info if not already loaded. */
    958       1.108   mycroft 			wdgetdisklabel(wd);
    959       1.108   mycroft 		}
    960       1.135   mycroft 	}
    961       1.108   mycroft 
    962       1.109   mycroft 	/* Check that the partition exists. */
    963        1.93   mycroft 	if (part != RAW_PART &&
    964       1.144   thorpej 	    (part >= wd->sc_dk.dk_label->d_npartitions ||
    965       1.144   thorpej 	     wd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
    966        1.93   mycroft 		error = ENXIO;
    967       1.294   thorpej 		goto bad2;
    968        1.93   mycroft 	}
    969       1.259       dsl 
    970        1.64   mycroft 	/* Insure only one open at a time. */
    971         1.3   deraadt 	switch (fmt) {
    972         1.3   deraadt 	case S_IFCHR:
    973        1.94   mycroft 		wd->sc_dk.dk_copenmask |= (1 << part);
    974         1.3   deraadt 		break;
    975         1.3   deraadt 	case S_IFBLK:
    976        1.94   mycroft 		wd->sc_dk.dk_bopenmask |= (1 << part);
    977         1.3   deraadt 		break;
    978         1.3   deraadt 	}
    979       1.181    bouyer 	wd->sc_dk.dk_openmask =
    980       1.181    bouyer 	    wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
    981        1.60   mycroft 
    982   1.337.2.8        ad 	mutex_exit(&wd->sc_dk.dk_openlock);
    983        1.37   mycroft 	return 0;
    984        1.93   mycroft 
    985       1.294   thorpej  bad2:
    986       1.187   thorpej 	if (wd->sc_dk.dk_openmask == 0)
    987       1.217    bouyer 		wd->atabus->ata_delref(wd->drvp);
    988       1.294   thorpej  bad1:
    989   1.337.2.8        ad 	mutex_exit(&wd->sc_dk.dk_openlock);
    990        1.93   mycroft 	return error;
    991         1.1       cgd }
    992         1.1       cgd 
    993       1.135   mycroft int
    994       1.335  christos wdclose(dev_t dev, int flag, int fmt, struct lwp *l)
    995       1.135   mycroft {
    996       1.209   thorpej 	struct wd_softc *wd = device_lookup(&wd_cd, WDUNIT(dev));
    997       1.135   mycroft 	int part = WDPART(dev);
    998       1.259       dsl 
    999       1.289   thorpej 	ATADEBUG_PRINT(("wdclose\n"), DEBUG_FUNCS);
   1000       1.294   thorpej 
   1001   1.337.2.8        ad 	mutex_enter(&wd->sc_dk.dk_openlock);
   1002       1.135   mycroft 
   1003       1.135   mycroft 	switch (fmt) {
   1004       1.135   mycroft 	case S_IFCHR:
   1005       1.135   mycroft 		wd->sc_dk.dk_copenmask &= ~(1 << part);
   1006       1.135   mycroft 		break;
   1007       1.135   mycroft 	case S_IFBLK:
   1008       1.135   mycroft 		wd->sc_dk.dk_bopenmask &= ~(1 << part);
   1009       1.135   mycroft 		break;
   1010       1.135   mycroft 	}
   1011       1.181    bouyer 	wd->sc_dk.dk_openmask =
   1012       1.181    bouyer 	    wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
   1013       1.135   mycroft 
   1014       1.135   mycroft 	if (wd->sc_dk.dk_openmask == 0) {
   1015       1.194    bouyer 		wd_flushcache(wd, AT_WAIT);
   1016       1.187   thorpej 
   1017       1.199       leo 		if (! (wd->sc_flags & WDF_KLABEL))
   1018       1.199       leo 			wd->sc_flags &= ~WDF_LOADED;
   1019       1.199       leo 
   1020       1.217    bouyer 		wd->atabus->ata_delref(wd->drvp);
   1021       1.135   mycroft 	}
   1022       1.135   mycroft 
   1023   1.337.2.8        ad 	mutex_exit(&wd->sc_dk.dk_openlock);
   1024       1.135   mycroft 	return 0;
   1025       1.135   mycroft }
   1026       1.135   mycroft 
   1027       1.108   mycroft void
   1028       1.259       dsl wdgetdefaultlabel(struct wd_softc *wd, struct disklabel *lp)
   1029       1.108   mycroft {
   1030       1.163    bouyer 
   1031       1.289   thorpej 	ATADEBUG_PRINT(("wdgetdefaultlabel\n"), DEBUG_FUNCS);
   1032       1.181    bouyer 	memset(lp, 0, sizeof(struct disklabel));
   1033       1.108   mycroft 
   1034       1.142   mycroft 	lp->d_secsize = DEV_BSIZE;
   1035       1.181    bouyer 	lp->d_ntracks = wd->sc_params.atap_heads;
   1036       1.181    bouyer 	lp->d_nsectors = wd->sc_params.atap_sectors;
   1037       1.260    bouyer 	lp->d_ncylinders = (wd->sc_flags & WDF_LBA) ? wd->sc_capacity /
   1038       1.260    bouyer 		(wd->sc_params.atap_heads * wd->sc_params.atap_sectors) :
   1039       1.260    bouyer 		wd->sc_params.atap_cylinders;
   1040       1.142   mycroft 	lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
   1041       1.108   mycroft 
   1042       1.198       leo 	if (strcmp(wd->sc_params.atap_model, "ST506") == 0)
   1043       1.181    bouyer 		lp->d_type = DTYPE_ST506;
   1044       1.198       leo 	else
   1045       1.181    bouyer 		lp->d_type = DTYPE_ESDI;
   1046       1.198       leo 
   1047       1.181    bouyer 	strncpy(lp->d_typename, wd->sc_params.atap_model, 16);
   1048       1.180  drochner 	strncpy(lp->d_packname, "fictitious", 16);
   1049       1.240      fvdl 	if (wd->sc_capacity > UINT32_MAX)
   1050       1.240      fvdl 		lp->d_secperunit = UINT32_MAX;
   1051       1.240      fvdl 	else
   1052       1.240      fvdl 		lp->d_secperunit = wd->sc_capacity;
   1053       1.142   mycroft 	lp->d_rpm = 3600;
   1054       1.142   mycroft 	lp->d_interleave = 1;
   1055       1.142   mycroft 	lp->d_flags = 0;
   1056       1.142   mycroft 
   1057       1.142   mycroft 	lp->d_partitions[RAW_PART].p_offset = 0;
   1058       1.142   mycroft 	lp->d_partitions[RAW_PART].p_size =
   1059       1.259       dsl 	    lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
   1060       1.142   mycroft 	lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
   1061       1.142   mycroft 	lp->d_npartitions = RAW_PART + 1;
   1062       1.142   mycroft 
   1063       1.142   mycroft 	lp->d_magic = DISKMAGIC;
   1064       1.142   mycroft 	lp->d_magic2 = DISKMAGIC;
   1065       1.142   mycroft 	lp->d_checksum = dkcksum(lp);
   1066       1.164   thorpej }
   1067       1.164   thorpej 
   1068       1.164   thorpej /*
   1069       1.164   thorpej  * Fabricate a default disk label, and try to read the correct one.
   1070       1.164   thorpej  */
   1071       1.164   thorpej void
   1072       1.259       dsl wdgetdisklabel(struct wd_softc *wd)
   1073       1.164   thorpej {
   1074       1.164   thorpej 	struct disklabel *lp = wd->sc_dk.dk_label;
   1075       1.251       dsl 	const char *errstring;
   1076       1.291   thorpej 	int s;
   1077       1.164   thorpej 
   1078       1.289   thorpej 	ATADEBUG_PRINT(("wdgetdisklabel\n"), DEBUG_FUNCS);
   1079       1.164   thorpej 
   1080       1.181    bouyer 	memset(wd->sc_dk.dk_cpulabel, 0, sizeof(struct cpu_disklabel));
   1081       1.164   thorpej 
   1082       1.164   thorpej 	wdgetdefaultlabel(wd, lp);
   1083       1.108   mycroft 
   1084       1.181    bouyer 	wd->sc_badsect[0] = -1;
   1085       1.113   mycroft 
   1086       1.291   thorpej 	if (wd->drvp->state > RESET) {
   1087       1.291   thorpej 		s = splbio();
   1088       1.183    bouyer 		wd->drvp->drive_flags |= DRIVE_RESET;
   1089       1.291   thorpej 		splx(s);
   1090       1.291   thorpej 	}
   1091       1.321   thorpej 	errstring = readdisklabel(MAKEWDDEV(0, device_unit(&wd->sc_dev),
   1092       1.321   thorpej 				  RAW_PART), wdstrategy, lp,
   1093       1.321   thorpej 				  wd->sc_dk.dk_cpulabel);
   1094       1.108   mycroft 	if (errstring) {
   1095       1.108   mycroft 		/*
   1096       1.108   mycroft 		 * This probably happened because the drive's default
   1097       1.108   mycroft 		 * geometry doesn't match the DOS geometry.  We
   1098       1.108   mycroft 		 * assume the DOS geometry is now in the label and try
   1099       1.108   mycroft 		 * again.  XXX This is a kluge.
   1100       1.108   mycroft 		 */
   1101       1.291   thorpej 		if (wd->drvp->state > RESET) {
   1102       1.291   thorpej 			s = splbio();
   1103       1.183    bouyer 			wd->drvp->drive_flags |= DRIVE_RESET;
   1104       1.291   thorpej 			splx(s);
   1105       1.291   thorpej 		}
   1106       1.321   thorpej 		errstring = readdisklabel(MAKEWDDEV(0, device_unit(&wd->sc_dev),
   1107       1.181    bouyer 		    RAW_PART), wdstrategy, lp, wd->sc_dk.dk_cpulabel);
   1108       1.108   mycroft 	}
   1109       1.108   mycroft 	if (errstring) {
   1110       1.153  christos 		printf("%s: %s\n", wd->sc_dev.dv_xname, errstring);
   1111       1.108   mycroft 		return;
   1112       1.108   mycroft 	}
   1113       1.108   mycroft 
   1114       1.291   thorpej 	if (wd->drvp->state > RESET) {
   1115       1.291   thorpej 		s = splbio();
   1116       1.183    bouyer 		wd->drvp->drive_flags |= DRIVE_RESET;
   1117       1.291   thorpej 		splx(s);
   1118       1.291   thorpej 	}
   1119       1.170       leo #ifdef HAS_BAD144_HANDLING
   1120       1.142   mycroft 	if ((lp->d_flags & D_BADSECT) != 0)
   1121       1.108   mycroft 		bad144intern(wd);
   1122       1.170       leo #endif
   1123       1.108   mycroft }
   1124       1.108   mycroft 
   1125       1.217    bouyer void
   1126       1.259       dsl wdperror(const struct wd_softc *wd)
   1127       1.217    bouyer {
   1128       1.221      yamt 	static const char *const errstr0_3[] = {"address mark not found",
   1129       1.217    bouyer 	    "track 0 not found", "aborted command", "media change requested",
   1130       1.217    bouyer 	    "id not found", "media changed", "uncorrectable data error",
   1131       1.217    bouyer 	    "bad block detected"};
   1132       1.221      yamt 	static const char *const errstr4_5[] = {
   1133       1.221      yamt 	    "obsolete (address mark not found)",
   1134       1.217    bouyer 	    "no media/write protected", "aborted command",
   1135       1.217    bouyer 	    "media change requested", "id not found", "media changed",
   1136       1.217    bouyer 	    "uncorrectable data error", "interface CRC error"};
   1137       1.259       dsl 	const char *const *errstr;
   1138       1.217    bouyer 	int i;
   1139       1.301  christos 	const char *sep = "";
   1140       1.217    bouyer 
   1141       1.221      yamt 	const char *devname = wd->sc_dev.dv_xname;
   1142       1.221      yamt 	struct ata_drive_datas *drvp = wd->drvp;
   1143       1.221      yamt 	int errno = wd->sc_wdc_bio.r_error;
   1144       1.221      yamt 
   1145       1.217    bouyer 	if (drvp->ata_vers >= 4)
   1146       1.217    bouyer 		errstr = errstr4_5;
   1147       1.217    bouyer 	else
   1148       1.217    bouyer 		errstr = errstr0_3;
   1149       1.217    bouyer 
   1150       1.221      yamt 	printf("%s: (", devname);
   1151       1.221      yamt 
   1152       1.217    bouyer 	if (errno == 0)
   1153       1.221      yamt 		printf("error not notified");
   1154       1.217    bouyer 
   1155       1.217    bouyer 	for (i = 0; i < 8; i++) {
   1156       1.217    bouyer 		if (errno & (1 << i)) {
   1157       1.221      yamt 			printf("%s%s", sep, errstr[i]);
   1158       1.217    bouyer 			sep = ", ";
   1159       1.217    bouyer 		}
   1160       1.217    bouyer 	}
   1161       1.221      yamt 	printf(")\n");
   1162       1.217    bouyer }
   1163       1.217    bouyer 
   1164         1.1       cgd int
   1165       1.337  christos wdioctl(dev_t dev, u_long xfer, void *addr, int flag, struct lwp *l)
   1166         1.1       cgd {
   1167       1.209   thorpej 	struct wd_softc *wd = device_lookup(&wd_cd, WDUNIT(dev));
   1168       1.291   thorpej 	int error = 0, s;
   1169       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1170       1.233      fvdl 	struct disklabel *newlabel = NULL;
   1171       1.211      fvdl #endif
   1172       1.163    bouyer 
   1173       1.289   thorpej 	ATADEBUG_PRINT(("wdioctl\n"), DEBUG_FUNCS);
   1174       1.163    bouyer 
   1175       1.181    bouyer 	if ((wd->sc_flags & WDF_LOADED) == 0)
   1176       1.108   mycroft 		return EIO;
   1177       1.108   mycroft 
   1178       1.332   thorpej 	error = disk_ioctl(&wd->sc_dk, xfer, addr, flag, l);
   1179       1.332   thorpej 	if (error != EPASSTHROUGH)
   1180       1.332   thorpej 		return (error);
   1181       1.332   thorpej 
   1182       1.163    bouyer 	switch (xfer) {
   1183       1.170       leo #ifdef HAS_BAD144_HANDLING
   1184         1.1       cgd 	case DIOCSBAD:
   1185         1.3   deraadt 		if ((flag & FWRITE) == 0)
   1186        1.54   mycroft 			return EBADF;
   1187       1.144   thorpej 		wd->sc_dk.dk_cpulabel->bad = *(struct dkbad *)addr;
   1188       1.144   thorpej 		wd->sc_dk.dk_label->d_flags |= D_BADSECT;
   1189        1.64   mycroft 		bad144intern(wd);
   1190        1.54   mycroft 		return 0;
   1191       1.170       leo #endif
   1192       1.292  drochner #ifdef WD_SOFTBADSECT
   1193       1.241   darrenr 	case DIOCBSLIST :
   1194       1.241   darrenr 	{
   1195       1.243   darrenr 		u_int32_t count, missing, skip;
   1196       1.243   darrenr 		struct disk_badsecinfo dbsi;
   1197       1.241   darrenr 		struct disk_badsectors *dbs;
   1198       1.241   darrenr 		size_t available;
   1199  1.337.2.10        ad 		uint8_t *laddr;
   1200       1.241   darrenr 
   1201       1.243   darrenr 		dbsi = *(struct disk_badsecinfo *)addr;
   1202       1.243   darrenr 		missing = wd->sc_bscount;
   1203       1.241   darrenr 		count = 0;
   1204       1.243   darrenr 		available = dbsi.dbsi_bufsize;
   1205       1.243   darrenr 		skip = dbsi.dbsi_skip;
   1206  1.337.2.10        ad 		laddr = (uint8_t *)dbsi.dbsi_buffer;
   1207       1.243   darrenr 
   1208       1.243   darrenr 		/*
   1209       1.243   darrenr 		 * We start this loop with the expectation that all of the
   1210       1.243   darrenr 		 * entries will be missed and decrement this counter each
   1211       1.243   darrenr 		 * time we either skip over one (already copied out) or
   1212       1.243   darrenr 		 * we actually copy it back to user space.  The structs
   1213       1.243   darrenr 		 * holding the bad sector information are copied directly
   1214       1.243   darrenr 		 * back to user space whilst the summary is returned via
   1215       1.243   darrenr 		 * the struct passed in via the ioctl.
   1216       1.243   darrenr 		 */
   1217       1.241   darrenr 		SLIST_FOREACH(dbs, &wd->sc_bslist, dbs_next) {
   1218       1.243   darrenr 			if (skip > 0) {
   1219       1.243   darrenr 				missing--;
   1220       1.243   darrenr 				skip--;
   1221       1.243   darrenr 				continue;
   1222       1.243   darrenr 			}
   1223       1.243   darrenr 			if (available < sizeof(*dbs))
   1224       1.241   darrenr 				break;
   1225       1.243   darrenr 			available -= sizeof(*dbs);
   1226       1.241   darrenr 			copyout(dbs, laddr, sizeof(*dbs));
   1227       1.241   darrenr 			laddr += sizeof(*dbs);
   1228       1.243   darrenr 			missing--;
   1229       1.241   darrenr 			count++;
   1230       1.241   darrenr 		}
   1231       1.243   darrenr 		dbsi.dbsi_left = missing;
   1232       1.243   darrenr 		dbsi.dbsi_copied = count;
   1233       1.243   darrenr 		*(struct disk_badsecinfo *)addr = dbsi;
   1234       1.241   darrenr 		return 0;
   1235       1.241   darrenr 	}
   1236       1.241   darrenr 
   1237       1.241   darrenr 	case DIOCBSFLUSH :
   1238       1.241   darrenr 		/* Clean out the bad sector list */
   1239       1.241   darrenr 		while (!SLIST_EMPTY(&wd->sc_bslist)) {
   1240       1.241   darrenr 			void *head = SLIST_FIRST(&wd->sc_bslist);
   1241       1.241   darrenr 			SLIST_REMOVE_HEAD(&wd->sc_bslist, dbs_next);
   1242       1.241   darrenr 			free(head, M_TEMP);
   1243       1.241   darrenr 		}
   1244       1.243   darrenr 		wd->sc_bscount = 0;
   1245       1.241   darrenr 		return 0;
   1246       1.292  drochner #endif
   1247         1.1       cgd 	case DIOCGDINFO:
   1248       1.144   thorpej 		*(struct disklabel *)addr = *(wd->sc_dk.dk_label);
   1249        1.54   mycroft 		return 0;
   1250       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1251       1.211      fvdl 	case ODIOCGDINFO:
   1252       1.233      fvdl 		newlabel = malloc(sizeof *newlabel, M_TEMP, M_WAITOK);
   1253       1.233      fvdl 		if (newlabel == NULL)
   1254       1.233      fvdl 			return EIO;
   1255       1.234      fvdl 		*newlabel = *(wd->sc_dk.dk_label);
   1256       1.233      fvdl 		if (newlabel->d_npartitions <= OLDMAXPARTITIONS)
   1257       1.234      fvdl 			memcpy(addr, newlabel, sizeof (struct olddisklabel));
   1258       1.233      fvdl 		else
   1259       1.233      fvdl 			error = ENOTTY;
   1260       1.233      fvdl 		free(newlabel, M_TEMP);
   1261       1.233      fvdl 		return error;
   1262       1.211      fvdl #endif
   1263       1.211      fvdl 
   1264         1.3   deraadt 	case DIOCGPART:
   1265       1.144   thorpej 		((struct partinfo *)addr)->disklab = wd->sc_dk.dk_label;
   1266         1.3   deraadt 		((struct partinfo *)addr)->part =
   1267       1.144   thorpej 		    &wd->sc_dk.dk_label->d_partitions[WDPART(dev)];
   1268        1.54   mycroft 		return 0;
   1269       1.259       dsl 
   1270       1.132   mycroft 	case DIOCWDINFO:
   1271         1.3   deraadt 	case DIOCSDINFO:
   1272       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1273       1.211      fvdl 	case ODIOCWDINFO:
   1274       1.211      fvdl 	case ODIOCSDINFO:
   1275       1.211      fvdl #endif
   1276       1.211      fvdl 	{
   1277       1.211      fvdl 		struct disklabel *lp;
   1278       1.211      fvdl 
   1279       1.233      fvdl 		if ((flag & FWRITE) == 0)
   1280       1.233      fvdl 			return EBADF;
   1281       1.233      fvdl 
   1282       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1283       1.211      fvdl 		if (xfer == ODIOCSDINFO || xfer == ODIOCWDINFO) {
   1284       1.233      fvdl 			newlabel = malloc(sizeof *newlabel, M_TEMP, M_WAITOK);
   1285       1.233      fvdl 			if (newlabel == NULL)
   1286       1.233      fvdl 				return EIO;
   1287       1.233      fvdl 			memset(newlabel, 0, sizeof newlabel);
   1288       1.233      fvdl 			memcpy(newlabel, addr, sizeof (struct olddisklabel));
   1289       1.233      fvdl 			lp = newlabel;
   1290       1.211      fvdl 		} else
   1291       1.211      fvdl #endif
   1292       1.211      fvdl 		lp = (struct disklabel *)addr;
   1293       1.211      fvdl 
   1294   1.337.2.8        ad 		mutex_enter(&wd->sc_dk.dk_openlock);
   1295       1.181    bouyer 		wd->sc_flags |= WDF_LABELLING;
   1296       1.132   mycroft 
   1297       1.144   thorpej 		error = setdisklabel(wd->sc_dk.dk_label,
   1298       1.211      fvdl 		    lp, /*wd->sc_dk.dk_openmask : */0,
   1299       1.144   thorpej 		    wd->sc_dk.dk_cpulabel);
   1300         1.3   deraadt 		if (error == 0) {
   1301       1.291   thorpej 			if (wd->drvp->state > RESET) {
   1302       1.291   thorpej 				s = splbio();
   1303       1.183    bouyer 				wd->drvp->drive_flags |= DRIVE_RESET;
   1304       1.291   thorpej 				splx(s);
   1305       1.291   thorpej 			}
   1306       1.211      fvdl 			if (xfer == DIOCWDINFO
   1307       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1308       1.211      fvdl 			    || xfer == ODIOCWDINFO
   1309       1.211      fvdl #endif
   1310       1.211      fvdl 			    )
   1311       1.132   mycroft 				error = writedisklabel(WDLABELDEV(dev),
   1312       1.144   thorpej 				    wdstrategy, wd->sc_dk.dk_label,
   1313       1.144   thorpej 				    wd->sc_dk.dk_cpulabel);
   1314         1.1       cgd 		}
   1315       1.132   mycroft 
   1316       1.181    bouyer 		wd->sc_flags &= ~WDF_LABELLING;
   1317   1.337.2.8        ad 		mutex_exit(&wd->sc_dk.dk_openlock);
   1318       1.233      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1319       1.233      fvdl 		if (newlabel != NULL)
   1320       1.233      fvdl 			free(newlabel, M_TEMP);
   1321       1.233      fvdl #endif
   1322        1.54   mycroft 		return error;
   1323       1.211      fvdl 	}
   1324       1.199       leo 
   1325       1.199       leo 	case DIOCKLABEL:
   1326       1.199       leo 		if (*(int *)addr)
   1327       1.199       leo 			wd->sc_flags |= WDF_KLABEL;
   1328       1.199       leo 		else
   1329       1.199       leo 			wd->sc_flags &= ~WDF_KLABEL;
   1330       1.199       leo 		return 0;
   1331       1.259       dsl 
   1332        1.44   mycroft 	case DIOCWLABEL:
   1333         1.3   deraadt 		if ((flag & FWRITE) == 0)
   1334        1.54   mycroft 			return EBADF;
   1335        1.93   mycroft 		if (*(int *)addr)
   1336       1.181    bouyer 			wd->sc_flags |= WDF_WLABEL;
   1337        1.93   mycroft 		else
   1338       1.181    bouyer 			wd->sc_flags &= ~WDF_WLABEL;
   1339        1.54   mycroft 		return 0;
   1340       1.164   thorpej 
   1341       1.164   thorpej 	case DIOCGDEFLABEL:
   1342       1.164   thorpej 		wdgetdefaultlabel(wd, (struct disklabel *)addr);
   1343       1.164   thorpej 		return 0;
   1344       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1345       1.211      fvdl 	case ODIOCGDEFLABEL:
   1346       1.233      fvdl 		newlabel = malloc(sizeof *newlabel, M_TEMP, M_WAITOK);
   1347       1.233      fvdl 		if (newlabel == NULL)
   1348       1.233      fvdl 			return EIO;
   1349       1.233      fvdl 		wdgetdefaultlabel(wd, newlabel);
   1350       1.233      fvdl 		if (newlabel->d_npartitions <= OLDMAXPARTITIONS)
   1351       1.233      fvdl 			memcpy(addr, &newlabel, sizeof (struct olddisklabel));
   1352       1.233      fvdl 		else
   1353       1.233      fvdl 			error = ENOTTY;
   1354       1.233      fvdl 		free(newlabel, M_TEMP);
   1355       1.233      fvdl 		return error;
   1356       1.211      fvdl #endif
   1357       1.164   thorpej 
   1358         1.1       cgd #ifdef notyet
   1359         1.1       cgd 	case DIOCWFORMAT:
   1360         1.1       cgd 		if ((flag & FWRITE) == 0)
   1361        1.54   mycroft 			return EBADF;
   1362       1.181    bouyer 		{
   1363        1.54   mycroft 		register struct format_op *fop;
   1364        1.54   mycroft 		struct iovec aiov;
   1365        1.54   mycroft 		struct uio auio;
   1366       1.259       dsl 
   1367        1.54   mycroft 		fop = (struct format_op *)addr;
   1368        1.54   mycroft 		aiov.iov_base = fop->df_buf;
   1369        1.54   mycroft 		aiov.iov_len = fop->df_count;
   1370        1.54   mycroft 		auio.uio_iov = &aiov;
   1371        1.54   mycroft 		auio.uio_iovcnt = 1;
   1372        1.54   mycroft 		auio.uio_resid = fop->df_count;
   1373        1.54   mycroft 		auio.uio_offset =
   1374       1.181    bouyer 			fop->df_startblk * wd->sc_dk.dk_label->d_secsize;
   1375       1.320      yamt 		auio.uio_vmspace = l->l_proc->p_vmspace;
   1376        1.64   mycroft 		error = physio(wdformat, NULL, dev, B_WRITE, minphys,
   1377        1.64   mycroft 		    &auio);
   1378        1.54   mycroft 		fop->df_count -= auio.uio_resid;
   1379        1.64   mycroft 		fop->df_reg[0] = wdc->sc_status;
   1380        1.64   mycroft 		fop->df_reg[1] = wdc->sc_error;
   1381        1.54   mycroft 		return error;
   1382       1.181    bouyer 		}
   1383         1.1       cgd #endif
   1384       1.248    bouyer 	case DIOCGCACHE:
   1385       1.248    bouyer 		return wd_getcache(wd, (int *)addr);
   1386       1.248    bouyer 
   1387       1.248    bouyer 	case DIOCSCACHE:
   1388       1.248    bouyer 		return wd_setcache(wd, *(int *)addr);
   1389       1.185      kenh 
   1390       1.276    bouyer 	case DIOCCACHESYNC:
   1391       1.276    bouyer 		return wd_flushcache(wd, AT_WAIT);
   1392       1.276    bouyer 
   1393       1.186      kenh 	case ATAIOCCOMMAND:
   1394       1.185      kenh 		/*
   1395       1.185      kenh 		 * Make sure this command is (relatively) safe first
   1396       1.185      kenh 		 */
   1397       1.186      kenh 		if ((((atareq_t *) addr)->flags & ATACMD_READ) == 0 &&
   1398       1.185      kenh 		    (flag & FWRITE) == 0)
   1399       1.185      kenh 			return (EBADF);
   1400       1.185      kenh 		{
   1401       1.185      kenh 		struct wd_ioctl *wi;
   1402       1.186      kenh 		atareq_t *atareq = (atareq_t *) addr;
   1403       1.301  christos 		int error1;
   1404       1.185      kenh 
   1405       1.185      kenh 		wi = wi_get();
   1406       1.185      kenh 		wi->wi_softc = wd;
   1407       1.186      kenh 		wi->wi_atareq = *atareq;
   1408       1.185      kenh 
   1409       1.186      kenh 		if (atareq->datalen && atareq->flags &
   1410       1.186      kenh 		    (ATACMD_READ | ATACMD_WRITE)) {
   1411   1.337.2.6        ad 			void *tbuf;
   1412   1.337.2.6        ad 			if (atareq->datalen < DEV_BSIZE
   1413   1.337.2.6        ad 			    && atareq->command == WDCC_IDENTIFY) {
   1414   1.337.2.6        ad 				tbuf = malloc(DEV_BSIZE, M_TEMP, M_WAITOK);
   1415   1.337.2.6        ad 				wi->wi_iov.iov_base = tbuf;
   1416   1.337.2.6        ad 				wi->wi_iov.iov_len = DEV_BSIZE;
   1417   1.337.2.6        ad 				UIO_SETUP_SYSSPACE(&wi->wi_uio);
   1418   1.337.2.6        ad 			} else {
   1419   1.337.2.6        ad 				tbuf = NULL;
   1420   1.337.2.6        ad 				wi->wi_iov.iov_base = atareq->databuf;
   1421   1.337.2.6        ad 				wi->wi_iov.iov_len = atareq->datalen;
   1422   1.337.2.6        ad 				wi->wi_uio.uio_vmspace = l->l_proc->p_vmspace;
   1423   1.337.2.6        ad 			}
   1424       1.185      kenh 			wi->wi_uio.uio_iov = &wi->wi_iov;
   1425       1.185      kenh 			wi->wi_uio.uio_iovcnt = 1;
   1426       1.186      kenh 			wi->wi_uio.uio_resid = atareq->datalen;
   1427       1.185      kenh 			wi->wi_uio.uio_offset = 0;
   1428       1.185      kenh 			wi->wi_uio.uio_rw =
   1429       1.186      kenh 			    (atareq->flags & ATACMD_READ) ? B_READ : B_WRITE;
   1430       1.301  christos 			error1 = physio(wdioctlstrategy, &wi->wi_bp, dev,
   1431       1.186      kenh 			    (atareq->flags & ATACMD_READ) ? B_READ : B_WRITE,
   1432       1.185      kenh 			    minphys, &wi->wi_uio);
   1433   1.337.2.6        ad 			if (tbuf != NULL && error1 == 0) {
   1434   1.337.2.6        ad 				error1 = copyout(tbuf, atareq->databuf,
   1435   1.337.2.6        ad 				    atareq->datalen);
   1436   1.337.2.6        ad 				free(tbuf, M_TEMP);
   1437   1.337.2.6        ad 			}
   1438       1.185      kenh 		} else {
   1439       1.185      kenh 			/* No need to call physio if we don't have any
   1440       1.185      kenh 			   user data */
   1441       1.185      kenh 			wi->wi_bp.b_flags = 0;
   1442       1.185      kenh 			wi->wi_bp.b_data = 0;
   1443       1.185      kenh 			wi->wi_bp.b_bcount = 0;
   1444       1.185      kenh 			wi->wi_bp.b_dev = 0;
   1445       1.314  christos 			wi->wi_bp.b_proc = l->l_proc;
   1446       1.185      kenh 			wdioctlstrategy(&wi->wi_bp);
   1447       1.301  christos 			error1 = wi->wi_bp.b_error;
   1448       1.185      kenh 		}
   1449       1.186      kenh 		*atareq = wi->wi_atareq;
   1450       1.185      kenh 		wi_free(wi);
   1451       1.301  christos 		return(error1);
   1452       1.185      kenh 		}
   1453       1.185      kenh 
   1454       1.294   thorpej 	case DIOCAWEDGE:
   1455       1.294   thorpej 	    {
   1456       1.294   thorpej 	    	struct dkwedge_info *dkw = (void *) addr;
   1457       1.294   thorpej 
   1458       1.294   thorpej 		if ((flag & FWRITE) == 0)
   1459       1.294   thorpej 			return (EBADF);
   1460       1.294   thorpej 
   1461       1.294   thorpej 		/* If the ioctl happens here, the parent is us. */
   1462       1.294   thorpej 		strcpy(dkw->dkw_parent, wd->sc_dev.dv_xname);
   1463       1.294   thorpej 		return (dkwedge_add(dkw));
   1464       1.294   thorpej 	    }
   1465       1.294   thorpej 
   1466       1.294   thorpej 	case DIOCDWEDGE:
   1467       1.294   thorpej 	    {
   1468       1.294   thorpej 	    	struct dkwedge_info *dkw = (void *) addr;
   1469       1.294   thorpej 
   1470       1.294   thorpej 		if ((flag & FWRITE) == 0)
   1471       1.294   thorpej 			return (EBADF);
   1472       1.294   thorpej 
   1473       1.294   thorpej 		/* If the ioctl happens here, the parent is us. */
   1474       1.294   thorpej 		strcpy(dkw->dkw_parent, wd->sc_dev.dv_xname);
   1475       1.294   thorpej 		return (dkwedge_del(dkw));
   1476       1.294   thorpej 	    }
   1477       1.294   thorpej 
   1478       1.294   thorpej 	case DIOCLWEDGES:
   1479       1.294   thorpej 	    {
   1480       1.294   thorpej 	    	struct dkwedge_list *dkwl = (void *) addr;
   1481       1.294   thorpej 
   1482       1.314  christos 		return (dkwedge_list(&wd->sc_dk, dkwl, l));
   1483       1.294   thorpej 	    }
   1484       1.294   thorpej 
   1485       1.315      yamt 	case DIOCGSTRATEGY:
   1486       1.315      yamt 	    {
   1487       1.315      yamt 		struct disk_strategy *dks = (void *)addr;
   1488       1.315      yamt 
   1489       1.315      yamt 		s = splbio();
   1490       1.315      yamt 		strlcpy(dks->dks_name, bufq_getstrategyname(wd->sc_q),
   1491       1.315      yamt 		    sizeof(dks->dks_name));
   1492       1.315      yamt 		splx(s);
   1493       1.315      yamt 		dks->dks_paramlen = 0;
   1494       1.315      yamt 
   1495       1.315      yamt 		return 0;
   1496       1.315      yamt 	    }
   1497       1.315      yamt 
   1498       1.315      yamt 	case DIOCSSTRATEGY:
   1499       1.315      yamt 	    {
   1500       1.315      yamt 		struct disk_strategy *dks = (void *)addr;
   1501       1.315      yamt 		struct bufq_state *new;
   1502       1.315      yamt 		struct bufq_state *old;
   1503       1.315      yamt 
   1504       1.315      yamt 		if ((flag & FWRITE) == 0) {
   1505       1.315      yamt 			return EBADF;
   1506       1.315      yamt 		}
   1507       1.315      yamt 		if (dks->dks_param != NULL) {
   1508       1.315      yamt 			return EINVAL;
   1509       1.315      yamt 		}
   1510       1.315      yamt 		dks->dks_name[sizeof(dks->dks_name) - 1] = 0; /* ensure term */
   1511       1.315      yamt 		error = bufq_alloc(&new, dks->dks_name,
   1512       1.315      yamt 		    BUFQ_EXACT|BUFQ_SORT_RAWBLOCK);
   1513       1.315      yamt 		if (error) {
   1514       1.315      yamt 			return error;
   1515       1.315      yamt 		}
   1516       1.315      yamt 		s = splbio();
   1517       1.315      yamt 		old = wd->sc_q;
   1518       1.315      yamt 		bufq_move(new, old);
   1519       1.315      yamt 		wd->sc_q = new;
   1520       1.315      yamt 		splx(s);
   1521       1.315      yamt 		bufq_free(old);
   1522       1.315      yamt 
   1523       1.315      yamt 		return 0;
   1524       1.315      yamt 	    }
   1525       1.315      yamt 
   1526         1.1       cgd 	default:
   1527        1.54   mycroft 		return ENOTTY;
   1528         1.1       cgd 	}
   1529        1.54   mycroft 
   1530        1.54   mycroft #ifdef DIAGNOSTIC
   1531        1.54   mycroft 	panic("wdioctl: impossible");
   1532        1.54   mycroft #endif
   1533         1.1       cgd }
   1534         1.1       cgd 
   1535        1.44   mycroft #ifdef B_FORMAT
   1536         1.1       cgd int
   1537         1.1       cgd wdformat(struct buf *bp)
   1538         1.1       cgd {
   1539        1.44   mycroft 
   1540         1.1       cgd 	bp->b_flags |= B_FORMAT;
   1541        1.37   mycroft 	return wdstrategy(bp);
   1542         1.1       cgd }
   1543         1.1       cgd #endif
   1544         1.1       cgd 
   1545         1.1       cgd int
   1546       1.259       dsl wdsize(dev_t dev)
   1547         1.1       cgd {
   1548        1.64   mycroft 	struct wd_softc *wd;
   1549       1.208   thorpej 	int part, omask;
   1550       1.108   mycroft 	int size;
   1551       1.163    bouyer 
   1552       1.289   thorpej 	ATADEBUG_PRINT(("wdsize\n"), DEBUG_FUNCS);
   1553       1.163    bouyer 
   1554       1.208   thorpej 	wd = device_lookup(&wd_cd, WDUNIT(dev));
   1555       1.158        pk 	if (wd == NULL)
   1556       1.158        pk 		return (-1);
   1557       1.158        pk 
   1558       1.158        pk 	part = WDPART(dev);
   1559       1.158        pk 	omask = wd->sc_dk.dk_openmask & (1 << part);
   1560       1.158        pk 
   1561       1.158        pk 	if (omask == 0 && wdopen(dev, 0, S_IFBLK, NULL) != 0)
   1562       1.158        pk 		return (-1);
   1563       1.144   thorpej 	if (wd->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
   1564       1.108   mycroft 		size = -1;
   1565       1.108   mycroft 	else
   1566       1.160   thorpej 		size = wd->sc_dk.dk_label->d_partitions[part].p_size *
   1567       1.181    bouyer 		    (wd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
   1568       1.158        pk 	if (omask == 0 && wdclose(dev, 0, S_IFBLK, NULL) != 0)
   1569       1.158        pk 		return (-1);
   1570       1.158        pk 	return (size);
   1571         1.1       cgd }
   1572         1.1       cgd 
   1573       1.140       cgd /* #define WD_DUMP_NOT_TRUSTED if you just want to watch */
   1574       1.181    bouyer static int wddoingadump = 0;
   1575       1.181    bouyer static int wddumprecalibrated = 0;
   1576       1.140       cgd 
   1577        1.64   mycroft /*
   1578        1.64   mycroft  * Dump core after a system crash.
   1579        1.64   mycroft  */
   1580         1.1       cgd int
   1581       1.337  christos wddump(dev_t dev, daddr_t blkno, void *va, size_t size)
   1582       1.140       cgd {
   1583       1.140       cgd 	struct wd_softc *wd;	/* disk unit to do the I/O */
   1584       1.181    bouyer 	struct disklabel *lp;   /* disk's disklabel */
   1585       1.208   thorpej 	int part, err;
   1586       1.181    bouyer 	int nblks;	/* total number of sectors left to write */
   1587       1.140       cgd 
   1588       1.140       cgd 	/* Check if recursive dump; if so, punt. */
   1589       1.116   mycroft 	if (wddoingadump)
   1590       1.116   mycroft 		return EFAULT;
   1591       1.142   mycroft 	wddoingadump = 1;
   1592       1.140       cgd 
   1593       1.208   thorpej 	wd = device_lookup(&wd_cd, WDUNIT(dev));
   1594       1.208   thorpej 	if (wd == NULL)
   1595       1.208   thorpej 		return (ENXIO);
   1596        1.60   mycroft 
   1597       1.140       cgd 	part = WDPART(dev);
   1598       1.140       cgd 
   1599       1.181    bouyer 	/* Convert to disk sectors.  Request must be a multiple of size. */
   1600       1.144   thorpej 	lp = wd->sc_dk.dk_label;
   1601       1.142   mycroft 	if ((size % lp->d_secsize) != 0)
   1602       1.140       cgd 		return EFAULT;
   1603       1.142   mycroft 	nblks = size / lp->d_secsize;
   1604       1.142   mycroft 	blkno = blkno / (lp->d_secsize / DEV_BSIZE);
   1605       1.116   mycroft 
   1606        1.64   mycroft 	/* Check transfer bounds against partition size. */
   1607       1.142   mycroft 	if ((blkno < 0) || ((blkno + nblks) > lp->d_partitions[part].p_size))
   1608       1.259       dsl 		return EINVAL;
   1609       1.140       cgd 
   1610       1.140       cgd 	/* Offset block number to start of partition. */
   1611       1.142   mycroft 	blkno += lp->d_partitions[part].p_offset;
   1612        1.60   mycroft 
   1613       1.140       cgd 	/* Recalibrate, if first dump transfer. */
   1614       1.140       cgd 	if (wddumprecalibrated == 0) {
   1615       1.140       cgd 		wddumprecalibrated = 1;
   1616       1.290   thorpej 		(*wd->atabus->ata_reset_drive)(wd->drvp,
   1617       1.290   thorpej 					       AT_POLL | AT_RST_EMERG);
   1618       1.205    bouyer 		wd->drvp->state = RESET;
   1619        1.63   mycroft 	}
   1620       1.259       dsl 
   1621       1.308    bouyer 	wd->sc_bp = NULL;
   1622       1.308    bouyer 	wd->sc_wdc_bio.blkno = blkno;
   1623       1.308    bouyer 	wd->sc_wdc_bio.flags = ATA_POLL;
   1624       1.308    bouyer 	if (wd->sc_flags & WDF_LBA48 &&
   1625       1.308    bouyer 	    (blkno > LBA48_THRESHOLD ||
   1626       1.308    bouyer     	    (wd->sc_quirks & WD_QUIRK_FORCE_LBA48) != 0))
   1627       1.308    bouyer 		wd->sc_wdc_bio.flags |= ATA_LBA48;
   1628       1.308    bouyer 	if (wd->sc_flags & WDF_LBA)
   1629       1.308    bouyer 		wd->sc_wdc_bio.flags |= ATA_LBA;
   1630       1.308    bouyer 	wd->sc_wdc_bio.bcount = nblks * lp->d_secsize;
   1631       1.308    bouyer 	wd->sc_wdc_bio.databuf = va;
   1632       1.181    bouyer #ifndef WD_DUMP_NOT_TRUSTED
   1633       1.308    bouyer 	switch (wd->atabus->ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
   1634       1.308    bouyer 	case ATACMD_TRY_AGAIN:
   1635       1.308    bouyer 		panic("wddump: try again");
   1636       1.308    bouyer 		break;
   1637       1.308    bouyer 	case ATACMD_QUEUED:
   1638       1.308    bouyer 		panic("wddump: polled command has been queued");
   1639       1.308    bouyer 		break;
   1640       1.308    bouyer 	case ATACMD_COMPLETE:
   1641       1.308    bouyer 		break;
   1642       1.308    bouyer 	}
   1643       1.308    bouyer 	switch(wd->sc_wdc_bio.error) {
   1644       1.308    bouyer 	case TIMEOUT:
   1645       1.308    bouyer 		printf("wddump: device timed out");
   1646       1.308    bouyer 		err = EIO;
   1647       1.308    bouyer 		break;
   1648       1.308    bouyer 	case ERR_DF:
   1649       1.308    bouyer 		printf("wddump: drive fault");
   1650       1.308    bouyer 		err = EIO;
   1651       1.308    bouyer 		break;
   1652       1.308    bouyer 	case ERR_DMA:
   1653       1.308    bouyer 		printf("wddump: DMA error");
   1654       1.308    bouyer 		err = EIO;
   1655       1.308    bouyer 		break;
   1656       1.308    bouyer 	case ERROR:
   1657       1.308    bouyer 		printf("wddump: ");
   1658       1.308    bouyer 		wdperror(wd);
   1659       1.308    bouyer 		err = EIO;
   1660       1.308    bouyer 		break;
   1661       1.308    bouyer 	case NOERROR:
   1662       1.308    bouyer 		err = 0;
   1663       1.308    bouyer 		break;
   1664       1.308    bouyer 	default:
   1665       1.308    bouyer 		panic("wddump: unknown error type");
   1666       1.308    bouyer 	}
   1667       1.308    bouyer 	if (err != 0) {
   1668       1.308    bouyer 		printf("\n");
   1669       1.308    bouyer 		return err;
   1670       1.308    bouyer 	}
   1671       1.140       cgd #else	/* WD_DUMP_NOT_TRUSTED */
   1672       1.308    bouyer 	/* Let's just talk about this first... */
   1673       1.308    bouyer 	printf("wd%d: dump addr 0x%x, cylin %d, head %d, sector %d\n",
   1674       1.308    bouyer 	    unit, va, cylin, head, sector);
   1675       1.308    bouyer 	delay(500 * 1000);	/* half a second */
   1676       1.140       cgd #endif
   1677         1.1       cgd 
   1678       1.140       cgd 	wddoingadump = 0;
   1679       1.140       cgd 	return 0;
   1680       1.140       cgd }
   1681         1.3   deraadt 
   1682       1.170       leo #ifdef HAS_BAD144_HANDLING
   1683         1.3   deraadt /*
   1684         1.3   deraadt  * Internalize the bad sector table.
   1685         1.3   deraadt  */
   1686         1.3   deraadt void
   1687       1.259       dsl bad144intern(struct wd_softc *wd)
   1688         1.3   deraadt {
   1689       1.144   thorpej 	struct dkbad *bt = &wd->sc_dk.dk_cpulabel->bad;
   1690       1.144   thorpej 	struct disklabel *lp = wd->sc_dk.dk_label;
   1691        1.98   mycroft 	int i = 0;
   1692        1.55   mycroft 
   1693       1.289   thorpej 	ATADEBUG_PRINT(("bad144intern\n"), DEBUG_XFERS);
   1694       1.163    bouyer 
   1695       1.170       leo 	for (; i < NBT_BAD; i++) {
   1696        1.98   mycroft 		if (bt->bt_bad[i].bt_cyl == 0xffff)
   1697        1.55   mycroft 			break;
   1698       1.181    bouyer 		wd->sc_badsect[i] =
   1699        1.98   mycroft 		    bt->bt_bad[i].bt_cyl * lp->d_secpercyl +
   1700        1.98   mycroft 		    (bt->bt_bad[i].bt_trksec >> 8) * lp->d_nsectors +
   1701        1.98   mycroft 		    (bt->bt_bad[i].bt_trksec & 0xff);
   1702         1.3   deraadt 	}
   1703       1.170       leo 	for (; i < NBT_BAD+1; i++)
   1704       1.181    bouyer 		wd->sc_badsect[i] = -1;
   1705        1.64   mycroft }
   1706       1.170       leo #endif
   1707        1.64   mycroft 
   1708       1.330   thorpej static void
   1709       1.335  christos wd_params_to_properties(struct wd_softc *wd, struct ataparams *params)
   1710       1.330   thorpej {
   1711       1.332   thorpej 	prop_dictionary_t disk_info, odisk_info, geom;
   1712       1.333   thorpej 	const char *cp;
   1713       1.330   thorpej 
   1714       1.330   thorpej 	disk_info = prop_dictionary_create();
   1715       1.330   thorpej 
   1716       1.330   thorpej 	if (strcmp(wd->sc_params.atap_model, "ST506") == 0)
   1717       1.333   thorpej 		cp = "ST506";
   1718       1.330   thorpej 	else {
   1719       1.330   thorpej 		/* XXX Should have a case for ATA here, too. */
   1720       1.333   thorpej 		cp = "ESDI";
   1721       1.330   thorpej 	}
   1722       1.333   thorpej 	prop_dictionary_set_cstring_nocopy(disk_info, "type", cp);
   1723       1.330   thorpej 
   1724       1.330   thorpej 	geom = prop_dictionary_create();
   1725       1.330   thorpej 
   1726       1.333   thorpej 	prop_dictionary_set_uint64(geom, "sectors-per-unit", wd->sc_capacity);
   1727       1.333   thorpej 
   1728       1.333   thorpej 	prop_dictionary_set_uint32(geom, "sector-size",
   1729       1.333   thorpej 				   DEV_BSIZE /* XXX 512? */);
   1730       1.333   thorpej 
   1731       1.333   thorpej 	prop_dictionary_set_uint16(geom, "sectors-per-track",
   1732       1.333   thorpej 				   wd->sc_params.atap_sectors);
   1733       1.333   thorpej 
   1734       1.333   thorpej 	prop_dictionary_set_uint16(geom, "tracks-per-cylinder",
   1735       1.333   thorpej 				   wd->sc_params.atap_heads);
   1736       1.333   thorpej 
   1737       1.333   thorpej 	if (wd->sc_flags & WDF_LBA)
   1738       1.333   thorpej 		prop_dictionary_set_uint64(geom, "cylinders-per-unit",
   1739       1.333   thorpej 					   wd->sc_capacity /
   1740       1.333   thorpej 					       (wd->sc_params.atap_heads *
   1741       1.333   thorpej 					        wd->sc_params.atap_sectors));
   1742       1.333   thorpej 	else
   1743       1.333   thorpej 		prop_dictionary_set_uint16(geom, "cylinders-per-unit",
   1744       1.333   thorpej 					   wd->sc_params.atap_cylinders);
   1745       1.330   thorpej 
   1746       1.330   thorpej 	prop_dictionary_set(disk_info, "geometry", geom);
   1747       1.330   thorpej 	prop_object_release(geom);
   1748       1.330   thorpej 
   1749       1.330   thorpej 	prop_dictionary_set(device_properties(&wd->sc_dev),
   1750       1.330   thorpej 			    "disk-info", disk_info);
   1751       1.332   thorpej 
   1752       1.332   thorpej 	/*
   1753       1.332   thorpej 	 * Don't release disk_info here; we keep a reference to it.
   1754       1.332   thorpej 	 * disk_detach() will release it when we go away.
   1755       1.332   thorpej 	 */
   1756       1.332   thorpej 
   1757       1.332   thorpej 	odisk_info = wd->sc_dk.dk_info;
   1758       1.332   thorpej 	wd->sc_dk.dk_info = disk_info;
   1759       1.332   thorpej 	if (odisk_info)
   1760       1.332   thorpej 		prop_object_release(odisk_info);
   1761       1.330   thorpej }
   1762       1.330   thorpej 
   1763       1.181    bouyer int
   1764       1.259       dsl wd_get_params(struct wd_softc *wd, u_int8_t flags, struct ataparams *params)
   1765        1.63   mycroft {
   1766       1.217    bouyer 	switch (wd->atabus->ata_get_params(wd->drvp, flags, params)) {
   1767       1.181    bouyer 	case CMD_AGAIN:
   1768       1.181    bouyer 		return 1;
   1769       1.181    bouyer 	case CMD_ERR:
   1770       1.181    bouyer 		/*
   1771       1.181    bouyer 		 * We `know' there's a drive here; just assume it's old.
   1772       1.181    bouyer 		 * This geometry is only used to read the MBR and print a
   1773       1.181    bouyer 		 * (false) attach message.
   1774       1.181    bouyer 		 */
   1775       1.181    bouyer 		strncpy(params->atap_model, "ST506",
   1776       1.181    bouyer 		    sizeof params->atap_model);
   1777       1.181    bouyer 		params->atap_config = ATA_CFG_FIXED;
   1778       1.181    bouyer 		params->atap_cylinders = 1024;
   1779       1.181    bouyer 		params->atap_heads = 8;
   1780       1.181    bouyer 		params->atap_sectors = 17;
   1781       1.181    bouyer 		params->atap_multi = 1;
   1782       1.181    bouyer 		params->atap_capabilities1 = params->atap_capabilities2 = 0;
   1783       1.190    bouyer 		wd->drvp->ata_vers = -1; /* Mark it as pre-ATA */
   1784       1.330   thorpej 		/* FALLTHROUGH */
   1785       1.181    bouyer 	case CMD_OK:
   1786       1.330   thorpej 		wd_params_to_properties(wd, params);
   1787       1.181    bouyer 		return 0;
   1788       1.181    bouyer 	default:
   1789       1.181    bouyer 		panic("wd_get_params: bad return code from ata_get_params");
   1790       1.181    bouyer 		/* NOTREACHED */
   1791       1.181    bouyer 	}
   1792       1.248    bouyer }
   1793       1.248    bouyer 
   1794       1.248    bouyer int
   1795       1.259       dsl wd_getcache(struct wd_softc *wd, int *bitsp)
   1796       1.248    bouyer {
   1797       1.248    bouyer 	struct ataparams params;
   1798       1.248    bouyer 
   1799       1.248    bouyer 	if (wd_get_params(wd, AT_WAIT, &params) != 0)
   1800       1.248    bouyer 		return EIO;
   1801       1.248    bouyer 	if (params.atap_cmd_set1 == 0x0000 ||
   1802       1.248    bouyer 	    params.atap_cmd_set1 == 0xffff ||
   1803       1.248    bouyer 	    (params.atap_cmd_set1 & WDC_CMD1_CACHE) == 0) {
   1804       1.248    bouyer 		*bitsp = 0;
   1805       1.248    bouyer 		return 0;
   1806       1.248    bouyer 	}
   1807       1.248    bouyer 	*bitsp = DKCACHE_WCHANGE | DKCACHE_READ;
   1808       1.248    bouyer 	if (params.atap_cmd1_en & WDC_CMD1_CACHE)
   1809       1.248    bouyer 		*bitsp |= DKCACHE_WRITE;
   1810       1.248    bouyer 
   1811       1.248    bouyer 	return 0;
   1812       1.248    bouyer }
   1813       1.248    bouyer 
   1814       1.286   mycroft const char at_errbits[] = "\20\10ERROR\11TIMEOU\12DF";
   1815       1.286   mycroft 
   1816       1.248    bouyer int
   1817       1.259       dsl wd_setcache(struct wd_softc *wd, int bits)
   1818       1.248    bouyer {
   1819       1.248    bouyer 	struct ataparams params;
   1820       1.287   thorpej 	struct ata_command ata_c;
   1821       1.248    bouyer 
   1822       1.248    bouyer 	if (wd_get_params(wd, AT_WAIT, &params) != 0)
   1823       1.248    bouyer 		return EIO;
   1824       1.248    bouyer 
   1825       1.248    bouyer 	if (params.atap_cmd_set1 == 0x0000 ||
   1826       1.250    bouyer 	    params.atap_cmd_set1 == 0xffff ||
   1827       1.248    bouyer 	    (params.atap_cmd_set1 & WDC_CMD1_CACHE) == 0)
   1828       1.248    bouyer 		return EOPNOTSUPP;
   1829       1.248    bouyer 
   1830       1.249    bouyer 	if ((bits & DKCACHE_READ) == 0 ||
   1831       1.249    bouyer 	    (bits & DKCACHE_SAVE) != 0)
   1832       1.248    bouyer 		return EOPNOTSUPP;
   1833       1.248    bouyer 
   1834       1.287   thorpej 	memset(&ata_c, 0, sizeof(struct ata_command));
   1835       1.287   thorpej 	ata_c.r_command = SET_FEATURES;
   1836       1.287   thorpej 	ata_c.r_st_bmask = 0;
   1837       1.287   thorpej 	ata_c.r_st_pmask = 0;
   1838       1.287   thorpej 	ata_c.timeout = 30000; /* 30s timeout */
   1839       1.287   thorpej 	ata_c.flags = AT_WAIT;
   1840       1.248    bouyer 	if (bits & DKCACHE_WRITE)
   1841       1.287   thorpej 		ata_c.r_features = WDSF_WRITE_CACHE_EN;
   1842       1.248    bouyer 	else
   1843       1.287   thorpej 		ata_c.r_features = WDSF_WRITE_CACHE_DS;
   1844       1.288   thorpej 	if (wd->atabus->ata_exec_command(wd->drvp, &ata_c) != ATACMD_COMPLETE) {
   1845       1.248    bouyer 		printf("%s: wd_setcache command not complete\n",
   1846       1.248    bouyer 		    wd->sc_dev.dv_xname);
   1847       1.248    bouyer 		return EIO;
   1848       1.248    bouyer 	}
   1849       1.287   thorpej 	if (ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
   1850       1.286   mycroft 		char sbuf[sizeof(at_errbits) + 64];
   1851       1.287   thorpej 		bitmask_snprintf(ata_c.flags, at_errbits, sbuf, sizeof(sbuf));
   1852       1.286   mycroft 		printf("%s: wd_setcache: status=%s\n", wd->sc_dev.dv_xname,
   1853       1.286   mycroft 		    sbuf);
   1854       1.286   mycroft 		return EIO;
   1855       1.286   mycroft 	}
   1856       1.286   mycroft 	return 0;
   1857       1.286   mycroft }
   1858       1.286   mycroft 
   1859       1.286   mycroft int
   1860       1.286   mycroft wd_standby(struct wd_softc *wd, int flags)
   1861       1.286   mycroft {
   1862       1.287   thorpej 	struct ata_command ata_c;
   1863       1.286   mycroft 
   1864       1.287   thorpej 	memset(&ata_c, 0, sizeof(struct ata_command));
   1865       1.287   thorpej 	ata_c.r_command = WDCC_STANDBY_IMMED;
   1866       1.287   thorpej 	ata_c.r_st_bmask = WDCS_DRDY;
   1867       1.287   thorpej 	ata_c.r_st_pmask = WDCS_DRDY;
   1868       1.287   thorpej 	ata_c.flags = flags;
   1869       1.287   thorpej 	ata_c.timeout = 30000; /* 30s timeout */
   1870       1.288   thorpej 	if (wd->atabus->ata_exec_command(wd->drvp, &ata_c) != ATACMD_COMPLETE) {
   1871       1.286   mycroft 		printf("%s: standby immediate command didn't complete\n",
   1872       1.286   mycroft 		    wd->sc_dev.dv_xname);
   1873       1.286   mycroft 		return EIO;
   1874       1.286   mycroft 	}
   1875       1.287   thorpej 	if (ata_c.flags & AT_ERROR) {
   1876       1.287   thorpej 		if (ata_c.r_error == WDCE_ABRT) /* command not supported */
   1877       1.286   mycroft 			return ENODEV;
   1878       1.286   mycroft 	}
   1879       1.287   thorpej 	if (ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
   1880       1.286   mycroft 		char sbuf[sizeof(at_errbits) + 64];
   1881       1.287   thorpej 		bitmask_snprintf(ata_c.flags, at_errbits, sbuf, sizeof(sbuf));
   1882       1.286   mycroft 		printf("%s: wd_standby: status=%s\n", wd->sc_dev.dv_xname,
   1883       1.286   mycroft 		    sbuf);
   1884       1.248    bouyer 		return EIO;
   1885       1.248    bouyer 	}
   1886       1.248    bouyer 	return 0;
   1887       1.190    bouyer }
   1888       1.190    bouyer 
   1889       1.276    bouyer int
   1890       1.259       dsl wd_flushcache(struct wd_softc *wd, int flags)
   1891       1.190    bouyer {
   1892       1.287   thorpej 	struct ata_command ata_c;
   1893       1.190    bouyer 
   1894       1.297    bouyer 	/*
   1895       1.297    bouyer 	 * WDCC_FLUSHCACHE is here since ATA-4, but some drives report
   1896       1.297    bouyer 	 * only ATA-2 and still support it.
   1897       1.297    bouyer 	 */
   1898       1.297    bouyer 	if (wd->drvp->ata_vers < 4 &&
   1899       1.297    bouyer 	    ((wd->sc_params.atap_cmd_set2 & WDC_CMD2_FC) == 0 ||
   1900       1.297    bouyer 	    wd->sc_params.atap_cmd_set2 == 0xffff))
   1901       1.276    bouyer 		return ENODEV;
   1902       1.287   thorpej 	memset(&ata_c, 0, sizeof(struct ata_command));
   1903       1.275    bouyer 	if ((wd->sc_params.atap_cmd2_en & ATA_CMD2_LBA48) != 0 &&
   1904       1.275    bouyer 	    (wd->sc_params.atap_cmd2_en & ATA_CMD2_FCE) != 0)
   1905       1.287   thorpej 		ata_c.r_command = WDCC_FLUSHCACHE_EXT;
   1906       1.275    bouyer 	else
   1907       1.287   thorpej 		ata_c.r_command = WDCC_FLUSHCACHE;
   1908       1.287   thorpej 	ata_c.r_st_bmask = WDCS_DRDY;
   1909       1.287   thorpej 	ata_c.r_st_pmask = WDCS_DRDY;
   1910       1.287   thorpej 	ata_c.flags = flags;
   1911       1.287   thorpej 	ata_c.timeout = 30000; /* 30s timeout */
   1912       1.288   thorpej 	if (wd->atabus->ata_exec_command(wd->drvp, &ata_c) != ATACMD_COMPLETE) {
   1913       1.190    bouyer 		printf("%s: flush cache command didn't complete\n",
   1914       1.190    bouyer 		    wd->sc_dev.dv_xname);
   1915       1.276    bouyer 		return EIO;
   1916       1.190    bouyer 	}
   1917       1.287   thorpej 	if (ata_c.flags & AT_ERROR) {
   1918       1.287   thorpej 		if (ata_c.r_error == WDCE_ABRT) /* command not supported */
   1919       1.276    bouyer 			return ENODEV;
   1920       1.190    bouyer 	}
   1921       1.287   thorpej 	if (ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
   1922       1.286   mycroft 		char sbuf[sizeof(at_errbits) + 64];
   1923       1.287   thorpej 		bitmask_snprintf(ata_c.flags, at_errbits, sbuf, sizeof(sbuf));
   1924       1.286   mycroft 		printf("%s: wd_flushcache: status=%s\n", wd->sc_dev.dv_xname,
   1925       1.286   mycroft 		    sbuf);
   1926       1.276    bouyer 		return EIO;
   1927       1.190    bouyer 	}
   1928       1.276    bouyer 	return 0;
   1929       1.190    bouyer }
   1930       1.190    bouyer 
   1931       1.190    bouyer void
   1932       1.259       dsl wd_shutdown(void *arg)
   1933       1.190    bouyer {
   1934       1.190    bouyer 	struct wd_softc *wd = arg;
   1935       1.194    bouyer 	wd_flushcache(wd, AT_POLL);
   1936       1.185      kenh }
   1937       1.185      kenh 
   1938       1.185      kenh /*
   1939       1.185      kenh  * Allocate space for a ioctl queue structure.  Mostly taken from
   1940       1.185      kenh  * scsipi_ioctl.c
   1941       1.185      kenh  */
   1942       1.185      kenh struct wd_ioctl *
   1943       1.259       dsl wi_get(void)
   1944       1.185      kenh {
   1945       1.185      kenh 	struct wd_ioctl *wi;
   1946       1.185      kenh 	int s;
   1947       1.185      kenh 
   1948       1.219   tsutsui 	wi = malloc(sizeof(struct wd_ioctl), M_TEMP, M_WAITOK|M_ZERO);
   1949   1.337.2.4        ad 	buf_init(&wi->wi_bp);
   1950       1.185      kenh 	s = splbio();
   1951       1.185      kenh 	LIST_INSERT_HEAD(&wi_head, wi, wi_list);
   1952       1.185      kenh 	splx(s);
   1953       1.185      kenh 	return (wi);
   1954       1.185      kenh }
   1955       1.185      kenh 
   1956       1.185      kenh /*
   1957       1.185      kenh  * Free an ioctl structure and remove it from our list
   1958       1.185      kenh  */
   1959       1.185      kenh 
   1960       1.185      kenh void
   1961       1.259       dsl wi_free(struct wd_ioctl *wi)
   1962       1.185      kenh {
   1963       1.185      kenh 	int s;
   1964       1.185      kenh 
   1965       1.185      kenh 	s = splbio();
   1966       1.185      kenh 	LIST_REMOVE(wi, wi_list);
   1967       1.185      kenh 	splx(s);
   1968   1.337.2.4        ad 	buf_destroy(&wi->wi_bp);
   1969       1.185      kenh 	free(wi, M_TEMP);
   1970       1.185      kenh }
   1971       1.185      kenh 
   1972       1.185      kenh /*
   1973       1.185      kenh  * Find a wd_ioctl structure based on the struct buf.
   1974       1.185      kenh  */
   1975       1.185      kenh 
   1976       1.185      kenh struct wd_ioctl *
   1977       1.259       dsl wi_find(struct buf *bp)
   1978       1.185      kenh {
   1979       1.185      kenh 	struct wd_ioctl *wi;
   1980       1.185      kenh 	int s;
   1981       1.185      kenh 
   1982       1.185      kenh 	s = splbio();
   1983       1.185      kenh 	for (wi = wi_head.lh_first; wi != 0; wi = wi->wi_list.le_next)
   1984       1.185      kenh 		if (bp == &wi->wi_bp)
   1985       1.185      kenh 			break;
   1986       1.185      kenh 	splx(s);
   1987       1.185      kenh 	return (wi);
   1988       1.185      kenh }
   1989       1.185      kenh 
   1990       1.185      kenh /*
   1991       1.185      kenh  * Ioctl pseudo strategy routine
   1992       1.185      kenh  *
   1993       1.185      kenh  * This is mostly stolen from scsipi_ioctl.c:scsistrategy().  What
   1994       1.185      kenh  * happens here is:
   1995       1.185      kenh  *
   1996       1.185      kenh  * - wdioctl() queues a wd_ioctl structure.
   1997       1.185      kenh  *
   1998       1.185      kenh  * - wdioctl() calls physio/wdioctlstrategy based on whether or not
   1999       1.185      kenh  *   user space I/O is required.  If physio() is called, physio() eventually
   2000       1.185      kenh  *   calls wdioctlstrategy().
   2001       1.185      kenh  *
   2002       1.217    bouyer  * - In either case, wdioctlstrategy() calls wd->atabus->ata_exec_command()
   2003       1.185      kenh  *   to perform the actual command
   2004       1.185      kenh  *
   2005       1.185      kenh  * The reason for the use of the pseudo strategy routine is because
   2006       1.185      kenh  * when doing I/O to/from user space, physio _really_ wants to be in
   2007       1.185      kenh  * the loop.  We could put the entire buffer into the ioctl request
   2008       1.185      kenh  * structure, but that won't scale if we want to do things like download
   2009       1.185      kenh  * microcode.
   2010       1.185      kenh  */
   2011       1.185      kenh 
   2012       1.185      kenh void
   2013       1.259       dsl wdioctlstrategy(struct buf *bp)
   2014       1.185      kenh {
   2015       1.185      kenh 	struct wd_ioctl *wi;
   2016       1.287   thorpej 	struct ata_command ata_c;
   2017       1.185      kenh 	int error = 0;
   2018       1.185      kenh 
   2019       1.185      kenh 	wi = wi_find(bp);
   2020       1.185      kenh 	if (wi == NULL) {
   2021       1.313    martin 		printf("wdioctlstrategy: "
   2022       1.313    martin 		    "No matching ioctl request found in queue\n");
   2023       1.185      kenh 		error = EINVAL;
   2024       1.185      kenh 		goto bad;
   2025       1.185      kenh 	}
   2026       1.185      kenh 
   2027       1.287   thorpej 	memset(&ata_c, 0, sizeof(ata_c));
   2028       1.185      kenh 
   2029       1.185      kenh 	/*
   2030       1.185      kenh 	 * Abort if physio broke up the transfer
   2031       1.185      kenh 	 */
   2032       1.185      kenh 
   2033       1.186      kenh 	if (bp->b_bcount != wi->wi_atareq.datalen) {
   2034       1.185      kenh 		printf("physio split wd ioctl request... cannot proceed\n");
   2035       1.185      kenh 		error = EIO;
   2036       1.185      kenh 		goto bad;
   2037       1.185      kenh 	}
   2038       1.185      kenh 
   2039       1.185      kenh 	/*
   2040       1.185      kenh 	 * Abort if we didn't get a buffer size that was a multiple of
   2041       1.185      kenh 	 * our sector size (or was larger than NBBY)
   2042       1.185      kenh 	 */
   2043       1.185      kenh 
   2044       1.185      kenh 	if ((bp->b_bcount % wi->wi_softc->sc_dk.dk_label->d_secsize) != 0 ||
   2045       1.185      kenh 	    (bp->b_bcount / wi->wi_softc->sc_dk.dk_label->d_secsize) >=
   2046       1.185      kenh 	     (1 << NBBY)) {
   2047       1.185      kenh 		error = EINVAL;
   2048       1.185      kenh 		goto bad;
   2049       1.185      kenh 	}
   2050       1.185      kenh 
   2051       1.185      kenh 	/*
   2052       1.185      kenh 	 * Make sure a timeout was supplied in the ioctl request
   2053       1.185      kenh 	 */
   2054       1.185      kenh 
   2055       1.186      kenh 	if (wi->wi_atareq.timeout == 0) {
   2056       1.185      kenh 		error = EINVAL;
   2057       1.185      kenh 		goto bad;
   2058       1.185      kenh 	}
   2059       1.185      kenh 
   2060       1.186      kenh 	if (wi->wi_atareq.flags & ATACMD_READ)
   2061       1.287   thorpej 		ata_c.flags |= AT_READ;
   2062       1.186      kenh 	else if (wi->wi_atareq.flags & ATACMD_WRITE)
   2063       1.287   thorpej 		ata_c.flags |= AT_WRITE;
   2064       1.185      kenh 
   2065       1.188      kenh 	if (wi->wi_atareq.flags & ATACMD_READREG)
   2066       1.287   thorpej 		ata_c.flags |= AT_READREG;
   2067       1.188      kenh 
   2068       1.287   thorpej 	ata_c.flags |= AT_WAIT;
   2069       1.185      kenh 
   2070       1.287   thorpej 	ata_c.timeout = wi->wi_atareq.timeout;
   2071       1.287   thorpej 	ata_c.r_command = wi->wi_atareq.command;
   2072       1.287   thorpej 	ata_c.r_head = wi->wi_atareq.head & 0x0f;
   2073       1.287   thorpej 	ata_c.r_cyl = wi->wi_atareq.cylinder;
   2074       1.287   thorpej 	ata_c.r_sector = wi->wi_atareq.sec_num;
   2075       1.287   thorpej 	ata_c.r_count = wi->wi_atareq.sec_count;
   2076       1.287   thorpej 	ata_c.r_features = wi->wi_atareq.features;
   2077       1.287   thorpej 	ata_c.r_st_bmask = WDCS_DRDY;
   2078       1.287   thorpej 	ata_c.r_st_pmask = WDCS_DRDY;
   2079       1.287   thorpej 	ata_c.data = wi->wi_bp.b_data;
   2080       1.287   thorpej 	ata_c.bcount = wi->wi_bp.b_bcount;
   2081       1.185      kenh 
   2082       1.287   thorpej 	if (wi->wi_softc->atabus->ata_exec_command(wi->wi_softc->drvp, &ata_c)
   2083       1.288   thorpej 	    != ATACMD_COMPLETE) {
   2084       1.186      kenh 		wi->wi_atareq.retsts = ATACMD_ERROR;
   2085       1.185      kenh 		goto bad;
   2086       1.185      kenh 	}
   2087       1.185      kenh 
   2088       1.287   thorpej 	if (ata_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
   2089       1.287   thorpej 		if (ata_c.flags & AT_ERROR) {
   2090       1.186      kenh 			wi->wi_atareq.retsts = ATACMD_ERROR;
   2091       1.287   thorpej 			wi->wi_atareq.error = ata_c.r_error;
   2092       1.287   thorpej 		} else if (ata_c.flags & AT_DF)
   2093       1.186      kenh 			wi->wi_atareq.retsts = ATACMD_DF;
   2094       1.185      kenh 		else
   2095       1.186      kenh 			wi->wi_atareq.retsts = ATACMD_TIMEOUT;
   2096       1.188      kenh 	} else {
   2097       1.186      kenh 		wi->wi_atareq.retsts = ATACMD_OK;
   2098       1.188      kenh 		if (wi->wi_atareq.flags & ATACMD_READREG) {
   2099       1.287   thorpej 			wi->wi_atareq.head = ata_c.r_head ;
   2100       1.287   thorpej 			wi->wi_atareq.cylinder = ata_c.r_cyl;
   2101       1.287   thorpej 			wi->wi_atareq.sec_num = ata_c.r_sector;
   2102       1.287   thorpej 			wi->wi_atareq.sec_count = ata_c.r_count;
   2103       1.287   thorpej 			wi->wi_atareq.features = ata_c.r_features;
   2104       1.287   thorpej 			wi->wi_atareq.error = ata_c.r_error;
   2105       1.188      kenh 		}
   2106       1.188      kenh 	}
   2107       1.185      kenh 
   2108   1.337.2.7        ad 	bp->b_error = 0;
   2109   1.337.2.7        ad 	biodone(bp);
   2110       1.185      kenh 	return;
   2111       1.185      kenh bad:
   2112   1.337.2.7        ad 	bp->b_error = error;
   2113   1.337.2.7        ad 	biodone(bp);
   2114        1.21   deraadt }
   2115