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