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