1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (c) 2018, The Linux Foundation. All rights reserved.
6 #include <linux/module.h>
7 #include <linux/platform_device.h>
8 #include <linux/of_device.h>
9 #include <sound/core.h>
10 #include <sound/pcm.h>
11 #include <sound/pcm_params.h>
12 #include <sound/jack.h>
13 #include <sound/soc.h>
14 #include <linux/soundwire/sdw.h>
15 #include <uapi/linux/input-event-codes.h>
17 #include "qdsp6/q6afe.h"
18 #include "../codecs/rt5663.h"
20 #define DRIVER_NAME "sdm845"
21 #define DEFAULT_SAMPLE_RATE_48K 48000
22 #define DEFAULT_MCLK_RATE 24576000
23 #define TDM_BCLK_RATE 6144000
24 #define MI2S_BCLK_RATE 1536000
25 #define LEFT_SPK_TDM_TX_MASK 0x30
26 #define RIGHT_SPK_TDM_TX_MASK 0xC0
27 #define SPK_TDM_RX_MASK 0x03
28 #define NUM_TDM_SLOTS 8
29 #define SLIM_MAX_TX_PORTS 16
30 #define SLIM_MAX_RX_PORTS 16
31 #define WCD934X_DEFAULT_MCLK_RATE 9600000
33 struct sdm845_snd_data
{
34 struct snd_soc_jack jack
;
36 bool stream_prepared
[SLIM_MAX_RX_PORTS
];
37 struct snd_soc_card
*card
;
38 uint32_t pri_mi2s_clk_count
;
39 uint32_t sec_mi2s_clk_count
;
40 uint32_t quat_tdm_clk_count
;
41 struct sdw_stream_runtime
*sruntime
[SLIM_MAX_RX_PORTS
];
44 static unsigned int tdm_slot_offset
[8] = {0, 4, 8, 12, 16, 20, 24, 28};
46 static int sdm845_slim_snd_hw_params(struct snd_pcm_substream
*substream
,
47 struct snd_pcm_hw_params
*params
)
49 struct snd_soc_pcm_runtime
*rtd
= asoc_substream_to_rtd(substream
);
50 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
51 struct snd_soc_dai
*codec_dai
;
52 struct sdm845_snd_data
*pdata
= snd_soc_card_get_drvdata(rtd
->card
);
53 u32 rx_ch
[SLIM_MAX_RX_PORTS
], tx_ch
[SLIM_MAX_TX_PORTS
];
54 struct sdw_stream_runtime
*sruntime
;
55 u32 rx_ch_cnt
= 0, tx_ch_cnt
= 0;
58 for_each_rtd_codec_dais(rtd
, i
, codec_dai
) {
59 sruntime
= snd_soc_dai_get_sdw_stream(codec_dai
,
61 if (sruntime
!= ERR_PTR(-ENOTSUPP
))
62 pdata
->sruntime
[cpu_dai
->id
] = sruntime
;
64 ret
= snd_soc_dai_get_channel_map(codec_dai
,
65 &tx_ch_cnt
, tx_ch
, &rx_ch_cnt
, rx_ch
);
67 if (ret
!= 0 && ret
!= -ENOTSUPP
) {
68 pr_err("failed to get codec chan map, err:%d\n", ret
);
70 } else if (ret
== -ENOTSUPP
) {
71 /* Ignore unsupported */
75 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
76 ret
= snd_soc_dai_set_channel_map(cpu_dai
, 0, NULL
,
79 ret
= snd_soc_dai_set_channel_map(cpu_dai
, tx_ch_cnt
,
86 static int sdm845_tdm_snd_hw_params(struct snd_pcm_substream
*substream
,
87 struct snd_pcm_hw_params
*params
)
89 struct snd_soc_pcm_runtime
*rtd
= asoc_substream_to_rtd(substream
);
90 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
91 struct snd_soc_dai
*codec_dai
;
93 int channels
, slot_width
;
95 switch (params_format(params
)) {
96 case SNDRV_PCM_FORMAT_S16_LE
:
100 dev_err(rtd
->dev
, "%s: invalid param format 0x%x\n",
101 __func__
, params_format(params
));
105 channels
= params_channels(params
);
106 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
107 ret
= snd_soc_dai_set_tdm_slot(cpu_dai
, 0, 0x3,
110 dev_err(rtd
->dev
, "%s: failed to set tdm slot, err:%d\n",
115 ret
= snd_soc_dai_set_channel_map(cpu_dai
, 0, NULL
,
116 channels
, tdm_slot_offset
);
118 dev_err(rtd
->dev
, "%s: failed to set channel map, err:%d\n",
123 ret
= snd_soc_dai_set_tdm_slot(cpu_dai
, 0xf, 0,
126 dev_err(rtd
->dev
, "%s: failed to set tdm slot, err:%d\n",
131 ret
= snd_soc_dai_set_channel_map(cpu_dai
, channels
,
132 tdm_slot_offset
, 0, NULL
);
134 dev_err(rtd
->dev
, "%s: failed to set channel map, err:%d\n",
140 for_each_rtd_codec_dais(rtd
, j
, codec_dai
) {
142 if (!strcmp(codec_dai
->component
->name_prefix
, "Left")) {
143 ret
= snd_soc_dai_set_tdm_slot(
144 codec_dai
, LEFT_SPK_TDM_TX_MASK
,
145 SPK_TDM_RX_MASK
, NUM_TDM_SLOTS
,
149 "DEV0 TDM slot err:%d\n", ret
);
154 if (!strcmp(codec_dai
->component
->name_prefix
, "Right")) {
155 ret
= snd_soc_dai_set_tdm_slot(
156 codec_dai
, RIGHT_SPK_TDM_TX_MASK
,
157 SPK_TDM_RX_MASK
, NUM_TDM_SLOTS
,
161 "DEV1 TDM slot err:%d\n", ret
);
171 static int sdm845_snd_hw_params(struct snd_pcm_substream
*substream
,
172 struct snd_pcm_hw_params
*params
)
174 struct snd_soc_pcm_runtime
*rtd
= asoc_substream_to_rtd(substream
);
175 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
176 struct snd_soc_dai
*codec_dai
= asoc_rtd_to_codec(rtd
, 0);
179 switch (cpu_dai
->id
) {
180 case PRIMARY_MI2S_RX
:
181 case PRIMARY_MI2S_TX
:
183 * Use ASRC for internal clocks, as PLL rate isn't multiple
186 rt5663_sel_asrc_clk_src(
187 codec_dai
->component
,
188 RT5663_DA_STEREO_FILTER
| RT5663_AD_STEREO_FILTER
,
189 RT5663_CLK_SEL_I2S1_ASRC
);
190 ret
= snd_soc_dai_set_sysclk(
191 codec_dai
, RT5663_SCLK_S_MCLK
, DEFAULT_MCLK_RATE
,
195 "snd_soc_dai_set_sysclk err = %d\n", ret
);
197 case QUATERNARY_TDM_RX_0
:
198 case QUATERNARY_TDM_TX_0
:
199 ret
= sdm845_tdm_snd_hw_params(substream
, params
);
201 case SLIMBUS_0_RX
...SLIMBUS_6_TX
:
202 ret
= sdm845_slim_snd_hw_params(substream
, params
);
204 case QUATERNARY_MI2S_RX
:
207 pr_err("%s: invalid dai id 0x%x\n", __func__
, cpu_dai
->id
);
213 static void sdm845_jack_free(struct snd_jack
*jack
)
215 struct snd_soc_component
*component
= jack
->private_data
;
217 snd_soc_component_set_jack(component
, NULL
, NULL
);
220 static int sdm845_dai_init(struct snd_soc_pcm_runtime
*rtd
)
222 struct snd_soc_component
*component
;
223 struct snd_soc_card
*card
= rtd
->card
;
224 struct snd_soc_dai
*codec_dai
= asoc_rtd_to_codec(rtd
, 0);
225 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
226 struct sdm845_snd_data
*pdata
= snd_soc_card_get_drvdata(card
);
227 struct snd_jack
*jack
;
229 * Codec SLIMBUS configuration
230 * RX1, RX2, RX3, RX4, RX5, RX6, RX7, RX8, RX9, RX10, RX11, RX12, RX13
231 * TX1, TX2, TX3, TX4, TX5, TX6, TX7, TX8, TX9, TX10, TX11, TX12, TX13
234 unsigned int rx_ch
[SLIM_MAX_RX_PORTS
] = {144, 145, 146, 147, 148, 149,
235 150, 151, 152, 153, 154, 155, 156};
236 unsigned int tx_ch
[SLIM_MAX_TX_PORTS
] = {128, 129, 130, 131, 132, 133,
237 134, 135, 136, 137, 138, 139,
242 if (!pdata
->jack_setup
) {
243 rval
= snd_soc_card_jack_new(card
, "Headset Jack",
246 SND_JACK_BTN_0
| SND_JACK_BTN_1
|
247 SND_JACK_BTN_2
| SND_JACK_BTN_3
,
248 &pdata
->jack
, NULL
, 0);
251 dev_err(card
->dev
, "Unable to add Headphone Jack\n");
255 jack
= pdata
->jack
.jack
;
257 snd_jack_set_key(jack
, SND_JACK_BTN_0
, KEY_PLAYPAUSE
);
258 snd_jack_set_key(jack
, SND_JACK_BTN_1
, KEY_VOICECOMMAND
);
259 snd_jack_set_key(jack
, SND_JACK_BTN_2
, KEY_VOLUMEUP
);
260 snd_jack_set_key(jack
, SND_JACK_BTN_3
, KEY_VOLUMEDOWN
);
261 pdata
->jack_setup
= true;
264 switch (cpu_dai
->id
) {
265 case PRIMARY_MI2S_RX
:
266 jack
= pdata
->jack
.jack
;
267 component
= codec_dai
->component
;
269 jack
->private_data
= component
;
270 jack
->private_free
= sdm845_jack_free
;
271 rval
= snd_soc_component_set_jack(component
,
273 if (rval
!= 0 && rval
!= -ENOTSUPP
) {
274 dev_warn(card
->dev
, "Failed to set jack: %d\n", rval
);
278 case SLIMBUS_0_RX
...SLIMBUS_6_TX
:
279 for_each_rtd_codec_dais(rtd
, i
, codec_dai
) {
280 rval
= snd_soc_dai_set_channel_map(codec_dai
,
285 if (rval
!= 0 && rval
!= -ENOTSUPP
)
288 snd_soc_dai_set_sysclk(codec_dai
, 0,
289 WCD934X_DEFAULT_MCLK_RATE
,
290 SNDRV_PCM_STREAM_PLAYBACK
);
301 static int sdm845_snd_startup(struct snd_pcm_substream
*substream
)
303 unsigned int fmt
= SND_SOC_DAIFMT_CBS_CFS
;
304 unsigned int codec_dai_fmt
= SND_SOC_DAIFMT_CBS_CFS
;
305 struct snd_soc_pcm_runtime
*rtd
= asoc_substream_to_rtd(substream
);
306 struct snd_soc_card
*card
= rtd
->card
;
307 struct sdm845_snd_data
*data
= snd_soc_card_get_drvdata(card
);
308 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
309 struct snd_soc_dai
*codec_dai
= asoc_rtd_to_codec(rtd
, 0);
313 switch (cpu_dai
->id
) {
314 case PRIMARY_MI2S_RX
:
315 case PRIMARY_MI2S_TX
:
316 codec_dai_fmt
|= SND_SOC_DAIFMT_NB_NF
;
317 if (++(data
->pri_mi2s_clk_count
) == 1) {
318 snd_soc_dai_set_sysclk(cpu_dai
,
319 Q6AFE_LPASS_CLK_ID_MCLK_1
,
320 DEFAULT_MCLK_RATE
, SNDRV_PCM_STREAM_PLAYBACK
);
321 snd_soc_dai_set_sysclk(cpu_dai
,
322 Q6AFE_LPASS_CLK_ID_PRI_MI2S_IBIT
,
323 MI2S_BCLK_RATE
, SNDRV_PCM_STREAM_PLAYBACK
);
325 snd_soc_dai_set_fmt(cpu_dai
, fmt
);
326 snd_soc_dai_set_fmt(codec_dai
, codec_dai_fmt
);
329 case SECONDARY_MI2S_TX
:
330 codec_dai_fmt
|= SND_SOC_DAIFMT_NB_NF
| SND_SOC_DAIFMT_I2S
;
331 if (++(data
->sec_mi2s_clk_count
) == 1) {
332 snd_soc_dai_set_sysclk(cpu_dai
,
333 Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT
,
334 MI2S_BCLK_RATE
, SNDRV_PCM_STREAM_CAPTURE
);
336 snd_soc_dai_set_fmt(cpu_dai
, fmt
);
337 snd_soc_dai_set_fmt(codec_dai
, codec_dai_fmt
);
339 case QUATERNARY_MI2S_RX
:
340 snd_soc_dai_set_sysclk(cpu_dai
,
341 Q6AFE_LPASS_CLK_ID_QUAD_MI2S_IBIT
,
342 MI2S_BCLK_RATE
, SNDRV_PCM_STREAM_PLAYBACK
);
343 snd_soc_dai_set_fmt(cpu_dai
, SND_SOC_DAIFMT_CBS_CFS
);
348 case QUATERNARY_TDM_RX_0
:
349 case QUATERNARY_TDM_TX_0
:
350 if (++(data
->quat_tdm_clk_count
) == 1) {
351 snd_soc_dai_set_sysclk(cpu_dai
,
352 Q6AFE_LPASS_CLK_ID_QUAD_TDM_IBIT
,
353 TDM_BCLK_RATE
, SNDRV_PCM_STREAM_PLAYBACK
);
356 codec_dai_fmt
|= SND_SOC_DAIFMT_IB_NF
| SND_SOC_DAIFMT_DSP_B
;
358 for_each_rtd_codec_dais(rtd
, j
, codec_dai
) {
360 if (!strcmp(codec_dai
->component
->name_prefix
,
362 ret
= snd_soc_dai_set_fmt(
363 codec_dai
, codec_dai_fmt
);
366 "Left TDM fmt err:%d\n", ret
);
371 if (!strcmp(codec_dai
->component
->name_prefix
,
373 ret
= snd_soc_dai_set_fmt(
374 codec_dai
, codec_dai_fmt
);
377 "Right TDM slot err:%d\n", ret
);
383 case SLIMBUS_0_RX
...SLIMBUS_6_TX
:
387 pr_err("%s: invalid dai id 0x%x\n", __func__
, cpu_dai
->id
);
393 static void sdm845_snd_shutdown(struct snd_pcm_substream
*substream
)
395 struct snd_soc_pcm_runtime
*rtd
= asoc_substream_to_rtd(substream
);
396 struct snd_soc_card
*card
= rtd
->card
;
397 struct sdm845_snd_data
*data
= snd_soc_card_get_drvdata(card
);
398 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
400 switch (cpu_dai
->id
) {
401 case PRIMARY_MI2S_RX
:
402 case PRIMARY_MI2S_TX
:
403 if (--(data
->pri_mi2s_clk_count
) == 0) {
404 snd_soc_dai_set_sysclk(cpu_dai
,
405 Q6AFE_LPASS_CLK_ID_MCLK_1
,
406 0, SNDRV_PCM_STREAM_PLAYBACK
);
407 snd_soc_dai_set_sysclk(cpu_dai
,
408 Q6AFE_LPASS_CLK_ID_PRI_MI2S_IBIT
,
409 0, SNDRV_PCM_STREAM_PLAYBACK
);
413 case SECONDARY_MI2S_TX
:
414 if (--(data
->sec_mi2s_clk_count
) == 0) {
415 snd_soc_dai_set_sysclk(cpu_dai
,
416 Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT
,
417 0, SNDRV_PCM_STREAM_CAPTURE
);
421 case QUATERNARY_TDM_RX_0
:
422 case QUATERNARY_TDM_TX_0
:
423 if (--(data
->quat_tdm_clk_count
) == 0) {
424 snd_soc_dai_set_sysclk(cpu_dai
,
425 Q6AFE_LPASS_CLK_ID_QUAD_TDM_IBIT
,
426 0, SNDRV_PCM_STREAM_PLAYBACK
);
429 case SLIMBUS_0_RX
...SLIMBUS_6_TX
:
430 case QUATERNARY_MI2S_RX
:
434 pr_err("%s: invalid dai id 0x%x\n", __func__
, cpu_dai
->id
);
439 static int sdm845_snd_prepare(struct snd_pcm_substream
*substream
)
441 struct snd_soc_pcm_runtime
*rtd
= asoc_substream_to_rtd(substream
);
442 struct sdm845_snd_data
*data
= snd_soc_card_get_drvdata(rtd
->card
);
443 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
444 struct sdw_stream_runtime
*sruntime
= data
->sruntime
[cpu_dai
->id
];
450 if (data
->stream_prepared
[cpu_dai
->id
]) {
451 sdw_disable_stream(sruntime
);
452 sdw_deprepare_stream(sruntime
);
453 data
->stream_prepared
[cpu_dai
->id
] = false;
456 ret
= sdw_prepare_stream(sruntime
);
461 * NOTE: there is a strict hw requirement about the ordering of port
462 * enables and actual WSA881x PA enable. PA enable should only happen
463 * after soundwire ports are enabled if not DC on the line is
464 * accumulated resulting in Click/Pop Noise
465 * PA enable/mute are handled as part of codec DAPM and digital mute.
468 ret
= sdw_enable_stream(sruntime
);
470 sdw_deprepare_stream(sruntime
);
473 data
->stream_prepared
[cpu_dai
->id
] = true;
478 static int sdm845_snd_hw_free(struct snd_pcm_substream
*substream
)
480 struct snd_soc_pcm_runtime
*rtd
= asoc_substream_to_rtd(substream
);
481 struct sdm845_snd_data
*data
= snd_soc_card_get_drvdata(rtd
->card
);
482 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
483 struct sdw_stream_runtime
*sruntime
= data
->sruntime
[cpu_dai
->id
];
485 if (sruntime
&& data
->stream_prepared
[cpu_dai
->id
]) {
486 sdw_disable_stream(sruntime
);
487 sdw_deprepare_stream(sruntime
);
488 data
->stream_prepared
[cpu_dai
->id
] = false;
494 static const struct snd_soc_ops sdm845_be_ops
= {
495 .hw_params
= sdm845_snd_hw_params
,
496 .hw_free
= sdm845_snd_hw_free
,
497 .prepare
= sdm845_snd_prepare
,
498 .startup
= sdm845_snd_startup
,
499 .shutdown
= sdm845_snd_shutdown
,
502 static int sdm845_be_hw_params_fixup(struct snd_soc_pcm_runtime
*rtd
,
503 struct snd_pcm_hw_params
*params
)
505 struct snd_interval
*rate
= hw_param_interval(params
,
506 SNDRV_PCM_HW_PARAM_RATE
);
507 struct snd_interval
*channels
= hw_param_interval(params
,
508 SNDRV_PCM_HW_PARAM_CHANNELS
);
509 struct snd_mask
*fmt
= hw_param_mask(params
, SNDRV_PCM_HW_PARAM_FORMAT
);
511 rate
->min
= rate
->max
= DEFAULT_SAMPLE_RATE_48K
;
512 channels
->min
= channels
->max
= 2;
513 snd_mask_set_format(fmt
, SNDRV_PCM_FORMAT_S16_LE
);
518 static const struct snd_soc_dapm_widget sdm845_snd_widgets
[] = {
519 SND_SOC_DAPM_HP("Headphone Jack", NULL
),
520 SND_SOC_DAPM_MIC("Headset Mic", NULL
),
521 SND_SOC_DAPM_SPK("Left Spk", NULL
),
522 SND_SOC_DAPM_SPK("Right Spk", NULL
),
523 SND_SOC_DAPM_MIC("Int Mic", NULL
),
526 static void sdm845_add_ops(struct snd_soc_card
*card
)
528 struct snd_soc_dai_link
*link
;
531 for_each_card_prelinks(card
, i
, link
) {
532 if (link
->no_pcm
== 1) {
533 link
->ops
= &sdm845_be_ops
;
534 link
->be_hw_params_fixup
= sdm845_be_hw_params_fixup
;
536 link
->init
= sdm845_dai_init
;
540 static int sdm845_snd_platform_probe(struct platform_device
*pdev
)
542 struct snd_soc_card
*card
;
543 struct sdm845_snd_data
*data
;
544 struct device
*dev
= &pdev
->dev
;
547 card
= devm_kzalloc(dev
, sizeof(*card
), GFP_KERNEL
);
551 /* Allocate the private data */
552 data
= devm_kzalloc(dev
, sizeof(*data
), GFP_KERNEL
);
556 card
->driver_name
= DRIVER_NAME
;
557 card
->dapm_widgets
= sdm845_snd_widgets
;
558 card
->num_dapm_widgets
= ARRAY_SIZE(sdm845_snd_widgets
);
560 card
->owner
= THIS_MODULE
;
561 dev_set_drvdata(dev
, card
);
562 ret
= qcom_snd_parse_of(card
);
567 snd_soc_card_set_drvdata(card
, data
);
569 sdm845_add_ops(card
);
570 return devm_snd_soc_register_card(dev
, card
);
573 static const struct of_device_id sdm845_snd_device_id
[] = {
574 { .compatible
= "qcom,sdm845-sndcard" },
575 { .compatible
= "qcom,db845c-sndcard" },
576 { .compatible
= "lenovo,yoga-c630-sndcard" },
579 MODULE_DEVICE_TABLE(of
, sdm845_snd_device_id
);
581 static struct platform_driver sdm845_snd_driver
= {
582 .probe
= sdm845_snd_platform_probe
,
584 .name
= "msm-snd-sdm845",
585 .of_match_table
= sdm845_snd_device_id
,
588 module_platform_driver(sdm845_snd_driver
);
590 MODULE_DESCRIPTION("sdm845 ASoC Machine Driver");
591 MODULE_LICENSE("GPL v2");