diff --git a/drivers/net/pcs/pcs.c b/drivers/net/pcs/pcs.c
index b1d48f6eee7f..f234a4635417 100644
--- a/drivers/net/pcs/pcs.c
+++ b/drivers/net/pcs/pcs.c
@@ -22,6 +22,19 @@ struct fwnode_pcs_provider {
static LIST_HEAD(fwnode_pcs_providers);
static DEFINE_MUTEX(fwnode_pcs_mutex);
+static BLOCKING_NOTIFIER_HEAD(fwnode_pcs_notify_list);
+
+int register_fwnode_pcs_notifier(struct notifier_block *nb)
+{
+ return blocking_notifier_chain_register(&fwnode_pcs_notify_list, nb);
+}
+EXPORT_SYMBOL_GPL(register_fwnode_pcs_notifier);
+
+int unregister_fwnode_pcs_notifier(struct notifier_block *nb)
+{
+ return blocking_notifier_chain_unregister(&fwnode_pcs_notify_list, nb);
+}
+EXPORT_SYMBOL_GPL(unregister_fwnode_pcs_notifier);
struct phylink_pcs *fwnode_pcs_simple_xlate(struct fwnode_reference_args *pcsspec,
void *data)@@ -74,6 +87,11 @@ void fwnode_pcs_del_provider(struct fwnode_pcs_provider *pp)
mutex_unlock(&fwnode_pcs_mutex);
+ /* Signal phylink to release any PCS from this provider */
+ blocking_notifier_call_chain(&fwnode_pcs_notify_list,
+ FWNODE_PCS_PROVIDER_DEL,
+ pp);
+
fwnode_handle_put(pp->fwnode);
kfree(pp);
}
@@ -183,6 +201,35 @@ struct phylink_pcs *fwnode_pcs_get(const struct fwnode_handle *fwnode, unsigned
}
EXPORT_SYMBOL_GPL(fwnode_pcs_get);
+bool fwnode_pcs_matches_provider(struct fwnode_pcs_provider *provider,
+ const struct fwnode_handle *fwnode,
+ struct phylink_pcs *pl_pcs)
+{
+ struct fwnode_reference_args pcsspec;
+ int index = 0;
+ int ret;
+
+ while (true) {
+ struct phylink_pcs *pcs;
+
+ ret = fwnode_parse_pcsspec(fwnode, index, NULL, &pcsspec);
+ if (ret)
+ return false;
+
+ pcs = __fwnode_pcs_get_from_pcsspec_provider(&pcsspec, provider);
+ if (!IS_ERR(pcs) && pcs == pl_pcs) {
+ fwnode_handle_put(pcsspec.fwnode);
+ return true;
+ }
+
+ fwnode_handle_put(pcsspec.fwnode);
+ index++;
+ }
+
+ return false;
+}
+EXPORT_SYMBOL_GPL(fwnode_pcs_matches_provider);
+
unsigned int fwnode_phylink_pcs_count(struct fwnode_handle *fwnode)
{
struct fwnode_reference_args out_args;diff --git a/drivers/net/phy/phylink.c b/drivers/net/phy/phylink.c
index 921c227a5b3c..094a15f3dbcd 100644
--- a/drivers/net/phy/phylink.c
+++ b/drivers/net/phy/phylink.c
@@ -11,8 +11,10 @@
#include <linux/gpio/consumer.h>
#include <linux/lockdep.h>
#include <linux/netdevice.h>
+#include <linux/notifier.h>
#include <linux/of.h>
#include <linux/of_mdio.h>
+#include <linux/pcs/pcs.h>
#include <linux/phy.h>
#include <linux/phy_fixed.h>
#include <linux/phy_link_topology.h>
@@ -38,6 +40,7 @@ enum {
PCS_STATE_DOWN = 0,
PCS_STATE_STARTING,
PCS_STATE_STARTED,
+ PCS_STATE_DETACHING,
};
/**@@ -70,6 +73,7 @@ struct phylink {
/* List of available PCS */
struct list_head pcs_list;
+ struct notifier_block fwnode_pcs_nb;
/* What interface are supported by the current link.
* Can change on removal or addition of new PCS.@@ -934,13 +938,15 @@ static int phylink_parse_fixedlink(struct phylink *pl,
pl->link_config.speed);
mutex_lock(&pl->state_mutex);
+
ret = phylink_parse_fixedlink_capabilities(pl, &pl->link_config);
- mutex_unlock(&pl->state_mutex);
if (ret)
phylink_warn(pl, "fixed link %s duplex %dMbps not recognised\n",
pl->link_config.duplex == DUPLEX_FULL ? "full" : "half",
pl->link_config.speed);
+ mutex_unlock(&pl->state_mutex);
+
pl->link_config.link = 1;
pl->link_config.an_complete = 1;
@@ -1154,6 +1160,9 @@ static unsigned int phylink_inband_caps(struct phylink *pl,
phy_interface_t interface)
{
struct phylink_pcs *pcs = NULL;
+ int ret = 0;
+
+ mutex_lock(&pl->state_mutex);
if (pl->mac_ops->mac_select_pcs) {
pcs = pl->mac_ops->mac_select_pcs(pl->config,@@ -1170,9 +1179,14 @@ static unsigned int phylink_inband_caps(struct phylink *pl,
}
if (IS_ERR_OR_NULL(pcs))
- return 0;
+ goto exit;
- return phylink_pcs_inband_caps(pcs, interface);
+ ret = phylink_pcs_inband_caps(pcs, interface);
+
+exit:
+ mutex_unlock(&pl->state_mutex);
+
+ return ret;
}
static void phylink_pcs_poll_stop(struct phylink *pl)
@@ -1713,7 +1727,9 @@ static void phylink_mac_initial_config(struct phylink *pl, bool force_restart)
phylink_apply_manual_flow(pl, &link_state);
if (phy)
mutex_lock(&phy->lock);
+ mutex_lock(&pl->state_mutex);
phylink_major_config(pl, force_restart, &link_state);
+ mutex_unlock(&pl->state_mutex);
if (phy)
mutex_unlock(&phy->lock);
}
@@ -2143,6 +2159,9 @@ static int phylink_fill_available_pcs(struct phylink *pl,
if (!pcss)
return -ENOMEM;
+ /* Lock state_mutex while filling to handle PCS notify */
+ mutex_lock(&pl->state_mutex);
+
ret = config->fill_available_pcs(config, pcss, config->num_possible_pcs);
if (ret < 0)
goto out;
@@ -2162,6 +2181,8 @@ static int phylink_fill_available_pcs(struct phylink *pl,
}
out:
+ mutex_unlock(&pl->state_mutex);
+
kfree(pcss);
return ret;
@@ -2350,6 +2371,11 @@ static void phylink_update_capabilities(struct phylink *pl,
config->interface);
linkmode_copy(pl->supported, supported);
linkmode_copy(pl->advertising, config->advertising);
+ } else {
+ /* No SFP modes remain usable with the current interfaces. */
+ linkmode_zero(pl->supported);
+ linkmode_zero(pl->advertising);
+ linkmode_zero(config->advertising);
}
goto exit;@@ -2425,6 +2451,133 @@ void phylink_update_mac_pause_capabilities(struct phylink *pl, unsigned long mac
}
EXPORT_SYMBOL_GPL(phylink_update_mac_pause_capabilities);
+static void phylink_del_pcs(struct phylink *pl, struct phylink_pcs *pcs)
+{
+ ASSERT_RTNL();
+
+ lockdep_assert_held(&pl->state_mutex);
+
+ rcu_assign_pointer(pcs->phylink, NULL);
+ synchronize_rcu();
+ list_del(&pcs->list);
+
+ /*
+ * Check if we are removing the PCS currently
+ * in use by this phylink instance. If this is the case,
+ * tear down the link, force phylink resolve to reconfigure the
+ * interface mode, disable the current PCS and set the
+ * phylink PCS to NULL.
+ */
+ if (pl->pcs == pcs) {
+ if (pl->old_link_state) {
+ phylink_link_down(pl);
+ pl->old_link_state = false;
+ }
+ if (pl->cfg_link_an_mode == MLO_AN_INBAND)
+ timer_delete_sync(&pl->link_poll);
+
+ if (pl->pcs_state != PCS_STATE_DOWN)
+ phylink_pcs_disable(pl->pcs);
+
+ if (!pl->phylink_disable_state)
+ pl->force_major_config = true;
+
+ WRITE_ONCE(pl->pcs, NULL);
+ }
+}
+
+static int pcs_provider_notify(struct notifier_block *self,
+ unsigned long val, void *data)
+{
+ struct phylink *pl = container_of(self, struct phylink, fwnode_pcs_nb);
+ struct fwnode_pcs_provider *pp = data;
+ struct phylink_pcs *pcs, *tmp;
+ struct phy_device *phydev;
+ bool resolve = false;
+
+ rtnl_lock();
+ mutex_lock(&pl->phydev_mutex);
+ phydev = pl->phydev;
+ if (phydev)
+ mutex_lock(&phydev->lock);
+ mutex_lock(&pl->state_mutex);
+
+ /* phylink instance is being destroyed, ignore any event */
+ if (pl->pcs_state == PCS_STATE_DETACHING)
+ goto exit;
+
+ /*
+ * Loop all the PCS for phylink instance and check if
+ * this notification is relevant for some of them.
+ */
+ list_for_each_entry_safe(pcs, tmp, &pl->pcs_list, list) {
+ if (!fwnode_pcs_matches_provider(pp, pl->fwnode, pcs))
+ continue;
+
+ phylink_del_pcs(pl, pcs);
+ resolve = true;
+ }
+
+ /* Exit early if nothing has changed */
+ if (!resolve)
+ goto exit;
+
+ /* Refresh supported interfaces */
+ phy_interface_copy(pl->supported_interfaces,
+ pl->config->supported_interfaces);
+ list_for_each_entry(pcs, &pl->pcs_list, list)
+ phy_interface_or(pl->supported_interfaces,
+ pl->supported_interfaces,
+ pcs->supported_interfaces);
+
+ /* Recalculate capabilities */
+ phylink_update_capabilities(pl, &pl->link_config);
+
+exit:
+ mutex_unlock(&pl->state_mutex);
+ if (phydev)
+ mutex_unlock(&phydev->lock);
+ mutex_unlock(&pl->phydev_mutex);
+ rtnl_unlock();
+
+ if (resolve)
+ phylink_run_resolve(pl);
+
+ return resolve ? NOTIFY_OK : NOTIFY_DONE;
+}
+
+static void phylink_detach_pcss(struct phylink *pl)
+{
+ struct phylink_pcs *pcs, *tmp;
+ bool rcu_sync = false;
+
+ mutex_lock(&pl->state_mutex);
+
+ pl->pcs_state = PCS_STATE_DETACHING;
+
+ /* Remove every PCS from phylink PCS list */
+ list_for_each_entry_safe(pcs, tmp, &pl->pcs_list, list) {
+ rcu_assign_pointer(pcs->phylink, NULL);
+ list_del(&pcs->list);
+ rcu_sync = true;
+ }
+
+ if (pl->pcs) {
+ rcu_assign_pointer(pl->pcs->phylink, NULL);
+ WRITE_ONCE(pl->pcs, NULL);
+ rcu_sync = true;
+ }
+
+ if (rcu_sync)
+ synchronize_rcu();
+
+ mutex_unlock(&pl->state_mutex);
+
+ /* Unregister notifier for late PCS attach */
+ if (pl->fwnode_pcs_nb.notifier_call)
+ unregister_fwnode_pcs_notifier(&pl->fwnode_pcs_nb);
+}
+
/**
* phylink_create() - create a phylink instance
* @config: a pointer to the target &struct phylink_config@@ -2446,7 +2599,7 @@ struct phylink *phylink_create(struct phylink_config *config,
phy_interface_t iface,
const struct phylink_mac_ops *mac_ops)
{
- struct phylink_pcs *tmp, *pcs;
+ struct phylink_pcs *pcs;
struct phylink *pl;
int ret;
@@ -2515,10 +2668,18 @@ struct phylink *phylink_create(struct phylink_config *config,
__set_bit(PHYLINK_DISABLE_STOPPED, &pl->phylink_disable_state);
timer_setup(&pl->link_poll, phylink_fixed_poll, 0);
+ /* First register notifier for hotplug PCS events */
+ if (!phy_interface_empty(config->pcs_interfaces)) {
+ pl->fwnode_pcs_nb.notifier_call = pcs_provider_notify;
+ register_fwnode_pcs_notifier(&pl->fwnode_pcs_nb);
+ }
+
/* Fill the PCS list with available PCS from phylink config */
ret = phylink_fill_available_pcs(pl, config);
if (ret < 0)
- goto free_pl;
+ goto unregister_pcs_notify;
+
+ mutex_lock(&pl->state_mutex);
/* Link available PCS to phylink */
list_for_each_entry(pcs, &pl->pcs_list, list)@@ -2533,13 +2694,13 @@ struct phylink *phylink_create(struct phylink_config *config,
pl->supported_interfaces,
pcs->supported_interfaces);
- mutex_lock(&pl->state_mutex);
phylink_update_capabilities(pl, &pl->link_config);
+
mutex_unlock(&pl->state_mutex);
ret = phylink_parse_mode(pl, fwnode);
if (ret < 0)
- goto unlink_pcs_list;
+ goto unregister_pcs_notify;
if (pl->cfg_link_an_mode == MLO_AN_FIXED) {
ret = phylink_parse_fixedlink(pl, fwnode);@@ -2558,14 +2719,10 @@ struct phylink *phylink_create(struct phylink_config *config,
release_link_gpio:
if (pl->link_gpio)
gpiod_put(pl->link_gpio);
-unlink_pcs_list:
- list_for_each_entry(pcs, &pl->pcs_list, list)
- rcu_assign_pointer(pcs->phylink, NULL);
-
- synchronize_rcu();
-
- list_for_each_entry_safe(pcs, tmp, &pl->pcs_list, list)
- list_del(&pcs->list);
+unregister_pcs_notify:
+ phylink_detach_pcss(pl);
+ /* previous PCS notifier might have queued a resolve, cancel it */
+ cancel_work_sync(&pl->resolve);
free_pl:
fwnode_handle_put(pl->fwnode);
kfree(pl);
@@ -2584,29 +2741,15 @@ EXPORT_SYMBOL_GPL(phylink_create);
*/
void phylink_destroy(struct phylink *pl)
{
- struct phylink_pcs *pcs, *tmp;
-
sfp_bus_del_upstream(pl->sfp_bus);
phylink_destroy_sfp_cage_port(pl);
if (pl->link_gpio)
gpiod_put(pl->link_gpio);
- /* Remove phylink instance from every PCS */
- list_for_each_entry(pcs, &pl->pcs_list, list)
- rcu_assign_pointer(pcs->phylink, NULL);
-
- if (pl->pcs)
- rcu_assign_pointer(pl->pcs->phylink, NULL);
-
- if (pl->pcs || !list_empty(&pl->pcs_list))
- synchronize_rcu();
+ phylink_detach_pcss(pl);
cancel_work_sync(&pl->resolve);
- /* Remove every PCS from phylink PCS list */
- list_for_each_entry_safe(pcs, tmp, &pl->pcs_list, list)
- list_del(&pcs->list);
-
fwnode_handle_put(pl->fwnode);
kfree(pl);diff --git a/include/linux/pcs/pcs.h b/include/linux/pcs/pcs.h
index ef2134c578c7..83e0a2ad4b09 100644
--- a/include/linux/pcs/pcs.h
+++ b/include/linux/pcs/pcs.h
@@ -4,7 +4,38 @@
#include <linux/phylink.h>
+enum fwnode_pcs_notify_event {
+ FWNODE_PCS_PROVIDER_DEL,
+};
+
+struct fwnode_pcs_provider;
+
#if IS_ENABLED(CONFIG_FWNODE_PCS)
+/**
+ * register_fwnode_pcs_notifier - Register a notifier block for fwnode
+ * PCS events
+ * @nb: pointer to the notifier block
+ *
+ * Registers a notifier block to the fwnode_pcs_notify_list blocking
+ * notifier chain. This allows phylink instance to subscribe for
+ * PCS provider events.
+ *
+ * Returns: 0 or a negative error.
+ */
+int register_fwnode_pcs_notifier(struct notifier_block *nb);
+
+/**
+ * unregister_fwnode_pcs_notifier - Unregister a notifier block for fwnode
+ * PCS events
+ * @nb: pointer to the notifier block
+ *
+ * Unregisters a notifier block to the fwnode_pcs_notify_list blocking
+ * notifier chain.
+ *
+ * Returns: 0 or a negative error.
+ */
+int unregister_fwnode_pcs_notifier(struct notifier_block *nb);
+
/**
* fwnode_pcs_get - Retrieves a PCS from a firmware node
* @fwnode: firmware node@@ -19,6 +50,27 @@
struct phylink_pcs *fwnode_pcs_get(const struct fwnode_handle *fwnode,
unsigned int index);
+/**
+ * fwnode_pcs_matches_provider() - Check whether a PCS belongs to a provider
+ * @provider: PCS provider to check
+ * @fwnode: firmware node containing the PCS references
+ * @pl_pcs: PCS to check
+ *
+ * Parse the PCS references from the "pcs-handle" property of a firmware node
+ * and use provider to determine whether pl_pcs is one of the PCS provided by
+ * provider.
+ *
+ * This function is intended to be used when handling provider removal
+ * notifications, where the provider is already known and its PCS need to be
+ * identified among the PCS associated with a phylink instance.
+ *
+ * Returns: true if pl_pcs is provided by provider and referenced by fwnode,
+ * false otherwise.
+ */
+bool fwnode_pcs_matches_provider(struct fwnode_pcs_provider *provider,
+ const struct fwnode_handle *fwnode,
+ struct phylink_pcs *pl_pcs);
+
/**
* fwnode_phylink_pcs_count - Count PCS entries described in firmware node
* @fwnode: firmware node
@@ -52,12 +104,29 @@ int fwnode_phylink_pcs_parse(struct fwnode_handle *fwnode,
struct phylink_pcs **available_pcs,
unsigned int num_pcs);
#else
+static inline int register_fwnode_pcs_notifier(struct notifier_block *nb)
+{
+ return -EOPNOTSUPP;
+}
+
+static inline int unregister_fwnode_pcs_notifier(struct notifier_block *nb)
+{
+ return -EOPNOTSUPP;
+}
+
static inline struct phylink_pcs *fwnode_pcs_get(const struct fwnode_handle *fwnode,
unsigned int index)
{
return ERR_PTR(-ENOENT);
}
+static inline bool fwnode_pcs_matches_provider(struct fwnode_pcs_provider *provider,
+ const struct fwnode_handle *fwnode,
+ struct phylink_pcs *pl_pcs)
+{
+ return false;
+}
+
static inline unsigned int fwnode_phylink_pcs_count(struct fwnode_handle *fwnode)
{
return 0;--
2.55.0