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

Commit 7777de9a authored by Anirban Chakraborty's avatar Anirban Chakraborty Committed by David S. Miller
Browse files

qlcnic: Change CDRP function 



Argument list to CDRP function has become unmanageably long. Fix it by properly
declaring a struct that encompasses all the input and output parameters.

Signed-off-by: default avatarAnirban Chakraborty <anirban.chakraborty@qlogic.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 853d4bca

drivers/net/ethernet/qlogic/qlcnic/qlcnic.h

+16 −5
Original line number Diff line number Diff line
@@ -36,8 +36,8 @@ 


#define _QLCNIC_LINUX_MAJOR 5

#define _QLCNIC_LINUX_MINOR 0

#define _QLCNIC_LINUX_SUBVERSION 23

#define QLCNIC_LINUX_VERSIONID  "5.0.23"

#define _QLCNIC_LINUX_SUBVERSION 24

#define QLCNIC_LINUX_VERSIONID  "5.0.24"

#define QLCNIC_DRV_IDC_VER  0x01

#define QLCNIC_DRIVER_VERSION  ((_QLCNIC_LINUX_MAJOR << 16) |\

		 (_QLCNIC_LINUX_MINOR << 8) | (_QLCNIC_LINUX_SUBVERSION))
@@ -583,6 +583,7 @@ struct qlcnic_recv_context { 
#define QLCNIC_CDRP_CMD_DESTROY_RX_CTX          0x00000008

#define QLCNIC_CDRP_CMD_CREATE_TX_CTX           0x00000009

#define QLCNIC_CDRP_CMD_DESTROY_TX_CTX          0x0000000a

#define QLCNIC_CDRP_CMD_INTRPT_TEST		0x00000011

#define QLCNIC_CDRP_CMD_SET_MTU                 0x00000012

#define QLCNIC_CDRP_CMD_READ_PHY		0x00000013

#define QLCNIC_CDRP_CMD_WRITE_PHY		0x00000014
@@ -1358,6 +1359,18 @@ struct qlcnic_dump_operations { 
			struct qlcnic_dump_entry *, u32 *);

};



struct _cdrp_cmd {

	u32 cmd;

	u32 arg1;

	u32 arg2;

	u32 arg3;

};



struct qlcnic_cmd_args {

	struct _cdrp_cmd req;

	struct _cdrp_cmd rsp;

};



int qlcnic_fw_cmd_get_minidump_temp(struct qlcnic_adapter *adapter);

int qlcnic_fw_cmd_set_port(struct qlcnic_adapter *adapter, u32 config);
@@ -1470,9 +1483,7 @@ int qlcnic_check_loopback_buff(unsigned char *data, u8 mac[]); 


/* Functions from qlcnic_main.c */

int qlcnic_reset_context(struct qlcnic_adapter *);

u32 qlcnic_issue_cmd(struct qlcnic_adapter *adapter,

	u32 pci_fn, u32 version, u32 arg1, u32 arg2, u32 arg3, u32 cmd,

		u32 *rd_args[3]);

void qlcnic_issue_cmd(struct qlcnic_adapter *adapter, struct qlcnic_cmd_args *);

void qlcnic_diag_free_res(struct net_device *netdev, int max_sds_rings);

int qlcnic_diag_alloc_res(struct net_device *netdev, int test);

netdev_tx_t qlcnic_xmit_frame(struct sk_buff *skb, struct net_device *netdev);

drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c

+162 −212
Original line number Diff line number Diff line
@@ -26,50 +26,54 @@ qlcnic_poll_rsp(struct qlcnic_adapter *adapter) 
	return rsp;

}



u32

qlcnic_issue_cmd(struct qlcnic_adapter *adapter,

	u32 pci_fn, u32 version, u32 arg1, u32 arg2, u32 arg3, u32 cmd,

		u32 *rd_args[3])

void

qlcnic_issue_cmd(struct qlcnic_adapter *adapter, struct qlcnic_cmd_args *cmd)

{

	u32 rsp;

	u32 signature;

	u32 rcode = QLCNIC_RCODE_SUCCESS;

	struct pci_dev *pdev = adapter->pdev;

	struct qlcnic_hardware_context *ahw = adapter->ahw;



	signature = QLCNIC_CDRP_SIGNATURE_MAKE(pci_fn, version);

	signature = QLCNIC_CDRP_SIGNATURE_MAKE(ahw->pci_func,

		adapter->fw_hal_version);



	/* Acquire semaphore before accessing CRB */

	if (qlcnic_api_lock(adapter))

		return QLCNIC_RCODE_TIMEOUT;

	if (qlcnic_api_lock(adapter)) {

		cmd->rsp.cmd = QLCNIC_RCODE_TIMEOUT;

		return;

	}



	QLCWR32(adapter, QLCNIC_SIGN_CRB_OFFSET, signature);

	QLCWR32(adapter, QLCNIC_ARG1_CRB_OFFSET, arg1);

	QLCWR32(adapter, QLCNIC_ARG2_CRB_OFFSET, arg2);

	QLCWR32(adapter, QLCNIC_ARG3_CRB_OFFSET, arg3);

	QLCWR32(adapter, QLCNIC_CDRP_CRB_OFFSET, QLCNIC_CDRP_FORM_CMD(cmd));

	QLCWR32(adapter, QLCNIC_ARG1_CRB_OFFSET, cmd->req.arg1);

	QLCWR32(adapter, QLCNIC_ARG2_CRB_OFFSET, cmd->req.arg2);

	QLCWR32(adapter, QLCNIC_ARG3_CRB_OFFSET, cmd->req.arg3);

	QLCWR32(adapter, QLCNIC_CDRP_CRB_OFFSET,

		QLCNIC_CDRP_FORM_CMD(cmd->req.cmd));



	rsp = qlcnic_poll_rsp(adapter);



	if (rsp == QLCNIC_CDRP_RSP_TIMEOUT) {

		dev_err(&pdev->dev, "card response timeout.\n");

		rcode = QLCNIC_RCODE_TIMEOUT;

		cmd->rsp.cmd = QLCNIC_RCODE_TIMEOUT;

	} else if (rsp == QLCNIC_CDRP_RSP_FAIL) {

		rcode = QLCRD32(adapter, QLCNIC_ARG1_CRB_OFFSET);

		cmd->rsp.cmd = QLCRD32(adapter, QLCNIC_ARG1_CRB_OFFSET);

		dev_err(&pdev->dev, "failed card response code:0x%x\n",

				rcode);

				cmd->rsp.cmd);

	} else if (rsp == QLCNIC_CDRP_RSP_OK) {

		if (rd_args[1])

			*rd_args[1] = QLCRD32(adapter, QLCNIC_ARG2_CRB_OFFSET);

		if (rd_args[2])

			*rd_args[2] = QLCRD32(adapter, QLCNIC_ARG3_CRB_OFFSET);

		cmd->rsp.cmd = QLCNIC_RCODE_SUCCESS;

		if (cmd->rsp.arg2)

			cmd->rsp.arg2 = QLCRD32(adapter,

				QLCNIC_ARG2_CRB_OFFSET);

		if (cmd->rsp.arg3)

			cmd->rsp.arg3 = QLCRD32(adapter,

				QLCNIC_ARG3_CRB_OFFSET);

	}

	if (rd_args[0])

		*rd_args[0] = QLCRD32(adapter, QLCNIC_ARG1_CRB_OFFSET);

	if (cmd->rsp.arg1)

		cmd->rsp.arg1 = QLCRD32(adapter, QLCNIC_ARG1_CRB_OFFSET);



	/* Release semaphore */

	qlcnic_api_unlock(adapter);



	return rcode;

}



static uint32_t qlcnic_temp_checksum(uint32_t *temp_buffer, u16 temp_size)
@@ -88,30 +92,25 @@ int qlcnic_fw_cmd_get_minidump_temp(struct qlcnic_adapter *adapter) 
	int err, i;

	u16 temp_size;

	void *tmp_addr;

	u32 version, csum, *template, *tmp_buf, rsp;

	u32 *rd_args[3];

	u32 version, csum, *template, *tmp_buf;

	struct qlcnic_cmd_args cmd;

	struct qlcnic_hardware_context *ahw;

	struct qlcnic_dump_template_hdr *tmpl_hdr, *tmp_tmpl;

	dma_addr_t tmp_addr_t = 0;



	ahw = adapter->ahw;

	rd_args[0] = &rsp;

	rd_args[1] = (u32 *) &temp_size;

	rd_args[2] = &version;

	err = qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			0,

			0,

			0,

			QLCNIC_CDRP_CMD_TEMP_SIZE,

			rd_args);

	if (err != QLCNIC_RCODE_SUCCESS) {

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

	cmd.req.cmd = QLCNIC_CDRP_CMD_TEMP_SIZE;

	memset(&cmd.rsp, 1, sizeof(struct _cdrp_cmd));

	qlcnic_issue_cmd(adapter, &cmd);

	if (cmd.rsp.cmd != QLCNIC_RCODE_SUCCESS) {

		dev_info(&adapter->pdev->dev,

			"Can't get template size %d\n", rsp);

			"Can't get template size %d\n", cmd.rsp.cmd);

		err = -EIO;

		return err;

	}

	temp_size = cmd.rsp.arg2;

	version = cmd.rsp.arg3;

	if (!temp_size)

		return -EIO;
@@ -122,16 +121,14 @@ int qlcnic_fw_cmd_get_minidump_temp(struct qlcnic_adapter *adapter) 
			"Can't get memory for FW dump template\n");

		return -ENOMEM;

	}

	memset(rd_args, 0, sizeof(rd_args));

	err = qlcnic_issue_cmd(adapter,

		adapter->ahw->pci_func,

		adapter->fw_hal_version,

		LSD(tmp_addr_t),

		MSD(tmp_addr_t),

		temp_size,

		QLCNIC_CDRP_CMD_GET_TEMP_HDR,

		rd_args);

	memset(&cmd.rsp, 0, sizeof(struct _cdrp_cmd));

	cmd.req.cmd = QLCNIC_CDRP_CMD_GET_TEMP_HDR;

	cmd.req.arg1 = LSD(tmp_addr_t);

	cmd.req.arg2 = MSD(tmp_addr_t);

	cmd.req.arg3 = temp_size;

	qlcnic_issue_cmd(adapter, &cmd);



	err = cmd.rsp.cmd;

	if (err != QLCNIC_RCODE_SUCCESS) {

		dev_err(&adapter->pdev->dev,

			"Failed to get mini dump template header %d\n", err);
@@ -167,20 +164,17 @@ error: 
int

qlcnic_fw_cmd_set_mtu(struct qlcnic_adapter *adapter, int mtu)

{

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;

	struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;



	memset(rd_args, 0, sizeof(rd_args));

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

	cmd.req.cmd = QLCNIC_CDRP_CMD_SET_MTU;

	cmd.req.arg1 = recv_ctx->context_id;

	cmd.req.arg2 = mtu;

	cmd.req.arg3 = 0;

	if (recv_ctx->state == QLCNIC_HOST_CTX_STATE_ACTIVE) {

		if (qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			recv_ctx->context_id,

			mtu,

			0,

			QLCNIC_CDRP_CMD_SET_MTU,

			rd_args)) {



		qlcnic_issue_cmd(adapter, &cmd);

		if (cmd.rsp.cmd) {

			dev_err(&adapter->pdev->dev, "Failed to set mtu\n");

			return -EIO;

		}
@@ -201,6 +195,7 @@ qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter *adapter) 
	struct qlcnic_cardrsp_sds_ring *prsp_sds;

	struct qlcnic_host_rds_ring *rds_ring;

	struct qlcnic_host_sds_ring *sds_ring;

	struct qlcnic_cmd_args cmd;



	dma_addr_t hostrq_phys_addr, cardrsp_phys_addr;

	u64 phys_addr;
@@ -208,7 +203,6 @@ qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter *adapter) 
	u8 i, nrds_rings, nsds_rings;

	size_t rq_size, rsp_size;

	u32 cap, reg, val, reg2;

	u32 *rd_args[3];

	int err;



	struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;
@@ -290,15 +284,13 @@ qlcnic_fw_cmd_create_rx_ctx(struct qlcnic_adapter *adapter) 
	}



	phys_addr = hostrq_phys_addr;

	memset(rd_args, 0, sizeof(rd_args));

	err = qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			(u32)(phys_addr >> 32),

			(u32)(phys_addr & 0xffffffff),

			rq_size,

			QLCNIC_CDRP_CMD_CREATE_RX_CTX,

			rd_args);

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

	cmd.req.arg1 = (u32) (phys_addr >> 32);

	cmd.req.arg2 = (u32) (phys_addr & 0xffffffff);

	cmd.req.arg3 = rq_size;

	cmd.req.cmd = QLCNIC_CDRP_CMD_CREATE_RX_CTX;

	qlcnic_issue_cmd(adapter, &cmd);

	err = cmd.rsp.cmd;

	if (err) {

		dev_err(&adapter->pdev->dev,

			"Failed to create rx ctx in firmware%d\n", err);
@@ -344,22 +336,18 @@ out_free_rq: 
static void

qlcnic_fw_cmd_destroy_rx_ctx(struct qlcnic_adapter *adapter)

{

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;

	struct qlcnic_recv_context *recv_ctx = adapter->recv_ctx;



	memset(rd_args, 0, sizeof(rd_args));

	if (qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			recv_ctx->context_id,

			QLCNIC_DESTROY_CTX_RESET,

			0,

			QLCNIC_CDRP_CMD_DESTROY_RX_CTX,

			rd_args)) {



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

	cmd.req.arg1 = recv_ctx->context_id;

	cmd.req.arg2 = QLCNIC_DESTROY_CTX_RESET;

	cmd.req.arg3 = 0;

	cmd.req.cmd = QLCNIC_CDRP_CMD_DESTROY_RX_CTX;

	qlcnic_issue_cmd(adapter, &cmd);

	if (cmd.rsp.cmd)

		dev_err(&adapter->pdev->dev,

			"Failed to destroy rx ctx in firmware\n");

	}



	recv_ctx->state = QLCNIC_HOST_CTX_STATE_FREED;

}
@@ -373,7 +361,7 @@ qlcnic_fw_cmd_create_tx_ctx(struct qlcnic_adapter *adapter) 
	void	*rq_addr, *rsp_addr;

	size_t	rq_size, rsp_size;

	u32	temp;

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;

	int	err;

	u64	phys_addr;

	dma_addr_t	rq_phys_addr, rsp_phys_addr;
@@ -423,15 +411,13 @@ qlcnic_fw_cmd_create_tx_ctx(struct qlcnic_adapter *adapter) 
	prq_cds->ring_size = cpu_to_le32(tx_ring->num_desc);



	phys_addr = rq_phys_addr;

	memset(rd_args, 0, sizeof(rd_args));

	err = qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			(u32)(phys_addr >> 32),

			((u32)phys_addr & 0xffffffff),

			rq_size,

			QLCNIC_CDRP_CMD_CREATE_TX_CTX,

			rd_args);

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

	cmd.req.arg1 = (u32)(phys_addr >> 32);

	cmd.req.arg2 = ((u32)phys_addr & 0xffffffff);

	cmd.req.arg3 = rq_size;

	cmd.req.cmd = QLCNIC_CDRP_CMD_CREATE_TX_CTX;

	qlcnic_issue_cmd(adapter, &cmd);

	err = cmd.rsp.cmd;



	if (err == QLCNIC_RCODE_SUCCESS) {

		temp = le32_to_cpu(prsp->cds_ring.host_producer_crb);
@@ -457,37 +443,30 @@ out_free_rq: 
static void

qlcnic_fw_cmd_destroy_tx_ctx(struct qlcnic_adapter *adapter)

{

	u32 *rd_args[3];



	memset(rd_args, 0, sizeof(rd_args));

	if (qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			adapter->tx_context_id,

			QLCNIC_DESTROY_CTX_RESET,

			0,

			QLCNIC_CDRP_CMD_DESTROY_TX_CTX,

			rd_args)) {



	struct qlcnic_cmd_args cmd;



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

	cmd.req.arg1 = adapter->tx_context_id;

	cmd.req.arg2 = QLCNIC_DESTROY_CTX_RESET;

	cmd.req.arg3 = 0;

	cmd.req.cmd = QLCNIC_CDRP_CMD_DESTROY_TX_CTX;

	qlcnic_issue_cmd(adapter, &cmd);

	if (cmd.rsp.cmd)

		dev_err(&adapter->pdev->dev,

			"Failed to destroy tx ctx in firmware\n");

}

}



int

qlcnic_fw_cmd_set_port(struct qlcnic_adapter *adapter, u32 config)

{

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;



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

	cmd.req.arg1 = config;

	cmd.req.cmd = QLCNIC_CDRP_CMD_CONFIG_PORT;

	qlcnic_issue_cmd(adapter, &cmd);



	memset(rd_args, 0, sizeof(rd_args));

	return qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			config,

			0,

			0,

			QLCNIC_CDRP_CMD_CONFIG_PORT,

			rd_args);

	return cmd.rsp.cmd;

}



int qlcnic_alloc_hw_resources(struct qlcnic_adapter *adapter)
@@ -652,24 +631,17 @@ void qlcnic_free_hw_resources(struct qlcnic_adapter *adapter) 
int qlcnic_get_mac_address(struct qlcnic_adapter *adapter, u8 *mac)

{

	int err;

	u32 arg1, rd_arg1, rd_arg2;

	u32 *rd_args[3];



	arg1 = adapter->ahw->pci_func | BIT_8;

	rd_args[0] = &rd_arg1;

	rd_args[1] = &rd_arg2;

	rd_args[2] = 0;

	err = qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			arg1,

			0,

			0,

			QLCNIC_CDRP_CMD_MAC_ADDRESS,

			rd_args);

	struct qlcnic_cmd_args cmd;



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

	cmd.req.arg1 = adapter->ahw->pci_func | BIT_8;

	cmd.req.cmd = QLCNIC_CDRP_CMD_MAC_ADDRESS;

	cmd.rsp.arg1 = cmd.rsp.arg2 = 1;

	qlcnic_issue_cmd(adapter, &cmd);

	err = cmd.rsp.cmd;



	if (err == QLCNIC_RCODE_SUCCESS)

		qlcnic_fetch_mac(adapter, rd_arg1, rd_arg2, 0, mac);

		qlcnic_fetch_mac(adapter, cmd.rsp.arg1, cmd.rsp.arg2, 0, mac);

	else {

		dev_err(&adapter->pdev->dev,

			"Failed to get mac address%d\n", err);
@@ -687,7 +659,7 @@ int qlcnic_get_nic_info(struct qlcnic_adapter *adapter, 
	dma_addr_t nic_dma_t;

	struct qlcnic_info *nic_info;

	void *nic_info_addr;

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;

	size_t	nic_size = sizeof(struct qlcnic_info);



	nic_info_addr = dma_alloc_coherent(&adapter->pdev->dev, nic_size,
@@ -697,15 +669,13 @@ int qlcnic_get_nic_info(struct qlcnic_adapter *adapter, 
	memset(nic_info_addr, 0, nic_size);



	nic_info = nic_info_addr;

	memset(rd_args, 0, sizeof(rd_args));

	err = qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			MSD(nic_dma_t),

			LSD(nic_dma_t),

			(func_id << 16 | nic_size),

			QLCNIC_CDRP_CMD_GET_NIC_INFO,

			rd_args);

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

	cmd.req.cmd = QLCNIC_CDRP_CMD_GET_NIC_INFO;

	cmd.req.arg1 = MSD(nic_dma_t);

	cmd.req.arg2 = LSD(nic_dma_t);

	cmd.req.arg3 = (func_id << 16 | nic_size);

	qlcnic_issue_cmd(adapter, &cmd);

	err = cmd.rsp.cmd;



	if (err == QLCNIC_RCODE_SUCCESS) {

		npar_info->pci_func = le16_to_cpu(nic_info->pci_func);
@@ -744,7 +714,7 @@ int qlcnic_set_nic_info(struct qlcnic_adapter *adapter, struct qlcnic_info *nic) 
	int err = -EIO;

	dma_addr_t nic_dma_t;

	void *nic_info_addr;

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;

	struct qlcnic_info *nic_info;

	size_t nic_size = sizeof(struct qlcnic_info);
@@ -770,15 +740,13 @@ int qlcnic_set_nic_info(struct qlcnic_adapter *adapter, struct qlcnic_info *nic) 
	nic_info->min_tx_bw = cpu_to_le16(nic->min_tx_bw);

	nic_info->max_tx_bw = cpu_to_le16(nic->max_tx_bw);



	memset(rd_args, 0, sizeof(rd_args));

	err = qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			MSD(nic_dma_t),

			LSD(nic_dma_t),

			((nic->pci_func << 16) | nic_size),

			QLCNIC_CDRP_CMD_SET_NIC_INFO,

			rd_args);

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

	cmd.req.cmd = QLCNIC_CDRP_CMD_SET_NIC_INFO;

	cmd.req.arg1 = MSD(nic_dma_t);

	cmd.req.arg2 = LSD(nic_dma_t);

	cmd.req.arg3 = ((nic->pci_func << 16) | nic_size);

	qlcnic_issue_cmd(adapter, &cmd);

	err = cmd.rsp.cmd;



	if (err != QLCNIC_RCODE_SUCCESS) {

		dev_err(&adapter->pdev->dev,
@@ -796,7 +764,7 @@ int qlcnic_get_pci_info(struct qlcnic_adapter *adapter, 
				struct qlcnic_pci_info *pci_info)

{

	int err = 0, i;

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;

	dma_addr_t pci_info_dma_t;

	struct qlcnic_pci_info *npar;

	void *pci_info_addr;
@@ -810,15 +778,13 @@ int qlcnic_get_pci_info(struct qlcnic_adapter *adapter, 
	memset(pci_info_addr, 0, pci_size);



	npar = pci_info_addr;

	memset(rd_args, 0, sizeof(rd_args));

	err = qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			MSD(pci_info_dma_t),

			LSD(pci_info_dma_t),

			pci_size,

			QLCNIC_CDRP_CMD_GET_PCI_INFO,

			rd_args);

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

	cmd.req.cmd = QLCNIC_CDRP_CMD_GET_PCI_INFO;

	cmd.req.arg1 = MSD(pci_info_dma_t);

	cmd.req.arg2 = LSD(pci_info_dma_t);

	cmd.req.arg3 = pci_size;

	qlcnic_issue_cmd(adapter, &cmd);

	err = cmd.rsp.cmd;



	if (err == QLCNIC_RCODE_SUCCESS) {

		for (i = 0; i < QLCNIC_MAX_PCI_FUNC; i++, npar++, pci_info++) {
@@ -850,7 +816,7 @@ int qlcnic_config_port_mirroring(struct qlcnic_adapter *adapter, u8 id, 
{

	int err = -EIO;

	u32 arg1;

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;



	if (adapter->op_mode != QLCNIC_MGMT_FUNC ||

		!(adapter->eswitch[id].flags & QLCNIC_SWITCH_ENABLE))
@@ -859,15 +825,11 @@ int qlcnic_config_port_mirroring(struct qlcnic_adapter *adapter, u8 id, 
	arg1 = id | (enable_mirroring ? BIT_4 : 0);

	arg1 |= pci_func << 8;



	memset(rd_args, 0, sizeof(rd_args));

	err = qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			arg1,

			0,

			0,

			QLCNIC_CDRP_CMD_SET_PORTMIRRORING,

			rd_args);

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

	cmd.req.cmd = QLCNIC_CDRP_CMD_SET_PORTMIRRORING;

	cmd.req.arg1 = arg1;

	qlcnic_issue_cmd(adapter, &cmd);

	err = cmd.rsp.cmd;



	if (err != QLCNIC_RCODE_SUCCESS) {

		dev_err(&adapter->pdev->dev,
@@ -890,7 +852,7 @@ int qlcnic_get_port_stats(struct qlcnic_adapter *adapter, const u8 func, 
	dma_addr_t stats_dma_t;

	void *stats_addr;

	u32 arg1;

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;

	int err;



	if (esw_stats == NULL)
@@ -914,15 +876,13 @@ int qlcnic_get_port_stats(struct qlcnic_adapter *adapter, const u8 func, 
	arg1 = func | QLCNIC_STATS_VERSION << 8 | QLCNIC_STATS_PORT << 12;

	arg1 |= rx_tx << 15 | stats_size << 16;



	memset(rd_args, 0, sizeof(rd_args));

	err = qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			arg1,

			MSD(stats_dma_t),

			LSD(stats_dma_t),

			QLCNIC_CDRP_CMD_GET_ESWITCH_STATS,

			rd_args);

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

	cmd.req.cmd = QLCNIC_CDRP_CMD_GET_ESWITCH_STATS;

	cmd.req.arg1 = arg1;

	cmd.req.arg2 = MSD(stats_dma_t);

	cmd.req.arg3 = LSD(stats_dma_t);

	qlcnic_issue_cmd(adapter, &cmd);

	err = cmd.rsp.cmd;



	if (!err) {

		stats = stats_addr;
@@ -1003,7 +963,7 @@ int qlcnic_clear_esw_stats(struct qlcnic_adapter *adapter, const u8 func_esw, 
{



	u32 arg1;

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;



	if (adapter->op_mode != QLCNIC_MGMT_FUNC)

		return -EIO;
@@ -1024,15 +984,11 @@ int qlcnic_clear_esw_stats(struct qlcnic_adapter *adapter, const u8 func_esw, 
	arg1 = port | QLCNIC_STATS_VERSION << 8 | func_esw << 12;

	arg1 |= BIT_14 | rx_tx << 15;



	memset(rd_args, 0, sizeof(rd_args));

	return qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			arg1,

			0,

			0,

			QLCNIC_CDRP_CMD_GET_ESWITCH_STATS,

			rd_args);

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

	cmd.req.cmd = QLCNIC_CDRP_CMD_GET_ESWITCH_STATS;

	cmd.req.arg1 = arg1;

	qlcnic_issue_cmd(adapter, &cmd);

	return cmd.rsp.cmd;



err_ret:

	dev_err(&adapter->pdev->dev, "Invalid argument func_esw=%d port=%d"
@@ -1045,20 +1001,17 @@ __qlcnic_get_eswitch_port_config(struct qlcnic_adapter *adapter, 
					u32 *arg1, u32 *arg2)

{

	int err = -EIO;

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;

	u8 pci_func;

	pci_func = (*arg1 >> 8);

	rd_args[0] = arg1;

	rd_args[1] = arg2;

	rd_args[2] = 0;

	err = qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			*arg1,

			0,

			0,

			QLCNIC_CDRP_CMD_GET_ESWITCH_PORT_CONFIG,

			rd_args);



	cmd.req.cmd = QLCNIC_CDRP_CMD_GET_ESWITCH_PORT_CONFIG;

	cmd.req.arg1 = *arg1;

	cmd.rsp.arg1 = cmd.rsp.arg2 = 1;

	qlcnic_issue_cmd(adapter, &cmd);

	*arg1 = cmd.rsp.arg1;

	*arg2 = cmd.rsp.arg2;

	err = cmd.rsp.cmd;



	if (err == QLCNIC_RCODE_SUCCESS) {

		dev_info(&adapter->pdev->dev,
@@ -1082,7 +1035,7 @@ int qlcnic_config_switch_port(struct qlcnic_adapter *adapter, 
{

	int err = -EIO;

	u32 arg1, arg2 = 0;

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;

	u8 pci_func;



	if (adapter->op_mode != QLCNIC_MGMT_FUNC)
@@ -1129,16 +1082,13 @@ int qlcnic_config_switch_port(struct qlcnic_adapter *adapter, 
		return err;

	}



	memset(rd_args, 0, sizeof(rd_args));

	err = qlcnic_issue_cmd(adapter,

			adapter->ahw->pci_func,

			adapter->fw_hal_version,

			arg1,

			arg2,

			0,

			QLCNIC_CDRP_CMD_CONFIGURE_ESWITCH,

			rd_args);

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

	cmd.req.cmd = QLCNIC_CDRP_CMD_CONFIGURE_ESWITCH;

	cmd.req.arg1 = arg1;

	cmd.req.arg2 = arg2;

	qlcnic_issue_cmd(adapter, &cmd);



	err = cmd.rsp.cmd;

	if (err != QLCNIC_RCODE_SUCCESS) {

		dev_err(&adapter->pdev->dev,

			"Failed to configure eswitch pci func %d\n", pci_func);

drivers/net/ethernet/qlogic/qlcnic/qlcnic_ethtool.c

+7 −5
Original line number Diff line number Diff line
@@ -659,7 +659,7 @@ static int qlcnic_irq_test(struct net_device *netdev) 
	struct qlcnic_adapter *adapter = netdev_priv(netdev);

	int max_sds_rings = adapter->max_sds_rings;

	int ret;

	u32 *rd_args[3];

	struct qlcnic_cmd_args cmd;



	if (test_and_set_bit(__QLCNIC_RESETTING, &adapter->state))

		return -EIO;
@@ -669,10 +669,12 @@ static int qlcnic_irq_test(struct net_device *netdev) 
		goto clear_it;



	adapter->diag_cnt = 0;

	memset(rd_args, 0, sizeof(rd_args));

	ret = qlcnic_issue_cmd(adapter, adapter->ahw->pci_func,

			adapter->fw_hal_version, adapter->ahw->pci_func,

			0, 0, 0x00000011, rd_args);

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

	cmd.req.cmd = QLCNIC_CDRP_CMD_INTRPT_TEST;

	cmd.req.arg1 = adapter->ahw->pci_func;

	qlcnic_issue_cmd(adapter, &cmd);

	ret = cmd.rsp.cmd;



	if (ret)

		goto done;