1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) 2020, Linaro Limited
4 #include <linux/module.h>
5 #include <linux/platform_device.h>
6 #include <linux/of_device.h>
8 #include <sound/soc-dapm.h>
10 #include <linux/soundwire/sdw.h>
11 #include <sound/jack.h>
12 #include <linux/input-event-codes.h>
13 #include "qdsp6/q6afe.h"
16 #define DRIVER_NAME "sm8250"
17 #define MI2S_BCLK_RATE 1536000
19 struct sm8250_snd_data
{
20 bool stream_prepared
[AFE_PORT_MAX
];
21 struct snd_soc_card
*card
;
22 struct sdw_stream_runtime
*sruntime
[AFE_PORT_MAX
];
23 struct snd_soc_jack jack
;
27 static int sm8250_snd_init(struct snd_soc_pcm_runtime
*rtd
)
29 struct sm8250_snd_data
*data
= snd_soc_card_get_drvdata(rtd
->card
);
30 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
31 struct snd_soc_dai
*codec_dai
= asoc_rtd_to_codec(rtd
, 0);
32 struct snd_soc_card
*card
= rtd
->card
;
35 if (!data
->jack_setup
) {
36 struct snd_jack
*jack
;
38 rval
= snd_soc_card_jack_new(card
, "Headset Jack",
39 SND_JACK_HEADSET
| SND_JACK_LINEOUT
|
41 SND_JACK_BTN_0
| SND_JACK_BTN_1
|
42 SND_JACK_BTN_2
| SND_JACK_BTN_3
|
43 SND_JACK_BTN_4
| SND_JACK_BTN_5
,
47 dev_err(card
->dev
, "Unable to add Headphone Jack\n");
51 jack
= data
->jack
.jack
;
53 snd_jack_set_key(jack
, SND_JACK_BTN_0
, KEY_MEDIA
);
54 snd_jack_set_key(jack
, SND_JACK_BTN_1
, KEY_VOICECOMMAND
);
55 snd_jack_set_key(jack
, SND_JACK_BTN_2
, KEY_VOLUMEUP
);
56 snd_jack_set_key(jack
, SND_JACK_BTN_3
, KEY_VOLUMEDOWN
);
57 data
->jack_setup
= true;
60 switch (cpu_dai
->id
) {
61 case TX_CODEC_DMA_TX_0
:
62 case TX_CODEC_DMA_TX_1
:
63 case TX_CODEC_DMA_TX_2
:
64 case TX_CODEC_DMA_TX_3
:
65 for_each_rtd_codec_dais(rtd
, i
, codec_dai
) {
66 rval
= snd_soc_component_set_jack(codec_dai
->component
,
68 if (rval
!= 0 && rval
!= -ENOTSUPP
) {
69 dev_warn(card
->dev
, "Failed to set jack: %d\n", rval
);
83 static int sm8250_be_hw_params_fixup(struct snd_soc_pcm_runtime
*rtd
,
84 struct snd_pcm_hw_params
*params
)
86 struct snd_interval
*rate
= hw_param_interval(params
,
87 SNDRV_PCM_HW_PARAM_RATE
);
88 struct snd_interval
*channels
= hw_param_interval(params
,
89 SNDRV_PCM_HW_PARAM_CHANNELS
);
91 rate
->min
= rate
->max
= 48000;
92 channels
->min
= channels
->max
= 2;
97 static int sm8250_snd_startup(struct snd_pcm_substream
*substream
)
99 unsigned int fmt
= SND_SOC_DAIFMT_BP_FP
;
100 unsigned int codec_dai_fmt
= SND_SOC_DAIFMT_BC_FC
;
101 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
102 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
103 struct snd_soc_dai
*codec_dai
= asoc_rtd_to_codec(rtd
, 0);
105 switch (cpu_dai
->id
) {
106 case TERTIARY_MI2S_RX
:
107 codec_dai_fmt
|= SND_SOC_DAIFMT_NB_NF
| SND_SOC_DAIFMT_I2S
;
108 snd_soc_dai_set_sysclk(cpu_dai
,
109 Q6AFE_LPASS_CLK_ID_TER_MI2S_IBIT
,
110 MI2S_BCLK_RATE
, SNDRV_PCM_STREAM_PLAYBACK
);
111 snd_soc_dai_set_fmt(cpu_dai
, fmt
);
112 snd_soc_dai_set_fmt(codec_dai
, codec_dai_fmt
);
120 static int sm8250_snd_hw_params(struct snd_pcm_substream
*substream
,
121 struct snd_pcm_hw_params
*params
)
123 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
124 struct snd_soc_dai
*codec_dai
;
125 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
126 struct sm8250_snd_data
*pdata
= snd_soc_card_get_drvdata(rtd
->card
);
127 struct sdw_stream_runtime
*sruntime
;
130 switch (cpu_dai
->id
) {
131 case WSA_CODEC_DMA_RX_0
:
132 case RX_CODEC_DMA_RX_0
:
133 case RX_CODEC_DMA_RX_1
:
134 case TX_CODEC_DMA_TX_0
:
135 case TX_CODEC_DMA_TX_1
:
136 case TX_CODEC_DMA_TX_2
:
137 case TX_CODEC_DMA_TX_3
:
138 for_each_rtd_codec_dais(rtd
, i
, codec_dai
) {
139 sruntime
= snd_soc_dai_get_stream(codec_dai
,
141 if (sruntime
!= ERR_PTR(-ENOTSUPP
))
142 pdata
->sruntime
[cpu_dai
->id
] = sruntime
;
151 static int sm8250_snd_wsa_dma_prepare(struct snd_pcm_substream
*substream
)
153 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
154 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
155 struct sm8250_snd_data
*data
= snd_soc_card_get_drvdata(rtd
->card
);
156 struct sdw_stream_runtime
*sruntime
= data
->sruntime
[cpu_dai
->id
];
162 if (data
->stream_prepared
[cpu_dai
->id
]) {
163 sdw_disable_stream(sruntime
);
164 sdw_deprepare_stream(sruntime
);
165 data
->stream_prepared
[cpu_dai
->id
] = false;
168 ret
= sdw_prepare_stream(sruntime
);
173 * NOTE: there is a strict hw requirement about the ordering of port
174 * enables and actual WSA881x PA enable. PA enable should only happen
175 * after soundwire ports are enabled if not DC on the line is
176 * accumulated resulting in Click/Pop Noise
177 * PA enable/mute are handled as part of codec DAPM and digital mute.
180 ret
= sdw_enable_stream(sruntime
);
182 sdw_deprepare_stream(sruntime
);
185 data
->stream_prepared
[cpu_dai
->id
] = true;
190 static int sm8250_snd_prepare(struct snd_pcm_substream
*substream
)
192 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
193 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
195 switch (cpu_dai
->id
) {
196 case WSA_CODEC_DMA_RX_0
:
197 case WSA_CODEC_DMA_RX_1
:
198 case RX_CODEC_DMA_RX_0
:
199 case RX_CODEC_DMA_RX_1
:
200 case TX_CODEC_DMA_TX_0
:
201 case TX_CODEC_DMA_TX_1
:
202 case TX_CODEC_DMA_TX_2
:
203 case TX_CODEC_DMA_TX_3
:
204 return sm8250_snd_wsa_dma_prepare(substream
);
212 static int sm8250_snd_hw_free(struct snd_pcm_substream
*substream
)
214 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
215 struct sm8250_snd_data
*data
= snd_soc_card_get_drvdata(rtd
->card
);
216 struct snd_soc_dai
*cpu_dai
= asoc_rtd_to_cpu(rtd
, 0);
217 struct sdw_stream_runtime
*sruntime
= data
->sruntime
[cpu_dai
->id
];
219 switch (cpu_dai
->id
) {
220 case WSA_CODEC_DMA_RX_0
:
221 case WSA_CODEC_DMA_RX_1
:
222 case RX_CODEC_DMA_RX_0
:
223 case RX_CODEC_DMA_RX_1
:
224 case TX_CODEC_DMA_TX_0
:
225 case TX_CODEC_DMA_TX_1
:
226 case TX_CODEC_DMA_TX_2
:
227 case TX_CODEC_DMA_TX_3
:
228 if (sruntime
&& data
->stream_prepared
[cpu_dai
->id
]) {
229 sdw_disable_stream(sruntime
);
230 sdw_deprepare_stream(sruntime
);
231 data
->stream_prepared
[cpu_dai
->id
] = false;
241 static const struct snd_soc_ops sm8250_be_ops
= {
242 .startup
= sm8250_snd_startup
,
243 .hw_params
= sm8250_snd_hw_params
,
244 .hw_free
= sm8250_snd_hw_free
,
245 .prepare
= sm8250_snd_prepare
,
248 static void sm8250_add_be_ops(struct snd_soc_card
*card
)
250 struct snd_soc_dai_link
*link
;
253 for_each_card_prelinks(card
, i
, link
) {
254 if (link
->no_pcm
== 1) {
255 link
->init
= sm8250_snd_init
;
256 link
->be_hw_params_fixup
= sm8250_be_hw_params_fixup
;
257 link
->ops
= &sm8250_be_ops
;
262 static int sm8250_platform_probe(struct platform_device
*pdev
)
264 struct snd_soc_card
*card
;
265 struct sm8250_snd_data
*data
;
266 struct device
*dev
= &pdev
->dev
;
269 card
= devm_kzalloc(dev
, sizeof(*card
), GFP_KERNEL
);
273 card
->owner
= THIS_MODULE
;
274 /* Allocate the private data */
275 data
= devm_kzalloc(dev
, sizeof(*data
), GFP_KERNEL
);
280 dev_set_drvdata(dev
, card
);
281 snd_soc_card_set_drvdata(card
, data
);
282 ret
= qcom_snd_parse_of(card
);
286 card
->driver_name
= DRIVER_NAME
;
287 sm8250_add_be_ops(card
);
288 return devm_snd_soc_register_card(dev
, card
);
291 static const struct of_device_id snd_sm8250_dt_match
[] = {
292 {.compatible
= "qcom,sm8250-sndcard"},
293 {.compatible
= "qcom,qrb5165-rb5-sndcard"},
297 MODULE_DEVICE_TABLE(of
, snd_sm8250_dt_match
);
299 static struct platform_driver snd_sm8250_driver
= {
300 .probe
= sm8250_platform_probe
,
302 .name
= "snd-sm8250",
303 .of_match_table
= snd_sm8250_dt_match
,
306 module_platform_driver(snd_sm8250_driver
);
307 MODULE_AUTHOR("Srinivas Kandagatla <srinivas.kandagatla@linaro.org");
308 MODULE_DESCRIPTION("SM8250 ASoC Machine Driver");
309 MODULE_LICENSE("GPL v2");