1 /* 2 * Copyright 2014 Cisco Systems, Inc. All rights reserved. 3 * 4 * This program is free software; you may redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation; version 2 of the License. 7 * 8 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 9 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 10 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 11 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 12 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 13 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 14 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 15 * SOFTWARE. 16 */ 17 18 #include <linux/module.h> 19 #include <linux/mempool.h> 20 #include <linux/string.h> 21 #include <linux/slab.h> 22 #include <linux/errno.h> 23 #include <linux/init.h> 24 #include <linux/pci.h> 25 #include <linux/skbuff.h> 26 #include <linux/interrupt.h> 27 #include <linux/spinlock.h> 28 #include <linux/workqueue.h> 29 #include <scsi/scsi_host.h> 30 #include <scsi/scsi_tcq.h> 31 32 #include "snic.h" 33 #include "snic_fwint.h" 34 35 #define PCI_DEVICE_ID_CISCO_SNIC 0x0046 36 37 /* Supported devices by snic module */ 38 static struct pci_device_id snic_id_table[] = { 39 {PCI_DEVICE(0x1137, PCI_DEVICE_ID_CISCO_SNIC) }, 40 { 0, } /* end of table */ 41 }; 42 43 unsigned int snic_log_level = 0x0; 44 module_param(snic_log_level, int, S_IRUGO|S_IWUSR); 45 MODULE_PARM_DESC(snic_log_level, "bitmask for snic logging levels"); 46 47 #ifdef CONFIG_SCSI_SNIC_DEBUG_FS 48 unsigned int snic_trace_max_pages = 16; 49 module_param(snic_trace_max_pages, uint, S_IRUGO|S_IWUSR); 50 MODULE_PARM_DESC(snic_trace_max_pages, 51 "Total allocated memory pages for snic trace buffer"); 52 53 #endif 54 unsigned int snic_max_qdepth = SNIC_DFLT_QUEUE_DEPTH; 55 module_param(snic_max_qdepth, uint, S_IRUGO | S_IWUSR); 56 MODULE_PARM_DESC(snic_max_qdepth, "Queue depth to report for each LUN"); 57 58 /* 59 * snic_slave_alloc : callback function to SCSI Mid Layer, called on 60 * scsi device initialization. 61 */ 62 static int 63 snic_slave_alloc(struct scsi_device *sdev) 64 { 65 struct snic_tgt *tgt = starget_to_tgt(scsi_target(sdev)); 66 67 if (!tgt || snic_tgt_chkready(tgt)) 68 return -ENXIO; 69 70 return 0; 71 } 72 73 /* 74 * snic_slave_configure : callback function to SCSI Mid Layer, called on 75 * scsi device initialization. 76 */ 77 static int 78 snic_slave_configure(struct scsi_device *sdev) 79 { 80 struct snic *snic = shost_priv(sdev->host); 81 u32 qdepth = 0, max_ios = 0; 82 int tmo = SNIC_DFLT_CMD_TIMEOUT * HZ; 83 84 /* Set Queue Depth */ 85 max_ios = snic_max_qdepth; 86 qdepth = min_t(u32, max_ios, SNIC_MAX_QUEUE_DEPTH); 87 scsi_change_queue_depth(sdev, qdepth); 88 89 if (snic->fwinfo.io_tmo > 1) 90 tmo = snic->fwinfo.io_tmo * HZ; 91 92 /* FW requires extended timeouts */ 93 blk_queue_rq_timeout(sdev->request_queue, tmo); 94 95 return 0; 96 } 97 98 static int 99 snic_change_queue_depth(struct scsi_device *sdev, int qdepth) 100 { 101 struct snic *snic = shost_priv(sdev->host); 102 int qsz = 0; 103 104 qsz = min_t(u32, qdepth, SNIC_MAX_QUEUE_DEPTH); 105 if (qsz < sdev->queue_depth) 106 atomic64_inc(&snic->s_stats.misc.qsz_rampdown); 107 else if (qsz > sdev->queue_depth) 108 atomic64_inc(&snic->s_stats.misc.qsz_rampup); 109 110 atomic64_set(&snic->s_stats.misc.last_qsz, sdev->queue_depth); 111 112 scsi_change_queue_depth(sdev, qsz); 113 114 return sdev->queue_depth; 115 } 116 117 static struct scsi_host_template snic_host_template = { 118 .module = THIS_MODULE, 119 .name = SNIC_DRV_NAME, 120 .queuecommand = snic_queuecommand, 121 .eh_abort_handler = snic_abort_cmd, 122 .eh_device_reset_handler = snic_device_reset, 123 .eh_host_reset_handler = snic_host_reset, 124 .slave_alloc = snic_slave_alloc, 125 .slave_configure = snic_slave_configure, 126 .change_queue_depth = snic_change_queue_depth, 127 .this_id = -1, 128 .cmd_per_lun = SNIC_DFLT_QUEUE_DEPTH, 129 .can_queue = SNIC_MAX_IO_REQ, 130 .sg_tablesize = SNIC_MAX_SG_DESC_CNT, 131 .max_sectors = 0x800, 132 .shost_attrs = snic_attrs, 133 .track_queue_depth = 1, 134 .cmd_size = sizeof(struct snic_internal_io_state), 135 .proc_name = "snic_scsi", 136 }; 137 138 /* 139 * snic_handle_link_event : Handles link events such as link up/down/error 140 */ 141 void 142 snic_handle_link_event(struct snic *snic) 143 { 144 unsigned long flags; 145 146 spin_lock_irqsave(&snic->snic_lock, flags); 147 if (snic->stop_link_events) { 148 spin_unlock_irqrestore(&snic->snic_lock, flags); 149 150 return; 151 } 152 spin_unlock_irqrestore(&snic->snic_lock, flags); 153 154 queue_work(snic_glob->event_q, &snic->link_work); 155 } /* end of snic_handle_link_event */ 156 157 /* 158 * snic_notify_set : sets notification area 159 * This notification area is to receive events from fw 160 * Note: snic supports only MSIX interrupts, in which we can just call 161 * svnic_dev_notify_set directly 162 */ 163 static int 164 snic_notify_set(struct snic *snic) 165 { 166 int ret = 0; 167 enum vnic_dev_intr_mode intr_mode; 168 169 intr_mode = svnic_dev_get_intr_mode(snic->vdev); 170 171 if (intr_mode == VNIC_DEV_INTR_MODE_MSIX) { 172 ret = svnic_dev_notify_set(snic->vdev, SNIC_MSIX_ERR_NOTIFY); 173 } else { 174 SNIC_HOST_ERR(snic->shost, 175 "Interrupt mode should be setup before devcmd notify set %d\n", 176 intr_mode); 177 ret = -1; 178 } 179 180 return ret; 181 } /* end of snic_notify_set */ 182 183 /* 184 * snic_dev_wait : polls vnic open status. 185 */ 186 static int 187 snic_dev_wait(struct vnic_dev *vdev, 188 int (*start)(struct vnic_dev *, int), 189 int (*finished)(struct vnic_dev *, int *), 190 int arg) 191 { 192 unsigned long time; 193 int ret, done; 194 int retry_cnt = 0; 195 196 ret = start(vdev, arg); 197 if (ret) 198 return ret; 199 200 /* 201 * Wait for func to complete...2 seconds max. 202 * 203 * Sometimes schedule_timeout_uninterruptible take long time 204 * to wakeup, which results skipping retry. The retry counter 205 * ensures to retry at least two times. 206 */ 207 time = jiffies + (HZ * 2); 208 do { 209 ret = finished(vdev, &done); 210 if (ret) 211 return ret; 212 213 if (done) 214 return 0; 215 schedule_timeout_uninterruptible(HZ/10); 216 ++retry_cnt; 217 } while (time_after(time, jiffies) || (retry_cnt < 3)); 218 219 return -ETIMEDOUT; 220 } /* end of snic_dev_wait */ 221 222 /* 223 * snic_cleanup: called by snic_remove 224 * Stops the snic device, masks all interrupts, Completed CQ entries are 225 * drained. Posted WQ/RQ/Copy-WQ entries are cleanup 226 */ 227 static int 228 snic_cleanup(struct snic *snic) 229 { 230 unsigned int i; 231 int ret; 232 233 svnic_dev_disable(snic->vdev); 234 for (i = 0; i < snic->intr_count; i++) 235 svnic_intr_mask(&snic->intr[i]); 236 237 for (i = 0; i < snic->wq_count; i++) { 238 ret = svnic_wq_disable(&snic->wq[i]); 239 if (ret) 240 return ret; 241 } 242 243 /* Clean up completed IOs */ 244 snic_fwcq_cmpl_handler(snic, -1); 245 246 snic_wq_cmpl_handler(snic, -1); 247 248 /* Clean up the IOs that have not completed */ 249 for (i = 0; i < snic->wq_count; i++) 250 svnic_wq_clean(&snic->wq[i], snic_free_wq_buf); 251 252 for (i = 0; i < snic->cq_count; i++) 253 svnic_cq_clean(&snic->cq[i]); 254 255 for (i = 0; i < snic->intr_count; i++) 256 svnic_intr_clean(&snic->intr[i]); 257 258 /* Cleanup snic specific requests */ 259 snic_free_all_untagged_reqs(snic); 260 261 /* Cleanup Pending SCSI commands */ 262 snic_shutdown_scsi_cleanup(snic); 263 264 for (i = 0; i < SNIC_REQ_MAX_CACHES; i++) 265 mempool_destroy(snic->req_pool[i]); 266 267 return 0; 268 } /* end of snic_cleanup */ 269 270 271 static void 272 snic_iounmap(struct snic *snic) 273 { 274 if (snic->bar0.vaddr) 275 iounmap(snic->bar0.vaddr); 276 } 277 278 /* 279 * snic_vdev_open_done : polls for svnic_dev_open cmd completion. 280 */ 281 static int 282 snic_vdev_open_done(struct vnic_dev *vdev, int *done) 283 { 284 struct snic *snic = svnic_dev_priv(vdev); 285 int ret; 286 int nretries = 5; 287 288 do { 289 ret = svnic_dev_open_done(vdev, done); 290 if (ret == 0) 291 break; 292 293 SNIC_HOST_INFO(snic->shost, "VNIC_DEV_OPEN Timedout.\n"); 294 } while (nretries--); 295 296 return ret; 297 } /* end of snic_vdev_open_done */ 298 299 /* 300 * snic_add_host : registers scsi host with ML 301 */ 302 static int 303 snic_add_host(struct Scsi_Host *shost, struct pci_dev *pdev) 304 { 305 int ret = 0; 306 307 ret = scsi_add_host(shost, &pdev->dev); 308 if (ret) { 309 SNIC_HOST_ERR(shost, 310 "snic: scsi_add_host failed. %d\n", 311 ret); 312 313 return ret; 314 } 315 316 SNIC_BUG_ON(shost->work_q != NULL); 317 snprintf(shost->work_q_name, sizeof(shost->work_q_name), "scsi_wq_%d", 318 shost->host_no); 319 shost->work_q = create_singlethread_workqueue(shost->work_q_name); 320 if (!shost->work_q) { 321 SNIC_HOST_ERR(shost, "Failed to Create ScsiHost wq.\n"); 322 323 ret = -ENOMEM; 324 } 325 326 return ret; 327 } /* end of snic_add_host */ 328 329 static void 330 snic_del_host(struct Scsi_Host *shost) 331 { 332 if (!shost->work_q) 333 return; 334 335 destroy_workqueue(shost->work_q); 336 shost->work_q = NULL; 337 scsi_remove_host(shost); 338 } 339 340 int 341 snic_get_state(struct snic *snic) 342 { 343 return atomic_read(&snic->state); 344 } 345 346 void 347 snic_set_state(struct snic *snic, enum snic_state state) 348 { 349 SNIC_HOST_INFO(snic->shost, "snic state change from %s to %s\n", 350 snic_state_to_str(snic_get_state(snic)), 351 snic_state_to_str(state)); 352 353 atomic_set(&snic->state, state); 354 } 355 356 /* 357 * snic_probe : Initialize the snic interface. 358 */ 359 static int 360 snic_probe(struct pci_dev *pdev, const struct pci_device_id *ent) 361 { 362 struct Scsi_Host *shost; 363 struct snic *snic; 364 mempool_t *pool; 365 unsigned long flags; 366 u32 max_ios = 0; 367 int ret, i; 368 369 /* Device Information */ 370 SNIC_INFO("snic device %4x:%4x:%4x:%4x: ", 371 pdev->vendor, pdev->device, pdev->subsystem_vendor, 372 pdev->subsystem_device); 373 374 SNIC_INFO("snic device bus %x: slot %x: fn %x\n", 375 pdev->bus->number, PCI_SLOT(pdev->devfn), 376 PCI_FUNC(pdev->devfn)); 377 378 /* 379 * Allocate SCSI Host and setup association between host, and snic 380 */ 381 shost = scsi_host_alloc(&snic_host_template, sizeof(struct snic)); 382 if (!shost) { 383 SNIC_ERR("Unable to alloc scsi_host\n"); 384 ret = -ENOMEM; 385 386 goto prob_end; 387 } 388 snic = shost_priv(shost); 389 snic->shost = shost; 390 391 snprintf(snic->name, sizeof(snic->name) - 1, "%s%d", SNIC_DRV_NAME, 392 shost->host_no); 393 394 SNIC_HOST_INFO(shost, 395 "snic%d = %p shost = %p device bus %x: slot %x: fn %x\n", 396 shost->host_no, snic, shost, pdev->bus->number, 397 PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn)); 398 #ifdef CONFIG_SCSI_SNIC_DEBUG_FS 399 /* Per snic debugfs init */ 400 ret = snic_stats_debugfs_init(snic); 401 if (ret) { 402 SNIC_HOST_ERR(snic->shost, 403 "Failed to initialize debugfs stats\n"); 404 snic_stats_debugfs_remove(snic); 405 } 406 #endif 407 408 /* Setup PCI Resources */ 409 pci_set_drvdata(pdev, snic); 410 snic->pdev = pdev; 411 412 ret = pci_enable_device(pdev); 413 if (ret) { 414 SNIC_HOST_ERR(shost, 415 "Cannot enable PCI Resources, aborting : %d\n", 416 ret); 417 418 goto err_free_snic; 419 } 420 421 ret = pci_request_regions(pdev, SNIC_DRV_NAME); 422 if (ret) { 423 SNIC_HOST_ERR(shost, 424 "Cannot obtain PCI Resources, aborting : %d\n", 425 ret); 426 427 goto err_pci_disable; 428 } 429 430 pci_set_master(pdev); 431 432 /* 433 * Query PCI Controller on system for DMA addressing 434 * limitation for the device. Try 43-bit first, and 435 * fail to 32-bit. 436 */ 437 ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(43)); 438 if (ret) { 439 ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 440 if (ret) { 441 SNIC_HOST_ERR(shost, 442 "No Usable DMA Configuration, aborting %d\n", 443 ret); 444 goto err_rel_regions; 445 } 446 } 447 448 /* Map vNIC resources from BAR0 */ 449 if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) { 450 SNIC_HOST_ERR(shost, "BAR0 not memory mappable aborting.\n"); 451 452 ret = -ENODEV; 453 goto err_rel_regions; 454 } 455 456 snic->bar0.vaddr = pci_iomap(pdev, 0, 0); 457 if (!snic->bar0.vaddr) { 458 SNIC_HOST_ERR(shost, 459 "Cannot memory map BAR0 res hdr aborting.\n"); 460 461 ret = -ENODEV; 462 goto err_rel_regions; 463 } 464 465 snic->bar0.bus_addr = pci_resource_start(pdev, 0); 466 snic->bar0.len = pci_resource_len(pdev, 0); 467 SNIC_BUG_ON(snic->bar0.bus_addr == 0); 468 469 /* Devcmd2 Resource Allocation and Initialization */ 470 snic->vdev = svnic_dev_alloc_discover(NULL, snic, pdev, &snic->bar0, 1); 471 if (!snic->vdev) { 472 SNIC_HOST_ERR(shost, "vNIC Resource Discovery Failed.\n"); 473 474 ret = -ENODEV; 475 goto err_iounmap; 476 } 477 478 ret = svnic_dev_cmd_init(snic->vdev, 0); 479 if (ret) { 480 SNIC_HOST_INFO(shost, "Devcmd2 Init Failed. err = %d\n", ret); 481 482 goto err_vnic_unreg; 483 } 484 485 ret = snic_dev_wait(snic->vdev, svnic_dev_open, snic_vdev_open_done, 0); 486 if (ret) { 487 SNIC_HOST_ERR(shost, 488 "vNIC dev open failed, aborting. %d\n", 489 ret); 490 491 goto err_vnic_unreg; 492 } 493 494 ret = svnic_dev_init(snic->vdev, 0); 495 if (ret) { 496 SNIC_HOST_ERR(shost, 497 "vNIC dev init failed. aborting. %d\n", 498 ret); 499 500 goto err_dev_close; 501 } 502 503 /* Get vNIC information */ 504 ret = snic_get_vnic_config(snic); 505 if (ret) { 506 SNIC_HOST_ERR(shost, 507 "Get vNIC configuration failed, aborting. %d\n", 508 ret); 509 510 goto err_dev_close; 511 } 512 513 /* Configure Maximum Outstanding IO reqs */ 514 max_ios = snic->config.io_throttle_count; 515 if (max_ios != SNIC_UCSM_DFLT_THROTTLE_CNT_BLD) 516 shost->can_queue = min_t(u32, SNIC_MAX_IO_REQ, 517 max_t(u32, SNIC_MIN_IO_REQ, max_ios)); 518 519 snic->max_tag_id = shost->can_queue; 520 521 shost->max_lun = snic->config.luns_per_tgt; 522 shost->max_id = SNIC_MAX_TARGET; 523 524 shost->max_cmd_len = MAX_COMMAND_SIZE; /*defined in scsi_cmnd.h*/ 525 526 snic_get_res_counts(snic); 527 528 /* 529 * Assumption: Only MSIx is supported 530 */ 531 ret = snic_set_intr_mode(snic); 532 if (ret) { 533 SNIC_HOST_ERR(shost, 534 "Failed to set intr mode aborting. %d\n", 535 ret); 536 537 goto err_dev_close; 538 } 539 540 ret = snic_alloc_vnic_res(snic); 541 if (ret) { 542 SNIC_HOST_ERR(shost, 543 "Failed to alloc vNIC resources aborting. %d\n", 544 ret); 545 546 goto err_clear_intr; 547 } 548 549 /* Initialize specific lists */ 550 INIT_LIST_HEAD(&snic->list); 551 552 /* 553 * spl_cmd_list for maintaining snic specific cmds 554 * such as EXCH_VER_REQ, REPORT_TARGETS etc 555 */ 556 INIT_LIST_HEAD(&snic->spl_cmd_list); 557 spin_lock_init(&snic->spl_cmd_lock); 558 559 /* initialize all snic locks */ 560 spin_lock_init(&snic->snic_lock); 561 562 for (i = 0; i < SNIC_WQ_MAX; i++) 563 spin_lock_init(&snic->wq_lock[i]); 564 565 for (i = 0; i < SNIC_IO_LOCKS; i++) 566 spin_lock_init(&snic->io_req_lock[i]); 567 568 pool = mempool_create_slab_pool(2, 569 snic_glob->req_cache[SNIC_REQ_CACHE_DFLT_SGL]); 570 if (!pool) { 571 SNIC_HOST_ERR(shost, "dflt sgl pool creation failed\n"); 572 573 ret = -ENOMEM; 574 goto err_free_res; 575 } 576 577 snic->req_pool[SNIC_REQ_CACHE_DFLT_SGL] = pool; 578 579 pool = mempool_create_slab_pool(2, 580 snic_glob->req_cache[SNIC_REQ_CACHE_MAX_SGL]); 581 if (!pool) { 582 SNIC_HOST_ERR(shost, "max sgl pool creation failed\n"); 583 584 ret = -ENOMEM; 585 goto err_free_dflt_sgl_pool; 586 } 587 588 snic->req_pool[SNIC_REQ_CACHE_MAX_SGL] = pool; 589 590 pool = mempool_create_slab_pool(2, 591 snic_glob->req_cache[SNIC_REQ_TM_CACHE]); 592 if (!pool) { 593 SNIC_HOST_ERR(shost, "snic tmreq info pool creation failed.\n"); 594 595 ret = -ENOMEM; 596 goto err_free_max_sgl_pool; 597 } 598 599 snic->req_pool[SNIC_REQ_TM_CACHE] = pool; 600 601 /* Initialize snic state */ 602 atomic_set(&snic->state, SNIC_INIT); 603 604 atomic_set(&snic->ios_inflight, 0); 605 606 /* Setup notification buffer area */ 607 ret = snic_notify_set(snic); 608 if (ret) { 609 SNIC_HOST_ERR(shost, 610 "Failed to alloc notify buffer aborting. %d\n", 611 ret); 612 613 goto err_free_tmreq_pool; 614 } 615 616 spin_lock_irqsave(&snic_glob->snic_list_lock, flags); 617 list_add_tail(&snic->list, &snic_glob->snic_list); 618 spin_unlock_irqrestore(&snic_glob->snic_list_lock, flags); 619 620 snic_disc_init(&snic->disc); 621 INIT_WORK(&snic->tgt_work, snic_handle_tgt_disc); 622 INIT_WORK(&snic->disc_work, snic_handle_disc); 623 INIT_WORK(&snic->link_work, snic_handle_link); 624 625 /* Enable all queues */ 626 for (i = 0; i < snic->wq_count; i++) 627 svnic_wq_enable(&snic->wq[i]); 628 629 ret = svnic_dev_enable_wait(snic->vdev); 630 if (ret) { 631 SNIC_HOST_ERR(shost, 632 "vNIC dev enable failed w/ error %d\n", 633 ret); 634 635 goto err_vdev_enable; 636 } 637 638 ret = snic_request_intr(snic); 639 if (ret) { 640 SNIC_HOST_ERR(shost, "Unable to request irq. %d\n", ret); 641 642 goto err_req_intr; 643 } 644 645 for (i = 0; i < snic->intr_count; i++) 646 svnic_intr_unmask(&snic->intr[i]); 647 648 /* Get snic params */ 649 ret = snic_get_conf(snic); 650 if (ret) { 651 SNIC_HOST_ERR(shost, 652 "Failed to get snic io config from FW w err %d\n", 653 ret); 654 655 goto err_get_conf; 656 } 657 658 /* 659 * Initialization done with PCI system, hardware, firmware. 660 * Add shost to SCSI 661 */ 662 ret = snic_add_host(shost, pdev); 663 if (ret) { 664 SNIC_HOST_ERR(shost, 665 "Adding scsi host Failed ... exiting. %d\n", 666 ret); 667 668 goto err_get_conf; 669 } 670 671 snic_set_state(snic, SNIC_ONLINE); 672 673 ret = snic_disc_start(snic); 674 if (ret) { 675 SNIC_HOST_ERR(shost, "snic_probe:Discovery Failed w err = %d\n", 676 ret); 677 678 goto err_get_conf; 679 } 680 681 SNIC_HOST_INFO(shost, "SNIC Device Probe Successful.\n"); 682 683 return 0; 684 685 err_get_conf: 686 snic_free_all_untagged_reqs(snic); 687 688 for (i = 0; i < snic->intr_count; i++) 689 svnic_intr_mask(&snic->intr[i]); 690 691 snic_free_intr(snic); 692 693 err_req_intr: 694 svnic_dev_disable(snic->vdev); 695 696 err_vdev_enable: 697 svnic_dev_notify_unset(snic->vdev); 698 699 for (i = 0; i < snic->wq_count; i++) { 700 int rc = 0; 701 702 rc = svnic_wq_disable(&snic->wq[i]); 703 if (rc) { 704 SNIC_HOST_ERR(shost, 705 "WQ Disable Failed w/ err = %d\n", rc); 706 707 break; 708 } 709 } 710 snic_del_host(snic->shost); 711 712 err_free_tmreq_pool: 713 mempool_destroy(snic->req_pool[SNIC_REQ_TM_CACHE]); 714 715 err_free_max_sgl_pool: 716 mempool_destroy(snic->req_pool[SNIC_REQ_CACHE_MAX_SGL]); 717 718 err_free_dflt_sgl_pool: 719 mempool_destroy(snic->req_pool[SNIC_REQ_CACHE_DFLT_SGL]); 720 721 err_free_res: 722 snic_free_vnic_res(snic); 723 724 err_clear_intr: 725 snic_clear_intr_mode(snic); 726 727 err_dev_close: 728 svnic_dev_close(snic->vdev); 729 730 err_vnic_unreg: 731 svnic_dev_unregister(snic->vdev); 732 733 err_iounmap: 734 snic_iounmap(snic); 735 736 err_rel_regions: 737 pci_release_regions(pdev); 738 739 err_pci_disable: 740 pci_disable_device(pdev); 741 742 err_free_snic: 743 #ifdef CONFIG_SCSI_SNIC_DEBUG_FS 744 snic_stats_debugfs_remove(snic); 745 #endif 746 scsi_host_put(shost); 747 pci_set_drvdata(pdev, NULL); 748 749 prob_end: 750 SNIC_INFO("sNIC device : bus %d: slot %d: fn %d Registration Failed.\n", 751 pdev->bus->number, PCI_SLOT(pdev->devfn), 752 PCI_FUNC(pdev->devfn)); 753 754 return ret; 755 } /* end of snic_probe */ 756 757 758 /* 759 * snic_remove : invoked on unbinding the interface to cleanup the 760 * resources allocated in snic_probe on initialization. 761 */ 762 static void 763 snic_remove(struct pci_dev *pdev) 764 { 765 struct snic *snic = pci_get_drvdata(pdev); 766 unsigned long flags; 767 768 if (!snic) { 769 SNIC_INFO("sNIC dev: bus %d slot %d fn %d snic inst is null.\n", 770 pdev->bus->number, PCI_SLOT(pdev->devfn), 771 PCI_FUNC(pdev->devfn)); 772 773 return; 774 } 775 776 /* 777 * Mark state so that the workqueue thread stops forwarding 778 * received frames and link events. ISR and other threads 779 * that can queue work items will also stop creating work 780 * items on the snic workqueue 781 */ 782 snic_set_state(snic, SNIC_OFFLINE); 783 spin_lock_irqsave(&snic->snic_lock, flags); 784 snic->stop_link_events = 1; 785 spin_unlock_irqrestore(&snic->snic_lock, flags); 786 787 flush_workqueue(snic_glob->event_q); 788 snic_disc_term(snic); 789 790 spin_lock_irqsave(&snic->snic_lock, flags); 791 snic->in_remove = 1; 792 spin_unlock_irqrestore(&snic->snic_lock, flags); 793 794 /* 795 * This stops the snic device, masks all interrupts, Completed 796 * CQ entries are drained. Posted WQ/RQ/Copy-WQ entries are 797 * cleanup 798 */ 799 snic_cleanup(snic); 800 801 spin_lock_irqsave(&snic_glob->snic_list_lock, flags); 802 list_del(&snic->list); 803 spin_unlock_irqrestore(&snic_glob->snic_list_lock, flags); 804 805 snic_tgt_del_all(snic); 806 #ifdef CONFIG_SCSI_SNIC_DEBUG_FS 807 snic_stats_debugfs_remove(snic); 808 #endif 809 snic_del_host(snic->shost); 810 811 svnic_dev_notify_unset(snic->vdev); 812 snic_free_intr(snic); 813 snic_free_vnic_res(snic); 814 snic_clear_intr_mode(snic); 815 svnic_dev_close(snic->vdev); 816 svnic_dev_unregister(snic->vdev); 817 snic_iounmap(snic); 818 pci_release_regions(pdev); 819 pci_disable_device(pdev); 820 pci_set_drvdata(pdev, NULL); 821 822 /* this frees Scsi_Host and snic memory (continuous chunk) */ 823 scsi_host_put(snic->shost); 824 } /* end of snic_remove */ 825 826 827 struct snic_global *snic_glob; 828 829 /* 830 * snic_global_data_init: Initialize SNIC Global Data 831 * Notes: All the global lists, variables should be part of global data 832 * this helps in debugging. 833 */ 834 static int 835 snic_global_data_init(void) 836 { 837 int ret = 0; 838 struct kmem_cache *cachep; 839 ssize_t len = 0; 840 841 snic_glob = kzalloc(sizeof(*snic_glob), GFP_KERNEL); 842 843 if (!snic_glob) { 844 SNIC_ERR("Failed to allocate Global Context.\n"); 845 846 ret = -ENOMEM; 847 goto gdi_end; 848 } 849 850 #ifdef CONFIG_SCSI_SNIC_DEBUG_FS 851 /* Debugfs related Initialization */ 852 /* Create debugfs entries for snic */ 853 ret = snic_debugfs_init(); 854 if (ret < 0) { 855 SNIC_ERR("Failed to create sysfs dir for tracing and stats.\n"); 856 snic_debugfs_term(); 857 /* continue even if it fails */ 858 } 859 860 /* Trace related Initialization */ 861 /* Allocate memory for trace buffer */ 862 ret = snic_trc_init(); 863 if (ret < 0) { 864 SNIC_ERR("Trace buffer init failed, SNIC tracing disabled\n"); 865 snic_trc_free(); 866 /* continue even if it fails */ 867 } 868 869 #endif 870 INIT_LIST_HEAD(&snic_glob->snic_list); 871 spin_lock_init(&snic_glob->snic_list_lock); 872 873 /* Create a cache for allocation of snic_host_req+default size ESGLs */ 874 len = sizeof(struct snic_req_info); 875 len += sizeof(struct snic_host_req) + sizeof(struct snic_dflt_sgl); 876 cachep = kmem_cache_create("snic_req_dfltsgl", len, SNIC_SG_DESC_ALIGN, 877 SLAB_HWCACHE_ALIGN, NULL); 878 if (!cachep) { 879 SNIC_ERR("Failed to create snic default sgl slab\n"); 880 ret = -ENOMEM; 881 882 goto err_dflt_req_slab; 883 } 884 snic_glob->req_cache[SNIC_REQ_CACHE_DFLT_SGL] = cachep; 885 886 /* Create a cache for allocation of max size Extended SGLs */ 887 len = sizeof(struct snic_req_info); 888 len += sizeof(struct snic_host_req) + sizeof(struct snic_max_sgl); 889 cachep = kmem_cache_create("snic_req_maxsgl", len, SNIC_SG_DESC_ALIGN, 890 SLAB_HWCACHE_ALIGN, NULL); 891 if (!cachep) { 892 SNIC_ERR("Failed to create snic max sgl slab\n"); 893 ret = -ENOMEM; 894 895 goto err_max_req_slab; 896 } 897 snic_glob->req_cache[SNIC_REQ_CACHE_MAX_SGL] = cachep; 898 899 len = sizeof(struct snic_host_req); 900 cachep = kmem_cache_create("snic_req_maxsgl", len, SNIC_SG_DESC_ALIGN, 901 SLAB_HWCACHE_ALIGN, NULL); 902 if (!cachep) { 903 SNIC_ERR("Failed to create snic tm req slab\n"); 904 ret = -ENOMEM; 905 906 goto err_tmreq_slab; 907 } 908 snic_glob->req_cache[SNIC_REQ_TM_CACHE] = cachep; 909 910 /* snic_event queue */ 911 snic_glob->event_q = create_singlethread_workqueue("snic_event_wq"); 912 if (!snic_glob->event_q) { 913 SNIC_ERR("snic event queue create failed\n"); 914 ret = -ENOMEM; 915 916 goto err_eventq; 917 } 918 919 return ret; 920 921 err_eventq: 922 kmem_cache_destroy(snic_glob->req_cache[SNIC_REQ_TM_CACHE]); 923 924 err_tmreq_slab: 925 kmem_cache_destroy(snic_glob->req_cache[SNIC_REQ_CACHE_MAX_SGL]); 926 927 err_max_req_slab: 928 kmem_cache_destroy(snic_glob->req_cache[SNIC_REQ_CACHE_DFLT_SGL]); 929 930 err_dflt_req_slab: 931 #ifdef CONFIG_SCSI_SNIC_DEBUG_FS 932 snic_trc_free(); 933 snic_debugfs_term(); 934 #endif 935 kfree(snic_glob); 936 snic_glob = NULL; 937 938 gdi_end: 939 return ret; 940 } /* end of snic_glob_init */ 941 942 /* 943 * snic_global_data_cleanup : Frees SNIC Global Data 944 */ 945 static void 946 snic_global_data_cleanup(void) 947 { 948 SNIC_BUG_ON(snic_glob == NULL); 949 950 destroy_workqueue(snic_glob->event_q); 951 kmem_cache_destroy(snic_glob->req_cache[SNIC_REQ_TM_CACHE]); 952 kmem_cache_destroy(snic_glob->req_cache[SNIC_REQ_CACHE_MAX_SGL]); 953 kmem_cache_destroy(snic_glob->req_cache[SNIC_REQ_CACHE_DFLT_SGL]); 954 955 #ifdef CONFIG_SCSI_SNIC_DEBUG_FS 956 /* Freeing Trace Resources */ 957 snic_trc_free(); 958 959 /* Freeing Debugfs Resources */ 960 snic_debugfs_term(); 961 #endif 962 kfree(snic_glob); 963 snic_glob = NULL; 964 } /* end of snic_glob_cleanup */ 965 966 static struct pci_driver snic_driver = { 967 .name = SNIC_DRV_NAME, 968 .id_table = snic_id_table, 969 .probe = snic_probe, 970 .remove = snic_remove, 971 }; 972 973 static int __init 974 snic_init_module(void) 975 { 976 int ret = 0; 977 978 #ifndef __x86_64__ 979 SNIC_INFO("SNIC Driver is supported only for x86_64 platforms!\n"); 980 add_taint(TAINT_CPU_OUT_OF_SPEC, LOCKDEP_STILL_OK); 981 #endif 982 983 SNIC_INFO("%s, ver %s\n", SNIC_DRV_DESCRIPTION, SNIC_DRV_VERSION); 984 985 ret = snic_global_data_init(); 986 if (ret) { 987 SNIC_ERR("Failed to Initialize Global Data.\n"); 988 989 return ret; 990 } 991 992 ret = pci_register_driver(&snic_driver); 993 if (ret < 0) { 994 SNIC_ERR("PCI driver register error\n"); 995 996 goto err_pci_reg; 997 } 998 999 return ret; 1000 1001 err_pci_reg: 1002 snic_global_data_cleanup(); 1003 1004 return ret; 1005 } 1006 1007 static void __exit 1008 snic_cleanup_module(void) 1009 { 1010 pci_unregister_driver(&snic_driver); 1011 snic_global_data_cleanup(); 1012 } 1013 1014 module_init(snic_init_module); 1015 module_exit(snic_cleanup_module); 1016 1017 MODULE_LICENSE("GPL v2"); 1018 MODULE_DESCRIPTION(SNIC_DRV_DESCRIPTION); 1019 MODULE_VERSION(SNIC_DRV_VERSION); 1020 MODULE_DEVICE_TABLE(pci, snic_id_table); 1021 MODULE_AUTHOR("Narsimhulu Musini <nmusini@cisco.com>, " 1022 "Sesidhar Baddela <sebaddel@cisco.com>"); 1023