firmware: cs_dsp: Add API to hibernate the DSP

For some parts, the DSP is kept running when in low power mode
(hibernation), leaving the firmware ALSA controls enabled, but the
registers are inaccessible. Attempts to access volatile firmware
controls whilst in this state would produce errors in the kernel log
due to a regmap_raw_read() into DSP registers whilst the regmap is in
cache_only.

To remove this error log, add a hibernating flag to indicate that the
controls are inaccessible, so we no longer try to read or write to the
registers whilst the regmap is in cache_only.

This would still produce an error when trying to read or write to these
controls, but this would be a different error (-EPERM instead of
-EBUSY), and would not produce a spurious error log in the kernel.

Upon wake from hibernation, the control caches are re-synced to the
hardware, if the DSP is running.

Signed-off-by: Stefan Binding <sbinding@opensource.cirrus.com>
Link: https://patch.msgid.link/20260224161821.93365-2-sbinding@opensource.cirrus.com
Reviewed-by: Richard Fitzgerald <rf@opensource.cirrus.com>
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/drivers/firmware/cirrus/cs_dsp.c b/drivers/firmware/cirrus/cs_dsp.c
index b4f1c01e3b5b6d86fa02bd51d10ec01bd9923164..f9d8a883900d8a8a1f0b727ddd4b5dbc5096929d 100644 (file)
--- a/drivers/firmware/cirrus/cs_dsp.c
+++ b/drivers/firmware/cirrus/cs_dsp.c
@@ -515,6 +515,7 @@ void cs_dsp_init_debugfs(struct cs_dsp *dsp, struct dentry *debugfs_root)
 
        debugfs_create_bool("booted", 0444, root, &dsp->booted);
        debugfs_create_bool("running", 0444, root, &dsp->running);
+       debugfs_create_bool("hibernating", 0444, root, &dsp->hibernating);
        debugfs_create_x32("fw_id", 0444, root, &dsp->fw_id);
        debugfs_create_x32("fw_version", 0444, root, &dsp->fw_id_version);
 
@@ -703,7 +704,7 @@ int cs_dsp_coeff_write_acked_control(struct cs_dsp_coeff_ctl *ctl, unsigned int
 
        lockdep_assert_held(&dsp->pwr_lock);
 
-       if (!dsp->running)
+       if (!dsp->running || dsp->hibernating)
                return -EPERM;
 
        ret = cs_dsp_coeff_base_reg(ctl, &reg, 0);
@@ -827,7 +828,7 @@ int cs_dsp_coeff_write_ctrl(struct cs_dsp_coeff_ctl *ctl,
        }
 
        ctl->set = 1;
-       if (ctl->enabled && ctl->dsp->running)
+       if (ctl->enabled && ctl->dsp->running && !ctl->dsp->hibernating)
                ret = cs_dsp_coeff_write_ctrl_raw(ctl, off, buf, len);
 
        if (ret < 0)
@@ -920,12 +921,12 @@ int cs_dsp_coeff_read_ctrl(struct cs_dsp_coeff_ctl *ctl,
                return -EINVAL;
 
        if (ctl->flags & WMFW_CTL_FLAG_VOLATILE) {
-               if (ctl->enabled && ctl->dsp->running)
+               if (ctl->enabled && ctl->dsp->running && !ctl->dsp->hibernating)
                        return cs_dsp_coeff_read_ctrl_raw(ctl, off, buf, len);
                else
                        return -EPERM;
        } else {
-               if (!ctl->flags && ctl->enabled && ctl->dsp->running)
+               if (!ctl->flags && ctl->enabled && ctl->dsp->running && !ctl->dsp->hibernating)
                        ret = cs_dsp_coeff_read_ctrl_raw(ctl, 0, ctl->cache, ctl->len);
 
                if (buf != ctl->cache)
@@ -1108,6 +1109,44 @@ err_ctl:
        return ret;
 }
 
+
+/**
+ * cs_dsp_hibernate() - Disable or enable all controls for a DSP
+ * @dsp: pointer to DSP structure
+ * @hibernate: whether to set controls to cache only mode
+ *
+ * When @hibernate is true, the DSP is entering hibernation mode where the
+ * regmap is inaccessible, and all controls become cache only.
+ * When @hibernate is false, the DSP has exited hibernation mode. If the DSP
+ * is running, all controls are re-synced to the DSP.
+ *
+ */
+void cs_dsp_hibernate(struct cs_dsp *dsp, bool hibernate)
+{
+       mutex_lock(&dsp->pwr_lock);
+
+       if (!dsp->running) {
+               cs_dsp_dbg(dsp, "Cannot hibernate, DSP not running\n");
+               goto out;
+       }
+
+       if (dsp->hibernating == hibernate)
+               goto out;
+
+       cs_dsp_dbg(dsp, "Set hibernating to %d\n", hibernate);
+       dsp->hibernating = hibernate;
+
+       if (!dsp->hibernating && dsp->running) {
+               int ret = cs_dsp_coeff_sync_controls(dsp);
+
+               if (ret)
+                       cs_dsp_err(dsp, "Error syncing controls: %d\n", ret);
+       }
+out:
+       mutex_unlock(&dsp->pwr_lock);
+}
+EXPORT_SYMBOL_NS_GPL(cs_dsp_hibernate, "FW_CS_DSP");
+
 struct cs_dsp_coeff_parsed_alg {
        int id;
        const u8 *name;
@@ -2498,6 +2537,7 @@ int cs_dsp_adsp1_power_up(struct cs_dsp *dsp,
                goto err_ena;
 
        dsp->booted = true;
+       dsp->hibernating = false;
 
        /* Start the core running */
        regmap_update_bits(dsp->regmap, dsp->base + ADSP1_CONTROL_30,
@@ -2776,6 +2816,7 @@ int cs_dsp_power_up(struct cs_dsp *dsp,
                dsp->ops->disable_core(dsp);
 
        dsp->booted = true;
+       dsp->hibernating = false;
 
        mutex_unlock(&dsp->pwr_lock);
 

diff --git a/include/linux/firmware/cirrus/cs_dsp.h b/include/linux/firmware/cirrus/cs_dsp.h
index 0ec1cdc5585d25a11ff9c3250b00a710663571d1..4e3baa5570687e7b9eca564a23900211f166582a 100644 (file)
--- a/include/linux/firmware/cirrus/cs_dsp.h
+++ b/include/linux/firmware/cirrus/cs_dsp.h
@@ -179,6 +179,7 @@ struct cs_dsp {
 
        bool booted;
        bool running;
+       bool hibernating;
 
        struct list_head ctl_list;
 
@@ -354,4 +355,6 @@ int cs_dsp_chunk_write(struct cs_dsp_chunk *ch, int nbits, u32 val);
 int cs_dsp_chunk_flush(struct cs_dsp_chunk *ch);
 int cs_dsp_chunk_read(struct cs_dsp_chunk *ch, int nbits);
 
+void cs_dsp_hibernate(struct cs_dsp *dsp, bool hibernating);
+
 #endif