sys/dev/isp/isp_pci.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2009-2020 Alexander Motin <mav@FreeBSD.org>
   5  * Copyright (c) 1997-2008 by Matthew Jacob
   6  * All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice immediately at the beginning of the file, without modification,
  13  *    this list of conditions, and the following disclaimer.
  14  * 2. The name of the author may not be used to endorse or promote products
  15  *    derived from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  21  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29 /*
  30  * PCI specific probe and attach routines for Qlogic ISP SCSI adapters.
  31  * FreeBSD Version.
  32  */
  33 #include <sys/cdefs.h>
  34 __FBSDID("$FreeBSD$");
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/kernel.h>
  39 #include <sys/module.h>
  40 #include <sys/linker.h>
  41 #include <sys/firmware.h>
  42 #include <sys/bus.h>
  43 #include <sys/stdint.h>
  44 #include <dev/pci/pcireg.h>
  45 #include <dev/pci/pcivar.h>
  46 #include <machine/bus.h>
  47 #include <machine/resource.h>
  48 #include <sys/rman.h>
  49 #include <sys/malloc.h>
  50 #include <sys/uio.h>
  51 #include <dev/isp/isp_freebsd.h>
  52
  53 static uint32_t isp_pci_rd_reg_2400(ispsoftc_t *, int);
  54 static void isp_pci_wr_reg_2400(ispsoftc_t *, int, uint32_t);
  55 static uint32_t isp_pci_rd_reg_2600(ispsoftc_t *, int);
  56 static void isp_pci_wr_reg_2600(ispsoftc_t *, int, uint32_t);
  57 static void isp_pci_run_isr_2400(ispsoftc_t *);
  58 static int isp_pci_mbxdma(ispsoftc_t *);
  59 static void isp_pci_mbxdmafree(ispsoftc_t *);
  60 static int isp_pci_irqsetup(ispsoftc_t *);
  61
  62 static struct ispmdvec mdvec_2400 = {
  63         isp_pci_run_isr_2400,
  64         isp_pci_rd_reg_2400,
  65         isp_pci_wr_reg_2400,
  66         isp_pci_mbxdma,
  67         isp_send_cmd,
  68         isp_pci_irqsetup,
  69         NULL
  70 };
  71
  72 static struct ispmdvec mdvec_2500 = {
  73         isp_pci_run_isr_2400,
  74         isp_pci_rd_reg_2400,
  75         isp_pci_wr_reg_2400,
  76         isp_pci_mbxdma,
  77         isp_send_cmd,
  78         isp_pci_irqsetup,
  79         NULL
  80 };
  81
  82 static struct ispmdvec mdvec_2600 = {
  83         isp_pci_run_isr_2400,
  84         isp_pci_rd_reg_2600,
  85         isp_pci_wr_reg_2600,
  86         isp_pci_mbxdma,
  87         isp_send_cmd,
  88         isp_pci_irqsetup,
  89         NULL
  90 };
  91
  92 static struct ispmdvec mdvec_2700 = {
  93         isp_pci_run_isr_2400,
  94         isp_pci_rd_reg_2600,
  95         isp_pci_wr_reg_2600,
  96         isp_pci_mbxdma,
  97         isp_send_cmd,
  98         isp_pci_irqsetup,
  99         NULL
 100 };
 101
 102 #ifndef PCIM_CMD_INVEN
 103 #define PCIM_CMD_INVEN                  0x10
 104 #endif
 105 #ifndef PCIM_CMD_BUSMASTEREN
 106 #define PCIM_CMD_BUSMASTEREN            0x0004
 107 #endif
 108 #ifndef PCIM_CMD_PERRESPEN
 109 #define PCIM_CMD_PERRESPEN              0x0040
 110 #endif
 111 #ifndef PCIM_CMD_SEREN
 112 #define PCIM_CMD_SEREN                  0x0100
 113 #endif
 114 #ifndef PCIM_CMD_INTX_DISABLE
 115 #define PCIM_CMD_INTX_DISABLE           0x0400
 116 #endif
 117
 118 #ifndef PCIR_COMMAND
 119 #define PCIR_COMMAND                    0x04
 120 #endif
 121
 122 #ifndef PCIR_CACHELNSZ
 123 #define PCIR_CACHELNSZ                  0x0c
 124 #endif
 125
 126 #ifndef PCIR_LATTIMER
 127 #define PCIR_LATTIMER                   0x0d
 128 #endif
 129
 130 #ifndef PCIR_ROMADDR
 131 #define PCIR_ROMADDR                    0x30
 132 #endif
 133
 134 #define PCI_VENDOR_QLOGIC               0x1077
 135
 136 #define PCI_PRODUCT_QLOGIC_ISP2422      0x2422
 137 #define PCI_PRODUCT_QLOGIC_ISP2432      0x2432
 138 #define PCI_PRODUCT_QLOGIC_ISP2532      0x2532
 139 #define PCI_PRODUCT_QLOGIC_ISP5432      0x5432
 140 #define PCI_PRODUCT_QLOGIC_ISP2031      0x2031
 141 #define PCI_PRODUCT_QLOGIC_ISP8031      0x8031
 142 #define PCI_PRODUCT_QLOGIC_ISP2684      0x2171
 143 #define PCI_PRODUCT_QLOGIC_ISP2692      0x2b61
 144 #define PCI_PRODUCT_QLOGIC_ISP2714      0x2071
 145 #define PCI_PRODUCT_QLOGIC_ISP2722      0x2261
 146
 147 #define PCI_QLOGIC_ISP2422      \
 148         ((PCI_PRODUCT_QLOGIC_ISP2422 << 16) | PCI_VENDOR_QLOGIC)
 149 #define PCI_QLOGIC_ISP2432      \
 150         ((PCI_PRODUCT_QLOGIC_ISP2432 << 16) | PCI_VENDOR_QLOGIC)
 151 #define PCI_QLOGIC_ISP2532      \
 152         ((PCI_PRODUCT_QLOGIC_ISP2532 << 16) | PCI_VENDOR_QLOGIC)
 153 #define PCI_QLOGIC_ISP5432      \
 154         ((PCI_PRODUCT_QLOGIC_ISP5432 << 16) | PCI_VENDOR_QLOGIC)
 155 #define PCI_QLOGIC_ISP2031      \
 156         ((PCI_PRODUCT_QLOGIC_ISP2031 << 16) | PCI_VENDOR_QLOGIC)
 157 #define PCI_QLOGIC_ISP8031      \
 158         ((PCI_PRODUCT_QLOGIC_ISP8031 << 16) | PCI_VENDOR_QLOGIC)
 159 #define PCI_QLOGIC_ISP2684      \
 160         ((PCI_PRODUCT_QLOGIC_ISP2684 << 16) | PCI_VENDOR_QLOGIC)
 161 #define PCI_QLOGIC_ISP2692      \
 162         ((PCI_PRODUCT_QLOGIC_ISP2692 << 16) | PCI_VENDOR_QLOGIC)
 163 #define PCI_QLOGIC_ISP2714      \
 164         ((PCI_PRODUCT_QLOGIC_ISP2714 << 16) | PCI_VENDOR_QLOGIC)
 165 #define PCI_QLOGIC_ISP2722      \
 166         ((PCI_PRODUCT_QLOGIC_ISP2722 << 16) | PCI_VENDOR_QLOGIC)
 167
 168 #define PCI_DFLT_LTNCY  0x40
 169 #define PCI_DFLT_LNSZ   0x10
 170
 171 static int isp_pci_probe (device_t);
 172 static int isp_pci_attach (device_t);
 173 static int isp_pci_detach (device_t);
 174
 175
 176 struct isp_pcisoftc {
 177         ispsoftc_t                      pci_isp;
 178         struct resource *               regs;
 179         struct resource *               regs1;
 180         struct resource *               regs2;
 181         struct {
 182                 int                             iqd;
 183                 struct resource *               irq;
 184                 void *                          ih;
 185         } irq[ISP_MAX_IRQS];
 186         int                             rtp;
 187         int                             rgd;
 188         int                             rtp1;
 189         int                             rgd1;
 190         int                             rtp2;
 191         int                             rgd2;
 192         bus_dma_tag_t                   dmat;
 193         int                             msicount;
 194 };
 195
 196
 197 static device_method_t isp_pci_methods[] = {
 198         /* Device interface */
 199         DEVMETHOD(device_probe,         isp_pci_probe),
 200         DEVMETHOD(device_attach,        isp_pci_attach),
 201         DEVMETHOD(device_detach,        isp_pci_detach),
 202         { 0, 0 }
 203 };
 204
 205 static driver_t isp_pci_driver = {
 206         "isp", isp_pci_methods, sizeof (struct isp_pcisoftc)
 207 };
 208 static devclass_t isp_devclass;
 209 DRIVER_MODULE(isp, pci, isp_pci_driver, isp_devclass, 0, 0);
 210 MODULE_DEPEND(isp, cam, 1, 1, 1);
 211 MODULE_DEPEND(isp, firmware, 1, 1, 1);
 212 static int isp_nvports = 0;
 213
 214 static int
 215 isp_pci_probe(device_t dev)
 216 {
 217         switch ((pci_get_device(dev) << 16) | (pci_get_vendor(dev))) {
 218         case PCI_QLOGIC_ISP2422:
 219                 device_set_desc(dev, "Qlogic ISP 2422 PCI FC-AL Adapter");
 220                 break;
 221         case PCI_QLOGIC_ISP2432:
 222                 device_set_desc(dev, "Qlogic ISP 2432 PCI FC-AL Adapter");
 223                 break;
 224         case PCI_QLOGIC_ISP2532:
 225                 device_set_desc(dev, "Qlogic ISP 2532 PCI FC-AL Adapter");
 226                 break;
 227         case PCI_QLOGIC_ISP5432:
 228                 device_set_desc(dev, "Qlogic ISP 5432 PCI FC-AL Adapter");
 229                 break;
 230         case PCI_QLOGIC_ISP2031:
 231                 device_set_desc(dev, "Qlogic ISP 2031 PCI FC-AL Adapter");
 232                 break;
 233         case PCI_QLOGIC_ISP8031:
 234                 device_set_desc(dev, "Qlogic ISP 8031 PCI FCoE Adapter");
 235                 break;
 236         case PCI_QLOGIC_ISP2684:
 237                 device_set_desc(dev, "Qlogic ISP 2684 PCI FC Adapter");
 238                 break;
 239         case PCI_QLOGIC_ISP2692:
 240                 device_set_desc(dev, "Qlogic ISP 2692 PCI FC Adapter");
 241                 break;
 242         case PCI_QLOGIC_ISP2714:
 243                 device_set_desc(dev, "Qlogic ISP 2714 PCI FC Adapter");
 244                 break;
 245         case PCI_QLOGIC_ISP2722:
 246                 device_set_desc(dev, "Qlogic ISP 2722 PCI FC Adapter");
 247                 break;
 248         default:
 249                 return (ENXIO);
 250         }
 251         if (isp_announced == 0 && bootverbose) {
 252                 printf("Qlogic ISP Driver, FreeBSD Version %d.%d, "
 253                     "Core Version %d.%d\n",
 254                     ISP_PLATFORM_VERSION_MAJOR, ISP_PLATFORM_VERSION_MINOR,
 255                     ISP_CORE_VERSION_MAJOR, ISP_CORE_VERSION_MINOR);
 256                 isp_announced++;
 257         }
 258         /*
 259          * XXXX: Here is where we might load the f/w module
 260          * XXXX: (or increase a reference count to it).
 261          */
 262         return (BUS_PROBE_DEFAULT);
 263 }
 264
 265 static void
 266 isp_get_generic_options(device_t dev, ispsoftc_t *isp)
 267 {
 268         int tval;
 269
 270         tval = 0;
 271         if (resource_int_value(device_get_name(dev), device_get_unit(dev), "fwload_disable", &tval) == 0 && tval != 0) {
 272                 isp->isp_confopts |= ISP_CFG_NORELOAD;
 273         }
 274         tval = 0;
 275         if (resource_int_value(device_get_name(dev), device_get_unit(dev), "ignore_nvram", &tval) == 0 && tval != 0) {
 276                 isp->isp_confopts |= ISP_CFG_NONVRAM;
 277         }
 278         tval = 0;
 279         (void) resource_int_value(device_get_name(dev), device_get_unit(dev), "debug", &tval);
 280         if (tval) {
 281                 isp->isp_dblev = tval;
 282         } else {
 283                 isp->isp_dblev = ISP_LOGWARN|ISP_LOGERR;
 284         }
 285         if (bootverbose) {
 286                 isp->isp_dblev |= ISP_LOGCONFIG|ISP_LOGINFO;
 287         }
 288         tval = -1;
 289         (void) resource_int_value(device_get_name(dev), device_get_unit(dev), "vports", &tval);
 290         if (tval > 0 && tval <= 254) {
 291                 isp_nvports = tval;
 292         }
 293         tval = 7;
 294         (void) resource_int_value(device_get_name(dev), device_get_unit(dev), "quickboot_time", &tval);
 295         isp_quickboot_time = tval;
 296 }
 297
 298 static void
 299 isp_get_specific_options(device_t dev, int chan, ispsoftc_t *isp)
 300 {
 301         const char *sptr;
 302         int tval = 0;
 303         char prefix[12], name[16];
 304
 305         if (chan == 0)
 306                 prefix[0] = 0;
 307         else
 308                 snprintf(prefix, sizeof(prefix), "chan%d.", chan);
 309         snprintf(name, sizeof(name), "%siid", prefix);
 310         if (resource_int_value(device_get_name(dev), device_get_unit(dev),
 311             name, &tval)) {
 312                 ISP_FC_PC(isp, chan)->default_id = 109 - chan;
 313         } else {
 314                 ISP_FC_PC(isp, chan)->default_id = tval - chan;
 315                 isp->isp_confopts |= ISP_CFG_OWNLOOPID;
 316         }
 317
 318         tval = -1;
 319         snprintf(name, sizeof(name), "%srole", prefix);
 320         if (resource_int_value(device_get_name(dev), device_get_unit(dev),
 321             name, &tval) == 0) {
 322                 switch (tval) {
 323                 case ISP_ROLE_NONE:
 324                 case ISP_ROLE_INITIATOR:
 325                 case ISP_ROLE_TARGET:
 326                 case ISP_ROLE_BOTH:
 327                         device_printf(dev, "Chan %d setting role to 0x%x\n", chan, tval);
 328                         break;
 329                 default:
 330                         tval = -1;
 331                         break;
 332                 }
 333         }
 334         if (tval == -1) {
 335                 tval = ISP_DEFAULT_ROLES;
 336         }
 337         ISP_FC_PC(isp, chan)->def_role = tval;
 338
 339         tval = 0;
 340         snprintf(name, sizeof(name), "%sfullduplex", prefix);
 341         if (resource_int_value(device_get_name(dev), device_get_unit(dev),
 342             name, &tval) == 0 && tval != 0) {
 343                 isp->isp_confopts |= ISP_CFG_FULL_DUPLEX;
 344         }
 345         sptr = NULL;
 346         snprintf(name, sizeof(name), "%stopology", prefix);
 347         if (resource_string_value(device_get_name(dev), device_get_unit(dev),
 348             name, (const char **) &sptr) == 0 && sptr != NULL) {
 349                 if (strcmp(sptr, "lport") == 0) {
 350                         isp->isp_confopts |= ISP_CFG_LPORT;
 351                 } else if (strcmp(sptr, "nport") == 0) {
 352                         isp->isp_confopts |= ISP_CFG_NPORT;
 353                 } else if (strcmp(sptr, "lport-only") == 0) {
 354                         isp->isp_confopts |= ISP_CFG_LPORT_ONLY;
 355                 } else if (strcmp(sptr, "nport-only") == 0) {
 356                         isp->isp_confopts |= ISP_CFG_NPORT_ONLY;
 357                 }
 358         }
 359
 360 #ifdef ISP_FCTAPE_OFF
 361         isp->isp_confopts |= ISP_CFG_NOFCTAPE;
 362 #else
 363         isp->isp_confopts |= ISP_CFG_FCTAPE;
 364 #endif
 365
 366         tval = 0;
 367         snprintf(name, sizeof(name), "%snofctape", prefix);
 368         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 369             name, &tval);
 370         if (tval) {
 371                 isp->isp_confopts &= ~ISP_CFG_FCTAPE;
 372                 isp->isp_confopts |= ISP_CFG_NOFCTAPE;
 373         }
 374
 375         tval = 0;
 376         snprintf(name, sizeof(name), "%sfctape", prefix);
 377         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 378             name, &tval);
 379         if (tval) {
 380                 isp->isp_confopts &= ~ISP_CFG_NOFCTAPE;
 381                 isp->isp_confopts |= ISP_CFG_FCTAPE;
 382         }
 383
 384
 385         /*
 386          * Because the resource_*_value functions can neither return
 387          * 64 bit integer values, nor can they be directly coerced
 388          * to interpret the right hand side of the assignment as
 389          * you want them to interpret it, we have to force WWN
 390          * hint replacement to specify WWN strings with a leading
 391          * 'w' (e..g w50000000aaaa0001). Sigh.
 392          */
 393         sptr = NULL;
 394         snprintf(name, sizeof(name), "%sportwwn", prefix);
 395         tval = resource_string_value(device_get_name(dev), device_get_unit(dev),
 396             name, (const char **) &sptr);
 397         if (tval == 0 && sptr != NULL && *sptr++ == 'w') {
 398                 char *eptr = NULL;
 399                 ISP_FC_PC(isp, chan)->def_wwpn = strtouq(sptr, &eptr, 16);
 400                 if (eptr < sptr + 16 || ISP_FC_PC(isp, chan)->def_wwpn == -1) {
 401                         device_printf(dev, "mangled portwwn hint '%s'\n", sptr);
 402                         ISP_FC_PC(isp, chan)->def_wwpn = 0;
 403                 }
 404         }
 405
 406         sptr = NULL;
 407         snprintf(name, sizeof(name), "%snodewwn", prefix);
 408         tval = resource_string_value(device_get_name(dev), device_get_unit(dev),
 409             name, (const char **) &sptr);
 410         if (tval == 0 && sptr != NULL && *sptr++ == 'w') {
 411                 char *eptr = NULL;
 412                 ISP_FC_PC(isp, chan)->def_wwnn = strtouq(sptr, &eptr, 16);
 413                 if (eptr < sptr + 16 || ISP_FC_PC(isp, chan)->def_wwnn == 0) {
 414                         device_printf(dev, "mangled nodewwn hint '%s'\n", sptr);
 415                         ISP_FC_PC(isp, chan)->def_wwnn = 0;
 416                 }
 417         }
 418
 419         tval = -1;
 420         snprintf(name, sizeof(name), "%sloop_down_limit", prefix);
 421         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 422             name, &tval);
 423         if (tval >= 0 && tval < 0xffff) {
 424                 ISP_FC_PC(isp, chan)->loop_down_limit = tval;
 425         } else {
 426                 ISP_FC_PC(isp, chan)->loop_down_limit = isp_loop_down_limit;
 427         }
 428
 429         tval = -1;
 430         snprintf(name, sizeof(name), "%sgone_device_time", prefix);
 431         (void) resource_int_value(device_get_name(dev), device_get_unit(dev),
 432             name, &tval);
 433         if (tval >= 0 && tval < 0xffff) {
 434                 ISP_FC_PC(isp, chan)->gone_device_time = tval;
 435         } else {
 436                 ISP_FC_PC(isp, chan)->gone_device_time = isp_gone_device_time;
 437         }
 438 }
 439
 440 static int
 441 isp_pci_attach(device_t dev)
 442 {
 443         struct isp_pcisoftc *pcs = device_get_softc(dev);
 444         ispsoftc_t *isp = &pcs->pci_isp;
 445         int i;
 446         uint32_t data, cmd, linesz, did;
 447         size_t psize, xsize;
 448         char fwname[32];
 449
 450         isp->isp_dev = dev;
 451         isp->isp_nchan = 1;
 452         mtx_init(&isp->isp_lock, "isp", NULL, MTX_DEF);
 453
 454         /*
 455          * Get Generic Options
 456          */
 457         isp_nvports = 0;
 458         isp_get_generic_options(dev, isp);
 459
 460         linesz = PCI_DFLT_LNSZ;
 461         pcs->regs = pcs->regs2 = NULL;
 462         pcs->rgd = pcs->rtp = 0;
 463
 464         isp->isp_nchan += isp_nvports;
 465         switch (pci_get_devid(dev)) {
 466         case PCI_QLOGIC_ISP2422:
 467         case PCI_QLOGIC_ISP2432:
 468                 did = 0x2400;
 469                 isp->isp_mdvec = &mdvec_2400;
 470                 isp->isp_type = ISP_HA_FC_2400;
 471                 break;
 472         case PCI_QLOGIC_ISP2532:
 473                 did = 0x2500;
 474                 isp->isp_mdvec = &mdvec_2500;
 475                 isp->isp_type = ISP_HA_FC_2500;
 476                 break;
 477         case PCI_QLOGIC_ISP5432:
 478                 did = 0x2500;
 479                 isp->isp_mdvec = &mdvec_2500;
 480                 isp->isp_type = ISP_HA_FC_2500;
 481                 break;
 482         case PCI_QLOGIC_ISP2031:
 483         case PCI_QLOGIC_ISP8031:
 484                 did = 0x2600;
 485                 isp->isp_mdvec = &mdvec_2600;
 486                 isp->isp_type = ISP_HA_FC_2600;
 487                 break;
 488         case PCI_QLOGIC_ISP2684:
 489         case PCI_QLOGIC_ISP2692:
 490         case PCI_QLOGIC_ISP2714:
 491         case PCI_QLOGIC_ISP2722:
 492                 did = 0x2700;
 493                 isp->isp_mdvec = &mdvec_2700;
 494                 isp->isp_type = ISP_HA_FC_2700;
 495                 break;
 496         default:
 497                 device_printf(dev, "unknown device type\n");
 498                 goto bad;
 499                 break;
 500         }
 501         isp->isp_revision = pci_get_revid(dev);
 502
 503         if (IS_26XX(isp)) {
 504                 pcs->rtp = SYS_RES_MEMORY;
 505                 pcs->rgd = PCIR_BAR(0);
 506                 pcs->regs = bus_alloc_resource_any(dev, pcs->rtp, &pcs->rgd,
 507                     RF_ACTIVE);
 508                 pcs->rtp1 = SYS_RES_MEMORY;
 509                 pcs->rgd1 = PCIR_BAR(2);
 510                 pcs->regs1 = bus_alloc_resource_any(dev, pcs->rtp1, &pcs->rgd1,
 511                     RF_ACTIVE);
 512                 pcs->rtp2 = SYS_RES_MEMORY;
 513                 pcs->rgd2 = PCIR_BAR(4);
 514                 pcs->regs2 = bus_alloc_resource_any(dev, pcs->rtp2, &pcs->rgd2,
 515                     RF_ACTIVE);
 516         } else {
 517                 pcs->rtp = SYS_RES_MEMORY;
 518                 pcs->rgd = PCIR_BAR(1);
 519                 pcs->regs = bus_alloc_resource_any(dev, pcs->rtp, &pcs->rgd,
 520                     RF_ACTIVE);
 521                 if (pcs->regs == NULL) {
 522                         pcs->rtp = SYS_RES_IOPORT;
 523                         pcs->rgd = PCIR_BAR(0);
 524                         pcs->regs = bus_alloc_resource_any(dev, pcs->rtp,
 525                             &pcs->rgd, RF_ACTIVE);
 526                 }
 527         }
 528         if (pcs->regs == NULL) {
 529                 device_printf(dev, "Unable to map any ports\n");
 530                 goto bad;
 531         }
 532         if (bootverbose) {
 533                 device_printf(dev, "Using %s space register mapping\n",
 534                     (pcs->rtp == SYS_RES_IOPORT)? "I/O" : "Memory");
 535         }
 536         isp->isp_regs = pcs->regs;
 537         isp->isp_regs2 = pcs->regs2;
 538
 539         psize = sizeof(fcparam) * isp->isp_nchan;
 540         xsize = sizeof(struct isp_fc) * isp->isp_nchan;
 541         isp->isp_param = malloc(psize, M_DEVBUF, M_NOWAIT | M_ZERO);
 542         if (isp->isp_param == NULL) {
 543                 device_printf(dev, "cannot allocate parameter data\n");
 544                 goto bad;
 545         }
 546         isp->isp_osinfo.fc = malloc(xsize, M_DEVBUF, M_NOWAIT | M_ZERO);
 547         if (isp->isp_osinfo.fc == NULL) {
 548                 device_printf(dev, "cannot allocate parameter data\n");
 549                 goto bad;
 550         }
 551
 552         /*
 553          * Now that we know who we are (roughly) get/set specific options
 554          */
 555         for (i = 0; i < isp->isp_nchan; i++) {
 556                 isp_get_specific_options(dev, i, isp);
 557         }
 558
 559         isp->isp_osinfo.fw = NULL;
 560         if (isp->isp_osinfo.fw == NULL) {
 561                 snprintf(fwname, sizeof (fwname), "isp_%04x", did);
 562                 isp->isp_osinfo.fw = firmware_get(fwname);
 563         }
 564         if (isp->isp_osinfo.fw != NULL) {
 565                 isp_prt(isp, ISP_LOGCONFIG, "loaded firmware %s", fwname);
 566                 isp->isp_mdvec->dv_ispfw = isp->isp_osinfo.fw->data;
 567         }
 568
 569         /*
 570          * Make sure that SERR, PERR, WRITE INVALIDATE and BUSMASTER are set.
 571          */
 572         cmd = pci_read_config(dev, PCIR_COMMAND, 2);
 573         cmd |= PCIM_CMD_SEREN | PCIM_CMD_PERRESPEN | PCIM_CMD_BUSMASTEREN | PCIM_CMD_INVEN;
 574         cmd &= ~PCIM_CMD_INTX_DISABLE;
 575         pci_write_config(dev, PCIR_COMMAND, cmd, 2);
 576
 577         /*
 578          * Make sure the Cache Line Size register is set sensibly.
 579          */
 580         data = pci_read_config(dev, PCIR_CACHELNSZ, 1);
 581         if (data == 0 || (linesz != PCI_DFLT_LNSZ && data != linesz)) {
 582                 isp_prt(isp, ISP_LOGDEBUG0, "set PCI line size to %d from %d", linesz, data);
 583                 data = linesz;
 584                 pci_write_config(dev, PCIR_CACHELNSZ, data, 1);
 585         }
 586
 587         /*
 588          * Make sure the Latency Timer is sane.
 589          */
 590         data = pci_read_config(dev, PCIR_LATTIMER, 1);
 591         if (data < PCI_DFLT_LTNCY) {
 592                 data = PCI_DFLT_LTNCY;
 593                 isp_prt(isp, ISP_LOGDEBUG0, "set PCI latency to %d", data);
 594                 pci_write_config(dev, PCIR_LATTIMER, data, 1);
 595         }
 596
 597         /*
 598          * Make sure we've disabled the ROM.
 599          */
 600         data = pci_read_config(dev, PCIR_ROMADDR, 4);
 601         data &= ~1;
 602         pci_write_config(dev, PCIR_ROMADDR, data, 4);
 603
 604         /*
 605          * Last minute checks...
 606          */
 607         isp->isp_port = pci_get_function(dev);
 608
 609         /*
 610          * Make sure we're in reset state.
 611          */
 612         ISP_LOCK(isp);
 613         if (isp_reinit(isp, 1) != 0) {
 614                 ISP_UNLOCK(isp);
 615                 goto bad;
 616         }
 617         ISP_UNLOCK(isp);
 618         if (isp_attach(isp)) {
 619                 ISP_LOCK(isp);
 620                 isp_shutdown(isp);
 621                 ISP_UNLOCK(isp);
 622                 goto bad;
 623         }
 624         return (0);
 625
 626 bad:
 627         if (isp->isp_osinfo.fw == NULL && !IS_26XX(isp)) {
 628                 /*
 629                  * Failure to attach at boot time might have been caused
 630                  * by a missing ispfw(4).  Except for for 16Gb adapters,
 631                  * there's no loadable firmware for them.
 632                  */
 633                 isp_prt(isp, ISP_LOGWARN, "See the ispfw(4) man page on "
 634                     "how to load known good firmware at boot time");
 635         }
 636         for (i = 0; i < isp->isp_nirq; i++) {
 637                 (void) bus_teardown_intr(dev, pcs->irq[i].irq, pcs->irq[i].ih);
 638                 (void) bus_release_resource(dev, SYS_RES_IRQ, pcs->irq[i].iqd,
 639                     pcs->irq[0].irq);
 640         }
 641         if (pcs->msicount) {
 642                 pci_release_msi(dev);
 643         }
 644         if (pcs->regs)
 645                 (void) bus_release_resource(dev, pcs->rtp, pcs->rgd, pcs->regs);
 646         if (pcs->regs1)
 647                 (void) bus_release_resource(dev, pcs->rtp1, pcs->rgd1, pcs->regs1);
 648         if (pcs->regs2)
 649                 (void) bus_release_resource(dev, pcs->rtp2, pcs->rgd2, pcs->regs2);
 650         if (pcs->pci_isp.isp_param) {
 651                 free(pcs->pci_isp.isp_param, M_DEVBUF);
 652                 pcs->pci_isp.isp_param = NULL;
 653         }
 654         if (pcs->pci_isp.isp_osinfo.fc) {
 655                 free(pcs->pci_isp.isp_osinfo.fc, M_DEVBUF);
 656                 pcs->pci_isp.isp_osinfo.fc = NULL;
 657         }
 658         mtx_destroy(&isp->isp_lock);
 659         return (ENXIO);
 660 }
 661
 662 static int
 663 isp_pci_detach(device_t dev)
 664 {
 665         struct isp_pcisoftc *pcs = device_get_softc(dev);
 666         ispsoftc_t *isp = &pcs->pci_isp;
 667         int i, status;
 668
 669         status = isp_detach(isp);
 670         if (status)
 671                 return (status);
 672         ISP_LOCK(isp);
 673         isp_shutdown(isp);
 674         ISP_UNLOCK(isp);
 675         for (i = 0; i < isp->isp_nirq; i++) {
 676                 (void) bus_teardown_intr(dev, pcs->irq[i].irq, pcs->irq[i].ih);
 677                 (void) bus_release_resource(dev, SYS_RES_IRQ, pcs->irq[i].iqd,
 678                     pcs->irq[i].irq);
 679         }
 680         if (pcs->msicount)
 681                 pci_release_msi(dev);
 682         (void) bus_release_resource(dev, pcs->rtp, pcs->rgd, pcs->regs);
 683         if (pcs->regs1)
 684                 (void) bus_release_resource(dev, pcs->rtp1, pcs->rgd1, pcs->regs1);
 685         if (pcs->regs2)
 686                 (void) bus_release_resource(dev, pcs->rtp2, pcs->rgd2, pcs->regs2);
 687         isp_pci_mbxdmafree(isp);
 688         if (pcs->pci_isp.isp_param) {
 689                 free(pcs->pci_isp.isp_param, M_DEVBUF);
 690                 pcs->pci_isp.isp_param = NULL;
 691         }
 692         if (pcs->pci_isp.isp_osinfo.fc) {
 693                 free(pcs->pci_isp.isp_osinfo.fc, M_DEVBUF);
 694                 pcs->pci_isp.isp_osinfo.fc = NULL;
 695         }
 696         mtx_destroy(&isp->isp_lock);
 697         return (0);
 698 }
 699
 700 #define BXR2(isp, off)          bus_read_2((isp)->isp_regs, (off))
 701 #define BXW2(isp, off, v)       bus_write_2((isp)->isp_regs, (off), (v))
 702 #define BXR4(isp, off)          bus_read_4((isp)->isp_regs, (off))
 703 #define BXW4(isp, off, v)       bus_write_4((isp)->isp_regs, (off), (v))
 704 #define B2R4(isp, off)          bus_read_4((isp)->isp_regs2, (off))
 705 #define B2W4(isp, off, v)       bus_write_4((isp)->isp_regs2, (off), (v))
 706
 707 static void
 708 isp_pci_run_isr_2400(ispsoftc_t *isp)
 709 {
 710         uint32_t r2hisr;
 711         uint16_t isr, info;
 712
 713         r2hisr = BXR4(isp, BIU2400_R2HSTS);
 714         isp_prt(isp, ISP_LOGDEBUG3, "RISC2HOST ISR 0x%x", r2hisr);
 715         if ((r2hisr & BIU_R2HST_INTR) == 0)
 716                 return;
 717         isr = r2hisr & BIU_R2HST_ISTAT_MASK;
 718         info = (r2hisr >> 16);
 719         switch (isr) {
 720         case ISPR2HST_ROM_MBX_OK:
 721         case ISPR2HST_ROM_MBX_FAIL:
 722         case ISPR2HST_MBX_OK:
 723         case ISPR2HST_MBX_FAIL:
 724                 isp_intr_mbox(isp, info);
 725                 break;
 726         case ISPR2HST_ASYNC_EVENT:
 727                 isp_intr_async(isp, info);
 728                 break;
 729         case ISPR2HST_RSPQ_UPDATE:
 730                 isp_intr_respq(isp);
 731                 break;
 732         case ISPR2HST_RSPQ_UPDATE2:
 733 #ifdef  ISP_TARGET_MODE
 734         case ISPR2HST_ATIO_RSPQ_UPDATE:
 735 #endif
 736                 isp_intr_respq(isp);
 737                 /* FALLTHROUGH */
 738 #ifdef  ISP_TARGET_MODE
 739         case ISPR2HST_ATIO_UPDATE:
 740         case ISPR2HST_ATIO_UPDATE2:
 741                 isp_intr_atioq(isp);
 742 #endif
 743                 break;
 744         default:
 745                 isp_prt(isp, ISP_LOGERR, "unknown interrupt 0x%x\n", r2hisr);
 746         }
 747         ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
 748 }
 749
 750 static uint32_t
 751 isp_pci_rd_reg_2400(ispsoftc_t *isp, int regoff)
 752 {
 753         int block = regoff & _BLK_REG_MASK;
 754
 755         switch (block) {
 756         case BIU_BLOCK:
 757                 return (BXR4(isp, regoff));
 758         case MBOX_BLOCK:
 759                 return (BXR2(isp, regoff));
 760         }
 761         isp_prt(isp, ISP_LOGERR, "unknown block read at 0x%x", regoff);
 762         return (0xffffffff);
 763 }
 764
 765 static void
 766 isp_pci_wr_reg_2400(ispsoftc_t *isp, int regoff, uint32_t val)
 767 {
 768         int block = regoff & _BLK_REG_MASK;
 769
 770         switch (block) {
 771         case BIU_BLOCK:
 772                 BXW4(isp, regoff, val);
 773 #ifdef MEMORYBARRIERW
 774                 if (regoff == BIU2400_REQINP ||
 775                     regoff == BIU2400_RSPOUTP ||
 776                     regoff == BIU2400_PRI_REQINP ||
 777                     regoff == BIU2400_ATIO_RSPOUTP)
 778                         MEMORYBARRIERW(isp, SYNC_REG, regoff, 4, -1)
 779                 else
 780 #endif
 781                 MEMORYBARRIER(isp, SYNC_REG, regoff, 4, -1);
 782                 return;
 783         case MBOX_BLOCK:
 784                 BXW2(isp, regoff, val);
 785                 MEMORYBARRIER(isp, SYNC_REG, regoff, 2, -1);
 786                 return;
 787         }
 788         isp_prt(isp, ISP_LOGERR, "unknown block write at 0x%x", regoff);
 789 }
 790
 791 static uint32_t
 792 isp_pci_rd_reg_2600(ispsoftc_t *isp, int regoff)
 793 {
 794         uint32_t rv;
 795
 796         switch (regoff) {
 797         case BIU2400_PRI_REQINP:
 798         case BIU2400_PRI_REQOUTP:
 799                 isp_prt(isp, ISP_LOGERR, "unknown register read at 0x%x",
 800                     regoff);
 801                 rv = 0xffffffff;
 802                 break;
 803         case BIU2400_REQINP:
 804                 rv = B2R4(isp, 0x00);
 805                 break;
 806         case BIU2400_REQOUTP:
 807                 rv = B2R4(isp, 0x04);
 808                 break;
 809         case BIU2400_RSPINP:
 810                 rv = B2R4(isp, 0x08);
 811                 break;
 812         case BIU2400_RSPOUTP:
 813                 rv = B2R4(isp, 0x0c);
 814                 break;
 815         case BIU2400_ATIO_RSPINP:
 816                 rv = B2R4(isp, 0x10);
 817                 break;
 818         case BIU2400_ATIO_RSPOUTP:
 819                 rv = B2R4(isp, 0x14);
 820                 break;
 821         default:
 822                 rv = isp_pci_rd_reg_2400(isp, regoff);
 823                 break;
 824         }
 825         return (rv);
 826 }
 827
 828 static void
 829 isp_pci_wr_reg_2600(ispsoftc_t *isp, int regoff, uint32_t val)
 830 {
 831         int off;
 832
 833         switch (regoff) {
 834         case BIU2400_PRI_REQINP:
 835         case BIU2400_PRI_REQOUTP:
 836                 isp_prt(isp, ISP_LOGERR, "unknown register write at 0x%x",
 837                     regoff);
 838                 return;
 839         case BIU2400_REQINP:
 840                 off = 0x00;
 841                 break;
 842         case BIU2400_REQOUTP:
 843                 off = 0x04;
 844                 break;
 845         case BIU2400_RSPINP:
 846                 off = 0x08;
 847                 break;
 848         case BIU2400_RSPOUTP:
 849                 off = 0x0c;
 850                 break;
 851         case BIU2400_ATIO_RSPINP:
 852                 off = 0x10;
 853                 break;
 854         case BIU2400_ATIO_RSPOUTP:
 855                 off = 0x14;
 856                 break;
 857         default:
 858                 isp_pci_wr_reg_2400(isp, regoff, val);
 859                 return;
 860         }
 861         B2W4(isp, off, val);
 862 }
 863
 864
 865 struct imush {
 866         bus_addr_t maddr;
 867         int error;
 868 };
 869
 870 static void
 871 imc(void *arg, bus_dma_segment_t *segs, int nseg, int error)
 872 {
 873         struct imush *imushp = (struct imush *) arg;
 874
 875         if (!(imushp->error = error))
 876                 imushp->maddr = segs[0].ds_addr;
 877 }
 878
 879 static int
 880 isp_pci_mbxdma(ispsoftc_t *isp)
 881 {
 882         bus_dma_tag_t ptag;
 883         caddr_t base;
 884         uint32_t len;
 885         int i, error, cmap;
 886         bus_size_t slim;        /* segment size */
 887         struct imush im;
 888 #ifdef  ISP_TARGET_MODE
 889         isp_ecmd_t *ecmd;
 890 #endif
 891
 892         /* Already been here? If so, leave... */
 893         if (isp->isp_xflist != NULL)
 894                 return (0);
 895         if (isp->isp_rquest != NULL && isp->isp_maxcmds == 0)
 896                 return (0);
 897         ISP_UNLOCK(isp);
 898
 899         ptag = bus_get_dma_tag(isp->isp_osinfo.dev);
 900         if (sizeof (bus_size_t) > 4)
 901                 slim = (bus_size_t) (1ULL << 32);
 902         else
 903                 slim = (bus_size_t) (1UL << 31);
 904
 905         if (isp->isp_rquest != NULL)
 906                 goto gotmaxcmds;
 907
 908         /*
 909          * Allocate and map the request queue.
 910          */
 911         len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
 912         if (bus_dma_tag_create(ptag, QENTRY_LEN, slim,
 913             BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
 914             len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.reqdmat)) {
 915                 isp_prt(isp, ISP_LOGERR, "cannot create request DMA tag");
 916                 goto bad;
 917         }
 918         if (bus_dmamem_alloc(isp->isp_osinfo.reqdmat, (void **)&base,
 919             BUS_DMA_COHERENT, &isp->isp_osinfo.reqmap) != 0) {
 920                 isp_prt(isp, ISP_LOGERR, "cannot allocate request DMA memory");
 921                 bus_dma_tag_destroy(isp->isp_osinfo.reqdmat);
 922                 goto bad;
 923         }
 924         isp->isp_rquest = base;
 925         im.error = 0;
 926         if (bus_dmamap_load(isp->isp_osinfo.reqdmat, isp->isp_osinfo.reqmap,
 927             base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
 928                 isp_prt(isp, ISP_LOGERR, "error loading request DMA map %d", im.error);
 929                 goto bad;
 930         }
 931         isp_prt(isp, ISP_LOGDEBUG0, "request area @ 0x%jx/0x%jx",
 932             (uintmax_t)im.maddr, (uintmax_t)len);
 933         isp->isp_rquest_dma = im.maddr;
 934
 935 #ifdef  ISP_TARGET_MODE
 936         /*
 937          * Allocate region for external DMA addressable command/status structures.
 938          */
 939         len = N_XCMDS * XCMD_SIZE;
 940         if (bus_dma_tag_create(ptag, XCMD_SIZE, slim,
 941             BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
 942             len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.ecmd_dmat)) {
 943                 isp_prt(isp, ISP_LOGERR, "cannot create ECMD DMA tag");
 944                 goto bad;
 945         }
 946         if (bus_dmamem_alloc(isp->isp_osinfo.ecmd_dmat, (void **)&base,
 947             BUS_DMA_COHERENT, &isp->isp_osinfo.ecmd_map) != 0) {
 948                 isp_prt(isp, ISP_LOGERR, "cannot allocate ECMD DMA memory");
 949                 bus_dma_tag_destroy(isp->isp_osinfo.ecmd_dmat);
 950                 goto bad;
 951         }
 952         isp->isp_osinfo.ecmd_base = (isp_ecmd_t *)base;
 953         im.error = 0;
 954         if (bus_dmamap_load(isp->isp_osinfo.ecmd_dmat, isp->isp_osinfo.ecmd_map,
 955             base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
 956                 isp_prt(isp, ISP_LOGERR, "error loading ECMD DMA map %d", im.error);
 957                 goto bad;
 958         }
 959         isp_prt(isp, ISP_LOGDEBUG0, "ecmd area @ 0x%jx/0x%jx",
 960             (uintmax_t)im.maddr, (uintmax_t)len);
 961
 962         isp->isp_osinfo.ecmd_dma = im.maddr;
 963         isp->isp_osinfo.ecmd_free = (isp_ecmd_t *)base;
 964         for (ecmd = isp->isp_osinfo.ecmd_free;
 965             ecmd < &isp->isp_osinfo.ecmd_free[N_XCMDS]; ecmd++) {
 966                 if (ecmd == &isp->isp_osinfo.ecmd_free[N_XCMDS - 1])
 967                         ecmd->next = NULL;
 968                 else
 969                         ecmd->next = ecmd + 1;
 970         }
 971 #endif
 972
 973         /*
 974          * Allocate and map the result queue.
 975          */
 976         len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
 977         if (bus_dma_tag_create(ptag, QENTRY_LEN, slim,
 978             BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
 979             len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.respdmat)) {
 980                 isp_prt(isp, ISP_LOGERR, "cannot create response DMA tag");
 981                 goto bad;
 982         }
 983         if (bus_dmamem_alloc(isp->isp_osinfo.respdmat, (void **)&base,
 984             BUS_DMA_COHERENT, &isp->isp_osinfo.respmap) != 0) {
 985                 isp_prt(isp, ISP_LOGERR, "cannot allocate response DMA memory");
 986                 bus_dma_tag_destroy(isp->isp_osinfo.respdmat);
 987                 goto bad;
 988         }
 989         isp->isp_result = base;
 990         im.error = 0;
 991         if (bus_dmamap_load(isp->isp_osinfo.respdmat, isp->isp_osinfo.respmap,
 992             base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
 993                 isp_prt(isp, ISP_LOGERR, "error loading response DMA map %d", im.error);
 994                 goto bad;
 995         }
 996         isp_prt(isp, ISP_LOGDEBUG0, "response area @ 0x%jx/0x%jx",
 997             (uintmax_t)im.maddr, (uintmax_t)len);
 998         isp->isp_result_dma = im.maddr;
 999
1000 #ifdef  ISP_TARGET_MODE
1001         /*
1002          * Allocate and map ATIO queue.
1003          */
1004         len = ISP_QUEUE_SIZE(ATIO_QUEUE_LEN(isp));
1005         if (bus_dma_tag_create(ptag, QENTRY_LEN, slim,
1006             BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
1007             len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.atiodmat)) {
1008                 isp_prt(isp, ISP_LOGERR, "cannot create ATIO DMA tag");
1009                 goto bad;
1010         }
1011         if (bus_dmamem_alloc(isp->isp_osinfo.atiodmat, (void **)&base,
1012             BUS_DMA_COHERENT, &isp->isp_osinfo.atiomap) != 0) {
1013                 isp_prt(isp, ISP_LOGERR, "cannot allocate ATIO DMA memory");
1014                 bus_dma_tag_destroy(isp->isp_osinfo.atiodmat);
1015                 goto bad;
1016         }
1017         isp->isp_atioq = base;
1018         im.error = 0;
1019         if (bus_dmamap_load(isp->isp_osinfo.atiodmat, isp->isp_osinfo.atiomap,
1020             base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
1021                 isp_prt(isp, ISP_LOGERR, "error loading ATIO DMA map %d", im.error);
1022                 goto bad;
1023         }
1024         isp_prt(isp, ISP_LOGDEBUG0, "ATIO area @ 0x%jx/0x%jx",
1025             (uintmax_t)im.maddr, (uintmax_t)len);
1026         isp->isp_atioq_dma = im.maddr;
1027 #endif
1028
1029         if (bus_dma_tag_create(ptag, 64, slim,
1030             BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
1031             2*QENTRY_LEN, 1, 2*QENTRY_LEN, 0, NULL, NULL,
1032             &isp->isp_osinfo.iocbdmat)) {
1033                 goto bad;
1034         }
1035         if (bus_dmamem_alloc(isp->isp_osinfo.iocbdmat,
1036             (void **)&base, BUS_DMA_COHERENT, &isp->isp_osinfo.iocbmap) != 0)
1037                 goto bad;
1038         isp->isp_iocb = base;
1039         im.error = 0;
1040         if (bus_dmamap_load(isp->isp_osinfo.iocbdmat, isp->isp_osinfo.iocbmap,
1041             base, 2*QENTRY_LEN, imc, &im, BUS_DMA_NOWAIT) || im.error)
1042                 goto bad;
1043         isp->isp_iocb_dma = im.maddr;
1044
1045         if (bus_dma_tag_create(ptag, 64, slim,
1046             BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
1047             ISP_FC_SCRLEN, 1, ISP_FC_SCRLEN, 0, NULL, NULL,
1048             &isp->isp_osinfo.scdmat))
1049                 goto bad;
1050         for (cmap = 0; cmap < isp->isp_nchan; cmap++) {
1051                 struct isp_fc *fc = ISP_FC_PC(isp, cmap);
1052                 if (bus_dmamem_alloc(isp->isp_osinfo.scdmat,
1053                     (void **)&base, BUS_DMA_COHERENT, &fc->scmap) != 0)
1054                         goto bad;
1055                 FCPARAM(isp, cmap)->isp_scratch = base;
1056                 im.error = 0;
1057                 if (bus_dmamap_load(isp->isp_osinfo.scdmat, fc->scmap,
1058                     base, ISP_FC_SCRLEN, imc, &im, BUS_DMA_NOWAIT) ||
1059                     im.error) {
1060                         bus_dmamem_free(isp->isp_osinfo.scdmat,
1061                             base, fc->scmap);
1062                         FCPARAM(isp, cmap)->isp_scratch = NULL;
1063                         goto bad;
1064                 }
1065                 FCPARAM(isp, cmap)->isp_scdma = im.maddr;
1066                 for (i = 0; i < INITIAL_NEXUS_COUNT; i++) {
1067                         struct isp_nexus *n = malloc(sizeof (struct isp_nexus), M_DEVBUF, M_NOWAIT | M_ZERO);
1068                         if (n == NULL) {
1069                                 while (fc->nexus_free_list) {
1070                                         n = fc->nexus_free_list;
1071                                         fc->nexus_free_list = n->next;
1072                                         free(n, M_DEVBUF);
1073                                 }
1074                                 goto bad;
1075                         }
1076                         n->next = fc->nexus_free_list;
1077                         fc->nexus_free_list = n;
1078                 }
1079         }
1080
1081         if (isp->isp_maxcmds == 0) {
1082                 ISP_LOCK(isp);
1083                 return (0);
1084         }
1085
1086 gotmaxcmds:
1087         if (bus_dma_tag_create(ptag, 1, slim,
1088             BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
1089             (ISP_NSEG64_MAX - 1) * PAGE_SIZE, ISP_NSEG64_MAX,
1090             (ISP_NSEG64_MAX - 1) * PAGE_SIZE, 0,
1091             busdma_lock_mutex, &isp->isp_lock, &isp->isp_osinfo.dmat))
1092                 goto bad;
1093         len = isp->isp_maxcmds * sizeof (struct isp_pcmd);
1094         isp->isp_osinfo.pcmd_pool = (struct isp_pcmd *)
1095             malloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
1096         for (i = 0; i < isp->isp_maxcmds; i++) {
1097                 struct isp_pcmd *pcmd = &isp->isp_osinfo.pcmd_pool[i];
1098                 error = bus_dmamap_create(isp->isp_osinfo.dmat, 0, &pcmd->dmap);
1099                 if (error) {
1100                         isp_prt(isp, ISP_LOGERR, "error %d creating per-cmd DMA maps", error);
1101                         while (--i >= 0) {
1102                                 bus_dmamap_destroy(isp->isp_osinfo.dmat,
1103                                     isp->isp_osinfo.pcmd_pool[i].dmap);
1104                         }
1105                         goto bad;
1106                 }
1107                 callout_init_mtx(&pcmd->wdog, &isp->isp_lock, 0);
1108                 if (i == isp->isp_maxcmds-1)
1109                         pcmd->next = NULL;
1110                 else
1111                         pcmd->next = &isp->isp_osinfo.pcmd_pool[i+1];
1112         }
1113         isp->isp_osinfo.pcmd_free = &isp->isp_osinfo.pcmd_pool[0];
1114
1115         len = sizeof(isp_hdl_t) * ISP_HANDLE_NUM(isp);
1116         isp->isp_xflist = (isp_hdl_t *) malloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
1117         for (len = 0; len < ISP_HANDLE_NUM(isp) - 1; len++)
1118                 isp->isp_xflist[len].cmd = &isp->isp_xflist[len+1];
1119         isp->isp_xffree = isp->isp_xflist;
1120
1121         ISP_LOCK(isp);
1122         return (0);
1123
1124 bad:
1125         isp_pci_mbxdmafree(isp);
1126         ISP_LOCK(isp);
1127         return (1);
1128 }
1129
1130 static void
1131 isp_pci_mbxdmafree(ispsoftc_t *isp)
1132 {
1133         int i;
1134
1135         if (isp->isp_xflist != NULL) {
1136                 free(isp->isp_xflist, M_DEVBUF);
1137                 isp->isp_xflist = NULL;
1138         }
1139         if (isp->isp_osinfo.pcmd_pool != NULL) {
1140                 for (i = 0; i < isp->isp_maxcmds; i++) {
1141                         bus_dmamap_destroy(isp->isp_osinfo.dmat,
1142                             isp->isp_osinfo.pcmd_pool[i].dmap);
1143                 }
1144                 free(isp->isp_osinfo.pcmd_pool, M_DEVBUF);
1145                 isp->isp_osinfo.pcmd_pool = NULL;
1146         }
1147         if (isp->isp_osinfo.dmat) {
1148                 bus_dma_tag_destroy(isp->isp_osinfo.dmat);
1149                 isp->isp_osinfo.dmat = NULL;
1150         }
1151         for (i = 0; i < isp->isp_nchan; i++) {
1152                 struct isp_fc *fc = ISP_FC_PC(isp, i);
1153                 if (FCPARAM(isp, i)->isp_scdma != 0) {
1154                         bus_dmamap_unload(isp->isp_osinfo.scdmat,
1155                             fc->scmap);
1156                         FCPARAM(isp, i)->isp_scdma = 0;
1157                 }
1158                 if (FCPARAM(isp, i)->isp_scratch != NULL) {
1159                         bus_dmamem_free(isp->isp_osinfo.scdmat,
1160                             FCPARAM(isp, i)->isp_scratch, fc->scmap);
1161                         FCPARAM(isp, i)->isp_scratch = NULL;
1162                 }
1163                 while (fc->nexus_free_list) {
1164                         struct isp_nexus *n = fc->nexus_free_list;
1165                         fc->nexus_free_list = n->next;
1166                         free(n, M_DEVBUF);
1167                 }
1168         }
1169         if (isp->isp_osinfo.scdmat) {
1170                 bus_dma_tag_destroy(isp->isp_osinfo.scdmat);
1171                 isp->isp_osinfo.scdmat = NULL;
1172         }
1173         if (isp->isp_iocb_dma != 0) {
1174                 bus_dmamap_unload(isp->isp_osinfo.iocbdmat,
1175                     isp->isp_osinfo.iocbmap);
1176                 isp->isp_iocb_dma = 0;
1177         }
1178         if (isp->isp_iocb != NULL) {
1179                 bus_dmamem_free(isp->isp_osinfo.iocbdmat,
1180                     isp->isp_iocb, isp->isp_osinfo.iocbmap);
1181                 bus_dma_tag_destroy(isp->isp_osinfo.iocbdmat);
1182         }
1183 #ifdef  ISP_TARGET_MODE
1184         if (isp->isp_atioq_dma != 0) {
1185                 bus_dmamap_unload(isp->isp_osinfo.atiodmat,
1186                     isp->isp_osinfo.atiomap);
1187                 isp->isp_atioq_dma = 0;
1188         }
1189         if (isp->isp_atioq != NULL) {
1190                 bus_dmamem_free(isp->isp_osinfo.atiodmat, isp->isp_atioq,
1191                     isp->isp_osinfo.atiomap);
1192                 bus_dma_tag_destroy(isp->isp_osinfo.atiodmat);
1193                 isp->isp_atioq = NULL;
1194         }
1195 #endif
1196         if (isp->isp_result_dma != 0) {
1197                 bus_dmamap_unload(isp->isp_osinfo.respdmat,
1198                     isp->isp_osinfo.respmap);
1199                 isp->isp_result_dma = 0;
1200         }
1201         if (isp->isp_result != NULL) {
1202                 bus_dmamem_free(isp->isp_osinfo.respdmat, isp->isp_result,
1203                     isp->isp_osinfo.respmap);
1204                 bus_dma_tag_destroy(isp->isp_osinfo.respdmat);
1205                 isp->isp_result = NULL;
1206         }
1207 #ifdef  ISP_TARGET_MODE
1208         if (isp->isp_osinfo.ecmd_dma != 0) {
1209                 bus_dmamap_unload(isp->isp_osinfo.ecmd_dmat,
1210                     isp->isp_osinfo.ecmd_map);
1211                 isp->isp_osinfo.ecmd_dma = 0;
1212         }
1213         if (isp->isp_osinfo.ecmd_base != NULL) {
1214                 bus_dmamem_free(isp->isp_osinfo.ecmd_dmat, isp->isp_osinfo.ecmd_base,
1215                     isp->isp_osinfo.ecmd_map);
1216                 bus_dma_tag_destroy(isp->isp_osinfo.ecmd_dmat);
1217                 isp->isp_osinfo.ecmd_base = NULL;
1218         }
1219 #endif
1220         if (isp->isp_rquest_dma != 0) {
1221                 bus_dmamap_unload(isp->isp_osinfo.reqdmat,
1222                     isp->isp_osinfo.reqmap);
1223                 isp->isp_rquest_dma = 0;
1224         }
1225         if (isp->isp_rquest != NULL) {
1226                 bus_dmamem_free(isp->isp_osinfo.reqdmat, isp->isp_rquest,
1227                     isp->isp_osinfo.reqmap);
1228                 bus_dma_tag_destroy(isp->isp_osinfo.reqdmat);
1229                 isp->isp_rquest = NULL;
1230         }
1231 }
1232
1233 static int
1234 isp_pci_irqsetup(ispsoftc_t *isp)
1235 {
1236         device_t dev = isp->isp_osinfo.dev;
1237         struct isp_pcisoftc *pcs = device_get_softc(dev);
1238         driver_intr_t *f;
1239         int i, max_irq;
1240
1241         /* Allocate IRQs only once. */
1242         if (isp->isp_nirq > 0)
1243                 return (0);
1244
1245         ISP_UNLOCK(isp);
1246         if (ISP_CAP_MSIX(isp)) {
1247                 max_irq = IS_26XX(isp) ? 3 : (IS_25XX(isp) ? 2 : 0);
1248                 resource_int_value(device_get_name(dev),
1249                     device_get_unit(dev), "msix", &max_irq);
1250                 max_irq = imin(ISP_MAX_IRQS, max_irq);
1251                 pcs->msicount = imin(pci_msix_count(dev), max_irq);
1252                 if (pcs->msicount > 0 &&
1253                     pci_alloc_msix(dev, &pcs->msicount) != 0)
1254                         pcs->msicount = 0;
1255         }
1256         if (pcs->msicount == 0) {
1257                 max_irq = 1;
1258                 resource_int_value(device_get_name(dev),
1259                     device_get_unit(dev), "msi", &max_irq);
1260                 max_irq = imin(1, max_irq);
1261                 pcs->msicount = imin(pci_msi_count(dev), max_irq);
1262                 if (pcs->msicount > 0 &&
1263                     pci_alloc_msi(dev, &pcs->msicount) != 0)
1264                         pcs->msicount = 0;
1265         }
1266         for (i = 0; i < MAX(1, pcs->msicount); i++) {
1267                 pcs->irq[i].iqd = i + (pcs->msicount > 0);
1268                 pcs->irq[i].irq = bus_alloc_resource_any(dev, SYS_RES_IRQ,
1269                     &pcs->irq[i].iqd, RF_ACTIVE | RF_SHAREABLE);
1270                 if (pcs->irq[i].irq == NULL) {
1271                         device_printf(dev, "could not allocate interrupt\n");
1272                         break;
1273                 }
1274                 if (i == 0)
1275                         f = isp_platform_intr;
1276                 else if (i == 1)
1277                         f = isp_platform_intr_resp;
1278                 else
1279                         f = isp_platform_intr_atio;
1280                 if (bus_setup_intr(dev, pcs->irq[i].irq, ISP_IFLAGS, NULL,
1281                     f, isp, &pcs->irq[i].ih)) {
1282                         device_printf(dev, "could not setup interrupt\n");
1283                         (void) bus_release_resource(dev, SYS_RES_IRQ,
1284                             pcs->irq[i].iqd, pcs->irq[i].irq);
1285                         break;
1286                 }
1287                 if (pcs->msicount > 1) {
1288                         bus_describe_intr(dev, pcs->irq[i].irq, pcs->irq[i].ih,
1289                             "%d", i);
1290                 }
1291                 isp->isp_nirq = i + 1;
1292         }
1293         ISP_LOCK(isp);
1294
1295         return (isp->isp_nirq == 0);
1296 }