2369 lines · c
1// SPDX-License-Identifier: GPL-2.02/* Copyright(c) 1999 - 2018 Intel Corporation. */3 4/* ethtool support for e1000 */5 6#include <linux/netdevice.h>7#include <linux/interrupt.h>8#include <linux/ethtool.h>9#include <linux/pci.h>10#include <linux/slab.h>11#include <linux/delay.h>12#include <linux/vmalloc.h>13#include <linux/pm_runtime.h>14 15#include "e1000.h"16 17enum { NETDEV_STATS, E1000_STATS };18 19struct e1000_stats {20 char stat_string[ETH_GSTRING_LEN];21 int type;22 int sizeof_stat;23 int stat_offset;24};25 26static const char e1000e_priv_flags_strings[][ETH_GSTRING_LEN] = {27#define E1000E_PRIV_FLAGS_S0IX_ENABLED BIT(0)28 "s0ix-enabled",29};30 31#define E1000E_PRIV_FLAGS_STR_LEN ARRAY_SIZE(e1000e_priv_flags_strings)32 33#define E1000_STAT(str, m) { \34 .stat_string = str, \35 .type = E1000_STATS, \36 .sizeof_stat = sizeof(((struct e1000_adapter *)0)->m), \37 .stat_offset = offsetof(struct e1000_adapter, m) }38#define E1000_NETDEV_STAT(str, m) { \39 .stat_string = str, \40 .type = NETDEV_STATS, \41 .sizeof_stat = sizeof(((struct rtnl_link_stats64 *)0)->m), \42 .stat_offset = offsetof(struct rtnl_link_stats64, m) }43 44static const struct e1000_stats e1000_gstrings_stats[] = {45 E1000_STAT("rx_packets", stats.gprc),46 E1000_STAT("tx_packets", stats.gptc),47 E1000_STAT("rx_bytes", stats.gorc),48 E1000_STAT("tx_bytes", stats.gotc),49 E1000_STAT("rx_broadcast", stats.bprc),50 E1000_STAT("tx_broadcast", stats.bptc),51 E1000_STAT("rx_multicast", stats.mprc),52 E1000_STAT("tx_multicast", stats.mptc),53 E1000_NETDEV_STAT("rx_errors", rx_errors),54 E1000_NETDEV_STAT("tx_errors", tx_errors),55 E1000_NETDEV_STAT("tx_dropped", tx_dropped),56 E1000_STAT("multicast", stats.mprc),57 E1000_STAT("collisions", stats.colc),58 E1000_NETDEV_STAT("rx_length_errors", rx_length_errors),59 E1000_NETDEV_STAT("rx_over_errors", rx_over_errors),60 E1000_STAT("rx_crc_errors", stats.crcerrs),61 E1000_NETDEV_STAT("rx_frame_errors", rx_frame_errors),62 E1000_STAT("rx_no_buffer_count", stats.rnbc),63 E1000_STAT("rx_missed_errors", stats.mpc),64 E1000_STAT("tx_aborted_errors", stats.ecol),65 E1000_STAT("tx_carrier_errors", stats.tncrs),66 E1000_NETDEV_STAT("tx_fifo_errors", tx_fifo_errors),67 E1000_NETDEV_STAT("tx_heartbeat_errors", tx_heartbeat_errors),68 E1000_STAT("tx_window_errors", stats.latecol),69 E1000_STAT("tx_abort_late_coll", stats.latecol),70 E1000_STAT("tx_deferred_ok", stats.dc),71 E1000_STAT("tx_single_coll_ok", stats.scc),72 E1000_STAT("tx_multi_coll_ok", stats.mcc),73 E1000_STAT("tx_timeout_count", tx_timeout_count),74 E1000_STAT("tx_restart_queue", restart_queue),75 E1000_STAT("rx_long_length_errors", stats.roc),76 E1000_STAT("rx_short_length_errors", stats.ruc),77 E1000_STAT("rx_align_errors", stats.algnerrc),78 E1000_STAT("tx_tcp_seg_good", stats.tsctc),79 E1000_STAT("tx_tcp_seg_failed", stats.tsctfc),80 E1000_STAT("rx_flow_control_xon", stats.xonrxc),81 E1000_STAT("rx_flow_control_xoff", stats.xoffrxc),82 E1000_STAT("tx_flow_control_xon", stats.xontxc),83 E1000_STAT("tx_flow_control_xoff", stats.xofftxc),84 E1000_STAT("rx_csum_offload_good", hw_csum_good),85 E1000_STAT("rx_csum_offload_errors", hw_csum_err),86 E1000_STAT("rx_header_split", rx_hdr_split),87 E1000_STAT("alloc_rx_buff_failed", alloc_rx_buff_failed),88 E1000_STAT("tx_smbus", stats.mgptc),89 E1000_STAT("rx_smbus", stats.mgprc),90 E1000_STAT("dropped_smbus", stats.mgpdc),91 E1000_STAT("rx_dma_failed", rx_dma_failed),92 E1000_STAT("tx_dma_failed", tx_dma_failed),93 E1000_STAT("rx_hwtstamp_cleared", rx_hwtstamp_cleared),94 E1000_STAT("uncorr_ecc_errors", uncorr_errors),95 E1000_STAT("corr_ecc_errors", corr_errors),96 E1000_STAT("tx_hwtstamp_timeouts", tx_hwtstamp_timeouts),97 E1000_STAT("tx_hwtstamp_skipped", tx_hwtstamp_skipped),98};99 100#define E1000_GLOBAL_STATS_LEN ARRAY_SIZE(e1000_gstrings_stats)101#define E1000_STATS_LEN (E1000_GLOBAL_STATS_LEN)102static const char e1000_gstrings_test[][ETH_GSTRING_LEN] = {103 "Register test (offline)", "Eeprom test (offline)",104 "Interrupt test (offline)", "Loopback test (offline)",105 "Link test (on/offline)"106};107 108#define E1000_TEST_LEN ARRAY_SIZE(e1000_gstrings_test)109 110static int e1000_get_link_ksettings(struct net_device *netdev,111 struct ethtool_link_ksettings *cmd)112{113 u32 speed, supported, advertising, lp_advertising, lpa_t;114 struct e1000_adapter *adapter = netdev_priv(netdev);115 struct e1000_hw *hw = &adapter->hw;116 117 if (hw->phy.media_type == e1000_media_type_copper) {118 supported = (SUPPORTED_10baseT_Half |119 SUPPORTED_10baseT_Full |120 SUPPORTED_100baseT_Half |121 SUPPORTED_100baseT_Full |122 SUPPORTED_1000baseT_Full |123 SUPPORTED_Asym_Pause |124 SUPPORTED_Autoneg |125 SUPPORTED_Pause |126 SUPPORTED_TP);127 if (hw->phy.type == e1000_phy_ife)128 supported &= ~SUPPORTED_1000baseT_Full;129 advertising = ADVERTISED_TP;130 131 if (hw->mac.autoneg == 1) {132 advertising |= ADVERTISED_Autoneg;133 /* the e1000 autoneg seems to match ethtool nicely */134 advertising |= hw->phy.autoneg_advertised;135 }136 137 cmd->base.port = PORT_TP;138 cmd->base.phy_address = hw->phy.addr;139 } else {140 supported = (SUPPORTED_1000baseT_Full |141 SUPPORTED_FIBRE |142 SUPPORTED_Autoneg);143 144 advertising = (ADVERTISED_1000baseT_Full |145 ADVERTISED_FIBRE |146 ADVERTISED_Autoneg);147 148 cmd->base.port = PORT_FIBRE;149 }150 151 speed = SPEED_UNKNOWN;152 cmd->base.duplex = DUPLEX_UNKNOWN;153 154 if (netif_running(netdev)) {155 if (netif_carrier_ok(netdev)) {156 speed = adapter->link_speed;157 cmd->base.duplex = adapter->link_duplex - 1;158 }159 } else {160 u32 status = er32(STATUS);161 162 if (status & E1000_STATUS_LU) {163 if (status & E1000_STATUS_SPEED_1000)164 speed = SPEED_1000;165 else if (status & E1000_STATUS_SPEED_100)166 speed = SPEED_100;167 else168 speed = SPEED_10;169 170 if (status & E1000_STATUS_FD)171 cmd->base.duplex = DUPLEX_FULL;172 else173 cmd->base.duplex = DUPLEX_HALF;174 }175 }176 177 cmd->base.speed = speed;178 cmd->base.autoneg = ((hw->phy.media_type == e1000_media_type_fiber) ||179 hw->mac.autoneg) ? AUTONEG_ENABLE : AUTONEG_DISABLE;180 181 /* MDI-X => 2; MDI =>1; Invalid =>0 */182 if ((hw->phy.media_type == e1000_media_type_copper) &&183 netif_carrier_ok(netdev))184 cmd->base.eth_tp_mdix = hw->phy.is_mdix ?185 ETH_TP_MDI_X : ETH_TP_MDI;186 else187 cmd->base.eth_tp_mdix = ETH_TP_MDI_INVALID;188 189 if (hw->phy.mdix == AUTO_ALL_MODES)190 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_AUTO;191 else192 cmd->base.eth_tp_mdix_ctrl = hw->phy.mdix;193 194 if (hw->phy.media_type != e1000_media_type_copper)195 cmd->base.eth_tp_mdix_ctrl = ETH_TP_MDI_INVALID;196 197 lpa_t = mii_stat1000_to_ethtool_lpa_t(adapter->phy_regs.stat1000);198 lp_advertising = lpa_t |199 mii_lpa_to_ethtool_lpa_t(adapter->phy_regs.lpa);200 201 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,202 supported);203 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,204 advertising);205 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.lp_advertising,206 lp_advertising);207 208 return 0;209}210 211static int e1000_set_spd_dplx(struct e1000_adapter *adapter, u32 spd, u8 dplx)212{213 struct e1000_mac_info *mac = &adapter->hw.mac;214 215 mac->autoneg = 0;216 217 /* Make sure dplx is at most 1 bit and lsb of speed is not set218 * for the switch() below to work219 */220 if ((spd & 1) || (dplx & ~1))221 goto err_inval;222 223 /* Fiber NICs only allow 1000 gbps Full duplex */224 if ((adapter->hw.phy.media_type == e1000_media_type_fiber) &&225 (spd != SPEED_1000) && (dplx != DUPLEX_FULL)) {226 goto err_inval;227 }228 229 switch (spd + dplx) {230 case SPEED_10 + DUPLEX_HALF:231 mac->forced_speed_duplex = ADVERTISE_10_HALF;232 break;233 case SPEED_10 + DUPLEX_FULL:234 mac->forced_speed_duplex = ADVERTISE_10_FULL;235 break;236 case SPEED_100 + DUPLEX_HALF:237 mac->forced_speed_duplex = ADVERTISE_100_HALF;238 break;239 case SPEED_100 + DUPLEX_FULL:240 mac->forced_speed_duplex = ADVERTISE_100_FULL;241 break;242 case SPEED_1000 + DUPLEX_FULL:243 if (adapter->hw.phy.media_type == e1000_media_type_copper) {244 mac->autoneg = 1;245 adapter->hw.phy.autoneg_advertised =246 ADVERTISE_1000_FULL;247 } else {248 mac->forced_speed_duplex = ADVERTISE_1000_FULL;249 }250 break;251 case SPEED_1000 + DUPLEX_HALF: /* not supported */252 default:253 goto err_inval;254 }255 256 /* clear MDI, MDI(-X) override is only allowed when autoneg enabled */257 adapter->hw.phy.mdix = AUTO_ALL_MODES;258 259 return 0;260 261err_inval:262 e_err("Unsupported Speed/Duplex configuration\n");263 return -EINVAL;264}265 266static int e1000_set_link_ksettings(struct net_device *netdev,267 const struct ethtool_link_ksettings *cmd)268{269 struct e1000_adapter *adapter = netdev_priv(netdev);270 struct e1000_hw *hw = &adapter->hw;271 int ret_val = 0;272 u32 advertising;273 274 ethtool_convert_link_mode_to_legacy_u32(&advertising,275 cmd->link_modes.advertising);276 277 /* When SoL/IDER sessions are active, autoneg/speed/duplex278 * cannot be changed279 */280 if (hw->phy.ops.check_reset_block &&281 hw->phy.ops.check_reset_block(hw)) {282 e_err("Cannot change link characteristics when SoL/IDER is active.\n");283 return -EINVAL;284 }285 286 /* MDI setting is only allowed when autoneg enabled because287 * some hardware doesn't allow MDI setting when speed or288 * duplex is forced.289 */290 if (cmd->base.eth_tp_mdix_ctrl) {291 if (hw->phy.media_type != e1000_media_type_copper)292 return -EOPNOTSUPP;293 294 if ((cmd->base.eth_tp_mdix_ctrl != ETH_TP_MDI_AUTO) &&295 (cmd->base.autoneg != AUTONEG_ENABLE)) {296 e_err("forcing MDI/MDI-X state is not supported when link speed and/or duplex are forced\n");297 return -EINVAL;298 }299 }300 301 while (test_and_set_bit(__E1000_RESETTING, &adapter->state))302 usleep_range(1000, 2000);303 304 if (cmd->base.autoneg == AUTONEG_ENABLE) {305 hw->mac.autoneg = 1;306 if (hw->phy.media_type == e1000_media_type_fiber)307 hw->phy.autoneg_advertised = ADVERTISED_1000baseT_Full |308 ADVERTISED_FIBRE | ADVERTISED_Autoneg;309 else310 hw->phy.autoneg_advertised = advertising |311 ADVERTISED_TP | ADVERTISED_Autoneg;312 advertising = hw->phy.autoneg_advertised;313 if (adapter->fc_autoneg)314 hw->fc.requested_mode = e1000_fc_default;315 } else {316 u32 speed = cmd->base.speed;317 /* calling this overrides forced MDI setting */318 if (e1000_set_spd_dplx(adapter, speed, cmd->base.duplex)) {319 ret_val = -EINVAL;320 goto out;321 }322 }323 324 /* MDI-X => 2; MDI => 1; Auto => 3 */325 if (cmd->base.eth_tp_mdix_ctrl) {326 /* fix up the value for auto (3 => 0) as zero is mapped327 * internally to auto328 */329 if (cmd->base.eth_tp_mdix_ctrl == ETH_TP_MDI_AUTO)330 hw->phy.mdix = AUTO_ALL_MODES;331 else332 hw->phy.mdix = cmd->base.eth_tp_mdix_ctrl;333 }334 335 /* reset the link */336 if (netif_running(adapter->netdev)) {337 e1000e_down(adapter, true);338 e1000e_up(adapter);339 } else {340 e1000e_reset(adapter);341 }342 343out:344 clear_bit(__E1000_RESETTING, &adapter->state);345 return ret_val;346}347 348static void e1000_get_pauseparam(struct net_device *netdev,349 struct ethtool_pauseparam *pause)350{351 struct e1000_adapter *adapter = netdev_priv(netdev);352 struct e1000_hw *hw = &adapter->hw;353 354 pause->autoneg =355 (adapter->fc_autoneg ? AUTONEG_ENABLE : AUTONEG_DISABLE);356 357 if (hw->fc.current_mode == e1000_fc_rx_pause) {358 pause->rx_pause = 1;359 } else if (hw->fc.current_mode == e1000_fc_tx_pause) {360 pause->tx_pause = 1;361 } else if (hw->fc.current_mode == e1000_fc_full) {362 pause->rx_pause = 1;363 pause->tx_pause = 1;364 }365}366 367static int e1000_set_pauseparam(struct net_device *netdev,368 struct ethtool_pauseparam *pause)369{370 struct e1000_adapter *adapter = netdev_priv(netdev);371 struct e1000_hw *hw = &adapter->hw;372 int retval = 0;373 374 adapter->fc_autoneg = pause->autoneg;375 376 while (test_and_set_bit(__E1000_RESETTING, &adapter->state))377 usleep_range(1000, 2000);378 379 if (adapter->fc_autoneg == AUTONEG_ENABLE) {380 hw->fc.requested_mode = e1000_fc_default;381 if (netif_running(adapter->netdev)) {382 e1000e_down(adapter, true);383 e1000e_up(adapter);384 } else {385 e1000e_reset(adapter);386 }387 } else {388 if (pause->rx_pause && pause->tx_pause)389 hw->fc.requested_mode = e1000_fc_full;390 else if (pause->rx_pause && !pause->tx_pause)391 hw->fc.requested_mode = e1000_fc_rx_pause;392 else if (!pause->rx_pause && pause->tx_pause)393 hw->fc.requested_mode = e1000_fc_tx_pause;394 else if (!pause->rx_pause && !pause->tx_pause)395 hw->fc.requested_mode = e1000_fc_none;396 397 hw->fc.current_mode = hw->fc.requested_mode;398 399 if (hw->phy.media_type == e1000_media_type_fiber) {400 retval = hw->mac.ops.setup_link(hw);401 /* implicit goto out */402 } else {403 retval = e1000e_force_mac_fc(hw);404 if (retval)405 goto out;406 e1000e_set_fc_watermarks(hw);407 }408 }409 410out:411 clear_bit(__E1000_RESETTING, &adapter->state);412 return retval;413}414 415static u32 e1000_get_msglevel(struct net_device *netdev)416{417 struct e1000_adapter *adapter = netdev_priv(netdev);418 return adapter->msg_enable;419}420 421static void e1000_set_msglevel(struct net_device *netdev, u32 data)422{423 struct e1000_adapter *adapter = netdev_priv(netdev);424 adapter->msg_enable = data;425}426 427static int e1000_get_regs_len(struct net_device __always_unused *netdev)428{429#define E1000_REGS_LEN 32 /* overestimate */430 return E1000_REGS_LEN * sizeof(u32);431}432 433static void e1000_get_regs(struct net_device *netdev,434 struct ethtool_regs *regs, void *p)435{436 struct e1000_adapter *adapter = netdev_priv(netdev);437 struct e1000_hw *hw = &adapter->hw;438 u32 *regs_buff = p;439 u16 phy_data;440 441 memset(p, 0, E1000_REGS_LEN * sizeof(u32));442 443 regs->version = (1u << 24) |444 (adapter->pdev->revision << 16) |445 adapter->pdev->device;446 447 regs_buff[0] = er32(CTRL);448 regs_buff[1] = er32(STATUS);449 450 regs_buff[2] = er32(RCTL);451 regs_buff[3] = er32(RDLEN(0));452 regs_buff[4] = er32(RDH(0));453 regs_buff[5] = er32(RDT(0));454 regs_buff[6] = er32(RDTR);455 456 regs_buff[7] = er32(TCTL);457 regs_buff[8] = er32(TDLEN(0));458 regs_buff[9] = er32(TDH(0));459 regs_buff[10] = er32(TDT(0));460 regs_buff[11] = er32(TIDV);461 462 regs_buff[12] = adapter->hw.phy.type; /* PHY type (IGP=1, M88=0) */463 464 /* ethtool doesn't use anything past this point, so all this465 * code is likely legacy junk for apps that may or may not exist466 */467 if (hw->phy.type == e1000_phy_m88) {468 e1e_rphy(hw, M88E1000_PHY_SPEC_STATUS, &phy_data);469 regs_buff[13] = (u32)phy_data; /* cable length */470 regs_buff[14] = 0; /* Dummy (to align w/ IGP phy reg dump) */471 regs_buff[15] = 0; /* Dummy (to align w/ IGP phy reg dump) */472 regs_buff[16] = 0; /* Dummy (to align w/ IGP phy reg dump) */473 e1e_rphy(hw, M88E1000_PHY_SPEC_CTRL, &phy_data);474 regs_buff[17] = (u32)phy_data; /* extended 10bt distance */475 regs_buff[18] = regs_buff[13]; /* cable polarity */476 regs_buff[19] = 0; /* Dummy (to align w/ IGP phy reg dump) */477 regs_buff[20] = regs_buff[17]; /* polarity correction */478 /* phy receive errors */479 regs_buff[22] = adapter->phy_stats.receive_errors;480 regs_buff[23] = regs_buff[13]; /* mdix mode */481 }482 regs_buff[21] = 0; /* was idle_errors */483 e1e_rphy(hw, MII_STAT1000, &phy_data);484 regs_buff[24] = (u32)phy_data; /* phy local receiver status */485 regs_buff[25] = regs_buff[24]; /* phy remote receiver status */486}487 488static int e1000_get_eeprom_len(struct net_device *netdev)489{490 struct e1000_adapter *adapter = netdev_priv(netdev);491 return adapter->hw.nvm.word_size * 2;492}493 494static int e1000_get_eeprom(struct net_device *netdev,495 struct ethtool_eeprom *eeprom, u8 *bytes)496{497 struct e1000_adapter *adapter = netdev_priv(netdev);498 struct e1000_hw *hw = &adapter->hw;499 u16 *eeprom_buff;500 int first_word;501 int last_word;502 int ret_val = 0;503 u16 i;504 505 if (eeprom->len == 0)506 return -EINVAL;507 508 eeprom->magic = adapter->pdev->vendor | (adapter->pdev->device << 16);509 510 first_word = eeprom->offset >> 1;511 last_word = (eeprom->offset + eeprom->len - 1) >> 1;512 513 eeprom_buff = kmalloc_array(last_word - first_word + 1, sizeof(u16),514 GFP_KERNEL);515 if (!eeprom_buff)516 return -ENOMEM;517 518 if (hw->nvm.type == e1000_nvm_eeprom_spi) {519 ret_val = e1000_read_nvm(hw, first_word,520 last_word - first_word + 1,521 eeprom_buff);522 } else {523 for (i = 0; i < last_word - first_word + 1; i++) {524 ret_val = e1000_read_nvm(hw, first_word + i, 1,525 &eeprom_buff[i]);526 if (ret_val)527 break;528 }529 }530 531 if (ret_val) {532 /* a read error occurred, throw away the result */533 memset(eeprom_buff, 0xff, sizeof(u16) *534 (last_word - first_word + 1));535 } else {536 /* Device's eeprom is always little-endian, word addressable */537 for (i = 0; i < last_word - first_word + 1; i++)538 le16_to_cpus(&eeprom_buff[i]);539 }540 541 memcpy(bytes, (u8 *)eeprom_buff + (eeprom->offset & 1), eeprom->len);542 kfree(eeprom_buff);543 544 return ret_val;545}546 547static int e1000_set_eeprom(struct net_device *netdev,548 struct ethtool_eeprom *eeprom, u8 *bytes)549{550 struct e1000_adapter *adapter = netdev_priv(netdev);551 struct e1000_hw *hw = &adapter->hw;552 u16 *eeprom_buff;553 void *ptr;554 int max_len;555 int first_word;556 int last_word;557 int ret_val = 0;558 u16 i;559 560 if (eeprom->len == 0)561 return -EOPNOTSUPP;562 563 if (eeprom->magic !=564 (adapter->pdev->vendor | (adapter->pdev->device << 16)))565 return -EFAULT;566 567 if (adapter->flags & FLAG_READ_ONLY_NVM)568 return -EINVAL;569 570 max_len = hw->nvm.word_size * 2;571 572 first_word = eeprom->offset >> 1;573 last_word = (eeprom->offset + eeprom->len - 1) >> 1;574 eeprom_buff = kmalloc(max_len, GFP_KERNEL);575 if (!eeprom_buff)576 return -ENOMEM;577 578 ptr = (void *)eeprom_buff;579 580 if (eeprom->offset & 1) {581 /* need read/modify/write of first changed EEPROM word */582 /* only the second byte of the word is being modified */583 ret_val = e1000_read_nvm(hw, first_word, 1, &eeprom_buff[0]);584 ptr++;585 }586 if (((eeprom->offset + eeprom->len) & 1) && (!ret_val))587 /* need read/modify/write of last changed EEPROM word */588 /* only the first byte of the word is being modified */589 ret_val = e1000_read_nvm(hw, last_word, 1,590 &eeprom_buff[last_word - first_word]);591 592 if (ret_val)593 goto out;594 595 /* Device's eeprom is always little-endian, word addressable */596 for (i = 0; i < last_word - first_word + 1; i++)597 le16_to_cpus(&eeprom_buff[i]);598 599 memcpy(ptr, bytes, eeprom->len);600 601 for (i = 0; i < last_word - first_word + 1; i++)602 cpu_to_le16s(&eeprom_buff[i]);603 604 ret_val = e1000_write_nvm(hw, first_word,605 last_word - first_word + 1, eeprom_buff);606 607 if (ret_val)608 goto out;609 610 /* Update the checksum over the first part of the EEPROM if needed611 * and flush shadow RAM for applicable controllers612 */613 if ((first_word <= NVM_CHECKSUM_REG) ||614 (hw->mac.type == e1000_82583) ||615 (hw->mac.type == e1000_82574) ||616 (hw->mac.type == e1000_82573))617 ret_val = e1000e_update_nvm_checksum(hw);618 619out:620 kfree(eeprom_buff);621 return ret_val;622}623 624static void e1000_get_drvinfo(struct net_device *netdev,625 struct ethtool_drvinfo *drvinfo)626{627 struct e1000_adapter *adapter = netdev_priv(netdev);628 629 strscpy(drvinfo->driver, e1000e_driver_name, sizeof(drvinfo->driver));630 631 /* EEPROM image version # is reported as firmware version # for632 * PCI-E controllers633 */634 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),635 "%d.%d-%d",636 FIELD_GET(0xF000, adapter->eeprom_vers),637 FIELD_GET(0x0FF0, adapter->eeprom_vers),638 (adapter->eeprom_vers & 0x000F));639 640 strscpy(drvinfo->bus_info, pci_name(adapter->pdev),641 sizeof(drvinfo->bus_info));642}643 644static void e1000_get_ringparam(struct net_device *netdev,645 struct ethtool_ringparam *ring,646 struct kernel_ethtool_ringparam *kernel_ring,647 struct netlink_ext_ack *extack)648{649 struct e1000_adapter *adapter = netdev_priv(netdev);650 651 ring->rx_max_pending = E1000_MAX_RXD;652 ring->tx_max_pending = E1000_MAX_TXD;653 ring->rx_pending = adapter->rx_ring_count;654 ring->tx_pending = adapter->tx_ring_count;655}656 657static int e1000_set_ringparam(struct net_device *netdev,658 struct ethtool_ringparam *ring,659 struct kernel_ethtool_ringparam *kernel_ring,660 struct netlink_ext_ack *extack)661{662 struct e1000_adapter *adapter = netdev_priv(netdev);663 struct e1000_ring *temp_tx = NULL, *temp_rx = NULL;664 int err = 0, size = sizeof(struct e1000_ring);665 bool set_tx = false, set_rx = false;666 u16 new_rx_count, new_tx_count;667 668 if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))669 return -EINVAL;670 671 new_rx_count = clamp_t(u32, ring->rx_pending, E1000_MIN_RXD,672 E1000_MAX_RXD);673 new_rx_count = ALIGN(new_rx_count, REQ_RX_DESCRIPTOR_MULTIPLE);674 675 new_tx_count = clamp_t(u32, ring->tx_pending, E1000_MIN_TXD,676 E1000_MAX_TXD);677 new_tx_count = ALIGN(new_tx_count, REQ_TX_DESCRIPTOR_MULTIPLE);678 679 if ((new_tx_count == adapter->tx_ring_count) &&680 (new_rx_count == adapter->rx_ring_count))681 /* nothing to do */682 return 0;683 684 while (test_and_set_bit(__E1000_RESETTING, &adapter->state))685 usleep_range(1000, 2000);686 687 if (!netif_running(adapter->netdev)) {688 /* Set counts now and allocate resources during open() */689 adapter->tx_ring->count = new_tx_count;690 adapter->rx_ring->count = new_rx_count;691 adapter->tx_ring_count = new_tx_count;692 adapter->rx_ring_count = new_rx_count;693 goto clear_reset;694 }695 696 set_tx = (new_tx_count != adapter->tx_ring_count);697 set_rx = (new_rx_count != adapter->rx_ring_count);698 699 /* Allocate temporary storage for ring updates */700 if (set_tx) {701 temp_tx = vmalloc(size);702 if (!temp_tx) {703 err = -ENOMEM;704 goto free_temp;705 }706 }707 if (set_rx) {708 temp_rx = vmalloc(size);709 if (!temp_rx) {710 err = -ENOMEM;711 goto free_temp;712 }713 }714 715 e1000e_down(adapter, true);716 717 /* We can't just free everything and then setup again, because the718 * ISRs in MSI-X mode get passed pointers to the Tx and Rx ring719 * structs. First, attempt to allocate new resources...720 */721 if (set_tx) {722 memcpy(temp_tx, adapter->tx_ring, size);723 temp_tx->count = new_tx_count;724 err = e1000e_setup_tx_resources(temp_tx);725 if (err)726 goto err_setup;727 }728 if (set_rx) {729 memcpy(temp_rx, adapter->rx_ring, size);730 temp_rx->count = new_rx_count;731 err = e1000e_setup_rx_resources(temp_rx);732 if (err)733 goto err_setup_rx;734 }735 736 /* ...then free the old resources and copy back any new ring data */737 if (set_tx) {738 e1000e_free_tx_resources(adapter->tx_ring);739 memcpy(adapter->tx_ring, temp_tx, size);740 adapter->tx_ring_count = new_tx_count;741 }742 if (set_rx) {743 e1000e_free_rx_resources(adapter->rx_ring);744 memcpy(adapter->rx_ring, temp_rx, size);745 adapter->rx_ring_count = new_rx_count;746 }747 748err_setup_rx:749 if (err && set_tx)750 e1000e_free_tx_resources(temp_tx);751err_setup:752 e1000e_up(adapter);753free_temp:754 vfree(temp_tx);755 vfree(temp_rx);756clear_reset:757 clear_bit(__E1000_RESETTING, &adapter->state);758 return err;759}760 761static bool reg_pattern_test(struct e1000_adapter *adapter, u64 *data,762 int reg, int offset, u32 mask, u32 write)763{764 u32 pat, val;765 static const u32 test[] = {766 0x5A5A5A5A, 0xA5A5A5A5, 0x00000000, 0xFFFFFFFF767 };768 for (pat = 0; pat < ARRAY_SIZE(test); pat++) {769 E1000_WRITE_REG_ARRAY(&adapter->hw, reg, offset,770 (test[pat] & write));771 val = E1000_READ_REG_ARRAY(&adapter->hw, reg, offset);772 if (val != (test[pat] & write & mask)) {773 e_err("pattern test failed (reg 0x%05X): got 0x%08X expected 0x%08X\n",774 reg + (offset << 2), val,775 (test[pat] & write & mask));776 *data = reg;777 return true;778 }779 }780 return false;781}782 783static bool reg_set_and_check(struct e1000_adapter *adapter, u64 *data,784 int reg, u32 mask, u32 write)785{786 u32 val;787 788 __ew32(&adapter->hw, reg, write & mask);789 val = __er32(&adapter->hw, reg);790 if ((write & mask) != (val & mask)) {791 e_err("set/check test failed (reg 0x%05X): got 0x%08X expected 0x%08X\n",792 reg, (val & mask), (write & mask));793 *data = reg;794 return true;795 }796 return false;797}798 799#define REG_PATTERN_TEST_ARRAY(reg, offset, mask, write) \800 do { \801 if (reg_pattern_test(adapter, data, reg, offset, mask, write)) \802 return 1; \803 } while (0)804#define REG_PATTERN_TEST(reg, mask, write) \805 REG_PATTERN_TEST_ARRAY(reg, 0, mask, write)806 807#define REG_SET_AND_CHECK(reg, mask, write) \808 do { \809 if (reg_set_and_check(adapter, data, reg, mask, write)) \810 return 1; \811 } while (0)812 813static int e1000_reg_test(struct e1000_adapter *adapter, u64 *data)814{815 struct e1000_hw *hw = &adapter->hw;816 struct e1000_mac_info *mac = &adapter->hw.mac;817 u32 value;818 u32 before;819 u32 after;820 u32 i;821 u32 toggle;822 u32 mask;823 u32 wlock_mac = 0;824 825 /* The status register is Read Only, so a write should fail.826 * Some bits that get toggled are ignored. There are several bits827 * on newer hardware that are r/w.828 */829 switch (mac->type) {830 case e1000_82571:831 case e1000_82572:832 case e1000_80003es2lan:833 toggle = 0x7FFFF3FF;834 break;835 default:836 toggle = 0x7FFFF033;837 break;838 }839 840 before = er32(STATUS);841 value = (er32(STATUS) & toggle);842 ew32(STATUS, toggle);843 after = er32(STATUS) & toggle;844 if (value != after) {845 e_err("failed STATUS register test got: 0x%08X expected: 0x%08X\n",846 after, value);847 *data = 1;848 return 1;849 }850 /* restore previous status */851 ew32(STATUS, before);852 853 if (!(adapter->flags & FLAG_IS_ICH)) {854 REG_PATTERN_TEST(E1000_FCAL, 0xFFFFFFFF, 0xFFFFFFFF);855 REG_PATTERN_TEST(E1000_FCAH, 0x0000FFFF, 0xFFFFFFFF);856 REG_PATTERN_TEST(E1000_FCT, 0x0000FFFF, 0xFFFFFFFF);857 REG_PATTERN_TEST(E1000_VET, 0x0000FFFF, 0xFFFFFFFF);858 }859 860 REG_PATTERN_TEST(E1000_RDTR, 0x0000FFFF, 0xFFFFFFFF);861 REG_PATTERN_TEST(E1000_RDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF);862 REG_PATTERN_TEST(E1000_RDLEN(0), 0x000FFF80, 0x000FFFFF);863 REG_PATTERN_TEST(E1000_RDH(0), 0x0000FFFF, 0x0000FFFF);864 REG_PATTERN_TEST(E1000_RDT(0), 0x0000FFFF, 0x0000FFFF);865 REG_PATTERN_TEST(E1000_FCRTH, 0x0000FFF8, 0x0000FFF8);866 REG_PATTERN_TEST(E1000_FCTTV, 0x0000FFFF, 0x0000FFFF);867 REG_PATTERN_TEST(E1000_TIPG, 0x3FFFFFFF, 0x3FFFFFFF);868 REG_PATTERN_TEST(E1000_TDBAH(0), 0xFFFFFFFF, 0xFFFFFFFF);869 REG_PATTERN_TEST(E1000_TDLEN(0), 0x000FFF80, 0x000FFFFF);870 871 REG_SET_AND_CHECK(E1000_RCTL, 0xFFFFFFFF, 0x00000000);872 873 before = ((adapter->flags & FLAG_IS_ICH) ? 0x06C3B33E : 0x06DFB3FE);874 REG_SET_AND_CHECK(E1000_RCTL, before, 0x003FFFFB);875 REG_SET_AND_CHECK(E1000_TCTL, 0xFFFFFFFF, 0x00000000);876 877 REG_SET_AND_CHECK(E1000_RCTL, before, 0xFFFFFFFF);878 REG_PATTERN_TEST(E1000_RDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF);879 if (!(adapter->flags & FLAG_IS_ICH))880 REG_PATTERN_TEST(E1000_TXCW, 0xC000FFFF, 0x0000FFFF);881 REG_PATTERN_TEST(E1000_TDBAL(0), 0xFFFFFFF0, 0xFFFFFFFF);882 REG_PATTERN_TEST(E1000_TIDV, 0x0000FFFF, 0x0000FFFF);883 mask = 0x8003FFFF;884 switch (mac->type) {885 case e1000_ich10lan:886 case e1000_pchlan:887 case e1000_pch2lan:888 case e1000_pch_lpt:889 case e1000_pch_spt:890 case e1000_pch_cnp:891 case e1000_pch_tgp:892 case e1000_pch_adp:893 case e1000_pch_mtp:894 case e1000_pch_lnp:895 case e1000_pch_ptp:896 case e1000_pch_nvp:897 mask |= BIT(18);898 break;899 default:900 break;901 }902 903 if (mac->type >= e1000_pch_lpt)904 wlock_mac = FIELD_GET(E1000_FWSM_WLOCK_MAC_MASK, er32(FWSM));905 906 for (i = 0; i < mac->rar_entry_count; i++) {907 if (mac->type >= e1000_pch_lpt) {908 /* Cannot test write-protected SHRAL[n] registers */909 if ((wlock_mac == 1) || (wlock_mac && (i > wlock_mac)))910 continue;911 912 /* SHRAH[9] different than the others */913 if (i == 10)914 mask |= BIT(30);915 else916 mask &= ~BIT(30);917 }918 if (mac->type == e1000_pch2lan) {919 /* SHRAH[0,1,2] different than previous */920 if (i == 1)921 mask &= 0xFFF4FFFF;922 /* SHRAH[3] different than SHRAH[0,1,2] */923 if (i == 4)924 mask |= BIT(30);925 /* RAR[1-6] owned by management engine - skipping */926 if (i > 0)927 i += 6;928 }929 930 REG_PATTERN_TEST_ARRAY(E1000_RA, ((i << 1) + 1), mask,931 0xFFFFFFFF);932 /* reset index to actual value */933 if ((mac->type == e1000_pch2lan) && (i > 6))934 i -= 6;935 }936 937 for (i = 0; i < mac->mta_reg_count; i++)938 REG_PATTERN_TEST_ARRAY(E1000_MTA, i, 0xFFFFFFFF, 0xFFFFFFFF);939 940 *data = 0;941 942 return 0;943}944 945static int e1000_eeprom_test(struct e1000_adapter *adapter, u64 *data)946{947 u16 temp;948 u16 checksum = 0;949 u16 i;950 951 *data = 0;952 /* Read and add up the contents of the EEPROM */953 for (i = 0; i < (NVM_CHECKSUM_REG + 1); i++) {954 if ((e1000_read_nvm(&adapter->hw, i, 1, &temp)) < 0) {955 *data = 1;956 return *data;957 }958 checksum += temp;959 }960 961 /* If Checksum is not Correct return error else test passed */962 if ((checksum != (u16)NVM_SUM) && !(*data))963 *data = 2;964 965 return *data;966}967 968static irqreturn_t e1000_test_intr(int __always_unused irq, void *data)969{970 struct net_device *netdev = (struct net_device *)data;971 struct e1000_adapter *adapter = netdev_priv(netdev);972 struct e1000_hw *hw = &adapter->hw;973 974 adapter->test_icr |= er32(ICR);975 976 return IRQ_HANDLED;977}978 979static int e1000_intr_test(struct e1000_adapter *adapter, u64 *data)980{981 struct net_device *netdev = adapter->netdev;982 struct e1000_hw *hw = &adapter->hw;983 u32 mask;984 u32 shared_int = 1;985 u32 irq = adapter->pdev->irq;986 int i;987 int ret_val = 0;988 int int_mode = E1000E_INT_MODE_LEGACY;989 990 *data = 0;991 992 /* NOTE: we don't test MSI/MSI-X interrupts here, yet */993 if (adapter->int_mode == E1000E_INT_MODE_MSIX) {994 int_mode = adapter->int_mode;995 e1000e_reset_interrupt_capability(adapter);996 adapter->int_mode = E1000E_INT_MODE_LEGACY;997 e1000e_set_interrupt_capability(adapter);998 }999 /* Hook up test interrupt handler just for this test */1000 if (!request_irq(irq, e1000_test_intr, IRQF_PROBE_SHARED, netdev->name,1001 netdev)) {1002 shared_int = 0;1003 } else if (request_irq(irq, e1000_test_intr, IRQF_SHARED, netdev->name,1004 netdev)) {1005 *data = 1;1006 ret_val = -1;1007 goto out;1008 }1009 e_info("testing %s interrupt\n", (shared_int ? "shared" : "unshared"));1010 1011 /* Disable all the interrupts */1012 ew32(IMC, 0xFFFFFFFF);1013 e1e_flush();1014 usleep_range(10000, 11000);1015 1016 /* Test each interrupt */1017 for (i = 0; i < 10; i++) {1018 /* Interrupt to test */1019 mask = BIT(i);1020 1021 if (adapter->flags & FLAG_IS_ICH) {1022 switch (mask) {1023 case E1000_ICR_RXSEQ:1024 continue;1025 case 0x00000100:1026 if (adapter->hw.mac.type == e1000_ich8lan ||1027 adapter->hw.mac.type == e1000_ich9lan)1028 continue;1029 break;1030 default:1031 break;1032 }1033 }1034 1035 if (!shared_int) {1036 /* Disable the interrupt to be reported in1037 * the cause register and then force the same1038 * interrupt and see if one gets posted. If1039 * an interrupt was posted to the bus, the1040 * test failed.1041 */1042 adapter->test_icr = 0;1043 ew32(IMC, mask);1044 ew32(ICS, mask);1045 e1e_flush();1046 usleep_range(10000, 11000);1047 1048 if (adapter->test_icr & mask) {1049 *data = 3;1050 break;1051 }1052 }1053 1054 /* Enable the interrupt to be reported in1055 * the cause register and then force the same1056 * interrupt and see if one gets posted. If1057 * an interrupt was not posted to the bus, the1058 * test failed.1059 */1060 adapter->test_icr = 0;1061 ew32(IMS, mask);1062 ew32(ICS, mask);1063 e1e_flush();1064 usleep_range(10000, 11000);1065 1066 if (!(adapter->test_icr & mask)) {1067 *data = 4;1068 break;1069 }1070 1071 if (!shared_int) {1072 /* Disable the other interrupts to be reported in1073 * the cause register and then force the other1074 * interrupts and see if any get posted. If1075 * an interrupt was posted to the bus, the1076 * test failed.1077 */1078 adapter->test_icr = 0;1079 ew32(IMC, ~mask & 0x00007FFF);1080 ew32(ICS, ~mask & 0x00007FFF);1081 e1e_flush();1082 usleep_range(10000, 11000);1083 1084 if (adapter->test_icr) {1085 *data = 5;1086 break;1087 }1088 }1089 }1090 1091 /* Disable all the interrupts */1092 ew32(IMC, 0xFFFFFFFF);1093 e1e_flush();1094 usleep_range(10000, 11000);1095 1096 /* Unhook test interrupt handler */1097 free_irq(irq, netdev);1098 1099out:1100 if (int_mode == E1000E_INT_MODE_MSIX) {1101 e1000e_reset_interrupt_capability(adapter);1102 adapter->int_mode = int_mode;1103 e1000e_set_interrupt_capability(adapter);1104 }1105 1106 return ret_val;1107}1108 1109static void e1000_free_desc_rings(struct e1000_adapter *adapter)1110{1111 struct e1000_ring *tx_ring = &adapter->test_tx_ring;1112 struct e1000_ring *rx_ring = &adapter->test_rx_ring;1113 struct pci_dev *pdev = adapter->pdev;1114 struct e1000_buffer *buffer_info;1115 int i;1116 1117 if (tx_ring->desc && tx_ring->buffer_info) {1118 for (i = 0; i < tx_ring->count; i++) {1119 buffer_info = &tx_ring->buffer_info[i];1120 1121 if (buffer_info->dma)1122 dma_unmap_single(&pdev->dev,1123 buffer_info->dma,1124 buffer_info->length,1125 DMA_TO_DEVICE);1126 dev_kfree_skb(buffer_info->skb);1127 }1128 }1129 1130 if (rx_ring->desc && rx_ring->buffer_info) {1131 for (i = 0; i < rx_ring->count; i++) {1132 buffer_info = &rx_ring->buffer_info[i];1133 1134 if (buffer_info->dma)1135 dma_unmap_single(&pdev->dev,1136 buffer_info->dma,1137 2048, DMA_FROM_DEVICE);1138 dev_kfree_skb(buffer_info->skb);1139 }1140 }1141 1142 if (tx_ring->desc) {1143 dma_free_coherent(&pdev->dev, tx_ring->size, tx_ring->desc,1144 tx_ring->dma);1145 tx_ring->desc = NULL;1146 }1147 if (rx_ring->desc) {1148 dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,1149 rx_ring->dma);1150 rx_ring->desc = NULL;1151 }1152 1153 kfree(tx_ring->buffer_info);1154 tx_ring->buffer_info = NULL;1155 kfree(rx_ring->buffer_info);1156 rx_ring->buffer_info = NULL;1157}1158 1159static int e1000_setup_desc_rings(struct e1000_adapter *adapter)1160{1161 struct e1000_ring *tx_ring = &adapter->test_tx_ring;1162 struct e1000_ring *rx_ring = &adapter->test_rx_ring;1163 struct pci_dev *pdev = adapter->pdev;1164 struct e1000_hw *hw = &adapter->hw;1165 u32 rctl;1166 int i;1167 int ret_val;1168 1169 /* Setup Tx descriptor ring and Tx buffers */1170 1171 if (!tx_ring->count)1172 tx_ring->count = E1000_DEFAULT_TXD;1173 1174 tx_ring->buffer_info = kcalloc(tx_ring->count,1175 sizeof(struct e1000_buffer), GFP_KERNEL);1176 if (!tx_ring->buffer_info) {1177 ret_val = 1;1178 goto err_nomem;1179 }1180 1181 tx_ring->size = tx_ring->count * sizeof(struct e1000_tx_desc);1182 tx_ring->size = ALIGN(tx_ring->size, 4096);1183 tx_ring->desc = dma_alloc_coherent(&pdev->dev, tx_ring->size,1184 &tx_ring->dma, GFP_KERNEL);1185 if (!tx_ring->desc) {1186 ret_val = 2;1187 goto err_nomem;1188 }1189 tx_ring->next_to_use = 0;1190 tx_ring->next_to_clean = 0;1191 1192 ew32(TDBAL(0), ((u64)tx_ring->dma & 0x00000000FFFFFFFF));1193 ew32(TDBAH(0), ((u64)tx_ring->dma >> 32));1194 ew32(TDLEN(0), tx_ring->count * sizeof(struct e1000_tx_desc));1195 ew32(TDH(0), 0);1196 ew32(TDT(0), 0);1197 ew32(TCTL, E1000_TCTL_PSP | E1000_TCTL_EN | E1000_TCTL_MULR |1198 E1000_COLLISION_THRESHOLD << E1000_CT_SHIFT |1199 E1000_COLLISION_DISTANCE << E1000_COLD_SHIFT);1200 1201 for (i = 0; i < tx_ring->count; i++) {1202 struct e1000_tx_desc *tx_desc = E1000_TX_DESC(*tx_ring, i);1203 struct sk_buff *skb;1204 unsigned int skb_size = 1024;1205 1206 skb = alloc_skb(skb_size, GFP_KERNEL);1207 if (!skb) {1208 ret_val = 3;1209 goto err_nomem;1210 }1211 skb_put(skb, skb_size);1212 tx_ring->buffer_info[i].skb = skb;1213 tx_ring->buffer_info[i].length = skb->len;1214 tx_ring->buffer_info[i].dma =1215 dma_map_single(&pdev->dev, skb->data, skb->len,1216 DMA_TO_DEVICE);1217 if (dma_mapping_error(&pdev->dev,1218 tx_ring->buffer_info[i].dma)) {1219 ret_val = 4;1220 goto err_nomem;1221 }1222 tx_desc->buffer_addr = cpu_to_le64(tx_ring->buffer_info[i].dma);1223 tx_desc->lower.data = cpu_to_le32(skb->len);1224 tx_desc->lower.data |= cpu_to_le32(E1000_TXD_CMD_EOP |1225 E1000_TXD_CMD_IFCS |1226 E1000_TXD_CMD_RS);1227 tx_desc->upper.data = 0;1228 }1229 1230 /* Setup Rx descriptor ring and Rx buffers */1231 1232 if (!rx_ring->count)1233 rx_ring->count = E1000_DEFAULT_RXD;1234 1235 rx_ring->buffer_info = kcalloc(rx_ring->count,1236 sizeof(struct e1000_buffer), GFP_KERNEL);1237 if (!rx_ring->buffer_info) {1238 ret_val = 5;1239 goto err_nomem;1240 }1241 1242 rx_ring->size = rx_ring->count * sizeof(union e1000_rx_desc_extended);1243 rx_ring->desc = dma_alloc_coherent(&pdev->dev, rx_ring->size,1244 &rx_ring->dma, GFP_KERNEL);1245 if (!rx_ring->desc) {1246 ret_val = 6;1247 goto err_nomem;1248 }1249 rx_ring->next_to_use = 0;1250 rx_ring->next_to_clean = 0;1251 1252 rctl = er32(RCTL);1253 if (!(adapter->flags2 & FLAG2_NO_DISABLE_RX))1254 ew32(RCTL, rctl & ~E1000_RCTL_EN);1255 ew32(RDBAL(0), ((u64)rx_ring->dma & 0xFFFFFFFF));1256 ew32(RDBAH(0), ((u64)rx_ring->dma >> 32));1257 ew32(RDLEN(0), rx_ring->size);1258 ew32(RDH(0), 0);1259 ew32(RDT(0), 0);1260 rctl = E1000_RCTL_EN | E1000_RCTL_BAM | E1000_RCTL_SZ_2048 |1261 E1000_RCTL_UPE | E1000_RCTL_MPE | E1000_RCTL_LPE |1262 E1000_RCTL_SBP | E1000_RCTL_SECRC |1263 E1000_RCTL_LBM_NO | E1000_RCTL_RDMTS_HALF |1264 (adapter->hw.mac.mc_filter_type << E1000_RCTL_MO_SHIFT);1265 ew32(RCTL, rctl);1266 1267 for (i = 0; i < rx_ring->count; i++) {1268 union e1000_rx_desc_extended *rx_desc;1269 struct sk_buff *skb;1270 1271 skb = alloc_skb(2048 + NET_IP_ALIGN, GFP_KERNEL);1272 if (!skb) {1273 ret_val = 7;1274 goto err_nomem;1275 }1276 skb_reserve(skb, NET_IP_ALIGN);1277 rx_ring->buffer_info[i].skb = skb;1278 rx_ring->buffer_info[i].dma =1279 dma_map_single(&pdev->dev, skb->data, 2048,1280 DMA_FROM_DEVICE);1281 if (dma_mapping_error(&pdev->dev,1282 rx_ring->buffer_info[i].dma)) {1283 ret_val = 8;1284 goto err_nomem;1285 }1286 rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);1287 rx_desc->read.buffer_addr =1288 cpu_to_le64(rx_ring->buffer_info[i].dma);1289 memset(skb->data, 0x00, skb->len);1290 }1291 1292 return 0;1293 1294err_nomem:1295 e1000_free_desc_rings(adapter);1296 return ret_val;1297}1298 1299static void e1000_phy_disable_receiver(struct e1000_adapter *adapter)1300{1301 /* Write out to PHY registers 29 and 30 to disable the Receiver. */1302 e1e_wphy(&adapter->hw, 29, 0x001F);1303 e1e_wphy(&adapter->hw, 30, 0x8FFC);1304 e1e_wphy(&adapter->hw, 29, 0x001A);1305 e1e_wphy(&adapter->hw, 30, 0x8FF0);1306}1307 1308static int e1000_integrated_phy_loopback(struct e1000_adapter *adapter)1309{1310 struct e1000_hw *hw = &adapter->hw;1311 u32 ctrl_reg = 0;1312 u16 phy_reg = 0;1313 s32 ret_val = 0;1314 1315 hw->mac.autoneg = 0;1316 1317 if (hw->phy.type == e1000_phy_ife) {1318 /* force 100, set loopback */1319 e1e_wphy(hw, MII_BMCR, 0x6100);1320 1321 /* Now set up the MAC to the same speed/duplex as the PHY. */1322 ctrl_reg = er32(CTRL);1323 ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */1324 ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */1325 E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */1326 E1000_CTRL_SPD_100 |/* Force Speed to 100 */1327 E1000_CTRL_FD); /* Force Duplex to FULL */1328 1329 ew32(CTRL, ctrl_reg);1330 e1e_flush();1331 usleep_range(500, 1000);1332 1333 return 0;1334 }1335 1336 /* Specific PHY configuration for loopback */1337 switch (hw->phy.type) {1338 case e1000_phy_m88:1339 /* Auto-MDI/MDIX Off */1340 e1e_wphy(hw, M88E1000_PHY_SPEC_CTRL, 0x0808);1341 /* reset to update Auto-MDI/MDIX */1342 e1e_wphy(hw, MII_BMCR, 0x9140);1343 /* autoneg off */1344 e1e_wphy(hw, MII_BMCR, 0x8140);1345 break;1346 case e1000_phy_gg82563:1347 e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x1CC);1348 break;1349 case e1000_phy_bm:1350 /* Set Default MAC Interface speed to 1GB */1351 e1e_rphy(hw, PHY_REG(2, 21), &phy_reg);1352 phy_reg &= ~0x0007;1353 phy_reg |= 0x006;1354 e1e_wphy(hw, PHY_REG(2, 21), phy_reg);1355 /* Assert SW reset for above settings to take effect */1356 hw->phy.ops.commit(hw);1357 usleep_range(1000, 2000);1358 /* Force Full Duplex */1359 e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);1360 e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x000C);1361 /* Set Link Up (in force link) */1362 e1e_rphy(hw, PHY_REG(776, 16), &phy_reg);1363 e1e_wphy(hw, PHY_REG(776, 16), phy_reg | 0x0040);1364 /* Force Link */1365 e1e_rphy(hw, PHY_REG(769, 16), &phy_reg);1366 e1e_wphy(hw, PHY_REG(769, 16), phy_reg | 0x0040);1367 /* Set Early Link Enable */1368 e1e_rphy(hw, PHY_REG(769, 20), &phy_reg);1369 e1e_wphy(hw, PHY_REG(769, 20), phy_reg | 0x0400);1370 break;1371 case e1000_phy_82577:1372 case e1000_phy_82578:1373 /* Workaround: K1 must be disabled for stable 1Gbps operation */1374 ret_val = hw->phy.ops.acquire(hw);1375 if (ret_val) {1376 e_err("Cannot setup 1Gbps loopback.\n");1377 return ret_val;1378 }1379 e1000_configure_k1_ich8lan(hw, false);1380 hw->phy.ops.release(hw);1381 break;1382 case e1000_phy_82579:1383 /* Disable PHY energy detect power down */1384 e1e_rphy(hw, PHY_REG(0, 21), &phy_reg);1385 e1e_wphy(hw, PHY_REG(0, 21), phy_reg & ~BIT(3));1386 /* Disable full chip energy detect */1387 e1e_rphy(hw, PHY_REG(776, 18), &phy_reg);1388 e1e_wphy(hw, PHY_REG(776, 18), phy_reg | 1);1389 /* Enable loopback on the PHY */1390 e1e_wphy(hw, I82577_PHY_LBK_CTRL, 0x8001);1391 break;1392 default:1393 break;1394 }1395 1396 /* force 1000, set loopback */1397 e1e_wphy(hw, MII_BMCR, 0x4140);1398 msleep(250);1399 1400 /* Now set up the MAC to the same speed/duplex as the PHY. */1401 ctrl_reg = er32(CTRL);1402 ctrl_reg &= ~E1000_CTRL_SPD_SEL; /* Clear the speed sel bits */1403 ctrl_reg |= (E1000_CTRL_FRCSPD | /* Set the Force Speed Bit */1404 E1000_CTRL_FRCDPX | /* Set the Force Duplex Bit */1405 E1000_CTRL_SPD_1000 |/* Force Speed to 1000 */1406 E1000_CTRL_FD); /* Force Duplex to FULL */1407 1408 if (adapter->flags & FLAG_IS_ICH)1409 ctrl_reg |= E1000_CTRL_SLU; /* Set Link Up */1410 1411 if (hw->phy.media_type == e1000_media_type_copper &&1412 hw->phy.type == e1000_phy_m88) {1413 ctrl_reg |= E1000_CTRL_ILOS; /* Invert Loss of Signal */1414 } else {1415 /* Set the ILOS bit on the fiber Nic if half duplex link is1416 * detected.1417 */1418 if ((er32(STATUS) & E1000_STATUS_FD) == 0)1419 ctrl_reg |= (E1000_CTRL_ILOS | E1000_CTRL_SLU);1420 }1421 1422 ew32(CTRL, ctrl_reg);1423 1424 /* Disable the receiver on the PHY so when a cable is plugged in, the1425 * PHY does not begin to autoneg when a cable is reconnected to the NIC.1426 */1427 if (hw->phy.type == e1000_phy_m88)1428 e1000_phy_disable_receiver(adapter);1429 1430 usleep_range(500, 1000);1431 1432 return 0;1433}1434 1435static int e1000_set_82571_fiber_loopback(struct e1000_adapter *adapter)1436{1437 struct e1000_hw *hw = &adapter->hw;1438 u32 ctrl = er32(CTRL);1439 int link;1440 1441 /* special requirements for 82571/82572 fiber adapters */1442 1443 /* jump through hoops to make sure link is up because serdes1444 * link is hardwired up1445 */1446 ctrl |= E1000_CTRL_SLU;1447 ew32(CTRL, ctrl);1448 1449 /* disable autoneg */1450 ctrl = er32(TXCW);1451 ctrl &= ~BIT(31);1452 ew32(TXCW, ctrl);1453 1454 link = (er32(STATUS) & E1000_STATUS_LU);1455 1456 if (!link) {1457 /* set invert loss of signal */1458 ctrl = er32(CTRL);1459 ctrl |= E1000_CTRL_ILOS;1460 ew32(CTRL, ctrl);1461 }1462 1463 /* special write to serdes control register to enable SerDes analog1464 * loopback1465 */1466 ew32(SCTL, E1000_SCTL_ENABLE_SERDES_LOOPBACK);1467 e1e_flush();1468 usleep_range(10000, 11000);1469 1470 return 0;1471}1472 1473/* only call this for fiber/serdes connections to es2lan */1474static int e1000_set_es2lan_mac_loopback(struct e1000_adapter *adapter)1475{1476 struct e1000_hw *hw = &adapter->hw;1477 u32 ctrlext = er32(CTRL_EXT);1478 u32 ctrl = er32(CTRL);1479 1480 /* save CTRL_EXT to restore later, reuse an empty variable (unused1481 * on mac_type 80003es2lan)1482 */1483 adapter->tx_fifo_head = ctrlext;1484 1485 /* clear the serdes mode bits, putting the device into mac loopback */1486 ctrlext &= ~E1000_CTRL_EXT_LINK_MODE_PCIE_SERDES;1487 ew32(CTRL_EXT, ctrlext);1488 1489 /* force speed to 1000/FD, link up */1490 ctrl &= ~(E1000_CTRL_SPD_1000 | E1000_CTRL_SPD_100);1491 ctrl |= (E1000_CTRL_SLU | E1000_CTRL_FRCSPD | E1000_CTRL_FRCDPX |1492 E1000_CTRL_SPD_1000 | E1000_CTRL_FD);1493 ew32(CTRL, ctrl);1494 1495 /* set mac loopback */1496 ctrl = er32(RCTL);1497 ctrl |= E1000_RCTL_LBM_MAC;1498 ew32(RCTL, ctrl);1499 1500 /* set testing mode parameters (no need to reset later) */1501#define KMRNCTRLSTA_OPMODE (0x1F << 16)1502#define KMRNCTRLSTA_OPMODE_1GB_FD_GMII 0x05821503 ew32(KMRNCTRLSTA,1504 (KMRNCTRLSTA_OPMODE | KMRNCTRLSTA_OPMODE_1GB_FD_GMII));1505 1506 return 0;1507}1508 1509static int e1000_setup_loopback_test(struct e1000_adapter *adapter)1510{1511 struct e1000_hw *hw = &adapter->hw;1512 u32 rctl, fext_nvm11, tarc0;1513 1514 if (hw->mac.type >= e1000_pch_spt) {1515 fext_nvm11 = er32(FEXTNVM11);1516 fext_nvm11 |= E1000_FEXTNVM11_DISABLE_MULR_FIX;1517 ew32(FEXTNVM11, fext_nvm11);1518 tarc0 = er32(TARC(0));1519 /* clear bits 28 & 29 (control of MULR concurrent requests) */1520 tarc0 &= 0xcfffffff;1521 /* set bit 29 (value of MULR requests is now 2) */1522 tarc0 |= 0x20000000;1523 ew32(TARC(0), tarc0);1524 }1525 if (hw->phy.media_type == e1000_media_type_fiber ||1526 hw->phy.media_type == e1000_media_type_internal_serdes) {1527 switch (hw->mac.type) {1528 case e1000_80003es2lan:1529 return e1000_set_es2lan_mac_loopback(adapter);1530 case e1000_82571:1531 case e1000_82572:1532 return e1000_set_82571_fiber_loopback(adapter);1533 default:1534 rctl = er32(RCTL);1535 rctl |= E1000_RCTL_LBM_TCVR;1536 ew32(RCTL, rctl);1537 return 0;1538 }1539 } else if (hw->phy.media_type == e1000_media_type_copper) {1540 return e1000_integrated_phy_loopback(adapter);1541 }1542 1543 return 7;1544}1545 1546static void e1000_loopback_cleanup(struct e1000_adapter *adapter)1547{1548 struct e1000_hw *hw = &adapter->hw;1549 u32 rctl, fext_nvm11, tarc0;1550 u16 phy_reg;1551 1552 rctl = er32(RCTL);1553 rctl &= ~(E1000_RCTL_LBM_TCVR | E1000_RCTL_LBM_MAC);1554 ew32(RCTL, rctl);1555 1556 switch (hw->mac.type) {1557 case e1000_pch_spt:1558 case e1000_pch_cnp:1559 case e1000_pch_tgp:1560 case e1000_pch_adp:1561 case e1000_pch_mtp:1562 case e1000_pch_lnp:1563 case e1000_pch_ptp:1564 case e1000_pch_nvp:1565 fext_nvm11 = er32(FEXTNVM11);1566 fext_nvm11 &= ~E1000_FEXTNVM11_DISABLE_MULR_FIX;1567 ew32(FEXTNVM11, fext_nvm11);1568 tarc0 = er32(TARC(0));1569 /* clear bits 28 & 29 (control of MULR concurrent requests) */1570 /* set bit 29 (value of MULR requests is now 0) */1571 tarc0 &= 0xcfffffff;1572 ew32(TARC(0), tarc0);1573 fallthrough;1574 case e1000_80003es2lan:1575 if (hw->phy.media_type == e1000_media_type_fiber ||1576 hw->phy.media_type == e1000_media_type_internal_serdes) {1577 /* restore CTRL_EXT, stealing space from tx_fifo_head */1578 ew32(CTRL_EXT, adapter->tx_fifo_head);1579 adapter->tx_fifo_head = 0;1580 }1581 fallthrough;1582 case e1000_82571:1583 case e1000_82572:1584 if (hw->phy.media_type == e1000_media_type_fiber ||1585 hw->phy.media_type == e1000_media_type_internal_serdes) {1586 ew32(SCTL, E1000_SCTL_DISABLE_SERDES_LOOPBACK);1587 e1e_flush();1588 usleep_range(10000, 11000);1589 break;1590 }1591 fallthrough;1592 default:1593 hw->mac.autoneg = 1;1594 if (hw->phy.type == e1000_phy_gg82563)1595 e1e_wphy(hw, GG82563_PHY_KMRN_MODE_CTRL, 0x180);1596 e1e_rphy(hw, MII_BMCR, &phy_reg);1597 if (phy_reg & BMCR_LOOPBACK) {1598 phy_reg &= ~BMCR_LOOPBACK;1599 e1e_wphy(hw, MII_BMCR, phy_reg);1600 if (hw->phy.ops.commit)1601 hw->phy.ops.commit(hw);1602 }1603 break;1604 }1605}1606 1607static void e1000_create_lbtest_frame(struct sk_buff *skb,1608 unsigned int frame_size)1609{1610 memset(skb->data, 0xFF, frame_size);1611 frame_size &= ~1;1612 memset(&skb->data[frame_size / 2], 0xAA, frame_size / 2 - 1);1613 skb->data[frame_size / 2 + 10] = 0xBE;1614 skb->data[frame_size / 2 + 12] = 0xAF;1615}1616 1617static int e1000_check_lbtest_frame(struct sk_buff *skb,1618 unsigned int frame_size)1619{1620 frame_size &= ~1;1621 if (*(skb->data + 3) == 0xFF)1622 if ((*(skb->data + frame_size / 2 + 10) == 0xBE) &&1623 (*(skb->data + frame_size / 2 + 12) == 0xAF))1624 return 0;1625 return 13;1626}1627 1628static int e1000_run_loopback_test(struct e1000_adapter *adapter)1629{1630 struct e1000_ring *tx_ring = &adapter->test_tx_ring;1631 struct e1000_ring *rx_ring = &adapter->test_rx_ring;1632 struct pci_dev *pdev = adapter->pdev;1633 struct e1000_hw *hw = &adapter->hw;1634 struct e1000_buffer *buffer_info;1635 int i, j, k, l;1636 int lc;1637 int good_cnt;1638 int ret_val = 0;1639 unsigned long time;1640 1641 ew32(RDT(0), rx_ring->count - 1);1642 1643 /* Calculate the loop count based on the largest descriptor ring1644 * The idea is to wrap the largest ring a number of times using 641645 * send/receive pairs during each loop1646 */1647 1648 if (rx_ring->count <= tx_ring->count)1649 lc = ((tx_ring->count / 64) * 2) + 1;1650 else1651 lc = ((rx_ring->count / 64) * 2) + 1;1652 1653 k = 0;1654 l = 0;1655 /* loop count loop */1656 for (j = 0; j <= lc; j++) {1657 /* send the packets */1658 for (i = 0; i < 64; i++) {1659 buffer_info = &tx_ring->buffer_info[k];1660 1661 e1000_create_lbtest_frame(buffer_info->skb, 1024);1662 dma_sync_single_for_device(&pdev->dev,1663 buffer_info->dma,1664 buffer_info->length,1665 DMA_TO_DEVICE);1666 k++;1667 if (k == tx_ring->count)1668 k = 0;1669 }1670 ew32(TDT(0), k);1671 e1e_flush();1672 msleep(200);1673 time = jiffies; /* set the start time for the receive */1674 good_cnt = 0;1675 /* receive the sent packets */1676 do {1677 buffer_info = &rx_ring->buffer_info[l];1678 1679 dma_sync_single_for_cpu(&pdev->dev,1680 buffer_info->dma, 2048,1681 DMA_FROM_DEVICE);1682 1683 ret_val = e1000_check_lbtest_frame(buffer_info->skb,1684 1024);1685 if (!ret_val)1686 good_cnt++;1687 l++;1688 if (l == rx_ring->count)1689 l = 0;1690 /* time + 20 msecs (200 msecs on 2.4) is more than1691 * enough time to complete the receives, if it's1692 * exceeded, break and error off1693 */1694 } while ((good_cnt < 64) && !time_after(jiffies, time + 20));1695 if (good_cnt != 64) {1696 ret_val = 13; /* ret_val is the same as mis-compare */1697 break;1698 }1699 if (time_after(jiffies, time + 20)) {1700 ret_val = 14; /* error code for time out error */1701 break;1702 }1703 }1704 return ret_val;1705}1706 1707static int e1000_loopback_test(struct e1000_adapter *adapter, u64 *data)1708{1709 struct e1000_hw *hw = &adapter->hw;1710 1711 /* PHY loopback cannot be performed if SoL/IDER sessions are active */1712 if (hw->phy.ops.check_reset_block &&1713 hw->phy.ops.check_reset_block(hw)) {1714 e_err("Cannot do PHY loopback test when SoL/IDER is active.\n");1715 *data = 0;1716 goto out;1717 }1718 1719 *data = e1000_setup_desc_rings(adapter);1720 if (*data)1721 goto out;1722 1723 *data = e1000_setup_loopback_test(adapter);1724 if (*data)1725 goto err_loopback;1726 1727 *data = e1000_run_loopback_test(adapter);1728 e1000_loopback_cleanup(adapter);1729 1730err_loopback:1731 e1000_free_desc_rings(adapter);1732out:1733 return *data;1734}1735 1736static int e1000_link_test(struct e1000_adapter *adapter, u64 *data)1737{1738 struct e1000_hw *hw = &adapter->hw;1739 1740 *data = 0;1741 if (hw->phy.media_type == e1000_media_type_internal_serdes) {1742 int i = 0;1743 1744 hw->mac.serdes_has_link = false;1745 1746 /* On some blade server designs, link establishment1747 * could take as long as 2-3 minutes1748 */1749 do {1750 hw->mac.ops.check_for_link(hw);1751 if (hw->mac.serdes_has_link)1752 return *data;1753 msleep(20);1754 } while (i++ < 3750);1755 1756 *data = 1;1757 } else {1758 hw->mac.ops.check_for_link(hw);1759 if (hw->mac.autoneg)1760 /* On some Phy/switch combinations, link establishment1761 * can take a few seconds more than expected.1762 */1763 msleep_interruptible(5000);1764 1765 if (!(er32(STATUS) & E1000_STATUS_LU))1766 *data = 1;1767 }1768 return *data;1769}1770 1771static int e1000e_get_sset_count(struct net_device __always_unused *netdev,1772 int sset)1773{1774 switch (sset) {1775 case ETH_SS_TEST:1776 return E1000_TEST_LEN;1777 case ETH_SS_STATS:1778 return E1000_STATS_LEN;1779 case ETH_SS_PRIV_FLAGS:1780 return E1000E_PRIV_FLAGS_STR_LEN;1781 default:1782 return -EOPNOTSUPP;1783 }1784}1785 1786static void e1000_diag_test(struct net_device *netdev,1787 struct ethtool_test *eth_test, u64 *data)1788{1789 struct e1000_adapter *adapter = netdev_priv(netdev);1790 u16 autoneg_advertised;1791 u8 forced_speed_duplex;1792 u8 autoneg;1793 bool if_running = netif_running(netdev);1794 1795 set_bit(__E1000_TESTING, &adapter->state);1796 1797 if (!if_running) {1798 /* Get control of and reset hardware */1799 if (adapter->flags & FLAG_HAS_AMT)1800 e1000e_get_hw_control(adapter);1801 1802 e1000e_power_up_phy(adapter);1803 1804 adapter->hw.phy.autoneg_wait_to_complete = 1;1805 e1000e_reset(adapter);1806 adapter->hw.phy.autoneg_wait_to_complete = 0;1807 }1808 1809 if (eth_test->flags == ETH_TEST_FL_OFFLINE) {1810 /* Offline tests */1811 1812 /* save speed, duplex, autoneg settings */1813 autoneg_advertised = adapter->hw.phy.autoneg_advertised;1814 forced_speed_duplex = adapter->hw.mac.forced_speed_duplex;1815 autoneg = adapter->hw.mac.autoneg;1816 1817 e_info("offline testing starting\n");1818 1819 if (if_running)1820 /* indicate we're in test mode */1821 e1000e_close(netdev);1822 1823 if (e1000_reg_test(adapter, &data[0]))1824 eth_test->flags |= ETH_TEST_FL_FAILED;1825 1826 e1000e_reset(adapter);1827 if (e1000_eeprom_test(adapter, &data[1]))1828 eth_test->flags |= ETH_TEST_FL_FAILED;1829 1830 e1000e_reset(adapter);1831 if (e1000_intr_test(adapter, &data[2]))1832 eth_test->flags |= ETH_TEST_FL_FAILED;1833 1834 e1000e_reset(adapter);1835 if (e1000_loopback_test(adapter, &data[3]))1836 eth_test->flags |= ETH_TEST_FL_FAILED;1837 1838 /* force this routine to wait until autoneg complete/timeout */1839 adapter->hw.phy.autoneg_wait_to_complete = 1;1840 e1000e_reset(adapter);1841 adapter->hw.phy.autoneg_wait_to_complete = 0;1842 1843 if (e1000_link_test(adapter, &data[4]))1844 eth_test->flags |= ETH_TEST_FL_FAILED;1845 1846 /* restore speed, duplex, autoneg settings */1847 adapter->hw.phy.autoneg_advertised = autoneg_advertised;1848 adapter->hw.mac.forced_speed_duplex = forced_speed_duplex;1849 adapter->hw.mac.autoneg = autoneg;1850 e1000e_reset(adapter);1851 1852 clear_bit(__E1000_TESTING, &adapter->state);1853 if (if_running)1854 e1000e_open(netdev);1855 } else {1856 /* Online tests */1857 1858 e_info("online testing starting\n");1859 1860 /* register, eeprom, intr and loopback tests not run online */1861 data[0] = 0;1862 data[1] = 0;1863 data[2] = 0;1864 data[3] = 0;1865 1866 if (e1000_link_test(adapter, &data[4]))1867 eth_test->flags |= ETH_TEST_FL_FAILED;1868 1869 clear_bit(__E1000_TESTING, &adapter->state);1870 }1871 1872 if (!if_running) {1873 e1000e_reset(adapter);1874 1875 if (adapter->flags & FLAG_HAS_AMT)1876 e1000e_release_hw_control(adapter);1877 }1878 1879 msleep_interruptible(4 * 1000);1880}1881 1882static void e1000_get_wol(struct net_device *netdev,1883 struct ethtool_wolinfo *wol)1884{1885 struct e1000_adapter *adapter = netdev_priv(netdev);1886 1887 wol->supported = 0;1888 wol->wolopts = 0;1889 1890 if (!(adapter->flags & FLAG_HAS_WOL) ||1891 !device_can_wakeup(&adapter->pdev->dev))1892 return;1893 1894 wol->supported = WAKE_UCAST | WAKE_MCAST |1895 WAKE_BCAST | WAKE_MAGIC | WAKE_PHY;1896 1897 /* apply any specific unsupported masks here */1898 if (adapter->flags & FLAG_NO_WAKE_UCAST) {1899 wol->supported &= ~WAKE_UCAST;1900 1901 if (adapter->wol & E1000_WUFC_EX)1902 e_err("Interface does not support directed (unicast) frame wake-up packets\n");1903 }1904 1905 if (adapter->wol & E1000_WUFC_EX)1906 wol->wolopts |= WAKE_UCAST;1907 if (adapter->wol & E1000_WUFC_MC)1908 wol->wolopts |= WAKE_MCAST;1909 if (adapter->wol & E1000_WUFC_BC)1910 wol->wolopts |= WAKE_BCAST;1911 if (adapter->wol & E1000_WUFC_MAG)1912 wol->wolopts |= WAKE_MAGIC;1913 if (adapter->wol & E1000_WUFC_LNKC)1914 wol->wolopts |= WAKE_PHY;1915}1916 1917static int e1000_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)1918{1919 struct e1000_adapter *adapter = netdev_priv(netdev);1920 1921 if (!(adapter->flags & FLAG_HAS_WOL) ||1922 !device_can_wakeup(&adapter->pdev->dev) ||1923 (wol->wolopts & ~(WAKE_UCAST | WAKE_MCAST | WAKE_BCAST |1924 WAKE_MAGIC | WAKE_PHY)))1925 return -EOPNOTSUPP;1926 1927 /* these settings will always override what we currently have */1928 adapter->wol = 0;1929 1930 if (wol->wolopts & WAKE_UCAST)1931 adapter->wol |= E1000_WUFC_EX;1932 if (wol->wolopts & WAKE_MCAST)1933 adapter->wol |= E1000_WUFC_MC;1934 if (wol->wolopts & WAKE_BCAST)1935 adapter->wol |= E1000_WUFC_BC;1936 if (wol->wolopts & WAKE_MAGIC)1937 adapter->wol |= E1000_WUFC_MAG;1938 if (wol->wolopts & WAKE_PHY)1939 adapter->wol |= E1000_WUFC_LNKC;1940 1941 device_set_wakeup_enable(&adapter->pdev->dev, adapter->wol);1942 1943 return 0;1944}1945 1946static int e1000_set_phys_id(struct net_device *netdev,1947 enum ethtool_phys_id_state state)1948{1949 struct e1000_adapter *adapter = netdev_priv(netdev);1950 struct e1000_hw *hw = &adapter->hw;1951 1952 switch (state) {1953 case ETHTOOL_ID_ACTIVE:1954 pm_runtime_get_sync(netdev->dev.parent);1955 1956 if (!hw->mac.ops.blink_led)1957 return 2; /* cycle on/off twice per second */1958 1959 hw->mac.ops.blink_led(hw);1960 break;1961 1962 case ETHTOOL_ID_INACTIVE:1963 if (hw->phy.type == e1000_phy_ife)1964 e1e_wphy(hw, IFE_PHY_SPECIAL_CONTROL_LED, 0);1965 hw->mac.ops.led_off(hw);1966 hw->mac.ops.cleanup_led(hw);1967 pm_runtime_put_sync(netdev->dev.parent);1968 break;1969 1970 case ETHTOOL_ID_ON:1971 hw->mac.ops.led_on(hw);1972 break;1973 1974 case ETHTOOL_ID_OFF:1975 hw->mac.ops.led_off(hw);1976 break;1977 }1978 1979 return 0;1980}1981 1982static int e1000_get_coalesce(struct net_device *netdev,1983 struct ethtool_coalesce *ec,1984 struct kernel_ethtool_coalesce *kernel_coal,1985 struct netlink_ext_ack *extack)1986{1987 struct e1000_adapter *adapter = netdev_priv(netdev);1988 1989 if (adapter->itr_setting <= 4)1990 ec->rx_coalesce_usecs = adapter->itr_setting;1991 else1992 ec->rx_coalesce_usecs = 1000000 / adapter->itr_setting;1993 1994 return 0;1995}1996 1997static int e1000_set_coalesce(struct net_device *netdev,1998 struct ethtool_coalesce *ec,1999 struct kernel_ethtool_coalesce *kernel_coal,2000 struct netlink_ext_ack *extack)2001{2002 struct e1000_adapter *adapter = netdev_priv(netdev);2003 2004 if ((ec->rx_coalesce_usecs > E1000_MAX_ITR_USECS) ||2005 ((ec->rx_coalesce_usecs > 4) &&2006 (ec->rx_coalesce_usecs < E1000_MIN_ITR_USECS)) ||2007 (ec->rx_coalesce_usecs == 2))2008 return -EINVAL;2009 2010 if (ec->rx_coalesce_usecs == 4) {2011 adapter->itr_setting = 4;2012 adapter->itr = adapter->itr_setting;2013 } else if (ec->rx_coalesce_usecs <= 3) {2014 adapter->itr = 20000;2015 adapter->itr_setting = ec->rx_coalesce_usecs;2016 } else {2017 adapter->itr = (1000000 / ec->rx_coalesce_usecs);2018 adapter->itr_setting = adapter->itr & ~3;2019 }2020 2021 if (adapter->itr_setting != 0)2022 e1000e_write_itr(adapter, adapter->itr);2023 else2024 e1000e_write_itr(adapter, 0);2025 2026 return 0;2027}2028 2029static int e1000_nway_reset(struct net_device *netdev)2030{2031 struct e1000_adapter *adapter = netdev_priv(netdev);2032 2033 if (!netif_running(netdev))2034 return -EAGAIN;2035 2036 if (!adapter->hw.mac.autoneg)2037 return -EINVAL;2038 2039 e1000e_reinit_locked(adapter);2040 2041 return 0;2042}2043 2044static void e1000_get_ethtool_stats(struct net_device *netdev,2045 struct ethtool_stats __always_unused *stats,2046 u64 *data)2047{2048 struct e1000_adapter *adapter = netdev_priv(netdev);2049 struct rtnl_link_stats64 net_stats;2050 int i;2051 char *p = NULL;2052 2053 dev_get_stats(netdev, &net_stats);2054 2055 for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {2056 switch (e1000_gstrings_stats[i].type) {2057 case NETDEV_STATS:2058 p = (char *)&net_stats +2059 e1000_gstrings_stats[i].stat_offset;2060 break;2061 case E1000_STATS:2062 p = (char *)adapter +2063 e1000_gstrings_stats[i].stat_offset;2064 break;2065 default:2066 data[i] = 0;2067 continue;2068 }2069 2070 data[i] = (e1000_gstrings_stats[i].sizeof_stat ==2071 sizeof(u64)) ? *(u64 *)p : *(u32 *)p;2072 }2073}2074 2075static void e1000_get_strings(struct net_device __always_unused *netdev,2076 u32 stringset, u8 *data)2077{2078 u8 *p = data;2079 int i;2080 2081 switch (stringset) {2082 case ETH_SS_TEST:2083 memcpy(data, e1000_gstrings_test, sizeof(e1000_gstrings_test));2084 break;2085 case ETH_SS_STATS:2086 for (i = 0; i < E1000_GLOBAL_STATS_LEN; i++) {2087 memcpy(p, e1000_gstrings_stats[i].stat_string,2088 ETH_GSTRING_LEN);2089 p += ETH_GSTRING_LEN;2090 }2091 break;2092 case ETH_SS_PRIV_FLAGS:2093 memcpy(data, e1000e_priv_flags_strings,2094 E1000E_PRIV_FLAGS_STR_LEN * ETH_GSTRING_LEN);2095 break;2096 }2097}2098 2099static int e1000_get_rxnfc(struct net_device *netdev,2100 struct ethtool_rxnfc *info,2101 u32 __always_unused *rule_locs)2102{2103 info->data = 0;2104 2105 switch (info->cmd) {2106 case ETHTOOL_GRXFH: {2107 struct e1000_adapter *adapter = netdev_priv(netdev);2108 struct e1000_hw *hw = &adapter->hw;2109 u32 mrqc;2110 2111 mrqc = er32(MRQC);2112 2113 if (!(mrqc & E1000_MRQC_RSS_FIELD_MASK))2114 return 0;2115 2116 switch (info->flow_type) {2117 case TCP_V4_FLOW:2118 if (mrqc & E1000_MRQC_RSS_FIELD_IPV4_TCP)2119 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;2120 fallthrough;2121 case UDP_V4_FLOW:2122 case SCTP_V4_FLOW:2123 case AH_ESP_V4_FLOW:2124 case IPV4_FLOW:2125 if (mrqc & E1000_MRQC_RSS_FIELD_IPV4)2126 info->data |= RXH_IP_SRC | RXH_IP_DST;2127 break;2128 case TCP_V6_FLOW:2129 if (mrqc & E1000_MRQC_RSS_FIELD_IPV6_TCP)2130 info->data |= RXH_L4_B_0_1 | RXH_L4_B_2_3;2131 fallthrough;2132 case UDP_V6_FLOW:2133 case SCTP_V6_FLOW:2134 case AH_ESP_V6_FLOW:2135 case IPV6_FLOW:2136 if (mrqc & E1000_MRQC_RSS_FIELD_IPV6)2137 info->data |= RXH_IP_SRC | RXH_IP_DST;2138 break;2139 default:2140 break;2141 }2142 return 0;2143 }2144 default:2145 return -EOPNOTSUPP;2146 }2147}2148 2149static int e1000e_get_eee(struct net_device *netdev, struct ethtool_keee *edata)2150{2151 struct e1000_adapter *adapter = netdev_priv(netdev);2152 struct e1000_hw *hw = &adapter->hw;2153 u16 cap_addr, lpa_addr, pcs_stat_addr, phy_data;2154 u32 ret_val;2155 2156 if (!(adapter->flags2 & FLAG2_HAS_EEE))2157 return -EOPNOTSUPP;2158 2159 switch (hw->phy.type) {2160 case e1000_phy_82579:2161 cap_addr = I82579_EEE_CAPABILITY;2162 lpa_addr = I82579_EEE_LP_ABILITY;2163 pcs_stat_addr = I82579_EEE_PCS_STATUS;2164 break;2165 case e1000_phy_i217:2166 cap_addr = I217_EEE_CAPABILITY;2167 lpa_addr = I217_EEE_LP_ABILITY;2168 pcs_stat_addr = I217_EEE_PCS_STATUS;2169 break;2170 default:2171 return -EOPNOTSUPP;2172 }2173 2174 ret_val = hw->phy.ops.acquire(hw);2175 if (ret_val)2176 return -EBUSY;2177 2178 /* EEE Capability */2179 ret_val = e1000_read_emi_reg_locked(hw, cap_addr, &phy_data);2180 if (ret_val)2181 goto release;2182 mii_eee_cap1_mod_linkmode_t(edata->supported, phy_data);2183 2184 /* EEE Advertised */2185 mii_eee_cap1_mod_linkmode_t(edata->advertised, adapter->eee_advert);2186 2187 /* EEE Link Partner Advertised */2188 ret_val = e1000_read_emi_reg_locked(hw, lpa_addr, &phy_data);2189 if (ret_val)2190 goto release;2191 mii_eee_cap1_mod_linkmode_t(edata->lp_advertised, phy_data);2192 2193 /* EEE PCS Status */2194 ret_val = e1000_read_emi_reg_locked(hw, pcs_stat_addr, &phy_data);2195 if (ret_val)2196 goto release;2197 if (hw->phy.type == e1000_phy_82579)2198 phy_data <<= 8;2199 2200 /* Result of the EEE auto negotiation - there is no register that2201 * has the status of the EEE negotiation so do a best-guess based2202 * on whether Tx or Rx LPI indications have been received.2203 */2204 if (phy_data & (E1000_EEE_TX_LPI_RCVD | E1000_EEE_RX_LPI_RCVD))2205 edata->eee_active = true;2206 2207 edata->eee_enabled = !hw->dev_spec.ich8lan.eee_disable;2208 edata->tx_lpi_enabled = true;2209 edata->tx_lpi_timer = er32(LPIC) >> E1000_LPIC_LPIET_SHIFT;2210 2211release:2212 hw->phy.ops.release(hw);2213 if (ret_val)2214 ret_val = -ENODATA;2215 2216 return ret_val;2217}2218 2219static int e1000e_set_eee(struct net_device *netdev, struct ethtool_keee *edata)2220{2221 struct e1000_adapter *adapter = netdev_priv(netdev);2222 __ETHTOOL_DECLARE_LINK_MODE_MASK(supported) = {};2223 __ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = {};2224 struct e1000_hw *hw = &adapter->hw;2225 struct ethtool_keee eee_curr;2226 s32 ret_val;2227 2228 ret_val = e1000e_get_eee(netdev, &eee_curr);2229 if (ret_val)2230 return ret_val;2231 2232 if (eee_curr.tx_lpi_enabled != edata->tx_lpi_enabled) {2233 e_err("Setting EEE tx-lpi is not supported\n");2234 return -EINVAL;2235 }2236 2237 if (eee_curr.tx_lpi_timer != edata->tx_lpi_timer) {2238 e_err("Setting EEE Tx LPI timer is not supported\n");2239 return -EINVAL;2240 }2241 2242 linkmode_set_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,2243 supported);2244 linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,2245 supported);2246 2247 if (linkmode_andnot(tmp, edata->advertised, supported)) {2248 e_err("EEE advertisement supports only 100TX and/or 1000T full-duplex\n");2249 return -EINVAL;2250 }2251 2252 adapter->eee_advert = linkmode_to_mii_eee_cap1_t(edata->advertised);2253 2254 hw->dev_spec.ich8lan.eee_disable = !edata->eee_enabled;2255 2256 /* reset the link */2257 if (netif_running(netdev))2258 e1000e_reinit_locked(adapter);2259 else2260 e1000e_reset(adapter);2261 2262 return 0;2263}2264 2265static int e1000e_get_ts_info(struct net_device *netdev,2266 struct kernel_ethtool_ts_info *info)2267{2268 struct e1000_adapter *adapter = netdev_priv(netdev);2269 2270 ethtool_op_get_ts_info(netdev, info);2271 2272 if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))2273 return 0;2274 2275 info->so_timestamping |= (SOF_TIMESTAMPING_TX_HARDWARE |2276 SOF_TIMESTAMPING_RX_HARDWARE |2277 SOF_TIMESTAMPING_RAW_HARDWARE);2278 2279 info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON);2280 2281 info->rx_filters = (BIT(HWTSTAMP_FILTER_NONE) |2282 BIT(HWTSTAMP_FILTER_PTP_V1_L4_SYNC) |2283 BIT(HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ) |2284 BIT(HWTSTAMP_FILTER_PTP_V2_L4_SYNC) |2285 BIT(HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ) |2286 BIT(HWTSTAMP_FILTER_PTP_V2_L2_SYNC) |2287 BIT(HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ) |2288 BIT(HWTSTAMP_FILTER_PTP_V2_EVENT) |2289 BIT(HWTSTAMP_FILTER_PTP_V2_SYNC) |2290 BIT(HWTSTAMP_FILTER_PTP_V2_DELAY_REQ) |2291 BIT(HWTSTAMP_FILTER_ALL));2292 2293 if (adapter->ptp_clock)2294 info->phc_index = ptp_clock_index(adapter->ptp_clock);2295 2296 return 0;2297}2298 2299static u32 e1000e_get_priv_flags(struct net_device *netdev)2300{2301 struct e1000_adapter *adapter = netdev_priv(netdev);2302 u32 priv_flags = 0;2303 2304 if (adapter->flags2 & FLAG2_ENABLE_S0IX_FLOWS)2305 priv_flags |= E1000E_PRIV_FLAGS_S0IX_ENABLED;2306 2307 return priv_flags;2308}2309 2310static int e1000e_set_priv_flags(struct net_device *netdev, u32 priv_flags)2311{2312 struct e1000_adapter *adapter = netdev_priv(netdev);2313 unsigned int flags2 = adapter->flags2;2314 2315 flags2 &= ~FLAG2_ENABLE_S0IX_FLOWS;2316 if (priv_flags & E1000E_PRIV_FLAGS_S0IX_ENABLED) {2317 struct e1000_hw *hw = &adapter->hw;2318 2319 if (hw->mac.type < e1000_pch_cnp)2320 return -EINVAL;2321 flags2 |= FLAG2_ENABLE_S0IX_FLOWS;2322 }2323 2324 if (flags2 != adapter->flags2)2325 adapter->flags2 = flags2;2326 2327 return 0;2328}2329 2330static const struct ethtool_ops e1000_ethtool_ops = {2331 .supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,2332 .get_drvinfo = e1000_get_drvinfo,2333 .get_regs_len = e1000_get_regs_len,2334 .get_regs = e1000_get_regs,2335 .get_wol = e1000_get_wol,2336 .set_wol = e1000_set_wol,2337 .get_msglevel = e1000_get_msglevel,2338 .set_msglevel = e1000_set_msglevel,2339 .nway_reset = e1000_nway_reset,2340 .get_link = ethtool_op_get_link,2341 .get_eeprom_len = e1000_get_eeprom_len,2342 .get_eeprom = e1000_get_eeprom,2343 .set_eeprom = e1000_set_eeprom,2344 .get_ringparam = e1000_get_ringparam,2345 .set_ringparam = e1000_set_ringparam,2346 .get_pauseparam = e1000_get_pauseparam,2347 .set_pauseparam = e1000_set_pauseparam,2348 .self_test = e1000_diag_test,2349 .get_strings = e1000_get_strings,2350 .set_phys_id = e1000_set_phys_id,2351 .get_ethtool_stats = e1000_get_ethtool_stats,2352 .get_sset_count = e1000e_get_sset_count,2353 .get_coalesce = e1000_get_coalesce,2354 .set_coalesce = e1000_set_coalesce,2355 .get_rxnfc = e1000_get_rxnfc,2356 .get_ts_info = e1000e_get_ts_info,2357 .get_eee = e1000e_get_eee,2358 .set_eee = e1000e_set_eee,2359 .get_link_ksettings = e1000_get_link_ksettings,2360 .set_link_ksettings = e1000_set_link_ksettings,2361 .get_priv_flags = e1000e_get_priv_flags,2362 .set_priv_flags = e1000e_set_priv_flags,2363};2364 2365void e1000e_set_ethtool_ops(struct net_device *netdev)2366{2367 netdev->ethtool_ops = &e1000_ethtool_ops;2368}2369