if (err < 0)
return err;
- eee->supported = eee_mask_to_ethtool_mask(supported_rates);
+ eee->supported_u32 = eee_mask_to_ethtool_mask(supported_rates);
if (aq_nic->aq_nic_cfg.eee_speeds)
- eee->advertised = eee->supported;
+ eee->advertised_u32 = eee->supported_u32;
- eee->lp_advertised = eee_mask_to_ethtool_mask(rate);
+ eee->lp_advertised_u32 = eee_mask_to_ethtool_mask(rate);
- eee->eee_enabled = !!eee->advertised;
+ eee->eee_enabled = !!eee->advertised_u32;
eee->tx_lpi_enabled = eee->eee_enabled;
if ((supported_rates & rate) & AQ_NIC_RATE_EEE_MSK)
eee_cfg = bp->link_vars.eee_status;
- edata->supported =
+ edata->supported_u32 =
bnx2x_eee_to_adv((eee_cfg & SHMEM_EEE_SUPPORTED_MASK) >>
SHMEM_EEE_SUPPORTED_SHIFT);
- edata->advertised =
+ edata->advertised_u32 =
bnx2x_eee_to_adv((eee_cfg & SHMEM_EEE_ADV_STATUS_MASK) >>
SHMEM_EEE_ADV_STATUS_SHIFT);
- edata->lp_advertised =
+ edata->lp_advertised_u32 =
bnx2x_eee_to_adv((eee_cfg & SHMEM_EEE_LP_ADV_STATUS_MASK) >>
SHMEM_EEE_LP_ADV_STATUS_SHIFT);
return -EOPNOTSUPP;
}
- advertised = bnx2x_adv_to_eee(edata->advertised,
+ advertised = bnx2x_adv_to_eee(edata->advertised_u32,
SHMEM_EEE_ADV_STATUS_SHIFT);
if ((advertised != (eee_cfg & SHMEM_EEE_ADV_STATUS_MASK))) {
DP(BNX2X_MSG_ETHTOOL,
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);
+ eee->supported_u32 = _bnxt_fw_to_ethtool_adv_spds(fw_speeds, 0);
bp->lpi_tmr_lo = le32_to_cpu(resp->tx_lpi_timer_low) &
PORT_PHY_QCAPS_RESP_TX_LPI_TIMER_LOW_MASK;
bp->lpi_tmr_hi = le32_to_cpu(resp->valid_tx_lpi_timer_high) &
eee->eee_active = 1;
fw_speeds = le16_to_cpu(
resp->link_partner_adv_eee_link_speed_mask);
- eee->lp_advertised =
+ eee->lp_advertised_u32 =
_bnxt_fw_to_ethtool_adv_spds(fw_speeds, 0);
}
eee->eee_enabled = 1;
fw_speeds = le16_to_cpu(resp->adv_eee_link_speed_mask);
- eee->advertised =
+ eee->advertised_u32 =
_bnxt_fw_to_ethtool_adv_spds(fw_speeds, 0);
if (resp->eee_config_phy_addr &
flags |= PORT_PHY_CFG_REQ_FLAGS_EEE_TX_LPI_DISABLE;
req->flags |= cpu_to_le32(flags);
- eee_speeds = bnxt_get_fw_auto_link_speeds(eee->advertised);
+ eee_speeds = bnxt_get_fw_auto_link_speeds(eee->advertised_u32);
req->eee_link_speed_mask = cpu_to_le16(eee_speeds);
req->tx_lpi_timer = cpu_to_le32(eee->tx_lpi_timer);
} else {
eee->eee_enabled = 0;
return false;
}
- if (eee->advertised & ~advertising) {
- eee->advertised = advertising & eee->supported;
+ if (eee->advertised_u32 & ~advertising) {
+ eee->advertised_u32 = advertising & eee->supported_u32;
return false;
}
}
edata->tx_lpi_timer = eee->tx_lpi_timer;
}
}
- if (!edata->advertised) {
- edata->advertised = advertising & eee->supported;
- } else if (edata->advertised & ~advertising) {
+ if (!edata->advertised_u32) {
+ edata->advertised_u32 = advertising & eee->supported_u32;
+ } else if (edata->advertised_u32 & ~advertising) {
netdev_warn(dev, "EEE advertised %x must be a subset of autoneg advertised speeds %x\n",
- edata->advertised, advertising);
+ edata->advertised_u32, advertising);
rc = -EINVAL;
goto eee_exit;
}
- eee->advertised = edata->advertised;
+ eee->advertised_u32 = edata->advertised_u32;
eee->tx_lpi_enabled = edata->tx_lpi_enabled;
eee->tx_lpi_timer = edata->tx_lpi_timer;
eee_ok:
/* Preserve tx_lpi_timer so that the last value will be used
* by default when it is re-enabled.
*/
- edata->advertised = 0;
+ edata->advertised_u32 = 0;
edata->tx_lpi_enabled = 0;
}
if (!bp->eee.eee_active)
- edata->lp_advertised = 0;
+ edata->lp_advertised_u32 = 0;
return 0;
}
/* Pull lp advertised settings */
if (tg3_phy_cl45_read(tp, MDIO_MMD_AN, MDIO_AN_EEE_LPABLE, &val))
return;
- dest->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
+ dest->lp_advertised_u32 = mmd_eee_adv_to_ethtool_adv_t(val);
/* Pull advertised and eee_enabled settings */
if (tg3_phy_cl45_read(tp, MDIO_MMD_AN, MDIO_AN_EEE_ADV, &val))
return;
dest->eee_enabled = !!val;
- dest->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
+ dest->advertised_u32 = mmd_eee_adv_to_ethtool_adv_t(val);
/* Pull tx_lpi_enabled */
val = tr32(TG3_CPMU_EEE_MODE);
if (!tp->eee.eee_enabled) {
val = 0;
- tp->eee.advertised = 0;
+ tp->eee.advertised_u32 = 0;
} else {
- tp->eee.advertised = advertise &
+ tp->eee.advertised_u32 = advertise &
(ADVERTISED_100baseT_Full |
ADVERTISED_1000baseT_Full);
}
tg3_eee_pull_config(tp, &eee);
if (tp->eee.eee_enabled) {
- if (tp->eee.advertised != eee.advertised ||
+ if (tp->eee.advertised_u32 != eee.advertised_u32 ||
tp->eee.tx_lpi_timer != eee.tx_lpi_timer ||
tp->eee.tx_lpi_enabled != eee.tx_lpi_enabled)
return false;
} else {
/* EEE is disabled but we're advertising */
- if (eee.advertised)
+ if (eee.advertised_u32)
return false;
}
return -EOPNOTSUPP;
}
- if (edata->advertised != tp->eee.advertised) {
+ if (edata->advertised_u32 != tp->eee.advertised_u32) {
netdev_warn(tp->dev,
"Direct manipulation of EEE advertisement is not supported\n");
return -EINVAL;
tg3_chip_rev_id(tp) != CHIPREV_ID_57765_A0))) {
tp->phy_flags |= TG3_PHYFLG_EEE_CAP;
- tp->eee.supported = SUPPORTED_100baseT_Full |
- SUPPORTED_1000baseT_Full;
- tp->eee.advertised = ADVERTISED_100baseT_Full |
- ADVERTISED_1000baseT_Full;
+ tp->eee.supported_u32 = SUPPORTED_100baseT_Full |
+ SUPPORTED_1000baseT_Full;
+ tp->eee.advertised_u32 = ADVERTISED_100baseT_Full |
+ ADVERTISED_1000baseT_Full;
tp->eee.eee_enabled = 1;
tp->eee.tx_lpi_enabled = 1;
tp->eee.tx_lpi_timer = TG3_CPMU_DBTMR1_LNKIDLE_2047US;
ret_val = e1000_read_emi_reg_locked(hw, cap_addr, &phy_data);
if (ret_val)
goto release;
- edata->supported = mmd_eee_cap_to_ethtool_sup_t(phy_data);
+ edata->supported_u32 = mmd_eee_cap_to_ethtool_sup_t(phy_data);
/* EEE Advertised */
- edata->advertised = mmd_eee_adv_to_ethtool_adv_t(adapter->eee_advert);
+ edata->advertised_u32 = mmd_eee_adv_to_ethtool_adv_t(adapter->eee_advert);
/* EEE Link Partner Advertised */
ret_val = e1000_read_emi_reg_locked(hw, lpa_addr, &phy_data);
if (ret_val)
goto release;
- edata->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(phy_data);
+ edata->lp_advertised_u32 = mmd_eee_adv_to_ethtool_adv_t(phy_data);
/* EEE PCS Status */
ret_val = e1000_read_emi_reg_locked(hw, pcs_stat_addr, &phy_data);
return -EINVAL;
}
- if (edata->advertised & ~(ADVERTISE_100_FULL | ADVERTISE_1000_FULL)) {
+ if (edata->advertised_u32 & ~(ADVERTISE_100_FULL | ADVERTISE_1000_FULL)) {
e_err("EEE advertisement supports only 100TX and/or 1000T full-duplex\n");
return -EINVAL;
}
- adapter->eee_advert = ethtool_adv_to_mmd_eee_adv_t(edata->advertised);
+ adapter->eee_advert = ethtool_adv_to_mmd_eee_adv_t(edata->advertised_u32);
hw->dev_spec.ich8lan.eee_disable = !edata->eee_enabled;
if (phy_cfg.eee_capability == 0)
return -EOPNOTSUPP;
- edata->supported = SUPPORTED_Autoneg;
- edata->lp_advertised = edata->supported;
+ edata->supported_u32 = SUPPORTED_Autoneg;
+ edata->lp_advertised_u32 = edata->supported_u32;
/* Get current configuration */
status = i40e_aq_get_phy_capabilities(hw, false, false, &phy_cfg, NULL);
if (status)
return -EAGAIN;
- edata->advertised = phy_cfg.eee_capability ? SUPPORTED_Autoneg : 0U;
- edata->eee_enabled = !!edata->advertised;
+ edata->advertised_u32 = phy_cfg.eee_capability ? SUPPORTED_Autoneg : 0U;
+ edata->eee_enabled = !!edata->advertised_u32;
edata->tx_lpi_enabled = pf->stats.tx_lpi_status;
edata->eee_active = pf->stats.tx_lpi_status && pf->stats.rx_lpi_status;
u32 value;
const char *name;
} param[] = {
- {edata->advertised & ~SUPPORTED_Autoneg, "advertise"},
+ {edata->advertised_u32 & ~SUPPORTED_Autoneg, "advertise"},
{edata->tx_lpi_timer, "tx-timer"},
{edata->tx_lpi_enabled != pf->stats.tx_lpi_status, "tx-lpi"}
};
(hw->phy.media_type != e1000_media_type_copper))
return -EOPNOTSUPP;
- edata->supported = (SUPPORTED_1000baseT_Full |
- SUPPORTED_100baseT_Full);
+ edata->supported_u32 = (SUPPORTED_1000baseT_Full |
+ SUPPORTED_100baseT_Full);
if (!hw->dev_spec._82575.eee_disable)
- edata->advertised =
+ edata->advertised_u32 =
mmd_eee_adv_to_ethtool_adv_t(adapter->eee_advert);
/* The IPCNFG and EEER registers are not supported on I354. */
if (ret_val)
return -ENODATA;
- edata->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(phy_data);
+ edata->lp_advertised_u32 = mmd_eee_adv_to_ethtool_adv_t(phy_data);
break;
case e1000_i354:
case e1000_i210:
if (ret_val)
return -ENODATA;
- edata->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(phy_data);
+ edata->lp_advertised_u32 = mmd_eee_adv_to_ethtool_adv_t(phy_data);
break;
default:
edata->eee_enabled = false;
edata->eee_active = false;
edata->tx_lpi_enabled = false;
- edata->advertised &= ~edata->advertised;
+ edata->advertised_u32 &= ~edata->advertised_u32;
}
return 0;
return -EINVAL;
}
- if (!edata->advertised || (edata->advertised &
+ if (!edata->advertised_u32 || (edata->advertised_u32 &
~(ADVERTISE_100_FULL | ADVERTISE_1000_FULL))) {
dev_err(&adapter->pdev->dev,
"EEE Advertisement supports only 100Tx and/or 100T full duplex\n");
return -EINVAL;
}
- adv100m_eee = !!(edata->advertised & ADVERTISE_100_FULL);
- adv1g_eee = !!(edata->advertised & ADVERTISE_1000_FULL);
+ adv100m_eee = !!(edata->advertised_u32 & ADVERTISE_100_FULL);
+ adv1g_eee = !!(edata->advertised_u32 & ADVERTISE_1000_FULL);
} else if (!edata->eee_enabled) {
dev_err(&adapter->pdev->dev,
return -EINVAL;
}
- adapter->eee_advert = ethtool_adv_to_mmd_eee_adv_t(edata->advertised);
+ adapter->eee_advert = ethtool_adv_to_mmd_eee_adv_t(edata->advertised_u32);
if (hw->dev_spec._82575.eee_disable != !edata->eee_enabled) {
hw->dev_spec._82575.eee_disable = !edata->eee_enabled;
adapter->flags |= IGB_FLAG_EEE;
u32 eeer;
if (hw->dev_spec._base.eee_enable)
- edata->advertised =
+ edata->advertised_u32 =
mmd_eee_adv_to_ethtool_adv_t(adapter->eee_advert);
*edata = adapter->eee;
- edata->supported = SUPPORTED_Autoneg;
+ edata->supported_u32 = SUPPORTED_Autoneg;
eeer = rd32(IGC_EEER);
edata->eee_enabled = hw->dev_spec._base.eee_enable;
- edata->advertised = SUPPORTED_Autoneg;
- edata->lp_advertised = SUPPORTED_Autoneg;
+ edata->advertised_u32 = SUPPORTED_Autoneg;
+ edata->lp_advertised_u32 = SUPPORTED_Autoneg;
/* Report correct negotiated EEE status for devices that
* wrongly report EEE at half-duplex
edata->eee_enabled = false;
edata->eee_active = false;
edata->tx_lpi_enabled = false;
- edata->advertised &= ~edata->advertised;
+ edata->advertised_u32 &= ~edata->advertised_u32;
}
return 0;
return -EINVAL;
}
- adapter->eee_advert = ethtool_adv_to_mmd_eee_adv_t(edata->advertised);
+ adapter->eee_advert = ethtool_adv_to_mmd_eee_adv_t(edata->advertised_u32);
if (hw->dev_spec._base.eee_enable != edata->eee_enabled) {
hw->dev_spec._base.eee_enable = edata->eee_enabled;
adapter->flags |= IGC_FLAG_EEE;
if (rc)
return rc;
- edata->lp_advertised = 0;
+ edata->lp_advertised_u32 = 0;
for (i = 0; i < ARRAY_SIZE(ixgbe_lp_map); ++i) {
if (info[0] & ixgbe_lp_map[i].lp_advertised)
- edata->lp_advertised |= ixgbe_lp_map[i].mac_speed;
+ edata->lp_advertised_u32 |= ixgbe_lp_map[i].mac_speed;
}
- edata->supported = 0;
+ edata->supported_u32 = 0;
for (i = 0; i < ARRAY_SIZE(ixgbe_ls_map); ++i) {
if (hw->phy.eee_speeds_supported & ixgbe_ls_map[i].mac_speed)
- edata->supported |= ixgbe_ls_map[i].supported;
+ edata->supported_u32 |= ixgbe_ls_map[i].supported;
}
- edata->advertised = 0;
+ edata->advertised_u32 = 0;
for (i = 0; i < ARRAY_SIZE(ixgbe_ls_map); ++i) {
if (hw->phy.eee_speeds_advertised & ixgbe_ls_map[i].mac_speed)
- edata->advertised |= ixgbe_ls_map[i].supported;
+ edata->advertised_u32 |= ixgbe_ls_map[i].supported;
}
- edata->eee_enabled = !!edata->advertised;
+ edata->eee_enabled = !!edata->advertised_u32;
edata->tx_lpi_enabled = edata->eee_enabled;
- if (edata->advertised & edata->lp_advertised)
+ if (edata->advertised_u32 & edata->lp_advertised_u32)
edata->eee_active = true;
return 0;
return -EINVAL;
}
- if (eee_data.advertised != edata->advertised) {
+ if (eee_data.advertised_u32 != edata->advertised_u32) {
e_err(drv,
"Setting EEE advertised speeds is not supported\n");
return -EINVAL;
}
if (current_link.eee.adv_caps & QED_EEE_1G_ADV)
- edata->advertised = ADVERTISED_1000baseT_Full;
+ edata->advertised_u32 = ADVERTISED_1000baseT_Full;
if (current_link.eee.adv_caps & QED_EEE_10G_ADV)
- edata->advertised |= ADVERTISED_10000baseT_Full;
+ edata->advertised_u32 |= ADVERTISED_10000baseT_Full;
if (current_link.sup_caps & QED_EEE_1G_ADV)
- edata->supported = ADVERTISED_1000baseT_Full;
+ edata->supported_u32 = ADVERTISED_1000baseT_Full;
if (current_link.sup_caps & QED_EEE_10G_ADV)
- edata->supported |= ADVERTISED_10000baseT_Full;
+ edata->supported_u32 |= ADVERTISED_10000baseT_Full;
if (current_link.eee.lp_adv_caps & QED_EEE_1G_ADV)
- edata->lp_advertised = ADVERTISED_1000baseT_Full;
+ edata->lp_advertised_u32 = ADVERTISED_1000baseT_Full;
if (current_link.eee.lp_adv_caps & QED_EEE_10G_ADV)
- edata->lp_advertised |= ADVERTISED_10000baseT_Full;
+ edata->lp_advertised_u32 |= ADVERTISED_10000baseT_Full;
edata->tx_lpi_timer = current_link.eee.tx_lpi_timer;
edata->eee_enabled = current_link.eee.enable;
memset(¶ms, 0, sizeof(params));
params.override_flags |= QED_LINK_OVERRIDE_EEE_CONFIG;
- if (!(edata->advertised & (ADVERTISED_1000baseT_Full |
- ADVERTISED_10000baseT_Full)) ||
- ((edata->advertised & (ADVERTISED_1000baseT_Full |
- ADVERTISED_10000baseT_Full)) !=
- edata->advertised)) {
+ if (!(edata->advertised_u32 & (ADVERTISED_1000baseT_Full |
+ ADVERTISED_10000baseT_Full)) ||
+ ((edata->advertised_u32 & (ADVERTISED_1000baseT_Full |
+ ADVERTISED_10000baseT_Full)) !=
+ edata->advertised_u32)) {
DP_VERBOSE(edev, QED_MSG_DEBUG,
"Invalid advertised capabilities %d\n",
- edata->advertised);
+ edata->advertised_u32);
return -EINVAL;
}
- if (edata->advertised & ADVERTISED_1000baseT_Full)
+ if (edata->advertised_u32 & ADVERTISED_1000baseT_Full)
params.eee.adv_caps = QED_EEE_1G_ADV;
- if (edata->advertised & ADVERTISED_10000baseT_Full)
+ if (edata->advertised_u32 & ADVERTISED_10000baseT_Full)
params.eee.adv_caps |= QED_EEE_10G_ADV;
params.eee.enable = edata->eee_enabled;
params.eee.tx_lpi_enable = edata->tx_lpi_enabled;
data->eee_enabled = is_enabled;
data->eee_active = ret;
- if (!ethtool_convert_link_mode_to_legacy_u32(&data->supported,
+ if (!ethtool_convert_link_mode_to_legacy_u32(&data->supported_u32,
phydev->supported_eee))
overflow = true;
- if (!ethtool_convert_link_mode_to_legacy_u32(&data->advertised, adv))
+ if (!ethtool_convert_link_mode_to_legacy_u32(&data->advertised_u32, adv))
overflow = true;
- if (!ethtool_convert_link_mode_to_legacy_u32(&data->lp_advertised, lp))
+ if (!ethtool_convert_link_mode_to_legacy_u32(&data->lp_advertised_u32, lp))
overflow = true;
if (overflow)
int ret;
if (data->eee_enabled) {
- if (data->advertised) {
+ if (data->advertised_u32) {
__ETHTOOL_DECLARE_LINK_MODE_MASK(adv);
ethtool_convert_legacy_u32_to_link_mode(adv,
- data->advertised);
+ data->advertised_u32);
linkmode_andnot(adv, adv, phydev->supported_eee);
if (!linkmode_empty(adv)) {
phydev_warn(phydev, "At least some EEE link modes are not supported.\n");
}
ethtool_convert_legacy_u32_to_link_mode(phydev->advertising_eee,
- data->advertised);
+ data->advertised_u32);
} else {
linkmode_copy(phydev->advertising_eee,
phydev->supported_eee);
MDIO_MMD_PCS);
if (val < 0)
return val;
- data->supported = mmd_eee_cap_to_ethtool_sup_t(val);
+ data->supported_u32 = mmd_eee_cap_to_ethtool_sup_t(val);
/* Get advertisement EEE */
val = ax88179_phy_read_mmd_indirect(dev, MDIO_AN_EEE_ADV,
MDIO_MMD_AN);
if (val < 0)
return val;
- data->advertised = mmd_eee_adv_to_ethtool_adv_t(val);
+ data->advertised_u32 = mmd_eee_adv_to_ethtool_adv_t(val);
/* Get LP advertisement EEE */
val = ax88179_phy_read_mmd_indirect(dev, MDIO_AN_EEE_LPABLE,
MDIO_MMD_AN);
if (val < 0)
return val;
- data->lp_advertised = mmd_eee_adv_to_ethtool_adv_t(val);
+ data->lp_advertised_u32 = mmd_eee_adv_to_ethtool_adv_t(val);
return 0;
}
static int
ax88179_ethtool_set_eee(struct usbnet *dev, struct ethtool_keee *data)
{
- u16 tmp16 = ethtool_adv_to_mmd_eee_adv_t(data->advertised);
+ u16 tmp16 = ethtool_adv_to_mmd_eee_adv_t(data->advertised_u32);
return ax88179_phy_write_mmd_indirect(dev, MDIO_AN_EEE_ADV,
MDIO_MMD_AN, tmp16);
ax88179_disable_eee(dev);
ax88179_ethtool_get_eee(dev, &eee_data);
- eee_data.advertised = 0;
+ eee_data.advertised_u32 = 0;
ax88179_ethtool_set_eee(dev, &eee_data);
/* Restart autoneg */
eee->eee_enabled = tp->eee_en;
eee->eee_active = !!(supported & adv & lp);
- eee->supported = supported;
- eee->advertised = tp->eee_adv;
- eee->lp_advertised = lp;
+ eee->supported_u32 = supported;
+ eee->advertised_u32 = tp->eee_adv;
+ eee->lp_advertised_u32 = lp;
return 0;
}
static int r8152_set_eee(struct r8152 *tp, struct ethtool_keee *eee)
{
- u16 val = ethtool_adv_to_mmd_eee_adv_t(eee->advertised);
+ u16 val = ethtool_adv_to_mmd_eee_adv_t(eee->advertised_u32);
tp->eee_en = eee->eee_enabled;
tp->eee_adv = val;
eee->eee_enabled = tp->eee_en;
eee->eee_active = !!(supported & adv & lp);
- eee->supported = supported;
- eee->advertised = tp->eee_adv;
- eee->lp_advertised = lp;
+ eee->supported_u32 = supported;
+ eee->advertised_u32 = tp->eee_adv;
+ eee->lp_advertised_u32 = lp;
return 0;
}
struct ethtool_link_ksettings *link_ksettings);
struct ethtool_keee {
- u32 supported;
- u32 advertised;
- u32 lp_advertised;
+ u32 supported_u32;
+ u32 advertised_u32;
+ u32 lp_advertised_u32;
u32 tx_lpi_timer;
bool tx_lpi_enabled;
bool eee_active;
#include "bitset.h"
#define EEE_MODES_COUNT \
- (sizeof_field(struct ethtool_keee, supported) * BITS_PER_BYTE)
+ (sizeof_field(struct ethtool_keee, supported_u32) * BITS_PER_BYTE)
struct eee_req_info {
struct ethnl_req_info base;
int len = 0;
int ret;
- BUILD_BUG_ON(sizeof(eee->advertised) * BITS_PER_BYTE !=
+ BUILD_BUG_ON(sizeof(eee->advertised_u32) * BITS_PER_BYTE !=
EEE_MODES_COUNT);
- BUILD_BUG_ON(sizeof(eee->lp_advertised) * BITS_PER_BYTE !=
+ BUILD_BUG_ON(sizeof(eee->lp_advertised_u32) * BITS_PER_BYTE !=
EEE_MODES_COUNT);
/* MODES_OURS */
- ret = ethnl_bitset32_size(&eee->advertised, &eee->supported,
+ ret = ethnl_bitset32_size(&eee->advertised_u32, &eee->supported_u32,
EEE_MODES_COUNT, link_mode_names, compact);
if (ret < 0)
return ret;
len += ret;
/* MODES_PEERS */
- ret = ethnl_bitset32_size(&eee->lp_advertised, NULL,
+ ret = ethnl_bitset32_size(&eee->lp_advertised_u32, NULL,
EEE_MODES_COUNT, link_mode_names, compact);
if (ret < 0)
return ret;
int ret;
ret = ethnl_put_bitset32(skb, ETHTOOL_A_EEE_MODES_OURS,
- &eee->advertised, &eee->supported,
+ &eee->advertised_u32, &eee->supported_u32,
EEE_MODES_COUNT, link_mode_names, compact);
if (ret < 0)
return ret;
ret = ethnl_put_bitset32(skb, ETHTOOL_A_EEE_MODES_PEER,
- &eee->lp_advertised, NULL, EEE_MODES_COUNT,
+ &eee->lp_advertised_u32, NULL, EEE_MODES_COUNT,
link_mode_names, compact);
if (ret < 0)
return ret;
if (ret < 0)
return ret;
- ret = ethnl_update_bitset32(&eee.advertised, EEE_MODES_COUNT,
+ ret = ethnl_update_bitset32(&eee.advertised_u32, EEE_MODES_COUNT,
tb[ETHTOOL_A_EEE_MODES_OURS],
link_mode_names, info->extack, &mod);
if (ret < 0)
{
memset(keee, 0, sizeof(*keee));
- keee->supported = eee->supported;
- keee->advertised = eee->advertised;
- keee->lp_advertised = eee->lp_advertised;
+ keee->supported_u32 = eee->supported;
+ keee->advertised_u32 = eee->advertised;
+ keee->lp_advertised_u32 = eee->lp_advertised;
keee->eee_active = eee->eee_active;
keee->eee_enabled = eee->eee_enabled;
keee->tx_lpi_enabled = eee->tx_lpi_enabled;
{
memset(eee, 0, sizeof(*eee));
- eee->supported = keee->supported;
- eee->advertised = keee->advertised;
- eee->lp_advertised = keee->lp_advertised;
+ eee->supported = keee->supported_u32;
+ eee->advertised = keee->advertised_u32;
+ eee->lp_advertised = keee->lp_advertised_u32;
eee->eee_active = keee->eee_active;
eee->eee_enabled = keee->eee_enabled;
eee->tx_lpi_enabled = keee->tx_lpi_enabled;