Home | History | Annotate | Line # | Download | only in ata
wd.c revision 1.220.10.7
      1  1.220.10.7       jdc /*	$NetBSD: wd.c,v 1.220.10.7 2004/05/14 06:07:34 jdc 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.204    bouyer  * 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.178   mycroft  * Copyright (c) 1998 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.220.10.7       jdc __KERNEL_RCSID(0, "$NetBSD: wd.c,v 1.220.10.7 2004/05/14 06:07:34 jdc Exp $");
     70         1.1       cgd 
     71       1.192   hubertf #ifndef WDCDEBUG
     72       1.181    bouyer #define WDCDEBUG
     73       1.192   hubertf #endif /* WDCDEBUG */
     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.29   mycroft #include <sys/uio.h>
     86        1.29   mycroft #include <sys/malloc.h>
     87        1.64   mycroft #include <sys/device.h>
     88        1.94   mycroft #include <sys/disklabel.h>
     89        1.94   mycroft #include <sys/disk.h>
     90        1.29   mycroft #include <sys/syslog.h>
     91       1.149  christos #include <sys/proc.h>
     92       1.196     enami #include <sys/vnode.h>
     93       1.166  explorer #if NRND > 0
     94       1.165  explorer #include <sys/rnd.h>
     95       1.166  explorer #endif
     96        1.29   mycroft 
     97       1.150   mycroft #include <machine/intr.h>
     98       1.168       cgd #include <machine/bus.h>
     99        1.29   mycroft 
    100       1.181    bouyer #include <dev/ata/atareg.h>
    101       1.181    bouyer #include <dev/ata/atavar.h>
    102       1.181    bouyer #include <dev/ata/wdvar.h>
    103       1.181    bouyer #include <dev/ic/wdcreg.h>
    104       1.186      kenh #include <sys/ataio.h>
    105       1.163    bouyer #include "locators.h"
    106         1.1       cgd 
    107        1.98   mycroft #define	WAITTIME	(4 * hz)	/* time to wait for a completion */
    108  1.220.10.5       jmc 
    109  1.220.10.5       jmc #define	LBA48_THRESHOLD		(0xfffffff)	/* 128GB / DEV_BSIZE */
    110  1.220.10.5       jmc 
    111       1.189    bouyer #define	WDIORETRIES_SINGLE 4	/* number of retries before single-sector */
    112       1.181    bouyer #define	WDIORETRIES	5	/* number of retries before giving up */
    113       1.181    bouyer #define	RECOVERYTIME hz/2	/* time to wait before retrying a cmd */
    114        1.23   deraadt 
    115       1.181    bouyer #define	WDUNIT(dev)		DISKUNIT(dev)
    116       1.181    bouyer #define	WDPART(dev)		DISKPART(dev)
    117       1.196     enami #define	WDMINOR(unit, part)	DISKMINOR(unit, part)
    118        1.92       cgd #define	MAKEWDDEV(maj, unit, part)	MAKEDISKDEV(maj, unit, part)
    119        1.92       cgd 
    120        1.92       cgd #define	WDLABELDEV(dev)	(MAKEWDDEV(major(dev), WDUNIT(dev), RAW_PART))
    121         1.1       cgd 
    122       1.181    bouyer #define DEBUG_INTR   0x01
    123       1.181    bouyer #define DEBUG_XFERS  0x02
    124       1.181    bouyer #define DEBUG_STATUS 0x04
    125       1.181    bouyer #define DEBUG_FUNCS  0x08
    126       1.181    bouyer #define DEBUG_PROBE  0x10
    127       1.181    bouyer #ifdef WDCDEBUG
    128       1.181    bouyer extern int wdcdebug_wd_mask; /* init'ed in ata_wdc.c */
    129       1.181    bouyer #define WDCDEBUG_PRINT(args, level) \
    130       1.181    bouyer 	if (wdcdebug_wd_mask & (level)) \
    131       1.181    bouyer 		printf args
    132       1.163    bouyer #else
    133       1.181    bouyer #define WDCDEBUG_PRINT(args, level)
    134       1.163    bouyer #endif
    135       1.163    bouyer 
    136        1.64   mycroft struct wd_softc {
    137       1.181    bouyer 	/* General disk infos */
    138        1.64   mycroft 	struct device sc_dev;
    139       1.144   thorpej 	struct disk sc_dk;
    140       1.200   thorpej 	struct buf_queue sc_q;
    141       1.203   thorpej 	struct callout sc_restart_ch;
    142       1.181    bouyer 	/* IDE disk soft states */
    143       1.184    bouyer 	struct ata_bio sc_wdc_bio; /* current transfer */
    144       1.181    bouyer 	struct buf *sc_bp; /* buf being transfered */
    145       1.181    bouyer 	void *wdc_softc;   /* pointer to our parent */
    146       1.181    bouyer 	struct ata_drive_datas *drvp; /* Our controller's infos */
    147       1.217    bouyer 	const struct ata_bustype *atabus;
    148       1.181    bouyer 	int openings;
    149       1.181    bouyer 	struct ataparams sc_params;/* drive characteistics found */
    150       1.181    bouyer 	int sc_flags;
    151       1.220  christos #define	WDF_LOCKED	0x001
    152       1.220  christos #define	WDF_WANTED	0x002
    153       1.220  christos #define	WDF_WLABEL	0x004 /* label is writable */
    154       1.220  christos #define	WDF_LABELLING	0x008 /* writing label */
    155       1.181    bouyer /*
    156       1.181    bouyer  * XXX Nothing resets this yet, but disk change sensing will when ATA-4 is
    157       1.181    bouyer  * more fully implemented.
    158       1.181    bouyer  */
    159       1.220  christos #define WDF_LOADED	0x010 /* parameters loaded */
    160       1.220  christos #define WDF_WAIT	0x020 /* waiting for resources */
    161       1.220  christos #define WDF_LBA		0x040 /* using LBA mode */
    162       1.220  christos #define WDF_KLABEL	0x080 /* retain label after 'full' close */
    163       1.220  christos #define WDF_LBA48	0x100 /* using 48-bit LBA mode */
    164       1.181    bouyer 	int sc_capacity;
    165       1.181    bouyer 	int cyl; /* actual drive parameters */
    166       1.181    bouyer 	int heads;
    167       1.181    bouyer 	int sectors;
    168       1.181    bouyer 	int retries; /* number of xfer retry */
    169       1.196     enami 
    170       1.196     enami 	void *sc_sdhook;		/* our shutdown hook */
    171       1.196     enami 
    172       1.166  explorer #if NRND > 0
    173       1.165  explorer 	rndsource_element_t	rnd_source;
    174       1.166  explorer #endif
    175        1.74   mycroft };
    176        1.64   mycroft 
    177       1.181    bouyer #define sc_drive sc_wdc_bio.drive
    178       1.181    bouyer #define sc_mode sc_wdc_bio.mode
    179       1.181    bouyer #define sc_multi sc_wdc_bio.multi
    180       1.181    bouyer #define sc_badsect sc_wdc_bio.badsect
    181       1.181    bouyer 
    182       1.168       cgd int	wdprobe		__P((struct device *, struct cfdata *, void *));
    183       1.163    bouyer void	wdattach	__P((struct device *, struct device *, void *));
    184       1.196     enami int	wddetach __P((struct device *, int));
    185       1.196     enami int	wdactivate __P((struct device *, enum devact));
    186       1.181    bouyer int	wdprint	__P((void *, char *));
    187  1.220.10.1     lukem void	wdperror __P((const struct wd_softc *));
    188       1.102   mycroft 
    189       1.147   thorpej struct cfattach wd_ca = {
    190       1.196     enami 	sizeof(struct wd_softc), wdprobe, wdattach, wddetach, wdactivate
    191       1.147   thorpej };
    192       1.147   thorpej 
    193       1.167   thorpej extern struct cfdriver wd_cd;
    194       1.108   mycroft 
    195       1.185      kenh /*
    196       1.185      kenh  * Glue necessary to hook WDCIOCCOMMAND into physio
    197       1.185      kenh  */
    198       1.185      kenh 
    199       1.185      kenh struct wd_ioctl {
    200       1.185      kenh 	LIST_ENTRY(wd_ioctl) wi_list;
    201       1.185      kenh 	struct buf wi_bp;
    202       1.185      kenh 	struct uio wi_uio;
    203       1.185      kenh 	struct iovec wi_iov;
    204       1.186      kenh 	atareq_t wi_atareq;
    205       1.185      kenh 	struct wd_softc *wi_softc;
    206       1.185      kenh };
    207       1.185      kenh 
    208       1.185      kenh LIST_HEAD(, wd_ioctl) wi_head;
    209       1.185      kenh 
    210       1.185      kenh struct	wd_ioctl *wi_find __P((struct buf *));
    211       1.185      kenh void	wi_free __P((struct wd_ioctl *));
    212       1.185      kenh struct	wd_ioctl *wi_get __P((void));
    213       1.185      kenh void	wdioctlstrategy __P((struct buf *));
    214       1.185      kenh 
    215       1.181    bouyer void  wdgetdefaultlabel __P((struct wd_softc *, struct disklabel *));
    216       1.181    bouyer void  wdgetdisklabel	__P((struct wd_softc *));
    217       1.181    bouyer void  wdstrategy	__P((struct buf *));
    218       1.181    bouyer void  wdstart	__P((void *));
    219       1.181    bouyer void  __wdstart	__P((struct wd_softc*, struct buf *));
    220       1.181    bouyer void  wdrestart __P((void*));
    221       1.181    bouyer int   wd_get_params __P((struct wd_softc *, u_int8_t, struct ataparams *));
    222       1.190    bouyer void  wd_flushcache __P((struct wd_softc *, int));
    223       1.190    bouyer void  wd_shutdown __P((void*));
    224  1.220.10.3     grant int   wd_getcache __P((struct wd_softc *, int *));
    225  1.220.10.3     grant int   wd_setcache __P((struct wd_softc *, int));
    226       1.108   mycroft 
    227       1.102   mycroft struct dkdriver wddkdriver = { wdstrategy };
    228        1.65   mycroft 
    229       1.149  christos /* XXX: these should go elsewhere */
    230       1.149  christos cdev_decl(wd);
    231       1.149  christos bdev_decl(wd);
    232       1.149  christos 
    233       1.170       leo #ifdef HAS_BAD144_HANDLING
    234        1.64   mycroft static void bad144intern __P((struct wd_softc *));
    235       1.170       leo #endif
    236       1.181    bouyer int	wdlock	__P((struct wd_softc *));
    237       1.181    bouyer void	wdunlock	__P((struct wd_softc *));
    238         1.1       cgd 
    239         1.1       cgd int
    240       1.163    bouyer wdprobe(parent, match, aux)
    241       1.102   mycroft 	struct device *parent;
    242       1.168       cgd 	struct cfdata *match;
    243       1.168       cgd 
    244       1.168       cgd 	void *aux;
    245         1.1       cgd {
    246       1.216    bouyer 	struct ata_device *adev = aux;
    247       1.167   thorpej 
    248       1.216    bouyer 	if (adev == NULL)
    249       1.181    bouyer 		return 0;
    250       1.216    bouyer 	if (adev->adev_bustype->bustype_type != SCSIPI_BUSTYPE_ATA)
    251        1.64   mycroft 		return 0;
    252       1.181    bouyer 
    253       1.181    bouyer 	if (match->cf_loc[ATACF_CHANNEL] != ATACF_CHANNEL_DEFAULT &&
    254       1.216    bouyer 	    match->cf_loc[ATACF_CHANNEL] != adev->adev_channel)
    255       1.105   mycroft 		return 0;
    256       1.105   mycroft 
    257       1.168       cgd 	if (match->cf_loc[ATACF_DRIVE] != ATACF_DRIVE_DEFAULT &&
    258       1.216    bouyer 	    match->cf_loc[ATACF_DRIVE] != adev->adev_drv_data->drive)
    259        1.74   mycroft 		return 0;
    260        1.74   mycroft 	return 1;
    261        1.74   mycroft }
    262        1.64   mycroft 
    263        1.74   mycroft void
    264        1.74   mycroft wdattach(parent, self, aux)
    265        1.74   mycroft 	struct device *parent, *self;
    266        1.74   mycroft 	void *aux;
    267        1.74   mycroft {
    268        1.74   mycroft 	struct wd_softc *wd = (void *)self;
    269       1.216    bouyer 	struct ata_device *adev= aux;
    270        1.74   mycroft 	int i, blank;
    271       1.201     enami 	char buf[41], pbuf[9], c, *p, *q;
    272       1.181    bouyer 	WDCDEBUG_PRINT(("wdattach\n"), DEBUG_FUNCS | DEBUG_PROBE);
    273        1.56   mycroft 
    274       1.203   thorpej 	callout_init(&wd->sc_restart_ch);
    275       1.200   thorpej 	BUFQ_INIT(&wd->sc_q);
    276       1.200   thorpej 
    277       1.217    bouyer 	wd->atabus = adev->adev_bustype;
    278       1.216    bouyer 	wd->openings = adev->adev_openings;
    279       1.216    bouyer 	wd->drvp = adev->adev_drv_data;;
    280       1.181    bouyer 	wd->wdc_softc = parent;
    281       1.181    bouyer 	/* give back our softc to our caller */
    282       1.181    bouyer 	wd->drvp->drv_softc = &wd->sc_dev;
    283       1.181    bouyer 
    284       1.181    bouyer 	/* read our drive info */
    285       1.181    bouyer 	if (wd_get_params(wd, AT_POLL, &wd->sc_params) != 0) {
    286       1.181    bouyer 		printf("%s: IDENTIFY failed\n", wd->sc_dev.dv_xname);
    287       1.181    bouyer 		return;
    288       1.181    bouyer 	}
    289       1.163    bouyer 
    290       1.181    bouyer 	for (blank = 0, p = wd->sc_params.atap_model, q = buf, i = 0;
    291       1.181    bouyer 	    i < sizeof(wd->sc_params.atap_model); i++) {
    292       1.135   mycroft 		c = *p++;
    293       1.135   mycroft 		if (c == '\0')
    294       1.135   mycroft 			break;
    295       1.135   mycroft 		if (c != ' ') {
    296       1.135   mycroft 			if (blank) {
    297       1.135   mycroft 				*q++ = ' ';
    298       1.135   mycroft 				blank = 0;
    299       1.135   mycroft 			}
    300       1.135   mycroft 			*q++ = c;
    301       1.135   mycroft 		} else
    302       1.135   mycroft 			blank = 1;
    303       1.195     enami 	}
    304       1.135   mycroft 	*q++ = '\0';
    305       1.135   mycroft 
    306       1.172   mycroft 	printf(": <%s>\n", buf);
    307       1.113   mycroft 
    308       1.181    bouyer 	if ((wd->sc_params.atap_multi & 0xff) > 1) {
    309       1.181    bouyer 		wd->sc_multi = wd->sc_params.atap_multi & 0xff;
    310       1.113   mycroft 	} else {
    311       1.181    bouyer 		wd->sc_multi = 1;
    312       1.113   mycroft 	}
    313       1.113   mycroft 
    314       1.210     lukem 	printf("%s: drive supports %d-sector PIO transfers,",
    315       1.184    bouyer 	    wd->sc_dev.dv_xname, wd->sc_multi);
    316       1.172   mycroft 
    317       1.220  christos 	/* 48-bit LBA addressing */
    318       1.220  christos 	if ((wd->sc_params.atap_cmd2_en & WDC_CAP_LBA48) != 0)
    319       1.220  christos 		wd->sc_flags |= WDF_LBA48;
    320       1.220  christos 
    321       1.172   mycroft 	/* Prior to ATA-4, LBA was optional. */
    322       1.181    bouyer 	if ((wd->sc_params.atap_capabilities1 & WDC_CAP_LBA) != 0)
    323       1.181    bouyer 		wd->sc_flags |= WDF_LBA;
    324       1.174   mycroft #if 0
    325       1.172   mycroft 	/* ATA-4 requires LBA. */
    326       1.181    bouyer 	if (wd->sc_params.atap_ataversion != 0xffff &&
    327       1.181    bouyer 	    wd->sc_params.atap_ataversion >= WDC_VER_ATA4)
    328       1.181    bouyer 		wd->sc_flags |= WDF_LBA;
    329       1.174   mycroft #endif
    330       1.172   mycroft 
    331       1.220  christos 	if ((wd->sc_flags & WDF_LBA48) != 0) {
    332       1.220  christos 		printf(" LBA48 addressing\n");
    333       1.220  christos 		wd->sc_capacity =
    334       1.220  christos 		    ((u_int64_t) wd->sc_params.__reserved6[11] << 48) |
    335       1.220  christos 		    ((u_int64_t) wd->sc_params.__reserved6[10] << 32) |
    336       1.220  christos 		    ((u_int64_t) wd->sc_params.__reserved6[9]  << 16) |
    337       1.220  christos 		    ((u_int64_t) wd->sc_params.__reserved6[8]  << 0);
    338       1.220  christos 	} else if ((wd->sc_flags & WDF_LBA) != 0) {
    339       1.210     lukem 		printf(" LBA addressing\n");
    340       1.181    bouyer 		wd->sc_capacity =
    341       1.181    bouyer 		    (wd->sc_params.atap_capacity[1] << 16) |
    342       1.181    bouyer 		    wd->sc_params.atap_capacity[0];
    343       1.172   mycroft 	} else {
    344       1.184    bouyer 		printf(" chs addressing\n");
    345       1.181    bouyer 		wd->sc_capacity =
    346       1.181    bouyer 		    wd->sc_params.atap_cylinders *
    347       1.181    bouyer 		    wd->sc_params.atap_heads *
    348       1.181    bouyer 		    wd->sc_params.atap_sectors;
    349       1.172   mycroft 	}
    350       1.201     enami 	format_bytes(pbuf, sizeof(pbuf),
    351       1.201     enami 	    (u_int64_t)wd->sc_capacity * DEV_BSIZE);
    352       1.201     enami 	printf("%s: %s, %d cyl, %d head, %d sec, "
    353       1.201     enami 	    "%d bytes/sect x %d sectors\n",
    354  1.220.10.6       jmc 	    self->dv_xname, pbuf,
    355  1.220.10.6       jmc 	    (wd->sc_flags & WDF_LBA) ? (int)(wd->sc_capacity /
    356  1.220.10.6       jmc 		(wd->sc_params.atap_heads * wd->sc_params.atap_sectors)) :
    357  1.220.10.6       jmc 		wd->sc_params.atap_cylinders,
    358       1.201     enami 	    wd->sc_params.atap_heads, wd->sc_params.atap_sectors,
    359       1.201     enami 	    DEV_BSIZE, wd->sc_capacity);
    360       1.201     enami 
    361       1.181    bouyer 	WDCDEBUG_PRINT(("%s: atap_dmatiming_mimi=%d, atap_dmatiming_recom=%d\n",
    362       1.181    bouyer 	    self->dv_xname, wd->sc_params.atap_dmatiming_mimi,
    363       1.181    bouyer 	    wd->sc_params.atap_dmatiming_recom), DEBUG_PROBE);
    364       1.181    bouyer 	/*
    365       1.181    bouyer 	 * Initialize and attach the disk structure.
    366       1.181    bouyer 	 */
    367       1.181    bouyer 	wd->sc_dk.dk_driver = &wddkdriver;
    368       1.181    bouyer 	wd->sc_dk.dk_name = wd->sc_dev.dv_xname;
    369       1.181    bouyer 	disk_attach(&wd->sc_dk);
    370       1.181    bouyer 	wd->sc_wdc_bio.lp = wd->sc_dk.dk_label;
    371       1.196     enami 	wd->sc_sdhook = shutdownhook_establish(wd_shutdown, wd);
    372       1.196     enami 	if (wd->sc_sdhook == NULL)
    373       1.190    bouyer 		printf("%s: WARNING: unable to establish shutdown hook\n",
    374       1.190    bouyer 		    wd->sc_dev.dv_xname);
    375       1.166  explorer #if NRND > 0
    376       1.193  explorer 	rnd_attach_source(&wd->rnd_source, wd->sc_dev.dv_xname,
    377       1.193  explorer 			  RND_TYPE_DISK, 0);
    378       1.166  explorer #endif
    379       1.196     enami }
    380       1.196     enami 
    381       1.196     enami int
    382       1.196     enami wdactivate(self, act)
    383       1.196     enami 	struct device *self;
    384       1.196     enami 	enum devact act;
    385       1.196     enami {
    386       1.196     enami 	int rv = 0;
    387       1.196     enami 
    388       1.196     enami 	switch (act) {
    389       1.196     enami 	case DVACT_ACTIVATE:
    390       1.196     enami 		rv = EOPNOTSUPP;
    391       1.196     enami 		break;
    392       1.196     enami 
    393       1.196     enami 	case DVACT_DEACTIVATE:
    394       1.196     enami 		/*
    395       1.196     enami 		 * Nothing to do; we key off the device's DVF_ACTIVATE.
    396       1.196     enami 		 */
    397       1.196     enami 		break;
    398       1.196     enami 	}
    399       1.196     enami 	return (rv);
    400       1.196     enami }
    401       1.196     enami 
    402       1.196     enami int
    403       1.196     enami wddetach(self, flags)
    404       1.196     enami 	struct device *self;
    405       1.196     enami 	int flags;
    406       1.196     enami {
    407       1.196     enami 	struct wd_softc *sc = (struct wd_softc *)self;
    408       1.196     enami 	struct buf *bp;
    409       1.213  drochner 	int s, bmaj, cmaj, i, mn;
    410       1.196     enami 
    411       1.196     enami 	/* locate the major number */
    412       1.196     enami 	for (bmaj = 0; bmaj < nblkdev; bmaj++)
    413       1.196     enami 		if (bdevsw[bmaj].d_open == wdopen)
    414       1.196     enami 			break;
    415       1.196     enami 	for (cmaj = 0; cmaj < nchrdev; cmaj++)
    416       1.196     enami 		if (cdevsw[cmaj].d_open == wdopen)
    417       1.196     enami 			break;
    418       1.196     enami 
    419       1.196     enami 	s = splbio();
    420       1.196     enami 
    421       1.196     enami 	/* Kill off any queued buffers. */
    422       1.200   thorpej 	while ((bp = BUFQ_FIRST(&sc->sc_q)) != NULL) {
    423       1.200   thorpej 		BUFQ_REMOVE(&sc->sc_q, bp);
    424       1.196     enami 		bp->b_error = EIO;
    425       1.196     enami 		bp->b_flags |= B_ERROR;
    426       1.196     enami 		bp->b_resid = bp->b_bcount;
    427       1.196     enami 		biodone(bp);
    428       1.196     enami 	}
    429       1.196     enami 
    430       1.196     enami 	splx(s);
    431       1.196     enami 
    432       1.196     enami 	/* Nuke the vnodes for any open instances. */
    433       1.213  drochner 	for (i = 0; i < MAXPARTITIONS; i++) {
    434       1.213  drochner 		mn = WDMINOR(self->dv_unit, i);
    435       1.213  drochner 		vdevgone(bmaj, mn, mn, VBLK);
    436       1.213  drochner 		vdevgone(cmaj, mn, mn, VCHR);
    437       1.213  drochner 	}
    438       1.196     enami 
    439       1.196     enami 	/* Detach disk. */
    440       1.196     enami 	disk_detach(&sc->sc_dk);
    441       1.196     enami 
    442       1.196     enami 	/* Get rid of the shutdown hook. */
    443       1.196     enami 	if (sc->sc_sdhook != NULL)
    444       1.196     enami 		shutdownhook_disestablish(sc->sc_sdhook);
    445       1.196     enami 
    446       1.196     enami #if NRND > 0
    447       1.196     enami 	/* Unhook the entropy source. */
    448       1.196     enami 	rnd_detach_source(&sc->rnd_source);
    449       1.196     enami #endif
    450       1.196     enami 
    451       1.196     enami 	return (0);
    452         1.1       cgd }
    453         1.1       cgd 
    454        1.64   mycroft /*
    455       1.135   mycroft  * Read/write routine for a buffer.  Validates the arguments and schedules the
    456       1.135   mycroft  * transfer.  Does not wait for the transfer to complete.
    457         1.1       cgd  */
    458        1.64   mycroft void
    459        1.55   mycroft wdstrategy(bp)
    460        1.55   mycroft 	struct buf *bp;
    461         1.1       cgd {
    462       1.209   thorpej 	struct wd_softc *wd = device_lookup(&wd_cd, WDUNIT(bp->b_dev));
    463       1.202   thorpej 	struct disklabel *lp = wd->sc_dk.dk_label;
    464       1.202   thorpej 	daddr_t blkno;
    465        1.37   mycroft 	int s;
    466       1.202   thorpej 
    467       1.181    bouyer 	WDCDEBUG_PRINT(("wdstrategy (%s)\n", wd->sc_dev.dv_xname),
    468       1.182    bouyer 	    DEBUG_XFERS);
    469       1.181    bouyer 
    470       1.135   mycroft 	/* Valid request?  */
    471       1.135   mycroft 	if (bp->b_blkno < 0 ||
    472       1.202   thorpej 	    (bp->b_bcount % lp->d_secsize) != 0 ||
    473       1.202   thorpej 	    (bp->b_bcount / lp->d_secsize) >= (1 << NBBY)) {
    474         1.1       cgd 		bp->b_error = EINVAL;
    475        1.93   mycroft 		goto bad;
    476         1.1       cgd 	}
    477       1.181    bouyer 
    478       1.135   mycroft 	/* If device invalidated (e.g. media change, door open), error. */
    479       1.181    bouyer 	if ((wd->sc_flags & WDF_LOADED) == 0) {
    480       1.135   mycroft 		bp->b_error = EIO;
    481       1.135   mycroft 		goto bad;
    482       1.135   mycroft 	}
    483       1.135   mycroft 
    484        1.93   mycroft 	/* If it's a null transfer, return immediately. */
    485        1.93   mycroft 	if (bp->b_bcount == 0)
    486        1.93   mycroft 		goto done;
    487        1.93   mycroft 
    488       1.128   mycroft 	/*
    489       1.128   mycroft 	 * Do bounds checking, adjust transfer. if error, process.
    490       1.128   mycroft 	 * If end of partition, just return.
    491       1.128   mycroft 	 */
    492       1.138   mycroft 	if (WDPART(bp->b_dev) != RAW_PART &&
    493       1.144   thorpej 	    bounds_check_with_label(bp, wd->sc_dk.dk_label,
    494       1.181    bouyer 	    (wd->sc_flags & (WDF_WLABEL|WDF_LABELLING)) != 0) <= 0)
    495       1.128   mycroft 		goto done;
    496       1.202   thorpej 
    497       1.202   thorpej 	/*
    498       1.202   thorpej 	 * Now convert the block number to absolute and put it in
    499       1.202   thorpej 	 * terms of the device's logical block size.
    500       1.202   thorpej 	 */
    501       1.202   thorpej 	if (lp->d_secsize >= DEV_BSIZE)
    502       1.202   thorpej 		blkno = bp->b_blkno / (lp->d_secsize / DEV_BSIZE);
    503       1.202   thorpej 	else
    504       1.202   thorpej 		blkno = bp->b_blkno * (DEV_BSIZE / lp->d_secsize);
    505       1.202   thorpej 
    506       1.202   thorpej 	if (WDPART(bp->b_dev) != RAW_PART)
    507       1.202   thorpej 		blkno += lp->d_partitions[WDPART(bp->b_dev)].p_offset;
    508       1.202   thorpej 
    509       1.202   thorpej 	bp->b_rawblkno = blkno;
    510       1.202   thorpej 
    511        1.64   mycroft 	/* Queue transfer on drive, activate drive and controller if idle. */
    512         1.1       cgd 	s = splbio();
    513       1.200   thorpej 	disksort_blkno(&wd->sc_q, bp);
    514       1.163    bouyer 	wdstart(wd);
    515         1.1       cgd 	splx(s);
    516        1.64   mycroft 	return;
    517        1.93   mycroft bad:
    518        1.93   mycroft 	bp->b_flags |= B_ERROR;
    519         1.1       cgd done:
    520        1.64   mycroft 	/* Toss transfer; we're done early. */
    521       1.135   mycroft 	bp->b_resid = bp->b_bcount;
    522         1.1       cgd 	biodone(bp);
    523         1.1       cgd }
    524         1.1       cgd 
    525         1.1       cgd /*
    526       1.135   mycroft  * Queue a drive for I/O.
    527         1.1       cgd  */
    528       1.108   mycroft void
    529       1.163    bouyer wdstart(arg)
    530       1.163    bouyer 	void *arg;
    531         1.1       cgd {
    532       1.163    bouyer 	struct wd_softc *wd = arg;
    533       1.200   thorpej 	struct buf *bp = NULL;
    534       1.163    bouyer 
    535       1.181    bouyer 	WDCDEBUG_PRINT(("wdstart %s\n", wd->sc_dev.dv_xname),
    536       1.182    bouyer 	    DEBUG_XFERS);
    537       1.181    bouyer 	while (wd->openings > 0) {
    538       1.163    bouyer 
    539       1.163    bouyer 		/* Is there a buf for us ? */
    540       1.200   thorpej 		if ((bp = BUFQ_FIRST(&wd->sc_q)) == NULL)
    541       1.200   thorpej 			return;
    542       1.200   thorpej 		BUFQ_REMOVE(&wd->sc_q, bp);
    543       1.181    bouyer 
    544       1.163    bouyer 		/*
    545       1.163    bouyer 		 * Make the command. First lock the device
    546       1.163    bouyer 		 */
    547       1.181    bouyer 		wd->openings--;
    548       1.181    bouyer 
    549       1.181    bouyer 		wd->retries = 0;
    550       1.181    bouyer 		__wdstart(wd, bp);
    551       1.181    bouyer 	}
    552       1.181    bouyer }
    553       1.181    bouyer 
    554       1.181    bouyer void
    555       1.181    bouyer __wdstart(wd, bp)
    556       1.181    bouyer 	struct wd_softc *wd;
    557       1.181    bouyer 	struct buf *bp;
    558       1.181    bouyer {
    559       1.202   thorpej 
    560       1.202   thorpej 	wd->sc_wdc_bio.blkno = bp->b_rawblkno;
    561       1.181    bouyer 	wd->sc_wdc_bio.blkdone =0;
    562       1.181    bouyer 	wd->sc_bp = bp;
    563       1.181    bouyer 	/*
    564       1.181    bouyer 	 * If we're retrying, retry in single-sector mode. This will give us
    565       1.181    bouyer 	 * the sector number of the problem, and will eventually allow the
    566       1.184    bouyer 	 * transfer to succeed.
    567       1.181    bouyer 	 */
    568       1.189    bouyer 	if (wd->sc_multi == 1 || wd->retries >= WDIORETRIES_SINGLE)
    569       1.181    bouyer 		wd->sc_wdc_bio.flags = ATA_SINGLE;
    570       1.181    bouyer 	else
    571       1.181    bouyer 		wd->sc_wdc_bio.flags = 0;
    572  1.220.10.5       jmc 	if (wd->sc_flags & WDF_LBA48 && wd->sc_wdc_bio.blkno > LBA48_THRESHOLD)
    573       1.220  christos 		wd->sc_wdc_bio.flags |= ATA_LBA48;
    574       1.181    bouyer 	if (wd->sc_flags & WDF_LBA)
    575       1.181    bouyer 		wd->sc_wdc_bio.flags |= ATA_LBA;
    576       1.181    bouyer 	if (bp->b_flags & B_READ)
    577       1.181    bouyer 		wd->sc_wdc_bio.flags |= ATA_READ;
    578       1.181    bouyer 	wd->sc_wdc_bio.bcount = bp->b_bcount;
    579       1.181    bouyer 	wd->sc_wdc_bio.databuf = bp->b_data;
    580       1.181    bouyer 	/* Instrumentation. */
    581       1.181    bouyer 	disk_busy(&wd->sc_dk);
    582       1.217    bouyer 	switch (wd->atabus->ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
    583       1.181    bouyer 	case WDC_TRY_AGAIN:
    584       1.203   thorpej 		callout_reset(&wd->sc_restart_ch, hz, wdrestart, wd);
    585       1.181    bouyer 		break;
    586       1.181    bouyer 	case WDC_QUEUED:
    587       1.181    bouyer 	case WDC_COMPLETE:
    588       1.181    bouyer 		break;
    589       1.181    bouyer 	default:
    590       1.217    bouyer 		panic("__wdstart: bad return code from ata_bio()");
    591       1.181    bouyer 	}
    592       1.181    bouyer }
    593       1.181    bouyer 
    594       1.181    bouyer void
    595       1.181    bouyer wddone(v)
    596       1.181    bouyer 	void *v;
    597       1.181    bouyer {
    598       1.181    bouyer 	struct wd_softc *wd = v;
    599       1.181    bouyer 	struct buf *bp = wd->sc_bp;
    600  1.220.10.1     lukem 	const char *errmsg;
    601  1.220.10.1     lukem 	int do_perror = 0;
    602       1.181    bouyer 	WDCDEBUG_PRINT(("wddone %s\n", wd->sc_dev.dv_xname),
    603       1.182    bouyer 	    DEBUG_XFERS);
    604       1.181    bouyer 
    605       1.214     bjh21 	if (bp == NULL)
    606       1.214     bjh21 		return;
    607       1.181    bouyer 	bp->b_resid = wd->sc_wdc_bio.bcount;
    608       1.181    bouyer 	switch (wd->sc_wdc_bio.error) {
    609       1.181    bouyer 	case ERR_DMA:
    610  1.220.10.1     lukem 		errmsg = "DMA error";
    611       1.181    bouyer 		goto retry;
    612       1.181    bouyer 	case ERR_DF:
    613  1.220.10.1     lukem 		errmsg = "device fault";
    614       1.181    bouyer 		goto retry;
    615       1.181    bouyer 	case TIMEOUT:
    616  1.220.10.1     lukem 		errmsg = "device timeout";
    617       1.181    bouyer 		goto retry;
    618       1.181    bouyer 	case ERROR:
    619       1.181    bouyer 		/* Don't care about media change bits */
    620       1.181    bouyer 		if (wd->sc_wdc_bio.r_error != 0 &&
    621       1.181    bouyer 		    (wd->sc_wdc_bio.r_error & ~(WDCE_MC | WDCE_MCR)) == 0)
    622       1.181    bouyer 			goto noerror;
    623  1.220.10.1     lukem 		errmsg = "error";
    624  1.220.10.1     lukem 		do_perror = 1;
    625       1.181    bouyer retry:		/* Just reset and retry. Can we do more ? */
    626       1.217    bouyer 		wd->atabus->ata_reset_channel(wd->drvp);
    627  1.220.10.1     lukem 		diskerr(bp, "wd", errmsg, LOG_PRINTF,
    628       1.181    bouyer 		    wd->sc_wdc_bio.blkdone, wd->sc_dk.dk_label);
    629  1.220.10.1     lukem 		if (wd->retries < WDIORETRIES)
    630       1.181    bouyer 			printf(", retrying\n");
    631  1.220.10.1     lukem 		if (do_perror)
    632  1.220.10.1     lukem 			wdperror(wd);
    633  1.220.10.1     lukem 		if (wd->retries < WDIORETRIES) {
    634  1.220.10.1     lukem 			wd->retries++;
    635       1.203   thorpej 			callout_reset(&wd->sc_restart_ch, RECOVERYTIME,
    636       1.203   thorpej 			    wdrestart, wd);
    637       1.181    bouyer 			return;
    638       1.181    bouyer 		}
    639       1.181    bouyer 		printf("\n");
    640       1.181    bouyer 		bp->b_flags |= B_ERROR;
    641       1.181    bouyer 		bp->b_error = EIO;
    642       1.181    bouyer 		break;
    643       1.181    bouyer 	case NOERROR:
    644       1.181    bouyer noerror:	if ((wd->sc_wdc_bio.flags & ATA_CORR) || wd->retries > 0)
    645       1.181    bouyer 			printf("%s: soft error (corrected)\n",
    646       1.181    bouyer 			    wd->sc_dev.dv_xname);
    647       1.197     enami 		break;
    648       1.197     enami 	case ERR_NODEV:
    649       1.197     enami 		bp->b_flags |= B_ERROR;
    650       1.197     enami 		bp->b_error = EIO;
    651       1.197     enami 		break;
    652        1.64   mycroft 	}
    653       1.181    bouyer 	disk_unbusy(&wd->sc_dk, (bp->b_bcount - bp->b_resid));
    654       1.181    bouyer #if NRND > 0
    655       1.181    bouyer 	rnd_add_uint32(&wd->rnd_source, bp->b_blkno);
    656       1.181    bouyer #endif
    657       1.181    bouyer 	biodone(bp);
    658       1.181    bouyer 	wd->openings++;
    659       1.181    bouyer 	wdstart(wd);
    660       1.181    bouyer }
    661       1.181    bouyer 
    662       1.181    bouyer void
    663       1.181    bouyer wdrestart(v)
    664       1.181    bouyer 	void *v;
    665       1.181    bouyer {
    666       1.181    bouyer 	struct wd_softc *wd = v;
    667       1.181    bouyer 	struct buf *bp = wd->sc_bp;
    668       1.181    bouyer 	int s;
    669       1.181    bouyer 	WDCDEBUG_PRINT(("wdrestart %s\n", wd->sc_dev.dv_xname),
    670       1.182    bouyer 	    DEBUG_XFERS);
    671       1.181    bouyer 
    672       1.181    bouyer 	s = splbio();
    673       1.181    bouyer 	__wdstart(v, bp);
    674       1.181    bouyer 	splx(s);
    675       1.141   mycroft }
    676       1.141   mycroft 
    677       1.141   mycroft int
    678       1.149  christos wdread(dev, uio, flags)
    679       1.141   mycroft 	dev_t dev;
    680       1.141   mycroft 	struct uio *uio;
    681       1.149  christos 	int flags;
    682       1.141   mycroft {
    683       1.141   mycroft 
    684       1.182    bouyer 	WDCDEBUG_PRINT(("wdread\n"), DEBUG_XFERS);
    685       1.141   mycroft 	return (physio(wdstrategy, NULL, dev, B_READ, minphys, uio));
    686       1.141   mycroft }
    687       1.141   mycroft 
    688       1.141   mycroft int
    689       1.149  christos wdwrite(dev, uio, flags)
    690       1.141   mycroft 	dev_t dev;
    691       1.141   mycroft 	struct uio *uio;
    692       1.149  christos 	int flags;
    693       1.141   mycroft {
    694       1.141   mycroft 
    695       1.182    bouyer 	WDCDEBUG_PRINT(("wdwrite\n"), DEBUG_XFERS);
    696       1.141   mycroft 	return (physio(wdstrategy, NULL, dev, B_WRITE, minphys, uio));
    697        1.64   mycroft }
    698        1.64   mycroft 
    699         1.1       cgd /*
    700       1.135   mycroft  * Wait interruptibly for an exclusive lock.
    701       1.135   mycroft  *
    702       1.135   mycroft  * XXX
    703       1.135   mycroft  * Several drivers do this; it should be abstracted and made MP-safe.
    704       1.135   mycroft  */
    705       1.132   mycroft int
    706       1.181    bouyer wdlock(wd)
    707       1.181    bouyer 	struct wd_softc *wd;
    708       1.132   mycroft {
    709       1.132   mycroft 	int error;
    710       1.163    bouyer 	int s;
    711       1.163    bouyer 
    712       1.181    bouyer 	WDCDEBUG_PRINT(("wdlock\n"), DEBUG_FUNCS);
    713       1.132   mycroft 
    714       1.163    bouyer 	s = splbio();
    715       1.163    bouyer 
    716       1.181    bouyer 	while ((wd->sc_flags & WDF_LOCKED) != 0) {
    717       1.181    bouyer 		wd->sc_flags |= WDF_WANTED;
    718       1.181    bouyer 		if ((error = tsleep(wd, PRIBIO | PCATCH,
    719       1.163    bouyer 		    "wdlck", 0)) != 0) {
    720       1.163    bouyer 			splx(s);
    721       1.132   mycroft 			return error;
    722       1.163    bouyer 		}
    723       1.132   mycroft 	}
    724       1.181    bouyer 	wd->sc_flags |= WDF_LOCKED;
    725       1.163    bouyer 	splx(s);
    726       1.132   mycroft 	return 0;
    727       1.132   mycroft }
    728       1.132   mycroft 
    729       1.135   mycroft /*
    730       1.135   mycroft  * Unlock and wake up any waiters.
    731       1.135   mycroft  */
    732       1.132   mycroft void
    733       1.181    bouyer wdunlock(wd)
    734       1.181    bouyer 	struct wd_softc *wd;
    735       1.132   mycroft {
    736       1.132   mycroft 
    737       1.181    bouyer 	WDCDEBUG_PRINT(("wdunlock\n"), DEBUG_FUNCS);
    738       1.163    bouyer 
    739       1.181    bouyer 	wd->sc_flags &= ~WDF_LOCKED;
    740       1.181    bouyer 	if ((wd->sc_flags & WDF_WANTED) != 0) {
    741       1.181    bouyer 		wd->sc_flags &= ~WDF_WANTED;
    742       1.181    bouyer 		wakeup(wd);
    743       1.132   mycroft 	}
    744       1.132   mycroft }
    745       1.132   mycroft 
    746         1.1       cgd int
    747       1.149  christos wdopen(dev, flag, fmt, p)
    748        1.55   mycroft 	dev_t dev;
    749        1.93   mycroft 	int flag, fmt;
    750       1.149  christos 	struct proc *p;
    751         1.1       cgd {
    752       1.135   mycroft 	struct wd_softc *wd;
    753       1.208   thorpej 	int part, error;
    754       1.163    bouyer 
    755       1.181    bouyer 	WDCDEBUG_PRINT(("wdopen\n"), DEBUG_FUNCS);
    756       1.208   thorpej 	wd = device_lookup(&wd_cd, WDUNIT(dev));
    757       1.158        pk 	if (wd == NULL)
    758       1.208   thorpej 		return (ENXIO);
    759       1.187   thorpej 
    760       1.187   thorpej 	/*
    761       1.187   thorpej 	 * If this is the first open of this device, add a reference
    762       1.187   thorpej 	 * to the adapter.
    763       1.187   thorpej 	 */
    764       1.187   thorpej 	if (wd->sc_dk.dk_openmask == 0 &&
    765       1.217    bouyer 	    (error = wd->atabus->ata_addref(wd->drvp)) != 0)
    766       1.187   thorpej 		return (error);
    767       1.187   thorpej 
    768       1.181    bouyer 	if ((error = wdlock(wd)) != 0)
    769       1.187   thorpej 		goto bad4;
    770         1.3   deraadt 
    771       1.109   mycroft 	if (wd->sc_dk.dk_openmask != 0) {
    772       1.109   mycroft 		/*
    773       1.109   mycroft 		 * If any partition is open, but the disk has been invalidated,
    774       1.109   mycroft 		 * disallow further opens.
    775       1.109   mycroft 		 */
    776       1.181    bouyer 		if ((wd->sc_flags & WDF_LOADED) == 0) {
    777       1.136   mycroft 			error = EIO;
    778       1.136   mycroft 			goto bad3;
    779       1.136   mycroft 		}
    780       1.109   mycroft 	} else {
    781       1.181    bouyer 		if ((wd->sc_flags & WDF_LOADED) == 0) {
    782       1.181    bouyer 			wd->sc_flags |= WDF_LOADED;
    783       1.108   mycroft 
    784       1.108   mycroft 			/* Load the physical device parameters. */
    785       1.183    bouyer 			wd_get_params(wd, AT_WAIT, &wd->sc_params);
    786       1.108   mycroft 
    787       1.108   mycroft 			/* Load the partition info if not already loaded. */
    788       1.108   mycroft 			wdgetdisklabel(wd);
    789       1.108   mycroft 		}
    790       1.135   mycroft 	}
    791       1.108   mycroft 
    792       1.135   mycroft 	part = WDPART(dev);
    793       1.108   mycroft 
    794       1.109   mycroft 	/* Check that the partition exists. */
    795        1.93   mycroft 	if (part != RAW_PART &&
    796       1.144   thorpej 	    (part >= wd->sc_dk.dk_label->d_npartitions ||
    797       1.144   thorpej 	     wd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
    798        1.93   mycroft 		error = ENXIO;
    799        1.93   mycroft 		goto bad;
    800        1.93   mycroft 	}
    801       1.181    bouyer 
    802        1.64   mycroft 	/* Insure only one open at a time. */
    803         1.3   deraadt 	switch (fmt) {
    804         1.3   deraadt 	case S_IFCHR:
    805        1.94   mycroft 		wd->sc_dk.dk_copenmask |= (1 << part);
    806         1.3   deraadt 		break;
    807         1.3   deraadt 	case S_IFBLK:
    808        1.94   mycroft 		wd->sc_dk.dk_bopenmask |= (1 << part);
    809         1.3   deraadt 		break;
    810         1.3   deraadt 	}
    811       1.181    bouyer 	wd->sc_dk.dk_openmask =
    812       1.181    bouyer 	    wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
    813        1.60   mycroft 
    814       1.181    bouyer 	wdunlock(wd);
    815        1.37   mycroft 	return 0;
    816        1.93   mycroft 
    817        1.93   mycroft bad:
    818       1.118   mycroft 	if (wd->sc_dk.dk_openmask == 0) {
    819       1.108   mycroft 	}
    820       1.108   mycroft 
    821       1.136   mycroft bad3:
    822       1.181    bouyer 	wdunlock(wd);
    823       1.187   thorpej bad4:
    824       1.187   thorpej 	if (wd->sc_dk.dk_openmask == 0)
    825       1.217    bouyer 		wd->atabus->ata_delref(wd->drvp);
    826        1.93   mycroft 	return error;
    827         1.1       cgd }
    828         1.1       cgd 
    829       1.135   mycroft int
    830       1.149  christos wdclose(dev, flag, fmt, p)
    831       1.135   mycroft 	dev_t dev;
    832       1.135   mycroft 	int flag, fmt;
    833       1.149  christos 	struct proc *p;
    834       1.135   mycroft {
    835       1.209   thorpej 	struct wd_softc *wd = device_lookup(&wd_cd, WDUNIT(dev));
    836       1.135   mycroft 	int part = WDPART(dev);
    837       1.135   mycroft 	int error;
    838       1.181    bouyer 
    839       1.181    bouyer 	WDCDEBUG_PRINT(("wdclose\n"), DEBUG_FUNCS);
    840       1.181    bouyer 	if ((error = wdlock(wd)) != 0)
    841       1.135   mycroft 		return error;
    842       1.135   mycroft 
    843       1.135   mycroft 	switch (fmt) {
    844       1.135   mycroft 	case S_IFCHR:
    845       1.135   mycroft 		wd->sc_dk.dk_copenmask &= ~(1 << part);
    846       1.135   mycroft 		break;
    847       1.135   mycroft 	case S_IFBLK:
    848       1.135   mycroft 		wd->sc_dk.dk_bopenmask &= ~(1 << part);
    849       1.135   mycroft 		break;
    850       1.135   mycroft 	}
    851       1.181    bouyer 	wd->sc_dk.dk_openmask =
    852       1.181    bouyer 	    wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
    853       1.135   mycroft 
    854       1.135   mycroft 	if (wd->sc_dk.dk_openmask == 0) {
    855       1.194    bouyer 		wd_flushcache(wd, AT_WAIT);
    856       1.135   mycroft 		/* XXXX Must wait for I/O to complete! */
    857       1.187   thorpej 
    858       1.199       leo 		if (! (wd->sc_flags & WDF_KLABEL))
    859       1.199       leo 			wd->sc_flags &= ~WDF_LOADED;
    860       1.199       leo 
    861       1.217    bouyer 		wd->atabus->ata_delref(wd->drvp);
    862       1.135   mycroft 	}
    863       1.135   mycroft 
    864       1.181    bouyer 	wdunlock(wd);
    865       1.135   mycroft 	return 0;
    866       1.135   mycroft }
    867       1.135   mycroft 
    868       1.108   mycroft void
    869       1.164   thorpej wdgetdefaultlabel(wd, lp)
    870       1.108   mycroft 	struct wd_softc *wd;
    871       1.164   thorpej 	struct disklabel *lp;
    872       1.108   mycroft {
    873       1.163    bouyer 
    874       1.181    bouyer 	WDCDEBUG_PRINT(("wdgetdefaultlabel\n"), DEBUG_FUNCS);
    875       1.181    bouyer 	memset(lp, 0, sizeof(struct disklabel));
    876       1.108   mycroft 
    877       1.142   mycroft 	lp->d_secsize = DEV_BSIZE;
    878       1.181    bouyer 	lp->d_ntracks = wd->sc_params.atap_heads;
    879       1.181    bouyer 	lp->d_nsectors = wd->sc_params.atap_sectors;
    880  1.220.10.6       jmc 	lp->d_ncylinders = (wd->sc_flags & WDF_LBA) ? wd->sc_capacity /
    881  1.220.10.6       jmc 		(wd->sc_params.atap_heads * wd->sc_params.atap_sectors) :
    882  1.220.10.6       jmc 		wd->sc_params.atap_cylinders;
    883       1.142   mycroft 	lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
    884       1.108   mycroft 
    885       1.198       leo 	if (strcmp(wd->sc_params.atap_model, "ST506") == 0)
    886       1.181    bouyer 		lp->d_type = DTYPE_ST506;
    887       1.198       leo 	else
    888       1.181    bouyer 		lp->d_type = DTYPE_ESDI;
    889       1.198       leo 
    890       1.181    bouyer 	strncpy(lp->d_typename, wd->sc_params.atap_model, 16);
    891       1.180  drochner 	strncpy(lp->d_packname, "fictitious", 16);
    892       1.181    bouyer 	lp->d_secperunit = wd->sc_capacity;
    893       1.142   mycroft 	lp->d_rpm = 3600;
    894       1.142   mycroft 	lp->d_interleave = 1;
    895       1.142   mycroft 	lp->d_flags = 0;
    896       1.142   mycroft 
    897       1.142   mycroft 	lp->d_partitions[RAW_PART].p_offset = 0;
    898       1.142   mycroft 	lp->d_partitions[RAW_PART].p_size =
    899       1.181    bouyer 	lp->d_secperunit * (lp->d_secsize / DEV_BSIZE);
    900       1.142   mycroft 	lp->d_partitions[RAW_PART].p_fstype = FS_UNUSED;
    901       1.142   mycroft 	lp->d_npartitions = RAW_PART + 1;
    902       1.142   mycroft 
    903       1.142   mycroft 	lp->d_magic = DISKMAGIC;
    904       1.142   mycroft 	lp->d_magic2 = DISKMAGIC;
    905       1.142   mycroft 	lp->d_checksum = dkcksum(lp);
    906       1.164   thorpej }
    907       1.164   thorpej 
    908       1.164   thorpej /*
    909       1.164   thorpej  * Fabricate a default disk label, and try to read the correct one.
    910       1.164   thorpej  */
    911       1.164   thorpej void
    912       1.164   thorpej wdgetdisklabel(wd)
    913       1.164   thorpej 	struct wd_softc *wd;
    914       1.164   thorpej {
    915       1.164   thorpej 	struct disklabel *lp = wd->sc_dk.dk_label;
    916       1.164   thorpej 	char *errstring;
    917       1.164   thorpej 
    918       1.181    bouyer 	WDCDEBUG_PRINT(("wdgetdisklabel\n"), DEBUG_FUNCS);
    919       1.164   thorpej 
    920       1.181    bouyer 	memset(wd->sc_dk.dk_cpulabel, 0, sizeof(struct cpu_disklabel));
    921       1.164   thorpej 
    922       1.164   thorpej 	wdgetdefaultlabel(wd, lp);
    923       1.108   mycroft 
    924       1.181    bouyer 	wd->sc_badsect[0] = -1;
    925       1.113   mycroft 
    926       1.181    bouyer 	if (wd->drvp->state > RECAL)
    927       1.183    bouyer 		wd->drvp->drive_flags |= DRIVE_RESET;
    928       1.108   mycroft 	errstring = readdisklabel(MAKEWDDEV(0, wd->sc_dev.dv_unit, RAW_PART),
    929       1.144   thorpej 	    wdstrategy, lp, wd->sc_dk.dk_cpulabel);
    930       1.108   mycroft 	if (errstring) {
    931       1.108   mycroft 		/*
    932       1.108   mycroft 		 * This probably happened because the drive's default
    933       1.108   mycroft 		 * geometry doesn't match the DOS geometry.  We
    934       1.108   mycroft 		 * assume the DOS geometry is now in the label and try
    935       1.108   mycroft 		 * again.  XXX This is a kluge.
    936       1.108   mycroft 		 */
    937       1.181    bouyer 		if (wd->drvp->state > RECAL)
    938       1.183    bouyer 			wd->drvp->drive_flags |= DRIVE_RESET;
    939       1.181    bouyer 		errstring = readdisklabel(MAKEWDDEV(0, wd->sc_dev.dv_unit,
    940       1.181    bouyer 		    RAW_PART), wdstrategy, lp, wd->sc_dk.dk_cpulabel);
    941       1.108   mycroft 	}
    942       1.108   mycroft 	if (errstring) {
    943       1.153  christos 		printf("%s: %s\n", wd->sc_dev.dv_xname, errstring);
    944       1.108   mycroft 		return;
    945       1.108   mycroft 	}
    946       1.108   mycroft 
    947       1.181    bouyer 	if (wd->drvp->state > RECAL)
    948       1.183    bouyer 		wd->drvp->drive_flags |= DRIVE_RESET;
    949       1.170       leo #ifdef HAS_BAD144_HANDLING
    950       1.142   mycroft 	if ((lp->d_flags & D_BADSECT) != 0)
    951       1.108   mycroft 		bad144intern(wd);
    952       1.170       leo #endif
    953       1.108   mycroft }
    954       1.108   mycroft 
    955       1.217    bouyer void
    956  1.220.10.1     lukem wdperror(wd)
    957  1.220.10.1     lukem 	const struct wd_softc *wd;
    958       1.217    bouyer {
    959  1.220.10.1     lukem 	static const char *const errstr0_3[] = {"address mark not found",
    960       1.217    bouyer 	    "track 0 not found", "aborted command", "media change requested",
    961       1.217    bouyer 	    "id not found", "media changed", "uncorrectable data error",
    962       1.217    bouyer 	    "bad block detected"};
    963  1.220.10.1     lukem 	static const char *const errstr4_5[] = {
    964  1.220.10.1     lukem 	    "obsolete (address mark not found)",
    965       1.217    bouyer 	    "no media/write protected", "aborted command",
    966       1.217    bouyer 	    "media change requested", "id not found", "media changed",
    967       1.217    bouyer 	    "uncorrectable data error", "interface CRC error"};
    968  1.220.10.1     lukem 	const char *const *errstr;
    969       1.217    bouyer 	int i;
    970       1.217    bouyer 	char *sep = "";
    971       1.217    bouyer 
    972  1.220.10.1     lukem 	const char *devname = wd->sc_dev.dv_xname;
    973  1.220.10.1     lukem 	struct ata_drive_datas *drvp = wd->drvp;
    974  1.220.10.1     lukem 	int errno = wd->sc_wdc_bio.r_error;
    975  1.220.10.1     lukem 
    976       1.217    bouyer 	if (drvp->ata_vers >= 4)
    977       1.217    bouyer 		errstr = errstr4_5;
    978       1.217    bouyer 	else
    979       1.217    bouyer 		errstr = errstr0_3;
    980       1.217    bouyer 
    981  1.220.10.1     lukem 	printf("%s: (", devname);
    982  1.220.10.1     lukem 
    983       1.217    bouyer 	if (errno == 0)
    984  1.220.10.1     lukem 		printf("error not notified");
    985       1.217    bouyer 
    986       1.217    bouyer 	for (i = 0; i < 8; i++) {
    987       1.217    bouyer 		if (errno & (1 << i)) {
    988  1.220.10.1     lukem 			printf("%s%s", sep, errstr[i]);
    989       1.217    bouyer 			sep = ", ";
    990       1.217    bouyer 		}
    991       1.217    bouyer 	}
    992  1.220.10.1     lukem 	printf(")\n");
    993       1.217    bouyer }
    994       1.217    bouyer 
    995         1.1       cgd int
    996       1.163    bouyer wdioctl(dev, xfer, addr, flag, p)
    997        1.55   mycroft 	dev_t dev;
    998       1.163    bouyer 	u_long xfer;
    999        1.55   mycroft 	caddr_t addr;
   1000        1.55   mycroft 	int flag;
   1001        1.55   mycroft 	struct proc *p;
   1002         1.1       cgd {
   1003       1.209   thorpej 	struct wd_softc *wd = device_lookup(&wd_cd, WDUNIT(dev));
   1004        1.54   mycroft 	int error;
   1005       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1006       1.211      fvdl 	struct disklabel newlabel;
   1007       1.211      fvdl #endif
   1008       1.163    bouyer 
   1009       1.181    bouyer 	WDCDEBUG_PRINT(("wdioctl\n"), DEBUG_FUNCS);
   1010       1.163    bouyer 
   1011       1.181    bouyer 	if ((wd->sc_flags & WDF_LOADED) == 0)
   1012       1.108   mycroft 		return EIO;
   1013       1.108   mycroft 
   1014       1.163    bouyer 	switch (xfer) {
   1015       1.170       leo #ifdef HAS_BAD144_HANDLING
   1016         1.1       cgd 	case DIOCSBAD:
   1017         1.3   deraadt 		if ((flag & FWRITE) == 0)
   1018        1.54   mycroft 			return EBADF;
   1019       1.144   thorpej 		wd->sc_dk.dk_cpulabel->bad = *(struct dkbad *)addr;
   1020       1.144   thorpej 		wd->sc_dk.dk_label->d_flags |= D_BADSECT;
   1021        1.64   mycroft 		bad144intern(wd);
   1022        1.54   mycroft 		return 0;
   1023       1.170       leo #endif
   1024         1.1       cgd 
   1025         1.1       cgd 	case DIOCGDINFO:
   1026       1.144   thorpej 		*(struct disklabel *)addr = *(wd->sc_dk.dk_label);
   1027        1.54   mycroft 		return 0;
   1028       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1029       1.211      fvdl 	case ODIOCGDINFO:
   1030       1.211      fvdl 		newlabel = *(wd->sc_dk.dk_label);
   1031       1.211      fvdl 		if (newlabel.d_npartitions > OLDMAXPARTITIONS)
   1032       1.212      fvdl 			return ENOTTY;
   1033       1.211      fvdl 		memcpy(addr, &newlabel, sizeof (struct olddisklabel));
   1034       1.211      fvdl 		return 0;
   1035       1.211      fvdl #endif
   1036       1.211      fvdl 
   1037         1.3   deraadt 	case DIOCGPART:
   1038       1.144   thorpej 		((struct partinfo *)addr)->disklab = wd->sc_dk.dk_label;
   1039         1.3   deraadt 		((struct partinfo *)addr)->part =
   1040       1.144   thorpej 		    &wd->sc_dk.dk_label->d_partitions[WDPART(dev)];
   1041        1.54   mycroft 		return 0;
   1042         1.3   deraadt 
   1043       1.132   mycroft 	case DIOCWDINFO:
   1044         1.3   deraadt 	case DIOCSDINFO:
   1045       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1046       1.211      fvdl 	case ODIOCWDINFO:
   1047       1.211      fvdl 	case ODIOCSDINFO:
   1048       1.211      fvdl #endif
   1049       1.211      fvdl 	{
   1050       1.211      fvdl 		struct disklabel *lp;
   1051       1.211      fvdl 
   1052       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1053       1.211      fvdl 		if (xfer == ODIOCSDINFO || xfer == ODIOCWDINFO) {
   1054       1.211      fvdl 			memset(&newlabel, 0, sizeof newlabel);
   1055       1.211      fvdl 			memcpy(&newlabel, addr, sizeof (struct olddisklabel));
   1056       1.211      fvdl 			lp = &newlabel;
   1057       1.211      fvdl 		} else
   1058       1.211      fvdl #endif
   1059       1.211      fvdl 		lp = (struct disklabel *)addr;
   1060       1.211      fvdl 
   1061         1.3   deraadt 		if ((flag & FWRITE) == 0)
   1062        1.54   mycroft 			return EBADF;
   1063       1.132   mycroft 
   1064       1.181    bouyer 		if ((error = wdlock(wd)) != 0)
   1065       1.132   mycroft 			return error;
   1066       1.181    bouyer 		wd->sc_flags |= WDF_LABELLING;
   1067       1.132   mycroft 
   1068       1.144   thorpej 		error = setdisklabel(wd->sc_dk.dk_label,
   1069       1.211      fvdl 		    lp, /*wd->sc_dk.dk_openmask : */0,
   1070       1.144   thorpej 		    wd->sc_dk.dk_cpulabel);
   1071         1.3   deraadt 		if (error == 0) {
   1072       1.181    bouyer 			if (wd->drvp->state > RECAL)
   1073       1.183    bouyer 				wd->drvp->drive_flags |= DRIVE_RESET;
   1074       1.211      fvdl 			if (xfer == DIOCWDINFO
   1075       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1076       1.211      fvdl 			    || xfer == ODIOCWDINFO
   1077       1.211      fvdl #endif
   1078       1.211      fvdl 			    )
   1079       1.132   mycroft 				error = writedisklabel(WDLABELDEV(dev),
   1080       1.144   thorpej 				    wdstrategy, wd->sc_dk.dk_label,
   1081       1.144   thorpej 				    wd->sc_dk.dk_cpulabel);
   1082         1.1       cgd 		}
   1083       1.132   mycroft 
   1084       1.181    bouyer 		wd->sc_flags &= ~WDF_LABELLING;
   1085       1.181    bouyer 		wdunlock(wd);
   1086        1.54   mycroft 		return error;
   1087       1.211      fvdl 	}
   1088       1.199       leo 
   1089       1.199       leo 	case DIOCKLABEL:
   1090       1.199       leo 		if (*(int *)addr)
   1091       1.199       leo 			wd->sc_flags |= WDF_KLABEL;
   1092       1.199       leo 		else
   1093       1.199       leo 			wd->sc_flags &= ~WDF_KLABEL;
   1094       1.199       leo 		return 0;
   1095         1.3   deraadt 
   1096        1.44   mycroft 	case DIOCWLABEL:
   1097         1.3   deraadt 		if ((flag & FWRITE) == 0)
   1098        1.54   mycroft 			return EBADF;
   1099        1.93   mycroft 		if (*(int *)addr)
   1100       1.181    bouyer 			wd->sc_flags |= WDF_WLABEL;
   1101        1.93   mycroft 		else
   1102       1.181    bouyer 			wd->sc_flags &= ~WDF_WLABEL;
   1103        1.54   mycroft 		return 0;
   1104       1.164   thorpej 
   1105       1.164   thorpej 	case DIOCGDEFLABEL:
   1106       1.164   thorpej 		wdgetdefaultlabel(wd, (struct disklabel *)addr);
   1107       1.164   thorpej 		return 0;
   1108       1.211      fvdl #ifdef __HAVE_OLD_DISKLABEL
   1109       1.211      fvdl 	case ODIOCGDEFLABEL:
   1110       1.211      fvdl 		wdgetdefaultlabel(wd, &newlabel);
   1111       1.211      fvdl 		if (newlabel.d_npartitions > OLDMAXPARTITIONS)
   1112       1.212      fvdl 			return ENOTTY;
   1113       1.211      fvdl 		memcpy(addr, &newlabel, sizeof (struct olddisklabel));
   1114       1.211      fvdl 		return 0;
   1115       1.211      fvdl #endif
   1116       1.164   thorpej 
   1117         1.1       cgd #ifdef notyet
   1118         1.1       cgd 	case DIOCWFORMAT:
   1119         1.1       cgd 		if ((flag & FWRITE) == 0)
   1120        1.54   mycroft 			return EBADF;
   1121       1.181    bouyer 		{
   1122        1.54   mycroft 		register struct format_op *fop;
   1123        1.54   mycroft 		struct iovec aiov;
   1124        1.54   mycroft 		struct uio auio;
   1125       1.181    bouyer 
   1126        1.54   mycroft 		fop = (struct format_op *)addr;
   1127        1.54   mycroft 		aiov.iov_base = fop->df_buf;
   1128        1.54   mycroft 		aiov.iov_len = fop->df_count;
   1129        1.54   mycroft 		auio.uio_iov = &aiov;
   1130        1.54   mycroft 		auio.uio_iovcnt = 1;
   1131        1.54   mycroft 		auio.uio_resid = fop->df_count;
   1132        1.54   mycroft 		auio.uio_segflg = 0;
   1133        1.54   mycroft 		auio.uio_offset =
   1134       1.181    bouyer 			fop->df_startblk * wd->sc_dk.dk_label->d_secsize;
   1135        1.83        pk 		auio.uio_procp = p;
   1136        1.64   mycroft 		error = physio(wdformat, NULL, dev, B_WRITE, minphys,
   1137        1.64   mycroft 		    &auio);
   1138        1.54   mycroft 		fop->df_count -= auio.uio_resid;
   1139        1.64   mycroft 		fop->df_reg[0] = wdc->sc_status;
   1140        1.64   mycroft 		fop->df_reg[1] = wdc->sc_error;
   1141        1.54   mycroft 		return error;
   1142       1.181    bouyer 		}
   1143         1.1       cgd #endif
   1144  1.220.10.3     grant 	case DIOCGCACHE:
   1145  1.220.10.3     grant 		return wd_getcache(wd, (int *)addr);
   1146  1.220.10.3     grant 
   1147  1.220.10.3     grant 	case DIOCSCACHE:
   1148  1.220.10.3     grant 		return wd_setcache(wd, *(int *)addr);
   1149       1.185      kenh 
   1150       1.186      kenh 	case ATAIOCCOMMAND:
   1151       1.185      kenh 		/*
   1152       1.185      kenh 		 * Make sure this command is (relatively) safe first
   1153       1.185      kenh 		 */
   1154       1.186      kenh 		if ((((atareq_t *) addr)->flags & ATACMD_READ) == 0 &&
   1155       1.185      kenh 		    (flag & FWRITE) == 0)
   1156       1.185      kenh 			return (EBADF);
   1157       1.185      kenh 		{
   1158       1.185      kenh 		struct wd_ioctl *wi;
   1159       1.186      kenh 		atareq_t *atareq = (atareq_t *) addr;
   1160       1.185      kenh 		int error;
   1161       1.185      kenh 
   1162       1.185      kenh 		wi = wi_get();
   1163       1.185      kenh 		wi->wi_softc = wd;
   1164       1.186      kenh 		wi->wi_atareq = *atareq;
   1165       1.185      kenh 
   1166       1.186      kenh 		if (atareq->datalen && atareq->flags &
   1167       1.186      kenh 		    (ATACMD_READ | ATACMD_WRITE)) {
   1168       1.186      kenh 			wi->wi_iov.iov_base = atareq->databuf;
   1169       1.186      kenh 			wi->wi_iov.iov_len = atareq->datalen;
   1170       1.185      kenh 			wi->wi_uio.uio_iov = &wi->wi_iov;
   1171       1.185      kenh 			wi->wi_uio.uio_iovcnt = 1;
   1172       1.186      kenh 			wi->wi_uio.uio_resid = atareq->datalen;
   1173       1.185      kenh 			wi->wi_uio.uio_offset = 0;
   1174       1.185      kenh 			wi->wi_uio.uio_segflg = UIO_USERSPACE;
   1175       1.185      kenh 			wi->wi_uio.uio_rw =
   1176       1.186      kenh 			    (atareq->flags & ATACMD_READ) ? B_READ : B_WRITE;
   1177       1.185      kenh 			wi->wi_uio.uio_procp = p;
   1178       1.185      kenh 			error = physio(wdioctlstrategy, &wi->wi_bp, dev,
   1179       1.186      kenh 			    (atareq->flags & ATACMD_READ) ? B_READ : B_WRITE,
   1180       1.185      kenh 			    minphys, &wi->wi_uio);
   1181       1.185      kenh 		} else {
   1182       1.185      kenh 			/* No need to call physio if we don't have any
   1183       1.185      kenh 			   user data */
   1184       1.185      kenh 			wi->wi_bp.b_flags = 0;
   1185       1.185      kenh 			wi->wi_bp.b_data = 0;
   1186       1.185      kenh 			wi->wi_bp.b_bcount = 0;
   1187       1.185      kenh 			wi->wi_bp.b_dev = 0;
   1188       1.185      kenh 			wi->wi_bp.b_proc = p;
   1189       1.185      kenh 			wdioctlstrategy(&wi->wi_bp);
   1190       1.185      kenh 			error = wi->wi_bp.b_error;
   1191       1.185      kenh 		}
   1192       1.186      kenh 		*atareq = wi->wi_atareq;
   1193       1.185      kenh 		wi_free(wi);
   1194       1.185      kenh 		return(error);
   1195       1.185      kenh 		}
   1196       1.185      kenh 
   1197         1.1       cgd 	default:
   1198        1.54   mycroft 		return ENOTTY;
   1199         1.1       cgd 	}
   1200        1.54   mycroft 
   1201        1.54   mycroft #ifdef DIAGNOSTIC
   1202        1.54   mycroft 	panic("wdioctl: impossible");
   1203        1.54   mycroft #endif
   1204         1.1       cgd }
   1205         1.1       cgd 
   1206        1.44   mycroft #ifdef B_FORMAT
   1207         1.1       cgd int
   1208         1.1       cgd wdformat(struct buf *bp)
   1209         1.1       cgd {
   1210        1.44   mycroft 
   1211         1.1       cgd 	bp->b_flags |= B_FORMAT;
   1212        1.37   mycroft 	return wdstrategy(bp);
   1213         1.1       cgd }
   1214         1.1       cgd #endif
   1215         1.1       cgd 
   1216         1.1       cgd int
   1217        1.55   mycroft wdsize(dev)
   1218        1.55   mycroft 	dev_t dev;
   1219         1.1       cgd {
   1220        1.64   mycroft 	struct wd_softc *wd;
   1221       1.208   thorpej 	int part, omask;
   1222       1.108   mycroft 	int size;
   1223       1.163    bouyer 
   1224       1.181    bouyer 	WDCDEBUG_PRINT(("wdsize\n"), DEBUG_FUNCS);
   1225       1.163    bouyer 
   1226       1.208   thorpej 	wd = device_lookup(&wd_cd, WDUNIT(dev));
   1227       1.158        pk 	if (wd == NULL)
   1228       1.158        pk 		return (-1);
   1229       1.158        pk 
   1230       1.158        pk 	part = WDPART(dev);
   1231       1.158        pk 	omask = wd->sc_dk.dk_openmask & (1 << part);
   1232       1.158        pk 
   1233       1.158        pk 	if (omask == 0 && wdopen(dev, 0, S_IFBLK, NULL) != 0)
   1234       1.158        pk 		return (-1);
   1235       1.144   thorpej 	if (wd->sc_dk.dk_label->d_partitions[part].p_fstype != FS_SWAP)
   1236       1.108   mycroft 		size = -1;
   1237       1.108   mycroft 	else
   1238       1.160   thorpej 		size = wd->sc_dk.dk_label->d_partitions[part].p_size *
   1239       1.181    bouyer 		    (wd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
   1240       1.158        pk 	if (omask == 0 && wdclose(dev, 0, S_IFBLK, NULL) != 0)
   1241       1.158        pk 		return (-1);
   1242       1.158        pk 	return (size);
   1243         1.1       cgd }
   1244         1.1       cgd 
   1245       1.140       cgd /* #define WD_DUMP_NOT_TRUSTED if you just want to watch */
   1246       1.181    bouyer static int wddoingadump = 0;
   1247       1.181    bouyer static int wddumprecalibrated = 0;
   1248       1.181    bouyer static int wddumpmulti = 1;
   1249       1.140       cgd 
   1250        1.64   mycroft /*
   1251        1.64   mycroft  * Dump core after a system crash.
   1252        1.64   mycroft  */
   1253         1.1       cgd int
   1254       1.140       cgd wddump(dev, blkno, va, size)
   1255       1.181    bouyer 	dev_t dev;
   1256       1.181    bouyer 	daddr_t blkno;
   1257       1.181    bouyer 	caddr_t va;
   1258       1.181    bouyer 	size_t size;
   1259       1.140       cgd {
   1260       1.140       cgd 	struct wd_softc *wd;	/* disk unit to do the I/O */
   1261       1.181    bouyer 	struct disklabel *lp;   /* disk's disklabel */
   1262       1.208   thorpej 	int part, err;
   1263       1.181    bouyer 	int nblks;	/* total number of sectors left to write */
   1264       1.140       cgd 
   1265       1.140       cgd 	/* Check if recursive dump; if so, punt. */
   1266       1.116   mycroft 	if (wddoingadump)
   1267       1.116   mycroft 		return EFAULT;
   1268       1.142   mycroft 	wddoingadump = 1;
   1269       1.140       cgd 
   1270       1.208   thorpej 	wd = device_lookup(&wd_cd, WDUNIT(dev));
   1271       1.208   thorpej 	if (wd == NULL)
   1272       1.208   thorpej 		return (ENXIO);
   1273        1.60   mycroft 
   1274       1.140       cgd 	part = WDPART(dev);
   1275       1.140       cgd 
   1276       1.140       cgd 	/* Make sure it was initialized. */
   1277       1.181    bouyer 	if (wd->drvp->state < READY)
   1278        1.37   mycroft 		return ENXIO;
   1279       1.140       cgd 
   1280       1.181    bouyer 	/* Convert to disk sectors.  Request must be a multiple of size. */
   1281       1.144   thorpej 	lp = wd->sc_dk.dk_label;
   1282       1.142   mycroft 	if ((size % lp->d_secsize) != 0)
   1283       1.140       cgd 		return EFAULT;
   1284       1.142   mycroft 	nblks = size / lp->d_secsize;
   1285       1.142   mycroft 	blkno = blkno / (lp->d_secsize / DEV_BSIZE);
   1286       1.116   mycroft 
   1287        1.64   mycroft 	/* Check transfer bounds against partition size. */
   1288       1.142   mycroft 	if ((blkno < 0) || ((blkno + nblks) > lp->d_partitions[part].p_size))
   1289       1.140       cgd 		return EINVAL;
   1290       1.140       cgd 
   1291       1.140       cgd 	/* Offset block number to start of partition. */
   1292       1.142   mycroft 	blkno += lp->d_partitions[part].p_offset;
   1293        1.60   mycroft 
   1294       1.140       cgd 	/* Recalibrate, if first dump transfer. */
   1295       1.140       cgd 	if (wddumprecalibrated == 0) {
   1296       1.181    bouyer 		wddumpmulti = wd->sc_multi;
   1297       1.140       cgd 		wddumprecalibrated = 1;
   1298       1.205    bouyer 		wd->drvp->state = RESET;
   1299        1.63   mycroft 	}
   1300       1.181    bouyer 
   1301       1.142   mycroft 	while (nblks > 0) {
   1302       1.181    bouyer again:
   1303       1.214     bjh21 		wd->sc_bp = NULL;
   1304       1.181    bouyer 		wd->sc_wdc_bio.blkno = blkno;
   1305       1.181    bouyer 		wd->sc_wdc_bio.flags = ATA_POLL;
   1306       1.181    bouyer 		if (wddumpmulti == 1)
   1307       1.181    bouyer 			wd->sc_wdc_bio.flags |= ATA_SINGLE;
   1308  1.220.10.5       jmc 		if (wd->sc_flags & WDF_LBA48 && blkno > LBA48_THRESHOLD)
   1309       1.220  christos 			wd->sc_wdc_bio.flags |= ATA_LBA48;
   1310       1.181    bouyer 		if (wd->sc_flags & WDF_LBA)
   1311       1.181    bouyer 			wd->sc_wdc_bio.flags |= ATA_LBA;
   1312       1.181    bouyer 		wd->sc_wdc_bio.bcount =
   1313       1.181    bouyer 			min(nblks, wddumpmulti) * lp->d_secsize;
   1314       1.181    bouyer 		wd->sc_wdc_bio.databuf = va;
   1315       1.181    bouyer #ifndef WD_DUMP_NOT_TRUSTED
   1316       1.217    bouyer 		switch (wd->atabus->ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
   1317       1.181    bouyer 		case WDC_TRY_AGAIN:
   1318       1.181    bouyer 			panic("wddump: try again");
   1319       1.181    bouyer 			break;
   1320       1.181    bouyer 		case WDC_QUEUED:
   1321       1.181    bouyer 			panic("wddump: polled command has been queued");
   1322       1.181    bouyer 			break;
   1323       1.181    bouyer 		case WDC_COMPLETE:
   1324       1.181    bouyer 			break;
   1325       1.116   mycroft 		}
   1326       1.181    bouyer 		switch(wd->sc_wdc_bio.error) {
   1327       1.181    bouyer 		case TIMEOUT:
   1328       1.181    bouyer 			printf("wddump: device timed out");
   1329       1.181    bouyer 			err = EIO;
   1330       1.181    bouyer 			break;
   1331       1.181    bouyer 		case ERR_DF:
   1332       1.181    bouyer 			printf("wddump: drive fault");
   1333       1.181    bouyer 			err = EIO;
   1334       1.181    bouyer 			break;
   1335       1.181    bouyer 		case ERR_DMA:
   1336       1.181    bouyer 			printf("wddump: DMA error");
   1337       1.181    bouyer 			err = EIO;
   1338       1.181    bouyer 			break;
   1339       1.181    bouyer 		case ERROR:
   1340  1.220.10.1     lukem 			printf("wddump: ");
   1341  1.220.10.2     lukem 			wdperror(wd);
   1342       1.181    bouyer 			err = EIO;
   1343       1.181    bouyer 			break;
   1344       1.181    bouyer 		case NOERROR:
   1345       1.181    bouyer 			err = 0;
   1346       1.181    bouyer 			break;
   1347       1.181    bouyer 		default:
   1348       1.181    bouyer 			panic("wddump: unknown error type");
   1349         1.3   deraadt 		}
   1350       1.181    bouyer 		if (err != 0) {
   1351       1.181    bouyer 			if (wddumpmulti != 1) {
   1352       1.181    bouyer 				wddumpmulti = 1; /* retry in single-sector */
   1353       1.181    bouyer 				printf(", retrying\n");
   1354       1.181    bouyer 				goto again;
   1355       1.181    bouyer 			}
   1356       1.181    bouyer 			printf("\n");
   1357       1.181    bouyer 			return err;
   1358        1.63   mycroft 		}
   1359       1.140       cgd #else	/* WD_DUMP_NOT_TRUSTED */
   1360       1.140       cgd 		/* Let's just talk about this first... */
   1361       1.153  christos 		printf("wd%d: dump addr 0x%x, cylin %d, head %d, sector %d\n",
   1362       1.140       cgd 		    unit, va, cylin, head, sector);
   1363       1.140       cgd 		delay(500 * 1000);	/* half a second */
   1364       1.140       cgd #endif
   1365         1.1       cgd 
   1366       1.140       cgd 		/* update block count */
   1367       1.181    bouyer 		nblks -= min(nblks, wddumpmulti);
   1368       1.181    bouyer 		blkno += min(nblks, wddumpmulti);
   1369       1.181    bouyer 		va += min(nblks, wddumpmulti) * lp->d_secsize;
   1370         1.1       cgd 	}
   1371       1.142   mycroft 
   1372       1.140       cgd 	wddoingadump = 0;
   1373       1.140       cgd 	return 0;
   1374       1.140       cgd }
   1375         1.3   deraadt 
   1376       1.170       leo #ifdef HAS_BAD144_HANDLING
   1377         1.3   deraadt /*
   1378         1.3   deraadt  * Internalize the bad sector table.
   1379         1.3   deraadt  */
   1380         1.3   deraadt void
   1381        1.64   mycroft bad144intern(wd)
   1382        1.64   mycroft 	struct wd_softc *wd;
   1383         1.3   deraadt {
   1384       1.144   thorpej 	struct dkbad *bt = &wd->sc_dk.dk_cpulabel->bad;
   1385       1.144   thorpej 	struct disklabel *lp = wd->sc_dk.dk_label;
   1386        1.98   mycroft 	int i = 0;
   1387        1.55   mycroft 
   1388       1.182    bouyer 	WDCDEBUG_PRINT(("bad144intern\n"), DEBUG_XFERS);
   1389       1.163    bouyer 
   1390       1.170       leo 	for (; i < NBT_BAD; i++) {
   1391        1.98   mycroft 		if (bt->bt_bad[i].bt_cyl == 0xffff)
   1392        1.55   mycroft 			break;
   1393       1.181    bouyer 		wd->sc_badsect[i] =
   1394        1.98   mycroft 		    bt->bt_bad[i].bt_cyl * lp->d_secpercyl +
   1395        1.98   mycroft 		    (bt->bt_bad[i].bt_trksec >> 8) * lp->d_nsectors +
   1396        1.98   mycroft 		    (bt->bt_bad[i].bt_trksec & 0xff);
   1397         1.3   deraadt 	}
   1398       1.170       leo 	for (; i < NBT_BAD+1; i++)
   1399       1.181    bouyer 		wd->sc_badsect[i] = -1;
   1400        1.64   mycroft }
   1401       1.170       leo #endif
   1402        1.64   mycroft 
   1403       1.181    bouyer int
   1404       1.181    bouyer wd_get_params(wd, flags, params)
   1405       1.181    bouyer 	struct wd_softc *wd;
   1406       1.181    bouyer 	u_int8_t flags;
   1407       1.181    bouyer 	struct ataparams *params;
   1408        1.63   mycroft {
   1409       1.217    bouyer 	switch (wd->atabus->ata_get_params(wd->drvp, flags, params)) {
   1410       1.181    bouyer 	case CMD_AGAIN:
   1411       1.181    bouyer 		return 1;
   1412       1.181    bouyer 	case CMD_ERR:
   1413       1.181    bouyer 		/*
   1414       1.181    bouyer 		 * We `know' there's a drive here; just assume it's old.
   1415       1.181    bouyer 		 * This geometry is only used to read the MBR and print a
   1416       1.181    bouyer 		 * (false) attach message.
   1417       1.181    bouyer 		 */
   1418       1.181    bouyer 		strncpy(params->atap_model, "ST506",
   1419       1.181    bouyer 		    sizeof params->atap_model);
   1420       1.181    bouyer 		params->atap_config = ATA_CFG_FIXED;
   1421       1.181    bouyer 		params->atap_cylinders = 1024;
   1422       1.181    bouyer 		params->atap_heads = 8;
   1423       1.181    bouyer 		params->atap_sectors = 17;
   1424       1.181    bouyer 		params->atap_multi = 1;
   1425       1.181    bouyer 		params->atap_capabilities1 = params->atap_capabilities2 = 0;
   1426       1.190    bouyer 		wd->drvp->ata_vers = -1; /* Mark it as pre-ATA */
   1427       1.181    bouyer 		return 0;
   1428       1.181    bouyer 	case CMD_OK:
   1429       1.181    bouyer 		return 0;
   1430       1.181    bouyer 	default:
   1431       1.181    bouyer 		panic("wd_get_params: bad return code from ata_get_params");
   1432       1.181    bouyer 		/* NOTREACHED */
   1433       1.181    bouyer 	}
   1434  1.220.10.3     grant }
   1435  1.220.10.3     grant 
   1436  1.220.10.3     grant int
   1437  1.220.10.3     grant wd_getcache(wd, bitsp)
   1438  1.220.10.3     grant 	struct wd_softc *wd;
   1439  1.220.10.3     grant 	int *bitsp;
   1440  1.220.10.3     grant {
   1441  1.220.10.3     grant 	struct ataparams params;
   1442  1.220.10.3     grant 
   1443  1.220.10.3     grant 	if (wd_get_params(wd, AT_WAIT, &params) != 0)
   1444  1.220.10.3     grant 		return EIO;
   1445  1.220.10.3     grant 	if (params.atap_cmd_set1 == 0x0000 ||
   1446  1.220.10.3     grant 	    params.atap_cmd_set1 == 0xffff ||
   1447  1.220.10.3     grant 	    (params.atap_cmd_set1 & WDC_CMD1_CACHE) == 0) {
   1448  1.220.10.3     grant 		*bitsp = 0;
   1449  1.220.10.3     grant 		return 0;
   1450  1.220.10.3     grant 	}
   1451  1.220.10.3     grant 	*bitsp = DKCACHE_WCHANGE | DKCACHE_READ;
   1452  1.220.10.3     grant 	if (params.atap_cmd1_en & WDC_CMD1_CACHE)
   1453  1.220.10.3     grant 		*bitsp |= DKCACHE_WRITE;
   1454  1.220.10.3     grant 
   1455  1.220.10.3     grant 	return 0;
   1456  1.220.10.3     grant }
   1457  1.220.10.3     grant 
   1458  1.220.10.3     grant int
   1459  1.220.10.3     grant wd_setcache(wd, bits)
   1460  1.220.10.3     grant 	struct wd_softc *wd;
   1461  1.220.10.3     grant 	int bits;
   1462  1.220.10.3     grant {
   1463  1.220.10.3     grant 	struct ataparams params;
   1464  1.220.10.3     grant 	struct wdc_command wdc_c;
   1465  1.220.10.3     grant 
   1466  1.220.10.3     grant 	if (wd_get_params(wd, AT_WAIT, &params) != 0)
   1467  1.220.10.3     grant 		return EIO;
   1468  1.220.10.3     grant 
   1469  1.220.10.3     grant 	if (params.atap_cmd_set1 == 0x0000 ||
   1470  1.220.10.3     grant 	    params.atap_cmd_set1 == 0xffff ||
   1471  1.220.10.3     grant 	    (params.atap_cmd_set1 & WDC_CMD1_CACHE) == 0)
   1472  1.220.10.3     grant 		return EOPNOTSUPP;
   1473  1.220.10.3     grant 
   1474  1.220.10.3     grant 	if ((bits & DKCACHE_READ) == 0 ||
   1475  1.220.10.3     grant 	    (bits & DKCACHE_SAVE) != 0)
   1476  1.220.10.3     grant 		return EOPNOTSUPP;
   1477  1.220.10.3     grant 
   1478  1.220.10.3     grant 	memset(&wdc_c, 0, sizeof(struct wdc_command));
   1479  1.220.10.3     grant 	wdc_c.r_command = SET_FEATURES;
   1480  1.220.10.3     grant 	wdc_c.r_st_bmask = 0;
   1481  1.220.10.3     grant 	wdc_c.r_st_pmask = 0;
   1482  1.220.10.3     grant 	wdc_c.timeout = 30000; /* 30s timeout */
   1483  1.220.10.3     grant 	wdc_c.flags = AT_WAIT;
   1484  1.220.10.3     grant 	if (bits & DKCACHE_WRITE)
   1485  1.220.10.3     grant 		wdc_c.r_precomp = WDSF_WRITE_CACHE_EN;
   1486  1.220.10.3     grant 	else
   1487  1.220.10.3     grant 		wdc_c.r_precomp = WDSF_WRITE_CACHE_DS;
   1488  1.220.10.3     grant 	if (wd->atabus->ata_exec_command(wd->drvp, &wdc_c) != WDC_COMPLETE) {
   1489  1.220.10.3     grant 		printf("%s: wd_setcache command not complete\n",
   1490  1.220.10.3     grant 		    wd->sc_dev.dv_xname);
   1491  1.220.10.3     grant 		return EIO;
   1492  1.220.10.3     grant 	}
   1493  1.220.10.3     grant 	if (wdc_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
   1494  1.220.10.3     grant 		printf("%s: wd_setcache command error 0x%x\n",
   1495  1.220.10.3     grant 		    wd->sc_dev.dv_xname, wdc_c.flags);
   1496  1.220.10.3     grant 		return EIO;
   1497  1.220.10.3     grant 	}
   1498  1.220.10.3     grant 	if (wdc_c.flags & ERR_NODEV)
   1499  1.220.10.3     grant 		return ENODEV;
   1500  1.220.10.3     grant 	return 0;
   1501       1.190    bouyer }
   1502       1.190    bouyer 
   1503       1.190    bouyer void
   1504       1.190    bouyer wd_flushcache(wd, flags)
   1505       1.190    bouyer 	struct wd_softc *wd;
   1506       1.190    bouyer 	int flags;
   1507       1.190    bouyer {
   1508       1.190    bouyer 	struct wdc_command wdc_c;
   1509       1.190    bouyer 
   1510       1.190    bouyer 	if (wd->drvp->ata_vers < 4) /* WDCC_FLUSHCACHE is here since ATA-4 */
   1511       1.190    bouyer 		return;
   1512       1.190    bouyer 	memset(&wdc_c, 0, sizeof(struct wdc_command));
   1513  1.220.10.7       jdc 	if ((wd->sc_params.atap_cmd2_en & ATA_CMD2_LBA48) != 0 &&
   1514  1.220.10.7       jdc 	    (wd->sc_params.atap_cmd2_en & ATA_CMD2_FCE) != 0)
   1515  1.220.10.7       jdc 		wdc_c.r_command = WDCC_FLUSHCACHE_EXT;
   1516  1.220.10.7       jdc 	else
   1517  1.220.10.7       jdc 		wdc_c.r_command = WDCC_FLUSHCACHE;
   1518       1.190    bouyer 	wdc_c.r_st_bmask = WDCS_DRDY;
   1519       1.190    bouyer 	wdc_c.r_st_pmask = WDCS_DRDY;
   1520       1.194    bouyer 	wdc_c.flags = flags;
   1521       1.190    bouyer 	wdc_c.timeout = 30000; /* 30s timeout */
   1522       1.217    bouyer 	if (wd->atabus->ata_exec_command(wd->drvp, &wdc_c) != WDC_COMPLETE) {
   1523       1.190    bouyer 		printf("%s: flush cache command didn't complete\n",
   1524       1.190    bouyer 		    wd->sc_dev.dv_xname);
   1525       1.190    bouyer 	}
   1526       1.190    bouyer 	if (wdc_c.flags & AT_TIMEOU) {
   1527       1.190    bouyer 		printf("%s: flush cache command timeout\n",
   1528       1.190    bouyer 		    wd->sc_dev.dv_xname);
   1529       1.190    bouyer 	}
   1530       1.190    bouyer 	if (wdc_c.flags & AT_DF) {
   1531       1.190    bouyer 		printf("%s: flush cache command: drive fault\n",
   1532       1.190    bouyer 		    wd->sc_dev.dv_xname);
   1533       1.190    bouyer 	}
   1534       1.190    bouyer 	/*
   1535       1.190    bouyer 	 * Ignore error register, it shouldn't report anything else
   1536       1.190    bouyer 	 * than COMMAND ABORTED, which means the device doesn't support
   1537       1.190    bouyer 	 * flush cache
   1538       1.190    bouyer 	 */
   1539       1.190    bouyer }
   1540       1.190    bouyer 
   1541       1.190    bouyer void
   1542       1.190    bouyer wd_shutdown(arg)
   1543       1.190    bouyer 	void *arg;
   1544       1.190    bouyer {
   1545       1.190    bouyer 	struct wd_softc *wd = arg;
   1546       1.194    bouyer 	wd_flushcache(wd, AT_POLL);
   1547       1.185      kenh }
   1548       1.185      kenh 
   1549       1.185      kenh /*
   1550       1.185      kenh  * Allocate space for a ioctl queue structure.  Mostly taken from
   1551       1.185      kenh  * scsipi_ioctl.c
   1552       1.185      kenh  */
   1553       1.185      kenh struct wd_ioctl *
   1554       1.185      kenh wi_get()
   1555       1.185      kenh {
   1556       1.185      kenh 	struct wd_ioctl *wi;
   1557       1.185      kenh 	int s;
   1558       1.185      kenh 
   1559       1.219   tsutsui 	wi = malloc(sizeof(struct wd_ioctl), M_TEMP, M_WAITOK|M_ZERO);
   1560       1.185      kenh 	s = splbio();
   1561       1.185      kenh 	LIST_INSERT_HEAD(&wi_head, wi, wi_list);
   1562       1.185      kenh 	splx(s);
   1563       1.185      kenh 	return (wi);
   1564       1.185      kenh }
   1565       1.185      kenh 
   1566       1.185      kenh /*
   1567       1.185      kenh  * Free an ioctl structure and remove it from our list
   1568       1.185      kenh  */
   1569       1.185      kenh 
   1570       1.185      kenh void
   1571       1.185      kenh wi_free(wi)
   1572       1.185      kenh 	struct wd_ioctl *wi;
   1573       1.185      kenh {
   1574       1.185      kenh 	int s;
   1575       1.185      kenh 
   1576       1.185      kenh 	s = splbio();
   1577       1.185      kenh 	LIST_REMOVE(wi, wi_list);
   1578       1.185      kenh 	splx(s);
   1579       1.185      kenh 	free(wi, M_TEMP);
   1580       1.185      kenh }
   1581       1.185      kenh 
   1582       1.185      kenh /*
   1583       1.185      kenh  * Find a wd_ioctl structure based on the struct buf.
   1584       1.185      kenh  */
   1585       1.185      kenh 
   1586       1.185      kenh struct wd_ioctl *
   1587       1.185      kenh wi_find(bp)
   1588       1.185      kenh 	struct buf *bp;
   1589       1.185      kenh {
   1590       1.185      kenh 	struct wd_ioctl *wi;
   1591       1.185      kenh 	int s;
   1592       1.185      kenh 
   1593       1.185      kenh 	s = splbio();
   1594       1.185      kenh 	for (wi = wi_head.lh_first; wi != 0; wi = wi->wi_list.le_next)
   1595       1.185      kenh 		if (bp == &wi->wi_bp)
   1596       1.185      kenh 			break;
   1597       1.185      kenh 	splx(s);
   1598       1.185      kenh 	return (wi);
   1599       1.185      kenh }
   1600       1.185      kenh 
   1601       1.185      kenh /*
   1602       1.185      kenh  * Ioctl pseudo strategy routine
   1603       1.185      kenh  *
   1604       1.185      kenh  * This is mostly stolen from scsipi_ioctl.c:scsistrategy().  What
   1605       1.185      kenh  * happens here is:
   1606       1.185      kenh  *
   1607       1.185      kenh  * - wdioctl() queues a wd_ioctl structure.
   1608       1.185      kenh  *
   1609       1.185      kenh  * - wdioctl() calls physio/wdioctlstrategy based on whether or not
   1610       1.185      kenh  *   user space I/O is required.  If physio() is called, physio() eventually
   1611       1.185      kenh  *   calls wdioctlstrategy().
   1612       1.185      kenh  *
   1613       1.217    bouyer  * - In either case, wdioctlstrategy() calls wd->atabus->ata_exec_command()
   1614       1.185      kenh  *   to perform the actual command
   1615       1.185      kenh  *
   1616       1.185      kenh  * The reason for the use of the pseudo strategy routine is because
   1617       1.185      kenh  * when doing I/O to/from user space, physio _really_ wants to be in
   1618       1.185      kenh  * the loop.  We could put the entire buffer into the ioctl request
   1619       1.185      kenh  * structure, but that won't scale if we want to do things like download
   1620       1.185      kenh  * microcode.
   1621       1.185      kenh  */
   1622       1.185      kenh 
   1623       1.185      kenh void
   1624       1.185      kenh wdioctlstrategy(bp)
   1625       1.185      kenh 	struct buf *bp;
   1626       1.185      kenh {
   1627       1.185      kenh 	struct wd_ioctl *wi;
   1628       1.185      kenh 	struct wdc_command wdc_c;
   1629       1.185      kenh 	int error = 0;
   1630       1.185      kenh 
   1631       1.185      kenh 	wi = wi_find(bp);
   1632       1.185      kenh 	if (wi == NULL) {
   1633       1.185      kenh 		printf("user_strat: No ioctl\n");
   1634       1.185      kenh 		error = EINVAL;
   1635       1.185      kenh 		goto bad;
   1636       1.185      kenh 	}
   1637       1.185      kenh 
   1638       1.185      kenh 	memset(&wdc_c, 0, sizeof(wdc_c));
   1639       1.185      kenh 
   1640       1.185      kenh 	/*
   1641       1.185      kenh 	 * Abort if physio broke up the transfer
   1642       1.185      kenh 	 */
   1643       1.185      kenh 
   1644       1.186      kenh 	if (bp->b_bcount != wi->wi_atareq.datalen) {
   1645       1.185      kenh 		printf("physio split wd ioctl request... cannot proceed\n");
   1646       1.185      kenh 		error = EIO;
   1647       1.185      kenh 		goto bad;
   1648       1.185      kenh 	}
   1649       1.185      kenh 
   1650       1.185      kenh 	/*
   1651       1.185      kenh 	 * Abort if we didn't get a buffer size that was a multiple of
   1652       1.185      kenh 	 * our sector size (or was larger than NBBY)
   1653       1.185      kenh 	 */
   1654       1.185      kenh 
   1655       1.185      kenh 	if ((bp->b_bcount % wi->wi_softc->sc_dk.dk_label->d_secsize) != 0 ||
   1656       1.185      kenh 	    (bp->b_bcount / wi->wi_softc->sc_dk.dk_label->d_secsize) >=
   1657       1.185      kenh 	     (1 << NBBY)) {
   1658       1.185      kenh 		error = EINVAL;
   1659       1.185      kenh 		goto bad;
   1660       1.185      kenh 	}
   1661       1.185      kenh 
   1662       1.185      kenh 	/*
   1663       1.185      kenh 	 * Make sure a timeout was supplied in the ioctl request
   1664       1.185      kenh 	 */
   1665       1.185      kenh 
   1666       1.186      kenh 	if (wi->wi_atareq.timeout == 0) {
   1667       1.185      kenh 		error = EINVAL;
   1668       1.185      kenh 		goto bad;
   1669       1.185      kenh 	}
   1670       1.185      kenh 
   1671       1.186      kenh 	if (wi->wi_atareq.flags & ATACMD_READ)
   1672       1.185      kenh 		wdc_c.flags |= AT_READ;
   1673       1.186      kenh 	else if (wi->wi_atareq.flags & ATACMD_WRITE)
   1674       1.185      kenh 		wdc_c.flags |= AT_WRITE;
   1675       1.185      kenh 
   1676       1.188      kenh 	if (wi->wi_atareq.flags & ATACMD_READREG)
   1677       1.188      kenh 		wdc_c.flags |= AT_READREG;
   1678       1.188      kenh 
   1679       1.185      kenh 	wdc_c.flags |= AT_WAIT;
   1680       1.185      kenh 
   1681       1.186      kenh 	wdc_c.timeout = wi->wi_atareq.timeout;
   1682       1.186      kenh 	wdc_c.r_command = wi->wi_atareq.command;
   1683       1.186      kenh 	wdc_c.r_head = wi->wi_atareq.head & 0x0f;
   1684       1.186      kenh 	wdc_c.r_cyl = wi->wi_atareq.cylinder;
   1685       1.186      kenh 	wdc_c.r_sector = wi->wi_atareq.sec_num;
   1686       1.186      kenh 	wdc_c.r_count = wi->wi_atareq.sec_count;
   1687       1.186      kenh 	wdc_c.r_precomp = wi->wi_atareq.features;
   1688       1.185      kenh 	wdc_c.r_st_bmask = WDCS_DRDY;
   1689       1.185      kenh 	wdc_c.r_st_pmask = WDCS_DRDY;
   1690       1.185      kenh 	wdc_c.data = wi->wi_bp.b_data;
   1691       1.185      kenh 	wdc_c.bcount = wi->wi_bp.b_bcount;
   1692       1.185      kenh 
   1693       1.217    bouyer 	if (wi->wi_softc->atabus->ata_exec_command(wi->wi_softc->drvp, &wdc_c)
   1694       1.217    bouyer 	    != WDC_COMPLETE) {
   1695       1.186      kenh 		wi->wi_atareq.retsts = ATACMD_ERROR;
   1696       1.185      kenh 		goto bad;
   1697       1.185      kenh 	}
   1698       1.185      kenh 
   1699       1.185      kenh 	if (wdc_c.flags & (AT_ERROR | AT_TIMEOU | AT_DF)) {
   1700       1.185      kenh 		if (wdc_c.flags & AT_ERROR) {
   1701       1.186      kenh 			wi->wi_atareq.retsts = ATACMD_ERROR;
   1702       1.186      kenh 			wi->wi_atareq.error = wdc_c.r_error;
   1703       1.185      kenh 		} else if (wdc_c.flags & AT_DF)
   1704       1.186      kenh 			wi->wi_atareq.retsts = ATACMD_DF;
   1705       1.185      kenh 		else
   1706       1.186      kenh 			wi->wi_atareq.retsts = ATACMD_TIMEOUT;
   1707       1.188      kenh 	} else {
   1708       1.186      kenh 		wi->wi_atareq.retsts = ATACMD_OK;
   1709       1.188      kenh 		if (wi->wi_atareq.flags & ATACMD_READREG) {
   1710       1.188      kenh 			wi->wi_atareq.head = wdc_c.r_head ;
   1711       1.188      kenh 			wi->wi_atareq.cylinder = wdc_c.r_cyl;
   1712       1.188      kenh 			wi->wi_atareq.sec_num = wdc_c.r_sector;
   1713       1.188      kenh 			wi->wi_atareq.sec_count = wdc_c.r_count;
   1714       1.188      kenh 			wi->wi_atareq.features = wdc_c.r_precomp;
   1715       1.188      kenh 			wi->wi_atareq.error = wdc_c.r_error;
   1716       1.188      kenh 		}
   1717       1.188      kenh 	}
   1718       1.185      kenh 
   1719       1.185      kenh 	bp->b_error = 0;
   1720       1.185      kenh 	biodone(bp);
   1721       1.185      kenh 	return;
   1722       1.185      kenh bad:
   1723       1.185      kenh 	bp->b_flags |= B_ERROR;
   1724       1.185      kenh 	bp->b_error = error;
   1725       1.185      kenh 	biodone(bp);
   1726        1.21   deraadt }
   1727