1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // Copyright (c) 2020-2021, The Linux Foundation. All rights reserved.
4 //
5 // ALSA SoC Machine driver for sc7280
6
7 #include <linux/input.h>
8 #include <linux/module.h>
9 #include <linux/of_device.h>
10 #include <linux/platform_device.h>
11 #include <sound/core.h>
12 #include <sound/jack.h>
13 #include <sound/pcm.h>
14 #include <sound/soc.h>
15 #include <sound/rt5682s.h>
16 #include <linux/soundwire/sdw.h>
17 #include <sound/pcm_params.h>
18
19 #include "../codecs/rt5682.h"
20 #include "../codecs/rt5682s.h"
21 #include "common.h"
22 #include "lpass.h"
23 #include "qdsp6/q6afe.h"
24
25 #define DEFAULT_MCLK_RATE 19200000
26 #define RT5682_PLL_FREQ (48000 * 512)
27 #define MI2S_BCLK_RATE 1536000
28
29 struct sc7280_snd_data {
30 struct snd_soc_card card;
31 struct sdw_stream_runtime *sruntime[LPASS_MAX_PORTS];
32 u32 pri_mi2s_clk_count;
33 struct snd_soc_jack hs_jack;
34 struct snd_soc_jack hdmi_jack;
35 bool jack_setup;
36 bool stream_prepared[LPASS_MAX_PORTS];
37 };
38
sc7280_jack_free(struct snd_jack * jack)39 static void sc7280_jack_free(struct snd_jack *jack)
40 {
41 struct snd_soc_component *component = jack->private_data;
42
43 snd_soc_component_set_jack(component, NULL, NULL);
44 }
45
46 static struct snd_soc_jack_pin sc7280_jack_pins[] = {
47 {
48 .pin = "Headphone Jack",
49 .mask = SND_JACK_HEADPHONE,
50 },
51 {
52 .pin = "Headset Mic",
53 .mask = SND_JACK_MICROPHONE,
54 },
55 };
56
sc7280_headset_init(struct snd_soc_pcm_runtime * rtd)57 static int sc7280_headset_init(struct snd_soc_pcm_runtime *rtd)
58 {
59 struct snd_soc_card *card = rtd->card;
60 struct sc7280_snd_data *pdata = snd_soc_card_get_drvdata(card);
61 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
62 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
63 struct snd_soc_component *component = codec_dai->component;
64 struct snd_jack *jack;
65 int rval, i;
66
67 if (!pdata->jack_setup) {
68 rval = snd_soc_card_jack_new_pins(card, "Headset Jack",
69 SND_JACK_HEADSET | SND_JACK_LINEOUT |
70 SND_JACK_MECHANICAL |
71 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
72 SND_JACK_BTN_2 | SND_JACK_BTN_3 |
73 SND_JACK_BTN_4 | SND_JACK_BTN_5,
74 &pdata->hs_jack,
75 sc7280_jack_pins,
76 ARRAY_SIZE(sc7280_jack_pins));
77
78 if (rval < 0) {
79 dev_err(card->dev, "Unable to add Headset Jack\n");
80 return rval;
81 }
82
83 jack = pdata->hs_jack.jack;
84
85 snd_jack_set_key(jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
86 snd_jack_set_key(jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
87 snd_jack_set_key(jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
88 snd_jack_set_key(jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
89
90 jack->private_data = component;
91 jack->private_free = sc7280_jack_free;
92 pdata->jack_setup = true;
93 }
94 switch (cpu_dai->id) {
95 case MI2S_PRIMARY:
96 case LPASS_CDC_DMA_RX0:
97 case LPASS_CDC_DMA_TX3:
98 case TX_CODEC_DMA_TX_3:
99 for_each_rtd_codec_dais(rtd, i, codec_dai) {
100 rval = snd_soc_component_set_jack(component, &pdata->hs_jack, NULL);
101 if (rval != 0 && rval != -ENOTSUPP) {
102 dev_err(card->dev, "Failed to set jack: %d\n", rval);
103 return rval;
104 }
105 }
106 break;
107 default:
108 break;
109 }
110
111 return 0;
112 }
113
sc7280_hdmi_init(struct snd_soc_pcm_runtime * rtd)114 static int sc7280_hdmi_init(struct snd_soc_pcm_runtime *rtd)
115 {
116 struct snd_soc_card *card = rtd->card;
117 struct sc7280_snd_data *pdata = snd_soc_card_get_drvdata(card);
118 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
119 struct snd_soc_component *component = codec_dai->component;
120 struct snd_jack *jack;
121 int rval;
122
123 rval = snd_soc_card_jack_new(card, "HDMI Jack", SND_JACK_LINEOUT,
124 &pdata->hdmi_jack);
125
126 if (rval < 0) {
127 dev_err(card->dev, "Unable to add HDMI Jack\n");
128 return rval;
129 }
130
131 jack = pdata->hdmi_jack.jack;
132 jack->private_data = component;
133 jack->private_free = sc7280_jack_free;
134
135 return snd_soc_component_set_jack(component, &pdata->hdmi_jack, NULL);
136 }
137
sc7280_rt5682_init(struct snd_soc_pcm_runtime * rtd)138 static int sc7280_rt5682_init(struct snd_soc_pcm_runtime *rtd)
139 {
140 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
141 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
142 struct snd_soc_card *card = rtd->card;
143 struct sc7280_snd_data *data = snd_soc_card_get_drvdata(card);
144 int ret;
145
146 if (++data->pri_mi2s_clk_count == 1) {
147 snd_soc_dai_set_sysclk(cpu_dai,
148 LPASS_MCLK0,
149 DEFAULT_MCLK_RATE,
150 SNDRV_PCM_STREAM_PLAYBACK);
151 }
152 snd_soc_dai_set_fmt(codec_dai,
153 SND_SOC_DAIFMT_CBC_CFC |
154 SND_SOC_DAIFMT_NB_NF |
155 SND_SOC_DAIFMT_I2S);
156
157 ret = snd_soc_dai_set_pll(codec_dai, RT5682S_PLL2, RT5682S_PLL_S_MCLK,
158 DEFAULT_MCLK_RATE, RT5682_PLL_FREQ);
159 if (ret) {
160 dev_err(rtd->dev, "can't set codec pll: %d\n", ret);
161 return ret;
162 }
163
164 ret = snd_soc_dai_set_sysclk(codec_dai, RT5682S_SCLK_S_PLL2,
165 RT5682_PLL_FREQ,
166 SND_SOC_CLOCK_IN);
167
168 if (ret) {
169 dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n",
170 ret);
171 return ret;
172 }
173
174 return 0;
175 }
176
sc7280_init(struct snd_soc_pcm_runtime * rtd)177 static int sc7280_init(struct snd_soc_pcm_runtime *rtd)
178 {
179 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
180
181 switch (cpu_dai->id) {
182 case MI2S_PRIMARY:
183 case LPASS_CDC_DMA_TX3:
184 case TX_CODEC_DMA_TX_3:
185 return sc7280_headset_init(rtd);
186 case LPASS_CDC_DMA_RX0:
187 case LPASS_CDC_DMA_VA_TX0:
188 case MI2S_SECONDARY:
189 case RX_CODEC_DMA_RX_0:
190 case SECONDARY_MI2S_RX:
191 case VA_CODEC_DMA_TX_0:
192 return 0;
193 case LPASS_DP_RX:
194 return sc7280_hdmi_init(rtd);
195 default:
196 dev_err(rtd->dev, "%s: invalid dai id 0x%x\n", __func__, cpu_dai->id);
197 }
198
199 return -EINVAL;
200 }
201
sc7280_snd_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params)202 static int sc7280_snd_hw_params(struct snd_pcm_substream *substream,
203 struct snd_pcm_hw_params *params)
204 {
205 struct snd_pcm_runtime *runtime = substream->runtime;
206 struct snd_soc_pcm_runtime *rtd = substream->private_data;
207 struct snd_soc_dai *codec_dai;
208 const struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
209 struct sc7280_snd_data *pdata = snd_soc_card_get_drvdata(rtd->card);
210 struct sdw_stream_runtime *sruntime;
211 int i;
212
213 if (!rtd->dai_link->no_pcm) {
214 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS, 2, 2);
215 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE, 48000, 48000);
216 }
217
218 switch (cpu_dai->id) {
219 case LPASS_CDC_DMA_TX3:
220 case LPASS_CDC_DMA_RX0:
221 case RX_CODEC_DMA_RX_0:
222 case SECONDARY_MI2S_RX:
223 case TX_CODEC_DMA_TX_3:
224 case VA_CODEC_DMA_TX_0:
225 for_each_rtd_codec_dais(rtd, i, codec_dai) {
226 sruntime = snd_soc_dai_get_stream(codec_dai, substream->stream);
227 if (sruntime != ERR_PTR(-ENOTSUPP))
228 pdata->sruntime[cpu_dai->id] = sruntime;
229 }
230 break;
231 }
232
233 return 0;
234 }
235
sc7280_snd_swr_prepare(struct snd_pcm_substream * substream)236 static int sc7280_snd_swr_prepare(struct snd_pcm_substream *substream)
237 {
238 struct snd_soc_pcm_runtime *rtd = substream->private_data;
239 const struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
240 struct sc7280_snd_data *data = snd_soc_card_get_drvdata(rtd->card);
241 struct sdw_stream_runtime *sruntime = data->sruntime[cpu_dai->id];
242 int ret;
243
244 if (!sruntime)
245 return 0;
246
247 if (data->stream_prepared[cpu_dai->id]) {
248 sdw_disable_stream(sruntime);
249 sdw_deprepare_stream(sruntime);
250 data->stream_prepared[cpu_dai->id] = false;
251 }
252
253 ret = sdw_prepare_stream(sruntime);
254 if (ret)
255 return ret;
256
257 ret = sdw_enable_stream(sruntime);
258 if (ret) {
259 sdw_deprepare_stream(sruntime);
260 return ret;
261 }
262 data->stream_prepared[cpu_dai->id] = true;
263
264 return ret;
265 }
266
sc7280_snd_prepare(struct snd_pcm_substream * substream)267 static int sc7280_snd_prepare(struct snd_pcm_substream *substream)
268 {
269 struct snd_soc_pcm_runtime *rtd = substream->private_data;
270 const struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
271
272 switch (cpu_dai->id) {
273 case LPASS_CDC_DMA_RX0:
274 case LPASS_CDC_DMA_TX3:
275 case RX_CODEC_DMA_RX_0:
276 case TX_CODEC_DMA_TX_3:
277 case VA_CODEC_DMA_TX_0:
278 return sc7280_snd_swr_prepare(substream);
279 default:
280 break;
281 }
282
283 return 0;
284 }
285
sc7280_snd_hw_free(struct snd_pcm_substream * substream)286 static int sc7280_snd_hw_free(struct snd_pcm_substream *substream)
287 {
288 struct snd_soc_pcm_runtime *rtd = substream->private_data;
289 struct sc7280_snd_data *data = snd_soc_card_get_drvdata(rtd->card);
290 const struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
291 struct sdw_stream_runtime *sruntime = data->sruntime[cpu_dai->id];
292
293 switch (cpu_dai->id) {
294 case LPASS_CDC_DMA_RX0:
295 case LPASS_CDC_DMA_TX3:
296 case RX_CODEC_DMA_RX_0:
297 case TX_CODEC_DMA_TX_3:
298 case VA_CODEC_DMA_TX_0:
299 if (sruntime && data->stream_prepared[cpu_dai->id]) {
300 sdw_disable_stream(sruntime);
301 sdw_deprepare_stream(sruntime);
302 data->stream_prepared[cpu_dai->id] = false;
303 }
304 break;
305 default:
306 break;
307 }
308 return 0;
309 }
310
sc7280_snd_shutdown(struct snd_pcm_substream * substream)311 static void sc7280_snd_shutdown(struct snd_pcm_substream *substream)
312 {
313 struct snd_soc_pcm_runtime *rtd = substream->private_data;
314 struct snd_soc_card *card = rtd->card;
315 struct sc7280_snd_data *data = snd_soc_card_get_drvdata(card);
316 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
317
318 switch (cpu_dai->id) {
319 case MI2S_PRIMARY:
320 if (--data->pri_mi2s_clk_count == 0) {
321 snd_soc_dai_set_sysclk(cpu_dai,
322 LPASS_MCLK0,
323 0,
324 SNDRV_PCM_STREAM_PLAYBACK);
325 }
326 break;
327 case SECONDARY_MI2S_RX:
328 snd_soc_dai_set_sysclk(cpu_dai, Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT,
329 0, SNDRV_PCM_STREAM_PLAYBACK);
330 break;
331 default:
332 break;
333 }
334 }
335
sc7280_snd_startup(struct snd_pcm_substream * substream)336 static int sc7280_snd_startup(struct snd_pcm_substream *substream)
337 {
338 unsigned int fmt = SND_SOC_DAIFMT_CBS_CFS;
339 unsigned int codec_dai_fmt = SND_SOC_DAIFMT_CBS_CFS;
340 struct snd_soc_pcm_runtime *rtd = substream->private_data;
341 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0);
342 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0);
343 int ret = 0;
344
345 switch (cpu_dai->id) {
346 case MI2S_PRIMARY:
347 ret = sc7280_rt5682_init(rtd);
348 break;
349 case SECONDARY_MI2S_RX:
350 codec_dai_fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_I2S;
351
352 snd_soc_dai_set_sysclk(cpu_dai, Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT,
353 MI2S_BCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
354
355 snd_soc_dai_set_fmt(cpu_dai, fmt);
356 snd_soc_dai_set_fmt(codec_dai, codec_dai_fmt);
357 break;
358 default:
359 break;
360 }
361 return ret;
362 }
363
364 static const struct snd_soc_ops sc7280_ops = {
365 .startup = sc7280_snd_startup,
366 .hw_params = sc7280_snd_hw_params,
367 .hw_free = sc7280_snd_hw_free,
368 .prepare = sc7280_snd_prepare,
369 .shutdown = sc7280_snd_shutdown,
370 };
371
372 static const struct snd_soc_dapm_widget sc7280_snd_widgets[] = {
373 SND_SOC_DAPM_HP("Headphone Jack", NULL),
374 SND_SOC_DAPM_MIC("Headset Mic", NULL),
375 };
376
377 static const struct snd_kcontrol_new sc7280_snd_controls[] = {
378 SOC_DAPM_PIN_SWITCH("Headphone Jack"),
379 SOC_DAPM_PIN_SWITCH("Headset Mic"),
380 };
381
sc7280_snd_be_hw_params_fixup(struct snd_soc_pcm_runtime * rtd,struct snd_pcm_hw_params * params)382 static int sc7280_snd_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
383 struct snd_pcm_hw_params *params)
384 {
385 struct snd_interval *rate = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
386 struct snd_interval *channels = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
387 struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
388
389 rate->min = rate->max = 48000;
390 channels->min = channels->max = 2;
391 snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE);
392
393 return 0;
394 }
395
sc7280_snd_platform_probe(struct platform_device * pdev)396 static int sc7280_snd_platform_probe(struct platform_device *pdev)
397 {
398 struct snd_soc_card *card;
399 struct sc7280_snd_data *data;
400 struct device *dev = &pdev->dev;
401 struct snd_soc_dai_link *link;
402 int ret, i;
403
404 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
405 if (!data)
406 return -ENOMEM;
407
408 card = &data->card;
409 snd_soc_card_set_drvdata(card, data);
410
411 card->owner = THIS_MODULE;
412 card->driver_name = "SC7280";
413 card->dev = dev;
414
415 card->dapm_widgets = sc7280_snd_widgets;
416 card->num_dapm_widgets = ARRAY_SIZE(sc7280_snd_widgets);
417 card->controls = sc7280_snd_controls;
418 card->num_controls = ARRAY_SIZE(sc7280_snd_controls);
419
420 ret = qcom_snd_parse_of(card);
421 if (ret)
422 return ret;
423
424 for_each_card_prelinks(card, i, link) {
425 link->init = sc7280_init;
426 link->ops = &sc7280_ops;
427 if (link->no_pcm == 1)
428 link->be_hw_params_fixup = sc7280_snd_be_hw_params_fixup;
429 }
430
431 return devm_snd_soc_register_card(dev, card);
432 }
433
434 static const struct of_device_id sc7280_snd_device_id[] = {
435 { .compatible = "google,sc7280-herobrine" },
436 {}
437 };
438 MODULE_DEVICE_TABLE(of, sc7280_snd_device_id);
439
440 static struct platform_driver sc7280_snd_driver = {
441 .probe = sc7280_snd_platform_probe,
442 .driver = {
443 .name = "msm-snd-sc7280",
444 .of_match_table = sc7280_snd_device_id,
445 .pm = &snd_soc_pm_ops,
446 },
447 };
448 module_platform_driver(sc7280_snd_driver);
449
450 MODULE_DESCRIPTION("sc7280 ASoC Machine Driver");
451 MODULE_LICENSE("GPL");
452