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
cs35l56_wait_dsp_ready(struct cs35l56_private * cs35l56)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
cs35l56_dspwait_get_volsw(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
cs35l56_dspwait_put_volsw(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
cs35l56_play_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)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
cs35l56_dsp_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)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
cs35l56_asp_dai_set_fmt(struct snd_soc_dai * codec_dai,unsigned int fmt)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
cs35l56_make_tdm_config_word(unsigned int reg_val,unsigned long mask)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
cs35l56_asp_dai_set_tdm_slot(struct snd_soc_dai * dai,unsigned int tx_mask,unsigned int rx_mask,int slots,int slot_width)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
cs35l56_asp_dai_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)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
cs35l56_asp_dai_set_sysclk(struct snd_soc_dai * dai,int clk_id,unsigned int freq,int dir)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
cs35l56_sdw_dai_shutdown(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)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
cs35l56_sdw_dai_set_tdm_slot(struct snd_soc_dai * dai,unsigned int tx_mask,unsigned int rx_mask,int slots,int slot_width)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
cs35l56_sdw_dai_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)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
cs35l56_sdw_dai_hw_free(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)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
cs35l56_sdw_dai_set_stream(struct snd_soc_dai * dai,void * sdw_stream,int direction)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
cs35l56_write_cal(struct cs35l56_private * cs35l56)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
cs35l56_dsp_download_and_power_up(struct cs35l56_private * cs35l56,bool load_firmware)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
cs35l56_reinit_patch(struct cs35l56_private * cs35l56)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
cs35l56_patch(struct cs35l56_private * cs35l56,bool firmware_missing)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
cs35l56_dsp_work(struct work_struct * work)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
cs35l56_set_fw_suffix(struct cs35l56_private * cs35l56)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
cs35l56_component_probe(struct snd_soc_component * component)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
cs35l56_component_remove(struct snd_soc_component * component)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
cs35l56_set_bias_level(struct snd_soc_component * component,enum snd_soc_bias_level level)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
cs35l56_runtime_suspend_i2c_spi(struct device * dev)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
cs35l56_runtime_resume_i2c_spi(struct device * dev)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
cs35l56_system_suspend(struct device * dev)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
cs35l56_system_suspend_late(struct device * dev)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
cs35l56_system_suspend_no_irq(struct device * dev)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
cs35l56_system_resume_no_irq(struct device * dev)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
cs35l56_system_resume_early(struct device * dev)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
cs35l56_system_resume(struct device * dev)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
cs35l56_control_add_nop(struct wm_adsp * dsp,struct cs_dsp_coeff_ctl * cs_ctl)1198 static int cs35l56_control_add_nop(struct wm_adsp *dsp, struct cs_dsp_coeff_ctl *cs_ctl)
1199 {
1200 return 0;
1201 }
1202
cs35l56_dsp_init(struct cs35l56_private * cs35l56)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
cs35l56_get_firmware_uid(struct cs35l56_private * cs35l56)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
cs35l56_acpi_dev_release_driver_gpios(void * adev)1280 static void cs35l56_acpi_dev_release_driver_gpios(void *adev)
1281 {
1282 acpi_dev_remove_driver_gpios(adev);
1283 }
1284
cs35l56_try_get_broken_sdca_spkid_gpio(struct cs35l56_private * cs35l56)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
cs35l56_common_probe(struct cs35l56_private * cs35l56)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
cs35l56_init(struct cs35l56_private * cs35l56)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
cs35l56_remove(struct cs35l56_private * cs35l56)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