[PATCH v3 3/4] ASoC: qcom: lpass macro / soundwire: asynchronous probe with clock retry

[Daniel Carter <yass27106@gmail.com>]

The LPASS WSA/RX/TX/VA macro and Qualcomm SoundWire drivers request
clocks whose providers (va-macro fsgen, the q6prm clock controller
under the ADSP GPR service) can register after the consumers probe.
Clock-provider registration does not trigger deferred-probe retries,
so consumers stay deferred indefinitely.

Add a bounded retry (60 x 500 ms) around the clock acquisition in
these drivers, share the retry helpers through lpass-macro-common.h,
and mark the drivers PROBE_PREFER_ASYNCHRONOUS so a retrying consumer
does not block the probe of the clock supplier it is waiting for.

Signed-off-by: Daniel Carter <yass27106@gmail.com>
---
 drivers/soundwire/qcom.c              | 24 +++++++++++++++-
 sound/soc/codecs/lpass-macro-common.h | 40 +++++++++++++++++++++++++++
 sound/soc/codecs/lpass-rx-macro.c     | 11 ++++----
 sound/soc/codecs/lpass-tx-macro.c     | 11 ++++----
 sound/soc/codecs/lpass-va-macro.c     |  9 +++---
 sound/soc/codecs/lpass-wsa-macro.c    | 11 ++++----
 6 files changed, 86 insertions(+), 20 deletions(-)

diff --git a/drivers/soundwire/qcom.c b/drivers/soundwire/qcom.c
index 6e0c5fb10ef..473449dbdfa 100644
--- a/drivers/soundwire/qcom.c
+++ b/drivers/soundwire/qcom.c
@@ -21,6 +21,27 @@
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
 #include "bus.h"
+#include <linux/delay.h>
+
+/*
+ * Bounded retry for deferred clock providers. Clock-provider
+ * registration does not trigger deferred-probe retries, so a consumer
+ * that loses the probe-order race stays deferred forever. Wait up to
+ * 30 s for providers that are registered milliseconds later.
+ */
+static struct clk *clk_get_retry(struct device *dev, const char *id)
+{
+	struct clk *c;
+	int i;
+
+	for (i = 0; i < 60; i++) {
+		c = clk_get_retry(dev, id);
+		if (!IS_ERR(c) || PTR_ERR(c) != -EPROBE_DEFER)
+			return c;
+		msleep(500);
+	}
+	return c;
+}
 
 #define SWRM_COMP_SW_RESET					0x008
 #define SWRM_COMP_STATUS					0x014
@@ -1669,7 +1690,7 @@ static int qcom_swrm_probe(struct platform_device *pdev)
 		goto err_init;
 	}
 
-	ctrl->hclk = devm_clk_get(dev, "iface");
+	ctrl->hclk = clk_get_retry(dev, "iface");
 	if (IS_ERR(ctrl->hclk)) {
 		ret = dev_err_probe(dev, PTR_ERR(ctrl->hclk), "unable to get iface clock\n");
 		goto err_init;
@@ -1921,6 +1942,7 @@ static struct platform_driver qcom_swrm_driver = {
 	.remove = qcom_swrm_remove,
 	.driver = {
 		.name	= "qcom-soundwire",
+		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
 		.of_match_table = qcom_swrm_of_match,
 		.pm = &swrm_dev_pm_ops,
 	}
diff --git a/sound/soc/codecs/lpass-macro-common.h b/sound/soc/codecs/lpass-macro-common.h
index 10ad682019f..83bc7075a28 100644
--- a/sound/soc/codecs/lpass-macro-common.h
+++ b/sound/soc/codecs/lpass-macro-common.h
@@ -6,6 +6,9 @@
 #ifndef __LPASS_MACRO_COMMON_H__
 #define __LPASS_MACRO_COMMON_H__
 
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/clk.h>
 /* NPL clock is expected */
 #define LPASS_MACRO_FLAG_HAS_NPL_CLOCK		BIT(0)
 /* The soundwire block should be internally reset at probe */
@@ -74,4 +77,41 @@ static inline const char *lpass_macro_get_codec_version_string(int version)
 	return "NA";
 }
 
+
+/*
+ * Bounded retry for deferred clock providers. Clock-provider
+ * registration does not trigger deferred-probe retries, so a consumer
+ * that loses the probe-order race stays deferred forever. Wait up to
+ * 30 s for providers that are registered milliseconds later.
+ */
+static inline struct clk *
+lpass_macro_clk_get_retry(struct device *dev, const char *id)
+{
+	struct clk *c;
+	int i;
+
+	for (i = 0; i < 60; i++) {
+		c = devm_clk_get(dev, id);
+		if (!IS_ERR(c) || PTR_ERR(c) != -EPROBE_DEFER)
+			return c;
+		msleep(500);
+	}
+	return c;
+}
+
+static inline struct clk *
+lpass_macro_clk_get_retry_optional(struct device *dev, const char *id)
+{
+	struct clk *c;
+	int i;
+
+	for (i = 0; i < 60; i++) {
+		c = devm_clk_get_optional(dev, id);
+		if (!IS_ERR(c) || PTR_ERR(c) != -EPROBE_DEFER)
+			return c;
+		msleep(500);
+	}
+	return c;
+}
+
 #endif /* __LPASS_MACRO_COMMON_H__ */
diff --git a/sound/soc/codecs/lpass-rx-macro.c b/sound/soc/codecs/lpass-rx-macro.c
index c41eb8de616..658bf947aac 100644
--- a/sound/soc/codecs/lpass-rx-macro.c
+++ b/sound/soc/codecs/lpass-rx-macro.c
@@ -3780,25 +3780,25 @@ static int rx_macro_probe(struct platform_device *pdev)
 	if (!rx)
 		return -ENOMEM;
 
-	rx->macro = devm_clk_get_optional(dev, "macro");
+	rx->macro = lpass_macro_clk_get_retry_optional(dev, "macro");
 	if (IS_ERR(rx->macro))
 		return dev_err_probe(dev, PTR_ERR(rx->macro), "unable to get macro clock\n");
 
-	rx->dcodec = devm_clk_get_optional(dev, "dcodec");
+	rx->dcodec = lpass_macro_clk_get_retry_optional(dev, "dcodec");
 	if (IS_ERR(rx->dcodec))
 		return dev_err_probe(dev, PTR_ERR(rx->dcodec), "unable to get dcodec clock\n");
 
-	rx->mclk = devm_clk_get(dev, "mclk");
+	rx->mclk = lpass_macro_clk_get_retry(dev, "mclk");
 	if (IS_ERR(rx->mclk))
 		return dev_err_probe(dev, PTR_ERR(rx->mclk), "unable to get mclk clock\n");
 
 	if (flags & LPASS_MACRO_FLAG_HAS_NPL_CLOCK) {
-		rx->npl = devm_clk_get(dev, "npl");
+		rx->npl = lpass_macro_clk_get_retry(dev, "npl");
 		if (IS_ERR(rx->npl))
 			return dev_err_probe(dev, PTR_ERR(rx->npl), "unable to get npl clock\n");
 	}
 
-	rx->fsgen = devm_clk_get(dev, "fsgen");
+	rx->fsgen = lpass_macro_clk_get_retry(dev, "fsgen");
 	if (IS_ERR(rx->fsgen))
 		return dev_err_probe(dev, PTR_ERR(rx->fsgen), "unable to get fsgen clock\n");
 
@@ -4005,6 +4005,7 @@ static const struct dev_pm_ops rx_macro_pm_ops = {
 static struct platform_driver rx_macro_driver = {
 	.driver = {
 		.name = "rx_macro",
+		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
 		.of_match_table = rx_macro_dt_match,
 		.suppress_bind_attrs = true,
 		.pm = pm_ptr(&rx_macro_pm_ops),
diff --git a/sound/soc/codecs/lpass-tx-macro.c b/sound/soc/codecs/lpass-tx-macro.c
index 6deaaabe43a..329e1304b38 100644
--- a/sound/soc/codecs/lpass-tx-macro.c
+++ b/sound/soc/codecs/lpass-tx-macro.c
@@ -2258,25 +2258,25 @@ static int tx_macro_probe(struct platform_device *pdev)
 
 	tx->data = device_get_match_data(dev);
 
-	tx->macro = devm_clk_get_optional(dev, "macro");
+	tx->macro = lpass_macro_clk_get_retry_optional(dev, "macro");
 	if (IS_ERR(tx->macro))
 		return dev_err_probe(dev, PTR_ERR(tx->macro), "unable to get macro clock\n");
 
-	tx->dcodec = devm_clk_get_optional(dev, "dcodec");
+	tx->dcodec = lpass_macro_clk_get_retry_optional(dev, "dcodec");
 	if (IS_ERR(tx->dcodec))
 		return dev_err_probe(dev, PTR_ERR(tx->dcodec), "unable to get dcodec clock\n");
 
-	tx->mclk = devm_clk_get(dev, "mclk");
+	tx->mclk = lpass_macro_clk_get_retry(dev, "mclk");
 	if (IS_ERR(tx->mclk))
 		return dev_err_probe(dev, PTR_ERR(tx->mclk), "unable to get mclk clock\n");
 
 	if (tx->data->flags & LPASS_MACRO_FLAG_HAS_NPL_CLOCK) {
-		tx->npl = devm_clk_get(dev, "npl");
+		tx->npl = lpass_macro_clk_get_retry(dev, "npl");
 		if (IS_ERR(tx->npl))
 			return dev_err_probe(dev, PTR_ERR(tx->npl), "unable to get npl clock\n");
 	}
 
-	tx->fsgen = devm_clk_get(dev, "fsgen");
+	tx->fsgen = lpass_macro_clk_get_retry(dev, "fsgen");
 	if (IS_ERR(tx->fsgen))
 		return dev_err_probe(dev, PTR_ERR(tx->fsgen), "unable to get fsgen clock\n");
 
@@ -2515,6 +2515,7 @@ MODULE_DEVICE_TABLE(of, tx_macro_dt_match);
 static struct platform_driver tx_macro_driver = {
 	.driver = {
 		.name = "tx_macro",
+		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
 		.of_match_table = tx_macro_dt_match,
 		.suppress_bind_attrs = true,
 		.pm = pm_ptr(&tx_macro_pm_ops),
diff --git a/sound/soc/codecs/lpass-va-macro.c b/sound/soc/codecs/lpass-va-macro.c
index 03d6434a4a1..e718edd732e 100644
--- a/sound/soc/codecs/lpass-va-macro.c
+++ b/sound/soc/codecs/lpass-va-macro.c
@@ -1557,15 +1557,15 @@ static int va_macro_probe(struct platform_device *pdev)
 
 	va->dev = dev;
 
-	va->macro = devm_clk_get_optional(dev, "macro");
+	va->macro = lpass_macro_clk_get_retry_optional(dev, "macro");
 	if (IS_ERR(va->macro))
 		return dev_err_probe(dev, PTR_ERR(va->macro), "unable to get macro clock\n");
 
-	va->dcodec = devm_clk_get_optional(dev, "dcodec");
+	va->dcodec = lpass_macro_clk_get_retry_optional(dev, "dcodec");
 	if (IS_ERR(va->dcodec))
 		return dev_err_probe(dev, PTR_ERR(va->dcodec), "unable to get dcodec clock\n");
 
-	va->mclk = devm_clk_get(dev, "mclk");
+	va->mclk = lpass_macro_clk_get_retry(dev, "mclk");
 	if (IS_ERR(va->mclk))
 		return dev_err_probe(dev, PTR_ERR(va->mclk), "unable to get mclk clock\n");
 
@@ -1610,7 +1610,7 @@ static int va_macro_probe(struct platform_device *pdev)
 		goto err;
 
 	if (va->has_npl_clk) {
-		va->npl = devm_clk_get(dev, "npl");
+		va->npl = lpass_macro_clk_get_retry(dev, "npl");
 		if (IS_ERR(va->npl)) {
 			ret = PTR_ERR(va->npl);
 			goto err;
@@ -1782,6 +1782,7 @@ MODULE_DEVICE_TABLE(of, va_macro_dt_match);
 static struct platform_driver va_macro_driver = {
 	.driver = {
 		.name = "va_macro",
+		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
 		.of_match_table = va_macro_dt_match,
 		.suppress_bind_attrs = true,
 		.pm = pm_ptr(&va_macro_pm_ops),
diff --git a/sound/soc/codecs/lpass-wsa-macro.c b/sound/soc/codecs/lpass-wsa-macro.c
index 899c8bee464..02fca60edf4 100644
--- a/sound/soc/codecs/lpass-wsa-macro.c
+++ b/sound/soc/codecs/lpass-wsa-macro.c
@@ -2701,25 +2701,25 @@ static int wsa_macro_probe(struct platform_device *pdev)
 	if (!wsa)
 		return -ENOMEM;
 
-	wsa->macro = devm_clk_get_optional(dev, "macro");
+	wsa->macro = lpass_macro_clk_get_retry_optional(dev, "macro");
 	if (IS_ERR(wsa->macro))
 		return dev_err_probe(dev, PTR_ERR(wsa->macro), "unable to get macro clock\n");
 
-	wsa->dcodec = devm_clk_get_optional(dev, "dcodec");
+	wsa->dcodec = lpass_macro_clk_get_retry_optional(dev, "dcodec");
 	if (IS_ERR(wsa->dcodec))
 		return dev_err_probe(dev, PTR_ERR(wsa->dcodec), "unable to get dcodec clock\n");
 
-	wsa->mclk = devm_clk_get(dev, "mclk");
+	wsa->mclk = lpass_macro_clk_get_retry(dev, "mclk");
 	if (IS_ERR(wsa->mclk))
 		return dev_err_probe(dev, PTR_ERR(wsa->mclk), "unable to get mclk clock\n");
 
 	if (flags & LPASS_MACRO_FLAG_HAS_NPL_CLOCK) {
-		wsa->npl = devm_clk_get(dev, "npl");
+		wsa->npl = lpass_macro_clk_get_retry(dev, "npl");
 		if (IS_ERR(wsa->npl))
 			return dev_err_probe(dev, PTR_ERR(wsa->npl), "unable to get npl clock\n");
 	}
 
-	wsa->fsgen = devm_clk_get(dev, "fsgen");
+	wsa->fsgen = lpass_macro_clk_get_retry(dev, "fsgen");
 	if (IS_ERR(wsa->fsgen))
 		return dev_err_probe(dev, PTR_ERR(wsa->fsgen), "unable to get fsgen clock\n");
 
@@ -2917,6 +2917,7 @@ MODULE_DEVICE_TABLE(of, wsa_macro_dt_match);
 static struct platform_driver wsa_macro_driver = {
 	.driver = {
 		.name = "wsa_macro",
+		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
 		.of_match_table = wsa_macro_dt_match,
 		.pm = pm_ptr(&wsa_macro_pm_ops),
 	},
-- 
2.55.0