Commit 3f8f2e93 authored by Jakub Kicinski's avatar Jakub Kicinski
Browse files

Merge branch 'eth-fbnic-support-basic-rss-config-and-setting-channel-count' 

Jakub Kicinski says:

====================
eth: fbnic: support basic RSS config and setting channel count

Add support for basic RSS config (indirection table, key get and set),
and changing the number of channels.

  # ./ksft-net-drv/run_kselftest.sh -t drivers/net/hw:rss_ctx.py
  TAP version 13
  1..1
  # timeout set to 0
  # selftests: drivers/net/hw: rss_ctx.py
  # KTAP version 1
  # 1..15
  # ok 1 rss_ctx.test_rss_key_indir
  # ok 2 rss_ctx.test_rss_queue_reconfigure
  # ok 3 rss_ctx.test_rss_resize
  # ok 4 rss_ctx.test_hitless_key_update

  .. the rest of the tests are for additional contexts so they
  get skipped..

The slicing of the patches (and bugs) are mine, but I'm keeping
Alex as the author on the patches where he wrote 100% of the code.
====================

Link: https://patch.msgid.link/20241220025241.1522781-1-kuba@kernel.org


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parents f6f1795d 52dc722d

drivers/net/ethernet/meta/fbnic/fbnic.h

+15 −0
Original line number Diff line number Diff line
@@ -16,6 +16,10 @@ 
#include "fbnic_mac.h"

#include "fbnic_rpc.h"



struct fbnic_napi_vector;



#define FBNIC_MAX_NAPI_VECTORS		128u



struct fbnic_dev {

	struct device *dev;

	struct net_device *netdev;
@@ -29,6 +33,11 @@ struct fbnic_dev { 
	unsigned int pcs_msix_vector;

	unsigned short num_irqs;



	struct {

		u8 users;

		char name[IFNAMSIZ + 9];

	} napi_irq[FBNIC_MAX_NAPI_VECTORS];



	struct delayed_work service_task;



	struct fbnic_fw_mbx mbx[FBNIC_IPC_MBX_INDICES];
@@ -148,6 +157,12 @@ void fbnic_hwmon_unregister(struct fbnic_dev *fbd); 
int fbnic_pcs_irq_enable(struct fbnic_dev *fbd);

void fbnic_pcs_irq_disable(struct fbnic_dev *fbd);



void fbnic_napi_name_irqs(struct fbnic_dev *fbd);

int fbnic_napi_request_irq(struct fbnic_dev *fbd,

			   struct fbnic_napi_vector *nv);

void fbnic_napi_free_irq(struct fbnic_dev *fbd,

			 struct fbnic_napi_vector *nv);

void fbnic_synchronize_irq(struct fbnic_dev *fbd, int nr);

int fbnic_request_irq(struct fbnic_dev *dev, int nr, irq_handler_t handler,

		      unsigned long flags, const char *name, void *data);

void fbnic_free_irq(struct fbnic_dev *dev, int nr, void *data);

drivers/net/ethernet/meta/fbnic/fbnic_ethtool.c

+467 −76
Original line number Diff line number Diff line
@@ -40,49 +40,99 @@ static const struct fbnic_stat fbnic_gstrings_hw_stats[] = { 
#define FBNIC_HW_FIXED_STATS_LEN ARRAY_SIZE(fbnic_gstrings_hw_stats)

#define FBNIC_HW_STATS_LEN	FBNIC_HW_FIXED_STATS_LEN



static int

fbnic_get_ts_info(struct net_device *netdev,

		  struct kernel_ethtool_ts_info *tsinfo)

static void

fbnic_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	struct fbnic_dev *fbd = fbn->fbd;



	tsinfo->phc_index = ptp_clock_index(fbn->fbd->ptp);

	fbnic_get_fw_ver_commit_str(fbd, drvinfo->fw_version,

				    sizeof(drvinfo->fw_version));

}



	tsinfo->so_timestamping =

		SOF_TIMESTAMPING_TX_SOFTWARE |

		SOF_TIMESTAMPING_TX_HARDWARE |

		SOF_TIMESTAMPING_RX_HARDWARE |

		SOF_TIMESTAMPING_RAW_HARDWARE;

static int fbnic_get_regs_len(struct net_device *netdev)

{

	struct fbnic_net *fbn = netdev_priv(netdev);



	tsinfo->tx_types =

		BIT(HWTSTAMP_TX_OFF) |

		BIT(HWTSTAMP_TX_ON);

	return fbnic_csr_regs_len(fbn->fbd) * sizeof(u32);

}



	tsinfo->rx_filters =

		BIT(HWTSTAMP_FILTER_NONE) |

		BIT(HWTSTAMP_FILTER_PTP_V1_L4_EVENT) |

		BIT(HWTSTAMP_FILTER_PTP_V2_L4_EVENT) |

		BIT(HWTSTAMP_FILTER_PTP_V2_L2_EVENT) |

		BIT(HWTSTAMP_FILTER_PTP_V2_EVENT) |

		BIT(HWTSTAMP_FILTER_ALL);

static void fbnic_get_regs(struct net_device *netdev,

			   struct ethtool_regs *regs, void *data)

{

	struct fbnic_net *fbn = netdev_priv(netdev);



	return 0;

	fbnic_csr_get_regs(fbn->fbd, data, &regs->version);

}



static void

fbnic_get_drvinfo(struct net_device *netdev, struct ethtool_drvinfo *drvinfo)

static struct fbnic_net *fbnic_clone_create(struct fbnic_net *orig)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	struct fbnic_dev *fbd = fbn->fbd;

	struct fbnic_net *clone;



	fbnic_get_fw_ver_commit_str(fbd, drvinfo->fw_version,

				    sizeof(drvinfo->fw_version));

	clone = kmemdup(orig, sizeof(*orig), GFP_KERNEL);

	if (!clone)

		return NULL;



	memset(clone->tx, 0, sizeof(clone->tx));

	memset(clone->rx, 0, sizeof(clone->rx));

	memset(clone->napi, 0, sizeof(clone->napi));

	return clone;

}



static void fbnic_set_counter(u64 *stat, struct fbnic_stat_counter *counter)

static void fbnic_clone_swap_cfg(struct fbnic_net *orig,

				 struct fbnic_net *clone)

{

	if (counter->reported)

		*stat = counter->value;

	swap(clone->rcq_size, orig->rcq_size);

	swap(clone->hpq_size, orig->hpq_size);

	swap(clone->ppq_size, orig->ppq_size);

	swap(clone->txq_size, orig->txq_size);

	swap(clone->num_rx_queues, orig->num_rx_queues);

	swap(clone->num_tx_queues, orig->num_tx_queues);

	swap(clone->num_napi, orig->num_napi);

}



static void fbnic_aggregate_vector_counters(struct fbnic_net *fbn,

					    struct fbnic_napi_vector *nv)

{

	int i, j;



	for (i = 0; i < nv->txt_count; i++) {

		fbnic_aggregate_ring_tx_counters(fbn, &nv->qt[i].sub0);

		fbnic_aggregate_ring_tx_counters(fbn, &nv->qt[i].sub1);

		fbnic_aggregate_ring_tx_counters(fbn, &nv->qt[i].cmpl);

	}



	for (j = 0; j < nv->rxt_count; j++, i++) {

		fbnic_aggregate_ring_rx_counters(fbn, &nv->qt[i].sub0);

		fbnic_aggregate_ring_rx_counters(fbn, &nv->qt[i].sub1);

		fbnic_aggregate_ring_rx_counters(fbn, &nv->qt[i].cmpl);

	}

}



static void fbnic_clone_swap(struct fbnic_net *orig,

			     struct fbnic_net *clone)

{

	struct fbnic_dev *fbd = orig->fbd;

	unsigned int i;



	for (i = 0; i < max(clone->num_napi, orig->num_napi); i++)

		fbnic_synchronize_irq(fbd, FBNIC_NON_NAPI_VECTORS + i);

	for (i = 0; i < orig->num_napi; i++)

		fbnic_aggregate_vector_counters(orig, orig->napi[i]);



	fbnic_clone_swap_cfg(orig, clone);



	for (i = 0; i < ARRAY_SIZE(orig->napi); i++)

		swap(clone->napi[i], orig->napi[i]);

	for (i = 0; i < ARRAY_SIZE(orig->tx); i++)

		swap(clone->tx[i], orig->tx[i]);

	for (i = 0; i < ARRAY_SIZE(orig->rx); i++)

		swap(clone->rx[i], orig->rx[i]);

}



static void fbnic_clone_free(struct fbnic_net *clone)

{

	kfree(clone);

}



static void fbnic_get_strings(struct net_device *dev, u32 sset, u8 *data)
@@ -97,6 +147,21 @@ static void fbnic_get_strings(struct net_device *dev, u32 sset, u8 *data) 
	}

}



static void fbnic_get_ethtool_stats(struct net_device *dev,

				    struct ethtool_stats *stats, u64 *data)

{

	struct fbnic_net *fbn = netdev_priv(dev);

	const struct fbnic_stat *stat;

	int i;



	fbnic_get_hw_stats(fbn->fbd);



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

		stat = &fbnic_gstrings_hw_stats[i];

		data[i] = *(u64 *)((u8 *)&fbn->fbd->hw_stats + stat->offset);

	}

}



static int fbnic_get_sset_count(struct net_device *dev, int sset)

{

	switch (sset) {
@@ -107,19 +172,375 @@ static int fbnic_get_sset_count(struct net_device *dev, int sset) 
	}

}



static void fbnic_get_ethtool_stats(struct net_device *dev,

				    struct ethtool_stats *stats, u64 *data)

static int fbnic_get_rss_hash_idx(u32 flow_type)

{

	struct fbnic_net *fbn = netdev_priv(dev);

	const struct fbnic_stat *stat;

	int i;

	switch (flow_type & ~(FLOW_EXT | FLOW_MAC_EXT | FLOW_RSS)) {

	case TCP_V4_FLOW:

		return FBNIC_TCP4_HASH_OPT;

	case TCP_V6_FLOW:

		return FBNIC_TCP6_HASH_OPT;

	case UDP_V4_FLOW:

		return FBNIC_UDP4_HASH_OPT;

	case UDP_V6_FLOW:

		return FBNIC_UDP6_HASH_OPT;

	case AH_V4_FLOW:

	case ESP_V4_FLOW:

	case AH_ESP_V4_FLOW:

	case SCTP_V4_FLOW:

	case IPV4_FLOW:

	case IPV4_USER_FLOW:

		return FBNIC_IPV4_HASH_OPT;

	case AH_V6_FLOW:

	case ESP_V6_FLOW:

	case AH_ESP_V6_FLOW:

	case SCTP_V6_FLOW:

	case IPV6_FLOW:

	case IPV6_USER_FLOW:

		return FBNIC_IPV6_HASH_OPT;

	case ETHER_FLOW:

		return FBNIC_ETHER_HASH_OPT;

	}



	fbnic_get_hw_stats(fbn->fbd);

	return -1;

}



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

		stat = &fbnic_gstrings_hw_stats[i];

		data[i] = *(u64 *)((u8 *)&fbn->fbd->hw_stats + stat->offset);

static int

fbnic_get_rss_hash_opts(struct fbnic_net *fbn, struct ethtool_rxnfc *cmd)

{

	int hash_opt_idx = fbnic_get_rss_hash_idx(cmd->flow_type);



	if (hash_opt_idx < 0)

		return -EINVAL;



	/* Report options from rss_en table in fbn */

	cmd->data = fbn->rss_flow_hash[hash_opt_idx];



	return 0;

}



static int fbnic_get_rxnfc(struct net_device *netdev,

			   struct ethtool_rxnfc *cmd, u32 *rule_locs)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	int ret = -EOPNOTSUPP;



	switch (cmd->cmd) {

	case ETHTOOL_GRXRINGS:

		cmd->data = fbn->num_rx_queues;

		ret = 0;

		break;

	case ETHTOOL_GRXFH:

		ret = fbnic_get_rss_hash_opts(fbn, cmd);

		break;

	}



	return ret;

}



#define FBNIC_L2_HASH_OPTIONS \

	(RXH_L2DA | RXH_DISCARD)

#define FBNIC_L3_HASH_OPTIONS \

	(FBNIC_L2_HASH_OPTIONS | RXH_IP_SRC | RXH_IP_DST)

#define FBNIC_L4_HASH_OPTIONS \

	(FBNIC_L3_HASH_OPTIONS | RXH_L4_B_0_1 | RXH_L4_B_2_3)



static int

fbnic_set_rss_hash_opts(struct fbnic_net *fbn, const struct ethtool_rxnfc *cmd)

{

	int hash_opt_idx;



	/* Verify the type requested is correct */

	hash_opt_idx = fbnic_get_rss_hash_idx(cmd->flow_type);

	if (hash_opt_idx < 0)

		return -EINVAL;



	/* Verify the fields asked for can actually be assigned based on type */

	if (cmd->data & ~FBNIC_L4_HASH_OPTIONS ||

	    (hash_opt_idx > FBNIC_L4_HASH_OPT &&

	     cmd->data & ~FBNIC_L3_HASH_OPTIONS) ||

	    (hash_opt_idx > FBNIC_IP_HASH_OPT &&

	     cmd->data & ~FBNIC_L2_HASH_OPTIONS))

		return -EINVAL;



	fbn->rss_flow_hash[hash_opt_idx] = cmd->data;



	if (netif_running(fbn->netdev)) {

		fbnic_rss_reinit(fbn->fbd, fbn);

		fbnic_write_rules(fbn->fbd);

	}



	return 0;

}



static int fbnic_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	int ret = -EOPNOTSUPP;



	switch (cmd->cmd) {

	case ETHTOOL_SRXFH:

		ret = fbnic_set_rss_hash_opts(fbn, cmd);

		break;

	}



	return ret;

}



static u32 fbnic_get_rxfh_key_size(struct net_device *netdev)

{

	return FBNIC_RPC_RSS_KEY_BYTE_LEN;

}



static u32 fbnic_get_rxfh_indir_size(struct net_device *netdev)

{

	return FBNIC_RPC_RSS_TBL_SIZE;

}



static int

fbnic_get_rxfh(struct net_device *netdev, struct ethtool_rxfh_param *rxfh)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	unsigned int i;



	rxfh->hfunc = ETH_RSS_HASH_TOP;



	if (rxfh->key) {

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

			u32 rss_key = fbn->rss_key[i / 4] << ((i % 4) * 8);



			rxfh->key[i] = rss_key >> 24;

		}

	}



	if (rxfh->indir) {

		for (i = 0; i < FBNIC_RPC_RSS_TBL_SIZE; i++)

			rxfh->indir[i] = fbn->indir_tbl[0][i];

	}



	return 0;

}



static unsigned int

fbnic_set_indir(struct fbnic_net *fbn, unsigned int idx, const u32 *indir)

{

	unsigned int i, changes = 0;



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

		if (fbn->indir_tbl[idx][i] == indir[i])

			continue;



		fbn->indir_tbl[idx][i] = indir[i];

		changes++;

	}



	return changes;

}



static int

fbnic_set_rxfh(struct net_device *netdev, struct ethtool_rxfh_param *rxfh,

	       struct netlink_ext_ack *extack)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	unsigned int i, changes = 0;



	if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE &&

	    rxfh->hfunc != ETH_RSS_HASH_TOP)

		return -EINVAL;



	if (rxfh->key) {

		u32 rss_key = 0;



		for (i = FBNIC_RPC_RSS_KEY_BYTE_LEN; i--;) {

			rss_key >>= 8;

			rss_key |= (u32)(rxfh->key[i]) << 24;



			if (i % 4)

				continue;



			if (fbn->rss_key[i / 4] == rss_key)

				continue;



			fbn->rss_key[i / 4] = rss_key;

			changes++;

		}

	}



	if (rxfh->indir)

		changes += fbnic_set_indir(fbn, 0, rxfh->indir);



	if (changes && netif_running(netdev))

		fbnic_rss_reinit_hw(fbn->fbd, fbn);



	return 0;

}



static void fbnic_get_channels(struct net_device *netdev,

			       struct ethtool_channels *ch)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	struct fbnic_dev *fbd = fbn->fbd;



	ch->max_rx = fbd->max_num_queues;

	ch->max_tx = fbd->max_num_queues;

	ch->max_combined = min(ch->max_rx, ch->max_tx);

	ch->max_other =	FBNIC_NON_NAPI_VECTORS;



	if (fbn->num_rx_queues > fbn->num_napi ||

	    fbn->num_tx_queues > fbn->num_napi)

		ch->combined_count = min(fbn->num_rx_queues,

					 fbn->num_tx_queues);

	else

		ch->combined_count =

			fbn->num_rx_queues + fbn->num_tx_queues - fbn->num_napi;

	ch->rx_count = fbn->num_rx_queues - ch->combined_count;

	ch->tx_count = fbn->num_tx_queues - ch->combined_count;

	ch->other_count = FBNIC_NON_NAPI_VECTORS;

}



static void fbnic_set_queues(struct fbnic_net *fbn, struct ethtool_channels *ch,

			     unsigned int max_napis)

{

	fbn->num_rx_queues = ch->rx_count + ch->combined_count;

	fbn->num_tx_queues = ch->tx_count + ch->combined_count;

	fbn->num_napi = min(ch->rx_count + ch->tx_count + ch->combined_count,

			    max_napis);

}



static int fbnic_set_channels(struct net_device *netdev,

			      struct ethtool_channels *ch)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	unsigned int max_napis, standalone;

	struct fbnic_dev *fbd = fbn->fbd;

	struct fbnic_net *clone;

	int err;



	max_napis = fbd->num_irqs - FBNIC_NON_NAPI_VECTORS;

	standalone = ch->rx_count + ch->tx_count;



	/* Limits for standalone queues:

	 *  - each queue has it's own NAPI (num_napi >= rx + tx + combined)

	 *  - combining queues (combined not 0, rx or tx must be 0)

	 */

	if ((ch->rx_count && ch->tx_count && ch->combined_count) ||

	    (standalone && standalone + ch->combined_count > max_napis) ||

	    ch->rx_count + ch->combined_count > fbd->max_num_queues ||

	    ch->tx_count + ch->combined_count > fbd->max_num_queues ||

	    ch->other_count != FBNIC_NON_NAPI_VECTORS)

		return -EINVAL;



	if (!netif_running(netdev)) {

		fbnic_set_queues(fbn, ch, max_napis);

		fbnic_reset_indir_tbl(fbn);

		return 0;

	}



	clone = fbnic_clone_create(fbn);

	if (!clone)

		return -ENOMEM;



	fbnic_set_queues(clone, ch, max_napis);



	err = fbnic_alloc_napi_vectors(clone);

	if (err)

		goto err_free_clone;



	err = fbnic_alloc_resources(clone);

	if (err)

		goto err_free_napis;



	fbnic_down_noidle(fbn);

	err = fbnic_wait_all_queues_idle(fbn->fbd, true);

	if (err)

		goto err_start_stack;



	err = fbnic_set_netif_queues(clone);

	if (err)

		goto err_start_stack;



	/* Nothing can fail past this point */

	fbnic_flush(fbn);



	fbnic_clone_swap(fbn, clone);



	/* Reset RSS indirection table */

	fbnic_reset_indir_tbl(fbn);



	fbnic_up(fbn);



	fbnic_free_resources(clone);

	fbnic_free_napi_vectors(clone);

	fbnic_clone_free(clone);



	return 0;



err_start_stack:

	fbnic_flush(fbn);

	fbnic_up(fbn);

	fbnic_free_resources(clone);

err_free_napis:

	fbnic_free_napi_vectors(clone);

err_free_clone:

	fbnic_clone_free(clone);

	return err;

}



static int

fbnic_get_ts_info(struct net_device *netdev,

		  struct kernel_ethtool_ts_info *tsinfo)

{

	struct fbnic_net *fbn = netdev_priv(netdev);



	tsinfo->phc_index = ptp_clock_index(fbn->fbd->ptp);



	tsinfo->so_timestamping =

		SOF_TIMESTAMPING_TX_SOFTWARE |

		SOF_TIMESTAMPING_TX_HARDWARE |

		SOF_TIMESTAMPING_RX_HARDWARE |

		SOF_TIMESTAMPING_RAW_HARDWARE;



	tsinfo->tx_types =

		BIT(HWTSTAMP_TX_OFF) |

		BIT(HWTSTAMP_TX_ON);



	tsinfo->rx_filters =

		BIT(HWTSTAMP_FILTER_NONE) |

		BIT(HWTSTAMP_FILTER_PTP_V1_L4_EVENT) |

		BIT(HWTSTAMP_FILTER_PTP_V2_L4_EVENT) |

		BIT(HWTSTAMP_FILTER_PTP_V2_L2_EVENT) |

		BIT(HWTSTAMP_FILTER_PTP_V2_EVENT) |

		BIT(HWTSTAMP_FILTER_ALL);



	return 0;

}



static void fbnic_get_ts_stats(struct net_device *netdev,

			       struct ethtool_ts_stats *ts_stats)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	u64 ts_packets, ts_lost;

	struct fbnic_ring *ring;

	unsigned int start;

	int i;



	ts_stats->pkts = fbn->tx_stats.ts_packets;

	ts_stats->lost = fbn->tx_stats.ts_lost;

	for (i = 0; i < fbn->num_tx_queues; i++) {

		ring = fbn->tx[i];

		do {

			start = u64_stats_fetch_begin(&ring->stats.syncp);

			ts_packets = ring->stats.ts_packets;

			ts_lost = ring->stats.ts_lost;

		} while (u64_stats_fetch_retry(&ring->stats.syncp, start));

		ts_stats->pkts += ts_packets;

		ts_stats->lost += ts_lost;

	}

}



static void fbnic_set_counter(u64 *stat, struct fbnic_stat_counter *counter)

{

	if (counter->reported)

		*stat = counter->value;

}



static void
@@ -164,44 +585,6 @@ fbnic_get_eth_mac_stats(struct net_device *netdev, 
			  &mac_stats->eth_mac.FrameTooLongErrors);

}



static void fbnic_get_ts_stats(struct net_device *netdev,

			       struct ethtool_ts_stats *ts_stats)

{

	struct fbnic_net *fbn = netdev_priv(netdev);

	u64 ts_packets, ts_lost;

	struct fbnic_ring *ring;

	unsigned int start;

	int i;



	ts_stats->pkts = fbn->tx_stats.ts_packets;

	ts_stats->lost = fbn->tx_stats.ts_lost;

	for (i = 0; i < fbn->num_tx_queues; i++) {

		ring = fbn->tx[i];

		do {

			start = u64_stats_fetch_begin(&ring->stats.syncp);

			ts_packets = ring->stats.ts_packets;

			ts_lost = ring->stats.ts_lost;

		} while (u64_stats_fetch_retry(&ring->stats.syncp, start));

		ts_stats->pkts += ts_packets;

		ts_stats->lost += ts_lost;

	}

}



static void fbnic_get_regs(struct net_device *netdev,

			   struct ethtool_regs *regs, void *data)

{

	struct fbnic_net *fbn = netdev_priv(netdev);



	fbnic_csr_get_regs(fbn->fbd, data, &regs->version);

}



static int fbnic_get_regs_len(struct net_device *netdev)

{

	struct fbnic_net *fbn = netdev_priv(netdev);



	return fbnic_csr_regs_len(fbn->fbd) * sizeof(u32);

}



static const struct ethtool_ops fbnic_ethtool_ops = {

	.get_drvinfo		= fbnic_get_drvinfo,

	.get_regs_len		= fbnic_get_regs_len,
@@ -209,6 +592,14 @@ static const struct ethtool_ops fbnic_ethtool_ops = { 
	.get_strings		= fbnic_get_strings,

	.get_ethtool_stats	= fbnic_get_ethtool_stats,

	.get_sset_count		= fbnic_get_sset_count,

	.get_rxnfc		= fbnic_get_rxnfc,

	.set_rxnfc		= fbnic_set_rxnfc,

	.get_rxfh_key_size	= fbnic_get_rxfh_key_size,

	.get_rxfh_indir_size	= fbnic_get_rxfh_indir_size,

	.get_rxfh		= fbnic_get_rxfh,

	.set_rxfh		= fbnic_set_rxfh,

	.get_channels		= fbnic_get_channels,

	.set_channels		= fbnic_set_channels,

	.get_ts_info		= fbnic_get_ts_info,

	.get_ts_stats		= fbnic_get_ts_stats,

	.get_eth_mac_stats	= fbnic_get_eth_mac_stats,

drivers/net/ethernet/meta/fbnic/fbnic_irq.c

+53 −0
Original line number Diff line number Diff line
@@ -146,6 +146,17 @@ void fbnic_pcs_irq_disable(struct fbnic_dev *fbd) 
	free_irq(fbd->pcs_msix_vector, fbd);

}



void fbnic_synchronize_irq(struct fbnic_dev *fbd, int nr)

{

	struct pci_dev *pdev = to_pci_dev(fbd->dev);

	int irq = pci_irq_vector(pdev, nr);



	if (irq < 0)

		return;



	synchronize_irq(irq);

}



int fbnic_request_irq(struct fbnic_dev *fbd, int nr, irq_handler_t handler,

		      unsigned long flags, const char *name, void *data)

{
@@ -169,6 +180,48 @@ void fbnic_free_irq(struct fbnic_dev *fbd, int nr, void *data) 
	free_irq(irq, data);

}



void fbnic_napi_name_irqs(struct fbnic_dev *fbd)

{

	unsigned int i;



	for (i = 0; i < ARRAY_SIZE(fbd->napi_irq); i++)

		snprintf(fbd->napi_irq[i].name,

			 sizeof(fbd->napi_irq[i].name),

			 "%s-TxRx-%u", fbd->netdev->name, i);

}



int fbnic_napi_request_irq(struct fbnic_dev *fbd,

			   struct fbnic_napi_vector *nv)

{

	struct fbnic_net *fbn = netdev_priv(fbd->netdev);

	int i = fbnic_napi_idx(nv);

	int err;



	if (!fbd->napi_irq[i].users) {

		err = fbnic_request_irq(fbd, nv->v_idx,

					fbnic_msix_clean_rings,	0,

					fbd->napi_irq[i].name,

					&fbn->napi[i]);

		if (err)

			return err;

	}



	fbd->napi_irq[i].users++;

	return 0;

}



void fbnic_napi_free_irq(struct fbnic_dev *fbd,

			 struct fbnic_napi_vector *nv)

{

	struct fbnic_net *fbn = netdev_priv(fbd->netdev);

	int i = fbnic_napi_idx(nv);



	if (--fbd->napi_irq[i].users)

		return;



	fbnic_free_irq(fbd, nv->v_idx, &fbn->napi[i]);

}



void fbnic_free_irqs(struct fbnic_dev *fbd)

{

	struct pci_dev *pdev = to_pci_dev(fbd->dev);

drivers/net/ethernet/meta/fbnic/fbnic_netdev.c

+4 −8
Original line number Diff line number Diff line
@@ -23,13 +23,7 @@ int __fbnic_open(struct fbnic_net *fbn) 
	if (err)

		goto free_napi_vectors;



	err = netif_set_real_num_tx_queues(fbn->netdev,

					   fbn->num_tx_queues);

	if (err)

		goto free_resources;



	err = netif_set_real_num_rx_queues(fbn->netdev,

					   fbn->num_rx_queues);

	err = fbnic_set_netif_queues(fbn);

	if (err)

		goto free_resources;
@@ -74,6 +68,8 @@ static int fbnic_open(struct net_device *netdev) 
	struct fbnic_net *fbn = netdev_priv(netdev);

	int err;



	fbnic_napi_name_irqs(fbn->fbd);



	err = __fbnic_open(fbn);

	if (!err)

		fbnic_up(fbn);
@@ -91,6 +87,7 @@ static int fbnic_stop(struct net_device *netdev) 
	fbnic_time_stop(fbn);

	fbnic_fw_xmit_ownership_msg(fbn->fbd, false);



	fbnic_reset_netif_queues(fbn);

	fbnic_free_resources(fbn);

	fbnic_free_napi_vectors(fbn);
@@ -615,7 +612,6 @@ struct net_device *fbnic_netdev_alloc(struct fbnic_dev *fbd) 


	fbn->netdev = netdev;

	fbn->fbd = fbd;

	INIT_LIST_HEAD(&fbn->napis);



	fbn->txq_size = FBNIC_TXQ_SIZE_DEFAULT;

	fbn->hpq_size = FBNIC_HPQ_SIZE_DEFAULT;

drivers/net/ethernet/meta/fbnic/fbnic_netdev.h

+5 −2
Original line number Diff line number Diff line
@@ -11,10 +11,14 @@ 
#include "fbnic_rpc.h"

#include "fbnic_txrx.h"



#define FBNIC_MAX_NAPI_VECTORS		128u



struct fbnic_net {

	struct fbnic_ring *tx[FBNIC_MAX_TXQS];

	struct fbnic_ring *rx[FBNIC_MAX_RXQS];



	struct fbnic_napi_vector *napi[FBNIC_MAX_NAPI_VECTORS];



	struct net_device *netdev;

	struct fbnic_dev *fbd;
@@ -56,13 +60,12 @@ struct fbnic_net { 


	/* Time stampinn filter config */

	struct kernel_hwtstamp_config hwtstamp_config;



	struct list_head napis;

};



int __fbnic_open(struct fbnic_net *fbn);

void fbnic_up(struct fbnic_net *fbn);

void fbnic_down(struct fbnic_net *fbn);

void fbnic_down_noidle(struct fbnic_net *fbn);



struct net_device *fbnic_netdev_alloc(struct fbnic_dev *fbd);

void fbnic_netdev_free(struct fbnic_dev *fbd);