struct phy_device *phydev)
 {
        struct b53_device *dev = ds->priv;
-       struct ethtool_eee *p = &dev->ports[port].eee;
+       struct ethtool_keee *p = &dev->ports[port].eee;
        u8 rgmii_ctrl = 0, reg = 0, off;
        bool tx_pause = false;
        bool rx_pause = false;
 }
 EXPORT_SYMBOL(b53_eee_init);
 
-int b53_get_mac_eee(struct dsa_switch *ds, int port, struct ethtool_eee *e)
+int b53_get_mac_eee(struct dsa_switch *ds, int port, struct ethtool_keee *e)
 {
        struct b53_device *dev = ds->priv;
-       struct ethtool_eee *p = &dev->ports[port].eee;
+       struct ethtool_keee *p = &dev->ports[port].eee;
        u16 reg;
 
        if (is5325(dev) || is5365(dev))
 }
 EXPORT_SYMBOL(b53_get_mac_eee);
 
-int b53_set_mac_eee(struct dsa_switch *ds, int port, struct ethtool_eee *e)
+int b53_set_mac_eee(struct dsa_switch *ds, int port, struct ethtool_keee *e)
 {
        struct b53_device *dev = ds->priv;
-       struct ethtool_eee *p = &dev->ports[port].eee;
+       struct ethtool_keee *p = &dev->ports[port].eee;
 
        if (is5325(dev) || is5365(dev))
                return -EOPNOTSUPP;
 
 
 struct b53_port {
        u16             vlan_ctl_mask;
-       struct ethtool_eee eee;
+       struct ethtool_keee eee;
 };
 
 struct b53_vlan {
 void b53_brcm_hdr_setup(struct dsa_switch *ds, int port);
 void b53_eee_enable_set(struct dsa_switch *ds, int port, bool enable);
 int b53_eee_init(struct dsa_switch *ds, int port, struct phy_device *phy);
-int b53_get_mac_eee(struct dsa_switch *ds, int port, struct ethtool_eee *e);
-int b53_set_mac_eee(struct dsa_switch *ds, int port, struct ethtool_eee *e);
+int b53_get_mac_eee(struct dsa_switch *ds, int port, struct ethtool_keee *e);
+int b53_set_mac_eee(struct dsa_switch *ds, int port, struct ethtool_keee *e);
 
 #endif
 
                                   bool tx_pause, bool rx_pause)
 {
        struct bcm_sf2_priv *priv = bcm_sf2_to_priv(ds);
-       struct ethtool_eee *p = &priv->dev->ports[port].eee;
+       struct ethtool_keee *p = &priv->dev->ports[port].eee;
        u32 reg_rgmii_ctrl = 0;
        u32 reg, offset;
 
 
 }
 
 static int ksz_get_mac_eee(struct dsa_switch *ds, int port,
-                          struct ethtool_eee *e)
+                          struct ethtool_keee *e)
 {
        int ret;
 
 }
 
 static int ksz_set_mac_eee(struct dsa_switch *ds, int port,
-                          struct ethtool_eee *e)
+                          struct ethtool_keee *e)
 {
        struct ksz_device *dev = ds->priv;
        int ret;
 
 }
 
 static int mt753x_get_mac_eee(struct dsa_switch *ds, int port,
-                             struct ethtool_eee *e)
+                             struct ethtool_keee *e)
 {
        struct mt7530_priv *priv = ds->priv;
        u32 eeecr = mt7530_read(priv, MT7530_PMEEECR_P(port));
 }
 
 static int mt753x_set_mac_eee(struct dsa_switch *ds, int port,
-                             struct ethtool_eee *e)
+                             struct ethtool_keee *e)
 {
        struct mt7530_priv *priv = ds->priv;
        u32 set, mask = LPI_THRESH_MASK | LPI_MODE_EN;
 
 }
 
 static int mv88e6xxx_get_mac_eee(struct dsa_switch *ds, int port,
-                                struct ethtool_eee *e)
+                                struct ethtool_keee *e)
 {
        /* Nothing to do on the port's MAC */
        return 0;
 }
 
 static int mv88e6xxx_set_mac_eee(struct dsa_switch *ds, int port,
-                                struct ethtool_eee *e)
+                                struct ethtool_keee *e)
 {
        /* Nothing to do on the port's MAC */
        return 0;
 
 }
 
 int qca8k_set_mac_eee(struct dsa_switch *ds, int port,
-                     struct ethtool_eee *eee)
+                     struct ethtool_keee *eee)
 {
        u32 lpi_en = QCA8K_REG_EEE_CTRL_LPI_EN(port);
        struct qca8k_priv *priv = ds->priv;
 }
 
 int qca8k_get_mac_eee(struct dsa_switch *ds, int port,
-                     struct ethtool_eee *e)
+                     struct ethtool_keee *e)
 {
        /* Nothing to do on the port's MAC */
        return 0;
 
 int qca8k_get_sset_count(struct dsa_switch *ds, int port, int sset);
 
 /* Common eee function */
-int qca8k_set_mac_eee(struct dsa_switch *ds, int port, struct ethtool_eee *eee);
-int qca8k_get_mac_eee(struct dsa_switch *ds, int port, struct ethtool_eee *e);
+int qca8k_set_mac_eee(struct dsa_switch *ds, int port, struct ethtool_keee *eee);
+int qca8k_get_mac_eee(struct dsa_switch *ds, int port, struct ethtool_keee *e);
 
 /* Common bridge function */
 void qca8k_port_stp_state_set(struct dsa_switch *ds, int port, u8 state);
 
        return rate;
 }
 
-static int aq_ethtool_get_eee(struct net_device *ndev, struct ethtool_eee *eee)
+static int aq_ethtool_get_eee(struct net_device *ndev, struct ethtool_keee *eee)
 {
        struct aq_nic_s *aq_nic = netdev_priv(ndev);
        u32 rate, supported_rates;
        return 0;
 }
 
-static int aq_ethtool_set_eee(struct net_device *ndev, struct ethtool_eee *eee)
+static int aq_ethtool_set_eee(struct net_device *ndev, struct ethtool_keee *eee)
 {
        struct aq_nic_s *aq_nic = netdev_priv(ndev);
        u32 rate, supported_rates;
 
        int                             wol_irq;
        unsigned int                    wol_irq_enabled:1;
 
-       struct ethtool_eee              eee;
+       struct ethtool_keee             eee;
 };
 
 #define NUM_NET_FILTERS                                32
 
        intf->eee.eee_active = enable;
 }
 
-static int bcmasp_get_eee(struct net_device *dev, struct ethtool_eee *e)
+static int bcmasp_get_eee(struct net_device *dev, struct ethtool_keee *e)
 {
        struct bcmasp_intf *intf = netdev_priv(dev);
-       struct ethtool_eee *p = &intf->eee;
+       struct ethtool_keee *p = &intf->eee;
 
        if (!dev->phydev)
                return -ENODEV;
        return phy_ethtool_get_eee(dev->phydev, e);
 }
 
-static int bcmasp_set_eee(struct net_device *dev, struct ethtool_eee *e)
+static int bcmasp_set_eee(struct net_device *dev, struct ethtool_keee *e)
 {
        struct bcmasp_intf *intf = netdev_priv(dev);
-       struct ethtool_eee *p = &intf->eee;
+       struct ethtool_keee *p = &intf->eee;
        int ret;
 
        if (!dev->phydev)
 
        return eee_adv << shift;
 }
 
-static int bnx2x_get_eee(struct net_device *dev, struct ethtool_eee *edata)
+static int bnx2x_get_eee(struct net_device *dev, struct ethtool_keee *edata)
 {
        struct bnx2x *bp = netdev_priv(dev);
        u32 eee_cfg;
        return 0;
 }
 
-static int bnx2x_set_eee(struct net_device *dev, struct ethtool_eee *edata)
+static int bnx2x_set_eee(struct net_device *dev, struct ethtool_keee *edata)
 {
        struct bnx2x *bp = netdev_priv(dev);
        u32 eee_cfg;
 
 
        bp->phy_flags = resp->flags | (le16_to_cpu(resp->flags2) << 8);
        if (resp->flags & PORT_PHY_QCAPS_RESP_FLAGS_EEE_SUPPORTED) {
-               struct ethtool_eee *eee = &bp->eee;
+               struct ethtool_keee *eee = &bp->eee;
                u16 fw_speeds = le16_to_cpu(resp->supported_speeds_eee_mode);
 
                eee->supported = _bnxt_fw_to_ethtool_adv_spds(fw_speeds, 0);
        link_info->module_status = resp->module_status;
 
        if (bp->phy_flags & BNXT_PHY_FL_EEE_CAP) {
-               struct ethtool_eee *eee = &bp->eee;
+               struct ethtool_keee *eee = &bp->eee;
                u16 fw_speeds;
 
                eee->eee_active = 0;
 static void bnxt_hwrm_set_eee(struct bnxt *bp,
                              struct hwrm_port_phy_cfg_input *req)
 {
-       struct ethtool_eee *eee = &bp->eee;
+       struct ethtool_keee *eee = &bp->eee;
 
        if (eee->eee_enabled) {
                u16 eee_speeds;
 
 static bool bnxt_eee_config_ok(struct bnxt *bp)
 {
-       struct ethtool_eee *eee = &bp->eee;
+       struct ethtool_keee *eee = &bp->eee;
        struct bnxt_link_info *link_info = &bp->link_info;
 
        if (!(bp->phy_flags & BNXT_PHY_FL_EEE_CAP))
 
         */
        struct mutex            link_lock;
        struct bnxt_link_info   link_info;
-       struct ethtool_eee      eee;
+       struct ethtool_keee     eee;
        u32                     lpi_tmr_lo;
        u32                     lpi_tmr_hi;
 
 
                                eeprom->len);
 }
 
-static int bnxt_set_eee(struct net_device *dev, struct ethtool_eee *edata)
+static int bnxt_set_eee(struct net_device *dev, struct ethtool_keee *edata)
 {
        struct bnxt *bp = netdev_priv(dev);
-       struct ethtool_eee *eee = &bp->eee;
+       struct ethtool_keee *eee = &bp->eee;
        struct bnxt_link_info *link_info = &bp->link_info;
        u32 advertising;
        int rc = 0;
        return rc;
 }
 
-static int bnxt_get_eee(struct net_device *dev, struct ethtool_eee *edata)
+static int bnxt_get_eee(struct net_device *dev, struct ethtool_keee *edata)
 {
        struct bnxt *bp = netdev_priv(dev);
 
 
        priv->eee.tx_lpi_enabled = tx_lpi_enabled;
 }
 
-static int bcmgenet_get_eee(struct net_device *dev, struct ethtool_eee *e)
+static int bcmgenet_get_eee(struct net_device *dev, struct ethtool_keee *e)
 {
        struct bcmgenet_priv *priv = netdev_priv(dev);
-       struct ethtool_eee *p = &priv->eee;
+       struct ethtool_keee *p = &priv->eee;
 
        if (GENET_IS_V1(priv))
                return -EOPNOTSUPP;
        return phy_ethtool_get_eee(dev->phydev, e);
 }
 
-static int bcmgenet_set_eee(struct net_device *dev, struct ethtool_eee *e)
+static int bcmgenet_set_eee(struct net_device *dev, struct ethtool_keee *e)
 {
        struct bcmgenet_priv *priv = netdev_priv(dev);
-       struct ethtool_eee *p = &priv->eee;
+       struct ethtool_keee *p = &priv->eee;
 
        if (GENET_IS_V1(priv))
                return -EOPNOTSUPP;
 
 
        struct bcmgenet_mib_counters mib;
 
-       struct ethtool_eee eee;
+       struct ethtool_keee eee;
 };
 
 #define GENET_IO_MACRO(name, offset)                                   \
 
        tg3_phy_toggle_auxctl_smdsp(tp, false);
 }
 
-static void tg3_eee_pull_config(struct tg3 *tp, struct ethtool_eee *eee)
+static void tg3_eee_pull_config(struct tg3 *tp, struct ethtool_keee *eee)
 {
        u32 val;
-       struct ethtool_eee *dest = &tp->eee;
+       struct ethtool_keee *dest = &tp->eee;
 
        if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP))
                return;
 
 static bool tg3_phy_eee_config_ok(struct tg3 *tp)
 {
-       struct ethtool_eee eee;
+       struct ethtool_keee eee;
 
        if (!(tp->phy_flags & TG3_PHYFLG_EEE_CAP))
                return true;
        return 0;
 }
 
-static int tg3_set_eee(struct net_device *dev, struct ethtool_eee *edata)
+static int tg3_set_eee(struct net_device *dev, struct ethtool_keee *edata)
 {
        struct tg3 *tp = netdev_priv(dev);
 
        return 0;
 }
 
-static int tg3_get_eee(struct net_device *dev, struct ethtool_eee *edata)
+static int tg3_get_eee(struct net_device *dev, struct ethtool_keee *edata)
 {
        struct tg3 *tp = netdev_priv(dev);
 
 
        unsigned int                    irq_cnt;
 
        struct ethtool_coalesce         coal;
-       struct ethtool_eee              eee;
+       struct ethtool_keee             eee;
 
        /* firmware info */
        const char                      *fw_needed;
 
 static int tsnep_phy_open(struct tsnep_adapter *adapter)
 {
        struct phy_device *phydev;
-       struct ethtool_eee ethtool_eee;
+       struct ethtool_keee ethtool_keee;
        int retval;
 
        retval = phy_connect_direct(adapter->netdev, adapter->phydev,
        phy_remove_link_mode(phydev, ETHTOOL_LINK_MODE_1000baseT_Half_BIT);
 
        /* disable EEE autoneg, EEE not supported by TSNEP */
-       memset(ðtool_eee, 0, sizeof(ethtool_eee));
-       phy_ethtool_set_eee(adapter->phydev, ðtool_eee);
+       memset(ðtool_keee, 0, sizeof(ethtool_keee));
+       phy_ethtool_set_eee(adapter->phydev, ðtool_keee);
 
        adapter->phydev->irq = PHY_MAC_INTERRUPT;
        phy_start(adapter->phydev);
 
 static int enetc_phylink_connect(struct net_device *ndev)
 {
        struct enetc_ndev_priv *priv = netdev_priv(ndev);
-       struct ethtool_eee edata;
+       struct ethtool_keee edata;
        int err;
 
        if (!priv->phylink) {
        }
 
        /* disable EEE autoneg, until ENETC driver supports it */
-       memset(&edata, 0, sizeof(struct ethtool_eee));
+       memset(&edata, 0, sizeof(struct ethtool_keee));
        phylink_ethtool_set_eee(priv->phylink, &edata);
 
        phylink_start(priv->phylink);
 
        unsigned int itr_clk_rate;
 
        /* tx lpi eee mode */
-       struct ethtool_eee eee;
+       struct ethtool_keee eee;
        unsigned int clk_ref_rate;
 
        /* ptp clock period in ns*/
 
 static int fec_enet_eee_mode_set(struct net_device *ndev, bool enable)
 {
        struct fec_enet_private *fep = netdev_priv(ndev);
-       struct ethtool_eee *p = &fep->eee;
+       struct ethtool_keee *p = &fep->eee;
        unsigned int sleep_cycle, wake_cycle;
        int ret = 0;
 
 }
 
 static int
-fec_enet_get_eee(struct net_device *ndev, struct ethtool_eee *edata)
+fec_enet_get_eee(struct net_device *ndev, struct ethtool_keee *edata)
 {
        struct fec_enet_private *fep = netdev_priv(ndev);
-       struct ethtool_eee *p = &fep->eee;
+       struct ethtool_keee *p = &fep->eee;
 
        if (!(fep->quirks & FEC_QUIRK_HAS_EEE))
                return -EOPNOTSUPP;
 }
 
 static int
-fec_enet_set_eee(struct net_device *ndev, struct ethtool_eee *edata)
+fec_enet_set_eee(struct net_device *ndev, struct ethtool_keee *edata)
 {
        struct fec_enet_private *fep = netdev_priv(ndev);
-       struct ethtool_eee *p = &fep->eee;
+       struct ethtool_keee *p = &fep->eee;
        int ret = 0;
 
        if (!(fep->quirks & FEC_QUIRK_HAS_EEE))
 
        struct gfar_private *priv = netdev_priv(dev);
        phy_interface_t interface = priv->interface;
        struct phy_device *phydev;
-       struct ethtool_eee edata;
+       struct ethtool_keee edata;
 
        linkmode_set_bit_array(phy_10_100_features_array,
                               ARRAY_SIZE(phy_10_100_features_array),
        phy_support_asym_pause(phydev);
 
        /* disable EEE autoneg, EEE not supported by eTSEC */
-       memset(&edata, 0, sizeof(struct ethtool_eee));
+       memset(&edata, 0, sizeof(struct ethtool_keee));
        phy_ethtool_set_eee(phydev, &edata);
 
        return 0;
 
        }
 }
 
-static int e1000e_get_eee(struct net_device *netdev, struct ethtool_eee *edata)
+static int e1000e_get_eee(struct net_device *netdev, struct ethtool_keee *edata)
 {
        struct e1000_adapter *adapter = netdev_priv(netdev);
        struct e1000_hw *hw = &adapter->hw;
        return ret_val;
 }
 
-static int e1000e_set_eee(struct net_device *netdev, struct ethtool_eee *edata)
+static int e1000e_set_eee(struct net_device *netdev, struct ethtool_keee *edata)
 {
        struct e1000_adapter *adapter = netdev_priv(netdev);
        struct e1000_hw *hw = &adapter->hw;
-       struct ethtool_eee eee_curr;
+       struct ethtool_keee eee_curr;
        s32 ret_val;
 
        ret_val = e1000e_get_eee(netdev, &eee_curr);
 
        return 0;
 }
 
-static int i40e_get_eee(struct net_device *netdev, struct ethtool_eee *edata)
+static int i40e_get_eee(struct net_device *netdev, struct ethtool_keee *edata)
 {
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_aq_get_phy_abilities_resp phy_cfg;
 }
 
 static int i40e_is_eee_param_supported(struct net_device *netdev,
-                                      struct ethtool_eee *edata)
+                                      struct ethtool_keee *edata)
 {
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_vsi *vsi = np->vsi;
        return 0;
 }
 
-static int i40e_set_eee(struct net_device *netdev, struct ethtool_eee *edata)
+static int i40e_set_eee(struct net_device *netdev, struct ethtool_keee *edata)
 {
        struct i40e_netdev_priv *np = netdev_priv(netdev);
        struct i40e_aq_get_phy_abilities_resp abilities;
 
        return ret;
 }
 
-static int igb_get_eee(struct net_device *netdev, struct ethtool_eee *edata)
+static int igb_get_eee(struct net_device *netdev, struct ethtool_keee *edata)
 {
        struct igb_adapter *adapter = netdev_priv(netdev);
        struct e1000_hw *hw = &adapter->hw;
 }
 
 static int igb_set_eee(struct net_device *netdev,
-                      struct ethtool_eee *edata)
+                      struct ethtool_keee *edata)
 {
        struct igb_adapter *adapter = netdev_priv(netdev);
        struct e1000_hw *hw = &adapter->hw;
-       struct ethtool_eee eee_curr;
+       struct ethtool_keee eee_curr;
        bool adv1g_eee = true, adv100m_eee = true;
        s32 ret_val;
 
            (hw->phy.media_type != e1000_media_type_copper))
                return -EOPNOTSUPP;
 
-       memset(&eee_curr, 0, sizeof(struct ethtool_eee));
+       memset(&eee_curr, 0, sizeof(struct ethtool_keee));
 
        ret_val = igb_get_eee(netdev, &eee_curr);
        if (ret_val)
 
 struct igc_adapter {
        struct net_device *netdev;
 
-       struct ethtool_eee eee;
+       struct ethtool_keee eee;
        u16 eee_advert;
 
        unsigned long state;
 
 }
 
 static int igc_ethtool_get_eee(struct net_device *netdev,
-                              struct ethtool_eee *edata)
+                              struct ethtool_keee *edata)
 {
        struct igc_adapter *adapter = netdev_priv(netdev);
        struct igc_hw *hw = &adapter->hw;
 }
 
 static int igc_ethtool_set_eee(struct net_device *netdev,
-                              struct ethtool_eee *edata)
+                              struct ethtool_keee *edata)
 {
        struct igc_adapter *adapter = netdev_priv(netdev);
        struct igc_hw *hw = &adapter->hw;
-       struct ethtool_eee eee_curr;
+       struct ethtool_keee eee_curr;
        s32 ret_val;
 
-       memset(&eee_curr, 0, sizeof(struct ethtool_eee));
+       memset(&eee_curr, 0, sizeof(struct ethtool_keee));
 
        ret_val = igc_ethtool_get_eee(netdev, &eee_curr);
        if (ret_val) {
 
 };
 
 static int
-ixgbe_get_eee_fw(struct ixgbe_adapter *adapter, struct ethtool_eee *edata)
+ixgbe_get_eee_fw(struct ixgbe_adapter *adapter, struct ethtool_keee *edata)
 {
        u32 info[FW_PHY_ACT_DATA_COUNT] = { 0 };
        struct ixgbe_hw *hw = &adapter->hw;
        return 0;
 }
 
-static int ixgbe_get_eee(struct net_device *netdev, struct ethtool_eee *edata)
+static int ixgbe_get_eee(struct net_device *netdev, struct ethtool_keee *edata)
 {
        struct ixgbe_adapter *adapter = netdev_priv(netdev);
        struct ixgbe_hw *hw = &adapter->hw;
        return -EOPNOTSUPP;
 }
 
-static int ixgbe_set_eee(struct net_device *netdev, struct ethtool_eee *edata)
+static int ixgbe_set_eee(struct net_device *netdev, struct ethtool_keee *edata)
 {
        struct ixgbe_adapter *adapter = netdev_priv(netdev);
        struct ixgbe_hw *hw = &adapter->hw;
-       struct ethtool_eee eee_data;
+       struct ethtool_keee eee_data;
        s32 ret_val;
 
        if (!(adapter->flags2 & IXGBE_FLAG2_EEE_CAPABLE))
                return -EOPNOTSUPP;
 
-       memset(&eee_data, 0, sizeof(struct ethtool_eee));
+       memset(&eee_data, 0, sizeof(struct ethtool_keee));
 
        ret_val = ixgbe_get_eee(netdev, &eee_data);
        if (ret_val)
 
 }
 
 static int mvneta_ethtool_get_eee(struct net_device *dev,
-                                 struct ethtool_eee *eee)
+                                 struct ethtool_keee *eee)
 {
        struct mvneta_port *pp = netdev_priv(dev);
        u32 lpi_ctl0;
 }
 
 static int mvneta_ethtool_set_eee(struct net_device *dev,
-                                 struct ethtool_eee *eee)
+                                 struct ethtool_keee *eee)
 {
        struct mvneta_port *pp = netdev_priv(dev);
        u32 lpi_ctl0;
 
 }
 
 static int lan743x_ethtool_get_eee(struct net_device *netdev,
-                                  struct ethtool_eee *eee)
+                                  struct ethtool_keee *eee)
 {
        struct lan743x_adapter *adapter = netdev_priv(netdev);
        struct phy_device *phydev = netdev->phydev;
 }
 
 static int lan743x_ethtool_set_eee(struct net_device *netdev,
-                                  struct ethtool_eee *eee)
+                                  struct ethtool_keee *eee)
 {
        struct lan743x_adapter *adapter;
        struct phy_device *phydev;
 
        return 0;
 }
 
-static int qede_get_eee(struct net_device *dev, struct ethtool_eee *edata)
+static int qede_get_eee(struct net_device *dev, struct ethtool_keee *edata)
 {
        struct qede_dev *edev = netdev_priv(dev);
        struct qed_link_output current_link;
        return 0;
 }
 
-static int qede_set_eee(struct net_device *dev, struct ethtool_eee *edata)
+static int qede_set_eee(struct net_device *dev, struct ethtool_keee *edata)
 {
        struct qede_dev *edev = netdev_priv(dev);
        struct qed_link_output current_link;
 
        return 0;
 }
 
-static int rtl8169_get_eee(struct net_device *dev, struct ethtool_eee *data)
+static int rtl8169_get_eee(struct net_device *dev, struct ethtool_keee *data)
 {
        struct rtl8169_private *tp = netdev_priv(dev);
 
        return phy_ethtool_get_eee(tp->phydev, data);
 }
 
-static int rtl8169_set_eee(struct net_device *dev, struct ethtool_eee *data)
+static int rtl8169_set_eee(struct net_device *dev, struct ethtool_keee *data)
 {
        struct rtl8169_private *tp = netdev_priv(dev);
        int ret;
 
 #define SXGBE_STATS_LEN ARRAY_SIZE(sxgbe_gstrings_stats)
 
 static int sxgbe_get_eee(struct net_device *dev,
-                        struct ethtool_eee *edata)
+                        struct ethtool_keee *edata)
 {
        struct sxgbe_priv_data *priv = netdev_priv(dev);
 
 }
 
 static int sxgbe_set_eee(struct net_device *dev,
-                        struct ethtool_eee *edata)
+                        struct ethtool_keee *edata)
 {
        struct sxgbe_priv_data *priv = netdev_priv(dev);
 
 
 }
 
 static int stmmac_ethtool_op_get_eee(struct net_device *dev,
-                                    struct ethtool_eee *edata)
+                                    struct ethtool_keee *edata)
 {
        struct stmmac_priv *priv = netdev_priv(dev);
 
 }
 
 static int stmmac_ethtool_op_set_eee(struct net_device *dev,
-                                    struct ethtool_eee *edata)
+                                    struct ethtool_keee *edata)
 {
        struct stmmac_priv *priv = netdev_priv(dev);
        int ret;
 
        return phylink_ethtool_ksettings_set(salve->phylink, ecmd);
 }
 
-static int am65_cpsw_get_eee(struct net_device *ndev, struct ethtool_eee *edata)
+static int am65_cpsw_get_eee(struct net_device *ndev, struct ethtool_keee *edata)
 {
        struct am65_cpsw_slave_data *salve = am65_ndev_to_slave(ndev);
 
        return phylink_ethtool_get_eee(salve->phylink, edata);
 }
 
-static int am65_cpsw_set_eee(struct net_device *ndev, struct ethtool_eee *edata)
+static int am65_cpsw_set_eee(struct net_device *ndev, struct ethtool_keee *edata)
 {
        struct am65_cpsw_slave_data *salve = am65_ndev_to_slave(ndev);
 
 
        return phy_ethtool_ksettings_set(cpsw->slaves[slave_no].phy, ecmd);
 }
 
-int cpsw_get_eee(struct net_device *ndev, struct ethtool_eee *edata)
+int cpsw_get_eee(struct net_device *ndev, struct ethtool_keee *edata)
 {
        struct cpsw_priv *priv = netdev_priv(ndev);
        struct cpsw_common *cpsw = priv->cpsw;
                return -EOPNOTSUPP;
 }
 
-int cpsw_set_eee(struct net_device *ndev, struct ethtool_eee *edata)
+int cpsw_set_eee(struct net_device *ndev, struct ethtool_keee *edata)
 {
        struct cpsw_priv *priv = netdev_priv(ndev);
        struct cpsw_common *cpsw = priv->cpsw;
 
                            struct ethtool_link_ksettings *ecmd);
 int cpsw_set_link_ksettings(struct net_device *ndev,
                            const struct ethtool_link_ksettings *ecmd);
-int cpsw_get_eee(struct net_device *ndev, struct ethtool_eee *edata);
-int cpsw_set_eee(struct net_device *ndev, struct ethtool_eee *edata);
+int cpsw_get_eee(struct net_device *ndev, struct ethtool_keee *edata);
+int cpsw_set_eee(struct net_device *ndev, struct ethtool_keee *edata);
 int cpsw_nway_reset(struct net_device *ndev);
 void cpsw_get_ringparam(struct net_device *ndev,
                        struct ethtool_ringparam *ering,
 
        return phy_ethtool_set_link_ksettings(ndev, ecmd);
 }
 
-static int emac_get_eee(struct net_device *ndev, struct ethtool_eee *edata)
+static int emac_get_eee(struct net_device *ndev, struct ethtool_keee *edata)
 {
        if (!ndev->phydev)
                return -EOPNOTSUPP;
        return phy_ethtool_get_eee(ndev->phydev, edata);
 }
 
-static int emac_set_eee(struct net_device *ndev, struct ethtool_eee *edata)
+static int emac_set_eee(struct net_device *ndev, struct ethtool_keee *edata)
 {
        if (!ndev->phydev)
                return -EOPNOTSUPP;
 
 
 static int m88e1540_set_fld(struct phy_device *phydev, const u8 *msecs)
 {
-       struct ethtool_eee eee;
+       struct ethtool_keee eee;
        int val, ret;
 
        if (*msecs == ETHTOOL_PHY_FAST_LINK_DOWN_OFF)
 
 /**
  * genphy_c45_ethtool_get_eee - get EEE supported and status
  * @phydev: target phy_device struct
- * @data: ethtool_eee data
+ * @data: ethtool_keee data
  *
  * Description: it reports the Supported/Advertisement/LP Advertisement
  * capabilities.
  */
 int genphy_c45_ethtool_get_eee(struct phy_device *phydev,
-                              struct ethtool_eee *data)
+                              struct ethtool_keee *data)
 {
        __ETHTOOL_DECLARE_LINK_MODE_MASK(adv) = {};
        __ETHTOOL_DECLARE_LINK_MODE_MASK(lp) = {};
 /**
  * genphy_c45_ethtool_set_eee - set EEE supported and status
  * @phydev: target phy_device struct
- * @data: ethtool_eee data
+ * @data: ethtool_keee data
  *
  * Description: sets the Supported/Advertisement/LP Advertisement
  * capabilities. If eee_enabled is false, no links modes are
  * non-destructive way.
  */
 int genphy_c45_ethtool_set_eee(struct phy_device *phydev,
-                              struct ethtool_eee *data)
+                              struct ethtool_keee *data)
 {
        int ret;
 
 
 /**
  * phy_ethtool_get_eee - get EEE supported and status
  * @phydev: target phy_device struct
- * @data: ethtool_eee data
+ * @data: ethtool_keee data
  *
  * Description: it reportes the Supported/Advertisement/LP Advertisement
  * capabilities.
  */
-int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data)
+int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_keee *data)
 {
        int ret;
 
 /**
  * phy_ethtool_set_eee - set EEE supported and status
  * @phydev: target phy_device struct
- * @data: ethtool_eee data
+ * @data: ethtool_keee data
  *
  * Description: it is to program the Advertisement EEE register.
  */
-int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data)
+int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_keee *data)
 {
        int ret;
 
 
 /**
  * phylink_ethtool_get_eee() - read the energy efficient ethernet parameters
  * @pl: a pointer to a &struct phylink returned from phylink_create()
- * @eee: a pointer to a &struct ethtool_eee for the read parameters
+ * @eee: a pointer to a &struct ethtool_keee for the read parameters
  */
-int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_eee *eee)
+int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_keee *eee)
 {
        int ret = -EOPNOTSUPP;
 
 /**
  * phylink_ethtool_set_eee() - set the energy efficient ethernet parameters
  * @pl: a pointer to a &struct phylink returned from phylink_create()
- * @eee: a pointer to a &struct ethtool_eee for the desired parameters
+ * @eee: a pointer to a &struct ethtool_keee for the desired parameters
  */
-int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_eee *eee)
+int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_keee *eee)
 {
        int ret = -EOPNOTSUPP;
 
 
 }
 
 static int
-ax88179_ethtool_get_eee(struct usbnet *dev, struct ethtool_eee *data)
+ax88179_ethtool_get_eee(struct usbnet *dev, struct ethtool_keee *data)
 {
        int val;
 
 }
 
 static int
-ax88179_ethtool_set_eee(struct usbnet *dev, struct ethtool_eee *data)
+ax88179_ethtool_set_eee(struct usbnet *dev, struct ethtool_keee *data)
 {
        u16 tmp16 = ethtool_adv_to_mmd_eee_adv_t(data->advertised);
 
                          GMII_PHY_PAGE_SELECT, 2, &tmp16);
 }
 
-static int ax88179_get_eee(struct net_device *net, struct ethtool_eee *edata)
+static int ax88179_get_eee(struct net_device *net, struct ethtool_keee *edata)
 {
        struct usbnet *dev = netdev_priv(net);
        struct ax88179_data *priv = dev->driver_priv;
        return ax88179_ethtool_get_eee(dev, edata);
 }
 
-static int ax88179_set_eee(struct net_device *net, struct ethtool_eee *edata)
+static int ax88179_set_eee(struct net_device *net, struct ethtool_keee *edata)
 {
        struct usbnet *dev = netdev_priv(net);
        struct ax88179_data *priv = dev->driver_priv;
        u16 *tmp16;
        u8 *tmp;
        struct ax88179_data *ax179_data = dev->driver_priv;
-       struct ethtool_eee eee_data;
+       struct ethtool_keee eee_data;
 
        tmp16 = (u16 *)buf;
        tmp = (u8 *)buf;
 
        return ret;
 }
 
-static int lan78xx_get_eee(struct net_device *net, struct ethtool_eee *edata)
+static int lan78xx_get_eee(struct net_device *net, struct ethtool_keee *edata)
 {
        struct lan78xx_net *dev = netdev_priv(net);
        struct phy_device *phydev = net->phydev;
        return ret;
 }
 
-static int lan78xx_set_eee(struct net_device *net, struct ethtool_eee *edata)
+static int lan78xx_set_eee(struct net_device *net, struct ethtool_keee *edata)
 {
        struct lan78xx_net *dev = netdev_priv(net);
        int ret;
 
                void (*up)(struct r8152 *tp);
                void (*down)(struct r8152 *tp);
                void (*unload)(struct r8152 *tp);
-               int (*eee_get)(struct r8152 *tp, struct ethtool_eee *eee);
-               int (*eee_set)(struct r8152 *tp, struct ethtool_eee *eee);
+               int (*eee_get)(struct r8152 *tp, struct ethtool_keee *eee);
+               int (*eee_set)(struct r8152 *tp, struct ethtool_keee *eee);
                bool (*in_nway)(struct r8152 *tp);
                void (*hw_phy_cfg)(struct r8152 *tp);
                void (*autosuspend_en)(struct r8152 *tp, bool enable);
        }
 }
 
-static int r8152_get_eee(struct r8152 *tp, struct ethtool_eee *eee)
+static int r8152_get_eee(struct r8152 *tp, struct ethtool_keee *eee)
 {
        u32 lp, adv, supported = 0;
        u16 val;
        return 0;
 }
 
-static int r8152_set_eee(struct r8152 *tp, struct ethtool_eee *eee)
+static int r8152_set_eee(struct r8152 *tp, struct ethtool_keee *eee)
 {
        u16 val = ethtool_adv_to_mmd_eee_adv_t(eee->advertised);
 
        return 0;
 }
 
-static int r8153_get_eee(struct r8152 *tp, struct ethtool_eee *eee)
+static int r8153_get_eee(struct r8152 *tp, struct ethtool_keee *eee)
 {
        u32 lp, adv, supported = 0;
        u16 val;
 }
 
 static int
-rtl_ethtool_get_eee(struct net_device *net, struct ethtool_eee *edata)
+rtl_ethtool_get_eee(struct net_device *net, struct ethtool_keee *edata)
 {
        struct r8152 *tp = netdev_priv(net);
        int ret;
 }
 
 static int
-rtl_ethtool_set_eee(struct net_device *net, struct ethtool_eee *edata)
+rtl_ethtool_set_eee(struct net_device *net, struct ethtool_keee *edata)
 {
        struct r8152 *tp = netdev_priv(net);
        int ret;
 
 __ethtool_get_link_ksettings(struct net_device *dev,
                             struct ethtool_link_ksettings *link_ksettings);
 
+struct ethtool_keee {
+       u32     cmd;
+       u32     supported;
+       u32     advertised;
+       u32     lp_advertised;
+       u32     eee_active;
+       u32     eee_enabled;
+       u32     tx_lpi_enabled;
+       u32     tx_lpi_timer;
+       u32     reserved[2];
+};
+
 struct kernel_ethtool_coalesce {
        u8 use_cqe_mode_tx;
        u8 use_cqe_mode_rx;
                                   struct ethtool_modinfo *);
        int     (*get_module_eeprom)(struct net_device *,
                                     struct ethtool_eeprom *, u8 *);
-       int     (*get_eee)(struct net_device *, struct ethtool_eee *);
-       int     (*set_eee)(struct net_device *, struct ethtool_eee *);
+       int     (*get_eee)(struct net_device *dev, struct ethtool_keee *eee);
+       int     (*set_eee)(struct net_device *dev, struct ethtool_keee *eee);
        int     (*get_tunable)(struct net_device *,
                               const struct ethtool_tunable *, void *);
        int     (*set_tunable)(struct net_device *,
 
 int genphy_c45_eee_is_active(struct phy_device *phydev, unsigned long *adv,
                             unsigned long *lp, bool *is_enabled);
 int genphy_c45_ethtool_get_eee(struct phy_device *phydev,
-                              struct ethtool_eee *data);
+                              struct ethtool_keee *data);
 int genphy_c45_ethtool_set_eee(struct phy_device *phydev,
-                              struct ethtool_eee *data);
+                              struct ethtool_keee *data);
 int genphy_c45_write_eee_adv(struct phy_device *phydev, unsigned long *adv);
 int genphy_c45_an_config_eee_aneg(struct phy_device *phydev);
 int genphy_c45_read_eee_adv(struct phy_device *phydev, unsigned long *adv);
 
 int phy_init_eee(struct phy_device *phydev, bool clk_stop_enable);
 int phy_get_eee_err(struct phy_device *phydev);
-int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_eee *data);
-int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_eee *data);
+int phy_ethtool_set_eee(struct phy_device *phydev, struct ethtool_keee *data);
+int phy_ethtool_get_eee(struct phy_device *phydev, struct ethtool_keee *data);
 int phy_ethtool_set_wol(struct phy_device *phydev, struct ethtool_wolinfo *wol);
 void phy_ethtool_get_wol(struct phy_device *phydev,
                         struct ethtool_wolinfo *wol);
 
                                   struct ethtool_pauseparam *);
 int phylink_get_eee_err(struct phylink *);
 int phylink_init_eee(struct phylink *, bool);
-int phylink_ethtool_get_eee(struct phylink *, struct ethtool_eee *);
-int phylink_ethtool_set_eee(struct phylink *, struct ethtool_eee *);
+int phylink_ethtool_get_eee(struct phylink *link, struct ethtool_keee *eee);
+int phylink_ethtool_set_eee(struct phylink *link, struct ethtool_keee *eee);
 int phylink_mii_ioctl(struct phylink *, struct ifreq *, int);
 int phylink_speed_down(struct phylink *pl, bool sync);
 int phylink_speed_up(struct phylink *pl);
 
         * Port's MAC EEE settings
         */
        int     (*set_mac_eee)(struct dsa_switch *ds, int port,
-                              struct ethtool_eee *e);
+                              struct ethtool_keee *e);
        int     (*get_mac_eee)(struct dsa_switch *ds, int port,
-                              struct ethtool_eee *e);
+                              struct ethtool_keee *e);
 
        /* EEPROM access */
        int     (*get_eeprom_len)(struct dsa_switch *ds);
 
        return ret;
 }
 
-static int dsa_user_set_eee(struct net_device *dev, struct ethtool_eee *e)
+static int dsa_user_set_eee(struct net_device *dev, struct ethtool_keee *e)
 {
        struct dsa_port *dp = dsa_user_to_port(dev);
        struct dsa_switch *ds = dp->ds;
        return phylink_ethtool_set_eee(dp->pl, e);
 }
 
-static int dsa_user_get_eee(struct net_device *dev, struct ethtool_eee *e)
+static int dsa_user_get_eee(struct net_device *dev, struct ethtool_keee *e)
 {
        struct dsa_port *dp = dsa_user_to_port(dev);
        struct dsa_switch *ds = dp->ds;
 
 #include "bitset.h"
 
 #define EEE_MODES_COUNT \
-       (sizeof_field(struct ethtool_eee, supported) * BITS_PER_BYTE)
+       (sizeof_field(struct ethtool_keee, supported) * BITS_PER_BYTE)
 
 struct eee_req_info {
        struct ethnl_req_info           base;
 
 struct eee_reply_data {
        struct ethnl_reply_data         base;
-       struct ethtool_eee              eee;
+       struct ethtool_keee             eee;
 };
 
 #define EEE_REPDATA(__reply_base) \
 {
        bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
        const struct eee_reply_data *data = EEE_REPDATA(reply_base);
-       const struct ethtool_eee *eee = &data->eee;
+       const struct ethtool_keee *eee = &data->eee;
        int len = 0;
        int ret;
 
 {
        bool compact = req_base->flags & ETHTOOL_FLAG_COMPACT_BITSETS;
        const struct eee_reply_data *data = EEE_REPDATA(reply_base);
-       const struct ethtool_eee *eee = &data->eee;
+       const struct ethtool_keee *eee = &data->eee;
        int ret;
 
        ret = ethnl_put_bitset32(skb, ETHTOOL_A_EEE_MODES_OURS,
 {
        struct net_device *dev = req_info->dev;
        struct nlattr **tb = info->attrs;
-       struct ethtool_eee eee = {};
+       struct ethtool_keee eee = {};
        bool mod = false;
        int ret;
 
 
 
 static int ethtool_get_eee(struct net_device *dev, char __user *useraddr)
 {
-       struct ethtool_eee edata;
+       struct ethtool_keee edata;
        int rc;
 
        if (!dev->ethtool_ops->get_eee)
                return -EOPNOTSUPP;
 
-       memset(&edata, 0, sizeof(struct ethtool_eee));
+       memset(&edata, 0, sizeof(struct ethtool_keee));
        edata.cmd = ETHTOOL_GEEE;
        rc = dev->ethtool_ops->get_eee(dev, &edata);
 
 
 static int ethtool_set_eee(struct net_device *dev, char __user *useraddr)
 {
-       struct ethtool_eee edata;
+       struct ethtool_keee edata;
        int ret;
 
        if (!dev->ethtool_ops->set_eee)