1 // SPDX-License-Identifier: GPL-2.0+ 2 #include <linux/extcon.h> 3 #include <linux/iio/consumer.h> 4 #include <linux/input-event-codes.h> 5 #include <linux/mfd/wm8994/registers.h> 6 #include <linux/module.h> 7 #include <linux/of.h> 8 #include <linux/of_device.h> 9 #include <linux/of_gpio.h> 10 #include <linux/regulator/consumer.h> 11 #include <sound/jack.h> 12 #include <sound/pcm_params.h> 13 #include <sound/soc.h> 14 15 #include "i2s.h" 16 #include "../codecs/wm8994.h" 17 18 #define ARIES_MCLK1_FREQ 24000000 19 20 struct aries_wm8994_variant { 21 unsigned int modem_dai_fmt; 22 bool has_fm_radio; 23 }; 24 25 struct aries_wm8994_data { 26 struct extcon_dev *usb_extcon; 27 struct regulator *reg_main_micbias; 28 struct regulator *reg_headset_micbias; 29 struct gpio_desc *gpio_headset_detect; 30 struct gpio_desc *gpio_headset_key; 31 struct gpio_desc *gpio_earpath_sel; 32 struct iio_channel *adc; 33 const struct aries_wm8994_variant *variant; 34 }; 35 36 /* USB dock */ 37 static struct snd_soc_jack aries_dock; 38 39 static struct snd_soc_jack_pin dock_pins[] = { 40 { 41 .pin = "LINE", 42 .mask = SND_JACK_LINEOUT, 43 }, 44 }; 45 46 static int aries_extcon_notifier(struct notifier_block *this, 47 unsigned long connected, void *_cmd) 48 { 49 if (connected) 50 snd_soc_jack_report(&aries_dock, SND_JACK_LINEOUT, 51 SND_JACK_LINEOUT); 52 else 53 snd_soc_jack_report(&aries_dock, 0, SND_JACK_LINEOUT); 54 55 return NOTIFY_DONE; 56 } 57 58 static struct notifier_block aries_extcon_notifier_block = { 59 .notifier_call = aries_extcon_notifier, 60 }; 61 62 /* Headset jack */ 63 static struct snd_soc_jack aries_headset; 64 65 static struct snd_soc_jack_pin jack_pins[] = { 66 { 67 .pin = "HP", 68 .mask = SND_JACK_HEADPHONE, 69 }, { 70 .pin = "Headset Mic", 71 .mask = SND_JACK_MICROPHONE, 72 }, 73 }; 74 75 static struct snd_soc_jack_zone headset_zones[] = { 76 { 77 .min_mv = 0, 78 .max_mv = 241, 79 .jack_type = SND_JACK_HEADPHONE, 80 }, { 81 .min_mv = 242, 82 .max_mv = 2980, 83 .jack_type = SND_JACK_HEADSET, 84 }, { 85 .min_mv = 2981, 86 .max_mv = UINT_MAX, 87 .jack_type = SND_JACK_HEADPHONE, 88 }, 89 }; 90 91 static irqreturn_t headset_det_irq_thread(int irq, void *data) 92 { 93 struct aries_wm8994_data *priv = (struct aries_wm8994_data *) data; 94 int ret = 0; 95 int time_left_ms = 300; 96 int adc; 97 98 while (time_left_ms > 0) { 99 if (!gpiod_get_value(priv->gpio_headset_detect)) { 100 snd_soc_jack_report(&aries_headset, 0, 101 SND_JACK_HEADSET); 102 gpiod_set_value(priv->gpio_earpath_sel, 0); 103 return IRQ_HANDLED; 104 } 105 msleep(20); 106 time_left_ms -= 20; 107 } 108 109 /* Temporarily enable micbias and earpath selector */ 110 ret = regulator_enable(priv->reg_headset_micbias); 111 if (ret) 112 pr_err("%s failed to enable micbias: %d", __func__, ret); 113 114 gpiod_set_value(priv->gpio_earpath_sel, 1); 115 116 ret = iio_read_channel_processed(priv->adc, &adc); 117 if (ret < 0) { 118 /* failed to read ADC, so assume headphone */ 119 pr_err("%s failed to read ADC, assuming headphones", __func__); 120 snd_soc_jack_report(&aries_headset, SND_JACK_HEADPHONE, 121 SND_JACK_HEADSET); 122 } else { 123 snd_soc_jack_report(&aries_headset, 124 snd_soc_jack_get_type(&aries_headset, adc), 125 SND_JACK_HEADSET); 126 } 127 128 ret = regulator_disable(priv->reg_headset_micbias); 129 if (ret) 130 pr_err("%s failed disable micbias: %d", __func__, ret); 131 132 /* Disable earpath selector when no mic connected */ 133 if (!(aries_headset.status & SND_JACK_MICROPHONE)) 134 gpiod_set_value(priv->gpio_earpath_sel, 0); 135 136 return IRQ_HANDLED; 137 } 138 139 static int headset_button_check(void *data) 140 { 141 struct aries_wm8994_data *priv = (struct aries_wm8994_data *) data; 142 143 /* Filter out keypresses when 4 pole jack not detected */ 144 if (gpiod_get_value_cansleep(priv->gpio_headset_key) && 145 aries_headset.status & SND_JACK_MICROPHONE) 146 return SND_JACK_BTN_0; 147 148 return 0; 149 } 150 151 static struct snd_soc_jack_gpio headset_button_gpio[] = { 152 { 153 .name = "Media Button", 154 .report = SND_JACK_BTN_0, 155 .debounce_time = 30, 156 .jack_status_check = headset_button_check, 157 }, 158 }; 159 160 static int aries_spk_cfg(struct snd_soc_dapm_widget *w, 161 struct snd_kcontrol *kcontrol, int event) 162 { 163 struct snd_soc_card *card = w->dapm->card; 164 struct snd_soc_pcm_runtime *rtd; 165 struct snd_soc_component *component; 166 int ret = 0; 167 168 rtd = snd_soc_get_pcm_runtime(card, &card->dai_link[0]); 169 component = asoc_rtd_to_codec(rtd, 0)->component; 170 171 /** 172 * We have an odd setup - the SPKMODE pin is pulled up so 173 * we only have access to the left side SPK configs, 174 * but SPKOUTR isn't bridged so when playing back in 175 * stereo, we only get the left hand channel. The only 176 * option we're left with is to force the AIF into mono 177 * mode. 178 */ 179 switch (event) { 180 case SND_SOC_DAPM_POST_PMU: 181 ret = snd_soc_component_update_bits(component, 182 WM8994_AIF1_DAC1_FILTERS_1, 183 WM8994_AIF1DAC1_MONO, WM8994_AIF1DAC1_MONO); 184 break; 185 case SND_SOC_DAPM_PRE_PMD: 186 ret = snd_soc_component_update_bits(component, 187 WM8994_AIF1_DAC1_FILTERS_1, 188 WM8994_AIF1DAC1_MONO, 0); 189 break; 190 } 191 192 return ret; 193 } 194 195 static int aries_main_bias(struct snd_soc_dapm_widget *w, 196 struct snd_kcontrol *kcontrol, int event) 197 { 198 struct snd_soc_card *card = w->dapm->card; 199 struct aries_wm8994_data *priv = snd_soc_card_get_drvdata(card); 200 int ret = 0; 201 202 switch (event) { 203 case SND_SOC_DAPM_PRE_PMU: 204 ret = regulator_enable(priv->reg_main_micbias); 205 break; 206 case SND_SOC_DAPM_POST_PMD: 207 ret = regulator_disable(priv->reg_main_micbias); 208 break; 209 } 210 211 return ret; 212 } 213 214 static int aries_headset_bias(struct snd_soc_dapm_widget *w, 215 struct snd_kcontrol *kcontrol, int event) 216 { 217 struct snd_soc_card *card = w->dapm->card; 218 struct aries_wm8994_data *priv = snd_soc_card_get_drvdata(card); 219 int ret = 0; 220 221 switch (event) { 222 case SND_SOC_DAPM_PRE_PMU: 223 ret = regulator_enable(priv->reg_headset_micbias); 224 break; 225 case SND_SOC_DAPM_POST_PMD: 226 ret = regulator_disable(priv->reg_headset_micbias); 227 break; 228 } 229 230 return ret; 231 } 232 233 static const struct snd_kcontrol_new aries_controls[] = { 234 SOC_DAPM_PIN_SWITCH("Modem In"), 235 SOC_DAPM_PIN_SWITCH("Modem Out"), 236 }; 237 238 static const struct snd_soc_dapm_widget aries_dapm_widgets[] = { 239 SND_SOC_DAPM_HP("HP", NULL), 240 241 SND_SOC_DAPM_SPK("SPK", aries_spk_cfg), 242 SND_SOC_DAPM_SPK("RCV", NULL), 243 244 SND_SOC_DAPM_LINE("LINE", NULL), 245 246 SND_SOC_DAPM_MIC("Main Mic", aries_main_bias), 247 SND_SOC_DAPM_MIC("Headset Mic", aries_headset_bias), 248 249 SND_SOC_DAPM_MIC("Bluetooth Mic", NULL), 250 SND_SOC_DAPM_SPK("Bluetooth SPK", NULL), 251 252 SND_SOC_DAPM_LINE("Modem In", NULL), 253 SND_SOC_DAPM_LINE("Modem Out", NULL), 254 255 /* This must be last as it is conditionally not used */ 256 SND_SOC_DAPM_LINE("FM In", NULL), 257 }; 258 259 static int aries_hw_params(struct snd_pcm_substream *substream, 260 struct snd_pcm_hw_params *params) 261 { 262 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 263 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0); 264 unsigned int pll_out; 265 int ret; 266 267 /* AIF1CLK should be >=3MHz for optimal performance */ 268 if (params_width(params) == 24) 269 pll_out = params_rate(params) * 384; 270 else if (params_rate(params) == 8000 || params_rate(params) == 11025) 271 pll_out = params_rate(params) * 512; 272 else 273 pll_out = params_rate(params) * 256; 274 275 ret = snd_soc_dai_set_pll(codec_dai, WM8994_FLL1, WM8994_FLL_SRC_MCLK1, 276 ARIES_MCLK1_FREQ, pll_out); 277 if (ret < 0) 278 return ret; 279 280 ret = snd_soc_dai_set_sysclk(codec_dai, WM8994_SYSCLK_FLL1, 281 pll_out, SND_SOC_CLOCK_IN); 282 if (ret < 0) 283 return ret; 284 285 return 0; 286 } 287 288 static int aries_hw_free(struct snd_pcm_substream *substream) 289 { 290 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 291 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0); 292 int ret; 293 294 /* Switch sysclk to MCLK1 */ 295 ret = snd_soc_dai_set_sysclk(codec_dai, WM8994_SYSCLK_MCLK1, 296 ARIES_MCLK1_FREQ, SND_SOC_CLOCK_IN); 297 if (ret < 0) 298 return ret; 299 300 /* Stop PLL */ 301 ret = snd_soc_dai_set_pll(codec_dai, WM8994_FLL1, WM8994_FLL_SRC_MCLK1, 302 ARIES_MCLK1_FREQ, 0); 303 if (ret < 0) 304 return ret; 305 306 return 0; 307 } 308 309 /* 310 * Main DAI operations 311 */ 312 static const struct snd_soc_ops aries_ops = { 313 .hw_params = aries_hw_params, 314 .hw_free = aries_hw_free, 315 }; 316 317 static int aries_baseband_init(struct snd_soc_pcm_runtime *rtd) 318 { 319 struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0); 320 unsigned int pll_out; 321 int ret; 322 323 pll_out = 8000 * 512; 324 325 /* Set the codec FLL */ 326 ret = snd_soc_dai_set_pll(codec_dai, WM8994_FLL2, WM8994_FLL_SRC_MCLK1, 327 ARIES_MCLK1_FREQ, pll_out); 328 if (ret < 0) 329 return ret; 330 331 /* Set the codec system clock */ 332 ret = snd_soc_dai_set_sysclk(codec_dai, WM8994_SYSCLK_FLL2, 333 pll_out, SND_SOC_CLOCK_IN); 334 if (ret < 0) 335 return ret; 336 337 return 0; 338 } 339 340 static int aries_late_probe(struct snd_soc_card *card) 341 { 342 struct aries_wm8994_data *priv = snd_soc_card_get_drvdata(card); 343 int ret, irq; 344 345 ret = snd_soc_card_jack_new_pins(card, "Dock", SND_JACK_LINEOUT, 346 &aries_dock, dock_pins, ARRAY_SIZE(dock_pins)); 347 if (ret) 348 return ret; 349 350 ret = devm_extcon_register_notifier(card->dev, 351 priv->usb_extcon, EXTCON_JACK_LINE_OUT, 352 &aries_extcon_notifier_block); 353 if (ret) 354 return ret; 355 356 if (extcon_get_state(priv->usb_extcon, 357 EXTCON_JACK_LINE_OUT) > 0) 358 snd_soc_jack_report(&aries_dock, SND_JACK_LINEOUT, 359 SND_JACK_LINEOUT); 360 else 361 snd_soc_jack_report(&aries_dock, 0, SND_JACK_LINEOUT); 362 363 ret = snd_soc_card_jack_new_pins(card, "Headset", 364 SND_JACK_HEADSET | SND_JACK_BTN_0, 365 &aries_headset, 366 jack_pins, ARRAY_SIZE(jack_pins)); 367 if (ret) 368 return ret; 369 370 ret = snd_soc_jack_add_zones(&aries_headset, ARRAY_SIZE(headset_zones), 371 headset_zones); 372 if (ret) 373 return ret; 374 375 irq = gpiod_to_irq(priv->gpio_headset_detect); 376 if (irq < 0) { 377 dev_err(card->dev, "Failed to map headset detect gpio to irq"); 378 return -EINVAL; 379 } 380 381 ret = devm_request_threaded_irq(card->dev, irq, NULL, 382 headset_det_irq_thread, 383 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | 384 IRQF_ONESHOT, "headset_detect", priv); 385 if (ret) { 386 dev_err(card->dev, "Failed to request headset detect irq"); 387 return ret; 388 } 389 390 headset_button_gpio[0].data = priv; 391 headset_button_gpio[0].desc = priv->gpio_headset_key; 392 393 snd_jack_set_key(aries_headset.jack, SND_JACK_BTN_0, KEY_MEDIA); 394 395 return snd_soc_jack_add_gpios(&aries_headset, 396 ARRAY_SIZE(headset_button_gpio), headset_button_gpio); 397 } 398 399 static const struct snd_soc_pcm_stream baseband_params = { 400 .formats = SNDRV_PCM_FMTBIT_S16_LE, 401 .rate_min = 8000, 402 .rate_max = 8000, 403 .channels_min = 1, 404 .channels_max = 1, 405 }; 406 407 static const struct snd_soc_pcm_stream bluetooth_params = { 408 .formats = SNDRV_PCM_FMTBIT_S16_LE, 409 .rate_min = 8000, 410 .rate_max = 8000, 411 .channels_min = 1, 412 .channels_max = 2, 413 }; 414 415 static const struct snd_soc_dapm_widget aries_modem_widgets[] = { 416 SND_SOC_DAPM_INPUT("Modem RX"), 417 SND_SOC_DAPM_OUTPUT("Modem TX"), 418 }; 419 420 static const struct snd_soc_dapm_route aries_modem_routes[] = { 421 { "Modem Capture", NULL, "Modem RX" }, 422 { "Modem TX", NULL, "Modem Playback" }, 423 }; 424 425 static const struct snd_soc_component_driver aries_component = { 426 .name = "aries-audio", 427 .dapm_widgets = aries_modem_widgets, 428 .num_dapm_widgets = ARRAY_SIZE(aries_modem_widgets), 429 .dapm_routes = aries_modem_routes, 430 .num_dapm_routes = ARRAY_SIZE(aries_modem_routes), 431 .idle_bias_on = 1, 432 .use_pmdown_time = 1, 433 .endianness = 1, 434 }; 435 436 static struct snd_soc_dai_driver aries_ext_dai[] = { 437 { 438 .name = "Voice call", 439 .playback = { 440 .stream_name = "Modem Playback", 441 .channels_min = 1, 442 .channels_max = 1, 443 .rate_min = 8000, 444 .rate_max = 8000, 445 .rates = SNDRV_PCM_RATE_8000, 446 .formats = SNDRV_PCM_FMTBIT_S16_LE, 447 }, 448 .capture = { 449 .stream_name = "Modem Capture", 450 .channels_min = 1, 451 .channels_max = 1, 452 .rate_min = 8000, 453 .rate_max = 8000, 454 .rates = SNDRV_PCM_RATE_8000, 455 .formats = SNDRV_PCM_FMTBIT_S16_LE, 456 }, 457 }, 458 }; 459 460 SND_SOC_DAILINK_DEFS(aif1, 461 DAILINK_COMP_ARRAY(COMP_CPU(SAMSUNG_I2S_DAI)), 462 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "wm8994-aif1")), 463 DAILINK_COMP_ARRAY(COMP_EMPTY())); 464 465 SND_SOC_DAILINK_DEFS(baseband, 466 DAILINK_COMP_ARRAY(COMP_CPU("Voice call")), 467 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "wm8994-aif2"))); 468 469 SND_SOC_DAILINK_DEFS(bluetooth, 470 DAILINK_COMP_ARRAY(COMP_CPU("bt-sco-pcm")), 471 DAILINK_COMP_ARRAY(COMP_CODEC(NULL, "wm8994-aif3"))); 472 473 static struct snd_soc_dai_link aries_dai[] = { 474 { 475 .name = "WM8994 AIF1", 476 .stream_name = "HiFi", 477 .dai_fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF | 478 SND_SOC_DAIFMT_CBM_CFM, 479 .ops = &aries_ops, 480 SND_SOC_DAILINK_REG(aif1), 481 }, 482 { 483 .name = "WM8994 AIF2", 484 .stream_name = "Baseband", 485 .init = &aries_baseband_init, 486 .c2c_params = &baseband_params, 487 .num_c2c_params = 1, 488 .ignore_suspend = 1, 489 SND_SOC_DAILINK_REG(baseband), 490 }, 491 { 492 .name = "WM8994 AIF3", 493 .stream_name = "Bluetooth", 494 .c2c_params = &bluetooth_params, 495 .num_c2c_params = 1, 496 .ignore_suspend = 1, 497 SND_SOC_DAILINK_REG(bluetooth), 498 }, 499 }; 500 501 static struct snd_soc_card aries_card = { 502 .name = "ARIES", 503 .owner = THIS_MODULE, 504 .dai_link = aries_dai, 505 .num_links = ARRAY_SIZE(aries_dai), 506 .controls = aries_controls, 507 .num_controls = ARRAY_SIZE(aries_controls), 508 .dapm_widgets = aries_dapm_widgets, 509 .num_dapm_widgets = ARRAY_SIZE(aries_dapm_widgets), 510 .late_probe = aries_late_probe, 511 }; 512 513 static const struct aries_wm8994_variant fascinate4g_variant = { 514 .modem_dai_fmt = SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_CBS_CFS 515 | SND_SOC_DAIFMT_IB_NF, 516 .has_fm_radio = false, 517 }; 518 519 static const struct aries_wm8994_variant aries_variant = { 520 .modem_dai_fmt = SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_CBM_CFM 521 | SND_SOC_DAIFMT_IB_NF, 522 .has_fm_radio = true, 523 }; 524 525 static const struct of_device_id samsung_wm8994_of_match[] = { 526 { 527 .compatible = "samsung,fascinate4g-wm8994", 528 .data = &fascinate4g_variant, 529 }, 530 { 531 .compatible = "samsung,aries-wm8994", 532 .data = &aries_variant, 533 }, 534 { /* sentinel */ }, 535 }; 536 MODULE_DEVICE_TABLE(of, samsung_wm8994_of_match); 537 538 static int aries_audio_probe(struct platform_device *pdev) 539 { 540 struct device_node *np = pdev->dev.of_node; 541 struct device_node *cpu, *codec, *extcon_np; 542 struct device *dev = &pdev->dev; 543 struct snd_soc_card *card = &aries_card; 544 struct aries_wm8994_data *priv; 545 struct snd_soc_dai_link *dai_link; 546 const struct of_device_id *match; 547 enum iio_chan_type channel_type; 548 int ret, i; 549 550 if (!np) 551 return -EINVAL; 552 553 card->dev = dev; 554 555 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 556 if (!priv) 557 return -ENOMEM; 558 559 snd_soc_card_set_drvdata(card, priv); 560 561 match = of_match_node(samsung_wm8994_of_match, np); 562 priv->variant = match->data; 563 564 /* Remove FM widget if not present */ 565 if (!priv->variant->has_fm_radio) 566 card->num_dapm_widgets--; 567 568 priv->reg_main_micbias = devm_regulator_get(dev, "main-micbias"); 569 if (IS_ERR(priv->reg_main_micbias)) { 570 dev_err(dev, "Failed to get main micbias regulator\n"); 571 return PTR_ERR(priv->reg_main_micbias); 572 } 573 574 priv->reg_headset_micbias = devm_regulator_get(dev, "headset-micbias"); 575 if (IS_ERR(priv->reg_headset_micbias)) { 576 dev_err(dev, "Failed to get headset micbias regulator\n"); 577 return PTR_ERR(priv->reg_headset_micbias); 578 } 579 580 priv->gpio_earpath_sel = devm_gpiod_get(dev, "earpath-sel", 581 GPIOD_OUT_LOW); 582 if (IS_ERR(priv->gpio_earpath_sel)) { 583 dev_err(dev, "Failed to get earpath selector gpio"); 584 return PTR_ERR(priv->gpio_earpath_sel); 585 } 586 587 extcon_np = of_parse_phandle(np, "extcon", 0); 588 priv->usb_extcon = extcon_find_edev_by_node(extcon_np); 589 of_node_put(extcon_np); 590 if (IS_ERR(priv->usb_extcon)) 591 return dev_err_probe(dev, PTR_ERR(priv->usb_extcon), 592 "Failed to get extcon device"); 593 594 priv->adc = devm_iio_channel_get(dev, "headset-detect"); 595 if (IS_ERR(priv->adc)) 596 return dev_err_probe(dev, PTR_ERR(priv->adc), 597 "Failed to get ADC channel"); 598 599 ret = iio_get_channel_type(priv->adc, &channel_type); 600 if (ret) 601 return dev_err_probe(dev, ret, 602 "Failed to get ADC channel type"); 603 if (channel_type != IIO_VOLTAGE) 604 return -EINVAL; 605 606 priv->gpio_headset_key = devm_gpiod_get(dev, "headset-key", 607 GPIOD_IN); 608 if (IS_ERR(priv->gpio_headset_key)) { 609 dev_err(dev, "Failed to get headset key gpio"); 610 return PTR_ERR(priv->gpio_headset_key); 611 } 612 613 priv->gpio_headset_detect = devm_gpiod_get(dev, 614 "headset-detect", GPIOD_IN); 615 if (IS_ERR(priv->gpio_headset_detect)) { 616 dev_err(dev, "Failed to get headset detect gpio"); 617 return PTR_ERR(priv->gpio_headset_detect); 618 } 619 620 /* Update card-name if provided through DT, else use default name */ 621 snd_soc_of_parse_card_name(card, "model"); 622 623 ret = snd_soc_of_parse_audio_routing(card, "samsung,audio-routing"); 624 if (ret < 0) { 625 dev_err(dev, "Audio routing invalid/unspecified\n"); 626 return ret; 627 } 628 629 aries_dai[1].dai_fmt = priv->variant->modem_dai_fmt; 630 631 cpu = of_get_child_by_name(dev->of_node, "cpu"); 632 if (!cpu) 633 return -EINVAL; 634 635 codec = of_get_child_by_name(dev->of_node, "codec"); 636 if (!codec) { 637 ret = -EINVAL; 638 goto out; 639 } 640 641 for_each_card_prelinks(card, i, dai_link) { 642 dai_link->codecs->of_node = of_parse_phandle(codec, 643 "sound-dai", 0); 644 if (!dai_link->codecs->of_node) { 645 ret = -EINVAL; 646 goto out; 647 } 648 } 649 650 /* Set CPU and platform of_node for main DAI */ 651 aries_dai[0].cpus->of_node = of_parse_phandle(cpu, 652 "sound-dai", 0); 653 if (!aries_dai[0].cpus->of_node) { 654 ret = -EINVAL; 655 goto out; 656 } 657 658 aries_dai[0].platforms->of_node = aries_dai[0].cpus->of_node; 659 660 /* Set CPU of_node for BT DAI */ 661 aries_dai[2].cpus->of_node = of_parse_phandle(cpu, 662 "sound-dai", 1); 663 if (!aries_dai[2].cpus->of_node) { 664 ret = -EINVAL; 665 goto out; 666 } 667 668 ret = devm_snd_soc_register_component(dev, &aries_component, 669 aries_ext_dai, ARRAY_SIZE(aries_ext_dai)); 670 if (ret < 0) { 671 dev_err(dev, "Failed to register component: %d\n", ret); 672 goto out; 673 } 674 675 ret = devm_snd_soc_register_card(dev, card); 676 if (ret) 677 dev_err(dev, "snd_soc_register_card() failed:%d\n", ret); 678 679 out: 680 of_node_put(cpu); 681 of_node_put(codec); 682 683 return ret; 684 } 685 686 static struct platform_driver aries_audio_driver = { 687 .driver = { 688 .name = "aries-audio-wm8994", 689 .of_match_table = of_match_ptr(samsung_wm8994_of_match), 690 .pm = &snd_soc_pm_ops, 691 }, 692 .probe = aries_audio_probe, 693 }; 694 695 module_platform_driver(aries_audio_driver); 696 697 MODULE_DESCRIPTION("ALSA SoC ARIES WM8994"); 698 MODULE_LICENSE("GPL"); 699 MODULE_ALIAS("platform:aries-audio-wm8994"); 700