1 // SPDX-License-Identifier: GPL-2.0+ 2 // 3 // Copyright (C) 2015 - 2016 Samsung Electronics Co., Ltd. 4 // 5 // Authors: Inha Song <ideal.song@samsung.com> 6 // Sylwester Nawrocki <s.nawrocki@samsung.com> 7 8 #include <linux/clk.h> 9 #include <linux/gpio.h> 10 #include <linux/gpio/consumer.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <sound/pcm_params.h> 14 #include <sound/soc.h> 15 16 #include "i2s.h" 17 #include "../codecs/wm5110.h" 18 19 /* 20 * The source clock is XCLKOUT with its mux set to the external fixed rate 21 * oscillator (XXTI). 22 */ 23 #define MCLK_RATE 24000000U 24 25 #define TM2_DAI_AIF1 0 26 #define TM2_DAI_AIF2 1 27 28 struct tm2_machine_priv { 29 struct snd_soc_component *component; 30 unsigned int sysclk_rate; 31 struct gpio_desc *gpio_mic_bias; 32 }; 33 34 static int tm2_start_sysclk(struct snd_soc_card *card) 35 { 36 struct tm2_machine_priv *priv = snd_soc_card_get_drvdata(card); 37 struct snd_soc_component *component = priv->component; 38 int ret; 39 40 ret = snd_soc_component_set_pll(component, WM5110_FLL1_REFCLK, 41 ARIZONA_FLL_SRC_MCLK1, 42 MCLK_RATE, 43 priv->sysclk_rate); 44 if (ret < 0) { 45 dev_err(component->dev, "Failed to set FLL1 source: %d\n", ret); 46 return ret; 47 } 48 49 ret = snd_soc_component_set_pll(component, WM5110_FLL1, 50 ARIZONA_FLL_SRC_MCLK1, 51 MCLK_RATE, 52 priv->sysclk_rate); 53 if (ret < 0) { 54 dev_err(component->dev, "Failed to start FLL1: %d\n", ret); 55 return ret; 56 } 57 58 ret = snd_soc_component_set_sysclk(component, ARIZONA_CLK_SYSCLK, 59 ARIZONA_CLK_SRC_FLL1, 60 priv->sysclk_rate, 61 SND_SOC_CLOCK_IN); 62 if (ret < 0) { 63 dev_err(component->dev, "Failed to set SYSCLK source: %d\n", ret); 64 return ret; 65 } 66 67 return 0; 68 } 69 70 static int tm2_stop_sysclk(struct snd_soc_card *card) 71 { 72 struct tm2_machine_priv *priv = snd_soc_card_get_drvdata(card); 73 struct snd_soc_component *component = priv->component; 74 int ret; 75 76 ret = snd_soc_component_set_pll(component, WM5110_FLL1, 0, 0, 0); 77 if (ret < 0) { 78 dev_err(component->dev, "Failed to stop FLL1: %d\n", ret); 79 return ret; 80 } 81 82 ret = snd_soc_component_set_sysclk(component, ARIZONA_CLK_SYSCLK, 83 ARIZONA_CLK_SRC_FLL1, 0, 0); 84 if (ret < 0) { 85 dev_err(component->dev, "Failed to stop SYSCLK: %d\n", ret); 86 return ret; 87 } 88 89 return 0; 90 } 91 92 static int tm2_aif1_hw_params(struct snd_pcm_substream *substream, 93 struct snd_pcm_hw_params *params) 94 { 95 struct snd_soc_pcm_runtime *rtd = substream->private_data; 96 struct snd_soc_component *component = rtd->codec_dai->component; 97 struct tm2_machine_priv *priv = snd_soc_card_get_drvdata(rtd->card); 98 99 switch (params_rate(params)) { 100 case 4000: 101 case 8000: 102 case 12000: 103 case 16000: 104 case 24000: 105 case 32000: 106 case 48000: 107 case 96000: 108 case 192000: 109 /* Highest possible SYSCLK frequency: 147.456MHz */ 110 priv->sysclk_rate = 147456000U; 111 break; 112 case 11025: 113 case 22050: 114 case 44100: 115 case 88200: 116 case 176400: 117 /* Highest possible SYSCLK frequency: 135.4752 MHz */ 118 priv->sysclk_rate = 135475200U; 119 break; 120 default: 121 dev_err(component->dev, "Not supported sample rate: %d\n", 122 params_rate(params)); 123 return -EINVAL; 124 } 125 126 return tm2_start_sysclk(rtd->card); 127 } 128 129 static struct snd_soc_ops tm2_aif1_ops = { 130 .hw_params = tm2_aif1_hw_params, 131 }; 132 133 static int tm2_aif2_hw_params(struct snd_pcm_substream *substream, 134 struct snd_pcm_hw_params *params) 135 { 136 struct snd_soc_pcm_runtime *rtd = substream->private_data; 137 struct snd_soc_component *component = rtd->codec_dai->component; 138 unsigned int asyncclk_rate; 139 int ret; 140 141 switch (params_rate(params)) { 142 case 8000: 143 case 12000: 144 case 16000: 145 /* Highest possible ASYNCCLK frequency: 49.152MHz */ 146 asyncclk_rate = 49152000U; 147 break; 148 case 11025: 149 /* Highest possible ASYNCCLK frequency: 45.1584 MHz */ 150 asyncclk_rate = 45158400U; 151 break; 152 default: 153 dev_err(component->dev, "Not supported sample rate: %d\n", 154 params_rate(params)); 155 return -EINVAL; 156 } 157 158 ret = snd_soc_component_set_pll(component, WM5110_FLL2_REFCLK, 159 ARIZONA_FLL_SRC_MCLK1, 160 MCLK_RATE, 161 asyncclk_rate); 162 if (ret < 0) { 163 dev_err(component->dev, "Failed to set FLL2 source: %d\n", ret); 164 return ret; 165 } 166 167 ret = snd_soc_component_set_pll(component, WM5110_FLL2, 168 ARIZONA_FLL_SRC_MCLK1, 169 MCLK_RATE, 170 asyncclk_rate); 171 if (ret < 0) { 172 dev_err(component->dev, "Failed to start FLL2: %d\n", ret); 173 return ret; 174 } 175 176 ret = snd_soc_component_set_sysclk(component, ARIZONA_CLK_ASYNCCLK, 177 ARIZONA_CLK_SRC_FLL2, 178 asyncclk_rate, 179 SND_SOC_CLOCK_IN); 180 if (ret < 0) { 181 dev_err(component->dev, "Failed to set ASYNCCLK source: %d\n", ret); 182 return ret; 183 } 184 185 return 0; 186 } 187 188 static int tm2_aif2_hw_free(struct snd_pcm_substream *substream) 189 { 190 struct snd_soc_pcm_runtime *rtd = substream->private_data; 191 struct snd_soc_component *component = rtd->codec_dai->component; 192 int ret; 193 194 /* disable FLL2 */ 195 ret = snd_soc_component_set_pll(component, WM5110_FLL2, ARIZONA_FLL_SRC_MCLK1, 196 0, 0); 197 if (ret < 0) 198 dev_err(component->dev, "Failed to stop FLL2: %d\n", ret); 199 200 return ret; 201 } 202 203 static struct snd_soc_ops tm2_aif2_ops = { 204 .hw_params = tm2_aif2_hw_params, 205 .hw_free = tm2_aif2_hw_free, 206 }; 207 208 static int tm2_hdmi_hw_params(struct snd_pcm_substream *substream, 209 struct snd_pcm_hw_params *params) 210 { 211 struct snd_soc_pcm_runtime *rtd = substream->private_data; 212 struct snd_soc_dai *cpu_dai = rtd->cpu_dai; 213 unsigned int bfs; 214 int bitwidth, ret; 215 216 bitwidth = snd_pcm_format_width(params_format(params)); 217 if (bitwidth < 0) { 218 dev_err(rtd->card->dev, "Invalid bit-width: %d\n", bitwidth); 219 return bitwidth; 220 } 221 222 switch (bitwidth) { 223 case 48: 224 bfs = 64; 225 break; 226 case 16: 227 bfs = 32; 228 break; 229 default: 230 dev_err(rtd->card->dev, "Unsupported bit-width: %d\n", bitwidth); 231 return -EINVAL; 232 } 233 234 switch (params_rate(params)) { 235 case 48000: 236 case 96000: 237 case 192000: 238 break; 239 default: 240 dev_err(rtd->card->dev, "Unsupported sample rate: %d\n", 241 params_rate(params)); 242 return -EINVAL; 243 } 244 245 ret = snd_soc_dai_set_sysclk(cpu_dai, SAMSUNG_I2S_OPCLK, 246 0, SAMSUNG_I2S_OPCLK_PCLK); 247 if (ret < 0) 248 return ret; 249 250 ret = snd_soc_dai_set_clkdiv(cpu_dai, SAMSUNG_I2S_DIV_BCLK, bfs); 251 if (ret < 0) 252 return ret; 253 254 return 0; 255 } 256 257 static struct snd_soc_ops tm2_hdmi_ops = { 258 .hw_params = tm2_hdmi_hw_params, 259 }; 260 261 static int tm2_mic_bias(struct snd_soc_dapm_widget *w, 262 struct snd_kcontrol *kcontrol, int event) 263 { 264 struct snd_soc_card *card = w->dapm->card; 265 struct tm2_machine_priv *priv = snd_soc_card_get_drvdata(card); 266 267 switch (event) { 268 case SND_SOC_DAPM_PRE_PMU: 269 gpiod_set_value_cansleep(priv->gpio_mic_bias, 1); 270 break; 271 case SND_SOC_DAPM_POST_PMD: 272 gpiod_set_value_cansleep(priv->gpio_mic_bias, 0); 273 break; 274 } 275 276 return 0; 277 } 278 279 static int tm2_set_bias_level(struct snd_soc_card *card, 280 struct snd_soc_dapm_context *dapm, 281 enum snd_soc_bias_level level) 282 { 283 struct snd_soc_pcm_runtime *rtd; 284 285 rtd = snd_soc_get_pcm_runtime(card, card->dai_link[0].name); 286 287 if (dapm->dev != rtd->codec_dai->dev) 288 return 0; 289 290 switch (level) { 291 case SND_SOC_BIAS_STANDBY: 292 if (card->dapm.bias_level == SND_SOC_BIAS_OFF) 293 tm2_start_sysclk(card); 294 break; 295 case SND_SOC_BIAS_OFF: 296 tm2_stop_sysclk(card); 297 break; 298 default: 299 break; 300 } 301 302 return 0; 303 } 304 305 static struct snd_soc_aux_dev tm2_speaker_amp_dev; 306 307 static int tm2_late_probe(struct snd_soc_card *card) 308 { 309 struct tm2_machine_priv *priv = snd_soc_card_get_drvdata(card); 310 struct snd_soc_dai_link_component dlc = { 0 }; 311 unsigned int ch_map[] = { 0, 1 }; 312 struct snd_soc_dai *amp_pdm_dai; 313 struct snd_soc_pcm_runtime *rtd; 314 struct snd_soc_dai *aif1_dai; 315 struct snd_soc_dai *aif2_dai; 316 int ret; 317 318 rtd = snd_soc_get_pcm_runtime(card, card->dai_link[TM2_DAI_AIF1].name); 319 aif1_dai = rtd->codec_dai; 320 priv->component = rtd->codec_dai->component; 321 322 ret = snd_soc_dai_set_sysclk(aif1_dai, ARIZONA_CLK_SYSCLK, 0, 0); 323 if (ret < 0) { 324 dev_err(aif1_dai->dev, "Failed to set SYSCLK: %d\n", ret); 325 return ret; 326 } 327 328 rtd = snd_soc_get_pcm_runtime(card, card->dai_link[TM2_DAI_AIF2].name); 329 aif2_dai = rtd->codec_dai; 330 331 ret = snd_soc_dai_set_sysclk(aif2_dai, ARIZONA_CLK_ASYNCCLK, 0, 0); 332 if (ret < 0) { 333 dev_err(aif2_dai->dev, "Failed to set ASYNCCLK: %d\n", ret); 334 return ret; 335 } 336 337 dlc.of_node = tm2_speaker_amp_dev.codec_of_node; 338 amp_pdm_dai = snd_soc_find_dai(&dlc); 339 if (!amp_pdm_dai) 340 return -ENODEV; 341 342 /* Set the MAX98504 V/I sense PDM Tx DAI channel mapping */ 343 ret = snd_soc_dai_set_channel_map(amp_pdm_dai, ARRAY_SIZE(ch_map), 344 ch_map, 0, NULL); 345 if (ret < 0) 346 return ret; 347 348 ret = snd_soc_dai_set_tdm_slot(amp_pdm_dai, 0x3, 0x0, 2, 16); 349 if (ret < 0) 350 return ret; 351 352 return 0; 353 } 354 355 static const struct snd_kcontrol_new tm2_controls[] = { 356 SOC_DAPM_PIN_SWITCH("HP"), 357 SOC_DAPM_PIN_SWITCH("SPK"), 358 SOC_DAPM_PIN_SWITCH("RCV"), 359 SOC_DAPM_PIN_SWITCH("VPS"), 360 SOC_DAPM_PIN_SWITCH("HDMI"), 361 362 SOC_DAPM_PIN_SWITCH("Main Mic"), 363 SOC_DAPM_PIN_SWITCH("Sub Mic"), 364 SOC_DAPM_PIN_SWITCH("Third Mic"), 365 366 SOC_DAPM_PIN_SWITCH("Headset Mic"), 367 }; 368 369 static const struct snd_soc_dapm_widget tm2_dapm_widgets[] = { 370 SND_SOC_DAPM_HP("HP", NULL), 371 SND_SOC_DAPM_SPK("SPK", NULL), 372 SND_SOC_DAPM_SPK("RCV", NULL), 373 SND_SOC_DAPM_LINE("VPS", NULL), 374 SND_SOC_DAPM_LINE("HDMI", NULL), 375 376 SND_SOC_DAPM_MIC("Main Mic", tm2_mic_bias), 377 SND_SOC_DAPM_MIC("Sub Mic", NULL), 378 SND_SOC_DAPM_MIC("Third Mic", NULL), 379 380 SND_SOC_DAPM_MIC("Headset Mic", NULL), 381 }; 382 383 static const struct snd_soc_component_driver tm2_component = { 384 .name = "tm2-audio", 385 }; 386 387 static struct snd_soc_dai_driver tm2_ext_dai[] = { 388 { 389 .name = "Voice call", 390 .playback = { 391 .channels_min = 1, 392 .channels_max = 4, 393 .rate_min = 8000, 394 .rate_max = 48000, 395 .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 | 396 SNDRV_PCM_RATE_48000), 397 .formats = SNDRV_PCM_FMTBIT_S16_LE, 398 }, 399 .capture = { 400 .channels_min = 1, 401 .channels_max = 4, 402 .rate_min = 8000, 403 .rate_max = 48000, 404 .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 | 405 SNDRV_PCM_RATE_48000), 406 .formats = SNDRV_PCM_FMTBIT_S16_LE, 407 }, 408 }, 409 { 410 .name = "Bluetooth", 411 .playback = { 412 .channels_min = 1, 413 .channels_max = 4, 414 .rate_min = 8000, 415 .rate_max = 16000, 416 .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000), 417 .formats = SNDRV_PCM_FMTBIT_S16_LE, 418 }, 419 .capture = { 420 .channels_min = 1, 421 .channels_max = 2, 422 .rate_min = 8000, 423 .rate_max = 16000, 424 .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000), 425 .formats = SNDRV_PCM_FMTBIT_S16_LE, 426 }, 427 }, 428 }; 429 430 static struct snd_soc_dai_link tm2_dai_links[] = { 431 { 432 .name = "WM5110 AIF1", 433 .stream_name = "HiFi Primary", 434 .cpu_dai_name = SAMSUNG_I2S_DAI, 435 .codec_dai_name = "wm5110-aif1", 436 .ops = &tm2_aif1_ops, 437 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | 438 SND_SOC_DAIFMT_CBM_CFM, 439 }, { 440 .name = "WM5110 Voice", 441 .stream_name = "Voice call", 442 .cpu_dai_name = SAMSUNG_I2S_DAI, 443 .codec_dai_name = "wm5110-aif2", 444 .ops = &tm2_aif2_ops, 445 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | 446 SND_SOC_DAIFMT_CBM_CFM, 447 .ignore_suspend = 1, 448 }, { 449 .name = "WM5110 BT", 450 .stream_name = "Bluetooth", 451 .cpu_dai_name = SAMSUNG_I2S_DAI, 452 .codec_dai_name = "wm5110-aif3", 453 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | 454 SND_SOC_DAIFMT_CBM_CFM, 455 .ignore_suspend = 1, 456 }, { 457 .name = "HDMI", 458 .stream_name = "i2s1", 459 .ops = &tm2_hdmi_ops, 460 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | 461 SND_SOC_DAIFMT_CBS_CFS, 462 } 463 }; 464 465 static struct snd_soc_card tm2_card = { 466 .owner = THIS_MODULE, 467 468 .dai_link = tm2_dai_links, 469 .controls = tm2_controls, 470 .num_controls = ARRAY_SIZE(tm2_controls), 471 .dapm_widgets = tm2_dapm_widgets, 472 .num_dapm_widgets = ARRAY_SIZE(tm2_dapm_widgets), 473 .aux_dev = &tm2_speaker_amp_dev, 474 .num_aux_devs = 1, 475 476 .late_probe = tm2_late_probe, 477 .set_bias_level = tm2_set_bias_level, 478 }; 479 480 static int tm2_probe(struct platform_device *pdev) 481 { 482 struct device_node *cpu_dai_node[2] = {}; 483 struct device_node *codec_dai_node[2] = {}; 484 const char *cells_name = NULL; 485 struct device *dev = &pdev->dev; 486 struct snd_soc_card *card = &tm2_card; 487 struct tm2_machine_priv *priv; 488 struct of_phandle_args args; 489 struct snd_soc_dai_link *dai_link; 490 int num_codecs, ret, i; 491 492 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 493 if (!priv) 494 return -ENOMEM; 495 496 snd_soc_card_set_drvdata(card, priv); 497 card->dev = dev; 498 499 priv->gpio_mic_bias = devm_gpiod_get(dev, "mic-bias", GPIOD_OUT_HIGH); 500 if (IS_ERR(priv->gpio_mic_bias)) { 501 dev_err(dev, "Failed to get mic bias gpio\n"); 502 return PTR_ERR(priv->gpio_mic_bias); 503 } 504 505 ret = snd_soc_of_parse_card_name(card, "model"); 506 if (ret < 0) { 507 dev_err(dev, "Card name is not specified\n"); 508 return ret; 509 } 510 511 ret = snd_soc_of_parse_audio_routing(card, "samsung,audio-routing"); 512 if (ret < 0) { 513 dev_err(dev, "Audio routing is not specified or invalid\n"); 514 return ret; 515 } 516 517 card->aux_dev[0].codec_of_node = of_parse_phandle(dev->of_node, 518 "audio-amplifier", 0); 519 if (!card->aux_dev[0].codec_of_node) { 520 dev_err(dev, "audio-amplifier property invalid or missing\n"); 521 return -EINVAL; 522 } 523 524 num_codecs = of_count_phandle_with_args(dev->of_node, "audio-codec", 525 NULL); 526 527 /* Skip the HDMI link if not specified in DT */ 528 if (num_codecs > 1) { 529 card->num_links = ARRAY_SIZE(tm2_dai_links); 530 cells_name = "#sound-dai-cells"; 531 } else { 532 card->num_links = ARRAY_SIZE(tm2_dai_links) - 1; 533 } 534 535 for (i = 0; i < num_codecs; i++) { 536 struct of_phandle_args args; 537 538 ret = of_parse_phandle_with_args(dev->of_node, "i2s-controller", 539 cells_name, i, &args); 540 if (!args.np) { 541 dev_err(dev, "i2s-controller property parse error: %d\n", i); 542 ret = -EINVAL; 543 goto dai_node_put; 544 } 545 cpu_dai_node[i] = args.np; 546 547 codec_dai_node[i] = of_parse_phandle(dev->of_node, 548 "audio-codec", i); 549 if (!codec_dai_node[i]) { 550 dev_err(dev, "audio-codec property parse error\n"); 551 ret = -EINVAL; 552 goto dai_node_put; 553 } 554 } 555 556 /* Initialize WM5110 - I2S and HDMI - I2S1 DAI links */ 557 for_each_card_prelinks(card, i, dai_link) { 558 unsigned int dai_index = 0; /* WM5110 */ 559 560 dai_link->cpu_name = NULL; 561 dai_link->platform_name = NULL; 562 563 if (num_codecs > 1 && i == card->num_links - 1) 564 dai_index = 1; /* HDMI */ 565 566 dai_link->codec_of_node = codec_dai_node[dai_index]; 567 dai_link->cpu_of_node = cpu_dai_node[dai_index]; 568 dai_link->platform_of_node = cpu_dai_node[dai_index]; 569 } 570 571 if (num_codecs > 1) { 572 /* HDMI DAI link (I2S1) */ 573 i = card->num_links - 1; 574 575 ret = of_parse_phandle_with_fixed_args(dev->of_node, 576 "audio-codec", 0, 1, &args); 577 if (ret) { 578 dev_err(dev, "audio-codec property parse error\n"); 579 goto dai_node_put; 580 } 581 582 ret = snd_soc_get_dai_name(&args, &card->dai_link[i].codec_dai_name); 583 if (ret) { 584 dev_err(dev, "Unable to get codec_dai_name\n"); 585 goto dai_node_put; 586 } 587 } 588 589 ret = devm_snd_soc_register_component(dev, &tm2_component, 590 tm2_ext_dai, ARRAY_SIZE(tm2_ext_dai)); 591 if (ret < 0) { 592 dev_err(dev, "Failed to register component: %d\n", ret); 593 goto dai_node_put; 594 } 595 596 ret = devm_snd_soc_register_card(dev, card); 597 if (ret < 0) { 598 dev_err(dev, "Failed to register card: %d\n", ret); 599 goto dai_node_put; 600 } 601 602 dai_node_put: 603 for (i = 0; i < num_codecs; i++) { 604 of_node_put(codec_dai_node[i]); 605 of_node_put(cpu_dai_node[i]); 606 } 607 608 of_node_put(card->aux_dev[0].codec_of_node); 609 610 return ret; 611 } 612 613 static int tm2_pm_prepare(struct device *dev) 614 { 615 struct snd_soc_card *card = dev_get_drvdata(dev); 616 617 return tm2_stop_sysclk(card); 618 } 619 620 static void tm2_pm_complete(struct device *dev) 621 { 622 struct snd_soc_card *card = dev_get_drvdata(dev); 623 624 tm2_start_sysclk(card); 625 } 626 627 static const struct dev_pm_ops tm2_pm_ops = { 628 .prepare = tm2_pm_prepare, 629 .suspend = snd_soc_suspend, 630 .resume = snd_soc_resume, 631 .complete = tm2_pm_complete, 632 .freeze = snd_soc_suspend, 633 .thaw = snd_soc_resume, 634 .poweroff = snd_soc_poweroff, 635 .restore = snd_soc_resume, 636 }; 637 638 static const struct of_device_id tm2_of_match[] = { 639 { .compatible = "samsung,tm2-audio" }, 640 { }, 641 }; 642 MODULE_DEVICE_TABLE(of, tm2_of_match); 643 644 static struct platform_driver tm2_driver = { 645 .driver = { 646 .name = "tm2-audio", 647 .pm = &tm2_pm_ops, 648 .of_match_table = tm2_of_match, 649 }, 650 .probe = tm2_probe, 651 }; 652 module_platform_driver(tm2_driver); 653 654 MODULE_AUTHOR("Inha Song <ideal.song@samsung.com>"); 655 MODULE_DESCRIPTION("ALSA SoC Exynos TM2 Audio Support"); 656 MODULE_LICENSE("GPL v2"); 657