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