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 8 #include "igc.h" 9 10 /* forward declaration */ 11 struct igc_stats { 12 char stat_string[ETH_GSTRING_LEN]; 13 int sizeof_stat; 14 int stat_offset; 15 }; 16 17 #define IGC_STAT(_name, _stat) { \ 18 .stat_string = _name, \ 19 .sizeof_stat = sizeof_field(struct igc_adapter, _stat), \ 20 .stat_offset = offsetof(struct igc_adapter, _stat) \ 21 } 22 23 static const struct igc_stats igc_gstrings_stats[] = { 24 IGC_STAT("rx_packets", stats.gprc), 25 IGC_STAT("tx_packets", stats.gptc), 26 IGC_STAT("rx_bytes", stats.gorc), 27 IGC_STAT("tx_bytes", stats.gotc), 28 IGC_STAT("rx_broadcast", stats.bprc), 29 IGC_STAT("tx_broadcast", stats.bptc), 30 IGC_STAT("rx_multicast", stats.mprc), 31 IGC_STAT("tx_multicast", stats.mptc), 32 IGC_STAT("multicast", stats.mprc), 33 IGC_STAT("collisions", stats.colc), 34 IGC_STAT("rx_crc_errors", stats.crcerrs), 35 IGC_STAT("rx_no_buffer_count", stats.rnbc), 36 IGC_STAT("rx_missed_errors", stats.mpc), 37 IGC_STAT("tx_aborted_errors", stats.ecol), 38 IGC_STAT("tx_carrier_errors", stats.tncrs), 39 IGC_STAT("tx_window_errors", stats.latecol), 40 IGC_STAT("tx_abort_late_coll", stats.latecol), 41 IGC_STAT("tx_deferred_ok", stats.dc), 42 IGC_STAT("tx_single_coll_ok", stats.scc), 43 IGC_STAT("tx_multi_coll_ok", stats.mcc), 44 IGC_STAT("tx_timeout_count", tx_timeout_count), 45 IGC_STAT("rx_long_length_errors", stats.roc), 46 IGC_STAT("rx_short_length_errors", stats.ruc), 47 IGC_STAT("rx_align_errors", stats.algnerrc), 48 IGC_STAT("tx_tcp_seg_good", stats.tsctc), 49 IGC_STAT("tx_tcp_seg_failed", stats.tsctfc), 50 IGC_STAT("rx_flow_control_xon", stats.xonrxc), 51 IGC_STAT("rx_flow_control_xoff", stats.xoffrxc), 52 IGC_STAT("tx_flow_control_xon", stats.xontxc), 53 IGC_STAT("tx_flow_control_xoff", stats.xofftxc), 54 IGC_STAT("rx_long_byte_count", stats.gorc), 55 IGC_STAT("tx_dma_out_of_sync", stats.doosync), 56 IGC_STAT("tx_smbus", stats.mgptc), 57 IGC_STAT("rx_smbus", stats.mgprc), 58 IGC_STAT("dropped_smbus", stats.mgpdc), 59 IGC_STAT("os2bmc_rx_by_bmc", stats.o2bgptc), 60 IGC_STAT("os2bmc_tx_by_bmc", stats.b2ospc), 61 IGC_STAT("os2bmc_tx_by_host", stats.o2bspc), 62 IGC_STAT("os2bmc_rx_by_host", stats.b2ogprc), 63 IGC_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts), 64 IGC_STAT("tx_hwtstamp_skipped", tx_hwtstamp_skipped), 65 IGC_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared), 66 }; 67 68 #define IGC_NETDEV_STAT(_net_stat) { \ 69 .stat_string = __stringify(_net_stat), \ 70 .sizeof_stat = sizeof_field(struct rtnl_link_stats64, _net_stat), \ 71 .stat_offset = offsetof(struct rtnl_link_stats64, _net_stat) \ 72 } 73 74 static const struct igc_stats igc_gstrings_net_stats[] = { 75 IGC_NETDEV_STAT(rx_errors), 76 IGC_NETDEV_STAT(tx_errors), 77 IGC_NETDEV_STAT(tx_dropped), 78 IGC_NETDEV_STAT(rx_length_errors), 79 IGC_NETDEV_STAT(rx_over_errors), 80 IGC_NETDEV_STAT(rx_frame_errors), 81 IGC_NETDEV_STAT(rx_fifo_errors), 82 IGC_NETDEV_STAT(tx_fifo_errors), 83 IGC_NETDEV_STAT(tx_heartbeat_errors) 84 }; 85 86 enum igc_diagnostics_results { 87 TEST_REG = 0, 88 TEST_EEP, 89 TEST_IRQ, 90 TEST_LOOP, 91 TEST_LINK 92 }; 93 94 static const char igc_gstrings_test[][ETH_GSTRING_LEN] = { 95 [TEST_REG] = "Register test (offline)", 96 [TEST_EEP] = "Eeprom test (offline)", 97 [TEST_IRQ] = "Interrupt test (offline)", 98 [TEST_LOOP] = "Loopback test (offline)", 99 [TEST_LINK] = "Link test (on/offline)" 100 }; 101 102 #define IGC_TEST_LEN (sizeof(igc_gstrings_test) / ETH_GSTRING_LEN) 103 104 #define IGC_GLOBAL_STATS_LEN \ 105 (sizeof(igc_gstrings_stats) / sizeof(struct igc_stats)) 106 #define IGC_NETDEV_STATS_LEN \ 107 (sizeof(igc_gstrings_net_stats) / sizeof(struct igc_stats)) 108 #define IGC_RX_QUEUE_STATS_LEN \ 109 (sizeof(struct igc_rx_queue_stats) / sizeof(u64)) 110 #define IGC_TX_QUEUE_STATS_LEN 3 /* packets, bytes, restart_queue */ 111 #define IGC_QUEUE_STATS_LEN \ 112 ((((struct igc_adapter *)netdev_priv(netdev))->num_rx_queues * \ 113 IGC_RX_QUEUE_STATS_LEN) + \ 114 (((struct igc_adapter *)netdev_priv(netdev))->num_tx_queues * \ 115 IGC_TX_QUEUE_STATS_LEN)) 116 #define IGC_STATS_LEN \ 117 (IGC_GLOBAL_STATS_LEN + IGC_NETDEV_STATS_LEN + IGC_QUEUE_STATS_LEN) 118 119 static const char igc_priv_flags_strings[][ETH_GSTRING_LEN] = { 120 #define IGC_PRIV_FLAGS_LEGACY_RX BIT(0) 121 "legacy-rx", 122 }; 123 124 #define IGC_PRIV_FLAGS_STR_LEN ARRAY_SIZE(igc_priv_flags_strings) 125 126 static void igc_get_drvinfo(struct net_device *netdev, 127 struct ethtool_drvinfo *drvinfo) 128 { 129 struct igc_adapter *adapter = netdev_priv(netdev); 130 131 strlcpy(drvinfo->driver, igc_driver_name, sizeof(drvinfo->driver)); 132 strlcpy(drvinfo->version, igc_driver_version, sizeof(drvinfo->version)); 133 134 /* add fw_version here */ 135 strlcpy(drvinfo->bus_info, pci_name(adapter->pdev), 136 sizeof(drvinfo->bus_info)); 137 138 drvinfo->n_priv_flags = IGC_PRIV_FLAGS_STR_LEN; 139 } 140 141 static int igc_get_regs_len(struct net_device *netdev) 142 { 143 return IGC_REGS_LEN * sizeof(u32); 144 } 145 146 static void igc_get_regs(struct net_device *netdev, 147 struct ethtool_regs *regs, void *p) 148 { 149 struct igc_adapter *adapter = netdev_priv(netdev); 150 struct igc_hw *hw = &adapter->hw; 151 u32 *regs_buff = p; 152 u8 i; 153 154 memset(p, 0, IGC_REGS_LEN * sizeof(u32)); 155 156 regs->version = (2u << 24) | (hw->revision_id << 16) | hw->device_id; 157 158 /* General Registers */ 159 regs_buff[0] = rd32(IGC_CTRL); 160 regs_buff[1] = rd32(IGC_STATUS); 161 regs_buff[2] = rd32(IGC_CTRL_EXT); 162 regs_buff[3] = rd32(IGC_MDIC); 163 regs_buff[4] = rd32(IGC_CONNSW); 164 165 /* NVM Register */ 166 regs_buff[5] = rd32(IGC_EECD); 167 168 /* Interrupt */ 169 /* Reading EICS for EICR because they read the 170 * same but EICS does not clear on read 171 */ 172 regs_buff[6] = rd32(IGC_EICS); 173 regs_buff[7] = rd32(IGC_EICS); 174 regs_buff[8] = rd32(IGC_EIMS); 175 regs_buff[9] = rd32(IGC_EIMC); 176 regs_buff[10] = rd32(IGC_EIAC); 177 regs_buff[11] = rd32(IGC_EIAM); 178 /* Reading ICS for ICR because they read the 179 * same but ICS does not clear on read 180 */ 181 regs_buff[12] = rd32(IGC_ICS); 182 regs_buff[13] = rd32(IGC_ICS); 183 regs_buff[14] = rd32(IGC_IMS); 184 regs_buff[15] = rd32(IGC_IMC); 185 regs_buff[16] = rd32(IGC_IAC); 186 regs_buff[17] = rd32(IGC_IAM); 187 188 /* Flow Control */ 189 regs_buff[18] = rd32(IGC_FCAL); 190 regs_buff[19] = rd32(IGC_FCAH); 191 regs_buff[20] = rd32(IGC_FCTTV); 192 regs_buff[21] = rd32(IGC_FCRTL); 193 regs_buff[22] = rd32(IGC_FCRTH); 194 regs_buff[23] = rd32(IGC_FCRTV); 195 196 /* Receive */ 197 regs_buff[24] = rd32(IGC_RCTL); 198 regs_buff[25] = rd32(IGC_RXCSUM); 199 regs_buff[26] = rd32(IGC_RLPML); 200 regs_buff[27] = rd32(IGC_RFCTL); 201 202 /* Transmit */ 203 regs_buff[28] = rd32(IGC_TCTL); 204 regs_buff[29] = rd32(IGC_TIPG); 205 206 /* Wake Up */ 207 208 /* MAC */ 209 210 /* Statistics */ 211 regs_buff[30] = adapter->stats.crcerrs; 212 regs_buff[31] = adapter->stats.algnerrc; 213 regs_buff[32] = adapter->stats.symerrs; 214 regs_buff[33] = adapter->stats.rxerrc; 215 regs_buff[34] = adapter->stats.mpc; 216 regs_buff[35] = adapter->stats.scc; 217 regs_buff[36] = adapter->stats.ecol; 218 regs_buff[37] = adapter->stats.mcc; 219 regs_buff[38] = adapter->stats.latecol; 220 regs_buff[39] = adapter->stats.colc; 221 regs_buff[40] = adapter->stats.dc; 222 regs_buff[41] = adapter->stats.tncrs; 223 regs_buff[42] = adapter->stats.sec; 224 regs_buff[43] = adapter->stats.htdpmc; 225 regs_buff[44] = adapter->stats.rlec; 226 regs_buff[45] = adapter->stats.xonrxc; 227 regs_buff[46] = adapter->stats.xontxc; 228 regs_buff[47] = adapter->stats.xoffrxc; 229 regs_buff[48] = adapter->stats.xofftxc; 230 regs_buff[49] = adapter->stats.fcruc; 231 regs_buff[50] = adapter->stats.prc64; 232 regs_buff[51] = adapter->stats.prc127; 233 regs_buff[52] = adapter->stats.prc255; 234 regs_buff[53] = adapter->stats.prc511; 235 regs_buff[54] = adapter->stats.prc1023; 236 regs_buff[55] = adapter->stats.prc1522; 237 regs_buff[56] = adapter->stats.gprc; 238 regs_buff[57] = adapter->stats.bprc; 239 regs_buff[58] = adapter->stats.mprc; 240 regs_buff[59] = adapter->stats.gptc; 241 regs_buff[60] = adapter->stats.gorc; 242 regs_buff[61] = adapter->stats.gotc; 243 regs_buff[62] = adapter->stats.rnbc; 244 regs_buff[63] = adapter->stats.ruc; 245 regs_buff[64] = adapter->stats.rfc; 246 regs_buff[65] = adapter->stats.roc; 247 regs_buff[66] = adapter->stats.rjc; 248 regs_buff[67] = adapter->stats.mgprc; 249 regs_buff[68] = adapter->stats.mgpdc; 250 regs_buff[69] = adapter->stats.mgptc; 251 regs_buff[70] = adapter->stats.tor; 252 regs_buff[71] = adapter->stats.tot; 253 regs_buff[72] = adapter->stats.tpr; 254 regs_buff[73] = adapter->stats.tpt; 255 regs_buff[74] = adapter->stats.ptc64; 256 regs_buff[75] = adapter->stats.ptc127; 257 regs_buff[76] = adapter->stats.ptc255; 258 regs_buff[77] = adapter->stats.ptc511; 259 regs_buff[78] = adapter->stats.ptc1023; 260 regs_buff[79] = adapter->stats.ptc1522; 261 regs_buff[80] = adapter->stats.mptc; 262 regs_buff[81] = adapter->stats.bptc; 263 regs_buff[82] = adapter->stats.tsctc; 264 regs_buff[83] = adapter->stats.iac; 265 regs_buff[84] = adapter->stats.rpthc; 266 regs_buff[85] = adapter->stats.hgptc; 267 regs_buff[86] = adapter->stats.hgorc; 268 regs_buff[87] = adapter->stats.hgotc; 269 regs_buff[88] = adapter->stats.lenerrs; 270 regs_buff[89] = adapter->stats.scvpc; 271 regs_buff[90] = adapter->stats.hrmpc; 272 273 for (i = 0; i < 4; i++) 274 regs_buff[91 + i] = rd32(IGC_SRRCTL(i)); 275 for (i = 0; i < 4; i++) 276 regs_buff[95 + i] = rd32(IGC_PSRTYPE(i)); 277 for (i = 0; i < 4; i++) 278 regs_buff[99 + i] = rd32(IGC_RDBAL(i)); 279 for (i = 0; i < 4; i++) 280 regs_buff[103 + i] = rd32(IGC_RDBAH(i)); 281 for (i = 0; i < 4; i++) 282 regs_buff[107 + i] = rd32(IGC_RDLEN(i)); 283 for (i = 0; i < 4; i++) 284 regs_buff[111 + i] = rd32(IGC_RDH(i)); 285 for (i = 0; i < 4; i++) 286 regs_buff[115 + i] = rd32(IGC_RDT(i)); 287 for (i = 0; i < 4; i++) 288 regs_buff[119 + i] = rd32(IGC_RXDCTL(i)); 289 290 for (i = 0; i < 10; i++) 291 regs_buff[123 + i] = rd32(IGC_EITR(i)); 292 for (i = 0; i < 16; i++) 293 regs_buff[139 + i] = rd32(IGC_RAL(i)); 294 for (i = 0; i < 16; i++) 295 regs_buff[145 + i] = rd32(IGC_RAH(i)); 296 297 for (i = 0; i < 4; i++) 298 regs_buff[149 + i] = rd32(IGC_TDBAL(i)); 299 for (i = 0; i < 4; i++) 300 regs_buff[152 + i] = rd32(IGC_TDBAH(i)); 301 for (i = 0; i < 4; i++) 302 regs_buff[156 + i] = rd32(IGC_TDLEN(i)); 303 for (i = 0; i < 4; i++) 304 regs_buff[160 + i] = rd32(IGC_TDH(i)); 305 for (i = 0; i < 4; i++) 306 regs_buff[164 + i] = rd32(IGC_TDT(i)); 307 for (i = 0; i < 4; i++) 308 regs_buff[168 + i] = rd32(IGC_TXDCTL(i)); 309 310 /* XXX: Due to a bug few lines above, RAL and RAH registers are 311 * overwritten. To preserve the ABI, we write these registers again in 312 * regs_buff. 313 */ 314 for (i = 0; i < 16; i++) 315 regs_buff[172 + i] = rd32(IGC_RAL(i)); 316 for (i = 0; i < 16; i++) 317 regs_buff[188 + i] = rd32(IGC_RAH(i)); 318 } 319 320 static void igc_get_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) 321 { 322 struct igc_adapter *adapter = netdev_priv(netdev); 323 324 wol->wolopts = 0; 325 326 if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED)) 327 return; 328 329 wol->supported = WAKE_UCAST | WAKE_MCAST | 330 WAKE_BCAST | WAKE_MAGIC | 331 WAKE_PHY; 332 333 /* apply any specific unsupported masks here */ 334 switch (adapter->hw.device_id) { 335 default: 336 break; 337 } 338 339 if (adapter->wol & IGC_WUFC_EX) 340 wol->wolopts |= WAKE_UCAST; 341 if (adapter->wol & IGC_WUFC_MC) 342 wol->wolopts |= WAKE_MCAST; 343 if (adapter->wol & IGC_WUFC_BC) 344 wol->wolopts |= WAKE_BCAST; 345 if (adapter->wol & IGC_WUFC_MAG) 346 wol->wolopts |= WAKE_MAGIC; 347 if (adapter->wol & IGC_WUFC_LNKC) 348 wol->wolopts |= WAKE_PHY; 349 } 350 351 static int igc_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol) 352 { 353 struct igc_adapter *adapter = netdev_priv(netdev); 354 355 if (wol->wolopts & (WAKE_ARP | WAKE_MAGICSECURE | WAKE_FILTER)) 356 return -EOPNOTSUPP; 357 358 if (!(adapter->flags & IGC_FLAG_WOL_SUPPORTED)) 359 return wol->wolopts ? -EOPNOTSUPP : 0; 360 361 /* these settings will always override what we currently have */ 362 adapter->wol = 0; 363 364 if (wol->wolopts & WAKE_UCAST) 365 adapter->wol |= IGC_WUFC_EX; 366 if (wol->wolopts & WAKE_MCAST) 367 adapter->wol |= IGC_WUFC_MC; 368 if (wol->wolopts & WAKE_BCAST) 369 adapter->wol |= IGC_WUFC_BC; 370 if (wol->wolopts & WAKE_MAGIC) 371 adapter->wol |= IGC_WUFC_MAG; 372 if (wol->wolopts & WAKE_PHY) 373 adapter->wol |= IGC_WUFC_LNKC; 374 device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol); 375 376 return 0; 377 } 378 379 static u32 igc_get_msglevel(struct net_device *netdev) 380 { 381 struct igc_adapter *adapter = netdev_priv(netdev); 382 383 return adapter->msg_enable; 384 } 385 386 static void igc_set_msglevel(struct net_device *netdev, u32 data) 387 { 388 struct igc_adapter *adapter = netdev_priv(netdev); 389 390 adapter->msg_enable = data; 391 } 392 393 static int igc_nway_reset(struct net_device *netdev) 394 { 395 struct igc_adapter *adapter = netdev_priv(netdev); 396 397 if (netif_running(netdev)) 398 igc_reinit_locked(adapter); 399 return 0; 400 } 401 402 static u32 igc_get_link(struct net_device *netdev) 403 { 404 struct igc_adapter *adapter = netdev_priv(netdev); 405 struct igc_mac_info *mac = &adapter->hw.mac; 406 407 /* If the link is not reported up to netdev, interrupts are disabled, 408 * and so the physical link state may have changed since we last 409 * looked. Set get_link_status to make sure that the true link 410 * state is interrogated, rather than pulling a cached and possibly 411 * stale link state from the driver. 412 */ 413 if (!netif_carrier_ok(netdev)) 414 mac->get_link_status = 1; 415 416 return igc_has_link(adapter); 417 } 418 419 static int igc_get_eeprom_len(struct net_device *netdev) 420 { 421 struct igc_adapter *adapter = netdev_priv(netdev); 422 423 return adapter->hw.nvm.word_size * 2; 424 } 425 426 static int igc_get_eeprom(struct net_device *netdev, 427 struct ethtool_eeprom *eeprom, u8 *bytes) 428 { 429 struct igc_adapter *adapter = netdev_priv(netdev); 430 struct igc_hw *hw = &adapter->hw; 431 int first_word, last_word; 432 u16 *eeprom_buff; 433 int ret_val = 0; 434 u16 i; 435 436 if (eeprom->len == 0) 437 return -EINVAL; 438 439 eeprom->magic = hw->vendor_id | (hw->device_id << 16); 440 441 first_word = eeprom->offset >> 1; 442 last_word = (eeprom->offset + eeprom->len - 1) >> 1; 443 444 eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16), 445 GFP_KERNEL); 446 if (!eeprom_buff) 447 return -ENOMEM; 448 449 if (hw->nvm.type == igc_nvm_eeprom_spi) { 450 ret_val = hw->nvm.ops.read(hw, first_word, 451 last_word - first_word + 1, 452 eeprom_buff); 453 } else { 454 for (i = 0; i < last_word - first_word + 1; i++) { 455 ret_val = hw->nvm.ops.read(hw, first_word + i, 1, 456 &eeprom_buff[i]); 457 if (ret_val) 458 break; 459 } 460 } 461 462 /* Device's eeprom is always little-endian, word addressable */ 463 for (i = 0; i < last_word - first_word + 1; i++) 464 le16_to_cpus(&eeprom_buff[i]); 465 466 memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), 467 eeprom->len); 468 kfree(eeprom_buff); 469 470 return ret_val; 471 } 472 473 static int igc_set_eeprom(struct net_device *netdev, 474 struct ethtool_eeprom *eeprom, u8 *bytes) 475 { 476 struct igc_adapter *adapter = netdev_priv(netdev); 477 struct igc_hw *hw = &adapter->hw; 478 int max_len, first_word, last_word, ret_val = 0; 479 u16 *eeprom_buff; 480 void *ptr; 481 u16 i; 482 483 if (eeprom->len == 0) 484 return -EOPNOTSUPP; 485 486 if (hw->mac.type >= igc_i225 && 487 !igc_get_flash_presence_i225(hw)) { 488 return -EOPNOTSUPP; 489 } 490 491 if (eeprom->magic != (hw->vendor_id | (hw->device_id << 16))) 492 return -EFAULT; 493 494 max_len = hw->nvm.word_size * 2; 495 496 first_word = eeprom->offset >> 1; 497 last_word = (eeprom->offset + eeprom->len - 1) >> 1; 498 eeprom_buff = kmalloc(max_len, GFP_KERNEL); 499 if (!eeprom_buff) 500 return -ENOMEM; 501 502 ptr = (void *)eeprom_buff; 503 504 if (eeprom->offset & 1) { 505 /* need read/modify/write of first changed EEPROM word 506 * only the second byte of the word is being modified 507 */ 508 ret_val = hw->nvm.ops.read(hw, first_word, 1, 509 &eeprom_buff[0]); 510 ptr++; 511 } 512 if (((eeprom->offset + eeprom->len) & 1) && ret_val == 0) { 513 /* need read/modify/write of last changed EEPROM word 514 * only the first byte of the word is being modified 515 */ 516 ret_val = hw->nvm.ops.read(hw, last_word, 1, 517 &eeprom_buff[last_word - first_word]); 518 } 519 520 /* Device's eeprom is always little-endian, word addressable */ 521 for (i = 0; i < last_word - first_word + 1; i++) 522 le16_to_cpus(&eeprom_buff[i]); 523 524 memcpy(ptr, bytes, eeprom->len); 525 526 for (i = 0; i < last_word - first_word + 1; i++) 527 eeprom_buff[i] = cpu_to_le16(eeprom_buff[i]); 528 529 ret_val = hw->nvm.ops.write(hw, first_word, 530 last_word - first_word + 1, eeprom_buff); 531 532 /* Update the checksum if nvm write succeeded */ 533 if (ret_val == 0) 534 hw->nvm.ops.update(hw); 535 536 /* check if need: igc_set_fw_version(adapter); */ 537 kfree(eeprom_buff); 538 return ret_val; 539 } 540 541 static void igc_get_ringparam(struct net_device *netdev, 542 struct ethtool_ringparam *ring) 543 { 544 struct igc_adapter *adapter = netdev_priv(netdev); 545 546 ring->rx_max_pending = IGC_MAX_RXD; 547 ring->tx_max_pending = IGC_MAX_TXD; 548 ring->rx_pending = adapter->rx_ring_count; 549 ring->tx_pending = adapter->tx_ring_count; 550 } 551 552 static int igc_set_ringparam(struct net_device *netdev, 553 struct ethtool_ringparam *ring) 554 { 555 struct igc_adapter *adapter = netdev_priv(netdev); 556 struct igc_ring *temp_ring; 557 u16 new_rx_count, new_tx_count; 558 int i, err = 0; 559 560 if (ring->rx_mini_pending || ring->rx_jumbo_pending) 561 return -EINVAL; 562 563 new_rx_count = min_t(u32, ring->rx_pending, IGC_MAX_RXD); 564 new_rx_count = max_t(u16, new_rx_count, IGC_MIN_RXD); 565 new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE); 566 567 new_tx_count = min_t(u32, ring->tx_pending, IGC_MAX_TXD); 568 new_tx_count = max_t(u16, new_tx_count, IGC_MIN_TXD); 569 new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE); 570 571 if (new_tx_count == adapter->tx_ring_count && 572 new_rx_count == adapter->rx_ring_count) { 573 /* nothing to do */ 574 return 0; 575 } 576 577 while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 578 usleep_range(1000, 2000); 579 580 if (!netif_running(adapter->netdev)) { 581 for (i = 0; i < adapter->num_tx_queues; i++) 582 adapter->tx_ring[i]->count = new_tx_count; 583 for (i = 0; i < adapter->num_rx_queues; i++) 584 adapter->rx_ring[i]->count = new_rx_count; 585 adapter->tx_ring_count = new_tx_count; 586 adapter->rx_ring_count = new_rx_count; 587 goto clear_reset; 588 } 589 590 if (adapter->num_tx_queues > adapter->num_rx_queues) 591 temp_ring = vmalloc(array_size(sizeof(struct igc_ring), 592 adapter->num_tx_queues)); 593 else 594 temp_ring = vmalloc(array_size(sizeof(struct igc_ring), 595 adapter->num_rx_queues)); 596 597 if (!temp_ring) { 598 err = -ENOMEM; 599 goto clear_reset; 600 } 601 602 igc_down(adapter); 603 604 /* We can't just free everything and then setup again, 605 * because the ISRs in MSI-X mode get passed pointers 606 * to the Tx and Rx ring structs. 607 */ 608 if (new_tx_count != adapter->tx_ring_count) { 609 for (i = 0; i < adapter->num_tx_queues; i++) { 610 memcpy(&temp_ring[i], adapter->tx_ring[i], 611 sizeof(struct igc_ring)); 612 613 temp_ring[i].count = new_tx_count; 614 err = igc_setup_tx_resources(&temp_ring[i]); 615 if (err) { 616 while (i) { 617 i--; 618 igc_free_tx_resources(&temp_ring[i]); 619 } 620 goto err_setup; 621 } 622 } 623 624 for (i = 0; i < adapter->num_tx_queues; i++) { 625 igc_free_tx_resources(adapter->tx_ring[i]); 626 627 memcpy(adapter->tx_ring[i], &temp_ring[i], 628 sizeof(struct igc_ring)); 629 } 630 631 adapter->tx_ring_count = new_tx_count; 632 } 633 634 if (new_rx_count != adapter->rx_ring_count) { 635 for (i = 0; i < adapter->num_rx_queues; i++) { 636 memcpy(&temp_ring[i], adapter->rx_ring[i], 637 sizeof(struct igc_ring)); 638 639 temp_ring[i].count = new_rx_count; 640 err = igc_setup_rx_resources(&temp_ring[i]); 641 if (err) { 642 while (i) { 643 i--; 644 igc_free_rx_resources(&temp_ring[i]); 645 } 646 goto err_setup; 647 } 648 } 649 650 for (i = 0; i < adapter->num_rx_queues; i++) { 651 igc_free_rx_resources(adapter->rx_ring[i]); 652 653 memcpy(adapter->rx_ring[i], &temp_ring[i], 654 sizeof(struct igc_ring)); 655 } 656 657 adapter->rx_ring_count = new_rx_count; 658 } 659 err_setup: 660 igc_up(adapter); 661 vfree(temp_ring); 662 clear_reset: 663 clear_bit(__IGC_RESETTING, &adapter->state); 664 return err; 665 } 666 667 static void igc_get_pauseparam(struct net_device *netdev, 668 struct ethtool_pauseparam *pause) 669 { 670 struct igc_adapter *adapter = netdev_priv(netdev); 671 struct igc_hw *hw = &adapter->hw; 672 673 pause->autoneg = 674 (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE); 675 676 if (hw->fc.current_mode == igc_fc_rx_pause) { 677 pause->rx_pause = 1; 678 } else if (hw->fc.current_mode == igc_fc_tx_pause) { 679 pause->tx_pause = 1; 680 } else if (hw->fc.current_mode == igc_fc_full) { 681 pause->rx_pause = 1; 682 pause->tx_pause = 1; 683 } 684 } 685 686 static int igc_set_pauseparam(struct net_device *netdev, 687 struct ethtool_pauseparam *pause) 688 { 689 struct igc_adapter *adapter = netdev_priv(netdev); 690 struct igc_hw *hw = &adapter->hw; 691 int retval = 0; 692 693 adapter->fc_autoneg = pause->autoneg; 694 695 while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 696 usleep_range(1000, 2000); 697 698 if (adapter->fc_autoneg == AUTONEG_ENABLE) { 699 hw->fc.requested_mode = igc_fc_default; 700 if (netif_running(adapter->netdev)) { 701 igc_down(adapter); 702 igc_up(adapter); 703 } else { 704 igc_reset(adapter); 705 } 706 } else { 707 if (pause->rx_pause && pause->tx_pause) 708 hw->fc.requested_mode = igc_fc_full; 709 else if (pause->rx_pause && !pause->tx_pause) 710 hw->fc.requested_mode = igc_fc_rx_pause; 711 else if (!pause->rx_pause && pause->tx_pause) 712 hw->fc.requested_mode = igc_fc_tx_pause; 713 else if (!pause->rx_pause && !pause->tx_pause) 714 hw->fc.requested_mode = igc_fc_none; 715 716 hw->fc.current_mode = hw->fc.requested_mode; 717 718 retval = ((hw->phy.media_type == igc_media_type_copper) ? 719 igc_force_mac_fc(hw) : igc_setup_link(hw)); 720 } 721 722 clear_bit(__IGC_RESETTING, &adapter->state); 723 return retval; 724 } 725 726 static void igc_get_strings(struct net_device *netdev, u32 stringset, u8 *data) 727 { 728 struct igc_adapter *adapter = netdev_priv(netdev); 729 u8 *p = data; 730 int i; 731 732 switch (stringset) { 733 case ETH_SS_TEST: 734 memcpy(data, *igc_gstrings_test, 735 IGC_TEST_LEN * ETH_GSTRING_LEN); 736 break; 737 case ETH_SS_STATS: 738 for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) { 739 memcpy(p, igc_gstrings_stats[i].stat_string, 740 ETH_GSTRING_LEN); 741 p += ETH_GSTRING_LEN; 742 } 743 for (i = 0; i < IGC_NETDEV_STATS_LEN; i++) { 744 memcpy(p, igc_gstrings_net_stats[i].stat_string, 745 ETH_GSTRING_LEN); 746 p += ETH_GSTRING_LEN; 747 } 748 for (i = 0; i < adapter->num_tx_queues; i++) { 749 sprintf(p, "tx_queue_%u_packets", i); 750 p += ETH_GSTRING_LEN; 751 sprintf(p, "tx_queue_%u_bytes", i); 752 p += ETH_GSTRING_LEN; 753 sprintf(p, "tx_queue_%u_restart", i); 754 p += ETH_GSTRING_LEN; 755 } 756 for (i = 0; i < adapter->num_rx_queues; i++) { 757 sprintf(p, "rx_queue_%u_packets", i); 758 p += ETH_GSTRING_LEN; 759 sprintf(p, "rx_queue_%u_bytes", i); 760 p += ETH_GSTRING_LEN; 761 sprintf(p, "rx_queue_%u_drops", i); 762 p += ETH_GSTRING_LEN; 763 sprintf(p, "rx_queue_%u_csum_err", i); 764 p += ETH_GSTRING_LEN; 765 sprintf(p, "rx_queue_%u_alloc_failed", i); 766 p += ETH_GSTRING_LEN; 767 } 768 /* BUG_ON(p - data != IGC_STATS_LEN * ETH_GSTRING_LEN); */ 769 break; 770 case ETH_SS_PRIV_FLAGS: 771 memcpy(data, igc_priv_flags_strings, 772 IGC_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN); 773 break; 774 } 775 } 776 777 static int igc_get_sset_count(struct net_device *netdev, int sset) 778 { 779 switch (sset) { 780 case ETH_SS_STATS: 781 return IGC_STATS_LEN; 782 case ETH_SS_TEST: 783 return IGC_TEST_LEN; 784 case ETH_SS_PRIV_FLAGS: 785 return IGC_PRIV_FLAGS_STR_LEN; 786 default: 787 return -ENOTSUPP; 788 } 789 } 790 791 static void igc_get_ethtool_stats(struct net_device *netdev, 792 struct ethtool_stats *stats, u64 *data) 793 { 794 struct igc_adapter *adapter = netdev_priv(netdev); 795 struct rtnl_link_stats64 *net_stats = &adapter->stats64; 796 unsigned int start; 797 struct igc_ring *ring; 798 int i, j; 799 char *p; 800 801 spin_lock(&adapter->stats64_lock); 802 igc_update_stats(adapter); 803 804 for (i = 0; i < IGC_GLOBAL_STATS_LEN; i++) { 805 p = (char *)adapter + igc_gstrings_stats[i].stat_offset; 806 data[i] = (igc_gstrings_stats[i].sizeof_stat == 807 sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 808 } 809 for (j = 0; j < IGC_NETDEV_STATS_LEN; j++, i++) { 810 p = (char *)net_stats + igc_gstrings_net_stats[j].stat_offset; 811 data[i] = (igc_gstrings_net_stats[j].sizeof_stat == 812 sizeof(u64)) ? *(u64 *)p : *(u32 *)p; 813 } 814 for (j = 0; j < adapter->num_tx_queues; j++) { 815 u64 restart2; 816 817 ring = adapter->tx_ring[j]; 818 do { 819 start = u64_stats_fetch_begin_irq(&ring->tx_syncp); 820 data[i] = ring->tx_stats.packets; 821 data[i + 1] = ring->tx_stats.bytes; 822 data[i + 2] = ring->tx_stats.restart_queue; 823 } while (u64_stats_fetch_retry_irq(&ring->tx_syncp, start)); 824 do { 825 start = u64_stats_fetch_begin_irq(&ring->tx_syncp2); 826 restart2 = ring->tx_stats.restart_queue2; 827 } while (u64_stats_fetch_retry_irq(&ring->tx_syncp2, start)); 828 data[i + 2] += restart2; 829 830 i += IGC_TX_QUEUE_STATS_LEN; 831 } 832 for (j = 0; j < adapter->num_rx_queues; j++) { 833 ring = adapter->rx_ring[j]; 834 do { 835 start = u64_stats_fetch_begin_irq(&ring->rx_syncp); 836 data[i] = ring->rx_stats.packets; 837 data[i + 1] = ring->rx_stats.bytes; 838 data[i + 2] = ring->rx_stats.drops; 839 data[i + 3] = ring->rx_stats.csum_err; 840 data[i + 4] = ring->rx_stats.alloc_failed; 841 } while (u64_stats_fetch_retry_irq(&ring->rx_syncp, start)); 842 i += IGC_RX_QUEUE_STATS_LEN; 843 } 844 spin_unlock(&adapter->stats64_lock); 845 } 846 847 static int igc_get_coalesce(struct net_device *netdev, 848 struct ethtool_coalesce *ec) 849 { 850 struct igc_adapter *adapter = netdev_priv(netdev); 851 852 if (adapter->rx_itr_setting <= 3) 853 ec->rx_coalesce_usecs = adapter->rx_itr_setting; 854 else 855 ec->rx_coalesce_usecs = adapter->rx_itr_setting >> 2; 856 857 if (!(adapter->flags & IGC_FLAG_QUEUE_PAIRS)) { 858 if (adapter->tx_itr_setting <= 3) 859 ec->tx_coalesce_usecs = adapter->tx_itr_setting; 860 else 861 ec->tx_coalesce_usecs = adapter->tx_itr_setting >> 2; 862 } 863 864 return 0; 865 } 866 867 static int igc_set_coalesce(struct net_device *netdev, 868 struct ethtool_coalesce *ec) 869 { 870 struct igc_adapter *adapter = netdev_priv(netdev); 871 int i; 872 873 if (ec->rx_coalesce_usecs > IGC_MAX_ITR_USECS || 874 (ec->rx_coalesce_usecs > 3 && 875 ec->rx_coalesce_usecs < IGC_MIN_ITR_USECS) || 876 ec->rx_coalesce_usecs == 2) 877 return -EINVAL; 878 879 if (ec->tx_coalesce_usecs > IGC_MAX_ITR_USECS || 880 (ec->tx_coalesce_usecs > 3 && 881 ec->tx_coalesce_usecs < IGC_MIN_ITR_USECS) || 882 ec->tx_coalesce_usecs == 2) 883 return -EINVAL; 884 885 if ((adapter->flags & IGC_FLAG_QUEUE_PAIRS) && ec->tx_coalesce_usecs) 886 return -EINVAL; 887 888 /* If ITR is disabled, disable DMAC */ 889 if (ec->rx_coalesce_usecs == 0) { 890 if (adapter->flags & IGC_FLAG_DMAC) 891 adapter->flags &= ~IGC_FLAG_DMAC; 892 } 893 894 /* convert to rate of irq's per second */ 895 if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3) 896 adapter->rx_itr_setting = ec->rx_coalesce_usecs; 897 else 898 adapter->rx_itr_setting = ec->rx_coalesce_usecs << 2; 899 900 /* convert to rate of irq's per second */ 901 if (adapter->flags & IGC_FLAG_QUEUE_PAIRS) 902 adapter->tx_itr_setting = adapter->rx_itr_setting; 903 else if (ec->tx_coalesce_usecs && ec->tx_coalesce_usecs <= 3) 904 adapter->tx_itr_setting = ec->tx_coalesce_usecs; 905 else 906 adapter->tx_itr_setting = ec->tx_coalesce_usecs << 2; 907 908 for (i = 0; i < adapter->num_q_vectors; i++) { 909 struct igc_q_vector *q_vector = adapter->q_vector[i]; 910 911 q_vector->tx.work_limit = adapter->tx_work_limit; 912 if (q_vector->rx.ring) 913 q_vector->itr_val = adapter->rx_itr_setting; 914 else 915 q_vector->itr_val = adapter->tx_itr_setting; 916 if (q_vector->itr_val && q_vector->itr_val <= 3) 917 q_vector->itr_val = IGC_START_ITR; 918 q_vector->set_itr = 1; 919 } 920 921 return 0; 922 } 923 924 #define ETHER_TYPE_FULL_MASK ((__force __be16)~0) 925 static int igc_get_ethtool_nfc_entry(struct igc_adapter *adapter, 926 struct ethtool_rxnfc *cmd) 927 { 928 struct ethtool_rx_flow_spec *fsp = &cmd->fs; 929 struct igc_nfc_filter *rule = NULL; 930 931 /* report total rule count */ 932 cmd->data = IGC_MAX_RXNFC_FILTERS; 933 934 hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 935 if (fsp->location <= rule->sw_idx) 936 break; 937 } 938 939 if (!rule || fsp->location != rule->sw_idx) 940 return -EINVAL; 941 942 if (rule->filter.match_flags) { 943 fsp->flow_type = ETHER_FLOW; 944 fsp->ring_cookie = rule->action; 945 if (rule->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) { 946 fsp->h_u.ether_spec.h_proto = rule->filter.etype; 947 fsp->m_u.ether_spec.h_proto = ETHER_TYPE_FULL_MASK; 948 } 949 if (rule->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) { 950 fsp->flow_type |= FLOW_EXT; 951 fsp->h_ext.vlan_tci = rule->filter.vlan_tci; 952 fsp->m_ext.vlan_tci = htons(VLAN_PRIO_MASK); 953 } 954 if (rule->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) { 955 ether_addr_copy(fsp->h_u.ether_spec.h_dest, 956 rule->filter.dst_addr); 957 /* As we only support matching by the full 958 * mask, return the mask to userspace 959 */ 960 eth_broadcast_addr(fsp->m_u.ether_spec.h_dest); 961 } 962 if (rule->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) { 963 ether_addr_copy(fsp->h_u.ether_spec.h_source, 964 rule->filter.src_addr); 965 /* As we only support matching by the full 966 * mask, return the mask to userspace 967 */ 968 eth_broadcast_addr(fsp->m_u.ether_spec.h_source); 969 } 970 971 return 0; 972 } 973 return -EINVAL; 974 } 975 976 static int igc_get_ethtool_nfc_all(struct igc_adapter *adapter, 977 struct ethtool_rxnfc *cmd, 978 u32 *rule_locs) 979 { 980 struct igc_nfc_filter *rule; 981 int cnt = 0; 982 983 /* report total rule count */ 984 cmd->data = IGC_MAX_RXNFC_FILTERS; 985 986 hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 987 if (cnt == cmd->rule_cnt) 988 return -EMSGSIZE; 989 rule_locs[cnt] = rule->sw_idx; 990 cnt++; 991 } 992 993 cmd->rule_cnt = cnt; 994 995 return 0; 996 } 997 998 static int igc_get_rss_hash_opts(struct igc_adapter *adapter, 999 struct ethtool_rxnfc *cmd) 1000 { 1001 cmd->data = 0; 1002 1003 /* Report default options for RSS on igc */ 1004 switch (cmd->flow_type) { 1005 case TCP_V4_FLOW: 1006 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 1007 /* Fall through */ 1008 case UDP_V4_FLOW: 1009 if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV4_UDP) 1010 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 1011 /* Fall through */ 1012 case SCTP_V4_FLOW: 1013 /* Fall through */ 1014 case AH_ESP_V4_FLOW: 1015 /* Fall through */ 1016 case AH_V4_FLOW: 1017 /* Fall through */ 1018 case ESP_V4_FLOW: 1019 /* Fall through */ 1020 case IPV4_FLOW: 1021 cmd->data |= RXH_IP_SRC | RXH_IP_DST; 1022 break; 1023 case TCP_V6_FLOW: 1024 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 1025 /* Fall through */ 1026 case UDP_V6_FLOW: 1027 if (adapter->flags & IGC_FLAG_RSS_FIELD_IPV6_UDP) 1028 cmd->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3; 1029 /* Fall through */ 1030 case SCTP_V6_FLOW: 1031 /* Fall through */ 1032 case AH_ESP_V6_FLOW: 1033 /* Fall through */ 1034 case AH_V6_FLOW: 1035 /* Fall through */ 1036 case ESP_V6_FLOW: 1037 /* Fall through */ 1038 case IPV6_FLOW: 1039 cmd->data |= RXH_IP_SRC | RXH_IP_DST; 1040 break; 1041 default: 1042 return -EINVAL; 1043 } 1044 1045 return 0; 1046 } 1047 1048 static int igc_get_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd, 1049 u32 *rule_locs) 1050 { 1051 struct igc_adapter *adapter = netdev_priv(dev); 1052 int ret = -EOPNOTSUPP; 1053 1054 switch (cmd->cmd) { 1055 case ETHTOOL_GRXRINGS: 1056 cmd->data = adapter->num_rx_queues; 1057 ret = 0; 1058 break; 1059 case ETHTOOL_GRXCLSRLCNT: 1060 cmd->rule_cnt = adapter->nfc_filter_count; 1061 ret = 0; 1062 break; 1063 case ETHTOOL_GRXCLSRULE: 1064 ret = igc_get_ethtool_nfc_entry(adapter, cmd); 1065 break; 1066 case ETHTOOL_GRXCLSRLALL: 1067 ret = igc_get_ethtool_nfc_all(adapter, cmd, rule_locs); 1068 break; 1069 case ETHTOOL_GRXFH: 1070 ret = igc_get_rss_hash_opts(adapter, cmd); 1071 break; 1072 default: 1073 break; 1074 } 1075 1076 return ret; 1077 } 1078 1079 #define UDP_RSS_FLAGS (IGC_FLAG_RSS_FIELD_IPV4_UDP | \ 1080 IGC_FLAG_RSS_FIELD_IPV6_UDP) 1081 static int igc_set_rss_hash_opt(struct igc_adapter *adapter, 1082 struct ethtool_rxnfc *nfc) 1083 { 1084 u32 flags = adapter->flags; 1085 1086 /* RSS does not support anything other than hashing 1087 * to queues on src and dst IPs and ports 1088 */ 1089 if (nfc->data & ~(RXH_IP_SRC | RXH_IP_DST | 1090 RXH_L4_B_0_1 | RXH_L4_B_2_3)) 1091 return -EINVAL; 1092 1093 switch (nfc->flow_type) { 1094 case TCP_V4_FLOW: 1095 case TCP_V6_FLOW: 1096 if (!(nfc->data & RXH_IP_SRC) || 1097 !(nfc->data & RXH_IP_DST) || 1098 !(nfc->data & RXH_L4_B_0_1) || 1099 !(nfc->data & RXH_L4_B_2_3)) 1100 return -EINVAL; 1101 break; 1102 case UDP_V4_FLOW: 1103 if (!(nfc->data & RXH_IP_SRC) || 1104 !(nfc->data & RXH_IP_DST)) 1105 return -EINVAL; 1106 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 1107 case 0: 1108 flags &= ~IGC_FLAG_RSS_FIELD_IPV4_UDP; 1109 break; 1110 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 1111 flags |= IGC_FLAG_RSS_FIELD_IPV4_UDP; 1112 break; 1113 default: 1114 return -EINVAL; 1115 } 1116 break; 1117 case UDP_V6_FLOW: 1118 if (!(nfc->data & RXH_IP_SRC) || 1119 !(nfc->data & RXH_IP_DST)) 1120 return -EINVAL; 1121 switch (nfc->data & (RXH_L4_B_0_1 | RXH_L4_B_2_3)) { 1122 case 0: 1123 flags &= ~IGC_FLAG_RSS_FIELD_IPV6_UDP; 1124 break; 1125 case (RXH_L4_B_0_1 | RXH_L4_B_2_3): 1126 flags |= IGC_FLAG_RSS_FIELD_IPV6_UDP; 1127 break; 1128 default: 1129 return -EINVAL; 1130 } 1131 break; 1132 case AH_ESP_V4_FLOW: 1133 case AH_V4_FLOW: 1134 case ESP_V4_FLOW: 1135 case SCTP_V4_FLOW: 1136 case AH_ESP_V6_FLOW: 1137 case AH_V6_FLOW: 1138 case ESP_V6_FLOW: 1139 case SCTP_V6_FLOW: 1140 if (!(nfc->data & RXH_IP_SRC) || 1141 !(nfc->data & RXH_IP_DST) || 1142 (nfc->data & RXH_L4_B_0_1) || 1143 (nfc->data & RXH_L4_B_2_3)) 1144 return -EINVAL; 1145 break; 1146 default: 1147 return -EINVAL; 1148 } 1149 1150 /* if we changed something we need to update flags */ 1151 if (flags != adapter->flags) { 1152 struct igc_hw *hw = &adapter->hw; 1153 u32 mrqc = rd32(IGC_MRQC); 1154 1155 if ((flags & UDP_RSS_FLAGS) && 1156 !(adapter->flags & UDP_RSS_FLAGS)) 1157 dev_err(&adapter->pdev->dev, 1158 "enabling UDP RSS: fragmented packets may arrive out of order to the stack above\n"); 1159 1160 adapter->flags = flags; 1161 1162 /* Perform hash on these packet types */ 1163 mrqc |= IGC_MRQC_RSS_FIELD_IPV4 | 1164 IGC_MRQC_RSS_FIELD_IPV4_TCP | 1165 IGC_MRQC_RSS_FIELD_IPV6 | 1166 IGC_MRQC_RSS_FIELD_IPV6_TCP; 1167 1168 mrqc &= ~(IGC_MRQC_RSS_FIELD_IPV4_UDP | 1169 IGC_MRQC_RSS_FIELD_IPV6_UDP); 1170 1171 if (flags & IGC_FLAG_RSS_FIELD_IPV4_UDP) 1172 mrqc |= IGC_MRQC_RSS_FIELD_IPV4_UDP; 1173 1174 if (flags & IGC_FLAG_RSS_FIELD_IPV6_UDP) 1175 mrqc |= IGC_MRQC_RSS_FIELD_IPV6_UDP; 1176 1177 wr32(IGC_MRQC, mrqc); 1178 } 1179 1180 return 0; 1181 } 1182 1183 static int igc_rxnfc_write_etype_filter(struct igc_adapter *adapter, 1184 struct igc_nfc_filter *input) 1185 { 1186 struct igc_hw *hw = &adapter->hw; 1187 u8 i; 1188 u32 etqf; 1189 u16 etype; 1190 1191 /* find an empty etype filter register */ 1192 for (i = 0; i < MAX_ETYPE_FILTER; ++i) { 1193 if (!adapter->etype_bitmap[i]) 1194 break; 1195 } 1196 if (i == MAX_ETYPE_FILTER) { 1197 dev_err(&adapter->pdev->dev, "ethtool -N: etype filters are all used.\n"); 1198 return -EINVAL; 1199 } 1200 1201 adapter->etype_bitmap[i] = true; 1202 1203 etqf = rd32(IGC_ETQF(i)); 1204 etype = ntohs(input->filter.etype & ETHER_TYPE_FULL_MASK); 1205 1206 etqf |= IGC_ETQF_FILTER_ENABLE; 1207 etqf &= ~IGC_ETQF_ETYPE_MASK; 1208 etqf |= (etype & IGC_ETQF_ETYPE_MASK); 1209 1210 etqf &= ~IGC_ETQF_QUEUE_MASK; 1211 etqf |= ((input->action << IGC_ETQF_QUEUE_SHIFT) 1212 & IGC_ETQF_QUEUE_MASK); 1213 etqf |= IGC_ETQF_QUEUE_ENABLE; 1214 1215 wr32(IGC_ETQF(i), etqf); 1216 1217 input->etype_reg_index = i; 1218 1219 return 0; 1220 } 1221 1222 static int igc_rxnfc_write_vlan_prio_filter(struct igc_adapter *adapter, 1223 struct igc_nfc_filter *input) 1224 { 1225 struct igc_hw *hw = &adapter->hw; 1226 u8 vlan_priority; 1227 u16 queue_index; 1228 u32 vlapqf; 1229 1230 vlapqf = rd32(IGC_VLAPQF); 1231 vlan_priority = (ntohs(input->filter.vlan_tci) & VLAN_PRIO_MASK) 1232 >> VLAN_PRIO_SHIFT; 1233 queue_index = (vlapqf >> (vlan_priority * 4)) & IGC_VLAPQF_QUEUE_MASK; 1234 1235 /* check whether this vlan prio is already set */ 1236 if (vlapqf & IGC_VLAPQF_P_VALID(vlan_priority) && 1237 queue_index != input->action) { 1238 dev_err(&adapter->pdev->dev, "ethtool rxnfc set vlan prio filter failed.\n"); 1239 return -EEXIST; 1240 } 1241 1242 vlapqf |= IGC_VLAPQF_P_VALID(vlan_priority); 1243 vlapqf |= IGC_VLAPQF_QUEUE_SEL(vlan_priority, input->action); 1244 1245 wr32(IGC_VLAPQF, vlapqf); 1246 1247 return 0; 1248 } 1249 1250 int igc_add_filter(struct igc_adapter *adapter, struct igc_nfc_filter *input) 1251 { 1252 struct igc_hw *hw = &adapter->hw; 1253 int err = -EINVAL; 1254 1255 if (hw->mac.type == igc_i225 && 1256 !(input->filter.match_flags & ~IGC_FILTER_FLAG_SRC_MAC_ADDR)) { 1257 dev_err(&adapter->pdev->dev, 1258 "i225 doesn't support flow classification rules specifying only source addresses.\n"); 1259 return -EOPNOTSUPP; 1260 } 1261 1262 if (input->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) { 1263 err = igc_rxnfc_write_etype_filter(adapter, input); 1264 if (err) 1265 return err; 1266 } 1267 1268 if (input->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) { 1269 err = igc_add_mac_filter(adapter, input->filter.dst_addr, 1270 input->action, 0); 1271 if (err) 1272 return err; 1273 } 1274 1275 if (input->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) { 1276 err = igc_add_mac_filter(adapter, input->filter.src_addr, 1277 input->action, 1278 IGC_MAC_STATE_SRC_ADDR); 1279 if (err) 1280 return err; 1281 } 1282 1283 if (input->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) 1284 err = igc_rxnfc_write_vlan_prio_filter(adapter, input); 1285 1286 return err; 1287 } 1288 1289 static void igc_clear_etype_filter_regs(struct igc_adapter *adapter, 1290 u16 reg_index) 1291 { 1292 struct igc_hw *hw = &adapter->hw; 1293 u32 etqf = rd32(IGC_ETQF(reg_index)); 1294 1295 etqf &= ~IGC_ETQF_QUEUE_ENABLE; 1296 etqf &= ~IGC_ETQF_QUEUE_MASK; 1297 etqf &= ~IGC_ETQF_FILTER_ENABLE; 1298 1299 wr32(IGC_ETQF(reg_index), etqf); 1300 1301 adapter->etype_bitmap[reg_index] = false; 1302 } 1303 1304 static void igc_clear_vlan_prio_filter(struct igc_adapter *adapter, 1305 u16 vlan_tci) 1306 { 1307 struct igc_hw *hw = &adapter->hw; 1308 u8 vlan_priority; 1309 u32 vlapqf; 1310 1311 vlan_priority = (vlan_tci & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT; 1312 1313 vlapqf = rd32(IGC_VLAPQF); 1314 vlapqf &= ~IGC_VLAPQF_P_VALID(vlan_priority); 1315 vlapqf &= ~IGC_VLAPQF_QUEUE_SEL(vlan_priority, 1316 IGC_VLAPQF_QUEUE_MASK); 1317 1318 wr32(IGC_VLAPQF, vlapqf); 1319 } 1320 1321 int igc_erase_filter(struct igc_adapter *adapter, struct igc_nfc_filter *input) 1322 { 1323 if (input->filter.match_flags & IGC_FILTER_FLAG_ETHER_TYPE) 1324 igc_clear_etype_filter_regs(adapter, 1325 input->etype_reg_index); 1326 1327 if (input->filter.match_flags & IGC_FILTER_FLAG_VLAN_TCI) 1328 igc_clear_vlan_prio_filter(adapter, 1329 ntohs(input->filter.vlan_tci)); 1330 1331 if (input->filter.match_flags & IGC_FILTER_FLAG_SRC_MAC_ADDR) 1332 igc_del_mac_filter(adapter, input->filter.src_addr, 1333 IGC_MAC_STATE_SRC_ADDR); 1334 1335 if (input->filter.match_flags & IGC_FILTER_FLAG_DST_MAC_ADDR) 1336 igc_del_mac_filter(adapter, input->filter.dst_addr, 0); 1337 1338 return 0; 1339 } 1340 1341 static int igc_update_ethtool_nfc_entry(struct igc_adapter *adapter, 1342 struct igc_nfc_filter *input, 1343 u16 sw_idx) 1344 { 1345 struct igc_nfc_filter *rule, *parent; 1346 int err = -EINVAL; 1347 1348 parent = NULL; 1349 rule = NULL; 1350 1351 hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 1352 /* hash found, or no matching entry */ 1353 if (rule->sw_idx >= sw_idx) 1354 break; 1355 parent = rule; 1356 } 1357 1358 /* if there is an old rule occupying our place remove it */ 1359 if (rule && rule->sw_idx == sw_idx) { 1360 if (!input) 1361 err = igc_erase_filter(adapter, rule); 1362 1363 hlist_del(&rule->nfc_node); 1364 kfree(rule); 1365 adapter->nfc_filter_count--; 1366 } 1367 1368 /* If no input this was a delete, err should be 0 if a rule was 1369 * successfully found and removed from the list else -EINVAL 1370 */ 1371 if (!input) 1372 return err; 1373 1374 /* initialize node */ 1375 INIT_HLIST_NODE(&input->nfc_node); 1376 1377 /* add filter to the list */ 1378 if (parent) 1379 hlist_add_behind(&input->nfc_node, &parent->nfc_node); 1380 else 1381 hlist_add_head(&input->nfc_node, &adapter->nfc_filter_list); 1382 1383 /* update counts */ 1384 adapter->nfc_filter_count++; 1385 1386 return 0; 1387 } 1388 1389 static int igc_add_ethtool_nfc_entry(struct igc_adapter *adapter, 1390 struct ethtool_rxnfc *cmd) 1391 { 1392 struct net_device *netdev = adapter->netdev; 1393 struct ethtool_rx_flow_spec *fsp = 1394 (struct ethtool_rx_flow_spec *)&cmd->fs; 1395 struct igc_nfc_filter *input, *rule; 1396 int err = 0; 1397 1398 if (!(netdev->hw_features & NETIF_F_NTUPLE)) 1399 return -EOPNOTSUPP; 1400 1401 /* Don't allow programming if the action is a queue greater than 1402 * the number of online Rx queues. 1403 */ 1404 if (fsp->ring_cookie == RX_CLS_FLOW_DISC || 1405 fsp->ring_cookie >= adapter->num_rx_queues) { 1406 dev_err(&adapter->pdev->dev, "ethtool -N: The specified action is invalid\n"); 1407 return -EINVAL; 1408 } 1409 1410 /* Don't allow indexes to exist outside of available space */ 1411 if (fsp->location >= IGC_MAX_RXNFC_FILTERS) { 1412 dev_err(&adapter->pdev->dev, "Location out of range\n"); 1413 return -EINVAL; 1414 } 1415 1416 if ((fsp->flow_type & ~FLOW_EXT) != ETHER_FLOW) 1417 return -EINVAL; 1418 1419 input = kzalloc(sizeof(*input), GFP_KERNEL); 1420 if (!input) 1421 return -ENOMEM; 1422 1423 if (fsp->m_u.ether_spec.h_proto == ETHER_TYPE_FULL_MASK) { 1424 input->filter.etype = fsp->h_u.ether_spec.h_proto; 1425 input->filter.match_flags = IGC_FILTER_FLAG_ETHER_TYPE; 1426 } 1427 1428 /* Only support matching addresses by the full mask */ 1429 if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_source)) { 1430 input->filter.match_flags |= IGC_FILTER_FLAG_SRC_MAC_ADDR; 1431 ether_addr_copy(input->filter.src_addr, 1432 fsp->h_u.ether_spec.h_source); 1433 } 1434 1435 /* Only support matching addresses by the full mask */ 1436 if (is_broadcast_ether_addr(fsp->m_u.ether_spec.h_dest)) { 1437 input->filter.match_flags |= IGC_FILTER_FLAG_DST_MAC_ADDR; 1438 ether_addr_copy(input->filter.dst_addr, 1439 fsp->h_u.ether_spec.h_dest); 1440 } 1441 1442 if ((fsp->flow_type & FLOW_EXT) && fsp->m_ext.vlan_tci) { 1443 if (fsp->m_ext.vlan_tci != htons(VLAN_PRIO_MASK)) { 1444 err = -EINVAL; 1445 goto err_out; 1446 } 1447 input->filter.vlan_tci = fsp->h_ext.vlan_tci; 1448 input->filter.match_flags |= IGC_FILTER_FLAG_VLAN_TCI; 1449 } 1450 1451 input->action = fsp->ring_cookie; 1452 input->sw_idx = fsp->location; 1453 1454 spin_lock(&adapter->nfc_lock); 1455 1456 hlist_for_each_entry(rule, &adapter->nfc_filter_list, nfc_node) { 1457 if (!memcmp(&input->filter, &rule->filter, 1458 sizeof(input->filter))) { 1459 err = -EEXIST; 1460 dev_err(&adapter->pdev->dev, 1461 "ethtool: this filter is already set\n"); 1462 goto err_out_w_lock; 1463 } 1464 } 1465 1466 err = igc_add_filter(adapter, input); 1467 if (err) 1468 goto err_out_w_lock; 1469 1470 igc_update_ethtool_nfc_entry(adapter, input, input->sw_idx); 1471 1472 spin_unlock(&adapter->nfc_lock); 1473 return 0; 1474 1475 err_out_w_lock: 1476 spin_unlock(&adapter->nfc_lock); 1477 err_out: 1478 kfree(input); 1479 return err; 1480 } 1481 1482 static int igc_del_ethtool_nfc_entry(struct igc_adapter *adapter, 1483 struct ethtool_rxnfc *cmd) 1484 { 1485 struct ethtool_rx_flow_spec *fsp = 1486 (struct ethtool_rx_flow_spec *)&cmd->fs; 1487 int err; 1488 1489 spin_lock(&adapter->nfc_lock); 1490 err = igc_update_ethtool_nfc_entry(adapter, NULL, fsp->location); 1491 spin_unlock(&adapter->nfc_lock); 1492 1493 return err; 1494 } 1495 1496 static int igc_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd) 1497 { 1498 struct igc_adapter *adapter = netdev_priv(dev); 1499 int ret = -EOPNOTSUPP; 1500 1501 switch (cmd->cmd) { 1502 case ETHTOOL_SRXFH: 1503 ret = igc_set_rss_hash_opt(adapter, cmd); 1504 break; 1505 case ETHTOOL_SRXCLSRLINS: 1506 ret = igc_add_ethtool_nfc_entry(adapter, cmd); 1507 break; 1508 case ETHTOOL_SRXCLSRLDEL: 1509 ret = igc_del_ethtool_nfc_entry(adapter, cmd); 1510 default: 1511 break; 1512 } 1513 1514 return ret; 1515 } 1516 1517 void igc_write_rss_indir_tbl(struct igc_adapter *adapter) 1518 { 1519 struct igc_hw *hw = &adapter->hw; 1520 u32 reg = IGC_RETA(0); 1521 u32 shift = 0; 1522 int i = 0; 1523 1524 while (i < IGC_RETA_SIZE) { 1525 u32 val = 0; 1526 int j; 1527 1528 for (j = 3; j >= 0; j--) { 1529 val <<= 8; 1530 val |= adapter->rss_indir_tbl[i + j]; 1531 } 1532 1533 wr32(reg, val << shift); 1534 reg += 4; 1535 i += 4; 1536 } 1537 } 1538 1539 static u32 igc_get_rxfh_indir_size(struct net_device *netdev) 1540 { 1541 return IGC_RETA_SIZE; 1542 } 1543 1544 static int igc_get_rxfh(struct net_device *netdev, u32 *indir, u8 *key, 1545 u8 *hfunc) 1546 { 1547 struct igc_adapter *adapter = netdev_priv(netdev); 1548 int i; 1549 1550 if (hfunc) 1551 *hfunc = ETH_RSS_HASH_TOP; 1552 if (!indir) 1553 return 0; 1554 for (i = 0; i < IGC_RETA_SIZE; i++) 1555 indir[i] = adapter->rss_indir_tbl[i]; 1556 1557 return 0; 1558 } 1559 1560 static int igc_set_rxfh(struct net_device *netdev, const u32 *indir, 1561 const u8 *key, const u8 hfunc) 1562 { 1563 struct igc_adapter *adapter = netdev_priv(netdev); 1564 u32 num_queues; 1565 int i; 1566 1567 /* We do not allow change in unsupported parameters */ 1568 if (key || 1569 (hfunc != ETH_RSS_HASH_NO_CHANGE && hfunc != ETH_RSS_HASH_TOP)) 1570 return -EOPNOTSUPP; 1571 if (!indir) 1572 return 0; 1573 1574 num_queues = adapter->rss_queues; 1575 1576 /* Verify user input. */ 1577 for (i = 0; i < IGC_RETA_SIZE; i++) 1578 if (indir[i] >= num_queues) 1579 return -EINVAL; 1580 1581 for (i = 0; i < IGC_RETA_SIZE; i++) 1582 adapter->rss_indir_tbl[i] = indir[i]; 1583 1584 igc_write_rss_indir_tbl(adapter); 1585 1586 return 0; 1587 } 1588 1589 static unsigned int igc_max_channels(struct igc_adapter *adapter) 1590 { 1591 return igc_get_max_rss_queues(adapter); 1592 } 1593 1594 static void igc_get_channels(struct net_device *netdev, 1595 struct ethtool_channels *ch) 1596 { 1597 struct igc_adapter *adapter = netdev_priv(netdev); 1598 1599 /* Report maximum channels */ 1600 ch->max_combined = igc_max_channels(adapter); 1601 1602 /* Report info for other vector */ 1603 if (adapter->flags & IGC_FLAG_HAS_MSIX) { 1604 ch->max_other = NON_Q_VECTORS; 1605 ch->other_count = NON_Q_VECTORS; 1606 } 1607 1608 ch->combined_count = adapter->rss_queues; 1609 } 1610 1611 static int igc_set_channels(struct net_device *netdev, 1612 struct ethtool_channels *ch) 1613 { 1614 struct igc_adapter *adapter = netdev_priv(netdev); 1615 unsigned int count = ch->combined_count; 1616 unsigned int max_combined = 0; 1617 1618 /* Verify they are not requesting separate vectors */ 1619 if (!count || ch->rx_count || ch->tx_count) 1620 return -EINVAL; 1621 1622 /* Verify other_count is valid and has not been changed */ 1623 if (ch->other_count != NON_Q_VECTORS) 1624 return -EINVAL; 1625 1626 /* Verify the number of channels doesn't exceed hw limits */ 1627 max_combined = igc_max_channels(adapter); 1628 if (count > max_combined) 1629 return -EINVAL; 1630 1631 if (count != adapter->rss_queues) { 1632 adapter->rss_queues = count; 1633 igc_set_flag_queue_pairs(adapter, max_combined); 1634 1635 /* Hardware has to reinitialize queues and interrupts to 1636 * match the new configuration. 1637 */ 1638 return igc_reinit_queues(adapter); 1639 } 1640 1641 return 0; 1642 } 1643 1644 static int igc_get_ts_info(struct net_device *dev, 1645 struct ethtool_ts_info *info) 1646 { 1647 struct igc_adapter *adapter = netdev_priv(dev); 1648 1649 if (adapter->ptp_clock) 1650 info->phc_index = ptp_clock_index(adapter->ptp_clock); 1651 else 1652 info->phc_index = -1; 1653 1654 switch (adapter->hw.mac.type) { 1655 case igc_i225: 1656 info->so_timestamping = 1657 SOF_TIMESTAMPING_TX_SOFTWARE | 1658 SOF_TIMESTAMPING_RX_SOFTWARE | 1659 SOF_TIMESTAMPING_SOFTWARE | 1660 SOF_TIMESTAMPING_TX_HARDWARE | 1661 SOF_TIMESTAMPING_RX_HARDWARE | 1662 SOF_TIMESTAMPING_RAW_HARDWARE; 1663 1664 info->tx_types = 1665 BIT(HWTSTAMP_TX_OFF) | 1666 BIT(HWTSTAMP_TX_ON); 1667 1668 info->rx_filters = BIT(HWTSTAMP_FILTER_NONE); 1669 info->rx_filters |= BIT(HWTSTAMP_FILTER_ALL); 1670 1671 return 0; 1672 default: 1673 return -EOPNOTSUPP; 1674 } 1675 } 1676 1677 static u32 igc_get_priv_flags(struct net_device *netdev) 1678 { 1679 struct igc_adapter *adapter = netdev_priv(netdev); 1680 u32 priv_flags = 0; 1681 1682 if (adapter->flags & IGC_FLAG_RX_LEGACY) 1683 priv_flags |= IGC_PRIV_FLAGS_LEGACY_RX; 1684 1685 return priv_flags; 1686 } 1687 1688 static int igc_set_priv_flags(struct net_device *netdev, u32 priv_flags) 1689 { 1690 struct igc_adapter *adapter = netdev_priv(netdev); 1691 unsigned int flags = adapter->flags; 1692 1693 flags &= ~IGC_FLAG_RX_LEGACY; 1694 if (priv_flags & IGC_PRIV_FLAGS_LEGACY_RX) 1695 flags |= IGC_FLAG_RX_LEGACY; 1696 1697 if (flags != adapter->flags) { 1698 adapter->flags = flags; 1699 1700 /* reset interface to repopulate queues */ 1701 if (netif_running(netdev)) 1702 igc_reinit_locked(adapter); 1703 } 1704 1705 return 0; 1706 } 1707 1708 static int igc_ethtool_begin(struct net_device *netdev) 1709 { 1710 struct igc_adapter *adapter = netdev_priv(netdev); 1711 1712 pm_runtime_get_sync(&adapter->pdev->dev); 1713 return 0; 1714 } 1715 1716 static void igc_ethtool_complete(struct net_device *netdev) 1717 { 1718 struct igc_adapter *adapter = netdev_priv(netdev); 1719 1720 pm_runtime_put(&adapter->pdev->dev); 1721 } 1722 1723 static int igc_get_link_ksettings(struct net_device *netdev, 1724 struct ethtool_link_ksettings *cmd) 1725 { 1726 struct igc_adapter *adapter = netdev_priv(netdev); 1727 struct igc_hw *hw = &adapter->hw; 1728 u32 status; 1729 u32 speed; 1730 1731 ethtool_link_ksettings_zero_link_mode(cmd, supported); 1732 ethtool_link_ksettings_zero_link_mode(cmd, advertising); 1733 1734 /* supported link modes */ 1735 ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Half); 1736 ethtool_link_ksettings_add_link_mode(cmd, supported, 10baseT_Full); 1737 ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Half); 1738 ethtool_link_ksettings_add_link_mode(cmd, supported, 100baseT_Full); 1739 ethtool_link_ksettings_add_link_mode(cmd, supported, 1000baseT_Full); 1740 ethtool_link_ksettings_add_link_mode(cmd, supported, 2500baseT_Full); 1741 1742 /* twisted pair */ 1743 cmd->base.port = PORT_TP; 1744 cmd->base.phy_address = hw->phy.addr; 1745 1746 /* advertising link modes */ 1747 ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Half); 1748 ethtool_link_ksettings_add_link_mode(cmd, advertising, 10baseT_Full); 1749 ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Half); 1750 ethtool_link_ksettings_add_link_mode(cmd, advertising, 100baseT_Full); 1751 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1000baseT_Full); 1752 ethtool_link_ksettings_add_link_mode(cmd, advertising, 2500baseT_Full); 1753 1754 /* set autoneg settings */ 1755 if (hw->mac.autoneg == 1) { 1756 ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg); 1757 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1758 Autoneg); 1759 } 1760 1761 switch (hw->fc.requested_mode) { 1762 case igc_fc_full: 1763 ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause); 1764 break; 1765 case igc_fc_rx_pause: 1766 ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause); 1767 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1768 Asym_Pause); 1769 break; 1770 case igc_fc_tx_pause: 1771 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1772 Asym_Pause); 1773 break; 1774 default: 1775 ethtool_link_ksettings_add_link_mode(cmd, advertising, Pause); 1776 ethtool_link_ksettings_add_link_mode(cmd, advertising, 1777 Asym_Pause); 1778 } 1779 1780 status = rd32(IGC_STATUS); 1781 1782 if (status & IGC_STATUS_LU) { 1783 if (status & IGC_STATUS_SPEED_1000) { 1784 /* For I225, STATUS will indicate 1G speed in both 1785 * 1 Gbps and 2.5 Gbps link modes. 1786 * An additional bit is used 1787 * to differentiate between 1 Gbps and 2.5 Gbps. 1788 */ 1789 if (hw->mac.type == igc_i225 && 1790 (status & IGC_STATUS_SPEED_2500)) { 1791 speed = SPEED_2500; 1792 } else { 1793 speed = SPEED_1000; 1794 } 1795 } else if (status & IGC_STATUS_SPEED_100) { 1796 speed = SPEED_100; 1797 } else { 1798 speed = SPEED_10; 1799 } 1800 if ((status & IGC_STATUS_FD) || 1801 hw->phy.media_type != igc_media_type_copper) 1802 cmd->base.duplex = DUPLEX_FULL; 1803 else 1804 cmd->base.duplex = DUPLEX_HALF; 1805 } else { 1806 speed = SPEED_UNKNOWN; 1807 cmd->base.duplex = DUPLEX_UNKNOWN; 1808 } 1809 cmd->base.speed = speed; 1810 if (hw->mac.autoneg) 1811 cmd->base.autoneg = AUTONEG_ENABLE; 1812 else 1813 cmd->base.autoneg = AUTONEG_DISABLE; 1814 1815 /* MDI-X => 2; MDI =>1; Invalid =>0 */ 1816 if (hw->phy.media_type == igc_media_type_copper) 1817 cmd->base.eth_tp_mdix = hw->phy.is_mdix ? ETH_TP_MDI_X : 1818 ETH_TP_MDI; 1819 else 1820 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID; 1821 1822 if (hw->phy.mdix == AUTO_ALL_MODES) 1823 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO; 1824 else 1825 cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix; 1826 1827 return 0; 1828 } 1829 1830 static int igc_set_link_ksettings(struct net_device *netdev, 1831 const struct ethtool_link_ksettings *cmd) 1832 { 1833 struct igc_adapter *adapter = netdev_priv(netdev); 1834 struct igc_hw *hw = &adapter->hw; 1835 u32 advertising; 1836 1837 /* When adapter in resetting mode, autoneg/speed/duplex 1838 * cannot be changed 1839 */ 1840 if (igc_check_reset_block(hw)) { 1841 dev_err(&adapter->pdev->dev, 1842 "Cannot change link characteristics when reset is active.\n"); 1843 return -EINVAL; 1844 } 1845 1846 /* MDI setting is only allowed when autoneg enabled because 1847 * some hardware doesn't allow MDI setting when speed or 1848 * duplex is forced. 1849 */ 1850 if (cmd->base.eth_tp_mdix_ctrl) { 1851 if (cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO && 1852 cmd->base.autoneg != AUTONEG_ENABLE) { 1853 dev_err(&adapter->pdev->dev, "forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n"); 1854 return -EINVAL; 1855 } 1856 } 1857 1858 while (test_and_set_bit(__IGC_RESETTING, &adapter->state)) 1859 usleep_range(1000, 2000); 1860 1861 ethtool_convert_link_mode_to_legacy_u32(&advertising, 1862 cmd->link_modes.advertising); 1863 1864 if (cmd->base.autoneg == AUTONEG_ENABLE) { 1865 hw->mac.autoneg = 1; 1866 hw->phy.autoneg_advertised = advertising; 1867 if (adapter->fc_autoneg) 1868 hw->fc.requested_mode = igc_fc_default; 1869 } else { 1870 /* calling this overrides forced MDI setting */ 1871 dev_info(&adapter->pdev->dev, 1872 "Force mode currently not supported\n"); 1873 } 1874 1875 /* MDI-X => 2; MDI => 1; Auto => 3 */ 1876 if (cmd->base.eth_tp_mdix_ctrl) { 1877 /* fix up the value for auto (3 => 0) as zero is mapped 1878 * internally to auto 1879 */ 1880 if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO) 1881 hw->phy.mdix = AUTO_ALL_MODES; 1882 else 1883 hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl; 1884 } 1885 1886 /* reset the link */ 1887 if (netif_running(adapter->netdev)) { 1888 igc_down(adapter); 1889 igc_up(adapter); 1890 } else { 1891 igc_reset(adapter); 1892 } 1893 1894 clear_bit(__IGC_RESETTING, &adapter->state); 1895 1896 return 0; 1897 } 1898 1899 static const struct ethtool_ops igc_ethtool_ops = { 1900 .supported_coalesce_params = ETHTOOL_COALESCE_USECS, 1901 .get_drvinfo = igc_get_drvinfo, 1902 .get_regs_len = igc_get_regs_len, 1903 .get_regs = igc_get_regs, 1904 .get_wol = igc_get_wol, 1905 .set_wol = igc_set_wol, 1906 .get_msglevel = igc_get_msglevel, 1907 .set_msglevel = igc_set_msglevel, 1908 .nway_reset = igc_nway_reset, 1909 .get_link = igc_get_link, 1910 .get_eeprom_len = igc_get_eeprom_len, 1911 .get_eeprom = igc_get_eeprom, 1912 .set_eeprom = igc_set_eeprom, 1913 .get_ringparam = igc_get_ringparam, 1914 .set_ringparam = igc_set_ringparam, 1915 .get_pauseparam = igc_get_pauseparam, 1916 .set_pauseparam = igc_set_pauseparam, 1917 .get_strings = igc_get_strings, 1918 .get_sset_count = igc_get_sset_count, 1919 .get_ethtool_stats = igc_get_ethtool_stats, 1920 .get_coalesce = igc_get_coalesce, 1921 .set_coalesce = igc_set_coalesce, 1922 .get_rxnfc = igc_get_rxnfc, 1923 .set_rxnfc = igc_set_rxnfc, 1924 .get_rxfh_indir_size = igc_get_rxfh_indir_size, 1925 .get_rxfh = igc_get_rxfh, 1926 .set_rxfh = igc_set_rxfh, 1927 .get_ts_info = igc_get_ts_info, 1928 .get_channels = igc_get_channels, 1929 .set_channels = igc_set_channels, 1930 .get_priv_flags = igc_get_priv_flags, 1931 .set_priv_flags = igc_set_priv_flags, 1932 .begin = igc_ethtool_begin, 1933 .complete = igc_ethtool_complete, 1934 .get_link_ksettings = igc_get_link_ksettings, 1935 .set_link_ksettings = igc_set_link_ksettings, 1936 }; 1937 1938 void igc_set_ethtool_ops(struct net_device *netdev) 1939 { 1940 netdev->ethtool_ops = &igc_ethtool_ops; 1941 } 1942