xref: /linux/drivers/scsi/qedf/qedf_main.c (revision a1d1eb2f57501b2e7e2076ce89b3f3a666ddbfdd)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  QLogic FCoE Offload Driver
4  *  Copyright (c) 2016-2018 Cavium Inc.
5  */
6 #include <linux/init.h>
7 #include <linux/kernel.h>
8 #include <linux/module.h>
9 #include <linux/pci.h>
10 #include <linux/device.h>
11 #include <linux/highmem.h>
12 #include <linux/crc32.h>
13 #include <linux/interrupt.h>
14 #include <linux/list.h>
15 #include <linux/kthread.h>
16 #include <linux/phylink.h>
17 #include <scsi/libfc.h>
18 #include <scsi/scsi_host.h>
19 #include <scsi/fc_frame.h>
20 #include <linux/if_ether.h>
21 #include <linux/if_vlan.h>
22 #include <linux/cpu.h>
23 #include "qedf.h"
24 #include "qedf_dbg.h"
25 #include <uapi/linux/pci_regs.h>
26 
27 const struct qed_fcoe_ops *qed_ops;
28 
29 static int qedf_probe(struct pci_dev *pdev, const struct pci_device_id *id);
30 static void qedf_remove(struct pci_dev *pdev);
31 static void qedf_shutdown(struct pci_dev *pdev);
32 static void qedf_schedule_recovery_handler(void *dev);
33 static void qedf_recovery_handler(struct work_struct *work);
34 static int qedf_suspend(struct pci_dev *pdev, pm_message_t state);
35 
36 /*
37  * Driver module parameters.
38  */
39 static unsigned int qedf_dev_loss_tmo = 60;
40 module_param_named(dev_loss_tmo, qedf_dev_loss_tmo, int, S_IRUGO);
41 MODULE_PARM_DESC(dev_loss_tmo,  " dev_loss_tmo setting for attached "
42 	"remote ports (default 60)");
43 
44 uint qedf_debug = QEDF_LOG_INFO;
45 module_param_named(debug, qedf_debug, uint, S_IRUGO|S_IWUSR);
46 MODULE_PARM_DESC(debug, " Debug mask. Pass '1' to enable default debugging"
47 	" mask");
48 
49 static uint qedf_fipvlan_retries = 60;
50 module_param_named(fipvlan_retries, qedf_fipvlan_retries, int, S_IRUGO);
51 MODULE_PARM_DESC(fipvlan_retries, " Number of FIP VLAN requests to attempt "
52 	"before giving up (default 60)");
53 
54 static uint qedf_fallback_vlan = QEDF_FALLBACK_VLAN;
55 module_param_named(fallback_vlan, qedf_fallback_vlan, int, S_IRUGO);
56 MODULE_PARM_DESC(fallback_vlan, " VLAN ID to try if fip vlan request fails "
57 	"(default 1002).");
58 
59 static int qedf_default_prio = -1;
60 module_param_named(default_prio, qedf_default_prio, int, S_IRUGO);
61 MODULE_PARM_DESC(default_prio, " Override 802.1q priority for FIP and FCoE"
62 	" traffic (value between 0 and 7, default 3).");
63 
64 uint qedf_dump_frames;
65 module_param_named(dump_frames, qedf_dump_frames, int, S_IRUGO | S_IWUSR);
66 MODULE_PARM_DESC(dump_frames, " Print the skb data of FIP and FCoE frames "
67 	"(default off)");
68 
69 static uint qedf_queue_depth;
70 module_param_named(queue_depth, qedf_queue_depth, int, S_IRUGO);
71 MODULE_PARM_DESC(queue_depth, " Sets the queue depth for all LUNs discovered "
72 	"by the qedf driver. Default is 0 (use OS default).");
73 
74 uint qedf_io_tracing;
75 module_param_named(io_tracing, qedf_io_tracing, int, S_IRUGO | S_IWUSR);
76 MODULE_PARM_DESC(io_tracing, " Enable logging of SCSI requests/completions "
77 	"into trace buffer. (default off).");
78 
79 static uint qedf_max_lun = MAX_FIBRE_LUNS;
80 module_param_named(max_lun, qedf_max_lun, int, S_IRUGO);
81 MODULE_PARM_DESC(max_lun, " Sets the maximum luns per target that the driver "
82 	"supports. (default 0xffffffff)");
83 
84 uint qedf_link_down_tmo;
85 module_param_named(link_down_tmo, qedf_link_down_tmo, int, S_IRUGO);
86 MODULE_PARM_DESC(link_down_tmo, " Delays informing the fcoe transport that the "
87 	"link is down by N seconds.");
88 
89 bool qedf_retry_delay;
90 module_param_named(retry_delay, qedf_retry_delay, bool, S_IRUGO | S_IWUSR);
91 MODULE_PARM_DESC(retry_delay, " Enable/disable handling of FCP_RSP IU retry "
92 	"delay handling (default off).");
93 
94 static bool qedf_dcbx_no_wait;
95 module_param_named(dcbx_no_wait, qedf_dcbx_no_wait, bool, S_IRUGO | S_IWUSR);
96 MODULE_PARM_DESC(dcbx_no_wait, " Do not wait for DCBX convergence to start "
97 	"sending FIP VLAN requests on link up (Default: off).");
98 
99 static uint qedf_dp_module;
100 module_param_named(dp_module, qedf_dp_module, uint, S_IRUGO);
101 MODULE_PARM_DESC(dp_module, " bit flags control for verbose printk passed "
102 	"qed module during probe.");
103 
104 static uint qedf_dp_level = QED_LEVEL_NOTICE;
105 module_param_named(dp_level, qedf_dp_level, uint, S_IRUGO);
106 MODULE_PARM_DESC(dp_level, " printk verbosity control passed to qed module  "
107 	"during probe (0-3: 0 more verbose).");
108 
109 static bool qedf_enable_recovery = true;
110 module_param_named(enable_recovery, qedf_enable_recovery,
111 		bool, S_IRUGO | S_IWUSR);
112 MODULE_PARM_DESC(enable_recovery, "Enable/disable recovery on driver/firmware "
113 		"interface level errors 0 = Disabled, 1 = Enabled (Default: 1).");
114 
115 struct workqueue_struct *qedf_io_wq;
116 
117 static struct fcoe_percpu_s qedf_global;
118 static DEFINE_SPINLOCK(qedf_global_lock);
119 
120 static struct kmem_cache *qedf_io_work_cache;
121 
122 void qedf_set_vlan_id(struct qedf_ctx *qedf, int vlan_id)
123 {
124 	int vlan_id_tmp = 0;
125 
126 	vlan_id_tmp = vlan_id  | (qedf->prio << VLAN_PRIO_SHIFT);
127 	qedf->vlan_id = vlan_id_tmp;
128 	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
129 		  "Setting vlan_id=0x%04x prio=%d.\n",
130 		  vlan_id_tmp, qedf->prio);
131 }
132 
133 /* Returns true if we have a valid vlan, false otherwise */
134 static bool qedf_initiate_fipvlan_req(struct qedf_ctx *qedf)
135 {
136 
137 	while (qedf->fipvlan_retries--) {
138 		/* This is to catch if link goes down during fipvlan retries */
139 		if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
140 			QEDF_ERR(&qedf->dbg_ctx, "Link not up.\n");
141 			return false;
142 		}
143 
144 		if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
145 			QEDF_ERR(&qedf->dbg_ctx, "Driver unloading.\n");
146 			return false;
147 		}
148 
149 		if (qedf->vlan_id > 0) {
150 			QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
151 				  "vlan = 0x%x already set, calling ctlr_link_up.\n",
152 				  qedf->vlan_id);
153 			if (atomic_read(&qedf->link_state) == QEDF_LINK_UP)
154 				fcoe_ctlr_link_up(&qedf->ctlr);
155 			return true;
156 		}
157 
158 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
159 			   "Retry %d.\n", qedf->fipvlan_retries);
160 		init_completion(&qedf->fipvlan_compl);
161 		qedf_fcoe_send_vlan_req(qedf);
162 		wait_for_completion_timeout(&qedf->fipvlan_compl, 1 * HZ);
163 	}
164 
165 	return false;
166 }
167 
168 static void qedf_handle_link_update(struct work_struct *work)
169 {
170 	struct qedf_ctx *qedf =
171 	    container_of(work, struct qedf_ctx, link_update.work);
172 	int rc;
173 
174 	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC, "Entered. link_state=%d.\n",
175 		  atomic_read(&qedf->link_state));
176 
177 	if (atomic_read(&qedf->link_state) == QEDF_LINK_UP) {
178 		rc = qedf_initiate_fipvlan_req(qedf);
179 		if (rc)
180 			return;
181 
182 		if (atomic_read(&qedf->link_state) != QEDF_LINK_UP) {
183 			QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
184 				  "Link is down, resetting vlan_id.\n");
185 			qedf->vlan_id = 0;
186 			return;
187 		}
188 
189 		/*
190 		 * If we get here then we never received a repsonse to our
191 		 * fip vlan request so set the vlan_id to the default and
192 		 * tell FCoE that the link is up
193 		 */
194 		QEDF_WARN(&(qedf->dbg_ctx), "Did not receive FIP VLAN "
195 			   "response, falling back to default VLAN %d.\n",
196 			   qedf_fallback_vlan);
197 		qedf_set_vlan_id(qedf, qedf_fallback_vlan);
198 
199 		/*
200 		 * Zero out data_src_addr so we'll update it with the new
201 		 * lport port_id
202 		 */
203 		eth_zero_addr(qedf->data_src_addr);
204 		fcoe_ctlr_link_up(&qedf->ctlr);
205 	} else if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
206 		/*
207 		 * If we hit here and link_down_tmo_valid is still 1 it means
208 		 * that link_down_tmo timed out so set it to 0 to make sure any
209 		 * other readers have accurate state.
210 		 */
211 		atomic_set(&qedf->link_down_tmo_valid, 0);
212 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
213 		    "Calling fcoe_ctlr_link_down().\n");
214 		fcoe_ctlr_link_down(&qedf->ctlr);
215 		if (qedf_wait_for_upload(qedf) == false)
216 			QEDF_ERR(&qedf->dbg_ctx,
217 				 "Could not upload all sessions.\n");
218 		/* Reset the number of FIP VLAN retries */
219 		qedf->fipvlan_retries = qedf_fipvlan_retries;
220 	}
221 }
222 
223 #define	QEDF_FCOE_MAC_METHOD_GRANGED_MAC		1
224 #define QEDF_FCOE_MAC_METHOD_FCF_MAP			2
225 #define QEDF_FCOE_MAC_METHOD_FCOE_SET_MAC		3
226 static void qedf_set_data_src_addr(struct qedf_ctx *qedf, struct fc_frame *fp)
227 {
228 	u8 *granted_mac;
229 	struct fc_frame_header *fh = fc_frame_header_get(fp);
230 	u8 fc_map[3];
231 	int method = 0;
232 
233 	/* Get granted MAC address from FIP FLOGI payload */
234 	granted_mac = fr_cb(fp)->granted_mac;
235 
236 	/*
237 	 * We set the source MAC for FCoE traffic based on the Granted MAC
238 	 * address from the switch.
239 	 *
240 	 * If granted_mac is non-zero, we used that.
241 	 * If the granted_mac is zeroed out, created the FCoE MAC based on
242 	 * the sel_fcf->fc_map and the d_id fo the FLOGI frame.
243 	 * If sel_fcf->fc_map is 0 then we use the default FCF-MAC plus the
244 	 * d_id of the FLOGI frame.
245 	 */
246 	if (!is_zero_ether_addr(granted_mac)) {
247 		ether_addr_copy(qedf->data_src_addr, granted_mac);
248 		method = QEDF_FCOE_MAC_METHOD_GRANGED_MAC;
249 	} else if (qedf->ctlr.sel_fcf->fc_map != 0) {
250 		hton24(fc_map, qedf->ctlr.sel_fcf->fc_map);
251 		qedf->data_src_addr[0] = fc_map[0];
252 		qedf->data_src_addr[1] = fc_map[1];
253 		qedf->data_src_addr[2] = fc_map[2];
254 		qedf->data_src_addr[3] = fh->fh_d_id[0];
255 		qedf->data_src_addr[4] = fh->fh_d_id[1];
256 		qedf->data_src_addr[5] = fh->fh_d_id[2];
257 		method = QEDF_FCOE_MAC_METHOD_FCF_MAP;
258 	} else {
259 		fc_fcoe_set_mac(qedf->data_src_addr, fh->fh_d_id);
260 		method = QEDF_FCOE_MAC_METHOD_FCOE_SET_MAC;
261 	}
262 
263 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
264 	    "QEDF data_src_mac=%pM method=%d.\n", qedf->data_src_addr, method);
265 }
266 
267 static void qedf_flogi_resp(struct fc_seq *seq, struct fc_frame *fp,
268 	void *arg)
269 {
270 	struct fc_exch *exch = fc_seq_exch(seq);
271 	struct fc_lport *lport = exch->lp;
272 	struct qedf_ctx *qedf = lport_priv(lport);
273 
274 	if (!qedf) {
275 		QEDF_ERR(NULL, "qedf is NULL.\n");
276 		return;
277 	}
278 
279 	/*
280 	 * If ERR_PTR is set then don't try to stat anything as it will cause
281 	 * a crash when we access fp.
282 	 */
283 	if (IS_ERR(fp)) {
284 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
285 		    "fp has IS_ERR() set.\n");
286 		goto skip_stat;
287 	}
288 
289 	/* Log stats for FLOGI reject */
290 	if (fc_frame_payload_op(fp) == ELS_LS_RJT)
291 		qedf->flogi_failed++;
292 	else if (fc_frame_payload_op(fp) == ELS_LS_ACC) {
293 		/* Set the source MAC we will use for FCoE traffic */
294 		qedf_set_data_src_addr(qedf, fp);
295 		qedf->flogi_pending = 0;
296 	}
297 
298 	/* Complete flogi_compl so we can proceed to sending ADISCs */
299 	complete(&qedf->flogi_compl);
300 
301 skip_stat:
302 	/* Report response to libfc */
303 	fc_lport_flogi_resp(seq, fp, lport);
304 }
305 
306 static struct fc_seq *qedf_elsct_send(struct fc_lport *lport, u32 did,
307 	struct fc_frame *fp, unsigned int op,
308 	void (*resp)(struct fc_seq *,
309 	struct fc_frame *,
310 	void *),
311 	void *arg, u32 timeout)
312 {
313 	struct qedf_ctx *qedf = lport_priv(lport);
314 
315 	/*
316 	 * Intercept FLOGI for statistic purposes. Note we use the resp
317 	 * callback to tell if this is really a flogi.
318 	 */
319 	if (resp == fc_lport_flogi_resp) {
320 		qedf->flogi_cnt++;
321 		qedf->flogi_pending++;
322 
323 		if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
324 			QEDF_ERR(&qedf->dbg_ctx, "Driver unloading\n");
325 			qedf->flogi_pending = 0;
326 		}
327 
328 		if (qedf->flogi_pending >= QEDF_FLOGI_RETRY_CNT) {
329 			schedule_delayed_work(&qedf->stag_work, 2);
330 			return NULL;
331 		}
332 
333 		return fc_elsct_send(lport, did, fp, op, qedf_flogi_resp,
334 		    arg, timeout);
335 	}
336 
337 	return fc_elsct_send(lport, did, fp, op, resp, arg, timeout);
338 }
339 
340 int qedf_send_flogi(struct qedf_ctx *qedf)
341 {
342 	struct fc_lport *lport;
343 	struct fc_frame *fp;
344 
345 	lport = qedf->lport;
346 
347 	if (!lport->tt.elsct_send) {
348 		QEDF_ERR(&qedf->dbg_ctx, "tt.elsct_send not set.\n");
349 		return -EINVAL;
350 	}
351 
352 	fp = fc_frame_alloc(lport, sizeof(struct fc_els_flogi));
353 	if (!fp) {
354 		QEDF_ERR(&(qedf->dbg_ctx), "fc_frame_alloc failed.\n");
355 		return -ENOMEM;
356 	}
357 
358 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_ELS,
359 	    "Sending FLOGI to reestablish session with switch.\n");
360 	lport->tt.elsct_send(lport, FC_FID_FLOGI, fp,
361 	    ELS_FLOGI, qedf_flogi_resp, lport, lport->r_a_tov);
362 
363 	init_completion(&qedf->flogi_compl);
364 
365 	return 0;
366 }
367 
368 /*
369  * This function is called if link_down_tmo is in use.  If we get a link up and
370  * link_down_tmo has not expired then use just FLOGI/ADISC to recover our
371  * sessions with targets.  Otherwise, just call fcoe_ctlr_link_up().
372  */
373 static void qedf_link_recovery(struct work_struct *work)
374 {
375 	struct qedf_ctx *qedf =
376 	    container_of(work, struct qedf_ctx, link_recovery.work);
377 	struct fc_lport *lport = qedf->lport;
378 	struct fc_rport_priv *rdata;
379 	bool rc;
380 	int retries = 30;
381 	int rval, i;
382 	struct list_head rdata_login_list;
383 
384 	INIT_LIST_HEAD(&rdata_login_list);
385 
386 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
387 	    "Link down tmo did not expire.\n");
388 
389 	/*
390 	 * Essentially reset the fcoe_ctlr here without affecting the state
391 	 * of the libfc structs.
392 	 */
393 	qedf->ctlr.state = FIP_ST_LINK_WAIT;
394 	fcoe_ctlr_link_down(&qedf->ctlr);
395 
396 	/*
397 	 * Bring the link up before we send the fipvlan request so libfcoe
398 	 * can select a new fcf in parallel
399 	 */
400 	fcoe_ctlr_link_up(&qedf->ctlr);
401 
402 	/* Since the link when down and up to verify which vlan we're on */
403 	qedf->fipvlan_retries = qedf_fipvlan_retries;
404 	rc = qedf_initiate_fipvlan_req(qedf);
405 	/* If getting the VLAN fails, set the VLAN to the fallback one */
406 	if (!rc)
407 		qedf_set_vlan_id(qedf, qedf_fallback_vlan);
408 
409 	/*
410 	 * We need to wait for an FCF to be selected due to the
411 	 * fcoe_ctlr_link_up other the FLOGI will be rejected.
412 	 */
413 	while (retries > 0) {
414 		if (qedf->ctlr.sel_fcf) {
415 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
416 			    "FCF reselected, proceeding with FLOGI.\n");
417 			break;
418 		}
419 		msleep(500);
420 		retries--;
421 	}
422 
423 	if (retries < 1) {
424 		QEDF_ERR(&(qedf->dbg_ctx), "Exhausted retries waiting for "
425 		    "FCF selection.\n");
426 		return;
427 	}
428 
429 	rval = qedf_send_flogi(qedf);
430 	if (rval)
431 		return;
432 
433 	/* Wait for FLOGI completion before proceeding with sending ADISCs */
434 	i = wait_for_completion_timeout(&qedf->flogi_compl,
435 	    qedf->lport->r_a_tov);
436 	if (i == 0) {
437 		QEDF_ERR(&(qedf->dbg_ctx), "FLOGI timed out.\n");
438 		return;
439 	}
440 
441 	/*
442 	 * Call lport->tt.rport_login which will cause libfc to send an
443 	 * ADISC since the rport is in state ready.
444 	 */
445 	mutex_lock(&lport->disc.disc_mutex);
446 	list_for_each_entry_rcu(rdata, &lport->disc.rports, peers) {
447 		if (kref_get_unless_zero(&rdata->kref)) {
448 			fc_rport_login(rdata);
449 			kref_put(&rdata->kref, fc_rport_destroy);
450 		}
451 	}
452 	mutex_unlock(&lport->disc.disc_mutex);
453 }
454 
455 static void qedf_update_link_speed(struct qedf_ctx *qedf,
456 	struct qed_link_output *link)
457 {
458 	__ETHTOOL_DECLARE_LINK_MODE_MASK(sup_caps);
459 	struct fc_lport *lport = qedf->lport;
460 
461 	lport->link_speed = FC_PORTSPEED_UNKNOWN;
462 	lport->link_supported_speeds = FC_PORTSPEED_UNKNOWN;
463 
464 	/* Set fc_host link speed */
465 	switch (link->speed) {
466 	case 10000:
467 		lport->link_speed = FC_PORTSPEED_10GBIT;
468 		break;
469 	case 25000:
470 		lport->link_speed = FC_PORTSPEED_25GBIT;
471 		break;
472 	case 40000:
473 		lport->link_speed = FC_PORTSPEED_40GBIT;
474 		break;
475 	case 50000:
476 		lport->link_speed = FC_PORTSPEED_50GBIT;
477 		break;
478 	case 100000:
479 		lport->link_speed = FC_PORTSPEED_100GBIT;
480 		break;
481 	case 20000:
482 		lport->link_speed = FC_PORTSPEED_20GBIT;
483 		break;
484 	default:
485 		lport->link_speed = FC_PORTSPEED_UNKNOWN;
486 		break;
487 	}
488 
489 	/*
490 	 * Set supported link speed by querying the supported
491 	 * capabilities of the link.
492 	 */
493 
494 	phylink_zero(sup_caps);
495 	phylink_set(sup_caps, 10000baseT_Full);
496 	phylink_set(sup_caps, 10000baseKX4_Full);
497 	phylink_set(sup_caps, 10000baseR_FEC);
498 	phylink_set(sup_caps, 10000baseCR_Full);
499 	phylink_set(sup_caps, 10000baseSR_Full);
500 	phylink_set(sup_caps, 10000baseLR_Full);
501 	phylink_set(sup_caps, 10000baseLRM_Full);
502 	phylink_set(sup_caps, 10000baseKR_Full);
503 
504 	if (linkmode_intersects(link->supported_caps, sup_caps))
505 		lport->link_supported_speeds |= FC_PORTSPEED_10GBIT;
506 
507 	phylink_zero(sup_caps);
508 	phylink_set(sup_caps, 25000baseKR_Full);
509 	phylink_set(sup_caps, 25000baseCR_Full);
510 	phylink_set(sup_caps, 25000baseSR_Full);
511 
512 	if (linkmode_intersects(link->supported_caps, sup_caps))
513 		lport->link_supported_speeds |= FC_PORTSPEED_25GBIT;
514 
515 	phylink_zero(sup_caps);
516 	phylink_set(sup_caps, 40000baseLR4_Full);
517 	phylink_set(sup_caps, 40000baseKR4_Full);
518 	phylink_set(sup_caps, 40000baseCR4_Full);
519 	phylink_set(sup_caps, 40000baseSR4_Full);
520 
521 	if (linkmode_intersects(link->supported_caps, sup_caps))
522 		lport->link_supported_speeds |= FC_PORTSPEED_40GBIT;
523 
524 	phylink_zero(sup_caps);
525 	phylink_set(sup_caps, 50000baseKR2_Full);
526 	phylink_set(sup_caps, 50000baseCR2_Full);
527 	phylink_set(sup_caps, 50000baseSR2_Full);
528 
529 	if (linkmode_intersects(link->supported_caps, sup_caps))
530 		lport->link_supported_speeds |= FC_PORTSPEED_50GBIT;
531 
532 	phylink_zero(sup_caps);
533 	phylink_set(sup_caps, 100000baseKR4_Full);
534 	phylink_set(sup_caps, 100000baseSR4_Full);
535 	phylink_set(sup_caps, 100000baseCR4_Full);
536 	phylink_set(sup_caps, 100000baseLR4_ER4_Full);
537 
538 	if (linkmode_intersects(link->supported_caps, sup_caps))
539 		lport->link_supported_speeds |= FC_PORTSPEED_100GBIT;
540 
541 	phylink_zero(sup_caps);
542 	phylink_set(sup_caps, 20000baseKR2_Full);
543 
544 	if (linkmode_intersects(link->supported_caps, sup_caps))
545 		lport->link_supported_speeds |= FC_PORTSPEED_20GBIT;
546 
547 	if (lport->host && lport->host->shost_data)
548 		fc_host_supported_speeds(lport->host) =
549 			lport->link_supported_speeds;
550 }
551 
552 static void qedf_bw_update(void *dev)
553 {
554 	struct qedf_ctx *qedf = (struct qedf_ctx *)dev;
555 	struct qed_link_output link;
556 
557 	/* Get the latest status of the link */
558 	qed_ops->common->get_link(qedf->cdev, &link);
559 
560 	if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
561 		QEDF_ERR(&qedf->dbg_ctx,
562 			 "Ignore link update, driver getting unload.\n");
563 		return;
564 	}
565 
566 	if (link.link_up) {
567 		if (atomic_read(&qedf->link_state) == QEDF_LINK_UP)
568 			qedf_update_link_speed(qedf, &link);
569 		else
570 			QEDF_ERR(&qedf->dbg_ctx,
571 				 "Ignore bw update, link is down.\n");
572 
573 	} else {
574 		QEDF_ERR(&qedf->dbg_ctx, "link_up is not set.\n");
575 	}
576 }
577 
578 static void qedf_link_update(void *dev, struct qed_link_output *link)
579 {
580 	struct qedf_ctx *qedf = (struct qedf_ctx *)dev;
581 
582 	/*
583 	 * Prevent race where we're removing the module and we get link update
584 	 * for qed.
585 	 */
586 	if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
587 		QEDF_ERR(&qedf->dbg_ctx,
588 			 "Ignore link update, driver getting unload.\n");
589 		return;
590 	}
591 
592 	if (link->link_up) {
593 		if (atomic_read(&qedf->link_state) == QEDF_LINK_UP) {
594 			QEDF_INFO((&qedf->dbg_ctx), QEDF_LOG_DISC,
595 			    "Ignoring link up event as link is already up.\n");
596 			return;
597 		}
598 		QEDF_ERR(&(qedf->dbg_ctx), "LINK UP (%d GB/s).\n",
599 		    link->speed / 1000);
600 
601 		/* Cancel any pending link down work */
602 		cancel_delayed_work(&qedf->link_update);
603 
604 		atomic_set(&qedf->link_state, QEDF_LINK_UP);
605 		qedf_update_link_speed(qedf, link);
606 
607 		if (atomic_read(&qedf->dcbx) == QEDF_DCBX_DONE ||
608 		    qedf_dcbx_no_wait) {
609 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
610 			     "DCBx done.\n");
611 			if (atomic_read(&qedf->link_down_tmo_valid) > 0)
612 				queue_delayed_work(qedf->link_update_wq,
613 				    &qedf->link_recovery, 0);
614 			else
615 				queue_delayed_work(qedf->link_update_wq,
616 				    &qedf->link_update, 0);
617 			atomic_set(&qedf->link_down_tmo_valid, 0);
618 		}
619 
620 	} else {
621 		QEDF_ERR(&(qedf->dbg_ctx), "LINK DOWN.\n");
622 
623 		atomic_set(&qedf->link_state, QEDF_LINK_DOWN);
624 		atomic_set(&qedf->dcbx, QEDF_DCBX_PENDING);
625 		/*
626 		 * Flag that we're waiting for the link to come back up before
627 		 * informing the fcoe layer of the event.
628 		 */
629 		if (qedf_link_down_tmo > 0) {
630 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
631 			    "Starting link down tmo.\n");
632 			atomic_set(&qedf->link_down_tmo_valid, 1);
633 		}
634 		qedf->vlan_id = 0;
635 		qedf_update_link_speed(qedf, link);
636 		queue_delayed_work(qedf->link_update_wq, &qedf->link_update,
637 		    qedf_link_down_tmo * HZ);
638 	}
639 }
640 
641 
642 static void qedf_dcbx_handler(void *dev, struct qed_dcbx_get *get, u32 mib_type)
643 {
644 	struct qedf_ctx *qedf = (struct qedf_ctx *)dev;
645 	u8 tmp_prio;
646 
647 	QEDF_ERR(&(qedf->dbg_ctx), "DCBx event valid=%d enabled=%d fcoe "
648 	    "prio=%d.\n", get->operational.valid, get->operational.enabled,
649 	    get->operational.app_prio.fcoe);
650 
651 	if (get->operational.enabled && get->operational.valid) {
652 		/* If DCBX was already negotiated on link up then just exit */
653 		if (atomic_read(&qedf->dcbx) == QEDF_DCBX_DONE) {
654 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
655 			    "DCBX already set on link up.\n");
656 			return;
657 		}
658 
659 		atomic_set(&qedf->dcbx, QEDF_DCBX_DONE);
660 
661 		/*
662 		 * Set the 8021q priority in the following manner:
663 		 *
664 		 * 1. If a modparam is set use that
665 		 * 2. If the value is not between 0..7 use the default
666 		 * 3. Use the priority we get from the DCBX app tag
667 		 */
668 		tmp_prio = get->operational.app_prio.fcoe;
669 		if (qedf_default_prio > -1)
670 			qedf->prio = qedf_default_prio;
671 		else if (tmp_prio > 7) {
672 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
673 			    "FIP/FCoE prio %d out of range, setting to %d.\n",
674 			    tmp_prio, QEDF_DEFAULT_PRIO);
675 			qedf->prio = QEDF_DEFAULT_PRIO;
676 		} else
677 			qedf->prio = tmp_prio;
678 
679 		if (atomic_read(&qedf->link_state) == QEDF_LINK_UP &&
680 		    !qedf_dcbx_no_wait) {
681 			if (atomic_read(&qedf->link_down_tmo_valid) > 0)
682 				queue_delayed_work(qedf->link_update_wq,
683 				    &qedf->link_recovery, 0);
684 			else
685 				queue_delayed_work(qedf->link_update_wq,
686 				    &qedf->link_update, 0);
687 			atomic_set(&qedf->link_down_tmo_valid, 0);
688 		}
689 	}
690 
691 }
692 
693 static u32 qedf_get_login_failures(void *cookie)
694 {
695 	struct qedf_ctx *qedf;
696 
697 	qedf = (struct qedf_ctx *)cookie;
698 	return qedf->flogi_failed;
699 }
700 
701 static struct qed_fcoe_cb_ops qedf_cb_ops = {
702 	{
703 		.link_update = qedf_link_update,
704 		.bw_update = qedf_bw_update,
705 		.schedule_recovery_handler = qedf_schedule_recovery_handler,
706 		.dcbx_aen = qedf_dcbx_handler,
707 		.get_generic_tlv_data = qedf_get_generic_tlv_data,
708 		.get_protocol_tlv_data = qedf_get_protocol_tlv_data,
709 		.schedule_hw_err_handler = qedf_schedule_hw_err_handler,
710 	}
711 };
712 
713 /*
714  * Various transport templates.
715  */
716 
717 static struct scsi_transport_template *qedf_fc_transport_template;
718 static struct scsi_transport_template *qedf_fc_vport_transport_template;
719 
720 /*
721  * SCSI EH handlers
722  */
723 static int qedf_eh_abort(struct scsi_cmnd *sc_cmd)
724 {
725 	struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
726 	struct fc_lport *lport;
727 	struct qedf_ctx *qedf;
728 	struct qedf_ioreq *io_req;
729 	struct fc_rport_libfc_priv *rp = rport->dd_data;
730 	struct fc_rport_priv *rdata;
731 	struct qedf_rport *fcport = NULL;
732 	int rc = FAILED;
733 	int wait_count = 100;
734 	int refcount = 0;
735 	int rval;
736 	int got_ref = 0;
737 
738 	lport = shost_priv(sc_cmd->device->host);
739 	qedf = (struct qedf_ctx *)lport_priv(lport);
740 
741 	/* rport and tgt are allocated together, so tgt should be non-NULL */
742 	fcport = (struct qedf_rport *)&rp[1];
743 	rdata = fcport->rdata;
744 	if (!rdata || !kref_get_unless_zero(&rdata->kref)) {
745 		QEDF_ERR(&qedf->dbg_ctx, "stale rport, sc_cmd=%p\n", sc_cmd);
746 		rc = SUCCESS;
747 		goto out;
748 	}
749 
750 
751 	io_req = qedf_priv(sc_cmd)->io_req;
752 	if (!io_req) {
753 		QEDF_ERR(&qedf->dbg_ctx,
754 			 "sc_cmd not queued with lld, sc_cmd=%p op=0x%02x, port_id=%06x\n",
755 			 sc_cmd, sc_cmd->cmnd[0],
756 			 rdata->ids.port_id);
757 		rc = SUCCESS;
758 		goto drop_rdata_kref;
759 	}
760 
761 	rval = kref_get_unless_zero(&io_req->refcount);	/* ID: 005 */
762 	if (rval)
763 		got_ref = 1;
764 
765 	/* If we got a valid io_req, confirm it belongs to this sc_cmd. */
766 	if (!rval || io_req->sc_cmd != sc_cmd) {
767 		QEDF_ERR(&qedf->dbg_ctx,
768 			 "Freed/Incorrect io_req, io_req->sc_cmd=%p, sc_cmd=%p, port_id=%06x, bailing out.\n",
769 			 io_req->sc_cmd, sc_cmd, rdata->ids.port_id);
770 
771 		goto drop_rdata_kref;
772 	}
773 
774 	if (fc_remote_port_chkready(rport)) {
775 		refcount = kref_read(&io_req->refcount);
776 		QEDF_ERR(&qedf->dbg_ctx,
777 			 "rport not ready, io_req=%p, xid=0x%x sc_cmd=%p op=0x%02x, refcount=%d, port_id=%06x\n",
778 			 io_req, io_req->xid, sc_cmd, sc_cmd->cmnd[0],
779 			 refcount, rdata->ids.port_id);
780 
781 		goto drop_rdata_kref;
782 	}
783 
784 	rc = fc_block_rport(rport);
785 	if (rc)
786 		goto drop_rdata_kref;
787 
788 	if (test_bit(QEDF_RPORT_UPLOADING_CONNECTION, &fcport->flags)) {
789 		QEDF_ERR(&qedf->dbg_ctx,
790 			 "Connection uploading, xid=0x%x., port_id=%06x\n",
791 			 io_req->xid, rdata->ids.port_id);
792 		while (io_req->sc_cmd && (wait_count != 0)) {
793 			msleep(100);
794 			wait_count--;
795 		}
796 		if (wait_count) {
797 			QEDF_ERR(&qedf->dbg_ctx, "ABTS succeeded\n");
798 			rc = SUCCESS;
799 		} else {
800 			QEDF_ERR(&qedf->dbg_ctx, "ABTS failed\n");
801 			rc = FAILED;
802 		}
803 		goto drop_rdata_kref;
804 	}
805 
806 	if (lport->state != LPORT_ST_READY || !(lport->link_up)) {
807 		QEDF_ERR(&qedf->dbg_ctx, "link not ready.\n");
808 		goto drop_rdata_kref;
809 	}
810 
811 	QEDF_ERR(&qedf->dbg_ctx,
812 		 "Aborting io_req=%p sc_cmd=%p xid=0x%x fp_idx=%d, port_id=%06x.\n",
813 		 io_req, sc_cmd, io_req->xid, io_req->fp_idx,
814 		 rdata->ids.port_id);
815 
816 	if (qedf->stop_io_on_error) {
817 		qedf_stop_all_io(qedf);
818 		rc = SUCCESS;
819 		goto drop_rdata_kref;
820 	}
821 
822 	init_completion(&io_req->abts_done);
823 	rval = qedf_initiate_abts(io_req, true);
824 	if (rval) {
825 		QEDF_ERR(&(qedf->dbg_ctx), "Failed to queue ABTS.\n");
826 		/*
827 		 * If we fail to queue the ABTS then return this command to
828 		 * the SCSI layer as it will own and free the xid
829 		 */
830 		rc = SUCCESS;
831 		qedf_scsi_done(qedf, io_req, DID_ERROR);
832 		goto drop_rdata_kref;
833 	}
834 
835 	wait_for_completion(&io_req->abts_done);
836 
837 	if (io_req->event == QEDF_IOREQ_EV_ABORT_SUCCESS ||
838 	    io_req->event == QEDF_IOREQ_EV_ABORT_FAILED ||
839 	    io_req->event == QEDF_IOREQ_EV_CLEANUP_SUCCESS) {
840 		/*
841 		 * If we get a reponse to the abort this is success from
842 		 * the perspective that all references to the command have
843 		 * been removed from the driver and firmware
844 		 */
845 		rc = SUCCESS;
846 	} else {
847 		/* If the abort and cleanup failed then return a failure */
848 		rc = FAILED;
849 	}
850 
851 	if (rc == SUCCESS)
852 		QEDF_ERR(&(qedf->dbg_ctx), "ABTS succeeded, xid=0x%x.\n",
853 			  io_req->xid);
854 	else
855 		QEDF_ERR(&(qedf->dbg_ctx), "ABTS failed, xid=0x%x.\n",
856 			  io_req->xid);
857 
858 drop_rdata_kref:
859 	kref_put(&rdata->kref, fc_rport_destroy);
860 out:
861 	if (got_ref)
862 		kref_put(&io_req->refcount, qedf_release_cmd);
863 	return rc;
864 }
865 
866 static int qedf_eh_target_reset(struct scsi_cmnd *sc_cmd)
867 {
868 	struct scsi_target *starget = scsi_target(sc_cmd->device);
869 	struct fc_rport *rport = starget_to_rport(starget);
870 
871 	QEDF_ERR(NULL, "TARGET RESET Issued...");
872 	return qedf_initiate_tmf(rport, 0, FCP_TMF_TGT_RESET);
873 }
874 
875 static int qedf_eh_device_reset(struct scsi_cmnd *sc_cmd)
876 {
877 	struct fc_rport *rport = starget_to_rport(scsi_target(sc_cmd->device));
878 
879 	QEDF_ERR(NULL, "LUN RESET Issued...\n");
880 	return qedf_initiate_tmf(rport, sc_cmd->device->lun, FCP_TMF_LUN_RESET);
881 }
882 
883 bool qedf_wait_for_upload(struct qedf_ctx *qedf)
884 {
885 	struct qedf_rport *fcport;
886 	int wait_cnt = 120;
887 
888 	while (wait_cnt--) {
889 		if (atomic_read(&qedf->num_offloads))
890 			QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
891 				  "Waiting for all uploads to complete num_offloads = 0x%x.\n",
892 				  atomic_read(&qedf->num_offloads));
893 		else
894 			return true;
895 		msleep(500);
896 	}
897 
898 	rcu_read_lock();
899 	list_for_each_entry_rcu(fcport, &qedf->fcports, peers) {
900 		if (test_bit(QEDF_RPORT_SESSION_READY,
901 				       &fcport->flags)) {
902 			if (fcport->rdata)
903 				QEDF_ERR(&qedf->dbg_ctx,
904 					 "Waiting for fcport %p portid=%06x.\n",
905 					 fcport, fcport->rdata->ids.port_id);
906 			} else {
907 				QEDF_ERR(&qedf->dbg_ctx,
908 					 "Waiting for fcport %p.\n", fcport);
909 			}
910 	}
911 
912 	rcu_read_unlock();
913 	return false;
914 }
915 
916 /* Performs soft reset of qedf_ctx by simulating a link down/up */
917 void qedf_ctx_soft_reset(struct fc_lport *lport)
918 {
919 	struct qedf_ctx *qedf;
920 	struct qed_link_output if_link;
921 
922 	qedf = lport_priv(lport);
923 
924 	if (lport->vport) {
925 		clear_bit(QEDF_STAG_IN_PROGRESS, &qedf->flags);
926 		printk_ratelimited("Cannot issue host reset on NPIV port.\n");
927 		return;
928 	}
929 
930 	qedf->flogi_pending = 0;
931 	/* For host reset, essentially do a soft link up/down */
932 	atomic_set(&qedf->link_state, QEDF_LINK_DOWN);
933 	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
934 		  "Queuing link down work.\n");
935 	queue_delayed_work(qedf->link_update_wq, &qedf->link_update,
936 	    0);
937 
938 	if (qedf_wait_for_upload(qedf) == false) {
939 		QEDF_ERR(&qedf->dbg_ctx, "Could not upload all sessions.\n");
940 		WARN_ON(atomic_read(&qedf->num_offloads));
941 	}
942 
943 	/* Before setting link up query physical link state */
944 	qed_ops->common->get_link(qedf->cdev, &if_link);
945 	/* Bail if the physical link is not up */
946 	if (!if_link.link_up) {
947 		QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
948 			  "Physical link is not up.\n");
949 		clear_bit(QEDF_STAG_IN_PROGRESS, &qedf->flags);
950 		return;
951 	}
952 	/* Flush and wait to make sure link down is processed */
953 	flush_delayed_work(&qedf->link_update);
954 	msleep(500);
955 
956 	atomic_set(&qedf->link_state, QEDF_LINK_UP);
957 	qedf->vlan_id  = 0;
958 	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
959 		  "Queue link up work.\n");
960 	queue_delayed_work(qedf->link_update_wq, &qedf->link_update,
961 	    0);
962 	clear_bit(QEDF_STAG_IN_PROGRESS, &qedf->flags);
963 }
964 
965 /* Reset the host by gracefully logging out and then logging back in */
966 static int qedf_eh_host_reset(struct scsi_cmnd *sc_cmd)
967 {
968 	struct fc_lport *lport;
969 	struct qedf_ctx *qedf;
970 
971 	lport = shost_priv(sc_cmd->device->host);
972 	qedf = lport_priv(lport);
973 
974 	if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN ||
975 	    test_bit(QEDF_UNLOADING, &qedf->flags))
976 		return FAILED;
977 
978 	QEDF_ERR(&(qedf->dbg_ctx), "HOST RESET Issued...");
979 
980 	qedf_ctx_soft_reset(lport);
981 
982 	return SUCCESS;
983 }
984 
985 static int qedf_slave_configure(struct scsi_device *sdev)
986 {
987 	if (qedf_queue_depth) {
988 		scsi_change_queue_depth(sdev, qedf_queue_depth);
989 	}
990 
991 	return 0;
992 }
993 
994 static const struct scsi_host_template qedf_host_template = {
995 	.module 	= THIS_MODULE,
996 	.name 		= QEDF_MODULE_NAME,
997 	.this_id 	= -1,
998 	.cmd_per_lun	= 32,
999 	.max_sectors 	= 0xffff,
1000 	.queuecommand 	= qedf_queuecommand,
1001 	.shost_groups	= qedf_host_groups,
1002 	.eh_abort_handler	= qedf_eh_abort,
1003 	.eh_device_reset_handler = qedf_eh_device_reset, /* lun reset */
1004 	.eh_target_reset_handler = qedf_eh_target_reset, /* target reset */
1005 	.eh_host_reset_handler  = qedf_eh_host_reset,
1006 	.slave_configure	= qedf_slave_configure,
1007 	.dma_boundary = QED_HW_DMA_BOUNDARY,
1008 	.sg_tablesize = QEDF_MAX_BDS_PER_CMD,
1009 	.can_queue = FCOE_PARAMS_NUM_TASKS,
1010 	.change_queue_depth = scsi_change_queue_depth,
1011 	.cmd_size = sizeof(struct qedf_cmd_priv),
1012 };
1013 
1014 static int qedf_get_paged_crc_eof(struct sk_buff *skb, int tlen)
1015 {
1016 	int rc;
1017 
1018 	spin_lock(&qedf_global_lock);
1019 	rc = fcoe_get_paged_crc_eof(skb, tlen, &qedf_global);
1020 	spin_unlock(&qedf_global_lock);
1021 
1022 	return rc;
1023 }
1024 
1025 static struct qedf_rport *qedf_fcport_lookup(struct qedf_ctx *qedf, u32 port_id)
1026 {
1027 	struct qedf_rport *fcport;
1028 	struct fc_rport_priv *rdata;
1029 
1030 	rcu_read_lock();
1031 	list_for_each_entry_rcu(fcport, &qedf->fcports, peers) {
1032 		rdata = fcport->rdata;
1033 		if (rdata == NULL)
1034 			continue;
1035 		if (rdata->ids.port_id == port_id) {
1036 			rcu_read_unlock();
1037 			return fcport;
1038 		}
1039 	}
1040 	rcu_read_unlock();
1041 
1042 	/* Return NULL to caller to let them know fcport was not found */
1043 	return NULL;
1044 }
1045 
1046 /* Transmits an ELS frame over an offloaded session */
1047 static int qedf_xmit_l2_frame(struct qedf_rport *fcport, struct fc_frame *fp)
1048 {
1049 	struct fc_frame_header *fh;
1050 	int rc = 0;
1051 
1052 	fh = fc_frame_header_get(fp);
1053 	if ((fh->fh_type == FC_TYPE_ELS) &&
1054 	    (fh->fh_r_ctl == FC_RCTL_ELS_REQ)) {
1055 		switch (fc_frame_payload_op(fp)) {
1056 		case ELS_ADISC:
1057 			qedf_send_adisc(fcport, fp);
1058 			rc = 1;
1059 			break;
1060 		}
1061 	}
1062 
1063 	return rc;
1064 }
1065 
1066 /*
1067  * qedf_xmit - qedf FCoE frame transmit function
1068  */
1069 static int qedf_xmit(struct fc_lport *lport, struct fc_frame *fp)
1070 {
1071 	struct fc_lport		*base_lport;
1072 	struct qedf_ctx		*qedf;
1073 	struct ethhdr		*eh;
1074 	struct fcoe_crc_eof	*cp;
1075 	struct sk_buff		*skb;
1076 	struct fc_frame_header	*fh;
1077 	struct fcoe_hdr		*hp;
1078 	u8			sof, eof;
1079 	u32			crc;
1080 	unsigned int		hlen, tlen, elen;
1081 	int			wlen;
1082 	struct fc_lport *tmp_lport;
1083 	struct fc_lport *vn_port = NULL;
1084 	struct qedf_rport *fcport;
1085 	int rc;
1086 	u16 vlan_tci = 0;
1087 
1088 	qedf = (struct qedf_ctx *)lport_priv(lport);
1089 
1090 	fh = fc_frame_header_get(fp);
1091 	skb = fp_skb(fp);
1092 
1093 	/* Filter out traffic to other NPIV ports on the same host */
1094 	if (lport->vport)
1095 		base_lport = shost_priv(vport_to_shost(lport->vport));
1096 	else
1097 		base_lport = lport;
1098 
1099 	/* Flag if the destination is the base port */
1100 	if (base_lport->port_id == ntoh24(fh->fh_d_id)) {
1101 		vn_port = base_lport;
1102 	} else {
1103 		/* Got through the list of vports attached to the base_lport
1104 		 * and see if we have a match with the destination address.
1105 		 */
1106 		list_for_each_entry(tmp_lport, &base_lport->vports, list) {
1107 			if (tmp_lport->port_id == ntoh24(fh->fh_d_id)) {
1108 				vn_port = tmp_lport;
1109 				break;
1110 			}
1111 		}
1112 	}
1113 	if (vn_port && ntoh24(fh->fh_d_id) != FC_FID_FLOGI) {
1114 		struct fc_rport_priv *rdata = NULL;
1115 
1116 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
1117 		    "Dropping FCoE frame to %06x.\n", ntoh24(fh->fh_d_id));
1118 		kfree_skb(skb);
1119 		rdata = fc_rport_lookup(lport, ntoh24(fh->fh_d_id));
1120 		if (rdata) {
1121 			rdata->retries = lport->max_rport_retry_count;
1122 			kref_put(&rdata->kref, fc_rport_destroy);
1123 		}
1124 		return -EINVAL;
1125 	}
1126 	/* End NPIV filtering */
1127 
1128 	if (!qedf->ctlr.sel_fcf) {
1129 		kfree_skb(skb);
1130 		return 0;
1131 	}
1132 
1133 	if (!test_bit(QEDF_LL2_STARTED, &qedf->flags)) {
1134 		QEDF_WARN(&(qedf->dbg_ctx), "LL2 not started\n");
1135 		kfree_skb(skb);
1136 		return 0;
1137 	}
1138 
1139 	if (atomic_read(&qedf->link_state) != QEDF_LINK_UP) {
1140 		QEDF_WARN(&(qedf->dbg_ctx), "qedf link down\n");
1141 		kfree_skb(skb);
1142 		return 0;
1143 	}
1144 
1145 	if (unlikely(fh->fh_r_ctl == FC_RCTL_ELS_REQ)) {
1146 		if (fcoe_ctlr_els_send(&qedf->ctlr, lport, skb))
1147 			return 0;
1148 	}
1149 
1150 	/* Check to see if this needs to be sent on an offloaded session */
1151 	fcport = qedf_fcport_lookup(qedf, ntoh24(fh->fh_d_id));
1152 
1153 	if (fcport && test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
1154 		rc = qedf_xmit_l2_frame(fcport, fp);
1155 		/*
1156 		 * If the frame was successfully sent over the middle path
1157 		 * then do not try to also send it over the LL2 path
1158 		 */
1159 		if (rc)
1160 			return 0;
1161 	}
1162 
1163 	sof = fr_sof(fp);
1164 	eof = fr_eof(fp);
1165 
1166 	elen = sizeof(struct ethhdr);
1167 	hlen = sizeof(struct fcoe_hdr);
1168 	tlen = sizeof(struct fcoe_crc_eof);
1169 	wlen = (skb->len - tlen + sizeof(crc)) / FCOE_WORD_TO_BYTE;
1170 
1171 	skb->ip_summed = CHECKSUM_NONE;
1172 	crc = fcoe_fc_crc(fp);
1173 
1174 	/* copy port crc and eof to the skb buff */
1175 	if (skb_is_nonlinear(skb)) {
1176 		skb_frag_t *frag;
1177 
1178 		if (qedf_get_paged_crc_eof(skb, tlen)) {
1179 			kfree_skb(skb);
1180 			return -ENOMEM;
1181 		}
1182 		frag = &skb_shinfo(skb)->frags[skb_shinfo(skb)->nr_frags - 1];
1183 		cp = kmap_atomic(skb_frag_page(frag)) + skb_frag_off(frag);
1184 	} else {
1185 		cp = skb_put(skb, tlen);
1186 	}
1187 
1188 	memset(cp, 0, sizeof(*cp));
1189 	cp->fcoe_eof = eof;
1190 	cp->fcoe_crc32 = cpu_to_le32(~crc);
1191 	if (skb_is_nonlinear(skb)) {
1192 		kunmap_atomic(cp);
1193 		cp = NULL;
1194 	}
1195 
1196 
1197 	/* adjust skb network/transport offsets to match mac/fcoe/port */
1198 	skb_push(skb, elen + hlen);
1199 	skb_reset_mac_header(skb);
1200 	skb_reset_network_header(skb);
1201 	skb->mac_len = elen;
1202 	skb->protocol = htons(ETH_P_FCOE);
1203 
1204 	/*
1205 	 * Add VLAN tag to non-offload FCoE frame based on current stored VLAN
1206 	 * for FIP/FCoE traffic.
1207 	 */
1208 	__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), qedf->vlan_id);
1209 
1210 	/* fill up mac and fcoe headers */
1211 	eh = eth_hdr(skb);
1212 	eh->h_proto = htons(ETH_P_FCOE);
1213 	if (qedf->ctlr.map_dest)
1214 		fc_fcoe_set_mac(eh->h_dest, fh->fh_d_id);
1215 	else
1216 		/* insert GW address */
1217 		ether_addr_copy(eh->h_dest, qedf->ctlr.dest_addr);
1218 
1219 	/* Set the source MAC address */
1220 	ether_addr_copy(eh->h_source, qedf->data_src_addr);
1221 
1222 	hp = (struct fcoe_hdr *)(eh + 1);
1223 	memset(hp, 0, sizeof(*hp));
1224 	if (FC_FCOE_VER)
1225 		FC_FCOE_ENCAPS_VER(hp, FC_FCOE_VER);
1226 	hp->fcoe_sof = sof;
1227 
1228 	/*update tx stats */
1229 	this_cpu_inc(lport->stats->TxFrames);
1230 	this_cpu_add(lport->stats->TxWords, wlen);
1231 
1232 	/* Get VLAN ID from skb for printing purposes */
1233 	__vlan_hwaccel_get_tag(skb, &vlan_tci);
1234 
1235 	/* send down to lld */
1236 	fr_dev(fp) = lport;
1237 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, "FCoE frame send: "
1238 	    "src=%06x dest=%06x r_ctl=%x type=%x vlan=%04x.\n",
1239 	    ntoh24(fh->fh_s_id), ntoh24(fh->fh_d_id), fh->fh_r_ctl, fh->fh_type,
1240 	    vlan_tci);
1241 	if (qedf_dump_frames)
1242 		print_hex_dump(KERN_WARNING, "fcoe: ", DUMP_PREFIX_OFFSET, 16,
1243 		    1, skb->data, skb->len, false);
1244 	rc = qed_ops->ll2->start_xmit(qedf->cdev, skb, 0);
1245 	if (rc) {
1246 		QEDF_ERR(&qedf->dbg_ctx, "start_xmit failed rc = %d.\n", rc);
1247 		kfree_skb(skb);
1248 		return rc;
1249 	}
1250 
1251 	return 0;
1252 }
1253 
1254 static int qedf_alloc_sq(struct qedf_ctx *qedf, struct qedf_rport *fcport)
1255 {
1256 	int rval = 0;
1257 	u32 *pbl;
1258 	dma_addr_t page;
1259 	int num_pages;
1260 
1261 	/* Calculate appropriate queue and PBL sizes */
1262 	fcport->sq_mem_size = SQ_NUM_ENTRIES * sizeof(struct fcoe_wqe);
1263 	fcport->sq_mem_size = ALIGN(fcport->sq_mem_size, QEDF_PAGE_SIZE);
1264 	fcport->sq_pbl_size = (fcport->sq_mem_size / QEDF_PAGE_SIZE) *
1265 	    sizeof(void *);
1266 	fcport->sq_pbl_size = fcport->sq_pbl_size + QEDF_PAGE_SIZE;
1267 
1268 	fcport->sq = dma_alloc_coherent(&qedf->pdev->dev, fcport->sq_mem_size,
1269 					&fcport->sq_dma, GFP_KERNEL);
1270 	if (!fcport->sq) {
1271 		QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate send queue.\n");
1272 		rval = 1;
1273 		goto out;
1274 	}
1275 
1276 	fcport->sq_pbl = dma_alloc_coherent(&qedf->pdev->dev,
1277 					    fcport->sq_pbl_size,
1278 					    &fcport->sq_pbl_dma, GFP_KERNEL);
1279 	if (!fcport->sq_pbl) {
1280 		QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate send queue PBL.\n");
1281 		rval = 1;
1282 		goto out_free_sq;
1283 	}
1284 
1285 	/* Create PBL */
1286 	num_pages = fcport->sq_mem_size / QEDF_PAGE_SIZE;
1287 	page = fcport->sq_dma;
1288 	pbl = (u32 *)fcport->sq_pbl;
1289 
1290 	while (num_pages--) {
1291 		*pbl = U64_LO(page);
1292 		pbl++;
1293 		*pbl = U64_HI(page);
1294 		pbl++;
1295 		page += QEDF_PAGE_SIZE;
1296 	}
1297 
1298 	return rval;
1299 
1300 out_free_sq:
1301 	dma_free_coherent(&qedf->pdev->dev, fcport->sq_mem_size, fcport->sq,
1302 	    fcport->sq_dma);
1303 out:
1304 	return rval;
1305 }
1306 
1307 static void qedf_free_sq(struct qedf_ctx *qedf, struct qedf_rport *fcport)
1308 {
1309 	if (fcport->sq_pbl)
1310 		dma_free_coherent(&qedf->pdev->dev, fcport->sq_pbl_size,
1311 		    fcport->sq_pbl, fcport->sq_pbl_dma);
1312 	if (fcport->sq)
1313 		dma_free_coherent(&qedf->pdev->dev, fcport->sq_mem_size,
1314 		    fcport->sq, fcport->sq_dma);
1315 }
1316 
1317 static int qedf_offload_connection(struct qedf_ctx *qedf,
1318 	struct qedf_rport *fcport)
1319 {
1320 	struct qed_fcoe_params_offload conn_info;
1321 	u32 port_id;
1322 	int rval;
1323 	uint16_t total_sqe = (fcport->sq_mem_size / sizeof(struct fcoe_wqe));
1324 
1325 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Offloading connection "
1326 		   "portid=%06x.\n", fcport->rdata->ids.port_id);
1327 	rval = qed_ops->acquire_conn(qedf->cdev, &fcport->handle,
1328 	    &fcport->fw_cid, &fcport->p_doorbell);
1329 	if (rval) {
1330 		QEDF_WARN(&(qedf->dbg_ctx), "Could not acquire connection "
1331 			   "for portid=%06x.\n", fcport->rdata->ids.port_id);
1332 		rval = 1; /* For some reason qed returns 0 on failure here */
1333 		goto out;
1334 	}
1335 
1336 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "portid=%06x "
1337 		   "fw_cid=%08x handle=%d.\n", fcport->rdata->ids.port_id,
1338 		   fcport->fw_cid, fcport->handle);
1339 
1340 	memset(&conn_info, 0, sizeof(struct qed_fcoe_params_offload));
1341 
1342 	/* Fill in the offload connection info */
1343 	conn_info.sq_pbl_addr = fcport->sq_pbl_dma;
1344 
1345 	conn_info.sq_curr_page_addr = (dma_addr_t)(*(u64 *)fcport->sq_pbl);
1346 	conn_info.sq_next_page_addr =
1347 	    (dma_addr_t)(*(u64 *)(fcport->sq_pbl + 8));
1348 
1349 	/* Need to use our FCoE MAC for the offload session */
1350 	ether_addr_copy(conn_info.src_mac, qedf->data_src_addr);
1351 
1352 	ether_addr_copy(conn_info.dst_mac, qedf->ctlr.dest_addr);
1353 
1354 	conn_info.tx_max_fc_pay_len = fcport->rdata->maxframe_size;
1355 	conn_info.e_d_tov_timer_val = qedf->lport->e_d_tov;
1356 	conn_info.rec_tov_timer_val = 3; /* I think this is what E3 was */
1357 	conn_info.rx_max_fc_pay_len = fcport->rdata->maxframe_size;
1358 
1359 	/* Set VLAN data */
1360 	conn_info.vlan_tag = qedf->vlan_id <<
1361 	    FCOE_CONN_OFFLOAD_RAMROD_DATA_VLAN_ID_SHIFT;
1362 	conn_info.vlan_tag |=
1363 	    qedf->prio << FCOE_CONN_OFFLOAD_RAMROD_DATA_PRIORITY_SHIFT;
1364 	conn_info.flags |= (FCOE_CONN_OFFLOAD_RAMROD_DATA_B_VLAN_FLAG_MASK <<
1365 	    FCOE_CONN_OFFLOAD_RAMROD_DATA_B_VLAN_FLAG_SHIFT);
1366 
1367 	/* Set host port source id */
1368 	port_id = fc_host_port_id(qedf->lport->host);
1369 	fcport->sid = port_id;
1370 	conn_info.s_id.addr_hi = (port_id & 0x000000FF);
1371 	conn_info.s_id.addr_mid = (port_id & 0x0000FF00) >> 8;
1372 	conn_info.s_id.addr_lo = (port_id & 0x00FF0000) >> 16;
1373 
1374 	conn_info.max_conc_seqs_c3 = fcport->rdata->max_seq;
1375 
1376 	/* Set remote port destination id */
1377 	port_id = fcport->rdata->rport->port_id;
1378 	conn_info.d_id.addr_hi = (port_id & 0x000000FF);
1379 	conn_info.d_id.addr_mid = (port_id & 0x0000FF00) >> 8;
1380 	conn_info.d_id.addr_lo = (port_id & 0x00FF0000) >> 16;
1381 
1382 	conn_info.def_q_idx = 0; /* Default index for send queue? */
1383 
1384 	/* Set FC-TAPE specific flags if needed */
1385 	if (fcport->dev_type == QEDF_RPORT_TYPE_TAPE) {
1386 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN,
1387 		    "Enable CONF, REC for portid=%06x.\n",
1388 		    fcport->rdata->ids.port_id);
1389 		conn_info.flags |= 1 <<
1390 		    FCOE_CONN_OFFLOAD_RAMROD_DATA_B_CONF_REQ_SHIFT;
1391 		conn_info.flags |=
1392 		    ((fcport->rdata->sp_features & FC_SP_FT_SEQC) ? 1 : 0) <<
1393 		    FCOE_CONN_OFFLOAD_RAMROD_DATA_B_REC_VALID_SHIFT;
1394 	}
1395 
1396 	rval = qed_ops->offload_conn(qedf->cdev, fcport->handle, &conn_info);
1397 	if (rval) {
1398 		QEDF_WARN(&(qedf->dbg_ctx), "Could not offload connection "
1399 			   "for portid=%06x.\n", fcport->rdata->ids.port_id);
1400 		goto out_free_conn;
1401 	} else
1402 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Offload "
1403 			   "succeeded portid=%06x total_sqe=%d.\n",
1404 			   fcport->rdata->ids.port_id, total_sqe);
1405 
1406 	spin_lock_init(&fcport->rport_lock);
1407 	atomic_set(&fcport->free_sqes, total_sqe);
1408 	return 0;
1409 out_free_conn:
1410 	qed_ops->release_conn(qedf->cdev, fcport->handle);
1411 out:
1412 	return rval;
1413 }
1414 
1415 #define QEDF_TERM_BUFF_SIZE		10
1416 static void qedf_upload_connection(struct qedf_ctx *qedf,
1417 	struct qedf_rport *fcport)
1418 {
1419 	void *term_params;
1420 	dma_addr_t term_params_dma;
1421 
1422 	/* Term params needs to be a DMA coherent buffer as qed shared the
1423 	 * physical DMA address with the firmware. The buffer may be used in
1424 	 * the receive path so we may eventually have to move this.
1425 	 */
1426 	term_params = dma_alloc_coherent(&qedf->pdev->dev, QEDF_TERM_BUFF_SIZE,
1427 		&term_params_dma, GFP_KERNEL);
1428 	if (!term_params)
1429 		return;
1430 
1431 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Uploading connection "
1432 		   "port_id=%06x.\n", fcport->rdata->ids.port_id);
1433 
1434 	qed_ops->destroy_conn(qedf->cdev, fcport->handle, term_params_dma);
1435 	qed_ops->release_conn(qedf->cdev, fcport->handle);
1436 
1437 	dma_free_coherent(&qedf->pdev->dev, QEDF_TERM_BUFF_SIZE, term_params,
1438 	    term_params_dma);
1439 }
1440 
1441 static void qedf_cleanup_fcport(struct qedf_ctx *qedf,
1442 	struct qedf_rport *fcport)
1443 {
1444 	struct fc_rport_priv *rdata = fcport->rdata;
1445 
1446 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_CONN, "Cleaning up portid=%06x.\n",
1447 	    fcport->rdata->ids.port_id);
1448 
1449 	/* Flush any remaining i/o's before we upload the connection */
1450 	qedf_flush_active_ios(fcport, -1);
1451 
1452 	if (test_and_clear_bit(QEDF_RPORT_SESSION_READY, &fcport->flags))
1453 		qedf_upload_connection(qedf, fcport);
1454 	qedf_free_sq(qedf, fcport);
1455 	fcport->rdata = NULL;
1456 	fcport->qedf = NULL;
1457 	kref_put(&rdata->kref, fc_rport_destroy);
1458 }
1459 
1460 /*
1461  * This event_callback is called after successful completion of libfc
1462  * initiated target login. qedf can proceed with initiating the session
1463  * establishment.
1464  */
1465 static void qedf_rport_event_handler(struct fc_lport *lport,
1466 				struct fc_rport_priv *rdata,
1467 				enum fc_rport_event event)
1468 {
1469 	struct qedf_ctx *qedf = lport_priv(lport);
1470 	struct fc_rport *rport = rdata->rport;
1471 	struct fc_rport_libfc_priv *rp;
1472 	struct qedf_rport *fcport;
1473 	u32 port_id;
1474 	int rval;
1475 	unsigned long flags;
1476 
1477 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "event = %d, "
1478 		   "port_id = 0x%x\n", event, rdata->ids.port_id);
1479 
1480 	switch (event) {
1481 	case RPORT_EV_READY:
1482 		if (!rport) {
1483 			QEDF_WARN(&(qedf->dbg_ctx), "rport is NULL.\n");
1484 			break;
1485 		}
1486 
1487 		rp = rport->dd_data;
1488 		fcport = (struct qedf_rport *)&rp[1];
1489 		fcport->qedf = qedf;
1490 
1491 		if (atomic_read(&qedf->num_offloads) >= QEDF_MAX_SESSIONS) {
1492 			QEDF_ERR(&(qedf->dbg_ctx), "Not offloading "
1493 			    "portid=0x%x as max number of offloaded sessions "
1494 			    "reached.\n", rdata->ids.port_id);
1495 			return;
1496 		}
1497 
1498 		/*
1499 		 * Don't try to offload the session again. Can happen when we
1500 		 * get an ADISC
1501 		 */
1502 		if (test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
1503 			QEDF_WARN(&(qedf->dbg_ctx), "Session already "
1504 				   "offloaded, portid=0x%x.\n",
1505 				   rdata->ids.port_id);
1506 			return;
1507 		}
1508 
1509 		if (rport->port_id == FC_FID_DIR_SERV) {
1510 			/*
1511 			 * qedf_rport structure doesn't exist for
1512 			 * directory server.
1513 			 * We should not come here, as lport will
1514 			 * take care of fabric login
1515 			 */
1516 			QEDF_WARN(&(qedf->dbg_ctx), "rport struct does not "
1517 			    "exist for dir server port_id=%x\n",
1518 			    rdata->ids.port_id);
1519 			break;
1520 		}
1521 
1522 		if (rdata->spp_type != FC_TYPE_FCP) {
1523 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1524 			    "Not offloading since spp type isn't FCP\n");
1525 			break;
1526 		}
1527 		if (!(rdata->ids.roles & FC_RPORT_ROLE_FCP_TARGET)) {
1528 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1529 			    "Not FCP target so not offloading\n");
1530 			break;
1531 		}
1532 
1533 		/* Initial reference held on entry, so this can't fail */
1534 		kref_get(&rdata->kref);
1535 		fcport->rdata = rdata;
1536 		fcport->rport = rport;
1537 
1538 		rval = qedf_alloc_sq(qedf, fcport);
1539 		if (rval) {
1540 			qedf_cleanup_fcport(qedf, fcport);
1541 			break;
1542 		}
1543 
1544 		/* Set device type */
1545 		if (rdata->flags & FC_RP_FLAGS_RETRY &&
1546 		    rdata->ids.roles & FC_RPORT_ROLE_FCP_TARGET &&
1547 		    !(rdata->ids.roles & FC_RPORT_ROLE_FCP_INITIATOR)) {
1548 			fcport->dev_type = QEDF_RPORT_TYPE_TAPE;
1549 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1550 			    "portid=%06x is a TAPE device.\n",
1551 			    rdata->ids.port_id);
1552 		} else {
1553 			fcport->dev_type = QEDF_RPORT_TYPE_DISK;
1554 		}
1555 
1556 		rval = qedf_offload_connection(qedf, fcport);
1557 		if (rval) {
1558 			qedf_cleanup_fcport(qedf, fcport);
1559 			break;
1560 		}
1561 
1562 		/* Add fcport to list of qedf_ctx list of offloaded ports */
1563 		spin_lock_irqsave(&qedf->hba_lock, flags);
1564 		list_add_rcu(&fcport->peers, &qedf->fcports);
1565 		spin_unlock_irqrestore(&qedf->hba_lock, flags);
1566 
1567 		/*
1568 		 * Set the session ready bit to let everyone know that this
1569 		 * connection is ready for I/O
1570 		 */
1571 		set_bit(QEDF_RPORT_SESSION_READY, &fcport->flags);
1572 		atomic_inc(&qedf->num_offloads);
1573 
1574 		break;
1575 	case RPORT_EV_LOGO:
1576 	case RPORT_EV_FAILED:
1577 	case RPORT_EV_STOP:
1578 		port_id = rdata->ids.port_id;
1579 		if (port_id == FC_FID_DIR_SERV)
1580 			break;
1581 
1582 		if (rdata->spp_type != FC_TYPE_FCP) {
1583 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1584 			    "No action since spp type isn't FCP\n");
1585 			break;
1586 		}
1587 		if (!(rdata->ids.roles & FC_RPORT_ROLE_FCP_TARGET)) {
1588 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1589 			    "Not FCP target so no action\n");
1590 			break;
1591 		}
1592 
1593 		if (!rport) {
1594 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
1595 			    "port_id=%x - rport notcreated Yet!!\n", port_id);
1596 			break;
1597 		}
1598 		rp = rport->dd_data;
1599 		/*
1600 		 * Perform session upload. Note that rdata->peers is already
1601 		 * removed from disc->rports list before we get this event.
1602 		 */
1603 		fcport = (struct qedf_rport *)&rp[1];
1604 
1605 		spin_lock_irqsave(&fcport->rport_lock, flags);
1606 		/* Only free this fcport if it is offloaded already */
1607 		if (test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags) &&
1608 		    !test_bit(QEDF_RPORT_UPLOADING_CONNECTION,
1609 		    &fcport->flags)) {
1610 			set_bit(QEDF_RPORT_UPLOADING_CONNECTION,
1611 				&fcport->flags);
1612 			spin_unlock_irqrestore(&fcport->rport_lock, flags);
1613 			qedf_cleanup_fcport(qedf, fcport);
1614 			/*
1615 			 * Remove fcport to list of qedf_ctx list of offloaded
1616 			 * ports
1617 			 */
1618 			spin_lock_irqsave(&qedf->hba_lock, flags);
1619 			list_del_rcu(&fcport->peers);
1620 			spin_unlock_irqrestore(&qedf->hba_lock, flags);
1621 
1622 			clear_bit(QEDF_RPORT_UPLOADING_CONNECTION,
1623 			    &fcport->flags);
1624 			atomic_dec(&qedf->num_offloads);
1625 		} else {
1626 			spin_unlock_irqrestore(&fcport->rport_lock, flags);
1627 		}
1628 		break;
1629 
1630 	case RPORT_EV_NONE:
1631 		break;
1632 	}
1633 }
1634 
1635 static void qedf_abort_io(struct fc_lport *lport)
1636 {
1637 	/* NO-OP but need to fill in the template */
1638 }
1639 
1640 static void qedf_fcp_cleanup(struct fc_lport *lport)
1641 {
1642 	/*
1643 	 * NO-OP but need to fill in template to prevent a NULL
1644 	 * function pointer dereference during link down. I/Os
1645 	 * will be flushed when port is uploaded.
1646 	 */
1647 }
1648 
1649 static struct libfc_function_template qedf_lport_template = {
1650 	.frame_send		= qedf_xmit,
1651 	.fcp_abort_io		= qedf_abort_io,
1652 	.fcp_cleanup		= qedf_fcp_cleanup,
1653 	.rport_event_callback	= qedf_rport_event_handler,
1654 	.elsct_send		= qedf_elsct_send,
1655 };
1656 
1657 static void qedf_fcoe_ctlr_setup(struct qedf_ctx *qedf)
1658 {
1659 	fcoe_ctlr_init(&qedf->ctlr, FIP_MODE_AUTO);
1660 
1661 	qedf->ctlr.send = qedf_fip_send;
1662 	qedf->ctlr.get_src_addr = qedf_get_src_mac;
1663 	ether_addr_copy(qedf->ctlr.ctl_src_addr, qedf->mac);
1664 }
1665 
1666 static void qedf_setup_fdmi(struct qedf_ctx *qedf)
1667 {
1668 	struct fc_lport *lport = qedf->lport;
1669 	u8 buf[8];
1670 	int pos;
1671 	uint32_t i;
1672 
1673 	/*
1674 	 * fdmi_enabled needs to be set for libfc
1675 	 * to execute FDMI registration
1676 	 */
1677 	lport->fdmi_enabled = 1;
1678 
1679 	/*
1680 	 * Setup the necessary fc_host attributes to that will be used to fill
1681 	 * in the FDMI information.
1682 	 */
1683 
1684 	/* Get the PCI-e Device Serial Number Capability */
1685 	pos = pci_find_ext_capability(qedf->pdev, PCI_EXT_CAP_ID_DSN);
1686 	if (pos) {
1687 		pos += 4;
1688 		for (i = 0; i < 8; i++)
1689 			pci_read_config_byte(qedf->pdev, pos + i, &buf[i]);
1690 
1691 		snprintf(fc_host_serial_number(lport->host),
1692 		    FC_SERIAL_NUMBER_SIZE,
1693 		    "%02X%02X%02X%02X%02X%02X%02X%02X",
1694 		    buf[7], buf[6], buf[5], buf[4],
1695 		    buf[3], buf[2], buf[1], buf[0]);
1696 	} else
1697 		snprintf(fc_host_serial_number(lport->host),
1698 		    FC_SERIAL_NUMBER_SIZE, "Unknown");
1699 
1700 	snprintf(fc_host_manufacturer(lport->host),
1701 	    FC_SERIAL_NUMBER_SIZE, "%s", "Marvell Semiconductor Inc.");
1702 
1703 	if (qedf->pdev->device == QL45xxx) {
1704 		snprintf(fc_host_model(lport->host),
1705 			FC_SYMBOLIC_NAME_SIZE, "%s", "QL45xxx");
1706 
1707 		snprintf(fc_host_model_description(lport->host),
1708 			FC_SYMBOLIC_NAME_SIZE, "%s",
1709 			"Marvell FastLinQ QL45xxx FCoE Adapter");
1710 	}
1711 
1712 	if (qedf->pdev->device == QL41xxx) {
1713 		snprintf(fc_host_model(lport->host),
1714 			FC_SYMBOLIC_NAME_SIZE, "%s", "QL41xxx");
1715 
1716 		snprintf(fc_host_model_description(lport->host),
1717 			FC_SYMBOLIC_NAME_SIZE, "%s",
1718 			"Marvell FastLinQ QL41xxx FCoE Adapter");
1719 	}
1720 
1721 	snprintf(fc_host_hardware_version(lport->host),
1722 	    FC_VERSION_STRING_SIZE, "Rev %d", qedf->pdev->revision);
1723 
1724 	snprintf(fc_host_driver_version(lport->host),
1725 	    FC_VERSION_STRING_SIZE, "%s", QEDF_VERSION);
1726 
1727 	snprintf(fc_host_firmware_version(lport->host),
1728 	    FC_VERSION_STRING_SIZE, "%d.%d.%d.%d",
1729 	    FW_MAJOR_VERSION, FW_MINOR_VERSION, FW_REVISION_VERSION,
1730 	    FW_ENGINEERING_VERSION);
1731 
1732 	snprintf(fc_host_vendor_identifier(lport->host),
1733 		FC_VENDOR_IDENTIFIER, "%s", "Marvell");
1734 
1735 }
1736 
1737 static int qedf_lport_setup(struct qedf_ctx *qedf)
1738 {
1739 	struct fc_lport *lport = qedf->lport;
1740 
1741 	lport->link_up = 0;
1742 	lport->max_retry_count = QEDF_FLOGI_RETRY_CNT;
1743 	lport->max_rport_retry_count = QEDF_RPORT_RETRY_CNT;
1744 	lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
1745 	    FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
1746 	lport->boot_time = jiffies;
1747 	lport->e_d_tov = 2 * 1000;
1748 	lport->r_a_tov = 10 * 1000;
1749 
1750 	/* Set NPIV support */
1751 	lport->does_npiv = 1;
1752 	fc_host_max_npiv_vports(lport->host) = QEDF_MAX_NPIV;
1753 
1754 	fc_set_wwnn(lport, qedf->wwnn);
1755 	fc_set_wwpn(lport, qedf->wwpn);
1756 
1757 	if (fcoe_libfc_config(lport, &qedf->ctlr, &qedf_lport_template, 0)) {
1758 		QEDF_ERR(&qedf->dbg_ctx,
1759 			 "fcoe_libfc_config failed.\n");
1760 		return -ENOMEM;
1761 	}
1762 
1763 	/* Allocate the exchange manager */
1764 	fc_exch_mgr_alloc(lport, FC_CLASS_3, FCOE_PARAMS_NUM_TASKS,
1765 			  0xfffe, NULL);
1766 
1767 	if (fc_lport_init_stats(lport))
1768 		return -ENOMEM;
1769 
1770 	/* Finish lport config */
1771 	fc_lport_config(lport);
1772 
1773 	/* Set max frame size */
1774 	fc_set_mfs(lport, QEDF_MFS);
1775 	fc_host_maxframe_size(lport->host) = lport->mfs;
1776 
1777 	/* Set default dev_loss_tmo based on module parameter */
1778 	fc_host_dev_loss_tmo(lport->host) = qedf_dev_loss_tmo;
1779 
1780 	/* Set symbolic node name */
1781 	if (qedf->pdev->device == QL45xxx)
1782 		snprintf(fc_host_symbolic_name(lport->host), 256,
1783 			"Marvell FastLinQ 45xxx FCoE v%s", QEDF_VERSION);
1784 
1785 	if (qedf->pdev->device == QL41xxx)
1786 		snprintf(fc_host_symbolic_name(lport->host), 256,
1787 			"Marvell FastLinQ 41xxx FCoE v%s", QEDF_VERSION);
1788 
1789 	qedf_setup_fdmi(qedf);
1790 
1791 	return 0;
1792 }
1793 
1794 /*
1795  * NPIV functions
1796  */
1797 
1798 static int qedf_vport_libfc_config(struct fc_vport *vport,
1799 	struct fc_lport *lport)
1800 {
1801 	lport->link_up = 0;
1802 	lport->qfull = 0;
1803 	lport->max_retry_count = QEDF_FLOGI_RETRY_CNT;
1804 	lport->max_rport_retry_count = QEDF_RPORT_RETRY_CNT;
1805 	lport->service_params = (FCP_SPPF_INIT_FCN | FCP_SPPF_RD_XRDY_DIS |
1806 	    FCP_SPPF_RETRY | FCP_SPPF_CONF_COMPL);
1807 	lport->boot_time = jiffies;
1808 	lport->e_d_tov = 2 * 1000;
1809 	lport->r_a_tov = 10 * 1000;
1810 	lport->does_npiv = 1; /* Temporary until we add NPIV support */
1811 
1812 	/* Allocate stats for vport */
1813 	if (fc_lport_init_stats(lport))
1814 		return -ENOMEM;
1815 
1816 	/* Finish lport config */
1817 	fc_lport_config(lport);
1818 
1819 	/* offload related configuration */
1820 	lport->crc_offload = 0;
1821 	lport->seq_offload = 0;
1822 	lport->lro_enabled = 0;
1823 	lport->lro_xid = 0;
1824 	lport->lso_max = 0;
1825 
1826 	return 0;
1827 }
1828 
1829 static int qedf_vport_create(struct fc_vport *vport, bool disabled)
1830 {
1831 	struct Scsi_Host *shost = vport_to_shost(vport);
1832 	struct fc_lport *n_port = shost_priv(shost);
1833 	struct fc_lport *vn_port;
1834 	struct qedf_ctx *base_qedf = lport_priv(n_port);
1835 	struct qedf_ctx *vport_qedf;
1836 
1837 	char buf[32];
1838 	int rc = 0;
1839 
1840 	rc = fcoe_validate_vport_create(vport);
1841 	if (rc) {
1842 		fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
1843 		QEDF_WARN(&(base_qedf->dbg_ctx), "Failed to create vport, "
1844 			   "WWPN (0x%s) already exists.\n", buf);
1845 		return rc;
1846 	}
1847 
1848 	if (atomic_read(&base_qedf->link_state) != QEDF_LINK_UP) {
1849 		QEDF_WARN(&(base_qedf->dbg_ctx), "Cannot create vport "
1850 			   "because link is not up.\n");
1851 		return -EIO;
1852 	}
1853 
1854 	vn_port = libfc_vport_create(vport, sizeof(struct qedf_ctx));
1855 	if (!vn_port) {
1856 		QEDF_WARN(&(base_qedf->dbg_ctx), "Could not create lport "
1857 			   "for vport.\n");
1858 		return -ENOMEM;
1859 	}
1860 
1861 	fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
1862 	QEDF_ERR(&(base_qedf->dbg_ctx), "Creating NPIV port, WWPN=%s.\n",
1863 	    buf);
1864 
1865 	/* Copy some fields from base_qedf */
1866 	vport_qedf = lport_priv(vn_port);
1867 	memcpy(vport_qedf, base_qedf, sizeof(struct qedf_ctx));
1868 
1869 	/* Set qedf data specific to this vport */
1870 	vport_qedf->lport = vn_port;
1871 	/* Use same hba_lock as base_qedf */
1872 	vport_qedf->hba_lock = base_qedf->hba_lock;
1873 	vport_qedf->pdev = base_qedf->pdev;
1874 	vport_qedf->cmd_mgr = base_qedf->cmd_mgr;
1875 	init_completion(&vport_qedf->flogi_compl);
1876 	INIT_LIST_HEAD(&vport_qedf->fcports);
1877 	INIT_DELAYED_WORK(&vport_qedf->stag_work, qedf_stag_change_work);
1878 
1879 	rc = qedf_vport_libfc_config(vport, vn_port);
1880 	if (rc) {
1881 		QEDF_ERR(&(base_qedf->dbg_ctx), "Could not allocate memory "
1882 		    "for lport stats.\n");
1883 		goto err;
1884 	}
1885 
1886 	fc_set_wwnn(vn_port, vport->node_name);
1887 	fc_set_wwpn(vn_port, vport->port_name);
1888 	vport_qedf->wwnn = vn_port->wwnn;
1889 	vport_qedf->wwpn = vn_port->wwpn;
1890 
1891 	vn_port->host->transportt = qedf_fc_vport_transport_template;
1892 	vn_port->host->can_queue = FCOE_PARAMS_NUM_TASKS;
1893 	vn_port->host->max_lun = qedf_max_lun;
1894 	vn_port->host->sg_tablesize = QEDF_MAX_BDS_PER_CMD;
1895 	vn_port->host->max_cmd_len = QEDF_MAX_CDB_LEN;
1896 	vn_port->host->max_id = QEDF_MAX_SESSIONS;
1897 
1898 	rc = scsi_add_host(vn_port->host, &vport->dev);
1899 	if (rc) {
1900 		QEDF_WARN(&base_qedf->dbg_ctx,
1901 			  "Error adding Scsi_Host rc=0x%x.\n", rc);
1902 		goto err;
1903 	}
1904 
1905 	/* Set default dev_loss_tmo based on module parameter */
1906 	fc_host_dev_loss_tmo(vn_port->host) = qedf_dev_loss_tmo;
1907 
1908 	/* Init libfc stuffs */
1909 	memcpy(&vn_port->tt, &qedf_lport_template,
1910 		sizeof(qedf_lport_template));
1911 	fc_exch_init(vn_port);
1912 	fc_elsct_init(vn_port);
1913 	fc_lport_init(vn_port);
1914 	fc_disc_init(vn_port);
1915 	fc_disc_config(vn_port, vn_port);
1916 
1917 
1918 	/* Allocate the exchange manager */
1919 	shost = vport_to_shost(vport);
1920 	n_port = shost_priv(shost);
1921 	fc_exch_mgr_list_clone(n_port, vn_port);
1922 
1923 	/* Set max frame size */
1924 	fc_set_mfs(vn_port, QEDF_MFS);
1925 
1926 	fc_host_port_type(vn_port->host) = FC_PORTTYPE_UNKNOWN;
1927 
1928 	if (disabled) {
1929 		fc_vport_set_state(vport, FC_VPORT_DISABLED);
1930 	} else {
1931 		vn_port->boot_time = jiffies;
1932 		fc_fabric_login(vn_port);
1933 		fc_vport_setlink(vn_port);
1934 	}
1935 
1936 	/* Set symbolic node name */
1937 	if (base_qedf->pdev->device == QL45xxx)
1938 		snprintf(fc_host_symbolic_name(vn_port->host), 256,
1939 			 "Marvell FastLinQ 45xxx FCoE v%s", QEDF_VERSION);
1940 
1941 	if (base_qedf->pdev->device == QL41xxx)
1942 		snprintf(fc_host_symbolic_name(vn_port->host), 256,
1943 			 "Marvell FastLinQ 41xxx FCoE v%s", QEDF_VERSION);
1944 
1945 	/* Set supported speed */
1946 	fc_host_supported_speeds(vn_port->host) = n_port->link_supported_speeds;
1947 
1948 	/* Set speed */
1949 	vn_port->link_speed = n_port->link_speed;
1950 
1951 	/* Set port type */
1952 	fc_host_port_type(vn_port->host) = FC_PORTTYPE_NPIV;
1953 
1954 	/* Set maxframe size */
1955 	fc_host_maxframe_size(vn_port->host) = n_port->mfs;
1956 
1957 	QEDF_INFO(&(base_qedf->dbg_ctx), QEDF_LOG_NPIV, "vn_port=%p.\n",
1958 		   vn_port);
1959 
1960 	/* Set up debug context for vport */
1961 	vport_qedf->dbg_ctx.host_no = vn_port->host->host_no;
1962 	vport_qedf->dbg_ctx.pdev = base_qedf->pdev;
1963 
1964 	return 0;
1965 
1966 err:
1967 	scsi_host_put(vn_port->host);
1968 	return rc;
1969 }
1970 
1971 static int qedf_vport_destroy(struct fc_vport *vport)
1972 {
1973 	struct Scsi_Host *shost = vport_to_shost(vport);
1974 	struct fc_lport *n_port = shost_priv(shost);
1975 	struct fc_lport *vn_port = vport->dd_data;
1976 	struct qedf_ctx *qedf = lport_priv(vn_port);
1977 
1978 	if (!qedf) {
1979 		QEDF_ERR(NULL, "qedf is NULL.\n");
1980 		goto out;
1981 	}
1982 
1983 	/* Set unloading bit on vport qedf_ctx to prevent more I/O */
1984 	set_bit(QEDF_UNLOADING, &qedf->flags);
1985 
1986 	mutex_lock(&n_port->lp_mutex);
1987 	list_del(&vn_port->list);
1988 	mutex_unlock(&n_port->lp_mutex);
1989 
1990 	fc_fabric_logoff(vn_port);
1991 	fc_lport_destroy(vn_port);
1992 
1993 	/* Detach from scsi-ml */
1994 	fc_remove_host(vn_port->host);
1995 	scsi_remove_host(vn_port->host);
1996 
1997 	/*
1998 	 * Only try to release the exchange manager if the vn_port
1999 	 * configuration is complete.
2000 	 */
2001 	if (vn_port->state == LPORT_ST_READY)
2002 		fc_exch_mgr_free(vn_port);
2003 
2004 	/* Free memory used by statistical counters */
2005 	fc_lport_free_stats(vn_port);
2006 
2007 	/* Release Scsi_Host */
2008 	scsi_host_put(vn_port->host);
2009 
2010 out:
2011 	return 0;
2012 }
2013 
2014 static int qedf_vport_disable(struct fc_vport *vport, bool disable)
2015 {
2016 	struct fc_lport *lport = vport->dd_data;
2017 
2018 	if (disable) {
2019 		fc_vport_set_state(vport, FC_VPORT_DISABLED);
2020 		fc_fabric_logoff(lport);
2021 	} else {
2022 		lport->boot_time = jiffies;
2023 		fc_fabric_login(lport);
2024 		fc_vport_setlink(lport);
2025 	}
2026 	return 0;
2027 }
2028 
2029 /*
2030  * During removal we need to wait for all the vports associated with a port
2031  * to be destroyed so we avoid a race condition where libfc is still trying
2032  * to reap vports while the driver remove function has already reaped the
2033  * driver contexts associated with the physical port.
2034  */
2035 static void qedf_wait_for_vport_destroy(struct qedf_ctx *qedf)
2036 {
2037 	struct fc_host_attrs *fc_host = shost_to_fc_host(qedf->lport->host);
2038 
2039 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_NPIV,
2040 	    "Entered.\n");
2041 	while (fc_host->npiv_vports_inuse > 0) {
2042 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_NPIV,
2043 		    "Waiting for all vports to be reaped.\n");
2044 		msleep(1000);
2045 	}
2046 }
2047 
2048 /**
2049  * qedf_fcoe_reset - Resets the fcoe
2050  *
2051  * @shost: shost the reset is from
2052  *
2053  * Returns: always 0
2054  */
2055 static int qedf_fcoe_reset(struct Scsi_Host *shost)
2056 {
2057 	struct fc_lport *lport = shost_priv(shost);
2058 
2059 	qedf_ctx_soft_reset(lport);
2060 	return 0;
2061 }
2062 
2063 static void qedf_get_host_port_id(struct Scsi_Host *shost)
2064 {
2065 	struct fc_lport *lport = shost_priv(shost);
2066 
2067 	fc_host_port_id(shost) = lport->port_id;
2068 }
2069 
2070 static struct fc_host_statistics *qedf_fc_get_host_stats(struct Scsi_Host
2071 	*shost)
2072 {
2073 	struct fc_host_statistics *qedf_stats;
2074 	struct fc_lport *lport = shost_priv(shost);
2075 	struct qedf_ctx *qedf = lport_priv(lport);
2076 	struct qed_fcoe_stats *fw_fcoe_stats;
2077 
2078 	qedf_stats = fc_get_host_stats(shost);
2079 
2080 	/* We don't collect offload stats for specific NPIV ports */
2081 	if (lport->vport)
2082 		goto out;
2083 
2084 	fw_fcoe_stats = kmalloc(sizeof(struct qed_fcoe_stats), GFP_KERNEL);
2085 	if (!fw_fcoe_stats) {
2086 		QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate memory for "
2087 		    "fw_fcoe_stats.\n");
2088 		goto out;
2089 	}
2090 
2091 	mutex_lock(&qedf->stats_mutex);
2092 
2093 	/* Query firmware for offload stats */
2094 	qed_ops->get_stats(qedf->cdev, fw_fcoe_stats);
2095 
2096 	/*
2097 	 * The expectation is that we add our offload stats to the stats
2098 	 * being maintained by libfc each time the fc_get_host_status callback
2099 	 * is invoked. The additions are not carried over for each call to
2100 	 * the fc_get_host_stats callback.
2101 	 */
2102 	qedf_stats->tx_frames += fw_fcoe_stats->fcoe_tx_data_pkt_cnt +
2103 	    fw_fcoe_stats->fcoe_tx_xfer_pkt_cnt +
2104 	    fw_fcoe_stats->fcoe_tx_other_pkt_cnt;
2105 	qedf_stats->rx_frames += fw_fcoe_stats->fcoe_rx_data_pkt_cnt +
2106 	    fw_fcoe_stats->fcoe_rx_xfer_pkt_cnt +
2107 	    fw_fcoe_stats->fcoe_rx_other_pkt_cnt;
2108 	qedf_stats->fcp_input_megabytes +=
2109 	    do_div(fw_fcoe_stats->fcoe_rx_byte_cnt, 1000000);
2110 	qedf_stats->fcp_output_megabytes +=
2111 	    do_div(fw_fcoe_stats->fcoe_tx_byte_cnt, 1000000);
2112 	qedf_stats->rx_words += fw_fcoe_stats->fcoe_rx_byte_cnt / 4;
2113 	qedf_stats->tx_words += fw_fcoe_stats->fcoe_tx_byte_cnt / 4;
2114 	qedf_stats->invalid_crc_count +=
2115 	    fw_fcoe_stats->fcoe_silent_drop_pkt_crc_error_cnt;
2116 	qedf_stats->dumped_frames =
2117 	    fw_fcoe_stats->fcoe_silent_drop_total_pkt_cnt;
2118 	qedf_stats->error_frames +=
2119 	    fw_fcoe_stats->fcoe_silent_drop_total_pkt_cnt;
2120 	qedf_stats->fcp_input_requests += qedf->input_requests;
2121 	qedf_stats->fcp_output_requests += qedf->output_requests;
2122 	qedf_stats->fcp_control_requests += qedf->control_requests;
2123 	qedf_stats->fcp_packet_aborts += qedf->packet_aborts;
2124 	qedf_stats->fcp_frame_alloc_failures += qedf->alloc_failures;
2125 
2126 	mutex_unlock(&qedf->stats_mutex);
2127 	kfree(fw_fcoe_stats);
2128 out:
2129 	return qedf_stats;
2130 }
2131 
2132 static struct fc_function_template qedf_fc_transport_fn = {
2133 	.show_host_node_name = 1,
2134 	.show_host_port_name = 1,
2135 	.show_host_supported_classes = 1,
2136 	.show_host_supported_fc4s = 1,
2137 	.show_host_active_fc4s = 1,
2138 	.show_host_maxframe_size = 1,
2139 
2140 	.get_host_port_id = qedf_get_host_port_id,
2141 	.show_host_port_id = 1,
2142 	.show_host_supported_speeds = 1,
2143 	.get_host_speed = fc_get_host_speed,
2144 	.show_host_speed = 1,
2145 	.show_host_port_type = 1,
2146 	.get_host_port_state = fc_get_host_port_state,
2147 	.show_host_port_state = 1,
2148 	.show_host_symbolic_name = 1,
2149 
2150 	/*
2151 	 * Tell FC transport to allocate enough space to store the backpointer
2152 	 * for the associate qedf_rport struct.
2153 	 */
2154 	.dd_fcrport_size = (sizeof(struct fc_rport_libfc_priv) +
2155 				sizeof(struct qedf_rport)),
2156 	.show_rport_maxframe_size = 1,
2157 	.show_rport_supported_classes = 1,
2158 	.show_host_fabric_name = 1,
2159 	.show_starget_node_name = 1,
2160 	.show_starget_port_name = 1,
2161 	.show_starget_port_id = 1,
2162 	.set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
2163 	.show_rport_dev_loss_tmo = 1,
2164 	.get_fc_host_stats = qedf_fc_get_host_stats,
2165 	.issue_fc_host_lip = qedf_fcoe_reset,
2166 	.vport_create = qedf_vport_create,
2167 	.vport_delete = qedf_vport_destroy,
2168 	.vport_disable = qedf_vport_disable,
2169 	.bsg_request = fc_lport_bsg_request,
2170 };
2171 
2172 static struct fc_function_template qedf_fc_vport_transport_fn = {
2173 	.show_host_node_name = 1,
2174 	.show_host_port_name = 1,
2175 	.show_host_supported_classes = 1,
2176 	.show_host_supported_fc4s = 1,
2177 	.show_host_active_fc4s = 1,
2178 	.show_host_maxframe_size = 1,
2179 	.show_host_port_id = 1,
2180 	.show_host_supported_speeds = 1,
2181 	.get_host_speed = fc_get_host_speed,
2182 	.show_host_speed = 1,
2183 	.show_host_port_type = 1,
2184 	.get_host_port_state = fc_get_host_port_state,
2185 	.show_host_port_state = 1,
2186 	.show_host_symbolic_name = 1,
2187 	.dd_fcrport_size = (sizeof(struct fc_rport_libfc_priv) +
2188 				sizeof(struct qedf_rport)),
2189 	.show_rport_maxframe_size = 1,
2190 	.show_rport_supported_classes = 1,
2191 	.show_host_fabric_name = 1,
2192 	.show_starget_node_name = 1,
2193 	.show_starget_port_name = 1,
2194 	.show_starget_port_id = 1,
2195 	.set_rport_dev_loss_tmo = fc_set_rport_loss_tmo,
2196 	.show_rport_dev_loss_tmo = 1,
2197 	.get_fc_host_stats = fc_get_host_stats,
2198 	.issue_fc_host_lip = qedf_fcoe_reset,
2199 	.bsg_request = fc_lport_bsg_request,
2200 };
2201 
2202 static bool qedf_fp_has_work(struct qedf_fastpath *fp)
2203 {
2204 	struct qedf_ctx *qedf = fp->qedf;
2205 	struct global_queue *que;
2206 	struct qed_sb_info *sb_info = fp->sb_info;
2207 	struct status_block *sb = sb_info->sb_virt;
2208 	u16 prod_idx;
2209 
2210 	/* Get the pointer to the global CQ this completion is on */
2211 	que = qedf->global_queues[fp->sb_id];
2212 
2213 	/* Be sure all responses have been written to PI */
2214 	rmb();
2215 
2216 	/* Get the current firmware producer index */
2217 	prod_idx = sb->pi_array[QEDF_FCOE_PARAMS_GL_RQ_PI];
2218 
2219 	return (que->cq_prod_idx != prod_idx);
2220 }
2221 
2222 /*
2223  * Interrupt handler code.
2224  */
2225 
2226 /* Process completion queue and copy CQE contents for deferred processesing
2227  *
2228  * Return true if we should wake the I/O thread, false if not.
2229  */
2230 static bool qedf_process_completions(struct qedf_fastpath *fp)
2231 {
2232 	struct qedf_ctx *qedf = fp->qedf;
2233 	struct qed_sb_info *sb_info = fp->sb_info;
2234 	struct status_block *sb = sb_info->sb_virt;
2235 	struct global_queue *que;
2236 	u16 prod_idx;
2237 	struct fcoe_cqe *cqe;
2238 	struct qedf_io_work *io_work;
2239 	unsigned int cpu;
2240 	struct qedf_ioreq *io_req = NULL;
2241 	u16 xid;
2242 	u16 new_cqes;
2243 	u32 comp_type;
2244 
2245 	/* Get the current firmware producer index */
2246 	prod_idx = sb->pi_array[QEDF_FCOE_PARAMS_GL_RQ_PI];
2247 
2248 	/* Get the pointer to the global CQ this completion is on */
2249 	que = qedf->global_queues[fp->sb_id];
2250 
2251 	/* Calculate the amount of new elements since last processing */
2252 	new_cqes = (prod_idx >= que->cq_prod_idx) ?
2253 	    (prod_idx - que->cq_prod_idx) :
2254 	    0x10000 - que->cq_prod_idx + prod_idx;
2255 
2256 	/* Save producer index */
2257 	que->cq_prod_idx = prod_idx;
2258 
2259 	while (new_cqes) {
2260 		fp->completions++;
2261 		cqe = &que->cq[que->cq_cons_idx];
2262 
2263 		comp_type = (cqe->cqe_data >> FCOE_CQE_CQE_TYPE_SHIFT) &
2264 		    FCOE_CQE_CQE_TYPE_MASK;
2265 
2266 		/*
2267 		 * Process unsolicited CQEs directly in the interrupt handler
2268 		 * sine we need the fastpath ID
2269 		 */
2270 		if (comp_type == FCOE_UNSOLIC_CQE_TYPE) {
2271 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_UNSOL,
2272 			   "Unsolicated CQE.\n");
2273 			qedf_process_unsol_compl(qedf, fp->sb_id, cqe);
2274 			/*
2275 			 * Don't add a work list item.  Increment consumer
2276 			 * consumer index and move on.
2277 			 */
2278 			goto inc_idx;
2279 		}
2280 
2281 		xid = cqe->cqe_data & FCOE_CQE_TASK_ID_MASK;
2282 		io_req = &qedf->cmd_mgr->cmds[xid];
2283 
2284 		/*
2285 		 * Figure out which percpu thread we should queue this I/O
2286 		 * on.
2287 		 */
2288 		if (!io_req)
2289 			/* If there is not io_req associated with this CQE
2290 			 * just queue it on CPU 0
2291 			 */
2292 			cpu = 0;
2293 		else {
2294 			cpu = io_req->cpu;
2295 			io_req->int_cpu = smp_processor_id();
2296 		}
2297 
2298 		io_work = mempool_alloc(qedf->io_mempool, GFP_ATOMIC);
2299 		if (!io_work) {
2300 			QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate "
2301 				   "work for I/O completion.\n");
2302 			continue;
2303 		}
2304 		memset(io_work, 0, sizeof(struct qedf_io_work));
2305 
2306 		INIT_WORK(&io_work->work, qedf_fp_io_handler);
2307 
2308 		/* Copy contents of CQE for deferred processing */
2309 		memcpy(&io_work->cqe, cqe, sizeof(struct fcoe_cqe));
2310 
2311 		io_work->qedf = fp->qedf;
2312 		io_work->fp = NULL; /* Only used for unsolicited frames */
2313 
2314 		queue_work_on(cpu, qedf_io_wq, &io_work->work);
2315 
2316 inc_idx:
2317 		que->cq_cons_idx++;
2318 		if (que->cq_cons_idx == fp->cq_num_entries)
2319 			que->cq_cons_idx = 0;
2320 		new_cqes--;
2321 	}
2322 
2323 	return true;
2324 }
2325 
2326 
2327 /* MSI-X fastpath handler code */
2328 static irqreturn_t qedf_msix_handler(int irq, void *dev_id)
2329 {
2330 	struct qedf_fastpath *fp = dev_id;
2331 
2332 	if (!fp) {
2333 		QEDF_ERR(NULL, "fp is null.\n");
2334 		return IRQ_HANDLED;
2335 	}
2336 	if (!fp->sb_info) {
2337 		QEDF_ERR(NULL, "fp->sb_info in null.");
2338 		return IRQ_HANDLED;
2339 	}
2340 
2341 	/*
2342 	 * Disable interrupts for this status block while we process new
2343 	 * completions
2344 	 */
2345 	qed_sb_ack(fp->sb_info, IGU_INT_DISABLE, 0 /*do not update*/);
2346 
2347 	while (1) {
2348 		qedf_process_completions(fp);
2349 
2350 		if (qedf_fp_has_work(fp) == 0) {
2351 			/* Update the sb information */
2352 			qed_sb_update_sb_idx(fp->sb_info);
2353 
2354 			/* Check for more work */
2355 			rmb();
2356 
2357 			if (qedf_fp_has_work(fp) == 0) {
2358 				/* Re-enable interrupts */
2359 				qed_sb_ack(fp->sb_info, IGU_INT_ENABLE, 1);
2360 				return IRQ_HANDLED;
2361 			}
2362 		}
2363 	}
2364 
2365 	/* Do we ever want to break out of above loop? */
2366 	return IRQ_HANDLED;
2367 }
2368 
2369 /* simd handler for MSI/INTa */
2370 static void qedf_simd_int_handler(void *cookie)
2371 {
2372 	/* Cookie is qedf_ctx struct */
2373 	struct qedf_ctx *qedf = (struct qedf_ctx *)cookie;
2374 
2375 	QEDF_WARN(&(qedf->dbg_ctx), "qedf=%p.\n", qedf);
2376 }
2377 
2378 #define QEDF_SIMD_HANDLER_NUM		0
2379 static void qedf_sync_free_irqs(struct qedf_ctx *qedf)
2380 {
2381 	int i;
2382 	u16 vector_idx = 0;
2383 	u32 vector;
2384 
2385 	if (qedf->int_info.msix_cnt) {
2386 		for (i = 0; i < qedf->int_info.used_cnt; i++) {
2387 			vector_idx = i * qedf->dev_info.common.num_hwfns +
2388 				qed_ops->common->get_affin_hwfn_idx(qedf->cdev);
2389 			QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
2390 				  "Freeing IRQ #%d vector_idx=%d.\n",
2391 				  i, vector_idx);
2392 			vector = qedf->int_info.msix[vector_idx].vector;
2393 			synchronize_irq(vector);
2394 			irq_set_affinity_hint(vector, NULL);
2395 			irq_set_affinity_notifier(vector, NULL);
2396 			free_irq(vector, &qedf->fp_array[i]);
2397 		}
2398 	} else
2399 		qed_ops->common->simd_handler_clean(qedf->cdev,
2400 		    QEDF_SIMD_HANDLER_NUM);
2401 
2402 	qedf->int_info.used_cnt = 0;
2403 	qed_ops->common->set_fp_int(qedf->cdev, 0);
2404 }
2405 
2406 static int qedf_request_msix_irq(struct qedf_ctx *qedf)
2407 {
2408 	int i, rc, cpu;
2409 	u16 vector_idx = 0;
2410 	u32 vector;
2411 
2412 	cpu = cpumask_first(cpu_online_mask);
2413 	for (i = 0; i < qedf->num_queues; i++) {
2414 		vector_idx = i * qedf->dev_info.common.num_hwfns +
2415 			qed_ops->common->get_affin_hwfn_idx(qedf->cdev);
2416 		QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
2417 			  "Requesting IRQ #%d vector_idx=%d.\n",
2418 			  i, vector_idx);
2419 		vector = qedf->int_info.msix[vector_idx].vector;
2420 		rc = request_irq(vector, qedf_msix_handler, 0, "qedf",
2421 				 &qedf->fp_array[i]);
2422 
2423 		if (rc) {
2424 			QEDF_WARN(&(qedf->dbg_ctx), "request_irq failed.\n");
2425 			qedf_sync_free_irqs(qedf);
2426 			return rc;
2427 		}
2428 
2429 		qedf->int_info.used_cnt++;
2430 		rc = irq_set_affinity_hint(vector, get_cpu_mask(cpu));
2431 		cpu = cpumask_next(cpu, cpu_online_mask);
2432 	}
2433 
2434 	return 0;
2435 }
2436 
2437 static int qedf_setup_int(struct qedf_ctx *qedf)
2438 {
2439 	int rc = 0;
2440 
2441 	/*
2442 	 * Learn interrupt configuration
2443 	 */
2444 	rc = qed_ops->common->set_fp_int(qedf->cdev, num_online_cpus());
2445 	if (rc <= 0)
2446 		return 0;
2447 
2448 	rc  = qed_ops->common->get_fp_int(qedf->cdev, &qedf->int_info);
2449 	if (rc)
2450 		return 0;
2451 
2452 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Number of msix_cnt = "
2453 		   "0x%x num of cpus = 0x%x\n", qedf->int_info.msix_cnt,
2454 		   num_online_cpus());
2455 
2456 	if (qedf->int_info.msix_cnt)
2457 		return qedf_request_msix_irq(qedf);
2458 
2459 	qed_ops->common->simd_handler_config(qedf->cdev, &qedf,
2460 	    QEDF_SIMD_HANDLER_NUM, qedf_simd_int_handler);
2461 	qedf->int_info.used_cnt = 1;
2462 
2463 	QEDF_ERR(&qedf->dbg_ctx,
2464 		 "Cannot load driver due to a lack of MSI-X vectors.\n");
2465 	return -EINVAL;
2466 }
2467 
2468 /* Main function for libfc frame reception */
2469 static void qedf_recv_frame(struct qedf_ctx *qedf,
2470 	struct sk_buff *skb)
2471 {
2472 	u32 fr_len;
2473 	struct fc_lport *lport;
2474 	struct fc_frame_header *fh;
2475 	struct fcoe_crc_eof crc_eof;
2476 	struct fc_frame *fp;
2477 	u8 *mac = NULL;
2478 	u8 *dest_mac = NULL;
2479 	struct fcoe_hdr *hp;
2480 	struct qedf_rport *fcport;
2481 	struct fc_lport *vn_port;
2482 	u32 f_ctl;
2483 
2484 	lport = qedf->lport;
2485 	if (lport == NULL || lport->state == LPORT_ST_DISABLED) {
2486 		QEDF_WARN(NULL, "Invalid lport struct or lport disabled.\n");
2487 		kfree_skb(skb);
2488 		return;
2489 	}
2490 
2491 	if (skb_is_nonlinear(skb))
2492 		skb_linearize(skb);
2493 	mac = eth_hdr(skb)->h_source;
2494 	dest_mac = eth_hdr(skb)->h_dest;
2495 
2496 	/* Pull the header */
2497 	hp = (struct fcoe_hdr *)skb->data;
2498 	fh = (struct fc_frame_header *) skb_transport_header(skb);
2499 	skb_pull(skb, sizeof(struct fcoe_hdr));
2500 	fr_len = skb->len - sizeof(struct fcoe_crc_eof);
2501 
2502 	fp = (struct fc_frame *)skb;
2503 	fc_frame_init(fp);
2504 	fr_dev(fp) = lport;
2505 	fr_sof(fp) = hp->fcoe_sof;
2506 	if (skb_copy_bits(skb, fr_len, &crc_eof, sizeof(crc_eof))) {
2507 		QEDF_INFO(NULL, QEDF_LOG_LL2, "skb_copy_bits failed.\n");
2508 		kfree_skb(skb);
2509 		return;
2510 	}
2511 	fr_eof(fp) = crc_eof.fcoe_eof;
2512 	fr_crc(fp) = crc_eof.fcoe_crc32;
2513 	if (pskb_trim(skb, fr_len)) {
2514 		QEDF_INFO(NULL, QEDF_LOG_LL2, "pskb_trim failed.\n");
2515 		kfree_skb(skb);
2516 		return;
2517 	}
2518 
2519 	fh = fc_frame_header_get(fp);
2520 
2521 	/*
2522 	 * Invalid frame filters.
2523 	 */
2524 
2525 	if (fh->fh_r_ctl == FC_RCTL_DD_SOL_DATA &&
2526 	    fh->fh_type == FC_TYPE_FCP) {
2527 		/* Drop FCP data. We dont this in L2 path */
2528 		kfree_skb(skb);
2529 		return;
2530 	}
2531 	if (fh->fh_r_ctl == FC_RCTL_ELS_REQ &&
2532 	    fh->fh_type == FC_TYPE_ELS) {
2533 		switch (fc_frame_payload_op(fp)) {
2534 		case ELS_LOGO:
2535 			if (ntoh24(fh->fh_s_id) == FC_FID_FLOGI) {
2536 				/* drop non-FIP LOGO */
2537 				kfree_skb(skb);
2538 				return;
2539 			}
2540 			break;
2541 		}
2542 	}
2543 
2544 	if (fh->fh_r_ctl == FC_RCTL_BA_ABTS) {
2545 		/* Drop incoming ABTS */
2546 		kfree_skb(skb);
2547 		return;
2548 	}
2549 
2550 	if (ntoh24(&dest_mac[3]) != ntoh24(fh->fh_d_id)) {
2551 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
2552 		    "FC frame d_id mismatch with MAC %pM.\n", dest_mac);
2553 		kfree_skb(skb);
2554 		return;
2555 	}
2556 
2557 	if (qedf->ctlr.state) {
2558 		if (!ether_addr_equal(mac, qedf->ctlr.dest_addr)) {
2559 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
2560 			    "Wrong source address: mac:%pM dest_addr:%pM.\n",
2561 			    mac, qedf->ctlr.dest_addr);
2562 			kfree_skb(skb);
2563 			return;
2564 		}
2565 	}
2566 
2567 	vn_port = fc_vport_id_lookup(lport, ntoh24(fh->fh_d_id));
2568 
2569 	/*
2570 	 * If the destination ID from the frame header does not match what we
2571 	 * have on record for lport and the search for a NPIV port came up
2572 	 * empty then this is not addressed to our port so simply drop it.
2573 	 */
2574 	if (lport->port_id != ntoh24(fh->fh_d_id) && !vn_port) {
2575 		QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
2576 			  "Dropping frame due to destination mismatch: lport->port_id=0x%x fh->d_id=0x%x.\n",
2577 			  lport->port_id, ntoh24(fh->fh_d_id));
2578 		kfree_skb(skb);
2579 		return;
2580 	}
2581 
2582 	f_ctl = ntoh24(fh->fh_f_ctl);
2583 	if ((fh->fh_type == FC_TYPE_BLS) && (f_ctl & FC_FC_SEQ_CTX) &&
2584 	    (f_ctl & FC_FC_EX_CTX)) {
2585 		/* Drop incoming ABTS response that has both SEQ/EX CTX set */
2586 		QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
2587 			  "Dropping ABTS response as both SEQ/EX CTX set.\n");
2588 		kfree_skb(skb);
2589 		return;
2590 	}
2591 
2592 	/*
2593 	 * If a connection is uploading, drop incoming FCoE frames as there
2594 	 * is a small window where we could try to return a frame while libfc
2595 	 * is trying to clean things up.
2596 	 */
2597 
2598 	/* Get fcport associated with d_id if it exists */
2599 	fcport = qedf_fcport_lookup(qedf, ntoh24(fh->fh_d_id));
2600 
2601 	if (fcport && test_bit(QEDF_RPORT_UPLOADING_CONNECTION,
2602 	    &fcport->flags)) {
2603 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2,
2604 		    "Connection uploading, dropping fp=%p.\n", fp);
2605 		kfree_skb(skb);
2606 		return;
2607 	}
2608 
2609 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, "FCoE frame receive: "
2610 	    "skb=%p fp=%p src=%06x dest=%06x r_ctl=%x fh_type=%x.\n", skb, fp,
2611 	    ntoh24(fh->fh_s_id), ntoh24(fh->fh_d_id), fh->fh_r_ctl,
2612 	    fh->fh_type);
2613 	if (qedf_dump_frames)
2614 		print_hex_dump(KERN_WARNING, "fcoe: ", DUMP_PREFIX_OFFSET, 16,
2615 		    1, skb->data, skb->len, false);
2616 	fc_exch_recv(lport, fp);
2617 }
2618 
2619 static void qedf_ll2_process_skb(struct work_struct *work)
2620 {
2621 	struct qedf_skb_work *skb_work =
2622 	    container_of(work, struct qedf_skb_work, work);
2623 	struct qedf_ctx *qedf = skb_work->qedf;
2624 	struct sk_buff *skb = skb_work->skb;
2625 	struct ethhdr *eh;
2626 
2627 	if (!qedf) {
2628 		QEDF_ERR(NULL, "qedf is NULL\n");
2629 		goto err_out;
2630 	}
2631 
2632 	eh = (struct ethhdr *)skb->data;
2633 
2634 	/* Undo VLAN encapsulation */
2635 	if (eh->h_proto == htons(ETH_P_8021Q)) {
2636 		memmove((u8 *)eh + VLAN_HLEN, eh, ETH_ALEN * 2);
2637 		eh = skb_pull(skb, VLAN_HLEN);
2638 		skb_reset_mac_header(skb);
2639 	}
2640 
2641 	/*
2642 	 * Process either a FIP frame or FCoE frame based on the
2643 	 * protocol value.  If it's not either just drop the
2644 	 * frame.
2645 	 */
2646 	if (eh->h_proto == htons(ETH_P_FIP)) {
2647 		qedf_fip_recv(qedf, skb);
2648 		goto out;
2649 	} else if (eh->h_proto == htons(ETH_P_FCOE)) {
2650 		__skb_pull(skb, ETH_HLEN);
2651 		qedf_recv_frame(qedf, skb);
2652 		goto out;
2653 	} else
2654 		goto err_out;
2655 
2656 err_out:
2657 	kfree_skb(skb);
2658 out:
2659 	kfree(skb_work);
2660 	return;
2661 }
2662 
2663 static int qedf_ll2_rx(void *cookie, struct sk_buff *skb,
2664 	u32 arg1, u32 arg2)
2665 {
2666 	struct qedf_ctx *qedf = (struct qedf_ctx *)cookie;
2667 	struct qedf_skb_work *skb_work;
2668 
2669 	if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
2670 		QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
2671 			  "Dropping frame as link state is down.\n");
2672 		kfree_skb(skb);
2673 		return 0;
2674 	}
2675 
2676 	skb_work = kzalloc(sizeof(struct qedf_skb_work), GFP_ATOMIC);
2677 	if (!skb_work) {
2678 		QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate skb_work so "
2679 			   "dropping frame.\n");
2680 		kfree_skb(skb);
2681 		return 0;
2682 	}
2683 
2684 	INIT_WORK(&skb_work->work, qedf_ll2_process_skb);
2685 	skb_work->skb = skb;
2686 	skb_work->qedf = qedf;
2687 	queue_work(qedf->ll2_recv_wq, &skb_work->work);
2688 
2689 	return 0;
2690 }
2691 
2692 static struct qed_ll2_cb_ops qedf_ll2_cb_ops = {
2693 	.rx_cb = qedf_ll2_rx,
2694 	.tx_cb = NULL,
2695 };
2696 
2697 /* Main thread to process I/O completions */
2698 void qedf_fp_io_handler(struct work_struct *work)
2699 {
2700 	struct qedf_io_work *io_work =
2701 	    container_of(work, struct qedf_io_work, work);
2702 	u32 comp_type;
2703 
2704 	/*
2705 	 * Deferred part of unsolicited CQE sends
2706 	 * frame to libfc.
2707 	 */
2708 	comp_type = (io_work->cqe.cqe_data >>
2709 	    FCOE_CQE_CQE_TYPE_SHIFT) &
2710 	    FCOE_CQE_CQE_TYPE_MASK;
2711 	if (comp_type == FCOE_UNSOLIC_CQE_TYPE &&
2712 	    io_work->fp)
2713 		fc_exch_recv(io_work->qedf->lport, io_work->fp);
2714 	else
2715 		qedf_process_cqe(io_work->qedf, &io_work->cqe);
2716 
2717 	kfree(io_work);
2718 }
2719 
2720 static int qedf_alloc_and_init_sb(struct qedf_ctx *qedf,
2721 	struct qed_sb_info *sb_info, u16 sb_id)
2722 {
2723 	struct status_block *sb_virt;
2724 	dma_addr_t sb_phys;
2725 	int ret;
2726 
2727 	sb_virt = dma_alloc_coherent(&qedf->pdev->dev,
2728 	    sizeof(struct status_block), &sb_phys, GFP_KERNEL);
2729 
2730 	if (!sb_virt) {
2731 		QEDF_ERR(&qedf->dbg_ctx,
2732 			 "Status block allocation failed for id = %d.\n",
2733 			 sb_id);
2734 		return -ENOMEM;
2735 	}
2736 
2737 	ret = qed_ops->common->sb_init(qedf->cdev, sb_info, sb_virt, sb_phys,
2738 	    sb_id, QED_SB_TYPE_STORAGE);
2739 
2740 	if (ret) {
2741 		QEDF_ERR(&qedf->dbg_ctx,
2742 			 "Status block initialization failed (0x%x) for id = %d.\n",
2743 			 ret, sb_id);
2744 		return ret;
2745 	}
2746 
2747 	return 0;
2748 }
2749 
2750 static void qedf_free_sb(struct qedf_ctx *qedf, struct qed_sb_info *sb_info)
2751 {
2752 	if (sb_info->sb_virt)
2753 		dma_free_coherent(&qedf->pdev->dev, sizeof(*sb_info->sb_virt),
2754 		    (void *)sb_info->sb_virt, sb_info->sb_phys);
2755 }
2756 
2757 static void qedf_destroy_sb(struct qedf_ctx *qedf)
2758 {
2759 	int id;
2760 	struct qedf_fastpath *fp = NULL;
2761 
2762 	for (id = 0; id < qedf->num_queues; id++) {
2763 		fp = &(qedf->fp_array[id]);
2764 		if (fp->sb_id == QEDF_SB_ID_NULL)
2765 			break;
2766 		qedf_free_sb(qedf, fp->sb_info);
2767 		kfree(fp->sb_info);
2768 	}
2769 	kfree(qedf->fp_array);
2770 }
2771 
2772 static int qedf_prepare_sb(struct qedf_ctx *qedf)
2773 {
2774 	int id;
2775 	struct qedf_fastpath *fp;
2776 	int ret;
2777 
2778 	qedf->fp_array =
2779 	    kcalloc(qedf->num_queues, sizeof(struct qedf_fastpath),
2780 		GFP_KERNEL);
2781 
2782 	if (!qedf->fp_array) {
2783 		QEDF_ERR(&(qedf->dbg_ctx), "fastpath array allocation "
2784 			  "failed.\n");
2785 		return -ENOMEM;
2786 	}
2787 
2788 	for (id = 0; id < qedf->num_queues; id++) {
2789 		fp = &(qedf->fp_array[id]);
2790 		fp->sb_id = QEDF_SB_ID_NULL;
2791 		fp->sb_info = kcalloc(1, sizeof(*fp->sb_info), GFP_KERNEL);
2792 		if (!fp->sb_info) {
2793 			QEDF_ERR(&(qedf->dbg_ctx), "SB info struct "
2794 				  "allocation failed.\n");
2795 			goto err;
2796 		}
2797 		ret = qedf_alloc_and_init_sb(qedf, fp->sb_info, id);
2798 		if (ret) {
2799 			QEDF_ERR(&(qedf->dbg_ctx), "SB allocation and "
2800 				  "initialization failed.\n");
2801 			goto err;
2802 		}
2803 		fp->sb_id = id;
2804 		fp->qedf = qedf;
2805 		fp->cq_num_entries =
2806 		    qedf->global_queues[id]->cq_mem_size /
2807 		    sizeof(struct fcoe_cqe);
2808 	}
2809 err:
2810 	return 0;
2811 }
2812 
2813 void qedf_process_cqe(struct qedf_ctx *qedf, struct fcoe_cqe *cqe)
2814 {
2815 	u16 xid;
2816 	struct qedf_ioreq *io_req;
2817 	struct qedf_rport *fcport;
2818 	u32 comp_type;
2819 	u8 io_comp_type;
2820 	unsigned long flags;
2821 
2822 	comp_type = (cqe->cqe_data >> FCOE_CQE_CQE_TYPE_SHIFT) &
2823 	    FCOE_CQE_CQE_TYPE_MASK;
2824 
2825 	xid = cqe->cqe_data & FCOE_CQE_TASK_ID_MASK;
2826 	io_req = &qedf->cmd_mgr->cmds[xid];
2827 
2828 	/* Completion not for a valid I/O anymore so just return */
2829 	if (!io_req) {
2830 		QEDF_ERR(&qedf->dbg_ctx,
2831 			 "io_req is NULL for xid=0x%x.\n", xid);
2832 		return;
2833 	}
2834 
2835 	fcport = io_req->fcport;
2836 
2837 	if (fcport == NULL) {
2838 		QEDF_ERR(&qedf->dbg_ctx,
2839 			 "fcport is NULL for xid=0x%x io_req=%p.\n",
2840 			 xid, io_req);
2841 		return;
2842 	}
2843 
2844 	/*
2845 	 * Check that fcport is offloaded.  If it isn't then the spinlock
2846 	 * isn't valid and shouldn't be taken. We should just return.
2847 	 */
2848 	if (!test_bit(QEDF_RPORT_SESSION_READY, &fcport->flags)) {
2849 		QEDF_ERR(&qedf->dbg_ctx,
2850 			 "Session not offloaded yet, fcport = %p.\n", fcport);
2851 		return;
2852 	}
2853 
2854 	spin_lock_irqsave(&fcport->rport_lock, flags);
2855 	io_comp_type = io_req->cmd_type;
2856 	spin_unlock_irqrestore(&fcport->rport_lock, flags);
2857 
2858 	switch (comp_type) {
2859 	case FCOE_GOOD_COMPLETION_CQE_TYPE:
2860 		atomic_inc(&fcport->free_sqes);
2861 		switch (io_comp_type) {
2862 		case QEDF_SCSI_CMD:
2863 			qedf_scsi_completion(qedf, cqe, io_req);
2864 			break;
2865 		case QEDF_ELS:
2866 			qedf_process_els_compl(qedf, cqe, io_req);
2867 			break;
2868 		case QEDF_TASK_MGMT_CMD:
2869 			qedf_process_tmf_compl(qedf, cqe, io_req);
2870 			break;
2871 		case QEDF_SEQ_CLEANUP:
2872 			qedf_process_seq_cleanup_compl(qedf, cqe, io_req);
2873 			break;
2874 		}
2875 		break;
2876 	case FCOE_ERROR_DETECTION_CQE_TYPE:
2877 		atomic_inc(&fcport->free_sqes);
2878 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2879 		    "Error detect CQE.\n");
2880 		qedf_process_error_detect(qedf, cqe, io_req);
2881 		break;
2882 	case FCOE_EXCH_CLEANUP_CQE_TYPE:
2883 		atomic_inc(&fcport->free_sqes);
2884 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2885 		    "Cleanup CQE.\n");
2886 		qedf_process_cleanup_compl(qedf, cqe, io_req);
2887 		break;
2888 	case FCOE_ABTS_CQE_TYPE:
2889 		atomic_inc(&fcport->free_sqes);
2890 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2891 		    "Abort CQE.\n");
2892 		qedf_process_abts_compl(qedf, cqe, io_req);
2893 		break;
2894 	case FCOE_DUMMY_CQE_TYPE:
2895 		atomic_inc(&fcport->free_sqes);
2896 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2897 		    "Dummy CQE.\n");
2898 		break;
2899 	case FCOE_LOCAL_COMP_CQE_TYPE:
2900 		atomic_inc(&fcport->free_sqes);
2901 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2902 		    "Local completion CQE.\n");
2903 		break;
2904 	case FCOE_WARNING_CQE_TYPE:
2905 		atomic_inc(&fcport->free_sqes);
2906 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2907 		    "Warning CQE.\n");
2908 		qedf_process_warning_compl(qedf, cqe, io_req);
2909 		break;
2910 	case MAX_FCOE_CQE_TYPE:
2911 		atomic_inc(&fcport->free_sqes);
2912 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2913 		    "Max FCoE CQE.\n");
2914 		break;
2915 	default:
2916 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_IO,
2917 		    "Default CQE.\n");
2918 		break;
2919 	}
2920 }
2921 
2922 static void qedf_free_bdq(struct qedf_ctx *qedf)
2923 {
2924 	int i;
2925 
2926 	if (qedf->bdq_pbl_list)
2927 		dma_free_coherent(&qedf->pdev->dev, QEDF_PAGE_SIZE,
2928 		    qedf->bdq_pbl_list, qedf->bdq_pbl_list_dma);
2929 
2930 	if (qedf->bdq_pbl)
2931 		dma_free_coherent(&qedf->pdev->dev, qedf->bdq_pbl_mem_size,
2932 		    qedf->bdq_pbl, qedf->bdq_pbl_dma);
2933 
2934 	for (i = 0; i < QEDF_BDQ_SIZE; i++) {
2935 		if (qedf->bdq[i].buf_addr) {
2936 			dma_free_coherent(&qedf->pdev->dev, QEDF_BDQ_BUF_SIZE,
2937 			    qedf->bdq[i].buf_addr, qedf->bdq[i].buf_dma);
2938 		}
2939 	}
2940 }
2941 
2942 static void qedf_free_global_queues(struct qedf_ctx *qedf)
2943 {
2944 	int i;
2945 	struct global_queue **gl = qedf->global_queues;
2946 
2947 	for (i = 0; i < qedf->num_queues; i++) {
2948 		if (!gl[i])
2949 			continue;
2950 
2951 		if (gl[i]->cq)
2952 			dma_free_coherent(&qedf->pdev->dev,
2953 			    gl[i]->cq_mem_size, gl[i]->cq, gl[i]->cq_dma);
2954 		if (gl[i]->cq_pbl)
2955 			dma_free_coherent(&qedf->pdev->dev, gl[i]->cq_pbl_size,
2956 			    gl[i]->cq_pbl, gl[i]->cq_pbl_dma);
2957 
2958 		kfree(gl[i]);
2959 	}
2960 
2961 	qedf_free_bdq(qedf);
2962 }
2963 
2964 static int qedf_alloc_bdq(struct qedf_ctx *qedf)
2965 {
2966 	int i;
2967 	struct scsi_bd *pbl;
2968 	u64 *list;
2969 
2970 	/* Alloc dma memory for BDQ buffers */
2971 	for (i = 0; i < QEDF_BDQ_SIZE; i++) {
2972 		qedf->bdq[i].buf_addr = dma_alloc_coherent(&qedf->pdev->dev,
2973 		    QEDF_BDQ_BUF_SIZE, &qedf->bdq[i].buf_dma, GFP_KERNEL);
2974 		if (!qedf->bdq[i].buf_addr) {
2975 			QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate BDQ "
2976 			    "buffer %d.\n", i);
2977 			return -ENOMEM;
2978 		}
2979 	}
2980 
2981 	/* Alloc dma memory for BDQ page buffer list */
2982 	qedf->bdq_pbl_mem_size =
2983 	    QEDF_BDQ_SIZE * sizeof(struct scsi_bd);
2984 	qedf->bdq_pbl_mem_size =
2985 	    ALIGN(qedf->bdq_pbl_mem_size, QEDF_PAGE_SIZE);
2986 
2987 	qedf->bdq_pbl = dma_alloc_coherent(&qedf->pdev->dev,
2988 	    qedf->bdq_pbl_mem_size, &qedf->bdq_pbl_dma, GFP_KERNEL);
2989 	if (!qedf->bdq_pbl) {
2990 		QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate BDQ PBL.\n");
2991 		return -ENOMEM;
2992 	}
2993 
2994 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
2995 		  "BDQ PBL addr=0x%p dma=%pad\n",
2996 		  qedf->bdq_pbl, &qedf->bdq_pbl_dma);
2997 
2998 	/*
2999 	 * Populate BDQ PBL with physical and virtual address of individual
3000 	 * BDQ buffers
3001 	 */
3002 	pbl = (struct scsi_bd *)qedf->bdq_pbl;
3003 	for (i = 0; i < QEDF_BDQ_SIZE; i++) {
3004 		pbl->address.hi = cpu_to_le32(U64_HI(qedf->bdq[i].buf_dma));
3005 		pbl->address.lo = cpu_to_le32(U64_LO(qedf->bdq[i].buf_dma));
3006 		pbl->opaque.fcoe_opaque.hi = 0;
3007 		/* Opaque lo data is an index into the BDQ array */
3008 		pbl->opaque.fcoe_opaque.lo = cpu_to_le32(i);
3009 		pbl++;
3010 	}
3011 
3012 	/* Allocate list of PBL pages */
3013 	qedf->bdq_pbl_list = dma_alloc_coherent(&qedf->pdev->dev,
3014 						QEDF_PAGE_SIZE,
3015 						&qedf->bdq_pbl_list_dma,
3016 						GFP_KERNEL);
3017 	if (!qedf->bdq_pbl_list) {
3018 		QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate list of PBL pages.\n");
3019 		return -ENOMEM;
3020 	}
3021 
3022 	/*
3023 	 * Now populate PBL list with pages that contain pointers to the
3024 	 * individual buffers.
3025 	 */
3026 	qedf->bdq_pbl_list_num_entries = qedf->bdq_pbl_mem_size /
3027 	    QEDF_PAGE_SIZE;
3028 	list = (u64 *)qedf->bdq_pbl_list;
3029 	for (i = 0; i < qedf->bdq_pbl_list_num_entries; i++) {
3030 		*list = qedf->bdq_pbl_dma;
3031 		list++;
3032 	}
3033 
3034 	return 0;
3035 }
3036 
3037 static int qedf_alloc_global_queues(struct qedf_ctx *qedf)
3038 {
3039 	u32 *list;
3040 	int i;
3041 	int status;
3042 	u32 *pbl;
3043 	dma_addr_t page;
3044 	int num_pages;
3045 
3046 	/* Allocate and map CQs, RQs */
3047 	/*
3048 	 * Number of global queues (CQ / RQ). This should
3049 	 * be <= number of available MSIX vectors for the PF
3050 	 */
3051 	if (!qedf->num_queues) {
3052 		QEDF_ERR(&(qedf->dbg_ctx), "No MSI-X vectors available!\n");
3053 		return -ENOMEM;
3054 	}
3055 
3056 	/*
3057 	 * Make sure we allocated the PBL that will contain the physical
3058 	 * addresses of our queues
3059 	 */
3060 	if (!qedf->p_cpuq) {
3061 		QEDF_ERR(&qedf->dbg_ctx, "p_cpuq is NULL.\n");
3062 		return -EINVAL;
3063 	}
3064 
3065 	qedf->global_queues = kzalloc((sizeof(struct global_queue *)
3066 	    * qedf->num_queues), GFP_KERNEL);
3067 	if (!qedf->global_queues) {
3068 		QEDF_ERR(&(qedf->dbg_ctx), "Unable to allocate global "
3069 			  "queues array ptr memory\n");
3070 		return -ENOMEM;
3071 	}
3072 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3073 		   "qedf->global_queues=%p.\n", qedf->global_queues);
3074 
3075 	/* Allocate DMA coherent buffers for BDQ */
3076 	status = qedf_alloc_bdq(qedf);
3077 	if (status) {
3078 		QEDF_ERR(&qedf->dbg_ctx, "Unable to allocate bdq.\n");
3079 		goto mem_alloc_failure;
3080 	}
3081 
3082 	/* Allocate a CQ and an associated PBL for each MSI-X vector */
3083 	for (i = 0; i < qedf->num_queues; i++) {
3084 		qedf->global_queues[i] = kzalloc(sizeof(struct global_queue),
3085 		    GFP_KERNEL);
3086 		if (!qedf->global_queues[i]) {
3087 			QEDF_WARN(&(qedf->dbg_ctx), "Unable to allocate "
3088 				   "global queue %d.\n", i);
3089 			status = -ENOMEM;
3090 			goto mem_alloc_failure;
3091 		}
3092 
3093 		qedf->global_queues[i]->cq_mem_size =
3094 		    FCOE_PARAMS_CQ_NUM_ENTRIES * sizeof(struct fcoe_cqe);
3095 		qedf->global_queues[i]->cq_mem_size =
3096 		    ALIGN(qedf->global_queues[i]->cq_mem_size, QEDF_PAGE_SIZE);
3097 
3098 		qedf->global_queues[i]->cq_pbl_size =
3099 		    (qedf->global_queues[i]->cq_mem_size /
3100 		    PAGE_SIZE) * sizeof(void *);
3101 		qedf->global_queues[i]->cq_pbl_size =
3102 		    ALIGN(qedf->global_queues[i]->cq_pbl_size, QEDF_PAGE_SIZE);
3103 
3104 		qedf->global_queues[i]->cq =
3105 		    dma_alloc_coherent(&qedf->pdev->dev,
3106 				       qedf->global_queues[i]->cq_mem_size,
3107 				       &qedf->global_queues[i]->cq_dma,
3108 				       GFP_KERNEL);
3109 
3110 		if (!qedf->global_queues[i]->cq) {
3111 			QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate cq.\n");
3112 			status = -ENOMEM;
3113 			goto mem_alloc_failure;
3114 		}
3115 
3116 		qedf->global_queues[i]->cq_pbl =
3117 		    dma_alloc_coherent(&qedf->pdev->dev,
3118 				       qedf->global_queues[i]->cq_pbl_size,
3119 				       &qedf->global_queues[i]->cq_pbl_dma,
3120 				       GFP_KERNEL);
3121 
3122 		if (!qedf->global_queues[i]->cq_pbl) {
3123 			QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate cq PBL.\n");
3124 			status = -ENOMEM;
3125 			goto mem_alloc_failure;
3126 		}
3127 
3128 		/* Create PBL */
3129 		num_pages = qedf->global_queues[i]->cq_mem_size /
3130 		    QEDF_PAGE_SIZE;
3131 		page = qedf->global_queues[i]->cq_dma;
3132 		pbl = (u32 *)qedf->global_queues[i]->cq_pbl;
3133 
3134 		while (num_pages--) {
3135 			*pbl = U64_LO(page);
3136 			pbl++;
3137 			*pbl = U64_HI(page);
3138 			pbl++;
3139 			page += QEDF_PAGE_SIZE;
3140 		}
3141 		/* Set the initial consumer index for cq */
3142 		qedf->global_queues[i]->cq_cons_idx = 0;
3143 	}
3144 
3145 	list = (u32 *)qedf->p_cpuq;
3146 
3147 	/*
3148 	 * The list is built as follows: CQ#0 PBL pointer, RQ#0 PBL pointer,
3149 	 * CQ#1 PBL pointer, RQ#1 PBL pointer, etc.  Each PBL pointer points
3150 	 * to the physical address which contains an array of pointers to
3151 	 * the physical addresses of the specific queue pages.
3152 	 */
3153 	for (i = 0; i < qedf->num_queues; i++) {
3154 		*list = U64_LO(qedf->global_queues[i]->cq_pbl_dma);
3155 		list++;
3156 		*list = U64_HI(qedf->global_queues[i]->cq_pbl_dma);
3157 		list++;
3158 		*list = U64_LO(0);
3159 		list++;
3160 		*list = U64_HI(0);
3161 		list++;
3162 	}
3163 
3164 	return 0;
3165 
3166 mem_alloc_failure:
3167 	qedf_free_global_queues(qedf);
3168 	return status;
3169 }
3170 
3171 static int qedf_set_fcoe_pf_param(struct qedf_ctx *qedf)
3172 {
3173 	u8 sq_num_pbl_pages;
3174 	u32 sq_mem_size;
3175 	u32 cq_mem_size;
3176 	u32 cq_num_entries;
3177 	int rval;
3178 
3179 	/*
3180 	 * The number of completion queues/fastpath interrupts/status blocks
3181 	 * we allocation is the minimum off:
3182 	 *
3183 	 * Number of CPUs
3184 	 * Number allocated by qed for our PCI function
3185 	 */
3186 	qedf->num_queues = MIN_NUM_CPUS_MSIX(qedf);
3187 
3188 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Number of CQs is %d.\n",
3189 		   qedf->num_queues);
3190 
3191 	qedf->p_cpuq = dma_alloc_coherent(&qedf->pdev->dev,
3192 	    qedf->num_queues * sizeof(struct qedf_glbl_q_params),
3193 	    &qedf->hw_p_cpuq, GFP_KERNEL);
3194 
3195 	if (!qedf->p_cpuq) {
3196 		QEDF_ERR(&(qedf->dbg_ctx), "dma_alloc_coherent failed.\n");
3197 		return 1;
3198 	}
3199 
3200 	rval = qedf_alloc_global_queues(qedf);
3201 	if (rval) {
3202 		QEDF_ERR(&(qedf->dbg_ctx), "Global queue allocation "
3203 			  "failed.\n");
3204 		return 1;
3205 	}
3206 
3207 	/* Calculate SQ PBL size in the same manner as in qedf_sq_alloc() */
3208 	sq_mem_size = SQ_NUM_ENTRIES * sizeof(struct fcoe_wqe);
3209 	sq_mem_size = ALIGN(sq_mem_size, QEDF_PAGE_SIZE);
3210 	sq_num_pbl_pages = (sq_mem_size / QEDF_PAGE_SIZE);
3211 
3212 	/* Calculate CQ num entries */
3213 	cq_mem_size = FCOE_PARAMS_CQ_NUM_ENTRIES * sizeof(struct fcoe_cqe);
3214 	cq_mem_size = ALIGN(cq_mem_size, QEDF_PAGE_SIZE);
3215 	cq_num_entries = cq_mem_size / sizeof(struct fcoe_cqe);
3216 
3217 	memset(&(qedf->pf_params), 0, sizeof(qedf->pf_params));
3218 
3219 	/* Setup the value for fcoe PF */
3220 	qedf->pf_params.fcoe_pf_params.num_cons = QEDF_MAX_SESSIONS;
3221 	qedf->pf_params.fcoe_pf_params.num_tasks = FCOE_PARAMS_NUM_TASKS;
3222 	qedf->pf_params.fcoe_pf_params.glbl_q_params_addr =
3223 	    (u64)qedf->hw_p_cpuq;
3224 	qedf->pf_params.fcoe_pf_params.sq_num_pbl_pages = sq_num_pbl_pages;
3225 
3226 	qedf->pf_params.fcoe_pf_params.rq_buffer_log_size = 0;
3227 
3228 	qedf->pf_params.fcoe_pf_params.cq_num_entries = cq_num_entries;
3229 	qedf->pf_params.fcoe_pf_params.num_cqs = qedf->num_queues;
3230 
3231 	/* log_page_size: 12 for 4KB pages */
3232 	qedf->pf_params.fcoe_pf_params.log_page_size = ilog2(QEDF_PAGE_SIZE);
3233 
3234 	qedf->pf_params.fcoe_pf_params.mtu = 9000;
3235 	qedf->pf_params.fcoe_pf_params.gl_rq_pi = QEDF_FCOE_PARAMS_GL_RQ_PI;
3236 	qedf->pf_params.fcoe_pf_params.gl_cmd_pi = QEDF_FCOE_PARAMS_GL_CMD_PI;
3237 
3238 	/* BDQ address and size */
3239 	qedf->pf_params.fcoe_pf_params.bdq_pbl_base_addr[0] =
3240 	    qedf->bdq_pbl_list_dma;
3241 	qedf->pf_params.fcoe_pf_params.bdq_pbl_num_entries[0] =
3242 	    qedf->bdq_pbl_list_num_entries;
3243 	qedf->pf_params.fcoe_pf_params.rq_buffer_size = QEDF_BDQ_BUF_SIZE;
3244 
3245 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3246 	    "bdq_list=%p bdq_pbl_list_dma=%llx bdq_pbl_list_entries=%d.\n",
3247 	    qedf->bdq_pbl_list,
3248 	    qedf->pf_params.fcoe_pf_params.bdq_pbl_base_addr[0],
3249 	    qedf->pf_params.fcoe_pf_params.bdq_pbl_num_entries[0]);
3250 
3251 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3252 	    "cq_num_entries=%d.\n",
3253 	    qedf->pf_params.fcoe_pf_params.cq_num_entries);
3254 
3255 	return 0;
3256 }
3257 
3258 /* Free DMA coherent memory for array of queue pointers we pass to qed */
3259 static void qedf_free_fcoe_pf_param(struct qedf_ctx *qedf)
3260 {
3261 	size_t size = 0;
3262 
3263 	if (qedf->p_cpuq) {
3264 		size = qedf->num_queues * sizeof(struct qedf_glbl_q_params);
3265 		dma_free_coherent(&qedf->pdev->dev, size, qedf->p_cpuq,
3266 		    qedf->hw_p_cpuq);
3267 	}
3268 
3269 	qedf_free_global_queues(qedf);
3270 
3271 	kfree(qedf->global_queues);
3272 }
3273 
3274 /*
3275  * PCI driver functions
3276  */
3277 
3278 static const struct pci_device_id qedf_pci_tbl[] = {
3279 	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, 0x165c) },
3280 	{ PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, 0x8080) },
3281 	{0}
3282 };
3283 MODULE_DEVICE_TABLE(pci, qedf_pci_tbl);
3284 
3285 static struct pci_driver qedf_pci_driver = {
3286 	.name = QEDF_MODULE_NAME,
3287 	.id_table = qedf_pci_tbl,
3288 	.probe = qedf_probe,
3289 	.remove = qedf_remove,
3290 	.shutdown = qedf_shutdown,
3291 	.suspend = qedf_suspend,
3292 };
3293 
3294 static int __qedf_probe(struct pci_dev *pdev, int mode)
3295 {
3296 	int rc = -EINVAL;
3297 	struct fc_lport *lport;
3298 	struct qedf_ctx *qedf = NULL;
3299 	struct Scsi_Host *host;
3300 	bool is_vf = false;
3301 	struct qed_ll2_params params;
3302 	char host_buf[20];
3303 	struct qed_link_params link_params;
3304 	int status;
3305 	void *task_start, *task_end;
3306 	struct qed_slowpath_params slowpath_params;
3307 	struct qed_probe_params qed_params;
3308 	u16 retry_cnt = 10;
3309 
3310 	/*
3311 	 * When doing error recovery we didn't reap the lport so don't try
3312 	 * to reallocate it.
3313 	 */
3314 retry_probe:
3315 	if (mode == QEDF_MODE_RECOVERY)
3316 		msleep(2000);
3317 
3318 	if (mode != QEDF_MODE_RECOVERY) {
3319 		lport = libfc_host_alloc(&qedf_host_template,
3320 		    sizeof(struct qedf_ctx));
3321 
3322 		if (!lport) {
3323 			QEDF_ERR(NULL, "Could not allocate lport.\n");
3324 			rc = -ENOMEM;
3325 			goto err0;
3326 		}
3327 
3328 		fc_disc_init(lport);
3329 
3330 		/* Initialize qedf_ctx */
3331 		qedf = lport_priv(lport);
3332 		set_bit(QEDF_PROBING, &qedf->flags);
3333 		qedf->lport = lport;
3334 		qedf->ctlr.lp = lport;
3335 		qedf->pdev = pdev;
3336 		qedf->dbg_ctx.pdev = pdev;
3337 		qedf->dbg_ctx.host_no = lport->host->host_no;
3338 		spin_lock_init(&qedf->hba_lock);
3339 		INIT_LIST_HEAD(&qedf->fcports);
3340 		qedf->curr_conn_id = QEDF_MAX_SESSIONS - 1;
3341 		atomic_set(&qedf->num_offloads, 0);
3342 		qedf->stop_io_on_error = false;
3343 		pci_set_drvdata(pdev, qedf);
3344 		init_completion(&qedf->fipvlan_compl);
3345 		mutex_init(&qedf->stats_mutex);
3346 		mutex_init(&qedf->flush_mutex);
3347 		qedf->flogi_pending = 0;
3348 
3349 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_INFO,
3350 		   "QLogic FastLinQ FCoE Module qedf %s, "
3351 		   "FW %d.%d.%d.%d\n", QEDF_VERSION,
3352 		   FW_MAJOR_VERSION, FW_MINOR_VERSION, FW_REVISION_VERSION,
3353 		   FW_ENGINEERING_VERSION);
3354 	} else {
3355 		/* Init pointers during recovery */
3356 		qedf = pci_get_drvdata(pdev);
3357 		set_bit(QEDF_PROBING, &qedf->flags);
3358 		lport = qedf->lport;
3359 	}
3360 
3361 	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC, "Probe started.\n");
3362 
3363 	host = lport->host;
3364 
3365 	/* Allocate mempool for qedf_io_work structs */
3366 	qedf->io_mempool = mempool_create_slab_pool(QEDF_IO_WORK_MIN,
3367 	    qedf_io_work_cache);
3368 	if (qedf->io_mempool == NULL) {
3369 		QEDF_ERR(&(qedf->dbg_ctx), "qedf->io_mempool is NULL.\n");
3370 		goto err1;
3371 	}
3372 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_INFO, "qedf->io_mempool=%p.\n",
3373 	    qedf->io_mempool);
3374 
3375 	qedf->link_update_wq = alloc_workqueue("qedf_%u_link", WQ_MEM_RECLAIM,
3376 					       1, qedf->lport->host->host_no);
3377 	INIT_DELAYED_WORK(&qedf->link_update, qedf_handle_link_update);
3378 	INIT_DELAYED_WORK(&qedf->link_recovery, qedf_link_recovery);
3379 	INIT_DELAYED_WORK(&qedf->grcdump_work, qedf_wq_grcdump);
3380 	INIT_DELAYED_WORK(&qedf->stag_work, qedf_stag_change_work);
3381 	qedf->fipvlan_retries = qedf_fipvlan_retries;
3382 	/* Set a default prio in case DCBX doesn't converge */
3383 	if (qedf_default_prio > -1) {
3384 		/*
3385 		 * This is the case where we pass a modparam in so we want to
3386 		 * honor it even if dcbx doesn't converge.
3387 		 */
3388 		qedf->prio = qedf_default_prio;
3389 	} else
3390 		qedf->prio = QEDF_DEFAULT_PRIO;
3391 
3392 	/*
3393 	 * Common probe. Takes care of basic hardware init and pci_*
3394 	 * functions.
3395 	 */
3396 	memset(&qed_params, 0, sizeof(qed_params));
3397 	qed_params.protocol = QED_PROTOCOL_FCOE;
3398 	qed_params.dp_module = qedf_dp_module;
3399 	qed_params.dp_level = qedf_dp_level;
3400 	qed_params.is_vf = is_vf;
3401 	qedf->cdev = qed_ops->common->probe(pdev, &qed_params);
3402 	if (!qedf->cdev) {
3403 		if ((mode == QEDF_MODE_RECOVERY) && retry_cnt) {
3404 			QEDF_ERR(&qedf->dbg_ctx,
3405 				"Retry %d initialize hardware\n", retry_cnt);
3406 			retry_cnt--;
3407 			goto retry_probe;
3408 		}
3409 		QEDF_ERR(&qedf->dbg_ctx, "common probe failed.\n");
3410 		rc = -ENODEV;
3411 		goto err1;
3412 	}
3413 
3414 	/* Learn information crucial for qedf to progress */
3415 	rc = qed_ops->fill_dev_info(qedf->cdev, &qedf->dev_info);
3416 	if (rc) {
3417 		QEDF_ERR(&(qedf->dbg_ctx), "Failed to dev info.\n");
3418 		goto err1;
3419 	}
3420 
3421 	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
3422 		  "dev_info: num_hwfns=%d affin_hwfn_idx=%d.\n",
3423 		  qedf->dev_info.common.num_hwfns,
3424 		  qed_ops->common->get_affin_hwfn_idx(qedf->cdev));
3425 
3426 	/* queue allocation code should come here
3427 	 * order should be
3428 	 * 	slowpath_start
3429 	 * 	status block allocation
3430 	 *	interrupt registration (to get min number of queues)
3431 	 *	set_fcoe_pf_param
3432 	 *	qed_sp_fcoe_func_start
3433 	 */
3434 	rc = qedf_set_fcoe_pf_param(qedf);
3435 	if (rc) {
3436 		QEDF_ERR(&(qedf->dbg_ctx), "Cannot set fcoe pf param.\n");
3437 		goto err2;
3438 	}
3439 	qed_ops->common->update_pf_params(qedf->cdev, &qedf->pf_params);
3440 
3441 	/* Learn information crucial for qedf to progress */
3442 	rc = qed_ops->fill_dev_info(qedf->cdev, &qedf->dev_info);
3443 	if (rc) {
3444 		QEDF_ERR(&qedf->dbg_ctx, "Failed to fill dev info.\n");
3445 		goto err2;
3446 	}
3447 
3448 	if (mode != QEDF_MODE_RECOVERY) {
3449 		qedf->devlink = qed_ops->common->devlink_register(qedf->cdev);
3450 		if (IS_ERR(qedf->devlink)) {
3451 			QEDF_ERR(&qedf->dbg_ctx, "Cannot register devlink\n");
3452 			rc = PTR_ERR(qedf->devlink);
3453 			qedf->devlink = NULL;
3454 			goto err2;
3455 		}
3456 	}
3457 
3458 	/* Record BDQ producer doorbell addresses */
3459 	qedf->bdq_primary_prod = qedf->dev_info.primary_dbq_rq_addr;
3460 	qedf->bdq_secondary_prod = qedf->dev_info.secondary_bdq_rq_addr;
3461 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3462 	    "BDQ primary_prod=%p secondary_prod=%p.\n", qedf->bdq_primary_prod,
3463 	    qedf->bdq_secondary_prod);
3464 
3465 	qed_ops->register_ops(qedf->cdev, &qedf_cb_ops, qedf);
3466 
3467 	rc = qedf_prepare_sb(qedf);
3468 	if (rc) {
3469 
3470 		QEDF_ERR(&(qedf->dbg_ctx), "Cannot start slowpath.\n");
3471 		goto err2;
3472 	}
3473 
3474 	/* Start the Slowpath-process */
3475 	memset(&slowpath_params, 0, sizeof(struct qed_slowpath_params));
3476 	slowpath_params.int_mode = QED_INT_MODE_MSIX;
3477 	slowpath_params.drv_major = QEDF_DRIVER_MAJOR_VER;
3478 	slowpath_params.drv_minor = QEDF_DRIVER_MINOR_VER;
3479 	slowpath_params.drv_rev = QEDF_DRIVER_REV_VER;
3480 	slowpath_params.drv_eng = QEDF_DRIVER_ENG_VER;
3481 	strscpy(slowpath_params.name, "qedf", sizeof(slowpath_params.name));
3482 	rc = qed_ops->common->slowpath_start(qedf->cdev, &slowpath_params);
3483 	if (rc) {
3484 		QEDF_ERR(&(qedf->dbg_ctx), "Cannot start slowpath.\n");
3485 		goto err2;
3486 	}
3487 
3488 	/*
3489 	 * update_pf_params needs to be called before and after slowpath
3490 	 * start
3491 	 */
3492 	qed_ops->common->update_pf_params(qedf->cdev, &qedf->pf_params);
3493 
3494 	/* Setup interrupts */
3495 	rc = qedf_setup_int(qedf);
3496 	if (rc) {
3497 		QEDF_ERR(&qedf->dbg_ctx, "Setup interrupts failed.\n");
3498 		goto err3;
3499 	}
3500 
3501 	rc = qed_ops->start(qedf->cdev, &qedf->tasks);
3502 	if (rc) {
3503 		QEDF_ERR(&(qedf->dbg_ctx), "Cannot start FCoE function.\n");
3504 		goto err4;
3505 	}
3506 	task_start = qedf_get_task_mem(&qedf->tasks, 0);
3507 	task_end = qedf_get_task_mem(&qedf->tasks, MAX_TID_BLOCKS_FCOE - 1);
3508 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Task context start=%p, "
3509 		   "end=%p block_size=%u.\n", task_start, task_end,
3510 		   qedf->tasks.size);
3511 
3512 	/*
3513 	 * We need to write the number of BDs in the BDQ we've preallocated so
3514 	 * the f/w will do a prefetch and we'll get an unsolicited CQE when a
3515 	 * packet arrives.
3516 	 */
3517 	qedf->bdq_prod_idx = QEDF_BDQ_SIZE;
3518 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3519 	    "Writing %d to primary and secondary BDQ doorbell registers.\n",
3520 	    qedf->bdq_prod_idx);
3521 	writew(qedf->bdq_prod_idx, qedf->bdq_primary_prod);
3522 	readw(qedf->bdq_primary_prod);
3523 	writew(qedf->bdq_prod_idx, qedf->bdq_secondary_prod);
3524 	readw(qedf->bdq_secondary_prod);
3525 
3526 	qed_ops->common->set_power_state(qedf->cdev, PCI_D0);
3527 
3528 	/* Now that the dev_info struct has been filled in set the MAC
3529 	 * address
3530 	 */
3531 	ether_addr_copy(qedf->mac, qedf->dev_info.common.hw_mac);
3532 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "MAC address is %pM.\n",
3533 		   qedf->mac);
3534 
3535 	/*
3536 	 * Set the WWNN and WWPN in the following way:
3537 	 *
3538 	 * If the info we get from qed is non-zero then use that to set the
3539 	 * WWPN and WWNN. Otherwise fall back to use fcoe_wwn_from_mac() based
3540 	 * on the MAC address.
3541 	 */
3542 	if (qedf->dev_info.wwnn != 0 && qedf->dev_info.wwpn != 0) {
3543 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3544 		    "Setting WWPN and WWNN from qed dev_info.\n");
3545 		qedf->wwnn = qedf->dev_info.wwnn;
3546 		qedf->wwpn = qedf->dev_info.wwpn;
3547 	} else {
3548 		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3549 		    "Setting WWPN and WWNN using fcoe_wwn_from_mac().\n");
3550 		qedf->wwnn = fcoe_wwn_from_mac(qedf->mac, 1, 0);
3551 		qedf->wwpn = fcoe_wwn_from_mac(qedf->mac, 2, 0);
3552 	}
3553 	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,  "WWNN=%016llx "
3554 		   "WWPN=%016llx.\n", qedf->wwnn, qedf->wwpn);
3555 
3556 	sprintf(host_buf, "host_%d", host->host_no);
3557 	qed_ops->common->set_name(qedf->cdev, host_buf);
3558 
3559 	/* Allocate cmd mgr */
3560 	qedf->cmd_mgr = qedf_cmd_mgr_alloc(qedf);
3561 	if (!qedf->cmd_mgr) {
3562 		QEDF_ERR(&(qedf->dbg_ctx), "Failed to allocate cmd mgr.\n");
3563 		rc = -ENOMEM;
3564 		goto err5;
3565 	}
3566 
3567 	if (mode != QEDF_MODE_RECOVERY) {
3568 		host->transportt = qedf_fc_transport_template;
3569 		host->max_lun = qedf_max_lun;
3570 		host->max_cmd_len = QEDF_MAX_CDB_LEN;
3571 		host->max_id = QEDF_MAX_SESSIONS;
3572 		host->can_queue = FCOE_PARAMS_NUM_TASKS;
3573 		rc = scsi_add_host(host, &pdev->dev);
3574 		if (rc) {
3575 			QEDF_WARN(&qedf->dbg_ctx,
3576 				  "Error adding Scsi_Host rc=0x%x.\n", rc);
3577 			goto err6;
3578 		}
3579 	}
3580 
3581 	memset(&params, 0, sizeof(params));
3582 	params.mtu = QEDF_LL2_BUF_SIZE;
3583 	ether_addr_copy(params.ll2_mac_address, qedf->mac);
3584 
3585 	/* Start LL2 processing thread */
3586 	qedf->ll2_recv_wq = alloc_workqueue("qedf_%d_ll2", WQ_MEM_RECLAIM, 1,
3587 					    host->host_no);
3588 	if (!qedf->ll2_recv_wq) {
3589 		QEDF_ERR(&(qedf->dbg_ctx), "Failed to LL2 workqueue.\n");
3590 		rc = -ENOMEM;
3591 		goto err7;
3592 	}
3593 
3594 #ifdef CONFIG_DEBUG_FS
3595 	qedf_dbg_host_init(&(qedf->dbg_ctx), qedf_debugfs_ops,
3596 			    qedf_dbg_fops);
3597 #endif
3598 
3599 	/* Start LL2 */
3600 	qed_ops->ll2->register_cb_ops(qedf->cdev, &qedf_ll2_cb_ops, qedf);
3601 	rc = qed_ops->ll2->start(qedf->cdev, &params);
3602 	if (rc) {
3603 		QEDF_ERR(&(qedf->dbg_ctx), "Could not start Light L2.\n");
3604 		goto err7;
3605 	}
3606 	set_bit(QEDF_LL2_STARTED, &qedf->flags);
3607 
3608 	/* Set initial FIP/FCoE VLAN to NULL */
3609 	qedf->vlan_id = 0;
3610 
3611 	/*
3612 	 * No need to setup fcoe_ctlr or fc_lport objects during recovery since
3613 	 * they were not reaped during the unload process.
3614 	 */
3615 	if (mode != QEDF_MODE_RECOVERY) {
3616 		/* Setup imbedded fcoe controller */
3617 		qedf_fcoe_ctlr_setup(qedf);
3618 
3619 		/* Setup lport */
3620 		rc = qedf_lport_setup(qedf);
3621 		if (rc) {
3622 			QEDF_ERR(&(qedf->dbg_ctx),
3623 			    "qedf_lport_setup failed.\n");
3624 			goto err7;
3625 		}
3626 	}
3627 
3628 	qedf->timer_work_queue = alloc_workqueue("qedf_%u_timer",
3629 				WQ_MEM_RECLAIM, 1, qedf->lport->host->host_no);
3630 	if (!qedf->timer_work_queue) {
3631 		QEDF_ERR(&(qedf->dbg_ctx), "Failed to start timer "
3632 			  "workqueue.\n");
3633 		rc = -ENOMEM;
3634 		goto err7;
3635 	}
3636 
3637 	/* DPC workqueue is not reaped during recovery unload */
3638 	if (mode != QEDF_MODE_RECOVERY) {
3639 		sprintf(host_buf, "qedf_%u_dpc",
3640 		    qedf->lport->host->host_no);
3641 		qedf->dpc_wq =
3642 			alloc_workqueue("%s", WQ_MEM_RECLAIM, 1, host_buf);
3643 	}
3644 	INIT_DELAYED_WORK(&qedf->recovery_work, qedf_recovery_handler);
3645 
3646 	/*
3647 	 * GRC dump and sysfs parameters are not reaped during the recovery
3648 	 * unload process.
3649 	 */
3650 	if (mode != QEDF_MODE_RECOVERY) {
3651 		qedf->grcdump_size =
3652 		    qed_ops->common->dbg_all_data_size(qedf->cdev);
3653 		if (qedf->grcdump_size) {
3654 			rc = qedf_alloc_grc_dump_buf(&qedf->grcdump,
3655 			    qedf->grcdump_size);
3656 			if (rc) {
3657 				QEDF_ERR(&(qedf->dbg_ctx),
3658 				    "GRC Dump buffer alloc failed.\n");
3659 				qedf->grcdump = NULL;
3660 			}
3661 
3662 			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
3663 			    "grcdump: addr=%p, size=%u.\n",
3664 			    qedf->grcdump, qedf->grcdump_size);
3665 		}
3666 		qedf_create_sysfs_ctx_attr(qedf);
3667 
3668 		/* Initialize I/O tracing for this adapter */
3669 		spin_lock_init(&qedf->io_trace_lock);
3670 		qedf->io_trace_idx = 0;
3671 	}
3672 
3673 	init_completion(&qedf->flogi_compl);
3674 
3675 	status = qed_ops->common->update_drv_state(qedf->cdev, true);
3676 	if (status)
3677 		QEDF_ERR(&(qedf->dbg_ctx),
3678 			"Failed to send drv state to MFW.\n");
3679 
3680 	memset(&link_params, 0, sizeof(struct qed_link_params));
3681 	link_params.link_up = true;
3682 	status = qed_ops->common->set_link(qedf->cdev, &link_params);
3683 	if (status)
3684 		QEDF_WARN(&(qedf->dbg_ctx), "set_link failed.\n");
3685 
3686 	/* Start/restart discovery */
3687 	if (mode == QEDF_MODE_RECOVERY)
3688 		fcoe_ctlr_link_up(&qedf->ctlr);
3689 	else
3690 		fc_fabric_login(lport);
3691 
3692 	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC, "Probe done.\n");
3693 
3694 	clear_bit(QEDF_PROBING, &qedf->flags);
3695 
3696 	/* All good */
3697 	return 0;
3698 
3699 err7:
3700 	if (qedf->ll2_recv_wq)
3701 		destroy_workqueue(qedf->ll2_recv_wq);
3702 	fc_remove_host(qedf->lport->host);
3703 	scsi_remove_host(qedf->lport->host);
3704 #ifdef CONFIG_DEBUG_FS
3705 	qedf_dbg_host_exit(&(qedf->dbg_ctx));
3706 #endif
3707 err6:
3708 	qedf_cmd_mgr_free(qedf->cmd_mgr);
3709 err5:
3710 	qed_ops->stop(qedf->cdev);
3711 err4:
3712 	qedf_free_fcoe_pf_param(qedf);
3713 	qedf_sync_free_irqs(qedf);
3714 err3:
3715 	qed_ops->common->slowpath_stop(qedf->cdev);
3716 err2:
3717 	qed_ops->common->remove(qedf->cdev);
3718 err1:
3719 	scsi_host_put(lport->host);
3720 err0:
3721 	return rc;
3722 }
3723 
3724 static int qedf_probe(struct pci_dev *pdev, const struct pci_device_id *id)
3725 {
3726 	return __qedf_probe(pdev, QEDF_MODE_NORMAL);
3727 }
3728 
3729 static void __qedf_remove(struct pci_dev *pdev, int mode)
3730 {
3731 	struct qedf_ctx *qedf;
3732 	int rc;
3733 	int cnt = 0;
3734 
3735 	if (!pdev) {
3736 		QEDF_ERR(NULL, "pdev is NULL.\n");
3737 		return;
3738 	}
3739 
3740 	qedf = pci_get_drvdata(pdev);
3741 
3742 	/*
3743 	 * Prevent race where we're in board disable work and then try to
3744 	 * rmmod the module.
3745 	 */
3746 	if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
3747 		QEDF_ERR(&qedf->dbg_ctx, "Already removing PCI function.\n");
3748 		return;
3749 	}
3750 
3751 stag_in_prog:
3752 	if (test_bit(QEDF_STAG_IN_PROGRESS, &qedf->flags)) {
3753 		QEDF_ERR(&qedf->dbg_ctx, "Stag in progress, cnt=%d.\n", cnt);
3754 		cnt++;
3755 
3756 		if (cnt < 5) {
3757 			msleep(500);
3758 			goto stag_in_prog;
3759 		}
3760 	}
3761 
3762 	if (mode != QEDF_MODE_RECOVERY)
3763 		set_bit(QEDF_UNLOADING, &qedf->flags);
3764 
3765 	/* Logoff the fabric to upload all connections */
3766 	if (mode == QEDF_MODE_RECOVERY)
3767 		fcoe_ctlr_link_down(&qedf->ctlr);
3768 	else
3769 		fc_fabric_logoff(qedf->lport);
3770 
3771 	if (!qedf_wait_for_upload(qedf))
3772 		QEDF_ERR(&qedf->dbg_ctx, "Could not upload all sessions.\n");
3773 
3774 #ifdef CONFIG_DEBUG_FS
3775 	qedf_dbg_host_exit(&(qedf->dbg_ctx));
3776 #endif
3777 
3778 	/* Stop any link update handling */
3779 	cancel_delayed_work_sync(&qedf->link_update);
3780 	destroy_workqueue(qedf->link_update_wq);
3781 	qedf->link_update_wq = NULL;
3782 
3783 	if (qedf->timer_work_queue)
3784 		destroy_workqueue(qedf->timer_work_queue);
3785 
3786 	/* Stop Light L2 */
3787 	clear_bit(QEDF_LL2_STARTED, &qedf->flags);
3788 	qed_ops->ll2->stop(qedf->cdev);
3789 	if (qedf->ll2_recv_wq)
3790 		destroy_workqueue(qedf->ll2_recv_wq);
3791 
3792 	/* Stop fastpath */
3793 	qedf_sync_free_irqs(qedf);
3794 	qedf_destroy_sb(qedf);
3795 
3796 	/*
3797 	 * During recovery don't destroy OS constructs that represent the
3798 	 * physical port.
3799 	 */
3800 	if (mode != QEDF_MODE_RECOVERY) {
3801 		qedf_free_grc_dump_buf(&qedf->grcdump);
3802 		qedf_remove_sysfs_ctx_attr(qedf);
3803 
3804 		/* Remove all SCSI/libfc/libfcoe structures */
3805 		fcoe_ctlr_destroy(&qedf->ctlr);
3806 		fc_lport_destroy(qedf->lport);
3807 		fc_remove_host(qedf->lport->host);
3808 		scsi_remove_host(qedf->lport->host);
3809 	}
3810 
3811 	qedf_cmd_mgr_free(qedf->cmd_mgr);
3812 
3813 	if (mode != QEDF_MODE_RECOVERY) {
3814 		fc_exch_mgr_free(qedf->lport);
3815 		fc_lport_free_stats(qedf->lport);
3816 
3817 		/* Wait for all vports to be reaped */
3818 		qedf_wait_for_vport_destroy(qedf);
3819 	}
3820 
3821 	/*
3822 	 * Now that all connections have been uploaded we can stop the
3823 	 * rest of the qed operations
3824 	 */
3825 	qed_ops->stop(qedf->cdev);
3826 
3827 	if (mode != QEDF_MODE_RECOVERY) {
3828 		if (qedf->dpc_wq) {
3829 			/* Stop general DPC handling */
3830 			destroy_workqueue(qedf->dpc_wq);
3831 			qedf->dpc_wq = NULL;
3832 		}
3833 	}
3834 
3835 	/* Final shutdown for the board */
3836 	qedf_free_fcoe_pf_param(qedf);
3837 	if (mode != QEDF_MODE_RECOVERY) {
3838 		qed_ops->common->set_power_state(qedf->cdev, PCI_D0);
3839 		pci_set_drvdata(pdev, NULL);
3840 	}
3841 
3842 	rc = qed_ops->common->update_drv_state(qedf->cdev, false);
3843 	if (rc)
3844 		QEDF_ERR(&(qedf->dbg_ctx),
3845 			"Failed to send drv state to MFW.\n");
3846 
3847 	if (mode != QEDF_MODE_RECOVERY && qedf->devlink) {
3848 		qed_ops->common->devlink_unregister(qedf->devlink);
3849 		qedf->devlink = NULL;
3850 	}
3851 
3852 	qed_ops->common->slowpath_stop(qedf->cdev);
3853 	qed_ops->common->remove(qedf->cdev);
3854 
3855 	mempool_destroy(qedf->io_mempool);
3856 
3857 	/* Only reap the Scsi_host on a real removal */
3858 	if (mode != QEDF_MODE_RECOVERY)
3859 		scsi_host_put(qedf->lport->host);
3860 }
3861 
3862 static void qedf_remove(struct pci_dev *pdev)
3863 {
3864 	/* Check to make sure this function wasn't already disabled */
3865 	if (!atomic_read(&pdev->enable_cnt))
3866 		return;
3867 
3868 	__qedf_remove(pdev, QEDF_MODE_NORMAL);
3869 }
3870 
3871 void qedf_wq_grcdump(struct work_struct *work)
3872 {
3873 	struct qedf_ctx *qedf =
3874 	    container_of(work, struct qedf_ctx, grcdump_work.work);
3875 
3876 	QEDF_ERR(&(qedf->dbg_ctx), "Collecting GRC dump.\n");
3877 	qedf_capture_grc_dump(qedf);
3878 }
3879 
3880 void qedf_schedule_hw_err_handler(void *dev, enum qed_hw_err_type err_type)
3881 {
3882 	struct qedf_ctx *qedf = dev;
3883 
3884 	QEDF_ERR(&(qedf->dbg_ctx),
3885 			"Hardware error handler scheduled, event=%d.\n",
3886 			err_type);
3887 
3888 	if (test_bit(QEDF_IN_RECOVERY, &qedf->flags)) {
3889 		QEDF_ERR(&(qedf->dbg_ctx),
3890 				"Already in recovery, not scheduling board disable work.\n");
3891 		return;
3892 	}
3893 
3894 	switch (err_type) {
3895 	case QED_HW_ERR_FAN_FAIL:
3896 		schedule_delayed_work(&qedf->board_disable_work, 0);
3897 		break;
3898 	case QED_HW_ERR_MFW_RESP_FAIL:
3899 	case QED_HW_ERR_HW_ATTN:
3900 	case QED_HW_ERR_DMAE_FAIL:
3901 	case QED_HW_ERR_FW_ASSERT:
3902 		/* Prevent HW attentions from being reasserted */
3903 		qed_ops->common->attn_clr_enable(qedf->cdev, true);
3904 		break;
3905 	case QED_HW_ERR_RAMROD_FAIL:
3906 		/* Prevent HW attentions from being reasserted */
3907 		qed_ops->common->attn_clr_enable(qedf->cdev, true);
3908 
3909 		if (qedf_enable_recovery && qedf->devlink)
3910 			qed_ops->common->report_fatal_error(qedf->devlink,
3911 				err_type);
3912 
3913 		break;
3914 	default:
3915 		break;
3916 	}
3917 }
3918 
3919 /*
3920  * Protocol TLV handler
3921  */
3922 void qedf_get_protocol_tlv_data(void *dev, void *data)
3923 {
3924 	struct qedf_ctx *qedf = dev;
3925 	struct qed_mfw_tlv_fcoe *fcoe = data;
3926 	struct fc_lport *lport;
3927 	struct Scsi_Host *host;
3928 	struct fc_host_attrs *fc_host;
3929 	struct fc_host_statistics *hst;
3930 
3931 	if (!qedf) {
3932 		QEDF_ERR(NULL, "qedf is null.\n");
3933 		return;
3934 	}
3935 
3936 	if (test_bit(QEDF_PROBING, &qedf->flags)) {
3937 		QEDF_ERR(&qedf->dbg_ctx, "Function is still probing.\n");
3938 		return;
3939 	}
3940 
3941 	lport = qedf->lport;
3942 	host = lport->host;
3943 	fc_host = shost_to_fc_host(host);
3944 
3945 	/* Force a refresh of the fc_host stats including offload stats */
3946 	hst = qedf_fc_get_host_stats(host);
3947 
3948 	fcoe->qos_pri_set = true;
3949 	fcoe->qos_pri = 3; /* Hard coded to 3 in driver */
3950 
3951 	fcoe->ra_tov_set = true;
3952 	fcoe->ra_tov = lport->r_a_tov;
3953 
3954 	fcoe->ed_tov_set = true;
3955 	fcoe->ed_tov = lport->e_d_tov;
3956 
3957 	fcoe->npiv_state_set = true;
3958 	fcoe->npiv_state = 1; /* NPIV always enabled */
3959 
3960 	fcoe->num_npiv_ids_set = true;
3961 	fcoe->num_npiv_ids = fc_host->npiv_vports_inuse;
3962 
3963 	/* Certain attributes we only want to set if we've selected an FCF */
3964 	if (qedf->ctlr.sel_fcf) {
3965 		fcoe->switch_name_set = true;
3966 		u64_to_wwn(qedf->ctlr.sel_fcf->switch_name, fcoe->switch_name);
3967 	}
3968 
3969 	fcoe->port_state_set = true;
3970 	/* For qedf we're either link down or fabric attach */
3971 	if (lport->link_up)
3972 		fcoe->port_state = QED_MFW_TLV_PORT_STATE_FABRIC;
3973 	else
3974 		fcoe->port_state = QED_MFW_TLV_PORT_STATE_OFFLINE;
3975 
3976 	fcoe->link_failures_set = true;
3977 	fcoe->link_failures = (u16)hst->link_failure_count;
3978 
3979 	fcoe->fcoe_txq_depth_set = true;
3980 	fcoe->fcoe_rxq_depth_set = true;
3981 	fcoe->fcoe_rxq_depth = FCOE_PARAMS_NUM_TASKS;
3982 	fcoe->fcoe_txq_depth = FCOE_PARAMS_NUM_TASKS;
3983 
3984 	fcoe->fcoe_rx_frames_set = true;
3985 	fcoe->fcoe_rx_frames = hst->rx_frames;
3986 
3987 	fcoe->fcoe_tx_frames_set = true;
3988 	fcoe->fcoe_tx_frames = hst->tx_frames;
3989 
3990 	fcoe->fcoe_rx_bytes_set = true;
3991 	fcoe->fcoe_rx_bytes = hst->fcp_input_megabytes * 1000000;
3992 
3993 	fcoe->fcoe_tx_bytes_set = true;
3994 	fcoe->fcoe_tx_bytes = hst->fcp_output_megabytes * 1000000;
3995 
3996 	fcoe->crc_count_set = true;
3997 	fcoe->crc_count = hst->invalid_crc_count;
3998 
3999 	fcoe->tx_abts_set = true;
4000 	fcoe->tx_abts = hst->fcp_packet_aborts;
4001 
4002 	fcoe->tx_lun_rst_set = true;
4003 	fcoe->tx_lun_rst = qedf->lun_resets;
4004 
4005 	fcoe->abort_task_sets_set = true;
4006 	fcoe->abort_task_sets = qedf->packet_aborts;
4007 
4008 	fcoe->scsi_busy_set = true;
4009 	fcoe->scsi_busy = qedf->busy;
4010 
4011 	fcoe->scsi_tsk_full_set = true;
4012 	fcoe->scsi_tsk_full = qedf->task_set_fulls;
4013 }
4014 
4015 /* Deferred work function to perform soft context reset on STAG change */
4016 void qedf_stag_change_work(struct work_struct *work)
4017 {
4018 	struct qedf_ctx *qedf =
4019 	    container_of(work, struct qedf_ctx, stag_work.work);
4020 
4021 	if (!qedf) {
4022 		QEDF_ERR(&qedf->dbg_ctx, "qedf is NULL");
4023 		return;
4024 	}
4025 
4026 	if (test_bit(QEDF_IN_RECOVERY, &qedf->flags)) {
4027 		QEDF_ERR(&qedf->dbg_ctx,
4028 			 "Already is in recovery, hence not calling software context reset.\n");
4029 		return;
4030 	}
4031 
4032 	if (test_bit(QEDF_UNLOADING, &qedf->flags)) {
4033 		QEDF_ERR(&qedf->dbg_ctx, "Driver unloading\n");
4034 		return;
4035 	}
4036 
4037 	set_bit(QEDF_STAG_IN_PROGRESS, &qedf->flags);
4038 
4039 	printk_ratelimited("[%s]:[%s:%d]:%d: Performing software context reset.",
4040 			dev_name(&qedf->pdev->dev), __func__, __LINE__,
4041 			qedf->dbg_ctx.host_no);
4042 	qedf_ctx_soft_reset(qedf->lport);
4043 }
4044 
4045 static void qedf_shutdown(struct pci_dev *pdev)
4046 {
4047 	__qedf_remove(pdev, QEDF_MODE_NORMAL);
4048 }
4049 
4050 static int qedf_suspend(struct pci_dev *pdev, pm_message_t state)
4051 {
4052 	struct qedf_ctx *qedf;
4053 
4054 	if (!pdev) {
4055 		QEDF_ERR(NULL, "pdev is NULL.\n");
4056 		return -ENODEV;
4057 	}
4058 
4059 	qedf = pci_get_drvdata(pdev);
4060 
4061 	QEDF_ERR(&qedf->dbg_ctx, "%s: Device does not support suspend operation\n", __func__);
4062 
4063 	return -EPERM;
4064 }
4065 
4066 /*
4067  * Recovery handler code
4068  */
4069 static void qedf_schedule_recovery_handler(void *dev)
4070 {
4071 	struct qedf_ctx *qedf = dev;
4072 
4073 	QEDF_ERR(&qedf->dbg_ctx, "Recovery handler scheduled.\n");
4074 	schedule_delayed_work(&qedf->recovery_work, 0);
4075 }
4076 
4077 static void qedf_recovery_handler(struct work_struct *work)
4078 {
4079 	struct qedf_ctx *qedf =
4080 	    container_of(work, struct qedf_ctx, recovery_work.work);
4081 
4082 	if (test_and_set_bit(QEDF_IN_RECOVERY, &qedf->flags))
4083 		return;
4084 
4085 	/*
4086 	 * Call common_ops->recovery_prolog to allow the MFW to quiesce
4087 	 * any PCI transactions.
4088 	 */
4089 	qed_ops->common->recovery_prolog(qedf->cdev);
4090 
4091 	QEDF_ERR(&qedf->dbg_ctx, "Recovery work start.\n");
4092 	__qedf_remove(qedf->pdev, QEDF_MODE_RECOVERY);
4093 	/*
4094 	 * Reset link and dcbx to down state since we will not get a link down
4095 	 * event from the MFW but calling __qedf_remove will essentially be a
4096 	 * link down event.
4097 	 */
4098 	atomic_set(&qedf->link_state, QEDF_LINK_DOWN);
4099 	atomic_set(&qedf->dcbx, QEDF_DCBX_PENDING);
4100 	__qedf_probe(qedf->pdev, QEDF_MODE_RECOVERY);
4101 	clear_bit(QEDF_IN_RECOVERY, &qedf->flags);
4102 	QEDF_ERR(&qedf->dbg_ctx, "Recovery work complete.\n");
4103 }
4104 
4105 /* Generic TLV data callback */
4106 void qedf_get_generic_tlv_data(void *dev, struct qed_generic_tlvs *data)
4107 {
4108 	struct qedf_ctx *qedf;
4109 
4110 	if (!dev) {
4111 		QEDF_INFO(NULL, QEDF_LOG_EVT,
4112 			  "dev is NULL so ignoring get_generic_tlv_data request.\n");
4113 		return;
4114 	}
4115 	qedf = (struct qedf_ctx *)dev;
4116 
4117 	memset(data, 0, sizeof(struct qed_generic_tlvs));
4118 	ether_addr_copy(data->mac[0], qedf->mac);
4119 }
4120 
4121 /*
4122  * Module Init/Remove
4123  */
4124 
4125 static int __init qedf_init(void)
4126 {
4127 	int ret;
4128 
4129 	/* If debug=1 passed, set the default log mask */
4130 	if (qedf_debug == QEDF_LOG_DEFAULT)
4131 		qedf_debug = QEDF_DEFAULT_LOG_MASK;
4132 
4133 	/*
4134 	 * Check that default prio for FIP/FCoE traffic is between 0..7 if a
4135 	 * value has been set
4136 	 */
4137 	if (qedf_default_prio > -1)
4138 		if (qedf_default_prio > 7) {
4139 			qedf_default_prio = QEDF_DEFAULT_PRIO;
4140 			QEDF_ERR(NULL, "FCoE/FIP priority out of range, resetting to %d.\n",
4141 			    QEDF_DEFAULT_PRIO);
4142 		}
4143 
4144 	/* Print driver banner */
4145 	QEDF_INFO(NULL, QEDF_LOG_INFO, "%s v%s.\n", QEDF_DESCR,
4146 		   QEDF_VERSION);
4147 
4148 	/* Create kmem_cache for qedf_io_work structs */
4149 	qedf_io_work_cache = kmem_cache_create("qedf_io_work_cache",
4150 	    sizeof(struct qedf_io_work), 0, SLAB_HWCACHE_ALIGN, NULL);
4151 	if (qedf_io_work_cache == NULL) {
4152 		QEDF_ERR(NULL, "qedf_io_work_cache is NULL.\n");
4153 		goto err1;
4154 	}
4155 	QEDF_INFO(NULL, QEDF_LOG_DISC, "qedf_io_work_cache=%p.\n",
4156 	    qedf_io_work_cache);
4157 
4158 	qed_ops = qed_get_fcoe_ops();
4159 	if (!qed_ops) {
4160 		QEDF_ERR(NULL, "Failed to get qed fcoe operations\n");
4161 		goto err1;
4162 	}
4163 
4164 #ifdef CONFIG_DEBUG_FS
4165 	qedf_dbg_init("qedf");
4166 #endif
4167 
4168 	qedf_fc_transport_template =
4169 	    fc_attach_transport(&qedf_fc_transport_fn);
4170 	if (!qedf_fc_transport_template) {
4171 		QEDF_ERR(NULL, "Could not register with FC transport\n");
4172 		goto err2;
4173 	}
4174 
4175 	qedf_fc_vport_transport_template =
4176 		fc_attach_transport(&qedf_fc_vport_transport_fn);
4177 	if (!qedf_fc_vport_transport_template) {
4178 		QEDF_ERR(NULL, "Could not register vport template with FC "
4179 			  "transport\n");
4180 		goto err3;
4181 	}
4182 
4183 	qedf_io_wq = alloc_workqueue("%s", WQ_MEM_RECLAIM, 1, "qedf_io_wq");
4184 	if (!qedf_io_wq) {
4185 		QEDF_ERR(NULL, "Could not create qedf_io_wq.\n");
4186 		goto err4;
4187 	}
4188 
4189 	qedf_cb_ops.get_login_failures = qedf_get_login_failures;
4190 
4191 	ret = pci_register_driver(&qedf_pci_driver);
4192 	if (ret) {
4193 		QEDF_ERR(NULL, "Failed to register driver\n");
4194 		goto err5;
4195 	}
4196 
4197 	return 0;
4198 
4199 err5:
4200 	destroy_workqueue(qedf_io_wq);
4201 err4:
4202 	fc_release_transport(qedf_fc_vport_transport_template);
4203 err3:
4204 	fc_release_transport(qedf_fc_transport_template);
4205 err2:
4206 #ifdef CONFIG_DEBUG_FS
4207 	qedf_dbg_exit();
4208 #endif
4209 	qed_put_fcoe_ops();
4210 err1:
4211 	return -EINVAL;
4212 }
4213 
4214 static void __exit qedf_cleanup(void)
4215 {
4216 	pci_unregister_driver(&qedf_pci_driver);
4217 
4218 	destroy_workqueue(qedf_io_wq);
4219 
4220 	fc_release_transport(qedf_fc_vport_transport_template);
4221 	fc_release_transport(qedf_fc_transport_template);
4222 #ifdef CONFIG_DEBUG_FS
4223 	qedf_dbg_exit();
4224 #endif
4225 	qed_put_fcoe_ops();
4226 
4227 	kmem_cache_destroy(qedf_io_work_cache);
4228 }
4229 
4230 MODULE_LICENSE("GPL");
4231 MODULE_DESCRIPTION("QLogic FastLinQ 4xxxx FCoE Module");
4232 MODULE_AUTHOR("QLogic Corporation");
4233 MODULE_VERSION(QEDF_VERSION);
4234 module_init(qedf_init);
4235 module_exit(qedf_cleanup);
4236