[PATCH 00/15] ASoC/soundwire: Realtek codecs: wait codec init in hw_params

[PATCH 00/15] ASoC/soundwire: Realtek codecs: wait codec init in hw_params

[Bard Liao]

The current code waits for the codec initialization in the resume
callback. It could cause the resume takes a long time while waiting for
the codec being attached and initialized. Move the waiting to the
hw_params callback when the driver really needs it and shorten the
resume time.
The change is mainly on the ASoC tree. Let's go through the ASoC tree.

Bard Liao (15):
  soundwire: add sdw_slave_wait_for_initialization helper
  ASoC: rt722: wait codec init in hw_params
  ASoC: rt712: wait codec init in hw_params
  ASoC: rt1320: wait codec init in hw_params
  ASoC: rt721: wait codec init in hw_params
  ASoC: rt715-sdca: wait codec init in hw_params
  ASoC: rt711-sdca: wait codec init in hw_params
  ASoC: rt711: wait codec init in hw_params
  ASoC: rt715: wait codec init in hw_params
  ASoC: rt700: wait codec init in hw_params
  ASoC: rt1316: wait codec init in hw_params
  ASoC: rt1318: wait codec init in hw_params
  ASoC: rt1308: wait codec init in hw_params
  ASoC: rt5682: wait codec init in hw_params
  ASoC: rt1017: wait codec init in hw_params

 drivers/soundwire/slave.c          | 17 ++++++++++++++
 include/linux/soundwire/sdw.h      |  1 +
 sound/soc/codecs/rt1017-sdca-sdw.c | 32 ++++++++++++++++----------
 sound/soc/codecs/rt1308-sdw.c      | 32 ++++++++++++++++----------
 sound/soc/codecs/rt1316-sdw.c      | 32 ++++++++++++++++----------
 sound/soc/codecs/rt1318-sdw.c      | 30 ++++++++++++++++--------
 sound/soc/codecs/rt1320-sdw.c      | 32 ++++++++++++++++++--------
 sound/soc/codecs/rt5682-sdw.c      | 29 +++++++++++++++--------
 sound/soc/codecs/rt700-sdw.c       | 27 ++++++++++++----------
 sound/soc/codecs/rt700.c           |  6 +++++
 sound/soc/codecs/rt711-sdca-sdw.c  | 28 ++++++++++++----------
 sound/soc/codecs/rt711-sdca.c      |  6 +++++
 sound/soc/codecs/rt711-sdw.c       | 26 +++++++++++++--------
 sound/soc/codecs/rt711.c           |  6 +++++
 sound/soc/codecs/rt712-sdca-sdw.c  | 28 ++++++++++++----------
 sound/soc/codecs/rt712-sdca.c      |  6 +++++
 sound/soc/codecs/rt715-sdca-sdw.c  | 37 ++++++++++++++++++++----------
 sound/soc/codecs/rt715-sdca.c      |  6 +++++
 sound/soc/codecs/rt715-sdw.c       | 27 ++++++++++++----------
 sound/soc/codecs/rt715.c           |  6 +++++
 sound/soc/codecs/rt721-sdca-sdw.c  | 29 ++++++++++++-----------
 sound/soc/codecs/rt721-sdca.c      |  6 +++++
 sound/soc/codecs/rt722-sdca-sdw.c  | 26 +++++++++++----------
 sound/soc/codecs/rt722-sdca.c      |  6 +++++
 24 files changed, 320 insertions(+), 161 deletions(-)

-- 
2.43.0

[PATCH 01/15] soundwire: add sdw_slave_wait_for_initialization helper

[Bard Liao]

waiting for slave->initialization_complete is commonly used by SoundWire
codec drivers. Add a helper to reduce the duplicated code.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 drivers/soundwire/slave.c     | 17 +++++++++++++++++
 include/linux/soundwire/sdw.h |  1 +
 2 files changed, 18 insertions(+)

diff --git a/drivers/soundwire/slave.c b/drivers/soundwire/slave.c
index d2d99555ec5a..5d45adb28491 100644
--- a/drivers/soundwire/slave.c
+++ b/drivers/soundwire/slave.c
@@ -104,6 +104,23 @@ int sdw_slave_add(struct sdw_bus *bus,
 }
 EXPORT_SYMBOL(sdw_slave_add);
 
+int sdw_slave_wait_for_initialization(struct sdw_slave *slave, unsigned int timeout)
+{
+	unsigned long time;
+
+	time = wait_for_completion_timeout(&slave->initialization_complete,
+					   msecs_to_jiffies(timeout));
+	if (!time) {
+		dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
+		sdw_show_ping_status(slave->bus, true);
+
+		return -ETIMEDOUT;
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL(sdw_slave_wait_for_initialization);
+
 #if IS_ENABLED(CONFIG_ACPI)
 
 static bool find_slave(struct sdw_bus *bus,
diff --git a/include/linux/soundwire/sdw.h b/include/linux/soundwire/sdw.h
index 0832776262ac..961a10af12c1 100644
--- a/include/linux/soundwire/sdw.h
+++ b/include/linux/soundwire/sdw.h
@@ -1087,6 +1087,7 @@ int sdw_stream_remove_slave(struct sdw_slave *slave,
 			    struct sdw_stream_runtime *stream);
 
 int sdw_slave_get_scale_index(struct sdw_slave *slave, u8 *base);
+int sdw_slave_wait_for_initialization(struct sdw_slave *slave, unsigned int timeout);
 
 /* messaging and data APIs */
 int sdw_read(struct sdw_slave *slave, u32 addr);
-- 
2.43.0

[PATCH 02/15] ASoC: rt722: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt722_sdca_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt722-sdca-sdw.c | 26 ++++++++++++++------------
 sound/soc/codecs/rt722-sdca.c     |  6 ++++++
 2 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/sound/soc/codecs/rt722-sdca-sdw.c b/sound/soc/codecs/rt722-sdca-sdw.c
index 70700bdb80a1..b72d169bf15e 100644
--- a/sound/soc/codecs/rt722-sdca-sdw.c
+++ b/sound/soc/codecs/rt722-sdca-sdw.c
@@ -209,6 +209,7 @@ static int rt722_sdca_update_status(struct sdw_slave *slave,
 				enum sdw_slave_status status)
 {
 	struct rt722_sdca_priv *rt722 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt722->hw_init = false;
@@ -236,7 +237,18 @@ static int rt722_sdca_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt722_sdca_io_init(&slave->dev, slave);
+	ret = rt722_sdca_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "IO init failed: %d\n", ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt722->regmap, false);
+		regcache_sync(rt722->regmap);
+	}
+
+	return ret;
 }
 
 static int rt722_sdca_read_prop(struct sdw_slave *slave)
@@ -495,13 +507,10 @@ static int rt722_sdca_dev_system_suspend(struct device *dev)
 	return rt722_sdca_dev_suspend(dev);
 }
 
-#define RT722_PROBE_TIMEOUT 5000
-
 static int rt722_sdca_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt722_sdca_priv *rt722 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt722->first_hw_init)
 		return 0;
@@ -517,14 +526,7 @@ static int rt722_sdca_dev_resume(struct device *dev)
 		goto regmap_sync;
 	}
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT722_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "Initialization not complete, timed out\n");
-		sdw_show_ping_status(slave->bus, true);
-
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
diff --git a/sound/soc/codecs/rt722-sdca.c b/sound/soc/codecs/rt722-sdca.c
index ac9588284a95..68ba252467d0 100644
--- a/sound/soc/codecs/rt722-sdca.c
+++ b/sound/soc/codecs/rt722-sdca.c
@@ -1114,6 +1114,8 @@ static void rt722_sdca_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT722_PROBE_TIMEOUT 5000
+
 static int rt722_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 				struct snd_pcm_hw_params *params,
 				struct snd_soc_dai *dai)
@@ -1168,6 +1170,10 @@ static int rt722_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 	port_config.ch_mask = GENMASK(num_channels - 1, 0);
 	port_config.num = port;
 
+	retval = sdw_slave_wait_for_initialization(rt722->slave, RT722_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt722->slave, &stream_config,
 					&port_config, 1, sdw_stream);
 	if (retval) {
-- 
2.43.0

[PATCH 03/15] ASoC: rt712: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt712_sdca_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt712-sdca-sdw.c | 28 ++++++++++++++++------------
 sound/soc/codecs/rt712-sdca.c     |  6 ++++++
 2 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/sound/soc/codecs/rt712-sdca-sdw.c b/sound/soc/codecs/rt712-sdca-sdw.c
index ea07131edfa2..183496505e90 100644
--- a/sound/soc/codecs/rt712-sdca-sdw.c
+++ b/sound/soc/codecs/rt712-sdca-sdw.c
@@ -157,6 +157,7 @@ static int rt712_sdca_update_status(struct sdw_slave *slave,
 				enum sdw_slave_status status)
 {
 	struct rt712_sdca_priv *rt712 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt712->hw_init = false;
@@ -184,7 +185,20 @@ static int rt712_sdca_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt712_sdca_io_init(&slave->dev, slave);
+	ret = rt712_sdca_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "IO init failed: %d\n", ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt712->regmap, false);
+		regcache_sync(rt712->regmap);
+		regcache_cache_only(rt712->mbq_regmap, false);
+		regcache_sync(rt712->mbq_regmap);
+	}
+
+	return ret;
 }
 
 static int rt712_sdca_read_prop(struct sdw_slave *slave)
@@ -446,13 +460,10 @@ static int rt712_sdca_dev_system_suspend(struct device *dev)
 	return rt712_sdca_dev_suspend(dev);
 }
 
-#define RT712_PROBE_TIMEOUT 5000
-
 static int rt712_sdca_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt712_sdca_priv *rt712 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt712->first_hw_init)
 		return 0;
@@ -469,14 +480,7 @@ static int rt712_sdca_dev_resume(struct device *dev)
 		goto regmap_sync;
 	}
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT712_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
-		sdw_show_ping_status(slave->bus, true);
-
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
diff --git a/sound/soc/codecs/rt712-sdca.c b/sound/soc/codecs/rt712-sdca.c
index 570c2af1245d..c8c68fda5c20 100644
--- a/sound/soc/codecs/rt712-sdca.c
+++ b/sound/soc/codecs/rt712-sdca.c
@@ -1451,6 +1451,8 @@ static void rt712_sdca_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT712_PROBE_TIMEOUT 5000
+
 static int rt712_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 				struct snd_pcm_hw_params *params,
 				struct snd_soc_dai *dai)
@@ -1505,6 +1507,10 @@ static int rt712_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 	port_config.ch_mask = GENMASK(num_channels - 1, 0);
 	port_config.num = port;
 
+	retval = sdw_slave_wait_for_initialization(rt712->slave, RT712_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt712->slave, &stream_config,
 					&port_config, 1, sdw_stream);
 	if (retval) {
-- 
2.43.0

[PATCH 04/15] ASoC: rt1320: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt1320_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt1320-sdw.c | 32 ++++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/sound/soc/codecs/rt1320-sdw.c b/sound/soc/codecs/rt1320-sdw.c
index 015cc710e6dc..e4b208be492c 100644
--- a/sound/soc/codecs/rt1320-sdw.c
+++ b/sound/soc/codecs/rt1320-sdw.c
@@ -774,6 +774,7 @@ static int rt1320_update_status(struct sdw_slave *slave,
 					enum sdw_slave_status status)
 {
 	struct  rt1320_sdw_priv *rt1320 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt1320->hw_init = false;
@@ -786,7 +787,20 @@ static int rt1320_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt1320_io_init(&slave->dev, slave);
+	ret = rt1320_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "IO init failed: %d\n", ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt1320->regmap, false);
+		regcache_sync(rt1320->regmap);
+		regcache_cache_only(rt1320->mbq_regmap, false);
+		regcache_sync(rt1320->mbq_regmap);
+	}
+
+	return ret;
 }
 
 static int rt1320_pde11_event(struct snd_soc_dapm_widget *w,
@@ -1183,6 +1197,8 @@ static void rt1320_sdw_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT1320_PROBE_TIMEOUT 5000
+
 static int rt1320_sdw_hw_params(struct snd_pcm_substream *substream,
 	struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
 {
@@ -1225,6 +1241,10 @@ static int rt1320_sdw_hw_params(struct snd_pcm_substream *substream,
 			return -EINVAL;
 	}
 
+	retval = sdw_slave_wait_for_initialization(rt1320->sdw_slave, RT1320_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	if (dai->id == RT1320_AIF1)
 		retval = sdw_stream_add_slave(rt1320->sdw_slave, &stream_config,
 				&port_config, 1, sdw_stream);
@@ -1485,13 +1505,10 @@ static int rt1320_dev_suspend(struct device *dev)
 	return 0;
 }
 
-#define RT1320_PROBE_TIMEOUT 5000
-
 static int rt1320_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt1320_sdw_priv *rt1320 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt1320->first_hw_init)
 		return 0;
@@ -1499,12 +1516,7 @@ static int rt1320_dev_resume(struct device *dev)
 	if (!slave->unattach_request)
 		goto regmap_sync;
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT1320_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
-- 
2.43.0

[PATCH 05/15] ASoC: rt721: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt721_sdca_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt721-sdca-sdw.c | 29 ++++++++++++++++-------------
 sound/soc/codecs/rt721-sdca.c     |  6 ++++++
 2 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/sound/soc/codecs/rt721-sdca-sdw.c b/sound/soc/codecs/rt721-sdca-sdw.c
index 582b47d69278..342a55116771 100644
--- a/sound/soc/codecs/rt721-sdca-sdw.c
+++ b/sound/soc/codecs/rt721-sdca-sdw.c
@@ -190,6 +190,7 @@ static int rt721_sdca_update_status(struct sdw_slave *slave,
 				enum sdw_slave_status status)
 {
 	struct rt721_sdca_priv *rt721 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt721->hw_init = false;
@@ -217,7 +218,20 @@ static int rt721_sdca_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt721_sdca_io_init(&slave->dev, slave);
+	ret = rt721_sdca_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "IO init failed: %d\n", ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt721->regmap, false);
+		regcache_sync(rt721->regmap);
+		regcache_cache_only(rt721->mbq_regmap, false);
+		regcache_sync(rt721->mbq_regmap);
+	}
+
+	return ret;
 }
 
 static int rt721_sdca_read_prop(struct sdw_slave *slave)
@@ -483,13 +497,10 @@ static int rt721_sdca_dev_system_suspend(struct device *dev)
 	return rt721_sdca_dev_suspend(dev);
 }
 
-#define RT721_PROBE_TIMEOUT 5000
-
 static int rt721_sdca_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt721_sdca_priv *rt721 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt721->first_hw_init)
 		return 0;
@@ -504,15 +515,7 @@ static int rt721_sdca_dev_resume(struct device *dev)
 		mutex_unlock(&rt721->disable_irq_lock);
 		goto regmap_sync;
 	}
-
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT721_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "Initialization not complete, timed out\n");
-		sdw_show_ping_status(slave->bus, true);
-
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
diff --git a/sound/soc/codecs/rt721-sdca.c b/sound/soc/codecs/rt721-sdca.c
index ba080957e933..91a7b6f672c6 100644
--- a/sound/soc/codecs/rt721-sdca.c
+++ b/sound/soc/codecs/rt721-sdca.c
@@ -1261,6 +1261,8 @@ static void rt721_sdca_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT721_PROBE_TIMEOUT 5000
+
 static int rt721_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 				struct snd_pcm_hw_params *params,
 				struct snd_soc_dai *dai)
@@ -1315,6 +1317,10 @@ static int rt721_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 	port_config.ch_mask = GENMASK(num_channels - 1, 0);
 	port_config.num = port;
 
+	retval = sdw_slave_wait_for_initialization(rt721->slave, RT721_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt721->slave, &stream_config,
 					&port_config, 1, sdw_stream);
 	if (retval) {
-- 
2.43.0

[PATCH 06/15] ASoC: rt715-sdca: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt715_sdca_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt715-sdca-sdw.c | 37 +++++++++++++++++++++----------
 sound/soc/codecs/rt715-sdca.c     |  6 +++++
 2 files changed, 31 insertions(+), 12 deletions(-)

diff --git a/sound/soc/codecs/rt715-sdca-sdw.c b/sound/soc/codecs/rt715-sdca-sdw.c
index ce7d8955efc3..ed0e230fc009 100644
--- a/sound/soc/codecs/rt715-sdca-sdw.c
+++ b/sound/soc/codecs/rt715-sdca-sdw.c
@@ -120,6 +120,7 @@ static int rt715_sdca_update_status(struct sdw_slave *slave,
 				enum sdw_slave_status status)
 {
 	struct rt715_sdca_priv *rt715 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	/*
 	 * Perform initialization only if slave status is present and
@@ -129,7 +130,29 @@ static int rt715_sdca_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt715_sdca_io_init(&slave->dev, slave);
+	ret = rt715_sdca_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "IO init failed: %d\n", ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt715->regmap, false);
+		regcache_sync_region(rt715->regmap,
+				     SDW_SDCA_CTL(FUN_JACK_CODEC, RT715_SDCA_ST_EN,
+						  RT715_SDCA_ST_CTRL, CH_00),
+				     SDW_SDCA_CTL(FUN_MIC_ARRAY, RT715_SDCA_SMPU_TRIG_ST_EN,
+						  RT715_SDCA_SMPU_TRIG_ST_CTRL, CH_00));
+		regcache_cache_only(rt715->mbq_regmap, false);
+		regcache_sync_region(rt715->mbq_regmap, 0x2000000, 0x61020ff);
+		regcache_sync_region(rt715->mbq_regmap,
+				     SDW_SDCA_CTL(FUN_JACK_CODEC, RT715_SDCA_ST_EN,
+						  RT715_SDCA_ST_CTRL, CH_00),
+				     SDW_SDCA_CTL(FUN_MIC_ARRAY, RT715_SDCA_SMPU_TRIG_ST_EN,
+						  RT715_SDCA_SMPU_TRIG_ST_CTRL, CH_00));
+	}
+
+	return ret;
 }
 
 static int rt715_sdca_read_prop(struct sdw_slave *slave)
@@ -220,13 +243,10 @@ static int rt715_dev_suspend(struct device *dev)
 	return 0;
 }
 
-#define RT715_PROBE_TIMEOUT 5000
-
 static int rt715_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt715_sdca_priv *rt715 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt715->first_hw_init)
 		return 0;
@@ -234,14 +254,7 @@ static int rt715_dev_resume(struct device *dev)
 	if (!slave->unattach_request)
 		goto regmap_sync;
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-					   msecs_to_jiffies(RT715_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
-		sdw_show_ping_status(slave->bus, true);
-
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
diff --git a/sound/soc/codecs/rt715-sdca.c b/sound/soc/codecs/rt715-sdca.c
index 7fb02654c16b..c2a08ae8df95 100644
--- a/sound/soc/codecs/rt715-sdca.c
+++ b/sound/soc/codecs/rt715-sdca.c
@@ -792,6 +792,8 @@ static void rt715_sdca_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT715_PROBE_TIMEOUT 5000
+
 static int rt715_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 				struct snd_pcm_hw_params *params,
 				struct snd_soc_dai *dai)
@@ -830,6 +832,10 @@ static int rt715_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 		return -EINVAL;
 	}
 
+	retval = sdw_slave_wait_for_initialization(rt715->slave, RT715_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt715->slave, &stream_config,
 					&port_config, 1, sdw_stream);
 	if (retval) {
-- 
2.43.0

[PATCH 07/15] ASoC: rt711-sdca: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt711_sdca_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt711-sdca-sdw.c | 28 ++++++++++++++++------------
 sound/soc/codecs/rt711-sdca.c     |  6 ++++++
 2 files changed, 22 insertions(+), 12 deletions(-)

diff --git a/sound/soc/codecs/rt711-sdca-sdw.c b/sound/soc/codecs/rt711-sdca-sdw.c
index 6eb05871db37..ec11e0033a28 100644
--- a/sound/soc/codecs/rt711-sdca-sdw.c
+++ b/sound/soc/codecs/rt711-sdca-sdw.c
@@ -142,6 +142,7 @@ static int rt711_sdca_update_status(struct sdw_slave *slave,
 				enum sdw_slave_status status)
 {
 	struct rt711_sdca_priv *rt711 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt711->hw_init = false;
@@ -169,7 +170,20 @@ static int rt711_sdca_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt711_sdca_io_init(&slave->dev, slave);
+	ret = rt711_sdca_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "IO init failed: %d\n", ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt711->regmap, false);
+		regcache_sync(rt711->regmap);
+		regcache_cache_only(rt711->mbq_regmap, false);
+		regcache_sync(rt711->mbq_regmap);
+	}
+
+	return ret;
 }
 
 static int rt711_sdca_read_prop(struct sdw_slave *slave)
@@ -434,13 +448,10 @@ static int rt711_sdca_dev_system_suspend(struct device *dev)
 	return rt711_sdca_dev_suspend(dev);
 }
 
-#define RT711_PROBE_TIMEOUT 5000
-
 static int rt711_sdca_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt711_sdca_priv *rt711 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt711->first_hw_init)
 		return 0;
@@ -456,14 +467,7 @@ static int rt711_sdca_dev_resume(struct device *dev)
 		goto regmap_sync;
 	}
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT711_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
-		sdw_show_ping_status(slave->bus, true);
-
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
diff --git a/sound/soc/codecs/rt711-sdca.c b/sound/soc/codecs/rt711-sdca.c
index dd6ccf17afd4..a4027796dafc 100644
--- a/sound/soc/codecs/rt711-sdca.c
+++ b/sound/soc/codecs/rt711-sdca.c
@@ -1327,6 +1327,8 @@ static void rt711_sdca_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT711_PROBE_TIMEOUT 5000
+
 static int rt711_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 				struct snd_pcm_hw_params *params,
 				struct snd_soc_dai *dai)
@@ -1362,6 +1364,10 @@ static int rt711_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 			return -EINVAL;
 	}
 
+	retval = sdw_slave_wait_for_initialization(rt711->slave, RT711_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt711->slave, &stream_config,
 					&port_config, 1, sdw_stream);
 	if (retval) {
-- 
2.43.0

[PATCH 08/15] ASoC: rt711: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt711_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt711-sdw.c | 26 ++++++++++++++++----------
 sound/soc/codecs/rt711.c     |  6 ++++++
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/sound/soc/codecs/rt711-sdw.c b/sound/soc/codecs/rt711-sdw.c
index 93a5a89a96b1..884206850b46 100644
--- a/sound/soc/codecs/rt711-sdw.c
+++ b/sound/soc/codecs/rt711-sdw.c
@@ -320,6 +320,7 @@ static int rt711_update_status(struct sdw_slave *slave,
 				enum sdw_slave_status status)
 {
 	struct rt711_priv *rt711 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt711->hw_init = false;
@@ -332,7 +333,20 @@ static int rt711_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt711_io_init(&slave->dev, slave);
+	ret = rt711_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "%s: I/O init failed: %d\n",
+			__func__, ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt711->regmap, false);
+		regcache_sync_region(rt711->regmap, 0x3000, 0x8fff);
+		regcache_sync_region(rt711->regmap, 0x752009, 0x752091);
+	}
+
+	return ret;
 }
 
 static int rt711_read_prop(struct sdw_slave *slave)
@@ -526,13 +540,10 @@ static int rt711_dev_system_suspend(struct device *dev)
 	return rt711_dev_suspend(dev);
 }
 
-#define RT711_PROBE_TIMEOUT 5000
-
 static int rt711_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt711_priv *rt711 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt711->first_hw_init)
 		return 0;
@@ -547,12 +558,7 @@ static int rt711_dev_resume(struct device *dev)
 		goto regmap_sync;
 	}
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT711_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
diff --git a/sound/soc/codecs/rt711.c b/sound/soc/codecs/rt711.c
index 5446f9506a16..2fbd7c0227ff 100644
--- a/sound/soc/codecs/rt711.c
+++ b/sound/soc/codecs/rt711.c
@@ -982,6 +982,8 @@ static void rt711_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT711_PROBE_TIMEOUT 5000
+
 static int rt711_pcm_hw_params(struct snd_pcm_substream *substream,
 				struct snd_pcm_hw_params *params,
 				struct snd_soc_dai *dai)
@@ -1017,6 +1019,10 @@ static int rt711_pcm_hw_params(struct snd_pcm_substream *substream,
 			return -EINVAL;
 	}
 
+	retval = sdw_slave_wait_for_initialization(rt711->slave, RT711_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt711->slave, &stream_config,
 					&port_config, 1, sdw_stream);
 	if (retval) {
-- 
2.43.0

[PATCH 09/15] ASoC: rt715: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt715_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt715-sdw.c | 27 +++++++++++++++------------
 sound/soc/codecs/rt715.c     |  6 ++++++
 2 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/sound/soc/codecs/rt715-sdw.c b/sound/soc/codecs/rt715-sdw.c
index a3df4bbedf86..8276ff9958c4 100644
--- a/sound/soc/codecs/rt715-sdw.c
+++ b/sound/soc/codecs/rt715-sdw.c
@@ -376,6 +376,7 @@ static int rt715_update_status(struct sdw_slave *slave,
 				enum sdw_slave_status status)
 {
 	struct rt715_priv *rt715 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	/*
 	 * Perform initialization only if slave status is present and
@@ -385,7 +386,19 @@ static int rt715_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt715_io_init(&slave->dev, slave);
+	ret = rt715_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "%s: I/O init failed: %d\n", __func__, ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt715->regmap, false);
+		regcache_sync_region(rt715->regmap, 0x3000, 0x8fff);
+		regcache_sync_region(rt715->regmap, 0x752039, 0x752039);
+	}
+
+	return ret;
 }
 
 static int rt715_read_prop(struct sdw_slave *slave)
@@ -497,13 +510,10 @@ static int rt715_dev_suspend(struct device *dev)
 	return 0;
 }
 
-#define RT715_PROBE_TIMEOUT 5000
-
 static int rt715_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt715_priv *rt715 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt715->first_hw_init)
 		return 0;
@@ -511,14 +521,7 @@ static int rt715_dev_resume(struct device *dev)
 	if (!slave->unattach_request)
 		goto regmap_sync;
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-					   msecs_to_jiffies(RT715_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
-		sdw_show_ping_status(slave->bus, true);
-
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
diff --git a/sound/soc/codecs/rt715.c b/sound/soc/codecs/rt715.c
index 2cf461852091..bf523a39bdcf 100644
--- a/sound/soc/codecs/rt715.c
+++ b/sound/soc/codecs/rt715.c
@@ -822,6 +822,8 @@ static void rt715_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT715_PROBE_TIMEOUT 5000
+
 static int rt715_pcm_hw_params(struct snd_pcm_substream *substream,
 				struct snd_pcm_hw_params *params,
 				struct snd_soc_dai *dai)
@@ -858,6 +860,10 @@ static int rt715_pcm_hw_params(struct snd_pcm_substream *substream,
 		return -EINVAL;
 	}
 
+	retval = sdw_slave_wait_for_initialization(rt715->slave, RT715_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt715->slave, &stream_config,
 					&port_config, 1, sdw_stream);
 	if (retval) {
-- 
2.43.0

[PATCH 10/15] ASoC: rt700: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt700_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt700-sdw.c | 27 +++++++++++++++------------
 sound/soc/codecs/rt700.c     |  6 ++++++
 2 files changed, 21 insertions(+), 12 deletions(-)

diff --git a/sound/soc/codecs/rt700-sdw.c b/sound/soc/codecs/rt700-sdw.c
index 44543c0da177..dd775788c2ee 100644
--- a/sound/soc/codecs/rt700-sdw.c
+++ b/sound/soc/codecs/rt700-sdw.c
@@ -314,6 +314,7 @@ static int rt700_update_status(struct sdw_slave *slave,
 					enum sdw_slave_status status)
 {
 	struct rt700_priv *rt700 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt700->hw_init = false;
@@ -326,7 +327,19 @@ static int rt700_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt700_io_init(&slave->dev, slave);
+	ret = rt700_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "I/O init failed: %d\n", ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt700->regmap, false);
+		regcache_sync_region(rt700->regmap, 0x3000, 0x8fff);
+		regcache_sync_region(rt700->regmap, 0x752010, 0x75206b);
+	}
+
+	return ret;
 }
 
 static int rt700_read_prop(struct sdw_slave *slave)
@@ -518,13 +531,10 @@ static int rt700_dev_system_suspend(struct device *dev)
 	return rt700_dev_suspend(dev);
 }
 
-#define RT700_PROBE_TIMEOUT 5000
-
 static int rt700_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt700_priv *rt700 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt700->first_hw_init)
 		return 0;
@@ -532,14 +542,7 @@ static int rt700_dev_resume(struct device *dev)
 	if (!slave->unattach_request)
 		goto regmap_sync;
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT700_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "Initialization not complete, timed out\n");
-		sdw_show_ping_status(slave->bus, true);
-
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
diff --git a/sound/soc/codecs/rt700.c b/sound/soc/codecs/rt700.c
index 434b926f96c8..4a5338f7ad92 100644
--- a/sound/soc/codecs/rt700.c
+++ b/sound/soc/codecs/rt700.c
@@ -893,6 +893,8 @@ static void rt700_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT700_PROBE_TIMEOUT 5000
+
 static int rt700_pcm_hw_params(struct snd_pcm_substream *substream,
 					struct snd_pcm_hw_params *params,
 					struct snd_soc_dai *dai)
@@ -934,6 +936,10 @@ static int rt700_pcm_hw_params(struct snd_pcm_substream *substream,
 		return -EINVAL;
 	}
 
+	retval = sdw_slave_wait_for_initialization(rt700->slave, RT700_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt700->slave, &stream_config,
 					&port_config, 1, sdw_stream);
 	if (retval) {
-- 
2.43.0

[PATCH 11/15] ASoC: rt1316: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt1316_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt1316-sdw.c | 32 ++++++++++++++++++++------------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/sound/soc/codecs/rt1316-sdw.c b/sound/soc/codecs/rt1316-sdw.c
index 960b6c4f5a66..56e82c0f648d 100644
--- a/sound/soc/codecs/rt1316-sdw.c
+++ b/sound/soc/codecs/rt1316-sdw.c
@@ -313,6 +313,7 @@ static int rt1316_update_status(struct sdw_slave *slave,
 					enum sdw_slave_status status)
 {
 	struct  rt1316_sdw_priv *rt1316 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt1316->hw_init = false;
@@ -325,7 +326,18 @@ static int rt1316_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt1316_io_init(&slave->dev, slave);
+	ret = rt1316_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "%s: I/O init failed: %d\n", __func__, ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt1316->regmap, false);
+		regcache_sync(rt1316->regmap);
+	}
+
+	return ret;
 }
 
 static int rt1316_classd_event(struct snd_soc_dapm_widget *w,
@@ -505,6 +517,8 @@ static void rt1316_sdw_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT1316_PROBE_TIMEOUT 5000
+
 static int rt1316_sdw_hw_params(struct snd_pcm_substream *substream,
 	struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
 {
@@ -534,6 +548,10 @@ static int rt1316_sdw_hw_params(struct snd_pcm_substream *substream,
 	else
 		port_config.num = 2;
 
+	retval = sdw_slave_wait_for_initialization(rt1316->sdw_slave, RT1316_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt1316->sdw_slave, &stream_config,
 				&port_config, 1, sdw_stream);
 	if (retval) {
@@ -742,13 +760,10 @@ static int rt1316_dev_suspend(struct device *dev)
 	return 0;
 }
 
-#define RT1316_PROBE_TIMEOUT 5000
-
 static int rt1316_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt1316_sdw_priv *rt1316 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt1316->first_hw_init)
 		return 0;
@@ -756,14 +771,7 @@ static int rt1316_dev_resume(struct device *dev)
 	if (!slave->unattach_request)
 		goto regmap_sync;
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT1316_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
-		sdw_show_ping_status(slave->bus, true);
-
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
-- 
2.43.0

[PATCH 12/15] ASoC: rt1318: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt1318_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt1318-sdw.c | 30 ++++++++++++++++++++----------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/sound/soc/codecs/rt1318-sdw.c b/sound/soc/codecs/rt1318-sdw.c
index 4eb636e0c9ed..6add687b5f6a 100644
--- a/sound/soc/codecs/rt1318-sdw.c
+++ b/sound/soc/codecs/rt1318-sdw.c
@@ -445,6 +445,7 @@ static int rt1318_update_status(struct sdw_slave *slave,
 					enum sdw_slave_status status)
 {
 	struct  rt1318_sdw_priv *rt1318 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt1318->hw_init = false;
@@ -457,7 +458,18 @@ static int rt1318_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt1318_io_init(&slave->dev, slave);
+	ret = rt1318_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "%s: I/O init failed: %d\n", __func__, ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt1318->regmap, false);
+		regcache_sync(rt1318->regmap);
+	}
+
+	return ret;
 }
 
 static int rt1318_classd_event(struct snd_soc_dapm_widget *w,
@@ -560,6 +572,8 @@ static void rt1318_sdw_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT1318_PROBE_TIMEOUT 5000
+
 static int rt1318_sdw_hw_params(struct snd_pcm_substream *substream,
 	struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
 {
@@ -603,6 +617,10 @@ static int rt1318_sdw_hw_params(struct snd_pcm_substream *substream,
 	port_config.ch_mask = ch_mask;
 	port_config.num = port;
 
+	retval = sdw_slave_wait_for_initialization(rt1318->sdw_slave, RT1318_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt1318->sdw_slave, &stream_config,
 				&port_config, 1, sdw_stream);
 	if (retval) {
@@ -818,13 +836,10 @@ static int rt1318_dev_suspend(struct device *dev)
 	return 0;
 }
 
-#define RT1318_PROBE_TIMEOUT 5000
-
 static int rt1318_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt1318_sdw_priv *rt1318 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt1318->first_hw_init)
 		return 0;
@@ -832,12 +847,7 @@ static int rt1318_dev_resume(struct device *dev)
 	if (!slave->unattach_request)
 		goto regmap_sync;
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT1318_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
-- 
2.43.0

[PATCH 13/15] ASoC: rt1308: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt1308_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt1308-sdw.c | 32 ++++++++++++++++++++------------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/sound/soc/codecs/rt1308-sdw.c b/sound/soc/codecs/rt1308-sdw.c
index ea708068f0e8..3579189b49b6 100644
--- a/sound/soc/codecs/rt1308-sdw.c
+++ b/sound/soc/codecs/rt1308-sdw.c
@@ -303,6 +303,7 @@ static int rt1308_update_status(struct sdw_slave *slave,
 					enum sdw_slave_status status)
 {
 	struct  rt1308_sdw_priv *rt1308 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt1308->hw_init = false;
@@ -315,7 +316,18 @@ static int rt1308_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt1308_io_init(&slave->dev, slave);
+	ret = rt1308_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "IO init failed %d\n", ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt1308->regmap, false);
+		regcache_sync_region(rt1308->regmap, 0xc000, 0xcfff);
+	}
+
+	return ret;
 }
 
 static int rt1308_bus_config(struct sdw_slave *slave,
@@ -526,6 +538,8 @@ static int rt1308_sdw_set_tdm_slot(struct snd_soc_dai *dai,
 	return 0;
 }
 
+#define RT1308_PROBE_TIMEOUT 5000
+
 static int rt1308_sdw_hw_params(struct snd_pcm_substream *substream,
 	struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
 {
@@ -560,6 +574,10 @@ static int rt1308_sdw_hw_params(struct snd_pcm_substream *substream,
 		port_config.ch_mask = rt1308->rx_mask;
 	}
 
+	retval = sdw_slave_wait_for_initialization(rt1308->sdw_slave, RT1308_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt1308->sdw_slave, &stream_config,
 				&port_config, 1, sdw_stream);
 	if (retval) {
@@ -765,13 +783,10 @@ static int rt1308_dev_suspend(struct device *dev)
 	return 0;
 }
 
-#define RT1308_PROBE_TIMEOUT 5000
-
 static int rt1308_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt1308_sdw_priv *rt1308 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt1308->first_hw_init)
 		return 0;
@@ -779,14 +794,7 @@ static int rt1308_dev_resume(struct device *dev)
 	if (!slave->unattach_request)
 		goto regmap_sync;
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT1308_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "Initialization not complete, timed out\n");
-		sdw_show_ping_status(slave->bus, true);
-
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
-- 
2.43.0

[PATCH 14/15] ASoC: rt5682: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt5682_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt5682-sdw.c | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/sound/soc/codecs/rt5682-sdw.c b/sound/soc/codecs/rt5682-sdw.c
index aa229894129b..1c140691945f 100644
--- a/sound/soc/codecs/rt5682-sdw.c
+++ b/sound/soc/codecs/rt5682-sdw.c
@@ -129,6 +129,10 @@ static int rt5682_sdw_hw_params(struct snd_pcm_substream *substream,
 	else
 		port_config.num = 2;
 
+	retval = sdw_slave_wait_for_initialization(rt5682->slave, RT5682_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt5682->slave, &stream_config,
 				      &port_config, 1, sdw_stream);
 	if (retval) {
@@ -513,6 +517,7 @@ static int rt5682_update_status(struct sdw_slave *slave,
 					enum sdw_slave_status status)
 {
 	struct rt5682_priv *rt5682 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt5682->hw_init = false;
@@ -525,7 +530,19 @@ static int rt5682_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt5682_io_init(&slave->dev, slave);
+	ret = rt5682_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "IO init Failed: %d\n", ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt5682->sdw_regmap, false);
+		regcache_cache_only(rt5682->regmap, false);
+		regcache_sync(rt5682->regmap);
+	}
+
+	return ret;
 }
 
 static int rt5682_read_prop(struct sdw_slave *slave)
@@ -757,7 +774,6 @@ static int rt5682_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt5682_priv *rt5682 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt5682->first_hw_init)
 		return 0;
@@ -772,14 +788,7 @@ static int rt5682_dev_resume(struct device *dev)
 		goto regmap_sync;
 	}
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT5682_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
-		sdw_show_ping_status(slave->bus, true);
-
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
-- 
2.43.0

[PATCH 15/15] ASoC: rt1017: wait codec init in hw_params

[Bard Liao]

Move regmap sync to rt1017_sdca_update_status() when unattach_request
is set, and only do regmap sync in resume when no reattach needed.
And move waiting codec init to hw_params when the codec really need to
be initialized. The change can shorten the resume time.

Signed-off-by: Bard Liao <yung-chuan.liao@linux.intel.com>
Reviewed-by: Shuming Fan <shumingf@realtek.com>
Reviewed-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
 sound/soc/codecs/rt1017-sdca-sdw.c | 32 +++++++++++++++++++-----------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/sound/soc/codecs/rt1017-sdca-sdw.c b/sound/soc/codecs/rt1017-sdca-sdw.c
index 88fc23a4999f..bd9eb1854aa5 100644
--- a/sound/soc/codecs/rt1017-sdca-sdw.c
+++ b/sound/soc/codecs/rt1017-sdca-sdw.c
@@ -373,6 +373,7 @@ static int rt1017_sdca_update_status(struct sdw_slave *slave,
 				enum sdw_slave_status status)
 {
 	struct  rt1017_sdca_priv *rt1017 = dev_get_drvdata(&slave->dev);
+	int ret;
 
 	if (status == SDW_SLAVE_UNATTACHED)
 		rt1017->hw_init = false;
@@ -385,7 +386,18 @@ static int rt1017_sdca_update_status(struct sdw_slave *slave,
 		return 0;
 
 	/* perform I/O transfers required for Slave initialization */
-	return rt1017_sdca_io_init(&slave->dev, slave);
+	ret = rt1017_sdca_io_init(&slave->dev, slave);
+	if (ret < 0) {
+		dev_err(&slave->dev, "IO init failed: %d\n", ret);
+		return ret;
+	}
+
+	if (slave->unattach_request) {
+		regcache_cache_only(rt1017->regmap, false);
+		regcache_sync(rt1017->regmap);
+	}
+
+	return ret;
 }
 
 static const char * const rt1017_rx_data_ch_select[] = {
@@ -569,6 +581,8 @@ static void rt1017_sdca_shutdown(struct snd_pcm_substream *substream,
 	snd_soc_dai_set_dma_data(dai, substream, NULL);
 }
 
+#define RT1017_PROBE_TIMEOUT 5000
+
 static int rt1017_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 				struct snd_pcm_hw_params *params,
 				struct snd_soc_dai *dai)
@@ -616,6 +630,10 @@ static int rt1017_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
 		params_rate(params), num_channels, snd_pcm_format_width(params_format(params)),
 		direction, ch_mask, port);
 
+	retval = sdw_slave_wait_for_initialization(rt1017->sdw_slave, RT1017_PROBE_TIMEOUT);
+	if (retval < 0)
+		return retval;
+
 	retval = sdw_stream_add_slave(rt1017->sdw_slave, &stream_config,
 				&port_config, 1, sdw_stream);
 	if (retval) {
@@ -770,13 +788,10 @@ static int rt1017_sdca_dev_suspend(struct device *dev)
 	return 0;
 }
 
-#define RT1017_PROBE_TIMEOUT 5000
-
 static int rt1017_sdca_dev_resume(struct device *dev)
 {
 	struct sdw_slave *slave = dev_to_sdw_dev(dev);
 	struct rt1017_sdca_priv *rt1017 = dev_get_drvdata(dev);
-	unsigned long time;
 
 	if (!rt1017->first_hw_init)
 		return 0;
@@ -784,14 +799,7 @@ static int rt1017_sdca_dev_resume(struct device *dev)
 	if (!slave->unattach_request)
 		goto regmap_sync;
 
-	time = wait_for_completion_timeout(&slave->initialization_complete,
-				msecs_to_jiffies(RT1017_PROBE_TIMEOUT));
-	if (!time) {
-		dev_err(&slave->dev, "Initialization not complete, timed out\n");
-		sdw_show_ping_status(slave->bus, true);
-
-		return -ETIMEDOUT;
-	}
+	return 0;
 
 regmap_sync:
 	slave->unattach_request = 0;
-- 
2.43.0

Re: [PATCH 00/15] ASoC/soundwire: Realtek codecs: wait codec init in hw_params

[Pierre-Louis Bossart]

Hi Bard,

> The current code waits for the codec initialization in the resume
> callback. It could cause the resume takes a long time while waiting for
> the codec being attached and initialized. Move the waiting to the
> hw_params callback when the driver really needs it and shorten the
> resume time.
> The change is mainly on the ASoC tree. Let's go through the ASoC tree.

While I certainly understand the desire to make the resume time lower, is this approach desirable in all cases?

My main worry is this: not all functionality in a codec is related to the hw_params. One counter example would be register settings related to jack detection. You would want the regmap settings to be correctly applied in hardware registers even in the absence of any streaming request, no?

The other weird thing is that historically the codec initialization was never on the critical path, it was several orders of magnitude faster than the controller. It wouldn't hurt to provide broad-brush information on what a 'long' time means for a codec resume, so that we can really see the pros/cons of moving all the regmap initialization.

Another open is that SDCA defines the notion of 'blind writes' which would typically be done during a resume if context was lost. If we start moving some parts of the initialization to the hw_params and others remain in the resume flow, that will quickly lead to complexity in managing configuration.

The last point is that this is a change for Realtek codecs only, would other drivers for other vendors require this change? And if I may ask is there any merit in speeding-up resume times even for 'legacy' non-sdca parts?

> Bard Liao (15):
>   soundwire: add sdw_slave_wait_for_initialization helper
>   ASoC: rt722: wait codec init in hw_params
>   ASoC: rt712: wait codec init in hw_params
>   ASoC: rt1320: wait codec init in hw_params
>   ASoC: rt721: wait codec init in hw_params
>   ASoC: rt715-sdca: wait codec init in hw_params
>   ASoC: rt711-sdca: wait codec init in hw_params
>   ASoC: rt711: wait codec init in hw_params
>   ASoC: rt715: wait codec init in hw_params
>   ASoC: rt700: wait codec init in hw_params
>   ASoC: rt1316: wait codec init in hw_params
>   ASoC: rt1318: wait codec init in hw_params
>   ASoC: rt1308: wait codec init in hw_params
>   ASoC: rt5682: wait codec init in hw_params
>   ASoC: rt1017: wait codec init in hw_params
> 
>  drivers/soundwire/slave.c          | 17 ++++++++++++++
>  include/linux/soundwire/sdw.h      |  1 +
>  sound/soc/codecs/rt1017-sdca-sdw.c | 32 ++++++++++++++++----------
>  sound/soc/codecs/rt1308-sdw.c      | 32 ++++++++++++++++----------
>  sound/soc/codecs/rt1316-sdw.c      | 32 ++++++++++++++++----------
>  sound/soc/codecs/rt1318-sdw.c      | 30 ++++++++++++++++--------
>  sound/soc/codecs/rt1320-sdw.c      | 32 ++++++++++++++++++--------
>  sound/soc/codecs/rt5682-sdw.c      | 29 +++++++++++++++--------
>  sound/soc/codecs/rt700-sdw.c       | 27 ++++++++++++----------
>  sound/soc/codecs/rt700.c           |  6 +++++
>  sound/soc/codecs/rt711-sdca-sdw.c  | 28 ++++++++++++----------
>  sound/soc/codecs/rt711-sdca.c      |  6 +++++
>  sound/soc/codecs/rt711-sdw.c       | 26 +++++++++++++--------
>  sound/soc/codecs/rt711.c           |  6 +++++
>  sound/soc/codecs/rt712-sdca-sdw.c  | 28 ++++++++++++----------
>  sound/soc/codecs/rt712-sdca.c      |  6 +++++
>  sound/soc/codecs/rt715-sdca-sdw.c  | 37 ++++++++++++++++++++----------
>  sound/soc/codecs/rt715-sdca.c      |  6 +++++
>  sound/soc/codecs/rt715-sdw.c       | 27 ++++++++++++----------
>  sound/soc/codecs/rt715.c           |  6 +++++
>  sound/soc/codecs/rt721-sdca-sdw.c  | 29 ++++++++++++-----------
>  sound/soc/codecs/rt721-sdca.c      |  6 +++++
>  sound/soc/codecs/rt722-sdca-sdw.c  | 26 +++++++++++----------
>  sound/soc/codecs/rt722-sdca.c      |  6 +++++
>  24 files changed, 320 insertions(+), 161 deletions(-)
> 

RE: [PATCH 00/15] ASoC/soundwire: Realtek codecs: wait codec init in hw_params

[Liao, Bard]

> -----Original Message-----
> From: Pierre-Louis Bossart <pierre-louis.bossart@linux.dev>
> Sent: Thursday, June 26, 2025 8:19 PM
> To: Bard Liao <yung-chuan.liao@linux.intel.com>; broonie@kernel.org;
> tiwai@suse.de; linux-sound@vger.kernel.org; vkoul@kernel.org
> Cc: vinod.koul@linaro.org; linux-kernel@vger.kernel.org; Liao, Bard
> <bard.liao@intel.com>
> Subject: Re: [PATCH 00/15] ASoC/soundwire: Realtek codecs: wait codec init
> in hw_params
> 
> Hi Bard,
> 
> > The current code waits for the codec initialization in the resume
> > callback. It could cause the resume takes a long time while waiting for
> > the codec being attached and initialized. Move the waiting to the
> > hw_params callback when the driver really needs it and shorten the
> > resume time.
> > The change is mainly on the ASoC tree. Let's go through the ASoC tree.
> 
> While I certainly understand the desire to make the resume time lower, is this
> approach desirable in all cases?
> 
> My main worry is this: not all functionality in a codec is related to the
> hw_params. One counter example would be register settings related to jack
> detection. You would want the regmap settings to be correctly applied in
> hardware registers even in the absence of any streaming request, no?

Right, not all functionality is related to the hw_params However, the
codec need to be attached first if the functionality needs to access the
codec. That's the reason we do io init and regcache_sync in the
update_status callback when the codec is attached. Take the jack
detection as an example, the codec will be attached first when the JD
event happens. At that point, the driver will do io init and regsync and
then handle the interrupt.

> 
> The other weird thing is that historically the codec initialization was never on
> the critical path, it was several orders of magnitude faster than the controller.
> It wouldn't hurt to provide broad-brush information on what a 'long' time
> means for a codec resume, so that we can really see the pros/cons of moving
> all the regmap initialization.

The main issue is that the codec could be attached after the codec resume.
Sometimes, it could take 100 ms or longer.

> 
> Another open is that SDCA defines the notion of 'blind writes' which would
> typically be done during a resume if context was lost. If we start moving some
> parts of the initialization to the hw_params and others remain in the resume
> flow, that will quickly lead to complexity in managing configuration.

I am not trying to move the initialization to the hw_params. The
initialization is still done in the update_status() callback. Waiting on
hw_params is just to make sure the codec is initialized before the
audio get started. And currently, Realtek codec drivers do blind writes
in the io_init function not resume.

> 
> The last point is that this is a change for Realtek codecs only, would other
> drivers for other vendors require this change? And if I may ask is there any
> merit in speeding-up resume times even for 'legacy' non-sdca parts?

IMHO, yes, other drivers for other vendors require this change.
I don't see any difference between non-sdca and sdca codecs.
They both could be attached after the codec driver resume.


> 
> > Bard Liao (15):
> >   soundwire: add sdw_slave_wait_for_initialization helper
> >   ASoC: rt722: wait codec init in hw_params
> >   ASoC: rt712: wait codec init in hw_params
> >   ASoC: rt1320: wait codec init in hw_params
> >   ASoC: rt721: wait codec init in hw_params
> >   ASoC: rt715-sdca: wait codec init in hw_params
> >   ASoC: rt711-sdca: wait codec init in hw_params
> >   ASoC: rt711: wait codec init in hw_params
> >   ASoC: rt715: wait codec init in hw_params
> >   ASoC: rt700: wait codec init in hw_params
> >   ASoC: rt1316: wait codec init in hw_params
> >   ASoC: rt1318: wait codec init in hw_params
> >   ASoC: rt1308: wait codec init in hw_params
> >   ASoC: rt5682: wait codec init in hw_params
> >   ASoC: rt1017: wait codec init in hw_params
> >
> >  drivers/soundwire/slave.c          | 17 ++++++++++++++
> >  include/linux/soundwire/sdw.h      |  1 +
> >  sound/soc/codecs/rt1017-sdca-sdw.c | 32 ++++++++++++++++----------
> >  sound/soc/codecs/rt1308-sdw.c      | 32 ++++++++++++++++----------
> >  sound/soc/codecs/rt1316-sdw.c      | 32 ++++++++++++++++----------
> >  sound/soc/codecs/rt1318-sdw.c      | 30 ++++++++++++++++--------
> >  sound/soc/codecs/rt1320-sdw.c      | 32 ++++++++++++++++++--------
> >  sound/soc/codecs/rt5682-sdw.c      | 29 +++++++++++++++--------
> >  sound/soc/codecs/rt700-sdw.c       | 27 ++++++++++++----------
> >  sound/soc/codecs/rt700.c           |  6 +++++
> >  sound/soc/codecs/rt711-sdca-sdw.c  | 28 ++++++++++++----------
> >  sound/soc/codecs/rt711-sdca.c      |  6 +++++
> >  sound/soc/codecs/rt711-sdw.c       | 26 +++++++++++++--------
> >  sound/soc/codecs/rt711.c           |  6 +++++
> >  sound/soc/codecs/rt712-sdca-sdw.c  | 28 ++++++++++++----------
> >  sound/soc/codecs/rt712-sdca.c      |  6 +++++
> >  sound/soc/codecs/rt715-sdca-sdw.c  | 37 ++++++++++++++++++++--------
> --
> >  sound/soc/codecs/rt715-sdca.c      |  6 +++++
> >  sound/soc/codecs/rt715-sdw.c       | 27 ++++++++++++----------
> >  sound/soc/codecs/rt715.c           |  6 +++++
> >  sound/soc/codecs/rt721-sdca-sdw.c  | 29 ++++++++++++-----------
> >  sound/soc/codecs/rt721-sdca.c      |  6 +++++
> >  sound/soc/codecs/rt722-sdca-sdw.c  | 26 +++++++++++----------
> >  sound/soc/codecs/rt722-sdca.c      |  6 +++++
> >  24 files changed, 320 insertions(+), 161 deletions(-)
> >

Re: [PATCH 00/15] ASoC/soundwire: Realtek codecs: wait codec init in hw_params

[Pierre-Louis Bossart]

>>> The current code waits for the codec initialization in the resume
>>> callback. It could cause the resume takes a long time while waiting for
>>> the codec being attached and initialized. Move the waiting to the
>>> hw_params callback when the driver really needs it and shorten the
>>> resume time.
>>> The change is mainly on the ASoC tree. Let's go through the ASoC tree.
>>
>> While I certainly understand the desire to make the resume time lower, is this
>> approach desirable in all cases?
>>
>> My main worry is this: not all functionality in a codec is related to the
>> hw_params. One counter example would be register settings related to jack
>> detection. You would want the regmap settings to be correctly applied in
>> hardware registers even in the absence of any streaming request, no?
> 
> Right, not all functionality is related to the hw_params However, the
> codec need to be attached first if the functionality needs to access the
> codec. That's the reason we do io init and regcache_sync in the
> update_status callback when the codec is attached. Take the jack
> detection as an example, the codec will be attached first when the JD
> event happens. At that point, the driver will do io init and regsync and
> then handle the interrupt.

We agree on that part. The initialization is done from io_init. The disagreement is whether we have to wait in the resume() for the device to be fully initialized, see below.

>> The other weird thing is that historically the codec initialization was never on
>> the critical path, it was several orders of magnitude faster than the controller.
>> It wouldn't hurt to provide broad-brush information on what a 'long' time
>> means for a codec resume, so that we can really see the pros/cons of moving
>> all the regmap initialization.
> 
> The main issue is that the codec could be attached after the codec resume.
> Sometimes, it could take 100 ms or longer.

I don't really see the problem here. The codec device (in the Linux sense) is trying to resume, and you want to wait until the hardware device is fully configured, no?

Moving the waiting part is asking for trouble: the device will be reported as pm_runtime active, but it may not even be attached on the bus, and thus any register access will lead to invalid read/writes.

For example, starting a register dump via debugfs would fail if the codec is not attached. The machine driver could also set jack status that would fail as well.

>> Another open is that SDCA defines the notion of 'blind writes' which would
>> typically be done during a resume if context was lost. If we start moving some
>> parts of the initialization to the hw_params and others remain in the resume
>> flow, that will quickly lead to complexity in managing configuration.
> 
> I am not trying to move the initialization to the hw_params. The
> initialization is still done in the update_status() callback. Waiting on
> hw_params is just to make sure the codec is initialized before the
> audio get started. And currently, Realtek codec drivers do blind writes
> in the io_init function not resume.
> 
>>
>> The last point is that this is a change for Realtek codecs only, would other
>> drivers for other vendors require this change? And if I may ask is there any
>> merit in speeding-up resume times even for 'legacy' non-sdca parts?
> 
> IMHO, yes, other drivers for other vendors require this change.
> I don't see any difference between non-sdca and sdca codecs.
> They both could be attached after the codec driver resume.

I really don't see the rationale for 'speeding-up' the resume and losing the guaranty that the device is fully operational. The whole point of the wait_for_completion() in the resume part was to avoid any problems between the pm_runtime state machine and the asynchronous nature of the bus attachment at the hardware level.

Unless I am missing something big, it feels like you are playing with fire to speed-up a resume time that was not reported as a problem. You may be right that the SoundWire setup needs to evolve, change is the only constant in this world, but from my perspective it's not clear if the benefits offset the unknowns and potentially racy behavior introduced by this resume change.

>>> Bard Liao (15):
>>>   soundwire: add sdw_slave_wait_for_initialization helper
>>>   ASoC: rt722: wait codec init in hw_params
>>>   ASoC: rt712: wait codec init in hw_params
>>>   ASoC: rt1320: wait codec init in hw_params
>>>   ASoC: rt721: wait codec init in hw_params
>>>   ASoC: rt715-sdca: wait codec init in hw_params
>>>   ASoC: rt711-sdca: wait codec init in hw_params
>>>   ASoC: rt711: wait codec init in hw_params
>>>   ASoC: rt715: wait codec init in hw_params
>>>   ASoC: rt700: wait codec init in hw_params
>>>   ASoC: rt1316: wait codec init in hw_params
>>>   ASoC: rt1318: wait codec init in hw_params
>>>   ASoC: rt1308: wait codec init in hw_params
>>>   ASoC: rt5682: wait codec init in hw_params
>>>   ASoC: rt1017: wait codec init in hw_params
>>>
>>>  drivers/soundwire/slave.c          | 17 ++++++++++++++
>>>  include/linux/soundwire/sdw.h      |  1 +
>>>  sound/soc/codecs/rt1017-sdca-sdw.c | 32 ++++++++++++++++----------
>>>  sound/soc/codecs/rt1308-sdw.c      | 32 ++++++++++++++++----------
>>>  sound/soc/codecs/rt1316-sdw.c      | 32 ++++++++++++++++----------
>>>  sound/soc/codecs/rt1318-sdw.c      | 30 ++++++++++++++++--------
>>>  sound/soc/codecs/rt1320-sdw.c      | 32 ++++++++++++++++++--------
>>>  sound/soc/codecs/rt5682-sdw.c      | 29 +++++++++++++++--------
>>>  sound/soc/codecs/rt700-sdw.c       | 27 ++++++++++++----------
>>>  sound/soc/codecs/rt700.c           |  6 +++++
>>>  sound/soc/codecs/rt711-sdca-sdw.c  | 28 ++++++++++++----------
>>>  sound/soc/codecs/rt711-sdca.c      |  6 +++++
>>>  sound/soc/codecs/rt711-sdw.c       | 26 +++++++++++++--------
>>>  sound/soc/codecs/rt711.c           |  6 +++++
>>>  sound/soc/codecs/rt712-sdca-sdw.c  | 28 ++++++++++++----------
>>>  sound/soc/codecs/rt712-sdca.c      |  6 +++++
>>>  sound/soc/codecs/rt715-sdca-sdw.c  | 37 ++++++++++++++++++++--------
>> --
>>>  sound/soc/codecs/rt715-sdca.c      |  6 +++++
>>>  sound/soc/codecs/rt715-sdw.c       | 27 ++++++++++++----------
>>>  sound/soc/codecs/rt715.c           |  6 +++++
>>>  sound/soc/codecs/rt721-sdca-sdw.c  | 29 ++++++++++++-----------
>>>  sound/soc/codecs/rt721-sdca.c      |  6 +++++
>>>  sound/soc/codecs/rt722-sdca-sdw.c  | 26 +++++++++++----------
>>>  sound/soc/codecs/rt722-sdca.c      |  6 +++++
>>>  24 files changed, 320 insertions(+), 161 deletions(-)
>>>
> 

Re: [PATCH 00/15] ASoC/soundwire: Realtek codecs: wait codec init in hw_params

[Pierre-Louis Bossart]

>> The main issue is that the codec could be attached after the codec resume.
>> Sometimes, it could take 100 ms or longer.
> 
> I don't really see the problem here. The codec device (in the Linux sense) is trying to resume, and you want to wait until the hardware device is fully configured, no?
> 
> Moving the waiting part is asking for trouble: the device will be reported as pm_runtime active, but it may not even be attached on the bus, and thus any register access will lead to invalid read/writes.
> 
> For example, starting a register dump via debugfs would fail if the codec is not attached. The machine driver could also set jack status that would fail as well.

exhibit A for the last part: see rt700_set_jack_detect(). We absolutely want to make sure the device is attached *before* configuring the jack, that means waiting until pm_runtime_resume_and_get() is done.

So at at minimum, you would need to keep a wait_for_completion() in the resume method, but it could be demoted to a wait for the enumeration only. We do have to complete() for end of enumeration and end of initialization. 

If it's the initialization that takes time, it could indeed be handled in a more asynchronous way, but I don't think you want to even think of a case where the codec finishes successfully its resume routine before the device is enumerated and can be used for register read/writes.

RE: [PATCH 00/15] ASoC/soundwire: Realtek codecs: wait codec init in hw_params

[Liao, Bard]

> -----Original Message-----
> From: Pierre-Louis Bossart <pierre-louis.bossart@linux.dev>
> Sent: Tuesday, July 1, 2025 6:33 PM
> To: Liao, Bard <bard.liao@intel.com>; Bard Liao <yung-
> chuan.liao@linux.intel.com>; broonie@kernel.org; tiwai@suse.de; linux-
> sound@vger.kernel.org; vkoul@kernel.org
> Cc: vinod.koul@linaro.org; linux-kernel@vger.kernel.org
> Subject: Re: [PATCH 00/15] ASoC/soundwire: Realtek codecs: wait codec init
> in hw_params
> 
> 
> >> The main issue is that the codec could be attached after the codec resume.
> >> Sometimes, it could take 100 ms or longer.
> >
> > I don't really see the problem here. The codec device (in the Linux sense) is
> trying to resume, and you want to wait until the hardware device is fully
> configured, no?
> >
> > Moving the waiting part is asking for trouble: the device will be reported as
> pm_runtime active, but it may not even be attached on the bus, and thus any
> register access will lead to invalid read/writes.
> >
> > For example, starting a register dump via debugfs would fail if the codec is
> not attached. The machine driver could also set jack status that would fail as
> well.
> 
> exhibit A for the last part: see rt700_set_jack_detect(). We absolutely want to
> make sure the device is attached *before* configuring the jack, that means
> waiting until pm_runtime_resume_and_get() is done.
> 
> So at at minimum, you would need to keep a wait_for_completion() in the
> resume method, but it could be demoted to a wait for the enumeration only.
> We do have to complete() for end of enumeration and end of initialization.
> 
> If it's the initialization that takes time, it could indeed be handled in a more
> asynchronous way, but I don't think you want to even think of a case where
> the codec finishes successfully its resume routine before the device is
> enumerated and can be used for register read/writes.


Thanks Pierre. Fair point. You convinced me. Let's drop this series.