[SCSI] fnic: Set max_cmd_len to driver supported CDB length
[pandora-kernel.git] / drivers / scsi / fnic / fnic_main.c
1 /*
2  * Copyright 2008 Cisco Systems, Inc.  All rights reserved.
3  * Copyright 2007 Nuova Systems, Inc.  All rights reserved.
4  *
5  * This program is free software; you may redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; version 2 of the License.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
10  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
11  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
12  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
13  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
14  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
15  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
16  * SOFTWARE.
17  */
18 #include <linux/module.h>
19 #include <linux/mempool.h>
20 #include <linux/string.h>
21 #include <linux/errno.h>
22 #include <linux/init.h>
23 #include <linux/pci.h>
24 #include <linux/skbuff.h>
25 #include <linux/interrupt.h>
26 #include <linux/spinlock.h>
27 #include <linux/workqueue.h>
28 #include <scsi/scsi_host.h>
29 #include <scsi/scsi_transport.h>
30 #include <scsi/scsi_transport_fc.h>
31 #include <scsi/scsi_tcq.h>
32 #include <scsi/libfc.h>
33 #include <scsi/fc_frame.h>
34
35 #include "vnic_dev.h"
36 #include "vnic_intr.h"
37 #include "vnic_stats.h"
38 #include "fnic_io.h"
39 #include "fnic.h"
40
41 #define PCI_DEVICE_ID_CISCO_FNIC        0x0045
42
43 /* Timer to poll notification area for events. Used for MSI interrupts */
44 #define FNIC_NOTIFY_TIMER_PERIOD        (2 * HZ)
45
46 static struct kmem_cache *fnic_sgl_cache[FNIC_SGL_NUM_CACHES];
47 static struct kmem_cache *fnic_io_req_cache;
48 LIST_HEAD(fnic_list);
49 DEFINE_SPINLOCK(fnic_list_lock);
50
51 /* Supported devices by fnic module */
52 static struct pci_device_id fnic_id_table[] = {
53         { PCI_DEVICE(PCI_VENDOR_ID_CISCO, PCI_DEVICE_ID_CISCO_FNIC) },
54         { 0, }
55 };
56
57 MODULE_DESCRIPTION(DRV_DESCRIPTION);
58 MODULE_AUTHOR("Abhijeet Joglekar <abjoglek@cisco.com>, "
59               "Joseph R. Eykholt <jeykholt@cisco.com>");
60 MODULE_LICENSE("GPL v2");
61 MODULE_VERSION(DRV_VERSION);
62 MODULE_DEVICE_TABLE(pci, fnic_id_table);
63
64 unsigned int fnic_log_level;
65 module_param(fnic_log_level, int, S_IRUGO|S_IWUSR);
66 MODULE_PARM_DESC(fnic_log_level, "bit mask of fnic logging levels");
67
68
69 static struct libfc_function_template fnic_transport_template = {
70         .frame_send = fnic_send,
71         .fcp_abort_io = fnic_empty_scsi_cleanup,
72         .fcp_cleanup = fnic_empty_scsi_cleanup,
73         .exch_mgr_reset = fnic_exch_mgr_reset
74 };
75
76 static int fnic_slave_alloc(struct scsi_device *sdev)
77 {
78         struct fc_rport *rport = starget_to_rport(scsi_target(sdev));
79         struct fc_lport *lp = shost_priv(sdev->host);
80         struct fnic *fnic = lport_priv(lp);
81
82         sdev->tagged_supported = 1;
83
84         if (!rport || fc_remote_port_chkready(rport))
85                 return -ENXIO;
86
87         scsi_activate_tcq(sdev, FNIC_DFLT_QUEUE_DEPTH);
88         rport->dev_loss_tmo = fnic->config.port_down_timeout / 1000;
89
90         return 0;
91 }
92
93 static struct scsi_host_template fnic_host_template = {
94         .module = THIS_MODULE,
95         .name = DRV_NAME,
96         .queuecommand = fnic_queuecommand,
97         .eh_abort_handler = fnic_abort_cmd,
98         .eh_device_reset_handler = fnic_device_reset,
99         .eh_host_reset_handler = fnic_host_reset,
100         .slave_alloc = fnic_slave_alloc,
101         .change_queue_depth = fc_change_queue_depth,
102         .change_queue_type = fc_change_queue_type,
103         .this_id = -1,
104         .cmd_per_lun = 3,
105         .can_queue = FNIC_MAX_IO_REQ,
106         .use_clustering = ENABLE_CLUSTERING,
107         .sg_tablesize = FNIC_MAX_SG_DESC_CNT,
108         .max_sectors = 0xffff,
109         .shost_attrs = fnic_attrs,
110 };
111
112 static void fnic_get_host_speed(struct Scsi_Host *shost);
113 static struct scsi_transport_template *fnic_fc_transport;
114 static struct fc_host_statistics *fnic_get_stats(struct Scsi_Host *);
115
116 static struct fc_function_template fnic_fc_functions = {
117
118         .show_host_node_name = 1,
119         .show_host_port_name = 1,
120         .show_host_supported_classes = 1,
121         .show_host_supported_fc4s = 1,
122         .show_host_active_fc4s = 1,
123         .show_host_maxframe_size = 1,
124         .show_host_port_id = 1,
125         .show_host_supported_speeds = 1,
126         .get_host_speed = fnic_get_host_speed,
127         .show_host_speed = 1,
128         .show_host_port_type = 1,
129         .get_host_port_state = fc_get_host_port_state,
130         .show_host_port_state = 1,
131         .show_host_symbolic_name = 1,
132         .show_rport_maxframe_size = 1,
133         .show_rport_supported_classes = 1,
134         .show_host_fabric_name = 1,
135         .show_starget_node_name = 1,
136         .show_starget_port_name = 1,
137         .show_starget_port_id = 1,
138         .show_rport_dev_loss_tmo = 1,
139         .issue_fc_host_lip = fnic_reset,
140         .get_fc_host_stats = fnic_get_stats,
141         .dd_fcrport_size = sizeof(struct fc_rport_libfc_priv),
142         .terminate_rport_io = fnic_terminate_rport_io,
143 };
144
145 static void fnic_get_host_speed(struct Scsi_Host *shost)
146 {
147         struct fc_lport *lp = shost_priv(shost);
148         struct fnic *fnic = lport_priv(lp);
149         u32 port_speed = vnic_dev_port_speed(fnic->vdev);
150
151         /* Add in other values as they get defined in fw */
152         switch (port_speed) {
153         case 10000:
154                 fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
155                 break;
156         default:
157                 fc_host_speed(shost) = FC_PORTSPEED_10GBIT;
158                 break;
159         }
160 }
161
162 static struct fc_host_statistics *fnic_get_stats(struct Scsi_Host *host)
163 {
164         int ret;
165         struct fc_lport *lp = shost_priv(host);
166         struct fnic *fnic = lport_priv(lp);
167         struct fc_host_statistics *stats = &lp->host_stats;
168         struct vnic_stats *vs;
169         unsigned long flags;
170
171         if (time_before(jiffies, fnic->stats_time + HZ / FNIC_STATS_RATE_LIMIT))
172                 return stats;
173         fnic->stats_time = jiffies;
174
175         spin_lock_irqsave(&fnic->fnic_lock, flags);
176         ret = vnic_dev_stats_dump(fnic->vdev, &fnic->stats);
177         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
178
179         if (ret) {
180                 FNIC_MAIN_DBG(KERN_DEBUG, fnic->lport->host,
181                               "fnic: Get vnic stats failed"
182                               " 0x%x", ret);
183                 return stats;
184         }
185         vs = fnic->stats;
186         stats->tx_frames = vs->tx.tx_unicast_frames_ok;
187         stats->tx_words  = vs->tx.tx_unicast_bytes_ok / 4;
188         stats->rx_frames = vs->rx.rx_unicast_frames_ok;
189         stats->rx_words  = vs->rx.rx_unicast_bytes_ok / 4;
190         stats->error_frames = vs->tx.tx_errors + vs->rx.rx_errors;
191         stats->dumped_frames = vs->tx.tx_drops + vs->rx.rx_drop;
192         stats->invalid_crc_count = vs->rx.rx_crc_errors;
193         stats->seconds_since_last_reset = (jiffies - lp->boot_time) / HZ;
194         stats->fcp_input_megabytes = div_u64(fnic->fcp_input_bytes, 1000000);
195         stats->fcp_output_megabytes = div_u64(fnic->fcp_output_bytes, 1000000);
196
197         return stats;
198 }
199
200 void fnic_log_q_error(struct fnic *fnic)
201 {
202         unsigned int i;
203         u32 error_status;
204
205         for (i = 0; i < fnic->raw_wq_count; i++) {
206                 error_status = ioread32(&fnic->wq[i].ctrl->error_status);
207                 if (error_status)
208                         shost_printk(KERN_ERR, fnic->lport->host,
209                                      "WQ[%d] error_status"
210                                      " %d\n", i, error_status);
211         }
212
213         for (i = 0; i < fnic->rq_count; i++) {
214                 error_status = ioread32(&fnic->rq[i].ctrl->error_status);
215                 if (error_status)
216                         shost_printk(KERN_ERR, fnic->lport->host,
217                                      "RQ[%d] error_status"
218                                      " %d\n", i, error_status);
219         }
220
221         for (i = 0; i < fnic->wq_copy_count; i++) {
222                 error_status = ioread32(&fnic->wq_copy[i].ctrl->error_status);
223                 if (error_status)
224                         shost_printk(KERN_ERR, fnic->lport->host,
225                                      "CWQ[%d] error_status"
226                                      " %d\n", i, error_status);
227         }
228 }
229
230 void fnic_handle_link_event(struct fnic *fnic)
231 {
232         unsigned long flags;
233
234         spin_lock_irqsave(&fnic->fnic_lock, flags);
235         if (fnic->stop_rx_link_events) {
236                 spin_unlock_irqrestore(&fnic->fnic_lock, flags);
237                 return;
238         }
239         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
240
241         queue_work(fnic_event_queue, &fnic->link_work);
242
243 }
244
245 static int fnic_notify_set(struct fnic *fnic)
246 {
247         int err;
248
249         switch (vnic_dev_get_intr_mode(fnic->vdev)) {
250         case VNIC_DEV_INTR_MODE_INTX:
251                 err = vnic_dev_notify_set(fnic->vdev, FNIC_INTX_NOTIFY);
252                 break;
253         case VNIC_DEV_INTR_MODE_MSI:
254                 err = vnic_dev_notify_set(fnic->vdev, -1);
255                 break;
256         case VNIC_DEV_INTR_MODE_MSIX:
257                 err = vnic_dev_notify_set(fnic->vdev, FNIC_MSIX_ERR_NOTIFY);
258                 break;
259         default:
260                 shost_printk(KERN_ERR, fnic->lport->host,
261                              "Interrupt mode should be set up"
262                              " before devcmd notify set %d\n",
263                              vnic_dev_get_intr_mode(fnic->vdev));
264                 err = -1;
265                 break;
266         }
267
268         return err;
269 }
270
271 static void fnic_notify_timer(unsigned long data)
272 {
273         struct fnic *fnic = (struct fnic *)data;
274
275         fnic_handle_link_event(fnic);
276         mod_timer(&fnic->notify_timer,
277                   round_jiffies(jiffies + FNIC_NOTIFY_TIMER_PERIOD));
278 }
279
280 static void fnic_notify_timer_start(struct fnic *fnic)
281 {
282         switch (vnic_dev_get_intr_mode(fnic->vdev)) {
283         case VNIC_DEV_INTR_MODE_MSI:
284                 /*
285                  * Schedule first timeout immediately. The driver is
286                  * initiatialized and ready to look for link up notification
287                  */
288                 mod_timer(&fnic->notify_timer, jiffies);
289                 break;
290         default:
291                 /* Using intr for notification for INTx/MSI-X */
292                 break;
293         };
294 }
295
296 static int fnic_dev_wait(struct vnic_dev *vdev,
297                          int (*start)(struct vnic_dev *, int),
298                          int (*finished)(struct vnic_dev *, int *),
299                          int arg)
300 {
301         unsigned long time;
302         int done;
303         int err;
304
305         err = start(vdev, arg);
306         if (err)
307                 return err;
308
309         /* Wait for func to complete...2 seconds max */
310         time = jiffies + (HZ * 2);
311         do {
312                 err = finished(vdev, &done);
313                 if (err)
314                         return err;
315                 if (done)
316                         return 0;
317                 schedule_timeout_uninterruptible(HZ / 10);
318         } while (time_after(time, jiffies));
319
320         return -ETIMEDOUT;
321 }
322
323 static int fnic_cleanup(struct fnic *fnic)
324 {
325         unsigned int i;
326         int err;
327         unsigned long flags;
328         struct fc_frame *flogi = NULL;
329         struct fc_frame *flogi_resp = NULL;
330
331         vnic_dev_disable(fnic->vdev);
332         for (i = 0; i < fnic->intr_count; i++)
333                 vnic_intr_mask(&fnic->intr[i]);
334
335         for (i = 0; i < fnic->rq_count; i++) {
336                 err = vnic_rq_disable(&fnic->rq[i]);
337                 if (err)
338                         return err;
339         }
340         for (i = 0; i < fnic->raw_wq_count; i++) {
341                 err = vnic_wq_disable(&fnic->wq[i]);
342                 if (err)
343                         return err;
344         }
345         for (i = 0; i < fnic->wq_copy_count; i++) {
346                 err = vnic_wq_copy_disable(&fnic->wq_copy[i]);
347                 if (err)
348                         return err;
349         }
350
351         /* Clean up completed IOs and FCS frames */
352         fnic_wq_copy_cmpl_handler(fnic, -1);
353         fnic_wq_cmpl_handler(fnic, -1);
354         fnic_rq_cmpl_handler(fnic, -1);
355
356         /* Clean up the IOs and FCS frames that have not completed */
357         for (i = 0; i < fnic->raw_wq_count; i++)
358                 vnic_wq_clean(&fnic->wq[i], fnic_free_wq_buf);
359         for (i = 0; i < fnic->rq_count; i++)
360                 vnic_rq_clean(&fnic->rq[i], fnic_free_rq_buf);
361         for (i = 0; i < fnic->wq_copy_count; i++)
362                 vnic_wq_copy_clean(&fnic->wq_copy[i],
363                                    fnic_wq_copy_cleanup_handler);
364
365         for (i = 0; i < fnic->cq_count; i++)
366                 vnic_cq_clean(&fnic->cq[i]);
367         for (i = 0; i < fnic->intr_count; i++)
368                 vnic_intr_clean(&fnic->intr[i]);
369
370         /*
371          * Remove cached flogi and flogi resp frames if any
372          * These frames are not in any queue, and therefore queue
373          * cleanup does not clean them. So clean them explicitly
374          */
375         spin_lock_irqsave(&fnic->fnic_lock, flags);
376         flogi = fnic->flogi;
377         fnic->flogi = NULL;
378         flogi_resp = fnic->flogi_resp;
379         fnic->flogi_resp = NULL;
380         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
381
382         if (flogi)
383                 dev_kfree_skb(fp_skb(flogi));
384
385         if (flogi_resp)
386                 dev_kfree_skb(fp_skb(flogi_resp));
387
388         mempool_destroy(fnic->io_req_pool);
389         for (i = 0; i < FNIC_SGL_NUM_CACHES; i++)
390                 mempool_destroy(fnic->io_sgl_pool[i]);
391
392         return 0;
393 }
394
395 static void fnic_iounmap(struct fnic *fnic)
396 {
397         if (fnic->bar0.vaddr)
398                 iounmap(fnic->bar0.vaddr);
399 }
400
401 /*
402  * Allocate element for mempools requiring GFP_DMA flag.
403  * Otherwise, checks in kmem_flagcheck() hit BUG_ON().
404  */
405 static void *fnic_alloc_slab_dma(gfp_t gfp_mask, void *pool_data)
406 {
407         struct kmem_cache *mem = pool_data;
408
409         return kmem_cache_alloc(mem, gfp_mask | GFP_ATOMIC | GFP_DMA);
410 }
411
412 static int __devinit fnic_probe(struct pci_dev *pdev,
413                                 const struct pci_device_id *ent)
414 {
415         struct Scsi_Host *host;
416         struct fc_lport *lp;
417         struct fnic *fnic;
418         mempool_t *pool;
419         int err;
420         int i;
421         unsigned long flags;
422
423         /*
424          * Allocate SCSI Host and set up association between host,
425          * local port, and fnic
426          */
427         host = scsi_host_alloc(&fnic_host_template,
428                                sizeof(struct fc_lport) + sizeof(struct fnic));
429         if (!host) {
430                 printk(KERN_ERR PFX "Unable to alloc SCSI host\n");
431                 err = -ENOMEM;
432                 goto err_out;
433         }
434         lp = shost_priv(host);
435         lp->host = host;
436         fnic = lport_priv(lp);
437         fnic->lport = lp;
438
439         snprintf(fnic->name, sizeof(fnic->name) - 1, "%s%d", DRV_NAME,
440                  host->host_no);
441
442         host->transportt = fnic_fc_transport;
443
444         err = scsi_init_shared_tag_map(host, FNIC_MAX_IO_REQ);
445         if (err) {
446                 shost_printk(KERN_ERR, fnic->lport->host,
447                              "Unable to alloc shared tag map\n");
448                 goto err_out_free_hba;
449         }
450
451         /* Setup PCI resources */
452         pci_set_drvdata(pdev, fnic);
453
454         fnic->pdev = pdev;
455
456         err = pci_enable_device(pdev);
457         if (err) {
458                 shost_printk(KERN_ERR, fnic->lport->host,
459                              "Cannot enable PCI device, aborting.\n");
460                 goto err_out_free_hba;
461         }
462
463         err = pci_request_regions(pdev, DRV_NAME);
464         if (err) {
465                 shost_printk(KERN_ERR, fnic->lport->host,
466                              "Cannot enable PCI resources, aborting\n");
467                 goto err_out_disable_device;
468         }
469
470         pci_set_master(pdev);
471
472         /* Query PCI controller on system for DMA addressing
473          * limitation for the device.  Try 40-bit first, and
474          * fail to 32-bit.
475          */
476         err = pci_set_dma_mask(pdev, DMA_BIT_MASK(40));
477         if (err) {
478                 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
479                 if (err) {
480                         shost_printk(KERN_ERR, fnic->lport->host,
481                                      "No usable DMA configuration "
482                                      "aborting\n");
483                         goto err_out_release_regions;
484                 }
485                 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
486                 if (err) {
487                         shost_printk(KERN_ERR, fnic->lport->host,
488                                      "Unable to obtain 32-bit DMA "
489                                      "for consistent allocations, aborting.\n");
490                         goto err_out_release_regions;
491                 }
492         } else {
493                 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(40));
494                 if (err) {
495                         shost_printk(KERN_ERR, fnic->lport->host,
496                                      "Unable to obtain 40-bit DMA "
497                                      "for consistent allocations, aborting.\n");
498                         goto err_out_release_regions;
499                 }
500         }
501
502         /* Map vNIC resources from BAR0 */
503         if (!(pci_resource_flags(pdev, 0) & IORESOURCE_MEM)) {
504                 shost_printk(KERN_ERR, fnic->lport->host,
505                              "BAR0 not memory-map'able, aborting.\n");
506                 err = -ENODEV;
507                 goto err_out_release_regions;
508         }
509
510         fnic->bar0.vaddr = pci_iomap(pdev, 0, 0);
511         fnic->bar0.bus_addr = pci_resource_start(pdev, 0);
512         fnic->bar0.len = pci_resource_len(pdev, 0);
513
514         if (!fnic->bar0.vaddr) {
515                 shost_printk(KERN_ERR, fnic->lport->host,
516                              "Cannot memory-map BAR0 res hdr, "
517                              "aborting.\n");
518                 err = -ENODEV;
519                 goto err_out_release_regions;
520         }
521
522         fnic->vdev = vnic_dev_register(NULL, fnic, pdev, &fnic->bar0);
523         if (!fnic->vdev) {
524                 shost_printk(KERN_ERR, fnic->lport->host,
525                              "vNIC registration failed, "
526                              "aborting.\n");
527                 err = -ENODEV;
528                 goto err_out_iounmap;
529         }
530
531         err = fnic_dev_wait(fnic->vdev, vnic_dev_open,
532                             vnic_dev_open_done, 0);
533         if (err) {
534                 shost_printk(KERN_ERR, fnic->lport->host,
535                              "vNIC dev open failed, aborting.\n");
536                 goto err_out_vnic_unregister;
537         }
538
539         err = vnic_dev_init(fnic->vdev, 0);
540         if (err) {
541                 shost_printk(KERN_ERR, fnic->lport->host,
542                              "vNIC dev init failed, aborting.\n");
543                 goto err_out_dev_close;
544         }
545
546         err = vnic_dev_mac_addr(fnic->vdev, fnic->mac_addr);
547         if (err) {
548                 shost_printk(KERN_ERR, fnic->lport->host,
549                              "vNIC get MAC addr failed \n");
550                 goto err_out_dev_close;
551         }
552
553         /* Get vNIC configuration */
554         err = fnic_get_vnic_config(fnic);
555         if (err) {
556                 shost_printk(KERN_ERR, fnic->lport->host,
557                              "Get vNIC configuration failed, "
558                              "aborting.\n");
559                 goto err_out_dev_close;
560         }
561         host->max_lun = fnic->config.luns_per_tgt;
562         host->max_id = FNIC_MAX_FCP_TARGET;
563         host->max_cmd_len = FNIC_MAX_CMD_LEN;
564
565         fnic_get_res_counts(fnic);
566
567         err = fnic_set_intr_mode(fnic);
568         if (err) {
569                 shost_printk(KERN_ERR, fnic->lport->host,
570                              "Failed to set intr mode, "
571                              "aborting.\n");
572                 goto err_out_dev_close;
573         }
574
575         err = fnic_request_intr(fnic);
576         if (err) {
577                 shost_printk(KERN_ERR, fnic->lport->host,
578                              "Unable to request irq.\n");
579                 goto err_out_clear_intr;
580         }
581
582         err = fnic_alloc_vnic_resources(fnic);
583         if (err) {
584                 shost_printk(KERN_ERR, fnic->lport->host,
585                              "Failed to alloc vNIC resources, "
586                              "aborting.\n");
587                 goto err_out_free_intr;
588         }
589
590
591         /* initialize all fnic locks */
592         spin_lock_init(&fnic->fnic_lock);
593
594         for (i = 0; i < FNIC_WQ_MAX; i++)
595                 spin_lock_init(&fnic->wq_lock[i]);
596
597         for (i = 0; i < FNIC_WQ_COPY_MAX; i++) {
598                 spin_lock_init(&fnic->wq_copy_lock[i]);
599                 fnic->wq_copy_desc_low[i] = DESC_CLEAN_LOW_WATERMARK;
600                 fnic->fw_ack_recd[i] = 0;
601                 fnic->fw_ack_index[i] = -1;
602         }
603
604         for (i = 0; i < FNIC_IO_LOCKS; i++)
605                 spin_lock_init(&fnic->io_req_lock[i]);
606
607         fnic->io_req_pool = mempool_create_slab_pool(2, fnic_io_req_cache);
608         if (!fnic->io_req_pool)
609                 goto err_out_free_resources;
610
611         pool = mempool_create(2, fnic_alloc_slab_dma, mempool_free_slab,
612                               fnic_sgl_cache[FNIC_SGL_CACHE_DFLT]);
613         if (!pool)
614                 goto err_out_free_ioreq_pool;
615         fnic->io_sgl_pool[FNIC_SGL_CACHE_DFLT] = pool;
616
617         pool = mempool_create(2, fnic_alloc_slab_dma, mempool_free_slab,
618                               fnic_sgl_cache[FNIC_SGL_CACHE_MAX]);
619         if (!pool)
620                 goto err_out_free_dflt_pool;
621         fnic->io_sgl_pool[FNIC_SGL_CACHE_MAX] = pool;
622
623         /* setup vlan config, hw inserts vlan header */
624         fnic->vlan_hw_insert = 1;
625         fnic->vlan_id = 0;
626
627         fnic->flogi_oxid = FC_XID_UNKNOWN;
628         fnic->flogi = NULL;
629         fnic->flogi_resp = NULL;
630         fnic->state = FNIC_IN_FC_MODE;
631
632         /* Enable hardware stripping of vlan header on ingress */
633         fnic_set_nic_config(fnic, 0, 0, 0, 0, 0, 0, 1);
634
635         /* Setup notification buffer area */
636         err = fnic_notify_set(fnic);
637         if (err) {
638                 shost_printk(KERN_ERR, fnic->lport->host,
639                              "Failed to alloc notify buffer, aborting.\n");
640                 goto err_out_free_max_pool;
641         }
642
643         /* Setup notify timer when using MSI interrupts */
644         if (vnic_dev_get_intr_mode(fnic->vdev) == VNIC_DEV_INTR_MODE_MSI)
645                 setup_timer(&fnic->notify_timer,
646                             fnic_notify_timer, (unsigned long)fnic);
647
648         /* allocate RQ buffers and post them to RQ*/
649         for (i = 0; i < fnic->rq_count; i++) {
650                 err = vnic_rq_fill(&fnic->rq[i], fnic_alloc_rq_frame);
651                 if (err) {
652                         shost_printk(KERN_ERR, fnic->lport->host,
653                                      "fnic_alloc_rq_frame can't alloc "
654                                      "frame\n");
655                         goto err_out_free_rq_buf;
656                 }
657         }
658
659         /*
660          * Initialization done with PCI system, hardware, firmware.
661          * Add host to SCSI
662          */
663         err = scsi_add_host(lp->host, &pdev->dev);
664         if (err) {
665                 shost_printk(KERN_ERR, fnic->lport->host,
666                              "fnic: scsi_add_host failed...exiting\n");
667                 goto err_out_free_rq_buf;
668         }
669
670         /* Start local port initiatialization */
671
672         lp->link_up = 0;
673         lp->tt = fnic_transport_template;
674
675         lp->max_retry_count = fnic->config.flogi_retries;
676         lp->max_rport_retry_count = fnic->config.plogi_retries;
677         lp->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
678                               FCP_SPPF_CONF_COMPL);
679         if (fnic->config.flags & VFCF_FCP_SEQ_LVL_ERR)
680                 lp->service_params |= FCP_SPPF_RETRY;
681
682         lp->boot_time = jiffies;
683         lp->e_d_tov = fnic->config.ed_tov;
684         lp->r_a_tov = fnic->config.ra_tov;
685         lp->link_supported_speeds = FC_PORTSPEED_10GBIT;
686         fc_set_wwnn(lp, fnic->config.node_wwn);
687         fc_set_wwpn(lp, fnic->config.port_wwn);
688
689         fc_lport_init(lp);
690         fc_exch_init(lp);
691         fc_elsct_init(lp);
692         fc_rport_init(lp);
693         fc_disc_init(lp);
694
695         if (!fc_exch_mgr_alloc(lp, FC_CLASS_3, FCPIO_HOST_EXCH_RANGE_START,
696                                FCPIO_HOST_EXCH_RANGE_END, NULL)) {
697                 err = -ENOMEM;
698                 goto err_out_remove_scsi_host;
699         }
700
701         fc_lport_config(lp);
702
703         if (fc_set_mfs(lp, fnic->config.maxdatafieldsize +
704                        sizeof(struct fc_frame_header))) {
705                 err = -EINVAL;
706                 goto err_out_free_exch_mgr;
707         }
708         fc_host_maxframe_size(lp->host) = lp->mfs;
709
710         sprintf(fc_host_symbolic_name(lp->host),
711                 DRV_NAME " v" DRV_VERSION " over %s", fnic->name);
712
713         spin_lock_irqsave(&fnic_list_lock, flags);
714         list_add_tail(&fnic->list, &fnic_list);
715         spin_unlock_irqrestore(&fnic_list_lock, flags);
716
717         INIT_WORK(&fnic->link_work, fnic_handle_link);
718         INIT_WORK(&fnic->frame_work, fnic_handle_frame);
719         skb_queue_head_init(&fnic->frame_queue);
720
721         /* Enable all queues */
722         for (i = 0; i < fnic->raw_wq_count; i++)
723                 vnic_wq_enable(&fnic->wq[i]);
724         for (i = 0; i < fnic->rq_count; i++)
725                 vnic_rq_enable(&fnic->rq[i]);
726         for (i = 0; i < fnic->wq_copy_count; i++)
727                 vnic_wq_copy_enable(&fnic->wq_copy[i]);
728
729         fc_fabric_login(lp);
730
731         vnic_dev_enable(fnic->vdev);
732         for (i = 0; i < fnic->intr_count; i++)
733                 vnic_intr_unmask(&fnic->intr[i]);
734
735         fnic_notify_timer_start(fnic);
736
737         return 0;
738
739 err_out_free_exch_mgr:
740         fc_exch_mgr_free(lp);
741 err_out_remove_scsi_host:
742         fc_remove_host(fnic->lport->host);
743         scsi_remove_host(fnic->lport->host);
744 err_out_free_rq_buf:
745         for (i = 0; i < fnic->rq_count; i++)
746                 vnic_rq_clean(&fnic->rq[i], fnic_free_rq_buf);
747         vnic_dev_notify_unset(fnic->vdev);
748 err_out_free_max_pool:
749         mempool_destroy(fnic->io_sgl_pool[FNIC_SGL_CACHE_MAX]);
750 err_out_free_dflt_pool:
751         mempool_destroy(fnic->io_sgl_pool[FNIC_SGL_CACHE_DFLT]);
752 err_out_free_ioreq_pool:
753         mempool_destroy(fnic->io_req_pool);
754 err_out_free_resources:
755         fnic_free_vnic_resources(fnic);
756 err_out_free_intr:
757         fnic_free_intr(fnic);
758 err_out_clear_intr:
759         fnic_clear_intr_mode(fnic);
760 err_out_dev_close:
761         vnic_dev_close(fnic->vdev);
762 err_out_vnic_unregister:
763         vnic_dev_unregister(fnic->vdev);
764 err_out_iounmap:
765         fnic_iounmap(fnic);
766 err_out_release_regions:
767         pci_release_regions(pdev);
768 err_out_disable_device:
769         pci_disable_device(pdev);
770 err_out_free_hba:
771         scsi_host_put(lp->host);
772 err_out:
773         return err;
774 }
775
776 static void __devexit fnic_remove(struct pci_dev *pdev)
777 {
778         struct fnic *fnic = pci_get_drvdata(pdev);
779         unsigned long flags;
780
781         /*
782          * Mark state so that the workqueue thread stops forwarding
783          * received frames and link events to the local port. ISR and
784          * other threads that can queue work items will also stop
785          * creating work items on the fnic workqueue
786          */
787         spin_lock_irqsave(&fnic->fnic_lock, flags);
788         fnic->stop_rx_link_events = 1;
789         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
790
791         if (vnic_dev_get_intr_mode(fnic->vdev) == VNIC_DEV_INTR_MODE_MSI)
792                 del_timer_sync(&fnic->notify_timer);
793
794         /*
795          * Flush the fnic event queue. After this call, there should
796          * be no event queued for this fnic device in the workqueue
797          */
798         flush_workqueue(fnic_event_queue);
799         skb_queue_purge(&fnic->frame_queue);
800
801         /*
802          * Log off the fabric. This stops all remote ports, dns port,
803          * logs off the fabric. This flushes all rport, disc, lport work
804          * before returning
805          */
806         fc_fabric_logoff(fnic->lport);
807
808         spin_lock_irqsave(&fnic->fnic_lock, flags);
809         fnic->in_remove = 1;
810         spin_unlock_irqrestore(&fnic->fnic_lock, flags);
811
812         fc_lport_destroy(fnic->lport);
813
814         /*
815          * This stops the fnic device, masks all interrupts. Completed
816          * CQ entries are drained. Posted WQ/RQ/Copy-WQ entries are
817          * cleaned up
818          */
819         fnic_cleanup(fnic);
820
821         BUG_ON(!skb_queue_empty(&fnic->frame_queue));
822
823         spin_lock_irqsave(&fnic_list_lock, flags);
824         list_del(&fnic->list);
825         spin_unlock_irqrestore(&fnic_list_lock, flags);
826
827         fc_remove_host(fnic->lport->host);
828         scsi_remove_host(fnic->lport->host);
829         fc_exch_mgr_free(fnic->lport);
830         vnic_dev_notify_unset(fnic->vdev);
831         fnic_free_vnic_resources(fnic);
832         fnic_free_intr(fnic);
833         fnic_clear_intr_mode(fnic);
834         vnic_dev_close(fnic->vdev);
835         vnic_dev_unregister(fnic->vdev);
836         fnic_iounmap(fnic);
837         pci_release_regions(pdev);
838         pci_disable_device(pdev);
839         pci_set_drvdata(pdev, NULL);
840         scsi_host_put(fnic->lport->host);
841 }
842
843 static struct pci_driver fnic_driver = {
844         .name = DRV_NAME,
845         .id_table = fnic_id_table,
846         .probe = fnic_probe,
847         .remove = __devexit_p(fnic_remove),
848 };
849
850 static int __init fnic_init_module(void)
851 {
852         size_t len;
853         int err = 0;
854
855         printk(KERN_INFO PFX "%s, ver %s\n", DRV_DESCRIPTION, DRV_VERSION);
856
857         /* Create a cache for allocation of default size sgls */
858         len = sizeof(struct fnic_dflt_sgl_list);
859         fnic_sgl_cache[FNIC_SGL_CACHE_DFLT] = kmem_cache_create
860                 ("fnic_sgl_dflt", len + FNIC_SG_DESC_ALIGN, FNIC_SG_DESC_ALIGN,
861                  SLAB_HWCACHE_ALIGN | SLAB_CACHE_DMA,
862                  NULL);
863         if (!fnic_sgl_cache[FNIC_SGL_CACHE_DFLT]) {
864                 printk(KERN_ERR PFX "failed to create fnic dflt sgl slab\n");
865                 err = -ENOMEM;
866                 goto err_create_fnic_sgl_slab_dflt;
867         }
868
869         /* Create a cache for allocation of max size sgls*/
870         len = sizeof(struct fnic_sgl_list);
871         fnic_sgl_cache[FNIC_SGL_CACHE_MAX] = kmem_cache_create
872                 ("fnic_sgl_max", len + FNIC_SG_DESC_ALIGN, FNIC_SG_DESC_ALIGN,
873                  SLAB_HWCACHE_ALIGN | SLAB_CACHE_DMA,
874                  NULL);
875         if (!fnic_sgl_cache[FNIC_SGL_CACHE_MAX]) {
876                 printk(KERN_ERR PFX "failed to create fnic max sgl slab\n");
877                 err = -ENOMEM;
878                 goto err_create_fnic_sgl_slab_max;
879         }
880
881         /* Create a cache of io_req structs for use via mempool */
882         fnic_io_req_cache = kmem_cache_create("fnic_io_req",
883                                               sizeof(struct fnic_io_req),
884                                               0, SLAB_HWCACHE_ALIGN, NULL);
885         if (!fnic_io_req_cache) {
886                 printk(KERN_ERR PFX "failed to create fnic io_req slab\n");
887                 err = -ENOMEM;
888                 goto err_create_fnic_ioreq_slab;
889         }
890
891         fnic_event_queue = create_singlethread_workqueue("fnic_event_wq");
892         if (!fnic_event_queue) {
893                 printk(KERN_ERR PFX "fnic work queue create failed\n");
894                 err = -ENOMEM;
895                 goto err_create_fnic_workq;
896         }
897
898         spin_lock_init(&fnic_list_lock);
899         INIT_LIST_HEAD(&fnic_list);
900
901         fnic_fc_transport = fc_attach_transport(&fnic_fc_functions);
902         if (!fnic_fc_transport) {
903                 printk(KERN_ERR PFX "fc_attach_transport error\n");
904                 err = -ENOMEM;
905                 goto err_fc_transport;
906         }
907
908         /* register the driver with PCI system */
909         err = pci_register_driver(&fnic_driver);
910         if (err < 0) {
911                 printk(KERN_ERR PFX "pci register error\n");
912                 goto err_pci_register;
913         }
914         return err;
915
916 err_pci_register:
917         fc_release_transport(fnic_fc_transport);
918 err_fc_transport:
919         destroy_workqueue(fnic_event_queue);
920 err_create_fnic_workq:
921         kmem_cache_destroy(fnic_io_req_cache);
922 err_create_fnic_ioreq_slab:
923         kmem_cache_destroy(fnic_sgl_cache[FNIC_SGL_CACHE_MAX]);
924 err_create_fnic_sgl_slab_max:
925         kmem_cache_destroy(fnic_sgl_cache[FNIC_SGL_CACHE_DFLT]);
926 err_create_fnic_sgl_slab_dflt:
927         return err;
928 }
929
930 static void __exit fnic_cleanup_module(void)
931 {
932         pci_unregister_driver(&fnic_driver);
933         destroy_workqueue(fnic_event_queue);
934         kmem_cache_destroy(fnic_sgl_cache[FNIC_SGL_CACHE_MAX]);
935         kmem_cache_destroy(fnic_sgl_cache[FNIC_SGL_CACHE_DFLT]);
936         kmem_cache_destroy(fnic_io_req_cache);
937         fc_release_transport(fnic_fc_transport);
938 }
939
940 module_init(fnic_init_module);
941 module_exit(fnic_cleanup_module);
942