kernel 6.5.4

1 files changed, 1170 insertions, 0 deletions

diff --git a/SOURCES/chimera-ALSA.patch b/SOURCES/chimera-ALSA.patch
new file mode 100644
index 0000000..c7bd726
--- /dev/null
+++ b/SOURCES/chimera-ALSA.patch
@@ -0,0 +1,1170 @@
+From c21139c6470a5b08c7463e451f2ff404e55f652f Mon Sep 17 00:00:00 2001
+From: Stefan Binding <sbinding@opensource.cirrus.com>
+Date: Fri, 21 Jul 2023 16:18:06 +0100
+Subject: [PATCH 01/11] ALSA: cs35l41: Use mbox command to enable speaker
+ output for external boost
+
+To enable the speaker output in external boost mode, 2 registers must
+be set, one after another. The longer the time between the writes of
+the two registers, the more likely, and more loudly a pop may occur.
+To minimize this, an mbox command can be used to allow the firmware
+to perform this action, minimizing any delay between write, thus
+minimizing any pop or click as a result. The old method will remain
+when running without firmware.
+
+Acked-by: Mark Brown <broonie@kernel.org>
+Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
+---
+ include/sound/cs35l41.h        |  5 ++-
+ sound/pci/hda/cs35l41_hda.c    |  9 ++--
+ sound/soc/codecs/cs35l41-lib.c | 76 +++++++++++++++++++++++++++-------
+ sound/soc/codecs/cs35l41.c     |  8 ++--
+ 4 files changed, 74 insertions(+), 24 deletions(-)
+
+diff --git a/include/sound/cs35l41.h b/include/sound/cs35l41.h
+index 7239d943942c..1bf757901d02 100644
+--- a/include/sound/cs35l41.h
++++ b/include/sound/cs35l41.h
+@@ -829,6 +829,7 @@ enum cs35l41_cspl_mbox_cmd {
+ 	CSPL_MBOX_CMD_STOP_PRE_REINIT = 4,
+ 	CSPL_MBOX_CMD_HIBERNATE = 5,
+ 	CSPL_MBOX_CMD_OUT_OF_HIBERNATE = 6,
++	CSPL_MBOX_CMD_SPK_OUT_ENABLE = 7,
+ 	CSPL_MBOX_CMD_UNKNOWN_CMD = -1,
+ 	CSPL_MBOX_CMD_INVALID_SEQUENCE = -2,
+ };
+@@ -901,7 +902,7 @@ int cs35l41_exit_hibernate(struct device *dev, struct regmap *regmap);
+ int cs35l41_init_boost(struct device *dev, struct regmap *regmap,
+ 		       struct cs35l41_hw_cfg *hw_cfg);
+ bool cs35l41_safe_reset(struct regmap *regmap, enum cs35l41_boost_type b_type);
+-int cs35l41_global_enable(struct regmap *regmap, enum cs35l41_boost_type b_type, int enable,
+-			  struct completion *pll_lock);
++int cs35l41_global_enable(struct device *dev, struct regmap *regmap, enum cs35l41_boost_type b_type,
++			  int enable, struct completion *pll_lock, bool firmware_running);
+ 
+ #endif /* __CS35L41_H */
+diff --git a/sound/pci/hda/cs35l41_hda.c b/sound/pci/hda/cs35l41_hda.c
+index ce5faa620517..f9c97270db6f 100644
+--- a/sound/pci/hda/cs35l41_hda.c
++++ b/sound/pci/hda/cs35l41_hda.c
+@@ -514,13 +514,15 @@ static void cs35l41_hda_playback_hook(struct device *dev, int action)
+ 		break;
+ 	case HDA_GEN_PCM_ACT_PREPARE:
+ 		mutex_lock(&cs35l41->fw_mutex);
+-		ret = cs35l41_global_enable(reg, cs35l41->hw_cfg.bst_type, 1, NULL);
++		ret = cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1, NULL,
++					    cs35l41->firmware_running);
+ 		mutex_unlock(&cs35l41->fw_mutex);
+ 		break;
+ 	case HDA_GEN_PCM_ACT_CLEANUP:
+ 		mutex_lock(&cs35l41->fw_mutex);
+ 		regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute));
+-		ret = cs35l41_global_enable(reg, cs35l41->hw_cfg.bst_type, 0, NULL);
++		ret = cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0, NULL,
++					    cs35l41->firmware_running);
+ 		mutex_unlock(&cs35l41->fw_mutex);
+ 		break;
+ 	case HDA_GEN_PCM_ACT_CLOSE:
+@@ -672,7 +674,8 @@ static int cs35l41_runtime_suspend(struct device *dev)
+ 	if (cs35l41->playback_started) {
+ 		regmap_multi_reg_write(cs35l41->regmap, cs35l41_hda_mute,
+ 				       ARRAY_SIZE(cs35l41_hda_mute));
+-		cs35l41_global_enable(cs35l41->regmap, cs35l41->hw_cfg.bst_type, 0, NULL);
++		cs35l41_global_enable(cs35l41->dev, cs35l41->regmap, cs35l41->hw_cfg.bst_type, 0,
++				      NULL, cs35l41->firmware_running);
+ 		regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2,
+ 				   CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT);
+ 		if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
+diff --git a/sound/soc/codecs/cs35l41-lib.c b/sound/soc/codecs/cs35l41-lib.c
+index 1e4205295a0d..a7556fa33cdd 100644
+--- a/sound/soc/codecs/cs35l41-lib.c
++++ b/sound/soc/codecs/cs35l41-lib.c
+@@ -1080,28 +1080,32 @@ static const struct reg_sequence cs35l41_safe_to_reset[] = {
+ 	{ 0x00000040,			0x00000033 },
+ };
+ 
+-static const struct reg_sequence cs35l41_active_to_safe[] = {
++static const struct reg_sequence cs35l41_active_to_safe_start[] = {
+ 	{ 0x00000040,			0x00000055 },
+ 	{ 0x00000040,			0x000000AA },
+ 	{ 0x00007438,			0x00585941 },
+ 	{ CS35L41_PWR_CTRL1,		0x00000000 },
+-	{ 0x0000742C,			0x00000009, 3000 },
++	{ 0x0000742C,			0x00000009 },
++};
++
++static const struct reg_sequence cs35l41_active_to_safe_end[] = {
+ 	{ 0x00007438,			0x00580941 },
+ 	{ 0x00000040,			0x000000CC },
+ 	{ 0x00000040,			0x00000033 },
+ };
+ 
+-static const struct reg_sequence cs35l41_safe_to_active[] = {
++static const struct reg_sequence cs35l41_safe_to_active_start[] = {
+ 	{ 0x00000040,			0x00000055 },
+ 	{ 0x00000040,			0x000000AA },
+ 	{ 0x0000742C,			0x0000000F },
+ 	{ 0x0000742C,			0x00000079 },
+ 	{ 0x00007438,			0x00585941 },
+-	{ CS35L41_PWR_CTRL1,		0x00000001, 3000 }, // GLOBAL_EN = 1
++	{ CS35L41_PWR_CTRL1,		0x00000001 }, // GLOBAL_EN = 1
++};
++
++static const struct reg_sequence cs35l41_safe_to_active_en_spk[] = {
+ 	{ 0x0000742C,			0x000000F9 },
+ 	{ 0x00007438,			0x00580941 },
+-	{ 0x00000040,			0x000000CC },
+-	{ 0x00000040,			0x00000033 },
+ };
+ 
+ static const struct reg_sequence cs35l41_reset_to_safe[] = {
+@@ -1188,11 +1192,11 @@ bool cs35l41_safe_reset(struct regmap *regmap, enum cs35l41_boost_type b_type)
+ }
+ EXPORT_SYMBOL_GPL(cs35l41_safe_reset);
+ 
+-int cs35l41_global_enable(struct regmap *regmap, enum cs35l41_boost_type b_type, int enable,
+-			  struct completion *pll_lock)
++int cs35l41_global_enable(struct device *dev, struct regmap *regmap, enum cs35l41_boost_type b_type,
++			  int enable, struct completion *pll_lock, bool firmware_running)
+ {
+ 	int ret;
+-	unsigned int gpio1_func, pad_control, pwr_ctrl1, pwr_ctrl3;
++	unsigned int gpio1_func, pad_control, pwr_ctrl1, pwr_ctrl3, int_status;
+ 	struct reg_sequence cs35l41_mdsync_down_seq[] = {
+ 		{CS35L41_PWR_CTRL3,		0},
+ 		{CS35L41_GPIO_PAD_CONTROL,	0},
+@@ -1204,6 +1208,14 @@ int cs35l41_global_enable(struct regmap *regmap, enum cs35l41_boost_type b_type,
+ 		{CS35L41_PWR_CTRL1,	0x00000001, 3000},
+ 	};
+ 
++	if ((pwr_ctl1_val & CS35L41_GLOBAL_EN_MASK) && enable) {
++		dev_dbg(dev, "Cannot set Global Enable - already set.\n");
++		return 0;
++	} else if (!(pwr_ctl1_val & CS35L41_GLOBAL_EN_MASK) && !enable) {
++		dev_dbg(dev, "Cannot unset Global Enable - not set.\n");
++		return 0;
++	}
++
+ 	switch (b_type) {
+ 	case CS35L41_SHD_BOOST_ACTV:
+ 	case CS35L41_SHD_BOOST_PASS:
+@@ -1244,16 +1256,48 @@ int cs35l41_global_enable(struct regmap *regmap, enum cs35l41_boost_type b_type,
+ 	case CS35L41_INT_BOOST:
+ 		ret = regmap_update_bits(regmap, CS35L41_PWR_CTRL1, CS35L41_GLOBAL_EN_MASK,
+ 					 enable << CS35L41_GLOBAL_EN_SHIFT);
++		if (ret) {
++			dev_err(dev, "CS35L41_PWR_CTRL1 set failed: %d\n", ret);
++			return ret;
++		}
+ 		usleep_range(3000, 3100);
+ 		break;
+ 	case CS35L41_EXT_BOOST:
+ 	case CS35L41_EXT_BOOST_NO_VSPK_SWITCH:
+-		if (enable)
+-			ret = regmap_multi_reg_write(regmap, cs35l41_safe_to_active,
+-						     ARRAY_SIZE(cs35l41_safe_to_active));
+-		else
+-			ret = regmap_multi_reg_write(regmap, cs35l41_active_to_safe,
+-						     ARRAY_SIZE(cs35l41_active_to_safe));
++		if (enable) {
++			/* Test Key is unlocked here */
++			ret = regmap_multi_reg_write(regmap, cs35l41_safe_to_active_start,
++						     ARRAY_SIZE(cs35l41_safe_to_active_start));
++			if (ret)
++				return ret;
++
++			usleep_range(3000, 3100);
++
++			if (firmware_running)
++				ret = cs35l41_set_cspl_mbox_cmd(dev, regmap,
++								CSPL_MBOX_CMD_SPK_OUT_ENABLE);
++			else
++				ret = regmap_multi_reg_write(regmap, cs35l41_safe_to_active_en_spk,
++							ARRAY_SIZE(cs35l41_safe_to_active_en_spk));
++
++			/* Lock the test key, it was unlocked during the multi_reg_write */
++			cs35l41_test_key_lock(dev, regmap);
++		} else {
++			/* Test Key is unlocked here */
++			ret = regmap_multi_reg_write(regmap, cs35l41_active_to_safe_start,
++						     ARRAY_SIZE(cs35l41_active_to_safe_start));
++			if (ret) {
++				/* Lock the test key, it was unlocked during the multi_reg_write */
++				cs35l41_test_key_lock(dev, regmap);
++				return ret;
++			}
++
++			usleep_range(3000, 3100);
++
++			/* Test Key is locked here */
++			ret = regmap_multi_reg_write(regmap, cs35l41_active_to_safe_end,
++						     ARRAY_SIZE(cs35l41_active_to_safe_end));
++		}
+ 		break;
+ 	default:
+ 		ret = -EINVAL;
+@@ -1344,6 +1388,8 @@ static bool cs35l41_check_cspl_mbox_sts(enum cs35l41_cspl_mbox_cmd cmd,
+ 		return (sts == CSPL_MBOX_STS_RUNNING);
+ 	case CSPL_MBOX_CMD_STOP_PRE_REINIT:
+ 		return (sts == CSPL_MBOX_STS_RDY_FOR_REINIT);
++	case CSPL_MBOX_CMD_SPK_OUT_ENABLE:
++		return (sts == CSPL_MBOX_STS_RUNNING);
+ 	default:
+ 		return false;
+ 	}
+diff --git a/sound/soc/codecs/cs35l41.c b/sound/soc/codecs/cs35l41.c
+index 6ac501f008ec..d4e9c9d9b50a 100644
+--- a/sound/soc/codecs/cs35l41.c
++++ b/sound/soc/codecs/cs35l41.c
+@@ -500,12 +500,12 @@ static int cs35l41_main_amp_event(struct snd_soc_dapm_widget *w,
+ 						cs35l41_pup_patch,
+ 						ARRAY_SIZE(cs35l41_pup_patch));
+ 
+-		cs35l41_global_enable(cs35l41->regmap, cs35l41->hw_cfg.bst_type, 1,
+-				      &cs35l41->pll_lock);
++		ret = cs35l41_global_enable(cs35l41->dev, cs35l41->regmap, cs35l41->hw_cfg.bst_type,
++					    1, &cs35l41->pll_lock, cs35l41->dsp.cs_dsp.running);
+ 		break;
+ 	case SND_SOC_DAPM_POST_PMD:
+-		cs35l41_global_enable(cs35l41->regmap, cs35l41->hw_cfg.bst_type, 0,
+-				      &cs35l41->pll_lock);
++		ret = cs35l41_global_enable(cs35l41->dev, cs35l41->regmap, cs35l41->hw_cfg.bst_type,
++					    0, &cs35l41->pll_lock, cs35l41->dsp.cs_dsp.running);
+ 
+ 		ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS1,
+ 					       val, val &  CS35L41_PDN_DONE_MASK,
+-- 
+2.41.0
+
+From 437f5415c5ac8e49b0675f74132b6e1308b6e5c7 Mon Sep 17 00:00:00 2001
+From: Stefan Binding <sbinding@opensource.cirrus.com>
+Date: Fri, 21 Jul 2023 16:18:07 +0100
+Subject: [PATCH 02/11] ALSA: cs35l41: Poll for Power Up/Down rather than
+ waiting a fixed delay
+
+To ensure the chip has correctly powered up or down before continuing,
+the driver will now poll a register, rather than wait a fixed delay.
+
+Acked-by: Mark Brown <broonie@kernel.org>
+Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
+---
+ sound/soc/codecs/cs35l41-lib.c | 48 +++++++++++++++++++++++++++++++---
+ sound/soc/codecs/cs35l41.c     | 10 -------
+ 2 files changed, 44 insertions(+), 14 deletions(-)
+
+diff --git a/sound/soc/codecs/cs35l41-lib.c b/sound/soc/codecs/cs35l41-lib.c
+index a7556fa33cdd..a9c559a676e7 100644
+--- a/sound/soc/codecs/cs35l41-lib.c
++++ b/sound/soc/codecs/cs35l41-lib.c
+@@ -1196,7 +1196,8 @@ int cs35l41_global_enable(struct device *dev, struct regmap *regmap, enum cs35l4
+ 			  int enable, struct completion *pll_lock, bool firmware_running)
+ {
+ 	int ret;
+-	unsigned int gpio1_func, pad_control, pwr_ctrl1, pwr_ctrl3, int_status;
++	unsigned int gpio1_func, pad_control, pwr_ctrl1, pwr_ctrl3, int_status, pup_pdn_mask;
++	unsigned int pwr_ctl1_val;
+ 	struct reg_sequence cs35l41_mdsync_down_seq[] = {
+ 		{CS35L41_PWR_CTRL3,		0},
+ 		{CS35L41_GPIO_PAD_CONTROL,	0},
+@@ -1208,6 +1209,12 @@ int cs35l41_global_enable(struct device *dev, struct regmap *regmap, enum cs35l4
+ 		{CS35L41_PWR_CTRL1,	0x00000001, 3000},
+ 	};
+ 
++	pup_pdn_mask = enable ? CS35L41_PUP_DONE_MASK : CS35L41_PDN_DONE_MASK;
++
++	ret = regmap_read(regmap, CS35L41_PWR_CTRL1, &pwr_ctl1_val);
++	if (ret)
++		return ret;
++
+ 	if ((pwr_ctl1_val & CS35L41_GLOBAL_EN_MASK) && enable) {
+ 		dev_dbg(dev, "Cannot set Global Enable - already set.\n");
+ 		return 0;
+@@ -1252,6 +1259,15 @@ int cs35l41_global_enable(struct device *dev, struct regmap *regmap, enum cs35l4
+ 			ret = regmap_multi_reg_write(regmap, cs35l41_mdsync_up_seq,
+ 						     ARRAY_SIZE(cs35l41_mdsync_up_seq));
+ 		}
++
++		ret = regmap_read_poll_timeout(regmap, CS35L41_IRQ1_STATUS1,
++					int_status, int_status & pup_pdn_mask,
++					1000, 100000);
++		if (ret)
++			dev_err(dev, "Enable(%d) failed: %d\n", enable, ret);
++
++		// Clear PUP/PDN status
++		regmap_write(regmap, CS35L41_IRQ1_STATUS1, pup_pdn_mask);
+ 		break;
+ 	case CS35L41_INT_BOOST:
+ 		ret = regmap_update_bits(regmap, CS35L41_PWR_CTRL1, CS35L41_GLOBAL_EN_MASK,
+@@ -1260,7 +1276,15 @@ int cs35l41_global_enable(struct device *dev, struct regmap *regmap, enum cs35l4
+ 			dev_err(dev, "CS35L41_PWR_CTRL1 set failed: %d\n", ret);
+ 			return ret;
+ 		}
+-		usleep_range(3000, 3100);
++
++		ret = regmap_read_poll_timeout(regmap, CS35L41_IRQ1_STATUS1,
++					int_status, int_status & pup_pdn_mask,
++					1000, 100000);
++		if (ret)
++			dev_err(dev, "Enable(%d) failed: %d\n", enable, ret);
++
++		/* Clear PUP/PDN status */
++		regmap_write(regmap, CS35L41_IRQ1_STATUS1, pup_pdn_mask);
+ 		break;
+ 	case CS35L41_EXT_BOOST:
+ 	case CS35L41_EXT_BOOST_NO_VSPK_SWITCH:
+@@ -1271,7 +1295,15 @@ int cs35l41_global_enable(struct device *dev, struct regmap *regmap, enum cs35l4
+ 			if (ret)
+ 				return ret;
+ 
+-			usleep_range(3000, 3100);
++			ret = regmap_read_poll_timeout(regmap, CS35L41_IRQ1_STATUS1, int_status,
++				       int_status & CS35L41_PUP_DONE_MASK, 1000, 100000);
++			if (ret) {
++				dev_err(dev, "Failed waiting for CS35L41_PUP_DONE_MASK: %d\n", ret);
++				/* Lock the test key, it was unlocked during the multi_reg_write */
++				cs35l41_test_key_lock(dev, regmap);
++				return ret;
++			}
++			regmap_write(regmap, CS35L41_IRQ1_STATUS1, CS35L41_PUP_DONE_MASK);
+ 
+ 			if (firmware_running)
+ 				ret = cs35l41_set_cspl_mbox_cmd(dev, regmap,
+@@ -1292,7 +1324,15 @@ int cs35l41_global_enable(struct device *dev, struct regmap *regmap, enum cs35l4
+ 				return ret;
+ 			}
+ 
+-			usleep_range(3000, 3100);
++			ret = regmap_read_poll_timeout(regmap, CS35L41_IRQ1_STATUS1, int_status,
++				       int_status & CS35L41_PDN_DONE_MASK, 1000, 100000);
++			if (ret) {
++				dev_err(dev, "Failed waiting for CS35L41_PDN_DONE_MASK: %d\n", ret);
++				/* Lock the test key, it was unlocked during the multi_reg_write */
++				cs35l41_test_key_lock(dev, regmap);
++				return ret;
++			}
++			regmap_write(regmap, CS35L41_IRQ1_STATUS1, CS35L41_PDN_DONE_MASK);
+ 
+ 			/* Test Key is locked here */
+ 			ret = regmap_multi_reg_write(regmap, cs35l41_active_to_safe_end,
+diff --git a/sound/soc/codecs/cs35l41.c b/sound/soc/codecs/cs35l41.c
+index d4e9c9d9b50a..2b3c36f02edb 100644
+--- a/sound/soc/codecs/cs35l41.c
++++ b/sound/soc/codecs/cs35l41.c
+@@ -491,7 +491,6 @@ static int cs35l41_main_amp_event(struct snd_soc_dapm_widget *w,
+ {
+ 	struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
+ 	struct cs35l41_private *cs35l41 = snd_soc_component_get_drvdata(component);
+-	unsigned int val;
+ 	int ret = 0;
+ 
+ 	switch (event) {
+@@ -507,15 +506,6 @@ static int cs35l41_main_amp_event(struct snd_soc_dapm_widget *w,
+ 		ret = cs35l41_global_enable(cs35l41->dev, cs35l41->regmap, cs35l41->hw_cfg.bst_type,
+ 					    0, &cs35l41->pll_lock, cs35l41->dsp.cs_dsp.running);
+ 
+-		ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS1,
+-					       val, val &  CS35L41_PDN_DONE_MASK,
+-					       1000, 100000);
+-		if (ret)
+-			dev_warn(cs35l41->dev, "PDN failed: %d\n", ret);
+-
+-		regmap_write(cs35l41->regmap, CS35L41_IRQ1_STATUS1,
+-			     CS35L41_PDN_DONE_MASK);
+-
+ 		regmap_multi_reg_write_bypassed(cs35l41->regmap,
+ 						cs35l41_pdn_patch,
+ 						ARRAY_SIZE(cs35l41_pdn_patch));
+-- 
+2.41.0
+
+From 796af5ec6c6bb2eadf78a96f629e2c7fba11123b Mon Sep 17 00:00:00 2001
+From: Stefan Binding <sbinding@opensource.cirrus.com>
+Date: Fri, 21 Jul 2023 16:18:08 +0100
+Subject: [PATCH 03/11] ALSA: hda: cs35l41: Check mailbox status of pause
+ command after firmware load
+
+Currently, we do not check the return status of the pause command,
+immediately after we load firmware. If the pause has failed,
+the firmware is not running.
+
+Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
+---
+ sound/pci/hda/cs35l41_hda.c | 7 ++++++-
+ 1 file changed, 6 insertions(+), 1 deletion(-)
+
+diff --git a/sound/pci/hda/cs35l41_hda.c b/sound/pci/hda/cs35l41_hda.c
+index f9c97270db6f..29f1dce45f1d 100644
+--- a/sound/pci/hda/cs35l41_hda.c
++++ b/sound/pci/hda/cs35l41_hda.c
+@@ -781,7 +781,12 @@ static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41)
+ 		goto clean_dsp;
+ 	}
+ 
+-	cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE);
++	ret = cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap, CSPL_MBOX_CMD_PAUSE);
++	if (ret) {
++		dev_err(cs35l41->dev, "Error waiting for DSP to pause: %u\n", ret);
++		goto clean_dsp;
++	}
++
+ 	cs35l41->firmware_running = true;
+ 
+ 	return 0;
+-- 
+2.41.0
+
+From 9684d3a1fbe55573eccd6c7e5f72dd519a4e406b Mon Sep 17 00:00:00 2001
+From: Stefan Binding <sbinding@opensource.cirrus.com>
+Date: Fri, 21 Jul 2023 16:18:09 +0100
+Subject: [PATCH 04/11] ALSA: hda: cs35l41: Ensure we correctly re-sync regmap
+ before system suspending.
+
+In order to properly system suspend, it is necessary to unload the firmware
+and ensure the chip is ready for shutdown (if necessary). If the system
+is currently in runtime suspend, it is necessary to wake up the device,
+and then make it ready. Currently, the wake does not correctly resync
+the device, which may mean it cannot suspend correctly. Fix this by
+performaing a resync.
+
+Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
+---
+ sound/pci/hda/cs35l41_hda.c | 32 +++++++++++++++++++++++++++-----
+ 1 file changed, 27 insertions(+), 5 deletions(-)
+
+diff --git a/sound/pci/hda/cs35l41_hda.c b/sound/pci/hda/cs35l41_hda.c
+index 29f1dce45f1d..f42457147ce4 100644
+--- a/sound/pci/hda/cs35l41_hda.c
++++ b/sound/pci/hda/cs35l41_hda.c
+@@ -574,21 +574,43 @@ static int cs35l41_hda_channel_map(struct device *dev, unsigned int tx_num, unsi
+ 				    rx_slot);
+ }
+ 
+-static void cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41)
++static int cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41)
+ {
++	int ret = 0;
++
+ 	mutex_lock(&cs35l41->fw_mutex);
+ 	if (cs35l41->firmware_running) {
+ 
+ 		regcache_cache_only(cs35l41->regmap, false);
+ 
+-		cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
++		ret = cs35l41_exit_hibernate(cs35l41->dev, cs35l41->regmap);
++		if (ret) {
++			dev_warn(cs35l41->dev, "Unable to exit Hibernate.");
++			goto err;
++		}
++
++		/* Test key needs to be unlocked to allow the OTP settings to re-apply */
++		cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap);
++		ret = regcache_sync(cs35l41->regmap);
++		cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap);
++		if (ret) {
++			dev_err(cs35l41->dev, "Failed to restore register cache: %d\n", ret);
++			goto err;
++		}
++
++		if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
++			cs35l41_init_boost(cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg);
++
+ 		cs35l41_shutdown_dsp(cs35l41);
+ 		cs35l41_safe_reset(cs35l41->regmap, cs35l41->hw_cfg.bst_type);
+-
+-		regcache_cache_only(cs35l41->regmap, true);
+-		regcache_mark_dirty(cs35l41->regmap);
+ 	}
++err:
++	regcache_cache_only(cs35l41->regmap, true);
++	regcache_mark_dirty(cs35l41->regmap);
++
+ 	mutex_unlock(&cs35l41->fw_mutex);
++
++	return ret;
+ }
+ 
+ static int cs35l41_system_suspend(struct device *dev)
+-- 
+2.41.0
+
+From 05bfc01172a34466e660465922d1cab5b460880f Mon Sep 17 00:00:00 2001
+From: Stefan Binding <sbinding@opensource.cirrus.com>
+Date: Fri, 21 Jul 2023 16:18:10 +0100
+Subject: [PATCH 05/11] ALSA: hda: cs35l41: Ensure we pass up any errors during
+ system suspend.
+
+There are several steps required to put the system into system suspend.
+Some of these steps may fail, so the driver should pass up the errors
+if they occur.
+
+Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
+---
+ sound/pci/hda/cs35l41_hda.c | 17 +++++++++++++----
+ 1 file changed, 13 insertions(+), 4 deletions(-)
+
+diff --git a/sound/pci/hda/cs35l41_hda.c b/sound/pci/hda/cs35l41_hda.c
+index f42457147ce4..d4a11f7b5dbd 100644
+--- a/sound/pci/hda/cs35l41_hda.c
++++ b/sound/pci/hda/cs35l41_hda.c
+@@ -626,17 +626,22 @@ static int cs35l41_system_suspend(struct device *dev)
+ 	}
+ 
+ 	ret = pm_runtime_force_suspend(dev);
+-	if (ret)
++	if (ret) {
++		dev_err(dev, "System Suspend Failed, unable to runtime suspend: %d\n", ret);
+ 		return ret;
++	}
+ 
+ 	/* Shutdown DSP before system suspend */
+-	cs35l41_ready_for_reset(cs35l41);
++	ret = cs35l41_ready_for_reset(cs35l41);
++
++	if (ret)
++		dev_err(dev, "System Suspend Failed, not ready for Reset: %d\n", ret);
+ 
+ 	/*
+ 	 * Reset GPIO may be shared, so cannot reset here.
+ 	 * However beyond this point, amps may be powered down.
+ 	 */
+-	return 0;
++	return ret;
+ }
+ 
+ static int cs35l41_system_resume(struct device *dev)
+@@ -659,9 +664,13 @@ static int cs35l41_system_resume(struct device *dev)
+ 	usleep_range(2000, 2100);
+ 
+ 	ret = pm_runtime_force_resume(dev);
++	if (ret) {
++		dev_err(dev, "System Resume Failed: Unable to runtime resume: %d\n", ret);
++		return ret;
++	}
+ 
+ 	mutex_lock(&cs35l41->fw_mutex);
+-	if (!ret && cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) {
++	if (cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) {
+ 		cs35l41->fw_request_ongoing = true;
+ 		schedule_work(&cs35l41->fw_load_work);
+ 	}
+-- 
+2.41.0
+
+From f352ce9e5389e4746f25bfec33f4e0ee4dcbf690 Mon Sep 17 00:00:00 2001
+From: Stefan Binding <sbinding@opensource.cirrus.com>
+Date: Fri, 21 Jul 2023 16:18:11 +0100
+Subject: [PATCH 06/11] ALSA: hda: cs35l41: Move Play and Pause into separate
+ functions
+
+This allows play and pause to be called from multiple places,
+which is necessary for system suspend and resume.
+
+Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
+---
+ sound/pci/hda/cs35l41_hda.c | 131 ++++++++++++++++++++++--------------
+ 1 file changed, 79 insertions(+), 52 deletions(-)
+
+diff --git a/sound/pci/hda/cs35l41_hda.c b/sound/pci/hda/cs35l41_hda.c
+index d4a11f7b5dbd..f77583b46b6b 100644
+--- a/sound/pci/hda/cs35l41_hda.c
++++ b/sound/pci/hda/cs35l41_hda.c
+@@ -483,63 +483,103 @@ static void cs35l41_irq_release(struct cs35l41_hda *cs35l41)
+ 	cs35l41->irq_errors = 0;
+ }
+ 
+-static void cs35l41_hda_playback_hook(struct device *dev, int action)
++static void cs35l41_hda_play_start(struct device *dev)
+ {
+ 	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
+ 	struct regmap *reg = cs35l41->regmap;
+-	int ret = 0;
++
++	dev_dbg(dev, "Play (Start)\n");
++
++	if (cs35l41->playback_started) {
++		dev_dbg(dev, "Playback already started.");
++		return;
++	}
++
++	cs35l41->playback_started = true;
++
++	if (cs35l41->firmware_running) {
++		regmap_multi_reg_write(reg, cs35l41_hda_config_dsp,
++				       ARRAY_SIZE(cs35l41_hda_config_dsp));
++		regmap_update_bits(reg, CS35L41_PWR_CTRL2,
++				   CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
++				   1 << CS35L41_VMON_EN_SHIFT | 1 << CS35L41_IMON_EN_SHIFT);
++		cs35l41_set_cspl_mbox_cmd(cs35l41->dev, reg, CSPL_MBOX_CMD_RESUME);
++	} else {
++		regmap_multi_reg_write(reg, cs35l41_hda_config, ARRAY_SIZE(cs35l41_hda_config));
++	}
++	regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 1 << CS35L41_AMP_EN_SHIFT);
++	if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
++		regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00008001);
++
++}
++
++static void cs35l41_hda_play_done(struct device *dev)
++{
++	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
++	struct regmap *reg = cs35l41->regmap;
++
++	dev_dbg(dev, "Play (Complete)\n");
++
++	cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1, NULL,
++			      cs35l41->firmware_running);
++}
++
++static void cs35l41_hda_pause_start(struct device *dev)
++{
++	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
++	struct regmap *reg = cs35l41->regmap;
++
++	dev_dbg(dev, "Pause (Start)\n");
++
++	regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute));
++	cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0, NULL,
++			      cs35l41->firmware_running);
++}
++
++static void cs35l41_hda_pause_done(struct device *dev)
++{
++	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
++	struct regmap *reg = cs35l41->regmap;
++
++	dev_dbg(dev, "Pause (Complete)\n");
++
++	regmap_update_bits(reg, CS35L41_PWR_CTRL2, CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT);
++	if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
++		regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00000001);
++	if (cs35l41->firmware_running) {
++		cs35l41_set_cspl_mbox_cmd(dev, reg, CSPL_MBOX_CMD_PAUSE);
++		regmap_update_bits(reg, CS35L41_PWR_CTRL2,
++				   CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
++				   0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT);
++	}
++	cs35l41_irq_release(cs35l41);
++	cs35l41->playback_started = false;
++}
++
++static void cs35l41_hda_playback_hook(struct device *dev, int action)
++{
++	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
+ 
+ 	switch (action) {
+ 	case HDA_GEN_PCM_ACT_OPEN:
+ 		pm_runtime_get_sync(dev);
+ 		mutex_lock(&cs35l41->fw_mutex);
+-		cs35l41->playback_started = true;
+-		if (cs35l41->firmware_running) {
+-			regmap_multi_reg_write(reg, cs35l41_hda_config_dsp,
+-					       ARRAY_SIZE(cs35l41_hda_config_dsp));
+-			regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2,
+-					   CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
+-					   1 << CS35L41_VMON_EN_SHIFT | 1 << CS35L41_IMON_EN_SHIFT);
+-			cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap,
+-						  CSPL_MBOX_CMD_RESUME);
+-		} else {
+-			regmap_multi_reg_write(reg, cs35l41_hda_config,
+-					       ARRAY_SIZE(cs35l41_hda_config));
+-		}
+-		ret = regmap_update_bits(reg, CS35L41_PWR_CTRL2,
+-					 CS35L41_AMP_EN_MASK, 1 << CS35L41_AMP_EN_SHIFT);
+-		if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
+-			regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00008001);
++		cs35l41_hda_play_start(dev);
+ 		mutex_unlock(&cs35l41->fw_mutex);
+ 		break;
+ 	case HDA_GEN_PCM_ACT_PREPARE:
+ 		mutex_lock(&cs35l41->fw_mutex);
+-		ret = cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1, NULL,
+-					    cs35l41->firmware_running);
++		cs35l41_hda_play_done(dev);
+ 		mutex_unlock(&cs35l41->fw_mutex);
+ 		break;
+ 	case HDA_GEN_PCM_ACT_CLEANUP:
+ 		mutex_lock(&cs35l41->fw_mutex);
+-		regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute));
+-		ret = cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0, NULL,
+-					    cs35l41->firmware_running);
++		cs35l41_hda_pause_start(dev);
+ 		mutex_unlock(&cs35l41->fw_mutex);
+ 		break;
+ 	case HDA_GEN_PCM_ACT_CLOSE:
+ 		mutex_lock(&cs35l41->fw_mutex);
+-		ret = regmap_update_bits(reg, CS35L41_PWR_CTRL2,
+-					 CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT);
+-		if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
+-			regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00000001);
+-		if (cs35l41->firmware_running) {
+-			cs35l41_set_cspl_mbox_cmd(cs35l41->dev, cs35l41->regmap,
+-						  CSPL_MBOX_CMD_PAUSE);
+-			regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2,
+-					   CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
+-					   0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT);
+-		}
+-		cs35l41_irq_release(cs35l41);
+-		cs35l41->playback_started = false;
++		cs35l41_hda_pause_done(dev);
+ 		mutex_unlock(&cs35l41->fw_mutex);
+ 
+ 		pm_runtime_mark_last_busy(dev);
+@@ -549,9 +589,6 @@ static void cs35l41_hda_playback_hook(struct device *dev, int action)
+ 		dev_warn(cs35l41->dev, "Playback action not supported: %d\n", action);
+ 		break;
+ 	}
+-
+-	if (ret)
+-		dev_err(cs35l41->dev, "Regmap access fail: %d\n", ret);
+ }
+ 
+ static int cs35l41_hda_channel_map(struct device *dev, unsigned int tx_num, unsigned int *tx_slot,
+@@ -703,18 +740,8 @@ static int cs35l41_runtime_suspend(struct device *dev)
+ 	mutex_lock(&cs35l41->fw_mutex);
+ 
+ 	if (cs35l41->playback_started) {
+-		regmap_multi_reg_write(cs35l41->regmap, cs35l41_hda_mute,
+-				       ARRAY_SIZE(cs35l41_hda_mute));
+-		cs35l41_global_enable(cs35l41->dev, cs35l41->regmap, cs35l41->hw_cfg.bst_type, 0,
+-				      NULL, cs35l41->firmware_running);
+-		regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2,
+-				   CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT);
+-		if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST)
+-			regmap_write(cs35l41->regmap, CS35L41_GPIO1_CTRL1, 0x00000001);
+-		regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2,
+-				   CS35L41_VMON_EN_MASK | CS35L41_IMON_EN_MASK,
+-				   0 << CS35L41_VMON_EN_SHIFT | 0 << CS35L41_IMON_EN_SHIFT);
+-		cs35l41->playback_started = false;
++		cs35l41_hda_pause_start(dev);
++		cs35l41_hda_pause_done(dev);
+ 	}
+ 
+ 	if (cs35l41->firmware_running) {
+-- 
+2.41.0
+
+From c1bf8ed3a5f3d011276d975c7b1f62039bed160e Mon Sep 17 00:00:00 2001
+From: Stefan Binding <sbinding@opensource.cirrus.com>
+Date: Fri, 21 Jul 2023 16:18:12 +0100
+Subject: [PATCH 07/11] ALSA: hda: hda_component: Add pre and post playback
+ hooks to hda_component
+
+These hooks can be used to add callbacks that would be run before and after
+the main playback hooks. These hooks would be called for all amps, before
+moving on to the next hook, i.e. pre_playback_hook would be called for
+all amps, before the playback_hook is called for all amps, then finally
+the post_playback_hook is called for all amps.
+
+Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
+---
+ sound/pci/hda/hda_component.h |  2 ++
+ sound/pci/hda/patch_realtek.c | 10 +++++++++-
+ 2 files changed, 11 insertions(+), 1 deletion(-)
+
+diff --git a/sound/pci/hda/hda_component.h b/sound/pci/hda/hda_component.h
+index 534e845b9cd1..f170aec967c1 100644
+--- a/sound/pci/hda/hda_component.h
++++ b/sound/pci/hda/hda_component.h
+@@ -15,5 +15,7 @@ struct hda_component {
+ 	struct device *dev;
+ 	char name[HDA_MAX_NAME_SIZE];
+ 	struct hda_codec *codec;
++	void (*pre_playback_hook)(struct device *dev, int action);
+ 	void (*playback_hook)(struct device *dev, int action);
++	void (*post_playback_hook)(struct device *dev, int action);
+ };
+diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
+index 44fccfb93cff..dff92679ae72 100644
+--- a/sound/pci/hda/patch_realtek.c
++++ b/sound/pci/hda/patch_realtek.c
+@@ -6716,9 +6716,17 @@ static void comp_generic_playback_hook(struct hda_pcm_stream *hinfo, struct hda_
+ 	int i;
+ 
+ 	for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
+-		if (spec->comps[i].dev)
++		if (spec->comps[i].dev && spec->comps[i].pre_playback_hook)
++			spec->comps[i].pre_playback_hook(spec->comps[i].dev, action);
++	}
++	for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
++		if (spec->comps[i].dev && spec->comps[i].playback_hook)
+ 			spec->comps[i].playback_hook(spec->comps[i].dev, action);
+ 	}
++	for (i = 0; i < HDA_MAX_COMPONENTS; i++) {
++		if (spec->comps[i].dev && spec->comps[i].post_playback_hook)
++			spec->comps[i].post_playback_hook(spec->comps[i].dev, action);
++	}
+ }
+ 
+ struct cs35l41_dev_name {
+-- 
+2.41.0
+
+From 4f3b42e2f126f96b1e512871d7073fb10d9a7283 Mon Sep 17 00:00:00 2001
+From: Stefan Binding <sbinding@opensource.cirrus.com>
+Date: Fri, 21 Jul 2023 16:18:13 +0100
+Subject: [PATCH 08/11] ALSA: hda: cs35l41: Use pre and post playback hooks
+
+Use new hooks to ensure separation between play/pause actions,
+as required by external boost.
+
+External Boost on CS35L41 requires the amp to go through a
+particular sequence of steps. One of these steps involes
+the setting of a GPIO. This GPIO is connected to one or
+more of the amps, and it may control the boost for all of
+the amps. To ensure that the GPIO is set when it is safe
+to do so, and to ensure that boost is ready for the rest of
+the sequence to be able to continue, we must ensure that
+the each part of the sequence is executed for each amp
+before moving on to the next part of the sequence.
+
+Some of the Play and Pause actions have moved from Open to
+Prepare. This is because Open is not guaranteed to be called
+again on system resume, whereas Prepare should.
+
+Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
+---
+ sound/pci/hda/cs35l41_hda.c | 53 ++++++++++++++++++++++++++++++-------
+ 1 file changed, 43 insertions(+), 10 deletions(-)
+
+diff --git a/sound/pci/hda/cs35l41_hda.c b/sound/pci/hda/cs35l41_hda.c
+index f77583b46b6b..a482d4752b3f 100644
+--- a/sound/pci/hda/cs35l41_hda.c
++++ b/sound/pci/hda/cs35l41_hda.c
+@@ -556,37 +556,68 @@ static void cs35l41_hda_pause_done(struct device *dev)
+ 	cs35l41->playback_started = false;
+ }
+ 
++static void cs35l41_hda_pre_playback_hook(struct device *dev, int action)
++{
++	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
++
++	switch (action) {
++	case HDA_GEN_PCM_ACT_CLEANUP:
++		mutex_lock(&cs35l41->fw_mutex);
++		cs35l41_hda_pause_start(dev);
++		mutex_unlock(&cs35l41->fw_mutex);
++		break;
++	default:
++		break;
++	}
++}
+ static void cs35l41_hda_playback_hook(struct device *dev, int action)
+ {
+ 	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
+ 
+ 	switch (action) {
+ 	case HDA_GEN_PCM_ACT_OPEN:
++		/*
++		 * All amps must be resumed before we can start playing back.
++		 * This ensures, for external boost, that all amps are in AMP_SAFE mode.
++		 * Do this in HDA_GEN_PCM_ACT_OPEN, since this is run prior to any of the
++		 * other actions.
++		 */
+ 		pm_runtime_get_sync(dev);
+-		mutex_lock(&cs35l41->fw_mutex);
+-		cs35l41_hda_play_start(dev);
+-		mutex_unlock(&cs35l41->fw_mutex);
+ 		break;
+ 	case HDA_GEN_PCM_ACT_PREPARE:
+ 		mutex_lock(&cs35l41->fw_mutex);
+-		cs35l41_hda_play_done(dev);
++		cs35l41_hda_play_start(dev);
+ 		mutex_unlock(&cs35l41->fw_mutex);
+ 		break;
+ 	case HDA_GEN_PCM_ACT_CLEANUP:
+ 		mutex_lock(&cs35l41->fw_mutex);
+-		cs35l41_hda_pause_start(dev);
++		cs35l41_hda_pause_done(dev);
+ 		mutex_unlock(&cs35l41->fw_mutex);
+ 		break;
+ 	case HDA_GEN_PCM_ACT_CLOSE:
+-		mutex_lock(&cs35l41->fw_mutex);
+-		cs35l41_hda_pause_done(dev);
+-		mutex_unlock(&cs35l41->fw_mutex);
+-
++		/*
++		 * Playback must be finished for all amps before we start runtime suspend.
++		 * This ensures no amps are playing back when we start putting them to sleep.
++		 */
+ 		pm_runtime_mark_last_busy(dev);
+ 		pm_runtime_put_autosuspend(dev);
+ 		break;
+ 	default:
+-		dev_warn(cs35l41->dev, "Playback action not supported: %d\n", action);
++		break;
++	}
++}
++
++static void cs35l41_hda_post_playback_hook(struct device *dev, int action)
++{
++	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
++
++	switch (action) {
++	case HDA_GEN_PCM_ACT_PREPARE:
++		mutex_lock(&cs35l41->fw_mutex);
++		cs35l41_hda_play_done(dev);
++		mutex_unlock(&cs35l41->fw_mutex);
++		break;
++	default:
+ 		break;
+ 	}
+ }
+@@ -1037,6 +1068,8 @@ static int cs35l41_hda_bind(struct device *dev, struct device *master, void *mas
+ 	ret = cs35l41_create_controls(cs35l41);
+ 
+ 	comps->playback_hook = cs35l41_hda_playback_hook;
++	comps->pre_playback_hook = cs35l41_hda_pre_playback_hook;
++	comps->post_playback_hook = cs35l41_hda_post_playback_hook;
+ 
+ 	mutex_unlock(&cs35l41->fw_mutex);
+ 
+-- 
+2.41.0
+
+From 5091ba7ad9ea6a88db464b84b4993cc9e5033a84 Mon Sep 17 00:00:00 2001
+From: Stefan Binding <sbinding@opensource.cirrus.com>
+Date: Fri, 21 Jul 2023 16:18:14 +0100
+Subject: [PATCH 09/11] ALSA: hda: cs35l41: Rework System Suspend to ensure
+ correct call separation
+
+In order to correctly pause audio on suspend, amps using external boost
+require parts of the pause sequence to be called for all amps before moving
+on to the next steps.
+For example, as part of pausing the audio, the VSPK GPIO must be disabled,
+but since this GPIO is controlled by one amp, but controls the boost for
+all amps, it is required to separate the calls.
+During playback this is achieved by using the pre and post playback hooks,
+however during system suspend, this is not possible, so to separate the
+calls, we use both the .prepare and .suspend calls to pause the audio.
+
+Currently, for this reason, we do not restart audio on system resume.
+However, we can support this by relying on the playback hook to resume
+playback after system suspend.
+
+Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
+---
+ sound/pci/hda/cs35l41_hda.c | 40 ++++++++++++++++++++++++++++++++-----
+ 1 file changed, 35 insertions(+), 5 deletions(-)
+
+diff --git a/sound/pci/hda/cs35l41_hda.c b/sound/pci/hda/cs35l41_hda.c
+index a482d4752b3f..70aa819cfbd6 100644
+--- a/sound/pci/hda/cs35l41_hda.c
++++ b/sound/pci/hda/cs35l41_hda.c
+@@ -595,6 +595,15 @@ static void cs35l41_hda_playback_hook(struct device *dev, int action)
+ 		mutex_unlock(&cs35l41->fw_mutex);
+ 		break;
+ 	case HDA_GEN_PCM_ACT_CLOSE:
++		mutex_lock(&cs35l41->fw_mutex);
++		if (!cs35l41->firmware_running && cs35l41->request_fw_load &&
++		    !cs35l41->fw_request_ongoing) {
++			dev_info(dev, "Requesting Firmware Load after HDA_GEN_PCM_ACT_CLOSE\n");
++			cs35l41->fw_request_ongoing = true;
++			schedule_work(&cs35l41->fw_load_work);
++		}
++		mutex_unlock(&cs35l41->fw_mutex);
++
+ 		/*
+ 		 * Playback must be finished for all amps before we start runtime suspend.
+ 		 * This ensures no amps are playing back when we start putting them to sleep.
+@@ -681,6 +690,25 @@ static int cs35l41_ready_for_reset(struct cs35l41_hda *cs35l41)
+ 	return ret;
+ }
+ 
++static int cs35l41_system_suspend_prep(struct device *dev)
++{
++	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
++
++	dev_dbg(cs35l41->dev, "System Suspend Prepare\n");
++
++	if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST_NO_VSPK_SWITCH) {
++		dev_err_once(cs35l41->dev, "System Suspend not supported\n");
++		return 0; /* don't block the whole system suspend */
++	}
++
++	mutex_lock(&cs35l41->fw_mutex);
++	if (cs35l41->playback_started)
++		cs35l41_hda_pause_start(dev);
++	mutex_unlock(&cs35l41->fw_mutex);
++
++	return 0;
++}
++
+ static int cs35l41_system_suspend(struct device *dev)
+ {
+ 	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
+@@ -693,6 +721,11 @@ static int cs35l41_system_suspend(struct device *dev)
+ 		return 0; /* don't block the whole system suspend */
+ 	}
+ 
++	mutex_lock(&cs35l41->fw_mutex);
++	if (cs35l41->playback_started)
++		cs35l41_hda_pause_done(dev);
++	mutex_unlock(&cs35l41->fw_mutex);
++
+ 	ret = pm_runtime_force_suspend(dev);
+ 	if (ret) {
+ 		dev_err(dev, "System Suspend Failed, unable to runtime suspend: %d\n", ret);
+@@ -738,6 +771,7 @@ static int cs35l41_system_resume(struct device *dev)
+ 	}
+ 
+ 	mutex_lock(&cs35l41->fw_mutex);
++
+ 	if (cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) {
+ 		cs35l41->fw_request_ongoing = true;
+ 		schedule_work(&cs35l41->fw_load_work);
+@@ -770,11 +804,6 @@ static int cs35l41_runtime_suspend(struct device *dev)
+ 
+ 	mutex_lock(&cs35l41->fw_mutex);
+ 
+-	if (cs35l41->playback_started) {
+-		cs35l41_hda_pause_start(dev);
+-		cs35l41_hda_pause_done(dev);
+-	}
+-
+ 	if (cs35l41->firmware_running) {
+ 		ret = cs35l41_enter_hibernate(cs35l41->dev, cs35l41->regmap,
+ 					      cs35l41->hw_cfg.bst_type);
+@@ -1641,6 +1670,7 @@ EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, SND_HDA_SCODEC_CS35L41);
+ const struct dev_pm_ops cs35l41_hda_pm_ops = {
+ 	RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume,
+ 		       cs35l41_runtime_idle)
++	.prepare = cs35l41_system_suspend_prep,
+ 	SYSTEM_SLEEP_PM_OPS(cs35l41_system_suspend, cs35l41_system_resume)
+ };
+ EXPORT_SYMBOL_NS_GPL(cs35l41_hda_pm_ops, SND_HDA_SCODEC_CS35L41);
+-- 
+2.41.0
+
+From 74c165859e33b62888b93891d82680350b9a615f Mon Sep 17 00:00:00 2001
+From: Stefan Binding <sbinding@opensource.cirrus.com>
+Date: Fri, 21 Jul 2023 16:18:15 +0100
+Subject: [PATCH 10/11] ALSA: hda: cs35l41: Add device_link between HDA and
+ cs35l41_hda
+
+To ensure consistency between the HDA core and the CS35L41 HDA
+driver, add a device_link between them. This ensures that the
+HDA core will suspend first, and resume second, meaning the
+amp driver will not miss any events from the playback hook from
+the HDA core during system suspend and resume.
+
+Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
+---
+ sound/pci/hda/cs35l41_hda.c | 13 ++++++++++++-
+ 1 file changed, 12 insertions(+), 1 deletion(-)
+
+diff --git a/sound/pci/hda/cs35l41_hda.c b/sound/pci/hda/cs35l41_hda.c
+index 70aa819cfbd6..175378cdf9df 100644
+--- a/sound/pci/hda/cs35l41_hda.c
++++ b/sound/pci/hda/cs35l41_hda.c
+@@ -1063,6 +1063,7 @@ static int cs35l41_hda_bind(struct device *dev, struct device *master, void *mas
+ {
+ 	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
+ 	struct hda_component *comps = master_data;
++	unsigned int sleep_flags;
+ 	int ret = 0;
+ 
+ 	if (!comps || cs35l41->index < 0 || cs35l41->index >= HDA_MAX_COMPONENTS)
+@@ -1102,6 +1103,11 @@ static int cs35l41_hda_bind(struct device *dev, struct device *master, void *mas
+ 
+ 	mutex_unlock(&cs35l41->fw_mutex);
+ 
++	sleep_flags = lock_system_sleep();
++	if (!device_link_add(&comps->codec->core.dev, cs35l41->dev, DL_FLAG_STATELESS))
++		dev_warn(dev, "Unable to create device link\n");
++	unlock_system_sleep(sleep_flags);
++
+ 	pm_runtime_mark_last_busy(dev);
+ 	pm_runtime_put_autosuspend(dev);
+ 
+@@ -1112,9 +1118,14 @@ static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *
+ {
+ 	struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
+ 	struct hda_component *comps = master_data;
++	unsigned int sleep_flags;
+ 
+-	if (comps[cs35l41->index].dev == dev)
++	if (comps[cs35l41->index].dev == dev) {
+ 		memset(&comps[cs35l41->index], 0, sizeof(*comps));
++		sleep_flags = lock_system_sleep();
++		device_link_remove(&comps->codec->core.dev, cs35l41->dev);
++		unlock_system_sleep(sleep_flags);
++	}
+ }
+ 
+ static const struct component_ops cs35l41_hda_comp_ops = {
+-- 
+2.41.0
+
+From 6f1a7b41a626a567fcfe915e9dbe3aea34b6c3ec Mon Sep 17 00:00:00 2001
+From: Stefan Binding <sbinding@opensource.cirrus.com>
+Date: Fri, 21 Jul 2023 16:18:16 +0100
+Subject: [PATCH 11/11] ALSA: hda: cs35l41: Ensure amp is only unmuted during
+ playback
+
+Currently we only mute after playback has finished, and unmute
+prior to setting global enable. To prevent any possible pops
+and clicks, mute at probe, and then only unmute after global
+enable is set.
+
+Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
+---
+ sound/pci/hda/cs35l41_hda.c | 22 ++++++++++++++++++++--
+ 1 file changed, 20 insertions(+), 2 deletions(-)
+
+diff --git a/sound/pci/hda/cs35l41_hda.c b/sound/pci/hda/cs35l41_hda.c
+index 175378cdf9df..98feb5ccd586 100644
+--- a/sound/pci/hda/cs35l41_hda.c
++++ b/sound/pci/hda/cs35l41_hda.c
+@@ -58,8 +58,6 @@ static const struct reg_sequence cs35l41_hda_config[] = {
+ 	{ CS35L41_DSP1_RX3_SRC,         0x00000018 }, // DSP1RX3 SRC = VMON
+ 	{ CS35L41_DSP1_RX4_SRC,         0x00000019 }, // DSP1RX4 SRC = IMON
+ 	{ CS35L41_DSP1_RX5_SRC,         0x00000020 }, // DSP1RX5 SRC = ERRVOL
+-	{ CS35L41_AMP_DIG_VOL_CTRL,	0x00008000 }, // AMP_HPF_PCM_EN = 1, AMP_VOL_PCM  0.0 dB
+-	{ CS35L41_AMP_GAIN_CTRL,	0x00000084 }, // AMP_GAIN_PCM 4.5 dB
+ };
+ 
+ static const struct reg_sequence cs35l41_hda_config_dsp[] = {
+@@ -82,6 +80,14 @@ static const struct reg_sequence cs35l41_hda_config_dsp[] = {
+ 	{ CS35L41_DSP1_RX3_SRC,         0x00000018 }, // DSP1RX3 SRC = VMON
+ 	{ CS35L41_DSP1_RX4_SRC,         0x00000019 }, // DSP1RX4 SRC = IMON
+ 	{ CS35L41_DSP1_RX5_SRC,         0x00000029 }, // DSP1RX5 SRC = VBSTMON
++};
++
++static const struct reg_sequence cs35l41_hda_unmute[] = {
++	{ CS35L41_AMP_DIG_VOL_CTRL,	0x00008000 }, // AMP_HPF_PCM_EN = 1, AMP_VOL_PCM  0.0 dB
++	{ CS35L41_AMP_GAIN_CTRL,	0x00000084 }, // AMP_GAIN_PCM 4.5 dB
++};
++
++static const struct reg_sequence cs35l41_hda_unmute_dsp[] = {
+ 	{ CS35L41_AMP_DIG_VOL_CTRL,	0x00008000 }, // AMP_HPF_PCM_EN = 1, AMP_VOL_PCM  0.0 dB
+ 	{ CS35L41_AMP_GAIN_CTRL,	0x00000233 }, // AMP_GAIN_PCM = 17.5dB AMP_GAIN_PDM = 19.5dB
+ };
+@@ -522,6 +528,13 @@ static void cs35l41_hda_play_done(struct device *dev)
+ 
+ 	cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1, NULL,
+ 			      cs35l41->firmware_running);
++	if (cs35l41->firmware_running) {
++		regmap_multi_reg_write(reg, cs35l41_hda_unmute_dsp,
++				       ARRAY_SIZE(cs35l41_hda_unmute_dsp));
++	} else {
++		regmap_multi_reg_write(reg, cs35l41_hda_unmute,
++				       ARRAY_SIZE(cs35l41_hda_unmute));
++	}
+ }
+ 
+ static void cs35l41_hda_pause_start(struct device *dev)
+@@ -1616,6 +1629,11 @@ int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int i
+ 	if (ret)
+ 		goto err;
+ 
++	ret = regmap_multi_reg_write(cs35l41->regmap, cs35l41_hda_mute,
++				     ARRAY_SIZE(cs35l41_hda_mute));
++	if (ret)
++		goto err;
++
+ 	INIT_WORK(&cs35l41->fw_load_work, cs35l41_fw_load_work);
+ 	mutex_init(&cs35l41->fw_mutex);
+ 
+-- 
+2.41.0
+