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