Commit | Line | Data |
---|---|---|
6b1687bf R |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* | |
3 | * Copyright (c) 2018, The Linux Foundation. All rights reserved. | |
4 | */ | |
5 | ||
6 | #include <linux/module.h> | |
7 | #include <linux/platform_device.h> | |
6b1687bf | 8 | #include <linux/of_device.h> |
09b38200 | 9 | #include <sound/core.h> |
6b1687bf R |
10 | #include <sound/pcm.h> |
11 | #include <sound/pcm_params.h> | |
80e733fd | 12 | #include <sound/jack.h> |
09b38200 | 13 | #include <sound/soc.h> |
80e733fd | 14 | #include <uapi/linux/input-event-codes.h> |
6b1687bf R |
15 | #include "common.h" |
16 | #include "qdsp6/q6afe.h" | |
ce55698d | 17 | #include "../codecs/rt5663.h" |
6b1687bf R |
18 | |
19 | #define DEFAULT_SAMPLE_RATE_48K 48000 | |
20 | #define DEFAULT_MCLK_RATE 24576000 | |
a1849b7d R |
21 | #define TDM_BCLK_RATE 6144000 |
22 | #define MI2S_BCLK_RATE 1536000 | |
09b38200 CYC |
23 | #define LEFT_SPK_TDM_TX_MASK 0x30 |
24 | #define RIGHT_SPK_TDM_TX_MASK 0xC0 | |
25 | #define SPK_TDM_RX_MASK 0x03 | |
26 | #define NUM_TDM_SLOTS 8 | |
6b1687bf R |
27 | |
28 | struct sdm845_snd_data { | |
80e733fd CYC |
29 | struct snd_soc_jack jack; |
30 | bool jack_setup; | |
6b1687bf R |
31 | struct snd_soc_card *card; |
32 | uint32_t pri_mi2s_clk_count; | |
992e75b3 | 33 | uint32_t sec_mi2s_clk_count; |
6b1687bf R |
34 | uint32_t quat_tdm_clk_count; |
35 | }; | |
36 | ||
37 | static unsigned int tdm_slot_offset[8] = {0, 4, 8, 12, 16, 20, 24, 28}; | |
38 | ||
39 | static int sdm845_tdm_snd_hw_params(struct snd_pcm_substream *substream, | |
40 | struct snd_pcm_hw_params *params) | |
41 | { | |
42 | struct snd_soc_pcm_runtime *rtd = substream->private_data; | |
43 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; | |
09b38200 | 44 | int ret = 0, j; |
6b1687bf R |
45 | int channels, slot_width; |
46 | ||
47 | switch (params_format(params)) { | |
48 | case SNDRV_PCM_FORMAT_S16_LE: | |
a1849b7d | 49 | slot_width = 16; |
6b1687bf R |
50 | break; |
51 | default: | |
52 | dev_err(rtd->dev, "%s: invalid param format 0x%x\n", | |
53 | __func__, params_format(params)); | |
54 | return -EINVAL; | |
55 | } | |
56 | ||
57 | channels = params_channels(params); | |
58 | if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { | |
59 | ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0, 0x3, | |
60 | 8, slot_width); | |
61 | if (ret < 0) { | |
62 | dev_err(rtd->dev, "%s: failed to set tdm slot, err:%d\n", | |
63 | __func__, ret); | |
64 | goto end; | |
65 | } | |
66 | ||
67 | ret = snd_soc_dai_set_channel_map(cpu_dai, 0, NULL, | |
68 | channels, tdm_slot_offset); | |
69 | if (ret < 0) { | |
70 | dev_err(rtd->dev, "%s: failed to set channel map, err:%d\n", | |
71 | __func__, ret); | |
72 | goto end; | |
73 | } | |
74 | } else { | |
75 | ret = snd_soc_dai_set_tdm_slot(cpu_dai, 0xf, 0, | |
76 | 8, slot_width); | |
77 | if (ret < 0) { | |
78 | dev_err(rtd->dev, "%s: failed to set tdm slot, err:%d\n", | |
79 | __func__, ret); | |
80 | goto end; | |
81 | } | |
82 | ||
83 | ret = snd_soc_dai_set_channel_map(cpu_dai, channels, | |
84 | tdm_slot_offset, 0, NULL); | |
85 | if (ret < 0) { | |
86 | dev_err(rtd->dev, "%s: failed to set channel map, err:%d\n", | |
87 | __func__, ret); | |
88 | goto end; | |
89 | } | |
90 | } | |
09b38200 CYC |
91 | |
92 | for (j = 0; j < rtd->num_codecs; j++) { | |
93 | struct snd_soc_dai *codec_dai = rtd->codec_dais[j]; | |
94 | ||
95 | if (!strcmp(codec_dai->component->name_prefix, "Left")) { | |
96 | ret = snd_soc_dai_set_tdm_slot( | |
97 | codec_dai, LEFT_SPK_TDM_TX_MASK, | |
98 | SPK_TDM_RX_MASK, NUM_TDM_SLOTS, | |
99 | slot_width); | |
100 | if (ret < 0) { | |
101 | dev_err(rtd->dev, | |
102 | "DEV0 TDM slot err:%d\n", ret); | |
103 | return ret; | |
104 | } | |
105 | } | |
106 | ||
107 | if (!strcmp(codec_dai->component->name_prefix, "Right")) { | |
108 | ret = snd_soc_dai_set_tdm_slot( | |
109 | codec_dai, RIGHT_SPK_TDM_TX_MASK, | |
110 | SPK_TDM_RX_MASK, NUM_TDM_SLOTS, | |
111 | slot_width); | |
112 | if (ret < 0) { | |
113 | dev_err(rtd->dev, | |
114 | "DEV1 TDM slot err:%d\n", ret); | |
115 | return ret; | |
116 | } | |
117 | } | |
118 | } | |
119 | ||
6b1687bf R |
120 | end: |
121 | return ret; | |
122 | } | |
123 | ||
124 | static int sdm845_snd_hw_params(struct snd_pcm_substream *substream, | |
125 | struct snd_pcm_hw_params *params) | |
126 | { | |
127 | struct snd_soc_pcm_runtime *rtd = substream->private_data; | |
128 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; | |
ce55698d | 129 | struct snd_soc_dai *codec_dai = rtd->codec_dai; |
6b1687bf R |
130 | int ret = 0; |
131 | ||
132 | switch (cpu_dai->id) { | |
ce55698d CYC |
133 | case PRIMARY_MI2S_RX: |
134 | case PRIMARY_MI2S_TX: | |
135 | /* | |
136 | * Use ASRC for internal clocks, as PLL rate isn't multiple | |
137 | * of BCLK. | |
138 | */ | |
139 | rt5663_sel_asrc_clk_src( | |
140 | codec_dai->component, | |
141 | RT5663_DA_STEREO_FILTER | RT5663_AD_STEREO_FILTER, | |
142 | RT5663_CLK_SEL_I2S1_ASRC); | |
143 | ret = snd_soc_dai_set_sysclk( | |
144 | codec_dai, RT5663_SCLK_S_MCLK, DEFAULT_MCLK_RATE, | |
145 | SND_SOC_CLOCK_IN); | |
146 | if (ret < 0) | |
147 | dev_err(rtd->dev, | |
148 | "snd_soc_dai_set_sysclk err = %d\n", ret); | |
149 | break; | |
6b1687bf R |
150 | case QUATERNARY_TDM_RX_0: |
151 | case QUATERNARY_TDM_TX_0: | |
152 | ret = sdm845_tdm_snd_hw_params(substream, params); | |
153 | break; | |
154 | default: | |
155 | pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id); | |
156 | break; | |
157 | } | |
158 | return ret; | |
159 | } | |
160 | ||
2998369f R |
161 | static void sdm845_jack_free(struct snd_jack *jack) |
162 | { | |
163 | struct snd_soc_component *component = jack->private_data; | |
164 | ||
165 | snd_soc_component_set_jack(component, NULL, NULL); | |
166 | } | |
167 | ||
80e733fd CYC |
168 | static int sdm845_dai_init(struct snd_soc_pcm_runtime *rtd) |
169 | { | |
170 | struct snd_soc_component *component; | |
80e733fd | 171 | struct snd_soc_card *card = rtd->card; |
2998369f R |
172 | struct snd_soc_dai *codec_dai = rtd->codec_dai; |
173 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; | |
80e733fd | 174 | struct sdm845_snd_data *pdata = snd_soc_card_get_drvdata(card); |
2998369f R |
175 | struct snd_jack *jack; |
176 | int rval; | |
80e733fd CYC |
177 | |
178 | if (!pdata->jack_setup) { | |
80e733fd CYC |
179 | rval = snd_soc_card_jack_new(card, "Headset Jack", |
180 | SND_JACK_HEADSET | | |
181 | SND_JACK_HEADPHONE | | |
182 | SND_JACK_BTN_0 | SND_JACK_BTN_1 | | |
183 | SND_JACK_BTN_2 | SND_JACK_BTN_3, | |
184 | &pdata->jack, NULL, 0); | |
185 | ||
186 | if (rval < 0) { | |
187 | dev_err(card->dev, "Unable to add Headphone Jack\n"); | |
188 | return rval; | |
189 | } | |
190 | ||
191 | jack = pdata->jack.jack; | |
192 | ||
193 | snd_jack_set_key(jack, SND_JACK_BTN_0, KEY_PLAYPAUSE); | |
194 | snd_jack_set_key(jack, SND_JACK_BTN_1, KEY_VOICECOMMAND); | |
195 | snd_jack_set_key(jack, SND_JACK_BTN_2, KEY_VOLUMEUP); | |
196 | snd_jack_set_key(jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN); | |
197 | pdata->jack_setup = true; | |
198 | } | |
199 | ||
2998369f R |
200 | switch (cpu_dai->id) { |
201 | case PRIMARY_MI2S_RX: | |
202 | jack = pdata->jack.jack; | |
203 | component = codec_dai->component; | |
80e733fd | 204 | |
2998369f R |
205 | jack->private_data = component; |
206 | jack->private_free = sdm845_jack_free; | |
207 | rval = snd_soc_component_set_jack(component, | |
208 | &pdata->jack, NULL); | |
80e733fd CYC |
209 | if (rval != 0 && rval != -ENOTSUPP) { |
210 | dev_warn(card->dev, "Failed to set jack: %d\n", rval); | |
211 | return rval; | |
212 | } | |
2998369f R |
213 | break; |
214 | default: | |
215 | break; | |
80e733fd CYC |
216 | } |
217 | ||
218 | return 0; | |
219 | } | |
220 | ||
221 | ||
6b1687bf R |
222 | static int sdm845_snd_startup(struct snd_pcm_substream *substream) |
223 | { | |
224 | unsigned int fmt = SND_SOC_DAIFMT_CBS_CFS; | |
09b38200 | 225 | unsigned int codec_dai_fmt = SND_SOC_DAIFMT_CBS_CFS; |
6b1687bf R |
226 | struct snd_soc_pcm_runtime *rtd = substream->private_data; |
227 | struct snd_soc_card *card = rtd->card; | |
228 | struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card); | |
229 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; | |
09b38200 CYC |
230 | struct snd_soc_dai *codec_dai = rtd->codec_dai; |
231 | int j; | |
232 | int ret; | |
6b1687bf R |
233 | |
234 | switch (cpu_dai->id) { | |
235 | case PRIMARY_MI2S_RX: | |
236 | case PRIMARY_MI2S_TX: | |
ce55698d | 237 | codec_dai_fmt |= SND_SOC_DAIFMT_NB_NF; |
6b1687bf R |
238 | if (++(data->pri_mi2s_clk_count) == 1) { |
239 | snd_soc_dai_set_sysclk(cpu_dai, | |
240 | Q6AFE_LPASS_CLK_ID_MCLK_1, | |
241 | DEFAULT_MCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK); | |
242 | snd_soc_dai_set_sysclk(cpu_dai, | |
243 | Q6AFE_LPASS_CLK_ID_PRI_MI2S_IBIT, | |
a1849b7d | 244 | MI2S_BCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK); |
6b1687bf R |
245 | } |
246 | snd_soc_dai_set_fmt(cpu_dai, fmt); | |
ce55698d | 247 | snd_soc_dai_set_fmt(codec_dai, codec_dai_fmt); |
6b1687bf R |
248 | break; |
249 | ||
992e75b3 | 250 | case SECONDARY_MI2S_TX: |
9019ab10 | 251 | codec_dai_fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_I2S; |
992e75b3 R |
252 | if (++(data->sec_mi2s_clk_count) == 1) { |
253 | snd_soc_dai_set_sysclk(cpu_dai, | |
254 | Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT, | |
255 | MI2S_BCLK_RATE, SNDRV_PCM_STREAM_CAPTURE); | |
256 | } | |
257 | snd_soc_dai_set_fmt(cpu_dai, fmt); | |
9019ab10 | 258 | snd_soc_dai_set_fmt(codec_dai, codec_dai_fmt); |
992e75b3 R |
259 | break; |
260 | ||
6b1687bf R |
261 | case QUATERNARY_TDM_RX_0: |
262 | case QUATERNARY_TDM_TX_0: | |
263 | if (++(data->quat_tdm_clk_count) == 1) { | |
264 | snd_soc_dai_set_sysclk(cpu_dai, | |
265 | Q6AFE_LPASS_CLK_ID_QUAD_TDM_IBIT, | |
a1849b7d | 266 | TDM_BCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK); |
6b1687bf | 267 | } |
09b38200 CYC |
268 | |
269 | codec_dai_fmt |= SND_SOC_DAIFMT_IB_NF | SND_SOC_DAIFMT_DSP_B; | |
270 | ||
271 | for (j = 0; j < rtd->num_codecs; j++) { | |
272 | codec_dai = rtd->codec_dais[j]; | |
273 | ||
274 | if (!strcmp(codec_dai->component->name_prefix, | |
275 | "Left")) { | |
276 | ret = snd_soc_dai_set_fmt( | |
277 | codec_dai, codec_dai_fmt); | |
278 | if (ret < 0) { | |
279 | dev_err(rtd->dev, | |
280 | "Left TDM fmt err:%d\n", ret); | |
281 | return ret; | |
282 | } | |
283 | } | |
284 | ||
285 | if (!strcmp(codec_dai->component->name_prefix, | |
286 | "Right")) { | |
287 | ret = snd_soc_dai_set_fmt( | |
288 | codec_dai, codec_dai_fmt); | |
289 | if (ret < 0) { | |
290 | dev_err(rtd->dev, | |
291 | "Right TDM slot err:%d\n", ret); | |
292 | return ret; | |
293 | } | |
294 | } | |
295 | } | |
6b1687bf R |
296 | break; |
297 | ||
298 | default: | |
299 | pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id); | |
300 | break; | |
301 | } | |
302 | return 0; | |
303 | } | |
304 | ||
305 | static void sdm845_snd_shutdown(struct snd_pcm_substream *substream) | |
306 | { | |
307 | struct snd_soc_pcm_runtime *rtd = substream->private_data; | |
308 | struct snd_soc_card *card = rtd->card; | |
309 | struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card); | |
310 | struct snd_soc_dai *cpu_dai = rtd->cpu_dai; | |
311 | ||
312 | switch (cpu_dai->id) { | |
313 | case PRIMARY_MI2S_RX: | |
314 | case PRIMARY_MI2S_TX: | |
315 | if (--(data->pri_mi2s_clk_count) == 0) { | |
316 | snd_soc_dai_set_sysclk(cpu_dai, | |
317 | Q6AFE_LPASS_CLK_ID_MCLK_1, | |
318 | 0, SNDRV_PCM_STREAM_PLAYBACK); | |
319 | snd_soc_dai_set_sysclk(cpu_dai, | |
320 | Q6AFE_LPASS_CLK_ID_PRI_MI2S_IBIT, | |
321 | 0, SNDRV_PCM_STREAM_PLAYBACK); | |
322 | }; | |
323 | break; | |
324 | ||
992e75b3 R |
325 | case SECONDARY_MI2S_TX: |
326 | if (--(data->sec_mi2s_clk_count) == 0) { | |
327 | snd_soc_dai_set_sysclk(cpu_dai, | |
328 | Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT, | |
329 | 0, SNDRV_PCM_STREAM_CAPTURE); | |
330 | } | |
331 | break; | |
332 | ||
6b1687bf R |
333 | case QUATERNARY_TDM_RX_0: |
334 | case QUATERNARY_TDM_TX_0: | |
335 | if (--(data->quat_tdm_clk_count) == 0) { | |
336 | snd_soc_dai_set_sysclk(cpu_dai, | |
337 | Q6AFE_LPASS_CLK_ID_QUAD_TDM_IBIT, | |
338 | 0, SNDRV_PCM_STREAM_PLAYBACK); | |
339 | } | |
340 | break; | |
341 | ||
342 | default: | |
343 | pr_err("%s: invalid dai id 0x%x\n", __func__, cpu_dai->id); | |
344 | break; | |
345 | } | |
346 | } | |
347 | ||
ff60005e | 348 | static const struct snd_soc_ops sdm845_be_ops = { |
6b1687bf R |
349 | .hw_params = sdm845_snd_hw_params, |
350 | .startup = sdm845_snd_startup, | |
351 | .shutdown = sdm845_snd_shutdown, | |
352 | }; | |
353 | ||
354 | static int sdm845_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd, | |
355 | struct snd_pcm_hw_params *params) | |
356 | { | |
357 | struct snd_interval *rate = hw_param_interval(params, | |
358 | SNDRV_PCM_HW_PARAM_RATE); | |
359 | struct snd_interval *channels = hw_param_interval(params, | |
360 | SNDRV_PCM_HW_PARAM_CHANNELS); | |
361 | struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); | |
362 | ||
363 | rate->min = rate->max = DEFAULT_SAMPLE_RATE_48K; | |
364 | channels->min = channels->max = 2; | |
365 | snd_mask_set_format(fmt, SNDRV_PCM_FORMAT_S16_LE); | |
366 | ||
367 | return 0; | |
368 | } | |
369 | ||
7f1806eb CYC |
370 | static const struct snd_soc_dapm_widget sdm845_snd_widgets[] = { |
371 | SND_SOC_DAPM_HP("Headphone Jack", NULL), | |
372 | SND_SOC_DAPM_MIC("Headset Mic", NULL), | |
373 | SND_SOC_DAPM_SPK("Left Spk", NULL), | |
374 | SND_SOC_DAPM_SPK("Right Spk", NULL), | |
375 | SND_SOC_DAPM_MIC("Int Mic", NULL), | |
376 | }; | |
377 | ||
80e733fd | 378 | static void sdm845_add_ops(struct snd_soc_card *card) |
6b1687bf | 379 | { |
7fe072b4 KM |
380 | struct snd_soc_dai_link *link; |
381 | int i; | |
6b1687bf | 382 | |
7fe072b4 | 383 | for_each_card_prelinks(card, i, link) { |
6b1687bf R |
384 | if (link->no_pcm == 1) { |
385 | link->ops = &sdm845_be_ops; | |
386 | link->be_hw_params_fixup = sdm845_be_hw_params_fixup; | |
387 | } | |
80e733fd | 388 | link->init = sdm845_dai_init; |
6b1687bf R |
389 | } |
390 | } | |
391 | ||
392 | static int sdm845_snd_platform_probe(struct platform_device *pdev) | |
393 | { | |
394 | struct snd_soc_card *card; | |
395 | struct sdm845_snd_data *data; | |
396 | struct device *dev = &pdev->dev; | |
397 | int ret; | |
398 | ||
399 | card = kzalloc(sizeof(*card), GFP_KERNEL); | |
400 | if (!card) | |
401 | return -ENOMEM; | |
402 | ||
403 | /* Allocate the private data */ | |
404 | data = kzalloc(sizeof(*data), GFP_KERNEL); | |
8530ebf1 GS |
405 | if (!data) { |
406 | ret = -ENOMEM; | |
407 | goto data_alloc_fail; | |
408 | } | |
6b1687bf | 409 | |
7f1806eb CYC |
410 | card->dapm_widgets = sdm845_snd_widgets; |
411 | card->num_dapm_widgets = ARRAY_SIZE(sdm845_snd_widgets); | |
6b1687bf | 412 | card->dev = dev; |
6b1687bf R |
413 | dev_set_drvdata(dev, card); |
414 | ret = qcom_snd_parse_of(card); | |
415 | if (ret) { | |
416 | dev_err(dev, "Error parsing OF data\n"); | |
417 | goto parse_dt_fail; | |
418 | } | |
419 | ||
420 | data->card = card; | |
421 | snd_soc_card_set_drvdata(card, data); | |
422 | ||
80e733fd | 423 | sdm845_add_ops(card); |
6b1687bf R |
424 | ret = snd_soc_register_card(card); |
425 | if (ret) { | |
426 | dev_err(dev, "Sound card registration failed\n"); | |
427 | goto register_card_fail; | |
428 | } | |
429 | return ret; | |
430 | ||
431 | register_card_fail: | |
432 | kfree(card->dai_link); | |
433 | parse_dt_fail: | |
434 | kfree(data); | |
8530ebf1 | 435 | data_alloc_fail: |
6b1687bf R |
436 | kfree(card); |
437 | return ret; | |
438 | } | |
439 | ||
440 | static int sdm845_snd_platform_remove(struct platform_device *pdev) | |
441 | { | |
442 | struct snd_soc_card *card = dev_get_drvdata(&pdev->dev); | |
443 | struct sdm845_snd_data *data = snd_soc_card_get_drvdata(card); | |
444 | ||
6b1687bf R |
445 | snd_soc_unregister_card(card); |
446 | kfree(card->dai_link); | |
447 | kfree(data); | |
448 | kfree(card); | |
449 | return 0; | |
450 | } | |
451 | ||
452 | static const struct of_device_id sdm845_snd_device_id[] = { | |
453 | { .compatible = "qcom,sdm845-sndcard" }, | |
454 | {}, | |
455 | }; | |
456 | MODULE_DEVICE_TABLE(of, sdm845_snd_device_id); | |
457 | ||
458 | static struct platform_driver sdm845_snd_driver = { | |
459 | .probe = sdm845_snd_platform_probe, | |
460 | .remove = sdm845_snd_platform_remove, | |
461 | .driver = { | |
462 | .name = "msm-snd-sdm845", | |
463 | .of_match_table = sdm845_snd_device_id, | |
464 | }, | |
465 | }; | |
466 | module_platform_driver(sdm845_snd_driver); | |
467 | ||
468 | MODULE_DESCRIPTION("sdm845 ASoC Machine Driver"); | |
469 | MODULE_LICENSE("GPL v2"); |