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