ASoC: cs42l42: Handle system suspend

Add system suspend functions to handle clean power-down on suspend and
restoring registers on resume.

The jack state could change during suspend. Plug->unplug and unplug->plug
are straightforward because this looks no different from any other plug
state change - there will be a plugged or unplugged interrupt pending.
The jack could be unplugged and a different type of jack plugged, and on
resume the plug state would not have changed. Setting plug_state back to
TS_TRANS (transitioning) will make the next plug interrupt after resume
run a type detection.

During system suspend any jack plug/unplug and button events will not be
reported or generate a system wakeup. If the plug state or headset type
has changed it will be reported after resume.

Signed-off-by: Richard Fitzgerald <rf@opensource.cirrus.com>
Link: https://lore.kernel.org/r/20220121120412.672284-4-rf@opensource.cirrus.com
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/sound/soc/codecs/cs42l42.c b/sound/soc/codecs/cs42l42.c
index f1b95d4..db6ef6c 100644 (file)
--- a/sound/soc/codecs/cs42l42.c
+++ b/sound/soc/codecs/cs42l42.c
@@ -1614,6 +1614,10 @@ static irqreturn_t cs42l42_irq_thread(int irq, void *data)
        int report = 0;
 
        mutex_lock(&cs42l42->irq_lock);
+       if (cs42l42->suspended) {
+               mutex_unlock(&cs42l42->irq_lock);
+               return IRQ_NONE;
+       }
 
        /* Read sticky registers to clear interurpt */
        for (i = 0; i < ARRAY_SIZE(stickies); i++) {
@@ -2047,6 +2051,138 @@ static int cs42l42_handle_device_data(struct device *dev,
        return 0;
 }
 
+/* Datasheet suspend sequence */
+static const struct reg_sequence __maybe_unused cs42l42_shutdown_seq[] = {
+       REG_SEQ0(CS42L42_MIC_DET_CTL1,          0x9F),
+       REG_SEQ0(CS42L42_ADC_OVFL_INT_MASK,     0x01),
+       REG_SEQ0(CS42L42_MIXER_INT_MASK,        0x0F),
+       REG_SEQ0(CS42L42_SRC_INT_MASK,          0x0F),
+       REG_SEQ0(CS42L42_ASP_RX_INT_MASK,       0x1F),
+       REG_SEQ0(CS42L42_ASP_TX_INT_MASK,       0x0F),
+       REG_SEQ0(CS42L42_CODEC_INT_MASK,        0x03),
+       REG_SEQ0(CS42L42_SRCPL_INT_MASK,        0x7F),
+       REG_SEQ0(CS42L42_VPMON_INT_MASK,        0x01),
+       REG_SEQ0(CS42L42_PLL_LOCK_INT_MASK,     0x01),
+       REG_SEQ0(CS42L42_TSRS_PLUG_INT_MASK,    0x0F),
+       REG_SEQ0(CS42L42_WAKE_CTL,              0xE1),
+       REG_SEQ0(CS42L42_DET_INT1_MASK,         0xE0),
+       REG_SEQ0(CS42L42_DET_INT2_MASK,         0xFF),
+       REG_SEQ0(CS42L42_MIXER_CHA_VOL,         0x3F),
+       REG_SEQ0(CS42L42_MIXER_ADC_VOL,         0x3F),
+       REG_SEQ0(CS42L42_MIXER_CHB_VOL,         0x3F),
+       REG_SEQ0(CS42L42_HP_CTL,                0x0F),
+       REG_SEQ0(CS42L42_ASP_RX_DAI0_EN,        0x00),
+       REG_SEQ0(CS42L42_ASP_CLK_CFG,           0x00),
+       REG_SEQ0(CS42L42_HSDET_CTL2,            0x00),
+       REG_SEQ0(CS42L42_PWR_CTL1,              0xFE),
+       REG_SEQ0(CS42L42_PWR_CTL2,              0x8C),
+       REG_SEQ0(CS42L42_DAC_CTL2,              0x02),
+       REG_SEQ0(CS42L42_HS_CLAMP_DISABLE,      0x00),
+       REG_SEQ0(CS42L42_MISC_DET_CTL,          0x03),
+       REG_SEQ0(CS42L42_TIPSENSE_CTL,          0x02),
+       REG_SEQ0(CS42L42_HSBIAS_SC_AUTOCTL,     0x03),
+       REG_SEQ0(CS42L42_PWR_CTL1,              0xFF)
+};
+
+static int __maybe_unused cs42l42_suspend(struct device *dev)
+{
+       struct cs42l42_private *cs42l42 = dev_get_drvdata(dev);
+       unsigned int reg;
+       u8 save_regs[ARRAY_SIZE(cs42l42_shutdown_seq)];
+       int i, ret;
+
+       /*
+        * Wait for threaded irq handler to be idle and stop it processing
+        * future interrupts. This ensures a safe disable if the interrupt
+        * is shared.
+        */
+       mutex_lock(&cs42l42->irq_lock);
+       cs42l42->suspended = true;
+
+       /* Save register values that will be overwritten by shutdown sequence */
+       for (i = 0; i < ARRAY_SIZE(cs42l42_shutdown_seq); ++i) {
+               regmap_read(cs42l42->regmap, cs42l42_shutdown_seq[i].reg, &reg);
+               save_regs[i] = (u8)reg;
+       }
+
+       /* Shutdown codec */
+       regmap_multi_reg_write(cs42l42->regmap,
+                              cs42l42_shutdown_seq,
+                              ARRAY_SIZE(cs42l42_shutdown_seq));
+
+       /* All interrupt sources are now disabled */
+       mutex_unlock(&cs42l42->irq_lock);
+
+       /* Wait for power-down complete */
+       msleep(CS42L42_PDN_DONE_TIME_MS);
+       ret = regmap_read_poll_timeout(cs42l42->regmap,
+                                      CS42L42_CODEC_STATUS, reg,
+                                      (reg & CS42L42_PDN_DONE_MASK),
+                                      CS42L42_PDN_DONE_POLL_US,
+                                      CS42L42_PDN_DONE_TIMEOUT_US);
+       if (ret)
+               dev_warn(dev, "Failed to get PDN_DONE: %d\n", ret);
+
+       /* Discharge FILT+ */
+       regmap_update_bits(cs42l42->regmap, CS42L42_PWR_CTL2,
+                          CS42L42_DISCHARGE_FILT_MASK, CS42L42_DISCHARGE_FILT_MASK);
+       msleep(CS42L42_FILT_DISCHARGE_TIME_MS);
+
+       regcache_cache_only(cs42l42->regmap, true);
+       gpiod_set_value_cansleep(cs42l42->reset_gpio, 0);
+       regulator_bulk_disable(ARRAY_SIZE(cs42l42->supplies), cs42l42->supplies);
+
+       /* Restore register values to the regmap cache */
+       for (i = 0; i < ARRAY_SIZE(cs42l42_shutdown_seq); ++i)
+               regmap_write(cs42l42->regmap, cs42l42_shutdown_seq[i].reg, save_regs[i]);
+
+       /* The cached address page register value is now stale */
+       regcache_drop_region(cs42l42->regmap, CS42L42_PAGE_REGISTER, CS42L42_PAGE_REGISTER);
+
+       dev_dbg(dev, "System suspended\n");
+
+       return 0;
+
+}
+
+static int __maybe_unused cs42l42_resume(struct device *dev)
+{
+       struct cs42l42_private *cs42l42 = dev_get_drvdata(dev);
+       int ret;
+
+       /*
+        * If jack was unplugged and re-plugged during suspend it could
+        * have changed type but the tip-sense state hasn't changed.
+        * Force a plugged state to be re-evaluated.
+        */
+       if (cs42l42->plug_state != CS42L42_TS_UNPLUG)
+               cs42l42->plug_state = CS42L42_TS_TRANS;
+
+       ret = regulator_bulk_enable(ARRAY_SIZE(cs42l42->supplies), cs42l42->supplies);
+       if (ret != 0) {
+               dev_err(dev, "Failed to enable supplies: %d\n", ret);
+               return ret;
+       }
+
+       gpiod_set_value_cansleep(cs42l42->reset_gpio, 1);
+       usleep_range(CS42L42_BOOT_TIME_US, CS42L42_BOOT_TIME_US * 2);
+
+       regcache_cache_only(cs42l42->regmap, false);
+       regcache_mark_dirty(cs42l42->regmap);
+
+       mutex_lock(&cs42l42->irq_lock);
+       /* Sync LATCH_TO_VP first so the VP domain registers sync correctly */
+       regcache_sync_region(cs42l42->regmap, CS42L42_MIC_DET_CTL1, CS42L42_MIC_DET_CTL1);
+       regcache_sync(cs42l42->regmap);
+
+       cs42l42->suspended = false;
+       mutex_unlock(&cs42l42->irq_lock);
+
+       dev_dbg(dev, "System resumed\n");
+
+       return 0;
+}
+
 static int cs42l42_i2c_probe(struct i2c_client *i2c_client,
                                       const struct i2c_device_id *id)
 {
@@ -2217,6 +2353,10 @@ static int cs42l42_i2c_remove(struct i2c_client *i2c_client)
        return 0;
 }
 
+static const struct dev_pm_ops cs42l42_pm_ops = {
+       SET_SYSTEM_SLEEP_PM_OPS(cs42l42_suspend, cs42l42_resume)
+};
+
 #ifdef CONFIG_OF
 static const struct of_device_id cs42l42_of_match[] = {
        { .compatible = "cirrus,cs42l42", },
@@ -2243,6 +2383,7 @@ MODULE_DEVICE_TABLE(i2c, cs42l42_id);
 static struct i2c_driver cs42l42_i2c_driver = {
        .driver = {
                .name = "cs42l42",
+               .pm = &cs42l42_pm_ops,
                .of_match_table = of_match_ptr(cs42l42_of_match),
                .acpi_match_table = ACPI_PTR(cs42l42_acpi_match),
                },

diff --git a/sound/soc/codecs/cs42l42.h b/sound/soc/codecs/cs42l42.h
index 53d9628..244b24d 100644 (file)
--- a/sound/soc/codecs/cs42l42.h
+++ b/sound/soc/codecs/cs42l42.h
@@ -826,6 +826,10 @@
 #define CS42L42_PLL_LOCK_POLL_US       250
 #define CS42L42_PLL_LOCK_TIMEOUT_US    1250
 #define CS42L42_HP_ADC_EN_TIME_US      20000
+#define CS42L42_PDN_DONE_POLL_US       1000
+#define CS42L42_PDN_DONE_TIMEOUT_US    200000
+#define CS42L42_PDN_DONE_TIME_MS       100
+#define CS42L42_FILT_DISCHARGE_TIME_MS 46
 
 static const char *const cs42l42_supply_names[CS42L42_NUM_SUPPLIES] = {
        "VA",
@@ -860,6 +864,7 @@ struct  cs42l42_private {
        u8 hs_bias_sense_en;
        u8 stream_use;
        bool hp_adc_up_pending;
+       bool suspended;
 };
 
 #endif /* __CS42L42_H__ */