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