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

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
...@@ -201,6 +201,7 @@ struct dsa_port { ...@@ -201,6 +201,7 @@ struct dsa_port {
u8 stp_state; u8 stp_state;
struct net_device *bridge_dev; struct net_device *bridge_dev;
struct devlink_port devlink_port; struct devlink_port devlink_port;
struct phylink *pl;
/* /*
* Original copy of the master netdev ethtool_ops * Original copy of the master netdev ethtool_ops
*/ */
......
...@@ -75,15 +75,6 @@ struct dsa_slave_priv { ...@@ -75,15 +75,6 @@ struct dsa_slave_priv {
/* DSA port data, such as switch, port index, etc. */ /* DSA port data, such as switch, port index, etc. */
struct dsa_port *dp; 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 #ifdef CONFIG_NET_POLL_CONTROLLER
struct netpoll *netpoll; struct netpoll *netpoll;
#endif #endif
......
...@@ -13,6 +13,7 @@ ...@@ -13,6 +13,7 @@
#include <linux/netdevice.h> #include <linux/netdevice.h>
#include <linux/phy.h> #include <linux/phy.h>
#include <linux/phy_fixed.h> #include <linux/phy_fixed.h>
#include <linux/phylink.h>
#include <linux/of_net.h> #include <linux/of_net.h>
#include <linux/of_mdio.h> #include <linux/of_mdio.h>
#include <linux/mdio.h> #include <linux/mdio.h>
...@@ -97,8 +98,7 @@ static int dsa_slave_open(struct net_device *dev) ...@@ -97,8 +98,7 @@ static int dsa_slave_open(struct net_device *dev)
if (err) if (err)
goto clear_promisc; goto clear_promisc;
if (dev->phydev) phylink_start(dp->pl);
phy_start(dev->phydev);
return 0; return 0;
...@@ -120,8 +120,7 @@ static int dsa_slave_close(struct net_device *dev) ...@@ -120,8 +120,7 @@ static int dsa_slave_close(struct net_device *dev)
struct net_device *master = dsa_slave_to_master(dev); struct net_device *master = dsa_slave_to_master(dev);
struct dsa_port *dp = dsa_slave_to_port(dev); struct dsa_port *dp = dsa_slave_to_port(dev);
if (dev->phydev) phylink_stop(dp->pl);
phy_stop(dev->phydev);
dsa_port_disable(dp, dev->phydev); dsa_port_disable(dp, dev->phydev);
...@@ -272,10 +271,7 @@ static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) ...@@ -272,10 +271,7 @@ static int dsa_slave_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
break; break;
} }
if (!dev->phydev) return phylink_mii_ioctl(p->dp->pl, ifr, cmd);
return -ENODEV;
return phy_mii_ioctl(dev->phydev, ifr, cmd);
} }
static int dsa_slave_port_attr_set(struct net_device *dev, 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) ...@@ -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); 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) static int dsa_slave_get_eeprom_len(struct net_device *dev)
{ {
struct dsa_port *dp = dsa_slave_to_port(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) ...@@ -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_port *dp = dsa_slave_to_port(dev);
struct dsa_switch *ds = dp->ds; struct dsa_switch *ds = dp->ds;
phylink_ethtool_get_wol(dp->pl, w);
if (ds->ops->get_wol) if (ds->ops->get_wol)
ds->ops->get_wol(ds, dp->index, w); 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) ...@@ -619,6 +624,8 @@ static int dsa_slave_set_wol(struct net_device *dev, struct ethtool_wolinfo *w)
struct dsa_switch *ds = dp->ds; struct dsa_switch *ds = dp->ds;
int ret = -EOPNOTSUPP; int ret = -EOPNOTSUPP;
phylink_ethtool_set_wol(dp->pl, w);
if (ds->ops->set_wol) if (ds->ops->set_wol)
ret = ds->ops->set_wol(ds, dp->index, w); 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) ...@@ -642,13 +649,7 @@ static int dsa_slave_set_eee(struct net_device *dev, struct ethtool_eee *e)
if (ret) if (ret)
return ret; return ret;
if (e->eee_enabled) { return phylink_ethtool_set_eee(dp->pl, e);
ret = phy_init_eee(dev->phydev, 0);
if (ret)
return ret;
}
return phy_ethtool_set_eee(dev->phydev, e);
} }
static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *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) ...@@ -668,7 +669,23 @@ static int dsa_slave_get_eee(struct net_device *dev, struct ethtool_eee *e)
if (ret) if (ret)
return 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 #ifdef CONFIG_NET_POLL_CONTROLLER
...@@ -971,7 +988,7 @@ static const struct ethtool_ops dsa_slave_ethtool_ops = { ...@@ -971,7 +988,7 @@ static const struct ethtool_ops dsa_slave_ethtool_ops = {
.get_drvinfo = dsa_slave_get_drvinfo, .get_drvinfo = dsa_slave_get_drvinfo,
.get_regs_len = dsa_slave_get_regs_len, .get_regs_len = dsa_slave_get_regs_len,
.get_regs = dsa_slave_get_regs, .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_link = ethtool_op_get_link,
.get_eeprom_len = dsa_slave_get_eeprom_len, .get_eeprom_len = dsa_slave_get_eeprom_len,
.get_eeprom = dsa_slave_get_eeprom, .get_eeprom = dsa_slave_get_eeprom,
...@@ -983,8 +1000,8 @@ static const struct ethtool_ops dsa_slave_ethtool_ops = { ...@@ -983,8 +1000,8 @@ static const struct ethtool_ops dsa_slave_ethtool_ops = {
.get_wol = dsa_slave_get_wol, .get_wol = dsa_slave_get_wol,
.set_eee = dsa_slave_set_eee, .set_eee = dsa_slave_set_eee,
.get_eee = dsa_slave_get_eee, .get_eee = dsa_slave_get_eee,
.get_link_ksettings = phy_ethtool_get_link_ksettings, .get_link_ksettings = dsa_slave_get_link_ksettings,
.set_link_ksettings = phy_ethtool_set_link_ksettings, .set_link_ksettings = dsa_slave_set_link_ksettings,
.get_rxnfc = dsa_slave_get_rxnfc, .get_rxnfc = dsa_slave_get_rxnfc,
.set_rxnfc = dsa_slave_set_rxnfc, .set_rxnfc = dsa_slave_set_rxnfc,
.get_ts_info = dsa_slave_get_ts_info, .get_ts_info = dsa_slave_get_ts_info,
...@@ -1043,56 +1060,122 @@ static struct device_type dsa_type = { ...@@ -1043,56 +1060,122 @@ static struct device_type dsa_type = {
.name = "dsa", .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_port *dp = dsa_slave_to_port(dev);
struct dsa_slave_priv *p = netdev_priv(dev);
struct dsa_switch *ds = dp->ds; struct dsa_switch *ds = dp->ds;
unsigned int status_changed = 0;
if (p->old_link != dev->phydev->link) { if (!ds->ops->phylink_validate)
status_changed = 1; return;
p->old_link = dev->phydev->link;
}
if (p->old_duplex != dev->phydev->duplex) { ds->ops->phylink_validate(ds, dp->index, supported, state);
status_changed = 1; }
p->old_duplex = dev->phydev->duplex;
}
if (p->old_pause != dev->phydev->pause) { static int dsa_slave_phylink_mac_link_state(struct net_device *dev,
status_changed = 1; struct phylink_link_state *state)
p->old_pause = dev->phydev->pause; {
} struct dsa_port *dp = dsa_slave_to_port(dev);
struct dsa_switch *ds = dp->ds;
if (ds->ops->adjust_link && status_changed) /* Only called for SGMII and 802.3z */
ds->ops->adjust_link(ds, dp->index, dev->phydev); if (!ds->ops->phylink_mac_link_state)
return -EOPNOTSUPP;
if (status_changed) return ds->ops->phylink_mac_link_state(ds, dp->index, state);
phy_print_status(dev->phydev);
} }
static int dsa_slave_fixed_link_update(struct net_device *dev, static void dsa_slave_phylink_mac_config(struct net_device *dev,
struct fixed_phy_status *status) unsigned int mode,
const struct phylink_link_state *state)
{ {
struct dsa_switch *ds; struct dsa_port *dp = dsa_slave_to_port(dev);
struct dsa_port *dp; struct dsa_switch *ds = dp->ds;
if (!ds->ops->phylink_mac_config)
return;
if (dev) { ds->ops->phylink_mac_config(ds, dp->index, mode, state);
dp = dsa_slave_to_port(dev); }
ds = dp->ds;
if (ds->ops->fixed_link_update) static void dsa_slave_phylink_mac_an_restart(struct net_device *dev)
ds->ops->fixed_link_update(ds, dp->index, status); {
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;
} }
return 0; ds->ops->phylink_mac_link_down(ds, dp->index, mode, interface);
}
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;
}
ds->ops->phylink_mac_link_up(ds, dp->index, mode, interface, phydev);
}
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)
{
const struct dsa_port *dp = dsa_to_port(ds, port);
phylink_mac_change(dp->pl, up);
}
EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change);
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 *******************************************************/ /* slave device setup *******************************************************/
static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr) 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_port *dp = dsa_slave_to_port(slave_dev);
struct dsa_slave_priv *p = netdev_priv(slave_dev);
struct dsa_switch *ds = dp->ds; struct dsa_switch *ds = dp->ds;
slave_dev->phydev = mdiobus_get_phy(ds->slave_mii_bus, addr); 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) ...@@ -1101,80 +1184,54 @@ static int dsa_slave_phy_connect(struct net_device *slave_dev, int addr)
return -ENODEV; return -ENODEV;
} }
/* Use already configured phy mode */ return phylink_connect_phy(dp->pl, slave_dev->phydev);
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)
{
} }
EXPORT_SYMBOL_GPL(dsa_port_phylink_mac_change);
static int dsa_slave_phy_setup(struct net_device *slave_dev) static int dsa_slave_phy_setup(struct net_device *slave_dev)
{ {
struct dsa_port *dp = dsa_slave_to_port(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 device_node *port_dn = dp->dn;
struct dsa_switch *ds = dp->ds; struct dsa_switch *ds = dp->ds;
struct device_node *phy_dn;
bool phy_is_fixed = false;
u32 phy_flags = 0; u32 phy_flags = 0;
int mode, ret; int mode, ret;
mode = of_get_phy_mode(port_dn); mode = of_get_phy_mode(port_dn);
if (mode < 0) if (mode < 0)
mode = PHY_INTERFACE_MODE_NA; mode = PHY_INTERFACE_MODE_NA;
p->phy_interface = mode;
phy_dn = of_parse_phandle(port_dn, "phy-handle", 0); dp->pl = phylink_create(slave_dev, of_fwnode_handle(port_dn), mode,
if (!phy_dn && of_phy_is_fixed_link(port_dn)) { &dsa_slave_phylink_mac_ops);
/* In the case of a fixed PHY, the DT node associated if (IS_ERR(dp->pl)) {
* to the fixed PHY is the Port DT node netdev_err(slave_dev,
*/ "error creating PHYLINK: %ld\n", PTR_ERR(dp->pl));
ret = of_phy_register_fixed_link(port_dn); return PTR_ERR(dp->pl);
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);
} }
/* 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) if (ds->ops->get_phy_flags)
phy_flags = ds->ops->get_phy_flags(ds, dp->index); phy_flags = ds->ops->get_phy_flags(ds, dp->index);
if (phy_dn) { ret = phylink_of_phy_connect(dp->pl, port_dn, phy_flags);
slave_dev->phydev = of_phy_connect(slave_dev, phy_dn, if (ret == -ENODEV) {
dsa_slave_adjust_link, /* We could not connect to a designated PHY or SFP, so use the
phy_flags, * switch internal MDIO bus instead
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
*/
if (!slave_dev->phydev) {
ret = dsa_slave_phy_connect(slave_dev, dp->index); ret = dsa_slave_phy_connect(slave_dev, dp->index);
if (ret) { 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); dp->index, ret);
if (phy_is_fixed) phylink_destroy(dp->pl);
of_phy_deregister_fixed_link(port_dn);
return ret; return ret;
} }
} }
phy_attached_info(slave_dev->phydev);
return 0; return 0;
} }
...@@ -1189,29 +1246,26 @@ static void dsa_slave_set_lockdep_class_one(struct net_device *dev, ...@@ -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) 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); netif_device_detach(slave_dev);
if (slave_dev->phydev) { rtnl_lock();
phy_stop(slave_dev->phydev); phylink_stop(dp->pl);
p->old_pause = -1; rtnl_unlock();
p->old_link = -1;
p->old_duplex = -1;
phy_suspend(slave_dev->phydev);
}
return 0; return 0;
} }
int dsa_slave_resume(struct net_device *slave_dev) int dsa_slave_resume(struct net_device *slave_dev)
{ {
struct dsa_port *dp = dsa_slave_to_port(slave_dev);
netif_device_attach(slave_dev); netif_device_attach(slave_dev);
if (slave_dev->phydev) { rtnl_lock();
phy_resume(slave_dev->phydev); phylink_start(dp->pl);
phy_start(slave_dev->phydev); rtnl_unlock();
}
return 0; return 0;
} }
...@@ -1276,11 +1330,6 @@ int dsa_slave_create(struct dsa_port *port) ...@@ -1276,11 +1330,6 @@ int dsa_slave_create(struct dsa_port *port)
p->dp = port; p->dp = port;
INIT_LIST_HEAD(&p->mall_tc_list); INIT_LIST_HEAD(&p->mall_tc_list);
p->xmit = cpu_dp->tag_ops->xmit; p->xmit = cpu_dp->tag_ops->xmit;
p->old_pause = -1;
p->old_link = -1;
p->old_duplex = -1;
port->slave = slave_dev; port->slave = slave_dev;
netif_carrier_off(slave_dev); netif_carrier_off(slave_dev);
...@@ -1303,9 +1352,10 @@ int dsa_slave_create(struct dsa_port *port) ...@@ -1303,9 +1352,10 @@ int dsa_slave_create(struct dsa_port *port)
return 0; return 0;
out_phy: out_phy:
phy_disconnect(slave_dev->phydev); rtnl_lock();
if (of_phy_is_fixed_link(port->dn)) phylink_disconnect_phy(p->dp->pl);
of_phy_deregister_fixed_link(port->dn); rtnl_unlock();
phylink_destroy(p->dp->pl);
out_free: out_free:
free_percpu(p->stats64); free_percpu(p->stats64);
free_netdev(slave_dev); free_netdev(slave_dev);
...@@ -1317,17 +1367,15 @@ void dsa_slave_destroy(struct net_device *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_port *dp = dsa_slave_to_port(slave_dev);
struct dsa_slave_priv *p = netdev_priv(slave_dev); struct dsa_slave_priv *p = netdev_priv(slave_dev);
struct device_node *port_dn = dp->dn;
netif_carrier_off(slave_dev); netif_carrier_off(slave_dev);
if (slave_dev->phydev) { rtnl_lock();
phy_disconnect(slave_dev->phydev); 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); dsa_slave_notify(slave_dev, DSA_PORT_UNREGISTER);
unregister_netdev(slave_dev); unregister_netdev(slave_dev);
phylink_destroy(dp->pl);
free_percpu(p->stats64); free_percpu(p->stats64);
free_netdev(slave_dev); free_netdev(slave_dev);
} }
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment