[linux.git] / drivers / scsi / qedf / qedf_fip.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 *  QLogic FCoE Offload Driver
 *  Copyright (c) 2016-2018 Cavium Inc.
 */
#include <linux/if_ether.h>
#include <linux/if_vlan.h>
#include "qedf.h"

extern const struct qed_fcoe_ops *qed_ops;
/*
 * FIP VLAN functions that will eventually move to libfcoe.
 */

void qedf_fcoe_send_vlan_req(struct qedf_ctx *qedf)
{
	struct sk_buff *skb;
	char *eth_fr;
	struct fip_vlan *vlan;
#define MY_FIP_ALL_FCF_MACS        ((__u8[6]) { 1, 0x10, 0x18, 1, 0, 2 })
	static u8 my_fcoe_all_fcfs[ETH_ALEN] = MY_FIP_ALL_FCF_MACS;
	unsigned long flags = 0;
	int rc;

	skb = dev_alloc_skb(sizeof(struct fip_vlan));
	if (!skb) {
		QEDF_ERR(&qedf->dbg_ctx,
			 "Failed to allocate skb.\n");
		return;
	}

	eth_fr = (char *)skb->data;
	vlan = (struct fip_vlan *)eth_fr;

	memset(vlan, 0, sizeof(*vlan));
	ether_addr_copy(vlan->eth.h_source, qedf->mac);
	ether_addr_copy(vlan->eth.h_dest, my_fcoe_all_fcfs);
	vlan->eth.h_proto = htons(ETH_P_FIP);

	vlan->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
	vlan->fip.fip_op = htons(FIP_OP_VLAN);
	vlan->fip.fip_subcode = FIP_SC_VL_REQ;
	vlan->fip.fip_dl_len = htons(sizeof(vlan->desc) / FIP_BPW);

	vlan->desc.mac.fd_desc.fip_dtype = FIP_DT_MAC;
	vlan->desc.mac.fd_desc.fip_dlen = sizeof(vlan->desc.mac) / FIP_BPW;
	ether_addr_copy(vlan->desc.mac.fd_mac, qedf->mac);

	vlan->desc.wwnn.fd_desc.fip_dtype = FIP_DT_NAME;
	vlan->desc.wwnn.fd_desc.fip_dlen = sizeof(vlan->desc.wwnn) / FIP_BPW;
	put_unaligned_be64(qedf->lport->wwnn, &vlan->desc.wwnn.fd_wwn);

	skb_put(skb, sizeof(*vlan));
	skb->protocol = htons(ETH_P_FIP);
	skb_reset_mac_header(skb);
	skb_reset_network_header(skb);

	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Sending FIP VLAN "
		   "request.");

	if (atomic_read(&qedf->link_state) != QEDF_LINK_UP) {
		QEDF_WARN(&(qedf->dbg_ctx), "Cannot send vlan request "
		    "because link is not up.\n");

		kfree_skb(skb);
		return;
	}

	set_bit(QED_LL2_XMIT_FLAGS_FIP_DISCOVERY, &flags);
	rc = qed_ops->ll2->start_xmit(qedf->cdev, skb, flags);
	if (rc) {
		QEDF_ERR(&qedf->dbg_ctx, "start_xmit failed rc = %d.\n", rc);
		kfree_skb(skb);
		return;
	}

}

static void qedf_fcoe_process_vlan_resp(struct qedf_ctx *qedf,
	struct sk_buff *skb)
{
	struct fip_header *fiph;
	struct fip_desc *desc;
	u16 vid = 0;
	ssize_t rlen;
	size_t dlen;

	fiph = (struct fip_header *)(((void *)skb->data) + 2 * ETH_ALEN + 2);

	rlen = ntohs(fiph->fip_dl_len) * 4;
	desc = (struct fip_desc *)(fiph + 1);
	while (rlen > 0) {
		dlen = desc->fip_dlen * FIP_BPW;
		switch (desc->fip_dtype) {
		case FIP_DT_VLAN:
			vid = ntohs(((struct fip_vlan_desc *)desc)->fd_vlan);
			break;
		}
		desc = (struct fip_desc *)((char *)desc + dlen);
		rlen -= dlen;
	}

	if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
		QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
			  "Dropping VLAN response as link is down.\n");
		return;
	}

	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "VLAN response, "
		   "vid=0x%x.\n", vid);

	if (vid > 0 && qedf->vlan_id != vid) {
		qedf_set_vlan_id(qedf, vid);

		/* Inform waiter that it's ok to call fcoe_ctlr_link up() */
		if (!completion_done(&qedf->fipvlan_compl))
			complete(&qedf->fipvlan_compl);
	}
}

void qedf_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
{
	struct qedf_ctx *qedf = container_of(fip, struct qedf_ctx, ctlr);
	struct ethhdr *eth_hdr;
	struct fip_header *fiph;
	u16 op, vlan_tci = 0;
	u8 sub;
	int rc = -1;

	if (!test_bit(QEDF_LL2_STARTED, &qedf->flags)) {
		QEDF_WARN(&(qedf->dbg_ctx), "LL2 not started\n");
		kfree_skb(skb);
		return;
	}

	fiph = (struct fip_header *) ((void *)skb->data + 2 * ETH_ALEN + 2);
	eth_hdr = (struct ethhdr *)skb_mac_header(skb);
	op = ntohs(fiph->fip_op);
	sub = fiph->fip_subcode;

	/*
	 * Add VLAN tag to non-offload FIP frame based on current stored VLAN
	 * for FIP/FCoE traffic.
	 */
	__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), qedf->vlan_id);

	/* Get VLAN ID from skb for printing purposes */
	__vlan_hwaccel_get_tag(skb, &vlan_tci);

	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, "FIP frame send: "
	    "dest=%pM op=%x sub=%x vlan=%04x.", eth_hdr->h_dest, op, sub,
	    vlan_tci);
	if (qedf_dump_frames)
		print_hex_dump(KERN_WARNING, "fip ", DUMP_PREFIX_OFFSET, 16, 1,
		    skb->data, skb->len, false);

	rc = qed_ops->ll2->start_xmit(qedf->cdev, skb, 0);
	if (rc) {
		QEDF_ERR(&qedf->dbg_ctx, "start_xmit failed rc = %d.\n", rc);
		kfree_skb(skb);
		return;
	}
}

static u8 fcoe_all_enode[ETH_ALEN] = FIP_ALL_ENODE_MACS;

/* Process incoming FIP frames. */
void qedf_fip_recv(struct qedf_ctx *qedf, struct sk_buff *skb)
{
	struct ethhdr *eth_hdr;
	struct fip_header *fiph;
	struct fip_desc *desc;
	struct fip_mac_desc *mp;
	struct fip_wwn_desc *wp;
	struct fip_vn_desc *vp;
	size_t rlen, dlen;
	u16 op;
	u8 sub;
	bool fcf_valid = false;
	/* Default is to handle CVL regardless of fabric id descriptor */
	bool fabric_id_valid = true;
	bool fc_wwpn_valid = false;
	u64 switch_name;
	u16 vlan = 0;

	eth_hdr = (struct ethhdr *)skb_mac_header(skb);
	fiph = (struct fip_header *) ((void *)skb->data + 2 * ETH_ALEN + 2);
	op = ntohs(fiph->fip_op);
	sub = fiph->fip_subcode;

	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
		  "FIP frame received: skb=%p fiph=%p source=%pM destn=%pM op=%x sub=%x vlan=%04x",
		  skb, fiph, eth_hdr->h_source, eth_hdr->h_dest, op,
		  sub, vlan);
	if (qedf_dump_frames)
		print_hex_dump(KERN_WARNING, "fip ", DUMP_PREFIX_OFFSET, 16, 1,
		    skb->data, skb->len, false);

	if (!ether_addr_equal(eth_hdr->h_dest, qedf->mac) &&
	    !ether_addr_equal(eth_hdr->h_dest, fcoe_all_enode) &&
		!ether_addr_equal(eth_hdr->h_dest, qedf->data_src_addr)) {
		QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
			  "Dropping FIP type 0x%x pkt due to destination MAC mismatch dest_mac=%pM ctlr.dest_addr=%pM data_src_addr=%pM.\n",
			  op, eth_hdr->h_dest, qedf->mac,
			  qedf->data_src_addr);
		kfree_skb(skb);
		return;
	}

	/* Handle FIP VLAN resp in the driver */
	if (op == FIP_OP_VLAN && sub == FIP_SC_VL_NOTE) {
		qedf_fcoe_process_vlan_resp(qedf, skb);
		kfree_skb(skb);
	} else if (op == FIP_OP_CTRL && sub == FIP_SC_CLR_VLINK) {
		QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Clear virtual "
			   "link received.\n");

		/* Check that an FCF has been selected by fcoe */
		if (qedf->ctlr.sel_fcf == NULL) {
			QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
			    "Dropping CVL since FCF has not been selected "
			    "yet.");
			kfree_skb(skb);
			return;
		}

		/*
		 * We need to loop through the CVL descriptors to determine
		 * if we want to reset the fcoe link
		 */
		rlen = ntohs(fiph->fip_dl_len) * FIP_BPW;
		desc = (struct fip_desc *)(fiph + 1);
		while (rlen >= sizeof(*desc)) {
			dlen = desc->fip_dlen * FIP_BPW;
			switch (desc->fip_dtype) {
			case FIP_DT_MAC:
				mp = (struct fip_mac_desc *)desc;
				QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
					  "Switch fd_mac=%pM.\n", mp->fd_mac);
				if (ether_addr_equal(mp->fd_mac,
				    qedf->ctlr.sel_fcf->fcf_mac))
					fcf_valid = true;
				break;
			case FIP_DT_NAME:
				wp = (struct fip_wwn_desc *)desc;
				switch_name = get_unaligned_be64(&wp->fd_wwn);
				QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
					  "Switch fd_wwn=%016llx fcf_switch_name=%016llx.\n",
					  switch_name,
					  qedf->ctlr.sel_fcf->switch_name);
				if (switch_name ==
				    qedf->ctlr.sel_fcf->switch_name)
					fc_wwpn_valid = true;
				break;
			case FIP_DT_VN_ID:
				fabric_id_valid = false;
				vp = (struct fip_vn_desc *)desc;

				QEDF_ERR(&qedf->dbg_ctx,
					 "CVL vx_port fd_fc_id=0x%x fd_mac=%pM fd_wwpn=%016llx.\n",
					 ntoh24(vp->fd_fc_id), vp->fd_mac,
					 get_unaligned_be64(&vp->fd_wwpn));
				/* Check for vx_port wwpn OR Check vx_port
				 * fabric ID OR Check vx_port MAC
				 */
				if ((get_unaligned_be64(&vp->fd_wwpn) ==
					qedf->wwpn) ||
				   (ntoh24(vp->fd_fc_id) ==
					qedf->lport->port_id) ||
				   (ether_addr_equal(vp->fd_mac,
					qedf->data_src_addr))) {
					fabric_id_valid = true;
				}
				break;
			default:
				/* Ignore anything else */
				break;
			}
			desc = (struct fip_desc *)((char *)desc + dlen);
			rlen -= dlen;
		}

		QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
			  "fcf_valid=%d fabric_id_valid=%d fc_wwpn_valid=%d.\n",
			  fcf_valid, fabric_id_valid, fc_wwpn_valid);
		if (fcf_valid && fabric_id_valid && fc_wwpn_valid)
			qedf_ctx_soft_reset(qedf->lport);
		kfree_skb(skb);
	} else {
		/* Everything else is handled by libfcoe */
		__skb_pull(skb, ETH_HLEN);
		fcoe_ctlr_recv(&qedf->ctlr, skb);
	}
}

u8 *qedf_get_src_mac(struct fc_lport *lport)
{
	struct qedf_ctx *qedf = lport_priv(lport);

	return qedf->data_src_addr;
}
Commit	Line	Data
3287e96a	1	// SPDX-License-Identifier: GPL-2.0-only
61d8658b DC	2	/*
61d8658b DC	3	* QLogic FCoE Offload Driver
5d1c8b5b	4	* Copyright (c) 2016-2018 Cavium Inc.
61d8658b DC	5	*/
	6	#include <linux/if_ether.h>
	7	#include <linux/if_vlan.h>
	8	#include "qedf.h"
	9
	10	extern const struct qed_fcoe_ops *qed_ops;
	11	/*
	12	* FIP VLAN functions that will eventually move to libfcoe.
	13	*/
	14
	15	void qedf_fcoe_send_vlan_req(struct qedf_ctx *qedf)
	16	{
	17	struct sk_buff *skb;
	18	char *eth_fr;
61d8658b DC	19	struct fip_vlan *vlan;
	20	#define MY_FIP_ALL_FCF_MACS ((__u8[6]) { 1, 0x10, 0x18, 1, 0, 2 })
	21	static u8 my_fcoe_all_fcfs[ETH_ALEN] = MY_FIP_ALL_FCF_MACS;
cac6f691	22	unsigned long flags = 0;
89523cb8	23	int rc;
61d8658b DC	24
61d8658b DC	25	skb = dev_alloc_skb(sizeof(struct fip_vlan));
e82e6ff7 SK	26	if (!skb) {
	27	QEDF_ERR(&qedf->dbg_ctx,
	28	"Failed to allocate skb.\n");
61d8658b	29	return;
e82e6ff7	30	}
61d8658b	31
61d8658b DC	32	eth_fr = (char *)skb->data;
	33	vlan = (struct fip_vlan *)eth_fr;
	34
	35	memset(vlan, 0, sizeof(*vlan));
	36	ether_addr_copy(vlan->eth.h_source, qedf->mac);
	37	ether_addr_copy(vlan->eth.h_dest, my_fcoe_all_fcfs);
	38	vlan->eth.h_proto = htons(ETH_P_FIP);
	39
	40	vlan->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
	41	vlan->fip.fip_op = htons(FIP_OP_VLAN);
	42	vlan->fip.fip_subcode = FIP_SC_VL_REQ;
	43	vlan->fip.fip_dl_len = htons(sizeof(vlan->desc) / FIP_BPW);
	44
	45	vlan->desc.mac.fd_desc.fip_dtype = FIP_DT_MAC;
	46	vlan->desc.mac.fd_desc.fip_dlen = sizeof(vlan->desc.mac) / FIP_BPW;
	47	ether_addr_copy(vlan->desc.mac.fd_mac, qedf->mac);
	48
	49	vlan->desc.wwnn.fd_desc.fip_dtype = FIP_DT_NAME;
	50	vlan->desc.wwnn.fd_desc.fip_dlen = sizeof(vlan->desc.wwnn) / FIP_BPW;
	51	put_unaligned_be64(qedf->lport->wwnn, &vlan->desc.wwnn.fd_wwn);
	52
	53	skb_put(skb, sizeof(*vlan));
	54	skb->protocol = htons(ETH_P_FIP);
	55	skb_reset_mac_header(skb);
	56	skb_reset_network_header(skb);
	57
	58	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Sending FIP VLAN "
	59	"request.");
	60
	61	if (atomic_read(&qedf->link_state) != QEDF_LINK_UP) {
	62	QEDF_WARN(&(qedf->dbg_ctx), "Cannot send vlan request "
	63	"because link is not up.\n");
	64
	65	kfree_skb(skb);
	66	return;
	67	}
cac6f691 SRK	68
cac6f691 SRK	69	set_bit(QED_LL2_XMIT_FLAGS_FIP_DISCOVERY, &flags);
19c2b6d8 SK	70	rc = qed_ops->ll2->start_xmit(qedf->cdev, skb, flags);
	71	if (rc) {
	72	QEDF_ERR(&qedf->dbg_ctx, "start_xmit failed rc = %d.\n", rc);
	73	kfree_skb(skb);
	74	return;
	75	}
	76
61d8658b DC	77	}
	78
	79	static void qedf_fcoe_process_vlan_resp(struct qedf_ctx *qedf,
	80	struct sk_buff *skb)
	81	{
	82	struct fip_header *fiph;
	83	struct fip_desc *desc;
	84	u16 vid = 0;
	85	ssize_t rlen;
	86	size_t dlen;
	87
	88	fiph = (struct fip_header )(((void )skb->data) + 2 * ETH_ALEN + 2);
	89
	90	rlen = ntohs(fiph->fip_dl_len) * 4;
	91	desc = (struct fip_desc *)(fiph + 1);
	92	while (rlen > 0) {
	93	dlen = desc->fip_dlen * FIP_BPW;
	94	switch (desc->fip_dtype) {
	95	case FIP_DT_VLAN:
	96	vid = ntohs(((struct fip_vlan_desc *)desc)->fd_vlan);
	97	break;
	98	}
	99	desc = (struct fip_desc )((char )desc + dlen);
	100	rlen -= dlen;
	101	}
	102
76dbf4ff SK	103	if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
	104	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
	105	"Dropping VLAN response as link is down.\n");
	106	return;
	107	}
	108
61d8658b DC	109	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "VLAN response, "
	110	"vid=0x%x.\n", vid);
	111
	112	if (vid > 0 && qedf->vlan_id != vid) {
	113	qedf_set_vlan_id(qedf, vid);
	114
	115	/* Inform waiter that it's ok to call fcoe_ctlr_link up() */
8eaf7dfc CD	116	if (!completion_done(&qedf->fipvlan_compl))
8eaf7dfc CD	117	complete(&qedf->fipvlan_compl);
61d8658b DC	118	}
	119	}
	120
	121	void qedf_fip_send(struct fcoe_ctlr fip, struct sk_buff skb)
	122	{
	123	struct qedf_ctx *qedf = container_of(fip, struct qedf_ctx, ctlr);
	124	struct ethhdr *eth_hdr;
61d8658b DC	125	struct fip_header *fiph;
	126	u16 op, vlan_tci = 0;
	127	u8 sub;
19c2b6d8	128	int rc = -1;
61d8658b DC	129
	130	if (!test_bit(QEDF_LL2_STARTED, &qedf->flags)) {
	131	QEDF_WARN(&(qedf->dbg_ctx), "LL2 not started\n");
	132	kfree_skb(skb);
	133	return;
	134	}
	135
	136	fiph = (struct fip_header ) ((void )skb->data + 2 * ETH_ALEN + 2);
	137	eth_hdr = (struct ethhdr *)skb_mac_header(skb);
	138	op = ntohs(fiph->fip_op);
	139	sub = fiph->fip_subcode;
	140
cf291163 CD	141	/*
	142	* Add VLAN tag to non-offload FIP frame based on current stored VLAN
	143	* for FIP/FCoE traffic.
	144	*/
	145	__vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), qedf->vlan_id);
61d8658b	146
cf291163 CD	147	/* Get VLAN ID from skb for printing purposes */
cf291163 CD	148	__vlan_hwaccel_get_tag(skb, &vlan_tci);
61d8658b DC	149
	150	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, "FIP frame send: "
	151	"dest=%pM op=%x sub=%x vlan=%04x.", eth_hdr->h_dest, op, sub,
15a93de7	152	vlan_tci);
61d8658b DC	153	if (qedf_dump_frames)
	154	print_hex_dump(KERN_WARNING, "fip ", DUMP_PREFIX_OFFSET, 16, 1,
	155	skb->data, skb->len, false);
	156
19c2b6d8 SK	157	rc = qed_ops->ll2->start_xmit(qedf->cdev, skb, 0);
	158	if (rc) {
	159	QEDF_ERR(&qedf->dbg_ctx, "start_xmit failed rc = %d.\n", rc);
	160	kfree_skb(skb);
	161	return;
	162	}
61d8658b DC	163	}
61d8658b DC	164
fc37ddce CD	165	static u8 fcoe_all_enode[ETH_ALEN] = FIP_ALL_ENODE_MACS;
fc37ddce CD	166
61d8658b DC	167	/* Process incoming FIP frames. */
	168	void qedf_fip_recv(struct qedf_ctx qedf, struct sk_buff skb)
	169	{
	170	struct ethhdr *eth_hdr;
	171	struct fip_header *fiph;
	172	struct fip_desc *desc;
	173	struct fip_mac_desc *mp;
	174	struct fip_wwn_desc *wp;
	175	struct fip_vn_desc *vp;
	176	size_t rlen, dlen;
61d8658b DC	177	u16 op;
61d8658b DC	178	u8 sub;
fc37ddce CD	179	bool fcf_valid = false;
	180	/* Default is to handle CVL regardless of fabric id descriptor */
	181	bool fabric_id_valid = true;
	182	bool fc_wwpn_valid = false;
	183	u64 switch_name;
	184	u16 vlan = 0;
61d8658b DC	185
	186	eth_hdr = (struct ethhdr *)skb_mac_header(skb);
	187	fiph = (struct fip_header ) ((void )skb->data + 2 * ETH_ALEN + 2);
	188	op = ntohs(fiph->fip_op);
	189	sub = fiph->fip_subcode;
	190
fc37ddce CD	191	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
	192	"FIP frame received: skb=%p fiph=%p source=%pM destn=%pM op=%x sub=%x vlan=%04x",
	193	skb, fiph, eth_hdr->h_source, eth_hdr->h_dest, op,
	194	sub, vlan);
61d8658b DC	195	if (qedf_dump_frames)
	196	print_hex_dump(KERN_WARNING, "fip ", DUMP_PREFIX_OFFSET, 16, 1,
	197	skb->data, skb->len, false);
	198
fc37ddce CD	199	if (!ether_addr_equal(eth_hdr->h_dest, qedf->mac) &&
	200	!ether_addr_equal(eth_hdr->h_dest, fcoe_all_enode) &&
	201	!ether_addr_equal(eth_hdr->h_dest, qedf->data_src_addr)) {
	202	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
	203	"Dropping FIP type 0x%x pkt due to destination MAC mismatch dest_mac=%pM ctlr.dest_addr=%pM data_src_addr=%pM.\n",
	204	op, eth_hdr->h_dest, qedf->mac,
	205	qedf->data_src_addr);
	206	kfree_skb(skb);
	207	return;
	208	}
	209
61d8658b DC	210	/* Handle FIP VLAN resp in the driver */
	211	if (op == FIP_OP_VLAN && sub == FIP_SC_VL_NOTE) {
	212	qedf_fcoe_process_vlan_resp(qedf, skb);
61d8658b DC	213	kfree_skb(skb);
	214	} else if (op == FIP_OP_CTRL && sub == FIP_SC_CLR_VLINK) {
	215	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Clear virtual "
	216	"link received.\n");
	217
	218	/* Check that an FCF has been selected by fcoe */
	219	if (qedf->ctlr.sel_fcf == NULL) {
	220	QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
	221	"Dropping CVL since FCF has not been selected "
	222	"yet.");
f32803bb	223	kfree_skb(skb);
61d8658b DC	224	return;
	225	}
	226
61d8658b DC	227	/*
	228	* We need to loop through the CVL descriptors to determine
	229	* if we want to reset the fcoe link
	230	*/
	231	rlen = ntohs(fiph->fip_dl_len) * FIP_BPW;
	232	desc = (struct fip_desc *)(fiph + 1);
	233	while (rlen >= sizeof(*desc)) {
	234	dlen = desc->fip_dlen * FIP_BPW;
	235	switch (desc->fip_dtype) {
	236	case FIP_DT_MAC:
	237	mp = (struct fip_mac_desc *)desc;
fc37ddce CD	238	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
fc37ddce CD	239	"Switch fd_mac=%pM.\n", mp->fd_mac);
53c51adb CD	240	if (ether_addr_equal(mp->fd_mac,
53c51adb CD	241	qedf->ctlr.sel_fcf->fcf_mac))
fc37ddce	242	fcf_valid = true;
61d8658b DC	243	break;
	244	case FIP_DT_NAME:
	245	wp = (struct fip_wwn_desc *)desc;
fc37ddce CD	246	switch_name = get_unaligned_be64(&wp->fd_wwn);
	247	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
	248	"Switch fd_wwn=%016llx fcf_switch_name=%016llx.\n",
	249	switch_name,
	250	qedf->ctlr.sel_fcf->switch_name);
	251	if (switch_name ==
	252	qedf->ctlr.sel_fcf->switch_name)
	253	fc_wwpn_valid = true;
61d8658b DC	254	break;
61d8658b DC	255	case FIP_DT_VN_ID:
b29a907f	256	fabric_id_valid = false;
61d8658b	257	vp = (struct fip_vn_desc *)desc;
b29a907f SK	258
	259	QEDF_ERR(&qedf->dbg_ctx,
	260	"CVL vx_port fd_fc_id=0x%x fd_mac=%pM fd_wwpn=%016llx.\n",
	261	ntoh24(vp->fd_fc_id), vp->fd_mac,
	262	get_unaligned_be64(&vp->fd_wwpn));
	263	/* Check for vx_port wwpn OR Check vx_port
	264	* fabric ID OR Check vx_port MAC
	265	*/
	266	if ((get_unaligned_be64(&vp->fd_wwpn) ==
	267	qedf->wwpn) \|\|
	268	(ntoh24(vp->fd_fc_id) ==
	269	qedf->lport->port_id) \|\|
	270	(ether_addr_equal(vp->fd_mac,
	271	qedf->data_src_addr))) {
	272	fabric_id_valid = true;
	273	}
61d8658b DC	274	break;
	275	default:
	276	/* Ignore anything else */
	277	break;
	278	}
	279	desc = (struct fip_desc )((char )desc + dlen);
	280	rlen -= dlen;
	281	}
	282
fc37ddce CD	283	QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
	284	"fcf_valid=%d fabric_id_valid=%d fc_wwpn_valid=%d.\n",
	285	fcf_valid, fabric_id_valid, fc_wwpn_valid);
	286	if (fcf_valid && fabric_id_valid && fc_wwpn_valid)
a66c6cd2	287	qedf_ctx_soft_reset(qedf->lport);
61d8658b DC	288	kfree_skb(skb);
	289	} else {
	290	/* Everything else is handled by libfcoe */
	291	__skb_pull(skb, ETH_HLEN);
	292	fcoe_ctlr_recv(&qedf->ctlr, skb);
	293	}
	294	}
	295
61d8658b DC	296	u8 qedf_get_src_mac(struct fc_lport lport)
61d8658b DC	297	{
61d8658b DC	298	struct qedf_ctx *qedf = lport_priv(lport);
61d8658b DC	299
61d8658b DC	300	return qedf->data_src_addr;
61d8658b DC	301	}