Commit bdb27482 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'be2net' 



Sathya Perla says:

====================
be2net: patch set

Hi Dave, pls consider applying the following patch-set to the
net-next tree. It has 5 code/style cleanup patches and 4 patches that
add functionality to the driver.

Patch 1 moves routines that were not needed to be in be.h to the respective
src files, to avoid unnecessary compilation.

Patch 2 replaces (1 << x) with BIT(x) macro

Patch 3 refactors code that checks if a FW flash file is compatible
with the adapter. The code is now refactored into 2 routines, the first one
gets the file type from the image file and the 2nd routine checks if the
file type is compatible with the adapter.

Patch 4 adds compatibility checks for flashing a FW image on the new
Skyhawk P2 HW revision.

Patch 5 adds support for a new "offset based" flashing scheme, wherein
the driver informs the FW of the offset at which each component in the flash
file is to be flashed at. This helps flashing components that were
previously not recognized by the running FW.

Patch 6 simplifies the be_cmd_rx_filter() routine, by passing to it the
filter flags already used in the FW cmd, instead of the netdev flags that
were converted to the FW-cmd flags.

Patch 7 introduces helper routines in be_set_rx_mode() and be_vid_config()
to improve code readability.

Patch 8 adds processing of port-misconfig async event sent by the FW.

Patch 9 removes unnecessary swapping of a field in the TX desc.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 1fd0bddb f986afcb

drivers/net/ethernet/emulex/benet/be.h

+20 −179
Original line number Diff line number Diff line
@@ -59,26 +59,6 @@ 
#define OC_SUBSYS_DEVICE_ID3	0xE612

#define OC_SUBSYS_DEVICE_ID4	0xE652



static inline char *nic_name(struct pci_dev *pdev)

{

	switch (pdev->device) {

	case OC_DEVICE_ID1:

		return OC_NAME;

	case OC_DEVICE_ID2:

		return OC_NAME_BE;

	case OC_DEVICE_ID3:

	case OC_DEVICE_ID4:

		return OC_NAME_LANCER;

	case BE_DEVICE_ID2:

		return BE3_NAME;

	case OC_DEVICE_ID5:

	case OC_DEVICE_ID6:

		return OC_NAME_SH;

	default:

		return BE_NAME;

	}

}



/* Number of bytes of an RX frame that are copied to skb->data */

#define BE_HDR_LEN		((u16) 64)

/* allocate extra space to allow tunneling decapsulation without head reallocation */
@@ -381,15 +361,14 @@ enum vf_state { 
	ASSIGNED = 1

};



#define BE_FLAGS_LINK_STATUS_INIT		1

#define BE_FLAGS_SRIOV_ENABLED			(1 << 2)

#define BE_FLAGS_WORKER_SCHEDULED		(1 << 3)

#define BE_FLAGS_VLAN_PROMISC			(1 << 4)

#define BE_FLAGS_MCAST_PROMISC			(1 << 5)

#define BE_FLAGS_NAPI_ENABLED			(1 << 9)

#define BE_FLAGS_QNQ_ASYNC_EVT_RCVD		(1 << 11)

#define BE_FLAGS_VXLAN_OFFLOADS			(1 << 12)

#define BE_FLAGS_SETUP_DONE			(1 << 13)

#define BE_FLAGS_LINK_STATUS_INIT		BIT(1)

#define BE_FLAGS_SRIOV_ENABLED			BIT(2)

#define BE_FLAGS_WORKER_SCHEDULED		BIT(3)

#define BE_FLAGS_NAPI_ENABLED			BIT(6)

#define BE_FLAGS_QNQ_ASYNC_EVT_RCVD		BIT(7)

#define BE_FLAGS_VXLAN_OFFLOADS			BIT(8)

#define BE_FLAGS_SETUP_DONE			BIT(9)

#define BE_FLAGS_EVT_INCOMPATIBLE_SFP		BIT(10)



#define BE_UC_PMAC_COUNT			30

#define BE_VF_UC_PMAC_COUNT			2
@@ -399,6 +378,8 @@ enum vf_state { 
#define LANCER_DELETE_FW_DUMP			0x2



struct phy_info {

/* From SFF-8472 spec */

#define SFP_VENDOR_NAME_LEN			17

	u8 transceiver;

	u8 autoneg;

	u8 fc_autoneg;
@@ -412,6 +393,8 @@ struct phy_info { 
	u32 advertising;

	u32 supported;

	u8 cable_type;

	u8 vendor_name[SFP_VENDOR_NAME_LEN];

	u8 vendor_pn[SFP_VENDOR_NAME_LEN];

};



struct be_resources {
@@ -469,8 +452,6 @@ struct be_adapter { 


	struct be_drv_stats drv_stats;

	struct be_aic_obj aic_obj[MAX_EVT_QS];

	u16 vlans_added;

	unsigned long vids[BITS_TO_LONGS(VLAN_N_VID)];

	u8 vlan_prio_bmap;	/* Available Priority BitMap */

	u16 recommended_prio;	/* Recommended Priority */

	struct be_dma_mem rx_filter; /* Cmd DMA mem for rx-filter */
@@ -486,8 +467,15 @@ struct be_adapter { 
	/* Ethtool knobs and info */

	char fw_ver[FW_VER_LEN];

	char fw_on_flash[FW_VER_LEN];



	/* IFACE filtering fields */

	int if_handle;		/* Used to configure filtering */

	u32 if_flags;		/* Interface filtering flags */

	u32 *pmac_id;		/* MAC addr handle used by BE card */

	u32 uc_macs;		/* Count of secondary UC MAC programmed */

	unsigned long vids[BITS_TO_LONGS(VLAN_N_VID)];

	u16 vlans_added;



	u32 beacon_state;	/* for set_phys_id */



	bool eeh_error;
@@ -495,7 +483,7 @@ struct be_adapter { 
	bool hw_error;



	u32 port_num;

	bool promiscuous;

	char port_name;

	u8 mc_type;

	u32 function_mode;

	u32 function_caps;
@@ -528,7 +516,6 @@ struct be_adapter { 
	struct phy_info phy;

	u8 wol_cap;

	bool wol_en;

	u32 uc_macs;		/* Count of secondary UC MAC programmed */

	u16 asic_rev;

	u16 qnq_vid;

	u32 msg_enable;
@@ -734,19 +721,6 @@ static inline bool is_ipv4_pkt(struct sk_buff *skb) 
	return skb->protocol == htons(ETH_P_IP) && ip_hdr(skb)->version == 4;

}



static inline void be_vf_eth_addr_generate(struct be_adapter *adapter, u8 *mac)

{

	u32 addr;



	addr = jhash(adapter->netdev->dev_addr, ETH_ALEN, 0);



	mac[5] = (u8)(addr & 0xFF);

	mac[4] = (u8)((addr >> 8) & 0xFF);

	mac[3] = (u8)((addr >> 16) & 0xFF);

	/* Use the OUI from the current MAC address */

	memcpy(mac, adapter->netdev->dev_addr, 3);

}



static inline bool be_multi_rxq(const struct be_adapter *adapter)

{

	return adapter->num_rx_qs > 1;
@@ -769,129 +743,6 @@ static inline void be_clear_all_error(struct be_adapter *adapter) 
	adapter->fw_timeout = false;

}



static inline bool be_is_wol_excluded(struct be_adapter *adapter)

{

	struct pci_dev *pdev = adapter->pdev;



	if (!be_physfn(adapter))

		return true;



	switch (pdev->subsystem_device) {

	case OC_SUBSYS_DEVICE_ID1:

	case OC_SUBSYS_DEVICE_ID2:

	case OC_SUBSYS_DEVICE_ID3:

	case OC_SUBSYS_DEVICE_ID4:

		return true;

	default:

		return false;

	}

}



static inline int qnq_async_evt_rcvd(struct be_adapter *adapter)

{

	return adapter->flags & BE_FLAGS_QNQ_ASYNC_EVT_RCVD;

}



#ifdef CONFIG_NET_RX_BUSY_POLL

static inline bool be_lock_napi(struct be_eq_obj *eqo)

{

	bool status = true;



	spin_lock(&eqo->lock); /* BH is already disabled */

	if (eqo->state & BE_EQ_LOCKED) {

		WARN_ON(eqo->state & BE_EQ_NAPI);

		eqo->state |= BE_EQ_NAPI_YIELD;

		status = false;

	} else {

		eqo->state = BE_EQ_NAPI;

	}

	spin_unlock(&eqo->lock);

	return status;

}



static inline void be_unlock_napi(struct be_eq_obj *eqo)

{

	spin_lock(&eqo->lock); /* BH is already disabled */



	WARN_ON(eqo->state & (BE_EQ_POLL | BE_EQ_NAPI_YIELD));

	eqo->state = BE_EQ_IDLE;



	spin_unlock(&eqo->lock);

}



static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)

{

	bool status = true;



	spin_lock_bh(&eqo->lock);

	if (eqo->state & BE_EQ_LOCKED) {

		eqo->state |= BE_EQ_POLL_YIELD;

		status = false;

	} else {

		eqo->state |= BE_EQ_POLL;

	}

	spin_unlock_bh(&eqo->lock);

	return status;

}



static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)

{

	spin_lock_bh(&eqo->lock);



	WARN_ON(eqo->state & (BE_EQ_NAPI));

	eqo->state = BE_EQ_IDLE;



	spin_unlock_bh(&eqo->lock);

}



static inline void be_enable_busy_poll(struct be_eq_obj *eqo)

{

	spin_lock_init(&eqo->lock);

	eqo->state = BE_EQ_IDLE;

}



static inline void be_disable_busy_poll(struct be_eq_obj *eqo)

{

	local_bh_disable();



	/* It's enough to just acquire napi lock on the eqo to stop

	 * be_busy_poll() from processing any queueus.

	 */

	while (!be_lock_napi(eqo))

		mdelay(1);



	local_bh_enable();

}



#else /* CONFIG_NET_RX_BUSY_POLL */



static inline bool be_lock_napi(struct be_eq_obj *eqo)

{

	return true;

}



static inline void be_unlock_napi(struct be_eq_obj *eqo)

{

}



static inline bool be_lock_busy_poll(struct be_eq_obj *eqo)

{

	return false;

}



static inline void be_unlock_busy_poll(struct be_eq_obj *eqo)

{

}



static inline void be_enable_busy_poll(struct be_eq_obj *eqo)

{

}



static inline void be_disable_busy_poll(struct be_eq_obj *eqo)

{

}

#endif /* CONFIG_NET_RX_BUSY_POLL */



void be_cq_notify(struct be_adapter *adapter, u16 qid, bool arm,

		  u16 num_popped);

void be_link_status_update(struct be_adapter *adapter, u8 link_status);
@@ -900,16 +751,6 @@ int be_load_fw(struct be_adapter *adapter, u8 *func); 
bool be_is_wol_supported(struct be_adapter *adapter);

bool be_pause_supported(struct be_adapter *adapter);

u32 be_get_fw_log_level(struct be_adapter *adapter);



static inline int fw_major_num(const char *fw_ver)

{

	int fw_major = 0;



	sscanf(fw_ver, "%d.", &fw_major);



	return fw_major;

}



int be_update_queues(struct be_adapter *adapter);

int be_poll(struct napi_struct *napi, int budget);

drivers/net/ethernet/emulex/benet/be_cmds.c

+146 −63
Original line number Diff line number Diff line
@@ -19,6 +19,22 @@ 
#include "be.h"

#include "be_cmds.h"



static char *be_port_misconfig_evt_desc[] = {

	"A valid SFP module detected",

	"Optics faulted/ incorrectly installed/ not installed.",

	"Optics of two types installed.",

	"Incompatible optics.",

	"Unknown port SFP status"

};



static char *be_port_misconfig_remedy_desc[] = {

	"",

	"Reseat optics. If issue not resolved, replace",

	"Remove one optic or install matching pair of optics",

	"Replace with compatible optics for card to function",

	""

};



static struct be_cmd_priv_map cmd_priv_map[] = {

	{

		OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG,
@@ -249,6 +265,29 @@ static void be_async_link_state_process(struct be_adapter *adapter, 
				      evt->port_link_status & LINK_STATUS_MASK);

}



static void be_async_port_misconfig_event_process(struct be_adapter *adapter,

						  struct be_mcc_compl *compl)

{

	struct be_async_event_misconfig_port *evt =

			(struct be_async_event_misconfig_port *)compl;

	u32 sfp_mismatch_evt = le32_to_cpu(evt->event_data_word1);

	struct device *dev = &adapter->pdev->dev;

	u8 port_misconfig_evt;



	port_misconfig_evt =

		((sfp_mismatch_evt >> (adapter->hba_port_num * 8)) & 0xff);



	/* Log an error message that would allow a user to determine

	 * whether the SFPs have an issue

	 */

	dev_info(dev, "Port %c: %s %s", adapter->port_name,

		 be_port_misconfig_evt_desc[port_misconfig_evt],

		 be_port_misconfig_remedy_desc[port_misconfig_evt]);



	if (port_misconfig_evt == INCOMPATIBLE_SFP)

		adapter->flags |= BE_FLAGS_EVT_INCOMPATIBLE_SFP;

}



/* Grp5 CoS Priority evt */

static void be_async_grp5_cos_priority_process(struct be_adapter *adapter,

					       struct be_mcc_compl *compl)
@@ -334,6 +373,16 @@ static void be_async_dbg_evt_process(struct be_adapter *adapter, 
	}

}



static void be_async_sliport_evt_process(struct be_adapter *adapter,

					 struct be_mcc_compl *cmp)

{

	u8 event_type = (cmp->flags >> ASYNC_EVENT_TYPE_SHIFT) &

			ASYNC_EVENT_TYPE_MASK;



	if (event_type == ASYNC_EVENT_PORT_MISCONFIG)

		be_async_port_misconfig_event_process(adapter, cmp);

}



static inline bool is_link_state_evt(u32 flags)

{

	return ((flags >> ASYNC_EVENT_CODE_SHIFT) & ASYNC_EVENT_CODE_MASK) ==
@@ -352,6 +401,12 @@ static inline bool is_dbg_evt(u32 flags) 
			ASYNC_EVENT_CODE_QNQ;

}



static inline bool is_sliport_evt(u32 flags)

{

	return ((flags >> ASYNC_EVENT_CODE_SHIFT) & ASYNC_EVENT_CODE_MASK) ==

		ASYNC_EVENT_CODE_SLIPORT;

}



static void be_mcc_event_process(struct be_adapter *adapter,

				 struct be_mcc_compl *compl)

{
@@ -361,6 +416,8 @@ static void be_mcc_event_process(struct be_adapter *adapter, 
		be_async_grp5_evt_process(adapter, compl);

	else if (is_dbg_evt(compl->flags))

		be_async_dbg_evt_process(adapter, compl);

	else if (is_sliport_evt(compl->flags))

		be_async_sliport_evt_process(adapter, compl);

}



static struct be_mcc_compl *be_mcc_compl_get(struct be_adapter *adapter)
@@ -1171,9 +1228,15 @@ static int be_cmd_mccq_ext_create(struct be_adapter *adapter, 
			      ctxt, 1);

	}



	/* Subscribe to Link State and Group 5 Events(bits 1 and 5 set) */

	req->async_event_bitmap[0] = cpu_to_le32(0x00000022);

	req->async_event_bitmap[0] |= cpu_to_le32(1 << ASYNC_EVENT_CODE_QNQ);

	/* Subscribe to Link State, Sliport Event and Group 5 Events

	 * (bits 1, 5 and 17 set)

	 */

	req->async_event_bitmap[0] =

			cpu_to_le32(BIT(ASYNC_EVENT_CODE_LINK_STATE) |

				    BIT(ASYNC_EVENT_CODE_GRP_5) |

				    BIT(ASYNC_EVENT_CODE_QNQ) |

				    BIT(ASYNC_EVENT_CODE_SLIPORT));



	be_dws_cpu_to_le(ctxt, sizeof(req->context));



	be_cmd_page_addrs_prepare(req->pages, ARRAY_SIZE(req->pages), q_mem);
@@ -1886,7 +1949,7 @@ err: 
	return status;

}



int be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value)

static int __be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value)

{

	struct be_mcc_wrb *wrb;

	struct be_dma_mem *mem = &adapter->rx_filter;
@@ -1906,31 +1969,13 @@ int be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value) 
			       wrb, mem);



	req->if_id = cpu_to_le32(adapter->if_handle);

	if (flags & IFF_PROMISC) {

		req->if_flags_mask = cpu_to_le32(BE_IF_FLAGS_PROMISCUOUS |

						 BE_IF_FLAGS_VLAN_PROMISCUOUS |

						 BE_IF_FLAGS_MCAST_PROMISCUOUS);

		if (value == ON)

			req->if_flags =

				cpu_to_le32(BE_IF_FLAGS_PROMISCUOUS |

					    BE_IF_FLAGS_VLAN_PROMISCUOUS |

					    BE_IF_FLAGS_MCAST_PROMISCUOUS);

	} else if (flags & IFF_ALLMULTI) {

		req->if_flags_mask = cpu_to_le32(BE_IF_FLAGS_MCAST_PROMISCUOUS);

		req->if_flags =	cpu_to_le32(BE_IF_FLAGS_MCAST_PROMISCUOUS);

	} else if (flags & BE_FLAGS_VLAN_PROMISC) {

		req->if_flags_mask = cpu_to_le32(BE_IF_FLAGS_VLAN_PROMISCUOUS);



		if (value == ON)

			req->if_flags =

				cpu_to_le32(BE_IF_FLAGS_VLAN_PROMISCUOUS);

	} else {

	req->if_flags_mask = cpu_to_le32(flags);

	req->if_flags = (value == ON) ? req->if_flags_mask : 0;



	if (flags & BE_IF_FLAGS_MULTICAST) {

		struct netdev_hw_addr *ha;

		int i = 0;



		req->if_flags_mask = cpu_to_le32(BE_IF_FLAGS_MULTICAST);

		req->if_flags =	cpu_to_le32(BE_IF_FLAGS_MULTICAST);



		/* Reset mcast promisc mode if already set by setting mask

		 * and not setting flags field

		 */
@@ -1942,24 +1987,26 @@ int be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value) 
			memcpy(req->mcast_mac[i++].byte, ha->addr, ETH_ALEN);

	}



	if ((req->if_flags_mask & cpu_to_le32(be_if_cap_flags(adapter))) !=

	    req->if_flags_mask) {

		dev_warn(&adapter->pdev->dev,

			 "Cannot set rx filter flags 0x%x\n",

			 req->if_flags_mask);

		dev_warn(&adapter->pdev->dev,

			 "Interface is capable of 0x%x flags only\n",

			 be_if_cap_flags(adapter));

	}

	req->if_flags_mask &= cpu_to_le32(be_if_cap_flags(adapter));



	status = be_mcc_notify_wait(adapter);



err:

	spin_unlock_bh(&adapter->mcc_lock);

	return status;

}



int be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value)

{

	struct device *dev = &adapter->pdev->dev;



	if ((flags & be_if_cap_flags(adapter)) != flags) {

		dev_warn(dev, "Cannot set rx filter flags 0x%x\n", flags);

		dev_warn(dev, "Interface is capable of 0x%x flags only\n",

			 be_if_cap_flags(adapter));

	}

	flags &= be_if_cap_flags(adapter);



	return __be_cmd_rx_filter(adapter, flags, value);

}



/* Uses synchrounous mcc */

int be_cmd_set_flow_control(struct be_adapter *adapter, u32 tx_fc, u32 rx_fc)

{
@@ -2360,6 +2407,24 @@ int be_cmd_query_cable_type(struct be_adapter *adapter) 
	return status;

}



int be_cmd_query_sfp_info(struct be_adapter *adapter)

{

	u8 page_data[PAGE_DATA_LEN];

	int status;



	status = be_cmd_read_port_transceiver_data(adapter, TR_PAGE_A0,

						   page_data);

	if (!status) {

		strlcpy(adapter->phy.vendor_name, page_data +

			SFP_VENDOR_NAME_OFFSET, SFP_VENDOR_NAME_LEN - 1);

		strlcpy(adapter->phy.vendor_pn,

			page_data + SFP_VENDOR_PN_OFFSET,

			SFP_VENDOR_NAME_LEN - 1);

	}



	return status;

}



int lancer_cmd_delete_object(struct be_adapter *adapter, const char *obj_name)

{

	struct lancer_cmd_req_delete_object *req;
@@ -2436,7 +2501,8 @@ err_unlock: 
}



int be_cmd_write_flashrom(struct be_adapter *adapter, struct be_dma_mem *cmd,

			  u32 flash_type, u32 flash_opcode, u32 buf_size)

			  u32 flash_type, u32 flash_opcode, u32 img_offset,

			  u32 buf_size)

{

	struct be_mcc_wrb *wrb;

	struct be_cmd_write_flashrom *req;
@@ -2457,6 +2523,9 @@ int be_cmd_write_flashrom(struct be_adapter *adapter, struct be_dma_mem *cmd, 
			       cmd);



	req->params.op_type = cpu_to_le32(flash_type);

	if (flash_type == OPTYPE_OFFSET_SPECIFIED)

		req->params.offset = cpu_to_le32(img_offset);



	req->params.op_code = cpu_to_le32(flash_opcode);

	req->params.data_buf_size = cpu_to_le32(buf_size);
@@ -2477,10 +2546,10 @@ err_unlock: 
}



int be_cmd_get_flash_crc(struct be_adapter *adapter, u8 *flashed_crc,

			 u16 optype, int offset)

			 u16 img_optype, u32 img_offset, u32 crc_offset)

{

	struct be_mcc_wrb *wrb;

	struct be_cmd_read_flash_crc *req;

	struct be_mcc_wrb *wrb;

	int status;



	spin_lock_bh(&adapter->mcc_lock);
@@ -2496,9 +2565,13 @@ int be_cmd_get_flash_crc(struct be_adapter *adapter, u8 *flashed_crc, 
			       OPCODE_COMMON_READ_FLASHROM, sizeof(*req),

			       wrb, NULL);



	req->params.op_type = cpu_to_le32(optype);

	req->params.op_type = cpu_to_le32(img_optype);

	if (img_optype == OPTYPE_OFFSET_SPECIFIED)

		req->params.offset = cpu_to_le32(img_offset + crc_offset);

	else

		req->params.offset = cpu_to_le32(crc_offset);



	req->params.op_code = cpu_to_le32(FLASHROM_OPER_REPORT);

	req->params.offset = cpu_to_le32(offset);

	req->params.data_buf_size = cpu_to_le32(0x4);



	status = be_mcc_notify_wait(adapter);
@@ -3241,6 +3314,24 @@ err: 
	return status;

}



static bool be_is_wol_excluded(struct be_adapter *adapter)

{

	struct pci_dev *pdev = adapter->pdev;



	if (!be_physfn(adapter))

		return true;



	switch (pdev->subsystem_device) {

	case OC_SUBSYS_DEVICE_ID1:

	case OC_SUBSYS_DEVICE_ID2:

	case OC_SUBSYS_DEVICE_ID3:

	case OC_SUBSYS_DEVICE_ID4:

		return true;

	default:

		return false;

	}

}



int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter)

{

	struct be_mcc_wrb *wrb;
@@ -3427,42 +3518,34 @@ err: 
	return status;

}



int be_cmd_query_port_name(struct be_adapter *adapter, u8 *port_name)

int be_cmd_query_port_name(struct be_adapter *adapter)

{

	struct be_mcc_wrb *wrb;

	struct be_cmd_req_get_port_name *req;

	struct be_mcc_wrb *wrb;

	int status;



	if (!lancer_chip(adapter)) {

		*port_name = adapter->hba_port_num + '0';

		return 0;

	}



	spin_lock_bh(&adapter->mcc_lock);



	wrb = wrb_from_mccq(adapter);

	if (!wrb) {

		status = -EBUSY;

		goto err;

	}

	if (mutex_lock_interruptible(&adapter->mbox_lock))

		return -1;



	wrb = wrb_from_mbox(adapter);

	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

			       OPCODE_COMMON_GET_PORT_NAME, sizeof(*req), wrb,

			       NULL);

	if (!BEx_chip(adapter))

		req->hdr.version = 1;



	status = be_mcc_notify_wait(adapter);

	status = be_mbox_notify_wait(adapter);

	if (!status) {

		struct be_cmd_resp_get_port_name *resp = embedded_payload(wrb);



		*port_name = resp->port_name[adapter->hba_port_num];

		adapter->port_name = resp->port_name[adapter->hba_port_num];

	} else {

		*port_name = adapter->hba_port_num + '0';

		adapter->port_name = adapter->hba_port_num + '0';

	}

err:

	spin_unlock_bh(&adapter->mcc_lock);



	mutex_unlock(&adapter->mbox_lock);

	return status;

}

drivers/net/ethernet/emulex/benet/be_cmds.h

+36 −7
Original line number Diff line number Diff line
@@ -44,10 +44,10 @@ struct be_mcc_wrb { 
	} payload;

};



#define CQE_FLAGS_VALID_MASK 		(1 << 31)

#define CQE_FLAGS_ASYNC_MASK 		(1 << 30)

#define CQE_FLAGS_COMPLETED_MASK 	(1 << 28)

#define CQE_FLAGS_CONSUMED_MASK 	(1 << 27)

#define CQE_FLAGS_VALID_MASK		BIT(31)

#define CQE_FLAGS_ASYNC_MASK		BIT(30)

#define CQE_FLAGS_COMPLETED_MASK	BIT(28)

#define CQE_FLAGS_CONSUMED_MASK		BIT(27)



/* Completion Status */

enum mcc_base_status {
@@ -102,6 +102,8 @@ struct be_mcc_compl { 
#define ASYNC_EVENT_PVID_STATE		0x3

#define ASYNC_EVENT_CODE_QNQ		0x6

#define ASYNC_DEBUG_EVENT_TYPE_QNQ	1

#define ASYNC_EVENT_CODE_SLIPORT	0x11

#define ASYNC_EVENT_PORT_MISCONFIG	0x9



enum {

	LINK_DOWN	= 0x0,
@@ -169,6 +171,15 @@ struct be_async_event_qnq { 
	u32 flags;

} __packed;



#define INCOMPATIBLE_SFP		0x3

/* async event indicating misconfigured port */

struct be_async_event_misconfig_port {

	u32 event_data_word1;

	u32 event_data_word2;

	u32 rsvd0;

	u32 flags;

} __packed;



struct be_mcc_mailbox {

	struct be_mcc_wrb wrb;

	struct be_mcc_compl compl;
@@ -586,6 +597,10 @@ enum be_if_flags { 
			 BE_IF_FLAGS_PASS_L3L4_ERRORS | BE_IF_FLAGS_MULTICAST |\

			 BE_IF_FLAGS_UNTAGGED)



#define BE_IF_FLAGS_ALL_PROMISCUOUS	(BE_IF_FLAGS_PROMISCUOUS | \

					 BE_IF_FLAGS_VLAN_PROMISCUOUS |\

					 BE_IF_FLAGS_MCAST_PROMISCUOUS)



/* An RX interface is an object with one or more MAC addresses and

 * filtering capabilities. */

struct be_cmd_req_if_create {
@@ -1024,6 +1039,8 @@ enum { 
#define	SFP_PLUS_SFF_8472_COMP		0x5E

#define	SFP_PLUS_CABLE_TYPE_OFFSET	0x8

#define	SFP_PLUS_COPPER_CABLE		0x4

#define SFP_VENDOR_NAME_OFFSET		0x14

#define SFP_VENDOR_PN_OFFSET		0x28



#define PAGE_DATA_LEN   256

struct be_cmd_resp_port_type {
@@ -1091,6 +1108,10 @@ struct be_cmd_req_query_fw_cfg { 
	u32 rsvd[31];

};



/* ASIC revisions */

#define ASIC_REV_B0		0x10

#define ASIC_REV_P2		0x11



struct be_cmd_resp_query_fw_cfg {

	struct be_cmd_resp_hdr hdr;

	u32 be_config_number;
@@ -1168,6 +1189,7 @@ struct be_cmd_resp_get_beacon_state { 
#define OPTYPE_REDBOOT			1

#define OPTYPE_BIOS			2

#define OPTYPE_PXE_BIOS			3

#define OPTYPE_OFFSET_SPECIFIED		7

#define OPTYPE_FCOE_BIOS		8

#define OPTYPE_ISCSI_BACKUP		9

#define OPTYPE_FCOE_FW_ACTIVE		10
@@ -1260,6 +1282,11 @@ struct flash_file_hdr_g2 { 
	u8 build[24];

};



/* First letter of the build version of the image */

#define BLD_STR_UFI_TYPE_BE2	'2'

#define BLD_STR_UFI_TYPE_BE3	'3'

#define BLD_STR_UFI_TYPE_SH	'4'



struct flash_file_hdr_g3 {

	u8 sign[52];

	u8 ufi_version[4];
@@ -2245,8 +2272,10 @@ int be_cmd_get_beacon_state(struct be_adapter *adapter, u8 port_num, 
int be_cmd_read_port_transceiver_data(struct be_adapter *adapter,

				      u8 page_num, u8 *data);

int be_cmd_query_cable_type(struct be_adapter *adapter);

int be_cmd_query_sfp_info(struct be_adapter *adapter);

int be_cmd_write_flashrom(struct be_adapter *adapter, struct be_dma_mem *cmd,

			  u32 flash_oper, u32 flash_opcode, u32 buf_size);

			  u32 flash_oper, u32 flash_opcode, u32 img_offset,

			  u32 buf_size);

int lancer_cmd_write_object(struct be_adapter *adapter, struct be_dma_mem *cmd,

			    u32 data_size, u32 data_offset,

			    const char *obj_name, u32 *data_written,
@@ -2256,7 +2285,7 @@ int lancer_cmd_read_object(struct be_adapter *adapter, struct be_dma_mem *cmd, 
			   u32 *data_read, u32 *eof, u8 *addn_status);

int lancer_cmd_delete_object(struct be_adapter *adapter, const char *obj_name);

int be_cmd_get_flash_crc(struct be_adapter *adapter, u8 *flashed_crc,

			  u16 optype, int offset);

			 u16 img_optype, u32 img_offset, u32 crc_offset);

int be_cmd_enable_magic_wol(struct be_adapter *adapter, u8 *mac,

			    struct be_dma_mem *nonemb_cmd);

int be_cmd_fw_init(struct be_adapter *adapter);
@@ -2311,7 +2340,7 @@ int lancer_initiate_dump(struct be_adapter *adapter); 
int lancer_delete_dump(struct be_adapter *adapter);

bool dump_present(struct be_adapter *adapter);

int lancer_test_and_set_rdy_state(struct be_adapter *adapter);

int be_cmd_query_port_name(struct be_adapter *adapter, u8 *port_name);

int be_cmd_query_port_name(struct be_adapter *adapter);

int be_cmd_get_func_config(struct be_adapter *adapter,

			   struct be_resources *res);

int be_cmd_get_profile_config(struct be_adapter *adapter,

drivers/net/ethernet/emulex/benet/be_hw.h

+7 −7
Original line number Diff line number Diff line
@@ -75,7 +75,7 @@ 
 * atomically without having to arbitrate for the PCI Interrupt Disable bit

 * with the OS.

 */

#define MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK	(1 << 29) /* bit 29 */

#define MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK	BIT(29) /* bit 29 */



/********* PCI Function Capability *********/

#define BE_FUNCTION_CAPS_RSS			0x2
@@ -193,10 +193,10 @@ struct be_eq_entry { 
/* TX Queue Descriptor */

#define ETH_WRB_FRAG_LEN_MASK		0xFFFF

struct be_eth_wrb {

	u32 frag_pa_hi;		/* dword 0 */

	u32 frag_pa_lo;		/* dword 1 */

	__le32 frag_pa_hi;		/* dword 0 */

	__le32 frag_pa_lo;		/* dword 1 */

	u32 rsvd0;			/* dword 2 */

	u32 frag_len;		/* dword 3: bits 0 - 15 */

	__le32 frag_len;		/* dword 3: bits 0 - 15 */

} __packed;



/* Pseudo amap definition for eth_hdr_wrb in which each bit of the
@@ -224,12 +224,12 @@ struct amap_eth_hdr_wrb { 
} __packed;



#define TX_HDR_WRB_COMPL		1		/* word 2 */

#define TX_HDR_WRB_EVT			(1 << 1)	/* word 2 */

#define TX_HDR_WRB_EVT			BIT(1)		/* word 2 */

#define TX_HDR_WRB_NUM_SHIFT		13		/* word 2: bits 13:17 */

#define TX_HDR_WRB_NUM_MASK		0x1F		/* word 2: bits 13:17 */



struct be_eth_hdr_wrb {

	u32 dw[4];

	__le32 dw[4];

};



/********* Tx Compl Status Encoding *********/

drivers/net/ethernet/emulex/benet/be_main.c

+438 −197

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE