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