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

Merge branch 'sfc-even-more-code-refactoring' 



Alex Maftei says:

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

Splitting even 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, and the one
before it.
There will be a stand-alone patch as well after this - after which
the refactoring will be concluded, for now.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 9f120e76 f7226e0f

drivers/net/ethernet/sfc/Makefile

+2 −2
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0

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 \

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

			   selftest.o ethtool.o ethtool_common.o ptp.o \

			   mcdi.o mcdi_port.o mcdi_port_common.o \

			   mcdi_functions.o mcdi_mon.o

sfc-$(CONFIG_SFC_MTD)	+= mtd.o

drivers/net/ethernet/sfc/ef10.c

+18 −51
Original line number Diff line number Diff line
@@ -189,24 +189,6 @@ static bool efx_ef10_is_vf(struct efx_nic *efx) 
	return efx->type->is_vf;

}



static int efx_ef10_get_pf_index(struct efx_nic *efx)

{

	MCDI_DECLARE_BUF(outbuf, MC_CMD_GET_FUNCTION_INFO_OUT_LEN);

	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	size_t outlen;

	int rc;



	rc = efx_mcdi_rpc(efx, MC_CMD_GET_FUNCTION_INFO, NULL, 0, outbuf,

			  sizeof(outbuf), &outlen);

	if (rc)

		return rc;

	if (outlen < sizeof(outbuf))

		return -EIO;



	nic_data->pf_index = MCDI_DWORD(outbuf, GET_FUNCTION_INFO_OUT_PF);

	return 0;

}



#ifdef CONFIG_SFC_SRIOV

static int efx_ef10_get_vf_index(struct efx_nic *efx)

{
@@ -277,24 +259,9 @@ static int efx_ef10_init_datapath_caps(struct efx_nic *efx) 
		u8 vi_window_mode = MCDI_BYTE(outbuf,

				GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE);



		switch (vi_window_mode) {

		case MC_CMD_GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE_8K:

			efx->vi_stride = 8192;

			break;

		case MC_CMD_GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE_16K:

			efx->vi_stride = 16384;

			break;

		case MC_CMD_GET_CAPABILITIES_V3_OUT_VI_WINDOW_MODE_64K:

			efx->vi_stride = 65536;

			break;

		default:

			netif_err(efx, probe, efx->net_dev,

				  "Unrecognised VI window mode %d\n",

				  vi_window_mode);

			return -EIO;

		}

		netif_dbg(efx, probe, efx->net_dev, "vi_stride = %u\n",

			  efx->vi_stride);

		rc = efx_mcdi_window_mode_to_stride(efx, vi_window_mode);

		if (rc)

			return rc;

	} else {

		/* keep default VI stride */

		netif_dbg(efx, probe, efx->net_dev,
@@ -693,7 +660,7 @@ static int efx_ef10_probe(struct efx_nic *efx) 
	}

	nic_data->warm_boot_count = rc;



	efx->rss_context.context_id = EFX_EF10_RSS_CONTEXT_INVALID;

	efx->rss_context.context_id = EFX_MCDI_RSS_CONTEXT_INVALID;



	nic_data->vport_id = EVB_PORT_ID_ASSIGNED;
@@ -729,7 +696,7 @@ static int efx_ef10_probe(struct efx_nic *efx) 
	if (rc)

		goto fail4;



	rc = efx_ef10_get_pf_index(efx);

	rc = efx_get_pf_index(efx, &nic_data->pf_index);

	if (rc)

		goto fail5;
@@ -1473,7 +1440,7 @@ static void efx_ef10_reset_mc_allocations(struct efx_nic *efx) 
	nic_data->must_restore_filters = true;

	nic_data->must_restore_piobufs = true;

	efx_ef10_forget_old_piobufs(efx);

	efx->rss_context.context_id = EFX_EF10_RSS_CONTEXT_INVALID;

	efx->rss_context.context_id = EFX_MCDI_RSS_CONTEXT_INVALID;



	/* Driver-created vswitches and vports must be re-created */

	nic_data->must_probe_vswitching = true;
@@ -2631,7 +2598,7 @@ static int efx_ef10_alloc_rss_context(struct efx_nic *efx, bool exclusive, 
				    EFX_EF10_MAX_SHARED_RSS_CONTEXT_SIZE);



	if (!exclusive && rss_spread == 1) {

		ctx->context_id = EFX_EF10_RSS_CONTEXT_INVALID;

		ctx->context_id = EFX_MCDI_RSS_CONTEXT_INVALID;

		if (context_size)

			*context_size = 1;

		return 0;
@@ -2718,11 +2685,11 @@ static void efx_ef10_rx_free_indir_table(struct efx_nic *efx) 
{

	int rc;



	if (efx->rss_context.context_id != EFX_EF10_RSS_CONTEXT_INVALID) {

	if (efx->rss_context.context_id != EFX_MCDI_RSS_CONTEXT_INVALID) {

		rc = efx_ef10_free_rss_context(efx, efx->rss_context.context_id);

		WARN_ON(rc != 0);

	}

	efx->rss_context.context_id = EFX_EF10_RSS_CONTEXT_INVALID;

	efx->rss_context.context_id = EFX_MCDI_RSS_CONTEXT_INVALID;

}



static int efx_ef10_rx_push_shared_rss_config(struct efx_nic *efx,
@@ -2748,7 +2715,7 @@ static int efx_ef10_rx_push_exclusive_rss_config(struct efx_nic *efx, 
	struct efx_ef10_nic_data *nic_data = efx->nic_data;

	int rc;



	if (efx->rss_context.context_id == EFX_EF10_RSS_CONTEXT_INVALID ||

	if (efx->rss_context.context_id == EFX_MCDI_RSS_CONTEXT_INVALID ||

	    !nic_data->rx_rss_context_exclusive) {

		rc = efx_ef10_alloc_rss_context(efx, true, &efx->rss_context,

						NULL);
@@ -2764,7 +2731,7 @@ static int efx_ef10_rx_push_exclusive_rss_config(struct efx_nic *efx, 
		goto fail2;



	if (efx->rss_context.context_id != old_rx_rss_context &&

	    old_rx_rss_context != EFX_EF10_RSS_CONTEXT_INVALID)

	    old_rx_rss_context != EFX_MCDI_RSS_CONTEXT_INVALID)

		WARN_ON(efx_ef10_free_rss_context(efx, old_rx_rss_context) != 0);

	nic_data->rx_rss_context_exclusive = true;

	if (rx_indir_table != efx->rss_context.rx_indir_table)
@@ -2795,7 +2762,7 @@ static int efx_ef10_rx_push_rss_context_config(struct efx_nic *efx, 


	WARN_ON(!mutex_is_locked(&efx->rss_lock));



	if (ctx->context_id == EFX_EF10_RSS_CONTEXT_INVALID) {

	if (ctx->context_id == EFX_MCDI_RSS_CONTEXT_INVALID) {

		rc = efx_ef10_alloc_rss_context(efx, true, ctx, NULL);

		if (rc)

			return rc;
@@ -2830,7 +2797,7 @@ static int efx_ef10_rx_pull_rss_context_config(struct efx_nic *efx, 
	BUILD_BUG_ON(MC_CMD_RSS_CONTEXT_GET_TABLE_IN_LEN !=

		     MC_CMD_RSS_CONTEXT_GET_KEY_IN_LEN);



	if (ctx->context_id == EFX_EF10_RSS_CONTEXT_INVALID)

	if (ctx->context_id == EFX_MCDI_RSS_CONTEXT_INVALID)

		return -ENOENT;



	MCDI_SET_DWORD(inbuf, RSS_CONTEXT_GET_TABLE_IN_RSS_CONTEXT_ID,
@@ -2891,7 +2858,7 @@ static void efx_ef10_rx_restore_rss_contexts(struct efx_nic *efx) 


	list_for_each_entry(ctx, &efx->rss_context.list, list) {

		/* previous NIC RSS context is gone */

		ctx->context_id = EFX_EF10_RSS_CONTEXT_INVALID;

		ctx->context_id = EFX_MCDI_RSS_CONTEXT_INVALID;

		/* so try to allocate a new one */

		rc = efx_ef10_rx_push_rss_context_config(efx, ctx,

							 ctx->rx_indir_table,
@@ -2962,7 +2929,7 @@ static int efx_ef10_vf_rx_push_rss_config(struct efx_nic *efx, bool user, 
{

	if (user)

		return -EOPNOTSUPP;

	if (efx->rss_context.context_id != EFX_EF10_RSS_CONTEXT_INVALID)

	if (efx->rss_context.context_id != EFX_MCDI_RSS_CONTEXT_INVALID)

		return 0;

	return efx_ef10_rx_push_shared_rss_config(efx, NULL);

}
@@ -3883,7 +3850,7 @@ static void efx_ef10_filter_push_prep(struct efx_nic *efx, 
		 */

		if (WARN_ON_ONCE(!ctx))

			flags &= ~EFX_FILTER_FLAG_RX_RSS;

		else if (WARN_ON_ONCE(ctx->context_id == EFX_EF10_RSS_CONTEXT_INVALID))

		else if (WARN_ON_ONCE(ctx->context_id == EFX_MCDI_RSS_CONTEXT_INVALID))

			flags &= ~EFX_FILTER_FLAG_RX_RSS;

	}
@@ -4062,7 +4029,7 @@ static s32 efx_ef10_filter_insert_locked(struct efx_nic *efx, 
			rc = -ENOENT;

			goto out_unlock;

		}

		if (ctx->context_id == EFX_EF10_RSS_CONTEXT_INVALID) {

		if (ctx->context_id == EFX_MCDI_RSS_CONTEXT_INVALID) {

			rc = -EOPNOTSUPP;

			goto out_unlock;

		}
@@ -4803,7 +4770,7 @@ static void efx_ef10_filter_table_restore(struct efx_nic *efx) 
				invalid_filters++;

				goto not_restored;

			}

			if (ctx->context_id == EFX_EF10_RSS_CONTEXT_INVALID) {

			if (ctx->context_id == EFX_MCDI_RSS_CONTEXT_INVALID) {

				netif_warn(efx, drv, efx->net_dev,

					   "Warning: unable to restore a filter with RSS context %u as it was not created.\n",

					   spec->rss_context);

drivers/net/ethernet/sfc/efx.c

+1 −321
Original line number Diff line number Diff line
@@ -27,6 +27,7 @@ 
#include "efx_channels.h"

#include "rx_common.h"

#include "tx_common.h"

#include "rx_common.h"

#include "nic.h"

#include "io.h"

#include "selftest.h"
@@ -311,16 +312,6 @@ static void efx_dissociate(struct efx_nic *efx) 
	}

}



void efx_set_default_rx_indir_table(struct efx_nic *efx,

				    struct efx_rss_context *ctx)

{

	size_t i;



	for (i = 0; i < ARRAY_SIZE(ctx->rx_indir_table); i++)

		ctx->rx_indir_table[i] =

			ethtool_rxfh_indir_default(i, efx->rss_spread);

}



static int efx_probe_nic(struct efx_nic *efx)

{

	int rc;
@@ -393,70 +384,6 @@ static void efx_remove_nic(struct efx_nic *efx) 
	efx->type->remove(efx);

}



static int efx_probe_filters(struct efx_nic *efx)

{

	int rc;



	init_rwsem(&efx->filter_sem);

	mutex_lock(&efx->mac_lock);

	down_write(&efx->filter_sem);

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

	if (rc)

		goto out_unlock;



#ifdef CONFIG_RFS_ACCEL

	if (efx->type->offload_features & NETIF_F_NTUPLE) {

		struct efx_channel *channel;

		int i, success = 1;



		efx_for_each_channel(channel, efx) {

			channel->rps_flow_id =

				kcalloc(efx->type->max_rx_ip_filters,

					sizeof(*channel->rps_flow_id),

					GFP_KERNEL);

			if (!channel->rps_flow_id)

				success = 0;

			else

				for (i = 0;

				     i < efx->type->max_rx_ip_filters;

				     ++i)

					channel->rps_flow_id[i] =

						RPS_FLOW_ID_INVALID;

			channel->rfs_expire_index = 0;

			channel->rfs_filter_count = 0;

		}



		if (!success) {

			efx_for_each_channel(channel, efx)

				kfree(channel->rps_flow_id);

			efx->type->filter_table_remove(efx);

			rc = -ENOMEM;

			goto out_unlock;

		}

	}

#endif

out_unlock:

	up_write(&efx->filter_sem);

	mutex_unlock(&efx->mac_lock);

	return rc;

}



static void efx_remove_filters(struct efx_nic *efx)

{

#ifdef CONFIG_RFS_ACCEL

	struct efx_channel *channel;



	efx_for_each_channel(channel, efx) {

		cancel_delayed_work_sync(&channel->filter_work);

		kfree(channel->rps_flow_id);

	}

#endif

	down_write(&efx->filter_sem);

	efx->type->filter_table_remove(efx);

	up_write(&efx->filter_sem);

}





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

 *

 * NIC startup/shutdown
@@ -692,17 +619,6 @@ int efx_net_stop(struct net_device *net_dev) 
	return 0;

}



/* Context: process, dev_base_lock or RTNL held, non-blocking. */

static void efx_net_stats(struct net_device *net_dev,

			  struct rtnl_link_stats64 *stats)

{

	struct efx_nic *efx = netdev_priv(net_dev);



	spin_lock_bh(&efx->stats_lock);

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

	spin_unlock_bh(&efx->stats_lock);

}



/* Context: netif_tx_lock held, BHs disabled. */

static void efx_watchdog(struct net_device *net_dev, unsigned int txqueue)

{
@@ -715,51 +631,6 @@ static void efx_watchdog(struct net_device *net_dev, unsigned int txqueue) 
	efx_schedule_reset(efx, RESET_TYPE_TX_WATCHDOG);

}



static unsigned int efx_xdp_max_mtu(struct efx_nic *efx)

{

	/* The maximum MTU that we can fit in a single page, allowing for

	 * framing, overhead and XDP headroom.

	 */

	int overhead = EFX_MAX_FRAME_LEN(0) + sizeof(struct efx_rx_page_state) +

		       efx->rx_prefix_size + efx->type->rx_buffer_padding +

		       efx->rx_ip_align + XDP_PACKET_HEADROOM;



	return PAGE_SIZE - overhead;

}



/* Context: process, rtnl_lock() held. */

static int efx_change_mtu(struct net_device *net_dev, int new_mtu)

{

	struct efx_nic *efx = netdev_priv(net_dev);

	int rc;



	rc = efx_check_disabled(efx);

	if (rc)

		return rc;



	if (rtnl_dereference(efx->xdp_prog) &&

	    new_mtu > efx_xdp_max_mtu(efx)) {

		netif_err(efx, drv, efx->net_dev,

			  "Requested MTU of %d too big for XDP (max: %d)\n",

			  new_mtu, efx_xdp_max_mtu(efx));

		return -EINVAL;

	}



	netif_dbg(efx, drv, efx->net_dev, "changing MTU to %d\n", new_mtu);



	efx_device_detach_sync(efx);

	efx_stop_all(efx);



	mutex_lock(&efx->mac_lock);

	net_dev->mtu = new_mtu;

	efx_mac_reconfigure(efx);

	mutex_unlock(&efx->mac_lock);



	efx_start_all(efx);

	efx_device_attach_if_not_resetting(efx);

	return 0;

}



static int efx_set_mac_address(struct net_device *net_dev, void *data)

{

	struct efx_nic *efx = netdev_priv(net_dev);
@@ -1174,197 +1045,6 @@ void efx_update_sw_stats(struct efx_nic *efx, u64 *stats) 
	stats[GENERIC_STAT_rx_noskb_drops] = atomic_read(&efx->n_rx_noskb_drops);

}



bool efx_filter_spec_equal(const struct efx_filter_spec *left,

			   const struct efx_filter_spec *right)

{

	if ((left->match_flags ^ right->match_flags) |

	    ((left->flags ^ right->flags) &

	     (EFX_FILTER_FLAG_RX | EFX_FILTER_FLAG_TX)))

		return false;



	return memcmp(&left->outer_vid, &right->outer_vid,

		      sizeof(struct efx_filter_spec) -

		      offsetof(struct efx_filter_spec, outer_vid)) == 0;

}



u32 efx_filter_spec_hash(const struct efx_filter_spec *spec)

{

	BUILD_BUG_ON(offsetof(struct efx_filter_spec, outer_vid) & 3);

	return jhash2((const u32 *)&spec->outer_vid,

		      (sizeof(struct efx_filter_spec) -

		       offsetof(struct efx_filter_spec, outer_vid)) / 4,

		      0);

}



#ifdef CONFIG_RFS_ACCEL

bool efx_rps_check_rule(struct efx_arfs_rule *rule, unsigned int filter_idx,

			bool *force)

{

	if (rule->filter_id == EFX_ARFS_FILTER_ID_PENDING) {

		/* ARFS is currently updating this entry, leave it */

		return false;

	}

	if (rule->filter_id == EFX_ARFS_FILTER_ID_ERROR) {

		/* ARFS tried and failed to update this, so it's probably out

		 * of date.  Remove the filter and the ARFS rule entry.

		 */

		rule->filter_id = EFX_ARFS_FILTER_ID_REMOVING;

		*force = true;

		return true;

	} else if (WARN_ON(rule->filter_id != filter_idx)) { /* can't happen */

		/* ARFS has moved on, so old filter is not needed.  Since we did

		 * not mark the rule with EFX_ARFS_FILTER_ID_REMOVING, it will

		 * not be removed by efx_rps_hash_del() subsequently.

		 */

		*force = true;

		return true;

	}

	/* Remove it iff ARFS wants to. */

	return true;

}



static

struct hlist_head *efx_rps_hash_bucket(struct efx_nic *efx,

				       const struct efx_filter_spec *spec)

{

	u32 hash = efx_filter_spec_hash(spec);



	lockdep_assert_held(&efx->rps_hash_lock);

	if (!efx->rps_hash_table)

		return NULL;

	return &efx->rps_hash_table[hash % EFX_ARFS_HASH_TABLE_SIZE];

}



struct efx_arfs_rule *efx_rps_hash_find(struct efx_nic *efx,

					const struct efx_filter_spec *spec)

{

	struct efx_arfs_rule *rule;

	struct hlist_head *head;

	struct hlist_node *node;



	head = efx_rps_hash_bucket(efx, spec);

	if (!head)

		return NULL;

	hlist_for_each(node, head) {

		rule = container_of(node, struct efx_arfs_rule, node);

		if (efx_filter_spec_equal(spec, &rule->spec))

			return rule;

	}

	return NULL;

}



struct efx_arfs_rule *efx_rps_hash_add(struct efx_nic *efx,

				       const struct efx_filter_spec *spec,

				       bool *new)

{

	struct efx_arfs_rule *rule;

	struct hlist_head *head;

	struct hlist_node *node;



	head = efx_rps_hash_bucket(efx, spec);

	if (!head)

		return NULL;

	hlist_for_each(node, head) {

		rule = container_of(node, struct efx_arfs_rule, node);

		if (efx_filter_spec_equal(spec, &rule->spec)) {

			*new = false;

			return rule;

		}

	}

	rule = kmalloc(sizeof(*rule), GFP_ATOMIC);

	*new = true;

	if (rule) {

		memcpy(&rule->spec, spec, sizeof(rule->spec));

		hlist_add_head(&rule->node, head);

	}

	return rule;

}



void efx_rps_hash_del(struct efx_nic *efx, const struct efx_filter_spec *spec)

{

	struct efx_arfs_rule *rule;

	struct hlist_head *head;

	struct hlist_node *node;



	head = efx_rps_hash_bucket(efx, spec);

	if (WARN_ON(!head))

		return;

	hlist_for_each(node, head) {

		rule = container_of(node, struct efx_arfs_rule, node);

		if (efx_filter_spec_equal(spec, &rule->spec)) {

			/* Someone already reused the entry.  We know that if

			 * this check doesn't fire (i.e. filter_id == REMOVING)

			 * then the REMOVING mark was put there by our caller,

			 * because caller is holding a lock on filter table and

			 * only holders of that lock set REMOVING.

			 */

			if (rule->filter_id != EFX_ARFS_FILTER_ID_REMOVING)

				return;

			hlist_del(node);

			kfree(rule);

			return;

		}

	}

	/* We didn't find it. */

	WARN_ON(1);

}

#endif



/* RSS contexts.  We're using linked lists and crappy O(n) algorithms, because

 * (a) this is an infrequent control-plane operation and (b) n is small (max 64)

 */

struct efx_rss_context *efx_alloc_rss_context_entry(struct efx_nic *efx)

{

	struct list_head *head = &efx->rss_context.list;

	struct efx_rss_context *ctx, *new;

	u32 id = 1; /* Don't use zero, that refers to the master RSS context */



	WARN_ON(!mutex_is_locked(&efx->rss_lock));



	/* Search for first gap in the numbering */

	list_for_each_entry(ctx, head, list) {

		if (ctx->user_id != id)

			break;

		id++;

		/* Check for wrap.  If this happens, we have nearly 2^32

		 * allocated RSS contexts, which seems unlikely.

		 */

		if (WARN_ON_ONCE(!id))

			return NULL;

	}



	/* Create the new entry */

	new = kmalloc(sizeof(struct efx_rss_context), GFP_KERNEL);

	if (!new)

		return NULL;

	new->context_id = EFX_EF10_RSS_CONTEXT_INVALID;

	new->rx_hash_udp_4tuple = false;



	/* Insert the new entry into the gap */

	new->user_id = id;

	list_add_tail(&new->list, &ctx->list);

	return new;

}



struct efx_rss_context *efx_find_rss_context_entry(struct efx_nic *efx, u32 id)

{

	struct list_head *head = &efx->rss_context.list;

	struct efx_rss_context *ctx;



	WARN_ON(!mutex_is_locked(&efx->rss_lock));



	list_for_each_entry(ctx, head, list)

		if (ctx->user_id == id)

			return ctx;

	return NULL;

}



void efx_free_rss_context_entry(struct efx_rss_context *ctx)

{

	list_del(&ctx->list);

	kfree(ctx);

}



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

 *

 * PCI interface

drivers/net/ethernet/sfc/efx.h

+1 −31
Original line number Diff line number Diff line
@@ -26,8 +26,6 @@ extern unsigned int efx_piobuf_size; 
extern bool efx_separate_tx_channels;



/* RX */

void efx_set_default_rx_indir_table(struct efx_nic *efx,

				    struct efx_rss_context *ctx);

void __efx_rx_packet(struct efx_channel *channel);

void efx_rx_packet(struct efx_rx_queue *rx_queue, unsigned int index,

		   unsigned int n_frags, unsigned int len, u16 flags);
@@ -37,9 +35,6 @@ static inline void efx_rx_flush_packet(struct efx_channel *channel) 
		__efx_rx_packet(channel);

}



void efx_init_rx_recycle_ring(struct efx_rx_queue *rx_queue);

struct page *efx_reuse_page(struct efx_rx_queue *rx_queue);



#define EFX_MAX_DMAQ_SIZE 4096UL

#define EFX_DEFAULT_DMAQ_SIZE 1024UL

#define EFX_MIN_DMAQ_SIZE 512UL
@@ -174,36 +169,11 @@ static inline void efx_filter_rfs_expire(struct work_struct *data) 
static inline void efx_filter_rfs_expire(struct work_struct *data) {}

#define efx_filter_rfs_enabled() 0

#endif

bool efx_filter_is_mc_recipient(const struct efx_filter_spec *spec);



bool efx_filter_spec_equal(const struct efx_filter_spec *left,

			   const struct efx_filter_spec *right);

u32 efx_filter_spec_hash(const struct efx_filter_spec *spec);



#ifdef CONFIG_RFS_ACCEL

bool efx_rps_check_rule(struct efx_arfs_rule *rule, unsigned int filter_idx,

			bool *force);



struct efx_arfs_rule *efx_rps_hash_find(struct efx_nic *efx,

					const struct efx_filter_spec *spec);



/* @new is written to indicate if entry was newly added (true) or if an old

 * entry was found and returned (false).

 */

struct efx_arfs_rule *efx_rps_hash_add(struct efx_nic *efx,

				       const struct efx_filter_spec *spec,

				       bool *new);



void efx_rps_hash_del(struct efx_nic *efx, const struct efx_filter_spec *spec);

#endif



/* RSS contexts */

struct efx_rss_context *efx_alloc_rss_context_entry(struct efx_nic *efx);

struct efx_rss_context *efx_find_rss_context_entry(struct efx_nic *efx, u32 id);

void efx_free_rss_context_entry(struct efx_rss_context *ctx);

static inline bool efx_rss_active(struct efx_rss_context *ctx)

{

	return ctx->context_id != EFX_EF10_RSS_CONTEXT_INVALID;

	return ctx->context_id != EFX_MCDI_RSS_CONTEXT_INVALID;

}



/* Ethtool support */

drivers/net/ethernet/sfc/efx_common.c

+56 −1
Original line number Diff line number Diff line
@@ -197,6 +197,51 @@ void efx_link_status_changed(struct efx_nic *efx) 
		netif_info(efx, link, efx->net_dev, "link down\n");

}



unsigned int efx_xdp_max_mtu(struct efx_nic *efx)

{

	/* The maximum MTU that we can fit in a single page, allowing for

	 * framing, overhead and XDP headroom.

	 */

	int overhead = EFX_MAX_FRAME_LEN(0) + sizeof(struct efx_rx_page_state) +

		       efx->rx_prefix_size + efx->type->rx_buffer_padding +

		       efx->rx_ip_align + XDP_PACKET_HEADROOM;



	return PAGE_SIZE - overhead;

}



/* Context: process, rtnl_lock() held. */

int efx_change_mtu(struct net_device *net_dev, int new_mtu)

{

	struct efx_nic *efx = netdev_priv(net_dev);

	int rc;



	rc = efx_check_disabled(efx);

	if (rc)

		return rc;



	if (rtnl_dereference(efx->xdp_prog) &&

	    new_mtu > efx_xdp_max_mtu(efx)) {

		netif_err(efx, drv, efx->net_dev,

			  "Requested MTU of %d too big for XDP (max: %d)\n",

			  new_mtu, efx_xdp_max_mtu(efx));

		return -EINVAL;

	}



	netif_dbg(efx, drv, efx->net_dev, "changing MTU to %d\n", new_mtu);



	efx_device_detach_sync(efx);

	efx_stop_all(efx);



	mutex_lock(&efx->mac_lock);

	net_dev->mtu = new_mtu;

	efx_mac_reconfigure(efx);

	mutex_unlock(&efx->mac_lock);



	efx_start_all(efx);

	efx_device_attach_if_not_resetting(efx);

	return 0;

}



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

 *

 * Hardware monitor
@@ -454,6 +499,16 @@ void efx_stop_all(struct efx_nic *efx) 
	efx_stop_datapath(efx);

}



/* Context: process, dev_base_lock or RTNL held, non-blocking. */

void efx_net_stats(struct net_device *net_dev, struct rtnl_link_stats64 *stats)

{

	struct efx_nic *efx = netdev_priv(net_dev);



	spin_lock_bh(&efx->stats_lock);

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

	spin_unlock_bh(&efx->stats_lock);

}



/* Push loopback/power/transmit disable settings to the PHY, and reconfigure

 * the MAC appropriately. All other PHY configuration changes are pushed

 * through phy_op->set_settings(), and pushed asynchronously to the MAC
@@ -840,7 +895,7 @@ int efx_init_struct(struct efx_nic *efx, 
#endif

	INIT_WORK(&efx->reset_work, efx_reset_work);

	INIT_DELAYED_WORK(&efx->monitor_work, efx_monitor);

	INIT_DELAYED_WORK(&efx->selftest_work, efx_selftest_async_work);

	efx_selftest_async_init(efx);

	efx->pci_dev = pci_dev;

	efx->msg_enable = debug;

	efx->state = STATE_UNINIT;

CRA Git | Maintained and supported by SUSTech CRA and CCSE