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