Support System Suspend and Resume for CS35L41 HDA
cover Support System Suspend and Resume for CS35L41 HDA
The CS35L41 HDA driver currently only supports runtime suspend and resume. Add support for system suspend and resume into the CS35L41 HDA driver. The driver will put the parts into a state where they can be powered down during suspend, and on system resume, it will restore the part. If firmware was previously loaded, during system suspend, the firmware will be unloaded, and during system resume, it will be loaded again.
Note: System suspend is only supported for models which use Internal Boost, or models which use External Boost with a Boost Enable GPIO.
The chain also contains minor bug fixes for the CS35L41 HDA driver, and associated hda_cs_dsp_ctl driver.
Richard Fitzgerald (1):
ALSA: hda/cs_dsp_ctl: Fix mutex inversion when creating controls
Stefan Binding (4):
ALSA: hda: hda_cs_dsp_ctl: Minor clean and redundant code removal
ALSA: hda: hda_cs_dsp_ctl: Ensure pwr_lock is held before
reading/writing controls
ALSA: hda: cs35l41: Remove suspend/resume hda hooks
ALSA: hda: cs35l41: Support System Suspend
sound/pci/hda/cs35l41_hda.c | 197 +++++++++++++++++++++++++-------- sound/pci/hda/hda_component.h | 2 - sound/pci/hda/hda_cs_dsp_ctl.c | 79 +++++++------ sound/pci/hda/hda_cs_dsp_ctl.h | 2 +- sound/pci/hda/patch_realtek.c | 19 +--- 5 files changed, 198 insertions(+), 101 deletions(-)
Signature · 1 line
2.34.1
PATCH 1/5 ALSA: hda: hda_cs_dsp_ctl: Minor clean and redundant code removal
The cs_dsp core will return an error if passed a NULL cs_dsp struct so there is no need for the hda_cs_dsp_write|read_ctl functions to manually check that. The cs_dsp core will also check the data is within bounds of the control so the additional bounds check is redundant too. Simplify things a bit by removing said code.
--- sound/pci/hda/hda_cs_dsp_ctl.c | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-)
sound/pci/hda/hda_cs_dsp_ctl.c +4 -13
@@ -199,16 +199,10 @@ EXPORT_SYMBOL_NS_GPL(hda_cs_dsp_control_remove, SND_HDA_CS_DSP_CONTROLS);int hda_cs_dsp_write_ctl (struct cs_dsp *dsp,const char *name,int type,unsigned int alg,const void *buf,size_t len) { -struct cs_dsp_coeff_ctl *cs_ctl; +struct cs_dsp_coeff_ctl *cs_ctl =cs_dsp_get_ctl (dsp, name, type, alg);struct hda_cs_dsp_coeff_ctl *ctl;int ret; - cs_ctl =cs_dsp_get_ctl (dsp, name, type, alg); -if (!cs_ctl) -return -EINVAL ; - - ctl = cs_ctl->priv; - ret =cs_dsp_coeff_write_ctrl (cs_ctl,0 , buf, len);if (ret)return ret;
@@ -216,6 +210,8 @@ int hda_cs_dsp_write_ctl(struct cs_dsp *dsp, const char *name, int type,if (cs_ctl->flags &WMFW_CTL_FLAG_SYS )return 0 ; + ctl = cs_ctl->priv; +snd_ctl_notify (ctl->card,SNDRV_CTL_EVENT_MASK_VALUE , &ctl->kctl->id);return 0 ;
@@ -225,13 +221,8 @@ EXPORT_SYMBOL_NS_GPL(hda_cs_dsp_write_ctl, SND_HDA_CS_DSP_CONTROLS);int hda_cs_dsp_read_ctl (struct cs_dsp *dsp,const char *name,int type,unsigned int alg,void *buf,size_t len) { -struct cs_dsp_coeff_ctl *cs_ctl; - - cs_ctl =cs_dsp_get_ctl (dsp, name, type, alg); -if (!cs_ctl) -return -EINVAL ; +return cs_dsp_coeff_read_ctrl (cs_dsp_get_ctl (dsp, name, type, alg),0 , buf, len); -return cs_dsp_coeff_read_ctrl (cs_ctl,0 , buf, len); }EXPORT_SYMBOL_NS_GPL (hda_cs_dsp_read_ctl,SND_HDA_CS_DSP_CONTROLS );
Signature · 1 line
2.34.1
PATCH 2/5 ALSA: hda: hda_cs_dsp_ctl: Ensure pwr_lock is held before reading/writing controls
In reply to Stefan BindingThese apis require the pwr_lock to be held.
--- sound/pci/hda/hda_cs_dsp_ctl.c | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-)
sound/pci/hda/hda_cs_dsp_ctl.c +11 -2
@@ -199,11 +199,14 @@ EXPORT_SYMBOL_NS_GPL(hda_cs_dsp_control_remove, SND_HDA_CS_DSP_CONTROLS);int hda_cs_dsp_write_ctl (struct cs_dsp *dsp,const char *name,int type,unsigned int alg,const void *buf,size_t len) { -struct cs_dsp_coeff_ctl *cs_ctl =cs_dsp_get_ctl (dsp, name, type, alg); +struct cs_dsp_coeff_ctl *cs_ctl;struct hda_cs_dsp_coeff_ctl *ctl;int ret; +mutex_lock (&dsp->pwr_lock); + cs_ctl =cs_dsp_get_ctl (dsp, name, type, alg); ret =cs_dsp_coeff_write_ctrl (cs_ctl,0 , buf, len); +mutex_unlock (&dsp->pwr_lock);if (ret)return ret;
@@ -221,7 +224,13 @@ EXPORT_SYMBOL_NS_GPL(hda_cs_dsp_write_ctl, SND_HDA_CS_DSP_CONTROLS);int hda_cs_dsp_read_ctl (struct cs_dsp *dsp,const char *name,int type,unsigned int alg,void *buf,size_t len) { -return cs_dsp_coeff_read_ctrl (cs_dsp_get_ctl (dsp, name, type, alg),0 , buf, len); +int ret; + +mutex_lock (&dsp->pwr_lock); + ret =cs_dsp_coeff_read_ctrl (cs_dsp_get_ctl (dsp, name, type, alg),0 , buf, len); +mutex_unlock (&dsp->pwr_lock); + +return ret; }EXPORT_SYMBOL_NS_GPL (hda_cs_dsp_read_ctl,SND_HDA_CS_DSP_CONTROLS );
Signature · 1 line
2.34.1
PATCH 3/5 ALSA: hda/cs_dsp_ctl: Fix mutex inversion when creating controls
In reply to Stefan BindingFrom: Richard Fitzgerald <[email protected]>
Redesign the creation of ALSA controls so that the cs_dsp pwr_lock is not held when calling snd_ctl_add(). Instead of creating the ALSA control from the cs_dsp control_add callback, do it after cs_dsp_power_up() has completed. The existing functions are changed to return void instead of passing errors back - this duplicates the original behaviour, as cs_dsp does not abort firmware load if creation of a control fails.
It is safe to walk the control list without taking any mutex provided that the caller is not trying to load a new firmware or remove the driver in parallel. There is no other situation that the list can change. So the caller can trigger creation of ALSA controls after cs_dsp_power_up() has returned. A cs_dsp control will have a non-NULL priv pointer if we have created an ALSA control.
With the previous code the ALSA controls were created from the cs_dsp control_add callback. But this is called with pwr_lock held (as it is part of the DSP power-up sequence). The kernel lock checking will show a mutex inversion between this and the control creation path:
control_add
pwr_lock held, takes controls_rwsem (in snd_ctl_add)
get/put
controls_rwsem held, takes pwr_lock to call cs_dsp.
This is not completely theoretical. Although the time window is very small, it is possible for these to run in parallel and deadlock the old implementation.
--- sound/pci/hda/cs35l41_hda.c | 8 ++--- sound/pci/hda/hda_cs_dsp_ctl.c | 59 ++++++++++++++++++++-------------- sound/pci/hda/hda_cs_dsp_ctl.h | 2 +- 3 files changed, 40 insertions(+), 29 deletions(-)
sound/pci/hda/cs35l41_hda.c +4 -4
@@ -91,20 +91,18 @@ static const struct reg_sequence cs35l41_hda_mute[] = { { CS35L41_AMP_DIG_VOL_CTRL, 0x0000A678 }, // AMP_VOL_PCM Mute }; -static int cs35l41_control_add (struct cs_dsp_coeff_ctl *cs_ctl) +static void cs35l41_add_controls (struct cs35l41_hda *cs35l41) { - struct cs35l41_hda *cs35l41 = container_of(cs_ctl->dsp, struct cs35l41_hda, cs_dsp);struct hda_cs_dsp_ctl_info info; info.device_name = cs35l41->amp_name; info.fw_type = cs35l41->firmware_type; info.card = cs35l41->codec->card; -return hda_cs_dsp_control_add (cs_ctl, &info); +hda_cs_dsp_add_controls (&cs35l41->cs_dsp, &info); }static const struct cs_dsp_client_ops client_ops = { - .control_add = cs35l41_control_add, .control_remove = hda_cs_dsp_control_remove, };
@@ -435,6 +433,8 @@ static int cs35l41_init_dsp(struct cs35l41_hda *cs35l41)if (ret) goto err_release; +cs35l41_add_controls (cs35l41); + ret =cs35l41_save_calibration (cs35l41); err_release:
sound/pci/hda/hda_cs_dsp_ctl.c +35 -24
108 lines not on this page · raw message
sound/pci/hda/hda_cs_dsp_ctl.h +1 -1
@@ -29,7 +29,7 @@ struct hda_cs_dsp_ctl_info {extern const char *const hda_cs_dsp_fw_ids[HDA_CS_DSP_NUM_FW ]; -int hda_cs_dsp_control_add (struct cs_dsp_coeff_ctl *cs_ctl,struct hda_cs_dsp_ctl_info *info); +void hda_cs_dsp_add_controls (struct cs_dsp *dsp,const struct hda_cs_dsp_ctl_info *info);void hda_cs_dsp_control_remove (struct cs_dsp_coeff_ctl *cs_ctl);int hda_cs_dsp_write_ctl (struct cs_dsp *dsp,const char *name,int type,unsigned int alg,const void *buf,size_t len);
Signature · 1 line
2.34.1
PATCH 4/5 ALSA: hda: cs35l41: Remove suspend/resume hda hooks
In reply to Stefan BindingThe current code uses calls from the HDA Codec driver to determine when to suspend/resume by calling hooks via the hda_component binding.
However, this means the cs35l41 driver relies on the HDA Codec driver to tell it when to suspend or resume, creating an additional external dependency, and potentially creating race conditions in the future. It is better for the cs35l41 hda driver to decide for itself when the part should be suspended or resumed.
This makes supporting system suspend easier.
--- sound/pci/hda/cs35l41_hda.c | 31 ++++++++++++------------------- sound/pci/hda/hda_component.h | 2 -- sound/pci/hda/patch_realtek.c | 19 +------------------ 3 files changed, 13 insertions(+), 39 deletions(-)
sound/pci/hda/cs35l41_hda.c +12 -19
@@ -487,10 +487,10 @@ static void cs35l41_hda_playback_hook(struct device *dev, int action)struct regmap *reg = cs35l41->regmap;int ret =0 ; -mutex_lock (&cs35l41->fw_mutex); -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,
@@ -508,15 +508,21 @@ static void cs35l41_hda_playback_hook(struct device *dev, int action) 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 ); +mutex_unlock (&cs35l41->fw_mutex);break ;case HDA_GEN_PCM_ACT_PREPARE : +mutex_lock (&cs35l41->fw_mutex); ret =cs35l41_global_enable (reg, cs35l41->hw_cfg.bst_type,1 ); +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 ); +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 )
@@ -530,14 +536,16 @@ static void cs35l41_hda_playback_hook(struct device *dev, int action) }cs35l41_irq_release (cs35l41); cs35l41->playback_started = false; +mutex_unlock (&cs35l41->fw_mutex); + +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 ; } -mutex_unlock (&cs35l41->fw_mutex); -if (ret)dev_err (cs35l41->dev,"Regmap access fail: %d\n" , ret); }
@@ -618,19 +626,6 @@ static int cs35l41_runtime_resume(struct device *dev)return 0 ; } -static int cs35l41_hda_suspend_hook (struct device *dev) -{ -dev_dbg (dev,"Request Suspend\n" ); -pm_runtime_mark_last_busy (dev); -return pm_runtime_put_autosuspend (dev); -} - -static int cs35l41_hda_resume_hook (struct device *dev) -{ -dev_dbg (dev,"Request Resume\n" ); -return pm_runtime_get_sync (dev); -} -static int cs35l41_smart_amp (struct cs35l41_hda *cs35l41) {int halo_sts;
@@ -863,8 +858,6 @@ 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->suspend_hook = cs35l41_hda_suspend_hook; - comps->resume_hook = cs35l41_hda_resume_hook;pm_runtime_mark_last_busy (dev);pm_runtime_put_autosuspend (dev);
sound/pci/hda/hda_component.h +0 -2
@@ -16,6 +16,4 @@ struct hda_component {char name[HDA_MAX_NAME_SIZE ];struct hda_codec *codec;void (*playback_hook)(struct device *dev,int action); -int (*suspend_hook)(struct device *dev); -int (*resume_hook)(struct device *dev); };
sound/pci/hda/patch_realtek.c +1 -18
@@ -4022,22 +4022,16 @@ static void alc5505_dsp_init(struct hda_codec *codec)static int alc269_suspend (struct hda_codec *codec) {struct alc_spec *spec = codec->spec; -int i;if (spec->has_alc5505_dsp)alc5505_dsp_suspend (codec); -for (i =0 ; i <HDA_MAX_COMPONENTS ; i++) -if (spec->comps[i].suspend_hook) - spec->comps[i].suspend_hook (spec->comps[i].dev); -return alc_suspend (codec); }static int alc269_resume (struct hda_codec *codec) {struct alc_spec *spec = codec->spec; -int i;if (spec->codec_variant ==ALC269_TYPE_ALC269VB )alc269vb_toggle_power_output (codec,0 );
@@ -4068,10 +4062,6 @@ static int alc269_resume(struct hda_codec *codec)if (spec->has_alc5505_dsp)alc5505_dsp_resume (codec); -for (i =0 ; i <HDA_MAX_COMPONENTS ; i++) -if (spec->comps[i].resume_hook) - spec->comps[i].resume_hook (spec->comps[i].dev); - return 0; }#endif /* CONFIG_PM */
@@ -6664,19 +6654,12 @@ static int comp_bind(struct device *dev) {struct hda_codec *cdc =dev_to_hda_codec (dev);struct alc_spec *spec = cdc->spec; -int ret, i; +int ret; ret =component_bind_all (dev, spec->comps);if (ret)return ret; -if (snd_hdac_is_power_on (&cdc->core)) { -codec_dbg (cdc,"Resuming after bind.\n" ); -for (i =0 ; i <HDA_MAX_COMPONENTS ; i++) -if (spec->comps[i].resume_hook) - spec->comps[i].resume_hook (spec->comps[i].dev); - } -return 0 ; }
Signature · 1 line
2.34.1
PATCH 5/5 ALSA: hda: cs35l41: Support System Suspend
In reply to Stefan BindingAdd support for system suspend into the CS35L41 HDA Driver. Since S4 suspend may power off the system, it is required that the driver ensure the part is safe to be shutdown before system suspend, as well as ensuring that the firmware is unloaded before shutdown. The part must then be restored on system resume, including re-downloading the firmware.
--- sound/pci/hda/cs35l41_hda.c | 160 ++++++++++++++++++++++++++++++------ 1 file changed, 136 insertions(+), 24 deletions(-)
sound/pci/hda/cs35l41_hda.c +136 -24
@@ -461,9 +461,12 @@ static void cs35l41_remove_dsp(struct cs35l41_hda *cs35l41)struct cs_dsp *dsp = &cs35l41->cs_dsp;cancel_work_sync (&cs35l41->fw_load_work); + +mutex_lock (&cs35l41->fw_mutex);cs35l41_shutdown_dsp (cs35l41);cs_dsp_remove (dsp); cs35l41->halo_initialized = false; +mutex_unlock (&cs35l41->fw_mutex); }/* Protection release cycle to get the speaker out of Safe-Mode */
@@ -570,45 +573,148 @@ 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) +{ +mutex_lock (&cs35l41->fw_mutex); +if (cs35l41->firmware_running) { + +regcache_cache_only (cs35l41->regmap, false); + +cs35l41_exit_hibernate (cs35l41->dev, cs35l41->regmap); +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); + } +mutex_unlock (&cs35l41->fw_mutex); +} + +static int cs35l41_system_suspend (struct device *dev) +{ +struct cs35l41_hda *cs35l41 =dev_get_drvdata (dev); +int ret; + +dev_dbg (cs35l41->dev,"System Suspend\n" ); + +if (cs35l41->hw_cfg.bst_type ==CS35L41_EXT_BOOST_NO_VSPK_SWITCH ) { +dev_err (cs35l41->dev,"System Suspend not supported\n" ); +return -EINVAL ; + } + + ret =pm_runtime_force_suspend (dev); +if (ret) +return ret; + +/* Shutdown DSP before system suspend */ +cs35l41_ready_for_reset (cs35l41); + +/* +* Reset GPIO may be shared, so cannot reset here. +* However beyond this point, amps may be powered down. +*/ +return 0 ; +} + +static int cs35l41_system_resume (struct device *dev) +{ +struct cs35l41_hda *cs35l41 =dev_get_drvdata (dev); +int ret; + +dev_dbg (cs35l41->dev,"System Resume\n" ); + +if (cs35l41->hw_cfg.bst_type ==CS35L41_EXT_BOOST_NO_VSPK_SWITCH ) { +dev_err (cs35l41->dev,"System Resume not supported\n" ); +return -EINVAL ; + } + +if (cs35l41->reset_gpio) { +usleep_range (2000 ,2100 ); +gpiod_set_value_cansleep (cs35l41->reset_gpio,1 ); + } + +usleep_range (2000 ,2100 ); + + ret =pm_runtime_force_resume (dev); + +mutex_lock (&cs35l41->fw_mutex); +if (!ret && cs35l41->request_fw_load && !cs35l41->fw_request_ongoing) { + cs35l41->fw_request_ongoing = true; +schedule_work (&cs35l41->fw_load_work); + } +mutex_unlock (&cs35l41->fw_mutex); + +return ret; +} +static int cs35l41_runtime_suspend (struct device *dev) {struct cs35l41_hda *cs35l41 =dev_get_drvdata (dev); +int ret =0 ; -dev_dbg (cs35l41->dev,"Suspend\n" ); +dev_dbg (cs35l41->dev,"Runtime Suspend\n" ); -if (!cs35l41->firmware_running) +if (cs35l41->hw_cfg.bst_type ==CS35L41_EXT_BOOST_NO_VSPK_SWITCH ) { +dev_dbg (cs35l41->dev,"Runtime Suspend not supported\n" );return 0 ; + } -if (cs35l41_enter_hibernate (cs35l41->dev, cs35l41->regmap, cs35l41->hw_cfg.bst_type) <0 ) -return 0 ; +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->regmap, cs35l41->hw_cfg.bst_type,0 ); +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; + } + +if (cs35l41->firmware_running) { + ret =cs35l41_enter_hibernate (cs35l41->dev, cs35l41->regmap, + cs35l41->hw_cfg.bst_type); +if (ret) + goto err; + }else { +cs35l41_safe_reset (cs35l41->regmap, cs35l41->hw_cfg.bst_type); + }regcache_cache_only (cs35l41->regmap, true);regcache_mark_dirty (cs35l41->regmap); -return 0 ; +err: +mutex_unlock (&cs35l41->fw_mutex); + +return ret; }static int cs35l41_runtime_resume (struct device *dev) {struct cs35l41_hda *cs35l41 =dev_get_drvdata (dev); -int ret; +int ret =0 ; -dev_dbg (cs35l41->dev,"Resume.\n" ); +dev_dbg (cs35l41->dev,"Runtime Resume\n" );if (cs35l41->hw_cfg.bst_type ==CS35L41_EXT_BOOST_NO_VSPK_SWITCH ) { -dev_dbg (cs35l41->dev,"System does not support Resume\n" ); +dev_dbg (cs35l41->dev,"Runtime Resume not supported\n" );return 0 ; } -if (!cs35l41->firmware_running) -return 0 ; +mutex_lock (&cs35l41->fw_mutex);regcache_cache_only (cs35l41->regmap, false); - ret =cs35l41_exit_hibernate (cs35l41->dev, cs35l41->regmap); -if (ret) { -regcache_cache_only (cs35l41->regmap, true); -return ret; +if (cs35l41->firmware_running) { + 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 */
@@ -617,13 +723,16 @@ static int cs35l41_runtime_resume(struct device *dev)cs35l41_test_key_lock (cs35l41->dev, cs35l41->regmap);if (ret) {dev_err (cs35l41->dev,"Failed to restore register cache: %d\n" , ret); -return ret; + goto err; }if (cs35l41->hw_cfg.bst_type ==CS35L41_EXT_BOOST )cs35l41_init_boost (cs35l41->dev, cs35l41->regmap, &cs35l41->hw_cfg); -return 0 ; +err: +mutex_unlock (&cs35l41->fw_mutex); + +return ret; }static int cs35l41_smart_amp (struct cs35l41_hda *cs35l41)
@@ -673,8 +782,6 @@ static int cs35l41_smart_amp(struct cs35l41_hda *cs35l41)static void cs35l41_load_firmware (struct cs35l41_hda *cs35l41,bool load) { -pm_runtime_get_sync (cs35l41->dev); -if (cs35l41->firmware_running && !load) {dev_dbg (cs35l41->dev,"Unloading Firmware\n" );cs35l41_shutdown_dsp (cs35l41);
@@ -684,9 +791,6 @@ static void cs35l41_load_firmware(struct cs35l41_hda *cs35l41, bool load) }else {dev_dbg (cs35l41->dev,"Unable to Load firmware.\n" ); } - -pm_runtime_mark_last_busy (cs35l41->dev); -pm_runtime_put_autosuspend (cs35l41->dev); } static int cs35l41_fw_load_ctl_get(struct snd_kcontrol *kcontrol,
@@ -702,16 +806,21 @@ static void cs35l41_fw_load_work(struct work_struct *work) { struct cs35l41_hda *cs35l41 = container_of(work, struct cs35l41_hda, fw_load_work); +pm_runtime_get_sync (cs35l41->dev); +mutex_lock (&cs35l41->fw_mutex);/* Recheck if playback is ongoing, mutex will block playback during firmware loading */ if (cs35l41->playback_started) -dev_err (cs35l41->dev,"Cannot Load/Unload firmware during Playback\n" ); +dev_err (cs35l41->dev,"Cannot Load/Unload firmware during Playback. Retrying...\n" );else cs35l41_load_firmware (cs35l41, cs35l41->request_fw_load); cs35l41->fw_request_ongoing = false;mutex_unlock (&cs35l41->fw_mutex); + +pm_runtime_mark_last_busy (cs35l41->dev); +pm_runtime_put_autosuspend (cs35l41->dev); } static int cs35l41_fw_load_ctl_put(struct snd_kcontrol *kcontrol,
@@ -835,6 +944,8 @@ static int cs35l41_hda_bind(struct device *dev, struct device *master, void *maspm_runtime_get_sync (dev); +mutex_lock (&cs35l41->fw_mutex); + comps->dev = dev;if (!cs35l41->acpi_subsystem_id) cs35l41->acpi_subsystem_id = kasprintf(GFP_KERNEL, "%.8x",
@@ -847,10 +958,8 @@ static int cs35l41_hda_bind(struct device *dev, struct device *master, void *masif (firmware_autostart) {dev_dbg (cs35l41->dev,"Firmware Autostart.\n" ); cs35l41->request_fw_load = true; -mutex_lock (&cs35l41->fw_mutex);if (cs35l41_smart_amp (cs35l41) <0 )dev_warn (cs35l41->dev,"Cannot Run Firmware, reverting to dsp bypass...\n" ); -mutex_unlock (&cs35l41->fw_mutex); }else {dev_dbg (cs35l41->dev,"Firmware Autostart is disabled.\n" ); }
@@ -859,6 +968,8 @@ static int cs35l41_hda_bind(struct device *dev, struct device *master, void *mas comps->playback_hook = cs35l41_hda_playback_hook; +mutex_unlock (&cs35l41->fw_mutex); +pm_runtime_mark_last_busy (dev);pm_runtime_put_autosuspend (dev);
@@ -1426,6 +1537,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, NULL) +SYSTEM_SLEEP_PM_OPS (cs35l41_system_suspend, cs35l41_system_resume) };EXPORT_SYMBOL_NS_GPL (cs35l41_hda_pm_ops,SND_HDA_SCODEC_CS35L41 );
Signature · 1 line
2.34.1
Quoted 17 lines · Stefan Binding
The CS35L41 HDA driver currently only supports runtime suspend and resume. Add support for system suspend and resume into the CS35L41 HDA driver. The driver will put the parts into a state where they can be powered down during suspend, and on system resume, it will restore the part. If firmware was previously loaded, during system suspend, the firmware will be unloaded, and during system resume, it will be loaded again.
Note: System suspend is only supported for models which use Internal Boost, or models which use External Boost with a Boost Enable GPIO.
The chain also contains minor bug fixes for the CS35L41 HDA driver, and associated
hda_cs_dsp_ctldriver.Richard Fitzgerald (1):
ALSA: hda/cs_dsp_ctl: Fix mutex inversion when creating controls
Quoted 6 lines
Stefan Binding (4):
ALSA: hda:hda_cs_dsp_ctl: Minor clean and redundant code removal
ALSA: hda:hda_cs_dsp_ctl: Ensurepwr_lockis held before
reading/writing controls
ALSA: hda: cs35l41: Remove suspend/resume hda hooks
ALSA: hda: cs35l41: Support System Suspend
Applied all five patches now.
thanks,
Takashi