1352 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/* Copyright (C) 2023 Intel Corporation */3 4#include "idpf.h"5 6/**7 * idpf_get_rxnfc - command to get RX flow classification rules8 * @netdev: network interface device structure9 * @cmd: ethtool rxnfc command10 * @rule_locs: pointer to store rule locations11 *12 * Returns Success if the command is supported.13 */14static int idpf_get_rxnfc(struct net_device *netdev, struct ethtool_rxnfc *cmd,15 u32 __always_unused *rule_locs)16{17 struct idpf_vport *vport;18 19 idpf_vport_ctrl_lock(netdev);20 vport = idpf_netdev_to_vport(netdev);21 22 switch (cmd->cmd) {23 case ETHTOOL_GRXRINGS:24 cmd->data = vport->num_rxq;25 idpf_vport_ctrl_unlock(netdev);26 27 return 0;28 default:29 break;30 }31 32 idpf_vport_ctrl_unlock(netdev);33 34 return -EOPNOTSUPP;35}36 37/**38 * idpf_get_rxfh_key_size - get the RSS hash key size39 * @netdev: network interface device structure40 *41 * Returns the key size on success, error value on failure.42 */43static u32 idpf_get_rxfh_key_size(struct net_device *netdev)44{45 struct idpf_netdev_priv *np = netdev_priv(netdev);46 struct idpf_vport_user_config_data *user_config;47 48 if (!idpf_is_cap_ena_all(np->adapter, IDPF_RSS_CAPS, IDPF_CAP_RSS))49 return -EOPNOTSUPP;50 51 user_config = &np->adapter->vport_config[np->vport_idx]->user_config;52 53 return user_config->rss_data.rss_key_size;54}55 56/**57 * idpf_get_rxfh_indir_size - get the rx flow hash indirection table size58 * @netdev: network interface device structure59 *60 * Returns the table size on success, error value on failure.61 */62static u32 idpf_get_rxfh_indir_size(struct net_device *netdev)63{64 struct idpf_netdev_priv *np = netdev_priv(netdev);65 struct idpf_vport_user_config_data *user_config;66 67 if (!idpf_is_cap_ena_all(np->adapter, IDPF_RSS_CAPS, IDPF_CAP_RSS))68 return -EOPNOTSUPP;69 70 user_config = &np->adapter->vport_config[np->vport_idx]->user_config;71 72 return user_config->rss_data.rss_lut_size;73}74 75/**76 * idpf_get_rxfh - get the rx flow hash indirection table77 * @netdev: network interface device structure78 * @rxfh: pointer to param struct (indir, key, hfunc)79 *80 * Reads the indirection table directly from the hardware. Always returns 0.81 */82static int idpf_get_rxfh(struct net_device *netdev,83 struct ethtool_rxfh_param *rxfh)84{85 struct idpf_netdev_priv *np = netdev_priv(netdev);86 struct idpf_rss_data *rss_data;87 struct idpf_adapter *adapter;88 int err = 0;89 u16 i;90 91 idpf_vport_ctrl_lock(netdev);92 93 adapter = np->adapter;94 95 if (!idpf_is_cap_ena_all(adapter, IDPF_RSS_CAPS, IDPF_CAP_RSS)) {96 err = -EOPNOTSUPP;97 goto unlock_mutex;98 }99 100 rss_data = &adapter->vport_config[np->vport_idx]->user_config.rss_data;101 if (np->state != __IDPF_VPORT_UP)102 goto unlock_mutex;103 104 rxfh->hfunc = ETH_RSS_HASH_TOP;105 106 if (rxfh->key)107 memcpy(rxfh->key, rss_data->rss_key, rss_data->rss_key_size);108 109 if (rxfh->indir) {110 for (i = 0; i < rss_data->rss_lut_size; i++)111 rxfh->indir[i] = rss_data->rss_lut[i];112 }113 114unlock_mutex:115 idpf_vport_ctrl_unlock(netdev);116 117 return err;118}119 120/**121 * idpf_set_rxfh - set the rx flow hash indirection table122 * @netdev: network interface device structure123 * @rxfh: pointer to param struct (indir, key, hfunc)124 * @extack: extended ACK from the Netlink message125 *126 * Returns -EINVAL if the table specifies an invalid queue id, otherwise127 * returns 0 after programming the table.128 */129static int idpf_set_rxfh(struct net_device *netdev,130 struct ethtool_rxfh_param *rxfh,131 struct netlink_ext_ack *extack)132{133 struct idpf_netdev_priv *np = netdev_priv(netdev);134 struct idpf_rss_data *rss_data;135 struct idpf_adapter *adapter;136 struct idpf_vport *vport;137 int err = 0;138 u16 lut;139 140 idpf_vport_ctrl_lock(netdev);141 vport = idpf_netdev_to_vport(netdev);142 143 adapter = vport->adapter;144 145 if (!idpf_is_cap_ena_all(adapter, IDPF_RSS_CAPS, IDPF_CAP_RSS)) {146 err = -EOPNOTSUPP;147 goto unlock_mutex;148 }149 150 rss_data = &adapter->vport_config[vport->idx]->user_config.rss_data;151 if (np->state != __IDPF_VPORT_UP)152 goto unlock_mutex;153 154 if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE &&155 rxfh->hfunc != ETH_RSS_HASH_TOP) {156 err = -EOPNOTSUPP;157 goto unlock_mutex;158 }159 160 if (rxfh->key)161 memcpy(rss_data->rss_key, rxfh->key, rss_data->rss_key_size);162 163 if (rxfh->indir) {164 for (lut = 0; lut < rss_data->rss_lut_size; lut++)165 rss_data->rss_lut[lut] = rxfh->indir[lut];166 }167 168 err = idpf_config_rss(vport);169 170unlock_mutex:171 idpf_vport_ctrl_unlock(netdev);172 173 return err;174}175 176/**177 * idpf_get_channels: get the number of channels supported by the device178 * @netdev: network interface device structure179 * @ch: channel information structure180 *181 * Report maximum of TX and RX. Report one extra channel to match our MailBox182 * Queue.183 */184static void idpf_get_channels(struct net_device *netdev,185 struct ethtool_channels *ch)186{187 struct idpf_netdev_priv *np = netdev_priv(netdev);188 struct idpf_vport_config *vport_config;189 u16 num_txq, num_rxq;190 u16 combined;191 192 vport_config = np->adapter->vport_config[np->vport_idx];193 194 num_txq = vport_config->user_config.num_req_tx_qs;195 num_rxq = vport_config->user_config.num_req_rx_qs;196 197 combined = min(num_txq, num_rxq);198 199 /* Report maximum channels */200 ch->max_combined = min_t(u16, vport_config->max_q.max_txq,201 vport_config->max_q.max_rxq);202 ch->max_rx = vport_config->max_q.max_rxq;203 ch->max_tx = vport_config->max_q.max_txq;204 205 ch->max_other = IDPF_MAX_MBXQ;206 ch->other_count = IDPF_MAX_MBXQ;207 208 ch->combined_count = combined;209 ch->rx_count = num_rxq - combined;210 ch->tx_count = num_txq - combined;211}212 213/**214 * idpf_set_channels: set the new channel count215 * @netdev: network interface device structure216 * @ch: channel information structure217 *218 * Negotiate a new number of channels with CP. Returns 0 on success, negative219 * on failure.220 */221static int idpf_set_channels(struct net_device *netdev,222 struct ethtool_channels *ch)223{224 struct idpf_vport_config *vport_config;225 unsigned int num_req_tx_q;226 unsigned int num_req_rx_q;227 struct idpf_vport *vport;228 u16 num_txq, num_rxq;229 struct device *dev;230 int err = 0;231 u16 idx;232 233 if (ch->rx_count && ch->tx_count) {234 netdev_err(netdev, "Dedicated RX or TX channels cannot be used simultaneously\n");235 return -EINVAL;236 }237 238 idpf_vport_ctrl_lock(netdev);239 vport = idpf_netdev_to_vport(netdev);240 241 idx = vport->idx;242 vport_config = vport->adapter->vport_config[idx];243 244 num_txq = vport_config->user_config.num_req_tx_qs;245 num_rxq = vport_config->user_config.num_req_rx_qs;246 247 num_req_tx_q = ch->combined_count + ch->tx_count;248 num_req_rx_q = ch->combined_count + ch->rx_count;249 250 dev = &vport->adapter->pdev->dev;251 /* It's possible to specify number of queues that exceeds max.252 * Stack checks max combined_count and max [tx|rx]_count but not the253 * max combined_count + [tx|rx]_count. These checks should catch that.254 */255 if (num_req_tx_q > vport_config->max_q.max_txq) {256 dev_info(dev, "Maximum TX queues is %d\n",257 vport_config->max_q.max_txq);258 err = -EINVAL;259 goto unlock_mutex;260 }261 if (num_req_rx_q > vport_config->max_q.max_rxq) {262 dev_info(dev, "Maximum RX queues is %d\n",263 vport_config->max_q.max_rxq);264 err = -EINVAL;265 goto unlock_mutex;266 }267 268 if (num_req_tx_q == num_txq && num_req_rx_q == num_rxq)269 goto unlock_mutex;270 271 vport_config->user_config.num_req_tx_qs = num_req_tx_q;272 vport_config->user_config.num_req_rx_qs = num_req_rx_q;273 274 err = idpf_initiate_soft_reset(vport, IDPF_SR_Q_CHANGE);275 if (err) {276 /* roll back queue change */277 vport_config->user_config.num_req_tx_qs = num_txq;278 vport_config->user_config.num_req_rx_qs = num_rxq;279 }280 281unlock_mutex:282 idpf_vport_ctrl_unlock(netdev);283 284 return err;285}286 287/**288 * idpf_get_ringparam - Get ring parameters289 * @netdev: network interface device structure290 * @ring: ethtool ringparam structure291 * @kring: unused292 * @ext_ack: unused293 *294 * Returns current ring parameters. TX and RX rings are reported separately,295 * but the number of rings is not reported.296 */297static void idpf_get_ringparam(struct net_device *netdev,298 struct ethtool_ringparam *ring,299 struct kernel_ethtool_ringparam *kring,300 struct netlink_ext_ack *ext_ack)301{302 struct idpf_vport *vport;303 304 idpf_vport_ctrl_lock(netdev);305 vport = idpf_netdev_to_vport(netdev);306 307 ring->rx_max_pending = IDPF_MAX_RXQ_DESC;308 ring->tx_max_pending = IDPF_MAX_TXQ_DESC;309 ring->rx_pending = vport->rxq_desc_count;310 ring->tx_pending = vport->txq_desc_count;311 312 kring->tcp_data_split = idpf_vport_get_hsplit(vport);313 314 idpf_vport_ctrl_unlock(netdev);315}316 317/**318 * idpf_set_ringparam - Set ring parameters319 * @netdev: network interface device structure320 * @ring: ethtool ringparam structure321 * @kring: unused322 * @ext_ack: unused323 *324 * Sets ring parameters. TX and RX rings are controlled separately, but the325 * number of rings is not specified, so all rings get the same settings.326 */327static int idpf_set_ringparam(struct net_device *netdev,328 struct ethtool_ringparam *ring,329 struct kernel_ethtool_ringparam *kring,330 struct netlink_ext_ack *ext_ack)331{332 struct idpf_vport_user_config_data *config_data;333 u32 new_rx_count, new_tx_count;334 struct idpf_vport *vport;335 int i, err = 0;336 u16 idx;337 338 idpf_vport_ctrl_lock(netdev);339 vport = idpf_netdev_to_vport(netdev);340 341 idx = vport->idx;342 343 if (ring->tx_pending < IDPF_MIN_TXQ_DESC) {344 netdev_err(netdev, "Descriptors requested (Tx: %u) is less than min supported (%u)\n",345 ring->tx_pending,346 IDPF_MIN_TXQ_DESC);347 err = -EINVAL;348 goto unlock_mutex;349 }350 351 if (ring->rx_pending < IDPF_MIN_RXQ_DESC) {352 netdev_err(netdev, "Descriptors requested (Rx: %u) is less than min supported (%u)\n",353 ring->rx_pending,354 IDPF_MIN_RXQ_DESC);355 err = -EINVAL;356 goto unlock_mutex;357 }358 359 new_rx_count = ALIGN(ring->rx_pending, IDPF_REQ_RXQ_DESC_MULTIPLE);360 if (new_rx_count != ring->rx_pending)361 netdev_info(netdev, "Requested Rx descriptor count rounded up to %u\n",362 new_rx_count);363 364 new_tx_count = ALIGN(ring->tx_pending, IDPF_REQ_DESC_MULTIPLE);365 if (new_tx_count != ring->tx_pending)366 netdev_info(netdev, "Requested Tx descriptor count rounded up to %u\n",367 new_tx_count);368 369 if (new_tx_count == vport->txq_desc_count &&370 new_rx_count == vport->rxq_desc_count &&371 kring->tcp_data_split == idpf_vport_get_hsplit(vport))372 goto unlock_mutex;373 374 if (!idpf_vport_set_hsplit(vport, kring->tcp_data_split)) {375 NL_SET_ERR_MSG_MOD(ext_ack,376 "setting TCP data split is not supported");377 err = -EOPNOTSUPP;378 379 goto unlock_mutex;380 }381 382 config_data = &vport->adapter->vport_config[idx]->user_config;383 config_data->num_req_txq_desc = new_tx_count;384 config_data->num_req_rxq_desc = new_rx_count;385 386 /* Since we adjusted the RX completion queue count, the RX buffer queue387 * descriptor count needs to be adjusted as well388 */389 for (i = 0; i < vport->num_bufqs_per_qgrp; i++)390 vport->bufq_desc_count[i] =391 IDPF_RX_BUFQ_DESC_COUNT(new_rx_count,392 vport->num_bufqs_per_qgrp);393 394 err = idpf_initiate_soft_reset(vport, IDPF_SR_Q_DESC_CHANGE);395 396unlock_mutex:397 idpf_vport_ctrl_unlock(netdev);398 399 return err;400}401 402/**403 * struct idpf_stats - definition for an ethtool statistic404 * @stat_string: statistic name to display in ethtool -S output405 * @sizeof_stat: the sizeof() the stat, must be no greater than sizeof(u64)406 * @stat_offset: offsetof() the stat from a base pointer407 *408 * This structure defines a statistic to be added to the ethtool stats buffer.409 * It defines a statistic as offset from a common base pointer. Stats should410 * be defined in constant arrays using the IDPF_STAT macro, with every element411 * of the array using the same _type for calculating the sizeof_stat and412 * stat_offset.413 *414 * The @sizeof_stat is expected to be sizeof(u8), sizeof(u16), sizeof(u32) or415 * sizeof(u64). Other sizes are not expected and will produce a WARN_ONCE from416 * the idpf_add_ethtool_stat() helper function.417 *418 * The @stat_string is interpreted as a format string, allowing formatted419 * values to be inserted while looping over multiple structures for a given420 * statistics array. Thus, every statistic string in an array should have the421 * same type and number of format specifiers, to be formatted by variadic422 * arguments to the idpf_add_stat_string() helper function.423 */424struct idpf_stats {425 char stat_string[ETH_GSTRING_LEN];426 int sizeof_stat;427 int stat_offset;428};429 430/* Helper macro to define an idpf_stat structure with proper size and type.431 * Use this when defining constant statistics arrays. Note that @_type expects432 * only a type name and is used multiple times.433 */434#define IDPF_STAT(_type, _name, _stat) { \435 .stat_string = _name, \436 .sizeof_stat = sizeof_field(_type, _stat), \437 .stat_offset = offsetof(_type, _stat) \438}439 440/* Helper macros for defining some statistics related to queues */441#define IDPF_RX_QUEUE_STAT(_name, _stat) \442 IDPF_STAT(struct idpf_rx_queue, _name, _stat)443#define IDPF_TX_QUEUE_STAT(_name, _stat) \444 IDPF_STAT(struct idpf_tx_queue, _name, _stat)445 446/* Stats associated with a Tx queue */447static const struct idpf_stats idpf_gstrings_tx_queue_stats[] = {448 IDPF_TX_QUEUE_STAT("pkts", q_stats.packets),449 IDPF_TX_QUEUE_STAT("bytes", q_stats.bytes),450 IDPF_TX_QUEUE_STAT("lso_pkts", q_stats.lso_pkts),451};452 453/* Stats associated with an Rx queue */454static const struct idpf_stats idpf_gstrings_rx_queue_stats[] = {455 IDPF_RX_QUEUE_STAT("pkts", q_stats.packets),456 IDPF_RX_QUEUE_STAT("bytes", q_stats.bytes),457 IDPF_RX_QUEUE_STAT("rx_gro_hw_pkts", q_stats.rsc_pkts),458};459 460#define IDPF_TX_QUEUE_STATS_LEN ARRAY_SIZE(idpf_gstrings_tx_queue_stats)461#define IDPF_RX_QUEUE_STATS_LEN ARRAY_SIZE(idpf_gstrings_rx_queue_stats)462 463#define IDPF_PORT_STAT(_name, _stat) \464 IDPF_STAT(struct idpf_vport, _name, _stat)465 466static const struct idpf_stats idpf_gstrings_port_stats[] = {467 IDPF_PORT_STAT("rx-csum_errors", port_stats.rx_hw_csum_err),468 IDPF_PORT_STAT("rx-hsplit", port_stats.rx_hsplit),469 IDPF_PORT_STAT("rx-hsplit_hbo", port_stats.rx_hsplit_hbo),470 IDPF_PORT_STAT("rx-bad_descs", port_stats.rx_bad_descs),471 IDPF_PORT_STAT("tx-skb_drops", port_stats.tx_drops),472 IDPF_PORT_STAT("tx-dma_map_errs", port_stats.tx_dma_map_errs),473 IDPF_PORT_STAT("tx-linearized_pkts", port_stats.tx_linearize),474 IDPF_PORT_STAT("tx-busy_events", port_stats.tx_busy),475 IDPF_PORT_STAT("rx-unicast_pkts", port_stats.vport_stats.rx_unicast),476 IDPF_PORT_STAT("rx-multicast_pkts", port_stats.vport_stats.rx_multicast),477 IDPF_PORT_STAT("rx-broadcast_pkts", port_stats.vport_stats.rx_broadcast),478 IDPF_PORT_STAT("rx-unknown_protocol", port_stats.vport_stats.rx_unknown_protocol),479 IDPF_PORT_STAT("tx-unicast_pkts", port_stats.vport_stats.tx_unicast),480 IDPF_PORT_STAT("tx-multicast_pkts", port_stats.vport_stats.tx_multicast),481 IDPF_PORT_STAT("tx-broadcast_pkts", port_stats.vport_stats.tx_broadcast),482};483 484#define IDPF_PORT_STATS_LEN ARRAY_SIZE(idpf_gstrings_port_stats)485 486/**487 * __idpf_add_qstat_strings - copy stat strings into ethtool buffer488 * @p: ethtool supplied buffer489 * @stats: stat definitions array490 * @size: size of the stats array491 * @type: stat type492 * @idx: stat index493 *494 * Format and copy the strings described by stats into the buffer pointed at495 * by p.496 */497static void __idpf_add_qstat_strings(u8 **p, const struct idpf_stats *stats,498 const unsigned int size, const char *type,499 unsigned int idx)500{501 unsigned int i;502 503 for (i = 0; i < size; i++)504 ethtool_sprintf(p, "%s_q-%u_%s",505 type, idx, stats[i].stat_string);506}507 508/**509 * idpf_add_qstat_strings - Copy queue stat strings into ethtool buffer510 * @p: ethtool supplied buffer511 * @stats: stat definitions array512 * @type: stat type513 * @idx: stat idx514 *515 * Format and copy the strings described by the const static stats value into516 * the buffer pointed at by p.517 *518 * The parameter @stats is evaluated twice, so parameters with side effects519 * should be avoided. Additionally, stats must be an array such that520 * ARRAY_SIZE can be called on it.521 */522#define idpf_add_qstat_strings(p, stats, type, idx) \523 __idpf_add_qstat_strings(p, stats, ARRAY_SIZE(stats), type, idx)524 525/**526 * idpf_add_stat_strings - Copy port stat strings into ethtool buffer527 * @p: ethtool buffer528 * @stats: struct to copy from529 * @size: size of stats array to copy from530 */531static void idpf_add_stat_strings(u8 **p, const struct idpf_stats *stats,532 const unsigned int size)533{534 unsigned int i;535 536 for (i = 0; i < size; i++)537 ethtool_puts(p, stats[i].stat_string);538}539 540/**541 * idpf_get_stat_strings - Get stat strings542 * @netdev: network interface device structure543 * @data: buffer for string data544 *545 * Builds the statistics string table546 */547static void idpf_get_stat_strings(struct net_device *netdev, u8 *data)548{549 struct idpf_netdev_priv *np = netdev_priv(netdev);550 struct idpf_vport_config *vport_config;551 unsigned int i;552 553 idpf_add_stat_strings(&data, idpf_gstrings_port_stats,554 IDPF_PORT_STATS_LEN);555 556 vport_config = np->adapter->vport_config[np->vport_idx];557 /* It's critical that we always report a constant number of strings and558 * that the strings are reported in the same order regardless of how559 * many queues are actually in use.560 */561 for (i = 0; i < vport_config->max_q.max_txq; i++)562 idpf_add_qstat_strings(&data, idpf_gstrings_tx_queue_stats,563 "tx", i);564 565 for (i = 0; i < vport_config->max_q.max_rxq; i++)566 idpf_add_qstat_strings(&data, idpf_gstrings_rx_queue_stats,567 "rx", i);568}569 570/**571 * idpf_get_strings - Get string set572 * @netdev: network interface device structure573 * @sset: id of string set574 * @data: buffer for string data575 *576 * Builds string tables for various string sets577 */578static void idpf_get_strings(struct net_device *netdev, u32 sset, u8 *data)579{580 switch (sset) {581 case ETH_SS_STATS:582 idpf_get_stat_strings(netdev, data);583 break;584 default:585 break;586 }587}588 589/**590 * idpf_get_sset_count - Get length of string set591 * @netdev: network interface device structure592 * @sset: id of string set593 *594 * Reports size of various string tables.595 */596static int idpf_get_sset_count(struct net_device *netdev, int sset)597{598 struct idpf_netdev_priv *np = netdev_priv(netdev);599 struct idpf_vport_config *vport_config;600 u16 max_txq, max_rxq;601 602 if (sset != ETH_SS_STATS)603 return -EINVAL;604 605 vport_config = np->adapter->vport_config[np->vport_idx];606 /* This size reported back here *must* be constant throughout the607 * lifecycle of the netdevice, i.e. we must report the maximum length608 * even for queues that don't technically exist. This is due to the609 * fact that this userspace API uses three separate ioctl calls to get610 * stats data but has no way to communicate back to userspace when that611 * size has changed, which can typically happen as a result of changing612 * number of queues. If the number/order of stats change in the middle613 * of this call chain it will lead to userspace crashing/accessing bad614 * data through buffer under/overflow.615 */616 max_txq = vport_config->max_q.max_txq;617 max_rxq = vport_config->max_q.max_rxq;618 619 return IDPF_PORT_STATS_LEN + (IDPF_TX_QUEUE_STATS_LEN * max_txq) +620 (IDPF_RX_QUEUE_STATS_LEN * max_rxq);621}622 623/**624 * idpf_add_one_ethtool_stat - copy the stat into the supplied buffer625 * @data: location to store the stat value626 * @pstat: old stat pointer to copy from627 * @stat: the stat definition628 *629 * Copies the stat data defined by the pointer and stat structure pair into630 * the memory supplied as data. If the pointer is null, data will be zero'd.631 */632static void idpf_add_one_ethtool_stat(u64 *data, const void *pstat,633 const struct idpf_stats *stat)634{635 char *p;636 637 if (!pstat) {638 /* Ensure that the ethtool data buffer is zero'd for any stats639 * which don't have a valid pointer.640 */641 *data = 0;642 return;643 }644 645 p = (char *)pstat + stat->stat_offset;646 switch (stat->sizeof_stat) {647 case sizeof(u64):648 *data = *((u64 *)p);649 break;650 case sizeof(u32):651 *data = *((u32 *)p);652 break;653 case sizeof(u16):654 *data = *((u16 *)p);655 break;656 case sizeof(u8):657 *data = *((u8 *)p);658 break;659 default:660 WARN_ONCE(1, "unexpected stat size for %s",661 stat->stat_string);662 *data = 0;663 }664}665 666/**667 * idpf_add_queue_stats - copy queue statistics into supplied buffer668 * @data: ethtool stats buffer669 * @q: the queue to copy670 * @type: type of the queue671 *672 * Queue statistics must be copied while protected by u64_stats_fetch_begin,673 * so we can't directly use idpf_add_ethtool_stats. Assumes that queue stats674 * are defined in idpf_gstrings_queue_stats. If the queue pointer is null,675 * zero out the queue stat values and update the data pointer. Otherwise676 * safely copy the stats from the queue into the supplied buffer and update677 * the data pointer when finished.678 *679 * This function expects to be called while under rcu_read_lock().680 */681static void idpf_add_queue_stats(u64 **data, const void *q,682 enum virtchnl2_queue_type type)683{684 const struct u64_stats_sync *stats_sync;685 const struct idpf_stats *stats;686 unsigned int start;687 unsigned int size;688 unsigned int i;689 690 if (type == VIRTCHNL2_QUEUE_TYPE_RX) {691 size = IDPF_RX_QUEUE_STATS_LEN;692 stats = idpf_gstrings_rx_queue_stats;693 stats_sync = &((const struct idpf_rx_queue *)q)->stats_sync;694 } else {695 size = IDPF_TX_QUEUE_STATS_LEN;696 stats = idpf_gstrings_tx_queue_stats;697 stats_sync = &((const struct idpf_tx_queue *)q)->stats_sync;698 }699 700 /* To avoid invalid statistics values, ensure that we keep retrying701 * the copy until we get a consistent value according to702 * u64_stats_fetch_retry.703 */704 do {705 start = u64_stats_fetch_begin(stats_sync);706 for (i = 0; i < size; i++)707 idpf_add_one_ethtool_stat(&(*data)[i], q, &stats[i]);708 } while (u64_stats_fetch_retry(stats_sync, start));709 710 /* Once we successfully copy the stats in, update the data pointer */711 *data += size;712}713 714/**715 * idpf_add_empty_queue_stats - Add stats for a non-existent queue716 * @data: pointer to data buffer717 * @qtype: type of data queue718 *719 * We must report a constant length of stats back to userspace regardless of720 * how many queues are actually in use because stats collection happens over721 * three separate ioctls and there's no way to notify userspace the size722 * changed between those calls. This adds empty to data to the stats since we723 * don't have a real queue to refer to for this stats slot.724 */725static void idpf_add_empty_queue_stats(u64 **data, u16 qtype)726{727 unsigned int i;728 int stats_len;729 730 if (qtype == VIRTCHNL2_QUEUE_TYPE_RX)731 stats_len = IDPF_RX_QUEUE_STATS_LEN;732 else733 stats_len = IDPF_TX_QUEUE_STATS_LEN;734 735 for (i = 0; i < stats_len; i++)736 (*data)[i] = 0;737 *data += stats_len;738}739 740/**741 * idpf_add_port_stats - Copy port stats into ethtool buffer742 * @vport: virtual port struct743 * @data: ethtool buffer to copy into744 */745static void idpf_add_port_stats(struct idpf_vport *vport, u64 **data)746{747 unsigned int size = IDPF_PORT_STATS_LEN;748 unsigned int start;749 unsigned int i;750 751 do {752 start = u64_stats_fetch_begin(&vport->port_stats.stats_sync);753 for (i = 0; i < size; i++)754 idpf_add_one_ethtool_stat(&(*data)[i], vport,755 &idpf_gstrings_port_stats[i]);756 } while (u64_stats_fetch_retry(&vport->port_stats.stats_sync, start));757 758 *data += size;759}760 761/**762 * idpf_collect_queue_stats - accumulate various per queue stats763 * into port level stats764 * @vport: pointer to vport struct765 **/766static void idpf_collect_queue_stats(struct idpf_vport *vport)767{768 struct idpf_port_stats *pstats = &vport->port_stats;769 int i, j;770 771 /* zero out port stats since they're actually tracked in per772 * queue stats; this is only for reporting773 */774 u64_stats_update_begin(&pstats->stats_sync);775 u64_stats_set(&pstats->rx_hw_csum_err, 0);776 u64_stats_set(&pstats->rx_hsplit, 0);777 u64_stats_set(&pstats->rx_hsplit_hbo, 0);778 u64_stats_set(&pstats->rx_bad_descs, 0);779 u64_stats_set(&pstats->tx_linearize, 0);780 u64_stats_set(&pstats->tx_busy, 0);781 u64_stats_set(&pstats->tx_drops, 0);782 u64_stats_set(&pstats->tx_dma_map_errs, 0);783 u64_stats_update_end(&pstats->stats_sync);784 785 for (i = 0; i < vport->num_rxq_grp; i++) {786 struct idpf_rxq_group *rxq_grp = &vport->rxq_grps[i];787 u16 num_rxq;788 789 if (idpf_is_queue_model_split(vport->rxq_model))790 num_rxq = rxq_grp->splitq.num_rxq_sets;791 else792 num_rxq = rxq_grp->singleq.num_rxq;793 794 for (j = 0; j < num_rxq; j++) {795 u64 hw_csum_err, hsplit, hsplit_hbo, bad_descs;796 struct idpf_rx_queue_stats *stats;797 struct idpf_rx_queue *rxq;798 unsigned int start;799 800 if (idpf_is_queue_model_split(vport->rxq_model))801 rxq = &rxq_grp->splitq.rxq_sets[j]->rxq;802 else803 rxq = rxq_grp->singleq.rxqs[j];804 805 if (!rxq)806 continue;807 808 do {809 start = u64_stats_fetch_begin(&rxq->stats_sync);810 811 stats = &rxq->q_stats;812 hw_csum_err = u64_stats_read(&stats->hw_csum_err);813 hsplit = u64_stats_read(&stats->hsplit_pkts);814 hsplit_hbo = u64_stats_read(&stats->hsplit_buf_ovf);815 bad_descs = u64_stats_read(&stats->bad_descs);816 } while (u64_stats_fetch_retry(&rxq->stats_sync, start));817 818 u64_stats_update_begin(&pstats->stats_sync);819 u64_stats_add(&pstats->rx_hw_csum_err, hw_csum_err);820 u64_stats_add(&pstats->rx_hsplit, hsplit);821 u64_stats_add(&pstats->rx_hsplit_hbo, hsplit_hbo);822 u64_stats_add(&pstats->rx_bad_descs, bad_descs);823 u64_stats_update_end(&pstats->stats_sync);824 }825 }826 827 for (i = 0; i < vport->num_txq_grp; i++) {828 struct idpf_txq_group *txq_grp = &vport->txq_grps[i];829 830 for (j = 0; j < txq_grp->num_txq; j++) {831 u64 linearize, qbusy, skb_drops, dma_map_errs;832 struct idpf_tx_queue *txq = txq_grp->txqs[j];833 struct idpf_tx_queue_stats *stats;834 unsigned int start;835 836 if (!txq)837 continue;838 839 do {840 start = u64_stats_fetch_begin(&txq->stats_sync);841 842 stats = &txq->q_stats;843 linearize = u64_stats_read(&stats->linearize);844 qbusy = u64_stats_read(&stats->q_busy);845 skb_drops = u64_stats_read(&stats->skb_drops);846 dma_map_errs = u64_stats_read(&stats->dma_map_errs);847 } while (u64_stats_fetch_retry(&txq->stats_sync, start));848 849 u64_stats_update_begin(&pstats->stats_sync);850 u64_stats_add(&pstats->tx_linearize, linearize);851 u64_stats_add(&pstats->tx_busy, qbusy);852 u64_stats_add(&pstats->tx_drops, skb_drops);853 u64_stats_add(&pstats->tx_dma_map_errs, dma_map_errs);854 u64_stats_update_end(&pstats->stats_sync);855 }856 }857}858 859/**860 * idpf_get_ethtool_stats - report device statistics861 * @netdev: network interface device structure862 * @stats: ethtool statistics structure863 * @data: pointer to data buffer864 *865 * All statistics are added to the data buffer as an array of u64.866 */867static void idpf_get_ethtool_stats(struct net_device *netdev,868 struct ethtool_stats __always_unused *stats,869 u64 *data)870{871 struct idpf_netdev_priv *np = netdev_priv(netdev);872 struct idpf_vport_config *vport_config;873 struct idpf_vport *vport;874 unsigned int total = 0;875 unsigned int i, j;876 bool is_splitq;877 u16 qtype;878 879 idpf_vport_ctrl_lock(netdev);880 vport = idpf_netdev_to_vport(netdev);881 882 if (np->state != __IDPF_VPORT_UP) {883 idpf_vport_ctrl_unlock(netdev);884 885 return;886 }887 888 rcu_read_lock();889 890 idpf_collect_queue_stats(vport);891 idpf_add_port_stats(vport, &data);892 893 for (i = 0; i < vport->num_txq_grp; i++) {894 struct idpf_txq_group *txq_grp = &vport->txq_grps[i];895 896 qtype = VIRTCHNL2_QUEUE_TYPE_TX;897 898 for (j = 0; j < txq_grp->num_txq; j++, total++) {899 struct idpf_tx_queue *txq = txq_grp->txqs[j];900 901 if (!txq)902 idpf_add_empty_queue_stats(&data, qtype);903 else904 idpf_add_queue_stats(&data, txq, qtype);905 }906 }907 908 vport_config = vport->adapter->vport_config[vport->idx];909 /* It is critical we provide a constant number of stats back to910 * userspace regardless of how many queues are actually in use because911 * there is no way to inform userspace the size has changed between912 * ioctl calls. This will fill in any missing stats with zero.913 */914 for (; total < vport_config->max_q.max_txq; total++)915 idpf_add_empty_queue_stats(&data, VIRTCHNL2_QUEUE_TYPE_TX);916 total = 0;917 918 is_splitq = idpf_is_queue_model_split(vport->rxq_model);919 920 for (i = 0; i < vport->num_rxq_grp; i++) {921 struct idpf_rxq_group *rxq_grp = &vport->rxq_grps[i];922 u16 num_rxq;923 924 qtype = VIRTCHNL2_QUEUE_TYPE_RX;925 926 if (is_splitq)927 num_rxq = rxq_grp->splitq.num_rxq_sets;928 else929 num_rxq = rxq_grp->singleq.num_rxq;930 931 for (j = 0; j < num_rxq; j++, total++) {932 struct idpf_rx_queue *rxq;933 934 if (is_splitq)935 rxq = &rxq_grp->splitq.rxq_sets[j]->rxq;936 else937 rxq = rxq_grp->singleq.rxqs[j];938 if (!rxq)939 idpf_add_empty_queue_stats(&data, qtype);940 else941 idpf_add_queue_stats(&data, rxq, qtype);942 }943 }944 945 for (; total < vport_config->max_q.max_rxq; total++)946 idpf_add_empty_queue_stats(&data, VIRTCHNL2_QUEUE_TYPE_RX);947 948 rcu_read_unlock();949 950 idpf_vport_ctrl_unlock(netdev);951}952 953/**954 * idpf_find_rxq_vec - find rxq vector from q index955 * @vport: virtual port associated to queue956 * @q_num: q index used to find queue957 *958 * returns pointer to rx vector959 */960static struct idpf_q_vector *idpf_find_rxq_vec(const struct idpf_vport *vport,961 int q_num)962{963 int q_grp, q_idx;964 965 if (!idpf_is_queue_model_split(vport->rxq_model))966 return vport->rxq_grps->singleq.rxqs[q_num]->q_vector;967 968 q_grp = q_num / IDPF_DFLT_SPLITQ_RXQ_PER_GROUP;969 q_idx = q_num % IDPF_DFLT_SPLITQ_RXQ_PER_GROUP;970 971 return vport->rxq_grps[q_grp].splitq.rxq_sets[q_idx]->rxq.q_vector;972}973 974/**975 * idpf_find_txq_vec - find txq vector from q index976 * @vport: virtual port associated to queue977 * @q_num: q index used to find queue978 *979 * returns pointer to tx vector980 */981static struct idpf_q_vector *idpf_find_txq_vec(const struct idpf_vport *vport,982 int q_num)983{984 int q_grp;985 986 if (!idpf_is_queue_model_split(vport->txq_model))987 return vport->txqs[q_num]->q_vector;988 989 q_grp = q_num / IDPF_DFLT_SPLITQ_TXQ_PER_GROUP;990 991 return vport->txq_grps[q_grp].complq->q_vector;992}993 994/**995 * __idpf_get_q_coalesce - get ITR values for specific queue996 * @ec: ethtool structure to fill with driver's coalesce settings997 * @q_vector: queue vector corresponding to this queue998 * @type: queue type999 */1000static void __idpf_get_q_coalesce(struct ethtool_coalesce *ec,1001 const struct idpf_q_vector *q_vector,1002 enum virtchnl2_queue_type type)1003{1004 if (type == VIRTCHNL2_QUEUE_TYPE_RX) {1005 ec->use_adaptive_rx_coalesce =1006 IDPF_ITR_IS_DYNAMIC(q_vector->rx_intr_mode);1007 ec->rx_coalesce_usecs = q_vector->rx_itr_value;1008 } else {1009 ec->use_adaptive_tx_coalesce =1010 IDPF_ITR_IS_DYNAMIC(q_vector->tx_intr_mode);1011 ec->tx_coalesce_usecs = q_vector->tx_itr_value;1012 }1013}1014 1015/**1016 * idpf_get_q_coalesce - get ITR values for specific queue1017 * @netdev: pointer to the netdev associated with this query1018 * @ec: coalesce settings to program the device with1019 * @q_num: update ITR/INTRL (coalesce) settings for this queue number/index1020 *1021 * Return 0 on success, and negative on failure1022 */1023static int idpf_get_q_coalesce(struct net_device *netdev,1024 struct ethtool_coalesce *ec,1025 u32 q_num)1026{1027 const struct idpf_netdev_priv *np = netdev_priv(netdev);1028 const struct idpf_vport *vport;1029 int err = 0;1030 1031 idpf_vport_ctrl_lock(netdev);1032 vport = idpf_netdev_to_vport(netdev);1033 1034 if (np->state != __IDPF_VPORT_UP)1035 goto unlock_mutex;1036 1037 if (q_num >= vport->num_rxq && q_num >= vport->num_txq) {1038 err = -EINVAL;1039 goto unlock_mutex;1040 }1041 1042 if (q_num < vport->num_rxq)1043 __idpf_get_q_coalesce(ec, idpf_find_rxq_vec(vport, q_num),1044 VIRTCHNL2_QUEUE_TYPE_RX);1045 1046 if (q_num < vport->num_txq)1047 __idpf_get_q_coalesce(ec, idpf_find_txq_vec(vport, q_num),1048 VIRTCHNL2_QUEUE_TYPE_TX);1049 1050unlock_mutex:1051 idpf_vport_ctrl_unlock(netdev);1052 1053 return err;1054}1055 1056/**1057 * idpf_get_coalesce - get ITR values as requested by user1058 * @netdev: pointer to the netdev associated with this query1059 * @ec: coalesce settings to be filled1060 * @kec: unused1061 * @extack: unused1062 *1063 * Return 0 on success, and negative on failure1064 */1065static int idpf_get_coalesce(struct net_device *netdev,1066 struct ethtool_coalesce *ec,1067 struct kernel_ethtool_coalesce *kec,1068 struct netlink_ext_ack *extack)1069{1070 /* Return coalesce based on queue number zero */1071 return idpf_get_q_coalesce(netdev, ec, 0);1072}1073 1074/**1075 * idpf_get_per_q_coalesce - get ITR values as requested by user1076 * @netdev: pointer to the netdev associated with this query1077 * @q_num: queue for which the itr values has to retrieved1078 * @ec: coalesce settings to be filled1079 *1080 * Return 0 on success, and negative on failure1081 */1082 1083static int idpf_get_per_q_coalesce(struct net_device *netdev, u32 q_num,1084 struct ethtool_coalesce *ec)1085{1086 return idpf_get_q_coalesce(netdev, ec, q_num);1087}1088 1089/**1090 * __idpf_set_q_coalesce - set ITR values for specific queue1091 * @ec: ethtool structure from user to update ITR settings1092 * @qv: queue vector for which itr values has to be set1093 * @is_rxq: is queue type rx1094 *1095 * Returns 0 on success, negative otherwise.1096 */1097static int __idpf_set_q_coalesce(const struct ethtool_coalesce *ec,1098 struct idpf_q_vector *qv, bool is_rxq)1099{1100 u32 use_adaptive_coalesce, coalesce_usecs;1101 bool is_dim_ena = false;1102 u16 itr_val;1103 1104 if (is_rxq) {1105 is_dim_ena = IDPF_ITR_IS_DYNAMIC(qv->rx_intr_mode);1106 use_adaptive_coalesce = ec->use_adaptive_rx_coalesce;1107 coalesce_usecs = ec->rx_coalesce_usecs;1108 itr_val = qv->rx_itr_value;1109 } else {1110 is_dim_ena = IDPF_ITR_IS_DYNAMIC(qv->tx_intr_mode);1111 use_adaptive_coalesce = ec->use_adaptive_tx_coalesce;1112 coalesce_usecs = ec->tx_coalesce_usecs;1113 itr_val = qv->tx_itr_value;1114 }1115 if (coalesce_usecs != itr_val && use_adaptive_coalesce) {1116 netdev_err(qv->vport->netdev, "Cannot set coalesce usecs if adaptive enabled\n");1117 1118 return -EINVAL;1119 }1120 1121 if (is_dim_ena && use_adaptive_coalesce)1122 return 0;1123 1124 if (coalesce_usecs > IDPF_ITR_MAX) {1125 netdev_err(qv->vport->netdev,1126 "Invalid value, %d-usecs range is 0-%d\n",1127 coalesce_usecs, IDPF_ITR_MAX);1128 1129 return -EINVAL;1130 }1131 1132 if (coalesce_usecs % 2) {1133 coalesce_usecs--;1134 netdev_info(qv->vport->netdev,1135 "HW only supports even ITR values, ITR rounded to %d\n",1136 coalesce_usecs);1137 }1138 1139 if (is_rxq) {1140 qv->rx_itr_value = coalesce_usecs;1141 if (use_adaptive_coalesce) {1142 qv->rx_intr_mode = IDPF_ITR_DYNAMIC;1143 } else {1144 qv->rx_intr_mode = !IDPF_ITR_DYNAMIC;1145 idpf_vport_intr_write_itr(qv, qv->rx_itr_value,1146 false);1147 }1148 } else {1149 qv->tx_itr_value = coalesce_usecs;1150 if (use_adaptive_coalesce) {1151 qv->tx_intr_mode = IDPF_ITR_DYNAMIC;1152 } else {1153 qv->tx_intr_mode = !IDPF_ITR_DYNAMIC;1154 idpf_vport_intr_write_itr(qv, qv->tx_itr_value, true);1155 }1156 }1157 1158 /* Update of static/dynamic itr will be taken care when interrupt is1159 * fired1160 */1161 return 0;1162}1163 1164/**1165 * idpf_set_q_coalesce - set ITR values for specific queue1166 * @vport: vport associated to the queue that need updating1167 * @ec: coalesce settings to program the device with1168 * @q_num: update ITR/INTRL (coalesce) settings for this queue number/index1169 * @is_rxq: is queue type rx1170 *1171 * Return 0 on success, and negative on failure1172 */1173static int idpf_set_q_coalesce(const struct idpf_vport *vport,1174 const struct ethtool_coalesce *ec,1175 int q_num, bool is_rxq)1176{1177 struct idpf_q_vector *qv;1178 1179 qv = is_rxq ? idpf_find_rxq_vec(vport, q_num) :1180 idpf_find_txq_vec(vport, q_num);1181 1182 if (qv && __idpf_set_q_coalesce(ec, qv, is_rxq))1183 return -EINVAL;1184 1185 return 0;1186}1187 1188/**1189 * idpf_set_coalesce - set ITR values as requested by user1190 * @netdev: pointer to the netdev associated with this query1191 * @ec: coalesce settings to program the device with1192 * @kec: unused1193 * @extack: unused1194 *1195 * Return 0 on success, and negative on failure1196 */1197static int idpf_set_coalesce(struct net_device *netdev,1198 struct ethtool_coalesce *ec,1199 struct kernel_ethtool_coalesce *kec,1200 struct netlink_ext_ack *extack)1201{1202 struct idpf_netdev_priv *np = netdev_priv(netdev);1203 struct idpf_vport *vport;1204 int i, err = 0;1205 1206 idpf_vport_ctrl_lock(netdev);1207 vport = idpf_netdev_to_vport(netdev);1208 1209 if (np->state != __IDPF_VPORT_UP)1210 goto unlock_mutex;1211 1212 for (i = 0; i < vport->num_txq; i++) {1213 err = idpf_set_q_coalesce(vport, ec, i, false);1214 if (err)1215 goto unlock_mutex;1216 }1217 1218 for (i = 0; i < vport->num_rxq; i++) {1219 err = idpf_set_q_coalesce(vport, ec, i, true);1220 if (err)1221 goto unlock_mutex;1222 }1223 1224unlock_mutex:1225 idpf_vport_ctrl_unlock(netdev);1226 1227 return err;1228}1229 1230/**1231 * idpf_set_per_q_coalesce - set ITR values as requested by user1232 * @netdev: pointer to the netdev associated with this query1233 * @q_num: queue for which the itr values has to be set1234 * @ec: coalesce settings to program the device with1235 *1236 * Return 0 on success, and negative on failure1237 */1238static int idpf_set_per_q_coalesce(struct net_device *netdev, u32 q_num,1239 struct ethtool_coalesce *ec)1240{1241 struct idpf_vport *vport;1242 int err;1243 1244 idpf_vport_ctrl_lock(netdev);1245 vport = idpf_netdev_to_vport(netdev);1246 1247 err = idpf_set_q_coalesce(vport, ec, q_num, false);1248 if (err) {1249 idpf_vport_ctrl_unlock(netdev);1250 1251 return err;1252 }1253 1254 err = idpf_set_q_coalesce(vport, ec, q_num, true);1255 1256 idpf_vport_ctrl_unlock(netdev);1257 1258 return err;1259}1260 1261/**1262 * idpf_get_msglevel - Get debug message level1263 * @netdev: network interface device structure1264 *1265 * Returns current debug message level.1266 */1267static u32 idpf_get_msglevel(struct net_device *netdev)1268{1269 struct idpf_adapter *adapter = idpf_netdev_to_adapter(netdev);1270 1271 return adapter->msg_enable;1272}1273 1274/**1275 * idpf_set_msglevel - Set debug message level1276 * @netdev: network interface device structure1277 * @data: message level1278 *1279 * Set current debug message level. Higher values cause the driver to1280 * be noisier.1281 */1282static void idpf_set_msglevel(struct net_device *netdev, u32 data)1283{1284 struct idpf_adapter *adapter = idpf_netdev_to_adapter(netdev);1285 1286 adapter->msg_enable = data;1287}1288 1289/**1290 * idpf_get_link_ksettings - Get Link Speed and Duplex settings1291 * @netdev: network interface device structure1292 * @cmd: ethtool command1293 *1294 * Reports speed/duplex settings.1295 **/1296static int idpf_get_link_ksettings(struct net_device *netdev,1297 struct ethtool_link_ksettings *cmd)1298{1299 struct idpf_netdev_priv *np = netdev_priv(netdev);1300 1301 ethtool_link_ksettings_zero_link_mode(cmd, supported);1302 cmd->base.autoneg = AUTONEG_DISABLE;1303 cmd->base.port = PORT_NONE;1304 if (netif_carrier_ok(netdev)) {1305 cmd->base.duplex = DUPLEX_FULL;1306 cmd->base.speed = np->link_speed_mbps;1307 } else {1308 cmd->base.duplex = DUPLEX_UNKNOWN;1309 cmd->base.speed = SPEED_UNKNOWN;1310 }1311 1312 return 0;1313}1314 1315static const struct ethtool_ops idpf_ethtool_ops = {1316 .supported_coalesce_params = ETHTOOL_COALESCE_USECS |1317 ETHTOOL_COALESCE_USE_ADAPTIVE,1318 .supported_ring_params = ETHTOOL_RING_USE_TCP_DATA_SPLIT,1319 .get_msglevel = idpf_get_msglevel,1320 .set_msglevel = idpf_set_msglevel,1321 .get_link = ethtool_op_get_link,1322 .get_coalesce = idpf_get_coalesce,1323 .set_coalesce = idpf_set_coalesce,1324 .get_per_queue_coalesce = idpf_get_per_q_coalesce,1325 .set_per_queue_coalesce = idpf_set_per_q_coalesce,1326 .get_ethtool_stats = idpf_get_ethtool_stats,1327 .get_strings = idpf_get_strings,1328 .get_sset_count = idpf_get_sset_count,1329 .get_channels = idpf_get_channels,1330 .get_rxnfc = idpf_get_rxnfc,1331 .get_rxfh_key_size = idpf_get_rxfh_key_size,1332 .get_rxfh_indir_size = idpf_get_rxfh_indir_size,1333 .get_rxfh = idpf_get_rxfh,1334 .set_rxfh = idpf_set_rxfh,1335 .set_channels = idpf_set_channels,1336 .get_ringparam = idpf_get_ringparam,1337 .set_ringparam = idpf_set_ringparam,1338 .get_link_ksettings = idpf_get_link_ksettings,1339};1340 1341/**1342 * idpf_set_ethtool_ops - Initialize ethtool ops struct1343 * @netdev: network interface device structure1344 *1345 * Sets ethtool ops struct in our netdev so that ethtool can call1346 * our functions.1347 */1348void idpf_set_ethtool_ops(struct net_device *netdev)1349{1350 netdev->ethtool_ops = &idpf_ethtool_ops;1351}1352