mirror of https://github.com/hak5/openwrt.git
1006 lines
27 KiB
Diff
1006 lines
27 KiB
Diff
|
From c6de6de7d3df13822872ac756eebe868d236297a Mon Sep 17 00:00:00 2001
|
||
|
From: Russell King <rmk+kernel@arm.linux.org.uk>
|
||
|
Date: Tue, 22 Sep 2015 20:52:18 +0100
|
||
|
Subject: [PATCH 718/744] 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>
|
||
|
---
|
||
|
drivers/net/phy/Kconfig | 10 +
|
||
|
drivers/net/phy/Makefile | 1 +
|
||
|
drivers/net/phy/phy_device.c | 1 +
|
||
|
drivers/net/phy/phylink.c | 816 +++++++++++++++++++++++++++++++++++++++++++
|
||
|
include/linux/phy.h | 2 +
|
||
|
include/linux/phylink.h | 70 ++++
|
||
|
6 files changed, 900 insertions(+)
|
||
|
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 MDIO_BOARDINFO
|
||
|
--- a/drivers/net/phy/Makefile
|
||
|
+++ b/drivers/net/phy/Makefile
|
||
|
@@ -5,6 +5,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
|
||
|
obj-$(CONFIG_AQUANTIA_PHY) += aquantia.o
|
||
|
--- a/drivers/net/phy/phy_device.c
|
||
|
+++ b/drivers/net/phy/phy_device.c
|
||
|
@@ -754,6 +754,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,816 @@
|
||
|
+/*
|
||
|
+ * 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 */
|
||
|
+ u32 link_port_support; /* SUPPORTED_xxx ethtool for ports */
|
||
|
+
|
||
|
+ /* 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;
|
||
|
+
|
||
|
+ bool mac_link_up;
|
||
|
+};
|
||
|
+
|
||
|
+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)
|
||
|
+{
|
||
|
+ struct device_node *fixed_node;
|
||
|
+ int ret, len;
|
||
|
+
|
||
|
+ fixed_node = of_get_child_by_name(np, "fixed-link");
|
||
|
+ if (fixed_node) {
|
||
|
+ struct gpio_desc *desc;
|
||
|
+ u32 speed;
|
||
|
+
|
||
|
+ ret = of_property_read_u32(fixed_node, "speed", &speed);
|
||
|
+
|
||
|
+ pl->link_an_mode = MLO_AN_FIXED;
|
||
|
+ pl->link_config.link = 1;
|
||
|
+ pl->link_config.an_complete = 1;
|
||
|
+ pl->link_config.speed = speed;
|
||
|
+ pl->link_config.duplex = DUPLEX_HALF;
|
||
|
+ pl->link_config.pause = MLO_PAUSE_NONE;
|
||
|
+
|
||
|
+ 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);
|
||
|
+ } else {
|
||
|
+ const __be32 *fixed_prop;
|
||
|
+
|
||
|
+ fixed_prop = of_get_property(np, "fixed-link", &len);
|
||
|
+ if (fixed_prop && 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]);
|
||
|
+ pl->link_config.pause = MLO_PAUSE_NONE;
|
||
|
+ 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;
|
||
|
+
|
||
|
+ pl->link_an_mode = MLO_AN_FIXED;
|
||
|
+ }
|
||
|
+ ret = 0;
|
||
|
+ }
|
||
|
+
|
||
|
+ if (pl->link_an_mode == MLO_AN_FIXED) {
|
||
|
+ /* Generate the supported/advertising masks */
|
||
|
+ if (pl->link_config.pause & MLO_PAUSE_SYM) {
|
||
|
+ pl->link_config.supported |= SUPPORTED_Pause;
|
||
|
+ pl->link_config.advertising |= ADVERTISED_Pause;
|
||
|
+ }
|
||
|
+ if (pl->link_config.pause & MLO_PAUSE_ASYM) {
|
||
|
+ pl->link_config.supported |= SUPPORTED_Asym_Pause;
|
||
|
+ pl->link_config.advertising |= ADVERTISED_Asym_Pause;
|
||
|
+ }
|
||
|
+
|
||
|
+ 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);
|
||
|
+
|
||
|
+#define S(spd) \
|
||
|
+ pl->link_config.supported |= pl->link_config.duplex ? \
|
||
|
+ SUPPORTED_##spd##_Full : SUPPORTED_##spd##_Half
|
||
|
+#define A(spd) \
|
||
|
+ pl->link_config.advertising |= pl->link_config.duplex ? \
|
||
|
+ ADVERTISED_##spd##_Full : ADVERTISED_##spd##_Half
|
||
|
+#define C(spd, tech) \
|
||
|
+ case spd: \
|
||
|
+ S(spd##tech); \
|
||
|
+ A(spd##tech); \
|
||
|
+ break
|
||
|
+ switch (pl->link_config.speed) {
|
||
|
+ C(10, baseT);
|
||
|
+ C(100, baseT);
|
||
|
+ C(1000, baseT);
|
||
|
+#undef S
|
||
|
+#undef A
|
||
|
+#define S(spd) pl->link_config.supported |= SUPPORTED_##spd##_Full
|
||
|
+#define A(spd) pl->link_config.advertising |= ADVERTISED_##spd##_Full
|
||
|
+ C(2500, baseX);
|
||
|
+ C(10000, baseT);
|
||
|
+ }
|
||
|
+#undef S
|
||
|
+#undef A
|
||
|
+#undef C
|
||
|
+ }
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+
|
||
|
+static int phylink_parse_managed(struct phylink *pl, struct device_node *np)
|
||
|
+{
|
||
|
+ const char *managed;
|
||
|
+
|
||
|
+ 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;
|
||
|
+ }
|
||
|
+ pl->link_an_mode = MLO_AN_SGMII;
|
||
|
+ pl->link_config.an_enabled = true;
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+
|
||
|
+static int phylink_get_support(struct phylink *pl, unsigned int mode)
|
||
|
+{
|
||
|
+ struct phylink_link_state state = pl->link_config;
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ ret = pl->ops->mac_get_support(pl->netdev, mode, &state);
|
||
|
+ if (ret == 0) {
|
||
|
+ pl->link_an_mode = mode;
|
||
|
+ pl->link_config = state;
|
||
|
+ }
|
||
|
+
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+
|
||
|
+static void phylink_mac_config(struct phylink *pl,
|
||
|
+ const struct phylink_link_state *state)
|
||
|
+{
|
||
|
+ 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;
|
||
|
+
|
||
|
+ state->supported = pl->link_config.supported;
|
||
|
+ state->advertising = pl->link_config.advertising;
|
||
|
+ state->an_enabled = pl->link_config.an_enabled;
|
||
|
+ state->link = 1;
|
||
|
+ state->sync = 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);
|
||
|
+}
|
||
|
+
|
||
|
+extern const char *phy_speed_to_str(int speed);
|
||
|
+
|
||
|
+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),
|
||
|
+ link_state.duplex ? "Full" : "Half",
|
||
|
+ 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_support = SUPPORTED_MII;
|
||
|
+ pl->link_port = PORT_MII;
|
||
|
+ pl->ops = ops;
|
||
|
+ __set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state);
|
||
|
+
|
||
|
+ ret = phylink_parse_fixedlink(pl, np);
|
||
|
+ if (ret < 0) {
|
||
|
+ kfree(pl);
|
||
|
+ return ERR_PTR(ret);
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = phylink_parse_managed(pl, np);
|
||
|
+ if (ret < 0) {
|
||
|
+ kfree(pl);
|
||
|
+ return ERR_PTR(ret);
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = phylink_get_support(pl, pl->link_an_mode);
|
||
|
+ if (ret) {
|
||
|
+ kfree(pl);
|
||
|
+ return ERR_PTR(ret);
|
||
|
+ }
|
||
|
+
|
||
|
+ 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 *phy, bool up, bool do_carrier)
|
||
|
+{
|
||
|
+ struct phylink *pl = phy->phylink;
|
||
|
+
|
||
|
+ mutex_lock(&pl->state_mutex);
|
||
|
+ pl->phy_state.speed = phy->speed;
|
||
|
+ pl->phy_state.duplex = phy->duplex;
|
||
|
+ pl->phy_state.pause = MLO_PAUSE_NONE;
|
||
|
+ if (phy->pause)
|
||
|
+ pl->phy_state.pause |= MLO_PAUSE_SYM;
|
||
|
+ if (phy->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\n", up ? "up" : "down");
|
||
|
+}
|
||
|
+
|
||
|
+static int phylink_bringup_phy(struct phylink *pl, struct phy_device *phy)
|
||
|
+{
|
||
|
+ 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->dev),
|
||
|
+ phy->drv->name);
|
||
|
+
|
||
|
+ mutex_lock(&pl->state_mutex);
|
||
|
+ pl->phydev = phy;
|
||
|
+
|
||
|
+ /* Restrict the phy advertisment to the union of the PHY and
|
||
|
+ * MAC-level advert.
|
||
|
+ */
|
||
|
+ phy->advertising &= ADVERTISED_INTERFACES |
|
||
|
+ pl->link_config.advertising;
|
||
|
+ mutex_unlock(&pl->state_mutex);
|
||
|
+
|
||
|
+ 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);
|
||
|
+
|
||
|
+ pl->mac_link_up = false;
|
||
|
+
|
||
|
+ mutex_unlock(&pl->config_mutex);
|
||
|
+}
|
||
|
+EXPORT_SYMBOL_GPL(phylink_stop);
|
||
|
+
|
||
|
+static void phylink_get_ethtool(const struct phylink_link_state *state,
|
||
|
+ struct ethtool_cmd *cmd)
|
||
|
+{
|
||
|
+ cmd->supported &= SUPPORTED_INTERFACES;
|
||
|
+ cmd->supported |= state->supported;
|
||
|
+ cmd->advertising &= ADVERTISED_INTERFACES;
|
||
|
+ cmd->advertising |= state->advertising;
|
||
|
+ ethtool_cmd_speed_set(cmd, state->speed);
|
||
|
+ cmd->duplex = state->duplex;
|
||
|
+
|
||
|
+ cmd->autoneg = state->an_enabled ? AUTONEG_ENABLE : AUTONEG_DISABLE;
|
||
|
+}
|
||
|
+
|
||
|
+static int phylink_ethtool_gset(struct phylink *pl, struct ethtool_cmd *cmd)
|
||
|
+{
|
||
|
+ struct phylink_link_state link_state;
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ if (pl->phydev) {
|
||
|
+ ret = phy_ethtool_gset(pl->phydev, cmd);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+
|
||
|
+ cmd->supported &= SUPPORTED_INTERFACES |
|
||
|
+ pl->link_config.supported;
|
||
|
+ } else {
|
||
|
+ cmd->supported = pl->link_port_support;
|
||
|
+ cmd->transceiver = XCVR_EXTERNAL;
|
||
|
+ cmd->port = pl->link_port;
|
||
|
+ }
|
||
|
+
|
||
|
+ 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_ethtool(&link_state, cmd);
|
||
|
+ 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_ethtool(&link_state, cmd);
|
||
|
+ break;
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+int phylink_ethtool_get_settings(struct phylink *pl, struct ethtool_cmd *cmd)
|
||
|
+{
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ mutex_lock(&pl->config_mutex);
|
||
|
+ ret = phylink_ethtool_gset(pl, cmd);
|
||
|
+ mutex_unlock(&pl->config_mutex);
|
||
|
+
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+EXPORT_SYMBOL_GPL(phylink_ethtool_get_settings);
|
||
|
+
|
||
|
+static int phylink_ethtool_sset(struct phylink *pl, struct ethtool_cmd *cmd)
|
||
|
+{
|
||
|
+ u32 supported;
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ /* Calculate the union of the MAC support and attached phy support */
|
||
|
+ supported = pl->link_config.supported;
|
||
|
+ if (pl->phydev)
|
||
|
+ supported &= pl->phydev->supported;
|
||
|
+
|
||
|
+ /* Mask out unsupported advertisments */
|
||
|
+ cmd->advertising &= supported;
|
||
|
+
|
||
|
+ /* FIXME: should we reject autoneg if phy/mac does not support it? */
|
||
|
+
|
||
|
+ if (cmd->autoneg == AUTONEG_DISABLE) {
|
||
|
+ /* Autonegotiation disabled, validate speed and duplex */
|
||
|
+ if (cmd->duplex != DUPLEX_HALF && cmd->duplex != DUPLEX_FULL)
|
||
|
+ return -EINVAL;
|
||
|
+
|
||
|
+ /* FIXME: validate speed/duplex against supported */
|
||
|
+
|
||
|
+ cmd->advertising &= ~ADVERTISED_Autoneg;
|
||
|
+ } else {
|
||
|
+ /* Autonegotiation enabled, validate advertisment */
|
||
|
+ /* FIXME: shouldn't we ensure there's some duplex/speeds set */
|
||
|
+ if (cmd->advertising == 0)
|
||
|
+ return -EINVAL;
|
||
|
+
|
||
|
+ cmd->advertising |= ADVERTISED_Autoneg;
|
||
|
+ }
|
||
|
+
|
||
|
+ /* If we have a fixed link (as specified by firmware), refuse
|
||
|
+ * to enable autonegotiation, or change link parameters.
|
||
|
+ */
|
||
|
+ if (pl->link_an_mode == MLO_AN_FIXED) {
|
||
|
+ if (cmd->autoneg != AUTONEG_DISABLE ||
|
||
|
+ ethtool_cmd_speed(cmd) != pl->link_config.speed ||
|
||
|
+ cmd->duplex != pl->link_config.duplex)
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+
|
||
|
+ /* If we have a PHY, configure the phy */
|
||
|
+ if (pl->phydev) {
|
||
|
+ ret = phy_ethtool_sset(pl->phydev, cmd);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+ }
|
||
|
+
|
||
|
+ mutex_lock(&pl->state_mutex);
|
||
|
+ /* Configure the MAC to match the new settings */
|
||
|
+ pl->link_config.advertising = cmd->advertising;
|
||
|
+ pl->link_config.speed = cmd->speed;
|
||
|
+ pl->link_config.duplex = cmd->duplex;
|
||
|
+ pl->link_config.an_enabled = cmd->autoneg != AUTONEG_DISABLE;
|
||
|
+
|
||
|
+ phylink_mac_config(pl, &pl->link_config);
|
||
|
+ phylink_mac_an_restart(pl);
|
||
|
+ mutex_unlock(&pl->state_mutex);
|
||
|
+
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+
|
||
|
+int phylink_ethtool_set_settings(struct phylink *pl, struct ethtool_cmd *cmd)
|
||
|
+{
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ if (cmd->autoneg != AUTONEG_DISABLE && cmd->autoneg != AUTONEG_ENABLE)
|
||
|
+ return -EINVAL;
|
||
|
+
|
||
|
+ mutex_lock(&pl->config_mutex);
|
||
|
+ ret = phylink_ethtool_sset(pl, cmd);
|
||
|
+ mutex_unlock(&pl->config_mutex);
|
||
|
+
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+EXPORT_SYMBOL_GPL(phylink_ethtool_set_settings);
|
||
|
+
|
||
|
+/* 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;
|
||
|
+
|
||
|
+ if (pl->phydev && pl->phydev->addr != phy_id)
|
||
|
+ return mdiobus_read(pl->phydev->bus, phy_id, reg);
|
||
|
+
|
||
|
+ if (!pl->phydev && phy_id != 0)
|
||
|
+ return val;
|
||
|
+
|
||
|
+ switch (pl->link_an_mode) {
|
||
|
+ case MLO_AN_FIXED:
|
||
|
+ phylink_get_fixed_state(pl, &state);
|
||
|
+ val = phylink_mii_emul_read(pl->netdev, reg, &state, true);
|
||
|
+ break;
|
||
|
+
|
||
|
+ case MLO_AN_PHY:
|
||
|
+ val = mdiobus_read(pl->phydev->bus, phy_id, reg);
|
||
|
+ break;
|
||
|
+
|
||
|
+ case MLO_AN_SGMII:
|
||
|
+ if (pl->phydev) {
|
||
|
+ val = mdiobus_read(pl->phydev->bus,
|
||
|
+ pl->phydev->addr, reg);
|
||
|
+ break;
|
||
|
+ }
|
||
|
+ /* No phy, fall through to reading the MAC end */
|
||
|
+ case MLO_AN_8023Z:
|
||
|
+ 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 void phylink_mii_write(struct phylink *pl, unsigned int phy_id,
|
||
|
+ unsigned int reg, unsigned int val)
|
||
|
+{
|
||
|
+ if (pl->phydev && pl->phydev->addr != phy_id) {
|
||
|
+ mdiobus_write(pl->phydev->bus, phy_id, reg, val);
|
||
|
+ return;
|
||
|
+ }
|
||
|
+
|
||
|
+ if (!pl->phydev && phy_id != 0)
|
||
|
+ return;
|
||
|
+
|
||
|
+ switch (pl->link_an_mode) {
|
||
|
+ case MLO_AN_FIXED:
|
||
|
+ break;
|
||
|
+
|
||
|
+ case MLO_AN_PHY:
|
||
|
+ mdiobus_write(pl->phydev->bus, pl->phydev->addr,
|
||
|
+ reg, val);
|
||
|
+ break;
|
||
|
+
|
||
|
+ case MLO_AN_SGMII:
|
||
|
+ if (pl->phydev) {
|
||
|
+ mdiobus_write(pl->phydev->bus, phy_id, reg, val);
|
||
|
+ break;
|
||
|
+ }
|
||
|
+ /* No phy, fall through to reading the MAC end */
|
||
|
+ case MLO_AN_8023Z:
|
||
|
+ break;
|
||
|
+ }
|
||
|
+}
|
||
|
+
|
||
|
+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->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:
|
||
|
+ phylink_mii_write(pl, mii_data->phy_id, mii_data->reg_num,
|
||
|
+ mii_data->val_in);
|
||
|
+ ret = 0;
|
||
|
+ 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
|
||
|
@@ -147,6 +147,7 @@ static inline const char *phy_modes(phy_
|
||
|
#define MII_ADDR_C45 (1<<30)
|
||
|
|
||
|
struct device;
|
||
|
+struct phylink;
|
||
|
struct sk_buff;
|
||
|
|
||
|
/*
|
||
|
@@ -429,6 +430,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,70 @@
|
||
|
+#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 {
|
||
|
+ u32 supported;
|
||
|
+ u32 advertising;
|
||
|
+ u32 lp_advertising;
|
||
|
+ int speed;
|
||
|
+ int duplex;
|
||
|
+ int pause;
|
||
|
+ unsigned int link:1;
|
||
|
+ unsigned int sync:1;
|
||
|
+ unsigned int an_enabled:1;
|
||
|
+ unsigned int an_complete:1;
|
||
|
+};
|
||
|
+
|
||
|
+struct phylink_mac_ops {
|
||
|
+ /* Get the ethtool supported mask for the indicated mode */
|
||
|
+ int (*mac_get_support)(struct net_device *, unsigned int mode,
|
||
|
+ struct phylink_link_state *);
|
||
|
+
|
||
|
+ /* 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_get_settings(struct phylink *, struct ethtool_cmd *);
|
||
|
+int phylink_ethtool_set_settings(struct phylink *, struct ethtool_cmd *);
|
||
|
+int phylink_mii_ioctl(struct phylink *, struct ifreq *, int);
|
||
|
+
|
||
|
+#endif
|