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 = substream->private_data;
  96         struct snd_soc_component *component = rtd->codec_dai->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 = substream->private_data;
 137         struct snd_soc_component *component = rtd->codec_dai->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 = substream->private_data;
 191         struct snd_soc_component *component = rtd->codec_dai->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 = substream->private_data;
 212         struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
 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].name);
 286
 287         if (dapm->dev != rtd->codec_dai->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         struct snd_soc_dai_link_component dlc = { 0 };
 311         unsigned int ch_map[] = { 0, 1 };
 312         struct snd_soc_dai *amp_pdm_dai;
 313         struct snd_soc_pcm_runtime *rtd;
 314         struct snd_soc_dai *aif1_dai;
 315         struct snd_soc_dai *aif2_dai;
 316         int ret;
 317
 318         rtd = snd_soc_get_pcm_runtime(card, card->dai_link[TM2_DAI_AIF1].name);
 319         aif1_dai = rtd->codec_dai;
 320         priv->component = rtd->codec_dai->component;
 321
 322         ret = snd_soc_dai_set_sysclk(aif1_dai, ARIZONA_CLK_SYSCLK, 0, 0);
 323         if (ret < 0) {
 324                 dev_err(aif1_dai->dev, "Failed to set SYSCLK: %d\n", ret);
 325                 return ret;
 326         }
 327
 328         rtd = snd_soc_get_pcm_runtime(card, card->dai_link[TM2_DAI_AIF2].name);
 329         aif2_dai = rtd->codec_dai;
 330
 331         ret = snd_soc_dai_set_sysclk(aif2_dai, ARIZONA_CLK_ASYNCCLK, 0, 0);
 332         if (ret < 0) {
 333                 dev_err(aif2_dai->dev, "Failed to set ASYNCCLK: %d\n", ret);
 334                 return ret;
 335         }
 336
 337         dlc.of_node = tm2_speaker_amp_dev.codec_of_node;
 338         amp_pdm_dai = snd_soc_find_dai(&dlc);
 339         if (!amp_pdm_dai)
 340                 return -ENODEV;
 341
 342         /* Set the MAX98504 V/I sense PDM Tx DAI channel mapping */
 343         ret = snd_soc_dai_set_channel_map(amp_pdm_dai, ARRAY_SIZE(ch_map),
 344                                           ch_map, 0, NULL);
 345         if (ret < 0)
 346                 return ret;
 347
 348         ret = snd_soc_dai_set_tdm_slot(amp_pdm_dai, 0x3, 0x0, 2, 16);
 349         if (ret < 0)
 350                 return ret;
 351
 352         return 0;
 353 }
 354
 355 static const struct snd_kcontrol_new tm2_controls[] = {
 356         SOC_DAPM_PIN_SWITCH("HP"),
 357         SOC_DAPM_PIN_SWITCH("SPK"),
 358         SOC_DAPM_PIN_SWITCH("RCV"),
 359         SOC_DAPM_PIN_SWITCH("VPS"),
 360         SOC_DAPM_PIN_SWITCH("HDMI"),
 361
 362         SOC_DAPM_PIN_SWITCH("Main Mic"),
 363         SOC_DAPM_PIN_SWITCH("Sub Mic"),
 364         SOC_DAPM_PIN_SWITCH("Third Mic"),
 365
 366         SOC_DAPM_PIN_SWITCH("Headset Mic"),
 367 };
 368
 369 static const struct snd_soc_dapm_widget tm2_dapm_widgets[] = {
 370         SND_SOC_DAPM_HP("HP", NULL),
 371         SND_SOC_DAPM_SPK("SPK", NULL),
 372         SND_SOC_DAPM_SPK("RCV", NULL),
 373         SND_SOC_DAPM_LINE("VPS", NULL),
 374         SND_SOC_DAPM_LINE("HDMI", NULL),
 375
 376         SND_SOC_DAPM_MIC("Main Mic", tm2_mic_bias),
 377         SND_SOC_DAPM_MIC("Sub Mic", NULL),
 378         SND_SOC_DAPM_MIC("Third Mic", NULL),
 379
 380         SND_SOC_DAPM_MIC("Headset Mic", NULL),
 381 };
 382
 383 static const struct snd_soc_component_driver tm2_component = {
 384         .name   = "tm2-audio",
 385 };
 386
 387 static struct snd_soc_dai_driver tm2_ext_dai[] = {
 388         {
 389                 .name = "Voice call",
 390                 .playback = {
 391                         .channels_min = 1,
 392                         .channels_max = 4,
 393                         .rate_min = 8000,
 394                         .rate_max = 48000,
 395                         .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |
 396                                         SNDRV_PCM_RATE_48000),
 397                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 398                 },
 399                 .capture = {
 400                         .channels_min = 1,
 401                         .channels_max = 4,
 402                         .rate_min = 8000,
 403                         .rate_max = 48000,
 404                         .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |
 405                                         SNDRV_PCM_RATE_48000),
 406                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 407                 },
 408         },
 409         {
 410                 .name = "Bluetooth",
 411                 .playback = {
 412                         .channels_min = 1,
 413                         .channels_max = 4,
 414                         .rate_min = 8000,
 415                         .rate_max = 16000,
 416                         .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000),
 417                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 418                 },
 419                 .capture = {
 420                         .channels_min = 1,
 421                         .channels_max = 2,
 422                         .rate_min = 8000,
 423                         .rate_max = 16000,
 424                         .rates = (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000),
 425                         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 426                 },
 427         },
 428 };
 429
 430 static struct snd_soc_dai_link tm2_dai_links[] = {
 431         {
 432                 .name           = "WM5110 AIF1",
 433                 .stream_name    = "HiFi Primary",
 434                 .cpu_dai_name   = SAMSUNG_I2S_DAI,
 435                 .codec_dai_name = "wm5110-aif1",
 436                 .ops            = &tm2_aif1_ops,
 437                 .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 438                                   SND_SOC_DAIFMT_CBM_CFM,
 439         }, {
 440                 .name           = "WM5110 Voice",
 441                 .stream_name    = "Voice call",
 442                 .cpu_dai_name   = SAMSUNG_I2S_DAI,
 443                 .codec_dai_name = "wm5110-aif2",
 444                 .ops            = &tm2_aif2_ops,
 445                 .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 446                                   SND_SOC_DAIFMT_CBM_CFM,
 447                 .ignore_suspend = 1,
 448         }, {
 449                 .name           = "WM5110 BT",
 450                 .stream_name    = "Bluetooth",
 451                 .cpu_dai_name   = SAMSUNG_I2S_DAI,
 452                 .codec_dai_name = "wm5110-aif3",
 453                 .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 454                                   SND_SOC_DAIFMT_CBM_CFM,
 455                 .ignore_suspend = 1,
 456         }, {
 457                 .name           = "HDMI",
 458                 .stream_name    = "i2s1",
 459                 .ops            = &tm2_hdmi_ops,
 460                 .dai_fmt        = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
 461                                   SND_SOC_DAIFMT_CBS_CFS,
 462         }
 463 };
 464
 465 static struct snd_soc_card tm2_card = {
 466         .owner                  = THIS_MODULE,
 467
 468         .dai_link               = tm2_dai_links,
 469         .controls               = tm2_controls,
 470         .num_controls           = ARRAY_SIZE(tm2_controls),
 471         .dapm_widgets           = tm2_dapm_widgets,
 472         .num_dapm_widgets       = ARRAY_SIZE(tm2_dapm_widgets),
 473         .aux_dev                = &tm2_speaker_amp_dev,
 474         .num_aux_devs           = 1,
 475
 476         .late_probe             = tm2_late_probe,
 477         .set_bias_level         = tm2_set_bias_level,
 478 };
 479
 480 static int tm2_probe(struct platform_device *pdev)
 481 {
 482         struct device_node *cpu_dai_node[2] = {};
 483         struct device_node *codec_dai_node[2] = {};
 484         const char *cells_name = NULL;
 485         struct device *dev = &pdev->dev;
 486         struct snd_soc_card *card = &tm2_card;
 487         struct tm2_machine_priv *priv;
 488         struct of_phandle_args args;
 489         struct snd_soc_dai_link *dai_link;
 490         int num_codecs, ret, i;
 491
 492         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 493         if (!priv)
 494                 return -ENOMEM;
 495
 496         snd_soc_card_set_drvdata(card, priv);
 497         card->dev = dev;
 498
 499         priv->gpio_mic_bias = devm_gpiod_get(dev, "mic-bias", GPIOD_OUT_HIGH);
 500         if (IS_ERR(priv->gpio_mic_bias)) {
 501                 dev_err(dev, "Failed to get mic bias gpio\n");
 502                 return PTR_ERR(priv->gpio_mic_bias);
 503         }
 504
 505         ret = snd_soc_of_parse_card_name(card, "model");
 506         if (ret < 0) {
 507                 dev_err(dev, "Card name is not specified\n");
 508                 return ret;
 509         }
 510
 511         ret = snd_soc_of_parse_audio_routing(card, "samsung,audio-routing");
 512         if (ret < 0) {
 513                 dev_err(dev, "Audio routing is not specified or invalid\n");
 514                 return ret;
 515         }
 516
 517         card->aux_dev[0].codec_of_node = of_parse_phandle(dev->of_node,
 518                                                         "audio-amplifier", 0);
 519         if (!card->aux_dev[0].codec_of_node) {
 520                 dev_err(dev, "audio-amplifier property invalid or missing\n");
 521                 return -EINVAL;
 522         }
 523
 524         num_codecs = of_count_phandle_with_args(dev->of_node, "audio-codec",
 525                                                  NULL);
 526
 527         /* Skip the HDMI link if not specified in DT */
 528         if (num_codecs > 1) {
 529                 card->num_links = ARRAY_SIZE(tm2_dai_links);
 530                 cells_name = "#sound-dai-cells";
 531         } else {
 532                 card->num_links = ARRAY_SIZE(tm2_dai_links) - 1;
 533         }
 534
 535         for (i = 0; i < num_codecs; i++) {
 536                 struct of_phandle_args args;
 537
 538                 ret = of_parse_phandle_with_args(dev->of_node, "i2s-controller",
 539                                                  cells_name, i, &args);
 540                 if (!args.np) {
 541                         dev_err(dev, "i2s-controller property parse error: %d\n", i);
 542                         ret = -EINVAL;
 543                         goto dai_node_put;
 544                 }
 545                 cpu_dai_node[i] = args.np;
 546
 547                 codec_dai_node[i] = of_parse_phandle(dev->of_node,
 548                                                      "audio-codec", i);
 549                 if (!codec_dai_node[i]) {
 550                         dev_err(dev, "audio-codec property parse error\n");
 551                         ret = -EINVAL;
 552                         goto dai_node_put;
 553                 }
 554         }
 555
 556         /* Initialize WM5110 - I2S and HDMI - I2S1 DAI links */
 557         for_each_card_prelinks(card, i, dai_link) {
 558                 unsigned int dai_index = 0; /* WM5110 */
 559
 560                 dai_link->cpu_name = NULL;
 561                 dai_link->platform_name = NULL;
 562
 563                 if (num_codecs > 1 && i == card->num_links - 1)
 564                         dai_index = 1; /* HDMI */
 565
 566                 dai_link->codec_of_node = codec_dai_node[dai_index];
 567                 dai_link->cpu_of_node = cpu_dai_node[dai_index];
 568                 dai_link->platform_of_node = cpu_dai_node[dai_index];
 569         }
 570
 571         if (num_codecs > 1) {
 572                 /* HDMI DAI link (I2S1) */
 573                 i = card->num_links - 1;
 574
 575                 ret = of_parse_phandle_with_fixed_args(dev->of_node,
 576                                                 "audio-codec", 0, 1, &args);
 577                 if (ret) {
 578                         dev_err(dev, "audio-codec property parse error\n");
 579                         goto dai_node_put;
 580                 }
 581
 582                 ret = snd_soc_get_dai_name(&args, &card->dai_link[i].codec_dai_name);
 583                 if (ret) {
 584                         dev_err(dev, "Unable to get codec_dai_name\n");
 585                         goto dai_node_put;
 586                 }
 587         }
 588
 589         ret = devm_snd_soc_register_component(dev, &tm2_component,
 590                                 tm2_ext_dai, ARRAY_SIZE(tm2_ext_dai));
 591         if (ret < 0) {
 592                 dev_err(dev, "Failed to register component: %d\n", ret);
 593                 goto dai_node_put;
 594         }
 595
 596         ret = devm_snd_soc_register_card(dev, card);
 597         if (ret < 0) {
 598                 dev_err(dev, "Failed to register card: %d\n", ret);
 599                 goto dai_node_put;
 600         }
 601
 602 dai_node_put:
 603         for (i = 0; i < num_codecs; i++) {
 604                 of_node_put(codec_dai_node[i]);
 605                 of_node_put(cpu_dai_node[i]);
 606         }
 607
 608         of_node_put(card->aux_dev[0].codec_of_node);
 609
 610         return ret;
 611 }
 612
 613 static int tm2_pm_prepare(struct device *dev)
 614 {
 615         struct snd_soc_card *card = dev_get_drvdata(dev);
 616
 617         return tm2_stop_sysclk(card);
 618 }
 619
 620 static void tm2_pm_complete(struct device *dev)
 621 {
 622         struct snd_soc_card *card = dev_get_drvdata(dev);
 623
 624         tm2_start_sysclk(card);
 625 }
 626
 627 static const struct dev_pm_ops tm2_pm_ops = {
 628         .prepare        = tm2_pm_prepare,
 629         .suspend        = snd_soc_suspend,
 630         .resume         = snd_soc_resume,
 631         .complete       = tm2_pm_complete,
 632         .freeze         = snd_soc_suspend,
 633         .thaw           = snd_soc_resume,
 634         .poweroff       = snd_soc_poweroff,
 635         .restore        = snd_soc_resume,
 636 };
 637
 638 static const struct of_device_id tm2_of_match[] = {
 639         { .compatible = "samsung,tm2-audio" },
 640         { },
 641 };
 642 MODULE_DEVICE_TABLE(of, tm2_of_match);
 643
 644 static struct platform_driver tm2_driver = {
 645         .driver = {
 646                 .name           = "tm2-audio",
 647                 .pm             = &tm2_pm_ops,
 648                 .of_match_table = tm2_of_match,
 649         },
 650         .probe  = tm2_probe,
 651 };
 652 module_platform_driver(tm2_driver);
 653
 654 MODULE_AUTHOR("Inha Song <ideal.song@samsung.com>");
 655 MODULE_DESCRIPTION("ALSA SoC Exynos TM2 Audio Support");
 656 MODULE_LICENSE("GPL v2");