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