sound/soc/samsung/tm2_wm5110.c

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