1 // SPDX-License-Identifier: GPL-2.0 2 /* Copyright (c) 2018 Intel Corporation */ 3 4 /* ethtool support for igc */ 5 #include <linux/if_vlan.h> 6 #include <linux/pm_runtime.h> 7 #include <linux/mdio.h> 8 9 #include "igc.h" 10 #include "igc_diag.h" 11 #include "igc_tsn.h" 12 13 /* forward declaration */ 14 struct igc_stats { 15 char stat_string[ETH_GSTRING_LEN]; 16 int sizeof_stat; 17 int stat_offset; 18 }; 19 20 #define IGC_STAT(_name, _stat) { \ 21 .stat_string = _name, \ 22 .sizeof_stat = sizeof_field(struct igc_adapter, _stat), \ 23 .stat_offset = offsetof(struct igc_adapter, _stat) \ 24 } 25 26 static const struct igc_stats igc_gstrings_stats[] = { 27 IGC_STAT("rx_packets", stats.gprc), 28 IGC_STAT("tx_packets", stats.gptc), 29 IGC_STAT("rx_bytes", stats.gorc), 30 IGC_STAT("tx_bytes", stats.gotc), 31 IGC_STAT("rx_broadcast", stats.bprc), 32 IGC_STAT("tx_broadcast", stats.bptc), 33 IGC_STAT("rx_multicast", stats.mprc), 34 IGC_STAT("tx_multicast", stats.mptc), 35 IGC_STAT("multicast", stats.mprc), 36 IGC_STAT("collisions", stats.colc), 37 IGC_STAT("rx_crc_errors", stats.crcerrs), 38 IGC_STAT("rx_no_buffer_count", stats.rnbc), 39 IGC_STAT("rx_missed_errors", stats.mpc), 40 IGC_STAT("tx_aborted_errors", stats.ecol), 41 IGC_STAT("tx_carrier_errors", stats.tncrs), 42 IGC_STAT("tx_window_errors", stats.latecol), 43 IGC_STAT("tx_abort_late_coll", stats.latecol), 44 IGC_STAT("tx_deferred_ok", stats.dc), 45 IGC_STAT("tx_single_coll_ok", stats.scc), 46 IGC_STAT("tx_multi_coll_ok", stats.mcc), 47 IGC_STAT("tx_timeout_count", tx_timeout_count), 48 IGC_STAT("rx_long_length_errors", stats.roc), 49 IGC_STAT("rx_short_length_errors", stats.ruc), 50 IGC_STAT("rx_align_errors", stats.algnerrc), 51 IGC_STAT("tx_tcp_seg_good", stats.tsctc), 52 IGC_STAT("tx_tcp_seg_failed", stats.tsctfc), 53 IGC_STAT("rx_flow_control_xon", stats.xonrxc), 54 IGC_STAT("rx_flow_control_xoff", stats.xoffrxc), 55 IGC_STAT("tx_flow_control_xon", stats.xontxc), 56 IGC_STAT("tx_flow_control_xoff", stats.xofftxc), 57 IGC_STAT("rx_long_byte_count", stats.gorc), 58 IGC_STAT("tx_dma_out_of_sync", stats.doosync), 59 IGC_STAT("tx_smbus", stats.mgptc), 60 IGC_STAT("rx_smbus", stats.mgprc), 61 IGC_STAT("dropped_smbus", stats.mgpdc), 62 IGC_STAT("os2bmc_rx_by_bmc", stats.o2bgptc), 63 IGC_STAT("os2bmc_tx_by_bmc", stats.b2ospc), 64 IGC_STAT("os2bmc_tx_by_host", stats.o2bspc), 65 IGC_STAT("os2bmc_rx_by_host", stats.b2ogprc), 66 IGC_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts), 67 IGC_STAT("tx_hwtstamp_skipped", tx_hwtstamp_skipped), 68 IGC_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared), 69 IGC_STAT("tx_lpi_counter", stats.tlpic), 70 IGC_STAT("rx_lpi_counter", stats.rlpic), 71 IGC_STAT("qbv_config_change_errors", qbv_config_change_errors), 72 }; 73 74 #define IGC_NETDEV_STAT(_net_stat) { \ 75 .stat_string = __stringify(_net_stat), \ 76 .sizeof_stat = sizeof_field(struct rtnl_link_stats64, _net_stat), \ 77 .stat_offset = offsetof(struct rtnl_link_stats64, _net_stat) \ 78 } 79 80 static const struct igc_stats igc_gstrings_net_stats[] = { 81 IGC_NETDEV_STAT(rx_errors), 82 IGC_NETDEV_STAT(tx_errors), 83 IGC_NETDEV_STAT(tx_dropped), 84 IGC_NETDEV_STAT(rx_length_errors), 85 IGC_NETDEV_STAT(rx_over_errors), 86 IGC_NETDEV_STAT(rx_frame_errors), 87 IGC_NETDEV_STAT(rx_fifo_errors), 88 IGC_NETDEV_STAT(tx_fifo_errors), 89 IGC_NETDEV_STAT(tx_heartbeat_errors) 90 }; 91 92 enum igc_diagnostics_results { 93 TEST_REG = 0, 94 TEST_EEP, 95 TEST_IRQ, 96 TEST_LOOP, 97 TEST_LINK 98 }; 99 100 static const char igc_gstrings_test[][ETH_GSTRING_LEN] = { 101 [TEST_REG] = "Register test (offline)", 102 [TEST_EEP] = "Eeprom test (offline)", 103 [TEST_IRQ] = "Interrupt test (offline)", 104 [TEST_LOOP] = "Loopback test (offline)", 105 [TEST_LINK] = "Link test (on/offline)" 106 }; 107 108 #define IGC_TEST_LEN (sizeof(igc_gstrings_test) / ETH_GSTRING_LEN) 109 110 #define IGC_GLOBAL_STATS_LEN \ 111 (sizeof(igc_gstrings_stats) / sizeof(struct igc_stats)) 112 #define IGC_NETDEV_STATS_LEN \ 113 (sizeof(igc_gstrings_net_stats) / sizeof(struct igc_stats)) 114 #define IGC_RX_QUEUE_STATS_LEN \ 115 (sizeof(struct igc_rx_queue_stats) / sizeof(u64)) 116 #define IGC_TX_QUEUE_STATS_LEN 3 /* packets, bytes, restart_queue */ 117 #define IGC_QUEUE_STATS_LEN \ 118 ((((struct igc_adapter *)netdev_priv(netdev))->num_rx_queues * \ 119 IGC_RX_QUEUE_STATS_LEN) + \ 120 (((struct igc_adapter *)netdev_priv(netdev))->num_tx_queues * \ 121 IGC_TX_QUEUE_STATS_LEN)) 122 #define IGC_STATS_LEN \ 123 (IGC_GLOBAL_STATS_LEN + IGC_NETDEV_STATS_LEN + IGC_QUEUE_STATS_LEN) 124 125 #define IGC_PRIV_FLAGS_LEGACY_RX BIT(0) 126 #define IGC_PRIV_FLAGS_REVERSE_TSN_TXQ_PRIO BIT(1) 127 static const char igc_priv_flags_strings[][ETH_GSTRING_LEN] = { 128 "legacy-rx", 129 "reverse-tsn-txq-prio", 130 }; 131 132 #define IGC_PRIV_FLAGS_STR_LEN ARRAY_SIZE(igc_priv_flags_strings) 133 134 static void igc_ethtool_get_drvinfo(struct net_device *netdev, 135 struct ethtool_drvinfo *drvinfo) 136 { 137 struct igc_adapter *adapter = netdev_priv(netdev); 138 struct igc_hw *hw = &adapter->hw; 139 u16 nvm_version = 0; 140 u16 gphy_version; 141 142 strscpy(drvinfo->driver, igc_driver_name, sizeof(drvinfo->driver)); 143 144 /* NVM image version is reported as firmware version for i225 device */ 145 hw->nvm.ops.read(hw, IGC_NVM_DEV_STARTER, 1, &nvm_version); 146 147 /* gPHY firmware version is reported as PHY FW version */ 148 gphy_version = igc_read_phy_fw_version(hw); 149 150 scnprintf(adapter->fw_version, 151 sizeof(adapter->fw_version), 152 "%x:%x", 153 nvm_version, 154 gphy_version); 155 156 strscpy(drvinfo->fw_version, adapter->fw_version, 157 sizeof(drvinfo->fw_version)); 158 159 strscpy(drvinfo->bus_info, pci_name(adapter->pdev), 160 sizeof(drvinfo->bus_info)); 161 162 drvinfo->n_priv_flags = IGC_PRIV_FLAGS_STR_LEN; 163 } 164 165 static int igc_ethtool_get_regs_len(struct net_device *netdev) 166 { 167 return IGC_REGS_LEN * sizeof(u32); 168 } 169 170 static void igc_ethtool_get_regs(struct net_device *netdev, 171 struct ethtool_regs *regs, void *p) 172 { 173 struct igc_adapter *adapter = netdev_priv(netdev); 174 struct igc_hw *hw = &adapter->hw; 175 u32 *regs_buff = p; 176 u8 i; 177 178 memset(p, 0, IGC_REGS_LEN * sizeof(u32)); 179 180 regs->version = (2u << 24) | (hw->revision_id << 16) | hw->device_id; 181 182 /* General Registers */ 183 regs_buff[0] = rd32(IGC_CTRL); 184 regs_buff[1] = rd32(IGC_STATUS); 185 regs_buff[2] = rd32(IGC_CTRL_EXT); 186 regs_buff[3] = rd32(IGC_MDIC); 187 regs_buff[4] = rd32(IGC_CONNSW); 188 189 /* NVM Register */ 190 regs_buff[5] = rd32(IGC_EECD); 191 192 /* Interrupt */ 193 /* Reading EICS for EICR because they read the 194 * same but EICS does not clear on read 195 */ 196 regs_buff[6] = rd32(IGC_EICS); 197 regs_buff[7] = rd32(IGC_EICS); 198 regs_buff[8] = rd32(IGC_EIMS); 199 regs_buff[9] = rd32(IGC_EIMC); 200 regs_buff[10] = rd32(IGC_EIAC); 201 regs_buff[11] = rd32(IGC_EIAM); 202 /* Reading ICS for ICR because they read the 203 * same but ICS does not clear on read 204 */ 205 regs_buff[12] = rd32(IGC_ICS); 206 regs_buff[13] = rd32(IGC_ICS); 207 regs_buff[14] = rd32(IGC_IMS); 208 regs_buff[15] = rd32(IGC_IMC); 209 regs_buff[16] = rd32(IGC_IAC); 210 regs_buff[17] = rd32(IGC_IAM); 211 212 /* Flow Control */ 213 regs_buff[18] = rd32(IGC_FCAL); 214 regs_buff[19] = rd32(IGC_FCAH); 215 regs_buff[20] = rd32(IGC_FCTTV); 216 regs_buff[21] = rd32(IGC_FCRTL); 217 regs_buff[22] = rd32(IGC_FCRTH); 218 regs_buff[23] = rd32(IGC_FCRTV); 219 220 /* Receive */ 221 regs_buff[24] = rd32(IGC_RCTL); 222 regs_buff[25] = rd32(IGC_RXCSUM); 223 regs_buff[26] = rd32(IGC_RLPML); 224 regs_buff[27] = rd32(IGC_RFCTL); 225 226 /* Transmit */ 227 regs_buff[28] = rd32(IGC_TCTL); 228 regs_buff[29] = rd32(IGC_TIPG); 229 230 /* Wake Up */ 231 232 /* MAC */ 233 234 /* Statistics */ 235 regs_buff[30] = adapter->stats.crcerrs; 236 regs_buff[31] = adapter->stats.algnerrc; 237 regs_buff[32] = adapter->stats.symerrs; 238 regs_buff[33] = adapter->stats.rxerrc; 239 regs_buff[34] = adapter->stats.mpc; 240 regs_buff[35] = adapter->stats.scc; 241 regs_buff[36] = adapter->stats.ecol; 242 regs_buff[37] = adapter->stats.mcc; 243 regs_buff[38] = adapter->stats.latecol; 244 regs_buff[39] = adapter->stats.colc; 245 regs_buff[40] = adapter->stats.dc; 246 regs_buff[41] = adapter->stats.tncrs; 247 regs_buff[42] = adapter->stats.sec; 248 regs_buff[43] = adapter->stats.htdpmc; 249 regs_buff[44] = adapter->stats.rlec; 250 regs_buff[45] = adapter->stats.xonrxc; 251 regs_buff[46] = adapter->stats.xontxc; 252 regs_buff[47] = adapter->stats.xoffrxc; 253 regs_buff[48] = adapter->stats.xofftxc; 254 regs_buff[49] = adapter->stats.fcruc; 255 regs_buff[50] = adapter->stats.prc64; 256 regs_buff[51] = adapter->stats.prc127; 257 regs_buff[52] = adapter->stats.prc255; 258 regs_buff[53] = adapter->stats.prc511; 259 regs_buff[54] = adapter->stats.prc1023; 260 regs_buff[55] = adapter->stats.prc1522; 261 regs_buff[56] = adapter->stats.gprc; 262 regs_buff[57] = adapter->stats.bprc; 263 regs_buff[58] = adapter->stats.mprc; 264 regs_buff[59] = adapter->stats.gptc; 265 regs_buff[60] = adapter->stats.gorc; 266 regs_buff[61] = adapter->stats.gotc; 267 regs_buff[62] = adapter->stats.rnbc; 268 regs_buff[63] = adapter->stats.ruc; 269 regs_buff[64] = adapter->stats.rfc; 270 regs_buff[65] = adapter->stats.roc; 271 regs_buff[66] = adapter->stats.rjc; 272 regs_buff[67] = adapter->stats.mgprc; 273 regs_buff[68] = adapter->stats.mgpdc; 274 regs_buff[69] = adapter->stats.mgptc; 275 regs_buff[70] = adapter->stats.tor; 276 regs_buff[71] = adapter->stats.tot; 277 regs_buff[72] = adapter->stats.tpr; 278 regs_buff[73] = adapter->stats.tpt; 279 regs_buff[74] = adapter->stats.ptc64; 280 regs_buff[75] = adapter->stats.ptc127; 281 regs_buff[76] = adapter->stats.ptc255; 282 regs_buff[77] = adapter->stats.ptc511; 283 regs_buff[78] = adapter->stats.ptc1023; 284 regs_buff[79] = adapter->stats.ptc1522; 285 regs_buff[80] = adapter->stats.mptc; 286 regs_buff[81] = adapter->stats.bptc; 287 regs_buff[82] = adapter->stats.tsctc; 288 regs_buff[83] = adapter->stats.iac; 289 regs_buff[84] = adapter->stats.rpthc; 290 regs_buff[85] = adapter->stats.hgptc; 291 regs_buff[86] = adapter->stats.hgorc; 292 regs_buff[87] = adapter->stats.hgotc; 293 regs_buff[88] = adapter->stats.lenerrs; 294 regs_buff[89] = adapter->stats.scvpc; 295 regs_buff[90] = adapter->stats.hrmpc; 296 297 for (i = 0; i < 4; i++) 298 regs_buff[91 + i] = rd32(IGC_SRRCTL(i)); 299 for (i = 0; i < 4; i++) 300 regs_buff[95 + i] = rd32(IGC_PSRTYPE(i)); 301 for (i = 0; i < 4; i++) 302 regs_buff[99 + i] = rd32(IGC_RDBAL(i)); 303 for (i = 0; i < 4; i++) 304 regs_buff[103 + i] = rd32(IGC_RDBAH(i)); 305 for (i = 0; i < 4; i++) 306 regs_buff[107 + i] = rd32(IGC_RDLEN(i)); 307 for (i = 0; i < 4; i++) 308 regs_buff[111 + i] = rd32(IGC_RDH(i)); 309 for (i = 0; i < 4; i++) 310 regs_buff[115 + i] = rd32(IGC_RDT(i)); 311 for (i = 0; i < 4; i++) 312 regs_buff[119 + i] = rd32(IGC_RXDCTL(i)); 313 314 for (i = 0; i < 10; i++) 315 regs_buff[123 + i] = rd32(IGC_EITR(i)); 316 for (i = 0; i < 16; i++) 317 regs_buff[139 + i] = rd32(IGC_RAL(i)); 318 for (i = 0; i < 16; i++) 319 regs_buff[145 + i] = rd32(IGC_RAH(i)); 320 321 for (i = 0; i < 4; i++) 322 regs_buff[149 + i] = rd32(IGC_TDBAL(i)); 323 for (i = 0; i < 4; i++) 324 regs_buff[152 + i] = rd32(IGC_TDBAH(i)); 325 for (i = 0; i < 4; i++) 326 regs_buff[156 + i] = rd32(IGC_TDLEN(i)); 327 for (i = 0; i < 4; i++) 328 regs_buff[160 + i] = rd32(IGC_TDH(i)); 329 for (i = 0; i < 4; i++) 330 regs_buff[164 + i] = rd32(IGC_TDT(i)); 331 for (i = 0; i < 4; i++) 332 regs_buff[168 + i] = rd32(IGC_TXDCTL(i)); 333 334 /* XXX: Due to a bug few lines above, RAL and RAH registers are 335 * overwritten. To preserve the ABI, we write these registers again in 336 * regs_buff. 337 */ 338 for (i = 0; i < 16; i++) 339 regs_buff[172 + i] = rd32(IGC_RAL(i)); 340 for (i = 0; i < 16; i++) 341 regs_buff[188 + i] = rd32(IGC_RAH(i)); 342 343 regs_buff[204] = rd32(IGC_VLANPQF); 344 345 for (i = 0; i < 8; i++) 346 regs_buff[205 + i] = rd32(IGC_ETQF(i)); 347 348 regs_buff[213] = adapter->stats.tlpic; 349 regs_buff[214] = adapter->stats.rlpic; 350 } 351 352 static void igc_ethtool_get_wol(struct net_device *netdev, 353 struct ethtool_wolinfo *wol) 354 { 355 struct igc_adapter *adapter = netdev_priv(netdev); 356 357 wol->wolopts = 0; 358 359 if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED)) 360 return; 361 362 wol->supported = WAKE_UCAST | WAKE_MCAST | 363 WAKE_BCAST | WAKE_MAGIC | 364 WAKE_PHY; 365 366 /* apply any specific unsupported masks here */ 367 switch (adapter->hw.device_id) { 368 default: 369 break; 370 } 371 372 if (adapter->wol & IGC_WUFC_EX) 373 wol->wolopts |= WAKE_UCAST; 374 if (adapter->wol & IGC_WUFC_MC) 375 wol->wolopts |= WAKE_MCAST; 376 if (adapter->wol & IGC_WUFC_BC) 377 wol->wolopts |= WAKE_BCAST; 378 if (adapter->wol & IGC_WUFC_MAG) 379 wol->wolopts |= WAKE_MAGIC; 380 if (adapter->wol & IGC_WUFC_LNKC) 381 wol->wolopts |= WAKE_PHY; 382 } 383 384 static int igc_ethtool_set_wol(struct net_device *netdev, 385 struct ethtool_wolinfo *wol) 386 { 387 struct igc_adapter *adapter = netdev_priv(netdev); 388 389 if (wol->wolopts & (WAKE_ARP | WAKE_MAGICSECURE | WAKE_FILTER)) 390 return -EOPNOTSUPP; 391 392 if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED)) 393 return wol->wolopts ? -EOPNOTSUPP : 0; 394 395 /* these settings will always override what we currently have */ 396 adapter->wol = 0; 397 398 if (wol->wolopts & WAKE_UCAST) 399 adapter->wol |= IGC_WUFC_EX; 400 if (wol->wolopts & WAKE_MCAST) 401 adapter->wol |= IGC_WUFC_MC; 402 if (wol->wolopts & WAKE_BCAST) 403 adapter->wol |= IGC_WUFC_BC; 404 if (wol->wolopts & WAKE_MAGIC) 405 adapter->wol |= IGC_WUFC_MAG; 406 if (wol->wolopts & WAKE_PHY) 407 adapter->wol |= IGC_WUFC_LNKC; 408 device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol); 409 410 return 0; 411 } 412 413 static u32 igc_ethtool_get_msglevel(struct net_device *netdev) 414 { 415 struct igc_adapter *adapter = netdev_priv(netdev); 416 417 return adapter->msg_enable; 418 } 419 420 static void igc_ethtool_set_msglevel(struct net_device *netdev, u32 data) 421 { 422 struct igc_adapter *adapter = netdev_priv(netdev); 423 424 adapter->msg_enable = data; 425 } 426 427 static int igc_ethtool_nway_reset(struct net_device *netdev) 428 { 429 struct igc_adapter *adapter = netdev_priv(netdev); 430 431 if (netif_running(netdev)) 432 igc_reinit_locked(adapter); 433 return 0; 434 } 435 436 static u32 igc_ethtool_get_link(struct net_device *netdev) 437 { 438 struct igc_adapter *adapter = netdev_priv(netdev); 439 struct igc_mac_info *mac = &adapter->hw.mac; 440 441 /* If the link is not reported up to netdev, interrupts are disabled, 442 * and so the physical link state may have changed since we last 443 * looked. Set get_link_status to make sure that the true link 444 * state is interrogated, rather than pulling a cached and possibly 445 * stale link state from the driver. 446 */ 447 if (!netif_carrier_ok(netdev)) 448 mac->get_link_status = 1; 449 450 return igc_has_link(adapter); 451 } 452 453 static int igc_ethtool_get_eeprom_len(struct net_device *netdev) 454 { 455 struct igc_adapter *adapter = netdev_priv(netdev); 456 457 return adapter->hw.nvm.word_size * 2; 458 } 459 460 static int igc_ethtool_get_eeprom(struct net_device *netdev, 461 struct ethtool_eeprom *eeprom, u8 *bytes) 462 { 463 struct igc_adapter *adapter = netdev_priv(netdev); 464 struct igc_hw *hw = &adapter->hw; 465 int first_word, last_word; 466 u16 *eeprom_buff; 467 int ret_val = 0; 468 u16 i; 469 470 if (eeprom->len == 0) 471 return -EINVAL; 472 473 eeprom->magic = hw->vendor_id | (hw->device_id << 16); 474 475 first_word = eeprom->offset >> 1; 476 last_word = (eeprom->offset + eeprom->len - 1) >> 1; 477 478 eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16), 479 GFP_KERNEL); 480 if (!eeprom_buff) 481 return -ENOMEM; 482 483 if (hw->nvm.type == igc_nvm_eeprom_spi) { 484 ret_val = hw->nvm.ops.read(hw, first_word, 485 last_word - first_word + 1, 486 eeprom_buff); 487 } else { 488 for (i = 0; i < last_word - first_word + 1; i++) { 489 ret_val = hw->nvm.ops.read(hw, first_word + i, 1, 490 &eeprom_buff[i]); 491 if (ret_val) 492 break; 493 } 494 } 495 496 /* Device's eeprom is always little-endian, word addressable */ 497 for (i = 0; i < last_word - first_word + 1; i++) 498 le16_to_cpus(&eeprom_buff[i]); 499 500 memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), 501 eeprom->len); 502 kfree(eeprom_buff); 503 504 return ret_val; 505 } 506 507 static int igc_ethtool_set_eeprom(struct net_device *netdev, 508 struct ethtool_eeprom *eeprom, u8 *bytes) 509 { 510 struct igc_adapter *adapter = netdev_priv(netdev); 511 struct igc_hw *hw = &adapter->hw; 512 int max_len, first_word, last_word, ret_val = 0; 513 u16 *eeprom_buff; 514 void *ptr; 515 u16 i; 516 517 if (eeprom->len == 0) 518 return -EOPNOTSUPP; 519 520 if (hw->mac.type >= igc_i225 && 521 !igc_get_flash_presence_i225(hw)) { 522 return -EOPNOTSUPP; 523 } 524 525 if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16))) 526 return -EFAULT; 527 528 max_len = hw->nvm.word_size * 2; 529 530 first_word = eeprom->offset >> 1; 531 last_word = (eeprom->offset + eeprom->len - 1) >> 1; 532 eeprom_buff = kmalloc(max_len, GFP_KERNEL); 533 if (!eeprom_buff) 534 return -ENOMEM; 535 536 ptr = (void *)eeprom_buff; 537 538 if (eeprom->offset & 1) { 539 /* need read/modify/write of first changed EEPROM word 540 * only the second byte of the word is being modified 541 */ 542 ret_val = hw->nvm.ops.read(hw, first_word, 1, 543 &eeprom_buff[0]); 544 ptr++; 545 } 546 if (((eeprom->offset + eeprom->len) & 1) && ret_val == 0) { 547 /* need read/modify/write of last changed EEPROM word 548 * only the first byte of the word is being modified 549 */ 550 ret_val = hw->nvm.ops.read(hw, last_word, 1, 551 &eeprom_buff[last_word - first_word]); 552 } 553 554 /* Device's eeprom is always little-endian, word addressable */ 555 for (i = 0; i < last_word - first_word + 1; i++) 556 le16_to_cpus(&eeprom_buff[i]); 557 558 memcpy(ptr, bytes, eeprom->len); 559 560 for (i = 0; i < last_word - first_word + 1; i++) 561 cpu_to_le16s(&eeprom_buff[i]); 562 563 ret_val = hw->nvm.ops.write(hw, first_word, 564 last_word - first_word + 1, eeprom_buff); 565 566 /* Update the checksum if nvm write succeeded */ 567 if (ret_val == 0) 568 hw->nvm.ops.update(hw); 569 570 kfree(eeprom_buff); 571 return ret_val; 572 } 573 574 static void 575 igc_ethtool_get_ringparam(struct net_device *netdev, 576 struct ethtool_ringparam *ring, 577 struct kernel_ethtool_ringparam *kernel_ering, 578 struct netlink_ext_ack *extack) 579 { 580 struct igc_adapter *adapter = netdev_priv(netdev); 581 582 ring->rx_max_pending = IGC_MAX_RXD; 583 ring->tx_max_pending = IGC_MAX_TXD; 584 ring->rx_pending = adapter->rx_ring_count; 585 ring->tx_pending = adapter->tx_ring_count; 586 } 587 588 static int 589 igc_ethtool_set_ringparam(struct net_device *netdev, 590 struct ethtool_ringparam *ring, 591 struct kernel_ethtool_ringparam *kernel_ering, 592 struct netlink_ext_ack *extack) 593 { 594 struct igc_adapter *adapter = netdev_priv(netdev); 595 struct igc_ring *temp_ring; 596 u16 new_rx_count, new_tx_count; 597 int i, err = 0; 598 599 if (ring->rx_mini_pending || ring->rx_jumbo_pending) 600 return -EINVAL; 601 602 new_rx_count = min_t(u32, ring->rx_pending, IGC_MAX_RXD); 603 new_rx_count = max_t(u16, new_rx_count, IGC_MIN_RXD); 604 new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE); 605 606 new_tx_count = min_t(u32, ring->tx_pending, IGC_MAX_TXD); 607 new_tx_count = max_t(u16, new_tx_count, IGC_MIN_TXD); 608 new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE); 609 610 if (new_tx_count == adapter->tx_ring_count && 611 new_rx_count == adapter->rx_ring_count) { 612 /* nothing to do */ 613 return 0; 614 } 615 616 while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 617 usleep_range(1000, 2000); 618 619 if (!netif_running(adapter->netdev)) { 620 for (i = 0; i < adapter->num_tx_queues; i++) 621 adapter->tx_ring[i]->count = new_tx_count; 622 for (i = 0; i < adapter->num_rx_queues; i++) 623 adapter->rx_ring[i]->count = new_rx_count; 624 adapter->tx_ring_count = new_tx_count; 625 adapter->rx_ring_count = new_rx_count; 626 goto clear_reset; 627 } 628 629 if (adapter->num_tx_queues > adapter->num_rx_queues) 630 temp_ring = vmalloc_array(adapter->num_tx_queues, 631 sizeof(struct igc_ring)); 632 else 633 temp_ring = vmalloc_array(adapter->num_rx_queues, 634 sizeof(struct igc_ring)); 635 636 if (!temp_ring) { 637 err = -ENOMEM; 638 goto clear_reset; 639 } 640 641 igc_down(adapter); 642 643 /* We can't just free everything and then setup again, 644 * because the ISRs in MSI-X mode get passed pointers 645 * to the Tx and Rx ring structs. 646 */ 647 if (new_tx_count != adapter->tx_ring_count) { 648 for (i = 0; i < adapter->num_tx_queues; i++) { 649 memcpy(&temp_ring[i], adapter->tx_ring[i], 650 sizeof(struct igc_ring)); 651 652 temp_ring[i].count = new_tx_count; 653 err = igc_setup_tx_resources(&temp_ring[i]); 654 if (err) { 655 while (i) { 656 i--; 657 igc_free_tx_resources(&temp_ring[i]); 658 } 659 goto err_setup; 660 } 661 } 662 663 for (i = 0; i < adapter->num_tx_queues; i++) { 664 igc_free_tx_resources(adapter->tx_ring[i]); 665 666 memcpy(adapter->tx_ring[i], &temp_ring[i], 667 sizeof(struct igc_ring)); 668 } 669 670 adapter->tx_ring_count = new_tx_count; 671 } 672 673 if (new_rx_count != adapter->rx_ring_count) { 674 for (i = 0; i < adapter->num_rx_queues; i++) { 675 memcpy(&temp_ring[i], adapter->rx_ring[i], 676 sizeof(struct igc_ring)); 677 678 temp_ring[i].count = new_rx_count; 679 err = igc_setup_rx_resources(&temp_ring[i]); 680 if (err) { 681 while (i) { 682 i--; 683 igc_free_rx_resources(&temp_ring[i]); 684 } 685 goto err_setup; 686 } 687 } 688 689 for (i = 0; i < adapter->num_rx_queues; i++) { 690 igc_free_rx_resources(adapter->rx_ring[i]); 691 692 memcpy(adapter->rx_ring[i], &temp_ring[i], 693 sizeof(struct igc_ring)); 694 } 695 696 adapter->rx_ring_count = new_rx_count; 697 } 698 err_setup: 699 igc_up(adapter); 700 vfree(temp_ring); 701 clear_reset: 702 clear_bit(__IGC_RESETTING, &adapter->state); 703 return err; 704 } 705 706 static void igc_ethtool_get_pauseparam(struct net_device *netdev, 707 struct ethtool_pauseparam *pause) 708 { 709 struct igc_adapter *adapter = netdev_priv(netdev); 710 struct igc_hw *hw = &adapter->hw; 711 712 pause->autoneg = 713 (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE); 714 715 if (hw->fc.current_mode == igc_fc_rx_pause) { 716 pause->rx_pause = 1; 717 } else if (hw->fc.current_mode == igc_fc_tx_pause) { 718 pause->tx_pause = 1; 719 } else if (hw->fc.current_mode == igc_fc_full) { 720 pause->rx_pause = 1; 721 pause->tx_pause = 1; 722 } 723 } 724 725 static int igc_ethtool_set_pauseparam(struct net_device *netdev, 726 struct ethtool_pauseparam *pause) 727 { 728 struct igc_adapter *adapter = netdev_priv(netdev); 729 struct igc_hw *hw = &adapter->hw; 730 int retval = 0; 731 732 adapter->fc_autoneg = pause->autoneg; 733 734 while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 735 usleep_range(1000, 2000); 736 737 if (adapter->fc_autoneg == AUTONEG_ENABLE) { 738 hw->fc.requested_mode = igc_fc_default; 739 if (netif_running(adapter->netdev)) { 740 igc_down(adapter); 741 igc_up(adapter); 742 } else { 743 igc_reset(adapter); 744 } 745 } else { 746 if (pause->rx_pause && pause->tx_pause) 747 hw->fc.requested_mode = igc_fc_full; 748 else if (pause->rx_pause && !pause->tx_pause) 749 hw->fc.requested_mode = igc_fc_rx_pause; 750 else if (!pause->rx_pause && pause->tx_pause) 751 hw->fc.requested_mode = igc_fc_tx_pause; 752 else if (!pause->rx_pause && !pause->tx_pause) 753 hw->fc.requested_mode = igc_fc_none; 754 755 hw->fc.current_mode = hw->fc.requested_mode; 756 757 retval = ((hw->phy.media_type == igc_media_type_copper) ? 758 igc_force_mac_fc(hw) : igc_setup_link(hw)); 759 } 760 761 clear_bit(__IGC_RESETTING, &adapter->state); 762 return retval; 763 } 764 765 static void igc_ethtool_get_strings(struct net_device *netdev, u32 stringset, 766 u8 *data) 767 { 768 struct igc_adapter *adapter = netdev_priv(netdev); 769 u8 *p = data; 770 int i; 771 772 switch (stringset) { 773 case ETH_SS_TEST: 774 memcpy(data, *igc_gstrings_test, 775 IGC_TEST_LEN * ETH_GSTRING_LEN); 776 break; 777 case ETH_SS_STATS: 778 for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) 779 ethtool_puts(&p, igc_gstrings_stats[i].stat_string); 780 for (i = 0; i < IGC_NETDEV_STATS_LEN; i++) 781 ethtool_puts(&p, igc_gstrings_net_stats[i].stat_string); 782 for (i = 0; i < adapter->num_tx_queues; i++) { 783 ethtool_sprintf(&p, "tx_queue_%u_packets", i); 784 ethtool_sprintf(&p, "tx_queue_%u_bytes", i); 785 ethtool_sprintf(&p, "tx_queue_%u_restart", i); 786 } 787 for (i = 0; i < adapter->num_rx_queues; i++) { 788 ethtool_sprintf(&p, "rx_queue_%u_packets", i); 789 ethtool_sprintf(&p, "rx_queue_%u_bytes", i); 790 ethtool_sprintf(&p, "rx_queue_%u_drops", i); 791 ethtool_sprintf(&p, "rx_queue_%u_csum_err", i); 792 ethtool_sprintf(&p, "rx_queue_%u_alloc_failed", i); 793 } 794 /* BUG_ON(p - data != IGC_STATS_LEN * ETH_GSTRING_LEN); */ 795 break; 796 case ETH_SS_PRIV_FLAGS: 797 memcpy(data, igc_priv_flags_strings, 798 IGC_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN); 799 break; 800 } 801 } 802 803 static int igc_ethtool_get_sset_count(struct net_device *netdev, int sset) 804 { 805 switch (sset) { 806 case ETH_SS_STATS: 807 return IGC_STATS_LEN; 808 case ETH_SS_TEST: 809 return IGC_TEST_LEN; 810 case ETH_SS_PRIV_FLAGS: 811 return IGC_PRIV_FLAGS_STR_LEN; 812 default: 813 return -EOPNOTSUPP; 814 } 815 } 816 817 static void igc_ethtool_get_stats(struct net_device *netdev, 818 struct ethtool_stats *stats, u64 *data) 819 { 820 struct igc_adapter *adapter = netdev_priv(netdev); 821 struct rtnl_link_stats64 *net_stats = &adapter->stats64; 822 unsigned int start; 823 struct igc_ring *ring; 824 int i, j; 825 char *p; 826 827 spin_lock(&adapter->stats64_lock); 828 igc_update_stats(adapter); 829 830 for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) { 831 p = (char *)adapter + igc_gstrings_stats[i].stat_offset; 832 data[i] = (igc_gstrings_stats[i].sizeof_stat == 833 sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 834 } 835 for (j = 0; j < IGC_NETDEV_STATS_LEN; j++, i++) { 836 p = (char *)net_stats + igc_gstrings_net_stats[j].stat_offset; 837 data[i] = (igc_gstrings_net_stats[j].sizeof_stat == 838 sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 839 } 840 for (j = 0; j < adapter->num_tx_queues; j++) { 841 u64 restart2; 842 843 ring = adapter->tx_ring[j]; 844 do { 845 start = u64_stats_fetch_begin(&ring->tx_syncp); 846 data[i] = ring->tx_stats.packets; 847 data[i + 1] = ring->tx_stats.bytes; 848 data[i + 2] = ring->tx_stats.restart_queue; 849 } while (u64_stats_fetch_retry(&ring->tx_syncp, start)); 850 do { 851 start = u64_stats_fetch_begin(&ring->tx_syncp2); 852 restart2 = ring->tx_stats.restart_queue2; 853 } while (u64_stats_fetch_retry(&ring->tx_syncp2, start)); 854 data[i + 2] += restart2; 855 856 i += IGC_TX_QUEUE_STATS_LEN; 857 } 858 for (j = 0; j < adapter->num_rx_queues; j++) { 859 ring = adapter->rx_ring[j]; 860 do { 861 start = u64_stats_fetch_begin(&ring->rx_syncp); 862 data[i] = ring->rx_stats.packets; 863 data[i + 1] = ring->rx_stats.bytes; 864 data[i + 2] = ring->rx_stats.drops; 865 data[i + 3] = ring->rx_stats.csum_err; 866 data[i + 4] = ring->rx_stats.alloc_failed; 867 } while (u64_stats_fetch_retry(&ring->rx_syncp, start)); 868 i += IGC_RX_QUEUE_STATS_LEN; 869 } 870 spin_unlock(&adapter->stats64_lock); 871 } 872 873 static int igc_ethtool_get_previous_rx_coalesce(struct igc_adapter *adapter) 874 { 875 return (adapter->rx_itr_setting <= 3) ? 876 adapter->rx_itr_setting : adapter->rx_itr_setting >> 2; 877 } 878 879 static int igc_ethtool_get_previous_tx_coalesce(struct igc_adapter *adapter) 880 { 881 return (adapter->tx_itr_setting <= 3) ? 882 adapter->tx_itr_setting : adapter->tx_itr_setting >> 2; 883 } 884 885 static int igc_ethtool_get_coalesce(struct net_device *netdev, 886 struct ethtool_coalesce *ec, 887 struct kernel_ethtool_coalesce *kernel_coal, 888 struct netlink_ext_ack *extack) 889 { 890 struct igc_adapter *adapter = netdev_priv(netdev); 891 892 ec->rx_coalesce_usecs = igc_ethtool_get_previous_rx_coalesce(adapter); 893 ec->tx_coalesce_usecs = igc_ethtool_get_previous_tx_coalesce(adapter); 894 895 return 0; 896 } 897 898 static int igc_ethtool_set_coalesce(struct net_device *netdev, 899 struct ethtool_coalesce *ec, 900 struct kernel_ethtool_coalesce *kernel_coal, 901 struct netlink_ext_ack *extack) 902 { 903 struct igc_adapter *adapter = netdev_priv(netdev); 904 int i; 905 906 if (ec->rx_coalesce_usecs > IGC_MAX_ITR_USECS || 907 (ec->rx_coalesce_usecs > 3 && 908 ec->rx_coalesce_usecs < IGC_MIN_ITR_USECS) || 909 ec->rx_coalesce_usecs == 2) 910 return -EINVAL; 911 912 if (ec->tx_coalesce_usecs > IGC_MAX_ITR_USECS || 913 (ec->tx_coalesce_usecs > 3 && 914 ec->tx_coalesce_usecs < IGC_MIN_ITR_USECS) || 915 ec->tx_coalesce_usecs == 2) 916 return -EINVAL; 917 918 if ((adapter->flags & IGC_FLAG_QUEUE_PAIRS) && 919 ec->tx_coalesce_usecs != igc_ethtool_get_previous_tx_coalesce(adapter)) { 920 NL_SET_ERR_MSG_MOD(extack, 921 "Queue Pair mode enabled, both Rx and Tx coalescing controlled by rx-usecs"); 922 return -EINVAL; 923 } 924 925 /* If ITR is disabled, disable DMAC */ 926 if (ec->rx_coalesce_usecs == 0) { 927 if (adapter->flags & IGC_FLAG_DMAC) 928 adapter->flags &= ~IGC_FLAG_DMAC; 929 } 930 931 /* convert to rate of irq's per second */ 932 if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3) 933 adapter->rx_itr_setting = ec->rx_coalesce_usecs; 934 else 935 adapter->rx_itr_setting = ec->rx_coalesce_usecs << 2; 936 937 /* convert to rate of irq's per second */ 938 if (adapter->flags & IGC_FLAG_QUEUE_PAIRS) 939 adapter->tx_itr_setting = adapter->rx_itr_setting; 940 else if (ec->tx_coalesce_usecs && ec->tx_coalesce_usecs <= 3) 941 adapter->tx_itr_setting = ec->tx_coalesce_usecs; 942 else 943 adapter->tx_itr_setting = ec->tx_coalesce_usecs << 2; 944 945 for (i = 0; i < adapter->num_q_vectors; i++) { 946 struct igc_q_vector *q_vector = adapter->q_vector[i]; 947 948 q_vector->tx.work_limit = adapter->tx_work_limit; 949 if (q_vector->rx.ring) 950 q_vector->itr_val = adapter->rx_itr_setting; 951 else 952 q_vector->itr_val = adapter->tx_itr_setting; 953 if (q_vector->itr_val && q_vector->itr_val <= 3) 954 q_vector->itr_val = IGC_START_ITR; 955 q_vector->set_itr = 1; 956 } 957 958 return 0; 959 } 960 961 #define ETHER_TYPE_FULL_MASK ((__force __be16)~0) 962 #define VLAN_TCI_FULL_MASK ((__force __be16)~0) 963 static int igc_ethtool_get_nfc_rule(struct igc_adapter *adapter, 964 struct ethtool_rxnfc *cmd) 965 { 966 struct ethtool_rx_flow_spec *fsp = &cmd->fs; 967 struct igc_nfc_rule *rule = NULL; 968 969 cmd->data = IGC_MAX_RXNFC_RULES; 970 971 mutex_lock(&adapter->nfc_rule_lock); 972 973 rule = igc_get_nfc_rule(adapter, fsp->location); 974 if (!rule) 975 goto out; 976 977 fsp->flow_type = ETHER_FLOW; 978 fsp->ring_cookie = rule->action; 979 980 if (rule->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) { 981 fsp->h_u.ether_spec.h_proto = htons(rule->filter.etype); 982 fsp->m_u.ether_spec.h_proto = ETHER_TYPE_FULL_MASK; 983 } 984 985 if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_ETYPE) { 986 fsp->flow_type |= FLOW_EXT; 987 fsp->h_ext.vlan_etype = htons(rule->filter.vlan_etype); 988 fsp->m_ext.vlan_etype = ETHER_TYPE_FULL_MASK; 989 } 990 991 if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) { 992 fsp->flow_type |= FLOW_EXT; 993 fsp->h_ext.vlan_tci = htons(rule->filter.vlan_tci); 994 fsp->m_ext.vlan_tci = htons(rule->filter.vlan_tci_mask); 995 } 996 997 if (rule->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) { 998 ether_addr_copy(fsp->h_u.ether_spec.h_dest, 999 rule->filter.dst_addr); 1000 eth_broadcast_addr(fsp->m_u.ether_spec.h_dest); 1001 } 1002 1003 if (rule->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) { 1004 ether_addr_copy(fsp->h_u.ether_spec.h_source, 1005 rule->filter.src_addr); 1006 eth_broadcast_addr(fsp->m_u.ether_spec.h_source); 1007 } 1008 1009 if (rule->filter.match_flags & IGC_FILTER_FLAG_USER_DATA) { 1010 fsp->flow_type |= FLOW_EXT; 1011 memcpy(fsp->h_ext.data, rule->filter.user_data, sizeof(fsp->h_ext.data)); 1012 memcpy(fsp->m_ext.data, rule->filter.user_mask, sizeof(fsp->m_ext.data)); 1013 } 1014 1015 mutex_unlock(&adapter->nfc_rule_lock); 1016 return 0; 1017 1018 out: 1019 mutex_unlock(&adapter->nfc_rule_lock); 1020 return -EINVAL; 1021 } 1022 1023 static int igc_ethtool_get_nfc_rules(struct igc_adapter *adapter, 1024 struct ethtool_rxnfc *cmd, 1025 u32 *rule_locs) 1026 { 1027 struct igc_nfc_rule *rule; 1028 int cnt = 0; 1029 1030 cmd->data = IGC_MAX_RXNFC_RULES; 1031 1032 mutex_lock(&adapter->nfc_rule_lock); 1033 1034 list_for_each_entry(rule, &adapter->nfc_rule_list, list) { 1035 if (cnt == cmd->rule_cnt) { 1036 mutex_unlock(&adapter->nfc_rule_lock); 1037 return -EMSGSIZE; 1038 } 1039 rule_locs[cnt] = rule->location; 1040 cnt++; 1041 } 1042 1043 mutex_unlock(&adapter->nfc_rule_lock); 1044 1045 cmd->rule_cnt = cnt; 1046 1047 return 0; 1048 } 1049 1050 static int igc_ethtool_get_rxfh_fields(struct net_device *dev, 1051 struct ethtool_rxfh_fields *cmd) 1052 { 1053 struct igc_adapter *adapter = netdev_priv(dev); 1054 1055 cmd->data = 0; 1056 1057 /* Report default options for RSS on igc */ 1058 switch (cmd->flow_type) { 1059 case TCP_V4_FLOW: 1060 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 1061 fallthrough; 1062 case UDP_V4_FLOW: 1063 if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV4_UDP) 1064 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 1065 fallthrough; 1066 case SCTP_V4_FLOW: 1067 case AH_ESP_V4_FLOW: 1068 case AH_V4_FLOW: 1069 case ESP_V4_FLOW: 1070 case IPV4_FLOW: 1071 cmd->data |= RXH_IP_SRC | RXH_IP_DST; 1072 break; 1073 case TCP_V6_FLOW: 1074 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 1075 fallthrough; 1076 case UDP_V6_FLOW: 1077 if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV6_UDP) 1078 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 1079 fallthrough; 1080 case SCTP_V6_FLOW: 1081 case AH_ESP_V6_FLOW: 1082 case AH_V6_FLOW: 1083 case ESP_V6_FLOW: 1084 case IPV6_FLOW: 1085 cmd->data |= RXH_IP_SRC | RXH_IP_DST; 1086 break; 1087 default: 1088 return -EINVAL; 1089 } 1090 1091 return 0; 1092 } 1093 1094 static u32 igc_ethtool_get_rx_ring_count(struct net_device *dev) 1095 { 1096 struct igc_adapter *adapter = netdev_priv(dev); 1097 1098 return adapter->num_rx_queues; 1099 } 1100 1101 static int igc_ethtool_get_rxnfc(struct net_device *dev, 1102 struct ethtool_rxnfc *cmd, u32 *rule_locs) 1103 { 1104 struct igc_adapter *adapter = netdev_priv(dev); 1105 1106 switch (cmd->cmd) { 1107 case ETHTOOL_GRXCLSRLCNT: 1108 cmd->rule_cnt = adapter->nfc_rule_count; 1109 return 0; 1110 case ETHTOOL_GRXCLSRULE: 1111 return igc_ethtool_get_nfc_rule(adapter, cmd); 1112 case ETHTOOL_GRXCLSRLALL: 1113 return igc_ethtool_get_nfc_rules(adapter, cmd, rule_locs); 1114 default: 1115 return -EOPNOTSUPP; 1116 } 1117 } 1118 1119 #define UDP_RSS_FLAGS (IGC_FLAG_RSS_FIELD_IPV4_UDP | \ 1120 IGC_FLAG_RSS_FIELD_IPV6_UDP) 1121 static int igc_ethtool_set_rxfh_fields(struct net_device *dev, 1122 const struct ethtool_rxfh_fields *nfc, 1123 struct netlink_ext_ack *extack) 1124 { 1125 struct igc_adapter *adapter = netdev_priv(dev); 1126 u32 flags = adapter->flags; 1127 1128 /* RSS does not support anything other than hashing 1129 * to queues on src and dst IPs and ports 1130 */ 1131 if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST | 1132 RXH_L4_B_0_1 | RXH_L4_B_2_3)) 1133 return -EINVAL; 1134 1135 switch (nfc->flow_type) { 1136 case TCP_V4_FLOW: 1137 case TCP_V6_FLOW: 1138 if (!(nfc->data & RXH_IP_SRC) || 1139 !(nfc->data & RXH_IP_DST) || 1140 !(nfc->data & RXH_L4_B_0_1) || 1141 !(nfc->data & RXH_L4_B_2_3)) 1142 return -EINVAL; 1143 break; 1144 case UDP_V4_FLOW: 1145 if (!(nfc->data & RXH_IP_SRC) || 1146 !(nfc->data & RXH_IP_DST)) 1147 return -EINVAL; 1148 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 1149 case 0: 1150 flags &= ~IGC_FLAG_RSS_FIELD_IPV4_UDP; 1151 break; 1152 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 1153 flags |= IGC_FLAG_RSS_FIELD_IPV4_UDP; 1154 break; 1155 default: 1156 return -EINVAL; 1157 } 1158 break; 1159 case UDP_V6_FLOW: 1160 if (!(nfc->data & RXH_IP_SRC) || 1161 !(nfc->data & RXH_IP_DST)) 1162 return -EINVAL; 1163 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 1164 case 0: 1165 flags &= ~IGC_FLAG_RSS_FIELD_IPV6_UDP; 1166 break; 1167 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 1168 flags |= IGC_FLAG_RSS_FIELD_IPV6_UDP; 1169 break; 1170 default: 1171 return -EINVAL; 1172 } 1173 break; 1174 case AH_ESP_V4_FLOW: 1175 case AH_V4_FLOW: 1176 case ESP_V4_FLOW: 1177 case SCTP_V4_FLOW: 1178 case AH_ESP_V6_FLOW: 1179 case AH_V6_FLOW: 1180 case ESP_V6_FLOW: 1181 case SCTP_V6_FLOW: 1182 if (!(nfc->data & RXH_IP_SRC) || 1183 !(nfc->data & RXH_IP_DST) || 1184 (nfc->data & RXH_L4_B_0_1) || 1185 (nfc->data & RXH_L4_B_2_3)) 1186 return -EINVAL; 1187 break; 1188 default: 1189 return -EINVAL; 1190 } 1191 1192 /* if we changed something we need to update flags */ 1193 if (flags != adapter->flags) { 1194 struct igc_hw *hw = &adapter->hw; 1195 u32 mrqc = rd32(IGC_MRQC); 1196 1197 if ((flags & UDP_RSS_FLAGS) && 1198 !(adapter->flags & UDP_RSS_FLAGS)) 1199 netdev_err(adapter->netdev, 1200 "Enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n"); 1201 1202 adapter->flags = flags; 1203 1204 /* Perform hash on these packet types */ 1205 mrqc |= IGC_MRQC_RSS_FIELD_IPV4 | 1206 IGC_MRQC_RSS_FIELD_IPV4_TCP | 1207 IGC_MRQC_RSS_FIELD_IPV6 | 1208 IGC_MRQC_RSS_FIELD_IPV6_TCP; 1209 1210 mrqc &= ~(IGC_MRQC_RSS_FIELD_IPV4_UDP | 1211 IGC_MRQC_RSS_FIELD_IPV6_UDP); 1212 1213 if (flags & IGC_FLAG_RSS_FIELD_IPV4_UDP) 1214 mrqc |= IGC_MRQC_RSS_FIELD_IPV4_UDP; 1215 1216 if (flags & IGC_FLAG_RSS_FIELD_IPV6_UDP) 1217 mrqc |= IGC_MRQC_RSS_FIELD_IPV6_UDP; 1218 1219 wr32(IGC_MRQC, mrqc); 1220 } 1221 1222 return 0; 1223 } 1224 1225 static void igc_ethtool_init_nfc_rule(struct igc_nfc_rule *rule, 1226 const struct ethtool_rx_flow_spec *fsp) 1227 { 1228 INIT_LIST_HEAD(&rule->list); 1229 1230 rule->action = fsp->ring_cookie; 1231 rule->location = fsp->location; 1232 1233 if ((fsp->flow_type & FLOW_EXT) && fsp->m_ext.vlan_tci) { 1234 rule->filter.vlan_tci = ntohs(fsp->h_ext.vlan_tci); 1235 rule->filter.vlan_tci_mask = ntohs(fsp->m_ext.vlan_tci); 1236 rule->filter.match_flags |= IGC_FILTER_FLAG_VLAN_TCI; 1237 } 1238 1239 if (fsp->m_u.ether_spec.h_proto == ETHER_TYPE_FULL_MASK) { 1240 rule->filter.etype = ntohs(fsp->h_u.ether_spec.h_proto); 1241 rule->filter.match_flags = IGC_FILTER_FLAG_ETHER_TYPE; 1242 } 1243 1244 /* Both source and destination address filters only support the full 1245 * mask. 1246 */ 1247 if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_source)) { 1248 rule->filter.match_flags |= IGC_FILTER_FLAG_SRC_MAC_ADDR; 1249 ether_addr_copy(rule->filter.src_addr, 1250 fsp->h_u.ether_spec.h_source); 1251 } 1252 1253 if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_dest)) { 1254 rule->filter.match_flags |= IGC_FILTER_FLAG_DST_MAC_ADDR; 1255 ether_addr_copy(rule->filter.dst_addr, 1256 fsp->h_u.ether_spec.h_dest); 1257 } 1258 1259 /* VLAN etype matching */ 1260 if ((fsp->flow_type & FLOW_EXT) && fsp->h_ext.vlan_etype) { 1261 rule->filter.vlan_etype = ntohs(fsp->h_ext.vlan_etype); 1262 rule->filter.match_flags |= IGC_FILTER_FLAG_VLAN_ETYPE; 1263 } 1264 1265 /* Check for user defined data */ 1266 if ((fsp->flow_type & FLOW_EXT) && 1267 (fsp->h_ext.data[0] || fsp->h_ext.data[1])) { 1268 rule->filter.match_flags |= IGC_FILTER_FLAG_USER_DATA; 1269 memcpy(rule->filter.user_data, fsp->h_ext.data, sizeof(fsp->h_ext.data)); 1270 memcpy(rule->filter.user_mask, fsp->m_ext.data, sizeof(fsp->m_ext.data)); 1271 } 1272 1273 /* The i225/i226 has various different filters. Flex filters provide a 1274 * way to match up to the first 128 bytes of a packet. Use them for: 1275 * a) For specific user data 1276 * b) For VLAN EtherType 1277 * c) For full TCI match 1278 * d) Or in case multiple filter criteria are set 1279 * 1280 * Otherwise, use the simple MAC, VLAN PRIO or EtherType filters. 1281 */ 1282 if ((rule->filter.match_flags & IGC_FILTER_FLAG_USER_DATA) || 1283 (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_ETYPE) || 1284 ((rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) && 1285 rule->filter.vlan_tci_mask == ntohs(VLAN_TCI_FULL_MASK)) || 1286 (rule->filter.match_flags & (rule->filter.match_flags - 1))) 1287 rule->flex = true; 1288 else 1289 rule->flex = false; 1290 1291 /* The wildcard rule is only applied if: 1292 * a) None of the other filtering rules match (match_flags is zero) 1293 * b) The flow type is ETHER_FLOW only (no additional fields set) 1294 * c) Mask for Source MAC address is not specified (all zeros) 1295 * d) Mask for Destination MAC address is not specified (all zeros) 1296 * e) Mask for L2 EtherType is not specified (zero) 1297 * 1298 * If all these conditions are met, the rule is treated as a wildcard 1299 * rule. Default queue feature will be used, so that all packets that do 1300 * not match any other rule will be routed to the default queue. 1301 */ 1302 if (!rule->filter.match_flags && 1303 fsp->flow_type == ETHER_FLOW && 1304 is_zero_ether_addr(fsp->m_u.ether_spec.h_source) && 1305 is_zero_ether_addr(fsp->m_u.ether_spec.h_dest) && 1306 !fsp->m_u.ether_spec.h_proto) 1307 rule->filter.match_flags = IGC_FILTER_FLAG_DEFAULT_QUEUE; 1308 } 1309 1310 /** 1311 * igc_ethtool_check_nfc_rule() - Check if NFC rule is valid 1312 * @adapter: Pointer to adapter 1313 * @rule: Rule under evaluation 1314 * 1315 * The driver doesn't support rules with multiple matches so if more than 1316 * one bit in filter flags is set, @rule is considered invalid. 1317 * 1318 * Also, if there is already another rule with the same filter in a different 1319 * location, @rule is considered invalid. 1320 * 1321 * Context: Expects adapter->nfc_rule_lock to be held by caller. 1322 * 1323 * Return: 0 in case of success, negative errno code otherwise. 1324 */ 1325 static int igc_ethtool_check_nfc_rule(struct igc_adapter *adapter, 1326 struct igc_nfc_rule *rule) 1327 { 1328 struct net_device *dev = adapter->netdev; 1329 u8 flags = rule->filter.match_flags; 1330 struct igc_nfc_rule *tmp; 1331 1332 if (!flags) { 1333 netdev_dbg(dev, "Rule with no match\n"); 1334 return -EINVAL; 1335 } 1336 1337 list_for_each_entry(tmp, &adapter->nfc_rule_list, list) { 1338 if (!memcmp(&rule->filter, &tmp->filter, 1339 sizeof(rule->filter)) && 1340 tmp->location != rule->location) { 1341 netdev_dbg(dev, "Rule already exists\n"); 1342 return -EEXIST; 1343 } 1344 } 1345 1346 return 0; 1347 } 1348 1349 static int igc_ethtool_add_nfc_rule(struct igc_adapter *adapter, 1350 struct ethtool_rxnfc *cmd) 1351 { 1352 struct net_device *netdev = adapter->netdev; 1353 struct ethtool_rx_flow_spec *fsp = 1354 (struct ethtool_rx_flow_spec *)&cmd->fs; 1355 struct igc_nfc_rule *rule, *old_rule; 1356 int err; 1357 1358 if (!(netdev->hw_features & NETIF_F_NTUPLE)) { 1359 netdev_dbg(netdev, "N-tuple filters disabled\n"); 1360 return -EOPNOTSUPP; 1361 } 1362 1363 if ((fsp->flow_type & ~FLOW_EXT) != ETHER_FLOW) { 1364 netdev_dbg(netdev, "Only ethernet flow type is supported\n"); 1365 return -EOPNOTSUPP; 1366 } 1367 1368 if (fsp->ring_cookie >= adapter->num_rx_queues) { 1369 netdev_dbg(netdev, "Invalid action\n"); 1370 return -EINVAL; 1371 } 1372 1373 /* There are two ways to match the VLAN TCI: 1374 * 1. Match on PCP field and use vlan prio filter for it 1375 * 2. Match on complete TCI field and use flex filter for it 1376 */ 1377 if ((fsp->flow_type & FLOW_EXT) && 1378 fsp->m_ext.vlan_tci && 1379 fsp->m_ext.vlan_tci != htons(VLAN_PRIO_MASK) && 1380 fsp->m_ext.vlan_tci != VLAN_TCI_FULL_MASK) { 1381 netdev_dbg(netdev, "VLAN mask not supported\n"); 1382 return -EOPNOTSUPP; 1383 } 1384 1385 /* VLAN EtherType can only be matched by full mask. */ 1386 if ((fsp->flow_type & FLOW_EXT) && 1387 fsp->m_ext.vlan_etype && 1388 fsp->m_ext.vlan_etype != ETHER_TYPE_FULL_MASK) { 1389 netdev_dbg(netdev, "VLAN EtherType mask not supported\n"); 1390 return -EOPNOTSUPP; 1391 } 1392 1393 if (fsp->location >= IGC_MAX_RXNFC_RULES) { 1394 netdev_dbg(netdev, "Invalid location\n"); 1395 return -EINVAL; 1396 } 1397 1398 rule = kzalloc_obj(*rule); 1399 if (!rule) 1400 return -ENOMEM; 1401 1402 igc_ethtool_init_nfc_rule(rule, fsp); 1403 1404 mutex_lock(&adapter->nfc_rule_lock); 1405 1406 err = igc_ethtool_check_nfc_rule(adapter, rule); 1407 if (err) 1408 goto err; 1409 1410 old_rule = igc_get_nfc_rule(adapter, fsp->location); 1411 if (old_rule) 1412 igc_del_nfc_rule(adapter, old_rule); 1413 1414 err = igc_add_nfc_rule(adapter, rule); 1415 if (err) 1416 goto err; 1417 1418 mutex_unlock(&adapter->nfc_rule_lock); 1419 return 0; 1420 1421 err: 1422 mutex_unlock(&adapter->nfc_rule_lock); 1423 kfree(rule); 1424 return err; 1425 } 1426 1427 static int igc_ethtool_del_nfc_rule(struct igc_adapter *adapter, 1428 struct ethtool_rxnfc *cmd) 1429 { 1430 struct ethtool_rx_flow_spec *fsp = 1431 (struct ethtool_rx_flow_spec *)&cmd->fs; 1432 struct igc_nfc_rule *rule; 1433 1434 mutex_lock(&adapter->nfc_rule_lock); 1435 1436 rule = igc_get_nfc_rule(adapter, fsp->location); 1437 if (!rule) { 1438 mutex_unlock(&adapter->nfc_rule_lock); 1439 return -EINVAL; 1440 } 1441 1442 igc_del_nfc_rule(adapter, rule); 1443 1444 mutex_unlock(&adapter->nfc_rule_lock); 1445 return 0; 1446 } 1447 1448 static int igc_ethtool_set_rxnfc(struct net_device *dev, 1449 struct ethtool_rxnfc *cmd) 1450 { 1451 struct igc_adapter *adapter = netdev_priv(dev); 1452 1453 switch (cmd->cmd) { 1454 case ETHTOOL_SRXCLSRLINS: 1455 return igc_ethtool_add_nfc_rule(adapter, cmd); 1456 case ETHTOOL_SRXCLSRLDEL: 1457 return igc_ethtool_del_nfc_rule(adapter, cmd); 1458 default: 1459 return -EOPNOTSUPP; 1460 } 1461 } 1462 1463 /** 1464 * igc_write_rss_key - Program the RSS key into device registers 1465 * @adapter: board private structure 1466 * 1467 * Write the RSS key stored in adapter->rss_key to the IGC_RSSRK registers. 1468 * Each 32-bit chunk of the key is read using get_unaligned_le32() and written 1469 * to the appropriate register. 1470 */ 1471 void igc_write_rss_key(struct igc_adapter *adapter) 1472 { 1473 struct igc_hw *hw = &adapter->hw; 1474 u32 val; 1475 int i; 1476 1477 for (i = 0; i < IGC_RSS_KEY_SIZE / 4; i++) { 1478 val = get_unaligned_le32(&adapter->rss_key[i * 4]); 1479 wr32(IGC_RSSRK(i), val); 1480 } 1481 } 1482 1483 void igc_write_rss_indir_tbl(struct igc_adapter *adapter) 1484 { 1485 struct igc_hw *hw = &adapter->hw; 1486 u32 reg = IGC_RETA(0); 1487 u32 shift = 0; 1488 int i = 0; 1489 1490 while (i < IGC_RETA_SIZE) { 1491 u32 val = 0; 1492 int j; 1493 1494 for (j = 3; j >= 0; j--) { 1495 val <<= 8; 1496 val |= adapter->rss_indir_tbl[i + j]; 1497 } 1498 1499 wr32(reg, val << shift); 1500 reg += 4; 1501 i += 4; 1502 } 1503 } 1504 1505 static u32 igc_ethtool_get_rxfh_key_size(struct net_device *netdev) 1506 { 1507 return IGC_RSS_KEY_SIZE; 1508 } 1509 1510 static u32 igc_ethtool_get_rxfh_indir_size(struct net_device *netdev) 1511 { 1512 return IGC_RETA_SIZE; 1513 } 1514 1515 static int igc_ethtool_get_rxfh(struct net_device *netdev, 1516 struct ethtool_rxfh_param *rxfh) 1517 { 1518 struct igc_adapter *adapter = netdev_priv(netdev); 1519 int i; 1520 1521 rxfh->hfunc = ETH_RSS_HASH_TOP; 1522 1523 if (rxfh->indir) 1524 for (i = 0; i < IGC_RETA_SIZE; i++) 1525 rxfh->indir[i] = adapter->rss_indir_tbl[i]; 1526 1527 if (rxfh->key) 1528 memcpy(rxfh->key, adapter->rss_key, sizeof(adapter->rss_key)); 1529 1530 return 0; 1531 } 1532 1533 static int igc_ethtool_set_rxfh(struct net_device *netdev, 1534 struct ethtool_rxfh_param *rxfh, 1535 struct netlink_ext_ack *extack) 1536 { 1537 struct igc_adapter *adapter = netdev_priv(netdev); 1538 u32 num_queues; 1539 int i; 1540 1541 /* We do not allow change in unsupported parameters */ 1542 if (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE && 1543 rxfh->hfunc != ETH_RSS_HASH_TOP) 1544 return -EOPNOTSUPP; 1545 1546 if (rxfh->indir) { 1547 num_queues = adapter->rss_queues; 1548 1549 /* Verify user input. */ 1550 for (i = 0; i < IGC_RETA_SIZE; i++) 1551 if (rxfh->indir[i] >= num_queues) 1552 return -EINVAL; 1553 1554 for (i = 0; i < IGC_RETA_SIZE; i++) 1555 adapter->rss_indir_tbl[i] = rxfh->indir[i]; 1556 1557 igc_write_rss_indir_tbl(adapter); 1558 } 1559 1560 if (rxfh->key) { 1561 memcpy(adapter->rss_key, rxfh->key, sizeof(adapter->rss_key)); 1562 igc_write_rss_key(adapter); 1563 } 1564 1565 return 0; 1566 } 1567 1568 static void igc_ethtool_get_channels(struct net_device *netdev, 1569 struct ethtool_channels *ch) 1570 { 1571 struct igc_adapter *adapter = netdev_priv(netdev); 1572 1573 /* Report maximum channels */ 1574 ch->max_combined = igc_get_max_rss_queues(adapter); 1575 1576 /* Report info for other vector */ 1577 if (adapter->flags & IGC_FLAG_HAS_MSIX) { 1578 ch->max_other = NON_Q_VECTORS; 1579 ch->other_count = NON_Q_VECTORS; 1580 } 1581 1582 ch->combined_count = adapter->rss_queues; 1583 } 1584 1585 static int igc_ethtool_set_channels(struct net_device *netdev, 1586 struct ethtool_channels *ch) 1587 { 1588 struct igc_adapter *adapter = netdev_priv(netdev); 1589 unsigned int count = ch->combined_count; 1590 unsigned int max_combined = 0; 1591 1592 /* Verify they are not requesting separate vectors */ 1593 if (!count || ch->rx_count || ch->tx_count) 1594 return -EINVAL; 1595 1596 /* Verify other_count is valid and has not been changed */ 1597 if (ch->other_count != NON_Q_VECTORS) 1598 return -EINVAL; 1599 1600 /* Do not allow channel reconfiguration when any TSN qdisc is enabled */ 1601 if (adapter->flags & IGC_FLAG_TSN_ANY_ENABLED) 1602 return -EINVAL; 1603 1604 /* Verify the number of channels doesn't exceed hw limits */ 1605 max_combined = igc_get_max_rss_queues(adapter); 1606 if (count > max_combined) 1607 return -EINVAL; 1608 1609 if (count != adapter->rss_queues) { 1610 adapter->rss_queues = count; 1611 igc_set_flag_queue_pairs(adapter, max_combined); 1612 1613 /* Hardware has to reinitialize queues and interrupts to 1614 * match the new configuration. 1615 */ 1616 return igc_reinit_queues(adapter); 1617 } 1618 1619 return 0; 1620 } 1621 1622 static int igc_ethtool_get_ts_info(struct net_device *dev, 1623 struct kernel_ethtool_ts_info *info) 1624 { 1625 struct igc_adapter *adapter = netdev_priv(dev); 1626 1627 if (adapter->ptp_clock) 1628 info->phc_index = ptp_clock_index(adapter->ptp_clock); 1629 1630 switch (adapter->hw.mac.type) { 1631 case igc_i225: 1632 info->so_timestamping = 1633 SOF_TIMESTAMPING_TX_SOFTWARE | 1634 SOF_TIMESTAMPING_TX_HARDWARE | 1635 SOF_TIMESTAMPING_RX_HARDWARE | 1636 SOF_TIMESTAMPING_RAW_HARDWARE; 1637 1638 info->tx_types = 1639 BIT(HWTSTAMP_TX_OFF) | 1640 BIT(HWTSTAMP_TX_ON); 1641 1642 info->rx_filters = BIT(HWTSTAMP_FILTER_NONE); 1643 info->rx_filters |= BIT(HWTSTAMP_FILTER_ALL); 1644 1645 return 0; 1646 default: 1647 return -EOPNOTSUPP; 1648 } 1649 } 1650 1651 static u32 igc_ethtool_get_priv_flags(struct net_device *netdev) 1652 { 1653 struct igc_adapter *adapter = netdev_priv(netdev); 1654 u32 priv_flags = 0; 1655 1656 if (adapter->flags & IGC_FLAG_RX_LEGACY) 1657 priv_flags |= IGC_PRIV_FLAGS_LEGACY_RX; 1658 1659 if (adapter->flags & IGC_FLAG_TSN_REVERSE_TXQ_PRIO) 1660 priv_flags |= IGC_PRIV_FLAGS_REVERSE_TSN_TXQ_PRIO; 1661 1662 return priv_flags; 1663 } 1664 1665 static int igc_ethtool_set_priv_flags(struct net_device *netdev, u32 priv_flags) 1666 { 1667 struct igc_adapter *adapter = netdev_priv(netdev); 1668 unsigned int flags = adapter->flags; 1669 1670 flags &= ~(IGC_FLAG_RX_LEGACY | IGC_FLAG_TSN_REVERSE_TXQ_PRIO); 1671 if (priv_flags & IGC_PRIV_FLAGS_LEGACY_RX) 1672 flags |= IGC_FLAG_RX_LEGACY; 1673 1674 if (priv_flags & IGC_PRIV_FLAGS_REVERSE_TSN_TXQ_PRIO) 1675 flags |= IGC_FLAG_TSN_REVERSE_TXQ_PRIO; 1676 1677 if (flags != adapter->flags) { 1678 adapter->flags = flags; 1679 1680 /* reset interface to repopulate queues */ 1681 if (netif_running(netdev)) 1682 igc_reinit_locked(adapter); 1683 } 1684 1685 return 0; 1686 } 1687 1688 static int igc_ethtool_get_eee(struct net_device *netdev, 1689 struct ethtool_keee *edata) 1690 { 1691 struct igc_adapter *adapter = netdev_priv(netdev); 1692 struct igc_hw *hw = &adapter->hw; 1693 struct igc_phy_info *phy = &hw->phy; 1694 u16 eee_advert, eee_lp_advert; 1695 u32 eeer, ret_val; 1696 1697 /* EEE supported */ 1698 linkmode_set_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT, 1699 edata->supported); 1700 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1701 edata->supported); 1702 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, 1703 edata->supported); 1704 1705 /* EEE Advertisement 1 - reg 7.60 */ 1706 ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK << 1707 MMD_DEVADDR_SHIFT) | 1708 IGC_ANEG_EEE_AB1, 1709 &eee_advert); 1710 if (ret_val) { 1711 netdev_err(adapter->netdev, 1712 "Failed to read IEEE 7.60 register\n"); 1713 return -EINVAL; 1714 } 1715 1716 if (eee_advert & IGC_EEE_1000BT_MASK) 1717 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1718 edata->advertised); 1719 1720 if (eee_advert & IGC_EEE_100BT_MASK) 1721 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, 1722 edata->advertised); 1723 1724 /* EEE Advertisement 2 - reg 7.62 */ 1725 ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK << 1726 MMD_DEVADDR_SHIFT) | 1727 IGC_ANEG_EEE_AB2, 1728 &eee_advert); 1729 if (ret_val) { 1730 netdev_err(adapter->netdev, 1731 "Failed to read IEEE 7.62 register\n"); 1732 return -EINVAL; 1733 } 1734 1735 if (eee_advert & IGC_EEE_2500BT_MASK) 1736 linkmode_set_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT, 1737 edata->advertised); 1738 1739 /* EEE Link-Partner Ability 1 - reg 7.61 */ 1740 ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK << 1741 MMD_DEVADDR_SHIFT) | 1742 IGC_ANEG_EEE_LP_AB1, 1743 &eee_lp_advert); 1744 if (ret_val) { 1745 netdev_err(adapter->netdev, 1746 "Failed to read IEEE 7.61 register\n"); 1747 return -EINVAL; 1748 } 1749 1750 if (eee_lp_advert & IGC_LP_EEE_1000BT_MASK) 1751 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1752 edata->lp_advertised); 1753 1754 if (eee_lp_advert & IGC_LP_EEE_100BT_MASK) 1755 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, 1756 edata->lp_advertised); 1757 1758 /* EEE Link-Partner Ability 2 - reg 7.63 */ 1759 ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK << 1760 MMD_DEVADDR_SHIFT) | 1761 IGC_ANEG_EEE_LP_AB2, 1762 &eee_lp_advert); 1763 if (ret_val) { 1764 netdev_err(adapter->netdev, 1765 "Failed to read IEEE 7.63 register\n"); 1766 return -EINVAL; 1767 } 1768 1769 if (eee_lp_advert & IGC_LP_EEE_2500BT_MASK) 1770 linkmode_set_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT, 1771 edata->lp_advertised); 1772 1773 eeer = rd32(IGC_EEER); 1774 1775 /* EEE status on negotiated link */ 1776 if (eeer & IGC_EEER_EEE_NEG) 1777 edata->eee_active = true; 1778 1779 if (eeer & IGC_EEER_TX_LPI_EN) 1780 edata->tx_lpi_enabled = true; 1781 1782 edata->eee_enabled = hw->dev_spec._base.eee_enable; 1783 1784 /* Report correct negotiated EEE status for devices that 1785 * wrongly report EEE at half-duplex 1786 */ 1787 if (adapter->link_duplex == HALF_DUPLEX) { 1788 edata->eee_enabled = false; 1789 edata->eee_active = false; 1790 edata->tx_lpi_enabled = false; 1791 linkmode_zero(edata->advertised); 1792 } 1793 1794 return 0; 1795 } 1796 1797 static int igc_ethtool_set_eee(struct net_device *netdev, 1798 struct ethtool_keee *edata) 1799 { 1800 struct igc_adapter *adapter = netdev_priv(netdev); 1801 struct igc_hw *hw = &adapter->hw; 1802 struct ethtool_keee eee_curr; 1803 s32 ret_val; 1804 1805 memset(&eee_curr, 0, sizeof(struct ethtool_keee)); 1806 1807 ret_val = igc_ethtool_get_eee(netdev, &eee_curr); 1808 if (ret_val) { 1809 netdev_err(netdev, 1810 "Problem setting EEE advertisement options\n"); 1811 return -EINVAL; 1812 } 1813 1814 if (eee_curr.eee_enabled) { 1815 if (eee_curr.tx_lpi_enabled != edata->tx_lpi_enabled) { 1816 netdev_err(netdev, 1817 "Setting EEE tx-lpi is not supported\n"); 1818 return -EINVAL; 1819 } 1820 1821 /* Tx LPI timer is not implemented currently */ 1822 if (edata->tx_lpi_timer) { 1823 netdev_err(netdev, 1824 "Setting EEE Tx LPI timer is not supported\n"); 1825 return -EINVAL; 1826 } 1827 } else if (!edata->eee_enabled) { 1828 netdev_err(netdev, 1829 "Setting EEE options are not supported with EEE disabled\n"); 1830 return -EINVAL; 1831 } 1832 1833 if (hw->dev_spec._base.eee_enable != edata->eee_enabled) { 1834 hw->dev_spec._base.eee_enable = edata->eee_enabled; 1835 adapter->flags |= IGC_FLAG_EEE; 1836 1837 /* reset link */ 1838 if (netif_running(netdev)) 1839 igc_reinit_locked(adapter); 1840 else 1841 igc_reset(adapter); 1842 } 1843 1844 return 0; 1845 } 1846 1847 static int igc_ethtool_get_mm(struct net_device *netdev, 1848 struct ethtool_mm_state *cmd) 1849 { 1850 struct igc_adapter *adapter = netdev_priv(netdev); 1851 struct igc_fpe_t *fpe = &adapter->fpe; 1852 1853 ethtool_mmsv_get_mm(&fpe->mmsv, cmd); 1854 cmd->tx_min_frag_size = fpe->tx_min_frag_size; 1855 cmd->rx_min_frag_size = IGC_RX_MIN_FRAG_SIZE; 1856 1857 return 0; 1858 } 1859 1860 static int igc_ethtool_set_mm(struct net_device *netdev, 1861 struct ethtool_mm_cfg *cmd, 1862 struct netlink_ext_ack *extack) 1863 { 1864 struct igc_adapter *adapter = netdev_priv(netdev); 1865 struct igc_fpe_t *fpe = &adapter->fpe; 1866 1867 fpe->tx_min_frag_size = igc_fpe_get_supported_frag_size(cmd->tx_min_frag_size); 1868 if (fpe->tx_min_frag_size != cmd->tx_min_frag_size) 1869 NL_SET_ERR_MSG_MOD(extack, 1870 "tx-min-frag-size value set is unsupported. Rounded up to supported value (64, 128, 192, 256)"); 1871 1872 if (fpe->mmsv.pmac_enabled != cmd->pmac_enabled) { 1873 if (cmd->pmac_enabled) 1874 static_branch_inc(&igc_fpe_enabled); 1875 else 1876 static_branch_dec(&igc_fpe_enabled); 1877 } 1878 1879 ethtool_mmsv_set_mm(&fpe->mmsv, cmd); 1880 1881 return igc_tsn_offload_apply(adapter); 1882 } 1883 1884 /** 1885 * igc_ethtool_get_frame_ass_error - Get the frame assembly error count. 1886 * @reg_value: Register value for IGC_PRMEXCPRCNT 1887 * Return: The count of frame assembly errors. 1888 */ 1889 static u64 igc_ethtool_get_frame_ass_error(u32 reg_value) 1890 { 1891 /* Out of order statistics */ 1892 u32 ooo_frame_cnt, ooo_frag_cnt; 1893 u32 miss_frame_frag_cnt; 1894 1895 ooo_frame_cnt = FIELD_GET(IGC_PRMEXCPRCNT_OOO_FRAME_CNT, reg_value); 1896 ooo_frag_cnt = FIELD_GET(IGC_PRMEXCPRCNT_OOO_FRAG_CNT, reg_value); 1897 miss_frame_frag_cnt = FIELD_GET(IGC_PRMEXCPRCNT_MISS_FRAME_FRAG_CNT, 1898 reg_value); 1899 1900 return ooo_frame_cnt + ooo_frag_cnt + miss_frame_frag_cnt; 1901 } 1902 1903 static u64 igc_ethtool_get_frame_smd_error(u32 reg_value) 1904 { 1905 return FIELD_GET(IGC_PRMEXCPRCNT_OOO_SMDC, reg_value); 1906 } 1907 1908 static void igc_ethtool_get_mm_stats(struct net_device *dev, 1909 struct ethtool_mm_stats *stats) 1910 { 1911 struct igc_adapter *adapter = netdev_priv(dev); 1912 struct igc_hw *hw = &adapter->hw; 1913 u32 reg_value; 1914 1915 reg_value = rd32(IGC_PRMEXCPRCNT); 1916 1917 stats->MACMergeFrameAssErrorCount = igc_ethtool_get_frame_ass_error(reg_value); 1918 stats->MACMergeFrameSmdErrorCount = igc_ethtool_get_frame_smd_error(reg_value); 1919 stats->MACMergeFrameAssOkCount = rd32(IGC_PRMPTDRCNT); 1920 stats->MACMergeFragCountRx = rd32(IGC_PRMEVNTRCNT); 1921 stats->MACMergeFragCountTx = rd32(IGC_PRMEVNTTCNT); 1922 } 1923 1924 static int igc_ethtool_get_link_ksettings(struct net_device *netdev, 1925 struct ethtool_link_ksettings *cmd) 1926 { 1927 struct igc_adapter *adapter = netdev_priv(netdev); 1928 struct igc_hw *hw = &adapter->hw; 1929 u32 status; 1930 u32 speed; 1931 1932 ethtool_link_ksettings_zero_link_mode(cmd, supported); 1933 ethtool_link_ksettings_zero_link_mode(cmd, advertising); 1934 1935 /* supported link modes */ 1936 ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half); 1937 ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Full); 1938 ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Half); 1939 ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Full); 1940 ethtool_link_ksettings_add_link_mode(cmd, supported, 1000baseT_Full); 1941 ethtool_link_ksettings_add_link_mode(cmd, supported, 2500baseT_Full); 1942 1943 /* twisted pair */ 1944 cmd->base.port = PORT_TP; 1945 cmd->base.phy_address = hw->phy.addr; 1946 ethtool_link_ksettings_add_link_mode(cmd, supported, TP); 1947 ethtool_link_ksettings_add_link_mode(cmd, advertising, TP); 1948 1949 /* set autoneg settings */ 1950 ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg); 1951 if (hw->mac.autoneg_enabled) { 1952 ethtool_link_ksettings_add_link_mode(cmd, advertising, Autoneg); 1953 cmd->base.autoneg = AUTONEG_ENABLE; 1954 1955 /* advertising link modes only apply when autoneg is on */ 1956 if (hw->phy.autoneg_advertised & ADVERTISE_10_HALF) 1957 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1958 10baseT_Half); 1959 if (hw->phy.autoneg_advertised & ADVERTISE_10_FULL) 1960 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1961 10baseT_Full); 1962 if (hw->phy.autoneg_advertised & ADVERTISE_100_HALF) 1963 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1964 100baseT_Half); 1965 if (hw->phy.autoneg_advertised & ADVERTISE_100_FULL) 1966 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1967 100baseT_Full); 1968 if (hw->phy.autoneg_advertised & ADVERTISE_1000_FULL) 1969 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1970 1000baseT_Full); 1971 if (hw->phy.autoneg_advertised & ADVERTISE_2500_FULL) 1972 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1973 2500baseT_Full); 1974 1975 /* Set pause flow control advertising */ 1976 switch (hw->fc.requested_mode) { 1977 case igc_fc_full: 1978 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1979 Pause); 1980 break; 1981 case igc_fc_rx_pause: 1982 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1983 Pause); 1984 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1985 Asym_Pause); 1986 break; 1987 case igc_fc_tx_pause: 1988 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1989 Asym_Pause); 1990 break; 1991 default: 1992 break; 1993 } 1994 } else { 1995 cmd->base.autoneg = AUTONEG_DISABLE; 1996 } 1997 1998 /* Pause is always supported */ 1999 ethtool_link_ksettings_add_link_mode(cmd, supported, Pause); 2000 2001 status = pm_runtime_suspended(&adapter->pdev->dev) ? 2002 0 : rd32(IGC_STATUS); 2003 2004 if (status & IGC_STATUS_LU) { 2005 if (status & IGC_STATUS_SPEED_1000) { 2006 /* For I225, STATUS will indicate 1G speed in both 2007 * 1 Gbps and 2.5 Gbps link modes. 2008 * An additional bit is used 2009 * to differentiate between 1 Gbps and 2.5 Gbps. 2010 */ 2011 if (hw->mac.type == igc_i225 && 2012 (status & IGC_STATUS_SPEED_2500)) { 2013 speed = SPEED_2500; 2014 } else { 2015 speed = SPEED_1000; 2016 } 2017 } else if (status & IGC_STATUS_SPEED_100) { 2018 speed = SPEED_100; 2019 } else { 2020 speed = SPEED_10; 2021 } 2022 if ((status & IGC_STATUS_FD) || 2023 hw->phy.media_type != igc_media_type_copper) 2024 cmd->base.duplex = DUPLEX_FULL; 2025 else 2026 cmd->base.duplex = DUPLEX_HALF; 2027 } else { 2028 speed = SPEED_UNKNOWN; 2029 cmd->base.duplex = DUPLEX_UNKNOWN; 2030 } 2031 cmd->base.speed = speed; 2032 2033 /* MDI-X => 2; MDI =>1; Invalid =>0 */ 2034 if (hw->phy.media_type == igc_media_type_copper) 2035 cmd->base.eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X : 2036 ETH_TP_MDI; 2037 else 2038 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID; 2039 2040 if (hw->phy.mdix == AUTO_ALL_MODES) 2041 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO; 2042 else 2043 cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix; 2044 2045 return 0; 2046 } 2047 2048 /** 2049 * igc_handle_autoneg_disabled - Configure forced speed/duplex settings 2050 * @adapter: private driver structure 2051 * @speed: requested speed (must be SPEED_10 or SPEED_100) 2052 * @duplex: requested duplex 2053 * 2054 * Records forced speed/duplex when autoneg is disabled. 2055 * Caller must validate speed before calling this function. 2056 */ 2057 static void igc_handle_autoneg_disabled(struct igc_adapter *adapter, u32 speed, 2058 u8 duplex) 2059 { 2060 struct igc_mac_info *mac = &adapter->hw.mac; 2061 2062 switch (speed) { 2063 case SPEED_10: 2064 mac->forced_speed_duplex = (duplex == DUPLEX_FULL) ? 2065 IGC_FORCED_10F : IGC_FORCED_10H; 2066 break; 2067 case SPEED_100: 2068 mac->forced_speed_duplex = (duplex == DUPLEX_FULL) ? 2069 IGC_FORCED_100F : IGC_FORCED_100H; 2070 break; 2071 default: 2072 WARN_ONCE(1, "Unsupported speed %u\n", speed); 2073 return; 2074 } 2075 2076 mac->autoneg_enabled = false; 2077 } 2078 2079 /** 2080 * igc_handle_autoneg_enabled - Configure autonegotiation advertisement 2081 * @adapter: private driver structure 2082 * @cmd: ethtool link ksettings from user 2083 * 2084 * Records advertised speeds and flow control settings when autoneg 2085 * is enabled. 2086 */ 2087 static void igc_handle_autoneg_enabled(struct igc_adapter *adapter, 2088 const struct ethtool_link_ksettings *cmd) 2089 { 2090 struct igc_hw *hw = &adapter->hw; 2091 u16 advertised = 0; 2092 2093 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2094 2500baseT_Full)) 2095 advertised |= ADVERTISE_2500_FULL; 2096 2097 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2098 1000baseT_Full)) 2099 advertised |= ADVERTISE_1000_FULL; 2100 2101 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2102 100baseT_Full)) 2103 advertised |= ADVERTISE_100_FULL; 2104 2105 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2106 100baseT_Half)) 2107 advertised |= ADVERTISE_100_HALF; 2108 2109 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2110 10baseT_Full)) 2111 advertised |= ADVERTISE_10_FULL; 2112 2113 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2114 10baseT_Half)) 2115 advertised |= ADVERTISE_10_HALF; 2116 2117 hw->mac.autoneg_enabled = true; 2118 hw->phy.autoneg_advertised = advertised; 2119 if (adapter->fc_autoneg) 2120 hw->fc.requested_mode = igc_fc_default; 2121 } 2122 2123 static int 2124 igc_ethtool_set_link_ksettings(struct net_device *netdev, 2125 const struct ethtool_link_ksettings *cmd) 2126 { 2127 struct igc_adapter *adapter = netdev_priv(netdev); 2128 struct net_device *dev = adapter->netdev; 2129 struct igc_hw *hw = &adapter->hw; 2130 2131 /* When adapter in resetting mode, autoneg/speed/duplex 2132 * cannot be changed 2133 */ 2134 if (igc_check_reset_block(hw)) { 2135 netdev_err(dev, "Cannot change link characteristics when reset is active\n"); 2136 return -EINVAL; 2137 } 2138 2139 if (cmd->base.autoneg != AUTONEG_ENABLE && 2140 cmd->base.autoneg != AUTONEG_DISABLE) { 2141 netdev_info(dev, "Unsupported autoneg setting\n"); 2142 return -EINVAL; 2143 } 2144 2145 /* MDI setting is only allowed when autoneg enabled because 2146 * some hardware doesn't allow MDI setting when speed or 2147 * duplex is forced. 2148 */ 2149 if (cmd->base.eth_tp_mdix_ctrl) { 2150 if (cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO && 2151 cmd->base.autoneg != AUTONEG_ENABLE) { 2152 netdev_err(dev, "Forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n"); 2153 return -EINVAL; 2154 } 2155 } 2156 2157 if (cmd->base.autoneg == AUTONEG_DISABLE) { 2158 if (cmd->base.speed != SPEED_10 && cmd->base.speed != SPEED_100) { 2159 netdev_info(dev, "Unsupported speed for forced link\n"); 2160 return -EINVAL; 2161 } 2162 if (cmd->base.duplex != DUPLEX_HALF && cmd->base.duplex != DUPLEX_FULL) { 2163 netdev_info(dev, "Duplex must be half or full for forced link\n"); 2164 return -EINVAL; 2165 } 2166 } 2167 2168 while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 2169 usleep_range(1000, 2000); 2170 2171 if (cmd->base.autoneg == AUTONEG_ENABLE) 2172 igc_handle_autoneg_enabled(adapter, cmd); 2173 else 2174 igc_handle_autoneg_disabled(adapter, cmd->base.speed, 2175 cmd->base.duplex); 2176 2177 /* MDI-X => 2; MDI => 1; Auto => 3 */ 2178 if (cmd->base.eth_tp_mdix_ctrl) { 2179 /* fix up the value for auto (3 => 0) as zero is mapped 2180 * internally to auto 2181 */ 2182 if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO) 2183 hw->phy.mdix = AUTO_ALL_MODES; 2184 else 2185 hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl; 2186 } 2187 2188 /* reset the link */ 2189 if (netif_running(adapter->netdev)) { 2190 igc_down(adapter); 2191 igc_up(adapter); 2192 } else { 2193 igc_reset(adapter); 2194 } 2195 2196 clear_bit(__IGC_RESETTING, &adapter->state); 2197 2198 return 0; 2199 } 2200 2201 static void igc_ethtool_diag_test(struct net_device *netdev, 2202 struct ethtool_test *eth_test, u64 *data) 2203 { 2204 struct igc_adapter *adapter = netdev_priv(netdev); 2205 bool if_running = netif_running(netdev); 2206 2207 if (eth_test->flags == ETH_TEST_FL_OFFLINE) { 2208 netdev_info(adapter->netdev, "Offline testing starting"); 2209 set_bit(__IGC_TESTING, &adapter->state); 2210 2211 /* power up PHY for link test */ 2212 igc_power_up_phy_copper(&adapter->hw); 2213 2214 /* Link test performed before hardware reset so autoneg doesn't 2215 * interfere with test result 2216 */ 2217 if (!igc_link_test(adapter, &data[TEST_LINK])) 2218 eth_test->flags |= ETH_TEST_FL_FAILED; 2219 2220 if (if_running) 2221 igc_close(netdev); 2222 else 2223 igc_reset(adapter); 2224 2225 netdev_info(adapter->netdev, "Register testing starting"); 2226 if (!igc_reg_test(adapter, &data[TEST_REG])) 2227 eth_test->flags |= ETH_TEST_FL_FAILED; 2228 2229 igc_reset(adapter); 2230 2231 netdev_info(adapter->netdev, "EEPROM testing starting"); 2232 if (!igc_eeprom_test(adapter, &data[TEST_EEP])) 2233 eth_test->flags |= ETH_TEST_FL_FAILED; 2234 2235 igc_reset(adapter); 2236 2237 /* loopback and interrupt tests 2238 * will be implemented in the future 2239 */ 2240 data[TEST_LOOP] = 0; 2241 data[TEST_IRQ] = 0; 2242 2243 clear_bit(__IGC_TESTING, &adapter->state); 2244 if (if_running) 2245 igc_open(netdev); 2246 } else { 2247 netdev_info(adapter->netdev, "Online testing starting"); 2248 2249 /* register, eeprom, intr and loopback tests not run online */ 2250 data[TEST_REG] = 0; 2251 data[TEST_EEP] = 0; 2252 data[TEST_IRQ] = 0; 2253 data[TEST_LOOP] = 0; 2254 2255 if (!igc_link_test(adapter, &data[TEST_LINK])) 2256 eth_test->flags |= ETH_TEST_FL_FAILED; 2257 } 2258 2259 msleep_interruptible(4 * 1000); 2260 } 2261 2262 static const struct ethtool_ops igc_ethtool_ops = { 2263 .supported_coalesce_params = ETHTOOL_COALESCE_USECS, 2264 .get_drvinfo = igc_ethtool_get_drvinfo, 2265 .get_regs_len = igc_ethtool_get_regs_len, 2266 .get_regs = igc_ethtool_get_regs, 2267 .get_wol = igc_ethtool_get_wol, 2268 .set_wol = igc_ethtool_set_wol, 2269 .get_msglevel = igc_ethtool_get_msglevel, 2270 .set_msglevel = igc_ethtool_set_msglevel, 2271 .nway_reset = igc_ethtool_nway_reset, 2272 .get_link = igc_ethtool_get_link, 2273 .get_eeprom_len = igc_ethtool_get_eeprom_len, 2274 .get_eeprom = igc_ethtool_get_eeprom, 2275 .set_eeprom = igc_ethtool_set_eeprom, 2276 .get_ringparam = igc_ethtool_get_ringparam, 2277 .set_ringparam = igc_ethtool_set_ringparam, 2278 .get_pauseparam = igc_ethtool_get_pauseparam, 2279 .set_pauseparam = igc_ethtool_set_pauseparam, 2280 .get_strings = igc_ethtool_get_strings, 2281 .get_sset_count = igc_ethtool_get_sset_count, 2282 .get_ethtool_stats = igc_ethtool_get_stats, 2283 .get_coalesce = igc_ethtool_get_coalesce, 2284 .set_coalesce = igc_ethtool_set_coalesce, 2285 .get_rxnfc = igc_ethtool_get_rxnfc, 2286 .set_rxnfc = igc_ethtool_set_rxnfc, 2287 .get_rx_ring_count = igc_ethtool_get_rx_ring_count, 2288 .get_rxfh_key_size = igc_ethtool_get_rxfh_key_size, 2289 .get_rxfh_indir_size = igc_ethtool_get_rxfh_indir_size, 2290 .get_rxfh = igc_ethtool_get_rxfh, 2291 .set_rxfh = igc_ethtool_set_rxfh, 2292 .get_rxfh_fields = igc_ethtool_get_rxfh_fields, 2293 .set_rxfh_fields = igc_ethtool_set_rxfh_fields, 2294 .get_ts_info = igc_ethtool_get_ts_info, 2295 .get_channels = igc_ethtool_get_channels, 2296 .set_channels = igc_ethtool_set_channels, 2297 .get_priv_flags = igc_ethtool_get_priv_flags, 2298 .set_priv_flags = igc_ethtool_set_priv_flags, 2299 .get_eee = igc_ethtool_get_eee, 2300 .set_eee = igc_ethtool_set_eee, 2301 .get_link_ksettings = igc_ethtool_get_link_ksettings, 2302 .set_link_ksettings = igc_ethtool_set_link_ksettings, 2303 .self_test = igc_ethtool_diag_test, 2304 .get_mm = igc_ethtool_get_mm, 2305 .get_mm_stats = igc_ethtool_get_mm_stats, 2306 .set_mm = igc_ethtool_set_mm, 2307 }; 2308 2309 void igc_ethtool_set_ops(struct net_device *netdev) 2310 { 2311 netdev->ethtool_ops = &igc_ethtool_ops; 2312 } 2313