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