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