Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

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

Merge branch 'be2net-next' 



Sathya Perla says:

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

This patch set contains the following modificatons:
* three patches (1/7 to 3/7) that fix indentation style issues
* convert the u8 vlan[] array to a bit-map to reduce memory usage
* use MCCQ instead of MBOX in be_cmd_rss_config() as the MCCQ is already
  created by that time
* include rx-comp-error counter in ethtool stats
* remove the unused promiscuous setting from be_cmd_vlan_config()

Pls apply to net-next tree. Thanks!
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents fe6f397c b51aa367

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

+1 −1
Original line number Diff line number Diff line
@@ -455,7 +455,7 @@ struct be_adapter { 
	struct be_drv_stats drv_stats;

	struct be_aic_obj aic_obj[MAX_EVT_QS];

	u16 vlans_added;

	u8 vlan_tag[VLAN_N_VID];

	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 */

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

+191 −174
Original line number Diff line number Diff line
@@ -52,8 +52,7 @@ static struct be_cmd_priv_map cmd_priv_map[] = { 
	}

};



static bool be_cmd_allowed(struct be_adapter *adapter, u8 opcode,

			   u8 subsystem)

static bool be_cmd_allowed(struct be_adapter *adapter, u8 opcode, u8 subsystem)

{

	int i;

	int num_entries = sizeof(cmd_priv_map)/sizeof(struct be_cmd_priv_map);
@@ -221,7 +220,9 @@ static void be_async_link_state_process(struct be_adapter *adapter, 


/* Grp5 CoS Priority evt */

static void be_async_grp5_cos_priority_process(struct be_adapter *adapter,

		struct be_async_event_grp5_cos_priority *evt)

					       struct

					       be_async_event_grp5_cos_priority

					       *evt)

{

	if (evt->valid) {

		adapter->vlan_prio_bmap = evt->available_priority_bmap;
@@ -233,7 +234,9 @@ static void be_async_grp5_cos_priority_process(struct be_adapter *adapter, 


/* Grp5 QOS Speed evt: qos_link_speed is in units of 10 Mbps */

static void be_async_grp5_qos_speed_process(struct be_adapter *adapter,

		struct be_async_event_grp5_qos_link_speed *evt)

					    struct

					    be_async_event_grp5_qos_link_speed

					    *evt)

{

	if (adapter->phy.link_speed >= 0 &&

	    evt->physical_port == adapter->port_num)
@@ -242,7 +245,9 @@ static void be_async_grp5_qos_speed_process(struct be_adapter *adapter, 


/*Grp5 PVID evt*/

static void be_async_grp5_pvid_state_process(struct be_adapter *adapter,

		struct be_async_event_grp5_pvid_state *evt)

					     struct

					     be_async_event_grp5_pvid_state

					     *evt)

{

	if (evt->enabled) {

		adapter->pvid = le16_to_cpu(evt->tag) & VLAN_VID_MASK;
@@ -560,10 +565,8 @@ static bool lancer_provisioning_error(struct be_adapter *adapter) 
	u32 sliport_status = 0, sliport_err1 = 0, sliport_err2 = 0;

	sliport_status = ioread32(adapter->db + SLIPORT_STATUS_OFFSET);

	if (sliport_status & SLIPORT_STATUS_ERR_MASK) {

		sliport_err1 = ioread32(adapter->db +

					SLIPORT_ERROR1_OFFSET);

		sliport_err2 = ioread32(adapter->db +

					SLIPORT_ERROR2_OFFSET);

		sliport_err1 = ioread32(adapter->db + SLIPORT_ERROR1_OFFSET);

		sliport_err2 = ioread32(adapter->db + SLIPORT_ERROR2_OFFSET);



		if (sliport_err1 == SLIPORT_ERROR_NO_RESOURCE1 &&

		    sliport_err2 == SLIPORT_ERROR_NO_RESOURCE2)
@@ -630,8 +633,7 @@ int be_fw_wait_ready(struct be_adapter *adapter) 
		if (stage == POST_STAGE_ARMFW_RDY)

			return 0;



		dev_info(dev, "Waiting for POST, %ds elapsed\n",

			 timeout);

		dev_info(dev, "Waiting for POST, %ds elapsed\n", timeout);

		if (msleep_interruptible(2000)) {

			dev_err(dev, "Waiting for POST aborted\n");

			return -EINTR;
@@ -649,8 +651,7 @@ static inline struct be_sge *nonembedded_sgl(struct be_mcc_wrb *wrb) 
	return &wrb->payload.sgl[0];

}



static inline void fill_wrb_tags(struct be_mcc_wrb *wrb,

				 unsigned long addr)

static inline void fill_wrb_tags(struct be_mcc_wrb *wrb, unsigned long addr)

{

	wrb->tag0 = addr & 0xFFFFFFFF;

	wrb->tag1 = upper_32_bits(addr);
@@ -660,7 +661,8 @@ static inline void fill_wrb_tags(struct be_mcc_wrb *wrb, 
/* mem will be NULL for embedded commands */

static void be_wrb_cmd_hdr_prepare(struct be_cmd_req_hdr *req_hdr,

				   u8 subsystem, u8 opcode, int cmd_len,

				struct be_mcc_wrb *wrb, struct be_dma_mem *mem)

				   struct be_mcc_wrb *wrb,

				   struct be_dma_mem *mem)

{

	struct be_sge *sge;
@@ -868,7 +870,8 @@ int be_cmd_eq_create(struct be_adapter *adapter, struct be_eq_obj *eqo) 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_EQ_CREATE, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_EQ_CREATE, sizeof(*req), wrb,

			       NULL);



	/* Support for EQ_CREATEv2 available only SH-R onwards */

	if (!(BEx_chip(adapter) || lancer_chip(adapter)))
@@ -917,7 +920,8 @@ int be_cmd_mac_addr_query(struct be_adapter *adapter, u8 *mac_addr, 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_NTWK_MAC_QUERY, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_NTWK_MAC_QUERY, sizeof(*req), wrb,

			       NULL);

	req->type = MAC_ADDRESS_TYPE_NETWORK;

	if (permanent) {

		req->permanent = 1;
@@ -956,7 +960,8 @@ int be_cmd_pmac_add(struct be_adapter *adapter, u8 *mac_addr, 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_NTWK_PMAC_ADD, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_NTWK_PMAC_ADD, sizeof(*req), wrb,

			       NULL);



	req->hdr.domain = domain;

	req->if_id = cpu_to_le32(if_id);
@@ -1028,7 +1033,8 @@ int be_cmd_cq_create(struct be_adapter *adapter, struct be_queue_info *cq, 
	ctxt = &req->context;



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_CQ_CREATE, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_CQ_CREATE, sizeof(*req), wrb,

			       NULL);



	req->num_pages =  cpu_to_le16(PAGES_4K_SPANNED(q_mem->va, q_mem->size));
@@ -1057,10 +1063,8 @@ int be_cmd_cq_create(struct be_adapter *adapter, struct be_queue_info *cq, 
		AMAP_SET_BITS(struct amap_cq_context_v2, count, ctxt,

			      __ilog2_u32(cq->len / 256));

		AMAP_SET_BITS(struct amap_cq_context_v2, valid, ctxt, 1);

		AMAP_SET_BITS(struct amap_cq_context_v2, eventable,

								ctxt, 1);

		AMAP_SET_BITS(struct amap_cq_context_v2, eqid,

								ctxt, eq->id);

		AMAP_SET_BITS(struct amap_cq_context_v2, eventable, ctxt, 1);

		AMAP_SET_BITS(struct amap_cq_context_v2, eqid, ctxt, eq->id);

	}



	be_dws_cpu_to_le(ctxt, sizeof(req->context));
@@ -1105,7 +1109,8 @@ static int be_cmd_mccq_ext_create(struct be_adapter *adapter, 
	ctxt = &req->context;



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

			OPCODE_COMMON_MCC_CREATE_EXT, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_MCC_CREATE_EXT, sizeof(*req), wrb,

			       NULL);



	req->num_pages = cpu_to_le16(PAGES_4K_SPANNED(q_mem->va, q_mem->size));

	if (BEx_chip(adapter)) {
@@ -1162,7 +1167,8 @@ static int be_cmd_mccq_org_create(struct be_adapter *adapter, 
	ctxt = &req->context;



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

			OPCODE_COMMON_MCC_CREATE, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_MCC_CREATE, sizeof(*req), wrb,

			       NULL);



	req->num_pages = cpu_to_le16(PAGES_4K_SPANNED(q_mem->va, q_mem->size));
@@ -1187,8 +1193,7 @@ static int be_cmd_mccq_org_create(struct be_adapter *adapter, 
}



int be_cmd_mccq_create(struct be_adapter *adapter,

			struct be_queue_info *mccq,

			struct be_queue_info *cq)

		       struct be_queue_info *mccq, struct be_queue_info *cq)

{

	int status;
@@ -1384,7 +1389,8 @@ int be_cmd_if_create(struct be_adapter *adapter, u32 cap_flags, u32 en_flags, 


	req = embedded_payload(&wrb);

	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_NTWK_INTERFACE_CREATE, sizeof(*req), &wrb, NULL);

			       OPCODE_COMMON_NTWK_INTERFACE_CREATE,

			       sizeof(*req), &wrb, NULL);

	req->hdr.domain = domain;

	req->capability_flags = cpu_to_le32(cap_flags);

	req->enable_flags = cpu_to_le32(en_flags);
@@ -1422,7 +1428,8 @@ int be_cmd_if_destroy(struct be_adapter *adapter, int interface_id, u32 domain) 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_NTWK_INTERFACE_DESTROY, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_NTWK_INTERFACE_DESTROY,

			       sizeof(*req), wrb, NULL);

	req->hdr.domain = domain;

	req->interface_id = cpu_to_le32(interface_id);
@@ -1452,7 +1459,8 @@ int be_cmd_get_stats(struct be_adapter *adapter, struct be_dma_mem *nonemb_cmd) 
	hdr = nonemb_cmd->va;



	be_wrb_cmd_hdr_prepare(hdr, CMD_SUBSYSTEM_ETH,

		OPCODE_ETH_GET_STATISTICS, nonemb_cmd->size, wrb, nonemb_cmd);

			       OPCODE_ETH_GET_STATISTICS, nonemb_cmd->size, wrb,

			       nonemb_cmd);



	/* version 1 of the cmd is not supported only by BE2 */

	if (BE2_chip(adapter))
@@ -1493,8 +1501,8 @@ int lancer_cmd_get_pport_stats(struct be_adapter *adapter, 
	req = nonemb_cmd->va;



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ETH,

			OPCODE_ETH_GET_PPORT_STATS, nonemb_cmd->size, wrb,

			nonemb_cmd);

			       OPCODE_ETH_GET_PPORT_STATS, nonemb_cmd->size,

			       wrb, nonemb_cmd);



	req->cmd_params.params.pport_num = cpu_to_le16(adapter->hba_port_num);

	req->cmd_params.params.reset_stats = 0;
@@ -1553,7 +1561,8 @@ int be_cmd_link_status_query(struct be_adapter *adapter, u16 *link_speed, 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_NTWK_LINK_STATUS_QUERY, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_NTWK_LINK_STATUS_QUERY,

			       sizeof(*req), wrb, NULL);



	/* version 1 of the cmd is not supported only by BE2 */

	if (!BE2_chip(adapter))
@@ -1598,8 +1607,8 @@ int be_cmd_get_die_temperature(struct be_adapter *adapter) 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES, sizeof(*req),

		wrb, NULL);

			       OPCODE_COMMON_GET_CNTL_ADDITIONAL_ATTRIBUTES,

			       sizeof(*req), wrb, NULL);



	be_mcc_notify(adapter);
@@ -1625,7 +1634,8 @@ int be_cmd_get_reg_len(struct be_adapter *adapter, u32 *log_size) 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_MANAGE_FAT, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_MANAGE_FAT, sizeof(*req), wrb,

			       NULL);

	req->fat_operation = cpu_to_le32(QUERY_FAT);

	status = be_mcc_notify_wait(adapter);

	if (!status) {
@@ -1679,8 +1689,8 @@ void be_cmd_get_regs(struct be_adapter *adapter, u32 buf_len, void *buf) 


		payload_len = sizeof(struct be_cmd_req_get_fat) + buf_size;

		be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

				OPCODE_COMMON_MANAGE_FAT, payload_len, wrb,

				&get_fat_cmd);

				       OPCODE_COMMON_MANAGE_FAT, payload_len,

				       wrb, &get_fat_cmd);



		req->fat_operation = cpu_to_le32(RETRIEVE_FAT);

		req->read_log_offset = cpu_to_le32(log_offset);
@@ -1702,8 +1712,7 @@ void be_cmd_get_regs(struct be_adapter *adapter, u32 buf_len, void *buf) 
	}

err:

	pci_free_consistent(adapter->pdev, get_fat_cmd.size,

			get_fat_cmd.va,

			get_fat_cmd.dma);

			    get_fat_cmd.va, get_fat_cmd.dma);

	spin_unlock_bh(&adapter->mcc_lock);

}
@@ -1726,7 +1735,8 @@ int be_cmd_get_fw_ver(struct be_adapter *adapter, char *fw_ver, 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_GET_FW_VERSION, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_GET_FW_VERSION, sizeof(*req), wrb,

			       NULL);

	status = be_mcc_notify_wait(adapter);

	if (!status) {

		struct be_cmd_resp_get_fw_version *resp = embedded_payload(wrb);
@@ -1759,7 +1769,8 @@ int be_cmd_modify_eqd(struct be_adapter *adapter, struct be_set_eqd *set_eqd, 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_MODIFY_EQ_DELAY, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_MODIFY_EQ_DELAY, sizeof(*req), wrb,

			       NULL);



	req->num_eq = cpu_to_le32(num);

	for (i = 0; i < num; i++) {
@@ -1777,7 +1788,7 @@ int be_cmd_modify_eqd(struct be_adapter *adapter, struct be_set_eqd *set_eqd, 


/* Uses sycnhronous mcc */

int be_cmd_vlan_config(struct be_adapter *adapter, u32 if_id, u16 *vtag_array,

		       u32 num, bool promiscuous)

		       u32 num)

{

	struct be_mcc_wrb *wrb;

	struct be_cmd_req_vlan_config *req;
@@ -1793,19 +1804,16 @@ int be_cmd_vlan_config(struct be_adapter *adapter, u32 if_id, u16 *vtag_array, 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_NTWK_VLAN_CONFIG, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_NTWK_VLAN_CONFIG, sizeof(*req),

			       wrb, NULL);



	req->interface_id = if_id;

	req->promiscuous = promiscuous;

	req->untagged = BE_IF_FLAGS_UNTAGGED & be_if_cap_flags(adapter) ? 1 : 0;

	req->num_vlan = num;

	if (!promiscuous) {

	memcpy(req->normal_vlan, vtag_array,

	       req->num_vlan * sizeof(vtag_array[0]));

	}



	status = be_mcc_notify_wait(adapter);



err:

	spin_unlock_bh(&adapter->mcc_lock);

	return status;
@@ -1836,7 +1844,8 @@ int be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 value) 
						 BE_IF_FLAGS_VLAN_PROMISCUOUS |

						 BE_IF_FLAGS_MCAST_PROMISCUOUS);

		if (value == ON)

			req->if_flags = cpu_to_le32(BE_IF_FLAGS_PROMISCUOUS |

			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) {
@@ -1905,7 +1914,8 @@ int be_cmd_set_flow_control(struct be_adapter *adapter, u32 tx_fc, u32 rx_fc) 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_SET_FLOW_CONTROL, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_SET_FLOW_CONTROL, sizeof(*req),

			       wrb, NULL);



	req->tx_flow_control = cpu_to_le16((u16)tx_fc);

	req->rx_flow_control = cpu_to_le16((u16)rx_fc);
@@ -1938,7 +1948,8 @@ int be_cmd_get_flow_control(struct be_adapter *adapter, u32 *tx_fc, u32 *rx_fc) 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_GET_FLOW_CONTROL, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_GET_FLOW_CONTROL, sizeof(*req),

			       wrb, NULL);



	status = be_mcc_notify_wait(adapter);

	if (!status) {
@@ -1968,7 +1979,8 @@ int be_cmd_query_fw_cfg(struct be_adapter *adapter, u32 *port_num, 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_QUERY_FIRMWARE_CONFIG, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_QUERY_FIRMWARE_CONFIG,

			       sizeof(*req), wrb, NULL);



	status = be_mbox_notify_wait(adapter);

	if (!status) {
@@ -2011,7 +2023,8 @@ int be_cmd_reset_function(struct be_adapter *adapter) 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(req, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_FUNCTION_RESET, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_FUNCTION_RESET, sizeof(*req), wrb,

			       NULL);



	status = be_mbox_notify_wait(adapter);
@@ -2029,10 +2042,13 @@ int be_cmd_rss_config(struct be_adapter *adapter, u8 *rsstable, 
	if (!(be_if_cap_flags(adapter) & BE_IF_FLAGS_RSS))

		return 0;



	if (mutex_lock_interruptible(&adapter->mbox_lock))

		return -1;

	spin_lock_bh(&adapter->mcc_lock);



	wrb = wrb_from_mbox(adapter);

	wrb = wrb_from_mccq(adapter);

	if (!wrb) {

		status = -EBUSY;

		goto err;

	}

	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ETH,
@@ -2042,16 +2058,16 @@ int be_cmd_rss_config(struct be_adapter *adapter, u8 *rsstable, 
	req->enable_rss = cpu_to_le16(rss_hash_opts);

	req->cpu_table_size_log2 = cpu_to_le16(fls(table_size) - 1);



	if (lancer_chip(adapter) || skyhawk_chip(adapter))

	if (!BEx_chip(adapter))

		req->hdr.version = 1;



	memcpy(req->cpu_table, rsstable, table_size);

	memcpy(req->hash, rss_hkey, RSS_HASH_KEY_LEN);

	be_dws_cpu_to_le(req->hash, sizeof(req->hash));



	status = be_mbox_notify_wait(adapter);



	mutex_unlock(&adapter->mbox_lock);

	status = be_mcc_notify_wait(adapter);

err:

	spin_unlock_bh(&adapter->mcc_lock);

	return status;

}
@@ -2073,7 +2089,8 @@ int be_cmd_set_beacon_state(struct be_adapter *adapter, u8 port_num, 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_ENABLE_DISABLE_BEACON, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_ENABLE_DISABLE_BEACON,

			       sizeof(*req), wrb, NULL);



	req->port_num = port_num;

	req->beacon_state = state;
@@ -2104,7 +2121,8 @@ int be_cmd_get_beacon_state(struct be_adapter *adapter, u8 port_num, u32 *state) 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_GET_BEACON_STATE, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_GET_BEACON_STATE, sizeof(*req),

			       wrb, NULL);



	req->port_num = port_num;
@@ -2258,7 +2276,8 @@ int be_cmd_write_flashrom(struct be_adapter *adapter, struct be_dma_mem *cmd, 
	req = cmd->va;



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_WRITE_FLASHROM, cmd->size, wrb, cmd);

			       OPCODE_COMMON_WRITE_FLASHROM, cmd->size, wrb,

			       cmd);



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

	req->params.op_code = cpu_to_le32(flash_opcode);
@@ -2331,8 +2350,8 @@ int be_cmd_enable_magic_wol(struct be_adapter *adapter, u8 *mac, 
	req = nonemb_cmd->va;



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_ETH,

		OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG, sizeof(*req), wrb,

		nonemb_cmd);

			       OPCODE_ETH_ACPI_WOL_MAGIC_CONFIG, sizeof(*req),

			       wrb, nonemb_cmd);

	memcpy(req->magic_mac, mac, ETH_ALEN);



	status = be_mcc_notify_wait(adapter);
@@ -2360,8 +2379,8 @@ int be_cmd_set_loopback(struct be_adapter *adapter, u8 port_num, 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_LOWLEVEL,

			OPCODE_LOWLEVEL_SET_LOOPBACK_MODE, sizeof(*req), wrb,

			NULL);

			       OPCODE_LOWLEVEL_SET_LOOPBACK_MODE, sizeof(*req),

			       wrb, NULL);



	req->src_port = port_num;

	req->dest_port = port_num;
@@ -2375,7 +2394,8 @@ int be_cmd_set_loopback(struct be_adapter *adapter, u8 port_num, 
}



int be_cmd_loopback_test(struct be_adapter *adapter, u32 port_num,

		u32 loopback_type, u32 pkt_size, u32 num_pkts, u64 pattern)

			 u32 loopback_type, u32 pkt_size, u32 num_pkts,

			 u64 pattern)

{

	struct be_mcc_wrb *wrb;

	struct be_cmd_req_loopback_test *req;
@@ -2393,7 +2413,8 @@ int be_cmd_loopback_test(struct be_adapter *adapter, u32 port_num, 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_LOWLEVEL,

			OPCODE_LOWLEVEL_LOOPBACK_TEST, sizeof(*req), wrb, NULL);

			       OPCODE_LOWLEVEL_LOOPBACK_TEST, sizeof(*req), wrb,

			       NULL);



	req->hdr.timeout = cpu_to_le32(15);

	req->pattern = cpu_to_le64(pattern);
@@ -2434,7 +2455,8 @@ int be_cmd_ddr_dma_test(struct be_adapter *adapter, u64 pattern, 
	}

	req = cmd->va;

	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_LOWLEVEL,

			OPCODE_LOWLEVEL_HOST_DDR_DMA, cmd->size, wrb, cmd);

			       OPCODE_LOWLEVEL_HOST_DDR_DMA, cmd->size, wrb,

			       cmd);



	req->pattern = cpu_to_le64(pattern);

	req->byte_count = cpu_to_le32(byte_cnt);
@@ -2507,8 +2529,7 @@ int be_cmd_get_phy_info(struct be_adapter *adapter) 
		goto err;

	}

	cmd.size = sizeof(struct be_cmd_req_get_phy_info);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size,

					&cmd.dma);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);

	if (!cmd.va) {

		dev_err(&adapter->pdev->dev, "Memory alloc failure\n");

		status = -ENOMEM;
@@ -2541,8 +2562,7 @@ int be_cmd_get_phy_info(struct be_adapter *adapter) 
				BE_SUPPORTED_SPEED_1GBPS;

		}

	}

	pci_free_consistent(adapter->pdev, cmd.size,

				cmd.va, cmd.dma);

	pci_free_consistent(adapter->pdev, cmd.size, cmd.va, cmd.dma);

err:

	spin_unlock_bh(&adapter->mcc_lock);

	return status;
@@ -2596,8 +2616,7 @@ int be_cmd_get_cntl_attributes(struct be_adapter *adapter) 
	attribs_cmd.va = pci_alloc_consistent(adapter->pdev, attribs_cmd.size,

					      &attribs_cmd.dma);

	if (!attribs_cmd.va) {

		dev_err(&adapter->pdev->dev,

				"Memory allocation failure\n");

		dev_err(&adapter->pdev->dev, "Memory allocation failure\n");

		status = -ENOMEM;

		goto err;

	}
@@ -2610,8 +2629,8 @@ int be_cmd_get_cntl_attributes(struct be_adapter *adapter) 
	req = attribs_cmd.va;



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

			 OPCODE_COMMON_GET_CNTL_ATTRIBUTES, payload_len, wrb,

			&attribs_cmd);

			       OPCODE_COMMON_GET_CNTL_ATTRIBUTES, payload_len,

			       wrb, &attribs_cmd);



	status = be_mbox_notify_wait(adapter);

	if (!status) {
@@ -2646,7 +2665,8 @@ int be_cmd_req_native_mode(struct be_adapter *adapter) 
	req = embedded_payload(wrb);



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

		OPCODE_COMMON_SET_DRIVER_FUNCTION_CAP, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_SET_DRIVER_FUNCTION_CAP,

			       sizeof(*req), wrb, NULL);



	req->valid_cap_flags = cpu_to_le32(CAPABILITY_SW_TIMESTAMPS |

				CAPABILITY_BE3_NATIVE_ERX_API);
@@ -2838,8 +2858,8 @@ int be_cmd_get_mac_from_list(struct be_adapter *adapter, u8 *mac, 
	return status;

}



int be_cmd_get_active_mac(struct be_adapter *adapter, u32 curr_pmac_id, u8 *mac,

			  u32 if_handle, bool active, u32 domain)

int be_cmd_get_active_mac(struct be_adapter *adapter, u32 curr_pmac_id,

			  u8 *mac, u32 if_handle, bool active, u32 domain)

{



	if (!active)
@@ -2914,8 +2934,7 @@ int be_cmd_set_mac_list(struct be_adapter *adapter, u8 *mac_array, 
	status = be_mcc_notify_wait(adapter);



err:

	dma_free_coherent(&adapter->pdev->dev, cmd.size,

				cmd.va, cmd.dma);

	dma_free_coherent(&adapter->pdev->dev, cmd.size, cmd.va, cmd.dma);

	spin_unlock_bh(&adapter->mcc_lock);

	return status;

}
@@ -2960,7 +2979,8 @@ int be_cmd_set_hsw_config(struct be_adapter *adapter, u16 pvid, 
	ctxt = &req->context;



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

			OPCODE_COMMON_SET_HSW_CONFIG, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_SET_HSW_CONFIG, sizeof(*req), wrb,

			       NULL);



	req->hdr.domain = domain;

	AMAP_SET_BITS(struct amap_set_hsw_context, interface_id, ctxt, intf_id);
@@ -3006,7 +3026,8 @@ int be_cmd_get_hsw_config(struct be_adapter *adapter, u16 *pvid, 
	ctxt = &req->context;



	be_wrb_cmd_hdr_prepare(&req->hdr, CMD_SUBSYSTEM_COMMON,

			OPCODE_COMMON_GET_HSW_CONFIG, sizeof(*req), wrb, NULL);

			       OPCODE_COMMON_GET_HSW_CONFIG, sizeof(*req), wrb,

			       NULL);



	req->hdr.domain = domain;

	AMAP_SET_BITS(struct amap_get_hsw_req_context, interface_id,
@@ -3024,8 +3045,7 @@ int be_cmd_get_hsw_config(struct be_adapter *adapter, u16 *pvid, 
	if (!status) {

		struct be_cmd_resp_get_hsw_config *resp =

						embedded_payload(wrb);

		be_dws_le_to_cpu(&resp->context,

						sizeof(resp->context));

		be_dws_le_to_cpu(&resp->context, sizeof(resp->context));

		vid = AMAP_GET_BITS(struct amap_get_hsw_resp_context,

				    pvid, &resp->context);

		if (pvid)
@@ -3059,11 +3079,9 @@ int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter) 


	memset(&cmd, 0, sizeof(struct be_dma_mem));

	cmd.size = sizeof(struct be_cmd_resp_acpi_wol_magic_config_v1);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size,

					       &cmd.dma);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);

	if (!cmd.va) {

		dev_err(&adapter->pdev->dev,

				"Memory allocation failure\n");

		dev_err(&adapter->pdev->dev, "Memory allocation failure\n");

		status = -ENOMEM;

		goto err;

	}
@@ -3346,8 +3364,7 @@ int be_cmd_get_func_config(struct be_adapter *adapter, struct be_resources *res) 


	memset(&cmd, 0, sizeof(struct be_dma_mem));

	cmd.size = sizeof(struct be_cmd_resp_get_func_config);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size,

				      &cmd.dma);

	cmd.va = pci_alloc_consistent(adapter->pdev, cmd.size, &cmd.dma);

	if (!cmd.va) {

		dev_err(&adapter->pdev->dev, "Memory alloc failure\n");

		status = -ENOMEM;

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

+1 −1
Original line number Diff line number Diff line
@@ -2060,7 +2060,7 @@ int be_cmd_get_fw_ver(struct be_adapter *adapter, char *fw_ver, 
		      char *fw_on_flash);

int be_cmd_modify_eqd(struct be_adapter *adapter, struct be_set_eqd *, int num);

int be_cmd_vlan_config(struct be_adapter *adapter, u32 if_id, u16 *vtag_array,

		       u32 num, bool promiscuous);

		       u32 num);

int be_cmd_rx_filter(struct be_adapter *adapter, u32 flags, u32 status);

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

int be_cmd_get_flow_control(struct be_adapter *adapter, u32 *tx_fc, u32 *rx_fc);

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

+43 −58
Original line number Diff line number Diff line
@@ -132,6 +132,7 @@ static const struct be_ethtool_stat et_rx_stats[] = { 
	{DRVSTAT_RX_INFO(rx_bytes)},/* If moving this member see above note */

	{DRVSTAT_RX_INFO(rx_pkts)}, /* If moving this member see above note */

	{DRVSTAT_RX_INFO(rx_compl)},

	{DRVSTAT_RX_INFO(rx_compl_err)},

	{DRVSTAT_RX_INFO(rx_mcast_pkts)},

	/* Number of page allocation failures while posting receive buffers

	 * to HW.
@@ -201,8 +202,7 @@ static void be_get_drvinfo(struct net_device *netdev, 
	drvinfo->eedump_len = 0;

}



static u32

lancer_cmd_get_file_len(struct be_adapter *adapter, u8 *file_name)

static u32 lancer_cmd_get_file_len(struct be_adapter *adapter, u8 *file_name)

{

	u32 data_read = 0, eof;

	u8 addn_status;
@@ -212,13 +212,13 @@ lancer_cmd_get_file_len(struct be_adapter *adapter, u8 *file_name) 
	memset(&data_len_cmd, 0, sizeof(data_len_cmd));

	/* data_offset and data_size should be 0 to get reg len */

	status = lancer_cmd_read_object(adapter, &data_len_cmd, 0, 0,

				file_name, &data_read, &eof, &addn_status);

					file_name, &data_read, &eof,

					&addn_status);



	return data_read;

}



static int

lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name,

static int lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name,

				u32 buf_len, void *buf)

{

	struct be_dma_mem read_cmd;
@@ -242,8 +242,8 @@ lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name, 
				LANCER_READ_FILE_CHUNK);

		chunk_size = ALIGN(chunk_size, 4);

		status = lancer_cmd_read_object(adapter, &read_cmd, chunk_size,

				total_read_len, file_name, &read_len,

				&eof, &addn_status);

						total_read_len, file_name,

						&read_len, &eof, &addn_status);

		if (!status) {

			memcpy(buf + total_read_len, read_cmd.va, read_len);

			total_read_len += read_len;
@@ -259,8 +259,7 @@ lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name, 
	return status;

}



static int

be_get_reg_len(struct net_device *netdev)

static int be_get_reg_len(struct net_device *netdev)

{

	struct be_adapter *adapter = netdev_priv(netdev);

	u32 log_size = 0;
@@ -337,8 +336,7 @@ static int be_set_coalesce(struct net_device *netdev, 
	return 0;

}



static void

be_get_ethtool_stats(struct net_device *netdev,

static void be_get_ethtool_stats(struct net_device *netdev,

				 struct ethtool_stats *stats, uint64_t *data)

{

	struct be_adapter *adapter = netdev_priv(netdev);
@@ -390,8 +388,7 @@ be_get_ethtool_stats(struct net_device *netdev, 
	}

}



static void

be_get_stat_strings(struct net_device *netdev, uint32_t stringset,

static void be_get_stat_strings(struct net_device *netdev, uint32_t stringset,

				uint8_t *data)

{

	struct be_adapter *adapter = netdev_priv(netdev);
@@ -649,8 +646,7 @@ be_set_pauseparam(struct net_device *netdev, struct ethtool_pauseparam *ecmd) 
	return status;

}



static int

be_set_phys_id(struct net_device *netdev,

static int be_set_phys_id(struct net_device *netdev,

			  enum ethtool_phys_id_state state)

{

	struct be_adapter *adapter = netdev_priv(netdev);
@@ -708,8 +704,7 @@ static int be_set_dump(struct net_device *netdev, struct ethtool_dump *dump) 
	return status;

}



static void

be_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)

static void be_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)

{

	struct be_adapter *adapter = netdev_priv(netdev);
@@ -723,8 +718,7 @@ be_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) 
	memset(&wol->sopass, 0, sizeof(wol->sopass));

}



static int

be_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)

static int be_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)

{

	struct be_adapter *adapter = netdev_priv(netdev);
@@ -744,8 +738,7 @@ be_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) 
	return 0;

}



static int

be_test_ddr_dma(struct be_adapter *adapter)

static int be_test_ddr_dma(struct be_adapter *adapter)

{

	int ret, i;

	struct be_dma_mem ddrdma_cmd;
@@ -775,18 +768,15 @@ be_test_ddr_dma(struct be_adapter *adapter) 
static u64 be_loopback_test(struct be_adapter *adapter, u8 loopback_type,

			    u64 *status)

{

	be_cmd_set_loopback(adapter, adapter->hba_port_num,

				loopback_type, 1);

	be_cmd_set_loopback(adapter, adapter->hba_port_num, loopback_type, 1);

	*status = be_cmd_loopback_test(adapter, adapter->hba_port_num,

				loopback_type, 1500,

				2, 0xabc);

	be_cmd_set_loopback(adapter, adapter->hba_port_num,

				BE_NO_LOOPBACK, 1);

				       loopback_type, 1500, 2, 0xabc);

	be_cmd_set_loopback(adapter, adapter->hba_port_num, BE_NO_LOOPBACK, 1);

	return *status;

}



static void

be_self_test(struct net_device *netdev, struct ethtool_test *test, u64 *data)

static void be_self_test(struct net_device *netdev, struct ethtool_test *test,

			 u64 *data)

{

	struct be_adapter *adapter = netdev_priv(netdev);

	int status;
@@ -801,12 +791,10 @@ be_self_test(struct net_device *netdev, struct ethtool_test *test, u64 *data) 
	memset(data, 0, sizeof(u64) * ETHTOOL_TESTS_NUM);



	if (test->flags & ETH_TEST_FL_OFFLINE) {

		if (be_loopback_test(adapter, BE_MAC_LOOPBACK,

				     &data[0]) != 0)

		if (be_loopback_test(adapter, BE_MAC_LOOPBACK, &data[0]) != 0)

			test->flags |= ETH_TEST_FL_FAILED;



		if (be_loopback_test(adapter, BE_PHY_LOOPBACK,

				     &data[1]) != 0)

		if (be_loopback_test(adapter, BE_PHY_LOOPBACK, &data[1]) != 0)

			test->flags |= ETH_TEST_FL_FAILED;



		if (test->flags & ETH_TEST_FL_EXTERNAL_LB) {
@@ -832,16 +820,14 @@ be_self_test(struct net_device *netdev, struct ethtool_test *test, u64 *data) 
	}

}



static int

be_do_flash(struct net_device *netdev, struct ethtool_flash *efl)

static int be_do_flash(struct net_device *netdev, struct ethtool_flash *efl)

{

	struct be_adapter *adapter = netdev_priv(netdev);



	return be_load_fw(adapter, efl->data);

}



static int

be_get_eeprom_len(struct net_device *netdev)

static int be_get_eeprom_len(struct net_device *netdev)

{

	struct be_adapter *adapter = netdev_priv(netdev);
@@ -860,9 +846,8 @@ be_get_eeprom_len(struct net_device *netdev) 
	}

}



static int

be_read_eeprom(struct net_device *netdev, struct ethtool_eeprom *eeprom,

			uint8_t *data)

static int be_read_eeprom(struct net_device *netdev,

			  struct ethtool_eeprom *eeprom, uint8_t *data)

{

	struct be_adapter *adapter = netdev_priv(netdev);

	struct be_dma_mem eeprom_cmd;