drivers/scsi/snic/snic_main.c

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