1 // SPDX-License-Identifier: GPL-2.0-only 2 // Copyright(c) 2019 Intel Corporation. 3 4 /* 5 * Intel SOF Machine driver for Dialog headphone codec 6 */ 7 8 #include <linux/input.h> 9 #include <linux/module.h> 10 #include <sound/jack.h> 11 #include <sound/pcm.h> 12 #include <sound/pcm_params.h> 13 #include <linux/platform_device.h> 14 #include <sound/soc.h> 15 #include <sound/soc-acpi.h> 16 #include <sound/sof.h> 17 #include "../../codecs/da7219.h" 18 #include "hda_dsp_common.h" 19 #include "sof_hdmi_common.h" 20 #include "sof_maxim_common.h" 21 #include "sof_ssp_common.h" 22 23 /* Board Quirks */ 24 #define SOF_DA7219_JSL_BOARD BIT(2) 25 26 #define DIALOG_CODEC_DAI "da7219-hifi" 27 28 struct card_private { 29 struct snd_soc_jack headset_jack; 30 struct sof_hdmi_private hdmi; 31 enum sof_ssp_codec codec_type; 32 enum sof_ssp_codec amp_type; 33 34 unsigned int pll_bypass:1; 35 }; 36 37 static int platform_clock_control(struct snd_soc_dapm_widget *w, 38 struct snd_kcontrol *k, int event) 39 { 40 struct snd_soc_dapm_context *dapm = w->dapm; 41 struct snd_soc_card *card = dapm->card; 42 struct card_private *ctx = snd_soc_card_get_drvdata(card); 43 struct snd_soc_dai *codec_dai; 44 int ret = 0; 45 46 if (ctx->pll_bypass) 47 return ret; 48 49 /* PLL SRM mode */ 50 codec_dai = snd_soc_card_get_codec_dai(card, DIALOG_CODEC_DAI); 51 if (!codec_dai) { 52 dev_err(card->dev, "Codec dai not found; Unable to set/unset codec pll\n"); 53 return -EIO; 54 } 55 56 if (SND_SOC_DAPM_EVENT_OFF(event)) { 57 ret = snd_soc_dai_set_pll(codec_dai, 0, DA7219_SYSCLK_MCLK, 58 0, 0); 59 if (ret) 60 dev_err(card->dev, "failed to stop PLL: %d\n", ret); 61 } else if (SND_SOC_DAPM_EVENT_ON(event)) { 62 dev_dbg(card->dev, "pll srm mode\n"); 63 64 ret = snd_soc_dai_set_pll(codec_dai, 0, DA7219_SYSCLK_PLL_SRM, 65 0, DA7219_PLL_FREQ_OUT_98304); 66 if (ret) 67 dev_err(card->dev, "failed to start PLL: %d\n", ret); 68 } 69 70 return ret; 71 } 72 73 static const struct snd_kcontrol_new controls[] = { 74 SOC_DAPM_PIN_SWITCH("Headphone Jack"), 75 SOC_DAPM_PIN_SWITCH("Headset Mic"), 76 SOC_DAPM_PIN_SWITCH("Line Out"), 77 SOC_DAPM_PIN_SWITCH("Left Spk"), 78 SOC_DAPM_PIN_SWITCH("Right Spk"), 79 }; 80 81 static const struct snd_soc_dapm_widget widgets[] = { 82 SND_SOC_DAPM_HP("Headphone Jack", NULL), 83 SND_SOC_DAPM_MIC("Headset Mic", NULL), 84 SND_SOC_DAPM_LINE("Line Out", NULL), 85 86 SND_SOC_DAPM_SPK("Left Spk", NULL), 87 SND_SOC_DAPM_SPK("Right Spk", NULL), 88 89 SND_SOC_DAPM_SUPPLY("Platform Clock", SND_SOC_NOPM, 0, 0, 90 platform_clock_control, SND_SOC_DAPM_POST_PMD | 91 SND_SOC_DAPM_PRE_PMU), 92 93 SND_SOC_DAPM_MIC("SoC DMIC", NULL), 94 }; 95 96 static const struct snd_soc_dapm_route audio_map[] = { 97 { "Headphone Jack", NULL, "HPL" }, 98 { "Headphone Jack", NULL, "HPR" }, 99 100 { "MIC", NULL, "Headset Mic" }, 101 102 { "Headphone Jack", NULL, "Platform Clock" }, 103 { "Headset Mic", NULL, "Platform Clock" }, 104 { "Line Out", NULL, "Platform Clock" }, 105 106 /* digital mics */ 107 {"DMic", NULL, "SoC DMIC"}, 108 }; 109 110 static struct snd_soc_jack_pin jack_pins[] = { 111 { 112 .pin = "Headphone Jack", 113 .mask = SND_JACK_HEADPHONE, 114 }, 115 { 116 .pin = "Headset Mic", 117 .mask = SND_JACK_MICROPHONE, 118 }, 119 { 120 .pin = "Line Out", 121 .mask = SND_JACK_LINEOUT, 122 }, 123 }; 124 125 static int da7219_codec_init(struct snd_soc_pcm_runtime *rtd) 126 { 127 struct card_private *ctx = snd_soc_card_get_drvdata(rtd->card); 128 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0); 129 struct snd_soc_component *component = codec_dai->component; 130 struct snd_soc_jack *jack = &ctx->headset_jack; 131 int mclk_rate, ret; 132 133 mclk_rate = sof_dai_get_mclk(rtd); 134 if (mclk_rate <= 0) { 135 dev_err(rtd->dev, "invalid mclk freq %d\n", mclk_rate); 136 return -EINVAL; 137 } 138 139 ret = snd_soc_dai_set_sysclk(codec_dai, DA7219_CLKSRC_MCLK, mclk_rate, 140 SND_SOC_CLOCK_IN); 141 if (ret) { 142 dev_err(rtd->dev, "fail to set sysclk, ret %d\n", ret); 143 return ret; 144 } 145 146 /* 147 * Use PLL bypass mode if MCLK is available, be sure to set the 148 * frequency of MCLK to 12.288 or 24.576MHz on topology side. 149 */ 150 if (mclk_rate == 12288000 || mclk_rate == 24576000) { 151 /* PLL bypass mode */ 152 dev_dbg(rtd->dev, "pll bypass mode, mclk rate %d\n", mclk_rate); 153 154 ret = snd_soc_dai_set_pll(codec_dai, 0, DA7219_SYSCLK_MCLK, 0, 0); 155 if (ret) { 156 dev_err(rtd->dev, "fail to set pll, ret %d\n", ret); 157 return ret; 158 } 159 160 ctx->pll_bypass = 1; 161 } 162 163 /* 164 * Headset buttons map to the google Reference headset. 165 * These can be configured by userspace. 166 */ 167 ret = snd_soc_card_jack_new_pins(rtd->card, "Headset Jack", 168 SND_JACK_HEADSET | SND_JACK_BTN_0 | 169 SND_JACK_BTN_1 | SND_JACK_BTN_2 | 170 SND_JACK_BTN_3 | SND_JACK_LINEOUT, 171 jack, jack_pins, ARRAY_SIZE(jack_pins)); 172 if (ret) { 173 dev_err(rtd->dev, "Headset Jack creation failed: %d\n", ret); 174 return ret; 175 } 176 177 snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_PLAYPAUSE); 178 snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOLUMEUP); 179 snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEDOWN); 180 snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOICECOMMAND); 181 182 ret = snd_soc_component_set_jack(component, jack, NULL); 183 if (ret) { 184 dev_err(rtd->dev, "fail to set component jack, ret %d\n", ret); 185 return ret; 186 } 187 188 return ret; 189 } 190 191 static int max98373_hw_params(struct snd_pcm_substream *substream, 192 struct snd_pcm_hw_params *params) 193 { 194 struct snd_soc_pcm_runtime *runtime = snd_soc_substream_to_rtd(substream); 195 int ret, j; 196 197 for (j = 0; j < runtime->dai_link->num_codecs; j++) { 198 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(runtime, j); 199 200 if (!strcmp(codec_dai->component->name, MAX_98373_DEV0_NAME)) { 201 /* vmon_slot_no = 0 imon_slot_no = 1 for TX slots */ 202 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0x3, 3, 4, 16); 203 if (ret < 0) { 204 dev_err(runtime->dev, "DEV0 TDM slot err:%d\n", ret); 205 return ret; 206 } 207 } 208 if (!strcmp(codec_dai->component->name, MAX_98373_DEV1_NAME)) { 209 /* vmon_slot_no = 2 imon_slot_no = 3 for TX slots */ 210 ret = snd_soc_dai_set_tdm_slot(codec_dai, 0xC, 3, 4, 16); 211 if (ret < 0) { 212 dev_err(runtime->dev, "DEV1 TDM slot err:%d\n", ret); 213 return ret; 214 } 215 } 216 } 217 218 return 0; 219 } 220 221 static const struct snd_soc_ops max98373_ops = { 222 .hw_params = max98373_hw_params, 223 }; 224 225 static int hdmi_init(struct snd_soc_pcm_runtime *rtd) 226 { 227 struct card_private *ctx = snd_soc_card_get_drvdata(rtd->card); 228 struct snd_soc_dai *dai = snd_soc_rtd_to_codec(rtd, 0); 229 230 ctx->hdmi.hdmi_comp = dai->component; 231 232 return 0; 233 } 234 235 static int card_late_probe(struct snd_soc_card *card) 236 { 237 struct card_private *ctx = snd_soc_card_get_drvdata(card); 238 239 if (!ctx->hdmi.idisp_codec) 240 return 0; 241 242 if (!ctx->hdmi.hdmi_comp) 243 return -EINVAL; 244 245 return hda_dsp_hdmi_build_controls(card, ctx->hdmi.hdmi_comp); 246 } 247 248 SND_SOC_DAILINK_DEF(ssp0_pin, 249 DAILINK_COMP_ARRAY(COMP_CPU("SSP0 Pin"))); 250 SND_SOC_DAILINK_DEF(ssp0_codec, 251 DAILINK_COMP_ARRAY(COMP_CODEC("i2c-DLGS7219:00", DIALOG_CODEC_DAI))); 252 253 SND_SOC_DAILINK_DEF(ssp1_pin, 254 DAILINK_COMP_ARRAY(COMP_CPU("SSP1 Pin"))); 255 256 SND_SOC_DAILINK_DEF(ssp2_pin, 257 DAILINK_COMP_ARRAY(COMP_CPU("SSP2 Pin"))); 258 SND_SOC_DAILINK_DEF(dummy_codec, 259 DAILINK_COMP_ARRAY(COMP_CODEC("snd-soc-dummy", "snd-soc-dummy-dai"))); 260 261 SND_SOC_DAILINK_DEF(dmic_pin, 262 DAILINK_COMP_ARRAY(COMP_CPU("DMIC01 Pin"))); 263 SND_SOC_DAILINK_DEF(dmic_codec, 264 DAILINK_COMP_ARRAY(COMP_CODEC("dmic-codec", "dmic-hifi"))); 265 266 SND_SOC_DAILINK_DEF(dmic16k_pin, 267 DAILINK_COMP_ARRAY(COMP_CPU("DMIC16k Pin"))); 268 269 SND_SOC_DAILINK_DEF(idisp1_pin, 270 DAILINK_COMP_ARRAY(COMP_CPU("iDisp1 Pin"))); 271 SND_SOC_DAILINK_DEF(idisp1_codec, 272 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi1"))); 273 274 SND_SOC_DAILINK_DEF(idisp2_pin, 275 DAILINK_COMP_ARRAY(COMP_CPU("iDisp2 Pin"))); 276 SND_SOC_DAILINK_DEF(idisp2_codec, 277 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi2"))); 278 279 SND_SOC_DAILINK_DEF(idisp3_pin, 280 DAILINK_COMP_ARRAY(COMP_CPU("iDisp3 Pin"))); 281 SND_SOC_DAILINK_DEF(idisp3_codec, 282 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi3"))); 283 284 SND_SOC_DAILINK_DEF(idisp4_pin, 285 DAILINK_COMP_ARRAY(COMP_CPU("iDisp4 Pin"))); 286 SND_SOC_DAILINK_DEF(idisp4_codec, 287 DAILINK_COMP_ARRAY(COMP_CODEC("ehdaudio0D2", "intel-hdmi-hifi4"))); 288 289 SND_SOC_DAILINK_DEF(platform, /* subject to be overridden during probe */ 290 DAILINK_COMP_ARRAY(COMP_PLATFORM("0000:00:1f.3"))); 291 292 static struct snd_soc_dai_link jsl_dais[] = { 293 /* Back End DAI links */ 294 { 295 .name = "SSP1-Codec", 296 .id = 0, 297 .ignore_pmdown_time = 1, 298 .no_pcm = 1, 299 .dpcm_playback = 1, 300 .dpcm_capture = 1, /* IV feedback */ 301 SND_SOC_DAILINK_REG(ssp1_pin, max_98373_components, platform), 302 }, 303 { 304 .name = "SSP0-Codec", 305 .id = 1, 306 .no_pcm = 1, 307 .init = da7219_codec_init, 308 .ignore_pmdown_time = 1, 309 .dpcm_playback = 1, 310 .dpcm_capture = 1, 311 SND_SOC_DAILINK_REG(ssp0_pin, ssp0_codec, platform), 312 }, 313 { 314 .name = "dmic01", 315 .id = 2, 316 .ignore_suspend = 1, 317 .dpcm_capture = 1, 318 .no_pcm = 1, 319 SND_SOC_DAILINK_REG(dmic_pin, dmic_codec, platform), 320 }, 321 { 322 .name = "iDisp1", 323 .id = 3, 324 .init = hdmi_init, 325 .dpcm_playback = 1, 326 .no_pcm = 1, 327 SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform), 328 }, 329 { 330 .name = "iDisp2", 331 .id = 4, 332 .init = hdmi_init, 333 .dpcm_playback = 1, 334 .no_pcm = 1, 335 SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform), 336 }, 337 { 338 .name = "iDisp3", 339 .id = 5, 340 .init = hdmi_init, 341 .dpcm_playback = 1, 342 .no_pcm = 1, 343 SND_SOC_DAILINK_REG(idisp3_pin, idisp3_codec, platform), 344 }, 345 { 346 .name = "dmic16k", 347 .id = 6, 348 .ignore_suspend = 1, 349 .dpcm_capture = 1, 350 .no_pcm = 1, 351 SND_SOC_DAILINK_REG(dmic16k_pin, dmic_codec, platform), 352 } 353 }; 354 355 static struct snd_soc_dai_link adl_dais[] = { 356 /* Back End DAI links */ 357 { 358 .name = "SSP0-Codec", 359 .id = 0, 360 .no_pcm = 1, 361 .init = da7219_codec_init, 362 .ignore_pmdown_time = 1, 363 .dpcm_playback = 1, 364 .dpcm_capture = 1, 365 SND_SOC_DAILINK_REG(ssp0_pin, ssp0_codec, platform), 366 }, 367 { 368 .name = "dmic01", 369 .id = 1, 370 .ignore_suspend = 1, 371 .dpcm_capture = 1, 372 .no_pcm = 1, 373 SND_SOC_DAILINK_REG(dmic_pin, dmic_codec, platform), 374 }, 375 { 376 .name = "dmic16k", 377 .id = 2, 378 .ignore_suspend = 1, 379 .dpcm_capture = 1, 380 .no_pcm = 1, 381 SND_SOC_DAILINK_REG(dmic16k_pin, dmic_codec, platform), 382 }, 383 { 384 .name = "iDisp1", 385 .id = 3, 386 .init = hdmi_init, 387 .dpcm_playback = 1, 388 .no_pcm = 1, 389 SND_SOC_DAILINK_REG(idisp1_pin, idisp1_codec, platform), 390 }, 391 { 392 .name = "iDisp2", 393 .id = 4, 394 .init = hdmi_init, 395 .dpcm_playback = 1, 396 .no_pcm = 1, 397 SND_SOC_DAILINK_REG(idisp2_pin, idisp2_codec, platform), 398 }, 399 { 400 .name = "iDisp3", 401 .id = 5, 402 .init = hdmi_init, 403 .dpcm_playback = 1, 404 .no_pcm = 1, 405 SND_SOC_DAILINK_REG(idisp3_pin, idisp3_codec, platform), 406 }, 407 { 408 .name = "iDisp4", 409 .id = 6, 410 .init = hdmi_init, 411 .dpcm_playback = 1, 412 .no_pcm = 1, 413 SND_SOC_DAILINK_REG(idisp4_pin, idisp4_codec, platform), 414 }, 415 { 416 .name = "SSP1-Codec", 417 .id = 7, 418 .no_pcm = 1, 419 .dpcm_playback = 1, 420 /* feedback stream or firmware-generated echo reference */ 421 .dpcm_capture = 1, 422 SND_SOC_DAILINK_REG(ssp1_pin, max_98373_components, platform), 423 }, 424 { 425 .name = "SSP2-BT", 426 .id = 8, 427 .no_pcm = 1, 428 .dpcm_playback = 1, 429 .dpcm_capture = 1, 430 SND_SOC_DAILINK_REG(ssp2_pin, dummy_codec, platform), 431 }, 432 }; 433 434 static struct snd_soc_card card_da7219 = { 435 .name = "da7219", /* the sof- prefix is added by the core */ 436 .owner = THIS_MODULE, 437 .controls = controls, 438 .num_controls = ARRAY_SIZE(controls), 439 .dapm_widgets = widgets, 440 .num_dapm_widgets = ARRAY_SIZE(widgets), 441 .dapm_routes = audio_map, 442 .num_dapm_routes = ARRAY_SIZE(audio_map), 443 .fully_routed = true, 444 .late_probe = card_late_probe, 445 }; 446 447 static int audio_probe(struct platform_device *pdev) 448 { 449 struct snd_soc_acpi_mach *mach = pdev->dev.platform_data; 450 struct snd_soc_dai_link *dai_links; 451 struct card_private *ctx; 452 unsigned long board_quirk = 0; 453 int ret, amp_idx; 454 455 ctx = devm_kzalloc(&pdev->dev, sizeof(*ctx), GFP_KERNEL); 456 if (!ctx) 457 return -ENOMEM; 458 459 if (pdev->id_entry && pdev->id_entry->driver_data) 460 board_quirk = (unsigned long)pdev->id_entry->driver_data; 461 462 ctx->codec_type = sof_ssp_detect_codec_type(&pdev->dev); 463 ctx->amp_type = sof_ssp_detect_amp_type(&pdev->dev); 464 465 if (mach->mach_params.codec_mask & IDISP_CODEC_MASK) 466 ctx->hdmi.idisp_codec = true; 467 468 if (board_quirk & SOF_DA7219_JSL_BOARD) { 469 /* backward-compatible with existing devices */ 470 switch (ctx->amp_type) { 471 case CODEC_MAX98360A: 472 card_da7219.name = devm_kstrdup(&pdev->dev, 473 "da7219max98360a", 474 GFP_KERNEL); 475 break; 476 case CODEC_MAX98373: 477 card_da7219.name = devm_kstrdup(&pdev->dev, "da7219max", 478 GFP_KERNEL); 479 break; 480 default: 481 break; 482 } 483 484 dai_links = jsl_dais; 485 amp_idx = 0; 486 487 card_da7219.num_links = ARRAY_SIZE(jsl_dais); 488 } else { 489 dai_links = adl_dais; 490 amp_idx = 7; 491 492 card_da7219.num_links = ARRAY_SIZE(adl_dais); 493 } 494 495 dev_dbg(&pdev->dev, "board_quirk = %lx\n", board_quirk); 496 497 /* speaker amp */ 498 switch (ctx->amp_type) { 499 case CODEC_MAX98360A: 500 max_98360a_dai_link(&dai_links[amp_idx]); 501 break; 502 case CODEC_MAX98373: 503 dai_links[amp_idx].codecs = max_98373_components; 504 dai_links[amp_idx].num_codecs = ARRAY_SIZE(max_98373_components); 505 dai_links[amp_idx].init = max_98373_spk_codec_init; 506 if (board_quirk & SOF_DA7219_JSL_BOARD) { 507 dai_links[amp_idx].ops = &max98373_ops; /* use local ops */ 508 } else { 509 /* TBD: implement the amp for later platform */ 510 dev_err(&pdev->dev, "max98373 not support yet\n"); 511 return -EINVAL; 512 } 513 514 max_98373_set_codec_conf(&card_da7219); 515 break; 516 default: 517 dev_err(&pdev->dev, "invalid amp type %d\n", ctx->amp_type); 518 return -EINVAL; 519 } 520 521 card_da7219.dai_link = dai_links; 522 523 card_da7219.dev = &pdev->dev; 524 525 ret = snd_soc_fixup_dai_links_platform_name(&card_da7219, 526 mach->mach_params.platform); 527 if (ret) 528 return ret; 529 530 snd_soc_card_set_drvdata(&card_da7219, ctx); 531 532 return devm_snd_soc_register_card(&pdev->dev, &card_da7219); 533 } 534 535 static const struct platform_device_id board_ids[] = { 536 { 537 .name = "jsl_mx98373_da7219", 538 .driver_data = (kernel_ulong_t)(SOF_DA7219_JSL_BOARD), 539 }, 540 { 541 .name = "jsl_mx98360_da7219", 542 .driver_data = (kernel_ulong_t)(SOF_DA7219_JSL_BOARD), 543 }, 544 { 545 .name = "adl_mx98360_da7219", 546 /* no quirk needed for this board */ 547 }, 548 { } 549 }; 550 MODULE_DEVICE_TABLE(platform, board_ids); 551 552 static struct platform_driver audio = { 553 .probe = audio_probe, 554 .driver = { 555 .name = "sof_da7219", 556 .pm = &snd_soc_pm_ops, 557 }, 558 .id_table = board_ids, 559 }; 560 module_platform_driver(audio) 561 562 /* Module information */ 563 MODULE_DESCRIPTION("ASoC Intel(R) SOF Machine driver for Dialog codec"); 564 MODULE_AUTHOR("Yong Zhi <yong.zhi@intel.com>"); 565 MODULE_AUTHOR("Brent Lu <brent.lu@intel.com>"); 566 MODULE_LICENSE("GPL v2"); 567 MODULE_IMPORT_NS(SND_SOC_INTEL_HDA_DSP_COMMON); 568 MODULE_IMPORT_NS(SND_SOC_INTEL_SOF_MAXIM_COMMON); 569 MODULE_IMPORT_NS(SND_SOC_INTEL_SOF_SSP_COMMON); 570