From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alexander Lobakin Date: Fri, 28 Jan 2022 19:13:38 +0100 Subject: [Intel-wired-lan] [PATCH net-next 15/19] iecm: implement ethtool callbacks In-Reply-To: <20220128001009.721392-16-alan.brady@intel.com> References: <20220128001009.721392-1-alan.brady@intel.com> <20220128001009.721392-16-alan.brady@intel.com> Message-ID: <20220128181338.29738-1-alexandr.lobakin@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit To: intel-wired-lan@osuosl.org List-ID: From: Alan Brady Date: Thu, 27 Jan 2022 16:10:05 -0800 > This does everything needed to handle ethtool ops minus a few stubs for > cloud filters and other advanced features which will be added in later in > this series. > > Signed-off-by: Phani Burra > Signed-off-by: Joshua Hay > Signed-off-by: Madhu Chittim > Signed-off-by: Pavan Kumar Linga > Signed-off-by: Alan Brady > --- > drivers/net/ethernet/intel/iecm/Makefile | 1 + > .../net/ethernet/intel/iecm/iecm_ethtool.c | 1325 +++++++++++++++++ > drivers/net/ethernet/intel/iecm/iecm_lib.c | 11 +- > drivers/net/ethernet/intel/include/iecm.h | 1 + > 4 files changed, 1337 insertions(+), 1 deletion(-) > create mode 100644 drivers/net/ethernet/intel/iecm/iecm_ethtool.c > > diff --git a/drivers/net/ethernet/intel/iecm/Makefile b/drivers/net/ethernet/intel/iecm/Makefile > index 205d6f2b436a..fe2ed403d35c 100644 > --- a/drivers/net/ethernet/intel/iecm/Makefile > +++ b/drivers/net/ethernet/intel/iecm/Makefile > @@ -15,6 +15,7 @@ iecm-y := \ > iecm_virtchnl.o \ > iecm_txrx.o \ > iecm_singleq_txrx.o \ > + iecm_ethtool.o \ > iecm_controlq.o \ > iecm_controlq_setup.o \ > iecm_main.o > diff --git a/drivers/net/ethernet/intel/iecm/iecm_ethtool.c b/drivers/net/ethernet/intel/iecm/iecm_ethtool.c > new file mode 100644 > index 000000000000..32d905fb1bb6 > --- /dev/null > +++ b/drivers/net/ethernet/intel/iecm/iecm_ethtool.c > @@ -0,0 +1,1325 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* Copyright (C) 2019 Intel Corporation */ > + > +#include "iecm.h" > + > +/** > + * iecm_get_rxnfc - command to get RX flow classification rules > + * @netdev: network interface device structure > + * @cmd: ethtool rxnfc command > + * @rule_locs: pointer to store rule locations > + * > + * Returns Success if the command is supported. > + */ > +static int iecm_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd, > + u32 __always_unused *rule_locs) Kernel Kbuild system tell compilers to not complain on unused function arguments. It's pointless to add __always_unused here. > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + int ret = -EOPNOTSUPP; > + > + switch (cmd->cmd) { > + case ETHTOOL_GRXRINGS: > + cmd->data = vport->num_rxq; > + ret = 0; > + break; > + case ETHTOOL_GRXCLSRLCNT: > + /* stub */ > + ret = 0; > + break; > + case ETHTOOL_GRXCLSRULE: > + /* stub */ > + break; > + case ETHTOOL_GRXCLSRLALL: > + /* stub */ > + break; > + case ETHTOOL_GRXFH: > + /* stub */ > + break; > + default: > + break; > + } > + > + return ret; > +} > + > +/** > + * iecm_set_rxnfc - command to set Rx flow rules. > + * @netdev: network interface device structure > + * @cmd: ethtool rxnfc command > + * > + * Returns 0 for success and negative values for errors > + */ > +static int iecm_set_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd) > +{ > + int ret = -EOPNOTSUPP; > + > + switch (cmd->cmd) { > + case ETHTOOL_SRXCLSRLINS: > + /* stub */ > + break; > + case ETHTOOL_SRXCLSRLDEL: > + /* stub */ > + break; > + case ETHTOOL_SRXFH: > + /* stub */ > + break; > + default: > + break; > + } > + > + return ret; > +} > + > +/** > + * iecm_get_rxfh_key_size - get the RSS hash key size > + * @netdev: network interface device structure > + * > + * Returns the table size. > + */ > +static u32 iecm_get_rxfh_key_size(struct net_device *netdev) > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + > + if (!iecm_is_cap_ena_all(vport->adapter, IECM_RSS_CAPS, IECM_CAP_RSS)) { > + dev_info(&vport->adapter->pdev->dev, "RSS is not supported on this device\n"); > + return 0; > + } > + > + return vport->adapter->rss_data.rss_key_size; If you invert the condition, it would take less lines. > +} > + > +/** > + * iecm_get_rxfh_indir_size - get the rx flow hash indirection table size > + * @netdev: network interface device structure > + * > + * Returns the table size. > + */ > +static u32 iecm_get_rxfh_indir_size(struct net_device *netdev) > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + > + if (!iecm_is_cap_ena_all(vport->adapter, IECM_RSS_CAPS, IECM_CAP_RSS)) { > + dev_info(&vport->adapter->pdev->dev, "RSS is not supported on this device\n"); > + return 0; > + } > + > + return vport->adapter->rss_data.rss_lut_size; Same here. > +} > + > +/** > + * iecm_get_rxfh - get the rx flow hash indirection table > + * @netdev: network interface device structure > + * @indir: indirection table > + * @key: hash key > + * @hfunc: hash function in use > + * > + * Reads the indirection table directly from the hardware. Always returns 0. > + */ > +static int iecm_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key, > + u8 *hfunc) > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + struct iecm_adapter *adapter; > + u16 i; > + > + adapter = vport->adapter; > + > + if (!iecm_is_cap_ena_all(adapter, IECM_RSS_CAPS, IECM_CAP_RSS)) { > + dev_info(&vport->adapter->pdev->dev, "RSS is not supported on this device\n"); > + return 0; > + } > + > + if (adapter->state != __IECM_UP) > + return 0; > + > + if (hfunc) > + *hfunc = ETH_RSS_HASH_TOP; > + > + if (key) > + memcpy(key, adapter->rss_data.rss_key, > + adapter->rss_data.rss_key_size); > + > + if (indir) > + /* Each 32 bits pointed by 'indir' is stored with a lut entry */ > + for (i = 0; i < adapter->rss_data.rss_lut_size; i++) > + indir[i] = adapter->rss_data.rss_lut[i]; > + > + return 0; > +} > + > +/** > + * iecm_set_rxfh - set the rx flow hash indirection table > + * @netdev: network interface device structure > + * @indir: indirection table > + * @key: hash key > + * @hfunc: hash function to use > + * > + * Returns -EINVAL if the table specifies an invalid queue id, otherwise > + * returns 0 after programming the table. > + */ > +static int iecm_set_rxfh(struct net_device *netdev, const u32 *indir, > + const u8 *key, const u8 hfunc) > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + struct iecm_adapter *adapter; > + u16 lut; > + > + adapter = vport->adapter; > + > + if (!iecm_is_cap_ena_all(adapter, IECM_RSS_CAPS, IECM_CAP_RSS)) { > + dev_info(&adapter->pdev->dev, "RSS is not supported on this device\n"); > + return 0; > + } > + if (adapter->state != __IECM_UP) > + return 0; > + if (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP) > + return -EOPNOTSUPP; > + > + if (key) > + memcpy(adapter->rss_data.rss_key, key, > + adapter->rss_data.rss_key_size); > + > + if (indir) { > + for (lut = 0; lut < adapter->rss_data.rss_lut_size; lut++) > + adapter->rss_data.rss_lut[lut] = indir[lut]; > + } > + > + return iecm_config_rss(vport); > +} > + > +/** > + * iecm_get_channels: get the number of channels supported by the device > + * @netdev: network interface device structure > + * @ch: channel information structure > + * > + * Report maximum of TX and RX. Report one extra channel to match our MailBox > + * Queue. > + */ > +static void iecm_get_channels(struct net_device *netdev, > + struct ethtool_channels *ch) > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + unsigned int combined; > + int num_txq, num_rxq; > + > + num_txq = vport->adapter->config_data.num_req_tx_qs; > + num_rxq = vport->adapter->config_data.num_req_rx_qs; > + > + combined = min(num_txq, num_rxq); > + > + /* Report maximum channels */ > + ch->max_combined = vport->adapter->max_queue_limit; > + > + /* For now we've only enabled combined queues but will be enabling > + * asymmetric queues after splitq model is fleshed out more. > + */ > + ch->max_rx = 0; > + ch->max_tx = 0; > + > + ch->max_other = IECM_MAX_NONQ; > + ch->other_count = IECM_MAX_NONQ; > + > + ch->combined_count = combined; > + ch->rx_count = num_rxq - combined; > + ch->tx_count = num_txq - combined; > +} > + > +/** > + * iecm_set_channels: set the new channel count > + * @netdev: network interface device structure > + * @ch: channel information structure > + * > + * Negotiate a new number of channels with CP. Returns 0 on success, negative > + * on failure. > + */ > +static int iecm_set_channels(struct net_device *netdev, > + struct ethtool_channels *ch) > +{ > + unsigned int num_req_tx_q = ch->combined_count + ch->tx_count; > + unsigned int num_req_rx_q = ch->combined_count + ch->rx_count; > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + struct iecm_adapter *adapter = vport->adapter; > + int num_txq, num_rxq, err; > + > + if (num_req_tx_q == 0 || num_req_rx_q == 0) > + return -EINVAL; > + > + num_txq = vport->adapter->config_data.num_req_tx_qs; > + num_rxq = vport->adapter->config_data.num_req_rx_qs; > + > + if (num_req_tx_q == num_txq && num_req_rx_q == num_rxq) > + return 0; > + > + vport->adapter->config_data.num_req_tx_qs = num_req_tx_q; > + vport->adapter->config_data.num_req_rx_qs = num_req_rx_q; > + > + if (adapter->virt_ver_maj < VIRTCHNL_VERSION_MAJOR_2) { > + err = adapter->dev_ops.vc_ops.add_queues(vport, > + num_req_tx_q, 0, > + num_req_rx_q, 0); > + } else { > + err = iecm_initiate_soft_reset(vport, __IECM_SR_Q_CHANGE); > + } One-liners, no need for braces. > + > + if (err) { > + /* roll back queue change */ > + vport->adapter->config_data.num_req_tx_qs = num_txq; > + vport->adapter->config_data.num_req_rx_qs = num_rxq; > + } > + > + return err; > +} > + > +/** > + * iecm_get_ringparam - Get ring parameters > + * @netdev: network interface device structure > + * @ring: ethtool ringparam structure > + * @kring: unused > + * @ext_ack: unused > + * > + * Returns current ring parameters. TX and RX rings are reported separately, > + * but the number of rings is not reported. > + */ > +static void iecm_get_ringparam(struct net_device *netdev, > + struct ethtool_ringparam *ring, > + __always_unused struct kernel_ethtool_ringparam *kring, > + __always_unused struct netlink_ext_ack *ext_ack) Same here for __always_unused. +lines longer than 79. > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + > + ring->rx_max_pending = IECM_MAX_RXQ_DESC; > + ring->tx_max_pending = IECM_MAX_TXQ_DESC; > + ring->rx_pending = vport->rxq_desc_count; > + ring->tx_pending = vport->txq_desc_count; > +} > + > +/** > + * iecm_set_ringparam - Set ring parameters > + * @netdev: network interface device structure > + * @ring: ethtool ringparam structure > + * @kring: unused > + * @ext_ack: unused > + * > + * Sets ring parameters. TX and RX rings are controlled separately, but the > + * number of rings is not specified, so all rings get the same settings. > + */ > +static int iecm_set_ringparam(struct net_device *netdev, > + struct ethtool_ringparam *ring, > + __always_unused struct kernel_ethtool_ringparam *kring, > + __always_unused struct netlink_ext_ack *ext_ack) Same. > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + u32 new_rx_count, new_tx_count; > + int i; > + > + if (iecm_is_queue_model_split(vport->rxq_model)) > + /* When in splitq mode, any one RXQ needs to contain enough > + * descriptors to service the 2 buffer queues associated with > + * it. Since each buffer queue must be a multiple of 32, the > + * RXQ then needs to be a multiple of 64 to be divided into > + * multiples of 32 for each buffer queue > + */ > + new_rx_count = ALIGN(ring->rx_pending, > + IECM_REQ_SPLITQ_RXQ_DESC_MULTIPLE); > + else > + new_rx_count = ALIGN(ring->rx_pending, IECM_REQ_DESC_MULTIPLE); > + > + new_tx_count = ALIGN(ring->tx_pending, IECM_REQ_DESC_MULTIPLE); > + > + /* if nothing to do return success */ > + if (new_tx_count == vport->txq_desc_count && > + new_rx_count == vport->rxq_desc_count) > + return 0; > + > + vport->adapter->config_data.num_req_txq_desc = new_tx_count; > + vport->adapter->config_data.num_req_rxq_desc = new_rx_count; > + > + /* Since we adjusted the RX completion queue count, the RX buffer queue > + * descriptor count needs to be adjusted as well > + */ > + for (i = 0; i < vport->num_bufqs_per_qgrp; i++) > + vport->bufq_desc_count[i] = > + IECM_RX_BUFQ_DESC_COUNT(new_rx_count, > + vport->num_bufqs_per_qgrp); > + > + return iecm_initiate_soft_reset(vport, __IECM_SR_Q_DESC_CHANGE); > +} > + > +/** > + * struct iecm_stats - definition for an ethtool statistic > + * @stat_string: statistic name to display in ethtool -S output > + * @sizeof_stat: the sizeof() the stat, must be no greater than sizeof(u64) > + * @stat_offset: offsetof() the stat from a base pointer > + * > + * This structure defines a statistic to be added to the ethtool stats buffer. > + * It defines a statistic as offset from a common base pointer. Stats should > + * be defined in constant arrays using the IECM_STAT macro, with every element > + * of the array using the same _type for calculating the sizeof_stat and > + * stat_offset. > + * > + * The @sizeof_stat is expected to be sizeof(u8), sizeof(u16), sizeof(u32) or > + * sizeof(u64). Other sizes are not expected and will produce a WARN_ONCE from > + * the iecm_add_ethtool_stat() helper function. > + * > + * The @stat_string is interpreted as a format string, allowing formatted > + * values to be inserted while looping over multiple structures for a given > + * statistics array. Thus, every statistic string in an array should have the > + * same type and number of format specifiers, to be formatted by variadic > + * arguments to the iecm_add_stat_string() helper function. > + */ > +struct iecm_stats { > + char stat_string[ETH_GSTRING_LEN]; > + int sizeof_stat; > + int stat_offset; > +}; > + > +/* Helper macro to define an iecm_stat structure with proper size and type. > + * Use this when defining constant statistics arrays. Note that @_type expects > + * only a type name and is used multiple times. > + */ > +#define IECM_STAT(_type, _name, _stat) { \ > + .stat_string = _name, \ > + .sizeof_stat = sizeof_field(_type, _stat), \ > + .stat_offset = offsetof(_type, _stat) \ > +} > + > +/* Helper macro for defining some statistics related to queues */ > +#define IECM_QUEUE_STAT(_name, _stat) \ > + IECM_STAT(struct iecm_queue, _name, _stat) > + > +/* Stats associated with a Tx queue */ > +static const struct iecm_stats iecm_gstrings_tx_queue_stats[] = { > + IECM_QUEUE_STAT("packets", q_stats.tx.packets), > + IECM_QUEUE_STAT("bytes", q_stats.tx.bytes), > + IECM_QUEUE_STAT("lso_pkts", q_stats.tx.lso_pkts), > +}; > + > +/* Stats associated with an Rx queue */ > +static const struct iecm_stats iecm_gstrings_rx_queue_stats[] = { > + IECM_QUEUE_STAT("packets", q_stats.rx.packets), > + IECM_QUEUE_STAT("bytes", q_stats.rx.bytes), > + IECM_QUEUE_STAT("rsc_pkts", q_stats.rx.rsc_pkts), > +}; > + > +#define IECM_TX_QUEUE_STATS_LEN ARRAY_SIZE(iecm_gstrings_tx_queue_stats) > +#define IECM_RX_QUEUE_STATS_LEN ARRAY_SIZE(iecm_gstrings_rx_queue_stats) > + > +#define IECM_PORT_STAT(_name, _stat) \ > + IECM_STAT(struct iecm_vport, _name, _stat) > + > +static const struct iecm_stats iecm_gstrings_port_stats[] = { > + IECM_PORT_STAT("port-rx-csum_errors", port_stats.rx_hw_csum_err), > + IECM_PORT_STAT("port-rx-hsplit", port_stats.rx_hsplit), > + IECM_PORT_STAT("port-rx-hsplit_hbo", port_stats.rx_hsplit_hbo), > + IECM_PORT_STAT("tx-linearized_pkts", port_stats.tx_linearize), > + IECM_PORT_STAT("rx-bad_descs", port_stats.rx_bad_descs), > + IECM_PORT_STAT("port-rx_bytes", port_stats.eth_stats.rx_bytes), > + IECM_PORT_STAT("port-rx-unicast_pkts", port_stats.eth_stats.rx_unicast), > + IECM_PORT_STAT("port-rx-multicast_pkts", port_stats.eth_stats.rx_multicast), > + IECM_PORT_STAT("port-rx-broadcast_pkts", port_stats.eth_stats.rx_broadcast), > + IECM_PORT_STAT("port-rx-unknown_protocol", port_stats.eth_stats.rx_unknown_protocol), 94-cols line. > + IECM_PORT_STAT("port-tx_bytes", port_stats.eth_stats.tx_bytes), > + IECM_PORT_STAT("port-tx-unicast_pkts", port_stats.eth_stats.tx_unicast), > + IECM_PORT_STAT("port-tx-multicast_pkts", port_stats.eth_stats.tx_multicast), > + IECM_PORT_STAT("port-tx-broadcast_pkts", port_stats.eth_stats.tx_broadcast), > + IECM_PORT_STAT("port-tx_errors", port_stats.eth_stats.tx_errors), > +}; > + > +#define IECM_PORT_STATS_LEN ARRAY_SIZE(iecm_gstrings_port_stats) > + > +struct iecm_priv_flags { > + char flag_string[ETH_GSTRING_LEN]; > + bool read_only; > + u32 bitno; > +}; > + > +#define IECM_PRIV_FLAG(_name, _bitno, _read_only) { \ > + .read_only = _read_only, \ > + .flag_string = _name, \ > + .bitno = _bitno, \ > +} > + > +static const struct iecm_priv_flags iecm_gstrings_priv_flags[] = { > + IECM_PRIV_FLAG("header-split", __IECM_PRIV_FLAGS_HDR_SPLIT, 0), > +}; > + > +#define IECM_PRIV_FLAGS_STR_LEN ARRAY_SIZE(iecm_gstrings_priv_flags) > + > +/** > + * __iecm_add_qstat_strings - copy stat strings into ethtool buffer > + * @p: ethtool supplied buffer > + * @stats: stat definitions array > + * @size: size of the stats array > + * @type: stat type > + * @idx: stat index > + * > + * Format and copy the strings described by stats into the buffer pointed at > + * by p. > + */ > +static void __iecm_add_qstat_strings(u8 **p, const struct iecm_stats stats[], > + const unsigned int size, const char *type, > + unsigned int idx) > +{ > + unsigned int i; > + > + for (i = 0; i < size; i++) { > + snprintf((char *)*p, ETH_GSTRING_LEN, > + "%2s-%u.%.17s", type, idx, stats[i].stat_string); > + *p += ETH_GSTRING_LEN; > + } > +} > + > +/** > + * iecm_add_qstat_strings - Copy queue stat strings into ethtool buffer > + * @p: ethtool supplied buffer > + * @stats: stat definitions array > + * @type: stat type > + * @idx: stat idx > + * > + * Format and copy the strings described by the const static stats value into > + * the buffer pointed at by p. > + * > + * The parameter @stats is evaluated twice, so parameters with side effects > + * should be avoided. Additionally, stats must be an array such that > + * ARRAY_SIZE can be called on it. > + */ > +#define iecm_add_qstat_strings(p, stats, type, idx) \ > + __iecm_add_qstat_strings(p, stats, ARRAY_SIZE(stats), type, idx) > + > +/** > + * iecm_add_port_stat_strings - Copy port stat strings into ethtool buffer > + * @p: ethtool buffer > + * @stats: struct to copy from > + */ > +static void iecm_add_port_stat_strings(u8 **p, const struct iecm_stats stats[]) > +{ > + const unsigned int size = IECM_PORT_STATS_LEN; > + unsigned int i; > + > + for (i = 0; i < size; i++) { > + snprintf((char *)*p, ETH_GSTRING_LEN, "%.32s", > + stats[i].stat_string); > + *p += ETH_GSTRING_LEN; > + } > +} > + > +/** > + * iecm_get_stat_strings - Get stat strings > + * @netdev: network interface device structure > + * @data: buffer for string data > + * > + * Builds the statistics string table > + */ > +static void iecm_get_stat_strings(struct net_device *netdev, u8 *data) > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + unsigned int i; > + u16 max_q; > + > + iecm_add_port_stat_strings(&data, iecm_gstrings_port_stats); > + > + /* It's critical that we always report a constant number of strings and > + * that the strings are reported in the same order regardless of how > + * many queues are actually in use. > + */ > + max_q = vport->adapter->max_queue_limit; > + > + for (i = 0; i < max_q; i++) > + iecm_add_qstat_strings(&data, iecm_gstrings_tx_queue_stats, > + "tx", i); > + for (i = 0; i < max_q; i++) > + iecm_add_qstat_strings(&data, iecm_gstrings_rx_queue_stats, > + "rx", i); > +} > + > +/** > + * iecm_get_priv_flag_strings - Get private flag strings > + * @netdev: network interface device structure > + * @data: buffer for string data > + * > + * Builds the private flags string table > + */ > +static void iecm_get_priv_flag_strings(struct net_device *netdev, u8 *data) > +{ > + unsigned int i; > + > + for (i = 0; i < IECM_PRIV_FLAGS_STR_LEN; i++) { > + snprintf((char *)data, ETH_GSTRING_LEN, "%s", > + iecm_gstrings_priv_flags[i].flag_string); > + data += ETH_GSTRING_LEN; > + } > +} > + > +/** > + * iecm_get_priv_flags - report device private flags > + * @dev: network interface device structure > + * > + * The get string set count and the string set should be matched for each > + * flag returned. Add new strings for each flag to the iecm_gstrings_priv_flags > + * array. > + * > + * Returns a u32 bitmap of flags. > + **/ > +static u32 iecm_get_priv_flags(struct net_device *dev) > +{ > + struct iecm_netdev_priv *np = netdev_priv(dev); > + struct iecm_user_config_data *user_data; > + struct iecm_vport *vport = np->vport; > + u32 i, ret_flags = 0; > + > + user_data = &vport->adapter->config_data; > + > + for (i = 0; i < IECM_PRIV_FLAGS_STR_LEN; i++) { > + const struct iecm_priv_flags *priv_flag; > + > + priv_flag = &iecm_gstrings_priv_flags[i]; > + > + if (test_bit(priv_flag->bitno, user_data->user_flags)) > + ret_flags |= BIT(i); > + } > + > + return ret_flags; > +} > + > +/** > + * iecm_set_priv_flags - set private flags > + * @dev: network interface device structure > + * @flags: bit flags to be set > + **/ > +static int iecm_set_priv_flags(struct net_device *dev, u32 flags) > +{ > + struct iecm_netdev_priv *np = netdev_priv(dev); > + DECLARE_BITMAP(change_flags, __IECM_USER_FLAGS_NBITS); > + DECLARE_BITMAP(orig_flags, __IECM_USER_FLAGS_NBITS); RCT. > + struct iecm_user_config_data *user_data; > + struct iecm_vport *vport = np->vport; > + bool is_reset_needed; > + int err = 0; > + u32 i; > + > + if (flags > BIT(IECM_PRIV_FLAGS_STR_LEN)) > + return -EINVAL; > + > + user_data = &vport->adapter->config_data; > + > + bitmap_copy(orig_flags, user_data->user_flags, __IECM_USER_FLAGS_NBITS); > + > + for (i = 0; i < IECM_PRIV_FLAGS_STR_LEN; i++) { > + const struct iecm_priv_flags *priv_flag; > + > + priv_flag = &iecm_gstrings_priv_flags[i]; > + > + if (flags & BIT(i)) { > + /* If this is a read-only flag, it can't be changed */ > + if (priv_flag->read_only) > + return -EOPNOTSUPP; > + > + set_bit(priv_flag->bitno, user_data->user_flags); > + } else { > + clear_bit(priv_flag->bitno, user_data->user_flags); > + } > + } > + > + bitmap_xor(change_flags, user_data->user_flags, > + orig_flags, __IECM_USER_FLAGS_NBITS); > + > + is_reset_needed = > + !!(test_bit(__IECM_PRIV_FLAGS_HDR_SPLIT, change_flags)); Shorter name would allow avoiding line break. > + > + /* Issue reset to cause things to take effect, as additional bits > + * are added we will need to create a mask of bits requiring reset > + */ > + if (is_reset_needed) > + err = iecm_initiate_soft_reset(vport, __IECM_SR_HSPLIT_CHANGE); > + > + return err; > +} > + > +/** > + * iecm_get_strings - Get string set > + * @netdev: network interface device structure > + * @sset: id of string set > + * @data: buffer for string data > + * > + * Builds string tables for various string sets > + */ > +static void iecm_get_strings(struct net_device *netdev, u32 sset, u8 *data) > +{ > + switch (sset) { > + case ETH_SS_STATS: > + iecm_get_stat_strings(netdev, data); > + break; > + case ETH_SS_PRIV_FLAGS: > + iecm_get_priv_flag_strings(netdev, data); > + break; > + default: > + break; Equivalent to not having a 'default' case. > + } > +} > + > +/** > + * iecm_get_sset_count - Get length of string set > + * @netdev: network interface device structure > + * @sset: id of string set > + * > + * Reports size of various string tables. > + */ > +static > +int iecm_get_sset_count(struct net_device *netdev, int sset) > +{ > + if (sset == ETH_SS_STATS) { > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + u16 max_q; > + > + /* This size reported back here *must* be constant throughout > + * the lifecycle of the netdevice, i.e. we must report the > + * maximum length even for queues that don't technically exist. > + * This is due to the fact that this userspace API uses three > + * separate ioctl calls to get stats data but has no way to > + * communicate back to userspace when that size has changed, > + * which can typically happen as a result of changing number of > + * queues. If the number/order of stats change in the middle of > + * this call chain it will lead to userspace crashing/accessing > + * bad data through buffer under/overflow. > + */ > + max_q = vport->adapter->max_queue_limit; > + > + return IECM_PORT_STATS_LEN + > + (IECM_TX_QUEUE_STATS_LEN * max_q) + > + (IECM_RX_QUEUE_STATS_LEN * max_q); > + } else if (sset == ETH_SS_PRIV_FLAGS) { > + return IECM_PRIV_FLAGS_STR_LEN; > + } else { > + return -EINVAL; Check for this at first and save 1 level of indentation for ETH_SS_STATS. > + } > +} > + > +/** > + * iecm_add_one_ethtool_stat - copy the stat into the supplied buffer > + * @data: location to store the stat value > + * @pstat: old stat pointer to copy from > + * @stat: the stat definition > + * > + * Copies the stat data defined by the pointer and stat structure pair into > + * the memory supplied as data. Used to implement iecm_add_ethtool_stats and > + * iecm_add_queue_stats. If the pointer is null, data will be zero'd. > + */ > +static void > +iecm_add_one_ethtool_stat(u64 *data, void *pstat, > + const struct iecm_stats *stat) > +{ > + char *p; > + > + if (!pstat) { > + /* Ensure that the ethtool data buffer is zero'd for any stats > + * which don't have a valid pointer. > + */ > + *data = 0; > + return; > + } > + > + p = (char *)pstat + stat->stat_offset; > + switch (stat->sizeof_stat) { > + case sizeof(u64): > + *data = *((u64 *)p); > + break; > + case sizeof(u32): > + *data = *((u32 *)p); > + break; > + case sizeof(u16): > + *data = *((u16 *)p); > + break; > + case sizeof(u8): > + *data = *((u8 *)p); > + break; > + default: > + WARN_ONCE(1, "unexpected stat size for %s", > + stat->stat_string); > + *data = 0; > + } > +} > + > +/** > + * iecm_add_queue_stats - copy queue statistics into supplied buffer > + * @data: ethtool stats buffer > + * @q: the queue to copy > + * > + * Queue statistics must be copied while protected by > + * u64_stats_fetch_begin_irq, so we can't directly use iecm_add_ethtool_stats. > + * Assumes that queue stats are defined in iecm_gstrings_queue_stats. If the > + * queue pointer is null, zero out the queue stat values and update the data > + * pointer. Otherwise safely copy the stats from the queue into the supplied > + * buffer and update the data pointer when finished. > + * > + * This function expects to be called while under rcu_read_lock(). > + */ > +static void > +iecm_add_queue_stats(u64 **data, struct iecm_queue *q) > +{ > + const struct iecm_stats *stats; > + unsigned int start; > + unsigned int size; > + unsigned int i; > + > + if (q->q_type == VIRTCHNL2_QUEUE_TYPE_RX) { > + size = IECM_RX_QUEUE_STATS_LEN; > + stats = iecm_gstrings_rx_queue_stats; > + } else { > + size = IECM_TX_QUEUE_STATS_LEN; > + stats = iecm_gstrings_tx_queue_stats; > + } > + > + /* To avoid invalid statistics values, ensure that we keep retrying > + * the copy until we get a consistent value according to > + * u64_stats_fetch_retry_irq. But first, make sure our queue is > + * non-null before attempting to access its syncp. > + */ > + do { > + start = u64_stats_fetch_begin_irq(&q->stats_sync); > + for (i = 0; i < size; i++) > + iecm_add_one_ethtool_stat(&(*data)[i], q, &stats[i]); > + } while (u64_stats_fetch_retry_irq(&q->stats_sync, start)); > + > + /* Once we successfully copy the stats in, update the data pointer */ > + *data += size; > +} > + > +/** > + * iecm_add_empty_queue_stats - Add stats for a non-existent queue > + * @data: pointer to data buffer > + * @qtype: type of data queue > + * > + * We must report a constant length of stats back to userspace regardless of > + * how many queues are actually in use because stats collection happens over > + * three separate ioctls and there's no way to notify userspace the size > + * changed between those calls. This adds empty to data to the stats since we > + * don't have a real queue to refer to for this stats slot. > + */ > +static void > +iecm_add_empty_queue_stats(u64 **data, u16 qtype) > +{ > + unsigned int i; > + int stats_len; > + > + if (qtype == VIRTCHNL2_QUEUE_TYPE_RX) > + stats_len = IECM_RX_QUEUE_STATS_LEN; > + else > + stats_len = IECM_TX_QUEUE_STATS_LEN; > + > + for (i = 0; i < stats_len; i++) > + (*data)[i] = 0; > + *data += stats_len; > +} > + > +/** > + * iecm_add_port_stats - Copy port stats into ethtool buffer > + * @vport: virtual port struct > + * @data: ethtool buffer to copy into > + */ > +static void iecm_add_port_stats(struct iecm_vport *vport, u64 **data) > +{ > + unsigned int size = IECM_PORT_STATS_LEN; > + unsigned int start; > + unsigned int i; > + > + /* To avoid invalid statistics values, ensure that we keep retrying > + * the copy until we get a consistent value according to > + * u64_stats_fetch_retry_irq. > + */ > + do { > + start = u64_stats_fetch_begin_irq(&vport->port_stats.stats_sync); > + for (i = 0; i < size; i++) { > + iecm_add_one_ethtool_stat(&(*data)[i], vport, > + &iecm_gstrings_port_stats[i]); > + } Redundant braces. > + } while (u64_stats_fetch_retry_irq(&vport->port_stats.stats_sync, start)); > + > + *data += size; > +} > + > +/** > + * iecm_get_ethtool_stats - report device statistics > + * @netdev: network interface device structure > + * @stats: ethtool statistics structure > + * @data: pointer to data buffer > + * > + * All statistics are added to the data buffer as an array of u64. > + */ > +static void iecm_get_ethtool_stats(struct net_device *netdev, > + struct ethtool_stats __always_unused *stats, Redundant __always_unused. > + u64 *data) > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + unsigned int total = 0; > + unsigned int i, j; > + u16 max_q, qtype; > + > + if (vport->adapter->state != __IECM_UP) > + return; > + > + set_bit(__IECM_MB_STATS_PENDING, vport->adapter->flags); > + > + max_q = vport->adapter->max_queue_limit; > + > + rcu_read_lock(); > + > + iecm_add_port_stats(vport, &data); > + > + for (i = 0; i < vport->num_txq_grp; i++) { > + struct iecm_txq_group *txq_grp = &vport->txq_grps[i]; > + > + qtype = VIRTCHNL2_QUEUE_TYPE_TX; > + > + for (j = 0; j < txq_grp->num_txq; j++, total++) { > + struct iecm_queue *txq = txq_grp->txqs[j]; > + > + if (!txq) > + iecm_add_empty_queue_stats(&data, qtype); > + else > + iecm_add_queue_stats(&data, txq); > + } > + } > + /* It is critical we provide a constant number of stats back to > + * userspace regardless of how many queues are actually in use because > + * there is no way to inform userspace the size has changed between > + * ioctl calls. This will fill in any missing stats with zero. > + */ > + for (; total < max_q; total++) > + iecm_add_empty_queue_stats(&data, VIRTCHNL2_QUEUE_TYPE_TX); > + total = 0; > + > + for (i = 0; i < vport->num_rxq_grp; i++) { > + struct iecm_rxq_group *rxq_grp = &vport->rxq_grps[i]; > + int num_rxq; > + > + qtype = VIRTCHNL2_QUEUE_TYPE_RX; > + > + if (iecm_is_queue_model_split(vport->rxq_model)) > + num_rxq = rxq_grp->splitq.num_rxq_sets; > + else > + num_rxq = rxq_grp->singleq.num_rxq; > + > + for (j = 0; j < num_rxq; j++, total++) { > + struct iecm_queue *rxq; > + > + if (iecm_is_queue_model_split(vport->rxq_model)) > + rxq = &rxq_grp->splitq.rxq_sets[j]->rxq; > + else > + rxq = rxq_grp->singleq.rxqs[j]; > + if (!rxq) > + iecm_add_empty_queue_stats(&data, qtype); > + else > + iecm_add_queue_stats(&data, rxq); > + } > + } > + for (; total < max_q; total++) > + iecm_add_empty_queue_stats(&data, VIRTCHNL2_QUEUE_TYPE_RX); > + rcu_read_unlock(); > +} > + > +/** > + * iecm_find_rxq - find rxq from q index > + * @vport: virtual port associated to queue > + * @q_num: q index used to find queue > + * > + * returns pointer to rx queue > + */ > +static struct iecm_queue * > +iecm_find_rxq(struct iecm_vport *vport, int q_num) > +{ > + struct iecm_queue *rxq; > + > + if (iecm_is_queue_model_split(vport->rxq_model)) { > + int q_grp, q_idx; > + > + q_grp = q_num / IECM_DFLT_SPLITQ_RXQ_PER_GROUP; > + q_idx = q_num % IECM_DFLT_SPLITQ_RXQ_PER_GROUP; > + > + rxq = &vport->rxq_grps[q_grp].splitq.rxq_sets[q_idx]->rxq; > + } else { > + rxq = vport->rxq_grps->singleq.rxqs[q_num]; > + } > + > + return rxq; > +} > + > +/** > + * iecm_find_txq - find txq from q index > + * @vport: virtual port associated to queue > + * @q_num: q index used to find queue > + * > + * returns pointer to tx queue > + */ > +static struct iecm_queue * > +iecm_find_txq(struct iecm_vport *vport, int q_num) > +{ > + struct iecm_queue *txq; > + > + if (iecm_is_queue_model_split(vport->txq_model)) { > + int q_grp = q_num / IECM_DFLT_SPLITQ_TXQ_PER_GROUP; > + > + txq = vport->txq_grps[q_grp].complq; > + } else { > + txq = vport->txqs[q_num]; > + } > + > + return txq; > +} > + > +/** > + * __iecm_get_q_coalesce - get ITR values for specific queue > + * @ec: ethtool structure to fill with driver's coalesce settings > + * @q: quuee of Rx or Tx > + */ > +static void > +__iecm_get_q_coalesce(struct ethtool_coalesce *ec, struct iecm_queue *q) > +{ > + if (q->q_type == VIRTCHNL2_QUEUE_TYPE_RX) { > + ec->use_adaptive_rx_coalesce = > + IECM_ITR_IS_DYNAMIC(q->q_vector->rx_intr_mode); > + ec->rx_coalesce_usecs = q->q_vector->rx_itr_value; > + } else { > + ec->use_adaptive_tx_coalesce = > + IECM_ITR_IS_DYNAMIC(q->q_vector->tx_intr_mode); > + ec->tx_coalesce_usecs = q->q_vector->tx_itr_value; > + } > +} > + > +/** > + * iecm_get_q_coalesce - get ITR values for specific queue > + * @netdev: pointer to the netdev associated with this query > + * @ec: coalesce settings to program the device with > + * @q_num: update ITR/INTRL (coalesce) settings for this queue number/index > + * > + * Return 0 on success, and negative on failure > + */ > +static int > +iecm_get_q_coalesce(struct net_device *netdev, struct ethtool_coalesce *ec, > + u32 q_num) > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + > + if (vport->adapter->state != __IECM_UP) > + return 0; > + > + if (q_num >= vport->num_rxq && q_num >= vport->num_txq) > + return -EINVAL; > + > + if (q_num < vport->num_rxq) { > + struct iecm_queue *rxq = iecm_find_rxq(vport, q_num); > + > + __iecm_get_q_coalesce(ec, rxq); > + } > + > + if (q_num < vport->num_txq) { > + struct iecm_queue *txq = iecm_find_txq(vport, q_num); > + > + __iecm_get_q_coalesce(ec, txq); > + } > + > + return 0; > +} > + > +/** > + * iecm_get_coalesce - get ITR values as requested by user > + * @netdev: pointer to the netdev associated with this query > + * @ec: coalesce settings to be filled > + * @kec: unused > + * @extack: unused > + * > + * Return 0 on success, and negative on failure > + */ > +static int > +iecm_get_coalesce(struct net_device *netdev, struct ethtool_coalesce *ec, > + struct kernel_ethtool_coalesce __always_unused *kec, > + struct netlink_ext_ack __always_unused *extack) __always_unused. > +{ > + /* Return coalesce based on queue number zero */ > + return iecm_get_q_coalesce(netdev, ec, 0); > +} > + > +/** > + * iecm_get_per_q_coalesce - get ITR values as requested by user > + * @netdev: pointer to the netdev associated with this query > + * @q_num: queue for which the itr values has to retrieved > + * @ec: coalesce settings to be filled > + * > + * Return 0 on success, and negative on failure > + */ > + > +static int > +iecm_get_per_q_coalesce(struct net_device *netdev, u32 q_num, > + struct ethtool_coalesce *ec) > +{ > + return iecm_get_q_coalesce(netdev, ec, q_num); > +} > + > +/** > + * __iecm_set_q_coalesce - set ITR values for specific queue > + * @ec: ethtool structure from user to update ITR settings > + * @q: queue for which itr values has to be set > + * > + * Returns 0 on success, negative otherwise. > + */ > +static int > +__iecm_set_q_coalesce(struct ethtool_coalesce *ec, struct iecm_queue *q) > +{ > + u32 use_adaptive_coalesce, coalesce_usecs; > + struct iecm_q_vector *qv = q->q_vector; > + struct iecm_vport *vport; > + bool is_dim_ena = false; > + > + vport = q->vport; > + if (q->q_type == VIRTCHNL2_QUEUE_TYPE_RX) { > + is_dim_ena = IECM_ITR_IS_DYNAMIC(qv->rx_intr_mode); > + use_adaptive_coalesce = ec->use_adaptive_rx_coalesce; > + coalesce_usecs = ec->rx_coalesce_usecs; > + } else { > + is_dim_ena = IECM_ITR_IS_DYNAMIC(qv->tx_intr_mode); > + use_adaptive_coalesce = ec->use_adaptive_tx_coalesce; > + coalesce_usecs = ec->tx_coalesce_usecs; > + } > + > + if (coalesce_usecs && use_adaptive_coalesce) { > + netdev_info(vport->netdev, "Cannot set coalesce usecs if adaptive enabled\n"); > + return -EINVAL; > + } > + > + if (is_dim_ena && use_adaptive_coalesce) > + return 0; > + > + if (coalesce_usecs > IECM_ITR_MAX) { > + netdev_info(vport->netdev, > + "Invalid value, %d-usecs range is 0-%d\n", > + coalesce_usecs, IECM_ITR_MAX); > + return -EINVAL; > + } > + > + if (coalesce_usecs % 2 != 0) { > + coalesce_usecs = coalesce_usecs & 0xFFFFFFFE; > + netdev_info(vport->netdev, "HW only supports even ITR values, ITR rounded to %d\n", > + coalesce_usecs); > + } > + > + if (q->q_type == VIRTCHNL2_QUEUE_TYPE_RX) { > + qv->rx_itr_value = coalesce_usecs; > + if (use_adaptive_coalesce) { > + qv->rx_intr_mode = IECM_ITR_DYNAMIC; > + } else { > + qv->rx_intr_mode = !IECM_ITR_DYNAMIC; > + iecm_vport_intr_write_itr(qv, qv->rx_itr_value, > + false); > + } > + } else { > + qv->tx_itr_value = coalesce_usecs; > + if (use_adaptive_coalesce) { > + qv->tx_intr_mode = IECM_ITR_DYNAMIC; > + } else { > + qv->tx_intr_mode = !IECM_ITR_DYNAMIC; > + iecm_vport_intr_write_itr(qv, qv->tx_itr_value, true); > + } > + } > + /* Update of static/dynamic itr will be taken care when interrupt is > + * fired > + */ > + return 0; > +} > + > +/** > + * iecm_set_q_coalesce - set ITR values for specific queue > + * @vport: vport associated to the queue that need updating > + * @ec: coalesce settings to program the device with > + * @q_num: update ITR/INTRL (coalesce) settings for this queue number/index > + * @is_rxq: is queue type rx > + * > + * Return 0 on success, and negative on failure > + */ > +static int > +iecm_set_q_coalesce(struct iecm_vport *vport, struct ethtool_coalesce *ec, > + int q_num, bool is_rxq) > +{ > + struct iecm_queue *q; > + > + if (is_rxq) > + q = iecm_find_rxq(vport, q_num); > + else > + q = iecm_find_txq(vport, q_num); > + > + if (q && __iecm_set_q_coalesce(ec, q)) > + return -EINVAL; > + > + return 0; > +} > + > +/** > + * iecm_set_coalesce - set ITR values as requested by user > + * @netdev: pointer to the netdev associated with this query > + * @ec: coalesce settings to program the device with > + * @kec: unused > + * @extack: unused > + * > + * Return 0 on success, and negative on failure > + */ > +static int > +iecm_set_coalesce(struct net_device *netdev, struct ethtool_coalesce *ec, > + struct kernel_ethtool_coalesce __always_unused *kec, > + struct netlink_ext_ack __always_unused *extack) > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + int i, err; > + > + if (vport->adapter->state != __IECM_UP) > + return 0; > + > + for (i = 0; i < vport->num_txq; i++) { > + err = iecm_set_q_coalesce(vport, ec, i, false); > + if (err) > + return err; > + } > + > + for (i = 0; i < vport->num_rxq; i++) { > + err = iecm_set_q_coalesce(vport, ec, i, true); > + if (err) > + return err; > + } > + return 0; > +} > + > +/** > + * iecm_set_per_q_coalesce - set ITR values as requested by user > + * @netdev: pointer to the netdev associated with this query > + * @q_num: queue for which the itr values has to be set > + * @ec: coalesce settings to program the device with > + * > + * Return 0 on success, and negative on failure > + */ > +static int > +iecm_set_per_q_coalesce(struct net_device *netdev, u32 q_num, > + struct ethtool_coalesce *ec) > +{ > + struct iecm_vport *vport = iecm_netdev_to_vport(netdev); > + int err; > + > + err = iecm_set_q_coalesce(vport, ec, q_num, false); > + if (!err) > + err = iecm_set_q_coalesce(vport, ec, q_num, true); > + > + return err; err = iecm_set_q_coalesce(vport, ec, q_num, false); if (err) return err; return iecm_set_q_coalesce(vport, ec, q_num, true); > +} > + > +/** > + * iecm_get_msglevel - Get debug message level > + * @netdev: network interface device structure > + * > + * Returns current debug message level. > + */ > +static u32 iecm_get_msglevel(struct net_device *netdev) > +{ > + struct iecm_adapter *adapter = iecm_netdev_to_adapter(netdev); > + > + return adapter->msg_enable; > +} > + > +/** > + * iecm_set_msglevel - Set debug message level > + * @netdev: network interface device structure > + * @data: message level > + * > + * Set current debug message level. Higher values cause the driver to > + * be noisier. > + */ > +static void iecm_set_msglevel(struct net_device *netdev, u32 data) > +{ > + struct iecm_adapter *adapter = iecm_netdev_to_adapter(netdev); > + > + adapter->msg_enable = data; > +} > + > +/** > + * iecm_get_link_ksettings - Get Link Speed and Duplex settings > + * @netdev: network interface device structure > + * @cmd: ethtool command > + * > + * Reports speed/duplex settings. > + **/ > +static int iecm_get_link_ksettings(struct net_device *netdev, > + struct ethtool_link_ksettings *cmd) > +{ > + struct iecm_netdev_priv *np = netdev_priv(netdev); > + struct iecm_adapter *adapter = np->vport->adapter; > + > + ethtool_link_ksettings_zero_link_mode(cmd, supported); > + cmd->base.autoneg = AUTONEG_DISABLE; > + cmd->base.port = PORT_NONE; > + cmd->base.duplex = DUPLEX_FULL; > + > + if (adapter->link_speed_mbps) { > + cmd->base.speed = adapter->link_speed_mbps; > + return 0; > + } > + > + /* Set speed and duplex */ > + switch (adapter->link_speed) { > + case VIRTCHNL_LINK_SPEED_40GB: > + cmd->base.speed = SPEED_40000; > + break; > + case VIRTCHNL_LINK_SPEED_25GB: > + cmd->base.speed = SPEED_25000; > + break; > + case VIRTCHNL_LINK_SPEED_20GB: > + cmd->base.speed = SPEED_20000; > + break; > + case VIRTCHNL_LINK_SPEED_10GB: > + cmd->base.speed = SPEED_10000; > + break; > + case VIRTCHNL_LINK_SPEED_1GB: > + cmd->base.speed = SPEED_1000; > + break; > + case VIRTCHNL_LINK_SPEED_100MB: > + cmd->base.speed = SPEED_100; > + break; > + default: > + break; > + } > + > + return 0; > +} > + > +static const struct ethtool_ops iecm_ethtool_ops = { > + .supported_coalesce_params = ETHTOOL_COALESCE_USECS | > + ETHTOOL_COALESCE_USE_ADAPTIVE, > + .get_msglevel = iecm_get_msglevel, > + .set_msglevel = iecm_set_msglevel, > + .get_coalesce = iecm_get_coalesce, > + .set_coalesce = iecm_set_coalesce, > + .get_per_queue_coalesce = iecm_get_per_q_coalesce, > + .set_per_queue_coalesce = iecm_set_per_q_coalesce, > + .get_ethtool_stats = iecm_get_ethtool_stats, > + .get_strings = iecm_get_strings, > + .get_sset_count = iecm_get_sset_count, > + .get_priv_flags = iecm_get_priv_flags, > + .set_priv_flags = iecm_set_priv_flags, > + .get_rxnfc = iecm_get_rxnfc, > + .set_rxnfc = iecm_set_rxnfc, > + .get_rxfh_key_size = iecm_get_rxfh_key_size, > + .get_rxfh_indir_size = iecm_get_rxfh_indir_size, > + .get_rxfh = iecm_get_rxfh, > + .set_rxfh = iecm_set_rxfh, > + .get_channels = iecm_get_channels, > + .set_channels = iecm_set_channels, > + .get_ringparam = iecm_get_ringparam, > + .set_ringparam = iecm_set_ringparam, > + .get_link_ksettings = iecm_get_link_ksettings, > +}; > + > +/** > + * iecm_set_ethtool_ops - Initialize ethtool ops struct > + * @netdev: network interface device structure > + * > + * Sets ethtool ops struct in our netdev so that ethtool can call > + * our functions. > + */ > +void iecm_set_ethtool_ops(struct net_device *netdev) > +{ > + netdev->ethtool_ops = &iecm_ethtool_ops; > +} Declaring @iecm_ethtool_ops as external and directly assigning it in iecm_cfg_netdev() would result in smaller code size than this. > diff --git a/drivers/net/ethernet/intel/iecm/iecm_lib.c b/drivers/net/ethernet/intel/iecm/iecm_lib.c > index cbde65f1c523..c5900723b018 100644 > --- a/drivers/net/ethernet/intel/iecm/iecm_lib.c > +++ b/drivers/net/ethernet/intel/iecm/iecm_lib.c > @@ -871,6 +871,7 @@ static int iecm_cfg_netdev(struct iecm_vport *vport) > netdev->hw_features |= dflt_features | offloads; > netdev->hw_enc_features |= dflt_features | offloads; > > + iecm_set_ethtool_ops(netdev); > SET_NETDEV_DEV(netdev, &adapter->pdev->dev); > > /* carrier off on init to avoid Tx hangs */ > @@ -1150,7 +1151,15 @@ iecm_vport_alloc(struct iecm_adapter *adapter, int vport_id) > */ > static void iecm_statistics_task(struct work_struct *work) > { > - /* stub */ > + struct iecm_adapter *adapter = container_of(work, > + struct iecm_adapter, > + stats_task.work); struct iecm_adapter *adapter; adapter = container_of(work, typeof(*adapter), stats_task.work); This fits into 79 without a line wrap. > + if (test_bit(__IECM_MB_STATS_PENDING, adapter->flags) && > + !test_bit(__IECM_HR_RESET_IN_PROG, adapter->flags)) > + adapter->dev_ops.vc_ops.get_stats_msg(adapter->vports[0]); > + > + queue_delayed_work(adapter->stats_wq, &adapter->stats_task, > + msecs_to_jiffies(1000)); > } > > /** > diff --git a/drivers/net/ethernet/intel/include/iecm.h b/drivers/net/ethernet/intel/include/iecm.h > index 97c9935b832d..d118da1ea8cd 100644 > --- a/drivers/net/ethernet/intel/include/iecm.h > +++ b/drivers/net/ethernet/intel/include/iecm.h > @@ -745,6 +745,7 @@ int iecm_recv_mb_msg(struct iecm_adapter *adapter, enum virtchnl_ops op, > void *msg, int msg_size); > int iecm_send_mb_msg(struct iecm_adapter *adapter, enum virtchnl_ops op, > u16 msg_size, u8 *msg); > +void iecm_set_ethtool_ops(struct net_device *netdev); > void iecm_vport_set_hsplit(struct iecm_vport *vport, bool ena); > void iecm_add_del_ether_addrs(struct iecm_vport *vport, bool add, bool async); > int iecm_set_promiscuous(struct iecm_adapter *adapter); > -- > 2.33.0 Thanks, Al