sound/soc/tegra/tegra_asoc_machine.c

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