diff --git a/drivers/net/pcs/pcs.c b/drivers/net/pcs/pcs.c
index 39550d9a12a2..25b3248e8b93 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 957241652525..f8fc52c73646 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>
@@ -68,6 +70,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.@@ -722,6 +725,8 @@ static void phylink_calculate_capabilities(struct phylink *pl)
{
__ETHTOOL_DECLARE_LINK_MODE_MASK(disabled_advertising);
+ lockdep_assert_held(&pl->state_mutex);
+
/* Get user-disabled advertising modes */
linkmode_xor(disabled_advertising, pl->advertising,
pl->link_config.advertising);@@ -729,7 +734,7 @@ static void phylink_calculate_capabilities(struct phylink *pl)
/* Calculate the full supported advertisement */
linkmode_fill(pl->supported);
linkmode_copy(pl->link_config.advertising, pl->supported);
- phylink_validate(pl, pl->supported, &pl->link_config);
+ __phylink_validate(pl, pl->supported, &pl->link_config);
/* Save the newly calculated full advertisement */
linkmode_copy(pl->advertising, pl->link_config.advertising);
@@ -1058,6 +1063,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,@@ -1074,9 +1082,14 @@ static unsigned int phylink_inband_caps(struct phylink *pl,
}
if (IS_ERR_OR_NULL(pcs))
- return 0;
+ goto exit;
+
+ ret = phylink_pcs_inband_caps(pcs, interface);
- return phylink_pcs_inband_caps(pcs, interface);
+exit:
+ mutex_unlock(&pl->state_mutex);
+
+ return ret;
}
static void phylink_pcs_poll_stop(struct phylink *pl)
@@ -1617,7 +1630,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);
}
@@ -2047,6 +2062,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;
@@ -2066,11 +2084,91 @@ static int phylink_fill_available_pcs(struct phylink *pl,
}
out:
+ mutex_unlock(&pl->state_mutex);
+
kfree(pcss);
return ret;
}
+static void phylink_del_pcs(struct phylink *pl, struct phylink_pcs *pcs)
+{
+ 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);
+ phylink_pcs_disable(pl->pcs);
+
+ 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;
+ bool resolve = false;
+
+ rtnl_lock();
+ mutex_lock(&pl->state_mutex);
+
+ /*
+ * 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) {
+ mutex_unlock(&pl->state_mutex);
+ rtnl_unlock();
+ return NOTIFY_DONE;
+ }
+
+ /* 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_calculate_capabilities(pl);
+
+ mutex_unlock(&pl->state_mutex);
+ rtnl_unlock();
+
+ phylink_run_resolve(pl);
+
+ return NOTIFY_OK;
+}
+
/**
* phylink_update_pause_state() - Update the phylink pause frame configuration
* @pl: a pointer to a &struct phylink instance@@ -2281,10 +2379,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)@@ -2301,9 +2407,11 @@ struct phylink *phylink_create(struct phylink_config *config,
phylink_calculate_capabilities(pl);
+ 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);@@ -2322,14 +2430,18 @@ struct phylink *phylink_create(struct phylink_config *config,
release_link_gpio:
if (pl->link_gpio)
gpiod_put(pl->link_gpio);
-unlink_pcs_list:
+unregister_pcs_notify:
+ if (pl->fwnode_pcs_nb.notifier_call)
+ unregister_fwnode_pcs_notifier(&pl->fwnode_pcs_nb);
list_for_each_entry(pcs, &pl->pcs_list, list)
rcu_assign_pointer(pcs->phylink, NULL);
-
synchronize_rcu();
-
+ /* PCS notifier might queue a resolve, cancel it */
+ cancel_work_sync(&pl->resolve);
+ mutex_lock(&pl->state_mutex);
list_for_each_entry_safe(pcs, tmp, &pl->pcs_list, list)
list_del(&pcs->list);
+ mutex_unlock(&pl->state_mutex);
free_pl:
fwnode_handle_put(pl->fwnode);
kfree(pl);
@@ -2355,6 +2467,10 @@ void phylink_destroy(struct phylink *pl)
if (pl->link_gpio)
gpiod_put(pl->link_gpio);
+ /* Unregister notifier for late PCS attach */
+ if (pl->fwnode_pcs_nb.notifier_call)
+ unregister_fwnode_pcs_notifier(&pl->fwnode_pcs_nb);
+
/* Remove phylink instance from every PCS */
list_for_each_entry(pcs, &pl->pcs_list, list)
rcu_assign_pointer(pcs->phylink, NULL);
@@ -2367,10 +2483,14 @@ void phylink_destroy(struct phylink *pl)
cancel_work_sync(&pl->resolve);
+ mutex_lock(&pl->state_mutex);
+
/* Remove every PCS from phylink PCS list */
list_for_each_entry_safe(pcs, tmp, &pl->pcs_list, list)
list_del(&pcs->list);
+ mutex_unlock(&pl->state_mutex);
+
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