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