sys/dev/isp/isp_pci.c

   1 /*-
   2  * Copyright (c) 1997-2008 by Matthew Jacob
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice immediately at the beginning of the file, without modification,
  10  *    this list of conditions, and the following disclaimer.
  11  * 2. The name of the author may not be used to endorse or promote products
  12  *    derived from this software without specific prior written permission.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  18  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26 /*
  27  * PCI specific probe and attach routines for Qlogic ISP SCSI adapters.
  28  * FreeBSD Version.
  29  */
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32
  33 #include <sys/param.h>
  34 #include <sys/systm.h>
  35 #include <sys/kernel.h>
  36 #include <sys/module.h>
  37 #include <sys/linker.h>
  38 #include <sys/firmware.h>
  39 #include <sys/bus.h>
  40 #include <sys/stdint.h>
  41 #include <dev/pci/pcireg.h>
  42 #include <dev/pci/pcivar.h>
  43 #include <machine/bus.h>
  44 #include <machine/resource.h>
  45 #include <sys/rman.h>
  46 #include <sys/malloc.h>
  47 #include <sys/uio.h>
  48
  49 #ifdef __sparc64__
  50 #include <dev/ofw/openfirm.h>
  51 #include <machine/ofw_machdep.h>
  52 #endif
  53
  54 #include <dev/isp/isp_freebsd.h>
  55
  56 static uint32_t isp_pci_rd_reg(ispsoftc_t *, int);
  57 static void isp_pci_wr_reg(ispsoftc_t *, int, uint32_t);
  58 static uint32_t isp_pci_rd_reg_1080(ispsoftc_t *, int);
  59 static void isp_pci_wr_reg_1080(ispsoftc_t *, int, uint32_t);
  60 static uint32_t isp_pci_rd_reg_2400(ispsoftc_t *, int);
  61 static void isp_pci_wr_reg_2400(ispsoftc_t *, int, uint32_t);
  62 static uint32_t isp_pci_rd_reg_2600(ispsoftc_t *, int);
  63 static void isp_pci_wr_reg_2600(ispsoftc_t *, int, uint32_t);
  64 static int isp_pci_rd_isr(ispsoftc_t *, uint16_t *, uint16_t *, uint16_t *);
  65 static int isp_pci_rd_isr_2300(ispsoftc_t *, uint16_t *, uint16_t *, uint16_t *);
  66 static int isp_pci_rd_isr_2400(ispsoftc_t *, uint16_t *, uint16_t *, uint16_t *);
  67 static int isp_pci_mbxdma(ispsoftc_t *);
  68 static int isp_pci_dmasetup(ispsoftc_t *, XS_T *, void *);
  69
  70
  71 static void isp_pci_reset0(ispsoftc_t *);
  72 static void isp_pci_reset1(ispsoftc_t *);
  73 static void isp_pci_dumpregs(ispsoftc_t *, const char *);
  74
  75 static struct ispmdvec mdvec = {
  76         isp_pci_rd_isr,
  77         isp_pci_rd_reg,
  78         isp_pci_wr_reg,
  79         isp_pci_mbxdma,
  80         isp_pci_dmasetup,
  81         isp_common_dmateardown,
  82         isp_pci_reset0,
  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_1080 = {
  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_common_dmateardown,
  96         isp_pci_reset0,
  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_12160 = {
 104         isp_pci_rd_isr,
 105         isp_pci_rd_reg_1080,
 106         isp_pci_wr_reg_1080,
 107         isp_pci_mbxdma,
 108         isp_pci_dmasetup,
 109         isp_common_dmateardown,
 110         isp_pci_reset0,
 111         isp_pci_reset1,
 112         isp_pci_dumpregs,
 113         NULL,
 114         BIU_BURST_ENABLE|BIU_PCI_CONF1_FIFO_64
 115 };
 116
 117 static struct ispmdvec mdvec_2100 = {
 118         isp_pci_rd_isr,
 119         isp_pci_rd_reg,
 120         isp_pci_wr_reg,
 121         isp_pci_mbxdma,
 122         isp_pci_dmasetup,
 123         isp_common_dmateardown,
 124         isp_pci_reset0,
 125         isp_pci_reset1,
 126         isp_pci_dumpregs
 127 };
 128
 129 static struct ispmdvec mdvec_2200 = {
 130         isp_pci_rd_isr,
 131         isp_pci_rd_reg,
 132         isp_pci_wr_reg,
 133         isp_pci_mbxdma,
 134         isp_pci_dmasetup,
 135         isp_common_dmateardown,
 136         isp_pci_reset0,
 137         isp_pci_reset1,
 138         isp_pci_dumpregs
 139 };
 140
 141 static struct ispmdvec mdvec_2300 = {
 142         isp_pci_rd_isr_2300,
 143         isp_pci_rd_reg,
 144         isp_pci_wr_reg,
 145         isp_pci_mbxdma,
 146         isp_pci_dmasetup,
 147         isp_common_dmateardown,
 148         isp_pci_reset0,
 149         isp_pci_reset1,
 150         isp_pci_dumpregs
 151 };
 152
 153 static struct ispmdvec mdvec_2400 = {
 154         isp_pci_rd_isr_2400,
 155         isp_pci_rd_reg_2400,
 156         isp_pci_wr_reg_2400,
 157         isp_pci_mbxdma,
 158         isp_pci_dmasetup,
 159         isp_common_dmateardown,
 160         isp_pci_reset0,
 161         isp_pci_reset1,
 162         NULL
 163 };
 164
 165 static struct ispmdvec mdvec_2500 = {
 166         isp_pci_rd_isr_2400,
 167         isp_pci_rd_reg_2400,
 168         isp_pci_wr_reg_2400,
 169         isp_pci_mbxdma,
 170         isp_pci_dmasetup,
 171         isp_common_dmateardown,
 172         isp_pci_reset0,
 173         isp_pci_reset1,
 174         NULL
 175 };
 176
 177 static struct ispmdvec mdvec_2600 = {
 178         isp_pci_rd_isr_2400,
 179         isp_pci_rd_reg_2600,
 180         isp_pci_wr_reg_2600,
 181         isp_pci_mbxdma,
 182         isp_pci_dmasetup,
 183         isp_common_dmateardown,
 184         isp_pci_reset0,
 185         isp_pci_reset1,
 186         NULL
 187 };
 188
 189 #ifndef PCIM_CMD_INVEN
 190 #define PCIM_CMD_INVEN                  0x10
 191 #endif
 192 #ifndef PCIM_CMD_BUSMASTEREN
 193 #define PCIM_CMD_BUSMASTEREN            0x0004
 194 #endif
 195 #ifndef PCIM_CMD_PERRESPEN
 196 #define PCIM_CMD_PERRESPEN              0x0040
 197 #endif
 198 #ifndef PCIM_CMD_SEREN
 199 #define PCIM_CMD_SEREN                  0x0100
 200 #endif
 201 #ifndef PCIM_CMD_INTX_DISABLE
 202 #define PCIM_CMD_INTX_DISABLE           0x0400
 203 #endif
 204
 205 #ifndef PCIR_COMMAND
 206 #define PCIR_COMMAND                    0x04
 207 #endif
 208
 209 #ifndef PCIR_CACHELNSZ
 210 #define PCIR_CACHELNSZ                  0x0c
 211 #endif
 212
 213 #ifndef PCIR_LATTIMER
 214 #define PCIR_LATTIMER                   0x0d
 215 #endif
 216
 217 #ifndef PCIR_ROMADDR
 218 #define PCIR_ROMADDR                    0x30
 219 #endif
 220
 221 #ifndef PCI_VENDOR_QLOGIC
 222 #define PCI_VENDOR_QLOGIC               0x1077
 223 #endif
 224
 225 #ifndef PCI_PRODUCT_QLOGIC_ISP1020
 226 #define PCI_PRODUCT_QLOGIC_ISP1020      0x1020
 227 #endif
 228
 229 #ifndef PCI_PRODUCT_QLOGIC_ISP1080
 230 #define PCI_PRODUCT_QLOGIC_ISP1080      0x1080
 231 #endif
 232
 233 #ifndef PCI_PRODUCT_QLOGIC_ISP10160
 234 #define PCI_PRODUCT_QLOGIC_ISP10160     0x1016
 235 #endif
 236
 237 #ifndef PCI_PRODUCT_QLOGIC_ISP12160
 238 #define PCI_PRODUCT_QLOGIC_ISP12160     0x1216
 239 #endif
 240
 241 #ifndef PCI_PRODUCT_QLOGIC_ISP1240
 242 #define PCI_PRODUCT_QLOGIC_ISP1240      0x1240
 243 #endif
 244
 245 #ifndef PCI_PRODUCT_QLOGIC_ISP1280
 246 #define PCI_PRODUCT_QLOGIC_ISP1280      0x1280
 247 #endif
 248
 249 #ifndef PCI_PRODUCT_QLOGIC_ISP2100
 250 #define PCI_PRODUCT_QLOGIC_ISP2100      0x2100
 251 #endif
 252
 253 #ifndef PCI_PRODUCT_QLOGIC_ISP2200
 254 #define PCI_PRODUCT_QLOGIC_ISP2200      0x2200
 255 #endif
 256
 257 #ifndef PCI_PRODUCT_QLOGIC_ISP2300
 258 #define PCI_PRODUCT_QLOGIC_ISP2300      0x2300
 259 #endif
 260
 261 #ifndef PCI_PRODUCT_QLOGIC_ISP2312
 262 #define PCI_PRODUCT_QLOGIC_ISP2312      0x2312
 263 #endif
 264
 265 #ifndef PCI_PRODUCT_QLOGIC_ISP2322
 266 #define PCI_PRODUCT_QLOGIC_ISP2322      0x2322
 267 #endif
 268
 269 #ifndef PCI_PRODUCT_QLOGIC_ISP2422
 270 #define PCI_PRODUCT_QLOGIC_ISP2422      0x2422
 271 #endif
 272
 273 #ifndef PCI_PRODUCT_QLOGIC_ISP2432
 274 #define PCI_PRODUCT_QLOGIC_ISP2432      0x2432
 275 #endif
 276
 277 #ifndef PCI_PRODUCT_QLOGIC_ISP2532
 278 #define PCI_PRODUCT_QLOGIC_ISP2532      0x2532
 279 #endif
 280
 281 #ifndef PCI_PRODUCT_QLOGIC_ISP6312
 282 #define PCI_PRODUCT_QLOGIC_ISP6312      0x6312
 283 #endif
 284
 285 #ifndef PCI_PRODUCT_QLOGIC_ISP6322
 286 #define PCI_PRODUCT_QLOGIC_ISP6322      0x6322
 287 #endif
 288
 289 #ifndef        PCI_PRODUCT_QLOGIC_ISP5432
 290 #define        PCI_PRODUCT_QLOGIC_ISP5432      0x5432
 291 #endif
 292
 293 #ifndef PCI_PRODUCT_QLOGIC_ISP2031
 294 #define PCI_PRODUCT_QLOGIC_ISP2031      0x2031
 295 #endif
 296
 297 #ifndef PCI_PRODUCT_QLOGIC_ISP8031
 298 #define PCI_PRODUCT_QLOGIC_ISP8031      0x8031
 299 #endif
 300
 301 #define        PCI_QLOGIC_ISP5432      \
 302        ((PCI_PRODUCT_QLOGIC_ISP5432 << 16) | PCI_VENDOR_QLOGIC)
 303
 304 #define PCI_QLOGIC_ISP1020      \
 305         ((PCI_PRODUCT_QLOGIC_ISP1020 << 16) | PCI_VENDOR_QLOGIC)
 306
 307 #define PCI_QLOGIC_ISP1080      \
 308         ((PCI_PRODUCT_QLOGIC_ISP1080 << 16) | PCI_VENDOR_QLOGIC)
 309
 310 #define PCI_QLOGIC_ISP10160     \
 311         ((PCI_PRODUCT_QLOGIC_ISP10160 << 16) | PCI_VENDOR_QLOGIC)
 312
 313 #define PCI_QLOGIC_ISP12160     \
 314         ((PCI_PRODUCT_QLOGIC_ISP12160 << 16) | PCI_VENDOR_QLOGIC)
 315
 316 #define PCI_QLOGIC_ISP1240      \
 317         ((PCI_PRODUCT_QLOGIC_ISP1240 << 16) | PCI_VENDOR_QLOGIC)
 318
 319 #define PCI_QLOGIC_ISP1280      \
 320         ((PCI_PRODUCT_QLOGIC_ISP1280 << 16) | PCI_VENDOR_QLOGIC)
 321
 322 #define PCI_QLOGIC_ISP2100      \
 323         ((PCI_PRODUCT_QLOGIC_ISP2100 << 16) | PCI_VENDOR_QLOGIC)
 324
 325 #define PCI_QLOGIC_ISP2200      \
 326         ((PCI_PRODUCT_QLOGIC_ISP2200 << 16) | PCI_VENDOR_QLOGIC)
 327
 328 #define PCI_QLOGIC_ISP2300      \
 329         ((PCI_PRODUCT_QLOGIC_ISP2300 << 16) | PCI_VENDOR_QLOGIC)
 330
 331 #define PCI_QLOGIC_ISP2312      \
 332         ((PCI_PRODUCT_QLOGIC_ISP2312 << 16) | PCI_VENDOR_QLOGIC)
 333
 334 #define PCI_QLOGIC_ISP2322      \
 335         ((PCI_PRODUCT_QLOGIC_ISP2322 << 16) | PCI_VENDOR_QLOGIC)
 336
 337 #define PCI_QLOGIC_ISP2422      \
 338         ((PCI_PRODUCT_QLOGIC_ISP2422 << 16) | PCI_VENDOR_QLOGIC)
 339
 340 #define PCI_QLOGIC_ISP2432      \
 341         ((PCI_PRODUCT_QLOGIC_ISP2432 << 16) | PCI_VENDOR_QLOGIC)
 342
 343 #define PCI_QLOGIC_ISP2532      \
 344         ((PCI_PRODUCT_QLOGIC_ISP2532 << 16) | PCI_VENDOR_QLOGIC)
 345
 346 #define PCI_QLOGIC_ISP6312      \
 347         ((PCI_PRODUCT_QLOGIC_ISP6312 << 16) | PCI_VENDOR_QLOGIC)
 348
 349 #define PCI_QLOGIC_ISP6322      \
 350         ((PCI_PRODUCT_QLOGIC_ISP6322 << 16) | PCI_VENDOR_QLOGIC)
 351
 352 #define PCI_QLOGIC_ISP2031      \
 353         ((PCI_PRODUCT_QLOGIC_ISP2031 << 16) | PCI_VENDOR_QLOGIC)
 354
 355 #define PCI_QLOGIC_ISP8031      \
 356         ((PCI_PRODUCT_QLOGIC_ISP8031 << 16) | PCI_VENDOR_QLOGIC)
 357
 358 /*
 359  * Odd case for some AMI raid cards... We need to *not* attach to this.
 360  */
 361 #define AMI_RAID_SUBVENDOR_ID   0x101e
 362
 363 #define PCI_DFLT_LTNCY  0x40
 364 #define PCI_DFLT_LNSZ   0x10
 365
 366 static int isp_pci_probe (device_t);
 367 static int isp_pci_attach (device_t);
 368 static int isp_pci_detach (device_t);
 369
 370
 371 #define ISP_PCD(isp)    ((struct isp_pcisoftc *)isp)->pci_dev
 372 struct isp_pcisoftc {
 373         ispsoftc_t                      pci_isp;
 374         device_t                        pci_dev;
 375         struct resource *               regs;
 376         struct resource *               regs1;
 377         struct resource *               regs2;
 378         void *                          irq;
 379         int                             iqd;
 380         int                             rtp;
 381         int                             rgd;
 382         int                             rtp1;
 383         int                             rgd1;
 384         int                             rtp2;
 385         int                             rgd2;
 386         void *                          ih;
 387         int16_t                         pci_poff[_NREG_BLKS];
 388         bus_dma_tag_t                   dmat;
 389         int                             msicount;
 390 };
 391
 392
 393 static device_method_t isp_pci_methods[] = {
 394         /* Device interface */
 395         DEVMETHOD(device_probe,         isp_pci_probe),
 396         DEVMETHOD(device_attach,        isp_pci_attach),
 397         DEVMETHOD(device_detach,        isp_pci_detach),
 398         { 0, 0 }
 399 };
 400
 401 static driver_t isp_pci_driver = {
 402         "isp", isp_pci_methods, sizeof (struct isp_pcisoftc)
 403 };
 404 static devclass_t isp_devclass;
 405 DRIVER_MODULE(isp, pci, isp_pci_driver, isp_devclass, 0, 0);
 406 MODULE_DEPEND(isp, cam, 1, 1, 1);
 407 MODULE_DEPEND(isp, firmware, 1, 1, 1);
 408 static int isp_nvports = 0;
 409
 410 static int
 411 isp_pci_probe(device_t dev)
 412 {
 413         switch ((pci_get_device(dev) << 16) | (pci_get_vendor(dev))) {
 414         case PCI_QLOGIC_ISP1020:
 415                 device_set_desc(dev, "Qlogic ISP 1020/1040 PCI SCSI Adapter");
 416                 break;
 417         case PCI_QLOGIC_ISP1080:
 418                 device_set_desc(dev, "Qlogic ISP 1080 PCI SCSI Adapter");
 419                 break;
 420         case PCI_QLOGIC_ISP1240:
 421                 device_set_desc(dev, "Qlogic ISP 1240 PCI SCSI Adapter");
 422                 break;
 423         case PCI_QLOGIC_ISP1280:
 424                 device_set_desc(dev, "Qlogic ISP 1280 PCI SCSI Adapter");
 425                 break;
 426         case PCI_QLOGIC_ISP10160:
 427                 device_set_desc(dev, "Qlogic ISP 10160 PCI SCSI Adapter");
 428                 break;
 429         case PCI_QLOGIC_ISP12160:
 430                 if (pci_get_subvendor(dev) == AMI_RAID_SUBVENDOR_ID) {
 431                         return (ENXIO);
 432                 }
 433                 device_set_desc(dev, "Qlogic ISP 12160 PCI SCSI Adapter");
 434                 break;
 435         case PCI_QLOGIC_ISP2100:
 436                 device_set_desc(dev, "Qlogic ISP 2100 PCI FC-AL Adapter");
 437                 break;
 438         case PCI_QLOGIC_ISP2200:
 439                 device_set_desc(dev, "Qlogic ISP 2200 PCI FC-AL Adapter");
 440                 break;
 441         case PCI_QLOGIC_ISP2300:
 442                 device_set_desc(dev, "Qlogic ISP 2300 PCI FC-AL Adapter");
 443                 break;
 444         case PCI_QLOGIC_ISP2312:
 445                 device_set_desc(dev, "Qlogic ISP 2312 PCI FC-AL Adapter");
 446                 break;
 447         case PCI_QLOGIC_ISP2322:
 448                 device_set_desc(dev, "Qlogic ISP 2322 PCI FC-AL Adapter");
 449                 break;
 450         case PCI_QLOGIC_ISP2422:
 451                 device_set_desc(dev, "Qlogic ISP 2422 PCI FC-AL Adapter");
 452                 break;
 453         case PCI_QLOGIC_ISP2432:
 454                 device_set_desc(dev, "Qlogic ISP 2432 PCI FC-AL Adapter");
 455                 break;
 456         case PCI_QLOGIC_ISP2532:
 457                 device_set_desc(dev, "Qlogic ISP 2532 PCI FC-AL Adapter");
 458                 break;
 459         case PCI_QLOGIC_ISP5432:
 460                 device_set_desc(dev, "Qlogic ISP 5432 PCI FC-AL Adapter");
 461                 break;
 462         case PCI_QLOGIC_ISP6312:
 463                 device_set_desc(dev, "Qlogic ISP 6312 PCI FC-AL Adapter");
 464                 break;
 465         case PCI_QLOGIC_ISP6322:
 466                 device_set_desc(dev, "Qlogic ISP 6322 PCI FC-AL Adapter");
 467                 break;
 468         case PCI_QLOGIC_ISP2031:
 469                 device_set_desc(dev, "Qlogic ISP 2031 PCI FC-AL Adapter");
 470                 break;
 471         case PCI_QLOGIC_ISP8031:
 472                 device_set_desc(dev, "Qlogic ISP 8031 PCI FCoE Adapter");
 473                 break;
 474         default:
 475                 return (ENXIO);
 476         }
 477         if (isp_announced == 0 && bootverbose) {
 478                 printf("Qlogic ISP Driver, FreeBSD Version %d.%d, "
 479                     "Core Version %d.%d\n",
 480                     ISP_PLATFORM_VERSION_MAJOR, ISP_PLATFORM_VERSION_MINOR,
 481                     ISP_CORE_VERSION_MAJOR, ISP_CORE_VERSION_MINOR);
 482                 isp_announced++;
 483         }
 484         /*
 485          * XXXX: Here is where we might load the f/w module
 486          * XXXX: (or increase a reference count to it).
 487          */
 488         return (BUS_PROBE_DEFAULT);
 489 }
 490
 491 static void
 492 isp_get_generic_options(device_t dev, ispsoftc_t *isp)
 493 {
 494         int tval;
 495
 496         tval = 0;
 497         if (resource_int_value(device_get_name(dev), device_get_unit(dev), "fwload_disable", &tval) == 0 && tval != 0) {
 498                 isp->isp_confopts |= ISP_CFG_NORELOAD;
 499         }
 500         tval = 0;
 501         if (resource_int_value(device_get_name(dev), device_get_unit(dev), "ignore_nvram", &tval) == 0 && tval != 0) {
 502                 isp->isp_confopts |= ISP_CFG_NONVRAM;
 503         }
 504         tval = 0;
 505         (void) resource_int_value(device_get_name(dev), device_get_unit(dev), "debug", &tval);
 506         if (tval) {
 507                 isp->isp_dblev = tval;
 508         } else {
 509                 isp->isp_dblev = ISP_LOGWARN|ISP_LOGERR;
 510         }
 511         if (bootverbose) {
 512                 isp->isp_dblev |= ISP_LOGCONFIG|ISP_LOGINFO;
 513         }
 514         tval = -1;
 515         (void) resource_int_value(device_get_name(dev), device_get_unit(dev), "vports", &tval);
 516         if (tval > 0 && tval <= 254) {
 517                 isp_nvports = tval;
 518         }
 519         tval = 7;
 520         (void) resource_int_value(device_get_name(dev), device_get_unit(dev), "quickboot_time", &tval);
 521         isp_quickboot_time = tval;
 522 }
 523
 524 static void
 525 isp_get_specific_options(device_t dev, int chan, ispsoftc_t *isp)
 526 {
 527         const char *sptr;
 528         int tval = 0;
 529         char prefix[12], name[16];
 530
 531         if (chan == 0)
 532                 prefix[0] = 0;
 533         else
 534                 snprintf(prefix, sizeof(prefix), "chan%d.", chan);
 535         snprintf(name, sizeof(name), "%siid", prefix);
 536         if (resource_int_value(device_get_name(dev), device_get_unit(dev),
 537             name, &tval)) {
 538                 if (IS_FC(isp)) {
 539                         ISP_FC_PC(isp, chan)->default_id = 109 - chan;
 540                 } else {
 541 #ifdef __sparc64__
 542                         ISP_SPI_PC(isp, chan)->iid = OF_getscsinitid(dev);
 543 #else
 544                         ISP_SPI_PC(isp, chan)->iid = 7;
 545 #endif
 546                 }
 547         } else {
 548                 if (IS_FC(isp)) {
 549                         ISP_FC_PC(isp, chan)->default_id = tval - chan;
 550                 } else {
 551                         ISP_SPI_PC(isp, chan)->iid = tval;
 552                 }
 553                 isp->isp_confopts |= ISP_CFG_OWNLOOPID;
 554         }
 555
 556         if (IS_SCSI(isp))
 557                 return;
 558
 559         tval = -1;
 560         snprintf(name, sizeof(name), "%srole", prefix);
 561         if (resource_int_value(device_get_name(dev), device_get_unit(dev),
 562             name, &tval) == 0) {
 563                 switch (tval) {
 564                 case ISP_ROLE_NONE:
 565                 case ISP_ROLE_INITIATOR:
 566                 case ISP_ROLE_TARGET:
 567                 case ISP_ROLE_BOTH:
 568                         device_printf(dev, "Chan %d setting role to 0x%x\n", chan, tval);
 569                         break;
 570                 default:
 571                         tval = -1;
 572                         break;
 573                 }
 574         }
 575         if (tval == -1) {
 576                 tval = ISP_DEFAULT_ROLES;
 577         }
 578         ISP_FC_PC(isp, chan)->def_role = tval;
 579
 580         tval = 0;
 581         snprintf(name, sizeof(name), "%sfullduplex", prefix);
 582         if (resource_int_value(device_get_name(dev), device_get_unit(dev),
 583             name, &tval) == 0 && tval != 0) {
 584                 isp->isp_confopts |= ISP_CFG_FULL_DUPLEX;
 585         }
 586         sptr = 0;
 587         snprintf(name, sizeof(name), "%stopology", prefix);
 588         if (resource_string_value(device_get_name(dev), device_get_unit(dev),
 589             name, (const char **) &sptr) == 0 && sptr != 0) {
 590                 if (strcmp(sptr, "lport") == 0) {
 591                         isp->isp_confopts |= ISP_CFG_LPORT;
 592                 } else if (strcmp(sptr, "nport") == 0) {
 593                         isp->isp_confopts |= ISP_CFG_NPORT;
 594                 } else if (strcmp(sptr, "lport-only") == 0) {
 595                         isp->isp_confopts |= ISP_CFG_LPORT_ONLY;
 596                 } else if (strcmp(sptr, "nport-only") == 0) {
 597                         isp->isp_confopts |= ISP_CFG_NPORT_ONLY;
 598                 }
 599         }
 600
 601         tval = 0;
 602         snprintf(name, sizeof(name), "%snofctape", prefix);
 603         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 604             name, &tval);
 605         if (tval) {
 606                 isp->isp_confopts |= ISP_CFG_NOFCTAPE;
 607         }
 608
 609         tval = 0;
 610         snprintf(name, sizeof(name), "%sfctape", prefix);
 611         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 612             name, &tval);
 613         if (tval) {
 614                 isp->isp_confopts &= ~ISP_CFG_NOFCTAPE;
 615                 isp->isp_confopts |= ISP_CFG_FCTAPE;
 616         }
 617
 618
 619         /*
 620          * Because the resource_*_value functions can neither return
 621          * 64 bit integer values, nor can they be directly coerced
 622          * to interpret the right hand side of the assignment as
 623          * you want them to interpret it, we have to force WWN
 624          * hint replacement to specify WWN strings with a leading
 625          * 'w' (e..g w50000000aaaa0001). Sigh.
 626          */
 627         sptr = 0;
 628         snprintf(name, sizeof(name), "%sportwwn", prefix);
 629         tval = resource_string_value(device_get_name(dev), device_get_unit(dev),
 630             name, (const char **) &sptr);
 631         if (tval == 0 && sptr != 0 && *sptr++ == 'w') {
 632                 char *eptr = 0;
 633                 ISP_FC_PC(isp, chan)->def_wwpn = strtouq(sptr, &eptr, 16);
 634                 if (eptr < sptr + 16 || ISP_FC_PC(isp, chan)->def_wwpn == -1) {
 635                         device_printf(dev, "mangled portwwn hint '%s'\n", sptr);
 636                         ISP_FC_PC(isp, chan)->def_wwpn = 0;
 637                 }
 638         }
 639
 640         sptr = 0;
 641         snprintf(name, sizeof(name), "%snodewwn", prefix);
 642         tval = resource_string_value(device_get_name(dev), device_get_unit(dev),
 643             name, (const char **) &sptr);
 644         if (tval == 0 && sptr != 0 && *sptr++ == 'w') {
 645                 char *eptr = 0;
 646                 ISP_FC_PC(isp, chan)->def_wwnn = strtouq(sptr, &eptr, 16);
 647                 if (eptr < sptr + 16 || ISP_FC_PC(isp, chan)->def_wwnn == 0) {
 648                         device_printf(dev, "mangled nodewwn hint '%s'\n", sptr);
 649                         ISP_FC_PC(isp, chan)->def_wwnn = 0;
 650                 }
 651         }
 652
 653         tval = -1;
 654         snprintf(name, sizeof(name), "%sloop_down_limit", prefix);
 655         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 656             name, &tval);
 657         if (tval >= 0 && tval < 0xffff) {
 658                 ISP_FC_PC(isp, chan)->loop_down_limit = tval;
 659         } else {
 660                 ISP_FC_PC(isp, chan)->loop_down_limit = isp_loop_down_limit;
 661         }
 662
 663         tval = -1;
 664         snprintf(name, sizeof(name), "%sgone_device_time", prefix);
 665         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 666             name, &tval);
 667         if (tval >= 0 && tval < 0xffff) {
 668                 ISP_FC_PC(isp, chan)->gone_device_time = tval;
 669         } else {
 670                 ISP_FC_PC(isp, chan)->gone_device_time = isp_gone_device_time;
 671         }
 672 }
 673
 674 static int
 675 isp_pci_attach(device_t dev)
 676 {
 677         int i, locksetup = 0;
 678         uint32_t data, cmd, linesz, did;
 679         struct isp_pcisoftc *pcs;
 680         ispsoftc_t *isp;
 681         size_t psize, xsize;
 682         char fwname[32];
 683
 684         pcs = device_get_softc(dev);
 685         if (pcs == NULL) {
 686                 device_printf(dev, "cannot get softc\n");
 687                 return (ENOMEM);
 688         }
 689         memset(pcs, 0, sizeof (*pcs));
 690
 691         pcs->pci_dev = dev;
 692         isp = &pcs->pci_isp;
 693         isp->isp_dev = dev;
 694         isp->isp_nchan = 1;
 695         if (sizeof (bus_addr_t) > 4)
 696                 isp->isp_osinfo.sixtyfourbit = 1;
 697
 698         /*
 699          * Get Generic Options
 700          */
 701         isp_nvports = 0;
 702         isp_get_generic_options(dev, isp);
 703
 704         linesz = PCI_DFLT_LNSZ;
 705         pcs->irq = pcs->regs = pcs->regs2 = NULL;
 706         pcs->rgd = pcs->rtp = pcs->iqd = 0;
 707
 708         pcs->pci_dev = dev;
 709         pcs->pci_poff[BIU_BLOCK >> _BLK_REG_SHFT] = BIU_REGS_OFF;
 710         pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = PCI_MBOX_REGS_OFF;
 711         pcs->pci_poff[SXP_BLOCK >> _BLK_REG_SHFT] = PCI_SXP_REGS_OFF;
 712         pcs->pci_poff[RISC_BLOCK >> _BLK_REG_SHFT] = PCI_RISC_REGS_OFF;
 713         pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] = DMA_REGS_OFF;
 714
 715         switch (pci_get_devid(dev)) {
 716         case PCI_QLOGIC_ISP1020:
 717                 did = 0x1040;
 718                 isp->isp_mdvec = &mdvec;
 719                 isp->isp_type = ISP_HA_SCSI_UNKNOWN;
 720                 break;
 721         case PCI_QLOGIC_ISP1080:
 722                 did = 0x1080;
 723                 isp->isp_mdvec = &mdvec_1080;
 724                 isp->isp_type = ISP_HA_SCSI_1080;
 725                 pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] = ISP1080_DMA_REGS_OFF;
 726                 break;
 727         case PCI_QLOGIC_ISP1240:
 728                 did = 0x1080;
 729                 isp->isp_mdvec = &mdvec_1080;
 730                 isp->isp_type = ISP_HA_SCSI_1240;
 731                 isp->isp_nchan = 2;
 732                 pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] = ISP1080_DMA_REGS_OFF;
 733                 break;
 734         case PCI_QLOGIC_ISP1280:
 735                 did = 0x1080;
 736                 isp->isp_mdvec = &mdvec_1080;
 737                 isp->isp_type = ISP_HA_SCSI_1280;
 738                 pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] = ISP1080_DMA_REGS_OFF;
 739                 break;
 740         case PCI_QLOGIC_ISP10160:
 741                 did = 0x12160;
 742                 isp->isp_mdvec = &mdvec_12160;
 743                 isp->isp_type = ISP_HA_SCSI_10160;
 744                 pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] = ISP1080_DMA_REGS_OFF;
 745                 break;
 746         case PCI_QLOGIC_ISP12160:
 747                 did = 0x12160;
 748                 isp->isp_nchan = 2;
 749                 isp->isp_mdvec = &mdvec_12160;
 750                 isp->isp_type = ISP_HA_SCSI_12160;
 751                 pcs->pci_poff[DMA_BLOCK >> _BLK_REG_SHFT] = ISP1080_DMA_REGS_OFF;
 752                 break;
 753         case PCI_QLOGIC_ISP2100:
 754                 did = 0x2100;
 755                 isp->isp_mdvec = &mdvec_2100;
 756                 isp->isp_type = ISP_HA_FC_2100;
 757                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = PCI_MBOX_REGS2100_OFF;
 758                 if (pci_get_revid(dev) < 3) {
 759                         /*
 760                          * XXX: Need to get the actual revision
 761                          * XXX: number of the 2100 FB. At any rate,
 762                          * XXX: lower cache line size for early revision
 763                          * XXX; boards.
 764                          */
 765                         linesz = 1;
 766                 }
 767                 break;
 768         case PCI_QLOGIC_ISP2200:
 769                 did = 0x2200;
 770                 isp->isp_mdvec = &mdvec_2200;
 771                 isp->isp_type = ISP_HA_FC_2200;
 772                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = PCI_MBOX_REGS2100_OFF;
 773                 break;
 774         case PCI_QLOGIC_ISP2300:
 775                 did = 0x2300;
 776                 isp->isp_mdvec = &mdvec_2300;
 777                 isp->isp_type = ISP_HA_FC_2300;
 778                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = PCI_MBOX_REGS2300_OFF;
 779                 break;
 780         case PCI_QLOGIC_ISP2312:
 781         case PCI_QLOGIC_ISP6312:
 782                 did = 0x2300;
 783                 isp->isp_mdvec = &mdvec_2300;
 784                 isp->isp_type = ISP_HA_FC_2312;
 785                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = PCI_MBOX_REGS2300_OFF;
 786                 break;
 787         case PCI_QLOGIC_ISP2322:
 788         case PCI_QLOGIC_ISP6322:
 789                 did = 0x2322;
 790                 isp->isp_mdvec = &mdvec_2300;
 791                 isp->isp_type = ISP_HA_FC_2322;
 792                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = PCI_MBOX_REGS2300_OFF;
 793                 break;
 794         case PCI_QLOGIC_ISP2422:
 795         case PCI_QLOGIC_ISP2432:
 796                 did = 0x2400;
 797                 isp->isp_nchan += isp_nvports;
 798                 isp->isp_mdvec = &mdvec_2400;
 799                 isp->isp_type = ISP_HA_FC_2400;
 800                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = PCI_MBOX_REGS2400_OFF;
 801                 break;
 802         case PCI_QLOGIC_ISP2532:
 803                 did = 0x2500;
 804                 isp->isp_nchan += isp_nvports;
 805                 isp->isp_mdvec = &mdvec_2500;
 806                 isp->isp_type = ISP_HA_FC_2500;
 807                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = PCI_MBOX_REGS2400_OFF;
 808                 break;
 809         case PCI_QLOGIC_ISP5432:
 810                 did = 0x2500;
 811                 isp->isp_mdvec = &mdvec_2500;
 812                 isp->isp_type = ISP_HA_FC_2500;
 813                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = PCI_MBOX_REGS2400_OFF;
 814                 break;
 815         case PCI_QLOGIC_ISP2031:
 816         case PCI_QLOGIC_ISP8031:
 817                 did = 0x2600;
 818                 isp->isp_nchan += isp_nvports;
 819                 isp->isp_mdvec = &mdvec_2600;
 820                 isp->isp_type = ISP_HA_FC_2600;
 821                 pcs->pci_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = PCI_MBOX_REGS2400_OFF;
 822                 break;
 823         default:
 824                 device_printf(dev, "unknown device type\n");
 825                 goto bad;
 826                 break;
 827         }
 828         isp->isp_revision = pci_get_revid(dev);
 829
 830         if (IS_26XX(isp)) {
 831                 pcs->rtp = SYS_RES_MEMORY;
 832                 pcs->rgd = PCIR_BAR(0);
 833                 pcs->regs = bus_alloc_resource_any(dev, pcs->rtp, &pcs->rgd,
 834                     RF_ACTIVE);
 835                 pcs->rtp1 = SYS_RES_MEMORY;
 836                 pcs->rgd1 = PCIR_BAR(2);
 837                 pcs->regs1 = bus_alloc_resource_any(dev, pcs->rtp1, &pcs->rgd1,
 838                     RF_ACTIVE);
 839                 pcs->rtp2 = SYS_RES_MEMORY;
 840                 pcs->rgd2 = PCIR_BAR(4);
 841                 pcs->regs2 = bus_alloc_resource_any(dev, pcs->rtp2, &pcs->rgd2,
 842                     RF_ACTIVE);
 843         } else {
 844                 pcs->rtp = SYS_RES_MEMORY;
 845                 pcs->rgd = PCIR_BAR(1);
 846                 pcs->regs = bus_alloc_resource_any(dev, pcs->rtp, &pcs->rgd,
 847                     RF_ACTIVE);
 848                 if (pcs->regs == NULL) {
 849                         pcs->rtp = SYS_RES_IOPORT;
 850                         pcs->rgd = PCIR_BAR(0);
 851                         pcs->regs = bus_alloc_resource_any(dev, pcs->rtp,
 852                             &pcs->rgd, RF_ACTIVE);
 853                 }
 854         }
 855         if (pcs->regs == NULL) {
 856                 device_printf(dev, "Unable to map any ports\n");
 857                 goto bad;
 858         }
 859         if (bootverbose) {
 860                 device_printf(dev, "Using %s space register mapping\n",
 861                     (pcs->rtp == SYS_RES_IOPORT)? "I/O" : "Memory");
 862         }
 863         isp->isp_regs = pcs->regs;
 864         isp->isp_regs2 = pcs->regs2;
 865
 866         if (IS_FC(isp)) {
 867                 psize = sizeof (fcparam);
 868                 xsize = sizeof (struct isp_fc);
 869         } else {
 870                 psize = sizeof (sdparam);
 871                 xsize = sizeof (struct isp_spi);
 872         }
 873         psize *= isp->isp_nchan;
 874         xsize *= isp->isp_nchan;
 875         isp->isp_param = malloc(psize, M_DEVBUF, M_NOWAIT | M_ZERO);
 876         if (isp->isp_param == NULL) {
 877                 device_printf(dev, "cannot allocate parameter data\n");
 878                 goto bad;
 879         }
 880         isp->isp_osinfo.pc.ptr = malloc(xsize, M_DEVBUF, M_NOWAIT | M_ZERO);
 881         if (isp->isp_osinfo.pc.ptr == NULL) {
 882                 device_printf(dev, "cannot allocate parameter data\n");
 883                 goto bad;
 884         }
 885
 886         /*
 887          * Now that we know who we are (roughly) get/set specific options
 888          */
 889         for (i = 0; i < isp->isp_nchan; i++) {
 890                 isp_get_specific_options(dev, i, isp);
 891         }
 892
 893         isp->isp_osinfo.fw = NULL;
 894         if (isp->isp_osinfo.fw == NULL) {
 895                 snprintf(fwname, sizeof (fwname), "isp_%04x", did);
 896                 isp->isp_osinfo.fw = firmware_get(fwname);
 897         }
 898         if (isp->isp_osinfo.fw != NULL) {
 899                 isp_prt(isp, ISP_LOGCONFIG, "loaded firmware %s", fwname);
 900                 isp->isp_mdvec->dv_ispfw = isp->isp_osinfo.fw->data;
 901         }
 902
 903         /*
 904          * Make sure that SERR, PERR, WRITE INVALIDATE and BUSMASTER are set.
 905          */
 906         cmd = pci_read_config(dev, PCIR_COMMAND, 2);
 907         cmd |= PCIM_CMD_SEREN | PCIM_CMD_PERRESPEN | PCIM_CMD_BUSMASTEREN | PCIM_CMD_INVEN;
 908         if (IS_2300(isp)) {     /* per QLogic errata */
 909                 cmd &= ~PCIM_CMD_INVEN;
 910         }
 911         if (IS_2322(isp) || pci_get_devid(dev) == PCI_QLOGIC_ISP6312) {
 912                 cmd &= ~PCIM_CMD_INTX_DISABLE;
 913         }
 914         if (IS_24XX(isp)) {
 915                 cmd &= ~PCIM_CMD_INTX_DISABLE;
 916         }
 917         pci_write_config(dev, PCIR_COMMAND, cmd, 2);
 918
 919         /*
 920          * Make sure the Cache Line Size register is set sensibly.
 921          */
 922         data = pci_read_config(dev, PCIR_CACHELNSZ, 1);
 923         if (data == 0 || (linesz != PCI_DFLT_LNSZ && data != linesz)) {
 924                 isp_prt(isp, ISP_LOGDEBUG0, "set PCI line size to %d from %d", linesz, data);
 925                 data = linesz;
 926                 pci_write_config(dev, PCIR_CACHELNSZ, data, 1);
 927         }
 928
 929         /*
 930          * Make sure the Latency Timer is sane.
 931          */
 932         data = pci_read_config(dev, PCIR_LATTIMER, 1);
 933         if (data < PCI_DFLT_LTNCY) {
 934                 data = PCI_DFLT_LTNCY;
 935                 isp_prt(isp, ISP_LOGDEBUG0, "set PCI latency to %d", data);
 936                 pci_write_config(dev, PCIR_LATTIMER, data, 1);
 937         }
 938
 939         /*
 940          * Make sure we've disabled the ROM.
 941          */
 942         data = pci_read_config(dev, PCIR_ROMADDR, 4);
 943         data &= ~1;
 944         pci_write_config(dev, PCIR_ROMADDR, data, 4);
 945
 946         if (IS_26XX(isp)) {
 947                 /* 26XX chips support only MSI-X, so start from them. */
 948                 pcs->msicount = imin(pci_msix_count(dev), 1);
 949                 if (pcs->msicount > 0 &&
 950                     (i = pci_alloc_msix(dev, &pcs->msicount)) == 0) {
 951                         pcs->iqd = 1;
 952                 } else {
 953                         pcs->msicount = 0;
 954                 }
 955         }
 956         if (pcs->msicount == 0 && (IS_24XX(isp) || IS_2322(isp))) {
 957                 /*
 958                  * Older chips support both MSI and MSI-X, but I have
 959                  * feeling that older firmware may not support MSI-X,
 960                  * but we have no way to check the firmware flag here.
 961                  */
 962                 pcs->msicount = imin(pci_msi_count(dev), 1);
 963                 if (pcs->msicount > 0 &&
 964                     pci_alloc_msi(dev, &pcs->msicount) == 0) {
 965                         pcs->iqd = 1;
 966                 } else {
 967                         pcs->msicount = 0;
 968                 }
 969         }
 970         pcs->irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &pcs->iqd, RF_ACTIVE | RF_SHAREABLE);
 971         if (pcs->irq == NULL) {
 972                 device_printf(dev, "could not allocate interrupt\n");
 973                 goto bad;
 974         }
 975
 976         /* Make sure the lock is set up. */
 977         mtx_init(&isp->isp_osinfo.lock, "isp", NULL, MTX_DEF);
 978         locksetup++;
 979
 980         if (isp_setup_intr(dev, pcs->irq, ISP_IFLAGS, NULL, isp_platform_intr, isp, &pcs->ih)) {
 981                 device_printf(dev, "could not setup interrupt\n");
 982                 goto bad;
 983         }
 984
 985         /*
 986          * Last minute checks...
 987          */
 988         if (IS_23XX(isp) || IS_24XX(isp)) {
 989                 isp->isp_port = pci_get_function(dev);
 990         }
 991
 992         /*
 993          * Make sure we're in reset state.
 994          */
 995         ISP_LOCK(isp);
 996         if (isp_reinit(isp, 1) != 0) {
 997                 ISP_UNLOCK(isp);
 998                 goto bad;
 999         }
1000         ISP_UNLOCK(isp);
1001         if (isp_attach(isp)) {
1002                 ISP_LOCK(isp);
1003                 isp_uninit(isp);
1004                 ISP_UNLOCK(isp);
1005                 goto bad;
1006         }
1007         return (0);
1008
1009 bad:
1010         if (pcs->ih) {
1011                 (void) bus_teardown_intr(dev, pcs->irq, pcs->ih);
1012         }
1013         if (locksetup) {
1014                 mtx_destroy(&isp->isp_osinfo.lock);
1015         }
1016         if (pcs->irq) {
1017                 (void) bus_release_resource(dev, SYS_RES_IRQ, pcs->iqd, pcs->irq);
1018         }
1019         if (pcs->msicount) {
1020                 pci_release_msi(dev);
1021         }
1022         if (pcs->regs)
1023                 (void) bus_release_resource(dev, pcs->rtp, pcs->rgd, pcs->regs);
1024         if (pcs->regs1)
1025                 (void) bus_release_resource(dev, pcs->rtp1, pcs->rgd1, pcs->regs1);
1026         if (pcs->regs2)
1027                 (void) bus_release_resource(dev, pcs->rtp2, pcs->rgd2, pcs->regs2);
1028         if (pcs->pci_isp.isp_param) {
1029                 free(pcs->pci_isp.isp_param, M_DEVBUF);
1030                 pcs->pci_isp.isp_param = NULL;
1031         }
1032         if (pcs->pci_isp.isp_osinfo.pc.ptr) {
1033                 free(pcs->pci_isp.isp_osinfo.pc.ptr, M_DEVBUF);
1034                 pcs->pci_isp.isp_osinfo.pc.ptr = NULL;
1035         }
1036         return (ENXIO);
1037 }
1038
1039 static int
1040 isp_pci_detach(device_t dev)
1041 {
1042         struct isp_pcisoftc *pcs;
1043         ispsoftc_t *isp;
1044         int status;
1045
1046         pcs = device_get_softc(dev);
1047         if (pcs == NULL) {
1048                 return (ENXIO);
1049         }
1050         isp = (ispsoftc_t *) pcs;
1051         status = isp_detach(isp);
1052         if (status)
1053                 return (status);
1054         ISP_LOCK(isp);
1055         isp_uninit(isp);
1056         if (pcs->ih) {
1057                 (void) bus_teardown_intr(dev, pcs->irq, pcs->ih);
1058         }
1059         ISP_UNLOCK(isp);
1060         mtx_destroy(&isp->isp_osinfo.lock);
1061         (void) bus_release_resource(dev, SYS_RES_IRQ, pcs->iqd, pcs->irq);
1062         if (pcs->msicount) {
1063                 pci_release_msi(dev);
1064         }
1065         (void) bus_release_resource(dev, pcs->rtp, pcs->rgd, pcs->regs);
1066         if (pcs->regs1)
1067                 (void) bus_release_resource(dev, pcs->rtp1, pcs->rgd1, pcs->regs1);
1068         if (pcs->regs2)
1069                 (void) bus_release_resource(dev, pcs->rtp2, pcs->rgd2, pcs->regs2);
1070         /*
1071          * XXX: THERE IS A LOT OF LEAKAGE HERE
1072          */
1073         if (pcs->pci_isp.isp_param) {
1074                 free(pcs->pci_isp.isp_param, M_DEVBUF);
1075                 pcs->pci_isp.isp_param = NULL;
1076         }
1077         if (pcs->pci_isp.isp_osinfo.pc.ptr) {
1078                 free(pcs->pci_isp.isp_osinfo.pc.ptr, M_DEVBUF);
1079                 pcs->pci_isp.isp_osinfo.pc.ptr = NULL;
1080         }
1081         return (0);
1082 }
1083
1084 #define IspVirt2Off(a, x)       \
1085         (((struct isp_pcisoftc *)a)->pci_poff[((x) & _BLK_REG_MASK) >> \
1086         _BLK_REG_SHFT] + ((x) & 0xfff))
1087
1088 #define BXR2(isp, off)          bus_read_2((isp)->isp_regs, (off))
1089 #define BXW2(isp, off, v)       bus_write_2((isp)->isp_regs, (off), (v))
1090 #define BXR4(isp, off)          bus_read_4((isp)->isp_regs, (off))
1091 #define BXW4(isp, off, v)       bus_write_4((isp)->isp_regs, (off), (v))
1092 #define B2R4(isp, off)          bus_read_4((isp)->isp_regs2, (off))
1093 #define B2W4(isp, off, v)       bus_write_4((isp)->isp_regs2, (off), (v))
1094
1095 static ISP_INLINE int
1096 isp_pci_rd_debounced(ispsoftc_t *isp, int off, uint16_t *rp)
1097 {
1098         uint32_t val0, val1;
1099         int i = 0;
1100
1101         do {
1102                 val0 = BXR2(isp, IspVirt2Off(isp, off));
1103                 val1 = BXR2(isp, IspVirt2Off(isp, off));
1104         } while (val0 != val1 && ++i < 1000);
1105         if (val0 != val1) {
1106                 return (1);
1107         }
1108         *rp = val0;
1109         return (0);
1110 }
1111
1112 static int
1113 isp_pci_rd_isr(ispsoftc_t *isp, uint16_t *isrp, uint16_t *semap, uint16_t *info)
1114 {
1115         uint16_t isr, sema;
1116
1117         if (IS_2100(isp)) {
1118                 if (isp_pci_rd_debounced(isp, BIU_ISR, &isr)) {
1119                     return (0);
1120                 }
1121                 if (isp_pci_rd_debounced(isp, BIU_SEMA, &sema)) {
1122                     return (0);
1123                 }
1124         } else {
1125                 isr = BXR2(isp, IspVirt2Off(isp, BIU_ISR));
1126                 sema = BXR2(isp, IspVirt2Off(isp, BIU_SEMA));
1127         }
1128         isp_prt(isp, ISP_LOGDEBUG3, "ISR 0x%x SEMA 0x%x", isr, sema);
1129         isr &= INT_PENDING_MASK(isp);
1130         sema &= BIU_SEMA_LOCK;
1131         if (isr == 0 && sema == 0) {
1132                 return (0);
1133         }
1134         *isrp = isr;
1135         if ((*semap = sema) != 0) {
1136                 if (IS_2100(isp)) {
1137                         if (isp_pci_rd_debounced(isp, OUTMAILBOX0, info)) {
1138                                 return (0);
1139                         }
1140                 } else {
1141                         *info = BXR2(isp, IspVirt2Off(isp, OUTMAILBOX0));
1142                 }
1143         }
1144         return (1);
1145 }
1146
1147 static int
1148 isp_pci_rd_isr_2300(ispsoftc_t *isp, uint16_t *isrp, uint16_t *semap, uint16_t *info)
1149 {
1150         uint32_t hccr, r2hisr;
1151
1152         if (!(BXR2(isp, IspVirt2Off(isp, BIU_ISR) & BIU2100_ISR_RISC_INT))) {
1153                 *isrp = 0;
1154                 return (0);
1155         }
1156         r2hisr = BXR4(isp, IspVirt2Off(isp, BIU_R2HSTSLO));
1157         isp_prt(isp, ISP_LOGDEBUG3, "RISC2HOST ISR 0x%x", r2hisr);
1158         if ((r2hisr & BIU_R2HST_INTR) == 0) {
1159                 *isrp = 0;
1160                 return (0);
1161         }
1162         switch ((*isrp = r2hisr & BIU_R2HST_ISTAT_MASK)) {
1163         case ISPR2HST_ROM_MBX_OK:
1164         case ISPR2HST_ROM_MBX_FAIL:
1165         case ISPR2HST_MBX_OK:
1166         case ISPR2HST_MBX_FAIL:
1167         case ISPR2HST_ASYNC_EVENT:
1168                 *semap = 1;
1169                 break;
1170         case ISPR2HST_RIO_16:
1171                 *info = ASYNC_RIO16_1;
1172                 *semap = 1;
1173                 return (1);
1174         case ISPR2HST_FPOST:
1175                 *info = ASYNC_CMD_CMPLT;
1176                 *semap = 1;
1177                 return (1);
1178         case ISPR2HST_FPOST_CTIO:
1179                 *info = ASYNC_CTIO_DONE;
1180                 *semap = 1;
1181                 return (1);
1182         case ISPR2HST_RSPQ_UPDATE:
1183                 *semap = 0;
1184                 break;
1185         default:
1186                 hccr = ISP_READ(isp, HCCR);
1187                 if (hccr & HCCR_PAUSE) {
1188                         ISP_WRITE(isp, HCCR, HCCR_RESET);
1189                         isp_prt(isp, ISP_LOGERR, "RISC paused at interrupt (%x->%x)", hccr, ISP_READ(isp, HCCR));
1190                         ISP_WRITE(isp, BIU_ICR, 0);
1191                 } else {
1192                         isp_prt(isp, ISP_LOGERR, "unknown interrupt 0x%x\n", r2hisr);
1193                 }
1194                 return (0);
1195         }
1196         *info = (r2hisr >> 16);
1197         return (1);
1198 }
1199
1200 static int
1201 isp_pci_rd_isr_2400(ispsoftc_t *isp, uint16_t *isrp, uint16_t *semap, uint16_t *info)
1202 {
1203         uint32_t r2hisr;
1204
1205         r2hisr = BXR4(isp, IspVirt2Off(isp, BIU2400_R2HSTSLO));
1206         isp_prt(isp, ISP_LOGDEBUG3, "RISC2HOST ISR 0x%x", r2hisr);
1207         if ((r2hisr & BIU_R2HST_INTR) == 0) {
1208                 *isrp = 0;
1209                 return (0);
1210         }
1211         switch ((*isrp = r2hisr & BIU_R2HST_ISTAT_MASK)) {
1212         case ISPR2HST_ROM_MBX_OK:
1213         case ISPR2HST_ROM_MBX_FAIL:
1214         case ISPR2HST_MBX_OK:
1215         case ISPR2HST_MBX_FAIL:
1216         case ISPR2HST_ASYNC_EVENT:
1217                 *semap = 1;
1218                 break;
1219         case ISPR2HST_RSPQ_UPDATE:
1220         case ISPR2HST_RSPQ_UPDATE2:
1221         case ISPR2HST_ATIO_UPDATE:
1222         case ISPR2HST_ATIO_RSPQ_UPDATE:
1223         case ISPR2HST_ATIO_UPDATE2:
1224                 *semap = 0;
1225                 break;
1226         default:
1227                 ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
1228                 isp_prt(isp, ISP_LOGERR, "unknown interrupt 0x%x\n", r2hisr);
1229                 return (0);
1230         }
1231         *info = (r2hisr >> 16);
1232         return (1);
1233 }
1234
1235 static uint32_t
1236 isp_pci_rd_reg(ispsoftc_t *isp, int regoff)
1237 {
1238         uint16_t rv;
1239         int oldconf = 0;
1240
1241         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
1242                 /*
1243                  * We will assume that someone has paused the RISC processor.
1244                  */
1245                 oldconf = BXR2(isp, IspVirt2Off(isp, BIU_CONF1));
1246                 BXW2(isp, IspVirt2Off(isp, BIU_CONF1), oldconf | BIU_PCI_CONF1_SXP);
1247                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2, -1);
1248         }
1249         rv = BXR2(isp, IspVirt2Off(isp, regoff));
1250         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
1251                 BXW2(isp, IspVirt2Off(isp, BIU_CONF1), oldconf);
1252                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2, -1);
1253         }
1254         return (rv);
1255 }
1256
1257 static void
1258 isp_pci_wr_reg(ispsoftc_t *isp, int regoff, uint32_t val)
1259 {
1260         int oldconf = 0;
1261
1262         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
1263                 /*
1264                  * We will assume that someone has paused the RISC processor.
1265                  */
1266                 oldconf = BXR2(isp, IspVirt2Off(isp, BIU_CONF1));
1267                 BXW2(isp, IspVirt2Off(isp, BIU_CONF1),
1268                     oldconf | BIU_PCI_CONF1_SXP);
1269                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2, -1);
1270         }
1271         BXW2(isp, IspVirt2Off(isp, regoff), val);
1272         MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, regoff), 2, -1);
1273         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
1274                 BXW2(isp, IspVirt2Off(isp, BIU_CONF1), oldconf);
1275                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2, -1);
1276         }
1277
1278 }
1279
1280 static uint32_t
1281 isp_pci_rd_reg_1080(ispsoftc_t *isp, int regoff)
1282 {
1283         uint32_t rv, oc = 0;
1284
1285         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
1286                 uint32_t tc;
1287                 /*
1288                  * We will assume that someone has paused the RISC processor.
1289                  */
1290                 oc = BXR2(isp, IspVirt2Off(isp, BIU_CONF1));
1291                 tc = oc & ~BIU_PCI1080_CONF1_DMA;
1292                 if (regoff & SXP_BANK1_SELECT)
1293                         tc |= BIU_PCI1080_CONF1_SXP1;
1294                 else
1295                         tc |= BIU_PCI1080_CONF1_SXP0;
1296                 BXW2(isp, IspVirt2Off(isp, BIU_CONF1), tc);
1297                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2, -1);
1298         } else if ((regoff & _BLK_REG_MASK) == DMA_BLOCK) {
1299                 oc = BXR2(isp, IspVirt2Off(isp, BIU_CONF1));
1300                 BXW2(isp, IspVirt2Off(isp, BIU_CONF1),
1301                     oc | BIU_PCI1080_CONF1_DMA);
1302                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2, -1);
1303         }
1304         rv = BXR2(isp, IspVirt2Off(isp, regoff));
1305         if (oc) {
1306                 BXW2(isp, IspVirt2Off(isp, BIU_CONF1), oc);
1307                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2, -1);
1308         }
1309         return (rv);
1310 }
1311
1312 static void
1313 isp_pci_wr_reg_1080(ispsoftc_t *isp, int regoff, uint32_t val)
1314 {
1315         int oc = 0;
1316
1317         if ((regoff & _BLK_REG_MASK) == SXP_BLOCK) {
1318                 uint32_t tc;
1319                 /*
1320                  * We will assume that someone has paused the RISC processor.
1321                  */
1322                 oc = BXR2(isp, IspVirt2Off(isp, BIU_CONF1));
1323                 tc = oc & ~BIU_PCI1080_CONF1_DMA;
1324                 if (regoff & SXP_BANK1_SELECT)
1325                         tc |= BIU_PCI1080_CONF1_SXP1;
1326                 else
1327                         tc |= BIU_PCI1080_CONF1_SXP0;
1328                 BXW2(isp, IspVirt2Off(isp, BIU_CONF1), tc);
1329                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2, -1);
1330         } else if ((regoff & _BLK_REG_MASK) == DMA_BLOCK) {
1331                 oc = BXR2(isp, IspVirt2Off(isp, BIU_CONF1));
1332                 BXW2(isp, IspVirt2Off(isp, BIU_CONF1),
1333                     oc | BIU_PCI1080_CONF1_DMA);
1334                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2, -1);
1335         }
1336         BXW2(isp, IspVirt2Off(isp, regoff), val);
1337         MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, regoff), 2, -1);
1338         if (oc) {
1339                 BXW2(isp, IspVirt2Off(isp, BIU_CONF1), oc);
1340                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, BIU_CONF1), 2, -1);
1341         }
1342 }
1343
1344 static uint32_t
1345 isp_pci_rd_reg_2400(ispsoftc_t *isp, int regoff)
1346 {
1347         uint32_t rv;
1348         int block = regoff & _BLK_REG_MASK;
1349
1350         switch (block) {
1351         case BIU_BLOCK:
1352                 break;
1353         case MBOX_BLOCK:
1354                 return (BXR2(isp, IspVirt2Off(isp, regoff)));
1355         case SXP_BLOCK:
1356                 isp_prt(isp, ISP_LOGERR, "SXP_BLOCK read at 0x%x", regoff);
1357                 return (0xffffffff);
1358         case RISC_BLOCK:
1359                 isp_prt(isp, ISP_LOGERR, "RISC_BLOCK read at 0x%x", regoff);
1360                 return (0xffffffff);
1361         case DMA_BLOCK:
1362                 isp_prt(isp, ISP_LOGERR, "DMA_BLOCK read at 0x%x", regoff);
1363                 return (0xffffffff);
1364         default:
1365                 isp_prt(isp, ISP_LOGERR, "unknown block read at 0x%x", regoff);
1366                 return (0xffffffff);
1367         }
1368
1369         switch (regoff) {
1370         case BIU2400_FLASH_ADDR:
1371         case BIU2400_FLASH_DATA:
1372         case BIU2400_ICR:
1373         case BIU2400_ISR:
1374         case BIU2400_CSR:
1375         case BIU2400_REQINP:
1376         case BIU2400_REQOUTP:
1377         case BIU2400_RSPINP:
1378         case BIU2400_RSPOUTP:
1379         case BIU2400_PRI_REQINP:
1380         case BIU2400_PRI_REQOUTP:
1381         case BIU2400_ATIO_RSPINP:
1382         case BIU2400_ATIO_RSPOUTP:
1383         case BIU2400_HCCR:
1384         case BIU2400_GPIOD:
1385         case BIU2400_GPIOE:
1386         case BIU2400_HSEMA:
1387                 rv = BXR4(isp, IspVirt2Off(isp, regoff));
1388                 break;
1389         case BIU2400_R2HSTSLO:
1390                 rv = BXR4(isp, IspVirt2Off(isp, regoff));
1391                 break;
1392         case BIU2400_R2HSTSHI:
1393                 rv = BXR4(isp, IspVirt2Off(isp, regoff)) >> 16;
1394                 break;
1395         default:
1396                 isp_prt(isp, ISP_LOGERR, "unknown register read at 0x%x",
1397                     regoff);
1398                 rv = 0xffffffff;
1399                 break;
1400         }
1401         return (rv);
1402 }
1403
1404 static void
1405 isp_pci_wr_reg_2400(ispsoftc_t *isp, int regoff, uint32_t val)
1406 {
1407         int block = regoff & _BLK_REG_MASK;
1408
1409         switch (block) {
1410         case BIU_BLOCK:
1411                 break;
1412         case MBOX_BLOCK:
1413                 BXW2(isp, IspVirt2Off(isp, regoff), val);
1414                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, regoff), 2, -1);
1415                 return;
1416         case SXP_BLOCK:
1417                 isp_prt(isp, ISP_LOGERR, "SXP_BLOCK write at 0x%x", regoff);
1418                 return;
1419         case RISC_BLOCK:
1420                 isp_prt(isp, ISP_LOGERR, "RISC_BLOCK write at 0x%x", regoff);
1421                 return;
1422         case DMA_BLOCK:
1423                 isp_prt(isp, ISP_LOGERR, "DMA_BLOCK write at 0x%x", regoff);
1424                 return;
1425         default:
1426                 isp_prt(isp, ISP_LOGERR, "unknown block write at 0x%x", regoff);
1427                 break;
1428         }
1429
1430         switch (regoff) {
1431         case BIU2400_FLASH_ADDR:
1432         case BIU2400_FLASH_DATA:
1433         case BIU2400_ICR:
1434         case BIU2400_ISR:
1435         case BIU2400_CSR:
1436         case BIU2400_REQINP:
1437         case BIU2400_REQOUTP:
1438         case BIU2400_RSPINP:
1439         case BIU2400_RSPOUTP:
1440         case BIU2400_PRI_REQINP:
1441         case BIU2400_PRI_REQOUTP:
1442         case BIU2400_ATIO_RSPINP:
1443         case BIU2400_ATIO_RSPOUTP:
1444         case BIU2400_HCCR:
1445         case BIU2400_GPIOD:
1446         case BIU2400_GPIOE:
1447         case BIU2400_HSEMA:
1448                 BXW4(isp, IspVirt2Off(isp, regoff), val);
1449 #ifdef MEMORYBARRIERW
1450                 if (regoff == BIU2400_REQINP ||
1451                     regoff == BIU2400_RSPOUTP ||
1452                     regoff == BIU2400_PRI_REQINP ||
1453                     regoff == BIU2400_ATIO_RSPOUTP)
1454                         MEMORYBARRIERW(isp, SYNC_REG,
1455                             IspVirt2Off(isp, regoff), 4, -1)
1456                 else
1457 #endif
1458                 MEMORYBARRIER(isp, SYNC_REG, IspVirt2Off(isp, regoff), 4, -1);
1459                 break;
1460         default:
1461                 isp_prt(isp, ISP_LOGERR, "unknown register write at 0x%x",
1462                     regoff);
1463                 break;
1464         }
1465 }
1466
1467 static uint32_t
1468 isp_pci_rd_reg_2600(ispsoftc_t *isp, int regoff)
1469 {
1470         uint32_t rv;
1471
1472         switch (regoff) {
1473         case BIU2400_PRI_REQINP:
1474         case BIU2400_PRI_REQOUTP:
1475                 isp_prt(isp, ISP_LOGERR, "unknown register read at 0x%x",
1476                     regoff);
1477                 rv = 0xffffffff;
1478                 break;
1479         case BIU2400_REQINP:
1480                 rv = B2R4(isp, 0x00);
1481                 break;
1482         case BIU2400_REQOUTP:
1483                 rv = B2R4(isp, 0x04);
1484                 break;
1485         case BIU2400_RSPINP:
1486                 rv = B2R4(isp, 0x08);
1487                 break;
1488         case BIU2400_RSPOUTP:
1489                 rv = B2R4(isp, 0x0c);
1490                 break;
1491         case BIU2400_ATIO_RSPINP:
1492                 rv = B2R4(isp, 0x10);
1493                 break;
1494         case BIU2400_ATIO_RSPOUTP:
1495                 rv = B2R4(isp, 0x14);
1496                 break;
1497         default:
1498                 rv = isp_pci_rd_reg_2400(isp, regoff);
1499                 break;
1500         }
1501         return (rv);
1502 }
1503
1504 static void
1505 isp_pci_wr_reg_2600(ispsoftc_t *isp, int regoff, uint32_t val)
1506 {
1507         int off;
1508
1509         switch (regoff) {
1510         case BIU2400_PRI_REQINP:
1511         case BIU2400_PRI_REQOUTP:
1512                 isp_prt(isp, ISP_LOGERR, "unknown register write at 0x%x",
1513                     regoff);
1514                 return;
1515         case BIU2400_REQINP:
1516                 off = 0x00;
1517                 break;
1518         case BIU2400_REQOUTP:
1519                 off = 0x04;
1520                 break;
1521         case BIU2400_RSPINP:
1522                 off = 0x08;
1523                 break;
1524         case BIU2400_RSPOUTP:
1525                 off = 0x0c;
1526                 break;
1527         case BIU2400_ATIO_RSPINP:
1528                 off = 0x10;
1529                 break;
1530         case BIU2400_ATIO_RSPOUTP:
1531                 off = 0x14;
1532                 break;
1533         default:
1534                 isp_pci_wr_reg_2400(isp, regoff, val);
1535                 return;
1536         }
1537         B2W4(isp, off, val);
1538 }
1539
1540
1541 struct imush {
1542         bus_addr_t maddr;
1543         int error;
1544 };
1545
1546 static void
1547 imc(void *arg, bus_dma_segment_t *segs, int nseg, int error)
1548 {
1549         struct imush *imushp = (struct imush *) arg;
1550
1551         if (!(imushp->error = error))
1552                 imushp->maddr = segs[0].ds_addr;
1553 }
1554
1555 static int
1556 isp_pci_mbxdma(ispsoftc_t *isp)
1557 {
1558         caddr_t base;
1559         uint32_t len, nsegs;
1560         int i, error, cmap = 0;
1561         bus_size_t slim;        /* segment size */
1562         bus_addr_t llim;        /* low limit of unavailable dma */
1563         bus_addr_t hlim;        /* high limit of unavailable dma */
1564         struct imush im;
1565         isp_ecmd_t *ecmd;
1566
1567         /*
1568          * Already been here? If so, leave...
1569          */
1570         if (isp->isp_rquest) {
1571                 return (0);
1572         }
1573         ISP_UNLOCK(isp);
1574
1575         if (isp->isp_maxcmds == 0) {
1576                 isp_prt(isp, ISP_LOGERR, "maxcmds not set");
1577                 ISP_LOCK(isp);
1578                 return (1);
1579         }
1580
1581         hlim = BUS_SPACE_MAXADDR;
1582         if (IS_ULTRA2(isp) || IS_FC(isp) || IS_1240(isp)) {
1583                 if (sizeof (bus_size_t) > 4) {
1584                         slim = (bus_size_t) (1ULL << 32);
1585                 } else {
1586                         slim = (bus_size_t) (1UL << 31);
1587                 }
1588                 llim = BUS_SPACE_MAXADDR;
1589         } else {
1590                 llim = BUS_SPACE_MAXADDR_32BIT;
1591                 slim = (1UL << 24);
1592         }
1593
1594         len = isp->isp_maxcmds * sizeof (struct isp_pcmd);
1595         isp->isp_osinfo.pcmd_pool = (struct isp_pcmd *) malloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
1596         if (isp->isp_osinfo.pcmd_pool == NULL) {
1597                 isp_prt(isp, ISP_LOGERR, "cannot allocate pcmds");
1598                 ISP_LOCK(isp);
1599                 return (1);
1600         }
1601
1602         if (isp->isp_osinfo.sixtyfourbit) {
1603                 nsegs = ISP_NSEG64_MAX;
1604         } else {
1605                 nsegs = ISP_NSEG_MAX;
1606         }
1607
1608         if (isp_dma_tag_create(BUS_DMA_ROOTARG(ISP_PCD(isp)), 1, slim, llim, hlim, NULL, NULL, BUS_SPACE_MAXSIZE, nsegs, slim, 0, &isp->isp_osinfo.dmat)) {
1609                 free(isp->isp_osinfo.pcmd_pool, M_DEVBUF);
1610                 ISP_LOCK(isp);
1611                 isp_prt(isp, ISP_LOGERR, "could not create master dma tag");
1612                 return (1);
1613         }
1614
1615         len = sizeof (isp_hdl_t) * isp->isp_maxcmds;
1616         isp->isp_xflist = (isp_hdl_t *) malloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
1617         if (isp->isp_xflist == NULL) {
1618                 free(isp->isp_osinfo.pcmd_pool, M_DEVBUF);
1619                 ISP_LOCK(isp);
1620                 isp_prt(isp, ISP_LOGERR, "cannot alloc xflist array");
1621                 return (1);
1622         }
1623         for (len = 0; len < isp->isp_maxcmds - 1; len++) {
1624                 isp->isp_xflist[len].cmd = &isp->isp_xflist[len+1];
1625         }
1626         isp->isp_xffree = isp->isp_xflist;
1627
1628         /*
1629          * Allocate and map the request queue and a region for external
1630          * DMA addressable command/status structures (22XX and later).
1631          */
1632         len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
1633         if (isp->isp_type >= ISP_HA_FC_2200)
1634                 len += (N_XCMDS * XCMD_SIZE);
1635         if (isp_dma_tag_create(isp->isp_osinfo.dmat, QENTRY_LEN, slim,
1636             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
1637             len, 1, len, 0, &isp->isp_osinfo.reqdmat)) {
1638                 isp_prt(isp, ISP_LOGERR, "cannot create request DMA tag");
1639                 goto bad1;
1640         }
1641         if (bus_dmamem_alloc(isp->isp_osinfo.reqdmat, (void **)&base,
1642             BUS_DMA_COHERENT, &isp->isp_osinfo.reqmap) != 0) {
1643                 isp_prt(isp, ISP_LOGERR, "cannot allocate request DMA memory");
1644                 bus_dma_tag_destroy(isp->isp_osinfo.reqdmat);
1645                 goto bad1;
1646         }
1647         isp->isp_rquest = base;
1648         im.error = 0;
1649         if (bus_dmamap_load(isp->isp_osinfo.reqdmat, isp->isp_osinfo.reqmap,
1650             base, len, imc, &im, 0) || im.error) {
1651                 isp_prt(isp, ISP_LOGERR, "error loading request DMA map %d", im.error);
1652                 goto bad1;
1653         }
1654         isp_prt(isp, ISP_LOGDEBUG0, "request area @ 0x%jx/0x%jx",
1655             (uintmax_t)im.maddr, (uintmax_t)len);
1656         isp->isp_rquest_dma = im.maddr;
1657         base += ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
1658         im.maddr += ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
1659         if (isp->isp_type >= ISP_HA_FC_2200) {
1660                 isp->isp_osinfo.ecmd_dma = im.maddr;
1661                 isp->isp_osinfo.ecmd_free = (isp_ecmd_t *)base;
1662                 isp->isp_osinfo.ecmd_base = isp->isp_osinfo.ecmd_free;
1663                 for (ecmd = isp->isp_osinfo.ecmd_free;
1664                     ecmd < &isp->isp_osinfo.ecmd_free[N_XCMDS]; ecmd++) {
1665                         if (ecmd == &isp->isp_osinfo.ecmd_free[N_XCMDS - 1])
1666                                 ecmd->next = NULL;
1667                         else
1668                                 ecmd->next = ecmd + 1;
1669                 }
1670         }
1671
1672         /*
1673          * Allocate and map the result queue.
1674          */
1675         len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
1676         if (isp_dma_tag_create(isp->isp_osinfo.dmat, QENTRY_LEN, slim,
1677             BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
1678             len, 1, len, 0, &isp->isp_osinfo.respdmat)) {
1679                 isp_prt(isp, ISP_LOGERR, "cannot create response DMA tag");
1680                 goto bad1;
1681         }
1682         if (bus_dmamem_alloc(isp->isp_osinfo.respdmat, (void **)&base,
1683             BUS_DMA_COHERENT, &isp->isp_osinfo.respmap) != 0) {
1684                 isp_prt(isp, ISP_LOGERR, "cannot allocate response DMA memory");
1685                 bus_dma_tag_destroy(isp->isp_osinfo.respdmat);
1686                 goto bad1;
1687         }
1688         isp->isp_result = base;
1689         im.error = 0;
1690         if (bus_dmamap_load(isp->isp_osinfo.respdmat, isp->isp_osinfo.respmap,
1691             base, len, imc, &im, 0) || im.error) {
1692                 isp_prt(isp, ISP_LOGERR, "error loading response DMA map %d", im.error);
1693                 goto bad1;
1694         }
1695         isp_prt(isp, ISP_LOGDEBUG0, "response area @ 0x%jx/0x%jx",
1696             (uintmax_t)im.maddr, (uintmax_t)len);
1697         isp->isp_result_dma = im.maddr;
1698
1699 #ifdef  ISP_TARGET_MODE
1700         /*
1701          * Allocate and map ATIO queue on 24xx with target mode.
1702          */
1703         if (IS_24XX(isp)) {
1704                 len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
1705                 if (isp_dma_tag_create(isp->isp_osinfo.dmat, QENTRY_LEN, slim,
1706                     BUS_SPACE_MAXADDR_32BIT, BUS_SPACE_MAXADDR, NULL, NULL,
1707                     len, 1, len, 0, &isp->isp_osinfo.atiodmat)) {
1708                         isp_prt(isp, ISP_LOGERR, "cannot create ATIO DMA tag");
1709                         goto bad1;
1710                 }
1711                 if (bus_dmamem_alloc(isp->isp_osinfo.atiodmat, (void **)&base,
1712                     BUS_DMA_COHERENT, &isp->isp_osinfo.atiomap) != 0) {
1713                         isp_prt(isp, ISP_LOGERR, "cannot allocate ATIO DMA memory");
1714                         bus_dma_tag_destroy(isp->isp_osinfo.atiodmat);
1715                         goto bad1;
1716                 }
1717                 isp->isp_atioq = base;
1718                 im.error = 0;
1719                 if (bus_dmamap_load(isp->isp_osinfo.atiodmat, isp->isp_osinfo.atiomap,
1720                     base, len, imc, &im, 0) || im.error) {
1721                         isp_prt(isp, ISP_LOGERR, "error loading ATIO DMA map %d", im.error);
1722                         goto bad;
1723                 }
1724                 isp_prt(isp, ISP_LOGDEBUG0, "ATIO area @ 0x%jx/0x%jx",
1725                     (uintmax_t)im.maddr, (uintmax_t)len);
1726                 isp->isp_atioq_dma = im.maddr;
1727         }
1728 #endif
1729
1730         if (IS_FC(isp)) {
1731                 if (isp_dma_tag_create(isp->isp_osinfo.dmat, 64, slim,
1732                     BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
1733                     ISP_FC_SCRLEN, 1, ISP_FC_SCRLEN, 0, &isp->isp_osinfo.scdmat)) {
1734                         goto bad;
1735                 }
1736                 for (cmap = 0; cmap < isp->isp_nchan; cmap++) {
1737                         struct isp_fc *fc = ISP_FC_PC(isp, cmap);
1738                         if (bus_dmamem_alloc(isp->isp_osinfo.scdmat,
1739                             (void **)&base, BUS_DMA_COHERENT, &fc->scmap) != 0)
1740                                 goto bad;
1741                         FCPARAM(isp, cmap)->isp_scratch = base;
1742                         im.error = 0;
1743                         if (bus_dmamap_load(isp->isp_osinfo.scdmat, fc->scmap,
1744                             base, ISP_FC_SCRLEN, imc, &im, 0) || im.error) {
1745                                 bus_dmamem_free(isp->isp_osinfo.scdmat,
1746                                     base, fc->scmap);
1747                                 goto bad;
1748                         }
1749                         FCPARAM(isp, cmap)->isp_scdma = im.maddr;
1750                         if (!IS_2100(isp)) {
1751                                 for (i = 0; i < INITIAL_NEXUS_COUNT; i++) {
1752                                         struct isp_nexus *n = malloc(sizeof (struct isp_nexus), M_DEVBUF, M_NOWAIT | M_ZERO);
1753                                         if (n == NULL) {
1754                                                 while (fc->nexus_free_list) {
1755                                                         n = fc->nexus_free_list;
1756                                                         fc->nexus_free_list = n->next;
1757                                                         free(n, M_DEVBUF);
1758                                                 }
1759                                                 goto bad;
1760                                         }
1761                                         n->next = fc->nexus_free_list;
1762                                         fc->nexus_free_list = n;
1763                                 }
1764                         }
1765                 }
1766         }
1767
1768         for (i = 0; i < isp->isp_maxcmds; i++) {
1769                 struct isp_pcmd *pcmd = &isp->isp_osinfo.pcmd_pool[i];
1770                 error = bus_dmamap_create(isp->isp_osinfo.dmat, 0, &pcmd->dmap);
1771                 if (error) {
1772                         isp_prt(isp, ISP_LOGERR, "error %d creating per-cmd DMA maps", error);
1773                         while (--i >= 0) {
1774                                 bus_dmamap_destroy(isp->isp_osinfo.dmat, isp->isp_osinfo.pcmd_pool[i].dmap);
1775                         }
1776                         goto bad;
1777                 }
1778                 callout_init_mtx(&pcmd->wdog, &isp->isp_osinfo.lock, 0);
1779                 if (i == isp->isp_maxcmds-1) {
1780                         pcmd->next = NULL;
1781                 } else {
1782                         pcmd->next = &isp->isp_osinfo.pcmd_pool[i+1];
1783                 }
1784         }
1785         isp->isp_osinfo.pcmd_free = &isp->isp_osinfo.pcmd_pool[0];
1786         ISP_LOCK(isp);
1787         return (0);
1788
1789 bad:
1790         if (IS_FC(isp)) {
1791                 while (--cmap >= 0) {
1792                         struct isp_fc *fc = ISP_FC_PC(isp, cmap);
1793                         bus_dmamap_unload(isp->isp_osinfo.scdmat, fc->scmap);
1794                         bus_dmamem_free(isp->isp_osinfo.scdmat, base, fc->scmap);
1795                         while (fc->nexus_free_list) {
1796                                 struct isp_nexus *n = fc->nexus_free_list;
1797                                 fc->nexus_free_list = n->next;
1798                                 free(n, M_DEVBUF);
1799                         }
1800                 }
1801                 bus_dma_tag_destroy(isp->isp_osinfo.scdmat);
1802         }
1803 bad1:
1804         if (isp->isp_rquest_dma != 0) {
1805                 bus_dmamap_unload(isp->isp_osinfo.reqdmat,
1806                     isp->isp_osinfo.reqmap);
1807         }
1808         if (isp->isp_rquest != NULL) {
1809                 bus_dmamem_free(isp->isp_osinfo.reqdmat, isp->isp_rquest,
1810                     isp->isp_osinfo.reqmap);
1811                 bus_dma_tag_destroy(isp->isp_osinfo.reqdmat);
1812         }
1813         if (isp->isp_result_dma != 0) {
1814                 bus_dmamap_unload(isp->isp_osinfo.respdmat,
1815                     isp->isp_osinfo.respmap);
1816         }
1817         if (isp->isp_result != NULL) {
1818                 bus_dmamem_free(isp->isp_osinfo.respdmat, isp->isp_result,
1819                     isp->isp_osinfo.respmap);
1820                 bus_dma_tag_destroy(isp->isp_osinfo.respdmat);
1821         }
1822 #ifdef  ISP_TARGET_MODE
1823         if (IS_24XX(isp)) {
1824                 if (isp->isp_atioq_dma != 0) {
1825                         bus_dmamap_unload(isp->isp_osinfo.atiodmat,
1826                             isp->isp_osinfo.atiomap);
1827                 }
1828                 if (isp->isp_atioq != NULL) {
1829                         bus_dmamem_free(isp->isp_osinfo.reqdmat, isp->isp_atioq,
1830                             isp->isp_osinfo.atiomap);
1831                         bus_dma_tag_destroy(isp->isp_osinfo.atiodmat);
1832                 }
1833         }
1834 #endif
1835         free(isp->isp_xflist, M_DEVBUF);
1836         free(isp->isp_osinfo.pcmd_pool, M_DEVBUF);
1837         isp->isp_rquest = NULL;
1838         ISP_LOCK(isp);
1839         return (1);
1840 }
1841
1842 typedef struct {
1843         ispsoftc_t *isp;
1844         void *cmd_token;
1845         void *rq;       /* original request */
1846         int error;
1847         bus_size_t mapsize;
1848 } mush_t;
1849
1850 #define MUSHERR_NOQENTRIES      -2
1851
1852 #ifdef  ISP_TARGET_MODE
1853 static void tdma2_2(void *, bus_dma_segment_t *, int, bus_size_t, int);
1854 static void tdma2(void *, bus_dma_segment_t *, int, int);
1855
1856 static void
1857 tdma2_2(void *arg, bus_dma_segment_t *dm_segs, int nseg, bus_size_t mapsize, int error)
1858 {
1859         mush_t *mp;
1860         mp = (mush_t *)arg;
1861         mp->mapsize = mapsize;
1862         tdma2(arg, dm_segs, nseg, error);
1863 }
1864
1865 static void
1866 tdma2(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error)
1867 {
1868         mush_t *mp;
1869         ispsoftc_t *isp;
1870         struct ccb_scsiio *csio;
1871         isp_ddir_t ddir;
1872         ispreq_t *rq;
1873
1874         mp = (mush_t *) arg;
1875         if (error) {
1876                 mp->error = error;
1877                 return;
1878         }
1879         csio = mp->cmd_token;
1880         isp = mp->isp;
1881         rq = mp->rq;
1882         if (nseg) {
1883                 if (isp->isp_osinfo.sixtyfourbit) {
1884                         if (nseg >= ISP_NSEG64_MAX) {
1885                                 isp_prt(isp, ISP_LOGERR, "number of segments (%d) exceed maximum we can support (%d)", nseg, ISP_NSEG64_MAX);
1886                                 mp->error = EFAULT;
1887                                 return;
1888                         }
1889                         if (rq->req_header.rqs_entry_type == RQSTYPE_CTIO2) {
1890                                 rq->req_header.rqs_entry_type = RQSTYPE_CTIO3;
1891                         }
1892                 } else {
1893                         if (nseg >= ISP_NSEG_MAX) {
1894                                 isp_prt(isp, ISP_LOGERR, "number of segments (%d) exceed maximum we can support (%d)", nseg, ISP_NSEG_MAX);
1895                                 mp->error = EFAULT;
1896                                 return;
1897                         }
1898                 }
1899                 if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
1900                         bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_PREWRITE);
1901                         ddir = ISP_TO_DEVICE;
1902                 } else if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT) {
1903                         bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_PREREAD);
1904                         ddir = ISP_FROM_DEVICE;
1905                 } else {
1906                         dm_segs = NULL;
1907                         nseg = 0;
1908                         ddir = ISP_NOXFR;
1909                 }
1910         } else {
1911                 dm_segs = NULL;
1912                 nseg = 0;
1913                 ddir = ISP_NOXFR;
1914         }
1915
1916         error = isp_send_tgt_cmd(isp, rq, dm_segs, nseg, XS_XFRLEN(csio), ddir, &csio->sense_data, csio->sense_len);
1917         switch (error) {
1918         case CMD_EAGAIN:
1919                 mp->error = MUSHERR_NOQENTRIES;
1920         case CMD_QUEUED:
1921                 break;
1922         default:
1923                 mp->error = EIO;
1924         }
1925 }
1926 #endif
1927
1928 static void dma2_2(void *, bus_dma_segment_t *, int, bus_size_t, int);
1929 static void dma2(void *, bus_dma_segment_t *, int, int);
1930
1931 static void
1932 dma2_2(void *arg, bus_dma_segment_t *dm_segs, int nseg, bus_size_t mapsize, int error)
1933 {
1934         mush_t *mp;
1935         mp = (mush_t *)arg;
1936         mp->mapsize = mapsize;
1937         dma2(arg, dm_segs, nseg, error);
1938 }
1939
1940 static void
1941 dma2(void *arg, bus_dma_segment_t *dm_segs, int nseg, int error)
1942 {
1943         mush_t *mp;
1944         ispsoftc_t *isp;
1945         struct ccb_scsiio *csio;
1946         isp_ddir_t ddir;
1947         ispreq_t *rq;
1948
1949         mp = (mush_t *) arg;
1950         if (error) {
1951                 mp->error = error;
1952                 return;
1953         }
1954         csio = mp->cmd_token;
1955         isp = mp->isp;
1956         rq = mp->rq;
1957         if (nseg) {
1958                 if (isp->isp_osinfo.sixtyfourbit) {
1959                         if (nseg >= ISP_NSEG64_MAX) {
1960                                 isp_prt(isp, ISP_LOGERR, "number of segments (%d) exceed maximum we can support (%d)", nseg, ISP_NSEG64_MAX);
1961                                 mp->error = EFAULT;
1962                                 return;
1963                         }
1964                         if (rq->req_header.rqs_entry_type == RQSTYPE_T2RQS) {
1965                                 rq->req_header.rqs_entry_type = RQSTYPE_T3RQS;
1966                         } else if (rq->req_header.rqs_entry_type == RQSTYPE_REQUEST) {
1967                                 rq->req_header.rqs_entry_type = RQSTYPE_A64;
1968                         }
1969                 } else {
1970                         if (nseg >= ISP_NSEG_MAX) {
1971                                 isp_prt(isp, ISP_LOGERR, "number of segments (%d) exceed maximum we can support (%d)", nseg, ISP_NSEG_MAX);
1972                                 mp->error = EFAULT;
1973                                 return;
1974                         }
1975                 }
1976                 if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_IN) {
1977                         bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_PREREAD);
1978                         ddir = ISP_FROM_DEVICE;
1979                 } else if ((csio->ccb_h.flags & CAM_DIR_MASK) == CAM_DIR_OUT) {
1980                         bus_dmamap_sync(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap, BUS_DMASYNC_PREWRITE);
1981                         ddir = ISP_TO_DEVICE;
1982                 } else {
1983                         ddir = ISP_NOXFR;
1984                 }
1985         } else {
1986                 dm_segs = NULL;
1987                 nseg = 0;
1988                 ddir = ISP_NOXFR;
1989         }
1990
1991         error = isp_send_cmd(isp, rq, dm_segs, nseg, XS_XFRLEN(csio), ddir, (ispds64_t *)csio->req_map);
1992         switch (error) {
1993         case CMD_EAGAIN:
1994                 mp->error = MUSHERR_NOQENTRIES;
1995                 break;
1996         case CMD_QUEUED:
1997                 break;
1998         default:
1999                 mp->error = EIO;
2000                 break;
2001         }
2002 }
2003
2004 static int
2005 isp_pci_dmasetup(ispsoftc_t *isp, struct ccb_scsiio *csio, void *ff)
2006 {
2007         mush_t mush, *mp;
2008         void (*eptr)(void *, bus_dma_segment_t *, int, int);
2009         void (*eptr2)(void *, bus_dma_segment_t *, int, bus_size_t, int);
2010         int error;
2011
2012         mp = &mush;
2013         mp->isp = isp;
2014         mp->cmd_token = csio;
2015         mp->rq = ff;
2016         mp->error = 0;
2017         mp->mapsize = 0;
2018
2019 #ifdef  ISP_TARGET_MODE
2020         if (csio->ccb_h.func_code == XPT_CONT_TARGET_IO) {
2021                 eptr = tdma2;
2022                 eptr2 = tdma2_2;
2023         } else
2024 #endif
2025         {
2026                 eptr = dma2;
2027                 eptr2 = dma2_2;
2028         }
2029
2030
2031         error = bus_dmamap_load_ccb(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap,
2032             (union ccb *)csio, eptr, mp, 0);
2033         if (error == EINPROGRESS) {
2034                 bus_dmamap_unload(isp->isp_osinfo.dmat, PISP_PCMD(csio)->dmap);
2035                 mp->error = EINVAL;
2036                 isp_prt(isp, ISP_LOGERR, "deferred dma allocation not supported");
2037         } else if (error && mp->error == 0) {
2038 #ifdef  DIAGNOSTIC
2039                 isp_prt(isp, ISP_LOGERR, "error %d in dma mapping code", error);
2040 #endif
2041                 mp->error = error;
2042         }
2043         if (mp->error) {
2044                 int retval = CMD_COMPLETE;
2045                 if (mp->error == MUSHERR_NOQENTRIES) {
2046                         retval = CMD_EAGAIN;
2047                 } else if (mp->error == EFBIG) {
2048                         csio->ccb_h.status = CAM_REQ_TOO_BIG;
2049                 } else if (mp->error == EINVAL) {
2050                         csio->ccb_h.status = CAM_REQ_INVALID;
2051                 } else {
2052                         csio->ccb_h.status = CAM_UNREC_HBA_ERROR;
2053                 }
2054                 return (retval);
2055         }
2056         return (CMD_QUEUED);
2057 }
2058
2059 static void
2060 isp_pci_reset0(ispsoftc_t *isp)
2061 {
2062         ISP_DISABLE_INTS(isp);
2063 }
2064
2065 static void
2066 isp_pci_reset1(ispsoftc_t *isp)
2067 {
2068         if (!IS_24XX(isp)) {
2069                 /* Make sure the BIOS is disabled */
2070                 isp_pci_wr_reg(isp, HCCR, PCI_HCCR_CMD_BIOS);
2071         }
2072         /* and enable interrupts */
2073         ISP_ENABLE_INTS(isp);
2074 }
2075
2076 static void
2077 isp_pci_dumpregs(ispsoftc_t *isp, const char *msg)
2078 {
2079         struct isp_pcisoftc *pcs = (struct isp_pcisoftc *)isp;
2080         if (msg)
2081                 printf("%s: %s\n", device_get_nameunit(isp->isp_dev), msg);
2082         else
2083                 printf("%s:\n", device_get_nameunit(isp->isp_dev));
2084         if (IS_SCSI(isp))
2085                 printf("    biu_conf1=%x", ISP_READ(isp, BIU_CONF1));
2086         else
2087                 printf("    biu_csr=%x", ISP_READ(isp, BIU2100_CSR));
2088         printf(" biu_icr=%x biu_isr=%x biu_sema=%x ", ISP_READ(isp, BIU_ICR),
2089             ISP_READ(isp, BIU_ISR), ISP_READ(isp, BIU_SEMA));
2090         printf("risc_hccr=%x\n", ISP_READ(isp, HCCR));
2091
2092
2093         if (IS_SCSI(isp)) {
2094                 ISP_WRITE(isp, HCCR, HCCR_CMD_PAUSE);
2095                 printf("    cdma_conf=%x cdma_sts=%x cdma_fifostat=%x\n",
2096                         ISP_READ(isp, CDMA_CONF), ISP_READ(isp, CDMA_STATUS),
2097                         ISP_READ(isp, CDMA_FIFO_STS));
2098                 printf("    ddma_conf=%x ddma_sts=%x ddma_fifostat=%x\n",
2099                         ISP_READ(isp, DDMA_CONF), ISP_READ(isp, DDMA_STATUS),
2100                         ISP_READ(isp, DDMA_FIFO_STS));
2101                 printf("    sxp_int=%x sxp_gross=%x sxp(scsi_ctrl)=%x\n",
2102                         ISP_READ(isp, SXP_INTERRUPT),
2103                         ISP_READ(isp, SXP_GROSS_ERR),
2104                         ISP_READ(isp, SXP_PINS_CTRL));
2105                 ISP_WRITE(isp, HCCR, HCCR_CMD_RELEASE);
2106         }
2107         printf("    mbox regs: %x %x %x %x %x\n",
2108             ISP_READ(isp, OUTMAILBOX0), ISP_READ(isp, OUTMAILBOX1),
2109             ISP_READ(isp, OUTMAILBOX2), ISP_READ(isp, OUTMAILBOX3),
2110             ISP_READ(isp, OUTMAILBOX4));
2111         printf("    PCI Status Command/Status=%x\n",
2112             pci_read_config(pcs->pci_dev, PCIR_COMMAND, 1));
2113 }