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"); 674