root/dev/ata/wd.c

DEFINITIONS

1. wdprobe
2. wdattach
3. wdactivate
4. wddetach
5. wdstrategy
6. wdstart
7. __wdstart
8. wddone
9. wdrestart
10. wdread
11. wdwrite
12. wdopen
13. wdclose
14. wdgetdefaultlabel
15. wdgetdisklabel
16. wdioctl
17. wdformat
18. wdsize
19. wddump
20. wd_get_params
21. wd_flushcache
22. wd_shutdown

    1 /*      $OpenBSD: wd.c,v 1.66 2007/06/20 18:15:46 deraadt Exp $ */
    2 /*      $NetBSD: wd.c,v 1.193 1999/02/28 17:15:27 explorer Exp $ */
    4 /*
    5  * Copyright (c) 1998, 2001 Manuel Bouyer.  All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without
    8  * modification, are permitted provided that the following conditions
    9  * are met:
   10  * 1. Redistributions of source code must retain the above copyright
   11  *      notice, this list of conditions and the following disclaimer.
   12  * 2. Redistributions in binary form must reproduce the above copyright
   13  *      notice, this list of conditions and the following disclaimer in the
   14  *      documentation and/or other materials provided with the distribution.
   15  * 3. All advertising materials mentioning features or use of this software
   16  *      must display the following acknowledgement:
   17  *  This product includes software developed by Manuel Bouyer.
   18  * 4. The name of the author may not be used to endorse or promote products
   19  *      derived from this software without specific prior written permission.
   20  *
   21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   22  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   23  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   24  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   25  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   26  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   27  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   28  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   29  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   30  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   31  */
   33 /*-
   34  * Copyright (c) 1998 The NetBSD Foundation, Inc.
   35  * All rights reserved.
   36  *
   37  * This code is derived from software contributed to The NetBSD Foundation
   38  * by Charles M. Hannum and by Onno van der Linden.
   39  *
   40  * Redistribution and use in source and binary forms, with or without
   41  * modification, are permitted provided that the following conditions
   42  * are met:
   43  * 1. Redistributions of source code must retain the above copyright
   44  *    notice, this list of conditions and the following disclaimer.
   45  * 2. Redistributions in binary form must reproduce the above copyright
   46  *    notice, this list of conditions and the following disclaimer in the
   47  *    documentation and/or other materials provided with the distribution.
   48  * 3. All advertising materials mentioning features or use of this software
   49  *    must display the following acknowledgement:
   50  *        This product includes software developed by the NetBSD
   51  *        Foundation, Inc. and its contributors.
   52  * 4. Neither the name of The NetBSD Foundation nor the names of its
   53  *    contributors may be used to endorse or promote products derived
   54  *    from this software without specific prior written permission.
   55  *
   56  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   57  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   58  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   59  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   60  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   61  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   62  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   63  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   64  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   65  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   66  * POSSIBILITY OF SUCH DAMAGE.
   67  */
   69 #if 0
   70 #include "rnd.h"
   71 #endif
   73 #include <sys/param.h>
   74 #include <sys/systm.h>
   75 #include <sys/kernel.h>
   76 #include <sys/conf.h>
   77 #include <sys/file.h>
   78 #include <sys/stat.h>
   79 #include <sys/ioctl.h>
   80 #include <sys/buf.h>
   81 #include <sys/uio.h>
   82 #include <sys/malloc.h>
   83 #include <sys/device.h>
   84 #include <sys/disklabel.h>
   85 #include <sys/disk.h>
   86 #include <sys/syslog.h>
   87 #include <sys/proc.h>
   88 #include <sys/vnode.h>
   90 #include <uvm/uvm_extern.h>
   92 #include <machine/intr.h>
   93 #include <machine/bus.h>
   95 #include <dev/ata/atareg.h>
   96 #include <dev/ata/atavar.h>
   97 #include <dev/ata/wdvar.h>
   98 #include <dev/ic/wdcreg.h>
   99 #include <dev/ic/wdcvar.h>
  100 #if 0
  101 #include "locators.h"
  102 #endif
  104 #define LBA48_THRESHOLD         (0xfffffff)     /* 128GB / DEV_BSIZE */
  106 #define WDIORETRIES_SINGLE 4    /* number of retries before single-sector */
  107 #define WDIORETRIES     5       /* number of retries before giving up */
  108 #define RECOVERYTIME hz/2       /* time to wait before retrying a cmd */
  110 #define DEBUG_INTR   0x01
  111 #define DEBUG_XFERS  0x02
  112 #define DEBUG_STATUS 0x04
  113 #define DEBUG_FUNCS  0x08
  114 #define DEBUG_PROBE  0x10
  115 #ifdef WDCDEBUG
  116 extern int wdcdebug_wd_mask; /* init'ed in ata_wdc.c */
  117 #define WDCDEBUG_PRINT(args, level) do {        \
  118         if ((wdcdebug_wd_mask & (level)) != 0)  \
printf args;                    \
  120 } while (0)
  121 #else
  122 #define WDCDEBUG_PRINT(args, level)
  123 #endif
  125 struct wd_softc {
  126         /* General disk infos */
  127         struct device sc_dev;
  128         struct disk sc_dk;
  129         struct buf sc_q;
  130         /* IDE disk soft states */
  131         struct ata_bio sc_wdc_bio; /* current transfer */
  132         struct buf *sc_bp; /* buf being transferred */
  133         struct ata_drive_datas *drvp; /* Our controller's infos */
  134         int openings;
  135         struct ataparams sc_params;/* drive characteristics found */
  136         int sc_flags;
  137 #define WDF_LOCKED        0x01
  138 #define WDF_WANTED        0x02
  139 #define WDF_WLABEL        0x04 /* label is writable */
  140 #define WDF_LABELLING     0x08 /* writing label */
  141 /*
  142  * XXX Nothing resets this yet, but disk change sensing will when ATA-4 is
  143  * more fully implemented.
  144  */
  145 #define WDF_LOADED      0x10 /* parameters loaded */
  146 #define WDF_WAIT        0x20 /* waiting for resources */
  147 #define WDF_LBA         0x40 /* using LBA mode */
  148 #define WDF_LBA48       0x80 /* using 48-bit LBA mode */
u_int64_t sc_capacity;
  151         int cyl; /* actual drive parameters */
  152         int heads;
  153         int sectors;
  154         int retries; /* number of xfer retry */
  155         struct timeout sc_restart_timeout;
  156         void *sc_sdhook;
  157 };
  159 #define sc_drive sc_wdc_bio.drive
  160 #define sc_mode sc_wdc_bio.mode
  161 #define sc_multi sc_wdc_bio.multi
  163 int     wdprobe(struct device *, void *, void *);
  164 void    wdattach(struct device *, struct device *, void *);
  165 int     wddetach(struct device *, int);
  166 int     wdactivate(struct device *, enum devact);
  167 int     wdprint(void *, char *);
  169 struct cfattach wd_ca = {
  170         sizeof(struct wd_softc), wdprobe, wdattach,
wddetach, wdactivate
  172 };
  174 struct cfdriver wd_cd = {
NULL, "wd", DV_DISK
  176 };
  178 void  wdgetdefaultlabel(struct wd_softc *, struct disklabel *);
  179 void  wdgetdisklabel(dev_t dev, struct wd_softc *, struct disklabel *, int);
  180 void  wdstrategy(struct buf *);
  181 void  wdstart(void *);
  182 void  __wdstart(struct wd_softc*, struct buf *);
  183 void  wdrestart(void *);
  184 int   wd_get_params(struct wd_softc *, u_int8_t, struct ataparams *);
  185 void  wd_flushcache(struct wd_softc *, int);
  186 void  wd_shutdown(void *);
  188 struct dkdriver wddkdriver = { wdstrategy };
  190 /* XXX: these should go elsewhere */
cdev_decl(wd);
bdev_decl(wd);
  194 #define wdlock(wd)  disk_lock(&(wd)->sc_dk)
  195 #define wdunlock(wd)  disk_unlock(&(wd)->sc_dk)
  196 #define wdlookup(unit) (struct wd_softc *)device_lookup(&wd_cd, (unit))
  199 int
wdprobe(struct device *parent, void *match_, void *aux)
  201 {
  202         struct ata_atapi_attach *aa_link = aux;
  203         struct cfdata *match = match_;
  205         if (aa_link == NULL)
  206                 return 0;
  207         if (aa_link->aa_type != T_ATA)
  208                 return 0;
  210         if (match->cf_loc[0] != -1 &&
match->cf_loc[0] != aa_link->aa_channel)
  212                 return 0;
  214         if (match->cf_loc[1] != -1 &&
match->cf_loc[1] != aa_link->aa_drv_data->drive)
  216                 return 0;
  218         return 1;
  219 }
  221 void
wdattach(struct device *parent, struct device *self, void *aux)
  223 {
  224         struct wd_softc *wd = (void *)self;
  225         struct ata_atapi_attach *aa_link= aux;
  226         struct wdc_command wdc_c;
  227         int i, blank;
  228         char buf[41], c, *p, *q;
WDCDEBUG_PRINT(("wdattach\n"), DEBUG_FUNCS | DEBUG_PROBE);
wd->openings = aa_link->aa_openings;
wd->drvp = aa_link->aa_drv_data;
strlcpy(wd->drvp->drive_name, wd->sc_dev.dv_xname,
  235             sizeof(wd->drvp->drive_name));
wd->drvp->cf_flags = wd->sc_dev.dv_cfdata->cf_flags;
  238         if ((NERRS_MAX - 2) > 0)
wd->drvp->n_dmaerrs = NERRS_MAX - 2;
  240         else
wd->drvp->n_dmaerrs = 0;
  243         /* read our drive info */
  244         if (wd_get_params(wd, at_poll, &wd->sc_params) != 0) {
printf("%s: IDENTIFY failed\n", wd->sc_dev.dv_xname);
  246                 return;
  247         }
  249         for (blank = 0, p = wd->sc_params.atap_model, q = buf, i = 0;
i < sizeof(wd->sc_params.atap_model); i++) {
c = *p++;
  252                 if (c == '\0')
  253                         break;
  254                 if (c != ' ') {
  255                         if (blank) {
  256                                 *q++ = ' ';
blank = 0;
  258                         }
  259                         *q++ = c;
  260                 } else
blank = 1;
  262                 }
  263         *q++ = '\0';
printf(": <%s>\n", buf);
wdc_probe_caps(wd->drvp, &wd->sc_params);
wdc_print_caps(wd->drvp);
  270         if ((wd->sc_params.atap_multi & 0xff) > 1) {
wd->sc_multi = wd->sc_params.atap_multi & 0xff;
  272         } else {
wd->sc_multi = 1;
  274         }
printf("%s: %d-sector PIO,", wd->sc_dev.dv_xname, wd->sc_multi);
  278         /* use 48-bit LBA if enabled */
  279         /* XXX: shall we use it if drive capacity < 137Gb? */
  280         if ((wd->sc_params.atap_cmd2_en & ATAPI_CMD2_48AD) != 0)
wd->sc_flags |= WDF_LBA48;
  283         /* Prior to ATA-4, LBA was optional. */
  284         if ((wd->sc_params.atap_capabilities1 & WDC_CAP_LBA) != 0)
wd->sc_flags |= WDF_LBA;
  286 #if 0
  287         /* ATA-4 requires LBA. */
  288         if (wd->sc_params.atap_ataversion != 0xffff &&
wd->sc_params.atap_ataversion >= WDC_VER_ATA4)
wd->sc_flags |= WDF_LBA;
  291 #endif
  293         if ((wd->sc_flags & WDF_LBA48) != 0) {
wd->sc_capacity =
  295                     (((u_int64_t)wd->sc_params.atap_max_lba[3] << 48) |
  296                      ((u_int64_t)wd->sc_params.atap_max_lba[2] << 32) |
  297                      ((u_int64_t)wd->sc_params.atap_max_lba[1] << 16) |
  298                       (u_int64_t)wd->sc_params.atap_max_lba[0]);
printf(" LBA48, %lluMB, %llu sectors\n",
wd->sc_capacity / (1048576 / DEV_BSIZE),
wd->sc_capacity);
  302         } else if ((wd->sc_flags & WDF_LBA) != 0) {
wd->sc_capacity =
  304                     (wd->sc_params.atap_capacity[1] << 16) |
wd->sc_params.atap_capacity[0];
printf(" LBA, %lluMB, %llu sectors\n",
wd->sc_capacity / (1048576 / DEV_BSIZE),
wd->sc_capacity);
  309         } else {
wd->sc_capacity =
wd->sc_params.atap_cylinders *
wd->sc_params.atap_heads *
wd->sc_params.atap_sectors;
printf(" CHS, %lluMB, %d cyl, %d head, %d sec, %llu sectors\n",
wd->sc_capacity / (1048576 / DEV_BSIZE),
wd->sc_params.atap_cylinders,
wd->sc_params.atap_heads,
wd->sc_params.atap_sectors,
wd->sc_capacity);
  320         }
WDCDEBUG_PRINT(("%s: atap_dmatiming_mimi=%d, atap_dmatiming_recom=%d\n",
self->dv_xname, wd->sc_params.atap_dmatiming_mimi,
wd->sc_params.atap_dmatiming_recom), DEBUG_PROBE);
  325         /*
  326          * FREEZE LOCK the drive so malicous users can't lock it on us.
  327          * As there is no harm in issuing this to drives that don't
  328          * support the security feature set we just send it, and don't
  329          * bother checking if the drive sends a command abort to tell us it
  330          * doesn't support it.
  331          */
bzero(&wdc_c, sizeof(struct wdc_command));
wdc_c.r_command = WDCC_SEC_FREEZE_LOCK;
wdc_c.timeout = 1000;
wdc_c.flags = at_poll;
  337         if (wdc_exec_command(wd->drvp, &wdc_c) != WDC_COMPLETE) {
printf("%s: freeze lock command didn't complete\n",
wd->sc_dev.dv_xname);
  340         }
  342         /*
  343          * Initialize and attach the disk structure.
  344          */
wd->sc_dk.dk_driver = &wddkdriver;
wd->sc_dk.dk_name = wd->sc_dev.dv_xname;
disk_attach(&wd->sc_dk);
wd->sc_wdc_bio.lp = wd->sc_dk.dk_label;
wd->sc_sdhook = shutdownhook_establish(wd_shutdown, wd);
  350         if (wd->sc_sdhook == NULL)
printf("%s: WARNING: unable to establish shutdown hook\n",
wd->sc_dev.dv_xname);
timeout_set(&wd->sc_restart_timeout, wdrestart, wd);
  354 }
  356 int
wdactivate(struct device *self, enum devact act)
  358 {
  359         int rv = 0;
  361         switch (act) {
  362         case DVACT_ACTIVATE:
  363                 break;
  365         case DVACT_DEACTIVATE:
  366                 /*
  367                 * Nothing to do; we key off the device's DVF_ACTIVATE.
  368                 */
  369                 break;
  370         }
  371         return (rv);
  372 }
  374 int
wddetach(struct device *self, int flags)
  376 {
  377         struct wd_softc *sc = (struct wd_softc *)self;
  378         struct buf *dp, *bp;
  379         int s, bmaj, cmaj, mn;
  381         /* Remove unprocessed buffers from queue */
s = splbio();
  383         for (dp = &sc->sc_q; (bp = dp->b_actf) != NULL; ) {
dp->b_actf = bp->b_actf;
bp->b_error = ENXIO;
bp->b_flags |= B_ERROR;
biodone(bp);
  388         }
splx(s);
  391         /* Locate the lowest minor number to be detached. */
mn = DISKMINOR(self->dv_unit, 0);
  394         for (bmaj = 0; bmaj < nblkdev; bmaj++)
  395                 if (bdevsw[bmaj].d_open == wdopen)
vdevgone(bmaj, mn, mn + MAXPARTITIONS - 1, VBLK);
  397         for (cmaj = 0; cmaj < nchrdev; cmaj++)
  398                 if (cdevsw[cmaj].d_open == wdopen)
vdevgone(cmaj, mn, mn + MAXPARTITIONS - 1, VCHR);
  401         /* Get rid of the shutdown hook. */
  402         if (sc->sc_sdhook != NULL)
shutdownhook_disestablish(sc->sc_sdhook);
  405         /* Detach disk. */
disk_detach(&sc->sc_dk);
  408         return (0);
  409 }
  411 /*
  412  * Read/write routine for a buffer.  Validates the arguments and schedules the
  413  * transfer.  Does not wait for the transfer to complete.
  414  */
  415 void
wdstrategy(struct buf *bp)
  417 {
  418         struct wd_softc *wd;
  419         int s;
wd = wdlookup(DISKUNIT(bp->b_dev));
  422         if (wd == NULL) {
bp->b_error = ENXIO;
  424                 goto bad;
  425         }
WDCDEBUG_PRINT(("wdstrategy (%s)\n", wd->sc_dev.dv_xname),
DEBUG_XFERS);
  430         /* Valid request?  */
  431         if (bp->b_blkno < 0 ||
  432             (bp->b_bcount % wd->sc_dk.dk_label->d_secsize) != 0 ||
  433             (bp->b_bcount / wd->sc_dk.dk_label->d_secsize) >= (1 << NBBY)) {
bp->b_error = EINVAL;
  435                 goto bad;
  436         }
  438         /* If device invalidated (e.g. media change, door open), error. */
  439         if ((wd->sc_flags & WDF_LOADED) == 0) {
bp->b_error = EIO;
  441                 goto bad;
  442         }
  444         /* If it's a null transfer, return immediately. */
  445         if (bp->b_bcount == 0)
  446                 goto done;
  448         /*
  449          * Do bounds checking, adjust transfer. if error, process.
  450          * If end of partition, just return.
  451          */
  452         if (DISKPART(bp->b_dev) != RAW_PART &&
bounds_check_with_label(bp, wd->sc_dk.dk_label,
  454             (wd->sc_flags & (WDF_WLABEL|WDF_LABELLING)) != 0) <= 0)
  455                 goto done;
  456         /* Queue transfer on drive, activate drive and controller if idle. */
s = splbio();
disksort(&wd->sc_q, bp);
wdstart(wd);
splx(s);
device_unref(&wd->sc_dev);
  462         return;
bad:
bp->b_flags |= B_ERROR;
done:
  466         /* Toss transfer; we're done early. */
bp->b_resid = bp->b_bcount;
s = splbio();
biodone(bp);
splx(s);
  471         if (wd != NULL)
device_unref(&wd->sc_dev);
  473 }
  475 /*
  476  * Queue a drive for I/O.
  477  */
  478 void
wdstart(void *arg)
  480 {
  481         struct wd_softc *wd = arg;
  482         struct buf *dp, *bp = NULL;
WDCDEBUG_PRINT(("wdstart %s\n", wd->sc_dev.dv_xname),
DEBUG_XFERS);
  486         while (wd->openings > 0) {
  488                 /* Is there a buf for us ? */
dp = &wd->sc_q;
  490                 if ((bp = dp->b_actf) == NULL)  /* yes, an assign */
  491                         return;
dp->b_actf = bp->b_actf;
  494                 /*
  495                  * Make the command. First lock the device
  496                  */
wd->openings--;
wd->retries = 0;
__wdstart(wd, bp);
  501         }
  502 }
  504 void
__wdstart(struct wd_softc *wd, struct buf *bp)
  506 {
daddr64_t nblks;
wd->sc_wdc_bio.blkno = bp->b_blkno +
DL_GETPOFFSET(&wd->sc_dk.dk_label->d_partitions[DISKPART(bp->b_dev)]);
wd->sc_wdc_bio.blkno /= (wd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
wd->sc_wdc_bio.blkdone =0;
wd->sc_bp = bp;
  514         /*
  515          * If we're retrying, retry in single-sector mode. This will give us
  516          * the sector number of the problem, and will eventually allow the
  517          * transfer to succeed.
  518          */
  519         if (wd->sc_multi == 1 || wd->retries >= WDIORETRIES_SINGLE)
wd->sc_wdc_bio.flags = ATA_SINGLE;
  521         else
wd->sc_wdc_bio.flags = 0;
nblks = bp->b_bcount / wd->sc_dk.dk_label->d_secsize;
  524         if ((wd->sc_flags & WDF_LBA48) &&
  525             /* use LBA48 only if really need */
  526             ((wd->sc_wdc_bio.blkno + nblks - 1 > LBA48_THRESHOLD) ||
  527              (nblks > 0xff)))
wd->sc_wdc_bio.flags |= ATA_LBA48;
  529         if (wd->sc_flags & WDF_LBA)
wd->sc_wdc_bio.flags |= ATA_LBA;
  531         if (bp->b_flags & B_READ)
wd->sc_wdc_bio.flags |= ATA_READ;
wd->sc_wdc_bio.bcount = bp->b_bcount;
wd->sc_wdc_bio.databuf = bp->b_data;
wd->sc_wdc_bio.wd = wd;
  536         /* Instrumentation. */
disk_busy(&wd->sc_dk);
  538         switch (wdc_ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
  539         case WDC_TRY_AGAIN:
timeout_add(&wd->sc_restart_timeout, hz);
  541                 break;
  542         case WDC_QUEUED:
  543                 break;
  544         case WDC_COMPLETE:
  545                 /*
  546                  * This code is never executed because we never set
  547                  * the ATA_POLL flag above
  548                  */
  549 #if 0
  550                 if (wd->sc_wdc_bio.flags & ATA_POLL)
wddone(wd);
  552 #endif
  553                 break;
  554         default:
panic("__wdstart: bad return code from wdc_ata_bio()");
  556         }
  557 }
  559 void
wddone(void *v)
  561 {
  562         struct wd_softc *wd = v;
  563         struct buf *bp = wd->sc_bp;
  564         char buf[256], *errbuf = buf;
WDCDEBUG_PRINT(("wddone %s\n", wd->sc_dev.dv_xname),
DEBUG_XFERS);
bp->b_resid = wd->sc_wdc_bio.bcount;
errbuf[0] = '\0';
  570         switch (wd->sc_wdc_bio.error) {
  571         case ERR_NODEV:
bp->b_flags |= B_ERROR;
bp->b_error = ENXIO;
  574                 break;
  575         case ERR_DMA:
errbuf = "DMA error";
  577                 goto retry;
  578         case ERR_DF:
errbuf = "device fault";
  580                 goto retry;
  581         case TIMEOUT:
errbuf = "device timeout";
  583                 goto retry;
  584         case ERROR:
  585                 /* Don't care about media change bits */
  586                 if (wd->sc_wdc_bio.r_error != 0 &&
  587                     (wd->sc_wdc_bio.r_error & ~(WDCE_MC | WDCE_MCR)) == 0)
  588                         goto noerror;
ata_perror(wd->drvp, wd->sc_wdc_bio.r_error, errbuf,
  590                     sizeof buf);
retry:
  592                 /* Just reset and retry. Can we do more ? */
wdc_reset_channel(wd->drvp);
diskerr(bp, "wd", errbuf, LOG_PRINTF,
wd->sc_wdc_bio.blkdone, wd->sc_dk.dk_label);
  596                 if (wd->retries++ < WDIORETRIES) {
printf(", retrying\n");
timeout_add(&wd->sc_restart_timeout, RECOVERYTIME);
  599                         return;
  600                 }
printf("\n");
bp->b_flags |= B_ERROR;
bp->b_error = EIO;
  604                 break;
  605         case NOERROR:
noerror:        if ((wd->sc_wdc_bio.flags & ATA_CORR) || wd->retries > 0)
printf("%s: soft error (corrected)\n",
wd->sc_dev.dv_xname);
  609         }
disk_unbusy(&wd->sc_dk, (bp->b_bcount - bp->b_resid),
  611             (bp->b_flags & B_READ));
biodone(bp);
wd->openings++;
wdstart(wd);
  615 }
  617 void
wdrestart(void *v)
  619 {
  620         struct wd_softc *wd = v;
  621         struct buf *bp = wd->sc_bp;
  622         int s;
WDCDEBUG_PRINT(("wdrestart %s\n", wd->sc_dev.dv_xname),
DEBUG_XFERS);
s = splbio();
disk_unbusy(&wd->sc_dk, 0, (bp->b_flags & B_READ));
__wdstart(v, bp);
splx(s);
  630 }
  632 int
  633 wdread(dev_t dev, struct uio *uio, int flags)
  634 {
WDCDEBUG_PRINT(("wdread\n"), DEBUG_XFERS);
  637         return (physio(wdstrategy, NULL, dev, B_READ, minphys, uio));
  638 }
  640 int
  641 wdwrite(dev_t dev, struct uio *uio, int flags)
  642 {
WDCDEBUG_PRINT(("wdwrite\n"), DEBUG_XFERS);
  645         return (physio(wdstrategy, NULL, dev, B_WRITE, minphys, uio));
  646 }
  648 int
wdopen(dev_t dev, int flag, int fmt, struct proc *p)
  650 {
  651         struct wd_softc *wd;
  652         int unit, part;
  653         int error;
WDCDEBUG_PRINT(("wdopen\n"), DEBUG_FUNCS);
unit = DISKUNIT(dev);
wd = wdlookup(unit);
  659         if (wd == NULL)
  660                 return ENXIO;
  662         /*
  663          * If this is the first open of this device, add a reference
  664          * to the adapter.
  665          */
  666         if ((error = wdlock(wd)) != 0)
  667                 goto bad4;
  669         if (wd->sc_dk.dk_openmask != 0) {
  670                 /*
  671                  * If any partition is open, but the disk has been invalidated,
  672                  * disallow further opens.
  673                  */
  674                 if ((wd->sc_flags & WDF_LOADED) == 0) {
error = EIO;
  676                         goto bad3;
  677                 }
  678         } else {
  679                 if ((wd->sc_flags & WDF_LOADED) == 0) {
wd->sc_flags |= WDF_LOADED;
  682                         /* Load the physical device parameters. */
wd_get_params(wd, AT_WAIT, &wd->sc_params);
  685                         /* Load the partition info if not already loaded. */
wdgetdisklabel(dev, wd, wd->sc_dk.dk_label, 0);
  687                 }
  688         }
part = DISKPART(dev);
  692         /* Check that the partition exists. */
  693         if (part != RAW_PART &&
  694             (part >= wd->sc_dk.dk_label->d_npartitions ||
wd->sc_dk.dk_label->d_partitions[part].p_fstype == FS_UNUSED)) {
error = ENXIO;
  697                 goto bad;
  698         }
  700         /* Insure only one open at a time. */
  701         switch (fmt) {
  702         case S_IFCHR:
wd->sc_dk.dk_copenmask |= (1 << part);
  704                 break;
  705         case S_IFBLK:
wd->sc_dk.dk_bopenmask |= (1 << part);
  707                 break;
  708         }
wd->sc_dk.dk_openmask =
wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
wdunlock(wd);
device_unref(&wd->sc_dev);
  714         return 0;
bad:
  717         if (wd->sc_dk.dk_openmask == 0) {
  718         }
bad3:
wdunlock(wd);
bad4:
device_unref(&wd->sc_dev);
  724         return error;
  725 }
  727 int
wdclose(dev_t dev, int flag, int fmt, struct proc *p)
  729 {
  730         struct wd_softc *wd;
  731         int part = DISKPART(dev);
  732         int error = 0;
wd = wdlookup(DISKUNIT(dev));
  735         if (wd == NULL)
  736                 return ENXIO;
WDCDEBUG_PRINT(("wdclose\n"), DEBUG_FUNCS);
  739         if ((error = wdlock(wd)) != 0)
  740                 goto exit;
  742         switch (fmt) {
  743         case S_IFCHR:
wd->sc_dk.dk_copenmask &= ~(1 << part);
  745                 break;
  746         case S_IFBLK:
wd->sc_dk.dk_bopenmask &= ~(1 << part);
  748                 break;
  749         }
wd->sc_dk.dk_openmask =
wd->sc_dk.dk_copenmask | wd->sc_dk.dk_bopenmask;
  753         if (wd->sc_dk.dk_openmask == 0) {
wd_flushcache(wd, 0);
  755                 /* XXXX Must wait for I/O to complete! */
  756         }
wdunlock(wd);
exit:
device_unref(&wd->sc_dev);
  762         return (error);
  763 }
  765 void
wdgetdefaultlabel(struct wd_softc *wd, struct disklabel *lp)
  767 {
WDCDEBUG_PRINT(("wdgetdefaultlabel\n"), DEBUG_FUNCS);
bzero(lp, sizeof(struct disklabel));
lp->d_secsize = DEV_BSIZE;
DL_SETDSIZE(lp, wd->sc_capacity);
lp->d_ntracks = wd->sc_params.atap_heads;
lp->d_nsectors = wd->sc_params.atap_sectors;
lp->d_secpercyl = lp->d_ntracks * lp->d_nsectors;
lp->d_ncylinders = DL_GETDSIZE(lp) / lp->d_secpercyl;
  777         if (wd->drvp->ata_vers == -1) {
lp->d_type = DTYPE_ST506;
strncpy(lp->d_typename, "ST506/MFM/RLL", sizeof lp->d_typename);
  780         } else {
lp->d_type = DTYPE_ESDI;
strncpy(lp->d_typename, "ESDI/IDE disk", sizeof lp->d_typename);
  783         }
  784         /* XXX - user viscopy() like sd.c */
strncpy(lp->d_packname, wd->sc_params.atap_model, sizeof lp->d_packname);
lp->d_rpm = 3600;
lp->d_interleave = 1;
lp->d_flags = 0;
lp->d_version = 1;
lp->d_magic = DISKMAGIC;
lp->d_magic2 = DISKMAGIC;
lp->d_checksum = dkcksum(lp);
  794 }
  796 /*
  797  * Fabricate a default disk label, and try to read the correct one.
  798  */
  799 void
wdgetdisklabel(dev_t dev, struct wd_softc *wd, struct disklabel *lp,
  801     int spoofonly)
  802 {
  803         char *errstring;
WDCDEBUG_PRINT(("wdgetdisklabel\n"), DEBUG_FUNCS);
wdgetdefaultlabel(wd, lp);
  809         if (wd->drvp->state > RECAL)
wd->drvp->drive_flags |= DRIVE_RESET;
errstring = readdisklabel(DISKLABELDEV(dev), wdstrategy, lp,
spoofonly);
  813         if (wd->drvp->state > RECAL)
wd->drvp->drive_flags |= DRIVE_RESET;
  815         if (errstring) {
  816                 /*printf("%s: %s\n", wd->sc_dev.dv_xname, errstring);*/
  817         }
  818 }
  820 int
  821 wdioctl(dev_t dev, u_long xfer, caddr_t addr, int flag, struct proc *p)
  822 {
  823         struct wd_softc *wd;
  824         struct disklabel *lp;
  825         int error = 0;
WDCDEBUG_PRINT(("wdioctl\n"), DEBUG_FUNCS);
wd = wdlookup(DISKUNIT(dev));
  830         if (wd == NULL)
  831                 return ENXIO;
  833         if ((wd->sc_flags & WDF_LOADED) == 0) {
error = EIO;
  835                 goto exit;
  836         }
  838         switch (xfer) {
  839         case DIOCRLDINFO:
lp = malloc(sizeof(*lp), M_TEMP, M_WAITOK);
wdgetdisklabel(dev, wd, lp, 0);
bcopy(lp, wd->sc_dk.dk_label, sizeof(*lp));
free(lp, M_TEMP);
  844                 goto exit;
  846         case DIOCGPDINFO:
wdgetdisklabel(dev, wd, (struct disklabel *)addr, 1);
  848                 goto exit;
  850         case DIOCGDINFO:
  851                 *(struct disklabel *)addr = *(wd->sc_dk.dk_label);
  852                 goto exit;
  854         case DIOCGPART:
  855                 ((struct partinfo *)addr)->disklab = wd->sc_dk.dk_label;
  856                 ((struct partinfo *)addr)->part =
  857                     &wd->sc_dk.dk_label->d_partitions[DISKPART(dev)];
  858                 goto exit;
  860         case DIOCWDINFO:
  861         case DIOCSDINFO:
  862                 if ((flag & FWRITE) == 0) {
error = EBADF;
  864                         goto exit;
  865                 }
  867                 if ((error = wdlock(wd)) != 0)
  868                         goto exit;
wd->sc_flags |= WDF_LABELLING;
error = setdisklabel(wd->sc_dk.dk_label,
  872                     (struct disklabel *)addr, /*wd->sc_dk.dk_openmask : */0);
  873                 if (error == 0) {
  874                         if (wd->drvp->state > RECAL)
wd->drvp->drive_flags |= DRIVE_RESET;
  876                         if (xfer == DIOCWDINFO)
error = writedisklabel(DISKLABELDEV(dev),
wdstrategy, wd->sc_dk.dk_label);
  879                 }
wd->sc_flags &= ~WDF_LABELLING;
wdunlock(wd);
  883                 goto exit;
  885         case DIOCWLABEL:
  886                 if ((flag & FWRITE) == 0) {
error = EBADF;
  888                         goto exit;
  889                 }
  891                 if (*(int *)addr)
wd->sc_flags |= WDF_WLABEL;
  893                 else
wd->sc_flags &= ~WDF_WLABEL;
  895                 goto exit;
  897 #ifdef notyet
  898         case DIOCWFORMAT:
  899                 if ((flag & FWRITE) == 0)
  900                         return EBADF;
  901                 {
  902                 struct format_op *fop;
  903                 struct iovec aiov;
  904                 struct uio auio;
fop = (struct format_op *)addr;
aiov.iov_base = fop->df_buf;
aiov.iov_len = fop->df_count;
auio.uio_iov = &aiov;
auio.uio_iovcnt = 1;
auio.uio_resid = fop->df_count;
auio.uio_segflg = 0;
auio.uio_offset =
fop->df_startblk * wd->sc_dk.dk_label->d_secsize;
auio.uio_procp = p;
error = physio(wdformat, NULL, dev, B_WRITE, minphys,
  917                     &auio);
fop->df_count -= auio.uio_resid;
fop->df_reg[0] = wdc->sc_status;
fop->df_reg[1] = wdc->sc_error;
  921                 goto exit;
  922                 }
  923 #endif
  925         default:
error = wdc_ioctl(wd->drvp, xfer, addr, flag, p);
  927                 goto exit;
  928         }
  930 #ifdef DIAGNOSTIC
panic("wdioctl: impossible");
  932 #endif
exit:
device_unref(&wd->sc_dev);
  936         return (error);
  937 }
  939 #ifdef B_FORMAT
  940 int
wdformat(struct buf *bp)
  942 {
bp->b_flags |= B_FORMAT;
  945         return wdstrategy(bp);
  946 }
  947 #endif
daddr64_t
  950 wdsize(dev_t dev)
  951 {
  952         struct wd_softc *wd;
  953         int part, omask;
int64_t size;
WDCDEBUG_PRINT(("wdsize\n"), DEBUG_FUNCS);
wd = wdlookup(DISKUNIT(dev));
  959         if (wd == NULL)
  960                 return (-1);
part = DISKPART(dev);
omask = wd->sc_dk.dk_openmask & (1 << part);
  965         if (omask == 0 && wdopen(dev, 0, S_IFBLK, NULL) != 0) {
size = -1;
  967                 goto exit;
  968         }
size = DL_GETPSIZE(&wd->sc_dk.dk_label->d_partitions[part]) *
  971             (wd->sc_dk.dk_label->d_secsize / DEV_BSIZE);
  972         if (omask == 0 && wdclose(dev, 0, S_IFBLK, NULL) != 0)
size = -1;
exit:
device_unref(&wd->sc_dev);
  977         return (size);
  978 }
  980 /* #define WD_DUMP_NOT_TRUSTED if you just want to watch */
  981 static int wddoingadump = 0;
  982 static int wddumprecalibrated = 0;
  983 static int wddumpmulti = 1;
  985 /*
  986  * Dump core after a system crash.
  987  */
  988 int
  989 wddump(dev_t dev, daddr64_t blkno, caddr_t va, size_t size)
  990 {
  991         struct wd_softc *wd;    /* disk unit to do the I/O */
  992         struct disklabel *lp;   /* disk's disklabel */
  993         int unit, part;
  994         int nblks;      /* total number of sectors left to write */
  995         int err;
  996         char errbuf[256];
  998         /* Check if recursive dump; if so, punt. */
  999         if (wddoingadump)
 1000                 return EFAULT;
wddoingadump = 1;
unit = DISKUNIT(dev);
wd = wdlookup(unit);
 1005         if (wd == NULL)
 1006                 return ENXIO;
part = DISKPART(dev);
 1010         /* Make sure it was initialized. */
 1011         if (wd->drvp->state < READY)
 1012                 return ENXIO;
 1014         /* Convert to disk sectors.  Request must be a multiple of size. */
lp = wd->sc_dk.dk_label;
 1016         if ((size % lp->d_secsize) != 0)
 1017                 return EFAULT;
nblks = size / lp->d_secsize;
blkno = blkno / (lp->d_secsize / DEV_BSIZE);
 1021         /* Check transfer bounds against partition size. */
 1022         if ((blkno < 0) || ((blkno + nblks) > DL_GETPSIZE(&lp->d_partitions[part])))
 1023                 return EINVAL;
 1025         /* Offset block number to start of partition. */
blkno += DL_GETPOFFSET(&lp->d_partitions[part]);
 1028         /* Recalibrate, if first dump transfer. */
 1029         if (wddumprecalibrated == 0) {
wddumpmulti = wd->sc_multi;
wddumprecalibrated = 1;
wd->drvp->state = RECAL;
 1033         }
 1035         while (nblks > 0) {
again:
wd->sc_wdc_bio.blkno = blkno;
wd->sc_wdc_bio.flags = ATA_POLL;
 1039                 if (wddumpmulti == 1)
wd->sc_wdc_bio.flags |= ATA_SINGLE;
 1041                 if (wd->sc_flags & WDF_LBA48)
wd->sc_wdc_bio.flags |= ATA_LBA48;
 1043                 if (wd->sc_flags & WDF_LBA)
wd->sc_wdc_bio.flags |= ATA_LBA;
wd->sc_wdc_bio.bcount =
min(nblks, wddumpmulti) * lp->d_secsize;
wd->sc_wdc_bio.databuf = va;
wd->sc_wdc_bio.wd = wd;
 1049 #ifndef WD_DUMP_NOT_TRUSTED
 1050                 switch (wdc_ata_bio(wd->drvp, &wd->sc_wdc_bio)) {
 1051                 case WDC_TRY_AGAIN:
panic("wddump: try again");
 1053                         break;
 1054                 case WDC_QUEUED:
panic("wddump: polled command has been queued");
 1056                         break;
 1057                 case WDC_COMPLETE:
 1058                         break;
 1059                 }
 1060                 switch(wd->sc_wdc_bio.error) {
 1061                 case TIMEOUT:
printf("wddump: device timed out");
err = EIO;
 1064                         break;
 1065                 case ERR_DF:
printf("wddump: drive fault");
err = EIO;
 1068                         break;
 1069                 case ERR_DMA:
printf("wddump: DMA error");
err = EIO;
 1072                         break;
 1073                 case ERROR:
errbuf[0] = '\0';
ata_perror(wd->drvp, wd->sc_wdc_bio.r_error, errbuf,
 1076                             sizeof errbuf);
printf("wddump: %s", errbuf);
err = EIO;
 1079                         break;
 1080                 case NOERROR:
err = 0;
 1082                         break;
 1083                 default:
panic("wddump: unknown error type");
 1085                 }
 1086                 if (err != 0) {
 1087                         if (wddumpmulti != 1) {
wddumpmulti = 1; /* retry in single-sector */
printf(", retrying\n");
 1090                                 goto again;
 1091                         }
printf("\n");
 1093                         return err;
 1094                 }
 1095 #else   /* WD_DUMP_NOT_TRUSTED */
 1096                 /* Let's just talk about this first... */
printf("wd%d: dump addr 0x%x, cylin %d, head %d, sector %d\n",
unit, va, cylin, head, sector);
delay(500 * 1000);      /* half a second */
 1100 #endif
 1102                 /* update block count */
nblks -= min(nblks, wddumpmulti);
blkno += min(nblks, wddumpmulti);
va += min(nblks, wddumpmulti) * lp->d_secsize;
 1106         }
wddoingadump = 0;
 1109         return 0;
 1110 }
 1112 int
wd_get_params(struct wd_softc *wd, u_int8_t flags, struct ataparams *params)
 1114 {
 1115         switch (ata_get_params(wd->drvp, flags, params)) {
 1116         case CMD_AGAIN:
 1117                 return 1;
 1118         case CMD_ERR:
 1119                 /* If we already have drive parameters, reuse them. */
 1120                 if (wd->sc_params.atap_cylinders != 0) {
 1121                         if (params != &wd->sc_params)
bcopy(&wd->sc_params, params,
 1123                                     sizeof(struct ataparams));
 1124                         return 0;
 1125                 }
 1126                 /*
 1127                  * We `know' there's a drive here; just assume it's old.
 1128                  * This geometry is only used to read the MBR and print a
 1129                  * (false) attach message.
 1130                  */
bzero(params, sizeof(struct ataparams));
strncpy(params->atap_model, "ST506",
 1133                     sizeof params->atap_model);
params->atap_config = ATA_CFG_FIXED;
params->atap_cylinders = 1024;
params->atap_heads = 8;
params->atap_sectors = 17;
params->atap_multi = 1;
params->atap_capabilities1 = params->atap_capabilities2 = 0;
wd->drvp->ata_vers = -1; /* Mark it as pre-ATA */
 1141                 return 0;
 1142         case CMD_OK:
 1143                 return 0;
 1144         default:
panic("wd_get_params: bad return code from ata_get_params");
 1146                 /* NOTREACHED */
 1147         }
 1148 }
 1150 void
wd_flushcache(struct wd_softc *wd, int flags)
 1152 {
 1153         struct wdc_command wdc_c;
 1155         if (wd->drvp->ata_vers < 4) /* WDCC_FLUSHCACHE is here since ATA-4 */
 1156                 return;
bzero(&wdc_c, sizeof(struct wdc_command));
wdc_c.r_command = (wd->sc_flags & WDF_LBA48 ? WDCC_FLUSHCACHE_EXT :
WDCC_FLUSHCACHE);
wdc_c.r_st_bmask = WDCS_DRDY;
wdc_c.r_st_pmask = WDCS_DRDY;
 1162         if (flags != 0) {
wdc_c.flags = AT_POLL;
 1164         } else {
wdc_c.flags = AT_WAIT;
 1166         }
wdc_c.timeout = 30000; /* 30s timeout */
 1168         if (wdc_exec_command(wd->drvp, &wdc_c) != WDC_COMPLETE) {
printf("%s: flush cache command didn't complete\n",
wd->sc_dev.dv_xname);
 1171         }
 1172         if (wdc_c.flags & AT_TIMEOU) {
printf("%s: flush cache command timeout\n",
wd->sc_dev.dv_xname);
 1175         }
 1176         if (wdc_c.flags & AT_DF) {
printf("%s: flush cache command: drive fault\n",
wd->sc_dev.dv_xname);
 1179         }
 1180         /*
 1181          * Ignore error register, it shouldn't report anything else
 1182          * than COMMAND ABORTED, which means the device doesn't support
 1183          * flush cache
 1184          */
 1185 }
 1187 void
wd_shutdown(void *arg)
 1189 {
 1190         struct wd_softc *wd = arg;
wd_flushcache(wd, AT_POLL);
 1192 }