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 SND_SOC_DAILINK_DEFS(aif1, 431 DAILINK_COMP_ARRAY(COMP_CPU(SAMSUNG_I2S_DAI)), 432 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "wm5110-aif1")), 433 DAILINK_COMP_ARRAY(COMP_EMPTY())); 434 435 SND_SOC_DAILINK_DEFS(voice, 436 DAILINK_COMP_ARRAY(COMP_CPU(SAMSUNG_I2S_DAI)), 437 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "wm5110-aif2")), 438 DAILINK_COMP_ARRAY(COMP_EMPTY())); 439 440 SND_SOC_DAILINK_DEFS(bt, 441 DAILINK_COMP_ARRAY(COMP_CPU(SAMSUNG_I2S_DAI)), 442 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "wm5110-aif3")), 443 DAILINK_COMP_ARRAY(COMP_EMPTY())); 444 445 SND_SOC_DAILINK_DEFS(hdmi, 446 DAILINK_COMP_ARRAY(COMP_EMPTY()), 447 DAILINK_COMP_ARRAY(COMP_EMPTY()), 448 DAILINK_COMP_ARRAY(COMP_EMPTY())); 449 450 static struct snd_soc_dai_link tm2_dai_links[] = { 451 { 452 .name = "WM5110 AIF1", 453 .stream_name = "HiFi Primary", 454 .ops = &tm2_aif1_ops, 455 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | 456 SND_SOC_DAIFMT_CBM_CFM, 457 SND_SOC_DAILINK_REG(aif1), 458 }, { 459 .name = "WM5110 Voice", 460 .stream_name = "Voice call", 461 .ops = &tm2_aif2_ops, 462 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | 463 SND_SOC_DAIFMT_CBM_CFM, 464 .ignore_suspend = 1, 465 SND_SOC_DAILINK_REG(voice), 466 }, { 467 .name = "WM5110 BT", 468 .stream_name = "Bluetooth", 469 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | 470 SND_SOC_DAIFMT_CBM_CFM, 471 .ignore_suspend = 1, 472 SND_SOC_DAILINK_REG(bt), 473 }, { 474 .name = "HDMI", 475 .stream_name = "i2s1", 476 .ops = &tm2_hdmi_ops, 477 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | 478 SND_SOC_DAIFMT_CBS_CFS, 479 SND_SOC_DAILINK_REG(hdmi), 480 } 481 }; 482 483 static struct snd_soc_card tm2_card = { 484 .owner = THIS_MODULE, 485 486 .dai_link = tm2_dai_links, 487 .controls = tm2_controls, 488 .num_controls = ARRAY_SIZE(tm2_controls), 489 .dapm_widgets = tm2_dapm_widgets, 490 .num_dapm_widgets = ARRAY_SIZE(tm2_dapm_widgets), 491 .aux_dev = &tm2_speaker_amp_dev, 492 .num_aux_devs = 1, 493 494 .late_probe = tm2_late_probe, 495 .set_bias_level = tm2_set_bias_level, 496 }; 497 498 static int tm2_probe(struct platform_device *pdev) 499 { 500 struct device_node *cpu_dai_node[2] = {}; 501 struct device_node *codec_dai_node[2] = {}; 502 const char *cells_name = NULL; 503 struct device *dev = &pdev->dev; 504 struct snd_soc_card *card = &tm2_card; 505 struct tm2_machine_priv *priv; 506 struct of_phandle_args args; 507 struct snd_soc_dai_link *dai_link; 508 int num_codecs, ret, i; 509 510 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 511 if (!priv) 512 return -ENOMEM; 513 514 snd_soc_card_set_drvdata(card, priv); 515 card->dev = dev; 516 517 priv->gpio_mic_bias = devm_gpiod_get(dev, "mic-bias", GPIOD_OUT_HIGH); 518 if (IS_ERR(priv->gpio_mic_bias)) { 519 dev_err(dev, "Failed to get mic bias gpio\n"); 520 return PTR_ERR(priv->gpio_mic_bias); 521 } 522 523 ret = snd_soc_of_parse_card_name(card, "model"); 524 if (ret < 0) { 525 dev_err(dev, "Card name is not specified\n"); 526 return ret; 527 } 528 529 ret = snd_soc_of_parse_audio_routing(card, "samsung,audio-routing"); 530 if (ret < 0) { 531 dev_err(dev, "Audio routing is not specified or invalid\n"); 532 return ret; 533 } 534 535 card->aux_dev[0].codec_of_node = of_parse_phandle(dev->of_node, 536 "audio-amplifier", 0); 537 if (!card->aux_dev[0].codec_of_node) { 538 dev_err(dev, "audio-amplifier property invalid or missing\n"); 539 return -EINVAL; 540 } 541 542 num_codecs = of_count_phandle_with_args(dev->of_node, "audio-codec", 543 NULL); 544 545 /* Skip the HDMI link if not specified in DT */ 546 if (num_codecs > 1) { 547 card->num_links = ARRAY_SIZE(tm2_dai_links); 548 cells_name = "#sound-dai-cells"; 549 } else { 550 card->num_links = ARRAY_SIZE(tm2_dai_links) - 1; 551 } 552 553 for (i = 0; i < num_codecs; i++) { 554 struct of_phandle_args args; 555 556 ret = of_parse_phandle_with_args(dev->of_node, "i2s-controller", 557 cells_name, i, &args); 558 if (!args.np) { 559 dev_err(dev, "i2s-controller property parse error: %d\n", i); 560 ret = -EINVAL; 561 goto dai_node_put; 562 } 563 cpu_dai_node[i] = args.np; 564 565 codec_dai_node[i] = of_parse_phandle(dev->of_node, 566 "audio-codec", i); 567 if (!codec_dai_node[i]) { 568 dev_err(dev, "audio-codec property parse error\n"); 569 ret = -EINVAL; 570 goto dai_node_put; 571 } 572 } 573 574 /* Initialize WM5110 - I2S and HDMI - I2S1 DAI links */ 575 for_each_card_prelinks(card, i, dai_link) { 576 unsigned int dai_index = 0; /* WM5110 */ 577 578 dai_link->cpus->name = NULL; 579 dai_link->platforms->name = NULL; 580 581 if (num_codecs > 1 && i == card->num_links - 1) 582 dai_index = 1; /* HDMI */ 583 584 dai_link->codecs->of_node = codec_dai_node[dai_index]; 585 dai_link->cpus->of_node = cpu_dai_node[dai_index]; 586 dai_link->platforms->of_node = cpu_dai_node[dai_index]; 587 } 588 589 if (num_codecs > 1) { 590 /* HDMI DAI link (I2S1) */ 591 i = card->num_links - 1; 592 593 ret = of_parse_phandle_with_fixed_args(dev->of_node, 594 "audio-codec", 0, 1, &args); 595 if (ret) { 596 dev_err(dev, "audio-codec property parse error\n"); 597 goto dai_node_put; 598 } 599 600 ret = snd_soc_get_dai_name(&args, &card->dai_link[i].codecs->dai_name); 601 if (ret) { 602 dev_err(dev, "Unable to get codec_dai_name\n"); 603 goto dai_node_put; 604 } 605 } 606 607 ret = devm_snd_soc_register_component(dev, &tm2_component, 608 tm2_ext_dai, ARRAY_SIZE(tm2_ext_dai)); 609 if (ret < 0) { 610 dev_err(dev, "Failed to register component: %d\n", ret); 611 goto dai_node_put; 612 } 613 614 ret = devm_snd_soc_register_card(dev, card); 615 if (ret < 0) { 616 dev_err(dev, "Failed to register card: %d\n", ret); 617 goto dai_node_put; 618 } 619 620 dai_node_put: 621 for (i = 0; i < num_codecs; i++) { 622 of_node_put(codec_dai_node[i]); 623 of_node_put(cpu_dai_node[i]); 624 } 625 626 of_node_put(card->aux_dev[0].codec_of_node); 627 628 return ret; 629 } 630 631 static int tm2_pm_prepare(struct device *dev) 632 { 633 struct snd_soc_card *card = dev_get_drvdata(dev); 634 635 return tm2_stop_sysclk(card); 636 } 637 638 static void tm2_pm_complete(struct device *dev) 639 { 640 struct snd_soc_card *card = dev_get_drvdata(dev); 641 642 tm2_start_sysclk(card); 643 } 644 645 static const struct dev_pm_ops tm2_pm_ops = { 646 .prepare = tm2_pm_prepare, 647 .suspend = snd_soc_suspend, 648 .resume = snd_soc_resume, 649 .complete = tm2_pm_complete, 650 .freeze = snd_soc_suspend, 651 .thaw = snd_soc_resume, 652 .poweroff = snd_soc_poweroff, 653 .restore = snd_soc_resume, 654 }; 655 656 static const struct of_device_id tm2_of_match[] = { 657 { .compatible = "samsung,tm2-audio" }, 658 { }, 659 }; 660 MODULE_DEVICE_TABLE(of, tm2_of_match); 661 662 static struct platform_driver tm2_driver = { 663 .driver = { 664 .name = "tm2-audio", 665 .pm = &tm2_pm_ops, 666 .of_match_table = tm2_of_match, 667 }, 668 .probe = tm2_probe, 669 }; 670 module_platform_driver(tm2_driver); 671 672 MODULE_AUTHOR("Inha Song <ideal.song@samsung.com>"); 673 MODULE_DESCRIPTION("ALSA SoC Exynos TM2 Audio Support"); 674 MODULE_LICENSE("GPL v2"); 675