net: phylink: add EEE management

Add EEE management to phylink, making use of the phylib implementation.
This will only be used where a MAC driver populates the methods and
capabilities bitfield, otherwise we keep our old behaviour.

Phylink will keep track of the EEE configuration, including the clock
stop abilities at each end of the MAC to PHY link, programming the PHY
appropriately and preserving the LPI configuration should the PHY go
away.

Phylink will call into the MAC driver when LPI needs to be enabled or
disabled, with the requirement that the MAC have LPI disabled prior
to the netdev being brought up (in other words, it will only call
mac_disable_tx_lpi() if it has already called mac_enable_tx_lpi().)

Support for phylink managed EEE is enabled by populating both tx_lpi
MAC operations method pointers, and filling in both LPI interfaces
and capabilities. If the methods are provided but the LPI interfaces
or capabilities remain empty, this indicates to phylink that EEE is
implemented by the driver but the hardware it is driving does not
support EEE, and thus the ethtool set_eee() and get_eee() methods will
return EOPNOTSUPP.

No validation of the LPI timer value is performed by this patch.

For interface modes which do not support LPI, we make no attempt to
manipulate the phylib EEE advertisement, but instead refuse to
activate LPI at the MAC, noting it at debug message level.

We also restrict the advertisement and reported userspace support
linkmode masks according to the lpi_capabilities provided to
phylink by the MAC driver.

Signed-off-by: Russell King (Oracle) <rmk+kernel@armlinux.org.uk>
Reviewed-by: Jacob Keller <jacob.e.keller@intel.com>
Link: https://patch.msgid.link/E1tYADq-0014Pn-J1@rmk-PC.armlinux.org.uk
Signed-off-by: Jakub Kicinski <kuba@kernel.org>

diff --git a/drivers/net/phy/phylink.c b/drivers/net/phy/phylink.c
index 918cb9a919f9a2da8d75df9c640329d9cf7aacef..66eea3f963d36aa4edf084a59f1b868fc155f062 100644 (file)
--- a/drivers/net/phy/phylink.c
+++ b/drivers/net/phy/phylink.c
@@ -60,6 +60,7 @@ struct phylink {
        u8 act_link_an_mode;            /* Active MLO_AN_xxx mode */
        u8 link_port;                   /* The current non-phy ethtool port */
        __ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
+       __ETHTOOL_DECLARE_LINK_MODE_MASK(supported_lpi);
 
        /* The link configuration settings */
        struct phylink_link_state link_config;
@@ -81,12 +82,20 @@ struct phylink {
        unsigned int pcs_state;
 
        bool link_failed;
+       bool mac_supports_eee_ops;
+       bool mac_supports_eee;
+       bool phy_enable_tx_lpi;
+       bool mac_enable_tx_lpi;
+       bool mac_tx_clk_stop;
+       u32 mac_tx_lpi_timer;
 
        struct sfp_bus *sfp_bus;
        bool sfp_may_have_phy;
        DECLARE_PHY_INTERFACE_MASK(sfp_interfaces);
        __ETHTOOL_DECLARE_LINK_MODE_MASK(sfp_support);
        u8 sfp_port;
+
+       struct eee_config eee_cfg;
 };
 
 #define phylink_printk(level, pl, fmt, ...) \
@@ -1584,6 +1593,39 @@ static const char *phylink_pause_to_str(int pause)
        }
 }
 
+static void phylink_deactivate_lpi(struct phylink *pl)
+{
+       if (pl->mac_enable_tx_lpi) {
+               pl->mac_enable_tx_lpi = false;
+
+               phylink_dbg(pl, "disabling LPI\n");
+
+               pl->mac_ops->mac_disable_tx_lpi(pl->config);
+       }
+}
+
+static void phylink_activate_lpi(struct phylink *pl)
+{
+       int err;
+
+       if (!test_bit(pl->cur_interface, pl->config->lpi_interfaces)) {
+               phylink_dbg(pl, "MAC does not support LPI with %s\n",
+                           phy_modes(pl->cur_interface));
+               return;
+       }
+
+       phylink_dbg(pl, "LPI timer %uus, tx clock stop %u\n",
+                   pl->mac_tx_lpi_timer, pl->mac_tx_clk_stop);
+
+       err = pl->mac_ops->mac_enable_tx_lpi(pl->config, pl->mac_tx_lpi_timer,
+                                            pl->mac_tx_clk_stop);
+       if (!err)
+               pl->mac_enable_tx_lpi = true;
+       else
+               phylink_err(pl, "%ps() failed: %pe\n",
+                           pl->mac_ops->mac_enable_tx_lpi, ERR_PTR(err));
+}
+
 static void phylink_link_up(struct phylink *pl,
                            struct phylink_link_state link_state)
 {
@@ -1630,6 +1672,9 @@ static void phylink_link_up(struct phylink *pl,
                                 pl->cur_interface, speed, duplex,
                                 !!(link_state.pause & MLO_PAUSE_TX), rx_pause);
 
+       if (pl->mac_supports_eee && pl->phy_enable_tx_lpi)
+               phylink_activate_lpi(pl);
+
        if (ndev)
                netif_carrier_on(ndev);
 
@@ -1646,6 +1691,9 @@ static void phylink_link_down(struct phylink *pl)
 
        if (ndev)
                netif_carrier_off(ndev);
+
+       phylink_deactivate_lpi(pl);
+
        pl->mac_ops->mac_link_down(pl->config, pl->act_link_an_mode,
                                   pl->cur_interface);
        phylink_info(pl, "Link is Down\n");
@@ -1909,6 +1957,17 @@ struct phylink *phylink_create(struct phylink_config *config,
                return ERR_PTR(-EINVAL);
        }
 
+       pl->mac_supports_eee_ops = mac_ops->mac_disable_tx_lpi &&
+                                  mac_ops->mac_enable_tx_lpi;
+       pl->mac_supports_eee = pl->mac_supports_eee_ops &&
+                              pl->config->lpi_capabilities &&
+                              !phy_interface_empty(pl->config->lpi_interfaces);
+
+       /* Set the default EEE configuration */
+       pl->eee_cfg.eee_enabled = pl->config->eee_enabled_default;
+       pl->eee_cfg.tx_lpi_enabled = pl->eee_cfg.eee_enabled;
+       pl->eee_cfg.tx_lpi_timer = pl->config->lpi_timer_default;
+
        pl->phy_state.interface = iface;
        pl->link_interface = iface;
        if (iface == PHY_INTERFACE_MODE_MOCA)
@@ -2013,16 +2072,22 @@ static void phylink_phy_change(struct phy_device *phydev, bool up)
        pl->phy_state.link = up;
        if (!up)
                pl->link_failed = true;
+
+       /* Get the LPI state from phylib */
+       pl->phy_enable_tx_lpi = phydev->enable_tx_lpi;
+       pl->mac_tx_lpi_timer = phydev->eee_cfg.tx_lpi_timer;
        mutex_unlock(&pl->state_mutex);
 
        phylink_run_resolve(pl);
 
-       phylink_dbg(pl, "phy link %s %s/%s/%s/%s/%s\n", up ? "up" : "down",
+       phylink_dbg(pl, "phy link %s %s/%s/%s/%s/%s/%slpi\n",
+                   up ? "up" : "down",
                    phy_modes(phydev->interface),
                    phy_speed_to_str(phydev->speed),
                    phy_duplex_to_str(phydev->duplex),
                    phy_rate_matching_to_str(phydev->rate_matching),
-                   phylink_pause_to_str(pl->phy_state.pause));
+                   phylink_pause_to_str(pl->phy_state.pause),
+                   phydev->enable_tx_lpi ? "" : "no");
 }
 
 static int phylink_validate_phy(struct phylink *pl, struct phy_device *phy,
@@ -2152,6 +2217,36 @@ static int phylink_bringup_phy(struct phylink *pl, struct phy_device *phy,
 
        /* Restrict the phy advertisement according to the MAC support. */
        linkmode_copy(phy->advertising, config.advertising);
+
+       /* If the MAC supports phylink managed EEE, restrict the EEE
+        * advertisement according to the MAC's LPI capabilities.
+        */
+       if (pl->mac_supports_eee) {
+               /* If EEE is enabled, then we need to call phy_support_eee()
+                * to ensure that the advertising mask is appropriately set.
+                * This also enables EEE at the PHY.
+                */
+               if (pl->eee_cfg.eee_enabled)
+                       phy_support_eee(phy);
+
+               phy->eee_cfg.tx_lpi_enabled = pl->eee_cfg.tx_lpi_enabled;
+               phy->eee_cfg.tx_lpi_timer = pl->eee_cfg.tx_lpi_timer;
+
+               /* Convert the MAC's LPI capabilities to linkmodes */
+               linkmode_zero(pl->supported_lpi);
+               phylink_caps_to_linkmodes(pl->supported_lpi,
+                                         pl->config->lpi_capabilities);
+
+               /* Restrict the PHYs EEE support/advertisement to the modes
+                * that the MAC supports.
+                */
+               linkmode_and(phy->advertising_eee, phy->advertising_eee,
+                            pl->supported_lpi);
+       } else if (pl->mac_supports_eee_ops) {
+               /* MAC supports phylink EEE, but wants EEE always disabled. */
+               phy_disable_eee(phy);
+       }
+
        mutex_unlock(&pl->state_mutex);
        mutex_unlock(&phy->lock);
 
@@ -2167,7 +2262,13 @@ static int phylink_bringup_phy(struct phylink *pl, struct phy_device *phy,
        if (pl->config->mac_managed_pm)
                phy->mac_managed_pm = true;
 
-       return 0;
+       /* Allow the MAC to stop its clock if the PHY has the capability */
+       pl->mac_tx_clk_stop = phy_eee_tx_clock_stop_capable(phy) > 0;
+
+       /* Explicitly configure whether the PHY is allowed to stop it's
+        * receive clock.
+        */
+       return phy_eee_rx_clock_stop(phy, pl->config->eee_rx_clk_stop_enable);
 }
 
 static int phylink_attach_phy(struct phylink *pl, struct phy_device *phy,
@@ -2324,6 +2425,8 @@ void phylink_disconnect_phy(struct phylink *pl)
                mutex_lock(&phy->lock);
                mutex_lock(&pl->state_mutex);
                pl->phydev = NULL;
+               pl->phy_enable_tx_lpi = false;
+               pl->mac_tx_clk_stop = false;
                mutex_unlock(&pl->state_mutex);
                mutex_unlock(&phy->lock);
                flush_work(&pl->resolve);
@@ -3078,8 +3181,16 @@ int phylink_ethtool_get_eee(struct phylink *pl, struct ethtool_keee *eee)
 
        ASSERT_RTNL();
 
-       if (pl->phydev)
+       if (pl->mac_supports_eee_ops && !pl->mac_supports_eee)
+               return ret;
+
+       if (pl->phydev) {
                ret = phy_ethtool_get_eee(pl->phydev, eee);
+               /* Restrict supported linkmode mask */
+               if (ret == 0 && pl->mac_supports_eee_ops)
+                       linkmode_and(eee->supported, eee->supported,
+                                    pl->supported_lpi);
+       }
 
        return ret;
 }
@@ -3092,12 +3203,29 @@ EXPORT_SYMBOL_GPL(phylink_ethtool_get_eee);
  */
 int phylink_ethtool_set_eee(struct phylink *pl, struct ethtool_keee *eee)
 {
+       bool mac_eee = pl->mac_supports_eee;
        int ret = -EOPNOTSUPP;
 
        ASSERT_RTNL();
 
-       if (pl->phydev)
+       phylink_dbg(pl, "mac %s phylink EEE%s, adv %*pbl, LPI%s timer %uus\n",
+                   mac_eee ? "supports" : "does not support",
+                   eee->eee_enabled ? ", enabled" : "",
+                   __ETHTOOL_LINK_MODE_MASK_NBITS, eee->advertised,
+                   eee->tx_lpi_enabled ? " enabled" : "", eee->tx_lpi_timer);
+
+       if (pl->mac_supports_eee_ops && !mac_eee)
+               return ret;
+
+       if (pl->phydev) {
+               /* Restrict advertisement mask */
+               if (pl->mac_supports_eee_ops)
+                       linkmode_and(eee->advertised, eee->advertised,
+                                    pl->supported_lpi);
                ret = phy_ethtool_set_eee(pl->phydev, eee);
+               if (ret == 0)
+                       eee_to_eeecfg(&pl->eee_cfg, eee);
+       }
 
        return ret;
 }

diff --git a/include/linux/phylink.h b/include/linux/phylink.h
index f19b7108c8408c4405885f28514405b62ff7f646..898b00451bbfd294ca818cd52e7b1b0f10a8062a 100644 (file)
--- a/include/linux/phylink.h
+++ b/include/linux/phylink.h
@@ -5,6 +5,8 @@
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
 
+#include <net/eee.h>
+
 struct device_node;
 struct ethtool_cmd;
 struct fwnode_handle;
@@ -143,11 +145,17 @@ enum phylink_op_type {
  *                    possible and avoid stopping it during suspend events.
  * @default_an_inband: if true, defaults to MLO_AN_INBAND rather than
  *                    MLO_AN_PHY. A fixed-link specification will override.
+ * @eee_rx_clk_stop_enable: if true, PHY can stop the receive clock during LPI
  * @get_fixed_state: callback to execute to determine the fixed link state,
  *                  if MAC link is at %MLO_AN_FIXED mode.
  * @supported_interfaces: bitmap describing which PHY_INTERFACE_MODE_xxx
  *                        are supported by the MAC/PCS.
+ * @lpi_interfaces: bitmap describing which PHY interface modes can support
+ *                 LPI signalling.
  * @mac_capabilities: MAC pause/speed/duplex capabilities.
+ * @lpi_capabilities: MAC speeds which can support LPI signalling
+ * @lpi_timer_default: Default EEE LPI timer setting.
+ * @eee_enabled_default: If set, EEE will be enabled by phylink at creation time
  */
 struct phylink_config {
        struct device *dev;
@@ -156,10 +164,15 @@ struct phylink_config {
        bool mac_managed_pm;
        bool mac_requires_rxc;
        bool default_an_inband;
+       bool eee_rx_clk_stop_enable;
        void (*get_fixed_state)(struct phylink_config *config,
                                struct phylink_link_state *state);
        DECLARE_PHY_INTERFACE_MASK(supported_interfaces);
+       DECLARE_PHY_INTERFACE_MASK(lpi_interfaces);
        unsigned long mac_capabilities;
+       unsigned long lpi_capabilities;
+       u32 lpi_timer_default;
+       bool eee_enabled_default;
 };
 
 void phylink_limit_mac_speed(struct phylink_config *config, u32 max_speed);
@@ -173,6 +186,8 @@ void phylink_limit_mac_speed(struct phylink_config *config, u32 max_speed);
  * @mac_finish: finish a major reconfiguration of the interface.
  * @mac_link_down: take the link down.
  * @mac_link_up: allow the link to come up.
+ * @mac_disable_tx_lpi: disable LPI.
+ * @mac_enable_tx_lpi: enable and configure LPI.
  *
  * The individual methods are described more fully below.
  */
@@ -193,6 +208,9 @@ struct phylink_mac_ops {
                            struct phy_device *phy, unsigned int mode,
                            phy_interface_t interface, int speed, int duplex,
                            bool tx_pause, bool rx_pause);
+       void (*mac_disable_tx_lpi)(struct phylink_config *config);
+       int (*mac_enable_tx_lpi)(struct phylink_config *config, u32 timer,
+                                bool tx_clk_stop);
 };
 
 #if 0 /* For kernel-doc purposes only. */
@@ -387,6 +405,33 @@ void mac_link_down(struct phylink_config *config, unsigned int mode,
 void mac_link_up(struct phylink_config *config, struct phy_device *phy,
                 unsigned int mode, phy_interface_t interface,
                 int speed, int duplex, bool tx_pause, bool rx_pause);
+
+/**
+ * mac_disable_tx_lpi() - disable LPI generation at the MAC
+ * @config: a pointer to a &struct phylink_config.
+ *
+ * Disable generation of LPI at the MAC, effectively preventing the MAC
+ * from indicating that it is idle.
+ */
+void mac_disable_tx_lpi(struct phylink_config *config);
+
+/**
+ * mac_enable_tx_lpi() - configure and enable LPI generation at the MAC
+ * @config: a pointer to a &struct phylink_config.
+ * @timer: LPI timeout in microseconds.
+ * @tx_clk_stop: allow xMII transmit clock to be stopped during LPI
+ *
+ * Configure the LPI timeout accordingly. This will only be called when
+ * the link is already up, to cater for situations where the hardware
+ * needs to be programmed according to the link speed.
+ *
+ * Enable LPI generation at the MAC, and configure whether the xMII transmit
+ * clock may be stopped.
+ *
+ * Returns: 0 on success. Please consult with rmk before returning an error.
+ */
+int mac_enable_tx_lpi(struct phylink_config *config, u32 timer,
+                     bool tx_clk_stop);
 #endif
 
 struct phylink_pcs_ops;