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