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