Commit 64fecd3e authored by Felix Manlunas's avatar Felix Manlunas Committed by David S. Miller
Browse files

liquidio: remove obsolete functions and data structures 



1. Remove unused functions and data structures.
2. Change the sending of the remaining soft commands to synchronous.

Signed-off-by: default avatarWeilin Chang <weilin.chang@cavium.com>
Signed-off-by: default avatarFelix Manlunas <felix.manlunas@cavium.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent edd572d7

drivers/net/ethernet/cavium/liquidio/lio_core.c

+11 −72
Original line number Diff line number Diff line
@@ -31,38 +31,6 @@ 


#define OCTNIC_MAX_SG  MAX_SKB_FRAGS



/**

 * \brief Callback for getting interface configuration

 * @param status status of request

 * @param buf pointer to resp structure

 */

void lio_if_cfg_callback(struct octeon_device *oct,

			 u32 status __attribute__((unused)), void *buf)

{

	struct octeon_soft_command *sc = (struct octeon_soft_command *)buf;

	struct liquidio_if_cfg_context *ctx;

	struct liquidio_if_cfg_resp *resp;



	resp = (struct liquidio_if_cfg_resp *)sc->virtrptr;

	ctx = (struct liquidio_if_cfg_context *)sc->ctxptr;



	oct = lio_get_device(ctx->octeon_id);

	if (resp->status)

		dev_err(&oct->pci_dev->dev, "nic if cfg instruction failed. Status: %llx\n",

			CVM_CAST64(resp->status));

	WRITE_ONCE(ctx->cond, 1);



	snprintf(oct->fw_info.liquidio_firmware_version, 32, "%s",

		 resp->cfg_info.liquidio_firmware_version);



	/* This barrier is required to be sure that the response has been

	 * written fully before waking up the handler

	 */

	wmb();



	wake_up_interruptible(&ctx->wc);

}



/**

 * \brief Delete gather lists

 * @param lio per-network private data
@@ -1211,30 +1179,6 @@ int octeon_setup_interrupt(struct octeon_device *oct, u32 num_ioqs) 
	return 0;

}



static void liquidio_change_mtu_completion(struct octeon_device *oct,

					   u32 status, void *buf)

{

	struct octeon_soft_command *sc = (struct octeon_soft_command *)buf;

	struct liquidio_if_cfg_context *ctx;



	ctx  = (struct liquidio_if_cfg_context *)sc->ctxptr;



	if (status) {

		dev_err(&oct->pci_dev->dev, "MTU change failed. Status: %llx\n",

			CVM_CAST64(status));

		WRITE_ONCE(ctx->cond, LIO_CHANGE_MTU_FAIL);

	} else {

		WRITE_ONCE(ctx->cond, LIO_CHANGE_MTU_SUCCESS);

	}



	/* This barrier is required to be sure that the response has been

	 * written fully before waking up the handler

	 */

	wmb();



	wake_up_interruptible(&ctx->wc);

}



/**

 * \brief Net device change_mtu

 * @param netdev network device
@@ -1243,22 +1187,17 @@ int liquidio_change_mtu(struct net_device *netdev, int new_mtu) 
{

	struct lio *lio = GET_LIO(netdev);

	struct octeon_device *oct = lio->oct_dev;

	struct liquidio_if_cfg_context *ctx;

	struct octeon_soft_command *sc;

	union octnet_cmd *ncmd;

	int ctx_size;

	int ret = 0;



	ctx_size = sizeof(struct liquidio_if_cfg_context);

	sc = (struct octeon_soft_command *)

		octeon_alloc_soft_command(oct, OCTNET_CMD_SIZE, 16, ctx_size);

		octeon_alloc_soft_command(oct, OCTNET_CMD_SIZE, 16, 0);



	ncmd = (union octnet_cmd *)sc->virtdptr;

	ctx  = (struct liquidio_if_cfg_context *)sc->ctxptr;



	WRITE_ONCE(ctx->cond, 0);

	ctx->octeon_id = lio_get_device_id(oct);

	init_waitqueue_head(&ctx->wc);

	init_completion(&sc->complete);

	sc->sc_status = OCTEON_REQUEST_PENDING;



	ncmd->u64 = 0;

	ncmd->s.cmd = OCTNET_CMD_CHANGE_MTU;
@@ -1271,28 +1210,28 @@ int liquidio_change_mtu(struct net_device *netdev, int new_mtu) 
	octeon_prepare_soft_command(oct, sc, OPCODE_NIC,

				    OPCODE_NIC_CMD, 0, 0, 0);



	sc->callback = liquidio_change_mtu_completion;

	sc->callback_arg = sc;

	sc->wait_time = 100;



	ret = octeon_send_soft_command(oct, sc);

	if (ret == IQ_SEND_FAILED) {

		netif_info(lio, rx_err, lio->netdev, "Failed to change MTU\n");

		octeon_free_soft_command(oct, sc);

		return -EINVAL;

	}

	/* Sleep on a wait queue till the cond flag indicates that the

	 * response arrived or timed-out.

	 */

	if (sleep_cond(&ctx->wc, &ctx->cond) == -EINTR ||

	    ctx->cond == LIO_CHANGE_MTU_FAIL) {

		octeon_free_soft_command(oct, sc);

	ret = wait_for_sc_completion_timeout(oct, sc, 0);

	if (ret)

		return ret;



	if (sc->sc_status) {

		WRITE_ONCE(sc->caller_is_done, true);

		return -EINVAL;

	}



	netdev->mtu = new_mtu;

	lio->mtu = new_mtu;



	octeon_free_soft_command(oct, sc);

	WRITE_ONCE(sc->caller_is_done, true);

	return 0;

}

drivers/net/ethernet/cavium/liquidio/lio_ethtool.c

+67 −168
Original line number Diff line number Diff line
@@ -33,25 +33,12 @@ 


static int lio_reset_queues(struct net_device *netdev, uint32_t num_qs);



struct oct_intrmod_context {

	int octeon_id;

	wait_queue_head_t wc;

	int cond;

	int status;

};



struct oct_intrmod_resp {

	u64     rh;

	struct oct_intrmod_cfg intrmod;

	u64     status;

};



struct oct_mdio_cmd_context {

	int octeon_id;

	wait_queue_head_t wc;

	int cond;

};



struct oct_mdio_cmd_resp {

	u64 rh;

	struct oct_mdio_cmd resp;
@@ -746,28 +733,6 @@ static int octnet_id_active(struct net_device *netdev, int val) 
	return 0;

}



/* Callback for when mdio command response arrives

 */

static void octnet_mdio_resp_callback(struct octeon_device *oct,

				      u32 status,

				      void *buf)

{

	struct oct_mdio_cmd_context *mdio_cmd_ctx;

	struct octeon_soft_command *sc = (struct octeon_soft_command *)buf;



	mdio_cmd_ctx = (struct oct_mdio_cmd_context *)sc->ctxptr;



	oct = lio_get_device(mdio_cmd_ctx->octeon_id);

	if (status) {

		dev_err(&oct->pci_dev->dev, "MIDO instruction failed. Status: %llx\n",

			CVM_CAST64(status));

		WRITE_ONCE(mdio_cmd_ctx->cond, -1);

	} else {

		WRITE_ONCE(mdio_cmd_ctx->cond, 1);

	}

	wake_up_interruptible(&mdio_cmd_ctx->wc);

}



/* This routine provides PHY access routines for

 * mdio  clause45 .

 */
@@ -777,25 +742,20 @@ octnet_mdio45_access(struct lio *lio, int op, int loc, int *value) 
	struct octeon_device *oct_dev = lio->oct_dev;

	struct octeon_soft_command *sc;

	struct oct_mdio_cmd_resp *mdio_cmd_rsp;

	struct oct_mdio_cmd_context *mdio_cmd_ctx;

	struct oct_mdio_cmd *mdio_cmd;

	int retval = 0;



	sc = (struct octeon_soft_command *)

		octeon_alloc_soft_command(oct_dev,

					  sizeof(struct oct_mdio_cmd),

					  sizeof(struct oct_mdio_cmd_resp),

					  sizeof(struct oct_mdio_cmd_context));

					  sizeof(struct oct_mdio_cmd_resp), 0);



	if (!sc)

		return -ENOMEM;



	mdio_cmd_ctx = (struct oct_mdio_cmd_context *)sc->ctxptr;

	mdio_cmd_rsp = (struct oct_mdio_cmd_resp *)sc->virtrptr;

	mdio_cmd = (struct oct_mdio_cmd *)sc->virtdptr;



	WRITE_ONCE(mdio_cmd_ctx->cond, 0);

	mdio_cmd_ctx->octeon_id = lio_get_device_id(oct_dev);

	mdio_cmd->op = op;

	mdio_cmd->mdio_addr = loc;

	if (op)
@@ -807,42 +767,40 @@ octnet_mdio45_access(struct lio *lio, int op, int loc, int *value) 
	octeon_prepare_soft_command(oct_dev, sc, OPCODE_NIC, OPCODE_NIC_MDIO45,

				    0, 0, 0);



	sc->wait_time = 1000;

	sc->callback = octnet_mdio_resp_callback;

	sc->callback_arg = sc;



	init_waitqueue_head(&mdio_cmd_ctx->wc);

	init_completion(&sc->complete);

	sc->sc_status = OCTEON_REQUEST_PENDING;



	retval = octeon_send_soft_command(oct_dev, sc);



	if (retval == IQ_SEND_FAILED) {

		dev_err(&oct_dev->pci_dev->dev,

			"octnet_mdio45_access instruction failed status: %x\n",

			retval);

		retval = -EBUSY;

		octeon_free_soft_command(oct_dev, sc);

		return -EBUSY;

	} else {

		/* Sleep on a wait queue till the cond flag indicates that the

		 * response arrived

		 */

		sleep_cond(&mdio_cmd_ctx->wc, &mdio_cmd_ctx->cond);

		retval = wait_for_sc_completion_timeout(oct_dev, sc, 0);

		if (retval)

			return retval;



		retval = mdio_cmd_rsp->status;

		if (retval) {

			dev_err(&oct_dev->pci_dev->dev, "octnet mdio45 access failed\n");

			retval = -EBUSY;

		} else {

			dev_err(&oct_dev->pci_dev->dev,

				"octnet mdio45 access failed: %x\n", retval);

			WRITE_ONCE(sc->caller_is_done, true);

			return -EBUSY;

		}



		octeon_swap_8B_data((u64 *)(&mdio_cmd_rsp->resp),

				    sizeof(struct oct_mdio_cmd) / 8);



			if (READ_ONCE(mdio_cmd_ctx->cond) == 1) {

		if (!op)

			*value = mdio_cmd_rsp->resp.value1;

			} else {

				retval = -EINVAL;

			}

		}

	}



	octeon_free_soft_command(oct_dev, sc);

		WRITE_ONCE(sc->caller_is_done, true);

	}



	return retval;

}
@@ -1006,8 +964,7 @@ lio_ethtool_get_ringparam(struct net_device *netdev, 
static int lio_23xx_reconfigure_queue_count(struct lio *lio)

{

	struct octeon_device *oct = lio->oct_dev;

	struct liquidio_if_cfg_context *ctx;

	u32 resp_size, ctx_size, data_size;

	u32 resp_size, data_size;

	struct liquidio_if_cfg_resp *resp;

	struct octeon_soft_command *sc;

	union oct_nic_if_cfg if_cfg;
@@ -1017,11 +974,10 @@ static int lio_23xx_reconfigure_queue_count(struct lio *lio) 
	int j;



	resp_size = sizeof(struct liquidio_if_cfg_resp);

	ctx_size = sizeof(struct liquidio_if_cfg_context);

	data_size = sizeof(struct lio_version);

	sc = (struct octeon_soft_command *)

		octeon_alloc_soft_command(oct, data_size,

					  resp_size, ctx_size);

					  resp_size, 0);

	if (!sc) {

		dev_err(&oct->pci_dev->dev, "%s: Failed to allocate soft command\n",

			__func__);
@@ -1029,7 +985,6 @@ static int lio_23xx_reconfigure_queue_count(struct lio *lio) 
	}



	resp = (struct liquidio_if_cfg_resp *)sc->virtrptr;

	ctx  = (struct liquidio_if_cfg_context *)sc->ctxptr;

	vdata = (struct lio_version *)sc->virtdptr;



	vdata->major = (__force u16)cpu_to_be16(LIQUIDIO_BASE_MAJOR_VERSION);
@@ -1037,9 +992,6 @@ static int lio_23xx_reconfigure_queue_count(struct lio *lio) 
	vdata->micro = (__force u16)cpu_to_be16(LIQUIDIO_BASE_MICRO_VERSION);



	ifidx_or_pfnum = oct->pf_num;

	WRITE_ONCE(ctx->cond, 0);

	ctx->octeon_id = lio_get_device_id(oct);

	init_waitqueue_head(&ctx->wc);



	if_cfg.u64 = 0;

	if_cfg.s.num_iqueues = oct->sriov_info.num_pf_rings;
@@ -1051,27 +1003,29 @@ static int lio_23xx_reconfigure_queue_count(struct lio *lio) 
	octeon_prepare_soft_command(oct, sc, OPCODE_NIC,

				    OPCODE_NIC_QCOUNT_UPDATE, 0,

				    if_cfg.u64, 0);

	sc->callback = lio_if_cfg_callback;

	sc->callback_arg = sc;

	sc->wait_time = LIO_IFCFG_WAIT_TIME;



	init_completion(&sc->complete);

	sc->sc_status = OCTEON_REQUEST_PENDING;



	retval = octeon_send_soft_command(oct, sc);

	if (retval == IQ_SEND_FAILED) {

		dev_err(&oct->pci_dev->dev,

			"iq/oq config failed status: %x\n",

			"Sending iq/oq config failed status: %x\n",

			retval);

		goto qcount_update_fail;

		octeon_free_soft_command(oct, sc);

		return -EIO;

	}



	if (sleep_cond(&ctx->wc, &ctx->cond) == -EINTR) {

		dev_err(&oct->pci_dev->dev, "Wait interrupted\n");

		return -1;

	}

	retval = wait_for_sc_completion_timeout(oct, sc, 0);

	if (retval)

		return retval;



	retval = resp->status;

	if (retval) {

		dev_err(&oct->pci_dev->dev, "iq/oq config failed\n");

		goto qcount_update_fail;

		dev_err(&oct->pci_dev->dev,

			"iq/oq config failed: %x\n", retval);

		WRITE_ONCE(sc->caller_is_done, true);

		return -1;

	}



	octeon_swap_8B_data((u64 *)(&resp->cfg_info),
@@ -1096,16 +1050,12 @@ static int lio_23xx_reconfigure_queue_count(struct lio *lio) 
	lio->txq = lio->linfo.txpciq[0].s.q_no;

	lio->rxq = lio->linfo.rxpciq[0].s.q_no;



	octeon_free_soft_command(oct, sc);

	dev_info(&oct->pci_dev->dev, "Queue count updated to %d\n",

		 lio->linfo.num_rxpciq);



	return 0;



qcount_update_fail:

	octeon_free_soft_command(oct, sc);

	WRITE_ONCE(sc->caller_is_done, true);



	return -1;

	return 0;

}



static int lio_reset_queues(struct net_device *netdev, uint32_t num_qs)
@@ -2012,34 +1962,11 @@ static int lio_vf_get_sset_count(struct net_device *netdev, int sset) 
	}

}



/* Callback function for intrmod */

static void octnet_intrmod_callback(struct octeon_device *oct_dev,

				    u32 status,

				    void *ptr)

{

	struct octeon_soft_command *sc = (struct octeon_soft_command *)ptr;

	struct oct_intrmod_context *ctx;



	ctx  = (struct oct_intrmod_context *)sc->ctxptr;



	ctx->status = status;



	WRITE_ONCE(ctx->cond, 1);



	/* This barrier is required to be sure that the response has been

	 * written fully before waking up the handler

	 */

	wmb();



	wake_up_interruptible(&ctx->wc);

}



/*  get interrupt moderation parameters */

static int octnet_get_intrmod_cfg(struct lio *lio,

				  struct oct_intrmod_cfg *intr_cfg)

{

	struct octeon_soft_command *sc;

	struct oct_intrmod_context *ctx;

	struct oct_intrmod_resp *resp;

	int retval;

	struct octeon_device *oct_dev = lio->oct_dev;
@@ -2048,8 +1975,7 @@ static int octnet_get_intrmod_cfg(struct lio *lio, 
	sc = (struct octeon_soft_command *)

		octeon_alloc_soft_command(oct_dev,

					  0,

					  sizeof(struct oct_intrmod_resp),

					  sizeof(struct oct_intrmod_context));

					  sizeof(struct oct_intrmod_resp), 0);



	if (!sc)

		return -ENOMEM;
@@ -2057,20 +1983,13 @@ static int octnet_get_intrmod_cfg(struct lio *lio, 
	resp = (struct oct_intrmod_resp *)sc->virtrptr;

	memset(resp, 0, sizeof(struct oct_intrmod_resp));



	ctx = (struct oct_intrmod_context *)sc->ctxptr;

	memset(ctx, 0, sizeof(struct oct_intrmod_context));

	WRITE_ONCE(ctx->cond, 0);

	ctx->octeon_id = lio_get_device_id(oct_dev);

	init_waitqueue_head(&ctx->wc);



	sc->iq_no = lio->linfo.txpciq[0].s.q_no;



	octeon_prepare_soft_command(oct_dev, sc, OPCODE_NIC,

				    OPCODE_NIC_INTRMOD_PARAMS, 0, 0, 0);



	sc->callback = octnet_intrmod_callback;

	sc->callback_arg = sc;

	sc->wait_time = 1000;

	init_completion(&sc->complete);

	sc->sc_status = OCTEON_REQUEST_PENDING;



	retval = octeon_send_soft_command(oct_dev, sc);

	if (retval == IQ_SEND_FAILED) {
@@ -2081,32 +2000,23 @@ static int octnet_get_intrmod_cfg(struct lio *lio, 
	/* Sleep on a wait queue till the cond flag indicates that the

	 * response arrived or timed-out.

	 */

	if (sleep_cond(&ctx->wc, &ctx->cond) == -EINTR) {

		dev_err(&oct_dev->pci_dev->dev, "Wait interrupted\n");

		goto intrmod_info_wait_intr;

	}

	retval = wait_for_sc_completion_timeout(oct_dev, sc, 0);

	if (retval)

		return -ENODEV;



	retval = ctx->status || resp->status;

	if (retval) {

	if (resp->status) {

		dev_err(&oct_dev->pci_dev->dev,

			"Get interrupt moderation parameters failed\n");

		goto intrmod_info_wait_fail;

		WRITE_ONCE(sc->caller_is_done, true);

		return -ENODEV;

	}



	octeon_swap_8B_data((u64 *)&resp->intrmod,

			    (sizeof(struct oct_intrmod_cfg)) / 8);

	memcpy(intr_cfg, &resp->intrmod, sizeof(struct oct_intrmod_cfg));

	octeon_free_soft_command(oct_dev, sc);

	WRITE_ONCE(sc->caller_is_done, true);



	return 0;



intrmod_info_wait_fail:



	octeon_free_soft_command(oct_dev, sc);



intrmod_info_wait_intr:



	return -ENODEV;

}



/*  Configure interrupt moderation parameters */
@@ -2114,7 +2024,6 @@ static int octnet_set_intrmod_cfg(struct lio *lio, 
				  struct oct_intrmod_cfg *intr_cfg)

{

	struct octeon_soft_command *sc;

	struct oct_intrmod_context *ctx;

	struct oct_intrmod_cfg *cfg;

	int retval;

	struct octeon_device *oct_dev = lio->oct_dev;
@@ -2123,18 +2032,11 @@ static int octnet_set_intrmod_cfg(struct lio *lio, 
	sc = (struct octeon_soft_command *)

		octeon_alloc_soft_command(oct_dev,

					  sizeof(struct oct_intrmod_cfg),

					  0,

					  sizeof(struct oct_intrmod_context));

					  16, 0);



	if (!sc)

		return -ENOMEM;



	ctx = (struct oct_intrmod_context *)sc->ctxptr;



	WRITE_ONCE(ctx->cond, 0);

	ctx->octeon_id = lio_get_device_id(oct_dev);

	init_waitqueue_head(&ctx->wc);



	cfg = (struct oct_intrmod_cfg *)sc->virtdptr;



	memcpy(cfg, intr_cfg, sizeof(struct oct_intrmod_cfg));
@@ -2145,9 +2047,8 @@ static int octnet_set_intrmod_cfg(struct lio *lio, 
	octeon_prepare_soft_command(oct_dev, sc, OPCODE_NIC,

				    OPCODE_NIC_INTRMOD_CFG, 0, 0, 0);



	sc->callback = octnet_intrmod_callback;

	sc->callback_arg = sc;

	sc->wait_time = 1000;

	init_completion(&sc->complete);

	sc->sc_status = OCTEON_REQUEST_PENDING;



	retval = octeon_send_soft_command(oct_dev, sc);

	if (retval == IQ_SEND_FAILED) {
@@ -2158,26 +2059,24 @@ static int octnet_set_intrmod_cfg(struct lio *lio, 
	/* Sleep on a wait queue till the cond flag indicates that the

	 * response arrived or timed-out.

	 */

	if (sleep_cond(&ctx->wc, &ctx->cond) != -EINTR) {

		retval = ctx->status;

	retval = wait_for_sc_completion_timeout(oct_dev, sc, 0);

	if (retval)

			dev_err(&oct_dev->pci_dev->dev,

				"intrmod config failed. Status: %llx\n",

				CVM_CAST64(retval));

		else

		return retval;



	retval = sc->sc_status;

	if (retval == 0) {

		dev_info(&oct_dev->pci_dev->dev,

			 "Rx-Adaptive Interrupt moderation %s\n",

			 (intr_cfg->rx_enable) ?

			 "enabled" : "disabled");



		octeon_free_soft_command(oct_dev, sc);



		return ((retval) ? -ENODEV : 0);

		WRITE_ONCE(sc->caller_is_done, true);

		return 0;

	}



	dev_err(&oct_dev->pci_dev->dev, "iq/oq config failed\n");



	return -EINTR;

	dev_err(&oct_dev->pci_dev->dev,

		"intrmod config failed. Status: %x\n", retval);

	WRITE_ONCE(sc->caller_is_done, true);

	return -ENODEV;

}



static int lio_get_intr_coalesce(struct net_device *netdev,

drivers/net/ethernet/cavium/liquidio/lio_main.c

+53 −112

File changed.

Preview size limit exceeded, changes collapsed.

drivers/net/ethernet/cavium/liquidio/lio_vf_main.c

+40 −82
Original line number Diff line number Diff line
@@ -40,14 +40,6 @@ MODULE_PARM_DESC(debug, "NETIF_MSG debug bits"); 


#define DEFAULT_MSG_ENABLE (NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK)



struct liquidio_rx_ctl_context {

	int octeon_id;



	wait_queue_head_t wc;



	int cond;

};



struct oct_timestamp_resp {

	u64 rh;

	u64 timestamp;
@@ -597,33 +589,6 @@ static void octeon_destroy_resources(struct octeon_device *oct) 
	}

}



/**

 * \brief Callback for rx ctrl

 * @param status status of request

 * @param buf pointer to resp structure

 */

static void rx_ctl_callback(struct octeon_device *oct,

			    u32 status, void *buf)

{

	struct octeon_soft_command *sc = (struct octeon_soft_command *)buf;

	struct liquidio_rx_ctl_context *ctx;



	ctx  = (struct liquidio_rx_ctl_context *)sc->ctxptr;



	oct = lio_get_device(ctx->octeon_id);

	if (status)

		dev_err(&oct->pci_dev->dev, "rx ctl instruction failed. Status: %llx\n",

			CVM_CAST64(status));

	WRITE_ONCE(ctx->cond, 1);



	/* This barrier is required to be sure that the response has been

	 * written fully before waking up the handler

	 */

	wmb();



	wake_up_interruptible(&ctx->wc);

}



/**

 * \brief Send Rx control command

 * @param lio per-network private data
@@ -632,8 +597,6 @@ static void rx_ctl_callback(struct octeon_device *oct, 
static void send_rx_ctrl_cmd(struct lio *lio, int start_stop)

{

	struct octeon_device *oct = (struct octeon_device *)lio->oct_dev;

	int ctx_size = sizeof(struct liquidio_rx_ctl_context);

	struct liquidio_rx_ctl_context *ctx;

	struct octeon_soft_command *sc;

	union octnet_cmd *ncmd;

	int retval;
@@ -643,14 +606,9 @@ static void send_rx_ctrl_cmd(struct lio *lio, int start_stop) 


	sc = (struct octeon_soft_command *)

		octeon_alloc_soft_command(oct, OCTNET_CMD_SIZE,

					  16, ctx_size);

					  16, 0);



	ncmd = (union octnet_cmd *)sc->virtdptr;

	ctx  = (struct liquidio_rx_ctl_context *)sc->ctxptr;



	WRITE_ONCE(ctx->cond, 0);

	ctx->octeon_id = lio_get_device_id(oct);

	init_waitqueue_head(&ctx->wc);



	ncmd->u64 = 0;

	ncmd->s.cmd = OCTNET_CMD_RX_CTL;
@@ -663,23 +621,24 @@ static void send_rx_ctrl_cmd(struct lio *lio, int start_stop) 
	octeon_prepare_soft_command(oct, sc, OPCODE_NIC,

				    OPCODE_NIC_CMD, 0, 0, 0);



	sc->callback = rx_ctl_callback;

	sc->callback_arg = sc;

	sc->wait_time = 5000;

	init_completion(&sc->complete);

	sc->sc_status = OCTEON_REQUEST_PENDING;



	retval = octeon_send_soft_command(oct, sc);

	if (retval == IQ_SEND_FAILED) {

		netif_info(lio, rx_err, lio->netdev, "Failed to send RX Control message\n");

		octeon_free_soft_command(oct, sc);

	} else {

		/* Sleep on a wait queue till the cond flag indicates that the

		 * response arrived or timed-out.

		 */

		if (sleep_cond(&ctx->wc, &ctx->cond) == -EINTR)

		retval = wait_for_sc_completion_timeout(oct, sc, 0);

		if (retval)

			return;



		oct->props[lio->ifidx].rx_on = start_stop;

		WRITE_ONCE(sc->caller_is_done, true);

	}



	octeon_free_soft_command(oct, sc);

}



/**
@@ -1938,8 +1897,7 @@ static int lio_nic_info(struct octeon_recv_info *recv_info, void *buf) 
static int setup_nic_devices(struct octeon_device *octeon_dev)

{

	int retval, num_iqueues, num_oqueues;

	struct liquidio_if_cfg_context *ctx;

	u32 resp_size, ctx_size, data_size;

	u32 resp_size, data_size;

	struct liquidio_if_cfg_resp *resp;

	struct octeon_soft_command *sc;

	union oct_nic_if_cfg if_cfg;
@@ -1970,13 +1928,11 @@ static int setup_nic_devices(struct octeon_device *octeon_dev) 


	for (i = 0; i < octeon_dev->ifcount; i++) {

		resp_size = sizeof(struct liquidio_if_cfg_resp);

		ctx_size = sizeof(struct liquidio_if_cfg_context);

		data_size = sizeof(struct lio_version);

		sc = (struct octeon_soft_command *)

			octeon_alloc_soft_command(octeon_dev, data_size,

						  resp_size, ctx_size);

						  resp_size, 0);

		resp = (struct liquidio_if_cfg_resp *)sc->virtrptr;

		ctx  = (struct liquidio_if_cfg_context *)sc->ctxptr;

		vdata = (struct lio_version *)sc->virtdptr;



		*((u64 *)vdata) = 0;
@@ -1984,10 +1940,6 @@ static int setup_nic_devices(struct octeon_device *octeon_dev) 
		vdata->minor = cpu_to_be16(LIQUIDIO_BASE_MINOR_VERSION);

		vdata->micro = cpu_to_be16(LIQUIDIO_BASE_MICRO_VERSION);



		WRITE_ONCE(ctx->cond, 0);

		ctx->octeon_id = lio_get_device_id(octeon_dev);

		init_waitqueue_head(&ctx->wc);



		if_cfg.u64 = 0;



		if_cfg.s.num_iqueues = octeon_dev->sriov_info.rings_per_vf;
@@ -2000,32 +1952,37 @@ static int setup_nic_devices(struct octeon_device *octeon_dev) 
					    OPCODE_NIC_IF_CFG, 0, if_cfg.u64,

					    0);



		sc->callback = lio_if_cfg_callback;

		sc->callback_arg = sc;

		sc->wait_time = 5000;

		init_completion(&sc->complete);

		sc->sc_status = OCTEON_REQUEST_PENDING;



		retval = octeon_send_soft_command(octeon_dev, sc);

		if (retval == IQ_SEND_FAILED) {

			dev_err(&octeon_dev->pci_dev->dev,

				"iq/oq config failed status: %x\n", retval);

			/* Soft instr is freed by driver in case of failure. */

			goto setup_nic_dev_fail;

			octeon_free_soft_command(octeon_dev, sc);

			return(-EIO);

		}



		/* Sleep on a wait queue till the cond flag indicates that the

		 * response arrived or timed-out.

		 */

		if (sleep_cond(&ctx->wc, &ctx->cond) == -EINTR) {

			dev_err(&octeon_dev->pci_dev->dev, "Wait interrupted\n");

			goto setup_nic_wait_intr;

		}

		retval = wait_for_sc_completion_timeout(octeon_dev, sc, 0);

		if (retval)

			return retval;



		retval = resp->status;

		if (retval) {

			dev_err(&octeon_dev->pci_dev->dev, "iq/oq config failed\n");

			goto setup_nic_dev_fail;

			dev_err(&octeon_dev->pci_dev->dev,

				"iq/oq config failed, retval = %d\n", retval);

			WRITE_ONCE(sc->caller_is_done, true);

			return -EIO;

		}



		snprintf(octeon_dev->fw_info.liquidio_firmware_version,

			 32, "%s",

			 resp->cfg_info.liquidio_firmware_version);



		octeon_swap_8B_data((u64 *)(&resp->cfg_info),

				    (sizeof(struct liquidio_if_cfg_info)) >> 3);
@@ -2036,7 +1993,8 @@ static int setup_nic_devices(struct octeon_device *octeon_dev) 
			dev_err(&octeon_dev->pci_dev->dev,

				"Got bad iqueues (%016llx) or oqueues (%016llx) from firmware.\n",

				resp->cfg_info.iqmask, resp->cfg_info.oqmask);

			goto setup_nic_dev_fail;

			WRITE_ONCE(sc->caller_is_done, true);

			goto setup_nic_dev_done;

		}

		dev_dbg(&octeon_dev->pci_dev->dev,

			"interface %d, iqmask %016llx, oqmask %016llx, numiqueues %d, numoqueues %d\n",
@@ -2047,7 +2005,8 @@ static int setup_nic_devices(struct octeon_device *octeon_dev) 


		if (!netdev) {

			dev_err(&octeon_dev->pci_dev->dev, "Device allocation failed\n");

			goto setup_nic_dev_fail;

			WRITE_ONCE(sc->caller_is_done, true);

			goto setup_nic_dev_done;

		}



		SET_NETDEV_DEV(netdev, &octeon_dev->pci_dev->dev);
@@ -2123,6 +2082,8 @@ static int setup_nic_devices(struct octeon_device *octeon_dev) 
		netdev->min_mtu = LIO_MIN_MTU_SIZE;

		netdev->max_mtu = LIO_MAX_MTU_SIZE;



		WRITE_ONCE(sc->caller_is_done, true);



		/* Point to the  properties for octeon device to which this

		 * interface belongs.

		 */
@@ -2146,7 +2107,7 @@ static int setup_nic_devices(struct octeon_device *octeon_dev) 
					     lio->linfo.num_txpciq,

					     lio->linfo.num_rxpciq)) {

			dev_err(&octeon_dev->pci_dev->dev, "I/O queues creation failed\n");

			goto setup_nic_dev_fail;

			goto setup_nic_dev_free;

		}



		ifstate_set(lio, LIO_IFSTATE_DROQ_OPS);
@@ -2169,7 +2130,7 @@ static int setup_nic_devices(struct octeon_device *octeon_dev) 
		if (lio_setup_glists(octeon_dev, lio, num_iqueues)) {

			dev_err(&octeon_dev->pci_dev->dev,

				"Gather list allocation failed\n");

			goto setup_nic_dev_fail;

			goto setup_nic_dev_free;

		}



		/* Register ethtool support */
@@ -2184,15 +2145,15 @@ static int setup_nic_devices(struct octeon_device *octeon_dev) 
					     OCTNIC_LROIPV4 | OCTNIC_LROIPV6);



		if (setup_link_status_change_wq(netdev))

			goto setup_nic_dev_fail;

			goto setup_nic_dev_free;



		if (setup_rx_oom_poll_fn(netdev))

			goto setup_nic_dev_fail;

			goto setup_nic_dev_free;



		/* Register the network device with the OS */

		if (register_netdev(netdev)) {

			dev_err(&octeon_dev->pci_dev->dev, "Device registration failed\n");

			goto setup_nic_dev_fail;

			goto setup_nic_dev_free;

		}



		dev_dbg(&octeon_dev->pci_dev->dev,
@@ -2215,24 +2176,21 @@ static int setup_nic_devices(struct octeon_device *octeon_dev) 
		dev_dbg(&octeon_dev->pci_dev->dev,

			"NIC ifidx:%d Setup successful\n", i);



		octeon_free_soft_command(octeon_dev, sc);



		octeon_dev->no_speed_setting = 1;

	}



	return 0;



setup_nic_dev_fail:



	octeon_free_soft_command(octeon_dev, sc);



setup_nic_wait_intr:

setup_nic_dev_free:



	while (i--) {

		dev_err(&octeon_dev->pci_dev->dev,

			"NIC ifidx:%d Setup failed\n", i);

		liquidio_destroy_nic_device(octeon_dev, i);

	}



setup_nic_dev_done:



	return -ENODEV;

}

drivers/net/ethernet/cavium/liquidio/lio_vf_rep.c

+4 −1
Original line number Diff line number Diff line
@@ -386,7 +386,7 @@ lio_vf_rep_pkt_xmit(struct sk_buff *skb, struct net_device *ndev) 
	}



	sc = (struct octeon_soft_command *)

		octeon_alloc_soft_command(oct, 0, 0, 0);

		octeon_alloc_soft_command(oct, 0, 16, 0);

	if (!sc) {

		dev_err(&oct->pci_dev->dev, "VF rep: Soft command alloc failed\n");

		goto xmit_failed;
@@ -395,6 +395,7 @@ lio_vf_rep_pkt_xmit(struct sk_buff *skb, struct net_device *ndev) 
	/* Multiple buffers are not used for vf_rep packets. */

	if (skb_shinfo(skb)->nr_frags != 0) {

		dev_err(&oct->pci_dev->dev, "VF rep: nr_frags != 0. Dropping packet\n");

		octeon_free_soft_command(oct, sc);

		goto xmit_failed;

	}
@@ -402,6 +403,7 @@ lio_vf_rep_pkt_xmit(struct sk_buff *skb, struct net_device *ndev) 
				     skb->data, skb->len, DMA_TO_DEVICE);

	if (dma_mapping_error(&oct->pci_dev->dev, sc->dmadptr)) {

		dev_err(&oct->pci_dev->dev, "VF rep: DMA mapping failed\n");

		octeon_free_soft_command(oct, sc);

		goto xmit_failed;

	}
@@ -422,6 +424,7 @@ lio_vf_rep_pkt_xmit(struct sk_buff *skb, struct net_device *ndev) 
	if (status == IQ_SEND_FAILED) {

		dma_unmap_single(&oct->pci_dev->dev, sc->dmadptr,

				 sc->datasize, DMA_TO_DEVICE);

		octeon_free_soft_command(oct, sc);

		goto xmit_failed;

	}