1// SPDX-License-Identifier: GPL-2.0-only 2/* Copyright (C) 2023 Intel Corporation */ 3 4#include "idpf.h" 5 6/** 7 * idpf_get_rxnfc - command to get RX flow classification rules 8 * @netdev: network interface device structure 9 * @cmd: ethtool rxnfc command 10 * @rule_locs: pointer to store rule locations 11 * 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 size 39 * @netdev: network interface device structure 40 * 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 size 58 * @netdev: network interface device structure 59 * 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 table 77 * @netdev: network interface device structure 78 * @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 table 122 * @netdev: network interface device structure 123 * @rxfh: pointer to param struct (indir, key, hfunc) 124 * @extack: extended ACK from the Netlink message 125 * 126 * Returns -EINVAL if the table specifies an invalid queue id, otherwise 127 * 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 device 178 * @netdev: network interface device structure 179 * @ch: channel information structure 180 * 181 * Report maximum of TX and RX. Report one extra channel to match our MailBox 182 * 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 count 215 * @netdev: network interface device structure 216 * @ch: channel information structure 217 * 218 * Negotiate a new number of channels with CP. Returns 0 on success, negative 219 * 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 u16 combined, num_txq, num_rxq; 226 unsigned int num_req_tx_q; 227 unsigned int num_req_rx_q; 228 struct idpf_vport *vport; 229 struct device *dev; 230 int err = 0; 231 u16 idx; 232 233 idpf_vport_ctrl_lock(netdev); 234 vport = idpf_netdev_to_vport(netdev); 235 236 idx = vport->idx; 237 vport_config = vport->adapter->vport_config[idx]; 238 239 num_txq = vport_config->user_config.num_req_tx_qs; 240 num_rxq = vport_config->user_config.num_req_rx_qs; 241 242 combined = min(num_txq, num_rxq); 243 244 /* these checks are for cases where user didn't specify a particular 245 * value on cmd line but we get non-zero value anyway via 246 * get_channels(); look at ethtool.c in ethtool repository (the user 247 * space part), particularly, do_schannels() routine 248 */ 249 if (ch->combined_count == combined) 250 ch->combined_count = 0; 251 if (ch->combined_count && ch->rx_count == num_rxq - combined) 252 ch->rx_count = 0; 253 if (ch->combined_count && ch->tx_count == num_txq - combined) 254 ch->tx_count = 0; 255 256 num_req_tx_q = ch->combined_count + ch->tx_count; 257 num_req_rx_q = ch->combined_count + ch->rx_count; 258 259 dev = &vport->adapter->pdev->dev; 260 /* It's possible to specify number of queues that exceeds max. 261 * Stack checks max combined_count and max [tx|rx]_count but not the 262 * max combined_count + [tx|rx]_count. These checks should catch that. 263 */ 264 if (num_req_tx_q > vport_config->max_q.max_txq) { 265 dev_info(dev, "Maximum TX queues is %d\n", 266 vport_config->max_q.max_txq); 267 err = -EINVAL; 268 goto unlock_mutex; 269 } 270 if (num_req_rx_q > vport_config->max_q.max_rxq) { 271 dev_info(dev, "Maximum RX queues is %d\n", 272 vport_config->max_q.max_rxq); 273 err = -EINVAL; 274 goto unlock_mutex; 275 } 276 277 if (num_req_tx_q == num_txq && num_req_rx_q == num_rxq) 278 goto unlock_mutex; 279 280 vport_config->user_config.num_req_tx_qs = num_req_tx_q; 281 vport_config->user_config.num_req_rx_qs = num_req_rx_q; 282 283 err = idpf_initiate_soft_reset(vport, IDPF_SR_Q_CHANGE); 284 if (err) { 285 /* roll back queue change */ 286 vport_config->user_config.num_req_tx_qs = num_txq; 287 vport_config->user_config.num_req_rx_qs = num_rxq; 288 } 289 290unlock_mutex: 291 idpf_vport_ctrl_unlock(netdev); 292 293 return err; 294} 295 296/** 297 * idpf_get_ringparam - Get ring parameters 298 * @netdev: network interface device structure 299 * @ring: ethtool ringparam structure 300 * @kring: unused 301 * @ext_ack: unused 302 * 303 * Returns current ring parameters. TX and RX rings are reported separately, 304 * but the number of rings is not reported. 305 */ 306static void idpf_get_ringparam(struct net_device *netdev, 307 struct ethtool_ringparam *ring, 308 struct kernel_ethtool_ringparam *kring, 309 struct netlink_ext_ack *ext_ack) 310{ 311 struct idpf_vport *vport; 312 313 idpf_vport_ctrl_lock(netdev); 314 vport = idpf_netdev_to_vport(netdev); 315 316 ring->rx_max_pending = IDPF_MAX_RXQ_DESC; 317 ring->tx_max_pending = IDPF_MAX_TXQ_DESC; 318 ring->rx_pending = vport->rxq_desc_count; 319 ring->tx_pending = vport->txq_desc_count; 320 321 kring->tcp_data_split = idpf_vport_get_hsplit(vport); 322 323 idpf_vport_ctrl_unlock(netdev); 324} 325 326/** 327 * idpf_set_ringparam - Set ring parameters 328 * @netdev: network interface device structure 329 * @ring: ethtool ringparam structure 330 * @kring: unused 331 * @ext_ack: unused 332 * 333 * Sets ring parameters. TX and RX rings are controlled separately, but the 334 * number of rings is not specified, so all rings get the same settings. 335 */ 336static int idpf_set_ringparam(struct net_device *netdev, 337 struct ethtool_ringparam *ring, 338 struct kernel_ethtool_ringparam *kring, 339 struct netlink_ext_ack *ext_ack) 340{ 341 struct idpf_vport_user_config_data *config_data; 342 u32 new_rx_count, new_tx_count; 343 struct idpf_vport *vport; 344 int i, err = 0; 345 u16 idx; 346 347 idpf_vport_ctrl_lock(netdev); 348 vport = idpf_netdev_to_vport(netdev); 349 350 idx = vport->idx; 351 352 if (ring->tx_pending < IDPF_MIN_TXQ_DESC) { 353 netdev_err(netdev, "Descriptors requested (Tx: %u) is less than min supported (%u)\n", 354 ring->tx_pending, 355 IDPF_MIN_TXQ_DESC); 356 err = -EINVAL; 357 goto unlock_mutex; 358 } 359 360 if (ring->rx_pending < IDPF_MIN_RXQ_DESC) { 361 netdev_err(netdev, "Descriptors requested (Rx: %u) is less than min supported (%u)\n", 362 ring->rx_pending, 363 IDPF_MIN_RXQ_DESC); 364 err = -EINVAL; 365 goto unlock_mutex; 366 } 367 368 new_rx_count = ALIGN(ring->rx_pending, IDPF_REQ_RXQ_DESC_MULTIPLE); 369 if (new_rx_count != ring->rx_pending) 370 netdev_info(netdev, "Requested Rx descriptor count rounded up to %u\n", 371 new_rx_count); 372 373 new_tx_count = ALIGN(ring->tx_pending, IDPF_REQ_DESC_MULTIPLE); 374 if (new_tx_count != ring->tx_pending) 375 netdev_info(netdev, "Requested Tx descriptor count rounded up to %u\n", 376 new_tx_count); 377 378 if (new_tx_count == vport->txq_desc_count && 379 new_rx_count == vport->rxq_desc_count) 380 goto unlock_mutex; 381 382 if (!idpf_vport_set_hsplit(vport, kring->tcp_data_split)) { 383 NL_SET_ERR_MSG_MOD(ext_ack, 384 "setting TCP data split is not supported"); 385 err = -EOPNOTSUPP; 386 387 goto unlock_mutex; 388 } 389 390 config_data = &vport->adapter->vport_config[idx]->user_config; 391 config_data->num_req_txq_desc = new_tx_count; 392 config_data->num_req_rxq_desc = new_rx_count; 393 394 /* Since we adjusted the RX completion queue count, the RX buffer queue 395 * descriptor count needs to be adjusted as well 396 */ 397 for (i = 0; i < vport->num_bufqs_per_qgrp; i++) 398 vport->bufq_desc_count[i] = 399 IDPF_RX_BUFQ_DESC_COUNT(new_rx_count, 400 vport->num_bufqs_per_qgrp); 401 402 err = idpf_initiate_soft_reset(vport, IDPF_SR_Q_DESC_CHANGE); 403 404unlock_mutex: 405 idpf_vport_ctrl_unlock(netdev); 406 407 return err; 408} 409 410/** 411 * struct idpf_stats - definition for an ethtool statistic 412 * @stat_string: statistic name to display in ethtool -S output 413 * @sizeof_stat: the sizeof() the stat, must be no greater than sizeof(u64) 414 * @stat_offset: offsetof() the stat from a base pointer 415 * 416 * This structure defines a statistic to be added to the ethtool stats buffer. 417 * It defines a statistic as offset from a common base pointer. Stats should 418 * be defined in constant arrays using the IDPF_STAT macro, with every element 419 * of the array using the same _type for calculating the sizeof_stat and 420 * stat_offset. 421 * 422 * The @sizeof_stat is expected to be sizeof(u8), sizeof(u16), sizeof(u32) or 423 * sizeof(u64). Other sizes are not expected and will produce a WARN_ONCE from 424 * the idpf_add_ethtool_stat() helper function. 425 * 426 * The @stat_string is interpreted as a format string, allowing formatted 427 * values to be inserted while looping over multiple structures for a given 428 * statistics array. Thus, every statistic string in an array should have the 429 * same type and number of format specifiers, to be formatted by variadic 430 * arguments to the idpf_add_stat_string() helper function. 431 */ 432struct idpf_stats { 433 char stat_string[ETH_GSTRING_LEN]; 434 int sizeof_stat; 435 int stat_offset; 436}; 437 438/* Helper macro to define an idpf_stat structure with proper size and type. 439 * Use this when defining constant statistics arrays. Note that @_type expects 440 * only a type name and is used multiple times. 441 */ 442#define IDPF_STAT(_type, _name, _stat) { \ 443 .stat_string = _name, \ 444 .sizeof_stat = sizeof_field(_type, _stat), \ 445 .stat_offset = offsetof(_type, _stat) \ 446} 447 448/* Helper macro for defining some statistics related to queues */ 449#define IDPF_QUEUE_STAT(_name, _stat) \ 450 IDPF_STAT(struct idpf_queue, _name, _stat) 451 452/* Stats associated with a Tx queue */ 453static const struct idpf_stats idpf_gstrings_tx_queue_stats[] = { 454 IDPF_QUEUE_STAT("pkts", q_stats.tx.packets), 455 IDPF_QUEUE_STAT("bytes", q_stats.tx.bytes), 456 IDPF_QUEUE_STAT("lso_pkts", q_stats.tx.lso_pkts), 457}; 458 459/* Stats associated with an Rx queue */ 460static const struct idpf_stats idpf_gstrings_rx_queue_stats[] = { 461 IDPF_QUEUE_STAT("pkts", q_stats.rx.packets), 462 IDPF_QUEUE_STAT("bytes", q_stats.rx.bytes), 463 IDPF_QUEUE_STAT("rx_gro_hw_pkts", q_stats.rx.rsc_pkts), 464}; 465 466#define IDPF_TX_QUEUE_STATS_LEN ARRAY_SIZE(idpf_gstrings_tx_queue_stats) 467#define IDPF_RX_QUEUE_STATS_LEN ARRAY_SIZE(idpf_gstrings_rx_queue_stats) 468 469#define IDPF_PORT_STAT(_name, _stat) \ 470 IDPF_STAT(struct idpf_vport, _name, _stat) 471 472static const struct idpf_stats idpf_gstrings_port_stats[] = { 473 IDPF_PORT_STAT("rx-csum_errors", port_stats.rx_hw_csum_err), 474 IDPF_PORT_STAT("rx-hsplit", port_stats.rx_hsplit), 475 IDPF_PORT_STAT("rx-hsplit_hbo", port_stats.rx_hsplit_hbo), 476 IDPF_PORT_STAT("rx-bad_descs", port_stats.rx_bad_descs), 477 IDPF_PORT_STAT("tx-skb_drops", port_stats.tx_drops), 478 IDPF_PORT_STAT("tx-dma_map_errs", port_stats.tx_dma_map_errs), 479 IDPF_PORT_STAT("tx-linearized_pkts", port_stats.tx_linearize), 480 IDPF_PORT_STAT("tx-busy_events", port_stats.tx_busy), 481 IDPF_PORT_STAT("rx-unicast_pkts", port_stats.vport_stats.rx_unicast), 482 IDPF_PORT_STAT("rx-multicast_pkts", port_stats.vport_stats.rx_multicast), 483 IDPF_PORT_STAT("rx-broadcast_pkts", port_stats.vport_stats.rx_broadcast), 484 IDPF_PORT_STAT("rx-unknown_protocol", port_stats.vport_stats.rx_unknown_protocol), 485 IDPF_PORT_STAT("tx-unicast_pkts", port_stats.vport_stats.tx_unicast), 486 IDPF_PORT_STAT("tx-multicast_pkts", port_stats.vport_stats.tx_multicast), 487 IDPF_PORT_STAT("tx-broadcast_pkts", port_stats.vport_stats.tx_broadcast), 488}; 489 490#define IDPF_PORT_STATS_LEN ARRAY_SIZE(idpf_gstrings_port_stats) 491 492/** 493 * __idpf_add_qstat_strings - copy stat strings into ethtool buffer 494 * @p: ethtool supplied buffer 495 * @stats: stat definitions array 496 * @size: size of the stats array 497 * @type: stat type 498 * @idx: stat index 499 * 500 * Format and copy the strings described by stats into the buffer pointed at 501 * by p. 502 */ 503static void __idpf_add_qstat_strings(u8 **p, const struct idpf_stats *stats, 504 const unsigned int size, const char *type, 505 unsigned int idx) 506{ 507 unsigned int i; 508 509 for (i = 0; i < size; i++) 510 ethtool_sprintf(p, "%s_q-%u_%s", 511 type, idx, stats[i].stat_string); 512} 513 514/** 515 * idpf_add_qstat_strings - Copy queue stat strings into ethtool buffer 516 * @p: ethtool supplied buffer 517 * @stats: stat definitions array 518 * @type: stat type 519 * @idx: stat idx 520 * 521 * Format and copy the strings described by the const static stats value into 522 * the buffer pointed at by p. 523 * 524 * The parameter @stats is evaluated twice, so parameters with side effects 525 * should be avoided. Additionally, stats must be an array such that 526 * ARRAY_SIZE can be called on it. 527 */ 528#define idpf_add_qstat_strings(p, stats, type, idx) \ 529 __idpf_add_qstat_strings(p, stats, ARRAY_SIZE(stats), type, idx) 530 531/** 532 * idpf_add_stat_strings - Copy port stat strings into ethtool buffer 533 * @p: ethtool buffer 534 * @stats: struct to copy from 535 * @size: size of stats array to copy from 536 */ 537static void idpf_add_stat_strings(u8 **p, const struct idpf_stats *stats, 538 const unsigned int size) 539{ 540 unsigned int i; 541 542 for (i = 0; i < size; i++) 543 ethtool_puts(p, stats[i].stat_string); 544} 545 546/** 547 * idpf_get_stat_strings - Get stat strings 548 * @netdev: network interface device structure 549 * @data: buffer for string data 550 * 551 * Builds the statistics string table 552 */ 553static void idpf_get_stat_strings(struct net_device *netdev, u8 *data) 554{ 555 struct idpf_netdev_priv *np = netdev_priv(netdev); 556 struct idpf_vport_config *vport_config; 557 unsigned int i; 558 559 idpf_add_stat_strings(&data, idpf_gstrings_port_stats, 560 IDPF_PORT_STATS_LEN); 561 562 vport_config = np->adapter->vport_config[np->vport_idx]; 563 /* It's critical that we always report a constant number of strings and 564 * that the strings are reported in the same order regardless of how 565 * many queues are actually in use. 566 */ 567 for (i = 0; i < vport_config->max_q.max_txq; i++) 568 idpf_add_qstat_strings(&data, idpf_gstrings_tx_queue_stats, 569 "tx", i); 570 571 for (i = 0; i < vport_config->max_q.max_rxq; i++) 572 idpf_add_qstat_strings(&data, idpf_gstrings_rx_queue_stats, 573 "rx", i); 574 575 page_pool_ethtool_stats_get_strings(data); 576} 577 578/** 579 * idpf_get_strings - Get string set 580 * @netdev: network interface device structure 581 * @sset: id of string set 582 * @data: buffer for string data 583 * 584 * Builds string tables for various string sets 585 */ 586static void idpf_get_strings(struct net_device *netdev, u32 sset, u8 *data) 587{ 588 switch (sset) { 589 case ETH_SS_STATS: 590 idpf_get_stat_strings(netdev, data); 591 break; 592 default: 593 break; 594 } 595} 596 597/** 598 * idpf_get_sset_count - Get length of string set 599 * @netdev: network interface device structure 600 * @sset: id of string set 601 * 602 * Reports size of various string tables. 603 */ 604static int idpf_get_sset_count(struct net_device *netdev, int sset) 605{ 606 struct idpf_netdev_priv *np = netdev_priv(netdev); 607 struct idpf_vport_config *vport_config; 608 u16 max_txq, max_rxq; 609 unsigned int size; 610 611 if (sset != ETH_SS_STATS) 612 return -EINVAL; 613 614 vport_config = np->adapter->vport_config[np->vport_idx]; 615 /* This size reported back here *must* be constant throughout the 616 * lifecycle of the netdevice, i.e. we must report the maximum length 617 * even for queues that don't technically exist. This is due to the 618 * fact that this userspace API uses three separate ioctl calls to get 619 * stats data but has no way to communicate back to userspace when that 620 * size has changed, which can typically happen as a result of changing 621 * number of queues. If the number/order of stats change in the middle 622 * of this call chain it will lead to userspace crashing/accessing bad 623 * data through buffer under/overflow. 624 */ 625 max_txq = vport_config->max_q.max_txq; 626 max_rxq = vport_config->max_q.max_rxq; 627 628 size = IDPF_PORT_STATS_LEN + (IDPF_TX_QUEUE_STATS_LEN * max_txq) + 629 (IDPF_RX_QUEUE_STATS_LEN * max_rxq); 630 size += page_pool_ethtool_stats_get_count(); 631 632 return size; 633} 634 635/** 636 * idpf_add_one_ethtool_stat - copy the stat into the supplied buffer 637 * @data: location to store the stat value 638 * @pstat: old stat pointer to copy from 639 * @stat: the stat definition 640 * 641 * Copies the stat data defined by the pointer and stat structure pair into 642 * the memory supplied as data. If the pointer is null, data will be zero'd. 643 */ 644static void idpf_add_one_ethtool_stat(u64 *data, void *pstat, 645 const struct idpf_stats *stat) 646{ 647 char *p; 648 649 if (!pstat) { 650 /* Ensure that the ethtool data buffer is zero'd for any stats 651 * which don't have a valid pointer. 652 */ 653 *data = 0; 654 return; 655 } 656 657 p = (char *)pstat + stat->stat_offset; 658 switch (stat->sizeof_stat) { 659 case sizeof(u64): 660 *data = *((u64 *)p); 661 break; 662 case sizeof(u32): 663 *data = *((u32 *)p); 664 break; 665 case sizeof(u16): 666 *data = *((u16 *)p); 667 break; 668 case sizeof(u8): 669 *data = *((u8 *)p); 670 break; 671 default: 672 WARN_ONCE(1, "unexpected stat size for %s", 673 stat->stat_string); 674 *data = 0; 675 } 676} 677 678/** 679 * idpf_add_queue_stats - copy queue statistics into supplied buffer 680 * @data: ethtool stats buffer 681 * @q: the queue to copy 682 * 683 * Queue statistics must be copied while protected by u64_stats_fetch_begin, 684 * so we can't directly use idpf_add_ethtool_stats. Assumes that queue stats 685 * are defined in idpf_gstrings_queue_stats. If the queue pointer is null, 686 * zero out the queue stat values and update the data pointer. Otherwise 687 * safely copy the stats from the queue into the supplied buffer and update 688 * the data pointer when finished. 689 * 690 * This function expects to be called while under rcu_read_lock(). 691 */ 692static void idpf_add_queue_stats(u64 **data, struct idpf_queue *q) 693{ 694 const struct idpf_stats *stats; 695 unsigned int start; 696 unsigned int size; 697 unsigned int i; 698 699 if (q->q_type == VIRTCHNL2_QUEUE_TYPE_RX) { 700 size = IDPF_RX_QUEUE_STATS_LEN; 701 stats = idpf_gstrings_rx_queue_stats; 702 } else { 703 size = IDPF_TX_QUEUE_STATS_LEN; 704 stats = idpf_gstrings_tx_queue_stats; 705 } 706 707 /* To avoid invalid statistics values, ensure that we keep retrying 708 * the copy until we get a consistent value according to 709 * u64_stats_fetch_retry. 710 */ 711 do { 712 start = u64_stats_fetch_begin(&q->stats_sync); 713 for (i = 0; i < size; i++) 714 idpf_add_one_ethtool_stat(&(*data)[i], q, &stats[i]); 715 } while (u64_stats_fetch_retry(&q->stats_sync, start)); 716 717 /* Once we successfully copy the stats in, update the data pointer */ 718 *data += size; 719} 720 721/** 722 * idpf_add_empty_queue_stats - Add stats for a non-existent queue 723 * @data: pointer to data buffer 724 * @qtype: type of data queue 725 * 726 * We must report a constant length of stats back to userspace regardless of 727 * how many queues are actually in use because stats collection happens over 728 * three separate ioctls and there's no way to notify userspace the size 729 * changed between those calls. This adds empty to data to the stats since we 730 * don't have a real queue to refer to for this stats slot. 731 */ 732static void idpf_add_empty_queue_stats(u64 **data, u16 qtype) 733{ 734 unsigned int i; 735 int stats_len; 736 737 if (qtype == VIRTCHNL2_QUEUE_TYPE_RX) 738 stats_len = IDPF_RX_QUEUE_STATS_LEN; 739 else 740 stats_len = IDPF_TX_QUEUE_STATS_LEN; 741 742 for (i = 0; i < stats_len; i++) 743 (*data)[i] = 0; 744 *data += stats_len; 745} 746 747/** 748 * idpf_add_port_stats - Copy port stats into ethtool buffer 749 * @vport: virtual port struct 750 * @data: ethtool buffer to copy into 751 */ 752static void idpf_add_port_stats(struct idpf_vport *vport, u64 **data) 753{ 754 unsigned int size = IDPF_PORT_STATS_LEN; 755 unsigned int start; 756 unsigned int i; 757 758 do { 759 start = u64_stats_fetch_begin(&vport->port_stats.stats_sync); 760 for (i = 0; i < size; i++) 761 idpf_add_one_ethtool_stat(&(*data)[i], vport, 762 &idpf_gstrings_port_stats[i]); 763 } while (u64_stats_fetch_retry(&vport->port_stats.stats_sync, start)); 764 765 *data += size; 766} 767 768/** 769 * idpf_collect_queue_stats - accumulate various per queue stats 770 * into port level stats 771 * @vport: pointer to vport struct 772 **/ 773static void idpf_collect_queue_stats(struct idpf_vport *vport) 774{ 775 struct idpf_port_stats *pstats = &vport->port_stats; 776 int i, j; 777 778 /* zero out port stats since they're actually tracked in per 779 * queue stats; this is only for reporting 780 */ 781 u64_stats_update_begin(&pstats->stats_sync); 782 u64_stats_set(&pstats->rx_hw_csum_err, 0); 783 u64_stats_set(&pstats->rx_hsplit, 0); 784 u64_stats_set(&pstats->rx_hsplit_hbo, 0); 785 u64_stats_set(&pstats->rx_bad_descs, 0); 786 u64_stats_set(&pstats->tx_linearize, 0); 787 u64_stats_set(&pstats->tx_busy, 0); 788 u64_stats_set(&pstats->tx_drops, 0); 789 u64_stats_set(&pstats->tx_dma_map_errs, 0); 790 u64_stats_update_end(&pstats->stats_sync); 791 792 for (i = 0; i < vport->num_rxq_grp; i++) { 793 struct idpf_rxq_group *rxq_grp = &vport->rxq_grps[i]; 794 u16 num_rxq; 795 796 if (idpf_is_queue_model_split(vport->rxq_model)) 797 num_rxq = rxq_grp->splitq.num_rxq_sets; 798 else 799 num_rxq = rxq_grp->singleq.num_rxq; 800 801 for (j = 0; j < num_rxq; j++) { 802 u64 hw_csum_err, hsplit, hsplit_hbo, bad_descs; 803 struct idpf_rx_queue_stats *stats; 804 struct idpf_queue *rxq; 805 unsigned int start; 806 807 if (idpf_is_queue_model_split(vport->rxq_model)) 808 rxq = &rxq_grp->splitq.rxq_sets[j]->rxq; 809 else 810 rxq = rxq_grp->singleq.rxqs[j]; 811 812 if (!rxq) 813 continue; 814 815 do { 816 start = u64_stats_fetch_begin(&rxq->stats_sync); 817 818 stats = &rxq->q_stats.rx; 819 hw_csum_err = u64_stats_read(&stats->hw_csum_err); 820 hsplit = u64_stats_read(&stats->hsplit_pkts); 821 hsplit_hbo = u64_stats_read(&stats->hsplit_buf_ovf); 822 bad_descs = u64_stats_read(&stats->bad_descs); 823 } while (u64_stats_fetch_retry(&rxq->stats_sync, start)); 824 825 u64_stats_update_begin(&pstats->stats_sync); 826 u64_stats_add(&pstats->rx_hw_csum_err, hw_csum_err); 827 u64_stats_add(&pstats->rx_hsplit, hsplit); 828 u64_stats_add(&pstats->rx_hsplit_hbo, hsplit_hbo); 829 u64_stats_add(&pstats->rx_bad_descs, bad_descs); 830 u64_stats_update_end(&pstats->stats_sync); 831 } 832 } 833 834 for (i = 0; i < vport->num_txq_grp; i++) { 835 struct idpf_txq_group *txq_grp = &vport->txq_grps[i]; 836 837 for (j = 0; j < txq_grp->num_txq; j++) { 838 u64 linearize, qbusy, skb_drops, dma_map_errs; 839 struct idpf_queue *txq = txq_grp->txqs[j]; 840 struct idpf_tx_queue_stats *stats; 841 unsigned int start; 842 843 if (!txq) 844 continue; 845 846 do { 847 start = u64_stats_fetch_begin(&txq->stats_sync); 848 849 stats = &txq->q_stats.tx; 850 linearize = u64_stats_read(&stats->linearize); 851 qbusy = u64_stats_read(&stats->q_busy); 852 skb_drops = u64_stats_read(&stats->skb_drops); 853 dma_map_errs = u64_stats_read(&stats->dma_map_errs); 854 } while (u64_stats_fetch_retry(&txq->stats_sync, start)); 855 856 u64_stats_update_begin(&pstats->stats_sync); 857 u64_stats_add(&pstats->tx_linearize, linearize); 858 u64_stats_add(&pstats->tx_busy, qbusy); 859 u64_stats_add(&pstats->tx_drops, skb_drops); 860 u64_stats_add(&pstats->tx_dma_map_errs, dma_map_errs); 861 u64_stats_update_end(&pstats->stats_sync); 862 } 863 } 864} 865 866/** 867 * idpf_get_ethtool_stats - report device statistics 868 * @netdev: network interface device structure 869 * @stats: ethtool statistics structure 870 * @data: pointer to data buffer 871 * 872 * All statistics are added to the data buffer as an array of u64. 873 */ 874static void idpf_get_ethtool_stats(struct net_device *netdev, 875 struct ethtool_stats __always_unused *stats, 876 u64 *data) 877{ 878 struct idpf_netdev_priv *np = netdev_priv(netdev); 879 struct idpf_vport_config *vport_config; 880 struct page_pool_stats pp_stats = { }; 881 struct idpf_vport *vport; 882 unsigned int total = 0; 883 unsigned int i, j; 884 bool is_splitq; 885 u16 qtype; 886 887 idpf_vport_ctrl_lock(netdev); 888 vport = idpf_netdev_to_vport(netdev); 889 890 if (np->state != __IDPF_VPORT_UP) { 891 idpf_vport_ctrl_unlock(netdev); 892 893 return; 894 } 895 896 rcu_read_lock(); 897 898 idpf_collect_queue_stats(vport); 899 idpf_add_port_stats(vport, &data); 900 901 for (i = 0; i < vport->num_txq_grp; i++) { 902 struct idpf_txq_group *txq_grp = &vport->txq_grps[i]; 903 904 qtype = VIRTCHNL2_QUEUE_TYPE_TX; 905 906 for (j = 0; j < txq_grp->num_txq; j++, total++) { 907 struct idpf_queue *txq = txq_grp->txqs[j]; 908 909 if (!txq) 910 idpf_add_empty_queue_stats(&data, qtype); 911 else 912 idpf_add_queue_stats(&data, txq); 913 } 914 } 915 916 vport_config = vport->adapter->vport_config[vport->idx]; 917 /* It is critical we provide a constant number of stats back to 918 * userspace regardless of how many queues are actually in use because 919 * there is no way to inform userspace the size has changed between 920 * ioctl calls. This will fill in any missing stats with zero. 921 */ 922 for (; total < vport_config->max_q.max_txq; total++) 923 idpf_add_empty_queue_stats(&data, VIRTCHNL2_QUEUE_TYPE_TX); 924 total = 0; 925 926 is_splitq = idpf_is_queue_model_split(vport->rxq_model); 927 928 for (i = 0; i < vport->num_rxq_grp; i++) { 929 struct idpf_rxq_group *rxq_grp = &vport->rxq_grps[i]; 930 u16 num_rxq; 931 932 qtype = VIRTCHNL2_QUEUE_TYPE_RX; 933 934 if (is_splitq) 935 num_rxq = rxq_grp->splitq.num_rxq_sets; 936 else 937 num_rxq = rxq_grp->singleq.num_rxq; 938 939 for (j = 0; j < num_rxq; j++, total++) { 940 struct idpf_queue *rxq; 941 942 if (is_splitq) 943 rxq = &rxq_grp->splitq.rxq_sets[j]->rxq; 944 else 945 rxq = rxq_grp->singleq.rxqs[j]; 946 if (!rxq) 947 idpf_add_empty_queue_stats(&data, qtype); 948 else 949 idpf_add_queue_stats(&data, rxq); 950 951 /* In splitq mode, don't get page pool stats here since 952 * the pools are attached to the buffer queues 953 */ 954 if (is_splitq) 955 continue; 956 957 if (rxq) 958 page_pool_get_stats(rxq->pp, &pp_stats); 959 } 960 } 961 962 for (i = 0; i < vport->num_rxq_grp; i++) { 963 for (j = 0; j < vport->num_bufqs_per_qgrp; j++) { 964 struct idpf_queue *rxbufq = 965 &vport->rxq_grps[i].splitq.bufq_sets[j].bufq; 966 967 page_pool_get_stats(rxbufq->pp, &pp_stats); 968 } 969 } 970 971 for (; total < vport_config->max_q.max_rxq; total++) 972 idpf_add_empty_queue_stats(&data, VIRTCHNL2_QUEUE_TYPE_RX); 973 974 page_pool_ethtool_stats_get(data, &pp_stats); 975 976 rcu_read_unlock(); 977 978 idpf_vport_ctrl_unlock(netdev); 979} 980 981/** 982 * idpf_find_rxq - find rxq from q index 983 * @vport: virtual port associated to queue 984 * @q_num: q index used to find queue 985 * 986 * returns pointer to rx queue 987 */ 988static struct idpf_queue *idpf_find_rxq(struct idpf_vport *vport, int q_num) 989{ 990 int q_grp, q_idx; 991 992 if (!idpf_is_queue_model_split(vport->rxq_model)) 993 return vport->rxq_grps->singleq.rxqs[q_num]; 994 995 q_grp = q_num / IDPF_DFLT_SPLITQ_RXQ_PER_GROUP; 996 q_idx = q_num % IDPF_DFLT_SPLITQ_RXQ_PER_GROUP; 997 998 return &vport->rxq_grps[q_grp].splitq.rxq_sets[q_idx]->rxq; 999} 1000 1001/** 1002 * idpf_find_txq - find txq from q index 1003 * @vport: virtual port associated to queue 1004 * @q_num: q index used to find queue 1005 * 1006 * returns pointer to tx queue 1007 */ 1008static struct idpf_queue *idpf_find_txq(struct idpf_vport *vport, int q_num) 1009{ 1010 int q_grp; 1011 1012 if (!idpf_is_queue_model_split(vport->txq_model)) 1013 return vport->txqs[q_num]; 1014 1015 q_grp = q_num / IDPF_DFLT_SPLITQ_TXQ_PER_GROUP; 1016 1017 return vport->txq_grps[q_grp].complq; 1018} 1019 1020/** 1021 * __idpf_get_q_coalesce - get ITR values for specific queue 1022 * @ec: ethtool structure to fill with driver's coalesce settings 1023 * @q: quuee of Rx or Tx 1024 */ 1025static void __idpf_get_q_coalesce(struct ethtool_coalesce *ec, 1026 struct idpf_queue *q) 1027{ 1028 if (q->q_type == VIRTCHNL2_QUEUE_TYPE_RX) { 1029 ec->use_adaptive_rx_coalesce = 1030 IDPF_ITR_IS_DYNAMIC(q->q_vector->rx_intr_mode); 1031 ec->rx_coalesce_usecs = q->q_vector->rx_itr_value; 1032 } else { 1033 ec->use_adaptive_tx_coalesce = 1034 IDPF_ITR_IS_DYNAMIC(q->q_vector->tx_intr_mode); 1035 ec->tx_coalesce_usecs = q->q_vector->tx_itr_value; 1036 } 1037} 1038 1039/** 1040 * idpf_get_q_coalesce - get ITR values for specific queue 1041 * @netdev: pointer to the netdev associated with this query 1042 * @ec: coalesce settings to program the device with 1043 * @q_num: update ITR/INTRL (coalesce) settings for this queue number/index 1044 * 1045 * Return 0 on success, and negative on failure 1046 */ 1047static int idpf_get_q_coalesce(struct net_device *netdev, 1048 struct ethtool_coalesce *ec, 1049 u32 q_num) 1050{ 1051 struct idpf_netdev_priv *np = netdev_priv(netdev); 1052 struct idpf_vport *vport; 1053 int err = 0; 1054 1055 idpf_vport_ctrl_lock(netdev); 1056 vport = idpf_netdev_to_vport(netdev); 1057 1058 if (np->state != __IDPF_VPORT_UP) 1059 goto unlock_mutex; 1060 1061 if (q_num >= vport->num_rxq && q_num >= vport->num_txq) { 1062 err = -EINVAL; 1063 goto unlock_mutex; 1064 } 1065 1066 if (q_num < vport->num_rxq) 1067 __idpf_get_q_coalesce(ec, idpf_find_rxq(vport, q_num)); 1068 1069 if (q_num < vport->num_txq) 1070 __idpf_get_q_coalesce(ec, idpf_find_txq(vport, q_num)); 1071 1072unlock_mutex: 1073 idpf_vport_ctrl_unlock(netdev); 1074 1075 return err; 1076} 1077 1078/** 1079 * idpf_get_coalesce - get ITR values as requested by user 1080 * @netdev: pointer to the netdev associated with this query 1081 * @ec: coalesce settings to be filled 1082 * @kec: unused 1083 * @extack: unused 1084 * 1085 * Return 0 on success, and negative on failure 1086 */ 1087static int idpf_get_coalesce(struct net_device *netdev, 1088 struct ethtool_coalesce *ec, 1089 struct kernel_ethtool_coalesce *kec, 1090 struct netlink_ext_ack *extack) 1091{ 1092 /* Return coalesce based on queue number zero */ 1093 return idpf_get_q_coalesce(netdev, ec, 0); 1094} 1095 1096/** 1097 * idpf_get_per_q_coalesce - get ITR values as requested by user 1098 * @netdev: pointer to the netdev associated with this query 1099 * @q_num: queue for which the itr values has to retrieved 1100 * @ec: coalesce settings to be filled 1101 * 1102 * Return 0 on success, and negative on failure 1103 */ 1104 1105static int idpf_get_per_q_coalesce(struct net_device *netdev, u32 q_num, 1106 struct ethtool_coalesce *ec) 1107{ 1108 return idpf_get_q_coalesce(netdev, ec, q_num); 1109} 1110 1111/** 1112 * __idpf_set_q_coalesce - set ITR values for specific queue 1113 * @ec: ethtool structure from user to update ITR settings 1114 * @q: queue for which itr values has to be set 1115 * @is_rxq: is queue type rx 1116 * 1117 * Returns 0 on success, negative otherwise. 1118 */ 1119static int __idpf_set_q_coalesce(struct ethtool_coalesce *ec, 1120 struct idpf_queue *q, bool is_rxq) 1121{ 1122 u32 use_adaptive_coalesce, coalesce_usecs; 1123 struct idpf_q_vector *qv = q->q_vector; 1124 bool is_dim_ena = false; 1125 u16 itr_val; 1126 1127 if (is_rxq) { 1128 is_dim_ena = IDPF_ITR_IS_DYNAMIC(qv->rx_intr_mode); 1129 use_adaptive_coalesce = ec->use_adaptive_rx_coalesce; 1130 coalesce_usecs = ec->rx_coalesce_usecs; 1131 itr_val = qv->rx_itr_value; 1132 } else { 1133 is_dim_ena = IDPF_ITR_IS_DYNAMIC(qv->tx_intr_mode); 1134 use_adaptive_coalesce = ec->use_adaptive_tx_coalesce; 1135 coalesce_usecs = ec->tx_coalesce_usecs; 1136 itr_val = qv->tx_itr_value; 1137 } 1138 if (coalesce_usecs != itr_val && use_adaptive_coalesce) { 1139 netdev_err(q->vport->netdev, "Cannot set coalesce usecs if adaptive enabled\n"); 1140 1141 return -EINVAL; 1142 } 1143 1144 if (is_dim_ena && use_adaptive_coalesce) 1145 return 0; 1146 1147 if (coalesce_usecs > IDPF_ITR_MAX) { 1148 netdev_err(q->vport->netdev, 1149 "Invalid value, %d-usecs range is 0-%d\n", 1150 coalesce_usecs, IDPF_ITR_MAX); 1151 1152 return -EINVAL; 1153 } 1154 1155 if (coalesce_usecs % 2) { 1156 coalesce_usecs--; 1157 netdev_info(q->vport->netdev, 1158 "HW only supports even ITR values, ITR rounded to %d\n", 1159 coalesce_usecs); 1160 } 1161 1162 if (is_rxq) { 1163 qv->rx_itr_value = coalesce_usecs; 1164 if (use_adaptive_coalesce) { 1165 qv->rx_intr_mode = IDPF_ITR_DYNAMIC; 1166 } else { 1167 qv->rx_intr_mode = !IDPF_ITR_DYNAMIC; 1168 idpf_vport_intr_write_itr(qv, qv->rx_itr_value, 1169 false); 1170 } 1171 } else { 1172 qv->tx_itr_value = coalesce_usecs; 1173 if (use_adaptive_coalesce) { 1174 qv->tx_intr_mode = IDPF_ITR_DYNAMIC; 1175 } else { 1176 qv->tx_intr_mode = !IDPF_ITR_DYNAMIC; 1177 idpf_vport_intr_write_itr(qv, qv->tx_itr_value, true); 1178 } 1179 } 1180 1181 /* Update of static/dynamic itr will be taken care when interrupt is 1182 * fired 1183 */ 1184 return 0; 1185} 1186 1187/** 1188 * idpf_set_q_coalesce - set ITR values for specific queue 1189 * @vport: vport associated to the queue that need updating 1190 * @ec: coalesce settings to program the device with 1191 * @q_num: update ITR/INTRL (coalesce) settings for this queue number/index 1192 * @is_rxq: is queue type rx 1193 * 1194 * Return 0 on success, and negative on failure 1195 */ 1196static int idpf_set_q_coalesce(struct idpf_vport *vport, 1197 struct ethtool_coalesce *ec, 1198 int q_num, bool is_rxq) 1199{ 1200 struct idpf_queue *q; 1201 1202 q = is_rxq ? idpf_find_rxq(vport, q_num) : idpf_find_txq(vport, q_num); 1203 1204 if (q && __idpf_set_q_coalesce(ec, q, is_rxq)) 1205 return -EINVAL; 1206 1207 return 0; 1208} 1209 1210/** 1211 * idpf_set_coalesce - set ITR values as requested by user 1212 * @netdev: pointer to the netdev associated with this query 1213 * @ec: coalesce settings to program the device with 1214 * @kec: unused 1215 * @extack: unused 1216 * 1217 * Return 0 on success, and negative on failure 1218 */ 1219static int idpf_set_coalesce(struct net_device *netdev, 1220 struct ethtool_coalesce *ec, 1221 struct kernel_ethtool_coalesce *kec, 1222 struct netlink_ext_ack *extack) 1223{ 1224 struct idpf_netdev_priv *np = netdev_priv(netdev); 1225 struct idpf_vport *vport; 1226 int i, err = 0; 1227 1228 idpf_vport_ctrl_lock(netdev); 1229 vport = idpf_netdev_to_vport(netdev); 1230 1231 if (np->state != __IDPF_VPORT_UP) 1232 goto unlock_mutex; 1233 1234 for (i = 0; i < vport->num_txq; i++) { 1235 err = idpf_set_q_coalesce(vport, ec, i, false); 1236 if (err) 1237 goto unlock_mutex; 1238 } 1239 1240 for (i = 0; i < vport->num_rxq; i++) { 1241 err = idpf_set_q_coalesce(vport, ec, i, true); 1242 if (err) 1243 goto unlock_mutex; 1244 } 1245 1246unlock_mutex: 1247 idpf_vport_ctrl_unlock(netdev); 1248 1249 return err; 1250} 1251 1252/** 1253 * idpf_set_per_q_coalesce - set ITR values as requested by user 1254 * @netdev: pointer to the netdev associated with this query 1255 * @q_num: queue for which the itr values has to be set 1256 * @ec: coalesce settings to program the device with 1257 * 1258 * Return 0 on success, and negative on failure 1259 */ 1260static int idpf_set_per_q_coalesce(struct net_device *netdev, u32 q_num, 1261 struct ethtool_coalesce *ec) 1262{ 1263 struct idpf_vport *vport; 1264 int err; 1265 1266 idpf_vport_ctrl_lock(netdev); 1267 vport = idpf_netdev_to_vport(netdev); 1268 1269 err = idpf_set_q_coalesce(vport, ec, q_num, false); 1270 if (err) { 1271 idpf_vport_ctrl_unlock(netdev); 1272 1273 return err; 1274 } 1275 1276 err = idpf_set_q_coalesce(vport, ec, q_num, true); 1277 1278 idpf_vport_ctrl_unlock(netdev); 1279 1280 return err; 1281} 1282 1283/** 1284 * idpf_get_msglevel - Get debug message level 1285 * @netdev: network interface device structure 1286 * 1287 * Returns current debug message level. 1288 */ 1289static u32 idpf_get_msglevel(struct net_device *netdev) 1290{ 1291 struct idpf_adapter *adapter = idpf_netdev_to_adapter(netdev); 1292 1293 return adapter->msg_enable; 1294} 1295 1296/** 1297 * idpf_set_msglevel - Set debug message level 1298 * @netdev: network interface device structure 1299 * @data: message level 1300 * 1301 * Set current debug message level. Higher values cause the driver to 1302 * be noisier. 1303 */ 1304static void idpf_set_msglevel(struct net_device *netdev, u32 data) 1305{ 1306 struct idpf_adapter *adapter = idpf_netdev_to_adapter(netdev); 1307 1308 adapter->msg_enable = data; 1309} 1310 1311/** 1312 * idpf_get_link_ksettings - Get Link Speed and Duplex settings 1313 * @netdev: network interface device structure 1314 * @cmd: ethtool command 1315 * 1316 * Reports speed/duplex settings. 1317 **/ 1318static int idpf_get_link_ksettings(struct net_device *netdev, 1319 struct ethtool_link_ksettings *cmd) 1320{ 1321 struct idpf_vport *vport; 1322 1323 idpf_vport_ctrl_lock(netdev); 1324 vport = idpf_netdev_to_vport(netdev); 1325 1326 ethtool_link_ksettings_zero_link_mode(cmd, supported); 1327 cmd->base.autoneg = AUTONEG_DISABLE; 1328 cmd->base.port = PORT_NONE; 1329 if (vport->link_up) { 1330 cmd->base.duplex = DUPLEX_FULL; 1331 cmd->base.speed = vport->link_speed_mbps; 1332 } else { 1333 cmd->base.duplex = DUPLEX_UNKNOWN; 1334 cmd->base.speed = SPEED_UNKNOWN; 1335 } 1336 1337 idpf_vport_ctrl_unlock(netdev); 1338 1339 return 0; 1340} 1341 1342static const struct ethtool_ops idpf_ethtool_ops = { 1343 .supported_coalesce_params = ETHTOOL_COALESCE_USECS | 1344 ETHTOOL_COALESCE_USE_ADAPTIVE, 1345 .supported_ring_params = ETHTOOL_RING_USE_TCP_DATA_SPLIT, 1346 .get_msglevel = idpf_get_msglevel, 1347 .set_msglevel = idpf_set_msglevel, 1348 .get_link = ethtool_op_get_link, 1349 .get_coalesce = idpf_get_coalesce, 1350 .set_coalesce = idpf_set_coalesce, 1351 .get_per_queue_coalesce = idpf_get_per_q_coalesce, 1352 .set_per_queue_coalesce = idpf_set_per_q_coalesce, 1353 .get_ethtool_stats = idpf_get_ethtool_stats, 1354 .get_strings = idpf_get_strings, 1355 .get_sset_count = idpf_get_sset_count, 1356 .get_channels = idpf_get_channels, 1357 .get_rxnfc = idpf_get_rxnfc, 1358 .get_rxfh_key_size = idpf_get_rxfh_key_size, 1359 .get_rxfh_indir_size = idpf_get_rxfh_indir_size, 1360 .get_rxfh = idpf_get_rxfh, 1361 .set_rxfh = idpf_set_rxfh, 1362 .set_channels = idpf_set_channels, 1363 .get_ringparam = idpf_get_ringparam, 1364 .set_ringparam = idpf_set_ringparam, 1365 .get_link_ksettings = idpf_get_link_ksettings, 1366}; 1367 1368/** 1369 * idpf_set_ethtool_ops - Initialize ethtool ops struct 1370 * @netdev: network interface device structure 1371 * 1372 * Sets ethtool ops struct in our netdev so that ethtool can call 1373 * our functions. 1374 */ 1375void idpf_set_ethtool_ops(struct net_device *netdev) 1376{ 1377 netdev->ethtool_ops = &idpf_ethtool_ops; 1378} 1379