1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * tegra_asoc_machine.c - Universal ASoC machine driver for NVIDIA Tegra boards. 4 */ 5 6 #include <linux/clk.h> 7 #include <linux/export.h> 8 #include <linux/gpio/consumer.h> 9 #include <linux/module.h> 10 #include <linux/of.h> 11 #include <linux/platform_device.h> 12 #include <linux/slab.h> 13 14 #include <sound/core.h> 15 #include <sound/jack.h> 16 #include <sound/pcm.h> 17 #include <sound/pcm_params.h> 18 #include <sound/soc.h> 19 20 #include "tegra_asoc_machine.h" 21 22 /* Headphones Jack */ 23 24 static struct snd_soc_jack tegra_machine_hp_jack; 25 26 static struct snd_soc_jack_pin tegra_machine_hp_jack_pins[] = { 27 { .pin = "Headphone", .mask = SND_JACK_HEADPHONE }, 28 { .pin = "Headphones", .mask = SND_JACK_HEADPHONE }, 29 }; 30 31 static struct snd_soc_jack_gpio tegra_machine_hp_jack_gpio = { 32 .name = "Headphones detection", 33 .report = SND_JACK_HEADPHONE, 34 .debounce_time = 150, 35 }; 36 37 /* Headset Jack */ 38 39 static struct snd_soc_jack tegra_machine_headset_jack; 40 41 static struct snd_soc_jack_pin tegra_machine_headset_jack_pins[] = { 42 { .pin = "Headset Mic", .mask = SND_JACK_MICROPHONE }, 43 { .pin = "Headset Stereophone", .mask = SND_JACK_HEADPHONE }, 44 }; 45 46 static struct snd_soc_jack_gpio tegra_machine_headset_jack_gpio = { 47 .name = "Headset detection", 48 .report = SND_JACK_HEADSET, 49 .debounce_time = 150, 50 }; 51 52 /* Mic Jack */ 53 static int coupled_mic_hp_check(void *data) 54 { 55 struct tegra_machine *machine = (struct tegra_machine *)data; 56 57 /* Detect mic insertion only if 3.5 jack is in */ 58 if (gpiod_get_value_cansleep(machine->gpiod_hp_det) && 59 gpiod_get_value_cansleep(machine->gpiod_mic_det)) 60 return SND_JACK_MICROPHONE; 61 62 return 0; 63 } 64 65 static struct snd_soc_jack tegra_machine_mic_jack; 66 67 static struct snd_soc_jack_pin tegra_machine_mic_jack_pins[] = { 68 { .pin = "Mic Jack", .mask = SND_JACK_MICROPHONE }, 69 { .pin = "Headset Mic", .mask = SND_JACK_MICROPHONE }, 70 }; 71 72 static struct snd_soc_jack_gpio tegra_machine_mic_jack_gpio = { 73 .name = "Mic detection", 74 .report = SND_JACK_MICROPHONE, 75 .debounce_time = 150, 76 }; 77 78 static int tegra_machine_event(struct snd_soc_dapm_widget *w, 79 struct snd_kcontrol *k, int event) 80 { 81 struct snd_soc_card *card = snd_soc_dapm_to_card(w->dapm); 82 struct tegra_machine *machine = snd_soc_card_get_drvdata(card); 83 84 if (!snd_soc_dapm_widget_name_cmp(w, "Int Spk") || 85 !snd_soc_dapm_widget_name_cmp(w, "Speakers")) 86 gpiod_set_value_cansleep(machine->gpiod_spkr_en, 87 SND_SOC_DAPM_EVENT_ON(event)); 88 89 if (!snd_soc_dapm_widget_name_cmp(w, "Mic Jack") || 90 !snd_soc_dapm_widget_name_cmp(w, "Headset Mic")) 91 gpiod_set_value_cansleep(machine->gpiod_ext_mic_en, 92 SND_SOC_DAPM_EVENT_ON(event)); 93 94 if (!snd_soc_dapm_widget_name_cmp(w, "Int Mic") || 95 !snd_soc_dapm_widget_name_cmp(w, "Internal Mic 2")) 96 gpiod_set_value_cansleep(machine->gpiod_int_mic_en, 97 SND_SOC_DAPM_EVENT_ON(event)); 98 99 if (!snd_soc_dapm_widget_name_cmp(w, "Headphone") || 100 !snd_soc_dapm_widget_name_cmp(w, "Headphone Jack")) 101 gpiod_set_value_cansleep(machine->gpiod_hp_mute, 102 !SND_SOC_DAPM_EVENT_ON(event)); 103 104 return 0; 105 } 106 107 static const struct snd_soc_dapm_widget tegra_machine_dapm_widgets[] = { 108 SND_SOC_DAPM_HP("Headphone Jack", tegra_machine_event), 109 SND_SOC_DAPM_HP("Headphone", tegra_machine_event), 110 SND_SOC_DAPM_HP("Headset Stereophone", NULL), 111 SND_SOC_DAPM_HP("Headphones", NULL), 112 SND_SOC_DAPM_SPK("Speakers", tegra_machine_event), 113 SND_SOC_DAPM_SPK("Int Spk", tegra_machine_event), 114 SND_SOC_DAPM_SPK("Earpiece", NULL), 115 SND_SOC_DAPM_MIC("Int Mic", tegra_machine_event), 116 SND_SOC_DAPM_MIC("Mic Jack", tegra_machine_event), 117 SND_SOC_DAPM_MIC("Internal Mic 1", NULL), 118 SND_SOC_DAPM_MIC("Internal Mic 2", tegra_machine_event), 119 SND_SOC_DAPM_MIC("Headset Mic", tegra_machine_event), 120 SND_SOC_DAPM_MIC("Digital Mic", NULL), 121 SND_SOC_DAPM_MIC("Mic", NULL), 122 SND_SOC_DAPM_LINE("Line In Jack", NULL), 123 SND_SOC_DAPM_LINE("Line In", NULL), 124 SND_SOC_DAPM_LINE("LineIn", NULL), 125 }; 126 127 static const struct snd_kcontrol_new tegra_machine_controls[] = { 128 SOC_DAPM_PIN_SWITCH("Speakers"), 129 SOC_DAPM_PIN_SWITCH("Int Spk"), 130 SOC_DAPM_PIN_SWITCH("Earpiece"), 131 SOC_DAPM_PIN_SWITCH("Int Mic"), 132 SOC_DAPM_PIN_SWITCH("Headset Mic"), 133 SOC_DAPM_PIN_SWITCH("Internal Mic 1"), 134 SOC_DAPM_PIN_SWITCH("Internal Mic 2"), 135 SOC_DAPM_PIN_SWITCH("Headphones"), 136 SOC_DAPM_PIN_SWITCH("Mic Jack"), 137 }; 138 139 int tegra_asoc_machine_init(struct snd_soc_pcm_runtime *rtd) 140 { 141 struct snd_soc_card *card = rtd->card; 142 struct tegra_machine *machine = snd_soc_card_get_drvdata(card); 143 const char *jack_name; 144 int err; 145 146 if (machine->gpiod_hp_det && machine->asoc->add_hp_jack) { 147 if (machine->asoc->hp_jack_name) 148 jack_name = machine->asoc->hp_jack_name; 149 else 150 jack_name = "Headphones Jack"; 151 152 err = snd_soc_card_jack_new_pins(card, jack_name, 153 SND_JACK_HEADPHONE, 154 &tegra_machine_hp_jack, 155 tegra_machine_hp_jack_pins, 156 ARRAY_SIZE(tegra_machine_hp_jack_pins)); 157 if (err) { 158 dev_err(rtd->dev, 159 "Headphones Jack creation failed: %d\n", err); 160 return err; 161 } 162 163 tegra_machine_hp_jack_gpio.desc = machine->gpiod_hp_det; 164 165 err = snd_soc_jack_add_gpios(&tegra_machine_hp_jack, 1, 166 &tegra_machine_hp_jack_gpio); 167 if (err) 168 dev_err(rtd->dev, "HP GPIOs not added: %d\n", err); 169 } 170 171 if (machine->gpiod_hp_det && machine->asoc->add_headset_jack) { 172 err = snd_soc_card_jack_new_pins(card, "Headset Jack", 173 SND_JACK_HEADSET, 174 &tegra_machine_headset_jack, 175 tegra_machine_headset_jack_pins, 176 ARRAY_SIZE(tegra_machine_headset_jack_pins)); 177 if (err) { 178 dev_err(rtd->dev, 179 "Headset Jack creation failed: %d\n", err); 180 return err; 181 } 182 183 tegra_machine_headset_jack_gpio.desc = machine->gpiod_hp_det; 184 185 err = snd_soc_jack_add_gpios(&tegra_machine_headset_jack, 1, 186 &tegra_machine_headset_jack_gpio); 187 if (err) 188 dev_err(rtd->dev, "Headset GPIOs not added: %d\n", err); 189 } 190 191 if (machine->gpiod_mic_det && machine->asoc->add_mic_jack) { 192 err = snd_soc_card_jack_new_pins(rtd->card, "Mic Jack", 193 SND_JACK_MICROPHONE, 194 &tegra_machine_mic_jack, 195 tegra_machine_mic_jack_pins, 196 ARRAY_SIZE(tegra_machine_mic_jack_pins)); 197 if (err) { 198 dev_err(rtd->dev, "Mic Jack creation failed: %d\n", err); 199 return err; 200 } 201 202 tegra_machine_mic_jack_gpio.data = machine; 203 tegra_machine_mic_jack_gpio.desc = machine->gpiod_mic_det; 204 205 if (of_property_read_bool(card->dev->of_node, 206 "nvidia,coupled-mic-hp-det")) { 207 tegra_machine_mic_jack_gpio.desc = machine->gpiod_hp_det; 208 tegra_machine_mic_jack_gpio.jack_status_check = coupled_mic_hp_check; 209 } 210 211 err = snd_soc_jack_add_gpios(&tegra_machine_mic_jack, 1, 212 &tegra_machine_mic_jack_gpio); 213 if (err) 214 dev_err(rtd->dev, "Mic GPIOs not added: %d\n", err); 215 } 216 217 return 0; 218 } 219 EXPORT_SYMBOL_GPL(tegra_asoc_machine_init); 220 221 static unsigned int tegra_machine_mclk_rate_128(unsigned int srate) 222 { 223 return 128 * srate; 224 } 225 226 static unsigned int tegra_machine_mclk_rate_256(unsigned int srate) 227 { 228 return 256 * srate; 229 } 230 231 static unsigned int tegra_machine_mclk_rate_512(unsigned int srate) 232 { 233 return 512 * srate; 234 } 235 236 static unsigned int tegra_machine_mclk_rate_12mhz(unsigned int srate) 237 { 238 unsigned int mclk; 239 240 switch (srate) { 241 case 8000: 242 case 16000: 243 case 24000: 244 case 32000: 245 case 48000: 246 case 64000: 247 case 96000: 248 mclk = 12288000; 249 break; 250 case 11025: 251 case 22050: 252 case 44100: 253 case 88200: 254 mclk = 11289600; 255 break; 256 default: 257 mclk = 12000000; 258 break; 259 } 260 261 return mclk; 262 } 263 264 static unsigned int tegra_machine_mclk_rate_6mhz(unsigned int srate) 265 { 266 unsigned int mclk; 267 268 switch (srate) { 269 case 8000: 270 case 16000: 271 case 64000: 272 mclk = 8192000; 273 break; 274 case 11025: 275 case 22050: 276 case 88200: 277 mclk = 11289600; 278 break; 279 case 96000: 280 mclk = 12288000; 281 break; 282 default: 283 mclk = 256 * srate; 284 break; 285 } 286 287 return mclk; 288 } 289 290 static int tegra_machine_hw_params(struct snd_pcm_substream *substream, 291 struct snd_pcm_hw_params *params) 292 { 293 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 294 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0); 295 struct snd_soc_card *card = rtd->card; 296 struct tegra_machine *machine = snd_soc_card_get_drvdata(card); 297 unsigned int srate = params_rate(params); 298 unsigned int mclk = machine->asoc->mclk_rate(srate); 299 unsigned int clk_id = machine->asoc->mclk_id; 300 unsigned int new_baseclock; 301 int err; 302 303 switch (srate) { 304 case 11025: 305 case 22050: 306 case 44100: 307 case 88200: 308 if (of_machine_is_compatible("nvidia,tegra20")) 309 new_baseclock = 56448000; 310 else if (of_machine_is_compatible("nvidia,tegra30")) 311 new_baseclock = 564480000; 312 else 313 new_baseclock = 282240000; 314 break; 315 case 8000: 316 case 16000: 317 case 32000: 318 case 48000: 319 case 64000: 320 case 96000: 321 if (of_machine_is_compatible("nvidia,tegra20")) 322 new_baseclock = 73728000; 323 else if (of_machine_is_compatible("nvidia,tegra30")) 324 new_baseclock = 552960000; 325 else 326 new_baseclock = 368640000; 327 break; 328 default: 329 dev_err(card->dev, "Invalid sound rate: %u\n", srate); 330 return -EINVAL; 331 } 332 333 if (new_baseclock != machine->set_baseclock || 334 mclk != machine->set_mclk) { 335 machine->set_baseclock = 0; 336 machine->set_mclk = 0; 337 338 clk_disable_unprepare(machine->clk_cdev1); 339 340 err = clk_set_rate(machine->clk_pll_a, new_baseclock); 341 if (err) { 342 dev_err(card->dev, "Can't set pll_a rate: %d\n", err); 343 return err; 344 } 345 346 err = clk_set_rate(machine->clk_pll_a_out0, mclk); 347 if (err) { 348 dev_err(card->dev, "Can't set pll_a_out0 rate: %d\n", err); 349 return err; 350 } 351 352 /* Don't set cdev1/extern1 rate; it's locked to pll_a_out0 */ 353 354 err = clk_prepare_enable(machine->clk_cdev1); 355 if (err) { 356 dev_err(card->dev, "Can't enable cdev1: %d\n", err); 357 return err; 358 } 359 360 machine->set_baseclock = new_baseclock; 361 machine->set_mclk = mclk; 362 } 363 364 err = snd_soc_dai_set_sysclk(codec_dai, clk_id, mclk, SND_SOC_CLOCK_IN); 365 if (err < 0) { 366 dev_err(card->dev, "codec_dai clock not set: %d\n", err); 367 return err; 368 } 369 370 return 0; 371 } 372 373 static const struct snd_soc_ops tegra_machine_snd_ops = { 374 .hw_params = tegra_machine_hw_params, 375 }; 376 377 static void tegra_machine_node_release(void *of_node) 378 { 379 of_node_put(of_node); 380 } 381 382 static struct device_node * 383 tegra_machine_parse_phandle(struct device *dev, const char *name) 384 { 385 struct device_node *np; 386 int err; 387 388 np = of_parse_phandle(dev->of_node, name, 0); 389 if (!np) { 390 dev_err(dev, "Property '%s' missing or invalid\n", name); 391 return ERR_PTR(-EINVAL); 392 } 393 394 err = devm_add_action_or_reset(dev, tegra_machine_node_release, np); 395 if (err) 396 return ERR_PTR(err); 397 398 return np; 399 } 400 401 static void tegra_machine_unregister_codec(void *pdev) 402 { 403 platform_device_unregister(pdev); 404 } 405 406 static int tegra_machine_register_codec(struct device *dev, const char *name) 407 { 408 struct platform_device *pdev; 409 int err; 410 411 if (!name) 412 return 0; 413 414 pdev = platform_device_register_simple(name, -1, NULL, 0); 415 if (IS_ERR(pdev)) 416 return PTR_ERR(pdev); 417 418 err = devm_add_action_or_reset(dev, tegra_machine_unregister_codec, 419 pdev); 420 if (err) 421 return err; 422 423 return 0; 424 } 425 426 int tegra_asoc_machine_probe(struct platform_device *pdev) 427 { 428 struct device_node *np_codec, *np_i2s, *np_ac97; 429 const struct tegra_asoc_data *asoc; 430 struct device *dev = &pdev->dev; 431 struct tegra_machine *machine; 432 struct snd_soc_card *card; 433 struct gpio_desc *gpiod; 434 int err; 435 436 machine = devm_kzalloc(dev, sizeof(*machine), GFP_KERNEL); 437 if (!machine) 438 return -ENOMEM; 439 440 asoc = of_device_get_match_data(dev); 441 card = asoc->card; 442 card->dev = dev; 443 444 machine->asoc = asoc; 445 machine->mic_jack = &tegra_machine_mic_jack; 446 machine->hp_jack_gpio = &tegra_machine_hp_jack_gpio; 447 snd_soc_card_set_drvdata(card, machine); 448 449 gpiod = devm_gpiod_get_optional(dev, "nvidia,hp-mute", GPIOD_OUT_HIGH); 450 machine->gpiod_hp_mute = gpiod; 451 if (IS_ERR(gpiod)) 452 return PTR_ERR(gpiod); 453 454 gpiod = devm_gpiod_get_optional(dev, "nvidia,hp-det", GPIOD_IN); 455 machine->gpiod_hp_det = gpiod; 456 if (IS_ERR(gpiod)) 457 return PTR_ERR(gpiod); 458 459 gpiod = devm_gpiod_get_optional(dev, "nvidia,mic-det", GPIOD_IN); 460 machine->gpiod_mic_det = gpiod; 461 if (IS_ERR(gpiod)) 462 return PTR_ERR(gpiod); 463 464 gpiod = devm_gpiod_get_optional(dev, "nvidia,spkr-en", GPIOD_OUT_LOW); 465 machine->gpiod_spkr_en = gpiod; 466 if (IS_ERR(gpiod)) 467 return PTR_ERR(gpiod); 468 469 gpiod = devm_gpiod_get_optional(dev, "nvidia,int-mic-en", GPIOD_OUT_LOW); 470 machine->gpiod_int_mic_en = gpiod; 471 if (IS_ERR(gpiod)) 472 return PTR_ERR(gpiod); 473 474 gpiod = devm_gpiod_get_optional(dev, "nvidia,ext-mic-en", GPIOD_OUT_LOW); 475 machine->gpiod_ext_mic_en = gpiod; 476 if (IS_ERR(gpiod)) 477 return PTR_ERR(gpiod); 478 479 err = snd_soc_of_parse_card_name(card, "nvidia,model"); 480 if (err) 481 return err; 482 483 if (!card->dapm_routes) { 484 err = snd_soc_of_parse_audio_routing(card, "nvidia,audio-routing"); 485 if (err) 486 return err; 487 } 488 489 if (asoc->set_ac97) { 490 err = tegra_machine_register_codec(dev, asoc->codec_dev_name); 491 if (err) 492 return err; 493 494 np_ac97 = tegra_machine_parse_phandle(dev, "nvidia,ac97-controller"); 495 if (IS_ERR(np_ac97)) 496 return PTR_ERR(np_ac97); 497 498 card->dai_link->cpus->of_node = np_ac97; 499 card->dai_link->platforms->of_node = np_ac97; 500 } else { 501 np_codec = tegra_machine_parse_phandle(dev, "nvidia,audio-codec"); 502 if (IS_ERR(np_codec)) 503 return PTR_ERR(np_codec); 504 505 np_i2s = tegra_machine_parse_phandle(dev, "nvidia,i2s-controller"); 506 if (IS_ERR(np_i2s)) 507 return PTR_ERR(np_i2s); 508 509 card->dai_link->cpus->of_node = np_i2s; 510 card->dai_link->codecs->of_node = np_codec; 511 card->dai_link->platforms->of_node = np_i2s; 512 } 513 514 if (asoc->add_common_controls) { 515 card->controls = tegra_machine_controls; 516 card->num_controls = ARRAY_SIZE(tegra_machine_controls); 517 } 518 519 if (asoc->add_common_dapm_widgets) { 520 card->dapm_widgets = tegra_machine_dapm_widgets; 521 card->num_dapm_widgets = ARRAY_SIZE(tegra_machine_dapm_widgets); 522 } 523 524 if (asoc->add_common_snd_ops) 525 card->dai_link->ops = &tegra_machine_snd_ops; 526 527 if (!card->owner) 528 card->owner = THIS_MODULE; 529 if (!card->driver_name) 530 card->driver_name = "tegra"; 531 532 machine->clk_pll_a = devm_clk_get(dev, "pll_a"); 533 if (IS_ERR(machine->clk_pll_a)) { 534 dev_err(dev, "Can't retrieve clk pll_a\n"); 535 return PTR_ERR(machine->clk_pll_a); 536 } 537 538 machine->clk_pll_a_out0 = devm_clk_get(dev, "pll_a_out0"); 539 if (IS_ERR(machine->clk_pll_a_out0)) { 540 dev_err(dev, "Can't retrieve clk pll_a_out0\n"); 541 return PTR_ERR(machine->clk_pll_a_out0); 542 } 543 544 machine->clk_cdev1 = devm_clk_get(dev, "mclk"); 545 if (IS_ERR(machine->clk_cdev1)) { 546 dev_err(dev, "Can't retrieve clk cdev1\n"); 547 return PTR_ERR(machine->clk_cdev1); 548 } 549 550 /* 551 * If clock parents are not set in DT, configure here to use clk_out_1 552 * as mclk and extern1 as parent for Tegra30 and higher. 553 */ 554 if (!of_property_present(dev->of_node, "assigned-clock-parents") && 555 !of_machine_is_compatible("nvidia,tegra20")) { 556 struct clk *clk_out_1, *clk_extern1; 557 558 dev_warn(dev, "Configuring clocks for a legacy device-tree\n"); 559 dev_warn(dev, "Please update DT to use assigned-clock-parents\n"); 560 561 clk_extern1 = devm_clk_get(dev, "extern1"); 562 if (IS_ERR(clk_extern1)) { 563 dev_err(dev, "Can't retrieve clk extern1\n"); 564 return PTR_ERR(clk_extern1); 565 } 566 567 err = clk_set_parent(clk_extern1, machine->clk_pll_a_out0); 568 if (err < 0) { 569 dev_err(dev, "Set parent failed for clk extern1\n"); 570 return err; 571 } 572 573 clk_out_1 = devm_clk_get(dev, "pmc_clk_out_1"); 574 if (IS_ERR(clk_out_1)) { 575 dev_err(dev, "Can't retrieve pmc_clk_out_1\n"); 576 return PTR_ERR(clk_out_1); 577 } 578 579 err = clk_set_parent(clk_out_1, clk_extern1); 580 if (err < 0) { 581 dev_err(dev, "Set parent failed for pmc_clk_out_1\n"); 582 return err; 583 } 584 585 machine->clk_cdev1 = clk_out_1; 586 } 587 588 if (asoc->set_ac97) { 589 /* 590 * AC97 rate is fixed at 24.576MHz and is used for both the 591 * host controller and the external codec 592 */ 593 err = clk_set_rate(machine->clk_pll_a, 73728000); 594 if (err) { 595 dev_err(dev, "Can't set pll_a rate: %d\n", err); 596 return err; 597 } 598 599 err = clk_set_rate(machine->clk_pll_a_out0, 24576000); 600 if (err) { 601 dev_err(dev, "Can't set pll_a_out0 rate: %d\n", err); 602 return err; 603 } 604 605 machine->set_baseclock = 73728000; 606 machine->set_mclk = 24576000; 607 } 608 609 /* 610 * FIXME: There is some unknown dependency between audio MCLK disable 611 * and suspend-resume functionality on Tegra30, although audio MCLK is 612 * only needed for audio. 613 */ 614 err = clk_prepare_enable(machine->clk_cdev1); 615 if (err) { 616 dev_err(dev, "Can't enable cdev1: %d\n", err); 617 return err; 618 } 619 620 err = devm_snd_soc_register_card(dev, card); 621 if (err) 622 return err; 623 624 return 0; 625 } 626 EXPORT_SYMBOL_GPL(tegra_asoc_machine_probe); 627 628 /* WM8753 machine */ 629 630 SND_SOC_DAILINK_DEFS(wm8753_hifi, 631 DAILINK_COMP_ARRAY(COMP_EMPTY()), 632 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "wm8753-hifi")), 633 DAILINK_COMP_ARRAY(COMP_EMPTY())); 634 635 static struct snd_soc_dai_link tegra_wm8753_dai = { 636 .name = "WM8753", 637 .stream_name = "WM8753 PCM", 638 .dai_fmt = SND_SOC_DAIFMT_I2S | 639 SND_SOC_DAIFMT_NB_NF | 640 SND_SOC_DAIFMT_CBC_CFC, 641 SND_SOC_DAILINK_REG(wm8753_hifi), 642 }; 643 644 static struct snd_soc_card snd_soc_tegra_wm8753 = { 645 .components = "codec:wm8753", 646 .dai_link = &tegra_wm8753_dai, 647 .num_links = 1, 648 .fully_routed = true, 649 }; 650 651 static const struct tegra_asoc_data tegra_wm8753_data = { 652 .mclk_rate = tegra_machine_mclk_rate_12mhz, 653 .card = &snd_soc_tegra_wm8753, 654 .add_common_dapm_widgets = true, 655 .add_common_snd_ops = true, 656 }; 657 658 /* WM9712 machine */ 659 660 static int tegra_wm9712_init(struct snd_soc_pcm_runtime *rtd) 661 { 662 struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(rtd->card); 663 664 return snd_soc_dapm_force_enable_pin(dapm, "Mic Bias"); 665 } 666 667 SND_SOC_DAILINK_DEFS(wm9712_hifi, 668 DAILINK_COMP_ARRAY(COMP_EMPTY()), 669 DAILINK_COMP_ARRAY(COMP_CODEC("wm9712-codec", "wm9712-hifi")), 670 DAILINK_COMP_ARRAY(COMP_EMPTY())); 671 672 static struct snd_soc_dai_link tegra_wm9712_dai = { 673 .name = "AC97 HiFi", 674 .stream_name = "AC97 HiFi", 675 .init = tegra_wm9712_init, 676 SND_SOC_DAILINK_REG(wm9712_hifi), 677 }; 678 679 static struct snd_soc_card snd_soc_tegra_wm9712 = { 680 .components = "codec:wm9712", 681 .dai_link = &tegra_wm9712_dai, 682 .num_links = 1, 683 .fully_routed = true, 684 }; 685 686 static const struct tegra_asoc_data tegra_wm9712_data = { 687 .card = &snd_soc_tegra_wm9712, 688 .add_common_dapm_widgets = true, 689 .codec_dev_name = "wm9712-codec", 690 .set_ac97 = true, 691 }; 692 693 /* MAX98090 machine */ 694 695 SND_SOC_DAILINK_DEFS(max98090_hifi, 696 DAILINK_COMP_ARRAY(COMP_EMPTY()), 697 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "HiFi")), 698 DAILINK_COMP_ARRAY(COMP_EMPTY())); 699 700 static struct snd_soc_dai_link tegra_max98090_dai = { 701 .name = "max98090", 702 .stream_name = "max98090 PCM", 703 .init = tegra_asoc_machine_init, 704 .dai_fmt = SND_SOC_DAIFMT_I2S | 705 SND_SOC_DAIFMT_NB_NF | 706 SND_SOC_DAIFMT_CBC_CFC, 707 SND_SOC_DAILINK_REG(max98090_hifi), 708 }; 709 710 static struct snd_soc_card snd_soc_tegra_max98090 = { 711 .components = "codec:max98090", 712 .dai_link = &tegra_max98090_dai, 713 .num_links = 1, 714 .fully_routed = true, 715 }; 716 717 static const struct tegra_asoc_data tegra_max98090_data = { 718 .mclk_rate = tegra_machine_mclk_rate_12mhz, 719 .card = &snd_soc_tegra_max98090, 720 .hp_jack_name = "Headphones", 721 .add_common_dapm_widgets = true, 722 .add_common_controls = true, 723 .add_common_snd_ops = true, 724 .add_mic_jack = true, 725 .add_hp_jack = true, 726 }; 727 728 /* MAX98088 machine */ 729 730 SND_SOC_DAILINK_DEFS(max98088_hifi, 731 DAILINK_COMP_ARRAY(COMP_EMPTY()), 732 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "HiFi")), 733 DAILINK_COMP_ARRAY(COMP_EMPTY())); 734 735 static struct snd_soc_dai_link tegra_max98088_dai = { 736 .name = "MAX98088", 737 .stream_name = "MAX98088 PCM", 738 .init = tegra_asoc_machine_init, 739 .dai_fmt = SND_SOC_DAIFMT_I2S | 740 SND_SOC_DAIFMT_NB_NF | 741 SND_SOC_DAIFMT_CBC_CFC, 742 SND_SOC_DAILINK_REG(max98088_hifi), 743 }; 744 745 static struct snd_soc_card snd_soc_tegra_max98088 = { 746 .components = "codec:max98088", 747 .dai_link = &tegra_max98088_dai, 748 .num_links = 1, 749 .fully_routed = true, 750 }; 751 752 static const struct tegra_asoc_data tegra_max98088_data = { 753 .mclk_rate = tegra_machine_mclk_rate_12mhz, 754 .card = &snd_soc_tegra_max98088, 755 .add_common_dapm_widgets = true, 756 .add_common_controls = true, 757 .add_common_snd_ops = true, 758 .add_mic_jack = true, 759 .add_hp_jack = true, 760 }; 761 762 /* SGTL5000 machine */ 763 764 SND_SOC_DAILINK_DEFS(sgtl5000_hifi, 765 DAILINK_COMP_ARRAY(COMP_EMPTY()), 766 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "sgtl5000")), 767 DAILINK_COMP_ARRAY(COMP_EMPTY())); 768 769 static struct snd_soc_dai_link tegra_sgtl5000_dai = { 770 .name = "sgtl5000", 771 .stream_name = "HiFi", 772 .dai_fmt = SND_SOC_DAIFMT_I2S | 773 SND_SOC_DAIFMT_NB_NF | 774 SND_SOC_DAIFMT_CBC_CFC, 775 SND_SOC_DAILINK_REG(sgtl5000_hifi), 776 }; 777 778 static struct snd_soc_card snd_soc_tegra_sgtl5000 = { 779 .components = "codec:sgtl5000", 780 .dai_link = &tegra_sgtl5000_dai, 781 .num_links = 1, 782 .fully_routed = true, 783 }; 784 785 static const struct tegra_asoc_data tegra_sgtl5000_data = { 786 .mclk_rate = tegra_machine_mclk_rate_12mhz, 787 .card = &snd_soc_tegra_sgtl5000, 788 .add_common_dapm_widgets = true, 789 .add_common_snd_ops = true, 790 }; 791 792 /* TLV320AIC23 machine */ 793 794 static const struct snd_soc_dapm_widget trimslice_dapm_widgets[] = { 795 SND_SOC_DAPM_HP("Line Out", NULL), 796 SND_SOC_DAPM_LINE("Line In", NULL), 797 }; 798 799 static const struct snd_soc_dapm_route trimslice_audio_map[] = { 800 {"Line Out", NULL, "LOUT"}, 801 {"Line Out", NULL, "ROUT"}, 802 803 {"LLINEIN", NULL, "Line In"}, 804 {"RLINEIN", NULL, "Line In"}, 805 }; 806 807 SND_SOC_DAILINK_DEFS(tlv320aic23_hifi, 808 DAILINK_COMP_ARRAY(COMP_EMPTY()), 809 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "tlv320aic23-hifi")), 810 DAILINK_COMP_ARRAY(COMP_EMPTY())); 811 812 static struct snd_soc_dai_link tegra_tlv320aic23_dai = { 813 .name = "TLV320AIC23", 814 .stream_name = "AIC23", 815 .dai_fmt = SND_SOC_DAIFMT_I2S | 816 SND_SOC_DAIFMT_NB_NF | 817 SND_SOC_DAIFMT_CBC_CFC, 818 SND_SOC_DAILINK_REG(tlv320aic23_hifi), 819 }; 820 821 static struct snd_soc_card snd_soc_tegra_trimslice = { 822 .name = "tegra-trimslice", 823 .components = "codec:tlv320aic23", 824 .dai_link = &tegra_tlv320aic23_dai, 825 .num_links = 1, 826 .dapm_widgets = trimslice_dapm_widgets, 827 .num_dapm_widgets = ARRAY_SIZE(trimslice_dapm_widgets), 828 .dapm_routes = trimslice_audio_map, 829 .num_dapm_routes = ARRAY_SIZE(trimslice_audio_map), 830 .fully_routed = true, 831 }; 832 833 static const struct tegra_asoc_data tegra_trimslice_data = { 834 .mclk_rate = tegra_machine_mclk_rate_128, 835 .card = &snd_soc_tegra_trimslice, 836 .add_common_snd_ops = true, 837 }; 838 839 /* RT5677 machine */ 840 841 static int tegra_rt5677_init(struct snd_soc_pcm_runtime *rtd) 842 { 843 struct snd_soc_card *card = rtd->card; 844 struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card); 845 int err; 846 847 err = tegra_asoc_machine_init(rtd); 848 if (err) 849 return err; 850 851 snd_soc_dapm_force_enable_pin(dapm, "MICBIAS1"); 852 853 return 0; 854 } 855 856 SND_SOC_DAILINK_DEFS(rt5677_aif1, 857 DAILINK_COMP_ARRAY(COMP_EMPTY()), 858 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "rt5677-aif1")), 859 DAILINK_COMP_ARRAY(COMP_EMPTY())); 860 861 static struct snd_soc_dai_link tegra_rt5677_dai = { 862 .name = "RT5677", 863 .stream_name = "RT5677 PCM", 864 .init = tegra_rt5677_init, 865 .dai_fmt = SND_SOC_DAIFMT_I2S | 866 SND_SOC_DAIFMT_NB_NF | 867 SND_SOC_DAIFMT_CBC_CFC, 868 SND_SOC_DAILINK_REG(rt5677_aif1), 869 }; 870 871 static struct snd_soc_card snd_soc_tegra_rt5677 = { 872 .components = "codec:rt5677", 873 .dai_link = &tegra_rt5677_dai, 874 .num_links = 1, 875 .fully_routed = true, 876 }; 877 878 static const struct tegra_asoc_data tegra_rt5677_data = { 879 .mclk_rate = tegra_machine_mclk_rate_256, 880 .card = &snd_soc_tegra_rt5677, 881 .add_common_dapm_widgets = true, 882 .add_common_controls = true, 883 .add_common_snd_ops = true, 884 .add_mic_jack = true, 885 .add_hp_jack = true, 886 }; 887 888 /* RT5640 machine */ 889 890 SND_SOC_DAILINK_DEFS(rt5640_aif1, 891 DAILINK_COMP_ARRAY(COMP_EMPTY()), 892 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "rt5640-aif1")), 893 DAILINK_COMP_ARRAY(COMP_EMPTY())); 894 895 static struct snd_soc_dai_link tegra_rt5640_dai = { 896 .name = "RT5640", 897 .stream_name = "RT5640 PCM", 898 .init = tegra_asoc_machine_init, 899 .dai_fmt = SND_SOC_DAIFMT_I2S | 900 SND_SOC_DAIFMT_NB_NF | 901 SND_SOC_DAIFMT_CBC_CFC, 902 SND_SOC_DAILINK_REG(rt5640_aif1), 903 }; 904 905 static struct snd_soc_card snd_soc_tegra_rt5640 = { 906 .components = "codec:rt5640", 907 .dai_link = &tegra_rt5640_dai, 908 .num_links = 1, 909 .fully_routed = true, 910 }; 911 912 static const struct tegra_asoc_data tegra_rt5640_data = { 913 .mclk_rate = tegra_machine_mclk_rate_256, 914 .card = &snd_soc_tegra_rt5640, 915 .add_common_dapm_widgets = true, 916 .add_common_controls = true, 917 .add_common_snd_ops = true, 918 .add_hp_jack = true, 919 }; 920 921 /* RT5632 machine */ 922 923 SND_SOC_DAILINK_DEFS(rt5632_hifi, 924 DAILINK_COMP_ARRAY(COMP_EMPTY()), 925 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "alc5632-hifi")), 926 DAILINK_COMP_ARRAY(COMP_EMPTY())); 927 928 static struct snd_soc_dai_link tegra_rt5632_dai = { 929 .name = "ALC5632", 930 .stream_name = "ALC5632 PCM", 931 .init = tegra_rt5677_init, 932 .dai_fmt = SND_SOC_DAIFMT_I2S | 933 SND_SOC_DAIFMT_NB_NF | 934 SND_SOC_DAIFMT_CBC_CFC, 935 SND_SOC_DAILINK_REG(rt5632_hifi), 936 }; 937 938 static struct snd_soc_card snd_soc_tegra_rt5632 = { 939 .components = "codec:rt5632", 940 .dai_link = &tegra_rt5632_dai, 941 .num_links = 1, 942 .fully_routed = true, 943 }; 944 945 static const struct tegra_asoc_data tegra_rt5632_data = { 946 .mclk_rate = tegra_machine_mclk_rate_512, 947 .card = &snd_soc_tegra_rt5632, 948 .add_common_dapm_widgets = true, 949 .add_common_controls = true, 950 .add_common_snd_ops = true, 951 .add_headset_jack = true, 952 }; 953 954 /* RT5631 machine */ 955 956 SND_SOC_DAILINK_DEFS(rt5631_hifi, 957 DAILINK_COMP_ARRAY(COMP_EMPTY()), 958 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "rt5631-hifi")), 959 DAILINK_COMP_ARRAY(COMP_EMPTY())); 960 961 static struct snd_soc_dai_link tegra_rt5631_dai = { 962 .name = "RT5631", 963 .stream_name = "RT5631 PCM", 964 .init = tegra_asoc_machine_init, 965 .dai_fmt = SND_SOC_DAIFMT_I2S | 966 SND_SOC_DAIFMT_NB_NF | 967 SND_SOC_DAIFMT_CBC_CFC, 968 SND_SOC_DAILINK_REG(rt5631_hifi), 969 }; 970 971 static struct snd_soc_card snd_soc_tegra_rt5631 = { 972 .components = "codec:rt5631", 973 .dai_link = &tegra_rt5631_dai, 974 .num_links = 1, 975 .fully_routed = true, 976 }; 977 978 static const struct tegra_asoc_data tegra_rt5631_data = { 979 .mclk_rate = tegra_machine_mclk_rate_6mhz, 980 .card = &snd_soc_tegra_rt5631, 981 .add_common_dapm_widgets = true, 982 .add_common_controls = true, 983 .add_common_snd_ops = true, 984 .add_mic_jack = true, 985 .add_hp_jack = true, 986 }; 987 988 static const struct of_device_id tegra_machine_of_match[] = { 989 { .compatible = "nvidia,tegra-audio-trimslice", .data = &tegra_trimslice_data }, 990 { .compatible = "nvidia,tegra-audio-max98090", .data = &tegra_max98090_data }, 991 { .compatible = "nvidia,tegra-audio-max98088", .data = &tegra_max98088_data }, 992 { .compatible = "nvidia,tegra-audio-max98089", .data = &tegra_max98088_data }, 993 { .compatible = "nvidia,tegra-audio-sgtl5000", .data = &tegra_sgtl5000_data }, 994 { .compatible = "nvidia,tegra-audio-wm9712", .data = &tegra_wm9712_data }, 995 { .compatible = "nvidia,tegra-audio-wm8753", .data = &tegra_wm8753_data }, 996 { .compatible = "nvidia,tegra-audio-rt5677", .data = &tegra_rt5677_data }, 997 { .compatible = "nvidia,tegra-audio-rt5640", .data = &tegra_rt5640_data }, 998 { .compatible = "nvidia,tegra-audio-alc5632", .data = &tegra_rt5632_data }, 999 { .compatible = "nvidia,tegra-audio-rt5631", .data = &tegra_rt5631_data }, 1000 {}, 1001 }; 1002 MODULE_DEVICE_TABLE(of, tegra_machine_of_match); 1003 1004 static struct platform_driver tegra_asoc_machine_driver = { 1005 .driver = { 1006 .name = "tegra-audio", 1007 .of_match_table = tegra_machine_of_match, 1008 .pm = &snd_soc_pm_ops, 1009 }, 1010 .probe = tegra_asoc_machine_probe, 1011 }; 1012 module_platform_driver(tegra_asoc_machine_driver); 1013 1014 MODULE_AUTHOR("Anatol Pomozov <anatol@google.com>"); 1015 MODULE_AUTHOR("Andrey Danin <danindrey@mail.ru>"); 1016 MODULE_AUTHOR("Dmitry Osipenko <digetx@gmail.com>"); 1017 MODULE_AUTHOR("Ion Agorria <ion@agorria.com>"); 1018 MODULE_AUTHOR("Leon Romanovsky <leon@leon.nu>"); 1019 MODULE_AUTHOR("Lucas Stach <dev@lynxeye.de>"); 1020 MODULE_AUTHOR("Marc Dietrich <marvin24@gmx.de>"); 1021 MODULE_AUTHOR("Marcel Ziswiler <marcel@ziswiler.com>"); 1022 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>"); 1023 MODULE_AUTHOR("Stephen Warren <swarren@nvidia.com>"); 1024 MODULE_AUTHOR("Svyatoslav Ryhel <clamor95@gmail.com>"); 1025 MODULE_DESCRIPTION("Tegra machine ASoC driver"); 1026 MODULE_LICENSE("GPL"); 1027