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(sizeof(*rule), GFP_KERNEL); 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 void igc_write_rss_indir_tbl(struct igc_adapter *adapter) 1464 { 1465 struct igc_hw *hw = &adapter->hw; 1466 u32 reg = IGC_RETA(0); 1467 u32 shift = 0; 1468 int i = 0; 1469 1470 while (i < IGC_RETA_SIZE) { 1471 u32 val = 0; 1472 int j; 1473 1474 for (j = 3; j >= 0; j--) { 1475 val <<= 8; 1476 val |= adapter->rss_indir_tbl[i + j]; 1477 } 1478 1479 wr32(reg, val << shift); 1480 reg += 4; 1481 i += 4; 1482 } 1483 } 1484 1485 static u32 igc_ethtool_get_rxfh_indir_size(struct net_device *netdev) 1486 { 1487 return IGC_RETA_SIZE; 1488 } 1489 1490 static int igc_ethtool_get_rxfh(struct net_device *netdev, 1491 struct ethtool_rxfh_param *rxfh) 1492 { 1493 struct igc_adapter *adapter = netdev_priv(netdev); 1494 int i; 1495 1496 rxfh->hfunc = ETH_RSS_HASH_TOP; 1497 if (!rxfh->indir) 1498 return 0; 1499 for (i = 0; i < IGC_RETA_SIZE; i++) 1500 rxfh->indir[i] = adapter->rss_indir_tbl[i]; 1501 1502 return 0; 1503 } 1504 1505 static int igc_ethtool_set_rxfh(struct net_device *netdev, 1506 struct ethtool_rxfh_param *rxfh, 1507 struct netlink_ext_ack *extack) 1508 { 1509 struct igc_adapter *adapter = netdev_priv(netdev); 1510 u32 num_queues; 1511 int i; 1512 1513 /* We do not allow change in unsupported parameters */ 1514 if (rxfh->key || 1515 (rxfh->hfunc != ETH_RSS_HASH_NO_CHANGE && 1516 rxfh->hfunc != ETH_RSS_HASH_TOP)) 1517 return -EOPNOTSUPP; 1518 if (!rxfh->indir) 1519 return 0; 1520 1521 num_queues = adapter->rss_queues; 1522 1523 /* Verify user input. */ 1524 for (i = 0; i < IGC_RETA_SIZE; i++) 1525 if (rxfh->indir[i] >= num_queues) 1526 return -EINVAL; 1527 1528 for (i = 0; i < IGC_RETA_SIZE; i++) 1529 adapter->rss_indir_tbl[i] = rxfh->indir[i]; 1530 1531 igc_write_rss_indir_tbl(adapter); 1532 1533 return 0; 1534 } 1535 1536 static void igc_ethtool_get_channels(struct net_device *netdev, 1537 struct ethtool_channels *ch) 1538 { 1539 struct igc_adapter *adapter = netdev_priv(netdev); 1540 1541 /* Report maximum channels */ 1542 ch->max_combined = igc_get_max_rss_queues(adapter); 1543 1544 /* Report info for other vector */ 1545 if (adapter->flags & IGC_FLAG_HAS_MSIX) { 1546 ch->max_other = NON_Q_VECTORS; 1547 ch->other_count = NON_Q_VECTORS; 1548 } 1549 1550 ch->combined_count = adapter->rss_queues; 1551 } 1552 1553 static int igc_ethtool_set_channels(struct net_device *netdev, 1554 struct ethtool_channels *ch) 1555 { 1556 struct igc_adapter *adapter = netdev_priv(netdev); 1557 unsigned int count = ch->combined_count; 1558 unsigned int max_combined = 0; 1559 1560 /* Verify they are not requesting separate vectors */ 1561 if (!count || ch->rx_count || ch->tx_count) 1562 return -EINVAL; 1563 1564 /* Verify other_count is valid and has not been changed */ 1565 if (ch->other_count != NON_Q_VECTORS) 1566 return -EINVAL; 1567 1568 /* Do not allow channel reconfiguration when mqprio is enabled */ 1569 if (adapter->strict_priority_enable) 1570 return -EINVAL; 1571 1572 /* Verify the number of channels doesn't exceed hw limits */ 1573 max_combined = igc_get_max_rss_queues(adapter); 1574 if (count > max_combined) 1575 return -EINVAL; 1576 1577 if (count != adapter->rss_queues) { 1578 adapter->rss_queues = count; 1579 igc_set_flag_queue_pairs(adapter, max_combined); 1580 1581 /* Hardware has to reinitialize queues and interrupts to 1582 * match the new configuration. 1583 */ 1584 return igc_reinit_queues(adapter); 1585 } 1586 1587 return 0; 1588 } 1589 1590 static int igc_ethtool_get_ts_info(struct net_device *dev, 1591 struct kernel_ethtool_ts_info *info) 1592 { 1593 struct igc_adapter *adapter = netdev_priv(dev); 1594 1595 if (adapter->ptp_clock) 1596 info->phc_index = ptp_clock_index(adapter->ptp_clock); 1597 1598 switch (adapter->hw.mac.type) { 1599 case igc_i225: 1600 info->so_timestamping = 1601 SOF_TIMESTAMPING_TX_SOFTWARE | 1602 SOF_TIMESTAMPING_TX_HARDWARE | 1603 SOF_TIMESTAMPING_RX_HARDWARE | 1604 SOF_TIMESTAMPING_RAW_HARDWARE; 1605 1606 info->tx_types = 1607 BIT(HWTSTAMP_TX_OFF) | 1608 BIT(HWTSTAMP_TX_ON); 1609 1610 info->rx_filters = BIT(HWTSTAMP_FILTER_NONE); 1611 info->rx_filters |= BIT(HWTSTAMP_FILTER_ALL); 1612 1613 return 0; 1614 default: 1615 return -EOPNOTSUPP; 1616 } 1617 } 1618 1619 static u32 igc_ethtool_get_priv_flags(struct net_device *netdev) 1620 { 1621 struct igc_adapter *adapter = netdev_priv(netdev); 1622 u32 priv_flags = 0; 1623 1624 if (adapter->flags & IGC_FLAG_RX_LEGACY) 1625 priv_flags |= IGC_PRIV_FLAGS_LEGACY_RX; 1626 1627 if (adapter->flags & IGC_FLAG_TSN_REVERSE_TXQ_PRIO) 1628 priv_flags |= IGC_PRIV_FLAGS_REVERSE_TSN_TXQ_PRIO; 1629 1630 return priv_flags; 1631 } 1632 1633 static int igc_ethtool_set_priv_flags(struct net_device *netdev, u32 priv_flags) 1634 { 1635 struct igc_adapter *adapter = netdev_priv(netdev); 1636 unsigned int flags = adapter->flags; 1637 1638 flags &= ~(IGC_FLAG_RX_LEGACY | IGC_FLAG_TSN_REVERSE_TXQ_PRIO); 1639 if (priv_flags & IGC_PRIV_FLAGS_LEGACY_RX) 1640 flags |= IGC_FLAG_RX_LEGACY; 1641 1642 if (priv_flags & IGC_PRIV_FLAGS_REVERSE_TSN_TXQ_PRIO) 1643 flags |= IGC_FLAG_TSN_REVERSE_TXQ_PRIO; 1644 1645 if (flags != adapter->flags) { 1646 adapter->flags = flags; 1647 1648 /* reset interface to repopulate queues */ 1649 if (netif_running(netdev)) 1650 igc_reinit_locked(adapter); 1651 } 1652 1653 return 0; 1654 } 1655 1656 static int igc_ethtool_get_eee(struct net_device *netdev, 1657 struct ethtool_keee *edata) 1658 { 1659 struct igc_adapter *adapter = netdev_priv(netdev); 1660 struct igc_hw *hw = &adapter->hw; 1661 struct igc_phy_info *phy = &hw->phy; 1662 u16 eee_advert, eee_lp_advert; 1663 u32 eeer, ret_val; 1664 1665 /* EEE supported */ 1666 linkmode_set_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT, 1667 edata->supported); 1668 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1669 edata->supported); 1670 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, 1671 edata->supported); 1672 1673 /* EEE Advertisement 1 - reg 7.60 */ 1674 ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK << 1675 MMD_DEVADDR_SHIFT) | 1676 IGC_ANEG_EEE_AB1, 1677 &eee_advert); 1678 if (ret_val) { 1679 netdev_err(adapter->netdev, 1680 "Failed to read IEEE 7.60 register\n"); 1681 return -EINVAL; 1682 } 1683 1684 if (eee_advert & IGC_EEE_1000BT_MASK) 1685 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1686 edata->advertised); 1687 1688 if (eee_advert & IGC_EEE_100BT_MASK) 1689 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, 1690 edata->advertised); 1691 1692 /* EEE Advertisement 2 - reg 7.62 */ 1693 ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK << 1694 MMD_DEVADDR_SHIFT) | 1695 IGC_ANEG_EEE_AB2, 1696 &eee_advert); 1697 if (ret_val) { 1698 netdev_err(adapter->netdev, 1699 "Failed to read IEEE 7.62 register\n"); 1700 return -EINVAL; 1701 } 1702 1703 if (eee_advert & IGC_EEE_2500BT_MASK) 1704 linkmode_set_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT, 1705 edata->advertised); 1706 1707 /* EEE Link-Partner Ability 1 - reg 7.61 */ 1708 ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK << 1709 MMD_DEVADDR_SHIFT) | 1710 IGC_ANEG_EEE_LP_AB1, 1711 &eee_lp_advert); 1712 if (ret_val) { 1713 netdev_err(adapter->netdev, 1714 "Failed to read IEEE 7.61 register\n"); 1715 return -EINVAL; 1716 } 1717 1718 if (eee_lp_advert & IGC_LP_EEE_1000BT_MASK) 1719 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT, 1720 edata->lp_advertised); 1721 1722 if (eee_lp_advert & IGC_LP_EEE_100BT_MASK) 1723 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, 1724 edata->lp_advertised); 1725 1726 /* EEE Link-Partner Ability 2 - reg 7.63 */ 1727 ret_val = phy->ops.read_reg(hw, (STANDARD_AN_REG_MASK << 1728 MMD_DEVADDR_SHIFT) | 1729 IGC_ANEG_EEE_LP_AB2, 1730 &eee_lp_advert); 1731 if (ret_val) { 1732 netdev_err(adapter->netdev, 1733 "Failed to read IEEE 7.63 register\n"); 1734 return -EINVAL; 1735 } 1736 1737 if (eee_lp_advert & IGC_LP_EEE_2500BT_MASK) 1738 linkmode_set_bit(ETHTOOL_LINK_MODE_2500baseT_Full_BIT, 1739 edata->lp_advertised); 1740 1741 eeer = rd32(IGC_EEER); 1742 1743 /* EEE status on negotiated link */ 1744 if (eeer & IGC_EEER_EEE_NEG) 1745 edata->eee_active = true; 1746 1747 if (eeer & IGC_EEER_TX_LPI_EN) 1748 edata->tx_lpi_enabled = true; 1749 1750 edata->eee_enabled = hw->dev_spec._base.eee_enable; 1751 1752 /* Report correct negotiated EEE status for devices that 1753 * wrongly report EEE at half-duplex 1754 */ 1755 if (adapter->link_duplex == HALF_DUPLEX) { 1756 edata->eee_enabled = false; 1757 edata->eee_active = false; 1758 edata->tx_lpi_enabled = false; 1759 linkmode_zero(edata->advertised); 1760 } 1761 1762 return 0; 1763 } 1764 1765 static int igc_ethtool_set_eee(struct net_device *netdev, 1766 struct ethtool_keee *edata) 1767 { 1768 struct igc_adapter *adapter = netdev_priv(netdev); 1769 struct igc_hw *hw = &adapter->hw; 1770 struct ethtool_keee eee_curr; 1771 s32 ret_val; 1772 1773 memset(&eee_curr, 0, sizeof(struct ethtool_keee)); 1774 1775 ret_val = igc_ethtool_get_eee(netdev, &eee_curr); 1776 if (ret_val) { 1777 netdev_err(netdev, 1778 "Problem setting EEE advertisement options\n"); 1779 return -EINVAL; 1780 } 1781 1782 if (eee_curr.eee_enabled) { 1783 if (eee_curr.tx_lpi_enabled != edata->tx_lpi_enabled) { 1784 netdev_err(netdev, 1785 "Setting EEE tx-lpi is not supported\n"); 1786 return -EINVAL; 1787 } 1788 1789 /* Tx LPI timer is not implemented currently */ 1790 if (edata->tx_lpi_timer) { 1791 netdev_err(netdev, 1792 "Setting EEE Tx LPI timer is not supported\n"); 1793 return -EINVAL; 1794 } 1795 } else if (!edata->eee_enabled) { 1796 netdev_err(netdev, 1797 "Setting EEE options are not supported with EEE disabled\n"); 1798 return -EINVAL; 1799 } 1800 1801 if (hw->dev_spec._base.eee_enable != edata->eee_enabled) { 1802 hw->dev_spec._base.eee_enable = edata->eee_enabled; 1803 adapter->flags |= IGC_FLAG_EEE; 1804 1805 /* reset link */ 1806 if (netif_running(netdev)) 1807 igc_reinit_locked(adapter); 1808 else 1809 igc_reset(adapter); 1810 } 1811 1812 return 0; 1813 } 1814 1815 static int igc_ethtool_get_mm(struct net_device *netdev, 1816 struct ethtool_mm_state *cmd) 1817 { 1818 struct igc_adapter *adapter = netdev_priv(netdev); 1819 struct igc_fpe_t *fpe = &adapter->fpe; 1820 1821 ethtool_mmsv_get_mm(&fpe->mmsv, cmd); 1822 cmd->tx_min_frag_size = fpe->tx_min_frag_size; 1823 cmd->rx_min_frag_size = IGC_RX_MIN_FRAG_SIZE; 1824 1825 return 0; 1826 } 1827 1828 static int igc_ethtool_set_mm(struct net_device *netdev, 1829 struct ethtool_mm_cfg *cmd, 1830 struct netlink_ext_ack *extack) 1831 { 1832 struct igc_adapter *adapter = netdev_priv(netdev); 1833 struct igc_fpe_t *fpe = &adapter->fpe; 1834 1835 fpe->tx_min_frag_size = igc_fpe_get_supported_frag_size(cmd->tx_min_frag_size); 1836 if (fpe->tx_min_frag_size != cmd->tx_min_frag_size) 1837 NL_SET_ERR_MSG_MOD(extack, 1838 "tx-min-frag-size value set is unsupported. Rounded up to supported value (64, 128, 192, 256)"); 1839 1840 if (fpe->mmsv.pmac_enabled != cmd->pmac_enabled) { 1841 if (cmd->pmac_enabled) 1842 static_branch_inc(&igc_fpe_enabled); 1843 else 1844 static_branch_dec(&igc_fpe_enabled); 1845 } 1846 1847 ethtool_mmsv_set_mm(&fpe->mmsv, cmd); 1848 1849 return igc_tsn_offload_apply(adapter); 1850 } 1851 1852 /** 1853 * igc_ethtool_get_frame_ass_error - Get the frame assembly error count. 1854 * @reg_value: Register value for IGC_PRMEXCPRCNT 1855 * Return: The count of frame assembly errors. 1856 */ 1857 static u64 igc_ethtool_get_frame_ass_error(u32 reg_value) 1858 { 1859 /* Out of order statistics */ 1860 u32 ooo_frame_cnt, ooo_frag_cnt; 1861 u32 miss_frame_frag_cnt; 1862 1863 ooo_frame_cnt = FIELD_GET(IGC_PRMEXCPRCNT_OOO_FRAME_CNT, reg_value); 1864 ooo_frag_cnt = FIELD_GET(IGC_PRMEXCPRCNT_OOO_FRAG_CNT, reg_value); 1865 miss_frame_frag_cnt = FIELD_GET(IGC_PRMEXCPRCNT_MISS_FRAME_FRAG_CNT, 1866 reg_value); 1867 1868 return ooo_frame_cnt + ooo_frag_cnt + miss_frame_frag_cnt; 1869 } 1870 1871 static u64 igc_ethtool_get_frame_smd_error(u32 reg_value) 1872 { 1873 return FIELD_GET(IGC_PRMEXCPRCNT_OOO_SMDC, reg_value); 1874 } 1875 1876 static void igc_ethtool_get_mm_stats(struct net_device *dev, 1877 struct ethtool_mm_stats *stats) 1878 { 1879 struct igc_adapter *adapter = netdev_priv(dev); 1880 struct igc_hw *hw = &adapter->hw; 1881 u32 reg_value; 1882 1883 reg_value = rd32(IGC_PRMEXCPRCNT); 1884 1885 stats->MACMergeFrameAssErrorCount = igc_ethtool_get_frame_ass_error(reg_value); 1886 stats->MACMergeFrameSmdErrorCount = igc_ethtool_get_frame_smd_error(reg_value); 1887 stats->MACMergeFrameAssOkCount = rd32(IGC_PRMPTDRCNT); 1888 stats->MACMergeFragCountRx = rd32(IGC_PRMEVNTRCNT); 1889 stats->MACMergeFragCountTx = rd32(IGC_PRMEVNTTCNT); 1890 } 1891 1892 static int igc_ethtool_get_link_ksettings(struct net_device *netdev, 1893 struct ethtool_link_ksettings *cmd) 1894 { 1895 struct igc_adapter *adapter = netdev_priv(netdev); 1896 struct igc_hw *hw = &adapter->hw; 1897 u32 status; 1898 u32 speed; 1899 1900 ethtool_link_ksettings_zero_link_mode(cmd, supported); 1901 ethtool_link_ksettings_zero_link_mode(cmd, advertising); 1902 1903 /* supported link modes */ 1904 ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half); 1905 ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Full); 1906 ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Half); 1907 ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Full); 1908 ethtool_link_ksettings_add_link_mode(cmd, supported, 1000baseT_Full); 1909 ethtool_link_ksettings_add_link_mode(cmd, supported, 2500baseT_Full); 1910 1911 /* twisted pair */ 1912 cmd->base.port = PORT_TP; 1913 cmd->base.phy_address = hw->phy.addr; 1914 ethtool_link_ksettings_add_link_mode(cmd, supported, TP); 1915 ethtool_link_ksettings_add_link_mode(cmd, advertising, TP); 1916 1917 /* advertising link modes */ 1918 if (hw->phy.autoneg_advertised & ADVERTISE_10_HALF) 1919 ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Half); 1920 if (hw->phy.autoneg_advertised & ADVERTISE_10_FULL) 1921 ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Full); 1922 if (hw->phy.autoneg_advertised & ADVERTISE_100_HALF) 1923 ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Half); 1924 if (hw->phy.autoneg_advertised & ADVERTISE_100_FULL) 1925 ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Full); 1926 if (hw->phy.autoneg_advertised & ADVERTISE_1000_FULL) 1927 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1000baseT_Full); 1928 if (hw->phy.autoneg_advertised & ADVERTISE_2500_FULL) 1929 ethtool_link_ksettings_add_link_mode(cmd, advertising, 2500baseT_Full); 1930 1931 /* set autoneg settings */ 1932 ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg); 1933 ethtool_link_ksettings_add_link_mode(cmd, advertising, Autoneg); 1934 1935 /* Set pause flow control settings */ 1936 ethtool_link_ksettings_add_link_mode(cmd, supported, Pause); 1937 1938 switch (hw->fc.requested_mode) { 1939 case igc_fc_full: 1940 ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause); 1941 break; 1942 case igc_fc_rx_pause: 1943 ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause); 1944 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1945 Asym_Pause); 1946 break; 1947 case igc_fc_tx_pause: 1948 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1949 Asym_Pause); 1950 break; 1951 default: 1952 break; 1953 } 1954 1955 status = pm_runtime_suspended(&adapter->pdev->dev) ? 1956 0 : rd32(IGC_STATUS); 1957 1958 if (status & IGC_STATUS_LU) { 1959 if (status & IGC_STATUS_SPEED_1000) { 1960 /* For I225, STATUS will indicate 1G speed in both 1961 * 1 Gbps and 2.5 Gbps link modes. 1962 * An additional bit is used 1963 * to differentiate between 1 Gbps and 2.5 Gbps. 1964 */ 1965 if (hw->mac.type == igc_i225 && 1966 (status & IGC_STATUS_SPEED_2500)) { 1967 speed = SPEED_2500; 1968 } else { 1969 speed = SPEED_1000; 1970 } 1971 } else if (status & IGC_STATUS_SPEED_100) { 1972 speed = SPEED_100; 1973 } else { 1974 speed = SPEED_10; 1975 } 1976 if ((status & IGC_STATUS_FD) || 1977 hw->phy.media_type != igc_media_type_copper) 1978 cmd->base.duplex = DUPLEX_FULL; 1979 else 1980 cmd->base.duplex = DUPLEX_HALF; 1981 } else { 1982 speed = SPEED_UNKNOWN; 1983 cmd->base.duplex = DUPLEX_UNKNOWN; 1984 } 1985 cmd->base.speed = speed; 1986 cmd->base.autoneg = AUTONEG_ENABLE; 1987 1988 /* MDI-X => 2; MDI =>1; Invalid =>0 */ 1989 if (hw->phy.media_type == igc_media_type_copper) 1990 cmd->base.eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X : 1991 ETH_TP_MDI; 1992 else 1993 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID; 1994 1995 if (hw->phy.mdix == AUTO_ALL_MODES) 1996 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO; 1997 else 1998 cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix; 1999 2000 return 0; 2001 } 2002 2003 static int 2004 igc_ethtool_set_link_ksettings(struct net_device *netdev, 2005 const struct ethtool_link_ksettings *cmd) 2006 { 2007 struct igc_adapter *adapter = netdev_priv(netdev); 2008 struct net_device *dev = adapter->netdev; 2009 struct igc_hw *hw = &adapter->hw; 2010 u16 advertised = 0; 2011 2012 /* When adapter in resetting mode, autoneg/speed/duplex 2013 * cannot be changed 2014 */ 2015 if (igc_check_reset_block(hw)) { 2016 netdev_err(dev, "Cannot change link characteristics when reset is active\n"); 2017 return -EINVAL; 2018 } 2019 2020 /* MDI setting is only allowed when autoneg enabled because 2021 * some hardware doesn't allow MDI setting when speed or 2022 * duplex is forced. 2023 */ 2024 if (cmd->base.eth_tp_mdix_ctrl) { 2025 if (cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO && 2026 cmd->base.autoneg != AUTONEG_ENABLE) { 2027 netdev_err(dev, "Forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n"); 2028 return -EINVAL; 2029 } 2030 } 2031 2032 while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 2033 usleep_range(1000, 2000); 2034 2035 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2036 2500baseT_Full)) 2037 advertised |= ADVERTISE_2500_FULL; 2038 2039 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2040 1000baseT_Full)) 2041 advertised |= ADVERTISE_1000_FULL; 2042 2043 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2044 100baseT_Full)) 2045 advertised |= ADVERTISE_100_FULL; 2046 2047 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2048 100baseT_Half)) 2049 advertised |= ADVERTISE_100_HALF; 2050 2051 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2052 10baseT_Full)) 2053 advertised |= ADVERTISE_10_FULL; 2054 2055 if (ethtool_link_ksettings_test_link_mode(cmd, advertising, 2056 10baseT_Half)) 2057 advertised |= ADVERTISE_10_HALF; 2058 2059 if (cmd->base.autoneg == AUTONEG_ENABLE) { 2060 hw->phy.autoneg_advertised = advertised; 2061 if (adapter->fc_autoneg) 2062 hw->fc.requested_mode = igc_fc_default; 2063 } else { 2064 netdev_info(dev, "Force mode currently not supported\n"); 2065 } 2066 2067 /* MDI-X => 2; MDI => 1; Auto => 3 */ 2068 if (cmd->base.eth_tp_mdix_ctrl) { 2069 /* fix up the value for auto (3 => 0) as zero is mapped 2070 * internally to auto 2071 */ 2072 if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO) 2073 hw->phy.mdix = AUTO_ALL_MODES; 2074 else 2075 hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl; 2076 } 2077 2078 /* reset the link */ 2079 if (netif_running(adapter->netdev)) { 2080 igc_down(adapter); 2081 igc_up(adapter); 2082 } else { 2083 igc_reset(adapter); 2084 } 2085 2086 clear_bit(__IGC_RESETTING, &adapter->state); 2087 2088 return 0; 2089 } 2090 2091 static void igc_ethtool_diag_test(struct net_device *netdev, 2092 struct ethtool_test *eth_test, u64 *data) 2093 { 2094 struct igc_adapter *adapter = netdev_priv(netdev); 2095 bool if_running = netif_running(netdev); 2096 2097 if (eth_test->flags == ETH_TEST_FL_OFFLINE) { 2098 netdev_info(adapter->netdev, "Offline testing starting"); 2099 set_bit(__IGC_TESTING, &adapter->state); 2100 2101 /* power up PHY for link test */ 2102 igc_power_up_phy_copper(&adapter->hw); 2103 2104 /* Link test performed before hardware reset so autoneg doesn't 2105 * interfere with test result 2106 */ 2107 if (!igc_link_test(adapter, &data[TEST_LINK])) 2108 eth_test->flags |= ETH_TEST_FL_FAILED; 2109 2110 if (if_running) 2111 igc_close(netdev); 2112 else 2113 igc_reset(adapter); 2114 2115 netdev_info(adapter->netdev, "Register testing starting"); 2116 if (!igc_reg_test(adapter, &data[TEST_REG])) 2117 eth_test->flags |= ETH_TEST_FL_FAILED; 2118 2119 igc_reset(adapter); 2120 2121 netdev_info(adapter->netdev, "EEPROM testing starting"); 2122 if (!igc_eeprom_test(adapter, &data[TEST_EEP])) 2123 eth_test->flags |= ETH_TEST_FL_FAILED; 2124 2125 igc_reset(adapter); 2126 2127 /* loopback and interrupt tests 2128 * will be implemented in the future 2129 */ 2130 data[TEST_LOOP] = 0; 2131 data[TEST_IRQ] = 0; 2132 2133 clear_bit(__IGC_TESTING, &adapter->state); 2134 if (if_running) 2135 igc_open(netdev); 2136 } else { 2137 netdev_info(adapter->netdev, "Online testing starting"); 2138 2139 /* register, eeprom, intr and loopback tests not run online */ 2140 data[TEST_REG] = 0; 2141 data[TEST_EEP] = 0; 2142 data[TEST_IRQ] = 0; 2143 data[TEST_LOOP] = 0; 2144 2145 if (!igc_link_test(adapter, &data[TEST_LINK])) 2146 eth_test->flags |= ETH_TEST_FL_FAILED; 2147 } 2148 2149 msleep_interruptible(4 * 1000); 2150 } 2151 2152 static const struct ethtool_ops igc_ethtool_ops = { 2153 .supported_coalesce_params = ETHTOOL_COALESCE_USECS, 2154 .get_drvinfo = igc_ethtool_get_drvinfo, 2155 .get_regs_len = igc_ethtool_get_regs_len, 2156 .get_regs = igc_ethtool_get_regs, 2157 .get_wol = igc_ethtool_get_wol, 2158 .set_wol = igc_ethtool_set_wol, 2159 .get_msglevel = igc_ethtool_get_msglevel, 2160 .set_msglevel = igc_ethtool_set_msglevel, 2161 .nway_reset = igc_ethtool_nway_reset, 2162 .get_link = igc_ethtool_get_link, 2163 .get_eeprom_len = igc_ethtool_get_eeprom_len, 2164 .get_eeprom = igc_ethtool_get_eeprom, 2165 .set_eeprom = igc_ethtool_set_eeprom, 2166 .get_ringparam = igc_ethtool_get_ringparam, 2167 .set_ringparam = igc_ethtool_set_ringparam, 2168 .get_pauseparam = igc_ethtool_get_pauseparam, 2169 .set_pauseparam = igc_ethtool_set_pauseparam, 2170 .get_strings = igc_ethtool_get_strings, 2171 .get_sset_count = igc_ethtool_get_sset_count, 2172 .get_ethtool_stats = igc_ethtool_get_stats, 2173 .get_coalesce = igc_ethtool_get_coalesce, 2174 .set_coalesce = igc_ethtool_set_coalesce, 2175 .get_rxnfc = igc_ethtool_get_rxnfc, 2176 .set_rxnfc = igc_ethtool_set_rxnfc, 2177 .get_rx_ring_count = igc_ethtool_get_rx_ring_count, 2178 .get_rxfh_indir_size = igc_ethtool_get_rxfh_indir_size, 2179 .get_rxfh = igc_ethtool_get_rxfh, 2180 .set_rxfh = igc_ethtool_set_rxfh, 2181 .get_rxfh_fields = igc_ethtool_get_rxfh_fields, 2182 .set_rxfh_fields = igc_ethtool_set_rxfh_fields, 2183 .get_ts_info = igc_ethtool_get_ts_info, 2184 .get_channels = igc_ethtool_get_channels, 2185 .set_channels = igc_ethtool_set_channels, 2186 .get_priv_flags = igc_ethtool_get_priv_flags, 2187 .set_priv_flags = igc_ethtool_set_priv_flags, 2188 .get_eee = igc_ethtool_get_eee, 2189 .set_eee = igc_ethtool_set_eee, 2190 .get_link_ksettings = igc_ethtool_get_link_ksettings, 2191 .set_link_ksettings = igc_ethtool_set_link_ksettings, 2192 .self_test = igc_ethtool_diag_test, 2193 .get_mm = igc_ethtool_get_mm, 2194 .get_mm_stats = igc_ethtool_get_mm_stats, 2195 .set_mm = igc_ethtool_set_mm, 2196 }; 2197 2198 void igc_ethtool_set_ops(struct net_device *netdev) 2199 { 2200 netdev->ethtool_ops = &igc_ethtool_ops; 2201 } 2202