Commit aab9c406 authored by Florian Fainelli's avatar Florian Fainelli Committed by David S. Miller
Browse files

net: dsa: Plug in PHYLINK support 



Add support for PHYLINK within the DSA subsystem in order to support more
complex devices such as pluggable (SFP) and non-pluggable (SFF) modules, 10G
PHYs, and traditional PHYs. Using PHYLINK allows us to drop some amount of
complexity we had while probing fixed and non-fixed PHYs using Device Tree.

Because PHYLINK separates the Ethernet MAC/port configuration into different
stages, we let switch drivers implement those, and for now, we maintain
functionality by calling dsa_slave_adjust_link() during
phylink_mac_link_{up,down} which provides semantically equivalent steps.

Drivers willing to take advantage of PHYLINK should implement the phylink_mac_*
operations that DSA wraps.

We cannot quite remove the adjust_link() callback just yet, because a number of
drivers rely on that for configuring their "CPU" and "DSA" ports, this is done
dsa_port_setup_phy_of() and dsa_port_fixed_link_register_of() still.

Drivers that utilize fixed links for user-facing ports (e.g: bcm_sf2) will need
to implement phylink_mac_ops from now on to preserve functionality, since PHYLINK
*does not* create a phy_device instance for fixed links.

Signed-off-by: default avatarFlorian Fainelli <f.fainelli@gmail.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent c9a2356f

include/net/dsa.h

+1 −0
Original line number Diff line number Diff line
@@ -201,6 +201,7 @@ struct dsa_port { 
	u8			stp_state;

	struct net_device	*bridge_dev;

	struct devlink_port	devlink_port;

	struct phylink		*pl;

	/*

	 * Original copy of the master netdev ethtool_ops

	 */

net/dsa/dsa_priv.h

+0 −9
Original line number Diff line number Diff line
@@ -75,15 +75,6 @@ struct dsa_slave_priv { 
	/* DSA port data, such as switch, port index, etc. */

	struct dsa_port		*dp;



	/*

	 * The phylib phy_device pointer for the PHY connected

	 * to this port.

	 */

	phy_interface_t		phy_interface;

	int			old_link;

	int			old_pause;

	int			old_duplex;



#ifdef CONFIG_NET_POLL_CONTROLLER

	struct netpoll		*netpoll;

#endif

net/dsa/slave.c

+171 −123
Original line number Diff line number Diff line
@@ -13,6 +13,7 @@ 
#include <linux/netdevice.h>

#include <linux/phy.h>

#include <linux/phy_fixed.h>

#include <linux/phylink.h>

#include <linux/of_net.h>

#include <linux/of_mdio.h>

#include <linux/mdio.h>
@@ -97,8 +98,7 @@ static int dsa_slave_open(struct net_device *dev) 
	if (err)

		goto clear_promisc;



	if (dev->phydev)

		phy_start(dev->phydev);

	phylink_start(dp->pl);



	return 0;
@@ -120,8 +120,7 @@ static int dsa_slave_close(struct net_device *dev) 
	struct net_device *master = dsa_slave_to_master(dev);

	struct dsa_port *dp = dsa_slave_to_port(dev);



	if (dev->phydev)

		phy_stop(dev->phydev);

	phylink_stop(dp->pl);



	dsa_port_disable(dp, dev->phydev);
@@ -272,10 +271,7 @@ static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 
		break;

	}



	if (!dev->phydev)

		return -ENODEV;



	return phy_mii_ioctl(dev->phydev, ifr, cmd);

	return phylink_mii_ioctl(p->dp->pl, ifr, cmd);

}



static int dsa_slave_port_attr_set(struct net_device *dev,
@@ -498,6 +494,13 @@ dsa_slave_get_regs(struct net_device *dev, struct ethtool_regs *regs, void *_p) 
		ds->ops->get_regs(ds, dp->index, regs, _p);

}



static int dsa_slave_nway_reset(struct net_device *dev)

{

	struct dsa_port *dp = dsa_slave_to_port(dev);



	return phylink_ethtool_nway_reset(dp->pl);

}



static int dsa_slave_get_eeprom_len(struct net_device *dev)

{

	struct dsa_port *dp = dsa_slave_to_port(dev);
@@ -609,6 +612,8 @@ static void dsa_slave_get_wol(struct net_device *dev, struct ethtool_wolinfo *w) 
	struct dsa_port *dp = dsa_slave_to_port(dev);

	struct dsa_switch *ds = dp->ds;



	phylink_ethtool_get_wol(dp->pl, w);



	if (ds->ops->get_wol)

		ds->ops->get_wol(ds, dp->index, w);

}
@@ -619,6 +624,8 @@ static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w) 
	struct dsa_switch *ds = dp->ds;

	int ret = -EOPNOTSUPP;



	phylink_ethtool_set_wol(dp->pl, w);



	if (ds->ops->set_wol)

		ret = ds->ops->set_wol(ds, dp->index, w);
@@ -642,13 +649,7 @@ static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e) 
	if (ret)

		return ret;



	if (e->eee_enabled) {

		ret = phy_init_eee(dev->phydev, 0);

		if (ret)

			return ret;

	}



	return phy_ethtool_set_eee(dev->phydev, e);

	return phylink_ethtool_set_eee(dp->pl, e);

}



static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
@@ -668,7 +669,23 @@ static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e) 
	if (ret)

		return ret;



	return phy_ethtool_get_eee(dev->phydev, e);

	return phylink_ethtool_get_eee(dp->pl, e);

}



static int dsa_slave_get_link_ksettings(struct net_device *dev,

					struct ethtool_link_ksettings *cmd)

{

	struct dsa_port *dp = dsa_slave_to_port(dev);



	return phylink_ethtool_ksettings_get(dp->pl, cmd);

}



static int dsa_slave_set_link_ksettings(struct net_device *dev,

					const struct ethtool_link_ksettings *cmd)

{

	struct dsa_port *dp = dsa_slave_to_port(dev);



	return phylink_ethtool_ksettings_set(dp->pl, cmd);

}



#ifdef CONFIG_NET_POLL_CONTROLLER
@@ -971,7 +988,7 @@ static const struct ethtool_ops dsa_slave_ethtool_ops = { 
	.get_drvinfo		= dsa_slave_get_drvinfo,

	.get_regs_len		= dsa_slave_get_regs_len,

	.get_regs		= dsa_slave_get_regs,

	.nway_reset		= phy_ethtool_nway_reset,

	.nway_reset		= dsa_slave_nway_reset,

	.get_link		= ethtool_op_get_link,

	.get_eeprom_len		= dsa_slave_get_eeprom_len,

	.get_eeprom		= dsa_slave_get_eeprom,
@@ -983,8 +1000,8 @@ static const struct ethtool_ops dsa_slave_ethtool_ops = { 
	.get_wol		= dsa_slave_get_wol,

	.set_eee		= dsa_slave_set_eee,

	.get_eee		= dsa_slave_get_eee,

	.get_link_ksettings	= phy_ethtool_get_link_ksettings,

	.set_link_ksettings	= phy_ethtool_set_link_ksettings,

	.get_link_ksettings	= dsa_slave_get_link_ksettings,

	.set_link_ksettings	= dsa_slave_set_link_ksettings,

	.get_rxnfc		= dsa_slave_get_rxnfc,

	.set_rxnfc		= dsa_slave_set_rxnfc,

	.get_ts_info		= dsa_slave_get_ts_info,
@@ -1043,56 +1060,122 @@ static struct device_type dsa_type = { 
	.name	= "dsa",

};



static void dsa_slave_adjust_link(struct net_device *dev)

static void dsa_slave_phylink_validate(struct net_device *dev,

				       unsigned long *supported,

				       struct phylink_link_state *state)

{

	struct dsa_port *dp = dsa_slave_to_port(dev);

	struct dsa_slave_priv *p = netdev_priv(dev);

	struct dsa_switch *ds = dp->ds;

	unsigned int status_changed = 0;



	if (p->old_link != dev->phydev->link) {

		status_changed = 1;

		p->old_link = dev->phydev->link;

	if (!ds->ops->phylink_validate)

		return;



	ds->ops->phylink_validate(ds, dp->index, supported, state);

}



	if (p->old_duplex != dev->phydev->duplex) {

		status_changed = 1;

		p->old_duplex = dev->phydev->duplex;

static int dsa_slave_phylink_mac_link_state(struct net_device *dev,

					    struct phylink_link_state *state)

{

	struct dsa_port *dp = dsa_slave_to_port(dev);

	struct dsa_switch *ds = dp->ds;



	/* Only called for SGMII and 802.3z */

	if (!ds->ops->phylink_mac_link_state)

		return -EOPNOTSUPP;



	return ds->ops->phylink_mac_link_state(ds, dp->index, state);

}



static void dsa_slave_phylink_mac_config(struct net_device *dev,

					 unsigned int mode,

					 const struct phylink_link_state *state)

{

	struct dsa_port *dp = dsa_slave_to_port(dev);

	struct dsa_switch *ds = dp->ds;



	if (!ds->ops->phylink_mac_config)

		return;



	ds->ops->phylink_mac_config(ds, dp->index, mode, state);

}



static void dsa_slave_phylink_mac_an_restart(struct net_device *dev)

{

	struct dsa_port *dp = dsa_slave_to_port(dev);

	struct dsa_switch *ds = dp->ds;



	if (!ds->ops->phylink_mac_an_restart)

		return;



	ds->ops->phylink_mac_an_restart(ds, dp->index);

}



static void dsa_slave_phylink_mac_link_down(struct net_device *dev,

					    unsigned int mode,

					    phy_interface_t interface)

{

	struct dsa_port *dp = dsa_slave_to_port(dev);

	struct dsa_switch *ds = dp->ds;



	if (!ds->ops->phylink_mac_link_down) {

		if (ds->ops->adjust_link && dev->phydev)

			ds->ops->adjust_link(ds, dp->index, dev->phydev);

		return;

	}



	if (p->old_pause != dev->phydev->pause) {

		status_changed = 1;

		p->old_pause = dev->phydev->pause;

	ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);

}



	if (ds->ops->adjust_link && status_changed)

static void dsa_slave_phylink_mac_link_up(struct net_device *dev,

					  unsigned int mode,

					  phy_interface_t interface,

					  struct phy_device *phydev)

{

	struct dsa_port *dp = dsa_slave_to_port(dev);

	struct dsa_switch *ds = dp->ds;



	if (!ds->ops->phylink_mac_link_up) {

		if (ds->ops->adjust_link && dev->phydev)

			ds->ops->adjust_link(ds, dp->index, dev->phydev);

		return;

	}



	if (status_changed)

		phy_print_status(dev->phydev);

	ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev);

}



static int dsa_slave_fixed_link_update(struct net_device *dev,

				       struct fixed_phy_status *status)

static const struct phylink_mac_ops dsa_slave_phylink_mac_ops = {

	.validate = dsa_slave_phylink_validate,

	.mac_link_state = dsa_slave_phylink_mac_link_state,

	.mac_config = dsa_slave_phylink_mac_config,

	.mac_an_restart = dsa_slave_phylink_mac_an_restart,

	.mac_link_down = dsa_slave_phylink_mac_link_down,

	.mac_link_up = dsa_slave_phylink_mac_link_up,

};



void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up)

{

	struct dsa_switch *ds;

	struct dsa_port *dp;

	const struct dsa_port *dp = dsa_to_port(ds, port);



	if (dev) {

		dp = dsa_slave_to_port(dev);

		ds = dp->ds;

		if (ds->ops->fixed_link_update)

			ds->ops->fixed_link_update(ds, dp->index, status);

	phylink_mac_change(dp->pl, up);

}

EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change);



	return 0;

static void dsa_slave_phylink_fixed_state(struct net_device *dev,

					  struct phylink_link_state *state)

{

	struct dsa_port *dp = dsa_slave_to_port(dev);

	struct dsa_switch *ds = dp->ds;



	/* No need to check that this operation is valid, the callback would

	 * not be called if it was not.

	 */

	ds->ops->phylink_fixed_state(ds, dp->index, state);

}



/* slave device setup *******************************************************/

static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr)

{

	struct dsa_port *dp = dsa_slave_to_port(slave_dev);

	struct dsa_slave_priv *p = netdev_priv(slave_dev);

	struct dsa_switch *ds = dp->ds;



	slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr);
@@ -1101,80 +1184,54 @@ static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr) 
		return -ENODEV;

	}



	/* Use already configured phy mode */

	if (p->phy_interface == PHY_INTERFACE_MODE_NA)

		p->phy_interface = slave_dev->phydev->interface;



	return phy_connect_direct(slave_dev, slave_dev->phydev,

				  dsa_slave_adjust_link, p->phy_interface);

}



void dsa_port_phylink_mac_change(struct dsa_switch *ds, int port, bool up)

{

	return phylink_connect_phy(dp->pl, slave_dev->phydev);

}

EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change);



static int dsa_slave_phy_setup(struct net_device *slave_dev)

{

	struct dsa_port *dp = dsa_slave_to_port(slave_dev);

	struct dsa_slave_priv *p = netdev_priv(slave_dev);

	struct device_node *port_dn = dp->dn;

	struct dsa_switch *ds = dp->ds;

	struct device_node *phy_dn;

	bool phy_is_fixed = false;

	u32 phy_flags = 0;

	int mode, ret;



	mode = of_get_phy_mode(port_dn);

	if (mode < 0)

		mode = PHY_INTERFACE_MODE_NA;

	p->phy_interface = mode;



	phy_dn = of_parse_phandle(port_dn, "phy-handle", 0);

	if (!phy_dn && of_phy_is_fixed_link(port_dn)) {

		/* In the case of a fixed PHY, the DT node associated

		 * to the fixed PHY is the Port DT node

		 */

		ret = of_phy_register_fixed_link(port_dn);

		if (ret) {

			netdev_err(slave_dev, "failed to register fixed PHY: %d\n", ret);

			return ret;

		}

		phy_is_fixed = true;

		phy_dn = of_node_get(port_dn);

	dp->pl = phylink_create(slave_dev, of_fwnode_handle(port_dn), mode,

				&dsa_slave_phylink_mac_ops);

	if (IS_ERR(dp->pl)) {

		netdev_err(slave_dev,

			   "error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));

		return PTR_ERR(dp->pl);

	}



	/* Register only if the switch provides such a callback, since this

	 * callback takes precedence over polling the link GPIO in PHYLINK

	 * (see phylink_get_fixed_state).

	 */

	if (ds->ops->phylink_fixed_state)

		phylink_fixed_state_cb(dp->pl, dsa_slave_phylink_fixed_state);



	if (ds->ops->get_phy_flags)

		phy_flags = ds->ops->get_phy_flags(ds, dp->index);



	if (phy_dn) {

		slave_dev->phydev = of_phy_connect(slave_dev, phy_dn,

						   dsa_slave_adjust_link,

						   phy_flags,

						   p->phy_interface);

		of_node_put(phy_dn);

	}



	if (slave_dev->phydev && phy_is_fixed)

		fixed_phy_set_link_update(slave_dev->phydev,

					  dsa_slave_fixed_link_update);



	/* We could not connect to a designated PHY, so use the switch internal

	 * MDIO bus instead

	ret = phylink_of_phy_connect(dp->pl, port_dn, phy_flags);

	if (ret == -ENODEV) {

		/* We could not connect to a designated PHY or SFP, so use the

		 * switch internal MDIO bus instead

		 */

	if (!slave_dev->phydev) {

		ret = dsa_slave_phy_connect(slave_dev, dp->index);

		if (ret) {

			netdev_err(slave_dev, "failed to connect to port %d: %d\n",

			netdev_err(slave_dev,

				   "failed to connect to port %d: %d\n",

				   dp->index, ret);

			if (phy_is_fixed)

				of_phy_deregister_fixed_link(port_dn);

			phylink_destroy(dp->pl);

			return ret;

		}

	}



	phy_attached_info(slave_dev->phydev);



	return 0;

}
@@ -1189,29 +1246,26 @@ static void dsa_slave_set_lockdep_class_one(struct net_device *dev, 


int dsa_slave_suspend(struct net_device *slave_dev)

{

	struct dsa_slave_priv *p = netdev_priv(slave_dev);

	struct dsa_port *dp = dsa_slave_to_port(slave_dev);



	netif_device_detach(slave_dev);



	if (slave_dev->phydev) {

		phy_stop(slave_dev->phydev);

		p->old_pause = -1;

		p->old_link = -1;

		p->old_duplex = -1;

		phy_suspend(slave_dev->phydev);

	}

	rtnl_lock();

	phylink_stop(dp->pl);

	rtnl_unlock();



	return 0;

}



int dsa_slave_resume(struct net_device *slave_dev)

{

	struct dsa_port *dp = dsa_slave_to_port(slave_dev);



	netif_device_attach(slave_dev);



	if (slave_dev->phydev) {

		phy_resume(slave_dev->phydev);

		phy_start(slave_dev->phydev);

	}

	rtnl_lock();

	phylink_start(dp->pl);

	rtnl_unlock();



	return 0;

}
@@ -1276,11 +1330,6 @@ int dsa_slave_create(struct dsa_port *port) 
	p->dp = port;

	INIT_LIST_HEAD(&p->mall_tc_list);

	p->xmit = cpu_dp->tag_ops->xmit;



	p->old_pause = -1;

	p->old_link = -1;

	p->old_duplex = -1;



	port->slave = slave_dev;



	netif_carrier_off(slave_dev);
@@ -1303,9 +1352,10 @@ int dsa_slave_create(struct dsa_port *port) 
	return 0;



out_phy:

	phy_disconnect(slave_dev->phydev);

	if (of_phy_is_fixed_link(port->dn))

		of_phy_deregister_fixed_link(port->dn);

	rtnl_lock();

	phylink_disconnect_phy(p->dp->pl);

	rtnl_unlock();

	phylink_destroy(p->dp->pl);

out_free:

	free_percpu(p->stats64);

	free_netdev(slave_dev);
@@ -1317,17 +1367,15 @@ void dsa_slave_destroy(struct net_device *slave_dev) 
{

	struct dsa_port *dp = dsa_slave_to_port(slave_dev);

	struct dsa_slave_priv *p = netdev_priv(slave_dev);

	struct device_node *port_dn = dp->dn;



	netif_carrier_off(slave_dev);

	if (slave_dev->phydev) {

		phy_disconnect(slave_dev->phydev);

	rtnl_lock();

	phylink_disconnect_phy(dp->pl);

	rtnl_unlock();



		if (of_phy_is_fixed_link(port_dn))

			of_phy_deregister_fixed_link(port_dn);

	}

	dsa_slave_notify(slave_dev, DSA_PORT_UNREGISTER);

	unregister_netdev(slave_dev);

	phylink_destroy(dp->pl);

	free_percpu(p->stats64);

	free_netdev(slave_dev);

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE