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