mvebu: add linux 4.9 support

Signed-off-by: Felix Fietkau <nbd@nbd.name>
Signed-off-by: Jonas Gorski <jonas.gorski@gmail.com>

1 files changed, 1120 insertions, 0 deletions

diff --git a/target/linux/mvebu/patches-4.9/415-phylink-add-phylink-infrastructure.patch b/target/linux/mvebu/patches-4.9/415-phylink-add-phylink-infrastructure.patch
new file mode 100644
index 0000000000..87c0daf178
--- /dev/null
+++ b/target/linux/mvebu/patches-4.9/415-phylink-add-phylink-infrastructure.patch
@@ -0,0 +1,1120 @@
+From: Russell King <rmk+kernel@arm.linux.org.uk>
+Date: Tue, 22 Sep 2015 20:52:18 +0100
+Subject: [PATCH] phylink: add phylink infrastructure
+
+The link between the ethernet MAC and its PHY has become more complex
+as the interface evolves.  This is especially true with serdes links,
+where the part of the PHY is effectively integrated into the MAC.
+
+Serdes links can be connected to a variety of devices, including SFF
+modules soldered down onto the board with the MAC, a SFP cage with
+a hotpluggable SFP module which may contain a PHY or directly modulate
+the serdes signals onto optical media with or without a PHY, or even
+a classical PHY connection.
+
+Moreover, the negotiation information on serdes links comes in two
+varieties - SGMII mode, where the PHY provides its speed/duplex/flow
+control information to the MAC, and 1000base-X mode where both ends
+exchange their abilities and each resolve the link capabilities.
+
+This means we need a more flexible means to support these arrangements,
+particularly with the hotpluggable nature of SFP, where the PHY can
+be attached or detached after the network device has been brought up.
+
+Ethtool information can come from multiple sources:
+- we may have a PHY operating in either SGMII or 1000base-X mode, in
+  which case we take ethtool/mii data directly from the PHY.
+- we may have a optical SFP module without a PHY, with the MAC
+  operating in 1000base-X mode - the ethtool/mii data needs to come
+  from the MAC.
+- we may have a copper SFP module with a PHY whic can't be accessed,
+  which means we need to take ethtool/mii data from the MAC.
+
+Phylink aims to solve this by providing an intermediary between the
+MAC and PHY, providing a safe way for PHYs to be hotplugged, and
+allowing a SFP driver to reconfigure the serdes connection.
+
+Phylink also takes over support of fixed link connections, where the
+speed/duplex/flow control are fixed, but link status may be controlled
+by a GPIO signal.  By avoiding the fixed-phy implementation, phylink
+can provide a faster response to link events: fixed-phy has to wait for
+phylib to operate its state machine, which can take several seconds.
+In comparison, phylink takes milliseconds.
+
+Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
+
+- remove sync status
+- rework supported and advertisment handling
+- add 1000base-x speed for fixed links
+- use functionality exported from phy-core, reworking
+  __phylink_ethtool_ksettings_set for it
+---
+ create mode 100644 drivers/net/phy/phylink.c
+ create mode 100644 include/linux/phylink.h
+
+--- a/drivers/net/phy/Kconfig
++++ b/drivers/net/phy/Kconfig
+@@ -10,6 +10,16 @@ menuconfig PHYLIB
+ 	  devices.  This option provides infrastructure for
+ 	  managing PHY devices.
+ 
++config PHYLINK
++	tristate
++	depends on NETDEVICES
++	select PHYLIB
++	select SWPHY
++	help
++	  PHYlink models the link between the PHY and MAC, allowing fixed
++	  configuration links, PHYs, and Serdes links with MAC level
++	  autonegotiation modes.
++
+ if PHYLIB
+ 
+ config SWPHY
+--- a/drivers/net/phy/Makefile
++++ b/drivers/net/phy/Makefile
+@@ -6,6 +6,7 @@ libphy-$(CONFIG_SWPHY)		+= swphy.o
+ 
+ obj-$(CONFIG_MDIO_BOARDINFO)	+= mdio-boardinfo.o
+ 
++obj-$(CONFIG_PHYLINK)		+= phylink.o
+ obj-$(CONFIG_PHYLIB)		+= libphy.o
+ 
+ obj-$(CONFIG_SWCONFIG)		+= swconfig.o
+--- a/drivers/net/phy/phy_device.c
++++ b/drivers/net/phy/phy_device.c
+@@ -1003,6 +1003,7 @@ void phy_detach(struct phy_device *phyde
+ 	phydev->attached_dev->phydev = NULL;
+ 	phydev->attached_dev = NULL;
+ 	phy_suspend(phydev);
++	phydev->phylink = NULL;
+ 
+ 	/* If the device had no specific driver before (i.e. - it
+ 	 * was using the generic driver), we unbind the device
+--- /dev/null
++++ b/drivers/net/phy/phylink.c
+@@ -0,0 +1,903 @@
++/*
++ * phylink models the MAC to optional PHY connection, supporting
++ * technologies such as SFP cages where the PHY is hot-pluggable.
++ *
++ * Copyright (C) 2015 Russell King
++ *
++ * This program is free software; you can redistribute it and/or modify
++ * it under the terms of the GNU General Public License version 2 as
++ * published by the Free Software Foundation.
++ */
++#include <linux/ethtool.h>
++#include <linux/export.h>
++#include <linux/gpio/consumer.h>
++#include <linux/netdevice.h>
++#include <linux/of.h>
++#include <linux/of_mdio.h>
++#include <linux/phy.h>
++#include <linux/phy_fixed.h>
++#include <linux/phylink.h>
++#include <linux/spinlock.h>
++#include <linux/workqueue.h>
++
++#include "swphy.h"
++
++#define SUPPORTED_INTERFACES \
++	(SUPPORTED_TP | SUPPORTED_MII | SUPPORTED_FIBRE | \
++	 SUPPORTED_BNC | SUPPORTED_AUI | SUPPORTED_Backplane)
++#define ADVERTISED_INTERFACES \
++	(ADVERTISED_TP | ADVERTISED_MII | ADVERTISED_FIBRE | \
++	 ADVERTISED_BNC | ADVERTISED_AUI | ADVERTISED_Backplane)
++
++enum {
++	PHYLINK_DISABLE_STOPPED,
++};
++
++struct phylink {
++	struct net_device *netdev;
++	const struct phylink_mac_ops *ops;
++	struct mutex config_mutex;
++
++	unsigned long phylink_disable_state; /* bitmask of disables */
++	struct phy_device *phydev;
++	phy_interface_t link_interface;	/* PHY_INTERFACE_xxx */
++	u8 link_an_mode;		/* MLO_AN_xxx */
++	u8 link_port;			/* The current non-phy ethtool port */
++	/* ethtool supported mask for ports */
++	__ETHTOOL_DECLARE_LINK_MODE_MASK(supported);
++
++	/* The link configuration settings */
++	struct phylink_link_state link_config;
++	struct gpio_desc *link_gpio;
++
++	struct mutex state_mutex;	/* may be taken within config_mutex */
++	struct phylink_link_state phy_state;
++	struct work_struct resolve;
++
++	const struct phylink_module_ops *module_ops;
++	void *module_data;
++};
++
++static inline void linkmode_zero(unsigned long *dst)
++{
++	bitmap_zero(dst, __ETHTOOL_LINK_MODE_MASK_NBITS);
++}
++
++static inline void linkmode_copy(unsigned long *dst, const unsigned long *src)
++{
++	bitmap_copy(dst, src, __ETHTOOL_LINK_MODE_MASK_NBITS);
++}
++
++static inline void linkmode_and(unsigned long *dst, const unsigned long *a,
++				const unsigned long *b)
++{
++	bitmap_and(dst, a, b, __ETHTOOL_LINK_MODE_MASK_NBITS);
++}
++
++static inline void linkmode_or(unsigned long *dst, const unsigned long *a,
++				const unsigned long *b)
++{
++	bitmap_or(dst, a, b, __ETHTOOL_LINK_MODE_MASK_NBITS);
++}
++
++static inline bool linkmode_empty(const unsigned long *src)
++{
++	return bitmap_empty(src, __ETHTOOL_LINK_MODE_MASK_NBITS);
++}
++
++static void phylink_set_port_bits(unsigned long *bits)
++{
++	__set_bit(ETHTOOL_LINK_MODE_TP_BIT, bits);
++	__set_bit(ETHTOOL_LINK_MODE_AUI_BIT, bits);
++	__set_bit(ETHTOOL_LINK_MODE_MII_BIT, bits);
++	__set_bit(ETHTOOL_LINK_MODE_FIBRE_BIT, bits);
++	__set_bit(ETHTOOL_LINK_MODE_BNC_BIT, bits);
++	__set_bit(ETHTOOL_LINK_MODE_Backplane_BIT, bits);
++}
++
++static const char *phylink_an_mode_str(unsigned int mode)
++{
++	static const char *modestr[] = {
++		[MLO_AN_PHY] = "phy",
++		[MLO_AN_FIXED] = "fixed",
++		[MLO_AN_SGMII] = "SGMII",
++		[MLO_AN_8023Z] = "802.3z",
++	};
++
++	return mode < ARRAY_SIZE(modestr) ? modestr[mode] : "unknown";
++}
++
++static int phylink_parse_fixedlink(struct phylink *pl, struct device_node *np)
++{
++	__ETHTOOL_DECLARE_LINK_MODE_MASK(mask) = { 0, };
++	struct device_node *fixed_node;
++	const struct phy_setting *s;
++	struct gpio_desc *desc;
++	const __be32 *fixed_prop;
++	u32 speed;
++	int ret, len;
++
++	fixed_node = of_get_child_by_name(np, "fixed-link");
++	if (fixed_node) {
++		ret = of_property_read_u32(fixed_node, "speed", &speed);
++
++		pl->link_config.speed = speed;
++		pl->link_config.duplex = DUPLEX_HALF;
++
++		if (of_property_read_bool(fixed_node, "full-duplex"))
++			pl->link_config.duplex = DUPLEX_FULL;
++		if (of_property_read_bool(fixed_node, "pause"))
++			pl->link_config.pause |= MLO_PAUSE_SYM;
++		if (of_property_read_bool(fixed_node, "asym-pause"))
++			pl->link_config.pause |= MLO_PAUSE_ASYM;
++
++		if (ret == 0) {
++			desc = fwnode_get_named_gpiod(&fixed_node->fwnode,
++						      "link-gpios");
++
++			if (!IS_ERR(desc))
++				pl->link_gpio = desc;
++			else if (desc == ERR_PTR(-EPROBE_DEFER))
++				ret = -EPROBE_DEFER;
++		}
++		of_node_put(fixed_node);
++
++		if (ret)
++			return ret;
++	} else {
++		fixed_prop = of_get_property(np, "fixed-link", &len);
++		if (!fixed_prop) {
++			netdev_err(pl->netdev, "broken fixed-link?\n");
++			return -EINVAL;
++		}
++		if (len == 5 * sizeof(*fixed_prop)) {
++			pl->link_config.duplex = be32_to_cpu(fixed_prop[1]) ?
++						DUPLEX_FULL : DUPLEX_HALF;
++			pl->link_config.speed = be32_to_cpu(fixed_prop[2]);
++			if (be32_to_cpu(fixed_prop[3]))
++				pl->link_config.pause |= MLO_PAUSE_SYM;
++			if (be32_to_cpu(fixed_prop[4]))
++				pl->link_config.pause |= MLO_PAUSE_ASYM;
++		}
++	}
++
++	bitmap_fill(mask, __ETHTOOL_LINK_MODE_MASK_NBITS);
++	pl->ops->validate_support(pl->netdev, MLO_AN_FIXED, mask);
++
++	pl->link_config.link = 1;
++	pl->link_config.an_complete = 1;
++
++	if (pl->link_config.speed > SPEED_1000 &&
++	    pl->link_config.duplex != DUPLEX_FULL)
++		netdev_warn(pl->netdev, "fixed link specifies half duplex for %dMbps link?\n",
++			    pl->link_config.speed);
++
++	s = phy_lookup_setting(pl->link_config.speed, pl->link_config.duplex,
++				mask, __ETHTOOL_LINK_MODE_MASK_NBITS, true);
++	if (s) {
++		__set_bit(s->bit, pl->supported);
++	} else {
++		netdev_warn(pl->netdev, "fixed link %s duplex %dMbps not recognised\n",
++			    pl->link_config.duplex == DUPLEX_FULL ? "full" : "half",
++			    pl->link_config.speed);
++	}
++	return 0;
++}
++
++static int phylink_parse_mode(struct phylink *pl, struct device_node *np)
++{
++	struct device_node *dn;
++	const char *managed;
++
++	dn = of_get_child_by_name(np, "fixed-link");
++	if (dn || of_find_property(np, "fixed-link", NULL))
++		pl->link_an_mode = MLO_AN_FIXED;
++	of_node_put(dn);
++
++	if (of_property_read_string(np, "managed", &managed) == 0 &&
++	    strcmp(managed, "in-band-status") == 0) {
++		if (pl->link_an_mode == MLO_AN_FIXED) {
++			netdev_err(pl->netdev,
++				   "can't use both fixed-link and in-band-status\n");
++			return -EINVAL;
++		}
++		phylink_set(pl->supported, 10baseT_Half);
++		phylink_set(pl->supported, 10baseT_Full);
++		phylink_set(pl->supported, 100baseT_Half);
++		phylink_set(pl->supported, 100baseT_Full);
++		phylink_set(pl->supported, 1000baseT_Half);
++		phylink_set(pl->supported, 1000baseT_Full);
++		phylink_set(pl->supported, Asym_Pause);
++		phylink_set(pl->supported, Pause);
++		pl->link_an_mode = MLO_AN_SGMII;
++		pl->link_config.an_enabled = true;
++		pl->ops->validate_support(pl->netdev, pl->link_an_mode,
++					  pl->supported);
++	}
++
++	return 0;
++}
++
++
++static void phylink_init_advert(struct phylink *pl, unsigned int mode,
++				const unsigned long *supported,
++				unsigned long *advertising)
++{
++	linkmode_copy(advertising, supported);
++	if (pl->ops->validate_advert)
++		pl->ops->validate_advert(pl->netdev, mode, supported,
++					 advertising);
++}
++
++static void phylink_mac_config(struct phylink *pl,
++			       const struct phylink_link_state *state)
++{
++	netdev_dbg(pl->netdev,
++		   "%s: mode=%s/%s/%s adv=%*pb pause=%02x link=%u an=%u\n",
++		   __func__, phylink_an_mode_str(pl->link_an_mode),
++		   phy_speed_to_str(state->speed),
++		   phy_duplex_to_str(state->duplex),
++		   __ETHTOOL_LINK_MODE_MASK_NBITS, state->advertising,
++		   state->pause, state->link, state->an_enabled);
++
++	pl->ops->mac_config(pl->netdev, pl->link_an_mode, state);
++}
++
++static void phylink_mac_an_restart(struct phylink *pl)
++{
++	if (pl->link_config.an_enabled)
++		pl->ops->mac_an_restart(pl->netdev, pl->link_an_mode);
++}
++
++static int phylink_get_mac_state(struct phylink *pl, struct phylink_link_state *state)
++{
++	struct net_device *ndev = pl->netdev;
++
++	linkmode_copy(state->advertising, pl->link_config.advertising);
++	linkmode_zero(state->lp_advertising);
++	state->an_enabled = pl->link_config.an_enabled;
++	state->link = 1;
++
++	return pl->ops->mac_link_state(ndev, state);
++}
++
++/* The fixed state is... fixed except for the link state,
++ * which may be determined by a GPIO.
++ */
++static void phylink_get_fixed_state(struct phylink *pl, struct phylink_link_state *state)
++{
++	*state = pl->link_config;
++	if (pl->link_gpio)
++		state->link = !!gpiod_get_value(pl->link_gpio);
++}
++
++static void phylink_resolve(struct work_struct *w)
++{
++	struct phylink *pl = container_of(w, struct phylink, resolve);
++	struct phylink_link_state link_state;
++	struct net_device *ndev = pl->netdev;
++
++	mutex_lock(&pl->state_mutex);
++	if (pl->phylink_disable_state) {
++		link_state.link = false;
++	} else {
++		switch (pl->link_an_mode) {
++		case MLO_AN_PHY:
++			link_state = pl->phy_state;
++			break;
++
++		case MLO_AN_FIXED:
++			phylink_get_fixed_state(pl, &link_state);
++			break;
++
++		case MLO_AN_SGMII:
++			phylink_get_mac_state(pl, &link_state);
++			if (pl->phydev)
++				link_state.link = link_state.link &&
++						  pl->phy_state.link;
++			break;
++
++		case MLO_AN_8023Z:
++			phylink_get_mac_state(pl, &link_state);
++			break;
++		}
++	}
++
++	if (link_state.link != netif_carrier_ok(ndev)) {
++		if (!link_state.link) {
++			netif_carrier_off(ndev);
++			pl->ops->mac_link_down(ndev, pl->link_an_mode);
++			netdev_info(ndev, "Link is Down\n");
++		} else {
++			/* If we have a PHY, we need the MAC updated with
++			 * the current link parameters (eg, in SGMII mode,
++			 * with flow control status.)
++			 */
++			if (pl->phydev)
++				phylink_mac_config(pl, &link_state);
++
++			pl->ops->mac_link_up(ndev, pl->link_an_mode);
++
++			netif_carrier_on(ndev);
++
++			netdev_info(ndev,
++				    "Link is Up - %s/%s - flow control %s\n",
++				    phy_speed_to_str(link_state.speed),
++				    phy_duplex_to_str(link_state.duplex),
++				    link_state.pause ? "rx/tx" : "off");
++		}
++	}
++	mutex_unlock(&pl->state_mutex);
++}
++
++static void phylink_run_resolve(struct phylink *pl)
++{
++	if (!pl->phylink_disable_state)
++		queue_work(system_power_efficient_wq, &pl->resolve);
++}
++
++struct phylink *phylink_create(struct net_device *ndev, struct device_node *np,
++	phy_interface_t iface, const struct phylink_mac_ops *ops)
++{
++	struct phylink *pl;
++	int ret;
++
++	pl = kzalloc(sizeof(*pl), GFP_KERNEL);
++	if (!pl)
++		return ERR_PTR(-ENOMEM);
++
++	mutex_init(&pl->state_mutex);
++	mutex_init(&pl->config_mutex);
++	INIT_WORK(&pl->resolve, phylink_resolve);
++	pl->netdev = ndev;
++	pl->link_interface = iface;
++	pl->link_port = PORT_MII;
++	pl->link_config.speed = SPEED_UNKNOWN;
++	pl->link_config.duplex = DUPLEX_UNKNOWN;
++	pl->ops = ops;
++	__set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state);
++
++	ret = phylink_parse_mode(pl, np);
++	if (ret < 0) {
++		kfree(pl);
++		return ERR_PTR(ret);
++	}
++
++	if (pl->link_an_mode == MLO_AN_FIXED) {
++		ret = phylink_parse_fixedlink(pl, np);
++		if (ret < 0) {
++			kfree(pl);
++			return ERR_PTR(ret);
++		}
++	}
++
++	phylink_set(pl->supported, MII);
++	phylink_init_advert(pl, pl->link_an_mode, pl->supported,
++			    pl->link_config.advertising);
++
++	return pl;
++}
++EXPORT_SYMBOL_GPL(phylink_create);
++
++void phylink_destroy(struct phylink *pl)
++{
++	cancel_work_sync(&pl->resolve);
++	kfree(pl);
++}
++EXPORT_SYMBOL_GPL(phylink_destroy);
++
++void phylink_phy_change(struct phy_device *phydev, bool up, bool do_carrier)
++{
++	struct phylink *pl = phydev->phylink;
++
++	mutex_lock(&pl->state_mutex);
++	pl->phy_state.speed = phydev->speed;
++	pl->phy_state.duplex = phydev->duplex;
++	pl->phy_state.pause = MLO_PAUSE_NONE;
++	if (phydev->pause)
++		pl->phy_state.pause |= MLO_PAUSE_SYM;
++	if (phydev->asym_pause)
++		pl->phy_state.pause |= MLO_PAUSE_ASYM;
++	pl->phy_state.link = up;
++	mutex_unlock(&pl->state_mutex);
++
++	phylink_run_resolve(pl);
++
++	netdev_dbg(pl->netdev, "phy link %s %s/%s\n", up ? "up" : "down",
++		   phy_speed_to_str(phydev->speed),
++		   phy_duplex_to_str(phydev->duplex));
++}
++
++static int phylink_empty_linkmode(const unsigned long *linkmode)
++{
++	__ETHTOOL_DECLARE_LINK_MODE_MASK(tmp) = { 0, };
++
++	phylink_set_port_bits(tmp);
++	phylink_set(tmp, Autoneg);
++	phylink_set(tmp, Pause);
++	phylink_set(tmp, Asym_Pause);
++
++	bitmap_andnot(tmp, linkmode, tmp, __ETHTOOL_LINK_MODE_MASK_NBITS);
++
++	return linkmode_empty(tmp);
++}
++
++static int phylink_validate_support(struct phylink *pl, int mode,
++				    unsigned long *mask)
++{
++	pl->ops->validate_support(pl->netdev, mode, mask);
++
++	return phylink_empty_linkmode(mask) ? -EINVAL : 0;
++}
++
++static int phylink_bringup_phy(struct phylink *pl, struct phy_device *phy)
++{
++	__ETHTOOL_DECLARE_LINK_MODE_MASK(mask);
++	u32 advertising;
++	int ret;
++
++	ethtool_convert_legacy_u32_to_link_mode(mask, phy->supported);
++	ret = phylink_validate_support(pl, pl->link_an_mode, mask);
++	if (ret)
++		return ret;
++
++	mutex_lock(&pl->config_mutex);
++	phy->phylink = pl;
++	phy->phy_link_change = phylink_phy_change;
++
++	netdev_info(pl->netdev,
++		    "PHY [%s] driver [%s]\n", dev_name(&phy->mdio.dev),
++		    phy->drv->name);
++
++	mutex_lock(&pl->state_mutex);
++	pl->phydev = phy;
++	linkmode_copy(pl->supported, mask);
++
++	/* Restrict the phy advertisment according to the MAC support. */
++	ethtool_convert_link_mode_to_legacy_u32(&advertising, mask);
++	phy->advertising &= ADVERTISED_INTERFACES | advertising;
++	ethtool_convert_legacy_u32_to_link_mode(pl->link_config.advertising,
++						phy->advertising);
++	mutex_unlock(&pl->state_mutex);
++
++	netdev_dbg(pl->netdev,
++		   "phy: setting supported %*pb advertising 0x%08x\n",
++		   __ETHTOOL_LINK_MODE_MASK_NBITS, pl->supported,
++		   phy->advertising);
++
++	phy_start_machine(phy);
++	if (phy->irq > 0)
++		phy_start_interrupts(phy);
++
++	mutex_unlock(&pl->config_mutex);
++
++	return 0;
++}
++
++int phylink_connect_phy(struct phylink *pl, struct phy_device *phy)
++{
++	int ret;
++
++	ret = phy_attach_direct(pl->netdev, phy, 0, pl->link_interface);
++	if (ret)
++		return ret;
++
++	ret = phylink_bringup_phy(pl, phy);
++	if (ret)
++		phy_detach(phy);
++
++	return ret;
++}
++EXPORT_SYMBOL_GPL(phylink_connect_phy);
++
++int phylink_of_phy_connect(struct phylink *pl, struct device_node *dn)
++{
++	struct device_node *phy_node;
++	struct phy_device *phy_dev;
++	int ret;
++
++	/* Fixed links are handled without needing a PHY */
++	if (pl->link_an_mode == MLO_AN_FIXED)
++		return 0;
++
++	phy_node = of_parse_phandle(dn, "phy-handle", 0);
++	if (!phy_node)
++		phy_node = of_parse_phandle(dn, "phy", 0);
++	if (!phy_node)
++		phy_node = of_parse_phandle(dn, "phy-device", 0);
++
++	if (!phy_node) {
++		if (pl->link_an_mode == MLO_AN_PHY) {
++			netdev_err(pl->netdev, "unable to find PHY node\n");
++			return -ENODEV;
++		}
++		return 0;
++	}
++
++	phy_dev = of_phy_attach(pl->netdev, phy_node, 0, pl->link_interface);
++	/* We're done with the phy_node handle */
++	of_node_put(phy_node);
++
++	if (!phy_dev)
++		return -ENODEV;
++
++	ret = phylink_bringup_phy(pl, phy_dev);
++	if (ret)
++		phy_detach(phy_dev);
++
++	return ret;
++}
++EXPORT_SYMBOL_GPL(phylink_of_phy_connect);
++
++void phylink_disconnect_phy(struct phylink *pl)
++{
++	struct phy_device *phy;
++
++	mutex_lock(&pl->config_mutex);
++	phy = pl->phydev;
++
++	mutex_lock(&pl->state_mutex);
++	pl->phydev = NULL;
++	mutex_unlock(&pl->state_mutex);
++	flush_work(&pl->resolve);
++
++	if (phy)
++		phy_disconnect(phy);
++
++	mutex_unlock(&pl->config_mutex);
++}
++EXPORT_SYMBOL_GPL(phylink_disconnect_phy);
++
++void phylink_mac_change(struct phylink *pl, bool up)
++{
++	phylink_run_resolve(pl);
++	netdev_dbg(pl->netdev, "mac link %s\n", up ? "up" : "down");
++}
++EXPORT_SYMBOL_GPL(phylink_mac_change);
++
++void phylink_start(struct phylink *pl)
++{
++	mutex_lock(&pl->config_mutex);
++
++	netdev_info(pl->netdev, "configuring for %s link mode\n",
++		    phylink_an_mode_str(pl->link_an_mode));
++
++	/* Apply the link configuration to the MAC when starting. This allows
++	 * a fixed-link to start with the correct parameters, and also
++	 * ensures that we set the appropriate advertisment for Serdes links.
++	 */
++	phylink_mac_config(pl, &pl->link_config);
++
++	clear_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state);
++	phylink_run_resolve(pl);
++
++	if (pl->phydev)
++		phy_start(pl->phydev);
++
++	mutex_unlock(&pl->config_mutex);
++}
++EXPORT_SYMBOL_GPL(phylink_start);
++
++void phylink_stop(struct phylink *pl)
++{
++	mutex_lock(&pl->config_mutex);
++
++	if (pl->phydev)
++		phy_stop(pl->phydev);
++
++	set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state);
++	flush_work(&pl->resolve);
++
++	mutex_unlock(&pl->config_mutex);
++}
++EXPORT_SYMBOL_GPL(phylink_stop);
++
++static void phylink_merge_link_mode(unsigned long *dst, const unsigned long *b)
++{
++	__ETHTOOL_DECLARE_LINK_MODE_MASK(mask);
++
++	linkmode_zero(mask);
++	phylink_set_port_bits(mask);
++
++	linkmode_and(dst, dst, mask);
++	linkmode_or(dst, dst, b);
++}
++
++static void phylink_get_ksettings(const struct phylink_link_state *state,
++				  struct ethtool_link_ksettings *kset)
++{
++	phylink_merge_link_mode(kset->link_modes.advertising, state->advertising);
++	linkmode_copy(kset->link_modes.lp_advertising, state->lp_advertising);
++	kset->base.speed = state->speed;
++	kset->base.duplex = state->duplex;
++	kset->base.autoneg = state->an_enabled ? AUTONEG_ENABLE :
++				AUTONEG_DISABLE;
++}
++
++static int __phylink_ethtool_ksettings_get(struct phylink *pl,
++					   struct ethtool_link_ksettings *kset)
++{
++	struct phylink_link_state link_state;
++	int ret;
++
++	if (pl->phydev) {
++		ret = phy_ethtool_ksettings_get(pl->phydev, kset);
++		if (ret)
++			return ret;
++	} else {
++		kset->base.port = pl->link_port;
++	}
++
++	linkmode_copy(kset->link_modes.supported, pl->supported);
++
++	switch (pl->link_an_mode) {
++	case MLO_AN_FIXED:
++		/* We are using fixed settings. Report these as the
++		 * current link settings - and note that these also
++		 * represent the supported speeds/duplex/pause modes.
++		 */
++		phylink_get_fixed_state(pl, &link_state);
++		phylink_get_ksettings(&link_state, kset);
++		break;
++
++	case MLO_AN_SGMII:
++		/* If there is a phy attached, then use the reported
++		 * settings from the phy with no modification.
++		 */
++		if (pl->phydev)
++			break;
++
++	case MLO_AN_8023Z:
++		phylink_get_mac_state(pl, &link_state);
++
++		/* The MAC is reporting the link results from its own PCS
++		 * layer via in-band status. Report these as the current
++		 * link settings.
++		 */
++		phylink_get_ksettings(&link_state, kset);
++		break;
++	}
++
++	return 0;
++}
++
++int phylink_ethtool_ksettings_get(struct phylink *pl,
++	struct ethtool_link_ksettings *kset)
++{
++	int ret;
++
++	mutex_lock(&pl->config_mutex);
++	ret = __phylink_ethtool_ksettings_get(pl, kset);
++	mutex_unlock(&pl->config_mutex);
++
++	return ret;
++}
++EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_get);
++
++static int __phylink_ethtool_ksettings_set(struct phylink *pl,
++					   const struct ethtool_link_ksettings *kset)
++{
++	struct ethtool_link_ksettings our_kset = *kset;
++	int ret;
++
++	/* Mask out unsupported advertisments */
++	linkmode_and(our_kset.link_modes.advertising,
++		     kset->link_modes.advertising, pl->supported);
++
++	if (pl->ops->validate_advert)
++		pl->ops->validate_advert(pl->netdev, pl->link_an_mode,
++					 pl->supported,
++					 our_kset.link_modes.advertising);
++
++	/* FIXME: should we reject autoneg if phy/mac does not support it? */
++
++	if (kset->base.autoneg == AUTONEG_DISABLE) {
++		const struct phy_setting *s;
++
++		/* Autonegotiation disabled, select a suitable speed and
++		 * duplex.
++		 */
++		s = phy_lookup_setting(kset->base.speed, kset->base.duplex,
++				       pl->supported,
++				       __ETHTOOL_LINK_MODE_MASK_NBITS, false);
++		if (!s)
++			return -EINVAL;
++
++		/* If we have a fixed link (as specified by firmware), refuse
++		 * to change link parameters.
++		 */
++		if (pl->link_an_mode == MLO_AN_FIXED &&
++		    (s->speed != pl->link_config.speed ||
++		     s->duplex != pl->link_config.duplex))
++			return -EINVAL;
++
++		our_kset.base.speed = s->speed;
++		our_kset.base.duplex = s->duplex;
++
++		__clear_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
++			    our_kset.link_modes.advertising);
++	} else {
++		/* If we have a fixed link, refuse to enable autonegotiation */
++		if (pl->link_an_mode == MLO_AN_FIXED)
++			return -EINVAL;
++
++		/* Autonegotiation enabled, validate advertisment */
++		if (phylink_empty_linkmode(our_kset.link_modes.advertising))
++			return -EINVAL;
++
++		__set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
++			  our_kset.link_modes.advertising);
++	}
++
++	/* If we have a PHY, configure the phy */
++	if (pl->phydev) {
++		ret = phy_ethtool_ksettings_set(pl->phydev, &our_kset);
++		if (ret)
++			return ret;
++	}
++
++	mutex_lock(&pl->state_mutex);
++	/* Configure the MAC to match the new settings */
++	linkmode_copy(pl->link_config.advertising, our_kset.link_modes.advertising);
++	pl->link_config.speed = our_kset.base.speed;
++	pl->link_config.duplex = our_kset.base.duplex;
++	pl->link_config.an_enabled = our_kset.base.autoneg != AUTONEG_DISABLE;
++
++	if (!test_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state)) {
++		phylink_mac_config(pl, &pl->link_config);
++		phylink_mac_an_restart(pl);
++	}
++	mutex_unlock(&pl->state_mutex);
++
++	return ret;
++}
++
++int phylink_ethtool_ksettings_set(struct phylink *pl,
++	const struct ethtool_link_ksettings *kset)
++{
++	int ret;
++
++	if (kset->base.autoneg != AUTONEG_DISABLE &&
++	    kset->base.autoneg != AUTONEG_ENABLE)
++		return -EINVAL;
++
++	mutex_lock(&pl->config_mutex);
++	ret = __phylink_ethtool_ksettings_set(pl, kset);
++	mutex_unlock(&pl->config_mutex);
++
++	return ret;
++}
++EXPORT_SYMBOL_GPL(phylink_ethtool_ksettings_set);
++
++/* This emulates MII registers for a fixed-mode phy operating as per the
++ * passed in state. "aneg" defines if we report negotiation is possible.
++ *
++ * FIXME: should deal with negotiation state too.
++ */
++static int phylink_mii_emul_read(struct net_device *ndev, unsigned int reg,
++				 struct phylink_link_state *state, bool aneg)
++{
++	struct fixed_phy_status fs;
++	int val;
++
++	fs.link = state->link;
++	fs.speed = state->speed;
++	fs.duplex = state->duplex;
++	fs.pause = state->pause & MLO_PAUSE_SYM;
++	fs.asym_pause = state->pause & MLO_PAUSE_ASYM;
++
++	val = swphy_read_reg(reg, &fs);
++	if (reg == MII_BMSR) {
++		if (!state->an_complete)
++			val &= ~BMSR_ANEGCOMPLETE;
++		if (!aneg)
++			val &= ~BMSR_ANEGCAPABLE;
++	}
++	return val;
++}
++
++static int phylink_mii_read(struct phylink *pl, unsigned int phy_id,
++			    unsigned int reg)
++{
++	struct phylink_link_state state;
++	int val = 0xffff;
++
++	/* PHYs only exist for MLO_AN_PHY and MLO_AN_SGMII */
++	if (pl->phydev)
++		return mdiobus_read(pl->phydev->mdio.bus, phy_id, reg);
++
++	switch (pl->link_an_mode) {
++	case MLO_AN_FIXED:
++		if (phy_id == 0) {
++			phylink_get_fixed_state(pl, &state);
++			val = phylink_mii_emul_read(pl->netdev, reg, &state,
++						    true);
++		}
++		break;
++
++	case MLO_AN_PHY:
++		return -EOPNOTSUPP;
++
++	case MLO_AN_SGMII:
++		/* No phy, fall through to 8023z method */
++	case MLO_AN_8023Z:
++		if (phy_id == 0) {
++			val = phylink_get_mac_state(pl, &state);
++			if (val < 0)
++				return val;
++
++			val = phylink_mii_emul_read(pl->netdev, reg, &state,
++						    true);
++		}
++		break;
++	}
++
++	return val & 0xffff;
++}
++
++static int phylink_mii_write(struct phylink *pl, unsigned int phy_id,
++			     unsigned int reg, unsigned int val)
++{
++	/* PHYs only exist for MLO_AN_PHY and MLO_AN_SGMII */
++	if (pl->phydev) {
++		mdiobus_write(pl->phydev->mdio.bus, phy_id, reg, val);
++		return 0;
++	}
++
++	switch (pl->link_an_mode) {
++	case MLO_AN_FIXED:
++		break;
++
++	case MLO_AN_PHY:
++		return -EOPNOTSUPP;
++
++	case MLO_AN_SGMII:
++		/* No phy, fall through to 8023z method */
++	case MLO_AN_8023Z:
++		break;
++	}
++
++	return 0;
++}
++
++int phylink_mii_ioctl(struct phylink *pl, struct ifreq *ifr, int cmd)
++{
++	struct mii_ioctl_data *mii_data = if_mii(ifr);
++	int val, ret;
++
++	mutex_lock(&pl->config_mutex);
++
++	switch (cmd) {
++	case SIOCGMIIPHY:
++		mii_data->phy_id = pl->phydev ? pl->phydev->mdio.addr : 0;
++		/* fallthrough */
++
++	case SIOCGMIIREG:
++		val = phylink_mii_read(pl, mii_data->phy_id, mii_data->reg_num);
++		if (val < 0) {
++			ret = val;
++		} else {
++			mii_data->val_out = val;
++			ret = 0;
++		}
++		break;
++
++	case SIOCSMIIREG:
++		ret = phylink_mii_write(pl, mii_data->phy_id, mii_data->reg_num,
++					mii_data->val_in);
++		break;
++
++	default:
++		ret = -EOPNOTSUPP;
++		if (pl->phydev)
++			ret = phy_mii_ioctl(pl->phydev, ifr, cmd);
++		break;
++	}
++
++	mutex_unlock(&pl->config_mutex);
++
++	return ret;
++}
++EXPORT_SYMBOL_GPL(phylink_mii_ioctl);
++
++MODULE_LICENSE("GPL");
+--- a/include/linux/phy.h
++++ b/include/linux/phy.h
+@@ -153,6 +153,7 @@ static inline const char *phy_modes(phy_
+ #define MII_ADDR_C45 (1<<30)
+ 
+ struct device;
++struct phylink;
+ struct sk_buff;
+ 
+ /*
+@@ -422,6 +423,7 @@ struct phy_device {
+ 
+ 	struct mutex lock;
+ 
++	struct phylink *phylink;
+ 	struct net_device *attached_dev;
+ 
+ 	u8 mdix;
+--- /dev/null
++++ b/include/linux/phylink.h
+@@ -0,0 +1,100 @@
++#ifndef NETDEV_PCS_H
++#define NETDEV_PCS_H
++
++#include <linux/phy.h>
++#include <linux/spinlock.h>
++#include <linux/workqueue.h>
++
++struct device_node;
++struct ethtool_cmd;
++struct net_device;
++
++enum {
++	MLO_PAUSE_NONE,
++	MLO_PAUSE_ASYM = BIT(0),
++	MLO_PAUSE_SYM = BIT(1),
++
++	MLO_AN_PHY = 0,
++	MLO_AN_FIXED,
++	MLO_AN_SGMII,
++	MLO_AN_8023Z,
++};
++
++struct phylink_link_state {
++	__ETHTOOL_DECLARE_LINK_MODE_MASK(advertising);
++	__ETHTOOL_DECLARE_LINK_MODE_MASK(lp_advertising);
++	int speed;
++	int duplex;
++	int pause;
++	unsigned int link:1;
++	unsigned int an_enabled:1;
++	unsigned int an_complete:1;
++};
++
++struct phylink_mac_ops {
++	/**
++	 * @validate_support:
++	 *
++	 * Validate and update the support mask provided by a PHY or
++	 * module.  Unsupported link modes should be cleared by the
++	 * MAC.
++	 *
++	 * Note: the PHY may be able to transform from one connection
++	 * technology to another, so, eg, don't clear 1000base-X just
++	 * because the MAC is unable to support it.  This is more about
++	 * clearing unsupported speeds and duplex settings.
++	 */
++	void (*validate_support)(struct net_device *, unsigned int mode,
++				 unsigned long *support);
++
++	/**
++	 * @validate_advert:
++	 *
++	 * Validate and update the advertisment mask, clearing bits that
++	 * can not be advertised in the chosen mode or with each other.
++	 */
++	void (*validate_advert)(struct net_device *, unsigned int mode,
++				const unsigned long *support,
++				unsigned long *advert);
++
++	/* Read the current link state from the hardware */
++	int (*mac_link_state)(struct net_device *, struct phylink_link_state *);
++
++	/* Configure the MAC */
++	void (*mac_config)(struct net_device *, unsigned int mode,
++			   const struct phylink_link_state *);
++	void (*mac_an_restart)(struct net_device *, unsigned int mode);
++
++	void (*mac_link_down)(struct net_device *, unsigned int mode);
++	void (*mac_link_up)(struct net_device *, unsigned int mode);
++};
++
++struct phylink *phylink_create(struct net_device *, struct device_node *,
++	phy_interface_t iface, const struct phylink_mac_ops *ops);
++void phylink_destroy(struct phylink *);
++
++int phylink_connect_phy(struct phylink *, struct phy_device *);
++int phylink_of_phy_connect(struct phylink *, struct device_node *);
++void phylink_disconnect_phy(struct phylink *);
++
++void phylink_mac_change(struct phylink *, bool up);
++
++void phylink_start(struct phylink *);
++void phylink_stop(struct phylink *);
++
++int phylink_ethtool_ksettings_get(struct phylink *,
++				  struct ethtool_link_ksettings *);
++int phylink_ethtool_ksettings_set(struct phylink *,
++				  const struct ethtool_link_ksettings *);
++int phylink_mii_ioctl(struct phylink *, struct ifreq *, int);
++
++#define phylink_zero(bm) \
++	bitmap_zero(bm, __ETHTOOL_LINK_MODE_MASK_NBITS)
++#define __phylink_do_bit(op, bm, mode) \
++	op(ETHTOOL_LINK_MODE_ ## mode ## _BIT, bm)
++
++#define phylink_set(bm, mode)	__phylink_do_bit(__set_bit, bm, mode)
++#define phylink_clear(bm, mode)	__phylink_do_bit(__clear_bit, bm, mode)
++#define phylink_test(bm, mode)	__phylink_do_bit(test_bit, bm, mode)
++
++#endif