brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0-only2/*3 *  QLogic FCoE Offload Driver4 *  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 27const struct qed_fcoe_ops *qed_ops;28 29static int qedf_probe(struct pci_dev *pdev, const struct pci_device_id *id);30static void qedf_remove(struct pci_dev *pdev);31static void qedf_shutdown(struct pci_dev *pdev);32static void qedf_schedule_recovery_handler(void *dev);33static void qedf_recovery_handler(struct work_struct *work);34static int qedf_suspend(struct pci_dev *pdev, pm_message_t state);35 36/*37 * Driver module parameters.38 */39static unsigned int qedf_dev_loss_tmo = 60;40module_param_named(dev_loss_tmo, qedf_dev_loss_tmo, int, S_IRUGO);41MODULE_PARM_DESC(dev_loss_tmo,  " dev_loss_tmo setting for attached "42	"remote ports (default 60)");43 44uint qedf_debug = QEDF_LOG_INFO;45module_param_named(debug, qedf_debug, uint, S_IRUGO|S_IWUSR);46MODULE_PARM_DESC(debug, " Debug mask. Pass '1' to enable default debugging"47	" mask");48 49static uint qedf_fipvlan_retries = 60;50module_param_named(fipvlan_retries, qedf_fipvlan_retries, int, S_IRUGO);51MODULE_PARM_DESC(fipvlan_retries, " Number of FIP VLAN requests to attempt "52	"before giving up (default 60)");53 54static uint qedf_fallback_vlan = QEDF_FALLBACK_VLAN;55module_param_named(fallback_vlan, qedf_fallback_vlan, int, S_IRUGO);56MODULE_PARM_DESC(fallback_vlan, " VLAN ID to try if fip vlan request fails "57	"(default 1002).");58 59static int qedf_default_prio = -1;60module_param_named(default_prio, qedf_default_prio, int, S_IRUGO);61MODULE_PARM_DESC(default_prio, " Override 802.1q priority for FIP and FCoE"62	" traffic (value between 0 and 7, default 3).");63 64uint qedf_dump_frames;65module_param_named(dump_frames, qedf_dump_frames, int, S_IRUGO | S_IWUSR);66MODULE_PARM_DESC(dump_frames, " Print the skb data of FIP and FCoE frames "67	"(default off)");68 69static uint qedf_queue_depth;70module_param_named(queue_depth, qedf_queue_depth, int, S_IRUGO);71MODULE_PARM_DESC(queue_depth, " Sets the queue depth for all LUNs discovered "72	"by the qedf driver. Default is 0 (use OS default).");73 74uint qedf_io_tracing;75module_param_named(io_tracing, qedf_io_tracing, int, S_IRUGO | S_IWUSR);76MODULE_PARM_DESC(io_tracing, " Enable logging of SCSI requests/completions "77	"into trace buffer. (default off).");78 79static uint qedf_max_lun = MAX_FIBRE_LUNS;80module_param_named(max_lun, qedf_max_lun, int, S_IRUGO);81MODULE_PARM_DESC(max_lun, " Sets the maximum luns per target that the driver "82	"supports. (default 0xffffffff)");83 84uint qedf_link_down_tmo;85module_param_named(link_down_tmo, qedf_link_down_tmo, int, S_IRUGO);86MODULE_PARM_DESC(link_down_tmo, " Delays informing the fcoe transport that the "87	"link is down by N seconds.");88 89bool qedf_retry_delay;90module_param_named(retry_delay, qedf_retry_delay, bool, S_IRUGO | S_IWUSR);91MODULE_PARM_DESC(retry_delay, " Enable/disable handling of FCP_RSP IU retry "92	"delay handling (default off).");93 94static bool qedf_dcbx_no_wait;95module_param_named(dcbx_no_wait, qedf_dcbx_no_wait, bool, S_IRUGO | S_IWUSR);96MODULE_PARM_DESC(dcbx_no_wait, " Do not wait for DCBX convergence to start "97	"sending FIP VLAN requests on link up (Default: off).");98 99static uint qedf_dp_module;100module_param_named(dp_module, qedf_dp_module, uint, S_IRUGO);101MODULE_PARM_DESC(dp_module, " bit flags control for verbose printk passed "102	"qed module during probe.");103 104static uint qedf_dp_level = QED_LEVEL_NOTICE;105module_param_named(dp_level, qedf_dp_level, uint, S_IRUGO);106MODULE_PARM_DESC(dp_level, " printk verbosity control passed to qed module  "107	"during probe (0-3: 0 more verbose).");108 109static bool qedf_enable_recovery = true;110module_param_named(enable_recovery, qedf_enable_recovery,111		bool, S_IRUGO | S_IWUSR);112MODULE_PARM_DESC(enable_recovery, "Enable/disable recovery on driver/firmware "113		"interface level errors 0 = Disabled, 1 = Enabled (Default: 1).");114 115struct workqueue_struct *qedf_io_wq;116 117static struct fcoe_percpu_s qedf_global;118static DEFINE_SPINLOCK(qedf_global_lock);119 120static struct kmem_cache *qedf_io_work_cache;121 122void 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 */134static 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 168static 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 our191		 * fip vlan request so set the vlan_id to the default and192		 * tell FCoE that the link is up193		 */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 new201		 * lport port_id202		 */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 means208		 * that link_down_tmo timed out so set it to 0 to make sure any209		 * 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		1224#define QEDF_FCOE_MAC_METHOD_FCF_MAP			2225#define QEDF_FCOE_MAC_METHOD_FCOE_SET_MAC		3226static 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 MAC238	 * 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 on242	 * 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 the244	 * 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 267static 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 cause281	 * 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 301skip_stat:302	/* Report response to libfc */303	fc_lport_flogi_resp(seq, fp, lport);304}305 306static 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 resp317	 * 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 340int 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 and370 * link_down_tmo has not expired then use just FLOGI/ADISC to recover our371 * sessions with targets.  Otherwise, just call fcoe_ctlr_link_up().372 */373static 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 state391	 * 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 libfcoe398	 * can select a new fcf in parallel399	 */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 the411	 * 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 an443	 * 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 455static 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 supported491	 * 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 552static 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		else570			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 578static 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 update584	 * 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			else615				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 before627		 * 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 642static 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 that665		 * 2. If the value is not between 0..7 use the default666		 * 3. Use the priority we get from the DCBX app tag667		 */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		} else677			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			else685				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 693static 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 701static 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 717static struct scsi_transport_template *qedf_fc_transport_template;718static struct scsi_transport_template *qedf_fc_vport_transport_template;719 720/*721 * SCSI EH handlers722 */723static 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 to828		 * the SCSI layer as it will own and free the xid829		 */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 from842		 * the perspective that all references to the command have843		 * been removed from the driver and firmware844		 */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	else855		QEDF_ERR(&(qedf->dbg_ctx), "ABTS failed, xid=0x%x.\n",856			  io_req->xid);857 858drop_rdata_kref:859	kref_put(&rdata->kref, fc_rport_destroy);860out:861	if (got_ref)862		kref_put(&io_req->refcount, qedf_release_cmd);863	return rc;864}865 866static 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 875static 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 883bool 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		else894			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 */917void 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 */966static 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 985static 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 994static 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 1014static 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 1025static 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 */1047static 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 function1068 */1069static 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	else1097		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_lport1104		 * 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 path1157		 * then do not try to also send it over the LL2 path1158		 */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 VLAN1206	 * 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	else1216		/* 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 1254static 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 1300out_free_sq:1301	dma_free_coherent(&qedf->pdev->dev, fcport->sq_mem_size, fcport->sq,1302	    fcport->sq_dma);1303out:1304	return rval;1305}1306 1307static 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 1317static 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	} else1402		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;1409out_free_conn:1410	qed_ops->release_conn(qedf->cdev, fcport->handle);1411out:1412	return rval;1413}1414 1415#define QEDF_TERM_BUFF_SIZE		101416static 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 the1423	 * physical DMA address with the firmware. The buffer may be used in1424	 * 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 1441static 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 libfc1462 * initiated target login. qedf can proceed with initiating the session1463 * establishment.1464 */1465static 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 we1500		 * get an ADISC1501		 */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 for1512			 * directory server.1513			 * We should not come here, as lport will1514			 * take care of fabric login1515			 */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 this1569		 * connection is ready for I/O1570		 */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 already1601		 * 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 offloaded1616			 * ports1617			 */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 1635static void qedf_abort_io(struct fc_lport *lport)1636{1637	/* NO-OP but need to fill in the template */1638}1639 1640static void qedf_fcp_cleanup(struct fc_lport *lport)1641{1642	/*1643	 * NO-OP but need to fill in template to prevent a NULL1644	 * function pointer dereference during link down. I/Os1645	 * will be flushed when port is uploaded.1646	 */1647}1648 1649static 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 1657static 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 1666static 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 libfc1675	 * to execute FDMI registration1676	 */1677	lport->fdmi_enabled = 1;1678 1679	/*1680	 * Setup the necessary fc_host attributes to that will be used to fill1681	 * 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	} else1697		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 1737static 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 functions1796 */1797 1798static 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 1829static 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 1966err:1967	scsi_host_put(vn_port->host);1968	return rc;1969}1970 1971static 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_port1999	 * 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 2010out:2011	return 0;2012}2013 2014static 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 port2031 * to be destroyed so we avoid a race condition where libfc is still trying2032 * to reap vports while the driver remove function has already reaped the2033 * driver contexts associated with the physical port.2034 */2035static 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 fcoe2050 *2051 * @shost: shost the reset is from2052 *2053 * Returns: always 02054 */2055static 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 2063static 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 2070static struct fc_host_statistics *qedf_fc_get_host_stats(struct Scsi_Host2071	*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 stats2098	 * being maintained by libfc each time the fc_get_host_status callback2099	 * is invoked. The additions are not carried over for each call to2100	 * 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);2128out:2129	return qedf_stats;2130}2131 2132static 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 backpointer2152	 * 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 2172static 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 2202static 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 processesing2227 *2228 * Return true if we should wake the I/O thread, false if not.2229 */2230static 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 handler2268		 * sine we need the fastpath ID2269		 */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 consumer2276			 * 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/O2286		 * on.2287		 */2288		if (!io_req)2289			/* If there is not io_req associated with this CQE2290			 * just queue it on CPU 02291			 */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 2316inc_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 */2328static 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 new2343	 * completions2344	 */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 */2370static 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		02379static 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	} else2399		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 2406static 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 2437static int qedf_setup_int(struct qedf_ctx *qedf)2438{2439	int rc = 0;2440 2441	/*2442	 * Learn interrupt configuration2443	 */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 */2469static 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 we2571	 * have on record for lport and the search for a NPIV port came up2572	 * 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 there2594	 * is a small window where we could try to return a frame while libfc2595	 * 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 2619static 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 the2643	 * protocol value.  If it's not either just drop the2644	 * 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	} else2654		goto err_out;2655 2656err_out:2657	kfree_skb(skb);2658out:2659	kfree(skb_work);2660	return;2661}2662 2663static 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 2692static 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 */2698void 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 sends2706	 * 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	else2715		qedf_process_cqe(io_work->qedf, &io_work->cqe);2716 2717	kfree(io_work);2718}2719 2720static 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 2750static 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 2757static 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 2772static 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	}2809err:2810	return 0;2811}2812 2813void 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 spinlock2846	 * 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 2922static 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 2942static 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 2964static 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 individual3000	 * BDQ buffers3001	 */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 the3024	 * 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 3037static 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 should3049	 * be <= number of available MSIX vectors for the PF3050	 */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 physical3058	 * addresses of our queues3059	 */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 points3150	 * to the physical address which contains an array of pointers to3151	 * 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 3166mem_alloc_failure:3167	qedf_free_global_queues(qedf);3168	return status;3169}3170 3171static 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 blocks3181	 * we allocation is the minimum off:3182	 *3183	 * Number of CPUs3184	 * Number allocated by qed for our PCI function3185	 */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 */3259static 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 functions3276 */3277 3278static 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};3283MODULE_DEVICE_TABLE(pci, qedf_pci_tbl);3284 3285static 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 3294static 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 try3312	 * to reallocate it.3313	 */3314retry_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 to3386		 * honor it even if dcbx doesn't converge.3387		 */3388		qedf->prio = qedf_default_prio;3389	} else3390		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 here3427	 * order should be3428	 * 	slowpath_start3429	 * 	status block allocation3430	 *	interrupt registration (to get min number of queues)3431	 *	set_fcoe_pf_param3432	 *	qed_sp_fcoe_func_start3433	 */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 slowpath3490	 * start3491	 */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 so3514	 * the f/w will do a prefetch and we'll get an unsolicited CQE when a3515	 * 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 MAC3529	 * address3530	 */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 the3539	 * WWPN and WWNN. Otherwise fall back to use fcoe_wwn_from_mac() based3540	 * 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_FS3595	qedf_dbg_host_init(&(qedf->dbg_ctx), qedf_debugfs_ops,3596			    qedf_dbg_fops);3597#endif3598 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 since3613	 * 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 recovery3648	 * 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	else3690		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 3699err7: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_FS3705	qedf_dbg_host_exit(&(qedf->dbg_ctx));3706#endif3707err6:3708	qedf_cmd_mgr_free(qedf->cmd_mgr);3709err5:3710	qed_ops->stop(qedf->cdev);3711err4:3712	qedf_free_fcoe_pf_param(qedf);3713	qedf_sync_free_irqs(qedf);3714err3:3715	qed_ops->common->slowpath_stop(qedf->cdev);3716err2:3717	qed_ops->common->remove(qedf->cdev);3718err1:3719	scsi_host_put(lport->host);3720err0:3721	return rc;3722}3723 3724static int qedf_probe(struct pci_dev *pdev, const struct pci_device_id *id)3725{3726	return __qedf_probe(pdev, QEDF_MODE_NORMAL);3727}3728 3729static 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 to3744	 * 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 3751stag_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	else3769		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_FS3775	qedf_dbg_host_exit(&(qedf->dbg_ctx));3776#endif3777 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 the3798	 * 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 the3823	 * rest of the qed operations3824	 */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 3862static 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 3871void 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 3880void 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 handler3921 */3922void 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	else3974		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 */4016void 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 4045static void qedf_shutdown(struct pci_dev *pdev)4046{4047	__qedf_remove(pdev, QEDF_MODE_NORMAL);4048}4049 4050static 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 code4068 */4069static 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 4077static 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 quiesce4087	 * 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 down4095	 * event from the MFW but calling __qedf_remove will essentially be a4096	 * 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 */4106void 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/Remove4123 */4124 4125static 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 a4135	 * value has been set4136	 */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_FS4165	qedf_dbg_init("qedf");4166#endif4167 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 4199err5:4200	destroy_workqueue(qedf_io_wq);4201err4:4202	fc_release_transport(qedf_fc_vport_transport_template);4203err3:4204	fc_release_transport(qedf_fc_transport_template);4205err2:4206#ifdef CONFIG_DEBUG_FS4207	qedf_dbg_exit();4208#endif4209	qed_put_fcoe_ops();4210err1:4211	return -EINVAL;4212}4213 4214static 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_FS4223	qedf_dbg_exit();4224#endif4225	qed_put_fcoe_ops();4226 4227	kmem_cache_destroy(qedf_io_work_cache);4228}4229 4230MODULE_LICENSE("GPL");4231MODULE_DESCRIPTION("QLogic FastLinQ 4xxxx FCoE Module");4232MODULE_AUTHOR("QLogic Corporation");4233MODULE_VERSION(QEDF_VERSION);4234module_init(qedf_init);4235module_exit(qedf_cleanup);4236