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

Merge branch 'sfc-more-code-refactoring' 



Alex Maftei says:

====================
sfc: more code refactoring

Splitting more of the driver code into different files, which will
later be used in another driver for a new product.

This is a continuation to my previous patch series.
There will be another series and a stand-alone patch as well
after this.

This series in particular covers MCDI (management controller
driver interface) code.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 43ad352d b69f7a3e

drivers/net/ethernet/sfc/Makefile

+2 −2
Original line number Diff line number Diff line
@@ -3,8 +3,8 @@ sfc-y += efx.o efx_common.o efx_channels.o nic.o \ 
			   farch.o siena.o ef10.o \

			   tx.o tx_common.o rx.o rx_common.o \

			   selftest.o ethtool.o ptp.o tx_tso.o \

			   mcdi.o mcdi_port.o \

			   mcdi_mon.o

			   mcdi.o mcdi_port.o mcdi_port_common.o \

			   mcdi_functions.o mcdi_mon.o

sfc-$(CONFIG_SFC_MTD)	+= mtd.o

sfc-$(CONFIG_SFC_SRIOV)	+= sriov.o siena_sriov.o ef10_sriov.o

drivers/net/ethernet/sfc/ef10.c

+35 −320
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
#include "mcdi.h"

#include "mcdi_pcol.h"

#include "mcdi_port_common.h"

#include "mcdi_functions.h"

#include "nic.h"

#include "workarounds.h"

#include "selftest.h"
@@ -834,22 +835,6 @@ fail1: 
	return rc;

}



static int efx_ef10_free_vis(struct efx_nic *efx)

{

	MCDI_DECLARE_BUF_ERR(outbuf);

	size_t outlen;

	int rc = efx_mcdi_rpc_quiet(efx, MC_CMD_FREE_VIS, NULL, 0,

				    outbuf, sizeof(outbuf), &outlen);



	/* -EALREADY means nothing to free, so ignore */

	if (rc == -EALREADY)

		rc = 0;

	if (rc)

		efx_mcdi_display_error(efx, MC_CMD_FREE_VIS, 0, outbuf, outlen,

				       rc);

	return rc;

}



#ifdef EFX_USE_PIO



static void efx_ef10_free_piobufs(struct efx_nic *efx)
@@ -1092,7 +1077,7 @@ static void efx_ef10_remove(struct efx_nic *efx) 
	if (nic_data->wc_membase)

		iounmap(nic_data->wc_membase);



	rc = efx_ef10_free_vis(efx);

	rc = efx_mcdi_free_vis(efx);

	WARN_ON(rc != 0);



	if (!nic_data->must_restore_piobufs)
@@ -1263,28 +1248,10 @@ static int efx_ef10_probe_vf(struct efx_nic *efx __attribute__ ((unused))) 
static int efx_ef10_alloc_vis(struct efx_nic *efx,

			      unsigned int min_vis, unsigned int max_vis)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_ALLOC_VIS_IN_LEN);

	MCDI_DECLARE_BUF(outbuf, MC_CMD_ALLOC_VIS_OUT_LEN);

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	size_t outlen;

	int rc;



	MCDI_SET_DWORD(inbuf, ALLOC_VIS_IN_MIN_VI_COUNT, min_vis);

	MCDI_SET_DWORD(inbuf, ALLOC_VIS_IN_MAX_VI_COUNT, max_vis);

	rc = efx_mcdi_rpc(efx, MC_CMD_ALLOC_VIS, inbuf, sizeof(inbuf),

			  outbuf, sizeof(outbuf), &outlen);

	if (rc != 0)

		return rc;



	if (outlen < MC_CMD_ALLOC_VIS_OUT_LEN)

		return -EIO;



	netif_dbg(efx, drv, efx->net_dev, "base VI is A0x%03x\n",

		  MCDI_DWORD(outbuf, ALLOC_VIS_OUT_VI_BASE));



	nic_data->vi_base = MCDI_DWORD(outbuf, ALLOC_VIS_OUT_VI_BASE);

	nic_data->n_allocated_vis = MCDI_DWORD(outbuf, ALLOC_VIS_OUT_VI_COUNT);

	return 0;

	return efx_mcdi_alloc_vis(efx, min_vis, max_vis, &nic_data->vi_base,

				  &nic_data->n_allocated_vis);

}



/* Note that the failure path of this function does not free
@@ -1366,7 +1333,7 @@ static int efx_ef10_dimension_resources(struct efx_nic *efx) 
	}



	/* In case the last attached driver failed to free VIs, do it now */

	rc = efx_ef10_free_vis(efx);

	rc = efx_mcdi_free_vis(efx);

	if (rc != 0)

		return rc;
@@ -1387,7 +1354,7 @@ static int efx_ef10_dimension_resources(struct efx_nic *efx) 
		efx->max_tx_channels =

			nic_data->n_allocated_vis / EFX_TXQ_TYPES;



		efx_ef10_free_vis(efx);

		efx_mcdi_free_vis(efx);

		return -EAGAIN;

	}
@@ -2411,20 +2378,15 @@ static u32 efx_ef10_tso_versions(struct efx_nic *efx) 


static void efx_ef10_tx_init(struct efx_tx_queue *tx_queue)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_INIT_TXQ_IN_LEN(EFX_MAX_DMAQ_SIZE * 8 /

						       EFX_BUF_SIZE));

	bool csum_offload = tx_queue->queue & EFX_TXQ_TYPE_OFFLOAD;

	size_t entries = tx_queue->txd.buf.len / EFX_BUF_SIZE;

	struct efx_channel *channel = tx_queue->channel;

	struct efx_nic *efx = tx_queue->efx;

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	struct efx_ef10_nic_data *nic_data;

	bool tso_v2 = false;

	size_t inlen;

	dma_addr_t dma_addr;

	efx_qword_t *txd;

	int rc;

	int i;

	BUILD_BUG_ON(MC_CMD_INIT_TXQ_OUT_LEN != 0);



	nic_data = efx->nic_data;



	/* Only attempt to enable TX timestamping if we have the license for it,

	 * otherwise TXQ init will fail
@@ -2451,51 +2413,9 @@ static void efx_ef10_tx_init(struct efx_tx_queue *tx_queue) 
				channel->channel);

	}



	MCDI_SET_DWORD(inbuf, INIT_TXQ_IN_SIZE, tx_queue->ptr_mask + 1);

	MCDI_SET_DWORD(inbuf, INIT_TXQ_IN_TARGET_EVQ, channel->channel);

	MCDI_SET_DWORD(inbuf, INIT_TXQ_IN_LABEL, tx_queue->queue);

	MCDI_SET_DWORD(inbuf, INIT_TXQ_IN_INSTANCE, tx_queue->queue);

	MCDI_SET_DWORD(inbuf, INIT_TXQ_IN_OWNER_ID, 0);

	MCDI_SET_DWORD(inbuf, INIT_TXQ_IN_PORT_ID, nic_data->vport_id);



	dma_addr = tx_queue->txd.buf.dma_addr;



	netif_dbg(efx, hw, efx->net_dev, "pushing TXQ %d. %zu entries (%llx)\n",

		  tx_queue->queue, entries, (u64)dma_addr);



	for (i = 0; i < entries; ++i) {

		MCDI_SET_ARRAY_QWORD(inbuf, INIT_TXQ_IN_DMA_ADDR, i, dma_addr);

		dma_addr += EFX_BUF_SIZE;

	}



	inlen = MC_CMD_INIT_TXQ_IN_LEN(entries);



	do {

		MCDI_POPULATE_DWORD_4(inbuf, INIT_TXQ_IN_FLAGS,

				/* This flag was removed from mcdi_pcol.h for

				 * the non-_EXT version of INIT_TXQ.  However,

				 * firmware still honours it.

				 */

				INIT_TXQ_EXT_IN_FLAG_TSOV2_EN, tso_v2,

				INIT_TXQ_IN_FLAG_IP_CSUM_DIS, !csum_offload,

				INIT_TXQ_IN_FLAG_TCP_CSUM_DIS, !csum_offload,

				INIT_TXQ_EXT_IN_FLAG_TIMESTAMP,

						tx_queue->timestamping);



		rc = efx_mcdi_rpc_quiet(efx, MC_CMD_INIT_TXQ, inbuf, inlen,

					NULL, 0, NULL);

		if (rc == -ENOSPC && tso_v2) {

			/* Retry without TSOv2 if we're short on contexts. */

			tso_v2 = false;

			netif_warn(efx, probe, efx->net_dev,

				   "TSOv2 context not available to segment in hardware. TCP performance may be reduced.\n");

		} else if (rc) {

			efx_mcdi_display_error(efx, MC_CMD_INIT_TXQ,

					       MC_CMD_INIT_TXQ_EXT_IN_LEN,

					       NULL, 0, rc);

	rc = efx_mcdi_tx_init(tx_queue, tso_v2);

	if (rc)

		goto fail;

		}

	} while (rc);



	/* A previous user of this TX queue might have set us up the

	 * bomb by writing a descriptor to the TX push collector but
@@ -2533,35 +2453,6 @@ fail: 
		    tx_queue->queue);

}



static void efx_ef10_tx_fini(struct efx_tx_queue *tx_queue)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_FINI_TXQ_IN_LEN);

	MCDI_DECLARE_BUF_ERR(outbuf);

	struct efx_nic *efx = tx_queue->efx;

	size_t outlen;

	int rc;



	MCDI_SET_DWORD(inbuf, FINI_TXQ_IN_INSTANCE,

		       tx_queue->queue);



	rc = efx_mcdi_rpc_quiet(efx, MC_CMD_FINI_TXQ, inbuf, sizeof(inbuf),

			  outbuf, sizeof(outbuf), &outlen);



	if (rc && rc != -EALREADY)

		goto fail;



	return;



fail:

	efx_mcdi_display_error(efx, MC_CMD_FINI_TXQ, MC_CMD_FINI_TXQ_IN_LEN,

			       outbuf, outlen, rc);

}



static void efx_ef10_tx_remove(struct efx_tx_queue *tx_queue)

{

	efx_nic_free_buffer(tx_queue->efx, &tx_queue->txd.buf);

}



/* This writes to the TX_DESC_WPTR; write pointer for TX descriptor ring */

static inline void efx_ef10_notify_tx_desc(struct efx_tx_queue *tx_queue)

{
@@ -3076,91 +2967,6 @@ static int efx_ef10_vf_rx_push_rss_config(struct efx_nic *efx, bool user, 
	return efx_ef10_rx_push_shared_rss_config(efx, NULL);

}



static int efx_ef10_rx_probe(struct efx_rx_queue *rx_queue)

{

	return efx_nic_alloc_buffer(rx_queue->efx, &rx_queue->rxd.buf,

				    (rx_queue->ptr_mask + 1) *

				    sizeof(efx_qword_t),

				    GFP_KERNEL);

}



static void efx_ef10_rx_init(struct efx_rx_queue *rx_queue)

{

	MCDI_DECLARE_BUF(inbuf,

			 MC_CMD_INIT_RXQ_IN_LEN(EFX_MAX_DMAQ_SIZE * 8 /

						EFX_BUF_SIZE));

	struct efx_channel *channel = efx_rx_queue_channel(rx_queue);

	size_t entries = rx_queue->rxd.buf.len / EFX_BUF_SIZE;

	struct efx_nic *efx = rx_queue->efx;

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	size_t inlen;

	dma_addr_t dma_addr;

	int rc;

	int i;

	BUILD_BUG_ON(MC_CMD_INIT_RXQ_OUT_LEN != 0);



	rx_queue->scatter_n = 0;

	rx_queue->scatter_len = 0;



	MCDI_SET_DWORD(inbuf, INIT_RXQ_IN_SIZE, rx_queue->ptr_mask + 1);

	MCDI_SET_DWORD(inbuf, INIT_RXQ_IN_TARGET_EVQ, channel->channel);

	MCDI_SET_DWORD(inbuf, INIT_RXQ_IN_LABEL, efx_rx_queue_index(rx_queue));

	MCDI_SET_DWORD(inbuf, INIT_RXQ_IN_INSTANCE,

		       efx_rx_queue_index(rx_queue));

	MCDI_POPULATE_DWORD_2(inbuf, INIT_RXQ_IN_FLAGS,

			      INIT_RXQ_IN_FLAG_PREFIX, 1,

			      INIT_RXQ_IN_FLAG_TIMESTAMP, 1);

	MCDI_SET_DWORD(inbuf, INIT_RXQ_IN_OWNER_ID, 0);

	MCDI_SET_DWORD(inbuf, INIT_RXQ_IN_PORT_ID, nic_data->vport_id);



	dma_addr = rx_queue->rxd.buf.dma_addr;



	netif_dbg(efx, hw, efx->net_dev, "pushing RXQ %d. %zu entries (%llx)\n",

		  efx_rx_queue_index(rx_queue), entries, (u64)dma_addr);



	for (i = 0; i < entries; ++i) {

		MCDI_SET_ARRAY_QWORD(inbuf, INIT_RXQ_IN_DMA_ADDR, i, dma_addr);

		dma_addr += EFX_BUF_SIZE;

	}



	inlen = MC_CMD_INIT_RXQ_IN_LEN(entries);



	rc = efx_mcdi_rpc(efx, MC_CMD_INIT_RXQ, inbuf, inlen,

			  NULL, 0, NULL);

	if (rc)

		netdev_WARN(efx->net_dev, "failed to initialise RXQ %d\n",

			    efx_rx_queue_index(rx_queue));

}



static void efx_ef10_rx_fini(struct efx_rx_queue *rx_queue)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_FINI_RXQ_IN_LEN);

	MCDI_DECLARE_BUF_ERR(outbuf);

	struct efx_nic *efx = rx_queue->efx;

	size_t outlen;

	int rc;



	MCDI_SET_DWORD(inbuf, FINI_RXQ_IN_INSTANCE,

		       efx_rx_queue_index(rx_queue));



	rc = efx_mcdi_rpc_quiet(efx, MC_CMD_FINI_RXQ, inbuf, sizeof(inbuf),

			  outbuf, sizeof(outbuf), &outlen);



	if (rc && rc != -EALREADY)

		goto fail;



	return;



fail:

	efx_mcdi_display_error(efx, MC_CMD_FINI_RXQ, MC_CMD_FINI_RXQ_IN_LEN,

			       outbuf, outlen, rc);

}



static void efx_ef10_rx_remove(struct efx_rx_queue *rx_queue)

{

	efx_nic_free_buffer(rx_queue->efx, &rx_queue->rxd.buf);

}



/* This creates an entry in the RX descriptor queue */

static inline void

efx_ef10_build_rx_desc(struct efx_rx_queue *rx_queue, unsigned int index)
@@ -3232,106 +3038,20 @@ efx_ef10_rx_defer_refill_complete(struct efx_nic *efx, unsigned long cookie, 
	/* nothing to do */

}



static int efx_ef10_ev_probe(struct efx_channel *channel)

{

	return efx_nic_alloc_buffer(channel->efx, &channel->eventq.buf,

				    (channel->eventq_mask + 1) *

				    sizeof(efx_qword_t),

				    GFP_KERNEL);

}



static void efx_ef10_ev_fini(struct efx_channel *channel)

{

	MCDI_DECLARE_BUF(inbuf, MC_CMD_FINI_EVQ_IN_LEN);

	MCDI_DECLARE_BUF_ERR(outbuf);

	struct efx_nic *efx = channel->efx;

	size_t outlen;

	int rc;



	MCDI_SET_DWORD(inbuf, FINI_EVQ_IN_INSTANCE, channel->channel);



	rc = efx_mcdi_rpc_quiet(efx, MC_CMD_FINI_EVQ, inbuf, sizeof(inbuf),

			  outbuf, sizeof(outbuf), &outlen);



	if (rc && rc != -EALREADY)

		goto fail;



	return;



fail:

	efx_mcdi_display_error(efx, MC_CMD_FINI_EVQ, MC_CMD_FINI_EVQ_IN_LEN,

			       outbuf, outlen, rc);

}



static int efx_ef10_ev_init(struct efx_channel *channel)

{

	MCDI_DECLARE_BUF(inbuf,

			 MC_CMD_INIT_EVQ_V2_IN_LEN(EFX_MAX_EVQ_SIZE * 8 /

						   EFX_BUF_SIZE));

	MCDI_DECLARE_BUF(outbuf, MC_CMD_INIT_EVQ_V2_OUT_LEN);

	size_t entries = channel->eventq.buf.len / EFX_BUF_SIZE;

	struct efx_nic *efx = channel->efx;

	struct efx_ef10_nic_data *nic_data;

	size_t inlen, outlen;

	unsigned int enabled, implemented;

	dma_addr_t dma_addr;

	bool use_v2, cut_thru;

	int rc;

	int i;



	nic_data = efx->nic_data;



	/* Fill event queue with all ones (i.e. empty events) */

	memset(channel->eventq.buf.addr, 0xff, channel->eventq.buf.len);



	MCDI_SET_DWORD(inbuf, INIT_EVQ_IN_SIZE, channel->eventq_mask + 1);

	MCDI_SET_DWORD(inbuf, INIT_EVQ_IN_INSTANCE, channel->channel);

	/* INIT_EVQ expects index in vector table, not absolute */

	MCDI_SET_DWORD(inbuf, INIT_EVQ_IN_IRQ_NUM, channel->channel);

	MCDI_SET_DWORD(inbuf, INIT_EVQ_IN_TMR_MODE,

		       MC_CMD_INIT_EVQ_IN_TMR_MODE_DIS);

	MCDI_SET_DWORD(inbuf, INIT_EVQ_IN_TMR_LOAD, 0);

	MCDI_SET_DWORD(inbuf, INIT_EVQ_IN_TMR_RELOAD, 0);

	MCDI_SET_DWORD(inbuf, INIT_EVQ_IN_COUNT_MODE,

		       MC_CMD_INIT_EVQ_IN_COUNT_MODE_DIS);

	MCDI_SET_DWORD(inbuf, INIT_EVQ_IN_COUNT_THRSHLD, 0);



	if (nic_data->datapath_caps2 &

	    1 << MC_CMD_GET_CAPABILITIES_V2_OUT_INIT_EVQ_V2_LBN) {

		/* Use the new generic approach to specifying event queue

		 * configuration, requesting lower latency or higher throughput.

		 * The options that actually get used appear in the output.

		 */

		MCDI_POPULATE_DWORD_2(inbuf, INIT_EVQ_V2_IN_FLAGS,

				      INIT_EVQ_V2_IN_FLAG_INTERRUPTING, 1,

				      INIT_EVQ_V2_IN_FLAG_TYPE,

				      MC_CMD_INIT_EVQ_V2_IN_FLAG_TYPE_AUTO);

	} else {

		bool cut_thru = !(nic_data->datapath_caps &

	use_v2 = nic_data->datapath_caps2 &

			    1 << MC_CMD_GET_CAPABILITIES_V2_OUT_INIT_EVQ_V2_LBN;

	cut_thru = !(nic_data->datapath_caps &

			      1 << MC_CMD_GET_CAPABILITIES_OUT_RX_BATCHING_LBN);



		MCDI_POPULATE_DWORD_4(inbuf, INIT_EVQ_IN_FLAGS,

				      INIT_EVQ_IN_FLAG_INTERRUPTING, 1,

				      INIT_EVQ_IN_FLAG_RX_MERGE, 1,

				      INIT_EVQ_IN_FLAG_TX_MERGE, 1,

				      INIT_EVQ_IN_FLAG_CUT_THRU, cut_thru);

	}



	dma_addr = channel->eventq.buf.dma_addr;

	for (i = 0; i < entries; ++i) {

		MCDI_SET_ARRAY_QWORD(inbuf, INIT_EVQ_IN_DMA_ADDR, i, dma_addr);

		dma_addr += EFX_BUF_SIZE;

	}



	inlen = MC_CMD_INIT_EVQ_IN_LEN(entries);



	rc = efx_mcdi_rpc(efx, MC_CMD_INIT_EVQ, inbuf, inlen,

			  outbuf, sizeof(outbuf), &outlen);



	if (outlen >= MC_CMD_INIT_EVQ_V2_OUT_LEN)

		netif_dbg(efx, drv, efx->net_dev,

			  "Channel %d using event queue flags %08x\n",

			  channel->channel,

			  MCDI_DWORD(outbuf, INIT_EVQ_V2_OUT_FLAGS));

	rc = efx_mcdi_ev_init(channel, cut_thru, use_v2);



	/* IRQ return is ignored */

	if (channel->channel || rc)
@@ -3389,15 +3109,10 @@ static int efx_ef10_ev_init(struct efx_channel *channel) 
		return 0;



fail:

	efx_ef10_ev_fini(channel);

	efx_mcdi_ev_fini(channel);

	return rc;

}



static void efx_ef10_ev_remove(struct efx_channel *channel)

{

	efx_nic_free_buffer(channel->efx, &channel->eventq.buf);

}



static void efx_ef10_handle_rx_wrong_queue(struct efx_rx_queue *rx_queue,

					   unsigned int rx_queue_label)

{
@@ -3979,9 +3694,9 @@ static int efx_ef10_fini_dmaq(struct efx_nic *efx) 
	if (efx->state != STATE_RECOVERY) {

		efx_for_each_channel(channel, efx) {

			efx_for_each_channel_rx_queue(rx_queue, channel)

				efx_ef10_rx_fini(rx_queue);

				efx_mcdi_rx_fini(rx_queue);

			efx_for_each_channel_tx_queue(tx_queue, channel)

				efx_ef10_tx_fini(tx_queue);

				efx_mcdi_tx_fini(tx_queue);

		}



		wait_event_timeout(efx->flush_wq,
@@ -6653,20 +6368,20 @@ const struct efx_nic_type efx_hunt_a0_vf_nic_type = { 
	.irq_handle_legacy = efx_ef10_legacy_interrupt,

	.tx_probe = efx_ef10_tx_probe,

	.tx_init = efx_ef10_tx_init,

	.tx_remove = efx_ef10_tx_remove,

	.tx_remove = efx_mcdi_tx_remove,

	.tx_write = efx_ef10_tx_write,

	.tx_limit_len = efx_ef10_tx_limit_len,

	.rx_push_rss_config = efx_ef10_vf_rx_push_rss_config,

	.rx_pull_rss_config = efx_ef10_rx_pull_rss_config,

	.rx_probe = efx_ef10_rx_probe,

	.rx_init = efx_ef10_rx_init,

	.rx_remove = efx_ef10_rx_remove,

	.rx_probe = efx_mcdi_rx_probe,

	.rx_init = efx_mcdi_rx_init,

	.rx_remove = efx_mcdi_rx_remove,

	.rx_write = efx_ef10_rx_write,

	.rx_defer_refill = efx_ef10_rx_defer_refill,

	.ev_probe = efx_ef10_ev_probe,

	.ev_probe = efx_mcdi_ev_probe,

	.ev_init = efx_ef10_ev_init,

	.ev_fini = efx_ef10_ev_fini,

	.ev_remove = efx_ef10_ev_remove,

	.ev_fini = efx_mcdi_ev_fini,

	.ev_remove = efx_mcdi_ev_remove,

	.ev_process = efx_ef10_ev_process,

	.ev_read_ack = efx_ef10_ev_read_ack,

	.ev_test_generate = efx_ef10_ev_test_generate,
@@ -6762,7 +6477,7 @@ const struct efx_nic_type efx_hunt_a0_nic_type = { 
	.irq_handle_legacy = efx_ef10_legacy_interrupt,

	.tx_probe = efx_ef10_tx_probe,

	.tx_init = efx_ef10_tx_init,

	.tx_remove = efx_ef10_tx_remove,

	.tx_remove = efx_mcdi_tx_remove,

	.tx_write = efx_ef10_tx_write,

	.tx_limit_len = efx_ef10_tx_limit_len,

	.rx_push_rss_config = efx_ef10_pf_rx_push_rss_config,
@@ -6770,15 +6485,15 @@ const struct efx_nic_type efx_hunt_a0_nic_type = { 
	.rx_push_rss_context_config = efx_ef10_rx_push_rss_context_config,

	.rx_pull_rss_context_config = efx_ef10_rx_pull_rss_context_config,

	.rx_restore_rss_contexts = efx_ef10_rx_restore_rss_contexts,

	.rx_probe = efx_ef10_rx_probe,

	.rx_init = efx_ef10_rx_init,

	.rx_remove = efx_ef10_rx_remove,

	.rx_probe = efx_mcdi_rx_probe,

	.rx_init = efx_mcdi_rx_init,

	.rx_remove = efx_mcdi_rx_remove,

	.rx_write = efx_ef10_rx_write,

	.rx_defer_refill = efx_ef10_rx_defer_refill,

	.ev_probe = efx_ef10_ev_probe,

	.ev_probe = efx_mcdi_ev_probe,

	.ev_init = efx_ef10_ev_init,

	.ev_fini = efx_ef10_ev_fini,

	.ev_remove = efx_ef10_ev_remove,

	.ev_fini = efx_mcdi_ev_fini,

	.ev_remove = efx_mcdi_ev_remove,

	.ev_process = efx_ef10_ev_process,

	.ev_read_ack = efx_ef10_ev_read_ack,

	.ev_test_generate = efx_ef10_ev_test_generate,

drivers/net/ethernet/sfc/efx.c

+3 −52
Original line number Diff line number Diff line
@@ -134,21 +134,6 @@ static int efx_xdp_xmit(struct net_device *dev, int n, struct xdp_frame **xdpfs, 
 *

 **************************************************************************/



void efx_link_set_advertising(struct efx_nic *efx,

			      const unsigned long *advertising)

{

	memcpy(efx->link_advertising, advertising,

	       sizeof(__ETHTOOL_DECLARE_LINK_MODE_MASK()));



	efx->link_advertising[0] |= ADVERTISED_Autoneg;

	if (advertising[0] & ADVERTISED_Pause)

		efx->wanted_fc |= (EFX_FC_TX | EFX_FC_RX);

	else

		efx->wanted_fc &= ~(EFX_FC_TX | EFX_FC_RX);

	if (advertising[0] & ADVERTISED_Asym_Pause)

		efx->wanted_fc ^= EFX_FC_TX;

}



/* Equivalent to efx_link_set_advertising with all-zeroes, except does not

 * force the Autoneg bit on.

 */
@@ -1051,28 +1036,6 @@ show_phy_type(struct device *dev, struct device_attribute *attr, char *buf) 
}

static DEVICE_ATTR(phy_type, 0444, show_phy_type, NULL);



#ifdef CONFIG_SFC_MCDI_LOGGING

static ssize_t show_mcdi_log(struct device *dev, struct device_attribute *attr,

			     char *buf)

{

	struct efx_nic *efx = dev_get_drvdata(dev);

	struct efx_mcdi_iface *mcdi = efx_mcdi(efx);



	return scnprintf(buf, PAGE_SIZE, "%d\n", mcdi->logging_enabled);

}

static ssize_t set_mcdi_log(struct device *dev, struct device_attribute *attr,

			    const char *buf, size_t count)

{

	struct efx_nic *efx = dev_get_drvdata(dev);

	struct efx_mcdi_iface *mcdi = efx_mcdi(efx);

	bool enable = count > 0 && *buf != '0';



	mcdi->logging_enabled = enable;

	return count;

}

static DEVICE_ATTR(mcdi_logging, 0644, show_mcdi_log, set_mcdi_log);

#endif



static int efx_register_netdev(struct efx_nic *efx)

{

	struct net_device *net_dev = efx->net_dev;
@@ -1132,21 +1095,11 @@ static int efx_register_netdev(struct efx_nic *efx) 
			  "failed to init net dev attributes\n");

		goto fail_registered;

	}

#ifdef CONFIG_SFC_MCDI_LOGGING

	rc = device_create_file(&efx->pci_dev->dev, &dev_attr_mcdi_logging);

	if (rc) {

		netif_err(efx, drv, efx->net_dev,

			  "failed to init net dev attributes\n");

		goto fail_attr_mcdi_logging;

	}

#endif



	efx_init_mcdi_logging(efx);



	return 0;



#ifdef CONFIG_SFC_MCDI_LOGGING

fail_attr_mcdi_logging:

	device_remove_file(&efx->pci_dev->dev, &dev_attr_phy_type);

#endif

fail_registered:

	rtnl_lock();

	efx_dissociate(efx);
@@ -1167,9 +1120,7 @@ static void efx_unregister_netdev(struct efx_nic *efx) 


	if (efx_dev_registered(efx)) {

		strlcpy(efx->name, pci_name(efx->pci_dev), sizeof(efx->name));

#ifdef CONFIG_SFC_MCDI_LOGGING

		device_remove_file(&efx->pci_dev->dev, &dev_attr_mcdi_logging);

#endif

		efx_fini_mcdi_logging(efx);

		device_remove_file(&efx->pci_dev->dev, &dev_attr_phy_type);

		unregister_netdev(efx->net_dev);

	}

drivers/net/ethernet/sfc/efx_channels.c

+4 −2
Original line number Diff line number Diff line
@@ -1039,7 +1039,7 @@ void efx_stop_channels(struct efx_nic *efx) 
	struct efx_tx_queue *tx_queue;

	struct efx_rx_queue *rx_queue;

	struct efx_channel *channel;

	int rc;

	int rc = 0;



	/* Stop RX refill */

	efx_for_each_channel(channel, efx) {
@@ -1060,7 +1060,9 @@ void efx_stop_channels(struct efx_nic *efx) 
		}

	}



	if (efx->type->fini_dmaq)

		rc = efx->type->fini_dmaq(efx);



	if (rc) {

		netif_err(efx, drv, efx->net_dev, "failed to flush queues\n");

	} else {

drivers/net/ethernet/sfc/efx_common.c

+67 −19
Original line number Diff line number Diff line
@@ -141,10 +141,12 @@ void efx_destroy_reset_workqueue(void) 
 */

void efx_mac_reconfigure(struct efx_nic *efx)

{

	if (efx->type->reconfigure_mac) {

		down_read(&efx->filter_sem);

		efx->type->reconfigure_mac(efx);

		up_read(&efx->filter_sem);

	}

}



/* Asynchronous work item for changing MAC promiscuity and multicast

 * hash.  Avoid a drain/rx_ingress enable by reconfiguring the current
@@ -296,7 +298,8 @@ static void efx_start_datapath(struct efx_nic *efx) 
		netdev_features_change(efx->net_dev);



	/* RX filters may also have scatter-enabled flags */

	if (efx->rx_scatter != old_rx_scatter)

	if ((efx->rx_scatter != old_rx_scatter) &&

	    efx->type->filter_update_rx_scatter)

		efx->type->filter_update_rx_scatter(efx);



	/* We must keep at least one descriptor in a TX ring empty.
@@ -405,12 +408,14 @@ void efx_start_all(struct efx_nic *efx) 
		efx_link_status_changed(efx);

	mutex_unlock(&efx->mac_lock);



	if (efx->type->start_stats) {

		efx->type->start_stats(efx);

		efx->type->pull_stats(efx);

		spin_lock_bh(&efx->stats_lock);

		efx->type->update_stats(efx, NULL, NULL);

		spin_unlock_bh(&efx->stats_lock);

	}

}



/* Quiesce the hardware and software data path, and regular activity

 * for the port without bringing the link down.  Safe to call multiple
@@ -425,6 +430,7 @@ void efx_stop_all(struct efx_nic *efx) 
	if (!efx->port_enabled)

		return;



	if (efx->type->update_stats) {

		/* update stats before we go down so we can accurately count

		 * rx_nodesc_drops

		 */
@@ -433,6 +439,8 @@ void efx_stop_all(struct efx_nic *efx) 
		efx->type->update_stats(efx, NULL, NULL);

		spin_unlock_bh(&efx->stats_lock);

		efx->type->stop_stats(efx);

	}



	efx_stop_port(efx);



	/* Stop the kernel transmit interface.  This is only valid if
@@ -456,7 +464,7 @@ void efx_stop_all(struct efx_nic *efx) 
int __efx_reconfigure_port(struct efx_nic *efx)

{

	enum efx_phy_mode phy_mode;

	int rc;

	int rc = 0;



	WARN_ON(!mutex_is_locked(&efx->mac_lock));
@@ -467,6 +475,7 @@ int __efx_reconfigure_port(struct efx_nic *efx) 
	else

		efx->phy_mode &= ~PHY_MODE_TX_DISABLED;



	if (efx->type->reconfigure_port)

		rc = efx->type->reconfigure_port(efx);



	if (rc)
@@ -997,3 +1006,42 @@ void efx_fini_io(struct efx_nic *efx, int bar) 
	if (!pci_vfs_assigned(efx->pci_dev))

		pci_disable_device(efx->pci_dev);

}



#ifdef CONFIG_SFC_MCDI_LOGGING

static ssize_t show_mcdi_log(struct device *dev, struct device_attribute *attr,

			     char *buf)

{

	struct efx_nic *efx = dev_get_drvdata(dev);

	struct efx_mcdi_iface *mcdi = efx_mcdi(efx);



	return scnprintf(buf, PAGE_SIZE, "%d\n", mcdi->logging_enabled);

}



static ssize_t set_mcdi_log(struct device *dev, struct device_attribute *attr,

			    const char *buf, size_t count)

{

	struct efx_nic *efx = dev_get_drvdata(dev);

	struct efx_mcdi_iface *mcdi = efx_mcdi(efx);

	bool enable = count > 0 && *buf != '0';



	mcdi->logging_enabled = enable;

	return count;

}



static DEVICE_ATTR(mcdi_logging, 0644, show_mcdi_log, set_mcdi_log);



void efx_init_mcdi_logging(struct efx_nic *efx)

{

	int rc = device_create_file(&efx->pci_dev->dev, &dev_attr_mcdi_logging);



	if (rc) {

		netif_warn(efx, drv, efx->net_dev,

			   "failed to init net dev attributes\n");

	}

}



void efx_fini_mcdi_logging(struct efx_nic *efx)

{

	device_remove_file(&efx->pci_dev->dev, &dev_attr_mcdi_logging);

}

#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE