1 /*- 2 * Copyright (c) 2017 Broadcom. All rights reserved. 3 * The term "Broadcom" refers to Broadcom Limited and/or its subsidiaries. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 11 * 2. Redistributions in binary form must reproduce the above copyright notice, 12 * this list of conditions and the following disclaimer in the documentation 13 * and/or other materials provided with the distribution. 14 * 15 * 3. Neither the name of the copyright holder nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE 23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 * 31 * $FreeBSD$ 32 */ 33 34 #define OCS_COPYRIGHT "Copyright (C) 2017 Broadcom. All rights reserved." 35 36 /** 37 * @file 38 * Implementation of required FreeBSD PCI interface functions 39 */ 40 41 #include "ocs.h" 42 #include "version.h" 43 #include <sys/sysctl.h> 44 #include <sys/malloc.h> 45 46 static MALLOC_DEFINE(M_OCS, "OCS", "OneCore Storage data"); 47 48 #include <dev/pci/pcireg.h> 49 #include <dev/pci/pcivar.h> 50 51 #include <machine/bus.h> 52 53 /** 54 * Tunable parameters for transport 55 */ 56 int logmask = 0; 57 int ctrlmask = 2; 58 int logdest = 1; 59 int loglevel = LOG_INFO; 60 int ramlog_size = 1*1024*1024; 61 int ddump_saved_size = 0; 62 static const char *queue_topology = "eq cq rq cq mq $nulp($nwq(cq wq:ulp=$rpt1)) cq wq:len=256:class=1"; 63 64 static void ocs_release_bus(struct ocs_softc *); 65 static int32_t ocs_intr_alloc(struct ocs_softc *); 66 static int32_t ocs_intr_setup(struct ocs_softc *); 67 static int32_t ocs_intr_teardown(struct ocs_softc *); 68 static int ocs_pci_intx_filter(void *); 69 static void ocs_pci_intr(void *); 70 static int32_t ocs_init_dma_tag(struct ocs_softc *ocs); 71 72 static int32_t ocs_setup_fcports(ocs_t *ocs); 73 74 ocs_t *ocs_devices[MAX_OCS_DEVICES]; 75 76 /** 77 * @brief Check support for the given device 78 * 79 * Determine support for a given device by examining the PCI vendor and 80 * device IDs 81 * 82 * @param dev device abstraction 83 * 84 * @return 0 if device is supported, ENXIO otherwise 85 */ 86 static int 87 ocs_pci_probe(device_t dev) 88 { 89 char *desc = NULL; 90 91 if (pci_get_vendor(dev) != PCI_VENDOR_EMULEX) { 92 return ENXIO; 93 } 94 95 switch (pci_get_device(dev)) { 96 case PCI_PRODUCT_EMULEX_OCE16001: 97 desc = "Emulex LightPulse FC Adapter"; 98 break; 99 case PCI_PRODUCT_EMULEX_LPE31004: 100 desc = "Emulex LightPulse FC Adapter"; 101 break; 102 case PCI_PRODUCT_EMULEX_OCE50102: 103 desc = "Emulex LightPulse 10GbE FCoE/NIC Adapter"; 104 break; 105 default: 106 return ENXIO; 107 } 108 109 device_set_desc(dev, desc); 110 111 return BUS_PROBE_DEFAULT; 112 } 113 114 static int 115 ocs_map_bars(device_t dev, struct ocs_softc *ocs) 116 { 117 118 /* 119 * Map PCI BAR0 register into the CPU's space. 120 */ 121 122 ocs->reg[0].rid = PCIR_BAR(PCI_64BIT_BAR0); 123 ocs->reg[0].res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, 124 &ocs->reg[0].rid, RF_ACTIVE); 125 126 if (ocs->reg[0].res == NULL) { 127 device_printf(dev, "bus_alloc_resource failed rid=%#x\n", 128 ocs->reg[0].rid); 129 return ENXIO; 130 } 131 132 ocs->reg[0].btag = rman_get_bustag(ocs->reg[0].res); 133 ocs->reg[0].bhandle = rman_get_bushandle(ocs->reg[0].res); 134 return 0; 135 } 136 137 138 static int 139 ocs_setup_params(struct ocs_softc *ocs) 140 { 141 int32_t i = 0; 142 const char *hw_war_version; 143 /* Setup tunable parameters */ 144 ocs->ctrlmask = ctrlmask; 145 ocs->speed = 0; 146 ocs->topology = 0; 147 ocs->ethernet_license = 0; 148 ocs->num_scsi_ios = 8192; 149 ocs->enable_hlm = 0; 150 ocs->hlm_group_size = 8; 151 ocs->logmask = logmask; 152 153 ocs->config_tgt = FALSE; 154 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 155 "target", &i)) { 156 if (1 == i) { 157 ocs->config_tgt = TRUE; 158 device_printf(ocs->dev, "Enabling target\n"); 159 } 160 } 161 162 ocs->config_ini = TRUE; 163 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 164 "initiator", &i)) { 165 if (0 == i) { 166 ocs->config_ini = FALSE; 167 device_printf(ocs->dev, "Disabling initiator\n"); 168 } 169 } 170 ocs->enable_ini = ocs->config_ini; 171 172 if (!ocs->config_ini && !ocs->config_tgt) { 173 device_printf(ocs->dev, "Unsupported, both initiator and target mode disabled.\n"); 174 return 1; 175 176 } 177 178 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 179 "logmask", &logmask)) { 180 device_printf(ocs->dev, "logmask = %#x\n", logmask); 181 } 182 183 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 184 "logdest", &logdest)) { 185 device_printf(ocs->dev, "logdest = %#x\n", logdest); 186 } 187 188 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 189 "loglevel", &loglevel)) { 190 device_printf(ocs->dev, "loglevel = %#x\n", loglevel); 191 } 192 193 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 194 "ramlog_size", &ramlog_size)) { 195 device_printf(ocs->dev, "ramlog_size = %#x\n", ramlog_size); 196 } 197 198 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 199 "ddump_saved_size", &ddump_saved_size)) { 200 device_printf(ocs->dev, "ddump_saved_size= %#x\n", ddump_saved_size); 201 } 202 203 /* If enabled, initailize a RAM logging buffer */ 204 if (logdest & 2) { 205 ocs->ramlog = ocs_ramlog_init(ocs, ramlog_size/OCS_RAMLOG_DEFAULT_BUFFERS, 206 OCS_RAMLOG_DEFAULT_BUFFERS); 207 /* If NULL was returned, then we'll simply skip using the ramlog but */ 208 /* set logdest to 1 to ensure that we at least get default logging. */ 209 if (ocs->ramlog == NULL) { 210 logdest = 1; 211 } 212 } 213 214 /* initialize a saved ddump */ 215 if (ddump_saved_size) { 216 if (ocs_textbuf_alloc(ocs, &ocs->ddump_saved, ddump_saved_size)) { 217 ocs_log_err(ocs, "failed to allocate memory for saved ddump\n"); 218 } 219 } 220 221 if (0 == resource_string_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 222 "hw_war_version", &hw_war_version)) { 223 device_printf(ocs->dev, "hw_war_version = %s\n", hw_war_version); 224 ocs->hw_war_version = strdup(hw_war_version, M_OCS); 225 } 226 227 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 228 "explicit_buffer_list", &i)) { 229 ocs->explicit_buffer_list = i; 230 } 231 232 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 233 "ethernet_license", &i)) { 234 ocs->ethernet_license = i; 235 } 236 237 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 238 "speed", &i)) { 239 device_printf(ocs->dev, "speed = %d Mbps\n", i); 240 ocs->speed = i; 241 } 242 ocs->desc = device_get_desc(ocs->dev); 243 244 ocs_device_lock_init(ocs); 245 ocs->driver_version = STR_BE_MAJOR "." STR_BE_MINOR "." STR_BE_BUILD "." STR_BE_BRANCH; 246 ocs->model = ocs_pci_model(ocs->pci_vendor, ocs->pci_device); 247 248 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 249 "enable_hlm", &i)) { 250 device_printf(ocs->dev, "enable_hlm = %d\n", i); 251 ocs->enable_hlm = i; 252 if (ocs->enable_hlm) { 253 ocs->hlm_group_size = 8; 254 255 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 256 "hlm_group_size", &i)) { 257 ocs->hlm_group_size = i; 258 } 259 device_printf(ocs->dev, "hlm_group_size = %d\n", i); 260 } 261 } 262 263 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 264 "num_scsi_ios", &i)) { 265 ocs->num_scsi_ios = i; 266 device_printf(ocs->dev, "num_scsi_ios = %d\n", ocs->num_scsi_ios); 267 } else { 268 ocs->num_scsi_ios = 8192; 269 } 270 271 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 272 "topology", &i)) { 273 ocs->topology = i; 274 device_printf(ocs->dev, "Setting topology=%#x\n", i); 275 } 276 277 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 278 "num_vports", &i)) { 279 if (i >= 0 && i <= 254) { 280 device_printf(ocs->dev, "num_vports = %d\n", i); 281 ocs->num_vports = i; 282 } else { 283 device_printf(ocs->dev, "num_vports: %d not supported \n", i); 284 } 285 } 286 287 288 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 289 "external_loopback", &i)) { 290 device_printf(ocs->dev, "external_loopback = %d\n", i); 291 ocs->external_loopback = i; 292 } 293 294 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 295 "tgt_rscn_delay", &i)) { 296 device_printf(ocs->dev, "tgt_rscn_delay = %d\n", i); 297 ocs->tgt_rscn_delay_msec = i * 1000; 298 } 299 300 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 301 "tgt_rscn_period", &i)) { 302 device_printf(ocs->dev, "tgt_rscn_period = %d\n", i); 303 ocs->tgt_rscn_period_msec = i * 1000; 304 } 305 306 if (0 == resource_int_value(device_get_name(ocs->dev), device_get_unit(ocs->dev), 307 "target_io_timer", &i)) { 308 device_printf(ocs->dev, "target_io_timer = %d\n", i); 309 ocs->target_io_timer_sec = i; 310 } 311 312 hw_global.queue_topology_string = queue_topology; 313 ocs->rq_selection_policy = 0; 314 ocs->rr_quanta = 1; 315 ocs->filter_def = "0,0,0,0"; 316 317 return 0; 318 } 319 320 static int32_t 321 ocs_setup_fcports(ocs_t *ocs) 322 { 323 uint32_t i = 0, role = 0; 324 uint64_t sli_wwpn, sli_wwnn; 325 size_t size; 326 ocs_xport_t *xport = ocs->xport; 327 ocs_vport_spec_t *vport; 328 ocs_fcport *fcp = NULL; 329 330 size = sizeof(ocs_fcport) * (ocs->num_vports + 1); 331 332 ocs->fcports = ocs_malloc(ocs, size, M_ZERO|M_NOWAIT); 333 if (ocs->fcports == NULL) { 334 device_printf(ocs->dev, "Can't allocate fcport \n"); 335 return 1; 336 } 337 338 role = (ocs->enable_ini)? KNOB_ROLE_INITIATOR: 0 | 339 (ocs->enable_tgt)? KNOB_ROLE_TARGET: 0; 340 341 fcp = FCPORT(ocs, i); 342 fcp->role = role; 343 i++; 344 345 ocs_list_foreach(&xport->vport_list, vport) { 346 fcp = FCPORT(ocs, i); 347 vport->tgt_data = fcp; 348 fcp->vport = vport; 349 fcp->role = role; 350 351 if (ocs_hw_get_def_wwn(ocs, i, &sli_wwpn, &sli_wwnn)) { 352 ocs_log_err(ocs, "Get default wwn failed \n"); 353 i++; 354 continue; 355 } 356 357 vport->wwpn = ocs_be64toh(sli_wwpn); 358 vport->wwnn = ocs_be64toh(sli_wwnn); 359 i++; 360 ocs_log_debug(ocs, "VPort wwpn: %lx wwnn: %lx \n", vport->wwpn, vport->wwnn); 361 } 362 363 return 0; 364 } 365 366 int32_t 367 ocs_device_attach(ocs_t *ocs) 368 { 369 int32_t i; 370 ocs_io_t *io = NULL; 371 372 if (ocs->attached) { 373 ocs_log_warn(ocs, "%s: Device is already attached\n", __func__); 374 return -1; 375 } 376 377 /* Allocate transport object and bring online */ 378 ocs->xport = ocs_xport_alloc(ocs); 379 if (ocs->xport == NULL) { 380 device_printf(ocs->dev, "failed to allocate transport object\n"); 381 return ENOMEM; 382 } else if (ocs_xport_attach(ocs->xport) != 0) { 383 device_printf(ocs->dev, "%s: failed to attach transport object\n", __func__); 384 goto fail_xport_attach; 385 } else if (ocs_xport_initialize(ocs->xport) != 0) { 386 device_printf(ocs->dev, "%s: failed to initialize transport object\n", __func__); 387 goto fail_xport_init; 388 } 389 390 if (ocs_init_dma_tag(ocs)) { 391 goto fail_intr_setup; 392 } 393 394 for (i = 0; (io = ocs_io_get_instance(ocs, i)); i++) { 395 if (bus_dmamap_create(ocs->buf_dmat, 0, &io->tgt_io.dmap)) { 396 device_printf(ocs->dev, "%s: bad dma map create\n", __func__); 397 } 398 399 io->tgt_io.state = OCS_CAM_IO_FREE; 400 } 401 402 if (ocs_setup_fcports(ocs)) { 403 device_printf(ocs->dev, "FCports creation failed\n"); 404 goto fail_intr_setup; 405 } 406 407 if(ocs_cam_attach(ocs)) { 408 device_printf(ocs->dev, "cam attach failed \n"); 409 goto fail_intr_setup; 410 } 411 412 if (ocs_intr_setup(ocs)) { 413 device_printf(ocs->dev, "Interrupt setup failed\n"); 414 goto fail_intr_setup; 415 } 416 417 if (ocs->enable_ini || ocs->enable_tgt) { 418 if (ocs_xport_control(ocs->xport, OCS_XPORT_PORT_ONLINE)) { 419 device_printf(ocs->dev, "Can't init port\n"); 420 goto fail_xport_online; 421 } 422 } 423 424 ocs->attached = true; 425 426 return 0; 427 428 fail_xport_online: 429 if (ocs_xport_control(ocs->xport, OCS_XPORT_SHUTDOWN)) { 430 device_printf(ocs->dev, "Transport Shutdown timed out\n"); 431 } 432 ocs_intr_teardown(ocs); 433 fail_intr_setup: 434 fail_xport_init: 435 ocs_xport_detach(ocs->xport); 436 if (ocs->config_tgt) 437 ocs_scsi_tgt_del_device(ocs); 438 439 ocs_xport_free(ocs->xport); 440 ocs->xport = NULL; 441 fail_xport_attach: 442 if (ocs->xport) 443 ocs_free(ocs, ocs->xport, sizeof(*(ocs->xport))); 444 ocs->xport = NULL; 445 return ENXIO; 446 } 447 448 /** 449 * @brief Connect the driver to the given device 450 * 451 * If the probe routine is successful, the OS will give the driver 452 * the opportunity to connect itself to the device. This routine 453 * maps PCI resources (memory BARs and interrupts) and initialize a 454 * hardware object. 455 * 456 * @param dev device abstraction 457 * 458 * @return 0 if the driver attaches to the device, ENXIO otherwise 459 */ 460 461 static int 462 ocs_pci_attach(device_t dev) 463 { 464 struct ocs_softc *ocs; 465 int instance; 466 467 instance = device_get_unit(dev); 468 469 ocs = (struct ocs_softc *)device_get_softc(dev); 470 if (NULL == ocs) { 471 device_printf(dev, "cannot allocate softc\n"); 472 return ENOMEM; 473 } 474 memset(ocs, 0, sizeof(struct ocs_softc)); 475 476 if (instance < ARRAY_SIZE(ocs_devices)) { 477 ocs_devices[instance] = ocs; 478 } else { 479 device_printf(dev, "got unexpected ocs instance number %d\n", instance); 480 } 481 482 ocs->instance_index = instance; 483 484 ocs->dev = dev; 485 486 pci_enable_io(dev, SYS_RES_MEMORY); 487 pci_enable_busmaster(dev); 488 489 ocs->pci_vendor = pci_get_vendor(dev); 490 ocs->pci_device = pci_get_device(dev); 491 snprintf(ocs->businfo, sizeof(ocs->businfo), "%02X:%02X:%02X", 492 pci_get_bus(dev), pci_get_slot(dev), pci_get_function(dev)); 493 494 /* Map all memory BARs */ 495 if (ocs_map_bars(dev, ocs)) { 496 device_printf(dev, "Failed to map pci bars\n"); 497 goto release_bus; 498 } 499 500 /* create a root DMA tag for the device */ 501 if (bus_dma_tag_create(bus_get_dma_tag(dev), 502 1, /* byte alignment */ 503 0, /* no boundary restrictions */ 504 BUS_SPACE_MAXADDR, /* no minimum low address */ 505 BUS_SPACE_MAXADDR, /* no maximum high address */ 506 NULL, /* no filter function */ 507 NULL, /* or arguments */ 508 BUS_SPACE_MAXSIZE, /* max size covered by tag */ 509 BUS_SPACE_UNRESTRICTED, /* no segment count restrictions */ 510 BUS_SPACE_MAXSIZE, /* no segment length restrictions */ 511 0, /* flags */ 512 NULL, /* no lock manipulation function */ 513 NULL, /* or arguments */ 514 &ocs->dmat)) { 515 device_printf(dev, "parent DMA tag allocation failed\n"); 516 goto release_bus; 517 } 518 519 if (ocs_intr_alloc(ocs)) { 520 device_printf(dev, "Interrupt allocation failed\n"); 521 goto release_bus; 522 } 523 524 if (PCIC_SERIALBUS == pci_get_class(dev) && 525 PCIS_SERIALBUS_FC == pci_get_subclass(dev)) 526 ocs->ocs_xport = OCS_XPORT_FC; 527 else { 528 device_printf(dev, "unsupported class (%#x : %#x)\n", 529 pci_get_class(dev), 530 pci_get_class(dev)); 531 goto release_bus; 532 } 533 534 /* Setup tunable parameters */ 535 if (ocs_setup_params(ocs)) { 536 device_printf(ocs->dev, "failed to setup params\n"); 537 goto release_bus; 538 } 539 540 if (ocs_device_attach(ocs)) { 541 device_printf(ocs->dev, "failed to attach device\n"); 542 goto release_params; 543 } 544 545 ocs->fc_type = FC_TYPE_FCP; 546 547 ocs_debug_attach(ocs); 548 549 return 0; 550 551 release_params: 552 ocs_ramlog_free(ocs, ocs->ramlog); 553 ocs_device_lock_free(ocs); 554 free(ocs->hw_war_version, M_OCS); 555 release_bus: 556 ocs_release_bus(ocs); 557 return ENXIO; 558 } 559 560 /** 561 * @brief free resources when pci device detach 562 * 563 * @param ocs pointer to ocs structure 564 * 565 * @return 0 for success, a negative error code value for failure. 566 */ 567 568 int32_t 569 ocs_device_detach(ocs_t *ocs) 570 { 571 int32_t rc = 0, i; 572 ocs_io_t *io = NULL; 573 574 if (ocs != NULL) { 575 if (!ocs->attached) { 576 ocs_log_warn(ocs, "%s: Device is not attached\n", __func__); 577 return -1; 578 } 579 580 ocs->attached = FALSE; 581 582 rc = ocs_xport_control(ocs->xport, OCS_XPORT_SHUTDOWN); 583 if (rc) { 584 ocs_log_err(ocs, "%s: Transport Shutdown timed out\n", __func__); 585 } 586 587 ocs_intr_teardown(ocs); 588 589 if (ocs_xport_detach(ocs->xport) != 0) { 590 ocs_log_err(ocs, "%s: Transport detach failed\n", __func__); 591 } 592 593 ocs_cam_detach(ocs); 594 ocs_free(ocs, ocs->fcports, sizeof(*(ocs->fcports))); 595 596 for (i = 0; (io = ocs_io_get_instance(ocs, i)); i++) { 597 if (bus_dmamap_destroy(ocs->buf_dmat, io->tgt_io.dmap)) { 598 device_printf(ocs->dev, "%s: bad dma map destroy\n", __func__); 599 } 600 } 601 bus_dma_tag_destroy(ocs->dmat); 602 ocs_xport_free(ocs->xport); 603 ocs->xport = NULL; 604 605 } 606 607 return 0; 608 } 609 610 611 /** 612 * @brief Detach the driver from the given device 613 * 614 * If the driver is a loadable module, this routine gets called at unload 615 * time. This routine will stop the device and free any allocated resources. 616 * 617 * @param dev device abstraction 618 * 619 * @return 0 if the driver detaches from the device, ENXIO otherwise 620 */ 621 static int 622 ocs_pci_detach(device_t dev) 623 { 624 struct ocs_softc *ocs; 625 626 ocs = (struct ocs_softc *)device_get_softc(dev); 627 if (!ocs) { 628 device_printf(dev, "no driver context?!?\n"); 629 return -1; 630 } 631 632 if (ocs->config_tgt && ocs->enable_tgt) { 633 device_printf(dev, "can't detach with target mode enabled\n"); 634 return EBUSY; 635 } 636 637 ocs_device_detach(ocs); 638 639 /* 640 * Workaround for OCS SCSI Transport quirk. 641 * 642 * CTL requires that target mode is disabled prior to unloading the 643 * driver (ie ocs->enable_tgt = FALSE), but once the target is disabled, 644 * the transport will not call ocs_scsi_tgt_del_device() which deallocates 645 * CAM resources. The workaround is to explicitly make the call here. 646 */ 647 if (ocs->config_tgt) 648 ocs_scsi_tgt_del_device(ocs); 649 650 /* free strdup created buffer.*/ 651 free(ocs->hw_war_version, M_OCS); 652 653 ocs_device_lock_free(ocs); 654 655 ocs_debug_detach(ocs); 656 657 ocs_ramlog_free(ocs, ocs->ramlog); 658 659 ocs_release_bus(ocs); 660 661 return 0; 662 } 663 664 /** 665 * @brief Notify driver of system shutdown 666 * 667 * @param dev device abstraction 668 * 669 * @return 0 if the driver attaches to the device, ENXIO otherwise 670 */ 671 static int 672 ocs_pci_shutdown(device_t dev) 673 { 674 device_printf(dev, "%s\n", __func__); 675 return 0; 676 } 677 678 /** 679 * @brief Release bus resources allocated within the soft context 680 * 681 * @param ocs Pointer to the driver's context 682 * 683 * @return none 684 */ 685 static void 686 ocs_release_bus(struct ocs_softc *ocs) 687 { 688 689 if (NULL != ocs) { 690 uint32_t i; 691 692 ocs_intr_teardown(ocs); 693 694 if (ocs->irq) { 695 bus_release_resource(ocs->dev, SYS_RES_IRQ, 696 rman_get_rid(ocs->irq), ocs->irq); 697 698 if (ocs->n_vec) { 699 pci_release_msi(ocs->dev); 700 ocs->n_vec = 0; 701 } 702 703 ocs->irq = NULL; 704 } 705 706 bus_dma_tag_destroy(ocs->dmat); 707 708 for (i = 0; i < PCI_MAX_BAR; i++) { 709 if (ocs->reg[i].res) { 710 bus_release_resource(ocs->dev, SYS_RES_MEMORY, 711 ocs->reg[i].rid, 712 ocs->reg[i].res); 713 } 714 } 715 } 716 } 717 718 /** 719 * @brief Allocate and initialize interrupts 720 * 721 * @param ocs Pointer to the driver's context 722 * 723 * @return none 724 */ 725 static int32_t 726 ocs_intr_alloc(struct ocs_softc *ocs) 727 { 728 729 ocs->n_vec = 1; 730 if (pci_alloc_msix(ocs->dev, &ocs->n_vec)) { 731 device_printf(ocs->dev, "MSI-X allocation failed\n"); 732 if (pci_alloc_msi(ocs->dev, &ocs->n_vec)) { 733 device_printf(ocs->dev, "MSI allocation failed \n"); 734 ocs->irqid = 0; 735 ocs->n_vec = 0; 736 } else 737 ocs->irqid = 1; 738 } else { 739 ocs->irqid = 1; 740 } 741 742 ocs->irq = bus_alloc_resource_any(ocs->dev, SYS_RES_IRQ, &ocs->irqid, 743 RF_ACTIVE | RF_SHAREABLE); 744 if (NULL == ocs->irq) { 745 device_printf(ocs->dev, "could not allocate interrupt\n"); 746 return -1; 747 } 748 749 ocs->intr_ctx.vec = 0; 750 ocs->intr_ctx.softc = ocs; 751 snprintf(ocs->intr_ctx.name, sizeof(ocs->intr_ctx.name), 752 "%s_intr_%d", 753 device_get_nameunit(ocs->dev), 754 ocs->intr_ctx.vec); 755 756 return 0; 757 } 758 759 /** 760 * @brief Create and attach an interrupt handler 761 * 762 * @param ocs Pointer to the driver's context 763 * 764 * @return 0 on success, non-zero otherwise 765 */ 766 static int32_t 767 ocs_intr_setup(struct ocs_softc *ocs) 768 { 769 driver_filter_t *filter = NULL; 770 771 if (0 == ocs->n_vec) { 772 filter = ocs_pci_intx_filter; 773 } 774 775 if (bus_setup_intr(ocs->dev, ocs->irq, INTR_MPSAFE | INTR_TYPE_CAM, 776 filter, ocs_pci_intr, &ocs->intr_ctx, 777 &ocs->tag)) { 778 device_printf(ocs->dev, "could not initialize interrupt\n"); 779 return -1; 780 } 781 782 return 0; 783 } 784 785 786 /** 787 * @brief Detach an interrupt handler 788 * 789 * @param ocs Pointer to the driver's context 790 * 791 * @return 0 on success, non-zero otherwise 792 */ 793 static int32_t 794 ocs_intr_teardown(struct ocs_softc *ocs) 795 { 796 797 if (!ocs) { 798 printf("%s: bad driver context?!?\n", __func__); 799 return -1; 800 } 801 802 if (ocs->tag) { 803 bus_teardown_intr(ocs->dev, ocs->irq, ocs->tag); 804 ocs->tag = NULL; 805 } 806 807 return 0; 808 } 809 810 /** 811 * @brief PCI interrupt handler 812 * 813 * @param arg pointer to the driver's software context 814 * 815 * @return FILTER_HANDLED if interrupt is processed, FILTER_STRAY otherwise 816 */ 817 static int 818 ocs_pci_intx_filter(void *arg) 819 { 820 ocs_intr_ctx_t *intr = arg; 821 struct ocs_softc *ocs = NULL; 822 uint16_t val = 0; 823 824 if (NULL == intr) { 825 return FILTER_STRAY; 826 } 827 828 ocs = intr->softc; 829 #ifndef PCIM_STATUS_INTR 830 #define PCIM_STATUS_INTR 0x0008 831 #endif 832 val = pci_read_config(ocs->dev, PCIR_STATUS, 2); 833 if (0xffff == val) { 834 device_printf(ocs->dev, "%s: pci_read_config(PCIR_STATUS) failed\n", __func__); 835 return FILTER_STRAY; 836 } 837 if (0 == (val & PCIM_STATUS_INTR)) { 838 return FILTER_STRAY; 839 } 840 841 val = pci_read_config(ocs->dev, PCIR_COMMAND, 2); 842 val |= PCIM_CMD_INTxDIS; 843 pci_write_config(ocs->dev, PCIR_COMMAND, val, 2); 844 845 return FILTER_SCHEDULE_THREAD; 846 } 847 848 /** 849 * @brief interrupt handler 850 * 851 * @param context pointer to the interrupt context 852 */ 853 static void 854 ocs_pci_intr(void *context) 855 { 856 ocs_intr_ctx_t *intr = context; 857 struct ocs_softc *ocs = intr->softc; 858 859 mtx_lock(&ocs->sim_lock); 860 ocs_hw_process(&ocs->hw, intr->vec, OCS_OS_MAX_ISR_TIME_MSEC); 861 mtx_unlock(&ocs->sim_lock); 862 } 863 864 /** 865 * @brief Initialize DMA tag 866 * 867 * @param ocs the driver instance's software context 868 * 869 * @return 0 on success, non-zero otherwise 870 */ 871 static int32_t 872 ocs_init_dma_tag(struct ocs_softc *ocs) 873 { 874 uint32_t max_sgl = 0; 875 uint32_t max_sge = 0; 876 877 /* 878 * IOs can't use the parent DMA tag and must create their 879 * own, based primarily on a restricted number of DMA segments. 880 * This is more of a BSD requirement than a SLI Port requirement 881 */ 882 ocs_hw_get(&ocs->hw, OCS_HW_N_SGL, &max_sgl); 883 ocs_hw_get(&ocs->hw, OCS_HW_MAX_SGE, &max_sge); 884 885 if (bus_dma_tag_create(ocs->dmat, 886 1, /* byte alignment */ 887 0, /* no boundary restrictions */ 888 BUS_SPACE_MAXADDR, /* no minimum low address */ 889 BUS_SPACE_MAXADDR, /* no maximum high address */ 890 NULL, /* no filter function */ 891 NULL, /* or arguments */ 892 BUS_SPACE_MAXSIZE, /* max size covered by tag */ 893 max_sgl, /* segment count restrictions */ 894 max_sge, /* segment length restrictions */ 895 0, /* flags */ 896 NULL, /* no lock manipulation function */ 897 NULL, /* or arguments */ 898 &ocs->buf_dmat)) { 899 device_printf(ocs->dev, "%s: bad bus_dma_tag_create(buf_dmat)\n", __func__); 900 return -1; 901 } 902 return 0; 903 } 904 905 int32_t 906 ocs_get_property(const char *prop_name, char *buffer, uint32_t buffer_len) 907 { 908 return -1; 909 } 910 911 /** 912 * @brief return pointer to ocs structure given instance index 913 * 914 * A pointer to an ocs structure is returned given an instance index. 915 * 916 * @param index index to ocs_devices array 917 * 918 * @return ocs pointer 919 */ 920 921 ocs_t *ocs_get_instance(uint32_t index) 922 { 923 if (index < ARRAY_SIZE(ocs_devices)) { 924 return ocs_devices[index]; 925 } 926 return NULL; 927 } 928 929 /** 930 * @brief Return instance index of an opaque ocs structure 931 * 932 * Returns the ocs instance index 933 * 934 * @param os pointer to ocs instance 935 * 936 * @return pointer to ocs instance index 937 */ 938 uint32_t 939 ocs_instance(void *os) 940 { 941 ocs_t *ocs = os; 942 return ocs->instance_index; 943 } 944 945 static device_method_t ocs_methods[] = { 946 DEVMETHOD(device_probe, ocs_pci_probe), 947 DEVMETHOD(device_attach, ocs_pci_attach), 948 DEVMETHOD(device_detach, ocs_pci_detach), 949 DEVMETHOD(device_shutdown, ocs_pci_shutdown), 950 {0, 0} 951 }; 952 953 static driver_t ocs_driver = { 954 "ocs_fc", 955 ocs_methods, 956 sizeof(struct ocs_softc) 957 }; 958 959 static devclass_t ocs_devclass; 960 961 DRIVER_MODULE(ocs_fc, pci, ocs_driver, ocs_devclass, 0, 0); 962 MODULE_VERSION(ocs_fc, 1); 963 964