ethtool: add linkmode bitmap support to struct ethtool_keee

Add linkmode bitmap members to struct ethtool_keee, but keep the legacy
u32 bitmaps for compatibility with existing drivers.
Use linkmode "supported" not being empty as indicator that a user wants
to use the linkmode bitmap members instead of the legacy bitmaps.

Signed-off-by: Heiner Kallweit <hkallweit1@gmail.com>
Reviewed-by: Andrew Lunn <andrew@lunn.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index 89807c3..b90c336 100644 (file)
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -223,6 +223,9 @@ __ethtool_get_link_ksettings(struct net_device *dev,
                             struct ethtool_link_ksettings *link_ksettings);
 
 struct ethtool_keee {
+       __ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
+       __ETHTOOL_DECLARE_LINK_MODE_MASK(advertised);
+       __ETHTOOL_DECLARE_LINK_MODE_MASK(lp_advertised);
        u32     supported_u32;
        u32     advertised_u32;
        u32     lp_advertised_u32;

diff --git a/net/ethtool/common.c b/net/ethtool/common.c
index 6b2a360..ce486ce 100644 (file)
--- a/net/ethtool/common.c
+++ b/net/ethtool/common.c
@@ -712,3 +712,8 @@ ethtool_forced_speed_maps_init(struct ethtool_forced_speed_map *maps, u32 size)
        }
 }
 EXPORT_SYMBOL_GPL(ethtool_forced_speed_maps_init);
+
+bool ethtool_eee_use_linkmodes(const struct ethtool_keee *eee)
+{
+       return !linkmode_empty(eee->supported);
+}

diff --git a/net/ethtool/common.h b/net/ethtool/common.h
index 28b8aaa..0f2b5f7 100644 (file)
--- a/net/ethtool/common.h
+++ b/net/ethtool/common.h
@@ -55,5 +55,6 @@ int ethtool_get_module_eeprom_call(struct net_device *dev,
                                   struct ethtool_eeprom *ee, u8 *data);
 
 bool __ethtool_dev_mm_supported(struct net_device *dev);
+bool ethtool_eee_use_linkmodes(const struct ethtool_keee *eee);
 
 #endif /* _ETHTOOL_COMMON_H */

diff --git a/net/ethtool/eee.c b/net/ethtool/eee.c
index ca56f28..db6faa1 100644 (file)
--- a/net/ethtool/eee.c
+++ b/net/ethtool/eee.c
@@ -30,6 +30,7 @@ static int eee_prepare_data(const struct ethnl_req_info *req_base,
 {
        struct eee_reply_data *data = EEE_REPDATA(reply_base);
        struct net_device *dev = reply_base->dev;
+       struct ethtool_keee *eee = &data->eee;
        int ret;
 
        if (!dev->ethtool_ops->get_eee)
@@ -37,9 +38,18 @@ static int eee_prepare_data(const struct ethnl_req_info *req_base,
        ret = ethnl_ops_begin(dev);
        if (ret < 0)
                return ret;
-       ret = dev->ethtool_ops->get_eee(dev, &data->eee);
+       ret = dev->ethtool_ops->get_eee(dev, eee);
        ethnl_ops_complete(dev);
 
+       if (!ret && !ethtool_eee_use_linkmodes(eee)) {
+               ethtool_convert_legacy_u32_to_link_mode(eee->supported,
+                                                       eee->supported_u32);
+               ethtool_convert_legacy_u32_to_link_mode(eee->advertised,
+                                                       eee->advertised_u32);
+               ethtool_convert_legacy_u32_to_link_mode(eee->lp_advertised,
+                                                       eee->lp_advertised_u32);
+       }
+
        return ret;
 }
 
@@ -58,14 +68,16 @@ static int eee_reply_size(const struct ethnl_req_info *req_base,
                     EEE_MODES_COUNT);
 
        /* MODES_OURS */
-       ret = ethnl_bitset32_size(&eee->advertised_u32, &eee->supported_u32,
-                                 EEE_MODES_COUNT, link_mode_names, compact);
+       ret = ethnl_bitset_size(eee->advertised, eee->supported,
+                               __ETHTOOL_LINK_MODE_MASK_NBITS,
+                               link_mode_names, compact);
        if (ret < 0)
                return ret;
        len += ret;
        /* MODES_PEERS */
-       ret = ethnl_bitset32_size(&eee->lp_advertised_u32, NULL,
-                                 EEE_MODES_COUNT, link_mode_names, compact);
+       ret = ethnl_bitset_size(eee->lp_advertised, NULL,
+                               __ETHTOOL_LINK_MODE_MASK_NBITS,
+                               link_mode_names, compact);
        if (ret < 0)
                return ret;
        len += ret;
@@ -87,14 +99,16 @@ static int eee_fill_reply(struct sk_buff *skb,
        const struct ethtool_keee *eee = &data->eee;
        int ret;
 
-       ret = ethnl_put_bitset32(skb, ETHTOOL_A_EEE_MODES_OURS,
-                                &eee->advertised_u32, &eee->supported_u32,
-                                EEE_MODES_COUNT, link_mode_names, compact);
+       ret = ethnl_put_bitset(skb, ETHTOOL_A_EEE_MODES_OURS,
+                              eee->advertised, eee->supported,
+                              __ETHTOOL_LINK_MODE_MASK_NBITS,
+                              link_mode_names, compact);
        if (ret < 0)
                return ret;
-       ret = ethnl_put_bitset32(skb, ETHTOOL_A_EEE_MODES_PEER,
-                                &eee->lp_advertised_u32, NULL, EEE_MODES_COUNT,
-                                link_mode_names, compact);
+       ret = ethnl_put_bitset(skb, ETHTOOL_A_EEE_MODES_PEER,
+                              eee->lp_advertised, NULL,
+                              __ETHTOOL_LINK_MODE_MASK_NBITS,
+                              link_mode_names, compact);
        if (ret < 0)
                return ret;
 
@@ -140,9 +154,16 @@ ethnl_set_eee(struct ethnl_req_info *req_info, struct genl_info *info)
        if (ret < 0)
                return ret;
 
-       ret = ethnl_update_bitset32(&eee.advertised_u32, EEE_MODES_COUNT,
-                                   tb[ETHTOOL_A_EEE_MODES_OURS],
-                                   link_mode_names, info->extack, &mod);
+       if (ethtool_eee_use_linkmodes(&eee)) {
+               ret = ethnl_update_bitset(eee.advertised,
+                                         __ETHTOOL_LINK_MODE_MASK_NBITS,
+                                         tb[ETHTOOL_A_EEE_MODES_OURS],
+                                         link_mode_names, info->extack, &mod);
+       } else {
+               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)
                return ret;
        ethnl_update_bool(&eee.eee_enabled, tb[ETHTOOL_A_EEE_ENABLED], &mod);

diff --git a/net/ethtool/ioctl.c b/net/ethtool/ioctl.c
index 5b2ca72..1763e8b 100644 (file)
--- a/net/ethtool/ioctl.c
+++ b/net/ethtool/ioctl.c
@@ -1520,6 +1520,13 @@ static void eee_to_keee(struct ethtool_keee *keee,
        keee->eee_enabled = eee->eee_enabled;
        keee->tx_lpi_enabled = eee->tx_lpi_enabled;
        keee->tx_lpi_timer = eee->tx_lpi_timer;
+
+       ethtool_convert_legacy_u32_to_link_mode(keee->supported,
+                                               eee->supported);
+       ethtool_convert_legacy_u32_to_link_mode(keee->advertised,
+                                               eee->advertised);
+       ethtool_convert_legacy_u32_to_link_mode(keee->lp_advertised,
+                                               eee->lp_advertised);
 }
 
 static void keee_to_eee(struct ethtool_eee *eee,
@@ -1527,13 +1534,27 @@ static void keee_to_eee(struct ethtool_eee *eee,
 {
        memset(eee, 0, sizeof(*eee));
 
-       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;
        eee->tx_lpi_timer = keee->tx_lpi_timer;
+
+       if (ethtool_eee_use_linkmodes(keee)) {
+               bool overflow;
+
+               overflow = !ethtool_convert_link_mode_to_legacy_u32(&eee->supported,
+                                                                   keee->supported);
+               ethtool_convert_link_mode_to_legacy_u32(&eee->advertised,
+                                                       keee->advertised);
+               ethtool_convert_link_mode_to_legacy_u32(&eee->lp_advertised,
+                                                       keee->lp_advertised);
+               if (overflow)
+                       pr_warn("Ethtool ioctl interface doesn't support passing EEE linkmodes beyond bit 32\n");
+       } else {
+               eee->supported = keee->supported_u32;
+               eee->advertised = keee->advertised_u32;
+               eee->lp_advertised = keee->lp_advertised_u32;
+       }
 }
 
 static int ethtool_get_eee(struct net_device *dev, char __user *useraddr)