root/dev/ata/ata_wdc.c

DEFINITIONS

1. wdc_ata_bio
2. wdc_ata_bio_start
3. _wdc_ata_bio_start
4. wdc_ata_bio_intr
5. wdc_ata_bio_kill_xfer
6. wdc_ata_bio_done
7. wdc_ata_ctrl_intr
8. wdc_ata_err
9. wdc_ata_addref
10. wdc_ata_delref

    1 /*      $OpenBSD: ata_wdc.c,v 1.30 2007/02/14 00:53:47 jsg Exp $        */
    2 /*      $NetBSD: ata_wdc.c,v 1.21 1999/08/09 09:43:11 bouyer Exp $      */
    4 /*
    5  * Copyright (c) 1998, 2001 Manuel Bouyer.
    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. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   32  *
   33  */
   35 /*-
   36  * Copyright (c) 1998 The NetBSD Foundation, Inc.
   37  * All rights reserved.
   38  *
   39  * This code is derived from software contributed to The NetBSD Foundation
   40  * by Charles M. Hannum, by Onno van der Linden and by Manuel Bouyer.
   41  *
   42  * Redistribution and use in source and binary forms, with or without
   43  * modification, are permitted provided that the following conditions
   44  * are met:
   45  * 1. Redistributions of source code must retain the above copyright
   46  *    notice, this list of conditions and the following disclaimer.
   47  * 2. Redistributions in binary form must reproduce the above copyright
   48  *    notice, this list of conditions and the following disclaimer in the
   49  *    documentation and/or other materials provided with the distribution.
   50  * 3. All advertising materials mentioning features or use of this software
   51  *    must display the following acknowledgement:
   52  *        This product includes software developed by the NetBSD
   53  *        Foundation, Inc. and its contributors.
   54  * 4. Neither the name of The NetBSD Foundation nor the names of its
   55  *    contributors may be used to endorse or promote products derived
   56  *    from this software without specific prior written permission.
   57  *
   58  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   59  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   60  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   61  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   62  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   63  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   64  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   65  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   66  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   67  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   68  * POSSIBILITY OF SUCH DAMAGE.
   69  */
   71 #include <sys/param.h>
   72 #include <sys/systm.h>
   73 #include <sys/kernel.h>
   74 #include <sys/file.h>
   75 #include <sys/stat.h>
   76 #include <sys/buf.h>
   77 #include <sys/malloc.h>
   78 #include <sys/device.h>
   79 #include <sys/disklabel.h>
   80 #include <sys/syslog.h>
   81 #include <sys/proc.h>
   83 #include <machine/intr.h>
   84 #include <machine/bus.h>
   86 #include <dev/ata/atareg.h>
   87 #include <dev/ata/atavar.h>
   88 #include <dev/ic/wdcreg.h>
   89 #include <dev/ic/wdcvar.h>
   90 #include <dev/ata/wdvar.h>
   92 #define DEBUG_INTR   0x01
   93 #define DEBUG_XFERS  0x02
   94 #define DEBUG_STATUS 0x04
   95 #define DEBUG_FUNCS  0x08
   96 #define DEBUG_PROBE  0x10
   98 #ifdef WDCDEBUG
   99 #ifndef WDCDEBUG_WD_MASK
  100 #define WDCDEBUG_WD_MASK 0x00
  101 #endif
  102 int wdcdebug_wd_mask = WDCDEBUG_WD_MASK;
  103 #define WDCDEBUG_PRINT(args, level) do {        \
  104         if ((wdcdebug_wd_mask & (level)) != 0)  \
printf args;                    \
  106 } while (0)
  107 #else
  108 #define WDCDEBUG_PRINT(args, level)
  109 #endif
  111 #define ATA_DELAY 10000 /* 10s for a drive I/O */
  113 struct cfdriver wdc_cd = {
NULL, "wdc", DV_DULL
  115 };
  117 void  wdc_ata_bio_start(struct channel_softc *, struct wdc_xfer *);
  118 void  _wdc_ata_bio_start(struct channel_softc *, struct wdc_xfer *);
  119 int   wdc_ata_bio_intr(struct channel_softc *, struct wdc_xfer *, int);
  120 void  wdc_ata_bio_kill_xfer(struct channel_softc *, struct wdc_xfer *);
  121 void  wdc_ata_bio_done(struct channel_softc *, struct wdc_xfer *);
  122 int   wdc_ata_ctrl_intr(struct channel_softc *, struct wdc_xfer *, int);
  123 int   wdc_ata_err(struct ata_drive_datas *, struct ata_bio *);
  124 #define WDC_ATA_NOERR 0x00 /* Drive doesn't report an error */
  125 #define WDC_ATA_RECOV 0x01 /* There was a recovered error */
  126 #define WDC_ATA_ERR   0x02 /* Drive reports an error */
  128 /*
  129  * Handle block I/O operation. Return WDC_COMPLETE, WDC_QUEUED, or
  130  * WDC_TRY_AGAIN. Must be called at splbio().
  131  */
  132 int
wdc_ata_bio(struct ata_drive_datas *drvp, struct ata_bio *ata_bio)
  134 {
  135         struct wdc_xfer *xfer;
  136         struct channel_softc *chp = drvp->chnl_softc;
xfer = wdc_get_xfer(WDC_NOSLEEP);
  139         if (xfer == NULL)
  140                 return WDC_TRY_AGAIN;
  141         if (ata_bio->flags & ATA_POLL)
xfer->c_flags |= C_POLL;
  143         if (!(ata_bio->flags & ATA_POLL) &&
  144             (drvp->drive_flags & (DRIVE_DMA | DRIVE_UDMA)) &&
  145             (ata_bio->flags & ATA_SINGLE) == 0 &&
  146             (ata_bio->bcount > 512 ||
  147             (chp->wdc->quirks & WDC_QUIRK_NOSHORTDMA) == 0))
xfer->c_flags |= C_DMA;
xfer->drive = drvp->drive;
xfer->cmd = ata_bio;
xfer->databuf = ata_bio->databuf;
xfer->c_bcount = ata_bio->bcount;
xfer->c_start = wdc_ata_bio_start;
xfer->c_intr = wdc_ata_bio_intr;
xfer->c_kill_xfer = wdc_ata_bio_kill_xfer;
wdc_exec_xfer(chp, xfer);
  157         return (ata_bio->flags & ATA_ITSDONE) ? WDC_COMPLETE : WDC_QUEUED;
  158 }
  160 void
wdc_ata_bio_start(struct channel_softc *chp, struct wdc_xfer *xfer)
  162 {
  163         struct ata_bio *ata_bio = xfer->cmd;
WDCDEBUG_PRINT(("wdc_ata_bio_start %s:%d:%d\n",
chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive),
DEBUG_XFERS);
  168         /* start timeout machinery */
  169         if ((ata_bio->flags & ATA_POLL) == 0)
timeout_add(&chp->ch_timo, ATA_DELAY / 1000 * hz);
_wdc_ata_bio_start(chp, xfer);
  172 }
  174 void
_wdc_ata_bio_start(struct channel_softc *chp, struct wdc_xfer *xfer)
  176 {
  177         struct ata_bio *ata_bio = xfer->cmd;
  178         struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
u_int16_t cyl;
u_int8_t head, sect, cmd = 0;
  181         int nblks;
  182         int ata_delay;
  183         int dma_flags = 0;
WDCDEBUG_PRINT(("_wdc_ata_bio_start %s:%d:%d\n",
chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive),
DEBUG_INTR | DEBUG_XFERS);
  188         /* Do control operations specially. */
  189         if (drvp->state < READY) {
  190                 /*
  191                  * Actually, we want to be careful not to mess with the control
  192                  * state if the device is currently busy, but we can assume
  193                  * that we never get to this point if that's the case.
  194                  */
  195                 /* at this point, we should only be in RECAL state */
  196                 if (drvp->state != RECAL) {
printf("%s:%d:%d: bad state %d in _wdc_ata_bio_start\n",
chp->wdc->sc_dev.dv_xname, chp->channel,
xfer->drive, drvp->state);
panic("_wdc_ata_bio_start: bad state");
  201                 }
xfer->c_intr = wdc_ata_ctrl_intr;
wdc_set_drive(chp, xfer->drive);
  204                 if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, ATA_DELAY) != 0)
  205                         goto timeout;
wdccommandshort(chp, xfer->drive, WDCC_RECAL);
drvp->state = RECAL_WAIT;
  208                 if ((ata_bio->flags & ATA_POLL) == 0) {
chp->ch_flags |= WDCF_IRQ_WAIT;
  210                 } else {
  211                         /* Wait for at last 400ns for status bit to be valid */
DELAY(1);
wdc_ata_ctrl_intr(chp, xfer, 0);
  214                 }
  215                 return;
  216         }
  218         if (xfer->c_flags & C_DMA) {
  219                 if (drvp->n_xfers <= NXFER)
drvp->n_xfers++;
dma_flags = (ata_bio->flags & ATA_READ) ?  WDC_DMA_READ : 0;
  222                 if (ata_bio->flags & ATA_LBA48)
dma_flags |= WDC_DMA_LBA48;
  224         }
  225         if (ata_bio->flags & ATA_SINGLE)
ata_delay = ATA_DELAY;
  227         else
ata_delay = ATA_DELAY;
again:
  230         /*
  231          *
  232          * When starting a multi-sector transfer, or doing single-sector
  233          * transfers...
  234          */
  235         if (xfer->c_skip == 0 || (ata_bio->flags & ATA_SINGLE) != 0) {
  236                 if (ata_bio->flags & ATA_SINGLE)
nblks = 1;
  238                 else
nblks = xfer->c_bcount / ata_bio->lp->d_secsize;
  240                 if (ata_bio->flags & ATA_LBA) {
sect = (ata_bio->blkno >> 0) & 0xff;
cyl = (ata_bio->blkno >> 8) & 0xffff;
head = (ata_bio->blkno >> 24) & 0x0f;
head |= WDSD_LBA;
  245                 } else {
  246                         int blkno = ata_bio->blkno;
sect = blkno % ata_bio->lp->d_nsectors;
sect++;    /* Sectors begin with 1, not 0. */
blkno /= ata_bio->lp->d_nsectors;
head = blkno % ata_bio->lp->d_ntracks;
blkno /= ata_bio->lp->d_ntracks;
cyl = blkno;
head |= WDSD_CHS;
  254                 }
  255                 if (xfer->c_flags & C_DMA) {
ata_bio->nblks = nblks;
ata_bio->nbytes = xfer->c_bcount;
  258                         if (ata_bio->flags & ATA_LBA48)
cmd = (ata_bio->flags & ATA_READ) ?
WDCC_READDMA_EXT : WDCC_WRITEDMA_EXT;
  261                         else
cmd = (ata_bio->flags & ATA_READ) ?
WDCC_READDMA : WDCC_WRITEDMA;
  264                         /* Init the DMA channel. */
  265                         if ((*chp->wdc->dma_init)(chp->wdc->dma_arg,
chp->channel, xfer->drive,
  267                             (char *)xfer->databuf + xfer->c_skip,
ata_bio->nbytes, dma_flags) != 0) {
ata_bio->error = ERR_DMA;
ata_bio->r_error = 0;
wdc_ata_bio_done(chp, xfer);
  272                                 return;
  273                         }
  274                         /* Initiate command */
wdc_set_drive(chp, xfer->drive);
  276                         if (wait_for_ready(chp, ata_delay) < 0)
  277                                 goto timeout;
  278                         if (ata_bio->flags & ATA_LBA48) {
wdccommandext(chp, xfer->drive, cmd,
  280                                     (u_int64_t)ata_bio->blkno, nblks);
  281                         } else {
wdccommand(chp, xfer->drive, cmd, cyl,
head, sect, nblks, 0);
  284                         }
  285                         /* start the DMA channel */
  286                         (*chp->wdc->dma_start)(chp->wdc->dma_arg,
chp->channel, xfer->drive);
chp->ch_flags |= WDCF_DMA_WAIT;
  289                         /* wait for irq */
  290                         goto intr;
  291                 } /* else not DMA */
ata_bio->nblks = min(nblks, ata_bio->multi);
ata_bio->nbytes = ata_bio->nblks * ata_bio->lp->d_secsize;
  294                 if (ata_bio->nblks > 1 && (ata_bio->flags & ATA_SINGLE) == 0) {
  295                         if (ata_bio->flags & ATA_LBA48)
cmd = (ata_bio->flags & ATA_READ) ?
WDCC_READMULTI_EXT : WDCC_WRITEMULTI_EXT;
  298                         else
cmd = (ata_bio->flags & ATA_READ) ?
WDCC_READMULTI : WDCC_WRITEMULTI;
  301                 } else {
  302                         if (ata_bio->flags & ATA_LBA48)
cmd = (ata_bio->flags & ATA_READ) ?
WDCC_READ_EXT : WDCC_WRITE_EXT;
  305                         else
cmd = (ata_bio->flags & ATA_READ) ?
WDCC_READ : WDCC_WRITE;
  308                 }
  309                 /* Initiate command! */
wdc_set_drive(chp, xfer->drive);
  311                 if (wait_for_ready(chp, ata_delay) < 0)
  312                         goto timeout;
  313                 if (ata_bio->flags & ATA_LBA48) {
wdccommandext(chp, xfer->drive, cmd,
  315                             (u_int64_t)ata_bio->blkno, nblks);
  316                 } else {
wdccommand(chp, xfer->drive, cmd, cyl,
head, sect, nblks,
  319                             (ata_bio->lp->d_type == DTYPE_ST506) ?
ata_bio->lp->d_precompcyl / 4 : 0);
  321                 }
  322         } else if (ata_bio->nblks > 1) {
  323                 /* The number of blocks in the last stretch may be smaller. */
nblks = xfer->c_bcount / ata_bio->lp->d_secsize;
  325                 if (ata_bio->nblks > nblks) {
ata_bio->nblks = nblks;
ata_bio->nbytes = xfer->c_bcount;
  328                 }
  329         }
  330         /* If this was a write and not using DMA, push the data. */
  331         if ((ata_bio->flags & ATA_READ) == 0) {
  332                 if (wait_for_drq(chp, ata_delay) != 0) {
printf("%s:%d:%d: timeout waiting for DRQ, "
  334                             "st=0x%b, err=0x%02x\n",
chp->wdc->sc_dev.dv_xname, chp->channel,
xfer->drive, chp->ch_status, WDCS_BITS,
chp->ch_error);
  338                         if (wdc_ata_err(drvp, ata_bio) != WDC_ATA_ERR)
ata_bio->error = TIMEOUT;
wdc_ata_bio_done(chp, xfer);
  341                         return;
  342                 }
  343                 if (wdc_ata_err(drvp, ata_bio) == WDC_ATA_ERR) {
wdc_ata_bio_done(chp, xfer);
  345                         return;
  346                 }
wdc_output_bytes(drvp, (char *)xfer->databuf + xfer->c_skip,
ata_bio->nbytes);
  349         }
intr:   /* Wait for IRQ (either real or polled) */
  352         if ((ata_bio->flags & ATA_POLL) == 0) {
chp->ch_flags |= WDCF_IRQ_WAIT;
  354         } else {
  355                 /* Wait for at last 400ns for status bit to be valid */
delay(1);
  357                 if (chp->ch_flags & WDCF_DMA_WAIT) {
wdc_dmawait(chp, xfer, ATA_DELAY);
chp->ch_flags &= ~WDCF_DMA_WAIT;
  360                 }
wdc_ata_bio_intr(chp, xfer, 0);
  362                 if ((ata_bio->flags & ATA_ITSDONE) == 0)
  363                         goto again;
  364         }
  365         return;
timeout:
printf("%s:%d:%d: not ready, st=0x%b, err=0x%02x\n",
chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
chp->ch_status, WDCS_BITS, chp->ch_error);
  370         if (wdc_ata_err(drvp, ata_bio) != WDC_ATA_ERR)
ata_bio->error = TIMEOUT;
wdc_ata_bio_done(chp, xfer);
  373         return;
  374 }
  376 int
wdc_ata_bio_intr(struct channel_softc *chp, struct wdc_xfer *xfer, int irq)
  378 {
  379         struct ata_bio *ata_bio = xfer->cmd;
  380         struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
  381         int drv_err;
WDCDEBUG_PRINT(("wdc_ata_bio_intr %s:%d:%d\n",
chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive),
DEBUG_INTR | DEBUG_XFERS);
  388         /* Is it not a transfer, but a control operation? */
  389         if (drvp->state < READY) {
printf("%s:%d:%d: bad state %d in wdc_ata_bio_intr\n",
chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
drvp->state);
panic("wdc_ata_bio_intr: bad state");
  394         }
  396         /*
  397          * reset on timeout. This will cause extra resets in the case
  398          * of occasional lost interrupts
  399          */
  400         if (xfer->c_flags & C_TIMEOU)
  401                 goto timeout;
  403         /* Ack interrupt done by wait_for_unbusy */
  404         if (wait_for_unbusy(chp,
  405             (irq == 0) ? ATA_DELAY : 0) < 0) {
  406                 if (irq)
  407                         return 0; /* IRQ was not for us */
printf("%s:%d:%d: device timeout, c_bcount=%d, c_skip%d\n",
chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
xfer->c_bcount, xfer->c_skip);
  412                 goto timeout;
  413         }
  414         if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
chp->wdc->irqack(chp);
drv_err = wdc_ata_err(drvp, ata_bio);
  419         if (xfer->c_flags & C_DMA) {
  420                 if (chp->wdc->dma_status != 0) {
  421                         if (drv_err != WDC_ATA_ERR) {
ata_bio->error = ERR_DMA;
drv_err = WDC_ATA_ERR;
  424                         }
  425                 }
  426                 if (chp->ch_status & WDCS_DRQ) {
  427                         if (drv_err != WDC_ATA_ERR) {
printf("%s:%d:%d: intr with DRQ (st=0x%b)\n",
chp->wdc->sc_dev.dv_xname, chp->channel,
xfer->drive, chp->ch_status, WDCS_BITS);
ata_bio->error = TIMEOUT;
drv_err = WDC_ATA_ERR;
  433                         }
  434                 }
  435                 if (drv_err != WDC_ATA_ERR)
  436                         goto end;
ata_dmaerr(drvp);
  438         }
  440         /* if we had an error, end */
  441         if (drv_err == WDC_ATA_ERR) {
wdc_ata_bio_done(chp, xfer);
  443                 return 1;
  444         }
  446         /* If this was a read and not using DMA, fetch the data. */
  447         if ((ata_bio->flags & ATA_READ) != 0) {
  448                 if ((chp->ch_status & WDCS_DRQ) != WDCS_DRQ) {
printf("%s:%d:%d: read intr before drq\n",
chp->wdc->sc_dev.dv_xname, chp->channel,
xfer->drive);
ata_bio->error = TIMEOUT;
wdc_ata_bio_done(chp, xfer);
  454                         return 1;
  455                 }
wdc_input_bytes(drvp, (char *)xfer->databuf + xfer->c_skip,
ata_bio->nbytes);
  458         }
end:
ata_bio->blkno += ata_bio->nblks;
ata_bio->blkdone += ata_bio->nblks;
xfer->c_skip += ata_bio->nbytes;
xfer->c_bcount -= ata_bio->nbytes;
  464         /* See if this transfer is complete. */
  465         if (xfer->c_bcount > 0) {
  466                 if ((ata_bio->flags & ATA_POLL) == 0) {
  467                         /* Start the next operation */
_wdc_ata_bio_start(chp, xfer);
  469                 } else {
  470                         /* Let _wdc_ata_bio_start do the loop */
  471                         return 1;
  472                 }
  473         } else { /* Done with this transfer */
ata_bio->error = NOERROR;
wdc_ata_bio_done(chp, xfer);
  476         }
  477         return 1;
timeout:
  480         if (xfer->c_flags & C_DMA)
ata_dmaerr(drvp);
ata_bio->error = TIMEOUT;
wdc_ata_bio_done(chp, xfer);
  485         return 1;
  486 }
  488 void
wdc_ata_bio_kill_xfer(struct channel_softc *chp, struct wdc_xfer *xfer)
  490 {
  491         struct ata_bio *ata_bio = xfer->cmd;
timeout_del(&chp->ch_timo);
  494         /* remove this command from xfer queue */
wdc_free_xfer(chp, xfer);
ata_bio->flags |= ATA_ITSDONE;
ata_bio->error = ERR_NODEV;
ata_bio->r_error = WDCE_ABRT;
  500         if ((ata_bio->flags & ATA_POLL) == 0) {
WDCDEBUG_PRINT(("wdc_ata_done: wddone\n"), DEBUG_XFERS);
wddone(ata_bio->wd);
  503         }
  504 }
  506 void
wdc_ata_bio_done(struct channel_softc *chp, struct wdc_xfer *xfer)
  508 {
  509         struct ata_bio *ata_bio = xfer->cmd;
WDCDEBUG_PRINT(("wdc_ata_bio_done %s:%d:%d: flags 0x%x\n",
chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
  513             (u_int)xfer->c_flags),
DEBUG_XFERS);
timeout_del(&chp->ch_timo);
  518         /* feed back residual bcount to our caller */
ata_bio->bcount = xfer->c_bcount;
  521         /* remove this command from xfer queue */
wdc_free_xfer(chp, xfer);
ata_bio->flags |= ATA_ITSDONE;
  525         if ((ata_bio->flags & ATA_POLL) == 0) {
WDCDEBUG_PRINT(("wdc_ata_done: wddone\n"), DEBUG_XFERS);
wddone(ata_bio->wd);
  528         }
WDCDEBUG_PRINT(("wdcstart from wdc_ata_done, flags 0x%x\n",
chp->ch_flags), DEBUG_XFERS);
wdcstart(chp);
  532 }
  534 /*
  535  * Implement operations needed before read/write.
  536  */
  537 int
wdc_ata_ctrl_intr(struct channel_softc *chp, struct wdc_xfer *xfer, int irq)
  539 {
  540         struct ata_bio *ata_bio = xfer->cmd;
  541         struct ata_drive_datas *drvp = &chp->ch_drive[xfer->drive];
  542         char *errstring = NULL;
  543         int delay = (irq == 0) ? ATA_DELAY : 0;
WDCDEBUG_PRINT(("wdc_ata_ctrl_intr: state %d\n", drvp->state),
DEBUG_FUNCS);
again:
  549         switch (drvp->state) {
  550         case RECAL:    /* Should not be in this state here */
panic("wdc_ata_ctrl_intr: state==RECAL");
  552                 break;
  554         case RECAL_WAIT:
errstring = "recal";
  556                 if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, delay))
  557                         goto timeout;
  558                 if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
chp->wdc->irqack(chp);
  560                 if (chp->ch_status & (WDCS_ERR | WDCS_DWF))
  561                         goto error;
  562         /* FALLTHROUGH */
  564         case PIOMODE:
  565                 /* Don't try to set modes if controller can't be adjusted */
  566                 if ((chp->wdc->cap & WDC_CAPABILITY_MODE) == 0)
  567                         goto geometry;
  568                 /* Also don't try if the drive didn't report its mode */
  569                 if ((drvp->drive_flags & DRIVE_MODE) == 0)
  570                         goto geometry;
  571                 /* SET FEATURES 0x08 is only for PIO mode > 2 */
  572                 if (drvp->PIO_mode <= 2)
  573                         goto geometry;
wdccommand(chp, drvp->drive, SET_FEATURES, 0, 0, 0,
  575                     0x08 | drvp->PIO_mode, WDSF_SET_MODE);
drvp->state = PIOMODE_WAIT;
  577                 break;
  579         case PIOMODE_WAIT:
errstring = "piomode";
  581                 if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, delay))
  582                         goto timeout;
  583                 if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
chp->wdc->irqack(chp);
  585                 if (chp->ch_status & (WDCS_ERR | WDCS_DWF))
  586                         goto error;
  587         /* FALLTHROUGH */
  589         case DMAMODE:
  590                 if (drvp->drive_flags & DRIVE_UDMA) {
wdccommand(chp, drvp->drive, SET_FEATURES, 0, 0, 0,
  592                             0x40 | drvp->UDMA_mode, WDSF_SET_MODE);
  593                 } else if (drvp->drive_flags & DRIVE_DMA) {
wdccommand(chp, drvp->drive, SET_FEATURES, 0, 0, 0,
  595                             0x20 | drvp->DMA_mode, WDSF_SET_MODE);
  596                 } else {
  597                         goto geometry;
  598                 }
drvp->state = DMAMODE_WAIT;
  600                 break;
  601         case DMAMODE_WAIT:
errstring = "dmamode";
  603                 if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, delay))
  604                         goto timeout;
  605                 if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
chp->wdc->irqack(chp);
  607                 if (chp->ch_status & (WDCS_ERR | WDCS_DWF))
  608                         goto error;
  609         /* FALLTHROUGH */
  611         case GEOMETRY:
geometry:
  613                 if (ata_bio->flags & ATA_LBA)
  614                         goto multimode;
wdccommand(chp, xfer->drive, WDCC_IDP,
ata_bio->lp->d_ncylinders,
ata_bio->lp->d_ntracks - 1, 0, ata_bio->lp->d_nsectors,
  618                     (ata_bio->lp->d_type == DTYPE_ST506) ?
ata_bio->lp->d_precompcyl / 4 : 0);
drvp->state = GEOMETRY_WAIT;
  621                 break;
  623         case GEOMETRY_WAIT:
errstring = "geometry";
  625                 if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, delay))
  626                         goto timeout;
  627                 if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
chp->wdc->irqack(chp);
  629                 if (chp->ch_status & (WDCS_ERR | WDCS_DWF))
  630                         goto error;
  631                 /* FALLTHROUGH */
  633         case MULTIMODE:
multimode:
  635                 if (ata_bio->multi == 1)
  636                         goto ready;
wdccommand(chp, xfer->drive, WDCC_SETMULTI, 0, 0, 0,
ata_bio->multi, 0);
drvp->state = MULTIMODE_WAIT;
  640                 break;
  642         case MULTIMODE_WAIT:
errstring = "setmulti";
  644                 if (wdcwait(chp, WDCS_DRDY, WDCS_DRDY, delay))
  645                         goto timeout;
  646                 if (chp->wdc->cap & WDC_CAPABILITY_IRQACK)
chp->wdc->irqack(chp);
  648                 if (chp->ch_status & (WDCS_ERR | WDCS_DWF))
  649                         goto error;
  650                 /* FALLTHROUGH */
  652         case READY:
ready:
drvp->state = READY;
  655                 /*
  656                  * The drive is usable now
  657                  */
xfer->c_intr = wdc_ata_bio_intr;
_wdc_ata_bio_start(chp, xfer);
  660                 return 1;
  661         }
  663         if ((ata_bio->flags & ATA_POLL) == 0) {
chp->ch_flags |= WDCF_IRQ_WAIT;
  665         } else {
  666                 goto again;
  667         }
  668         return 1;
timeout:
  671         if (irq && (xfer->c_flags & C_TIMEOU) == 0) {
  672                 return 0; /* IRQ was not for us */
  673         }
printf("%s:%d:%d: %s timed out\n",
chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive, errstring);
ata_bio->error = TIMEOUT;
drvp->state = 0;
wdc_ata_bio_done(chp, xfer);
  679         return 0;
error:
printf("%s:%d:%d: %s ",
chp->wdc->sc_dev.dv_xname, chp->channel, xfer->drive,
errstring);
  684         if (chp->ch_status & WDCS_DWF) {
printf("drive fault\n");
ata_bio->error = ERR_DF;
  687         } else {
printf("error (%x)\n", chp->ch_error);
ata_bio->r_error = chp->ch_error;
ata_bio->error = ERROR;
  691         }
drvp->state = 0;
wdc_ata_bio_done(chp, xfer);
  694         return 1;
  695 }
  697 int
wdc_ata_err(struct ata_drive_datas *drvp, struct ata_bio *ata_bio)
  699 {
  700         struct channel_softc *chp = drvp->chnl_softc;
ata_bio->error = 0;
  702         if (chp->ch_status & WDCS_BSY) {
ata_bio->error = TIMEOUT;
  704                 return WDC_ATA_ERR;
  705         }
  707         if (chp->ch_status & WDCS_DWF) {
ata_bio->error = ERR_DF;
  709                 return WDC_ATA_ERR;
  710         }
  712         if (chp->ch_status & WDCS_ERR) {
ata_bio->error = ERROR;
ata_bio->r_error = chp->ch_error;
  715                 if (drvp->drive_flags & DRIVE_UDMA &&
  716                     (ata_bio->r_error & WDCE_CRC)) {
  717                         /*
  718                          * Record the CRC error, to avoid downgrading to
  719                          * multiword DMA
  720                          */
drvp->drive_flags |= DRIVE_DMAERR;
  722                 }
  723                 if (ata_bio->r_error & (WDCE_BBK | WDCE_UNC | WDCE_IDNF |
WDCE_ABRT | WDCE_TK0NF | WDCE_AMNF))
  725                         return WDC_ATA_ERR;
  726                 return WDC_ATA_NOERR;
  727         }
  729         if (chp->ch_status & WDCS_CORR)
ata_bio->flags |= ATA_CORR;
  731         return WDC_ATA_NOERR;
  732 }
  734 #if 0
  735 int
wdc_ata_addref(drvp)
  737         struct ata_drive_datas *drvp;
  738 {
  739         struct channel_softc *chp = drvp->chnl_softc;
  741         return (wdc_addref(chp));
  742 }
  744 void
wdc_ata_delref(drvp)
  746         struct ata_drive_datas *drvp;
  747 {
  748         struct channel_softc *chp = drvp->chnl_softc;
wdc_delref(chp);
  751 }
  752 #endif