sound/soc/codecs/cs35l56.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 //
   3 // Driver for Cirrus Logic CS35L56 smart amp
   4 //
   5 // Copyright (C) 2023 Cirrus Logic, Inc. and
   6 //                    Cirrus Logic International Semiconductor Ltd.
   7
   8 #include <linux/acpi.h>
   9 #include <linux/completion.h>
  10 #include <linux/debugfs.h>
  11 #include <linux/delay.h>
  12 #include <linux/err.h>
  13 #include <linux/gpio/consumer.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/math.h>
  16 #include <linux/module.h>
  17 #include <linux/pm.h>
  18 #include <linux/pm_runtime.h>
  19 #include <linux/property.h>
  20 #include <linux/regmap.h>
  21 #include <linux/regulator/consumer.h>
  22 #include <linux/slab.h>
  23 #include <linux/soundwire/sdw.h>
  24 #include <linux/types.h>
  25 #include <linux/workqueue.h>
  26 #include <sound/cs-amp-lib.h>
  27 #include <sound/pcm.h>
  28 #include <sound/pcm_params.h>
  29 #include <sound/soc.h>
  30 #include <sound/soc-dapm.h>
  31 #include <sound/tlv.h>
  32
  33 #include "wm_adsp.h"
  34 #include "cs35l56.h"
  35
  36 static int cs35l56_dsp_event(struct snd_soc_dapm_widget *w,
  37                              struct snd_kcontrol *kcontrol, int event);
  38
  39 static void cs35l56_wait_dsp_ready(struct cs35l56_private *cs35l56)
  40 {
  41         /* Wait for patching to complete */
  42         flush_work(&cs35l56->dsp_work);
  43 }
  44
  45 static int cs35l56_dspwait_get_volsw(struct snd_kcontrol *kcontrol,
  46                                      struct snd_ctl_elem_value *ucontrol)
  47 {
  48         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
  49         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
  50
  51         cs35l56_wait_dsp_ready(cs35l56);
  52         return snd_soc_get_volsw(kcontrol, ucontrol);
  53 }
  54
  55 static int cs35l56_dspwait_put_volsw(struct snd_kcontrol *kcontrol,
  56                                      struct snd_ctl_elem_value *ucontrol)
  57 {
  58         struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
  59         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
  60
  61         cs35l56_wait_dsp_ready(cs35l56);
  62         return snd_soc_put_volsw(kcontrol, ucontrol);
  63 }
  64
  65 static const unsigned short cs35l56_asp1_mixer_regs[] = {
  66         CS35L56_ASP1TX1_INPUT, CS35L56_ASP1TX2_INPUT,
  67         CS35L56_ASP1TX3_INPUT, CS35L56_ASP1TX4_INPUT,
  68 };
  69
  70 static const char * const cs35l56_asp1_mux_control_names[] = {
  71         "ASP1 TX1 Source", "ASP1 TX2 Source", "ASP1 TX3 Source", "ASP1 TX4 Source"
  72 };
  73
  74 static int cs35l56_sync_asp1_mixer_widgets_with_firmware(struct cs35l56_private *cs35l56)
  75 {
  76         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(cs35l56->component);
  77         const char *prefix = cs35l56->component->name_prefix;
  78         char full_name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
  79         const char *name;
  80         struct snd_kcontrol *kcontrol;
  81         struct soc_enum *e;
  82         unsigned int val[4];
  83         int i, item, ret;
  84
  85         if (cs35l56->asp1_mixer_widgets_initialized)
  86                 return 0;
  87
  88         /*
  89          * Resume so we can read the registers from silicon if the regmap
  90          * cache has not yet been populated.
  91          */
  92         ret = pm_runtime_resume_and_get(cs35l56->base.dev);
  93         if (ret < 0)
  94                 return ret;
  95
  96         /* Wait for firmware download and reboot */
  97         cs35l56_wait_dsp_ready(cs35l56);
  98
  99         ret = regmap_bulk_read(cs35l56->base.regmap, CS35L56_ASP1TX1_INPUT,
 100                                val, ARRAY_SIZE(val));
 101
 102         pm_runtime_mark_last_busy(cs35l56->base.dev);
 103         pm_runtime_put_autosuspend(cs35l56->base.dev);
 104
 105         if (ret) {
 106                 dev_err(cs35l56->base.dev, "Failed to read ASP1 mixer regs: %d\n", ret);
 107                 return ret;
 108         }
 109
 110         for (i = 0; i < ARRAY_SIZE(cs35l56_asp1_mux_control_names); ++i) {
 111                 name = cs35l56_asp1_mux_control_names[i];
 112
 113                 if (prefix) {
 114                         snprintf(full_name, sizeof(full_name), "%s %s", prefix, name);
 115                         name = full_name;
 116                 }
 117
 118                 kcontrol = snd_soc_card_get_kcontrol_locked(dapm->card, name);
 119                 if (!kcontrol) {
 120                         dev_warn(cs35l56->base.dev, "Could not find control %s\n", name);
 121                         continue;
 122                 }
 123
 124                 e = (struct soc_enum *)kcontrol->private_value;
 125                 item = snd_soc_enum_val_to_item(e, val[i] & CS35L56_ASP_TXn_SRC_MASK);
 126                 snd_soc_dapm_mux_update_power(dapm, kcontrol, item, e, NULL);
 127         }
 128
 129         cs35l56->asp1_mixer_widgets_initialized = true;
 130
 131         return 0;
 132 }
 133
 134 static int cs35l56_dspwait_asp1tx_get(struct snd_kcontrol *kcontrol,
 135                                       struct snd_ctl_elem_value *ucontrol)
 136 {
 137         struct snd_soc_component *component = snd_soc_dapm_kcontrol_component(kcontrol);
 138         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
 139         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 140         int index = e->shift_l;
 141         unsigned int addr, val;
 142         int ret;
 143
 144         ret = cs35l56_sync_asp1_mixer_widgets_with_firmware(cs35l56);
 145         if (ret)
 146                 return ret;
 147
 148         addr = cs35l56_asp1_mixer_regs[index];
 149         ret = regmap_read(cs35l56->base.regmap, addr, &val);
 150         if (ret)
 151                 return ret;
 152
 153         val &= CS35L56_ASP_TXn_SRC_MASK;
 154         ucontrol->value.enumerated.item[0] = snd_soc_enum_val_to_item(e, val);
 155
 156         return 0;
 157 }
 158
 159 static int cs35l56_dspwait_asp1tx_put(struct snd_kcontrol *kcontrol,
 160                                       struct snd_ctl_elem_value *ucontrol)
 161 {
 162         struct snd_soc_component *component = snd_soc_dapm_kcontrol_component(kcontrol);
 163         struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_dapm(kcontrol);
 164         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
 165         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 166         int item = ucontrol->value.enumerated.item[0];
 167         int index = e->shift_l;
 168         unsigned int addr, val;
 169         bool changed;
 170         int ret;
 171
 172         ret = cs35l56_sync_asp1_mixer_widgets_with_firmware(cs35l56);
 173         if (ret)
 174                 return ret;
 175
 176         addr = cs35l56_asp1_mixer_regs[index];
 177         val = snd_soc_enum_item_to_val(e, item);
 178
 179         ret = regmap_update_bits_check(cs35l56->base.regmap, addr,
 180                                        CS35L56_ASP_TXn_SRC_MASK, val, &changed);
 181         if (ret)
 182                 return ret;
 183
 184         if (changed)
 185                 snd_soc_dapm_mux_update_power(dapm, kcontrol, item, e, NULL);
 186
 187         return changed;
 188 }
 189
 190 static DECLARE_TLV_DB_SCALE(vol_tlv, -10000, 25, 0);
 191
 192 static const struct snd_kcontrol_new cs35l56_controls[] = {
 193         SOC_SINGLE_EXT("Speaker Switch",
 194                        CS35L56_MAIN_RENDER_USER_MUTE, 0, 1, 1,
 195                        cs35l56_dspwait_get_volsw, cs35l56_dspwait_put_volsw),
 196         SOC_SINGLE_S_EXT_TLV("Speaker Volume",
 197                              CS35L56_MAIN_RENDER_USER_VOLUME,
 198                              6, -400, 400, 9, 0,
 199                              cs35l56_dspwait_get_volsw,
 200                              cs35l56_dspwait_put_volsw,
 201                              vol_tlv),
 202         SOC_SINGLE_EXT("Posture Number", CS35L56_MAIN_POSTURE_NUMBER,
 203                        0, 255, 0,
 204                        cs35l56_dspwait_get_volsw, cs35l56_dspwait_put_volsw),
 205 };
 206
 207 static SOC_VALUE_ENUM_SINGLE_DECL(cs35l56_asp1tx1_enum,
 208                                   SND_SOC_NOPM,
 209                                   0, 0,
 210                                   cs35l56_tx_input_texts,
 211                                   cs35l56_tx_input_values);
 212
 213 static const struct snd_kcontrol_new asp1_tx1_mux =
 214         SOC_DAPM_ENUM_EXT("ASP1TX1 SRC", cs35l56_asp1tx1_enum,
 215                           cs35l56_dspwait_asp1tx_get, cs35l56_dspwait_asp1tx_put);
 216
 217 static SOC_VALUE_ENUM_SINGLE_DECL(cs35l56_asp1tx2_enum,
 218                                   SND_SOC_NOPM,
 219                                   1, 0,
 220                                   cs35l56_tx_input_texts,
 221                                   cs35l56_tx_input_values);
 222
 223 static const struct snd_kcontrol_new asp1_tx2_mux =
 224         SOC_DAPM_ENUM_EXT("ASP1TX2 SRC", cs35l56_asp1tx2_enum,
 225                           cs35l56_dspwait_asp1tx_get, cs35l56_dspwait_asp1tx_put);
 226
 227 static SOC_VALUE_ENUM_SINGLE_DECL(cs35l56_asp1tx3_enum,
 228                                   SND_SOC_NOPM,
 229                                   2, 0,
 230                                   cs35l56_tx_input_texts,
 231                                   cs35l56_tx_input_values);
 232
 233 static const struct snd_kcontrol_new asp1_tx3_mux =
 234         SOC_DAPM_ENUM_EXT("ASP1TX3 SRC", cs35l56_asp1tx3_enum,
 235                           cs35l56_dspwait_asp1tx_get, cs35l56_dspwait_asp1tx_put);
 236
 237 static SOC_VALUE_ENUM_SINGLE_DECL(cs35l56_asp1tx4_enum,
 238                                   SND_SOC_NOPM,
 239                                   3, 0,
 240                                   cs35l56_tx_input_texts,
 241                                   cs35l56_tx_input_values);
 242
 243 static const struct snd_kcontrol_new asp1_tx4_mux =
 244         SOC_DAPM_ENUM_EXT("ASP1TX4 SRC", cs35l56_asp1tx4_enum,
 245                           cs35l56_dspwait_asp1tx_get, cs35l56_dspwait_asp1tx_put);
 246
 247 static SOC_VALUE_ENUM_SINGLE_DECL(cs35l56_sdw1tx1_enum,
 248                                 CS35L56_SWIRE_DP3_CH1_INPUT,
 249                                 0, CS35L56_SWIRETXn_SRC_MASK,
 250                                 cs35l56_tx_input_texts,
 251                                 cs35l56_tx_input_values);
 252
 253 static const struct snd_kcontrol_new sdw1_tx1_mux =
 254         SOC_DAPM_ENUM("SDW1TX1 SRC", cs35l56_sdw1tx1_enum);
 255
 256 static SOC_VALUE_ENUM_SINGLE_DECL(cs35l56_sdw1tx2_enum,
 257                                 CS35L56_SWIRE_DP3_CH2_INPUT,
 258                                 0, CS35L56_SWIRETXn_SRC_MASK,
 259                                 cs35l56_tx_input_texts,
 260                                 cs35l56_tx_input_values);
 261
 262 static const struct snd_kcontrol_new sdw1_tx2_mux =
 263         SOC_DAPM_ENUM("SDW1TX2 SRC", cs35l56_sdw1tx2_enum);
 264
 265 static SOC_VALUE_ENUM_SINGLE_DECL(cs35l56_sdw1tx3_enum,
 266                                 CS35L56_SWIRE_DP3_CH3_INPUT,
 267                                 0, CS35L56_SWIRETXn_SRC_MASK,
 268                                 cs35l56_tx_input_texts,
 269                                 cs35l56_tx_input_values);
 270
 271 static const struct snd_kcontrol_new sdw1_tx3_mux =
 272         SOC_DAPM_ENUM("SDW1TX3 SRC", cs35l56_sdw1tx3_enum);
 273
 274 static SOC_VALUE_ENUM_SINGLE_DECL(cs35l56_sdw1tx4_enum,
 275                                 CS35L56_SWIRE_DP3_CH4_INPUT,
 276                                 0, CS35L56_SWIRETXn_SRC_MASK,
 277                                 cs35l56_tx_input_texts,
 278                                 cs35l56_tx_input_values);
 279
 280 static const struct snd_kcontrol_new sdw1_tx4_mux =
 281         SOC_DAPM_ENUM("SDW1TX4 SRC", cs35l56_sdw1tx4_enum);
 282
 283 static int cs35l56_asp1_cfg_event(struct snd_soc_dapm_widget *w,
 284                                   struct snd_kcontrol *kcontrol, int event)
 285 {
 286         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 287         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
 288
 289         switch (event) {
 290         case SND_SOC_DAPM_PRE_PMU:
 291                 /* Override register values set by firmware boot */
 292                 return cs35l56_force_sync_asp1_registers_from_cache(&cs35l56->base);
 293         default:
 294                 return 0;
 295         }
 296 }
 297
 298 static int cs35l56_play_event(struct snd_soc_dapm_widget *w,
 299                               struct snd_kcontrol *kcontrol, int event)
 300 {
 301         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 302         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
 303         unsigned int val;
 304         int ret;
 305
 306         dev_dbg(cs35l56->base.dev, "play: %d\n", event);
 307
 308         switch (event) {
 309         case SND_SOC_DAPM_PRE_PMU:
 310                 /* Don't wait for ACK, we check in POST_PMU that it completed */
 311                 return regmap_write(cs35l56->base.regmap, CS35L56_DSP_VIRTUAL1_MBOX_1,
 312                                     CS35L56_MBOX_CMD_AUDIO_PLAY);
 313         case SND_SOC_DAPM_POST_PMU:
 314                 /* Wait for firmware to enter PS0 power state */
 315                 ret = regmap_read_poll_timeout(cs35l56->base.regmap,
 316                                                CS35L56_TRANSDUCER_ACTUAL_PS,
 317                                                val, (val == CS35L56_PS0),
 318                                                CS35L56_PS0_POLL_US,
 319                                                CS35L56_PS0_TIMEOUT_US);
 320                 if (ret)
 321                         dev_err(cs35l56->base.dev, "PS0 wait failed: %d\n", ret);
 322                 return ret;
 323         case SND_SOC_DAPM_POST_PMD:
 324                 return cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PAUSE);
 325         default:
 326                 return 0;
 327         }
 328 }
 329
 330 static const struct snd_soc_dapm_widget cs35l56_dapm_widgets[] = {
 331         SND_SOC_DAPM_REGULATOR_SUPPLY("VDD_B", 0, 0),
 332         SND_SOC_DAPM_REGULATOR_SUPPLY("VDD_AMP", 0, 0),
 333
 334         SND_SOC_DAPM_SUPPLY("ASP1 CFG", SND_SOC_NOPM, 0, 0, cs35l56_asp1_cfg_event,
 335                             SND_SOC_DAPM_PRE_PMU),
 336
 337         SND_SOC_DAPM_SUPPLY("PLAY", SND_SOC_NOPM, 0, 0, cs35l56_play_event,
 338                             SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
 339
 340         SND_SOC_DAPM_OUT_DRV("AMP", SND_SOC_NOPM, 0, 0, NULL, 0),
 341         SND_SOC_DAPM_OUTPUT("SPK"),
 342
 343         SND_SOC_DAPM_PGA_E("DSP1", SND_SOC_NOPM, 0, 0, NULL, 0, cs35l56_dsp_event,
 344                            SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
 345
 346         SND_SOC_DAPM_AIF_IN("ASP1RX1", NULL, 0, CS35L56_ASP1_ENABLES1,
 347                             CS35L56_ASP_RX1_EN_SHIFT, 0),
 348         SND_SOC_DAPM_AIF_IN("ASP1RX2", NULL, 1, CS35L56_ASP1_ENABLES1,
 349                             CS35L56_ASP_RX2_EN_SHIFT, 0),
 350         SND_SOC_DAPM_AIF_OUT("ASP1TX1", NULL, 0, CS35L56_ASP1_ENABLES1,
 351                              CS35L56_ASP_TX1_EN_SHIFT, 0),
 352         SND_SOC_DAPM_AIF_OUT("ASP1TX2", NULL, 1, CS35L56_ASP1_ENABLES1,
 353                              CS35L56_ASP_TX2_EN_SHIFT, 0),
 354         SND_SOC_DAPM_AIF_OUT("ASP1TX3", NULL, 2, CS35L56_ASP1_ENABLES1,
 355                              CS35L56_ASP_TX3_EN_SHIFT, 0),
 356         SND_SOC_DAPM_AIF_OUT("ASP1TX4", NULL, 3, CS35L56_ASP1_ENABLES1,
 357                              CS35L56_ASP_TX4_EN_SHIFT, 0),
 358
 359         SND_SOC_DAPM_MUX("ASP1 TX1 Source", SND_SOC_NOPM, 0, 0, &asp1_tx1_mux),
 360         SND_SOC_DAPM_MUX("ASP1 TX2 Source", SND_SOC_NOPM, 0, 0, &asp1_tx2_mux),
 361         SND_SOC_DAPM_MUX("ASP1 TX3 Source", SND_SOC_NOPM, 0, 0, &asp1_tx3_mux),
 362         SND_SOC_DAPM_MUX("ASP1 TX4 Source", SND_SOC_NOPM, 0, 0, &asp1_tx4_mux),
 363
 364         SND_SOC_DAPM_MUX("SDW1 TX1 Source", SND_SOC_NOPM, 0, 0, &sdw1_tx1_mux),
 365         SND_SOC_DAPM_MUX("SDW1 TX2 Source", SND_SOC_NOPM, 0, 0, &sdw1_tx2_mux),
 366         SND_SOC_DAPM_MUX("SDW1 TX3 Source", SND_SOC_NOPM, 0, 0, &sdw1_tx3_mux),
 367         SND_SOC_DAPM_MUX("SDW1 TX4 Source", SND_SOC_NOPM, 0, 0, &sdw1_tx4_mux),
 368
 369         SND_SOC_DAPM_SIGGEN("VMON ADC"),
 370         SND_SOC_DAPM_SIGGEN("IMON ADC"),
 371         SND_SOC_DAPM_SIGGEN("ERRVOL ADC"),
 372         SND_SOC_DAPM_SIGGEN("CLASSH ADC"),
 373         SND_SOC_DAPM_SIGGEN("VDDBMON ADC"),
 374         SND_SOC_DAPM_SIGGEN("VBSTMON ADC"),
 375         SND_SOC_DAPM_SIGGEN("TEMPMON ADC"),
 376 };
 377
 378 #define CS35L56_SRC_ROUTE(name) \
 379         { name" Source", "ASP1RX1", "ASP1RX1" }, \
 380         { name" Source", "ASP1RX2", "ASP1RX2" }, \
 381         { name" Source", "VMON", "VMON ADC" }, \
 382         { name" Source", "IMON", "IMON ADC" }, \
 383         { name" Source", "ERRVOL", "ERRVOL ADC" },   \
 384         { name" Source", "CLASSH", "CLASSH ADC" },   \
 385         { name" Source", "VDDBMON", "VDDBMON ADC" }, \
 386         { name" Source", "VBSTMON", "VBSTMON ADC" }, \
 387         { name" Source", "DSP1TX1", "DSP1" }, \
 388         { name" Source", "DSP1TX2", "DSP1" }, \
 389         { name" Source", "DSP1TX3", "DSP1" }, \
 390         { name" Source", "DSP1TX4", "DSP1" }, \
 391         { name" Source", "DSP1TX5", "DSP1" }, \
 392         { name" Source", "DSP1TX6", "DSP1" }, \
 393         { name" Source", "DSP1TX7", "DSP1" }, \
 394         { name" Source", "DSP1TX8", "DSP1" }, \
 395         { name" Source", "TEMPMON", "TEMPMON ADC" }, \
 396         { name" Source", "INTERPOLATOR", "AMP" }, \
 397         { name" Source", "SDW1RX1", "SDW1 Playback" }, \
 398         { name" Source", "SDW1RX2", "SDW1 Playback" },
 399
 400 static const struct snd_soc_dapm_route cs35l56_audio_map[] = {
 401         { "AMP", NULL, "VDD_B" },
 402         { "AMP", NULL, "VDD_AMP" },
 403
 404         { "ASP1 Playback", NULL, "ASP1 CFG" },
 405         { "ASP1 Capture", NULL, "ASP1 CFG" },
 406
 407         { "ASP1 Playback", NULL, "PLAY" },
 408         { "SDW1 Playback", NULL, "PLAY" },
 409
 410         { "ASP1RX1", NULL, "ASP1 Playback" },
 411         { "ASP1RX2", NULL, "ASP1 Playback" },
 412         { "DSP1", NULL, "ASP1RX1" },
 413         { "DSP1", NULL, "ASP1RX2" },
 414         { "DSP1", NULL, "SDW1 Playback" },
 415         { "AMP", NULL, "DSP1" },
 416         { "SPK", NULL, "AMP" },
 417
 418         CS35L56_SRC_ROUTE("ASP1 TX1")
 419         CS35L56_SRC_ROUTE("ASP1 TX2")
 420         CS35L56_SRC_ROUTE("ASP1 TX3")
 421         CS35L56_SRC_ROUTE("ASP1 TX4")
 422
 423         { "ASP1TX1", NULL, "ASP1 TX1 Source" },
 424         { "ASP1TX2", NULL, "ASP1 TX2 Source" },
 425         { "ASP1TX3", NULL, "ASP1 TX3 Source" },
 426         { "ASP1TX4", NULL, "ASP1 TX4 Source" },
 427         { "ASP1 Capture", NULL, "ASP1TX1" },
 428         { "ASP1 Capture", NULL, "ASP1TX2" },
 429         { "ASP1 Capture", NULL, "ASP1TX3" },
 430         { "ASP1 Capture", NULL, "ASP1TX4" },
 431
 432         CS35L56_SRC_ROUTE("SDW1 TX1")
 433         CS35L56_SRC_ROUTE("SDW1 TX2")
 434         CS35L56_SRC_ROUTE("SDW1 TX3")
 435         CS35L56_SRC_ROUTE("SDW1 TX4")
 436         { "SDW1 Capture", NULL, "SDW1 TX1 Source" },
 437         { "SDW1 Capture", NULL, "SDW1 TX2 Source" },
 438         { "SDW1 Capture", NULL, "SDW1 TX3 Source" },
 439         { "SDW1 Capture", NULL, "SDW1 TX4 Source" },
 440 };
 441
 442 static int cs35l56_dsp_event(struct snd_soc_dapm_widget *w,
 443                              struct snd_kcontrol *kcontrol, int event)
 444 {
 445         struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 446         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
 447
 448         dev_dbg(cs35l56->base.dev, "%s: %d\n", __func__, event);
 449
 450         return wm_adsp_event(w, kcontrol, event);
 451 }
 452
 453 static int cs35l56_asp_dai_set_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
 454 {
 455         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(codec_dai->component);
 456         unsigned int val;
 457         int ret;
 458
 459         dev_dbg(cs35l56->base.dev, "%s: %#x\n", __func__, fmt);
 460
 461         ret = cs35l56_init_asp1_regs_for_driver_control(&cs35l56->base);
 462         if (ret)
 463                 return ret;
 464
 465         switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
 466         case SND_SOC_DAIFMT_CBC_CFC:
 467                 break;
 468         default:
 469                 dev_err(cs35l56->base.dev, "Unsupported clock source mode\n");
 470                 return -EINVAL;
 471         }
 472
 473         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 474         case SND_SOC_DAIFMT_DSP_A:
 475                 val = CS35L56_ASP_FMT_DSP_A << CS35L56_ASP_FMT_SHIFT;
 476                 cs35l56->tdm_mode = true;
 477                 break;
 478         case SND_SOC_DAIFMT_I2S:
 479                 val = CS35L56_ASP_FMT_I2S << CS35L56_ASP_FMT_SHIFT;
 480                 cs35l56->tdm_mode = false;
 481                 break;
 482         default:
 483                 dev_err(cs35l56->base.dev, "Unsupported DAI format\n");
 484                 return -EINVAL;
 485         }
 486
 487         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 488         case SND_SOC_DAIFMT_NB_IF:
 489                 val |= CS35L56_ASP_FSYNC_INV_MASK;
 490                 break;
 491         case SND_SOC_DAIFMT_IB_NF:
 492                 val |= CS35L56_ASP_BCLK_INV_MASK;
 493                 break;
 494         case SND_SOC_DAIFMT_IB_IF:
 495                 val |= CS35L56_ASP_BCLK_INV_MASK | CS35L56_ASP_FSYNC_INV_MASK;
 496                 break;
 497         case SND_SOC_DAIFMT_NB_NF:
 498                 break;
 499         default:
 500                 dev_err(cs35l56->base.dev, "Invalid clock invert\n");
 501                 return -EINVAL;
 502         }
 503
 504         regmap_update_bits(cs35l56->base.regmap,
 505                            CS35L56_ASP1_CONTROL2,
 506                            CS35L56_ASP_FMT_MASK |
 507                            CS35L56_ASP_BCLK_INV_MASK | CS35L56_ASP_FSYNC_INV_MASK,
 508                            val);
 509
 510         /* Hi-Z DOUT in unused slots and when all TX are disabled */
 511         regmap_update_bits(cs35l56->base.regmap, CS35L56_ASP1_CONTROL3,
 512                            CS35L56_ASP1_DOUT_HIZ_CTRL_MASK,
 513                            CS35L56_ASP_UNUSED_HIZ_OFF_HIZ);
 514
 515         return 0;
 516 }
 517
 518 static unsigned int cs35l56_make_tdm_config_word(unsigned int reg_val, unsigned long mask)
 519 {
 520         unsigned int channel_shift;
 521         int bit_num;
 522
 523         /* Enable consecutive TX1..TXn for each of the slots set in mask */
 524         channel_shift = 0;
 525         for_each_set_bit(bit_num, &mask, 32) {
 526                 reg_val &= ~(0x3f << channel_shift);
 527                 reg_val |= bit_num << channel_shift;
 528                 channel_shift += 8;
 529         }
 530
 531         return reg_val;
 532 }
 533
 534 static int cs35l56_asp_dai_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
 535                                         unsigned int rx_mask, int slots, int slot_width)
 536 {
 537         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(dai->component);
 538         int ret;
 539
 540         ret = cs35l56_init_asp1_regs_for_driver_control(&cs35l56->base);
 541         if (ret)
 542                 return ret;
 543
 544         if ((slots == 0) || (slot_width == 0)) {
 545                 dev_dbg(cs35l56->base.dev, "tdm config cleared\n");
 546                 cs35l56->asp_slot_width = 0;
 547                 cs35l56->asp_slot_count = 0;
 548                 return 0;
 549         }
 550
 551         if (slot_width > (CS35L56_ASP_RX_WIDTH_MASK >> CS35L56_ASP_RX_WIDTH_SHIFT)) {
 552                 dev_err(cs35l56->base.dev, "tdm invalid slot width %d\n", slot_width);
 553                 return -EINVAL;
 554         }
 555
 556         /* More than 32 slots would give an unsupportable BCLK frequency */
 557         if (slots > 32) {
 558                 dev_err(cs35l56->base.dev, "tdm invalid slot count %d\n", slots);
 559                 return -EINVAL;
 560         }
 561
 562         cs35l56->asp_slot_width = (u8)slot_width;
 563         cs35l56->asp_slot_count = (u8)slots;
 564
 565         // Note: rx/tx is from point of view of the CPU end
 566         if (tx_mask == 0)
 567                 tx_mask = 0x3;  // ASPRX1/RX2 in slots 0 and 1
 568
 569         if (rx_mask == 0)
 570                 rx_mask = 0xf;  // ASPTX1..TX4 in slots 0..3
 571
 572         /* Default unused slots to 63 */
 573         regmap_write(cs35l56->base.regmap, CS35L56_ASP1_FRAME_CONTROL1,
 574                      cs35l56_make_tdm_config_word(0x3f3f3f3f, rx_mask));
 575         regmap_write(cs35l56->base.regmap, CS35L56_ASP1_FRAME_CONTROL5,
 576                      cs35l56_make_tdm_config_word(0x3f3f3f, tx_mask));
 577
 578         dev_dbg(cs35l56->base.dev, "tdm slot width: %u count: %u tx_mask: %#x rx_mask: %#x\n",
 579                 cs35l56->asp_slot_width, cs35l56->asp_slot_count, tx_mask, rx_mask);
 580
 581         return 0;
 582 }
 583
 584 static int cs35l56_asp_dai_hw_params(struct snd_pcm_substream *substream,
 585                                      struct snd_pcm_hw_params *params,
 586                                      struct snd_soc_dai *dai)
 587 {
 588         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(dai->component);
 589         unsigned int rate = params_rate(params);
 590         u8 asp_width, asp_wl;
 591         int ret;
 592
 593         ret = cs35l56_init_asp1_regs_for_driver_control(&cs35l56->base);
 594         if (ret)
 595                 return ret;
 596
 597         asp_wl = params_width(params);
 598         if (cs35l56->asp_slot_width)
 599                 asp_width = cs35l56->asp_slot_width;
 600         else
 601                 asp_width = asp_wl;
 602
 603         dev_dbg(cs35l56->base.dev, "%s: wl=%d, width=%d, rate=%d",
 604                 __func__, asp_wl, asp_width, rate);
 605
 606         if (!cs35l56->sysclk_set) {
 607                 unsigned int slots = cs35l56->asp_slot_count;
 608                 unsigned int bclk_freq;
 609                 int freq_id;
 610
 611                 if (slots == 0) {
 612                         slots = params_channels(params);
 613
 614                         /* I2S always has an even number of slots */
 615                         if (!cs35l56->tdm_mode)
 616                                 slots = round_up(slots, 2);
 617                 }
 618
 619                 bclk_freq = asp_width * slots * rate;
 620                 freq_id = cs35l56_get_bclk_freq_id(bclk_freq);
 621                 if (freq_id < 0) {
 622                         dev_err(cs35l56->base.dev, "%s: Invalid BCLK %u\n", __func__, bclk_freq);
 623                         return -EINVAL;
 624                 }
 625
 626                 regmap_update_bits(cs35l56->base.regmap, CS35L56_ASP1_CONTROL1,
 627                                    CS35L56_ASP_BCLK_FREQ_MASK,
 628                                    freq_id << CS35L56_ASP_BCLK_FREQ_SHIFT);
 629         }
 630
 631         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 632                 regmap_update_bits(cs35l56->base.regmap, CS35L56_ASP1_CONTROL2,
 633                                    CS35L56_ASP_RX_WIDTH_MASK, asp_width <<
 634                                    CS35L56_ASP_RX_WIDTH_SHIFT);
 635                 regmap_update_bits(cs35l56->base.regmap, CS35L56_ASP1_DATA_CONTROL5,
 636                                    CS35L56_ASP_RX_WL_MASK, asp_wl);
 637         } else {
 638                 regmap_update_bits(cs35l56->base.regmap, CS35L56_ASP1_CONTROL2,
 639                                    CS35L56_ASP_TX_WIDTH_MASK, asp_width <<
 640                                    CS35L56_ASP_TX_WIDTH_SHIFT);
 641                 regmap_update_bits(cs35l56->base.regmap, CS35L56_ASP1_DATA_CONTROL1,
 642                                    CS35L56_ASP_TX_WL_MASK, asp_wl);
 643         }
 644
 645         return 0;
 646 }
 647
 648 static int cs35l56_asp_dai_set_sysclk(struct snd_soc_dai *dai,
 649                                       int clk_id, unsigned int freq, int dir)
 650 {
 651         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(dai->component);
 652         int freq_id, ret;
 653
 654         ret = cs35l56_init_asp1_regs_for_driver_control(&cs35l56->base);
 655         if (ret)
 656                 return ret;
 657
 658         if (freq == 0) {
 659                 cs35l56->sysclk_set = false;
 660                 return 0;
 661         }
 662
 663         freq_id = cs35l56_get_bclk_freq_id(freq);
 664         if (freq_id < 0)
 665                 return freq_id;
 666
 667         regmap_update_bits(cs35l56->base.regmap, CS35L56_ASP1_CONTROL1,
 668                            CS35L56_ASP_BCLK_FREQ_MASK,
 669                            freq_id << CS35L56_ASP_BCLK_FREQ_SHIFT);
 670         cs35l56->sysclk_set = true;
 671
 672         return 0;
 673 }
 674
 675 static const struct snd_soc_dai_ops cs35l56_ops = {
 676         .set_fmt = cs35l56_asp_dai_set_fmt,
 677         .set_tdm_slot = cs35l56_asp_dai_set_tdm_slot,
 678         .hw_params = cs35l56_asp_dai_hw_params,
 679         .set_sysclk = cs35l56_asp_dai_set_sysclk,
 680 };
 681
 682 static void cs35l56_sdw_dai_shutdown(struct snd_pcm_substream *substream,
 683                                      struct snd_soc_dai *dai)
 684 {
 685         snd_soc_dai_set_dma_data(dai, substream, NULL);
 686 }
 687
 688 static int cs35l56_sdw_dai_set_tdm_slot(struct snd_soc_dai *dai, unsigned int tx_mask,
 689                                         unsigned int rx_mask, int slots, int slot_width)
 690 {
 691         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(dai->component);
 692
 693         /* rx/tx are from point of view of the CPU end so opposite to our rx/tx */
 694         cs35l56->rx_mask = tx_mask;
 695         cs35l56->tx_mask = rx_mask;
 696
 697         return 0;
 698 }
 699
 700 static int cs35l56_sdw_dai_hw_params(struct snd_pcm_substream *substream,
 701                                      struct snd_pcm_hw_params *params,
 702                                      struct snd_soc_dai *dai)
 703 {
 704         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(dai->component);
 705         struct sdw_stream_runtime *sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
 706         struct sdw_stream_config sconfig;
 707         struct sdw_port_config pconfig;
 708         int ret;
 709
 710         dev_dbg(cs35l56->base.dev, "%s: rate %d\n", __func__, params_rate(params));
 711
 712         if (!cs35l56->base.init_done)
 713                 return -ENODEV;
 714
 715         if (!sdw_stream)
 716                 return -EINVAL;
 717
 718         memset(&sconfig, 0, sizeof(sconfig));
 719         memset(&pconfig, 0, sizeof(pconfig));
 720
 721         sconfig.frame_rate = params_rate(params);
 722         sconfig.bps = snd_pcm_format_width(params_format(params));
 723
 724         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 725                 sconfig.direction = SDW_DATA_DIR_RX;
 726                 pconfig.num = CS35L56_SDW1_PLAYBACK_PORT;
 727                 pconfig.ch_mask = cs35l56->rx_mask;
 728         } else {
 729                 sconfig.direction = SDW_DATA_DIR_TX;
 730                 pconfig.num = CS35L56_SDW1_CAPTURE_PORT;
 731                 pconfig.ch_mask = cs35l56->tx_mask;
 732         }
 733
 734         if (pconfig.ch_mask == 0) {
 735                 sconfig.ch_count = params_channels(params);
 736                 pconfig.ch_mask = GENMASK(sconfig.ch_count - 1, 0);
 737         } else {
 738                 sconfig.ch_count = hweight32(pconfig.ch_mask);
 739         }
 740
 741         ret = sdw_stream_add_slave(cs35l56->sdw_peripheral, &sconfig, &pconfig,
 742                                    1, sdw_stream);
 743         if (ret) {
 744                 dev_err(dai->dev, "Failed to add sdw stream: %d\n", ret);
 745                 return ret;
 746         }
 747
 748         return 0;
 749 }
 750
 751 static int cs35l56_sdw_dai_hw_free(struct snd_pcm_substream *substream,
 752                                    struct snd_soc_dai *dai)
 753 {
 754         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(dai->component);
 755         struct sdw_stream_runtime *sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
 756
 757         if (!cs35l56->sdw_peripheral)
 758                 return -EINVAL;
 759
 760         sdw_stream_remove_slave(cs35l56->sdw_peripheral, sdw_stream);
 761
 762         return 0;
 763 }
 764
 765 static int cs35l56_sdw_dai_set_stream(struct snd_soc_dai *dai,
 766                                       void *sdw_stream, int direction)
 767 {
 768         snd_soc_dai_dma_data_set(dai, direction, sdw_stream);
 769
 770         return 0;
 771 }
 772
 773 static const struct snd_soc_dai_ops cs35l56_sdw_dai_ops = {
 774         .set_tdm_slot = cs35l56_sdw_dai_set_tdm_slot,
 775         .shutdown = cs35l56_sdw_dai_shutdown,
 776         .hw_params = cs35l56_sdw_dai_hw_params,
 777         .hw_free = cs35l56_sdw_dai_hw_free,
 778         .set_stream = cs35l56_sdw_dai_set_stream,
 779 };
 780
 781 static struct snd_soc_dai_driver cs35l56_dai[] = {
 782         {
 783                 .name = "cs35l56-asp1",
 784                 .id = 0,
 785                 .playback = {
 786                         .stream_name = "ASP1 Playback",
 787                         .channels_min = 1,
 788                         .channels_max = 2,
 789                         .rates = CS35L56_RATES,
 790                         .formats = CS35L56_RX_FORMATS,
 791                 },
 792                 .capture = {
 793                         .stream_name = "ASP1 Capture",
 794                         .channels_min = 1,
 795                         .channels_max = 4,
 796                         .rates = CS35L56_RATES,
 797                         .formats = CS35L56_TX_FORMATS,
 798                 },
 799                 .ops = &cs35l56_ops,
 800                 .symmetric_rate = 1,
 801                 .symmetric_sample_bits = 1,
 802         },
 803         {
 804                 .name = "cs35l56-sdw1",
 805                 .id = 1,
 806                 .playback = {
 807                         .stream_name = "SDW1 Playback",
 808                         .channels_min = 1,
 809                         .channels_max = 2,
 810                         .rates = CS35L56_RATES,
 811                         .formats = CS35L56_RX_FORMATS,
 812                 },
 813                 .capture = {
 814                         .stream_name = "SDW1 Capture",
 815                         .channels_min = 1,
 816                         .channels_max = 4,
 817                         .rates = CS35L56_RATES,
 818                         .formats = CS35L56_TX_FORMATS,
 819                 },
 820                 .symmetric_rate = 1,
 821                 .ops = &cs35l56_sdw_dai_ops,
 822         }
 823 };
 824
 825 static int cs35l56_write_cal(struct cs35l56_private *cs35l56)
 826 {
 827         int ret;
 828
 829         if (cs35l56->base.secured || !cs35l56->base.cal_data_valid)
 830                 return -ENODATA;
 831
 832         ret = wm_adsp_run(&cs35l56->dsp);
 833         if (ret)
 834                 return ret;
 835
 836         ret = cs_amp_write_cal_coeffs(&cs35l56->dsp.cs_dsp,
 837                                       &cs35l56_calibration_controls,
 838                                       &cs35l56->base.cal_data);
 839
 840         wm_adsp_stop(&cs35l56->dsp);
 841
 842         if (ret == 0)
 843                 dev_info(cs35l56->base.dev, "Calibration applied\n");
 844
 845         return ret;
 846 }
 847
 848 static void cs35l56_reinit_patch(struct cs35l56_private *cs35l56)
 849 {
 850         int ret;
 851
 852         /* Use wm_adsp to load and apply the firmware patch and coefficient files */
 853         ret = wm_adsp_power_up(&cs35l56->dsp, true);
 854         if (ret) {
 855                 dev_dbg(cs35l56->base.dev, "%s: wm_adsp_power_up ret %d\n", __func__, ret);
 856                 return;
 857         }
 858
 859         cs35l56_write_cal(cs35l56);
 860
 861         /* Always REINIT after applying patch or coefficients */
 862         cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_REINIT);
 863 }
 864
 865 static void cs35l56_patch(struct cs35l56_private *cs35l56, bool firmware_missing)
 866 {
 867         int ret;
 868
 869         /*
 870          * Disable SoundWire interrupts to prevent race with IRQ work.
 871          * Setting sdw_irq_no_unmask prevents the handler re-enabling
 872          * the SoundWire interrupt.
 873          */
 874         if (cs35l56->sdw_peripheral) {
 875                 cs35l56->sdw_irq_no_unmask = true;
 876                 flush_work(&cs35l56->sdw_irq_work);
 877                 sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1, 0);
 878                 sdw_read_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_STAT_1);
 879                 sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_STAT_1, 0xFF);
 880                 flush_work(&cs35l56->sdw_irq_work);
 881         }
 882
 883         ret = cs35l56_firmware_shutdown(&cs35l56->base);
 884         if (ret)
 885                 goto err;
 886
 887         /*
 888          * Use wm_adsp to load and apply the firmware patch and coefficient files,
 889          * but only if firmware is missing. If firmware is already patched just
 890          * power-up wm_adsp without downloading firmware.
 891          */
 892         ret = wm_adsp_power_up(&cs35l56->dsp, !!firmware_missing);
 893         if (ret) {
 894                 dev_dbg(cs35l56->base.dev, "%s: wm_adsp_power_up ret %d\n", __func__, ret);
 895                 goto err;
 896         }
 897
 898         mutex_lock(&cs35l56->base.irq_lock);
 899
 900         reinit_completion(&cs35l56->init_completion);
 901
 902         cs35l56->soft_resetting = true;
 903         cs35l56_system_reset(&cs35l56->base, !!cs35l56->sdw_peripheral);
 904
 905         if (cs35l56->sdw_peripheral) {
 906                 /*
 907                  * The system-reset causes the CS35L56 to detach from the bus.
 908                  * Wait for the manager to re-enumerate the CS35L56 and
 909                  * cs35l56_init() to run again.
 910                  */
 911                 if (!wait_for_completion_timeout(&cs35l56->init_completion,
 912                                                  msecs_to_jiffies(5000))) {
 913                         dev_err(cs35l56->base.dev, "%s: init_completion timed out (SDW)\n",
 914                                 __func__);
 915                         goto err_unlock;
 916                 }
 917         } else if (cs35l56_init(cs35l56)) {
 918                 goto err_unlock;
 919         }
 920
 921         regmap_clear_bits(cs35l56->base.regmap, CS35L56_PROTECTION_STATUS,
 922                           CS35L56_FIRMWARE_MISSING);
 923         cs35l56->base.fw_patched = true;
 924
 925         if (cs35l56_write_cal(cs35l56) == 0)
 926                 cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_REINIT);
 927
 928 err_unlock:
 929         mutex_unlock(&cs35l56->base.irq_lock);
 930 err:
 931         /* Re-enable SoundWire interrupts */
 932         if (cs35l56->sdw_peripheral) {
 933                 cs35l56->sdw_irq_no_unmask = false;
 934                 sdw_write_no_pm(cs35l56->sdw_peripheral, CS35L56_SDW_GEN_INT_MASK_1,
 935                                 CS35L56_SDW_INT_MASK_CODEC_IRQ);
 936         }
 937 }
 938
 939 static void cs35l56_dsp_work(struct work_struct *work)
 940 {
 941         struct cs35l56_private *cs35l56 = container_of(work,
 942                                                        struct cs35l56_private,
 943                                                        dsp_work);
 944         unsigned int firmware_version;
 945         bool firmware_missing;
 946         int ret;
 947
 948         if (!cs35l56->base.init_done)
 949                 return;
 950
 951         pm_runtime_get_sync(cs35l56->base.dev);
 952
 953         ret = cs35l56_read_prot_status(&cs35l56->base, &firmware_missing, &firmware_version);
 954         if (ret)
 955                 goto err;
 956
 957         /* Populate fw file qualifier with the revision and security state */
 958         kfree(cs35l56->dsp.fwf_name);
 959         if (firmware_missing) {
 960                 cs35l56->dsp.fwf_name = kasprintf(GFP_KERNEL, "%02x-dsp1", cs35l56->base.rev);
 961         } else {
 962                 /* Firmware files must match the running firmware version */
 963                 cs35l56->dsp.fwf_name = kasprintf(GFP_KERNEL,
 964                                                   "%02x%s-%06x-dsp1",
 965                                                   cs35l56->base.rev,
 966                                                   cs35l56->base.secured ? "-s" : "",
 967                                                   firmware_version);
 968         }
 969
 970         if (!cs35l56->dsp.fwf_name)
 971                 goto err;
 972
 973         dev_dbg(cs35l56->base.dev, "DSP fwf name: '%s' system name: '%s'\n",
 974                 cs35l56->dsp.fwf_name, cs35l56->dsp.system_name);
 975
 976         /*
 977          * The firmware cannot be patched if it is already running from
 978          * patch RAM. In this case the firmware files are versioned to
 979          * match the running firmware version and will only contain
 980          * tunings. We do not need to shutdown the firmware to apply
 981          * tunings so can use the lower cost reinit sequence instead.
 982          */
 983         if (!firmware_missing)
 984                 cs35l56_reinit_patch(cs35l56);
 985         else
 986                 cs35l56_patch(cs35l56, firmware_missing);
 987
 988 err:
 989         pm_runtime_mark_last_busy(cs35l56->base.dev);
 990         pm_runtime_put_autosuspend(cs35l56->base.dev);
 991 }
 992
 993 static int cs35l56_component_probe(struct snd_soc_component *component)
 994 {
 995         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
 996         struct dentry *debugfs_root = component->debugfs_root;
 997         unsigned short vendor, device;
 998
 999         BUILD_BUG_ON(ARRAY_SIZE(cs35l56_tx_input_texts) != ARRAY_SIZE(cs35l56_tx_input_values));
1000
1001         if (!cs35l56->dsp.system_name &&
1002             (snd_soc_card_get_pci_ssid(component->card, &vendor, &device) == 0)) {
1003                 /* Append a speaker qualifier if there is a speaker ID */
1004                 if (cs35l56->speaker_id >= 0) {
1005                         cs35l56->dsp.system_name = devm_kasprintf(cs35l56->base.dev,
1006                                                                   GFP_KERNEL,
1007                                                                   "%04x%04x-spkid%d",
1008                                                                   vendor, device,
1009                                                                   cs35l56->speaker_id);
1010                 } else {
1011                         cs35l56->dsp.system_name = devm_kasprintf(cs35l56->base.dev,
1012                                                                   GFP_KERNEL,
1013                                                                   "%04x%04x",
1014                                                                   vendor, device);
1015                 }
1016                 if (!cs35l56->dsp.system_name)
1017                         return -ENOMEM;
1018         }
1019
1020         if (!wait_for_completion_timeout(&cs35l56->init_completion,
1021                                          msecs_to_jiffies(5000))) {
1022                 dev_err(cs35l56->base.dev, "%s: init_completion timed out\n", __func__);
1023                 return -ENODEV;
1024         }
1025
1026         cs35l56->dsp.part = kasprintf(GFP_KERNEL, "cs35l%02x", cs35l56->base.type);
1027         if (!cs35l56->dsp.part)
1028                 return -ENOMEM;
1029
1030         cs35l56->component = component;
1031         wm_adsp2_component_probe(&cs35l56->dsp, component);
1032
1033         debugfs_create_bool("init_done", 0444, debugfs_root, &cs35l56->base.init_done);
1034         debugfs_create_bool("can_hibernate", 0444, debugfs_root, &cs35l56->base.can_hibernate);
1035         debugfs_create_bool("fw_patched", 0444, debugfs_root, &cs35l56->base.fw_patched);
1036
1037         /*
1038          * The widgets for the ASP1TX mixer can't be initialized
1039          * until the firmware has been downloaded and rebooted.
1040          */
1041         regcache_drop_region(cs35l56->base.regmap, CS35L56_ASP1TX1_INPUT, CS35L56_ASP1TX4_INPUT);
1042         cs35l56->asp1_mixer_widgets_initialized = false;
1043
1044         queue_work(cs35l56->dsp_wq, &cs35l56->dsp_work);
1045
1046         return 0;
1047 }
1048
1049 static void cs35l56_component_remove(struct snd_soc_component *component)
1050 {
1051         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
1052
1053         cancel_work_sync(&cs35l56->dsp_work);
1054
1055         if (cs35l56->dsp.cs_dsp.booted)
1056                 wm_adsp_power_down(&cs35l56->dsp);
1057
1058         wm_adsp2_component_remove(&cs35l56->dsp, component);
1059
1060         kfree(cs35l56->dsp.part);
1061         cs35l56->dsp.part = NULL;
1062
1063         kfree(cs35l56->dsp.fwf_name);
1064         cs35l56->dsp.fwf_name = NULL;
1065
1066         cs35l56->component = NULL;
1067 }
1068
1069 static int cs35l56_set_bias_level(struct snd_soc_component *component,
1070                                   enum snd_soc_bias_level level)
1071 {
1072         struct cs35l56_private *cs35l56 = snd_soc_component_get_drvdata(component);
1073
1074         switch (level) {
1075         case SND_SOC_BIAS_STANDBY:
1076                 /*
1077                  * Wait for patching to complete when transitioning from
1078                  * BIAS_OFF to BIAS_STANDBY
1079                  */
1080                 if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF)
1081                         cs35l56_wait_dsp_ready(cs35l56);
1082
1083                 break;
1084         default:
1085                 break;
1086         }
1087
1088         return 0;
1089 }
1090
1091 static const struct snd_soc_component_driver soc_component_dev_cs35l56 = {
1092         .probe = cs35l56_component_probe,
1093         .remove = cs35l56_component_remove,
1094
1095         .dapm_widgets = cs35l56_dapm_widgets,
1096         .num_dapm_widgets = ARRAY_SIZE(cs35l56_dapm_widgets),
1097         .dapm_routes = cs35l56_audio_map,
1098         .num_dapm_routes = ARRAY_SIZE(cs35l56_audio_map),
1099         .controls = cs35l56_controls,
1100         .num_controls = ARRAY_SIZE(cs35l56_controls),
1101
1102         .set_bias_level = cs35l56_set_bias_level,
1103
1104         .suspend_bias_off = 1, /* see cs35l56_system_resume() */
1105 };
1106
1107 static int __maybe_unused cs35l56_runtime_suspend_i2c_spi(struct device *dev)
1108 {
1109         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
1110
1111         return cs35l56_runtime_suspend_common(&cs35l56->base);
1112 }
1113
1114 static int __maybe_unused cs35l56_runtime_resume_i2c_spi(struct device *dev)
1115 {
1116         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
1117
1118         return cs35l56_runtime_resume_common(&cs35l56->base, false);
1119 }
1120
1121 int cs35l56_system_suspend(struct device *dev)
1122 {
1123         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
1124
1125         dev_dbg(dev, "system_suspend\n");
1126
1127         if (cs35l56->component)
1128                 flush_work(&cs35l56->dsp_work);
1129
1130         /*
1131          * The interrupt line is normally shared, but after we start suspending
1132          * we can't check if our device is the source of an interrupt, and can't
1133          * clear it. Prevent this race by temporarily disabling the parent irq
1134          * until we reach _no_irq.
1135          */
1136         if (cs35l56->base.irq)
1137                 disable_irq(cs35l56->base.irq);
1138
1139         return pm_runtime_force_suspend(dev);
1140 }
1141 EXPORT_SYMBOL_GPL(cs35l56_system_suspend);
1142
1143 int cs35l56_system_suspend_late(struct device *dev)
1144 {
1145         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
1146
1147         dev_dbg(dev, "system_suspend_late\n");
1148
1149         /*
1150          * Assert RESET before removing supplies.
1151          * RESET is usually shared by all amps so it must not be asserted until
1152          * all driver instances have done their suspend() stage.
1153          */
1154         if (cs35l56->base.reset_gpio) {
1155                 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1156                 cs35l56_wait_min_reset_pulse();
1157         }
1158
1159         regulator_bulk_disable(ARRAY_SIZE(cs35l56->supplies), cs35l56->supplies);
1160
1161         return 0;
1162 }
1163 EXPORT_SYMBOL_GPL(cs35l56_system_suspend_late);
1164
1165 int cs35l56_system_suspend_no_irq(struct device *dev)
1166 {
1167         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
1168
1169         dev_dbg(dev, "system_suspend_no_irq\n");
1170
1171         /* Handlers are now disabled so the parent IRQ can safely be re-enabled. */
1172         if (cs35l56->base.irq)
1173                 enable_irq(cs35l56->base.irq);
1174
1175         return 0;
1176 }
1177 EXPORT_SYMBOL_GPL(cs35l56_system_suspend_no_irq);
1178
1179 int cs35l56_system_resume_no_irq(struct device *dev)
1180 {
1181         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
1182
1183         dev_dbg(dev, "system_resume_no_irq\n");
1184
1185         /*
1186          * WAKE interrupts unmask if the CS35L56 hibernates, which can cause
1187          * spurious interrupts, and the interrupt line is normally shared.
1188          * We can't check if our device is the source of an interrupt, and can't
1189          * clear it, until it has fully resumed. Prevent this race by temporarily
1190          * disabling the parent irq until we complete resume().
1191          */
1192         if (cs35l56->base.irq)
1193                 disable_irq(cs35l56->base.irq);
1194
1195         return 0;
1196 }
1197 EXPORT_SYMBOL_GPL(cs35l56_system_resume_no_irq);
1198
1199 int cs35l56_system_resume_early(struct device *dev)
1200 {
1201         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
1202         int ret;
1203
1204         dev_dbg(dev, "system_resume_early\n");
1205
1206         /* Ensure a spec-compliant RESET pulse. */
1207         if (cs35l56->base.reset_gpio) {
1208                 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1209                 cs35l56_wait_min_reset_pulse();
1210         }
1211
1212         /* Enable supplies before releasing RESET. */
1213         ret = regulator_bulk_enable(ARRAY_SIZE(cs35l56->supplies), cs35l56->supplies);
1214         if (ret) {
1215                 dev_err(dev, "system_resume_early failed to enable supplies: %d\n", ret);
1216                 return ret;
1217         }
1218
1219         /* Release shared RESET before drivers start resume(). */
1220         gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
1221
1222         return 0;
1223 }
1224 EXPORT_SYMBOL_GPL(cs35l56_system_resume_early);
1225
1226 int cs35l56_system_resume(struct device *dev)
1227 {
1228         struct cs35l56_private *cs35l56 = dev_get_drvdata(dev);
1229         int ret;
1230
1231         dev_dbg(dev, "system_resume\n");
1232
1233         /*
1234          * We might have done a hard reset or the CS35L56 was power-cycled
1235          * so wait for control port to be ready.
1236          */
1237         cs35l56_wait_control_port_ready();
1238
1239         /* Undo pm_runtime_force_suspend() before re-enabling the irq */
1240         ret = pm_runtime_force_resume(dev);
1241         if (cs35l56->base.irq)
1242                 enable_irq(cs35l56->base.irq);
1243
1244         if (ret)
1245                 return ret;
1246
1247         /* Firmware won't have been loaded if the component hasn't probed */
1248         if (!cs35l56->component)
1249                 return 0;
1250
1251         ret = cs35l56_is_fw_reload_needed(&cs35l56->base);
1252         dev_dbg(cs35l56->base.dev, "fw_reload_needed: %d\n", ret);
1253         if (ret < 1)
1254                 return ret;
1255
1256         cs35l56->base.fw_patched = false;
1257         wm_adsp_power_down(&cs35l56->dsp);
1258         queue_work(cs35l56->dsp_wq, &cs35l56->dsp_work);
1259
1260         /*
1261          * suspend_bias_off ensures we are now in BIAS_OFF so there will be
1262          * a BIAS_OFF->BIAS_STANDBY transition to complete dsp patching.
1263          */
1264
1265         return 0;
1266 }
1267 EXPORT_SYMBOL_GPL(cs35l56_system_resume);
1268
1269 static int cs35l56_dsp_init(struct cs35l56_private *cs35l56)
1270 {
1271         struct wm_adsp *dsp;
1272         int ret;
1273
1274         cs35l56->dsp_wq = create_singlethread_workqueue("cs35l56-dsp");
1275         if (!cs35l56->dsp_wq)
1276                 return -ENOMEM;
1277
1278         INIT_WORK(&cs35l56->dsp_work, cs35l56_dsp_work);
1279
1280         dsp = &cs35l56->dsp;
1281         cs35l56_init_cs_dsp(&cs35l56->base, &dsp->cs_dsp);
1282
1283         /*
1284          * dsp->part is filled in later as it is based on the DEVID. In a
1285          * SoundWire system that cannot be read until enumeration has occurred
1286          * and the device has attached.
1287          */
1288         dsp->fw = 12;
1289         dsp->wmfw_optional = true;
1290
1291         dev_dbg(cs35l56->base.dev, "DSP system name: '%s'\n", dsp->system_name);
1292
1293         ret = wm_halo_init(dsp);
1294         if (ret != 0) {
1295                 dev_err(cs35l56->base.dev, "wm_halo_init failed\n");
1296                 return ret;
1297         }
1298
1299         return 0;
1300 }
1301
1302 static int cs35l56_get_firmware_uid(struct cs35l56_private *cs35l56)
1303 {
1304         struct device *dev = cs35l56->base.dev;
1305         const char *prop;
1306         int ret;
1307
1308         ret = device_property_read_string(dev, "cirrus,firmware-uid", &prop);
1309         /* If bad sw node property, return 0 and fallback to legacy firmware path */
1310         if (ret < 0)
1311                 return 0;
1312
1313         /* Append a speaker qualifier if there is a speaker ID */
1314         if (cs35l56->speaker_id >= 0)
1315                 cs35l56->dsp.system_name = devm_kasprintf(dev, GFP_KERNEL, "%s-spkid%d",
1316                                                           prop, cs35l56->speaker_id);
1317         else
1318                 cs35l56->dsp.system_name = devm_kstrdup(dev, prop, GFP_KERNEL);
1319
1320         if (cs35l56->dsp.system_name == NULL)
1321                 return -ENOMEM;
1322
1323         dev_dbg(dev, "Firmware UID: %s\n", cs35l56->dsp.system_name);
1324
1325         return 0;
1326 }
1327
1328 /*
1329  * Some SoundWire laptops have a spk-id-gpios property but it points to
1330  * the wrong ACPI Device node so can't be used to get the GPIO. Try to
1331  * find the SDCA node containing the GpioIo resource and add a GPIO
1332  * mapping to it.
1333  */
1334 static const struct acpi_gpio_params cs35l56_af01_first_gpio = { 0, 0, false };
1335 static const struct acpi_gpio_mapping cs35l56_af01_spkid_gpios_mapping[] = {
1336         { "spk-id-gpios", &cs35l56_af01_first_gpio, 1 },
1337         { }
1338 };
1339
1340 static void cs35l56_acpi_dev_release_driver_gpios(void *adev)
1341 {
1342         acpi_dev_remove_driver_gpios(adev);
1343 }
1344
1345 static int cs35l56_try_get_broken_sdca_spkid_gpio(struct cs35l56_private *cs35l56)
1346 {
1347         struct fwnode_handle *af01_fwnode;
1348         const union acpi_object *obj;
1349         struct gpio_desc *desc;
1350         int ret;
1351
1352         /* Find the SDCA node containing the GpioIo */
1353         af01_fwnode = device_get_named_child_node(cs35l56->base.dev, "AF01");
1354         if (!af01_fwnode) {
1355                 dev_dbg(cs35l56->base.dev, "No AF01 node\n");
1356                 return -ENOENT;
1357         }
1358
1359         ret = acpi_dev_get_property(ACPI_COMPANION(cs35l56->base.dev),
1360                                     "spk-id-gpios", ACPI_TYPE_PACKAGE, &obj);
1361         if (ret) {
1362                 dev_dbg(cs35l56->base.dev, "Could not get spk-id-gpios package: %d\n", ret);
1363                 fwnode_handle_put(af01_fwnode);
1364                 return -ENOENT;
1365         }
1366
1367         /* The broken properties we can handle are a 4-element package (one GPIO) */
1368         if (obj->package.count != 4) {
1369                 dev_warn(cs35l56->base.dev, "Unexpected spk-id element count %d\n",
1370                          obj->package.count);
1371                 fwnode_handle_put(af01_fwnode);
1372                 return -ENOENT;
1373         }
1374
1375         /* Add a GPIO mapping if it doesn't already have one */
1376         if (!fwnode_property_present(af01_fwnode, "spk-id-gpios")) {
1377                 struct acpi_device *adev = to_acpi_device_node(af01_fwnode);
1378
1379                 /*
1380                  * Can't use devm_acpi_dev_add_driver_gpios() because the
1381                  * mapping isn't being added to the node pointed to by
1382                  * ACPI_COMPANION().
1383                  */
1384                 ret = acpi_dev_add_driver_gpios(adev, cs35l56_af01_spkid_gpios_mapping);
1385                 if (ret) {
1386                         fwnode_handle_put(af01_fwnode);
1387                         return dev_err_probe(cs35l56->base.dev, ret,
1388                                              "Failed to add gpio mapping to AF01\n");
1389                 }
1390
1391                 ret = devm_add_action_or_reset(cs35l56->base.dev,
1392                                                cs35l56_acpi_dev_release_driver_gpios,
1393                                                adev);
1394                 if (ret) {
1395                         fwnode_handle_put(af01_fwnode);
1396                         return ret;
1397                 }
1398
1399                 dev_dbg(cs35l56->base.dev, "Added spk-id-gpios mapping to AF01\n");
1400         }
1401
1402         desc = fwnode_gpiod_get_index(af01_fwnode, "spk-id", 0, GPIOD_IN, NULL);
1403         if (IS_ERR(desc)) {
1404                 fwnode_handle_put(af01_fwnode);
1405                 ret = PTR_ERR(desc);
1406                 return dev_err_probe(cs35l56->base.dev, ret, "Get GPIO from AF01 failed\n");
1407         }
1408
1409         ret = gpiod_get_value_cansleep(desc);
1410         gpiod_put(desc);
1411
1412         if (ret < 0) {
1413                 fwnode_handle_put(af01_fwnode);
1414                 dev_err_probe(cs35l56->base.dev, ret, "Error reading spk-id GPIO\n");
1415                 return ret;
1416         }
1417
1418         fwnode_handle_put(af01_fwnode);
1419
1420         dev_info(cs35l56->base.dev, "Got spk-id from AF01\n");
1421
1422         return ret;
1423 }
1424
1425 int cs35l56_common_probe(struct cs35l56_private *cs35l56)
1426 {
1427         int ret;
1428
1429         init_completion(&cs35l56->init_completion);
1430         mutex_init(&cs35l56->base.irq_lock);
1431         cs35l56->base.cal_index = -1;
1432         cs35l56->speaker_id = -ENOENT;
1433
1434         /* Assume that the firmware owns ASP1 until we know different */
1435         cs35l56->base.fw_owns_asp1 = true;
1436
1437         dev_set_drvdata(cs35l56->base.dev, cs35l56);
1438
1439         cs35l56_fill_supply_names(cs35l56->supplies);
1440         ret = devm_regulator_bulk_get(cs35l56->base.dev, ARRAY_SIZE(cs35l56->supplies),
1441                                       cs35l56->supplies);
1442         if (ret != 0)
1443                 return dev_err_probe(cs35l56->base.dev, ret, "Failed to request supplies\n");
1444
1445         /* Reset could be controlled by the BIOS or shared by multiple amps */
1446         cs35l56->base.reset_gpio = devm_gpiod_get_optional(cs35l56->base.dev, "reset",
1447                                                            GPIOD_OUT_LOW);
1448         if (IS_ERR(cs35l56->base.reset_gpio)) {
1449                 ret = PTR_ERR(cs35l56->base.reset_gpio);
1450                 /*
1451                  * If RESET is shared the first amp to probe will grab the reset
1452                  * line and reset all the amps
1453                  */
1454                 if (ret != -EBUSY)
1455                         return dev_err_probe(cs35l56->base.dev, ret, "Failed to get reset GPIO\n");
1456
1457                 dev_info(cs35l56->base.dev, "Reset GPIO busy, assume shared reset\n");
1458                 cs35l56->base.reset_gpio = NULL;
1459         }
1460
1461         ret = regulator_bulk_enable(ARRAY_SIZE(cs35l56->supplies), cs35l56->supplies);
1462         if (ret != 0)
1463                 return dev_err_probe(cs35l56->base.dev, ret, "Failed to enable supplies\n");
1464
1465         if (cs35l56->base.reset_gpio) {
1466                 /* ACPI can override GPIOD_OUT_LOW flag so force it to start low */
1467                 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1468                 cs35l56_wait_min_reset_pulse();
1469                 gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
1470         }
1471
1472         ret = cs35l56_get_speaker_id(&cs35l56->base);
1473         if (ACPI_COMPANION(cs35l56->base.dev) && cs35l56->sdw_peripheral && (ret == -ENOENT))
1474                 ret = cs35l56_try_get_broken_sdca_spkid_gpio(cs35l56);
1475
1476         if ((ret < 0) && (ret != -ENOENT))
1477                 goto err;
1478
1479         cs35l56->speaker_id = ret;
1480
1481         ret = cs35l56_get_firmware_uid(cs35l56);
1482         if (ret != 0)
1483                 goto err;
1484
1485         ret = cs35l56_dsp_init(cs35l56);
1486         if (ret < 0) {
1487                 dev_err_probe(cs35l56->base.dev, ret, "DSP init failed\n");
1488                 goto err;
1489         }
1490
1491         ret = devm_snd_soc_register_component(cs35l56->base.dev,
1492                                               &soc_component_dev_cs35l56,
1493                                               cs35l56_dai, ARRAY_SIZE(cs35l56_dai));
1494         if (ret < 0) {
1495                 dev_err_probe(cs35l56->base.dev, ret, "Register codec failed\n");
1496                 goto err;
1497         }
1498
1499         return 0;
1500
1501 err:
1502         gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1503         regulator_bulk_disable(ARRAY_SIZE(cs35l56->supplies), cs35l56->supplies);
1504
1505         return ret;
1506 }
1507 EXPORT_SYMBOL_NS_GPL(cs35l56_common_probe, SND_SOC_CS35L56_CORE);
1508
1509 int cs35l56_init(struct cs35l56_private *cs35l56)
1510 {
1511         int ret;
1512
1513         /*
1514          * Check whether the actions associated with soft reset or one time
1515          * init need to be performed.
1516          */
1517         if (cs35l56->soft_resetting)
1518                 goto post_soft_reset;
1519
1520         if (cs35l56->base.init_done)
1521                 return 0;
1522
1523         pm_runtime_set_autosuspend_delay(cs35l56->base.dev, 100);
1524         pm_runtime_use_autosuspend(cs35l56->base.dev);
1525         pm_runtime_set_active(cs35l56->base.dev);
1526         pm_runtime_enable(cs35l56->base.dev);
1527
1528         ret = cs35l56_hw_init(&cs35l56->base);
1529         if (ret < 0)
1530                 return ret;
1531
1532         ret = cs35l56_set_patch(&cs35l56->base);
1533         if (ret)
1534                 return ret;
1535
1536         ret = cs35l56_get_calibration(&cs35l56->base);
1537         if (ret)
1538                 return ret;
1539
1540         if (!cs35l56->base.reset_gpio) {
1541                 dev_dbg(cs35l56->base.dev, "No reset gpio: using soft reset\n");
1542                 cs35l56->soft_resetting = true;
1543                 cs35l56_system_reset(&cs35l56->base, !!cs35l56->sdw_peripheral);
1544                 if (cs35l56->sdw_peripheral) {
1545                         /* Keep alive while we wait for re-enumeration */
1546                         pm_runtime_get_noresume(cs35l56->base.dev);
1547                         return 0;
1548                 }
1549         }
1550
1551 post_soft_reset:
1552         if (cs35l56->soft_resetting) {
1553                 cs35l56->soft_resetting = false;
1554
1555                 /* Done re-enumerating after one-time init so release the keep-alive */
1556                 if (cs35l56->sdw_peripheral && !cs35l56->base.init_done)
1557                         pm_runtime_put_noidle(cs35l56->base.dev);
1558
1559                 regcache_mark_dirty(cs35l56->base.regmap);
1560                 ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
1561                 if (ret)
1562                         return ret;
1563
1564                 dev_dbg(cs35l56->base.dev, "Firmware rebooted after soft reset\n");
1565
1566                 regcache_cache_only(cs35l56->base.regmap, false);
1567         }
1568
1569         /* Disable auto-hibernate so that runtime_pm has control */
1570         ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
1571         if (ret)
1572                 return ret;
1573
1574         /* Registers could be dirty after soft reset or SoundWire enumeration */
1575         regcache_sync(cs35l56->base.regmap);
1576
1577         /* Set ASP1 DOUT to high-impedance when it is not transmitting audio data. */
1578         ret = regmap_set_bits(cs35l56->base.regmap, CS35L56_ASP1_CONTROL3,
1579                               CS35L56_ASP1_DOUT_HIZ_CTRL_MASK);
1580         if (ret)
1581                 return dev_err_probe(cs35l56->base.dev, ret, "Failed to write ASP1_CONTROL3\n");
1582
1583         cs35l56->base.init_done = true;
1584         complete(&cs35l56->init_completion);
1585
1586         return 0;
1587 }
1588 EXPORT_SYMBOL_NS_GPL(cs35l56_init, SND_SOC_CS35L56_CORE);
1589
1590 void cs35l56_remove(struct cs35l56_private *cs35l56)
1591 {
1592         cs35l56->base.init_done = false;
1593
1594         /*
1595          * WAKE IRQs unmask if CS35L56 hibernates so free the handler to
1596          * prevent it racing with remove().
1597          */
1598         if (cs35l56->base.irq)
1599                 devm_free_irq(cs35l56->base.dev, cs35l56->base.irq, &cs35l56->base);
1600
1601         flush_workqueue(cs35l56->dsp_wq);
1602         destroy_workqueue(cs35l56->dsp_wq);
1603
1604         pm_runtime_dont_use_autosuspend(cs35l56->base.dev);
1605         pm_runtime_suspend(cs35l56->base.dev);
1606         pm_runtime_disable(cs35l56->base.dev);
1607
1608         regcache_cache_only(cs35l56->base.regmap, true);
1609
1610         gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
1611         regulator_bulk_disable(ARRAY_SIZE(cs35l56->supplies), cs35l56->supplies);
1612 }
1613 EXPORT_SYMBOL_NS_GPL(cs35l56_remove, SND_SOC_CS35L56_CORE);
1614
1615 #if IS_ENABLED(CONFIG_SND_SOC_CS35L56_I2C) || IS_ENABLED(CONFIG_SND_SOC_CS35L56_SPI)
1616 EXPORT_NS_GPL_DEV_PM_OPS(cs35l56_pm_ops_i2c_spi, SND_SOC_CS35L56_CORE) = {
1617         SET_RUNTIME_PM_OPS(cs35l56_runtime_suspend_i2c_spi, cs35l56_runtime_resume_i2c_spi, NULL)
1618         SYSTEM_SLEEP_PM_OPS(cs35l56_system_suspend, cs35l56_system_resume)
1619         LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_system_suspend_late, cs35l56_system_resume_early)
1620         NOIRQ_SYSTEM_SLEEP_PM_OPS(cs35l56_system_suspend_no_irq, cs35l56_system_resume_no_irq)
1621 };
1622 #endif
1623
1624 MODULE_DESCRIPTION("ASoC CS35L56 driver");
1625 MODULE_IMPORT_NS(SND_SOC_CS35L56_SHARED);
1626 MODULE_IMPORT_NS(SND_SOC_CS_AMP_LIB);
1627 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
1628 MODULE_AUTHOR("Simon Trimmer <simont@opensource.cirrus.com>");
1629 MODULE_LICENSE("GPL");