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