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