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