0001
0002
0003
0004
0005
0006
0007 #include <linux/input.h>
0008 #include <linux/module.h>
0009 #include <linux/of_device.h>
0010 #include <linux/platform_device.h>
0011 #include <sound/core.h>
0012 #include <sound/jack.h>
0013 #include <sound/pcm.h>
0014 #include <sound/soc.h>
0015 #include <sound/rt5682s.h>
0016 #include <linux/soundwire/sdw.h>
0017
0018 #include "../codecs/rt5682.h"
0019 #include "../codecs/rt5682s.h"
0020 #include "common.h"
0021 #include "lpass.h"
0022 #include "qdsp6/q6afe.h"
0023
0024 #define DEFAULT_MCLK_RATE 19200000
0025 #define RT5682_PLL_FREQ (48000 * 512)
0026 #define MI2S_BCLK_RATE 1536000
0027
0028 struct sc7280_snd_data {
0029 struct snd_soc_card card;
0030 struct sdw_stream_runtime *sruntime[LPASS_MAX_PORTS];
0031 u32 pri_mi2s_clk_count;
0032 struct snd_soc_jack hs_jack;
0033 struct snd_soc_jack hdmi_jack;
0034 bool jack_setup;
0035 bool stream_prepared[LPASS_MAX_PORTS];
0036 };
0037
0038 static void sc7280_jack_free(struct snd_jack *jack)
0039 {
0040 struct snd_soc_component *component = jack->private_data;
0041
0042 snd_soc_component_set_jack(component, NULL, NULL);
0043 }
0044
0045 static int sc7280_headset_init(struct snd_soc_pcm_runtime *rtd)
0046 {
0047 struct snd_soc_card *card = rtd->card;
0048 struct sc7280_snd_data *pdata = snd_soc_card_get_drvdata(card);
0049 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
0050 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
0051 struct snd_soc_component *component = codec_dai->component;
0052 struct snd_jack *jack;
0053 int rval, i;
0054
0055 if (!pdata->jack_setup) {
0056 rval = snd_soc_card_jack_new(card, "Headset Jack",
0057 SND_JACK_HEADSET | SND_JACK_LINEOUT |
0058 SND_JACK_MECHANICAL |
0059 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
0060 SND_JACK_BTN_2 | SND_JACK_BTN_3 |
0061 SND_JACK_BTN_4 | SND_JACK_BTN_5,
0062 &pdata->hs_jack);
0063
0064 if (rval < 0) {
0065 dev_err(card->dev, "Unable to add Headset Jack\n");
0066 return rval;
0067 }
0068
0069 jack = pdata->hs_jack.jack;
0070
0071 snd_jack_set_key(jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
0072 snd_jack_set_key(jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
0073 snd_jack_set_key(jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
0074 snd_jack_set_key(jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
0075
0076 jack->private_data = component;
0077 jack->private_free = sc7280_jack_free;
0078 pdata->jack_setup = true;
0079 }
0080 switch (cpu_dai->id) {
0081 case MI2S_PRIMARY:
0082 case LPASS_CDC_DMA_RX0:
0083 case LPASS_CDC_DMA_TX3:
0084 case TX_CODEC_DMA_TX_3:
0085 for_each_rtd_codec_dais(rtd, i, codec_dai) {
0086 rval = snd_soc_component_set_jack(component, &pdata->hs_jack, NULL);
0087 if (rval != 0 && rval != -ENOTSUPP) {
0088 dev_err(card->dev, "Failed to set jack: %d\n", rval);
0089 return rval;
0090 }
0091 }
0092 break;
0093 default:
0094 break;
0095 }
0096
0097 return 0;
0098 }
0099
0100 static int sc7280_hdmi_init(struct snd_soc_pcm_runtime *rtd)
0101 {
0102 struct snd_soc_card *card = rtd->card;
0103 struct sc7280_snd_data *pdata = snd_soc_card_get_drvdata(card);
0104 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
0105 struct snd_soc_component *component = codec_dai->component;
0106 struct snd_jack *jack;
0107 int rval;
0108
0109 rval = snd_soc_card_jack_new(card, "HDMI Jack", SND_JACK_LINEOUT,
0110 &pdata->hdmi_jack);
0111
0112 if (rval < 0) {
0113 dev_err(card->dev, "Unable to add HDMI Jack\n");
0114 return rval;
0115 }
0116
0117 jack = pdata->hdmi_jack.jack;
0118 jack->private_data = component;
0119 jack->private_free = sc7280_jack_free;
0120
0121 return snd_soc_component_set_jack(component, &pdata->hdmi_jack, NULL);
0122 }
0123
0124 static int sc7280_rt5682_init(struct snd_soc_pcm_runtime *rtd)
0125 {
0126 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
0127 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
0128 struct snd_soc_card *card = rtd->card;
0129 struct sc7280_snd_data *data = snd_soc_card_get_drvdata(card);
0130 int ret;
0131
0132 if (++data->pri_mi2s_clk_count == 1) {
0133 snd_soc_dai_set_sysclk(cpu_dai,
0134 LPASS_MCLK0,
0135 DEFAULT_MCLK_RATE,
0136 SNDRV_PCM_STREAM_PLAYBACK);
0137 }
0138 snd_soc_dai_set_fmt(codec_dai,
0139 SND_SOC_DAIFMT_CBC_CFC |
0140 SND_SOC_DAIFMT_NB_NF |
0141 SND_SOC_DAIFMT_I2S);
0142
0143 ret = snd_soc_dai_set_pll(codec_dai, RT5682S_PLL2, RT5682S_PLL_S_MCLK,
0144 DEFAULT_MCLK_RATE, RT5682_PLL_FREQ);
0145 if (ret) {
0146 dev_err(rtd->dev, "can't set codec pll: %d\n", ret);
0147 return ret;
0148 }
0149
0150 ret = snd_soc_dai_set_sysclk(codec_dai, RT5682S_SCLK_S_PLL2,
0151 RT5682_PLL_FREQ,
0152 SND_SOC_CLOCK_IN);
0153
0154 if (ret) {
0155 dev_err(rtd->dev, "snd_soc_dai_set_sysclk err = %d\n",
0156 ret);
0157 return ret;
0158 }
0159
0160 return 0;
0161 }
0162
0163 static int sc7280_init(struct snd_soc_pcm_runtime *rtd)
0164 {
0165 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
0166
0167 switch (cpu_dai->id) {
0168 case MI2S_PRIMARY:
0169 case LPASS_CDC_DMA_TX3:
0170 case TX_CODEC_DMA_TX_3:
0171 return sc7280_headset_init(rtd);
0172 case LPASS_CDC_DMA_RX0:
0173 case LPASS_CDC_DMA_VA_TX0:
0174 case MI2S_SECONDARY:
0175 case RX_CODEC_DMA_RX_0:
0176 case SECONDARY_MI2S_RX:
0177 case VA_CODEC_DMA_TX_0:
0178 return 0;
0179 case LPASS_DP_RX:
0180 return sc7280_hdmi_init(rtd);
0181 default:
0182 dev_err(rtd->dev, "%s: invalid dai id 0x%x\n", __func__, cpu_dai->id);
0183 }
0184
0185 return -EINVAL;
0186 }
0187
0188 static int sc7280_snd_hw_params(struct snd_pcm_substream *substream,
0189 struct snd_pcm_hw_params *params)
0190 {
0191 struct snd_pcm_runtime *runtime = substream->runtime;
0192 struct snd_soc_pcm_runtime *rtd = substream->private_data;
0193 struct snd_soc_dai *codec_dai;
0194 const struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
0195 struct sc7280_snd_data *pdata = snd_soc_card_get_drvdata(rtd->card);
0196 struct sdw_stream_runtime *sruntime;
0197 int i;
0198
0199 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_CHANNELS, 2, 2);
0200 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_RATE, 48000, 48000);
0201
0202 switch (cpu_dai->id) {
0203 case LPASS_CDC_DMA_TX3:
0204 case LPASS_CDC_DMA_RX0:
0205 case RX_CODEC_DMA_RX_0:
0206 case SECONDARY_MI2S_RX:
0207 case TX_CODEC_DMA_TX_3:
0208 case VA_CODEC_DMA_TX_0:
0209 for_each_rtd_codec_dais(rtd, i, codec_dai) {
0210 sruntime = snd_soc_dai_get_stream(codec_dai, substream->stream);
0211 if (sruntime != ERR_PTR(-ENOTSUPP))
0212 pdata->sruntime[cpu_dai->id] = sruntime;
0213 }
0214 break;
0215 }
0216
0217 return 0;
0218 }
0219
0220 static int sc7280_snd_swr_prepare(struct snd_pcm_substream *substream)
0221 {
0222 struct snd_soc_pcm_runtime *rtd = substream->private_data;
0223 const struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
0224 struct sc7280_snd_data *data = snd_soc_card_get_drvdata(rtd->card);
0225 struct sdw_stream_runtime *sruntime = data->sruntime[cpu_dai->id];
0226 int ret;
0227
0228 if (!sruntime)
0229 return 0;
0230
0231 if (data->stream_prepared[cpu_dai->id]) {
0232 sdw_disable_stream(sruntime);
0233 sdw_deprepare_stream(sruntime);
0234 data->stream_prepared[cpu_dai->id] = false;
0235 }
0236
0237 ret = sdw_prepare_stream(sruntime);
0238 if (ret)
0239 return ret;
0240
0241 ret = sdw_enable_stream(sruntime);
0242 if (ret) {
0243 sdw_deprepare_stream(sruntime);
0244 return ret;
0245 }
0246 data->stream_prepared[cpu_dai->id] = true;
0247
0248 return ret;
0249 }
0250
0251 static int sc7280_snd_prepare(struct snd_pcm_substream *substream)
0252 {
0253 struct snd_soc_pcm_runtime *rtd = substream->private_data;
0254 const struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
0255
0256 switch (cpu_dai->id) {
0257 case LPASS_CDC_DMA_RX0:
0258 case LPASS_CDC_DMA_TX3:
0259 case RX_CODEC_DMA_RX_0:
0260 case TX_CODEC_DMA_TX_3:
0261 case VA_CODEC_DMA_TX_0:
0262 return sc7280_snd_swr_prepare(substream);
0263 default:
0264 break;
0265 }
0266
0267 return 0;
0268 }
0269
0270 static int sc7280_snd_hw_free(struct snd_pcm_substream *substream)
0271 {
0272 struct snd_soc_pcm_runtime *rtd = substream->private_data;
0273 struct sc7280_snd_data *data = snd_soc_card_get_drvdata(rtd->card);
0274 const struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
0275 struct sdw_stream_runtime *sruntime = data->sruntime[cpu_dai->id];
0276
0277 switch (cpu_dai->id) {
0278 case LPASS_CDC_DMA_RX0:
0279 case LPASS_CDC_DMA_TX3:
0280 case RX_CODEC_DMA_RX_0:
0281 case TX_CODEC_DMA_TX_3:
0282 case VA_CODEC_DMA_TX_0:
0283 if (sruntime && data->stream_prepared[cpu_dai->id]) {
0284 sdw_disable_stream(sruntime);
0285 sdw_deprepare_stream(sruntime);
0286 data->stream_prepared[cpu_dai->id] = false;
0287 }
0288 break;
0289 default:
0290 break;
0291 }
0292 return 0;
0293 }
0294
0295 static void sc7280_snd_shutdown(struct snd_pcm_substream *substream)
0296 {
0297 struct snd_soc_pcm_runtime *rtd = substream->private_data;
0298 struct snd_soc_card *card = rtd->card;
0299 struct sc7280_snd_data *data = snd_soc_card_get_drvdata(card);
0300 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
0301
0302 switch (cpu_dai->id) {
0303 case MI2S_PRIMARY:
0304 if (--data->pri_mi2s_clk_count == 0) {
0305 snd_soc_dai_set_sysclk(cpu_dai,
0306 LPASS_MCLK0,
0307 0,
0308 SNDRV_PCM_STREAM_PLAYBACK);
0309 }
0310 break;
0311 case SECONDARY_MI2S_RX:
0312 snd_soc_dai_set_sysclk(cpu_dai, Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT,
0313 0, SNDRV_PCM_STREAM_PLAYBACK);
0314 break;
0315 default:
0316 break;
0317 }
0318 }
0319
0320 static int sc7280_snd_startup(struct snd_pcm_substream *substream)
0321 {
0322 unsigned int fmt = SND_SOC_DAIFMT_CBS_CFS;
0323 unsigned int codec_dai_fmt = SND_SOC_DAIFMT_CBS_CFS;
0324 struct snd_soc_pcm_runtime *rtd = substream->private_data;
0325 struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(rtd, 0);
0326 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
0327 int ret = 0;
0328
0329 switch (cpu_dai->id) {
0330 case MI2S_PRIMARY:
0331 ret = sc7280_rt5682_init(rtd);
0332 break;
0333 case SECONDARY_MI2S_RX:
0334 codec_dai_fmt |= SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_I2S;
0335
0336 snd_soc_dai_set_sysclk(cpu_dai, Q6AFE_LPASS_CLK_ID_SEC_MI2S_IBIT,
0337 MI2S_BCLK_RATE, SNDRV_PCM_STREAM_PLAYBACK);
0338
0339 snd_soc_dai_set_fmt(cpu_dai, fmt);
0340 snd_soc_dai_set_fmt(codec_dai, codec_dai_fmt);
0341 break;
0342 default:
0343 break;
0344 }
0345 return ret;
0346 }
0347
0348 static const struct snd_soc_ops sc7280_ops = {
0349 .startup = sc7280_snd_startup,
0350 .hw_params = sc7280_snd_hw_params,
0351 .hw_free = sc7280_snd_hw_free,
0352 .prepare = sc7280_snd_prepare,
0353 .shutdown = sc7280_snd_shutdown,
0354 };
0355
0356 static const struct snd_soc_dapm_widget sc7280_snd_widgets[] = {
0357 SND_SOC_DAPM_HP("Headphone Jack", NULL),
0358 SND_SOC_DAPM_MIC("Headset Mic", NULL),
0359 };
0360
0361 static int sc7280_snd_platform_probe(struct platform_device *pdev)
0362 {
0363 struct snd_soc_card *card;
0364 struct sc7280_snd_data *data;
0365 struct device *dev = &pdev->dev;
0366 struct snd_soc_dai_link *link;
0367 int ret, i;
0368
0369 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
0370 if (!data)
0371 return -ENOMEM;
0372
0373 card = &data->card;
0374 snd_soc_card_set_drvdata(card, data);
0375
0376 card->owner = THIS_MODULE;
0377 card->driver_name = "SC7280";
0378 card->dev = dev;
0379
0380 card->dapm_widgets = sc7280_snd_widgets;
0381 card->num_dapm_widgets = ARRAY_SIZE(sc7280_snd_widgets);
0382
0383 ret = qcom_snd_parse_of(card);
0384 if (ret)
0385 return ret;
0386
0387 for_each_card_prelinks(card, i, link) {
0388 link->init = sc7280_init;
0389 link->ops = &sc7280_ops;
0390 }
0391
0392 return devm_snd_soc_register_card(dev, card);
0393 }
0394
0395 static const struct of_device_id sc7280_snd_device_id[] = {
0396 { .compatible = "google,sc7280-herobrine" },
0397 {}
0398 };
0399 MODULE_DEVICE_TABLE(of, sc7280_snd_device_id);
0400
0401 static struct platform_driver sc7280_snd_driver = {
0402 .probe = sc7280_snd_platform_probe,
0403 .driver = {
0404 .name = "msm-snd-sc7280",
0405 .of_match_table = sc7280_snd_device_id,
0406 .pm = &snd_soc_pm_ops,
0407 },
0408 };
0409 module_platform_driver(sc7280_snd_driver);
0410
0411 MODULE_DESCRIPTION("sc7280 ASoC Machine Driver");
0412 MODULE_LICENSE("GPL");
