sys/dev/disk/isp/isp_pci.c

   1 /* $FreeBSD: src/sys/dev/isp/isp_pci.c,v 1.78.2.4 2002/10/11 18:50:53 mjacob Exp $ */
   2 /* $DragonFly: src/sys/dev/disk/isp/isp_pci.c,v 1.13 2008/01/06 16:55:49 swildner Exp $ */
   3 /*
   4  * PCI specific probe and attach routines for Qlogic ISP SCSI adapters.
   5  * FreeBSD Version.
   6  *
   7  * Copyright (c) 1997, 1998, 1999, 2000, 2001 by Matthew Jacob
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice immediately at the beginning of the file, without modification,
  14  *    this list of conditions, and the following disclaimer.
  15  * 2. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  22  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  */
  30
  31 #include <sys/param.h>
  32 #include <sys/systm.h>
  33 #include <sys/kernel.h>
  34 #include <sys/module.h>
  35 #include <sys/bus.h>
  36 #include <sys/rman.h>
  37 #include <sys/malloc.h>
  38
  39 #include <bus/pci/pcireg.h>
  40 #include <bus/pci/pcivar.h>
  41
  42 #include "isp_freebsd.h"
  43
  44 static u_int16_t isp_pci_rd_reg(struct ispsoftc *, int);
  45 static void isp_pci_wr_reg(struct ispsoftc *, int, u_int16_t);
  46 static u_int16_t isp_pci_rd_reg_1080(struct ispsoftc *, int);
  47 static void isp_pci_wr_reg_1080(struct ispsoftc *, int, u_int16_t);
  48 static int
  49 isp_pci_rd_isr(struct ispsoftc *, u_int16_t *, u_int16_t *, u_int16_t *);
  50 static int
  51 isp_pci_rd_isr_2300(struct ispsoftc *, u_int16_t *, u_int16_t *, u_int16_t *);
  52 static int isp_pci_mbxdma(struct ispsoftc *);
  53 static int
  54 isp_pci_dmasetup(struct ispsoftc *, XS_T *, ispreq_t *, u_int16_t *, u_int16_t);
  55 static void
  56 isp_pci_dmateardown(struct ispsoftc *, XS_T *, u_int16_t);
  57
  58 static void isp_pci_reset1(struct ispsoftc *);
  59 static void isp_pci_dumpregs(struct ispsoftc *, const char *);
  60
  61 static struct ispmdvec mdvec = {
  62         isp_pci_rd_isr,
  63         isp_pci_rd_reg,
  64         isp_pci_wr_reg,
  65         isp_pci_mbxdma,
  66         isp_pci_dmasetup,
  67         isp_pci_dmateardown,
  68         NULL,
  69         isp_pci_reset1,
  70         isp_pci_dumpregs,
  71         NULL,
  72         BIU_BURST_ENABLE|BIU_PCI_CONF1_FIFO_64
  73 };
  74
  75 static struct ispmdvec mdvec_1080 = {
  76         isp_pci_rd_isr,
  77         isp_pci_rd_reg_1080,
  78         isp_pci_wr_reg_1080,
  79         isp_pci_mbxdma,
  80         isp_pci_dmasetup,
  81         isp_pci_dmateardown,
  82         NULL,
  83         isp_pci_reset1,
  84         isp_pci_dumpregs,
  85         NULL,
  86         BIU_BURST_ENABLE|BIU_PCI_CONF1_FIFO_64
  87 };
  88
  89 static struct ispmdvec mdvec_12160 = {
  90         isp_pci_rd_isr,
  91         isp_pci_rd_reg_1080,
  92         isp_pci_wr_reg_1080,
  93         isp_pci_mbxdma,
  94         isp_pci_dmasetup,
  95         isp_pci_dmateardown,
  96         NULL,
  97         isp_pci_reset1,
  98         isp_pci_dumpregs,
  99         NULL,
 100         BIU_BURST_ENABLE|BIU_PCI_CONF1_FIFO_64
 101 };
 102
 103 static struct ispmdvec mdvec_2100 = {
 104         isp_pci_rd_isr,
 105         isp_pci_rd_reg,
 106         isp_pci_wr_reg,
 107         isp_pci_mbxdma,
 108         isp_pci_dmasetup,
 109         isp_pci_dmateardown,
 110         NULL,
 111         isp_pci_reset1,
 112         isp_pci_dumpregs
 113 };
 114
 115 static struct ispmdvec mdvec_2200 = {
 116         isp_pci_rd_isr,
 117         isp_pci_rd_reg,
 118         isp_pci_wr_reg,
 119         isp_pci_mbxdma,
 120         isp_pci_dmasetup,
 121         isp_pci_dmateardown,
 122         NULL,
 123         isp_pci_reset1,
 124         isp_pci_dumpregs
 125 };
 126
 127 static struct ispmdvec mdvec_2300 = {
 128         isp_pci_rd_isr_2300,
 129         isp_pci_rd_reg,
 130         isp_pci_wr_reg,
 131         isp_pci_mbxdma,
 132         isp_pci_dmasetup,
 133         isp_pci_dmateardown,
 134         NULL,
 135         isp_pci_reset1,
 136         isp_pci_dumpregs
 137 };
 138
 139 #ifndef PCIM_CMD_INVEN
 140 #define PCIM_CMD_INVEN                  0x10
 141 #endif
 142 #ifndef PCIM_CMD_BUSMASTEREN
 143 #define PCIM_CMD_BUSMASTEREN            0x0004
 144 #endif
 145 #ifndef PCIM_CMD_PERRESPEN
 146 #define PCIM_CMD_PERRESPEN              0x0040
 147 #endif
 148 #ifndef PCIM_CMD_SEREN
 149 #define PCIM_CMD_SEREN                  0x0100
 150 #endif
 151
 152 #ifndef PCIR_COMMAND
 153 #define PCIR_COMMAND                    0x04
 154 #endif
 155
 156 #ifndef PCIR_CACHELNSZ
 157 #define PCIR_CACHELNSZ                  0x0c
 158 #endif
 159
 160 #ifndef PCIR_LATTIMER
 161 #define PCIR_LATTIMER                   0x0d
 162 #endif
 163
 164 #ifndef PCIR_ROMADDR
 165 #define PCIR_ROMADDR                    0x30
 166 #endif
 167
 168 #ifndef PCI_VENDOR_QLOGIC
 169 #define PCI_VENDOR_QLOGIC               0x1077
 170 #endif
 171
 172 #ifndef PCI_PRODUCT_QLOGIC_ISP1020
 173 #define PCI_PRODUCT_QLOGIC_ISP1020      0x1020
 174 #endif
 175
 176 #ifndef PCI_PRODUCT_QLOGIC_ISP1080
 177 #define PCI_PRODUCT_QLOGIC_ISP1080      0x1080
 178 #endif
 179
 180 #ifndef PCI_PRODUCT_QLOGIC_ISP10160
 181 #define PCI_PRODUCT_QLOGIC_ISP10160     0x1016
 182 #endif
 183
 184 #ifndef PCI_PRODUCT_QLOGIC_ISP12160
 185 #define PCI_PRODUCT_QLOGIC_ISP12160     0x1216
 186 #endif
 187
 188 #ifndef PCI_PRODUCT_QLOGIC_ISP1240
 189 #define PCI_PRODUCT_QLOGIC_ISP1240      0x1240
 190 #endif
 191
 192 #ifndef PCI_PRODUCT_QLOGIC_ISP1280
 193 #define PCI_PRODUCT_QLOGIC_ISP1280      0x1280
 194 #endif
 195
 196 #ifndef PCI_PRODUCT_QLOGIC_ISP2100
 197 #define PCI_PRODUCT_QLOGIC_ISP2100      0x2100
 198 #endif
 199
 200 #ifndef PCI_PRODUCT_QLOGIC_ISP2200
 201 #define PCI_PRODUCT_QLOGIC_ISP2200      0x2200
 202 #endif
 203
 204 #ifndef PCI_PRODUCT_QLOGIC_ISP2300
 205 #define PCI_PRODUCT_QLOGIC_ISP2300      0x2300
 206 #endif
 207
 208 #ifndef PCI_PRODUCT_QLOGIC_ISP2312
 209 #define PCI_PRODUCT_QLOGIC_ISP2312      0x2312
 210 #endif
 211
 212 #define PCI_QLOGIC_ISP1020      \
 213         ((PCI_PRODUCT_QLOGIC_ISP1020 << 16) | PCI_VENDOR_QLOGIC)
 214
 215 #define PCI_QLOGIC_ISP1080      \
 216         ((PCI_PRODUCT_QLOGIC_ISP1080 << 16) | PCI_VENDOR_QLOGIC)
 217
 218 #define PCI_QLOGIC_ISP10160     \
 219         ((PCI_PRODUCT_QLOGIC_ISP10160 << 16) | PCI_VENDOR_QLOGIC)
 220
 221 #define PCI_QLOGIC_ISP12160     \
 222         ((PCI_PRODUCT_QLOGIC_ISP12160 << 16) | PCI_VENDOR_QLOGIC)
 223
 224 #define PCI_QLOGIC_ISP1240      \
 225         ((PCI_PRODUCT_QLOGIC_ISP1240 << 16) | PCI_VENDOR_QLOGIC)
 226
 227 #define PCI_QLOGIC_ISP1280      \
 228         ((PCI_PRODUCT_QLOGIC_ISP1280 << 16) | PCI_VENDOR_QLOGIC)
 229
 230 #define PCI_QLOGIC_ISP2100      \
 231         ((PCI_PRODUCT_QLOGIC_ISP2100 << 16) | PCI_VENDOR_QLOGIC)
 232
 233 #define PCI_QLOGIC_ISP2200      \
 234         ((PCI_PRODUCT_QLOGIC_ISP2200 << 16) | PCI_VENDOR_QLOGIC)
 235
 236 #define PCI_QLOGIC_ISP2300      \
 237         ((PCI_PRODUCT_QLOGIC_ISP2300 << 16) | PCI_VENDOR_QLOGIC)
 238
 239 #define PCI_QLOGIC_ISP2312      \
 240         ((PCI_PRODUCT_QLOGIC_ISP2312 << 16) | PCI_VENDOR_QLOGIC)
 241
 242 /*
 243  * Odd case for some AMI raid cards... We need to *not* attach to this.
 244  */
 245 #define AMI_RAID_SUBVENDOR_ID   0x101e
 246
 247 #define IO_MAP_REG      0x10
 248 #define MEM_MAP_REG     0x14
 249
 250 #define PCI_DFLT_LTNCY  0x40
 251 #define PCI_DFLT_LNSZ   0x10
 252
 253 static int isp_pci_probe (device_t);
 254 static int isp_pci_attach (device_t);
 255
 256
 257 struct isp_pcisoftc {
 258         struct ispsoftc                 pci_isp;
 259         device_t                        pci_dev;
 260         struct resource *               pci_reg;
 261         bus_space_tag_t                 pci_st;
 262         bus_space_handle_t              pci_sh;
 263         void *                          ih;
 264         int16_t                         pci_poff[_NREG_BLKS];
 265         bus_dma_tag_t                   dmat;
 266         bus_dmamap_t                    *dmaps;
 267 };
 268 ispfwfunc *isp_get_firmware_p = NULL;
 269
 270 static device_method_t isp_pci_methods[] = {
 271         /* Device interface */
 272         DEVMETHOD(device_probe,         isp_pci_probe),
 273         DEVMETHOD(device_attach,        isp_pci_attach),
 274         { 0, 0 }
 275 };
 276 static void isp_pci_intr(void *);
 277
 278 static driver_t isp_pci_driver = {
 279         "isp", isp_pci_methods, sizeof (struct isp_pcisoftc)
 280 };
 281 static devclass_t isp_devclass;
 282 DRIVER_MODULE(isp, pci, isp_pci_driver, isp_devclass, 0, 0);
 283 MODULE_VERSION(isp, 1);
 284
 285 static int
 286 isp_pci_probe(device_t dev)
 287 {
 288         switch ((pci_get_device(dev) << 16) | (pci_get_vendor(dev))) {
 289         case PCI_QLOGIC_ISP1020:
 290                 device_set_desc(dev, "Qlogic ISP 1020/1040 PCI SCSI Adapter");
 291                 break;
 292         case PCI_QLOGIC_ISP1080:
 293                 device_set_desc(dev, "Qlogic ISP 1080 PCI SCSI Adapter");
 294                 break;
 295         case PCI_QLOGIC_ISP1240:
 296                 device_set_desc(dev, "Qlogic ISP 1240 PCI SCSI Adapter");
 297                 break;
 298         case PCI_QLOGIC_ISP1280:
 299                 device_set_desc(dev, "Qlogic ISP 1280 PCI SCSI Adapter");
 300                 break;
 301         case PCI_QLOGIC_ISP10160:
 302                 device_set_desc(dev, "Qlogic ISP 10160 PCI SCSI Adapter");
 303                 break;
 304         case PCI_QLOGIC_ISP12160:
 305                 if (pci_get_subvendor(dev) == AMI_RAID_SUBVENDOR_ID) {
 306                         return (ENXIO);
 307                 }
 308                 device_set_desc(dev, "Qlogic ISP 12160 PCI SCSI Adapter");
 309                 break;
 310         case PCI_QLOGIC_ISP2100:
 311                 device_set_desc(dev, "Qlogic ISP 2100 PCI FC-AL Adapter");
 312                 break;
 313         case PCI_QLOGIC_ISP2200:
 314                 device_set_desc(dev, "Qlogic ISP 2200 PCI FC-AL Adapter");
 315                 break;
 316         case PCI_QLOGIC_ISP2300:
 317                 device_set_desc(dev, "Qlogic ISP 2300 PCI FC-AL Adapter");
 318                 break;
 319         case PCI_QLOGIC_ISP2312:
 320                 device_set_desc(dev, "Qlogic ISP 2312 PCI FC-AL Adapter");
 321                 break;
 322         default:
 323                 return (ENXIO);
 324         }
 325         if (device_get_unit(dev) == 0 && bootverbose) {
 326                 kprintf("Qlogic ISP Driver, FreeBSD Version %d.%d, "
 327                     "Core Version %d.%d\n",
 328                     ISP_PLATFORM_VERSION_MAJOR, ISP_PLATFORM_VERSION_MINOR,
 329                     ISP_CORE_VERSION_MAJOR, ISP_CORE_VERSION_MINOR);
 330         }
 331         /*
 332          * XXXX: Here is where we might load the f/w module
 333          * XXXX: (or increase a reference count to it).
 334          */
 335         return (0);
 336 }
 337
 338 static int
 339 isp_pci_attach(device_t dev)
 340 {
 341         struct resource *regs, *irq;
 342         int unit, bitmap, rtp, rgd, iqd, m1, m2, isp_debug;
 343         u_int32_t data, cmd, linesz, psize, basetype;
 344         struct isp_pcisoftc *pcs;
 345         struct ispsoftc *isp = NULL;
 346         struct ispmdvec *mdvp;
 347         quad_t wwn;
 348         bus_size_t lim;
 349
 350         /*
 351          * Figure out if we're supposed to skip this one.
 352          */
 353         unit = device_get_unit(dev);
 354         if (kgetenv_int("isp_disable", &bitmap)) {
 355                 if (bitmap & (1 << unit)) {
 356                         device_printf(dev, "not configuring\n");
 357                         /*
 358                          * But return '0' to preserve HBA numbering.
 359                          */
 360                         return (0);
 361                 }
 362         }
 363
 364         pcs = kmalloc(sizeof (struct isp_pcisoftc), M_DEVBUF, M_WAITOK | M_ZERO);
 365
 366         /*
 367          * Figure out which we should try first - memory mapping or i/o mapping?
 368          */
 369         m1 = PCIM_CMD_PORTEN;
 370         m2 = PCIM_CMD_MEMEN;
 371         bitmap = 0;
 372         if (kgetenv_int("isp_mem_map", &bitmap)) {
 373                 if (bitmap & (1 << unit)) {
 374                         m1 = PCIM_CMD_MEMEN;
 375                         m2 = PCIM_CMD_PORTEN;
 376                 }
 377         }
 378         bitmap = 0;
 379         if (kgetenv_int("isp_io_map", &bitmap)) {
 380                 if (bitmap & (1 << unit)) {
 381                         m1 = PCIM_CMD_PORTEN;
 382                         m2 = PCIM_CMD_MEMEN;
 383                 }
 384         }
 385
 386         linesz = PCI_DFLT_LNSZ;
 387         irq = regs = NULL;
 388         rgd = rtp = iqd = 0;
 389
 390         cmd = pci_read_config(dev, PCIR_COMMAND, 1);
 391         if (cmd & m1) {
 392                 rtp = (m1 == PCIM_CMD_MEMEN)? SYS_RES_MEMORY : SYS_RES_IOPORT;
 393                 rgd = (m1 == PCIM_CMD_MEMEN)? MEM_MAP_REG : IO_MAP_REG;
 394                 regs = bus_alloc_resource(dev, rtp, &rgd, 0, ~0, 1, RF_ACTIVE);
 395         }
 396         if (regs == NULL && (cmd & m2)) {
 397                 rtp = (m2 == PCIM_CMD_MEMEN)? SYS_RES_MEMORY : SYS_RES_IOPORT;
 398                 rgd = (m2 == PCIM_CMD_MEMEN)? MEM_MAP_REG : IO_MAP_REG;
 399                 regs = bus_alloc_resource(dev, rtp, &rgd, 0, ~0, 1, RF_ACTIVE);
 400         }
 401         if (regs == NULL) {
 402                 device_printf(dev, "unable to map any ports\n");
 403                 goto bad;
 404         }
 405         if (bootverbose)
 406                 device_printf(dev, "using %s space register mapping\n",
 407                     (rgd == IO_MAP_REG)? "I/O" : "Memory");
 408         pcs->pci_dev = dev;
 409         pcs->pci_reg = regs;
 410         pcs->pci_st = rman_get_bustag(regs);
 411         pcs->pci_sh = rman_get_bushandle(regs);
 412
 413         pcs->pci_poff[BIU_BLOCK >> _BLK_REG_SHFT] = BIU_REGS_OFF;
 414         pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = PCI_MBOX_REGS_OFF;
 415         pcs->pci_poff[SXP_BLOCK >> _BLK_REG_SHFT] = PCI_SXP_REGS_OFF;
 416         pcs->pci_poff[RISC_BLOCK >> _BLK_REG_SHFT] = PCI_RISC_REGS_OFF;
 417         pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] = DMA_REGS_OFF;
 418         mdvp = &mdvec;
 419         basetype = ISP_HA_SCSI_UNKNOWN;
 420         psize = sizeof (sdparam);
 421         lim = BUS_SPACE_MAXSIZE_32BIT;
 422         if (pci_get_devid(dev) == PCI_QLOGIC_ISP1020) {
 423                 mdvp = &mdvec;
 424                 basetype = ISP_HA_SCSI_UNKNOWN;
 425                 psize = sizeof (sdparam);
 426                 lim = BUS_SPACE_MAXSIZE_24BIT;
 427         }
 428         if (pci_get_devid(dev) == PCI_QLOGIC_ISP1080) {
 429                 mdvp = &mdvec_1080;
 430                 basetype = ISP_HA_SCSI_1080;
 431                 psize = sizeof (sdparam);
 432                 pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] =
 433                     ISP1080_DMA_REGS_OFF;
 434         }
 435         if (pci_get_devid(dev) == PCI_QLOGIC_ISP1240) {
 436                 mdvp = &mdvec_1080;
 437                 basetype = ISP_HA_SCSI_1240;
 438                 psize = 2 * sizeof (sdparam);
 439                 pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] =
 440                     ISP1080_DMA_REGS_OFF;
 441         }
 442         if (pci_get_devid(dev) == PCI_QLOGIC_ISP1280) {
 443                 mdvp = &mdvec_1080;
 444                 basetype = ISP_HA_SCSI_1280;
 445                 psize = 2 * sizeof (sdparam);
 446                 pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] =
 447                     ISP1080_DMA_REGS_OFF;
 448         }
 449         if (pci_get_devid(dev) == PCI_QLOGIC_ISP10160) {
 450                 mdvp = &mdvec_12160;
 451                 basetype = ISP_HA_SCSI_10160;
 452                 psize = sizeof (sdparam);
 453                 pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] =
 454                     ISP1080_DMA_REGS_OFF;
 455         }
 456         if (pci_get_devid(dev) == PCI_QLOGIC_ISP12160) {
 457                 mdvp = &mdvec_12160;
 458                 basetype = ISP_HA_SCSI_12160;
 459                 psize = 2 * sizeof (sdparam);
 460                 pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] =
 461                     ISP1080_DMA_REGS_OFF;
 462         }
 463         if (pci_get_devid(dev) == PCI_QLOGIC_ISP2100) {
 464                 mdvp = &mdvec_2100;
 465                 basetype = ISP_HA_FC_2100;
 466                 psize = sizeof (fcparam);
 467                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] =
 468                     PCI_MBOX_REGS2100_OFF;
 469                 if (pci_get_revid(dev) < 3) {
 470                         /*
 471                          * XXX: Need to get the actual revision
 472                          * XXX: number of the 2100 FB. At any rate,
 473                          * XXX: lower cache line size for early revision
 474                          * XXX; boards.
 475                          */
 476                         linesz = 1;
 477                 }
 478         }
 479         if (pci_get_devid(dev) == PCI_QLOGIC_ISP2200) {
 480                 mdvp = &mdvec_2200;
 481                 basetype = ISP_HA_FC_2200;
 482                 psize = sizeof (fcparam);
 483                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] =
 484                     PCI_MBOX_REGS2100_OFF;
 485         }
 486         if (pci_get_devid(dev) == PCI_QLOGIC_ISP2300) {
 487                 mdvp = &mdvec_2300;
 488                 basetype = ISP_HA_FC_2300;
 489                 psize = sizeof (fcparam);
 490                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] =
 491                     PCI_MBOX_REGS2300_OFF;
 492         }
 493         if (pci_get_devid(dev) == PCI_QLOGIC_ISP2312) {
 494                 mdvp = &mdvec_2300;
 495                 basetype = ISP_HA_FC_2312;
 496                 psize = sizeof (fcparam);
 497                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] =
 498                     PCI_MBOX_REGS2300_OFF;
 499         }
 500         isp = &pcs->pci_isp;
 501         isp->isp_param = kmalloc(psize, M_DEVBUF, M_WAITOK | M_ZERO);
 502         isp->isp_mdvec = mdvp;
 503         isp->isp_type = basetype;
 504         isp->isp_revision = pci_get_revid(dev);
 505 #ifdef  ISP_TARGET_MODE
 506         isp->isp_role = ISP_ROLE_BOTH;
 507 #else
 508         isp->isp_role = ISP_DEFAULT_ROLES;
 509 #endif
 510         isp->isp_dev = dev;
 511
 512
 513         /*
 514          * Try and find firmware for this device.
 515          */
 516
 517         if (isp_get_firmware_p) {
 518                 int device = (int) pci_get_device(dev);
 519 #ifdef  ISP_TARGET_MODE
 520                 (*isp_get_firmware_p)(0, 1, device, &mdvp->dv_ispfw);
 521 #else
 522                 (*isp_get_firmware_p)(0, 0, device, &mdvp->dv_ispfw);
 523 #endif
 524         }
 525
 526         /*
 527          * Make sure that SERR, PERR, WRITE INVALIDATE and BUSMASTER
 528          * are set.
 529          */
 530         cmd |= PCIM_CMD_SEREN | PCIM_CMD_PERRESPEN |
 531                 PCIM_CMD_BUSMASTEREN | PCIM_CMD_INVEN;
 532         if (IS_2300(isp)) {     /* per QLogic errata */
 533                 cmd &= ~PCIM_CMD_INVEN;
 534         }
 535         if (IS_23XX(isp)) {
 536                 /*
 537                  * Can't tell if ROM will hang on 'ABOUT FIRMWARE' command.
 538                  */
 539                 isp->isp_touched = 1;
 540
 541         }
 542         pci_write_config(dev, PCIR_COMMAND, cmd, 1);
 543
 544         /*
 545          * Make sure the Cache Line Size register is set sensibly.
 546          */
 547         data = pci_read_config(dev, PCIR_CACHELNSZ, 1);
 548         if (data != linesz) {
 549                 data = PCI_DFLT_LNSZ;
 550                 isp_prt(isp, ISP_LOGCONFIG, "set PCI line size to %d", data);
 551                 pci_write_config(dev, PCIR_CACHELNSZ, data, 1);
 552         }
 553
 554         /*
 555          * Make sure the Latency Timer is sane.
 556          */
 557         data = pci_read_config(dev, PCIR_LATTIMER, 1);
 558         if (data < PCI_DFLT_LTNCY) {
 559                 data = PCI_DFLT_LTNCY;
 560                 isp_prt(isp, ISP_LOGCONFIG, "set PCI latency to %d", data);
 561                 pci_write_config(dev, PCIR_LATTIMER, data, 1);
 562         }
 563
 564         /*
 565          * Make sure we've disabled the ROM.
 566          */
 567         data = pci_read_config(dev, PCIR_ROMADDR, 4);
 568         data &= ~1;
 569         pci_write_config(dev, PCIR_ROMADDR, data, 4);
 570
 571         iqd = 0;
 572         irq = bus_alloc_resource(dev, SYS_RES_IRQ, &iqd, 0, ~0,
 573             1, RF_ACTIVE | RF_SHAREABLE);
 574         if (irq == NULL) {
 575                 device_printf(dev, "could not allocate interrupt\n");
 576                 goto bad;
 577         }
 578
 579         if (kgetenv_int("isp_no_fwload", &bitmap)) {
 580                 if (bitmap & (1 << unit))
 581                         isp->isp_confopts |= ISP_CFG_NORELOAD;
 582         }
 583         if (kgetenv_int("isp_fwload", &bitmap)) {
 584                 if (bitmap & (1 << unit))
 585                         isp->isp_confopts &= ~ISP_CFG_NORELOAD;
 586         }
 587         if (kgetenv_int("isp_no_nvram", &bitmap)) {
 588                 if (bitmap & (1 << unit))
 589                         isp->isp_confopts |= ISP_CFG_NONVRAM;
 590         }
 591         if (kgetenv_int("isp_nvram", &bitmap)) {
 592                 if (bitmap & (1 << unit))
 593                         isp->isp_confopts &= ~ISP_CFG_NONVRAM;
 594         }
 595         if (kgetenv_int("isp_fcduplex", &bitmap)) {
 596                 if (bitmap & (1 << unit))
 597                         isp->isp_confopts |= ISP_CFG_FULL_DUPLEX;
 598         }
 599         if (kgetenv_int("isp_no_fcduplex", &bitmap)) {
 600                 if (bitmap & (1 << unit))
 601                         isp->isp_confopts &= ~ISP_CFG_FULL_DUPLEX;
 602         }
 603         if (kgetenv_int("isp_nport", &bitmap)) {
 604                 if (bitmap & (1 << unit))
 605                         isp->isp_confopts |= ISP_CFG_NPORT;
 606         }
 607
 608         /*
 609          * Because the resource_*_value functions can neither return
 610          * 64 bit integer values, nor can they be directly coerced
 611          * to interpret the right hand side of the assignment as
 612          * you want them to interpret it, we have to force WWN
 613          * hint replacement to specify WWN strings with a leading
 614          * 'w' (e..g w50000000aaaa0001). Sigh.
 615          */
 616         if (kgetenv_quad("isp_portwwn", &wwn)) {
 617                 isp->isp_osinfo.default_port_wwn = wwn;
 618                 isp->isp_confopts |= ISP_CFG_OWNWWPN;
 619         }
 620         if (isp->isp_osinfo.default_port_wwn == 0) {
 621                 isp->isp_osinfo.default_port_wwn = 0x400000007F000009ull;
 622         }
 623
 624         if (kgetenv_quad("isp_nodewwn", &wwn)) {
 625                 isp->isp_osinfo.default_node_wwn = wwn;
 626                 isp->isp_confopts |= ISP_CFG_OWNWWNN;
 627         }
 628         if (isp->isp_osinfo.default_node_wwn == 0) {
 629                 isp->isp_osinfo.default_node_wwn = 0x400000007F000009ull;
 630         }
 631
 632         isp_debug = 0;
 633         (void) kgetenv_int("isp_debug", &isp_debug);
 634         if (bus_setup_intr(dev, irq, 0, isp_pci_intr,
 635             isp, &pcs->ih, NULL)) {
 636                 device_printf(dev, "could not setup interrupt\n");
 637                 goto bad;
 638         }
 639
 640 #ifdef  ISP_FW_CRASH_DUMP
 641         bitmap = 0;
 642         if (kgetenv_int("isp_fw_dump_enable", &bitmap)) {
 643                 if (bitmap & (1 << unit) {
 644                         size_t amt = 0;
 645                         if (IS_2200(isp)) {
 646                                 amt = QLA2200_RISC_IMAGE_DUMP_SIZE;
 647                         } else if (IS_23XX(isp)) {
 648                                 amt = QLA2300_RISC_IMAGE_DUMP_SIZE;
 649                         }
 650                         if (amt) {
 651                                 FCPARAM(isp)->isp_dump_data =
 652                                     kmalloc(amt, M_DEVBUF, M_WAITOK);
 653                                 bzero(FCPARAM(isp)->isp_dump_data, amt);
 654                         } else {
 655                                 device_printf(dev,
 656                                     "f/w crash dumps not supported for card\n");
 657                         }
 658                 }
 659         }
 660 #endif
 661
 662         if (IS_2312(isp)) {
 663                 isp->isp_port = pci_get_function(dev);
 664         }
 665
 666         /*
 667          * Set up logging levels.
 668          */
 669         if (isp_debug) {
 670                 isp->isp_dblev = isp_debug;
 671         } else {
 672                 isp->isp_dblev = ISP_LOGWARN|ISP_LOGERR;
 673         }
 674         if (bootverbose)
 675                 isp->isp_dblev |= ISP_LOGCONFIG|ISP_LOGINFO;
 676
 677         /*
 678          * Make sure we're in reset state.
 679          */
 680         ISP_LOCK(isp);
 681         isp_reset(isp);
 682
 683         if (isp->isp_state != ISP_RESETSTATE) {
 684                 ISP_UNLOCK(isp);
 685                 goto bad;
 686         }
 687         isp_init(isp);
 688         if (isp->isp_state != ISP_INITSTATE) {
 689                 /* If we're a Fibre Channel Card, we allow deferred attach */
 690                 if (IS_SCSI(isp)) {
 691                         isp_uninit(isp);
 692                         ISP_UNLOCK(isp);
 693                         goto bad;
 694                 }
 695         }
 696         isp_attach(isp);
 697         if (isp->isp_state != ISP_RUNSTATE) {
 698                 /* If we're a Fibre Channel Card, we allow deferred attach */
 699                 if (IS_SCSI(isp)) {
 700                         isp_uninit(isp);
 701                         ISP_UNLOCK(isp);
 702                         goto bad;
 703                 }
 704         }
 705         /*
 706          * XXXX: Here is where we might unload the f/w module
 707          * XXXX: (or decrease the reference count to it).
 708          */
 709         ISP_UNLOCK(isp);
 710         return (0);
 711
 712 bad:
 713
 714         if (pcs && pcs->ih) {
 715                 (void) bus_teardown_intr(dev, irq, pcs->ih);
 716         }
 717
 718         if (irq) {
 719                 (void) bus_release_resource(dev, SYS_RES_IRQ, iqd, irq);
 720         }
 721
 722
 723         if (regs) {
 724                 (void) bus_release_resource(dev, rtp, rgd, regs);
 725         }
 726
 727         if (pcs) {
 728                 if (pcs->pci_isp.isp_param)
 729                         kfree(pcs->pci_isp.isp_param, M_DEVBUF);
 730                 kfree(pcs, M_DEVBUF);
 731         }
 732
 733         /*
 734          * XXXX: Here is where we might unload the f/w module
 735          * XXXX: (or decrease the reference count to it).
 736          */
 737         return (ENXIO);
 738 }
 739
 740 static void
 741 isp_pci_intr(void *arg)
 742 {
 743         struct ispsoftc *isp = arg;
 744         u_int16_t isr, sema, mbox;
 745
 746         ISP_LOCK(isp);
 747         isp->isp_intcnt++;
 748         if (ISP_READ_ISR(isp, &isr, &sema, &mbox) == 0) {
 749                 isp->isp_intbogus++;
 750         } else {
 751                 int iok = isp->isp_osinfo.intsok;
 752                 isp->isp_osinfo.intsok = 0;
 753                 isp_intr(isp, isr, sema, mbox);
 754                 isp->isp_osinfo.intsok = iok;
 755         }
 756         ISP_UNLOCK(isp);
 757 }
 758
 759
 760 #define IspVirt2Off(a, x)       \
 761         (((struct isp_pcisoftc *)a)->pci_poff[((x) & _BLK_REG_MASK) >> \
 762         _BLK_REG_SHFT] + ((x) & 0xff))
 763
 764 #define BXR2(pcs, off)          \
 765         bus_space_read_2(pcs->pci_st, pcs->pci_sh, off)
 766 #define BXW2(pcs, off, v)       \
 767         bus_space_write_2(pcs->pci_st, pcs->pci_sh, off, v)
 768
 769
 770 static INLINE int
 771 isp_pci_rd_debounced(struct ispsoftc *isp, int off, u_int16_t *rp)
 772 {
 773         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
 774         u_int16_t val0, val1;
 775         int i = 0;
 776
 777         do {
 778                 val0 = BXR2(pcs, IspVirt2Off(isp, off));
 779                 val1 = BXR2(pcs, IspVirt2Off(isp, off));
 780         } while (val0 != val1 && ++i < 1000);
 781         if (val0 != val1) {
 782                 return (1);
 783         }
 784         *rp = val0;
 785         return (0);
 786 }
 787
 788 static int
 789 isp_pci_rd_isr(struct ispsoftc *isp, u_int16_t *isrp,
 790     u_int16_t *semap, u_int16_t *mbp)
 791 {
 792         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
 793         u_int16_t isr, sema;
 794
 795         if (IS_2100(isp)) {
 796                 if (isp_pci_rd_debounced(isp, BIU_ISR, &isr)) {
 797                     return (0);
 798                 }
 799                 if (isp_pci_rd_debounced(isp, BIU_SEMA, &sema)) {
 800                     return (0);
 801                 }
 802         } else {
 803                 isr = BXR2(pcs, IspVirt2Off(isp, BIU_ISR));
 804                 sema = BXR2(pcs, IspVirt2Off(isp, BIU_SEMA));
 805         }
 806         isp_prt(isp, ISP_LOGDEBUG3, "ISR 0x%x SEMA 0x%x", isr, sema);
 807         isr &= INT_PENDING_MASK(isp);
 808         sema &= BIU_SEMA_LOCK;
 809         if (isr == 0 && sema == 0) {
 810                 return (0);
 811         }
 812         *isrp = isr;
 813         if ((*semap = sema) != 0) {
 814                 if (IS_2100(isp)) {
 815                         if (isp_pci_rd_debounced(isp, OUTMAILBOX0, mbp)) {
 816                                 return (0);
 817                         }
 818                 } else {
 819                         *mbp = BXR2(pcs, IspVirt2Off(isp, OUTMAILBOX0));
 820                 }
 821         }
 822         return (1);
 823 }
 824
 825 static int
 826 isp_pci_rd_isr_2300(struct ispsoftc *isp, u_int16_t *isrp,
 827     u_int16_t *semap, u_int16_t *mbox0p)
 828 {
 829         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
 830         u_int32_t r2hisr;
 831
 832         if (!(BXR2(pcs, IspVirt2Off(isp, BIU_ISR) & BIU2100_ISR_RISC_INT))) {
 833                 *isrp = 0;
 834                 return (0);
 835         }
 836         r2hisr = bus_space_read_4(pcs->pci_st, pcs->pci_sh,
 837             IspVirt2Off(pcs, BIU_R2HSTSLO));
 838         isp_prt(isp, ISP_LOGDEBUG3, "RISC2HOST ISR 0x%x", r2hisr);
 839         if ((r2hisr & BIU_R2HST_INTR) == 0) {
 840                 *isrp = 0;
 841                 return (0);
 842         }
 843         switch (r2hisr & BIU_R2HST_ISTAT_MASK) {
 844         case ISPR2HST_ROM_MBX_OK:
 845         case ISPR2HST_ROM_MBX_FAIL:
 846         case ISPR2HST_MBX_OK:
 847         case ISPR2HST_MBX_FAIL:
 848         case ISPR2HST_ASYNC_EVENT:
 849                 *isrp = r2hisr & 0xffff;
 850                 *mbox0p = (r2hisr >> 16);
 851                 *semap = 1;
 852                 return (1);
 853         case ISPR2HST_RIO_16:
 854                 *isrp = r2hisr & 0xffff;
 855                 *mbox0p = ASYNC_RIO1;
 856                 *semap = 1;
 857                 return (1);
 858         case ISPR2HST_FPOST:
 859                 *isrp = r2hisr & 0xffff;
 860                 *mbox0p = ASYNC_CMD_CMPLT;
 861                 *semap = 1;
 862                 return (1);
 863         case ISPR2HST_FPOST_CTIO:
 864                 *isrp = r2hisr & 0xffff;
 865                 *mbox0p = ASYNC_CTIO_DONE;
 866                 *semap = 1;
 867                 return (1);
 868         case ISPR2HST_RSPQ_UPDATE:
 869                 *isrp = r2hisr & 0xffff;
 870                 *mbox0p = 0;
 871                 *semap = 0;
 872                 return (1);
 873         default:
 874                 return (0);
 875         }
 876 }
 877
 878 static u_int16_t
 879 isp_pci_rd_reg(struct ispsoftc *isp, int regoff)
 880 {
 881         u_int16_t rv;
 882         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
 883         int oldconf = 0;
 884
 885         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
 886                 /*
 887                  * We will assume that someone has paused the RISC processor.
 888                  */
 889                 oldconf = BXR2(pcs, IspVirt2Off(isp, BIU_CONF1));
 890                 BXW2(pcs, IspVirt2Off(isp, BIU_CONF1),
 891                     oldconf | BIU_PCI_CONF1_SXP);
 892         }
 893         rv = BXR2(pcs, IspVirt2Off(isp, regoff));
 894         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
 895                 BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), oldconf);
 896         }
 897         return (rv);
 898 }
 899
 900 static void
 901 isp_pci_wr_reg(struct ispsoftc *isp, int regoff, u_int16_t val)
 902 {
 903         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
 904         int oldconf = 0;
 905
 906         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
 907                 /*
 908                  * We will assume that someone has paused the RISC processor.
 909                  */
 910                 oldconf = BXR2(pcs, IspVirt2Off(isp, BIU_CONF1));
 911                 BXW2(pcs, IspVirt2Off(isp, BIU_CONF1),
 912                     oldconf | BIU_PCI_CONF1_SXP);
 913         }
 914         BXW2(pcs, IspVirt2Off(isp, regoff), val);
 915         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
 916                 BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), oldconf);
 917         }
 918 }
 919
 920 static u_int16_t
 921 isp_pci_rd_reg_1080(struct ispsoftc *isp, int regoff)
 922 {
 923         u_int16_t rv, oc = 0;
 924         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
 925
 926         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK ||
 927             (regoff & _BLK_REG_MASK) == (SXP_BLOCK|SXP_BANK1_SELECT)) {
 928                 u_int16_t tc;
 929                 /*
 930                  * We will assume that someone has paused the RISC processor.
 931                  */
 932                 oc = BXR2(pcs, IspVirt2Off(isp, BIU_CONF1));
 933                 tc = oc & ~BIU_PCI1080_CONF1_DMA;
 934                 if (regoff & SXP_BANK1_SELECT)
 935                         tc |= BIU_PCI1080_CONF1_SXP1;
 936                 else
 937                         tc |= BIU_PCI1080_CONF1_SXP0;
 938                 BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), tc);
 939         } else if ((regoff & _BLK_REG_MASK) == DMA_BLOCK) {
 940                 oc = BXR2(pcs, IspVirt2Off(isp, BIU_CONF1));
 941                 BXW2(pcs, IspVirt2Off(isp, BIU_CONF1),
 942                     oc | BIU_PCI1080_CONF1_DMA);
 943         }
 944         rv = BXR2(pcs, IspVirt2Off(isp, regoff));
 945         if (oc) {
 946                 BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), oc);
 947         }
 948         return (rv);
 949 }
 950
 951 static void
 952 isp_pci_wr_reg_1080(struct ispsoftc *isp, int regoff, u_int16_t val)
 953 {
 954         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *) isp;
 955         int oc = 0;
 956
 957         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK ||
 958             (regoff & _BLK_REG_MASK) == (SXP_BLOCK|SXP_BANK1_SELECT)) {
 959                 u_int16_t tc;
 960                 /*
 961                  * We will assume that someone has paused the RISC processor.
 962                  */
 963                 oc = BXR2(pcs, IspVirt2Off(isp, BIU_CONF1));
 964                 tc = oc & ~BIU_PCI1080_CONF1_DMA;
 965                 if (regoff & SXP_BANK1_SELECT)
 966                         tc |= BIU_PCI1080_CONF1_SXP1;
 967                 else
 968                         tc |= BIU_PCI1080_CONF1_SXP0;
 969                 BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), tc);
 970         } else if ((regoff & _BLK_REG_MASK) == DMA_BLOCK) {
 971                 oc = BXR2(pcs, IspVirt2Off(isp, BIU_CONF1));
 972                 BXW2(pcs, IspVirt2Off(isp, BIU_CONF1),
 973                     oc | BIU_PCI1080_CONF1_DMA);
 974         }
 975         BXW2(pcs, IspVirt2Off(isp, regoff), val);
 976         if (oc) {
 977                 BXW2(pcs, IspVirt2Off(isp, BIU_CONF1), oc);
 978         }
 979 }
 980
 981
 982 struct imush {
 983         struct ispsoftc *isp;
 984         int error;
 985 };
 986
 987 static void imc(void *, bus_dma_segment_t *, int, int);
 988
 989 static void
 990 imc(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 991 {
 992         struct imush *imushp = (struct imush *) arg;
 993         if (error) {
 994                 imushp->error = error;
 995         } else {
 996                 struct ispsoftc *isp =imushp->isp;
 997                 bus_addr_t addr = segs->ds_addr;
 998
 999                 isp->isp_rquest_dma = addr;
1000                 addr += ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
1001                 isp->isp_result_dma = addr;
1002                 if (IS_FC(isp)) {
1003                         addr += ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
1004                         FCPARAM(isp)->isp_scdma = addr;
1005                 }
1006         }
1007 }
1008
1009 /*
1010  * Should be BUS_SPACE_MAXSIZE, but MAXPHYS is larger than BUS_SPACE_MAXSIZE
1011  */
1012 #define ISP_NSEGS ((MAXPHYS / PAGE_SIZE) + 1)
1013
1014 static int
1015 isp_pci_mbxdma(struct ispsoftc *isp)
1016 {
1017         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
1018         caddr_t base;
1019         u_int32_t len;
1020         int i, error, ns;
1021         bus_size_t alim, slim;
1022         struct imush im;
1023
1024         /*
1025          * Already been here? If so, leave...
1026          */
1027         if (isp->isp_rquest) {
1028                 return (0);
1029         }
1030
1031 #ifdef  ISP_DAC_SUPPORTED
1032         alim = BUS_SPACE_UNRESTRICTED;
1033 #else
1034         alim = BUS_SPACE_MAXADDR_32BIT;
1035 #endif
1036         if (IS_ULTRA2(isp) || IS_FC(isp) || IS_1240(isp)) {
1037                 slim = BUS_SPACE_MAXADDR_32BIT;
1038         } else {
1039                 slim = BUS_SPACE_MAXADDR_24BIT;
1040         }
1041
1042         ISP_UNLOCK(isp);
1043         if (bus_dma_tag_create(NULL, 1, slim+1, alim, alim,
1044             NULL, NULL, BUS_SPACE_MAXSIZE, ISP_NSEGS, slim, 0, &pcs->dmat)) {
1045                 isp_prt(isp, ISP_LOGERR, "could not create master dma tag");
1046                 ISP_LOCK(isp);
1047                 return(1);
1048         }
1049
1050
1051         len = sizeof (XS_T **) * isp->isp_maxcmds;
1052         isp->isp_xflist = (XS_T **) kmalloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
1053         len = sizeof (bus_dmamap_t) * isp->isp_maxcmds;
1054         pcs->dmaps = (bus_dmamap_t *) kmalloc(len, M_DEVBUF,  M_WAITOK);
1055
1056         /*
1057          * Allocate and map the request, result queues, plus FC scratch area.
1058          */
1059         len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
1060         len += ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
1061         if (IS_FC(isp)) {
1062                 len += ISP2100_SCRLEN;
1063         }
1064
1065         ns = (len / PAGE_SIZE) + 1;
1066         if (bus_dma_tag_create(pcs->dmat, QENTRY_LEN, slim+1, alim, alim,
1067             NULL, NULL, len, ns, slim, 0, &isp->isp_cdmat)) {
1068                 isp_prt(isp, ISP_LOGERR,
1069                     "cannot create a dma tag for control spaces");
1070                 kfree(pcs->dmaps, M_DEVBUF);
1071                 kfree(isp->isp_xflist, M_DEVBUF);
1072                 ISP_LOCK(isp);
1073                 return (1);
1074         }
1075
1076         if (bus_dmamem_alloc(isp->isp_cdmat, (void *)&base, BUS_DMA_NOWAIT,
1077             &isp->isp_cdmap) != 0) {
1078                 isp_prt(isp, ISP_LOGERR,
1079                     "cannot allocate %d bytes of CCB memory", len);
1080                 bus_dma_tag_destroy(isp->isp_cdmat);
1081                 kfree(isp->isp_xflist, M_DEVBUF);
1082                 kfree(pcs->dmaps, M_DEVBUF);
1083                 ISP_LOCK(isp);
1084                 return (1);
1085         }
1086
1087         for (i = 0; i < isp->isp_maxcmds; i++) {
1088                 error = bus_dmamap_create(pcs->dmat, 0, &pcs->dmaps[i]);
1089                 if (error) {
1090                         isp_prt(isp, ISP_LOGERR,
1091                             "error %d creating per-cmd DMA maps", error);
1092                         while (--i >= 0) {
1093                                 bus_dmamap_destroy(pcs->dmat, pcs->dmaps[i]);
1094                         }
1095                         goto bad;
1096                 }
1097         }
1098
1099         im.isp = isp;
1100         im.error = 0;
1101         bus_dmamap_load(isp->isp_cdmat, isp->isp_cdmap, base, len, imc, &im, 0);
1102         if (im.error) {
1103                 isp_prt(isp, ISP_LOGERR,
1104                     "error %d loading dma map for control areas", im.error);
1105                 goto bad;
1106         }
1107
1108         isp->isp_rquest = base;
1109         base += ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
1110         isp->isp_result = base;
1111         if (IS_FC(isp)) {
1112                 base += ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
1113                 FCPARAM(isp)->isp_scratch = base;
1114         }
1115         ISP_LOCK(isp);
1116         return (0);
1117
1118 bad:
1119         bus_dmamem_free(isp->isp_cdmat, base, isp->isp_cdmap);
1120         bus_dma_tag_destroy(isp->isp_cdmat);
1121         kfree(isp->isp_xflist, M_DEVBUF);
1122         kfree(pcs->dmaps, M_DEVBUF);
1123         ISP_LOCK(isp);
1124         isp->isp_rquest = NULL;
1125         return (1);
1126 }
1127
1128 typedef struct {
1129         struct ispsoftc *isp;
1130         void *cmd_token;
1131         void *rq;
1132         u_int16_t *nxtip;
1133         u_int16_t optr;
1134         u_int error;
1135 } mush_t;
1136
1137 #define MUSHERR_NOQENTRIES      -2
1138
1139 #ifdef  ISP_TARGET_MODE
1140 /*
1141  * We need to handle DMA for target mode differently from initiator mode.
1142  *
1143  * DMA mapping and construction and submission of CTIO Request Entries
1144  * and rendevous for completion are very tightly coupled because we start
1145  * out by knowing (per platform) how much data we have to move, but we
1146  * don't know, up front, how many DMA mapping segments will have to be used
1147  * cover that data, so we don't know how many CTIO Request Entries we
1148  * will end up using. Further, for performance reasons we may want to
1149  * (on the last CTIO for Fibre Channel), send status too (if all went well).
1150  *
1151  * The standard vector still goes through isp_pci_dmasetup, but the callback
1152  * for the DMA mapping routines comes here instead with the whole transfer
1153  * mapped and a pointer to a partially filled in already allocated request
1154  * queue entry. We finish the job.
1155  */
1156 static void tdma_mk(void *, bus_dma_segment_t *, int, int);
1157 static void tdma_mkfc(void *, bus_dma_segment_t *, int, int);
1158
1159 #define STATUS_WITH_DATA        1
1160
1161 static void
1162 tdma_mk(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error)
1163 {
1164         mush_t *mp;
1165         struct ccb_scsiio *csio;
1166         struct ispsoftc *isp;
1167         struct isp_pcisoftc *pcs;
1168         bus_dmamap_t *dp;
1169         ct_entry_t *cto, *qe;
1170         u_int8_t scsi_status;
1171         u_int16_t curi, nxti, handle;
1172         u_int32_t sflags;
1173         int32_t resid;
1174         int nth_ctio, nctios, send_status;
1175
1176         mp = (mush_t *) arg;
1177         if (error) {
1178                 mp->error = error;
1179                 return;
1180         }
1181
1182         isp = mp->isp;
1183         csio = mp->cmd_token;
1184         cto = mp->rq;
1185         curi = isp->isp_reqidx;
1186         qe = (ct_entry_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, curi);
1187
1188         cto->ct_xfrlen = 0;
1189         cto->ct_seg_count = 0;
1190         cto->ct_header.rqs_entry_count = 1;
1191         MEMZERO(cto->ct_dataseg, sizeof(cto->ct_dataseg));
1192
1193         if (nseg == 0) {
1194                 cto->ct_header.rqs_seqno = 1;
1195                 isp_prt(isp, ISP_LOGTDEBUG1,
1196                     "CTIO[%x] lun%d iid%d tag %x flgs %x sts %x ssts %x res %d",
1197                     cto->ct_fwhandle, csio->ccb_h.target_lun, cto->ct_iid,
1198                     cto->ct_tag_val, cto->ct_flags, cto->ct_status,
1199                     cto->ct_scsi_status, cto->ct_resid);
1200                 ISP_TDQE(isp, "tdma_mk[no data]", curi, cto);
1201                 isp_put_ctio(isp, cto, qe);
1202                 return;
1203         }
1204
1205         nctios = nseg / ISP_RQDSEG;
1206         if (nseg % ISP_RQDSEG) {
1207                 nctios++;
1208         }
1209
1210         /*
1211          * Save syshandle, and potentially any SCSI status, which we'll
1212          * reinsert on the last CTIO we're going to send.
1213          */
1214
1215         handle = cto->ct_syshandle;
1216         cto->ct_syshandle = 0;
1217         cto->ct_header.rqs_seqno = 0;
1218         send_status = (cto->ct_flags & CT_SENDSTATUS) != 0;
1219
1220         if (send_status) {
1221                 sflags = cto->ct_flags & (CT_SENDSTATUS | CT_CCINCR);
1222                 cto->ct_flags &= ~(CT_SENDSTATUS | CT_CCINCR);
1223                 /*
1224                  * Preserve residual.
1225                  */
1226                 resid = cto->ct_resid;
1227
1228                 /*
1229                  * Save actual SCSI status.
1230                  */
1231                 scsi_status = cto->ct_scsi_status;
1232
1233 #ifndef STATUS_WITH_DATA
1234                 sflags |= CT_NO_DATA;
1235                 /*
1236                  * We can't do a status at the same time as a data CTIO, so
1237                  * we need to synthesize an extra CTIO at this level.
1238                  */
1239                 nctios++;
1240 #endif
1241         } else {
1242                 sflags = scsi_status = resid = 0;
1243         }
1244
1245         cto->ct_resid = 0;
1246         cto->ct_scsi_status = 0;
1247
1248         pcs = (struct isp_pcisoftc *)isp;
1249         dp = &pcs->dmaps[isp_handle_index(handle)];
1250         if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
1251                 bus_dmamap_sync(pcs->dmat, *dp, BUS_DMASYNC_PREREAD);
1252         } else {
1253                 bus_dmamap_sync(pcs->dmat, *dp, BUS_DMASYNC_PREWRITE);
1254         }
1255
1256         nxti = *mp->nxtip;
1257
1258         for (nth_ctio = 0; nth_ctio < nctios; nth_ctio++) {
1259                 int seglim;
1260
1261                 seglim = nseg;
1262                 if (seglim) {
1263                         int seg;
1264
1265                         if (seglim > ISP_RQDSEG)
1266                                 seglim = ISP_RQDSEG;
1267
1268                         for (seg = 0; seg < seglim; seg++, nseg--) {
1269                                 /*
1270                                  * Unlike normal initiator commands, we don't
1271                                  * do any swizzling here.
1272                                  */
1273                                 cto->ct_dataseg[seg].ds_count = dm_segs->ds_len;
1274                                 cto->ct_dataseg[seg].ds_base = dm_segs->ds_addr;
1275                                 cto->ct_xfrlen += dm_segs->ds_len;
1276                                 dm_segs++;
1277                         }
1278                         cto->ct_seg_count = seg;
1279                 } else {
1280                         /*
1281                          * This case should only happen when we're sending an
1282                          * extra CTIO with final status.
1283                          */
1284                         if (send_status == 0) {
1285                                 isp_prt(isp, ISP_LOGWARN,
1286                                     "tdma_mk ran out of segments");
1287                                 mp->error = EINVAL;
1288                                 return;
1289                         }
1290                 }
1291
1292                 /*
1293                  * At this point, the fields ct_lun, ct_iid, ct_tagval,
1294                  * ct_tagtype, and ct_timeout have been carried over
1295                  * unchanged from what our caller had set.
1296                  *
1297                  * The dataseg fields and the seg_count fields we just got
1298                  * through setting. The data direction we've preserved all
1299                  * along and only clear it if we're now sending status.
1300                  */
1301
1302                 if (nth_ctio == nctios - 1) {
1303                         /*
1304                          * We're the last in a sequence of CTIOs, so mark
1305                          * this CTIO and save the handle to the CCB such that
1306                          * when this CTIO completes we can free dma resources
1307                          * and do whatever else we need to do to finish the
1308                          * rest of the command. We *don't* give this to the
1309                          * firmware to work on- the caller will do that.
1310                          */
1311
1312                         cto->ct_syshandle = handle;
1313                         cto->ct_header.rqs_seqno = 1;
1314
1315                         if (send_status) {
1316                                 cto->ct_scsi_status = scsi_status;
1317                                 cto->ct_flags |= sflags;
1318                                 cto->ct_resid = resid;
1319                         }
1320                         if (send_status) {
1321                                 isp_prt(isp, ISP_LOGTDEBUG1,
1322                                     "CTIO[%x] lun%d iid %d tag %x ct_flags %x "
1323                                     "scsi status %x resid %d",
1324                                     cto->ct_fwhandle, csio->ccb_h.target_lun,
1325                                     cto->ct_iid, cto->ct_tag_val, cto->ct_flags,
1326                                     cto->ct_scsi_status, cto->ct_resid);
1327                         } else {
1328                                 isp_prt(isp, ISP_LOGTDEBUG1,
1329                                     "CTIO[%x] lun%d iid%d tag %x ct_flags 0x%x",
1330                                     cto->ct_fwhandle, csio->ccb_h.target_lun,
1331                                     cto->ct_iid, cto->ct_tag_val,
1332                                     cto->ct_flags);
1333                         }
1334                         isp_put_ctio(isp, cto, qe);
1335                         ISP_TDQE(isp, "last tdma_mk", curi, cto);
1336                         if (nctios > 1) {
1337                                 MEMORYBARRIER(isp, SYNC_REQUEST,
1338                                     curi, QENTRY_LEN);
1339                         }
1340                 } else {
1341                         ct_entry_t *oqe = qe;
1342
1343                         /*
1344                          * Make sure syshandle fields are clean
1345                          */
1346                         cto->ct_syshandle = 0;
1347                         cto->ct_header.rqs_seqno = 0;
1348
1349                         isp_prt(isp, ISP_LOGTDEBUG1,
1350                             "CTIO[%x] lun%d for ID%d ct_flags 0x%x",
1351                             cto->ct_fwhandle, csio->ccb_h.target_lun,
1352                             cto->ct_iid, cto->ct_flags);
1353
1354                         /*
1355                          * Get a new CTIO
1356                          */
1357                         qe = (ct_entry_t *)
1358                             ISP_QUEUE_ENTRY(isp->isp_rquest, nxti);
1359                         nxti = ISP_NXT_QENTRY(nxti, RQUEST_QUEUE_LEN(isp));
1360                         if (nxti == mp->optr) {
1361                                 isp_prt(isp, ISP_LOGTDEBUG0,
1362                                     "Queue Overflow in tdma_mk");
1363                                 mp->error = MUSHERR_NOQENTRIES;
1364                                 return;
1365                         }
1366
1367                         /*
1368                          * Now that we're done with the old CTIO,
1369                          * flush it out to the request queue.
1370                          */
1371                         ISP_TDQE(isp, "dma_tgt_fc", curi, cto);
1372                         isp_put_ctio(isp, cto, oqe);
1373                         if (nth_ctio != 0) {
1374                                 MEMORYBARRIER(isp, SYNC_REQUEST, curi,
1375                                     QENTRY_LEN);
1376                         }
1377                         curi = ISP_NXT_QENTRY(curi, RQUEST_QUEUE_LEN(isp));
1378
1379                         /*
1380                          * Reset some fields in the CTIO so we can reuse
1381                          * for the next one we'll flush to the request
1382                          * queue.
1383                          */
1384                         cto->ct_header.rqs_entry_type = RQSTYPE_CTIO;
1385                         cto->ct_header.rqs_entry_count = 1;
1386                         cto->ct_header.rqs_flags = 0;
1387                         cto->ct_status = 0;
1388                         cto->ct_scsi_status = 0;
1389                         cto->ct_xfrlen = 0;
1390                         cto->ct_resid = 0;
1391                         cto->ct_seg_count = 0;
1392                         MEMZERO(cto->ct_dataseg, sizeof(cto->ct_dataseg));
1393                 }
1394         }
1395         *mp->nxtip = nxti;
1396 }
1397
1398 /*
1399  * We don't have to do multiple CTIOs here. Instead, we can just do
1400  * continuation segments as needed. This greatly simplifies the code
1401  * improves performance.
1402  */
1403
1404 static void
1405 tdma_mkfc(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error)
1406 {
1407         mush_t *mp;
1408         struct ccb_scsiio *csio;
1409         struct ispsoftc *isp;
1410         ct2_entry_t *cto, *qe;
1411         u_int16_t curi, nxti;
1412         int segcnt;
1413
1414         mp = (mush_t *) arg;
1415         if (error) {
1416                 mp->error = error;
1417                 return;
1418         }
1419
1420         isp = mp->isp;
1421         csio = mp->cmd_token;
1422         cto = mp->rq;
1423
1424         curi = isp->isp_reqidx;
1425         qe = (ct2_entry_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, curi);
1426
1427         if (nseg == 0) {
1428                 if ((cto->ct_flags & CT2_FLAG_MMASK) != CT2_FLAG_MODE1) {
1429                         isp_prt(isp, ISP_LOGWARN,
1430                             "dma2_tgt_fc, a status CTIO2 without MODE1 "
1431                             "set (0x%x)", cto->ct_flags);
1432                         mp->error = EINVAL;
1433                         return;
1434                 }
1435                 /*
1436                  * We preserve ct_lun, ct_iid, ct_rxid. We set the data
1437                  * flags to NO DATA and clear relative offset flags.
1438                  * We preserve the ct_resid and the response area.
1439                  */
1440                 cto->ct_header.rqs_seqno = 1;
1441                 cto->ct_seg_count = 0;
1442                 cto->ct_reloff = 0;
1443                 isp_prt(isp, ISP_LOGTDEBUG1,
1444                     "CTIO2[%x] lun %d->iid%d flgs 0x%x sts 0x%x ssts "
1445                     "0x%x res %d", cto->ct_rxid, csio->ccb_h.target_lun,
1446                     cto->ct_iid, cto->ct_flags, cto->ct_status,
1447                     cto->rsp.m1.ct_scsi_status, cto->ct_resid);
1448                 isp_put_ctio2(isp, cto, qe);
1449                 ISP_TDQE(isp, "dma2_tgt_fc[no data]", curi, qe);
1450                 return;
1451         }
1452
1453         if ((cto->ct_flags & CT2_FLAG_MMASK) != CT2_FLAG_MODE0) {
1454                 isp_prt(isp, ISP_LOGERR,
1455                     "dma2_tgt_fc, a data CTIO2 without MODE0 set "
1456                     "(0x%x)", cto->ct_flags);
1457                 mp->error = EINVAL;
1458                 return;
1459         }
1460
1461
1462         nxti = *mp->nxtip;
1463
1464         /*
1465          * Set up the CTIO2 data segments.
1466          */
1467         for (segcnt = 0; cto->ct_seg_count < ISP_RQDSEG_T2 && segcnt < nseg;
1468             cto->ct_seg_count++, segcnt++) {
1469                 cto->rsp.m0.ct_dataseg[cto->ct_seg_count].ds_base =
1470                     dm_segs[segcnt].ds_addr;
1471                 cto->rsp.m0.ct_dataseg[cto->ct_seg_count].ds_count =
1472                     dm_segs[segcnt].ds_len;
1473                 cto->rsp.m0.ct_xfrlen += dm_segs[segcnt].ds_len;
1474                 isp_prt(isp, ISP_LOGTDEBUG1, "isp_send_ctio2: ent0[%d]0x%x:%d",
1475                     cto->ct_seg_count, dm_segs[segcnt].ds_addr,
1476                     dm_segs[segcnt].ds_len);
1477         }
1478
1479         while (segcnt < nseg) {
1480                 u_int16_t curip;
1481                 int seg;
1482                 ispcontreq_t local, *crq = &local, *qep;
1483
1484                 qep = (ispcontreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, nxti);
1485                 curip = nxti;
1486                 nxti = ISP_NXT_QENTRY(curip, RQUEST_QUEUE_LEN(isp));
1487                 if (nxti == mp->optr) {
1488                         ISP_UNLOCK(isp);
1489                         isp_prt(isp, ISP_LOGTDEBUG0,
1490                             "tdma_mkfc: request queue overflow");
1491                         mp->error = MUSHERR_NOQENTRIES;
1492                         return;
1493                 }
1494                 cto->ct_header.rqs_entry_count++;
1495                 MEMZERO((void *)crq, sizeof (*crq));
1496                 crq->req_header.rqs_entry_count = 1;
1497                 crq->req_header.rqs_entry_type = RQSTYPE_DATASEG;
1498                 for (seg = 0; segcnt < nseg && seg < ISP_CDSEG;
1499                     segcnt++, seg++) {
1500                         crq->req_dataseg[seg].ds_base = dm_segs[segcnt].ds_addr;
1501                         crq->req_dataseg[seg].ds_count = dm_segs[segcnt].ds_len;
1502                         isp_prt(isp, ISP_LOGTDEBUG1,
1503                             "isp_send_ctio2: ent%d[%d]%x:%u",
1504                             cto->ct_header.rqs_entry_count-1, seg,
1505                             dm_segs[segcnt].ds_addr, dm_segs[segcnt].ds_len);
1506                         cto->rsp.m0.ct_xfrlen += dm_segs[segcnt].ds_len;
1507                         cto->ct_seg_count++;
1508                 }
1509                 MEMORYBARRIER(isp, SYNC_REQUEST, curip, QENTRY_LEN);
1510                 isp_put_cont_req(isp, crq, qep);
1511                 ISP_TDQE(isp, "cont entry", curi, qep);
1512         }
1513
1514         /*
1515          * No do final twiddling for the CTIO itself.
1516          */
1517         cto->ct_header.rqs_seqno = 1;
1518         isp_prt(isp, ISP_LOGTDEBUG1,
1519             "CTIO2[%x] lun %d->iid%d flgs 0x%x sts 0x%x ssts 0x%x resid %d",
1520             cto->ct_rxid, csio->ccb_h.target_lun, (int) cto->ct_iid,
1521             cto->ct_flags, cto->ct_status, cto->rsp.m1.ct_scsi_status,
1522             cto->ct_resid);
1523         isp_put_ctio2(isp, cto, qe);
1524         ISP_TDQE(isp, "last dma2_tgt_fc", curi, qe);
1525         *mp->nxtip = nxti;
1526 }
1527 #endif
1528
1529 static void dma2(void *, bus_dma_segment_t *, int, int);
1530
1531 static void
1532 dma2(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error)
1533 {
1534         mush_t *mp;
1535         struct ispsoftc *isp;
1536         struct ccb_scsiio *csio;
1537         struct isp_pcisoftc *pcs;
1538         bus_dmamap_t *dp;
1539         bus_dma_segment_t *eseg;
1540         ispreq_t *rq;
1541         int seglim, datalen;
1542         u_int16_t nxti;
1543
1544         mp = (mush_t *) arg;
1545         if (error) {
1546                 mp->error = error;
1547                 return;
1548         }
1549
1550         if (nseg < 1) {
1551                 isp_prt(mp->isp, ISP_LOGERR, "bad segment count (%d)", nseg);
1552                 mp->error = EFAULT;
1553                 return;
1554         }
1555         csio = mp->cmd_token;
1556         isp = mp->isp;
1557         rq = mp->rq;
1558         pcs = (struct isp_pcisoftc *)mp->isp;
1559         dp = &pcs->dmaps[isp_handle_index(rq->req_handle)];
1560         nxti = *mp->nxtip;
1561
1562         if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
1563                 bus_dmamap_sync(pcs->dmat, *dp, BUS_DMASYNC_PREREAD);
1564         } else {
1565                 bus_dmamap_sync(pcs->dmat, *dp, BUS_DMASYNC_PREWRITE);
1566         }
1567
1568         datalen = XS_XFRLEN(csio);
1569
1570         /*
1571          * We're passed an initial partially filled in entry that
1572          * has most fields filled in except for data transfer
1573          * related values.
1574          *
1575          * Our job is to fill in the initial request queue entry and
1576          * then to start allocating and filling in continuation entries
1577          * until we've covered the entire transfer.
1578          */
1579
1580         if (IS_FC(isp)) {
1581                 seglim = ISP_RQDSEG_T2;
1582                 ((ispreqt2_t *)rq)->req_totalcnt = datalen;
1583                 if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
1584                         ((ispreqt2_t *)rq)->req_flags |= REQFLAG_DATA_IN;
1585                 } else {
1586                         ((ispreqt2_t *)rq)->req_flags |= REQFLAG_DATA_OUT;
1587                 }
1588         } else {
1589                 if (csio->cdb_len > 12) {
1590                         seglim = 0;
1591                 } else {
1592                         seglim = ISP_RQDSEG;
1593                 }
1594                 if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
1595                         rq->req_flags |= REQFLAG_DATA_IN;
1596                 } else {
1597                         rq->req_flags |= REQFLAG_DATA_OUT;
1598                 }
1599         }
1600
1601         eseg = dm_segs + nseg;
1602
1603         while (datalen != 0 && rq->req_seg_count < seglim && dm_segs != eseg) {
1604                 if (IS_FC(isp)) {
1605                         ispreqt2_t *rq2 = (ispreqt2_t *)rq;
1606                         rq2->req_dataseg[rq2->req_seg_count].ds_base =
1607                             dm_segs->ds_addr;
1608                         rq2->req_dataseg[rq2->req_seg_count].ds_count =
1609                             dm_segs->ds_len;
1610                 } else {
1611                         rq->req_dataseg[rq->req_seg_count].ds_base =
1612                                 dm_segs->ds_addr;
1613                         rq->req_dataseg[rq->req_seg_count].ds_count =
1614                                 dm_segs->ds_len;
1615                 }
1616                 datalen -= dm_segs->ds_len;
1617                 rq->req_seg_count++;
1618                 dm_segs++;
1619         }
1620
1621         while (datalen > 0 && dm_segs != eseg) {
1622                 u_int16_t onxti;
1623                 ispcontreq_t local, *crq = &local, *cqe;
1624
1625                 cqe = (ispcontreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, nxti);
1626                 onxti = nxti;
1627                 nxti = ISP_NXT_QENTRY(onxti, RQUEST_QUEUE_LEN(isp));
1628                 if (nxti == mp->optr) {
1629                         isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow++");
1630                         mp->error = MUSHERR_NOQENTRIES;
1631                         return;
1632                 }
1633                 rq->req_header.rqs_entry_count++;
1634                 MEMZERO((void *)crq, sizeof (*crq));
1635                 crq->req_header.rqs_entry_count = 1;
1636                 crq->req_header.rqs_entry_type = RQSTYPE_DATASEG;
1637
1638                 seglim = 0;
1639                 while (datalen > 0 && seglim < ISP_CDSEG && dm_segs != eseg) {
1640                         crq->req_dataseg[seglim].ds_base =
1641                             dm_segs->ds_addr;
1642                         crq->req_dataseg[seglim].ds_count =
1643                             dm_segs->ds_len;
1644                         rq->req_seg_count++;
1645                         dm_segs++;
1646                         seglim++;
1647                         datalen -= dm_segs->ds_len;
1648                 }
1649                 isp_put_cont_req(isp, crq, cqe);
1650                 MEMORYBARRIER(isp, SYNC_REQUEST, onxti, QENTRY_LEN);
1651         }
1652         *mp->nxtip = nxti;
1653 }
1654
1655 static int
1656 isp_pci_dmasetup(struct ispsoftc *isp, struct ccb_scsiio *csio, ispreq_t *rq,
1657         u_int16_t *nxtip, u_int16_t optr)
1658 {
1659         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
1660         ispreq_t *qep;
1661         bus_dmamap_t *dp = NULL;
1662         mush_t mush, *mp;
1663         void (*eptr)(void *, bus_dma_segment_t *, int, int);
1664
1665         qep = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, isp->isp_reqidx);
1666 #ifdef  ISP_TARGET_MODE
1667         if (csio->ccb_h.func_code == XPT_CONT_TARGET_IO) {
1668                 if (IS_FC(isp)) {
1669                         eptr = tdma_mkfc;
1670                 } else {
1671                         eptr = tdma_mk;
1672                 }
1673                 if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_NONE ||
1674                     (csio->dxfer_len == 0)) {
1675                         mp = &mush;
1676                         mp->isp = isp;
1677                         mp->cmd_token = csio;
1678                         mp->rq = rq;    /* really a ct_entry_t or ct2_entry_t */
1679                         mp->nxtip = nxtip;
1680                         mp->optr = optr;
1681                         mp->error = 0;
1682                         (*eptr)(mp, NULL, 0, 0);
1683                         goto mbxsync;
1684                 }
1685         } else
1686 #endif
1687         eptr = dma2;
1688
1689
1690         if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_NONE ||
1691             (csio->dxfer_len == 0)) {
1692                 rq->req_seg_count = 1;
1693                 goto mbxsync;
1694         }
1695
1696         /*
1697          * Do a virtual grapevine step to collect info for
1698          * the callback dma allocation that we have to use...
1699          */
1700         mp = &mush;
1701         mp->isp = isp;
1702         mp->cmd_token = csio;
1703         mp->rq = rq;
1704         mp->nxtip = nxtip;
1705         mp->optr = optr;
1706         mp->error = 0;
1707
1708         if ((csio->ccb_h.flags & CAM_SCATTER_VALID) == 0) {
1709                 if ((csio->ccb_h.flags & CAM_DATA_PHYS) == 0) {
1710                         int error;
1711                         dp = &pcs->dmaps[isp_handle_index(rq->req_handle)];
1712                         crit_enter();
1713                         error = bus_dmamap_load(pcs->dmat, *dp,
1714                             csio->data_ptr, csio->dxfer_len, eptr, mp, 0);
1715                         if (error == EINPROGRESS) {
1716                                 bus_dmamap_unload(pcs->dmat, *dp);
1717                                 mp->error = EINVAL;
1718                                 isp_prt(isp, ISP_LOGERR,
1719                                     "deferred dma allocation not supported");
1720                         } else if (error && mp->error == 0) {
1721 #ifdef  DIAGNOSTIC
1722                                 isp_prt(isp, ISP_LOGERR,
1723                                     "error %d in dma mapping code", error);
1724 #endif
1725                                 mp->error = error;
1726                         }
1727                         crit_exit();
1728                 } else {
1729                         /* Pointer to physical buffer */
1730                         struct bus_dma_segment seg;
1731                         seg.ds_addr = (bus_addr_t)csio->data_ptr;
1732                         seg.ds_len = csio->dxfer_len;
1733                         (*eptr)(mp, &seg, 1, 0);
1734                 }
1735         } else {
1736                 struct bus_dma_segment *segs;
1737
1738                 if ((csio->ccb_h.flags & CAM_DATA_PHYS) != 0) {
1739                         isp_prt(isp, ISP_LOGERR,
1740                             "Physical segment pointers unsupported");
1741                         mp->error = EINVAL;
1742                 } else if ((csio->ccb_h.flags & CAM_SG_LIST_PHYS) == 0) {
1743                         isp_prt(isp, ISP_LOGERR,
1744                             "Virtual segment addresses unsupported");
1745                         mp->error = EINVAL;
1746                 } else {
1747                         /* Just use the segments provided */
1748                         segs = (struct bus_dma_segment *) csio->data_ptr;
1749                         (*eptr)(mp, segs, csio->sglist_cnt, 0);
1750                 }
1751         }
1752         if (mp->error) {
1753                 int retval = CMD_COMPLETE;
1754                 if (mp->error == MUSHERR_NOQENTRIES) {
1755                         retval = CMD_EAGAIN;
1756                 } else if (mp->error == EFBIG) {
1757                         XS_SETERR(csio, CAM_REQ_TOO_BIG);
1758                 } else if (mp->error == EINVAL) {
1759                         XS_SETERR(csio, CAM_REQ_INVALID);
1760                 } else {
1761                         XS_SETERR(csio, CAM_UNREC_HBA_ERROR);
1762                 }
1763                 return (retval);
1764         }
1765 mbxsync:
1766         switch (rq->req_header.rqs_entry_type) {
1767         case RQSTYPE_REQUEST:
1768                 isp_put_request(isp, rq, qep);
1769                 break;
1770         case RQSTYPE_CMDONLY:
1771                 isp_put_extended_request(isp, (ispextreq_t *)rq,
1772                     (ispextreq_t *)qep);
1773                 break;
1774         case RQSTYPE_T2RQS:
1775                 isp_put_request_t2(isp, (ispreqt2_t *) rq, (ispreqt2_t *) qep);
1776                 break;
1777         }
1778         return (CMD_QUEUED);
1779 }
1780
1781 static void
1782 isp_pci_dmateardown(struct ispsoftc *isp, XS_T *xs, u_int16_t handle)
1783 {
1784         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
1785         bus_dmamap_t *dp = &pcs->dmaps[isp_handle_index(handle)];
1786         if ((xs->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
1787                 bus_dmamap_sync(pcs->dmat, *dp, BUS_DMASYNC_POSTREAD);
1788         } else {
1789                 bus_dmamap_sync(pcs->dmat, *dp, BUS_DMASYNC_POSTWRITE);
1790         }
1791         bus_dmamap_unload(pcs->dmat, *dp);
1792 }
1793
1794
1795 static void
1796 isp_pci_reset1(struct ispsoftc *isp)
1797 {
1798         /* Make sure the BIOS is disabled */
1799         isp_pci_wr_reg(isp, HCCR, PCI_HCCR_CMD_BIOS);
1800         /* and enable interrupts */
1801         ENABLE_INTS(isp);
1802 }
1803
1804 static void
1805 isp_pci_dumpregs(struct ispsoftc *isp, const char *msg)
1806 {
1807         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
1808         if (msg)
1809                 kprintf("%s: %s\n", device_get_nameunit(isp->isp_dev), msg);
1810         else
1811                 kprintf("%s:\n", device_get_nameunit(isp->isp_dev));
1812         if (IS_SCSI(isp))
1813                 kprintf("    biu_conf1=%x", ISP_READ(isp, BIU_CONF1));
1814         else
1815                 kprintf("    biu_csr=%x", ISP_READ(isp, BIU2100_CSR));
1816         kprintf(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR),
1817             ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA));
1818         kprintf("risc_hccr=%x\n", ISP_READ(isp, HCCR));
1819
1820
1821         if (IS_SCSI(isp)) {
1822                 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
1823                 kprintf("    cdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n",
1824                         ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS),
1825                         ISP_READ(isp, CDMA_FIFO_STS));
1826                 kprintf("    ddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n",
1827                         ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS),
1828                         ISP_READ(isp, DDMA_FIFO_STS));
1829                 kprintf("    sxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n",
1830                         ISP_READ(isp, SXP_INTERRUPT),
1831                         ISP_READ(isp, SXP_GROSS_ERR),
1832                         ISP_READ(isp, SXP_PINS_CTRL));
1833                 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
1834         }
1835         kprintf("    mbox regs: %x %x %x %x %x\n",
1836             ISP_READ(isp, OUTMAILBOX0), ISP_READ(isp, OUTMAILBOX1),
1837             ISP_READ(isp, OUTMAILBOX2), ISP_READ(isp, OUTMAILBOX3),
1838             ISP_READ(isp, OUTMAILBOX4));
1839         kprintf("    PCI Status Command/Status=%x\n",
1840             pci_read_config(pcs->pci_dev, PCIR_COMMAND, 1));
1841 }