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