xref: /linux/sound/soc/generic/simple-card.c (revision ef815d2cba782e96b9aad9483523d474ed41c62a)
1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // ASoC simple sound card support
4 //
5 // Copyright (C) 2012 Renesas Solutions Corp.
6 // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
7 
8 #include <linux/clk.h>
9 #include <linux/device.h>
10 #include <linux/module.h>
11 #include <linux/of.h>
12 #include <linux/of_device.h>
13 #include <linux/platform_device.h>
14 #include <linux/string.h>
15 #include <sound/simple_card.h>
16 #include <sound/soc-dai.h>
17 #include <sound/soc.h>
18 
19 #define DPCM_SELECTABLE 1
20 
21 #define DAI	"sound-dai"
22 #define CELL	"#sound-dai-cells"
23 #define PREFIX	"simple-audio-card,"
24 
25 static const struct snd_soc_ops simple_ops = {
26 	.startup	= asoc_simple_startup,
27 	.shutdown	= asoc_simple_shutdown,
28 	.hw_params	= asoc_simple_hw_params,
29 };
30 
31 static int asoc_simple_parse_platform(struct device_node *node,
32 				      struct snd_soc_dai_link_component *dlc)
33 {
34 	struct of_phandle_args args;
35 	int ret;
36 
37 	if (!node)
38 		return 0;
39 
40 	/*
41 	 * Get node via "sound-dai = <&phandle port>"
42 	 * it will be used as xxx_of_node on soc_bind_dai_link()
43 	 */
44 	ret = of_parse_phandle_with_args(node, DAI, CELL, 0, &args);
45 	if (ret)
46 		return ret;
47 
48 	/* dai_name is not required and may not exist for plat component */
49 
50 	dlc->of_node = args.np;
51 
52 	return 0;
53 }
54 
55 static int asoc_simple_parse_dai(struct device_node *node,
56 				 struct snd_soc_dai_link_component *dlc,
57 				 int *is_single_link)
58 {
59 	struct of_phandle_args args;
60 	int ret;
61 
62 	if (!node)
63 		return 0;
64 
65 	/*
66 	 * Get node via "sound-dai = <&phandle port>"
67 	 * it will be used as xxx_of_node on soc_bind_dai_link()
68 	 */
69 	ret = of_parse_phandle_with_args(node, DAI, CELL, 0, &args);
70 	if (ret)
71 		return ret;
72 
73 	/*
74 	 * FIXME
75 	 *
76 	 * Here, dlc->dai_name is pointer to CPU/Codec DAI name.
77 	 * If user unbinded CPU or Codec driver, but not for Sound Card,
78 	 * dlc->dai_name is keeping unbinded CPU or Codec
79 	 * driver's pointer.
80 	 *
81 	 * If user re-bind CPU or Codec driver again, ALSA SoC will try
82 	 * to rebind Card via snd_soc_try_rebind_card(), but because of
83 	 * above reason, it might can't bind Sound Card.
84 	 * Because Sound Card is pointing to released dai_name pointer.
85 	 *
86 	 * To avoid this rebind Card issue,
87 	 * 1) It needs to alloc memory to keep dai_name eventhough
88 	 *    CPU or Codec driver was unbinded, or
89 	 * 2) user need to rebind Sound Card everytime
90 	 *    if he unbinded CPU or Codec.
91 	 */
92 	ret = snd_soc_get_dlc(&args, dlc);
93 	if (ret < 0)
94 		return ret;
95 
96 	if (is_single_link)
97 		*is_single_link = !args.args_count;
98 
99 	return 0;
100 }
101 
102 static void simple_parse_convert(struct device *dev,
103 				 struct device_node *np,
104 				 struct asoc_simple_data *adata)
105 {
106 	struct device_node *top = dev->of_node;
107 	struct device_node *node = of_get_parent(np);
108 
109 	asoc_simple_parse_convert(top,  PREFIX, adata);
110 	asoc_simple_parse_convert(node, PREFIX, adata);
111 	asoc_simple_parse_convert(node, NULL,   adata);
112 	asoc_simple_parse_convert(np,   NULL,   adata);
113 
114 	of_node_put(node);
115 }
116 
117 static void simple_parse_mclk_fs(struct device_node *top,
118 				 struct device_node *np,
119 				 struct simple_dai_props *props,
120 				 char *prefix)
121 {
122 	struct device_node *node = of_get_parent(np);
123 	char prop[128];
124 
125 	snprintf(prop, sizeof(prop), "%smclk-fs", PREFIX);
126 	of_property_read_u32(top,	prop, &props->mclk_fs);
127 
128 	snprintf(prop, sizeof(prop), "%smclk-fs", prefix);
129 	of_property_read_u32(node,	prop, &props->mclk_fs);
130 	of_property_read_u32(np,	prop, &props->mclk_fs);
131 
132 	of_node_put(node);
133 }
134 
135 static int simple_parse_node(struct asoc_simple_priv *priv,
136 			     struct device_node *np,
137 			     struct link_info *li,
138 			     char *prefix,
139 			     int *cpu)
140 {
141 	struct device *dev = simple_priv_to_dev(priv);
142 	struct device_node *top = dev->of_node;
143 	struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);
144 	struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link);
145 	struct snd_soc_dai_link_component *dlc;
146 	struct asoc_simple_dai *dai;
147 	int ret;
148 
149 	if (cpu) {
150 		dlc = asoc_link_to_cpu(dai_link, 0);
151 		dai = simple_props_to_dai_cpu(dai_props, 0);
152 	} else {
153 		dlc = asoc_link_to_codec(dai_link, 0);
154 		dai = simple_props_to_dai_codec(dai_props, 0);
155 	}
156 
157 	simple_parse_mclk_fs(top, np, dai_props, prefix);
158 
159 	ret = asoc_simple_parse_dai(np, dlc, cpu);
160 	if (ret)
161 		return ret;
162 
163 	ret = asoc_simple_parse_clk(dev, np, dai, dlc);
164 	if (ret)
165 		return ret;
166 
167 	ret = asoc_simple_parse_tdm(np, dai);
168 	if (ret)
169 		return ret;
170 
171 	return 0;
172 }
173 
174 static int simple_link_init(struct asoc_simple_priv *priv,
175 			    struct device_node *node,
176 			    struct device_node *codec,
177 			    struct link_info *li,
178 			    char *prefix, char *name)
179 {
180 	struct device *dev = simple_priv_to_dev(priv);
181 	struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);
182 	int ret;
183 
184 	ret = asoc_simple_parse_daifmt(dev, node, codec,
185 				       prefix, &dai_link->dai_fmt);
186 	if (ret < 0)
187 		return 0;
188 
189 	dai_link->init			= asoc_simple_dai_init;
190 	dai_link->ops			= &simple_ops;
191 
192 	return asoc_simple_set_dailink_name(dev, dai_link, name);
193 }
194 
195 static int simple_dai_link_of_dpcm(struct asoc_simple_priv *priv,
196 				   struct device_node *np,
197 				   struct device_node *codec,
198 				   struct link_info *li,
199 				   bool is_top)
200 {
201 	struct device *dev = simple_priv_to_dev(priv);
202 	struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);
203 	struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link);
204 	struct device_node *top = dev->of_node;
205 	struct device_node *node = of_get_parent(np);
206 	char *prefix = "";
207 	char dai_name[64];
208 	int ret;
209 
210 	dev_dbg(dev, "link_of DPCM (%pOF)\n", np);
211 
212 	/* For single DAI link & old style of DT node */
213 	if (is_top)
214 		prefix = PREFIX;
215 
216 	if (li->cpu) {
217 		struct snd_soc_dai_link_component *cpus = asoc_link_to_cpu(dai_link, 0);
218 		struct snd_soc_dai_link_component *platforms = asoc_link_to_platform(dai_link, 0);
219 		int is_single_links = 0;
220 
221 		/* Codec is dummy */
222 
223 		/* FE settings */
224 		dai_link->dynamic		= 1;
225 		dai_link->dpcm_merged_format	= 1;
226 
227 		ret = simple_parse_node(priv, np, li, prefix, &is_single_links);
228 		if (ret < 0)
229 			goto out_put_node;
230 
231 		snprintf(dai_name, sizeof(dai_name), "fe.%s", cpus->dai_name);
232 
233 		asoc_simple_canonicalize_cpu(cpus, is_single_links);
234 		asoc_simple_canonicalize_platform(platforms, cpus);
235 	} else {
236 		struct snd_soc_dai_link_component *codecs = asoc_link_to_codec(dai_link, 0);
237 		struct snd_soc_codec_conf *cconf;
238 
239 		/* CPU is dummy */
240 
241 		/* BE settings */
242 		dai_link->no_pcm		= 1;
243 		dai_link->be_hw_params_fixup	= asoc_simple_be_hw_params_fixup;
244 
245 		cconf	= simple_props_to_codec_conf(dai_props, 0);
246 
247 		ret = simple_parse_node(priv, np, li, prefix, NULL);
248 		if (ret < 0)
249 			goto out_put_node;
250 
251 		snprintf(dai_name, sizeof(dai_name), "be.%s", codecs->dai_name);
252 
253 		/* check "prefix" from top node */
254 		snd_soc_of_parse_node_prefix(top, cconf, codecs->of_node,
255 					      PREFIX "prefix");
256 		snd_soc_of_parse_node_prefix(node, cconf, codecs->of_node,
257 					     "prefix");
258 		snd_soc_of_parse_node_prefix(np, cconf, codecs->of_node,
259 					     "prefix");
260 	}
261 
262 	simple_parse_convert(dev, np, &dai_props->adata);
263 
264 	snd_soc_dai_link_set_capabilities(dai_link);
265 
266 	ret = simple_link_init(priv, node, codec, li, prefix, dai_name);
267 
268 out_put_node:
269 	li->link++;
270 
271 	of_node_put(node);
272 	return ret;
273 }
274 
275 static int simple_dai_link_of(struct asoc_simple_priv *priv,
276 			      struct device_node *np,
277 			      struct device_node *codec,
278 			      struct link_info *li,
279 			      bool is_top)
280 {
281 	struct device *dev = simple_priv_to_dev(priv);
282 	struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);
283 	struct snd_soc_dai_link_component *cpus = asoc_link_to_cpu(dai_link, 0);
284 	struct snd_soc_dai_link_component *codecs = asoc_link_to_codec(dai_link, 0);
285 	struct snd_soc_dai_link_component *platforms = asoc_link_to_platform(dai_link, 0);
286 	struct device_node *cpu = NULL;
287 	struct device_node *node = NULL;
288 	struct device_node *plat = NULL;
289 	char dai_name[64];
290 	char prop[128];
291 	char *prefix = "";
292 	int ret, single_cpu = 0;
293 
294 	cpu  = np;
295 	node = of_get_parent(np);
296 
297 	dev_dbg(dev, "link_of (%pOF)\n", node);
298 
299 	/* For single DAI link & old style of DT node */
300 	if (is_top)
301 		prefix = PREFIX;
302 
303 	snprintf(prop, sizeof(prop), "%splat", prefix);
304 	plat = of_get_child_by_name(node, prop);
305 
306 	ret = simple_parse_node(priv, cpu, li, prefix, &single_cpu);
307 	if (ret < 0)
308 		goto dai_link_of_err;
309 
310 	ret = simple_parse_node(priv, codec, li, prefix, NULL);
311 	if (ret < 0)
312 		goto dai_link_of_err;
313 
314 	ret = asoc_simple_parse_platform(plat, platforms);
315 	if (ret < 0)
316 		goto dai_link_of_err;
317 
318 	snprintf(dai_name, sizeof(dai_name),
319 		 "%s-%s", cpus->dai_name, codecs->dai_name);
320 
321 	asoc_simple_canonicalize_cpu(cpus, single_cpu);
322 	asoc_simple_canonicalize_platform(platforms, cpus);
323 
324 	ret = simple_link_init(priv, node, codec, li, prefix, dai_name);
325 
326 dai_link_of_err:
327 	of_node_put(plat);
328 	of_node_put(node);
329 
330 	li->link++;
331 
332 	return ret;
333 }
334 
335 static int __simple_for_each_link(struct asoc_simple_priv *priv,
336 			struct link_info *li,
337 			int (*func_noml)(struct asoc_simple_priv *priv,
338 					 struct device_node *np,
339 					 struct device_node *codec,
340 					 struct link_info *li, bool is_top),
341 			int (*func_dpcm)(struct asoc_simple_priv *priv,
342 					 struct device_node *np,
343 					 struct device_node *codec,
344 					 struct link_info *li, bool is_top))
345 {
346 	struct device *dev = simple_priv_to_dev(priv);
347 	struct device_node *top = dev->of_node;
348 	struct device_node *node;
349 	uintptr_t dpcm_selectable = (uintptr_t)of_device_get_match_data(dev);
350 	bool is_top = 0;
351 	int ret = 0;
352 
353 	/* Check if it has dai-link */
354 	node = of_get_child_by_name(top, PREFIX "dai-link");
355 	if (!node) {
356 		node = of_node_get(top);
357 		is_top = 1;
358 	}
359 
360 	/* loop for all dai-link */
361 	do {
362 		struct asoc_simple_data adata;
363 		struct device_node *codec;
364 		struct device_node *plat;
365 		struct device_node *np;
366 		int num = of_get_child_count(node);
367 
368 		/* get codec */
369 		codec = of_get_child_by_name(node, is_top ?
370 					     PREFIX "codec" : "codec");
371 		if (!codec) {
372 			ret = -ENODEV;
373 			goto error;
374 		}
375 		/* get platform */
376 		plat = of_get_child_by_name(node, is_top ?
377 					    PREFIX "plat" : "plat");
378 
379 		/* get convert-xxx property */
380 		memset(&adata, 0, sizeof(adata));
381 		for_each_child_of_node(node, np)
382 			simple_parse_convert(dev, np, &adata);
383 
384 		/* loop for all CPU/Codec node */
385 		for_each_child_of_node(node, np) {
386 			if (plat == np)
387 				continue;
388 			/*
389 			 * It is DPCM
390 			 * if it has many CPUs,
391 			 * or has convert-xxx property
392 			 */
393 			if (dpcm_selectable &&
394 			    (num > 2 || asoc_simple_is_convert_required(&adata))) {
395 				/*
396 				 * np
397 				 *	 |1(CPU)|0(Codec)  li->cpu
398 				 * CPU	 |Pass  |return
399 				 * Codec |return|Pass
400 				 */
401 				if (li->cpu != (np == codec))
402 					ret = func_dpcm(priv, np, codec, li, is_top);
403 			/* else normal sound */
404 			} else {
405 				/*
406 				 * np
407 				 *	 |1(CPU)|0(Codec)  li->cpu
408 				 * CPU	 |Pass  |return
409 				 * Codec |return|return
410 				 */
411 				if (li->cpu && (np != codec))
412 					ret = func_noml(priv, np, codec, li, is_top);
413 			}
414 
415 			if (ret < 0) {
416 				of_node_put(codec);
417 				of_node_put(plat);
418 				of_node_put(np);
419 				goto error;
420 			}
421 		}
422 
423 		of_node_put(codec);
424 		of_node_put(plat);
425 		node = of_get_next_child(top, node);
426 	} while (!is_top && node);
427 
428  error:
429 	of_node_put(node);
430 	return ret;
431 }
432 
433 static int simple_for_each_link(struct asoc_simple_priv *priv,
434 				struct link_info *li,
435 				int (*func_noml)(struct asoc_simple_priv *priv,
436 						 struct device_node *np,
437 						 struct device_node *codec,
438 						 struct link_info *li, bool is_top),
439 				int (*func_dpcm)(struct asoc_simple_priv *priv,
440 						 struct device_node *np,
441 						 struct device_node *codec,
442 						 struct link_info *li, bool is_top))
443 {
444 	int ret;
445 	/*
446 	 * Detect all CPU first, and Detect all Codec 2nd.
447 	 *
448 	 * In Normal sound case, all DAIs are detected
449 	 * as "CPU-Codec".
450 	 *
451 	 * In DPCM sound case,
452 	 * all CPUs   are detected as "CPU-dummy", and
453 	 * all Codecs are detected as "dummy-Codec".
454 	 * To avoid random sub-device numbering,
455 	 * detect "dummy-Codec" in last;
456 	 */
457 	for (li->cpu = 1; li->cpu >= 0; li->cpu--) {
458 		ret = __simple_for_each_link(priv, li, func_noml, func_dpcm);
459 		if (ret < 0)
460 			break;
461 	}
462 
463 	return ret;
464 }
465 
466 static int simple_parse_of(struct asoc_simple_priv *priv, struct link_info *li)
467 {
468 	struct snd_soc_card *card = simple_priv_to_card(priv);
469 	int ret;
470 
471 	ret = asoc_simple_parse_widgets(card, PREFIX);
472 	if (ret < 0)
473 		return ret;
474 
475 	ret = asoc_simple_parse_routing(card, PREFIX);
476 	if (ret < 0)
477 		return ret;
478 
479 	ret = asoc_simple_parse_pin_switches(card, PREFIX);
480 	if (ret < 0)
481 		return ret;
482 
483 	/* Single/Muti DAI link(s) & New style of DT node */
484 	memset(li, 0, sizeof(*li));
485 	ret = simple_for_each_link(priv, li,
486 				   simple_dai_link_of,
487 				   simple_dai_link_of_dpcm);
488 	if (ret < 0)
489 		return ret;
490 
491 	ret = asoc_simple_parse_card_name(card, PREFIX);
492 	if (ret < 0)
493 		return ret;
494 
495 	ret = snd_soc_of_parse_aux_devs(card, PREFIX "aux-devs");
496 
497 	return ret;
498 }
499 
500 static int simple_count_noml(struct asoc_simple_priv *priv,
501 			     struct device_node *np,
502 			     struct device_node *codec,
503 			     struct link_info *li, bool is_top)
504 {
505 	if (li->link >= SNDRV_MAX_LINKS) {
506 		struct device *dev = simple_priv_to_dev(priv);
507 
508 		dev_err(dev, "too many links\n");
509 		return -EINVAL;
510 	}
511 
512 	/*
513 	 * DON'T REMOVE platforms
514 	 *
515 	 * Some CPU might be using soc-generic-dmaengine-pcm. This means CPU and Platform
516 	 * are different Component, but are sharing same component->dev.
517 	 * Simple Card had been supported it without special Platform selection.
518 	 * We need platforms here.
519 	 *
520 	 * In case of no Platform, it will be Platform == CPU, but Platform will be
521 	 * ignored by snd_soc_rtd_add_component().
522 	 *
523 	 * see
524 	 *	simple-card-utils.c :: asoc_simple_canonicalize_platform()
525 	 */
526 	li->num[li->link].cpus		= 1;
527 	li->num[li->link].platforms	= 1;
528 
529 	li->num[li->link].codecs	= 1;
530 
531 	li->link += 1;
532 
533 	return 0;
534 }
535 
536 static int simple_count_dpcm(struct asoc_simple_priv *priv,
537 			     struct device_node *np,
538 			     struct device_node *codec,
539 			     struct link_info *li, bool is_top)
540 {
541 	if (li->link >= SNDRV_MAX_LINKS) {
542 		struct device *dev = simple_priv_to_dev(priv);
543 
544 		dev_err(dev, "too many links\n");
545 		return -EINVAL;
546 	}
547 
548 	if (li->cpu) {
549 		/*
550 		 * DON'T REMOVE platforms
551 		 * see
552 		 *	simple_count_noml()
553 		 */
554 		li->num[li->link].cpus		= 1;
555 		li->num[li->link].platforms	= 1;
556 
557 		li->link++; /* CPU-dummy */
558 	} else {
559 		li->num[li->link].codecs	= 1;
560 
561 		li->link++; /* dummy-Codec */
562 	}
563 
564 	return 0;
565 }
566 
567 static int simple_get_dais_count(struct asoc_simple_priv *priv,
568 				 struct link_info *li)
569 {
570 	struct device *dev = simple_priv_to_dev(priv);
571 	struct device_node *top = dev->of_node;
572 
573 	/*
574 	 * link_num :	number of links.
575 	 *		CPU-Codec / CPU-dummy / dummy-Codec
576 	 * dais_num :	number of DAIs
577 	 * ccnf_num :	number of codec_conf
578 	 *		same number for "dummy-Codec"
579 	 *
580 	 * ex1)
581 	 * CPU0 --- Codec0	link : 5
582 	 * CPU1 --- Codec1	dais : 7
583 	 * CPU2 -/		ccnf : 1
584 	 * CPU3 --- Codec2
585 	 *
586 	 *	=> 5 links = 2xCPU-Codec + 2xCPU-dummy + 1xdummy-Codec
587 	 *	=> 7 DAIs  = 4xCPU + 3xCodec
588 	 *	=> 1 ccnf  = 1xdummy-Codec
589 	 *
590 	 * ex2)
591 	 * CPU0 --- Codec0	link : 5
592 	 * CPU1 --- Codec1	dais : 6
593 	 * CPU2 -/		ccnf : 1
594 	 * CPU3 -/
595 	 *
596 	 *	=> 5 links = 1xCPU-Codec + 3xCPU-dummy + 1xdummy-Codec
597 	 *	=> 6 DAIs  = 4xCPU + 2xCodec
598 	 *	=> 1 ccnf  = 1xdummy-Codec
599 	 *
600 	 * ex3)
601 	 * CPU0 --- Codec0	link : 6
602 	 * CPU1 -/		dais : 6
603 	 * CPU2 --- Codec1	ccnf : 2
604 	 * CPU3 -/
605 	 *
606 	 *	=> 6 links = 0xCPU-Codec + 4xCPU-dummy + 2xdummy-Codec
607 	 *	=> 6 DAIs  = 4xCPU + 2xCodec
608 	 *	=> 2 ccnf  = 2xdummy-Codec
609 	 *
610 	 * ex4)
611 	 * CPU0 --- Codec0 (convert-rate)	link : 3
612 	 * CPU1 --- Codec1			dais : 4
613 	 *					ccnf : 1
614 	 *
615 	 *	=> 3 links = 1xCPU-Codec + 1xCPU-dummy + 1xdummy-Codec
616 	 *	=> 4 DAIs  = 2xCPU + 2xCodec
617 	 *	=> 1 ccnf  = 1xdummy-Codec
618 	 */
619 	if (!top) {
620 		li->num[0].cpus		= 1;
621 		li->num[0].codecs	= 1;
622 		li->num[0].platforms	= 1;
623 
624 		li->link = 1;
625 		return 0;
626 	}
627 
628 	return simple_for_each_link(priv, li,
629 				    simple_count_noml,
630 				    simple_count_dpcm);
631 }
632 
633 static int simple_soc_probe(struct snd_soc_card *card)
634 {
635 	struct asoc_simple_priv *priv = snd_soc_card_get_drvdata(card);
636 	int ret;
637 
638 	ret = asoc_simple_init_hp(card, &priv->hp_jack, PREFIX);
639 	if (ret < 0)
640 		return ret;
641 
642 	ret = asoc_simple_init_mic(card, &priv->mic_jack, PREFIX);
643 	if (ret < 0)
644 		return ret;
645 
646 	ret = asoc_simple_init_aux_jacks(priv, PREFIX);
647 	if (ret < 0)
648 		return ret;
649 
650 	return 0;
651 }
652 
653 static int asoc_simple_probe(struct platform_device *pdev)
654 {
655 	struct asoc_simple_priv *priv;
656 	struct device *dev = &pdev->dev;
657 	struct device_node *np = dev->of_node;
658 	struct snd_soc_card *card;
659 	struct link_info *li;
660 	int ret;
661 
662 	/* Allocate the private data and the DAI link array */
663 	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
664 	if (!priv)
665 		return -ENOMEM;
666 
667 	card = simple_priv_to_card(priv);
668 	card->owner		= THIS_MODULE;
669 	card->dev		= dev;
670 	card->probe		= simple_soc_probe;
671 	card->driver_name       = "simple-card";
672 
673 	li = devm_kzalloc(dev, sizeof(*li), GFP_KERNEL);
674 	if (!li)
675 		return -ENOMEM;
676 
677 	ret = simple_get_dais_count(priv, li);
678 	if (ret < 0)
679 		return ret;
680 
681 	if (!li->link)
682 		return -EINVAL;
683 
684 	ret = asoc_simple_init_priv(priv, li);
685 	if (ret < 0)
686 		return ret;
687 
688 	if (np && of_device_is_available(np)) {
689 
690 		ret = simple_parse_of(priv, li);
691 		if (ret < 0) {
692 			dev_err_probe(dev, ret, "parse error\n");
693 			goto err;
694 		}
695 
696 	} else {
697 		struct asoc_simple_card_info *cinfo;
698 		struct snd_soc_dai_link_component *cpus;
699 		struct snd_soc_dai_link_component *codecs;
700 		struct snd_soc_dai_link_component *platform;
701 		struct snd_soc_dai_link *dai_link = priv->dai_link;
702 		struct simple_dai_props *dai_props = priv->dai_props;
703 
704 		cinfo = dev->platform_data;
705 		if (!cinfo) {
706 			dev_err(dev, "no info for asoc-simple-card\n");
707 			return -EINVAL;
708 		}
709 
710 		if (!cinfo->name ||
711 		    !cinfo->codec_dai.name ||
712 		    !cinfo->codec ||
713 		    !cinfo->platform ||
714 		    !cinfo->cpu_dai.name) {
715 			dev_err(dev, "insufficient asoc_simple_card_info settings\n");
716 			return -EINVAL;
717 		}
718 
719 		cpus			= dai_link->cpus;
720 		cpus->dai_name		= cinfo->cpu_dai.name;
721 
722 		codecs			= dai_link->codecs;
723 		codecs->name		= cinfo->codec;
724 		codecs->dai_name	= cinfo->codec_dai.name;
725 
726 		platform		= dai_link->platforms;
727 		platform->name		= cinfo->platform;
728 
729 		card->name		= (cinfo->card) ? cinfo->card : cinfo->name;
730 		dai_link->name		= cinfo->name;
731 		dai_link->stream_name	= cinfo->name;
732 		dai_link->dai_fmt	= cinfo->daifmt;
733 		dai_link->init		= asoc_simple_dai_init;
734 		memcpy(dai_props->cpu_dai, &cinfo->cpu_dai,
735 					sizeof(*dai_props->cpu_dai));
736 		memcpy(dai_props->codec_dai, &cinfo->codec_dai,
737 					sizeof(*dai_props->codec_dai));
738 	}
739 
740 	snd_soc_card_set_drvdata(card, priv);
741 
742 	asoc_simple_debug_info(priv);
743 
744 	ret = devm_snd_soc_register_card(dev, card);
745 	if (ret < 0)
746 		goto err;
747 
748 	devm_kfree(dev, li);
749 	return 0;
750 err:
751 	asoc_simple_clean_reference(card);
752 
753 	return ret;
754 }
755 
756 static const struct of_device_id simple_of_match[] = {
757 	{ .compatible = "simple-audio-card", },
758 	{ .compatible = "simple-scu-audio-card",
759 	  .data = (void *)DPCM_SELECTABLE },
760 	{},
761 };
762 MODULE_DEVICE_TABLE(of, simple_of_match);
763 
764 static struct platform_driver asoc_simple_card = {
765 	.driver = {
766 		.name = "asoc-simple-card",
767 		.pm = &snd_soc_pm_ops,
768 		.of_match_table = simple_of_match,
769 	},
770 	.probe = asoc_simple_probe,
771 	.remove = asoc_simple_remove,
772 };
773 
774 module_platform_driver(asoc_simple_card);
775 
776 MODULE_ALIAS("platform:asoc-simple-card");
777 MODULE_LICENSE("GPL v2");
778 MODULE_DESCRIPTION("ASoC Simple Sound Card");
779 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
780