root/dev/ic/dpt.c

    1 /*      $OpenBSD: dpt.c,v 1.12 2007/04/10 17:47:55 miod Exp $   */
    2 /*      $NetBSD: dpt.c,v 1.12 1999/10/23 16:26:33 ad Exp $      */
    4 /*-
    5  * Copyright (c) 1997, 1998, 1999 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Andy Doran, Charles M. Hannum and by Jason R. Thorpe of the Numerical 
   10  * Aerospace Simulation Facility, NASA Ames Research Center.
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  * 1. Redistributions of source code must retain the above copyright
   16  *    notice, this list of conditions and the following disclaimer.
   17  * 2. Redistributions in binary form must reproduce the above copyright
   18  *    notice, this list of conditions and the following disclaimer in the
   19  *    documentation and/or other materials provided with the distribution.
   20  * 3. All advertising materials mentioning features or use of this software
   21  *    must display the following acknowledgement:
   22  *      This product includes software developed by the NetBSD
   23  *      Foundation, Inc. and its contributors.
   24  * 4. Neither the name of The NetBSD Foundation nor the names of its
   25  *    contributors may be used to endorse or promote products derived
   26  *    from this software without specific prior written permission.
   27  *
   28  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   29  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   30  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   31  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   32  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   38  * POSSIBILITY OF SUCH DAMAGE.
   39  */
   41 /*
   42  * Portions of this code fall under the following copyright:
   43  *
   44  * Originally written by Julian Elischer (julian@tfs.com)
   45  * for TRW Financial Systems for use under the MACH(2.5) operating system.
   46  *
   47  * TRW Financial Systems, in accordance with their agreement with Carnegie
   48  * Mellon University, makes this software available to CMU to distribute
   49  * or use in any manner that they see fit as long as this message is kept with
   50  * the software. For this reason TFS also grants any other persons or
   51  * organisations permission to use or modify this software.
   52  *
   53  * TFS supplies this software to be publicly redistributed
   54  * on the understanding that TFS is not responsible for the correct
   55  * functioning of this software in any circumstances.
   56  */
   58 /*
   59  * Driver for DPT EATA SCSI adapters.
   60  *
   61  * TODO:
   62  *
   63  * o Need a front-end for (newer) ISA boards.
   64  * o Handle older firmware better.
   65  * o Find a bunch of different firmware EEPROMs and try them out.
   66  * o Test with a bunch of different boards.
   67  * o dpt_readcfg() should not be using CP_PIO_GETCFG.
   68  * o An interface to userland applications.
   69  * o Some sysctls or a utility (eg dptctl(8)) to control parameters.
   70  */
   72 #include <sys/cdefs.h>
   73 #ifdef __NetBSD__
   74 __KERNEL_RCSID(0, "$NetBSD: dpt.c,v 1.12 1999/10/23 16:26:33 ad Exp $");
   75 #endif /* __NetBSD__ */
   77 #include <sys/param.h>
   78 #include <sys/systm.h>
   79 #include <sys/kernel.h>
   80 #include <sys/device.h>
   81 #include <sys/queue.h>
   82 #include <sys/proc.h>
   83 #include <sys/buf.h>
   85 #include <machine/endian.h>
   86 #ifdef __NetBSD__
   87 #include <machine/bswap.h>
   88 #endif /* __NetBSD__ */
   89 #include <machine/bus.h>
   91 #ifdef __NetBSD__
   92 #include <dev/scsipi/scsi_all.h>
   93 #include <dev/scsipi/scsipi_all.h>
   94 #include <dev/scsipi/scsiconf.h>
   95 #endif /* __NetBSD__ */
   96 #ifdef __OpenBSD__
   97 #include <scsi/scsi_all.h>
   98 #include <scsi/scsiconf.h>
   99 #endif /* __OpenBSD__ */
  101 #include <dev/ic/dptreg.h>
  102 #include <dev/ic/dptvar.h>
  104 #ifdef __OpenBSD__
  105 static void dpt_enqueue(struct dpt_softc *, struct scsi_xfer *, int);
  106 static struct scsi_xfer *dpt_dequeue(struct dpt_softc *);
  108 struct cfdriver dpt_cd = {
NULL, "dpt", DV_DULL
  110 };
  111 #endif /* __OpenBSD__ */
  113 /* A default for our link struct */
  114 #ifdef __NetBSD__
  115 static struct scsipi_device dpt_dev = {
  116 #endif /* __NetBSD__ */
  117 #ifdef __OpenBSD__
  118 static struct scsi_device dpt_dev = {
  119 #endif /* __OpenBSD__ */
NULL,                   /* Use default error handler */
NULL,                   /* have a queue, served by this */
NULL,                   /* have no async handler */
NULL,                   /* Use default 'done' routine */
  124 };
  126 #ifndef offsetof
  127 #define offsetof(type, member) (int)((&((type *)0)->member))
  128 #endif /* offsetof */
  130 static char *dpt_cname[] = {
  131         "PM3334", "SmartRAID IV",
  132         "PM3332", "SmartRAID IV",
  133         "PM2144", "SmartCache IV",
  134         "PM2044", "SmartCache IV",
  135         "PM2142", "SmartCache IV",
  136         "PM2042", "SmartCache IV",
  137         "PM2041", "SmartCache IV",
  138         "PM3224", "SmartRAID III",
  139         "PM3222", "SmartRAID III", 
  140         "PM3021", "SmartRAID III",
  141         "PM2124", "SmartCache III",
  142         "PM2024", "SmartCache III",
  143         "PM2122", "SmartCache III",
  144         "PM2022", "SmartCache III",
  145         "PM2021", "SmartCache III",
  146         "SK2012", "SmartCache Plus", 
  147         "SK2011", "SmartCache Plus",
NULL,     "unknown adapter, please report using sendbug(1)",
  149 };
  151 /*
  152  * Handle an interrupt from the HBA.
  153  */
  154 int
dpt_intr(xxx_sc)
  156         void *xxx_sc;
  157 {
  158         struct dpt_softc *sc;
  159         struct dpt_ccb *ccb;
  160         struct eata_sp *sp;
  161         static int moretimo;
  162         int more;
sc = xxx_sc;
sp = sc->sc_statpack;
  167         if (!sp) {
  168 #ifdef DEBUG
printf("%s: premature intr (st:%02x aux:%02x)\n",
sc->sc_dv.dv_xname, dpt_inb(sc, HA_STATUS),
dpt_inb(sc, HA_AUX_STATUS));
  172 #else /* DEBUG */
  173                 (void) dpt_inb(sc, HA_STATUS);
  174 #endif /* DEBUG */
  175                 return (0);
  176         }
more = 0;
  180 #ifdef DEBUG
  181         if ((dpt_inb(sc, HA_AUX_STATUS) & HA_AUX_INTR) == 0)
printf("%s: spurious intr\n", sc->sc_dv.dv_xname);
  183 #endif
  185         /* Don't get stalled by HA_ST_MORE */
  186         if (moretimo < DPT_MORE_TIMEOUT / 100)
moretimo = 0;
  189         for (;;) {
  190                 /*
  191                  * HBA might have interrupted while we were dealing with the
  192                  * last completed command, since we ACK before we deal; keep 
  193                  * polling. If no interrupt is signalled, but the HBA has
  194                  * indicated that more data will be available soon, hang 
  195                  * around. 
  196                  */ 
  197                 if ((dpt_inb(sc, HA_AUX_STATUS) & HA_AUX_INTR) == 0) {
  198                         if (more != 0 && moretimo++ < DPT_MORE_TIMEOUT / 100) {
DELAY(10);
  200                                 continue;
  201                         }
  202                         break;
  203                 }
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_ccb, sc->sc_spoff,
  206                     sizeof(struct eata_sp), BUS_DMASYNC_POSTREAD);
  208                 if (!sp) {
more = dpt_inb(sc, HA_STATUS) & HA_ST_MORE;
  211                         /* Don't get stalled by HA_ST_MORE */
  212                         if (moretimo < DPT_MORE_TIMEOUT / 100)
moretimo = 0;
  214                         continue;
  215                 }
  217                 /* Might have looped before HBA can reset HBA_AUX_INTR */
  218                 if (sp->sp_ccbid == -1) {
DELAY(50);
  220 #ifdef DIAGNOSTIC
printf("%s: slow reset of HA_AUX_STATUS?",
sc->sc_dv.dv_xname);
  223 #endif
  224                         if ((dpt_inb(sc, HA_AUX_STATUS) & HA_AUX_INTR) == 0)
  225                                 return (0);
  226 #ifdef DIAGNOSTIC
printf("%s: was a slow reset of HA_AUX_STATUS",
sc->sc_dv.dv_xname);
  229 #endif
  230                         /* Re-sync DMA map */
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_ccb, 
sc->sc_spoff, sizeof(struct eata_sp),
BUS_DMASYNC_POSTREAD);
  234                 }
  236                 /* Make sure CCB ID from status packet is realistic */
  237                 if (sp->sp_ccbid >= 0 && sp->sp_ccbid < sc->sc_nccbs) {
  238                         /* Sync up DMA map and cache cmd status */
ccb = sc->sc_ccbs + sp->sp_ccbid;
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_ccb, 
CCB_OFF(sc, ccb), sizeof(struct dpt_ccb), 
BUS_DMASYNC_POSTWRITE);
ccb->ccb_hba_status = sp->sp_hba_status & 0x7F;
ccb->ccb_scsi_status = sp->sp_scsi_status;
  248                         /* 
  249                          * Ack the interrupt and process the CCB. If this
  250                          * is a private CCB it's up to dpt_poll() to notice.
  251                          */
sp->sp_ccbid = -1;
ccb->ccb_flg |= CCB_INTR;
more = dpt_inb(sc, HA_STATUS) & HA_ST_MORE;
  255                         if ((ccb->ccb_flg & CCB_PRIVATE) == 0)
dpt_done_ccb(sc, ccb);
  257                 } else {
printf("%s: bogus status (returned CCB id %d)\n", 
sc->sc_dv.dv_xname, sp->sp_ccbid);
  261                         /* Ack the interrupt */
sp->sp_ccbid = -1;
more = dpt_inb(sc, HA_STATUS) & HA_ST_MORE;
  264                 }
  266                 /* Don't get stalled by HA_ST_MORE */
  267                 if (moretimo < DPT_MORE_TIMEOUT / 100)
moretimo = 0;
  269         }
  271         return (0);
  272 }
  274 /*
  275  * Initialize and attach the HBA. This is the entry point from bus
  276  * specific probe-and-attach code.
  277  */
  278 void
dpt_init(sc, intrstr)
  280         struct dpt_softc *sc;
  281         const char *intrstr;
  282 {
  283         struct eata_inquiry_data *ei;
  284         int i, j, error, rseg, mapsize;
bus_dma_segment_t seg;
  286         struct eata_cfg *ec;
  287         char model[16];
ec = &sc->sc_ec;
  291         /* Allocate the CCB/status packet/scratch DMA map and load */
sc->sc_nccbs = min(betoh16(*(int16_t *)ec->ec_queuedepth),
DPT_MAX_CCBS);
sc->sc_spoff = sc->sc_nccbs * sizeof(struct dpt_ccb);
sc->sc_scroff = sc->sc_spoff + sizeof(struct eata_sp);
sc->sc_scrlen = 256; /* XXX */
mapsize = sc->sc_nccbs * sizeof(struct dpt_ccb) + sc->sc_scrlen +
  298             sizeof(struct eata_sp);
  300         if ((error = bus_dmamem_alloc(sc->sc_dmat, mapsize, NBPG, 0, 
  301             &seg, 1, &rseg, BUS_DMA_NOWAIT)) != 0) {
printf("%s: unable to allocate CCBs, error = %d\n",
sc->sc_dv.dv_xname, error);
  304                 return;
  305         }
  307         if ((error = bus_dmamem_map(sc->sc_dmat, &seg, rseg, mapsize,
  308             (caddr_t *)&sc->sc_ccbs, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) != 0) {
printf("%s: unable to map CCBs, error = %d\n",
sc->sc_dv.dv_xname, error);
  311                 return;
  312         }
  314         if ((error = bus_dmamap_create(sc->sc_dmat, mapsize, mapsize, 1, 0, 
BUS_DMA_NOWAIT, &sc->sc_dmamap_ccb)) != 0) {
printf("%s: unable to create CCB DMA map, error = %d\n",
sc->sc_dv.dv_xname, error);
  318                 return;
  319         }
  321         if ((error = bus_dmamap_load(sc->sc_dmat, sc->sc_dmamap_ccb,
sc->sc_ccbs, mapsize, NULL, BUS_DMA_NOWAIT)) != 0) {
printf("%s: unable to load CCB DMA map, error = %d\n",
sc->sc_dv.dv_xname, error);
  325                 return;
  326         }
sc->sc_statpack = (struct eata_sp *)((caddr_t)sc->sc_ccbs +
sc->sc_spoff);
sc->sc_sppa = sc->sc_dmamap_ccb->dm_segs[0].ds_addr + sc->sc_spoff;
sc->sc_scr = (caddr_t)sc->sc_ccbs + sc->sc_scroff;
sc->sc_scrpa = sc->sc_dmamap_ccb->dm_segs[0].ds_addr + sc->sc_scroff;
sc->sc_statpack->sp_ccbid = -1;
  335         /* Initialize the CCBs */
TAILQ_INIT(&sc->sc_free_ccb);
i = dpt_create_ccbs(sc, sc->sc_ccbs, sc->sc_nccbs);
  339         if (i == 0) {
printf("%s: unable to create CCBs\n", sc->sc_dv.dv_xname);
  341                 return;
  342         } else if (i != sc->sc_nccbs) {
printf("%s: %d/%d CCBs created!\n", sc->sc_dv.dv_xname, i, 
sc->sc_nccbs);
sc->sc_nccbs = i;
  346         }
  348         /* Set shutdownhook before we start any device activity */
sc->sc_sdh = shutdownhook_establish(dpt_shutdown, sc);
  351         /* Get the page 0 inquiry data from the HBA */
dpt_hba_inquire(sc, &ei);
  354         /* 
  355          * dpt0 at pci0 dev 12 function 0: DPT SmartRAID III (PM3224A/9X-R)
  356          * dpt0: interrupting at irq 10
  357          * dpt0: 64 queued commands, 1 channel(s), adapter on ID(s) 7
  358          */
  359         for (i = 0; ei->ei_vendor[i] != ' ' && i < 8; i++)
  360                 ;
ei->ei_vendor[i] = '\0';
  363         for (i = 0; ei->ei_model[i] != ' ' && i < 7; i++)
model[i] = ei->ei_model[i];
  365         for (j = 0; ei->ei_suffix[j] != ' ' && j < 7; j++)
model[i++] = ei->ei_suffix[j];
model[i] = '\0';
  369         /* Find the canonical name for the board */
  370         for (i = 0; dpt_cname[i] != NULL; i += 2)
  371                 if (memcmp(ei->ei_model, dpt_cname[i], 6) == 0)
  372                         break;
printf("%s %s (%s)\n", ei->ei_vendor, dpt_cname[i + 1], model);
  376         if (intrstr != NULL)
printf("%s: interrupting at %s\n", sc->sc_dv.dv_xname, intrstr);
printf("%s: %d queued commands, %d channel(s), adapter on ID(s)", 
sc->sc_dv.dv_xname, sc->sc_nccbs, ec->ec_maxchannel + 1);
  382         for (i = 0; i <= ec->ec_maxchannel; i++)
printf(" %d", ec->ec_hba[3 - i]);
printf("\n");
  386         /* Reset the SCSI bus */
  387         if (dpt_cmd(sc, NULL, 0, CP_IMMEDIATE, CPI_BUS_RESET))
panic("%s: dpt_cmd failed", sc->sc_dv.dv_xname);
DELAY(20000);
  391         /* Fill in the adapter, each link and attach in turn */
  392 #ifdef __NetBSD__
sc->sc_adapter.scsipi_cmd = dpt_scsi_cmd;
sc->sc_adapter.scsipi_minphys = dpt_minphys;
  395 #endif /* __NetBSD__ */
  396 #ifdef __OpenBSD__
sc->sc_adapter.scsi_cmd = dpt_scsi_cmd;
sc->sc_adapter.scsi_minphys = dpt_minphys;
  399 #endif /* __OpenBSD__ */
  401         for (i = 0; i <= ec->ec_maxchannel; i++) {
  402 #ifdef __NetBSD__
  403                 struct scsipi_link *link;
  404 #endif /* __NetBSD__ */
  405 #ifdef __OpenBSD__
  406                 struct scsi_link *link;
  407 #endif /* __OpenBSD__ */
sc->sc_hbaid[i] = ec->ec_hba[3 - i];
link = &sc->sc_link[i];
  410 #ifdef __NetBSD__
link->scsipi_scsi.scsibus = i;
link->scsipi_scsi.adapter_target = sc->sc_hbaid[i];
link->scsipi_scsi.max_lun = ec->ec_maxlun;
link->scsipi_scsi.max_target = ec->ec_maxtarget;
link->type = BUS_SCSI;
  416 #endif /* __NetBSD__ */
  417 #ifdef __OpenBSD__
link->scsibus = i;
link->adapter_target = sc->sc_hbaid[i];
link->luns = ec->ec_maxlun + 1;
link->adapter_buswidth = ec->ec_maxtarget + 1;
  422 #endif /* __OpenBSD__ */
link->device = &dpt_dev;
link->adapter = &sc->sc_adapter;
link->adapter_softc = sc;
link->openings = sc->sc_nccbs;
config_found(&sc->sc_dv, link, scsiprint);
  428         }
  429 }
  431 /*
  432  * Our 'shutdownhook' to cleanly shut down the HBA. The HBA must flush 
  433  * all data from its cache and mark array groups as clean.
  434  */
  435 void
dpt_shutdown(xxx_sc)
  437         void *xxx_sc;
  438 {
  439         struct dpt_softc *sc;
sc = xxx_sc;
printf("shutting down %s...", sc->sc_dv.dv_xname);
dpt_cmd(sc, NULL, 0, CP_IMMEDIATE, CPI_POWEROFF_WARN);
DELAY(5000*1000);
printf(" done\n");
  446 }
  448 /*
  449  * Send an EATA command to the HBA.
  450  */
  451 int
dpt_cmd(sc, cp, addr, eatacmd, icmd)
  453         struct dpt_softc *sc;
  454         struct eata_cp *cp;
u_int32_t addr;
  456         int eatacmd, icmd;
  457 {
  458         int i;
  460         for (i = 20000; i; i--) {
  461                 if ((dpt_inb(sc, HA_AUX_STATUS) & HA_AUX_BUSY) == 0)
  462                         break;
DELAY(50);
  464         }
  466         /* Not the most graceful way to handle this */
  467         if (i == 0) {
printf("%s: HBA timeout on EATA command issue; aborting\n", 
sc->sc_dv.dv_xname);
  470                 return (-1);
  471         }
  473         if (cp == NULL)
addr = 0;
dpt_outb(sc, HA_DMA_BASE + 0, (u_int32_t)addr);
dpt_outb(sc, HA_DMA_BASE + 1, (u_int32_t)addr >> 8);
dpt_outb(sc, HA_DMA_BASE + 2, (u_int32_t)addr >> 16);
dpt_outb(sc, HA_DMA_BASE + 3, (u_int32_t)addr >> 24);
  481         if (eatacmd == CP_IMMEDIATE) {
  482                 if (cp == NULL) {
  483                         /* XXX should really pass meaningful values */
dpt_outb(sc, HA_ICMD_CODE2, 0);
dpt_outb(sc, HA_ICMD_CODE1, 0);
  486                 }
dpt_outb(sc, HA_ICMD, icmd);
  488         }
dpt_outb(sc, HA_COMMAND, eatacmd);
  491         return (0);
  492 }
  494 /*
  495  * Wait for the HBA to reach an arbitrary state.
  496  */
  497 int
dpt_wait(sc, mask, state, ms)
  499         struct dpt_softc *sc;
u_int8_t mask, state;
  501         int ms;
  502 {
  504         for (ms *= 10; ms; ms--) {
  505                 if ((dpt_inb(sc, HA_STATUS) & mask) == state)
  506                         return (0);
DELAY(100);
  508         }
  509         return (-1);
  510 }
  512 /*
  513  * Wait for the specified CCB to finish. This is used when we may not be
  514  * able to sleep and/or interrupts are disabled (eg autoconfiguration). 
  515  * The timeout value from the CCB is used. This should only be used for 
  516  * CCB_PRIVATE requests; otherwise the CCB will get recycled before we get 
  517  * a look at it.
  518  */
  519 int
dpt_poll(sc, ccb)
  521         struct dpt_softc *sc;
  522         struct dpt_ccb *ccb;
  523 {
  524         int i;
  526 #ifdef DEBUG
  527         if ((ccb->ccb_flg & CCB_PRIVATE) == 0)
panic("dpt_poll: called for non-CCB_PRIVATE request");
  529 #endif
  531         if ((ccb->ccb_flg & CCB_INTR) != 0)
  532                 return (0);                
  534         for (i = ccb->ccb_timeout * 20; i; i--) {
  535                 if ((dpt_inb(sc, HA_AUX_STATUS) & HA_AUX_INTR) != 0)
dpt_intr(sc);
  537                 if ((ccb->ccb_flg & CCB_INTR) != 0)
  538                         return (0);
DELAY(50);
  540         }
  541         return (-1);
  542 }
  544 /*
  545  * Read the EATA configuration from the HBA and perform some sanity checks.
  546  */
  547 int
dpt_readcfg(sc)
  549         struct dpt_softc *sc;
  550 {
  551         struct eata_cfg *ec;
  552         int i, j, stat;
u_int16_t *p;
ec = &sc->sc_ec;
  557         /* Older firmware may puke if we talk to it too soon after reset */
dpt_outb(sc, HA_COMMAND, CP_RESET);
DELAY(750000);
  561         for (i = 1000; i; i--) {
  562                 if ((dpt_inb(sc, HA_STATUS) & HA_ST_READY) != 0)
  563                         break;
DELAY(2000);
  565         }
  567         if (i == 0) {
printf("%s: HBA not ready after reset: %02x\n", 
sc->sc_dv.dv_xname, dpt_inb(sc, HA_STATUS));
  570                 return (-1);
  571         }
  573         while((((stat = dpt_inb(sc, HA_STATUS))
  574             != (HA_ST_READY|HA_ST_SEEK_COMPLETE))
  575             && (stat != (HA_ST_READY|HA_ST_SEEK_COMPLETE|HA_ST_ERROR))
  576             && (stat != (HA_ST_READY|HA_ST_SEEK_COMPLETE|HA_ST_ERROR|HA_ST_DRQ)))
  577             || (dpt_wait(sc, HA_ST_BUSY, 0, 2000))) {
  578                 /* RAID drives still spinning up? */
  579                 if((dpt_inb(sc, HA_ERROR) != 'D')
  580                     || (dpt_inb(sc, HA_ERROR + 1) != 'P')
  581                     || (dpt_inb(sc, HA_ERROR + 2) != 'T')) {
printf("%s: HBA not ready\n", sc->sc_dv.dv_xname);
  583                         return (-1);
  584                 }
  585         }
  587         /* 
  588          * Issue the read-config command and wait for the data to appear.
  589          * XXX we shouldn't be doing this with PIO, but it makes it a lot
  590          * easier as no DMA setup is required.
  591          */
dpt_outb(sc, HA_COMMAND, CP_PIO_GETCFG);
memset(ec, 0, sizeof(*ec));
i = ((int)&((struct eata_cfg *)0)->ec_cfglen + 
  595             sizeof(ec->ec_cfglen)) >> 1;
p = (u_int16_t *)ec;
  598         if (dpt_wait(sc, 0xFF, HA_ST_DATA_RDY, 2000)) {
printf("%s: cfg data didn't appear (status:%02x)\n", 
sc->sc_dv.dv_xname, dpt_inb(sc, HA_STATUS));
  601                 return (-1);
  602         }
  604         /* Begin reading */
  605         while (i--)
  606                 *p++ = dpt_inw(sc, HA_DATA);
  608         if ((i = ec->ec_cfglen) > (sizeof(struct eata_cfg)
  609             - (int)(&(((struct eata_cfg *)0L)->ec_cfglen))
  610             - sizeof(ec->ec_cfglen)))
i = sizeof(struct eata_cfg)
  612                   - (int)(&(((struct eata_cfg *)0L)->ec_cfglen))
  613                   - sizeof(ec->ec_cfglen);
j = i + (int)(&(((struct eata_cfg *)0L)->ec_cfglen)) + 
  616             sizeof(ec->ec_cfglen);
i >>= 1;
  619         while (i--)
  620                 *p++ = dpt_inw(sc, HA_DATA);
  622         /* Flush until we have read 512 bytes. */
i = (512 - j + 1) >> 1;
  624         while (i--)
dpt_inw(sc, HA_DATA);
  627         /* Defaults for older Firmware */
  628         if (p <= (u_short *)&ec->ec_hba[DPT_MAX_CHANNELS - 1])
ec->ec_hba[DPT_MAX_CHANNELS - 1] = 7;
  631         if ((dpt_inb(sc, HA_STATUS) & HA_ST_ERROR) != 0) {
printf("%s: HBA error\n", sc->sc_dv.dv_xname);
  633                 return (-1);
  634         }
  636         if (!ec->ec_hbavalid) {
printf("%s: ec_hba field invalid\n", sc->sc_dv.dv_xname);
  638                 return (-1);
  639         }
  641         if (memcmp(ec->ec_eatasig, "EATA", 4) != 0) {
printf("%s: EATA signature mismatch\n", sc->sc_dv.dv_xname);
  643                 return (-1);
  644         }
  646         if (!ec->ec_dmasupported) {
printf("%s: DMA not supported\n", sc->sc_dv.dv_xname);
  648                 return (-1);
  649         }
  651         return (0);
  652 }
  654 /*
  655  * Adjust the size of each I/O before it passes to the SCSI layer.
  656  */
  657 void
dpt_minphys(bp)
  659         struct buf *bp;
  660 {
  662         if (bp->b_bcount > DPT_MAX_XFER)
bp->b_bcount = DPT_MAX_XFER;
minphys(bp);
  665 }
  667 /*
  668  * Put a CCB onto the freelist.
  669  */
  670 void
dpt_free_ccb(sc, ccb)
  672         struct dpt_softc *sc;
  673         struct dpt_ccb *ccb;
  674 {
  675         int s;
s = splbio();
ccb->ccb_flg = 0;
TAILQ_INSERT_HEAD(&sc->sc_free_ccb, ccb, ccb_chain);
  681         /* Wake anybody waiting for a free ccb */
  682         if (TAILQ_NEXT(ccb, ccb_chain) == NULL)
wakeup(&sc->sc_free_ccb);
splx(s);
  685 }
  687 /*
  688  * Initialize the specified CCB.
  689  */
  690 int
dpt_init_ccb(sc, ccb)
  692         struct dpt_softc *sc;
  693         struct dpt_ccb *ccb;
  694 {
  695         int error;
  697         /* Create the DMA map for this CCB's data */
error = bus_dmamap_create(sc->sc_dmat, DPT_MAX_XFER, DPT_SG_SIZE, 
DPT_MAX_XFER, 0, BUS_DMA_NOWAIT | BUS_DMA_ALLOCNOW,
  700             &ccb->ccb_dmamap_xfer);
  702         if (error) {
printf("%s: can't create ccb dmamap (%d)\n", 
sc->sc_dv.dv_xname, error);
  705                 return (error);
  706         }
ccb->ccb_flg = 0;
ccb->ccb_ccbpa = sc->sc_dmamap_ccb->dm_segs[0].ds_addr +
CCB_OFF(sc, ccb);
  711         return (0);
  712 }
  714 /*
  715  * Create a set of CCBs and add them to the free list.
  716  */
  717 int
dpt_create_ccbs(sc, ccbstore, count)
  719         struct dpt_softc *sc;
  720         struct dpt_ccb *ccbstore;
  721         int count;
  722 {
  723         struct dpt_ccb *ccb;
  724         int i, error;
memset(ccbstore, 0, sizeof(struct dpt_ccb) * count);
  728         for (i = 0, ccb = ccbstore; i < count; i++, ccb++) {
  729                 if ((error = dpt_init_ccb(sc, ccb)) != 0) {
printf("%s: unable to init ccb, error = %d\n",
sc->sc_dv.dv_xname, error);
  732                         break;
  733                 }
ccb->ccb_id = i;
TAILQ_INSERT_TAIL(&sc->sc_free_ccb, ccb, ccb_chain);
  736         }
  738         return (i);
  739 }
  741 /*
  742  * Get a free ccb. If there are none, see if we can allocate a new one. If 
  743  * none are available right now and we are permitted to sleep, then wait 
  744  * until one becomes free, otherwise return an error.
  745  */
  746 struct dpt_ccb *
dpt_alloc_ccb(sc, flg)
  748         struct dpt_softc *sc;
  749         int flg;
  750 {
  751         struct dpt_ccb *ccb;
  752         int s;
s = splbio();
  756         for (;;) {
ccb = TAILQ_FIRST(&sc->sc_free_ccb);
  758                 if (ccb) {
TAILQ_REMOVE(&sc->sc_free_ccb, ccb, ccb_chain);
  760                         break;
  761                 }
  762 #ifdef __NetBSD__
  763                 if ((flg & XS_CTL_NOSLEEP) != 0) {
  764 #endif /* __NetBSD__ */
  765 #ifdef __OpenBSD__
  766                 if ((flg & SCSI_NOSLEEP) != 0) {
  767 #endif /* __OpenBSD__ */
splx(s);
  769                         return (NULL);
  770                 }
tsleep(&sc->sc_free_ccb, PRIBIO, "dptccb", 0);
  772         }
ccb->ccb_flg |= CCB_ALLOC;
splx(s);
  776         return (ccb);
  777 }
  779 /*
  780  * We have a CCB which has been processed by the HBA, now we look to see how 
  781  * the operation went. CCBs marked with CCB_PRIVATE are not automatically
  782  * passed here by dpt_intr().
  783  */
  784 void
dpt_done_ccb(sc, ccb)
  786         struct dpt_softc *sc;
  787         struct dpt_ccb *ccb;
  788 {
  789 #ifdef __NetBSD__
  790         struct scsipi_sense_data *s1, *s2;
  791         struct scsipi_xfer *xs;
  792 #endif /* __NetBSD__ */
  793 #ifdef __OpenBSD__
  794         struct scsi_sense_data *s1, *s2;
  795         struct scsi_xfer *xs;
  796 #endif /* __OpenBSD__ */
bus_dma_tag_t dmat;
dmat = sc->sc_dmat;
xs = ccb->ccb_xs;
SC_DEBUG(xs->sc_link, SDEV_DB2, ("dpt_done_ccb\n"));
  804         /*
  805          * If we were a data transfer, unload the map that described the 
  806          * data buffer.
  807          */
  808         if (xs->datalen) {
bus_dmamap_sync(dmat, ccb->ccb_dmamap_xfer, 0,
ccb->ccb_dmamap_xfer->dm_mapsize,
  811                     (xs->flags & SCSI_DATA_IN) ? BUS_DMASYNC_POSTREAD :
BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(dmat, ccb->ccb_dmamap_xfer);
  814         }
  816         /*
  817          * Otherwise, put the results of the operation into the xfer and 
  818          * call whoever started it.
  819          */
  820 #ifdef DIAGNOSTIC
  821         if ((ccb->ccb_flg & CCB_ALLOC) == 0) {
panic("%s: done ccb not allocated!", sc->sc_dv.dv_xname);
  823                 return;
  824         }
  825 #endif
  827         if (xs->error == XS_NOERROR) {
  828                 if (ccb->ccb_hba_status != HA_NO_ERROR) {
  829                         switch (ccb->ccb_hba_status) {
  830                         case HA_ERROR_SEL_TO:
xs->error = XS_SELTIMEOUT;
  832                                 break;
  833                         case HA_ERROR_RESET:
xs->error = XS_RESET;
  835                                 break;
  836                         default:        /* Other scsi protocol messes */
printf("%s: HBA status %x\n",
sc->sc_dv.dv_xname, ccb->ccb_hba_status);
xs->error = XS_DRIVER_STUFFUP;
  840                         }
  841                 } else if (ccb->ccb_scsi_status != SCSI_OK) {
  842                         switch (ccb->ccb_scsi_status) {
  843                         case SCSI_CHECK:
s1 = &ccb->ccb_sense;
  845 #ifdef __NetBSD__
s2 = &xs->sense.scsi_sense;
  847 #endif /* __NetBSD__ */
  848 #ifdef __OpenBSD__
s2 = &xs->sense;
  850 #endif /* __OpenBSD__ */
  851                                 *s2 = *s1;
xs->error = XS_SENSE;
  853                                 break;
  854                         case SCSI_BUSY:
xs->error = XS_BUSY;
  856                                 break;
  857                         default:
printf("%s: SCSI status %x\n",
sc->sc_dv.dv_xname, ccb->ccb_scsi_status);
xs->error = XS_DRIVER_STUFFUP;
  861                         }
  862                 } else
xs->resid = 0;
xs->status = ccb->ccb_scsi_status;
  866         }
  868         /* Free up the CCB and mark the command as done */
dpt_free_ccb(sc, ccb);
  870 #ifdef __NetBSD__
xs->xs_status |= XS_STS_DONE;
scsipi_done(xs);
  873 #endif /* __NetBSD__ */
  874 #ifdef __OpenBSD__
xs->flags |= ITSDONE;
scsi_done(xs);
  877 #endif /* __OpenBSD__ */
  879         /*
  880          * If there are entries in the software queue, try to run the first
  881          * one. We should be more or less guaranteed to succeed, since we
  882          * just freed an CCB. NOTE: dpt_scsi_cmd() relies on our calling it
  883          * with the first entry in the queue.
  884          */
  885 #ifdef __NetBSD__
  886         if ((xs = TAILQ_FIRST(&sc->sc_queue)) != NULL)
  887 #endif /* __NetBSD__ */
  888 #ifdef __OpenBSD__
  889         if ((xs = LIST_FIRST(&sc->sc_queue)) != NULL)
  890 #endif /* __OpenBSD__ */
dpt_scsi_cmd(xs);
  892 }
  894 #ifdef __OpenBSD__
  895 /*
  896  * Insert a scsi_xfer into the software queue.  We overload xs->free_list
  897  * to avoid having to allocate additional resources (since we're used
  898  * only during resource shortages anyhow.
  899  */
  900 static void
dpt_enqueue(sc, xs, infront)
  902         struct dpt_softc *sc;
  903         struct scsi_xfer *xs;
  904         int             infront;
  905 {
  907         if (infront || LIST_EMPTY(&sc->sc_queue)) {
  908                 if (LIST_EMPTY(&sc->sc_queue))
sc->sc_queuelast = xs;
LIST_INSERT_HEAD(&sc->sc_queue, xs, free_list);
  911                 return;
  912         }
LIST_INSERT_AFTER(sc->sc_queuelast, xs, free_list);
sc->sc_queuelast = xs;
  915 }
  917 /*
  918  * Pull a scsi_xfer off the front of the software queue.
  919  */
  920 static struct scsi_xfer *
dpt_dequeue(sc)
  922         struct dpt_softc *sc;
  923 {
  924         struct scsi_xfer *xs;
xs = LIST_FIRST(&sc->sc_queue);
LIST_REMOVE(xs, free_list);
  929         if (LIST_EMPTY(&sc->sc_queue))
sc->sc_queuelast = NULL;
  932         return (xs);
  933 }
  934 #endif /* __OpenBSD__ */
  936 /*
  937  * Start a SCSI command.
  938  */
  939 int
dpt_scsi_cmd(xs)
  941 #ifdef __NetBSD__
  942         struct scsipi_xfer *xs;
  943 #endif /* __NetBSD__ */
  944 #ifdef __OpenBSD__
  945         struct scsi_xfer *xs;
  946 #endif /* __OpenBSD__ */
  947 {
  948         int error, i, flags, s, fromqueue, dontqueue;
  949 #ifdef __NetBSD__
  950         struct scsipi_link *sc_link;
  951 #endif /* __NetBSD__ */
  952 #ifdef __OpenBSD__
  953         struct scsi_link *sc_link;
  954 #endif /* __OpenBSD__ */
  955         struct dpt_softc *sc;
  956         struct dpt_ccb *ccb;
  957         struct eata_sg *sg;
  958         struct eata_cp *cp;
bus_dma_tag_t dmat;
bus_dmamap_t xfer;
sc_link = xs->sc_link;
  963 #ifdef __NetBSD__
flags = xs->xs_control;
  965 #endif /* __NetBSD__ */
  966 #ifdef __OpenBSD__
flags = xs->flags;
  968 #endif /* __OpenBSD__ */
sc = sc_link->adapter_softc;
dmat = sc->sc_dmat;
fromqueue = 0;
dontqueue = 0;
SC_DEBUG(sc_link, SDEV_DB2, ("dpt_scsi_cmd\n"));
  976         /* Protect the queue */
s = splbio();
  979         /*
  980          * If we're running the queue from dpt_done_ccb(), we've been called 
  981          * with the first queue entry as our argument.
  982          */
  983 #ifdef __NetBSD__
  984         if (xs == TAILQ_FIRST(&sc->sc_queue)) {
TAILQ_REMOVE(&sc->sc_queue, xs, adapter_q);
  986 #endif /* __NetBSD__ */
  987 #ifdef __OpenBSD__
  988         if (xs == LIST_FIRST(&sc->sc_queue)) {
xs = dpt_dequeue(sc);
  990 #endif /* __OpenBSD__ */
fromqueue = 1;
  992         } else {
  993                 /* Cmds must be no more than 12 bytes for us */
  994                 if (xs->cmdlen > 12) {
splx(s);
xs->error = XS_DRIVER_STUFFUP;
  997                         return (COMPLETE);
  998                 }
 1000                 /* XXX we can't reset devices just yet */
 1001 #ifdef __NetBSD__
 1002                 if ((flags & XS_CTL_RESET) != 0) {
 1003 #endif /* __NetBSD__ */
 1004 #ifdef __OpenBSD__
 1005                 if ((xs->flags & SCSI_RESET) != 0) {
 1006 #endif /* __OpenBSD__ */
splx(s);
xs->error = XS_DRIVER_STUFFUP;
 1009                         return (COMPLETE);
 1010                 }
 1012                 /* Polled requests can't be queued for later */
 1013 #ifdef __NetBSD__
dontqueue = flags & XS_CTL_POLL;
 1015 #endif /* __NetBSD__ */
 1016 #ifdef __OpenBSD__
dontqueue = xs->flags & SCSI_POLL;
 1018 #endif /* __OpenBSD__ */
 1020                 /* If there are jobs in the queue, run them first */
 1021 #ifdef __NetBSD__
 1022                 if (TAILQ_FIRST(&sc->sc_queue) != NULL) {
 1023 #endif /* __NetBSD__ */
 1024 #ifdef __OpenBSD__
 1025                 if (!LIST_EMPTY(&sc->sc_queue)) {
 1026 #endif /* __OpenBSD__ */
 1027                         /*
 1028                          * If we can't queue we abort, since we must 
 1029                          * preserve the queue order.
 1030                          */
 1031                         if (dontqueue) {
splx(s);
 1033                                 return (TRY_AGAIN_LATER);
 1034                         }
 1036                         /* Swap with the first queue entry. */
 1037 #ifdef __NetBSD__
TAILQ_INSERT_TAIL(&sc->sc_queue, xs, adapter_q);
xs = TAILQ_FIRST(&sc->sc_queue);
TAILQ_REMOVE(&sc->sc_queue, xs, adapter_q);
 1041 #endif /* __NetBSD__ */
 1042 #ifdef __OpenBSD__
dpt_enqueue(sc, xs, 0);
xs = dpt_dequeue(sc);
 1045 #endif /* __OpenBSD__ */
fromqueue = 1;
 1047                 }
 1048         }
 1050         /* Get a CCB */
 1051 #ifdef __NetBSD__
 1052         if ((ccb = dpt_alloc_ccb(sc, flags)) == NULL) {
 1053 #endif /* __NetBSD__ */
 1054 #ifdef __OpenBSD__
 1055         if ((ccb = dpt_alloc_ccb(sc, xs->flags)) == NULL) {
 1056 #endif /* __OpenBSD__ */
 1057                 /* If we can't queue, we lose */
 1058                 if (dontqueue) {
splx(s);
 1060                         return (TRY_AGAIN_LATER);
 1061                 }
 1063                 /* 
 1064                  * Stuff request into the queue, in front if we came off 
 1065                  * it in the first place.
 1066                  */
 1067 #ifdef __NetBSD__
 1068                 if (fromqueue)
TAILQ_INSERT_HEAD(&sc->sc_queue, xs, adapter_q);
 1070                 else
TAILQ_INSERT_TAIL(&sc->sc_queue, xs, adapter_q);
 1072 #endif /* __NetBSD__ */
 1073 #ifdef __OpenBSD__
dpt_enqueue(sc, xs, fromqueue);
 1075 #endif /* __OpenBSD__ */
splx(s);
 1077                 return (SUCCESSFULLY_QUEUED);
 1078         }
splx(s);
ccb->ccb_xs = xs;
ccb->ccb_timeout = xs->timeout;
cp = &ccb->ccb_eata_cp;
 1086 #ifdef __NetBSD__
memcpy(&cp->cp_scsi_cmd, xs->cmd, xs->cmdlen);
 1088 #endif /* __NetBSD__ */
 1089 #ifdef __OpenBSD__
bcopy(xs->cmd, &cp->cp_scsi_cmd, xs->cmdlen);
 1091 #endif /* __OpenBSD__ */
cp->cp_ccbid = ccb->ccb_id;
 1093 #ifdef __NetBSD__
cp->cp_id = sc_link->scsipi_scsi.target;
cp->cp_lun = sc_link->scsipi_scsi.lun;
cp->cp_channel = sc_link->scsipi_scsi.channel;
 1097 #endif /* __NetBSD__ */
 1098 #ifdef __OpenBSD__
cp->cp_id = sc_link->target;
cp->cp_lun = sc_link->lun;
cp->cp_channel = sc_link->scsibus;
 1102 #endif /* __OpenBSD__ */
cp->cp_senselen = sizeof(ccb->ccb_sense);
cp->cp_stataddr = htobe32(sc->sc_sppa);
cp->cp_dispri = 1;
cp->cp_identify = 1;
cp->cp_autosense = 1;
 1108 #ifdef __NetBSD__
cp->cp_datain = ((flags & XS_CTL_DATA_IN) != 0);
cp->cp_dataout = ((flags & XS_CTL_DATA_OUT) != 0);
cp->cp_interpret = (sc->sc_hbaid[sc_link->scsipi_scsi.channel] ==
sc_link->scsipi_scsi.target);
 1113 #endif /* __NetBSD__ */
 1114 #ifdef __OpenBSD__
cp->cp_datain = ((xs->flags & SCSI_DATA_IN) != 0);
cp->cp_dataout = ((xs->flags & SCSI_DATA_OUT) != 0);
cp->cp_interpret = (sc->sc_hbaid[sc_link->scsibus] == sc_link->target);
 1118 #endif /* __OpenBSD__ */
 1120         /* Synchronous xfers musn't write-back through the cache */
 1121         if (xs->bp != NULL && (xs->bp->b_flags & (B_ASYNC | B_READ)) == 0)
cp->cp_nocache = 1;
 1123         else
cp->cp_nocache = 0;
cp->cp_senseaddr = htobe32(sc->sc_dmamap_ccb->dm_segs[0].ds_addr +
CCB_OFF(sc, ccb) + offsetof(struct dpt_ccb, ccb_sense));
 1129         if (xs->datalen) {
xfer = ccb->ccb_dmamap_xfer;
 1131 #ifdef  TFS
 1132 #ifdef __NetBSD__
 1133                 if ((flags & XS_CTL_DATA_UIO) != 0) {
error = bus_dmamap_load_uio(dmat, xfer, 
 1135                             (struct uio *)xs->data, (flags & XS_CTL_NOSLEEP) ? 
BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
 1137 #endif /* __NetBSD__ */
 1138 #ifdef __OpenBSD__
 1139                 if ((xs->flags & SCSI_DATA_UIO) != 0) {
error = bus_dmamap_load_uio(dmat, xfer, 
 1141                             (xs->flags & SCSI_NOSLEEP) ?
BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
 1143 #endif /* __OpenBSD__ */
 1144                 } else
 1145 #endif /*TFS */
 1146                 {
 1147 #ifdef __NetBSD__
error = bus_dmamap_load(dmat, xfer, xs->data, 
xs->datalen, NULL, (flags & XS_CTL_NOSLEEP) ? 
BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
 1151 #endif /* __NetBSD__ */
 1152 #ifdef __OpenBSD__
error = bus_dmamap_load(dmat, xfer, xs->data, 
xs->datalen, NULL, (xs->flags & SCSI_NOSLEEP) ? 
BUS_DMA_NOWAIT : BUS_DMA_WAITOK);
 1156 #endif /* __OpenBSD__ */
 1157                 }
 1159                 if (error) {
printf("%s: dpt_scsi_cmd: ", sc->sc_dv.dv_xname); 
 1161                         if (error == EFBIG)
printf("more than %d dma segs\n", DPT_SG_SIZE);
 1163                         else
printf("error %d loading dma map\n", error);
xs->error = XS_DRIVER_STUFFUP;
dpt_free_ccb(sc, ccb);
 1168                         return (COMPLETE);
 1169                 }
bus_dmamap_sync(dmat, xfer, 0, xfer->dm_mapsize,
 1172                     (flags & SCSI_DATA_IN) ? BUS_DMASYNC_PREREAD :
BUS_DMASYNC_PREWRITE);
 1175                 /* Don't bother using scatter/gather for just 1 segment */
 1176                 if (xfer->dm_nsegs == 1) {
cp->cp_dataaddr = htobe32(xfer->dm_segs[0].ds_addr);
cp->cp_datalen = htobe32(xfer->dm_segs[0].ds_len);
cp->cp_scatter = 0;
 1180                 } else {
 1181                         /*
 1182                          * Load the hardware scatter/gather map with the
 1183                          * contents of the DMA map.
 1184                          */
sg = ccb->ccb_sg;
 1186                         for (i = 0; i < xfer->dm_nsegs; i++, sg++) {
sg->sg_addr =
htobe32(xfer->dm_segs[i].ds_addr);
sg->sg_len =
htobe32(xfer->dm_segs[i].ds_len);
 1191                         }
cp->cp_dataaddr = htobe32(CCB_OFF(sc, ccb) + 
sc->sc_dmamap_ccb->dm_segs[0].ds_addr +
offsetof(struct dpt_ccb, ccb_sg));
cp->cp_datalen = htobe32(i * sizeof(struct eata_sg));
cp->cp_scatter = 1;
 1197                 }
 1198         } else {
cp->cp_dataaddr = 0;
cp->cp_datalen = 0;
cp->cp_scatter = 0;
 1202         }
 1204         /* Sync up CCB and status packet */
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_ccb, CCB_OFF(sc, ccb), 
 1206             sizeof(struct dpt_ccb), BUS_DMASYNC_PREWRITE);
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_ccb, sc->sc_spoff, 
 1208             sizeof(struct eata_sp), BUS_DMASYNC_PREREAD);
 1210         /* 
 1211          * Start the command. If we are polling on completion, mark it
 1212          * private so that dpt_intr/dpt_done_ccb don't recycle the CCB 
 1213          * without us noticing.
 1214          */
 1215         if (dontqueue != 0)
ccb->ccb_flg |= CCB_PRIVATE; 
 1218         if (dpt_cmd(sc, &ccb->ccb_eata_cp, ccb->ccb_ccbpa, CP_DMA_CMD, 0)) {
printf("%s: dpt_cmd failed\n", sc->sc_dv.dv_xname);
dpt_free_ccb(sc, ccb);
 1221                 return (TRY_AGAIN_LATER);
 1222         }
 1224         if (dontqueue == 0)
 1225                 return (SUCCESSFULLY_QUEUED);
 1227         /* Don't wait longer than this single command wants to wait */
 1228         if (dpt_poll(sc, ccb)) {
dpt_timeout(ccb);
 1230                 /* Wait for abort to complete */
 1231                 if (dpt_poll(sc, ccb))
dpt_timeout(ccb);
 1233         } 
dpt_done_ccb(sc, ccb);
 1236         return (COMPLETE);
 1237 }
 1239 /*
 1240  * Specified CCB has timed out, abort it.
 1241  */
 1242 void
dpt_timeout(arg)
 1244         void *arg;
 1245 {
 1246 #ifdef __NetBSD__
 1247         struct scsipi_link *sc_link;
 1248         struct scsipi_xfer *xs;
 1249 #endif /* __NetBSD__ */
 1250 #ifdef __OpenBSD__
 1251         struct scsi_link *sc_link;
 1252         struct scsi_xfer *xs;
 1253 #endif /* __OpenBSD__ */
 1254         struct dpt_softc *sc;
 1255         struct dpt_ccb *ccb;
 1256         int s;
ccb = arg;
xs = ccb->ccb_xs;
sc_link = xs->sc_link;
sc  = sc_link->adapter_softc;
 1263 #ifdef __NetBSD__
scsi_print_addr(sc_link);
 1265 #endif /* __NetBSD__ */
 1266 #ifdef __OpenBSD__
sc_print_addr(sc_link);
 1268 #endif /* __OpenBSD__ */
printf("timed out (status:%02x aux status:%02x)", 
dpt_inb(sc, HA_STATUS), dpt_inb(sc, HA_AUX_STATUS));
s = splbio();
 1274         if ((ccb->ccb_flg & CCB_ABORT) != 0) {
 1275                 /* Abort timed out, reset the HBA */
printf(" AGAIN, resetting HBA\n");
dpt_outb(sc, HA_COMMAND, CP_RESET);
DELAY(750000);
 1279         } else {
 1280                 /* Abort the operation that has timed out */
printf("\n");
ccb->ccb_xs->error = XS_TIMEOUT;
ccb->ccb_timeout = DPT_ABORT_TIMEOUT;
ccb->ccb_flg |= CCB_ABORT;
 1285                 /* Start the abort */
 1286                 if (dpt_cmd(sc, &ccb->ccb_eata_cp, ccb->ccb_ccbpa, 
CP_IMMEDIATE, CPI_SPEC_ABORT))
printf("%s: dpt_cmd failed\n", sc->sc_dv.dv_xname);
 1289         }
splx(s);
 1292 }
 1294 #ifdef DEBUG
 1295 /*
 1296  * Dump the contents of an EATA status packet.
 1297  */
 1298 void
dpt_dump_sp(sp)
 1300         struct eata_sp *sp;
 1301 {
 1302         int i;
printf("\thba_status\t%02x\n", sp->sp_hba_status);
printf("\tscsi_status\t%02x\n", sp->sp_scsi_status);    
printf("\tinv_residue\t%d\n", sp->sp_inv_residue);      
printf("\tccbid\t\t%d\n", sp->sp_ccbid);
printf("\tid_message\t%d\n", sp->sp_id_message);
printf("\tque_message\t%d\n", sp->sp_que_message);      
printf("\ttag_message\t%d\n", sp->sp_tag_message);
printf("\tmessages\t");
 1313         for (i = 0; i < 9; i++)
printf("%d ", sp->sp_messages[i]);
printf("\n");
 1317 }
 1318 #endif  /* DEBUG */
 1320 /*
 1321  * Get inquiry data from the adapter.
 1322  */
 1323 void
dpt_hba_inquire(sc, ei)
 1325         struct dpt_softc *sc;
 1326         struct eata_inquiry_data **ei;
 1327 {
 1328         struct dpt_ccb *ccb;
 1329         struct eata_cp *cp;
bus_dma_tag_t dmat;
 1332         *ei = (struct eata_inquiry_data *)sc->sc_scr;
dmat = sc->sc_dmat;
 1335         /* Get a CCB and mark as private */
 1336         if ((ccb = dpt_alloc_ccb(sc, 0)) == NULL)
panic("%s: no CCB for inquiry", sc->sc_dv.dv_xname);
ccb->ccb_flg |= CCB_PRIVATE;
ccb->ccb_timeout = 200;
 1342         /* Put all the arguments into the CCB */
cp = &ccb->ccb_eata_cp;
cp->cp_ccbid = ccb->ccb_id;
cp->cp_id = sc->sc_hbaid[0];
cp->cp_lun = 0;
cp->cp_channel = 0;
cp->cp_senselen = sizeof(ccb->ccb_sense);
cp->cp_stataddr = htobe32(sc->sc_sppa);
cp->cp_dispri = 1;
cp->cp_identify = 1;
cp->cp_autosense = 0;
cp->cp_interpret = 1;
cp->cp_nocache = 0;
cp->cp_datain = 1;
cp->cp_dataout = 0;
cp->cp_senseaddr = 0;
cp->cp_dataaddr = htobe32(sc->sc_scrpa);
cp->cp_datalen = htobe32(sizeof(struct eata_inquiry_data));
cp->cp_scatter = 0;
 1362         /* Put together the SCSI inquiry command */
memset(&cp->cp_scsi_cmd, 0, 12);        /* XXX */
cp->cp_scsi_cmd = INQUIRY;
cp->cp_len = sizeof(struct eata_inquiry_data);
 1367         /* Sync up CCB, status packet and scratch area */
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_ccb, CCB_OFF(sc, ccb), 
 1369             sizeof(struct dpt_ccb), BUS_DMASYNC_PREWRITE);
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_ccb, sc->sc_spoff, 
 1371             sizeof(struct eata_sp), BUS_DMASYNC_PREREAD);
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_ccb, sc->sc_scroff, 
 1373             sizeof(struct eata_inquiry_data), BUS_DMASYNC_PREREAD);
 1375         /* Start the command and poll on completion */
 1376         if (dpt_cmd(sc, &ccb->ccb_eata_cp, ccb->ccb_ccbpa, CP_DMA_CMD, 0))
panic("%s: dpt_cmd failed", sc->sc_dv.dv_xname);
 1379         if (dpt_poll(sc, ccb))
panic("%s: inquiry timed out", sc->sc_dv.dv_xname);
 1382         if (ccb->ccb_hba_status != HA_NO_ERROR ||
ccb->ccb_scsi_status != SCSI_OK)
panic("%s: inquiry failed (hba:%02x scsi:%02x", 
sc->sc_dv.dv_xname, ccb->ccb_hba_status,
ccb->ccb_scsi_status);
 1388         /* Sync up the DMA map and free CCB, returning */
bus_dmamap_sync(sc->sc_dmat, sc->sc_dmamap_ccb, sc->sc_scroff, 
 1390             sizeof(struct eata_inquiry_data), BUS_DMASYNC_POSTREAD);
dpt_free_ccb(sc, ccb);
 1392 }