xref: /linux/sound/soc/generic/audio-graph-card2.c (revision 2c1ed907520c50326b8f604907a8478b27881a2e)
1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // ASoC Audio Graph Card2 support
4 //
5 // Copyright (C) 2020 Renesas Electronics Corp.
6 // Copyright (C) 2020 Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
7 //
8 // based on ${LINUX}/sound/soc/generic/audio-graph-card.c
9 #include <linux/clk.h>
10 #include <linux/device.h>
11 #include <linux/gpio/consumer.h>
12 #include <linux/module.h>
13 #include <linux/of.h>
14 #include <linux/of_graph.h>
15 #include <linux/platform_device.h>
16 #include <linux/string.h>
17 #include <sound/graph_card.h>
18 
19 /************************************
20 	daifmt
21  ************************************
22 	ports {
23 		format = "left_j";
24 		port@0 {
25 			bitclock-master;
26 			sample0: endpoint@0 {
27 				frame-master;
28 			};
29 			sample1: endpoint@1 {
30 				format = "i2s";
31 			};
32 		};
33 		...
34 	};
35 
36  You can set daifmt at ports/port/endpoint.
37  It uses *latest* format, and *share* master settings.
38  In above case,
39 	sample0: left_j, bitclock-master, frame-master
40 	sample1: i2s,    bitclock-master
41 
42  If there was no settings, *Codec* will be
43  bitclock/frame provider as default.
44  see
45 	graph_parse_daifmt().
46 
47  "format" property is no longer needed on DT if both CPU/Codec drivers are
48  supporting snd_soc_dai_ops :: .auto_selectable_formats.
49  see
50 	snd_soc_runtime_get_dai_fmt()
51 
52 	sample driver
53 		linux/sound/soc/renesas/rcar/core.c
54 		linux/sound/soc/codecs/ak4613.c
55 		linux/sound/soc/codecs/pcm3168a.c
56 		linux/sound/soc/soc-utils.c
57 		linux/sound/soc/generic/test-component.c
58 
59  ************************************
60 	Normal Audio-Graph
61  ************************************
62 
63  CPU <---> Codec
64 
65  sound {
66 	compatible = "audio-graph-card2";
67 	links = <&cpu>;
68  };
69 
70  CPU {
71 	cpu: port {
72 		bitclock-master;
73 		frame-master;
74 		cpu_ep: endpoint { remote-endpoint = <&codec_ep>; }; };
75  };
76 
77  Codec {
78 	port {	codec_ep: endpoint { remote-endpoint = <&cpu_ep>; }; };
79  };
80 
81  ************************************
82 	Multi-CPU/Codec
83  ************************************
84 
85 It has link connection part (= X,x) and list part (= A,B,a,b).
86 "links" is connection part of CPU side (= @).
87 
88 	+----+		+---+
89  CPU1 --|A  X| <-@----> |x a|-- Codec1
90  CPU2 --|B   |		|  b|-- Codec2
91 	+----+		+---+
92 
93  sound {
94 	compatible = "audio-graph-card2";
95 
96 (@)	links = <&mcpu>;
97 
98 	multi {
99 		ports@0 {
100 (@)		mcpu:	port@0 { mcpu0_ep: endpoint { remote-endpoint = <&mcodec0_ep>;	}; };	// (X) to pair
101 			port@1 { mcpu1_ep: endpoint { remote-endpoint = <&cpu1_ep>;	}; };	// (A) Multi Element
102 			port@2 { mcpu2_ep: endpoint { remote-endpoint = <&cpu2_ep>;	}; };	// (B) Multi Element
103 		};
104 		ports@1 {
105 			port@0 { mcodec0_ep: endpoint { remote-endpoint = <&mcpu0_ep>;	}; };	// (x) to pair
106 			port@1 { mcodec1_ep: endpoint { remote-endpoint = <&codec1_ep>;	}; };	// (a) Multi Element
107 			port@2 { mcodec2_ep: endpoint { remote-endpoint = <&codec2_ep>;	}; };	// (b) Multi Element
108 		};
109 	};
110  };
111 
112  CPU {
113 	ports {
114 		bitclock-master;
115 		frame-master;
116 		port@0 { cpu1_ep: endpoint { remote-endpoint = <&mcpu1_ep>; }; };
117 		port@1 { cpu2_ep: endpoint { remote-endpoint = <&mcpu2_ep>; }; };
118 	};
119  };
120 
121  Codec {
122 	ports {
123 		port@0 { codec1_ep: endpoint { remote-endpoint = <&mcodec1_ep>; }; };
124 		port@1 { codec2_ep: endpoint { remote-endpoint = <&mcodec2_ep>; }; };
125 	};
126  };
127 
128  ************************************
129 	DPCM
130  ************************************
131 
132 		DSP
133 	   ************
134  PCM0 <--> * fe0  be0 * <--> DAI0: Codec Headset
135  PCM1 <--> * fe1  be1 * <--> DAI1: Codec Speakers
136  PCM2 <--> * fe2  be2 * <--> DAI2: MODEM
137  PCM3 <--> * fe3  be3 * <--> DAI3: BT
138 	   *	  be4 * <--> DAI4: DMIC
139 	   *	  be5 * <--> DAI5: FM
140 	   ************
141 
142  sound {
143 	compatible = "audio-graph-card2";
144 
145 	// indicate routing
146 	routing = "xxx Playback", "xxx Playback",
147 		  "xxx Playback", "xxx Playback",
148 		  "xxx Playback", "xxx Playback";
149 
150 	// indicate all Front-End, Back-End
151 	links = <&fe0, &fe1, ...,
152 		 &be0, &be1, ...>;
153 
154 	dpcm {
155 		// Front-End
156 		ports@0 {
157 			fe0: port@0 { fe0_ep: endpoint { remote-endpoint = <&pcm0_ep>; }; };
158 			fe1: port@1 { fe1_ep: endpoint { remote-endpoint = <&pcm1_ep>; }; };
159 			...
160 		};
161 		// Back-End
162 		ports@1 {
163 			be0: port@0 { be0_ep: endpoint { remote-endpoint = <&dai0_ep>; }; };
164 			be1: port@1 { be1_ep: endpoint { remote-endpoint = <&dai1_ep>; }; };
165 			...
166 		};
167 	};
168  };
169 
170  CPU {
171 	ports {
172 		bitclock-master;
173 		frame-master;
174 		port@0 { pcm0_ep: endpoint { remote-endpoint = <&fe0_ep>; }; };
175 		port@1 { pcm1_ep: endpoint { remote-endpoint = <&fe1_ep>; }; };
176 		...
177 	};
178  };
179 
180  Codec {
181 	ports {
182 		port@0 { dai0_ep: endpoint { remote-endpoint = <&be0_ep>; }; };
183 		port@1 { dai1_ep: endpoint { remote-endpoint = <&be1_ep>; }; };
184 		...
185 	};
186  };
187 
188  ************************************
189 	Codec to Codec
190  ************************************
191 
192  +--+
193  |  |<-- Codec0 <- IN
194  |  |--> Codec1 -> OUT
195  +--+
196 
197  sound {
198 	compatible = "audio-graph-card2";
199 
200 	routing = "OUT" ,"DAI1 Playback",
201 		  "DAI0 Capture", "IN";
202 
203 	links = <&c2c>;
204 
205 	codec2codec {
206 		ports {
207 			rate = <48000>;
208 		c2c:	port@0 { c2cf_ep: endpoint { remote-endpoint = <&codec0_ep>; }; };
209 			port@1 { c2cb_ep: endpoint { remote-endpoint = <&codec1_ep>; }; };
210 	};
211  };
212 
213  Codec {
214 	ports {
215 		port@0 {
216 			bitclock-master;
217 			frame-master;
218 			 codec0_ep: endpoint { remote-endpoint = <&c2cf_ep>; }; };
219 		port@1 { codec1_ep: endpoint { remote-endpoint = <&c2cb_ep>; }; };
220 	};
221  };
222 
223 */
224 
225 enum graph_type {
226 	GRAPH_NORMAL,
227 	GRAPH_DPCM,
228 	GRAPH_C2C,
229 
230 	GRAPH_MULTI,	/* don't use ! Use this only in __graph_get_type() */
231 };
232 
233 #define GRAPH_NODENAME_MULTI	"multi"
234 #define GRAPH_NODENAME_DPCM	"dpcm"
235 #define GRAPH_NODENAME_C2C	"codec2codec"
236 
237 #define ep_to_port(ep)	of_get_parent(ep)
port_to_ports(struct device_node * port)238 static struct device_node *port_to_ports(struct device_node *port)
239 {
240 	struct device_node *ports = of_get_parent(port);
241 
242 	if (!of_node_name_eq(ports, "ports")) {
243 		of_node_put(ports);
244 		return NULL;
245 	}
246 	return ports;
247 }
248 
__graph_get_type(struct device_node * lnk)249 static enum graph_type __graph_get_type(struct device_node *lnk)
250 {
251 	struct device_node *np, *parent_np;
252 	enum graph_type ret;
253 
254 	/*
255 	 * target {
256 	 *	ports {
257 	 * =>		lnk:	port@0 { ... };
258 	 *			port@1 { ... };
259 	 *	};
260 	 * };
261 	 */
262 	np = of_get_parent(lnk);
263 	if (of_node_name_eq(np, "ports")) {
264 		parent_np = of_get_parent(np);
265 		of_node_put(np);
266 		np = parent_np;
267 	}
268 
269 	if (of_node_name_eq(np, GRAPH_NODENAME_MULTI)) {
270 		ret = GRAPH_MULTI;
271 		fw_devlink_purge_absent_suppliers(&np->fwnode);
272 		goto out_put;
273 	}
274 
275 	if (of_node_name_eq(np, GRAPH_NODENAME_DPCM)) {
276 		ret = GRAPH_DPCM;
277 		fw_devlink_purge_absent_suppliers(&np->fwnode);
278 		goto out_put;
279 	}
280 
281 	if (of_node_name_eq(np, GRAPH_NODENAME_C2C)) {
282 		ret = GRAPH_C2C;
283 		fw_devlink_purge_absent_suppliers(&np->fwnode);
284 		goto out_put;
285 	}
286 
287 	ret = GRAPH_NORMAL;
288 
289 out_put:
290 	of_node_put(np);
291 	return ret;
292 
293 }
294 
graph_get_type(struct simple_util_priv * priv,struct device_node * lnk)295 static enum graph_type graph_get_type(struct simple_util_priv *priv,
296 				      struct device_node *lnk)
297 {
298 	enum graph_type type = __graph_get_type(lnk);
299 
300 	/* GRAPH_MULTI here means GRAPH_NORMAL */
301 	if (type == GRAPH_MULTI)
302 		type = GRAPH_NORMAL;
303 
304 #ifdef DEBUG
305 	{
306 		struct device *dev = simple_priv_to_dev(priv);
307 		const char *str = "Normal";
308 
309 		switch (type) {
310 		case GRAPH_DPCM:
311 			if (graph_util_is_ports0(lnk))
312 				str = "DPCM Front-End";
313 			else
314 				str = "DPCM Back-End";
315 			break;
316 		case GRAPH_C2C:
317 			str = "Codec2Codec";
318 			break;
319 		default:
320 			break;
321 		}
322 
323 		dev_dbg(dev, "%pOF (%s)", lnk, str);
324 	}
325 #endif
326 	return type;
327 }
328 
graph_lnk_is_multi(struct device_node * lnk)329 static int graph_lnk_is_multi(struct device_node *lnk)
330 {
331 	return __graph_get_type(lnk) == GRAPH_MULTI;
332 }
333 
graph_get_next_multi_ep(struct device_node ** port,int idx)334 static struct device_node *graph_get_next_multi_ep(struct device_node **port, int idx)
335 {
336 	struct device_node *ports __free(device_node) = port_to_ports(*port);
337 	struct device_node *rep = NULL;
338 
339 	/*
340 	 * multi {
341 	 *	ports {
342 	 * =>	lnk:	port@0 { ...		   }; // to pair
343 	 *		port@1 { ep { ... = rep0 } }; // Multi Element
344 	 *		port@2 { ep { ... = rep1 } }; // Multi Element
345 	 *		...
346 	 *	};
347 	 * };
348 	 *
349 	 * xxx {
350 	 *	port@0 { rep0 };
351 	 *	port@1 { rep1 };
352 	 * };
353 	 */
354 
355 	/*
356 	 * Don't use of_graph_get_next_port() here
357 	 *
358 	 * In overlay case, "port" are not necessarily in order. So we need to use
359 	 * of_graph_get_port_by_id() instead
360 	 */
361 	of_node_put(*port);
362 
363 	*port = of_graph_get_port_by_id(ports, idx);
364 	if (*port) {
365 		struct device_node *ep __free(device_node) = of_graph_get_next_port_endpoint(*port, NULL);
366 
367 		rep = of_graph_get_remote_endpoint(ep);
368 	}
369 
370 	return rep;
371 }
372 
373 static const struct snd_soc_ops graph_ops = {
374 	.startup	= simple_util_startup,
375 	.shutdown	= simple_util_shutdown,
376 	.hw_params	= simple_util_hw_params,
377 };
378 
graph_parse_convert(struct device_node * ep,struct simple_dai_props * props)379 static void graph_parse_convert(struct device_node *ep,
380 				struct simple_dai_props *props)
381 {
382 	struct device_node *port  __free(device_node) = ep_to_port(ep);
383 	struct device_node *ports __free(device_node) = port_to_ports(port);
384 	struct simple_util_data *adata = &props->adata;
385 
386 	simple_util_parse_convert(ports, NULL, adata);
387 	simple_util_parse_convert(port, NULL, adata);
388 	simple_util_parse_convert(ep,   NULL, adata);
389 }
390 
__graph_parse_node(struct simple_util_priv * priv,enum graph_type gtype,struct device_node * ep,struct link_info * li,int is_cpu,int idx)391 static int __graph_parse_node(struct simple_util_priv *priv,
392 			      enum graph_type gtype,
393 			      struct device_node *ep,
394 			      struct link_info *li,
395 			      int is_cpu, int idx)
396 {
397 	struct device *dev = simple_priv_to_dev(priv);
398 	struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);
399 	struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link);
400 	struct snd_soc_dai_link_component *dlc;
401 	struct simple_util_dai *dai;
402 	int ret, is_single_links = 0;
403 
404 	if (is_cpu) {
405 		dlc = snd_soc_link_to_cpu(dai_link, idx);
406 		dai = simple_props_to_dai_cpu(dai_props, idx);
407 	} else {
408 		dlc = snd_soc_link_to_codec(dai_link, idx);
409 		dai = simple_props_to_dai_codec(dai_props, idx);
410 	}
411 
412 	ret = graph_util_parse_dai(dev, ep, dlc, &is_single_links);
413 	if (ret < 0)
414 		return ret;
415 
416 	ret = simple_util_parse_tdm(ep, dai);
417 	if (ret < 0)
418 		return ret;
419 
420 	ret = simple_util_parse_tdm_width_map(dev, ep, dai);
421 	if (ret < 0)
422 		return ret;
423 
424 	ret = simple_util_parse_clk(dev, ep, dai, dlc);
425 	if (ret < 0)
426 		return ret;
427 
428 	/*
429 	 * set DAI Name
430 	 */
431 	if (!dai_link->name) {
432 		struct snd_soc_dai_link_component *cpus = dlc;
433 		struct snd_soc_dai_link_component *codecs = snd_soc_link_to_codec(dai_link, idx);
434 		char *cpu_multi   = "";
435 		char *codec_multi = "";
436 
437 		if (dai_link->num_cpus > 1)
438 			cpu_multi = "_multi";
439 		if (dai_link->num_codecs > 1)
440 			codec_multi = "_multi";
441 
442 		switch (gtype) {
443 		case GRAPH_NORMAL:
444 			/* run is_cpu only. see audio_graph2_link_normal() */
445 			if (is_cpu)
446 				simple_util_set_dailink_name(dev, dai_link, "%s%s-%s%s",
447 							       cpus->dai_name,   cpu_multi,
448 							     codecs->dai_name, codec_multi);
449 			break;
450 		case GRAPH_DPCM:
451 			if (is_cpu)
452 				simple_util_set_dailink_name(dev, dai_link, "fe.%pOFP.%s%s",
453 						cpus->of_node, cpus->dai_name, cpu_multi);
454 			else
455 				simple_util_set_dailink_name(dev, dai_link, "be.%pOFP.%s%s",
456 						codecs->of_node, codecs->dai_name, codec_multi);
457 			break;
458 		case GRAPH_C2C:
459 			/* run is_cpu only. see audio_graph2_link_c2c() */
460 			if (is_cpu)
461 				simple_util_set_dailink_name(dev, dai_link, "c2c.%s%s-%s%s",
462 							     cpus->dai_name,   cpu_multi,
463 							     codecs->dai_name, codec_multi);
464 			break;
465 		default:
466 			break;
467 		}
468 	}
469 
470 	/*
471 	 * Check "prefix" from top node
472 	 * if DPCM-BE case
473 	 */
474 	if (!is_cpu && gtype == GRAPH_DPCM) {
475 		struct snd_soc_dai_link_component *codecs = snd_soc_link_to_codec(dai_link, idx);
476 		struct snd_soc_codec_conf *cconf = simple_props_to_codec_conf(dai_props, idx);
477 		struct device_node *rport  __free(device_node) = ep_to_port(ep);
478 		struct device_node *rports __free(device_node) = port_to_ports(rport);
479 
480 		snd_soc_of_parse_node_prefix(rports, cconf, codecs->of_node, "prefix");
481 		snd_soc_of_parse_node_prefix(rport,  cconf, codecs->of_node, "prefix");
482 	}
483 
484 	if (is_cpu) {
485 		struct snd_soc_dai_link_component *cpus = dlc;
486 		struct snd_soc_dai_link_component *platforms = snd_soc_link_to_platform(dai_link, idx);
487 
488 		simple_util_canonicalize_cpu(cpus, is_single_links);
489 		simple_util_canonicalize_platform(platforms, cpus);
490 	}
491 
492 	return 0;
493 }
494 
graph_parse_node_multi_nm(struct snd_soc_dai_link * dai_link,int * nm_idx,int cpu_idx,struct device_node * mcpu_port)495 static int graph_parse_node_multi_nm(struct snd_soc_dai_link *dai_link,
496 				     int *nm_idx, int cpu_idx,
497 				     struct device_node *mcpu_port)
498 {
499 	/*
500 	 *		+---+		+---+
501 	 *		|  X|<-@------->|x  |
502 	 *		|   |		|   |
503 	 *	cpu0 <--|A 1|<--------->|4 a|-> codec0
504 	 *	cpu1 <--|B 2|<-----+--->|5 b|-> codec1
505 	 *	cpu2 <--|C 3|<----/	+---+
506 	 *		+---+
507 	 *
508 	 * multi {
509 	 *	ports {
510 	 *		port@0 { mcpu_top_ep	{...  = mcodec_ep;	}; };	// (X) to pair
511 	 * <mcpu_port>	port@1 { mcpu0_ep	{ ... = cpu0_ep;	};	// (A) Multi Element
512 	 *			 mcpu0_ep_0	{ ... = mcodec0_ep_0;	}; };	// (1) connected Codec
513 	 *		port@2 { mcpu1_ep	{ ... = cpu1_ep;	};	// (B) Multi Element
514 	 *			 mcpu1_ep_0	{ ... = mcodec1_ep_0;	}; };	// (2) connected Codec
515 	 *		port@3 { mcpu2_ep	{ ... = cpu2_ep;	};	// (C) Multi Element
516 	 *			 mcpu2_ep_0	{ ... = mcodec1_ep_1;	}; };	// (3) connected Codec
517 	 *	};
518 	 *
519 	 *	ports {
520 	 *		port@0 { mcodec_top_ep	{...  = mcpu_ep;	}; };	// (x) to pair
521 	 * <mcodec_port>port@1 { mcodec0_ep	{ ... = codec0_ep;	};	// (a) Multi Element
522 	 *			 mcodec0_ep_0	{ ... = mcpu0_ep_0;	}; };	// (4) connected CPU
523 	 *		port@2 { mcodec1_ep	{ ... = codec1_ep;	};	// (b) Multi Element
524 	 *			 mcodec1_ep_0	{ ... = mcpu1_ep_0;	};	// (5) connected CPU
525 	 *			 mcodec1_ep_1	{ ... = mcpu2_ep_0;	}; };	// (5) connected CPU
526 	 *	};
527 	 * };
528 	 */
529 	struct device_node *mcpu_ep		__free(device_node) = of_graph_get_next_port_endpoint(mcpu_port, NULL);
530 	struct device_node *mcpu_ports		__free(device_node) = port_to_ports(mcpu_port);
531 	struct device_node *mcpu_port_top	__free(device_node) = of_graph_get_next_port(mcpu_ports, NULL);
532 	struct device_node *mcpu_ep_top		__free(device_node) = of_graph_get_next_port_endpoint(mcpu_port_top, NULL);
533 	struct device_node *mcodec_ep_top	__free(device_node) = of_graph_get_remote_endpoint(mcpu_ep_top);
534 	struct device_node *mcodec_port_top	__free(device_node) = ep_to_port(mcodec_ep_top);
535 	struct device_node *mcodec_ports	__free(device_node) = port_to_ports(mcodec_port_top);
536 	int nm_max = max(dai_link->num_cpus, dai_link->num_codecs);
537 	int ret = 0;
538 
539 	if (cpu_idx > dai_link->num_cpus)
540 		return -EINVAL;
541 
542 	for_each_of_graph_port_endpoint(mcpu_port, mcpu_ep_n) {
543 		int codec_idx = 0;
544 
545 		/* ignore 1st ep which is for element */
546 		if (mcpu_ep_n == mcpu_ep)
547 			continue;
548 
549 		if (*nm_idx > nm_max)
550 			break;
551 
552 		struct device_node *mcodec_ep_n __free(device_node) = of_graph_get_remote_endpoint(mcpu_ep_n);
553 		struct device_node *mcodec_port __free(device_node) = ep_to_port(mcodec_ep_n);
554 
555 		ret = -EINVAL;
556 		if (mcodec_ports != port_to_ports(mcodec_port))
557 			break;
558 
559 		for_each_of_graph_port(mcodec_ports, mcodec_port_i) {
560 
561 			/* ignore 1st port which is for pair connection */
562 			if (mcodec_port_top == mcodec_port_i)
563 				continue;
564 
565 			if (codec_idx > dai_link->num_codecs)
566 				break;
567 
568 			if (mcodec_port_i == mcodec_port) {
569 				dai_link->ch_maps[*nm_idx].cpu	 = cpu_idx;
570 				dai_link->ch_maps[*nm_idx].codec = codec_idx;
571 
572 				(*nm_idx)++;
573 				ret = 0;
574 				break;
575 			}
576 			codec_idx++;
577 		}
578 		if (ret < 0)
579 			break;
580 	}
581 
582 	return ret;
583 }
584 
graph_parse_node_multi(struct simple_util_priv * priv,enum graph_type gtype,struct device_node * port,struct link_info * li,int is_cpu)585 static int graph_parse_node_multi(struct simple_util_priv *priv,
586 				  enum graph_type gtype,
587 				  struct device_node *port,
588 				  struct link_info *li, int is_cpu)
589 {
590 	struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);
591 	struct device *dev = simple_priv_to_dev(priv);
592 	int ret = -ENOMEM;
593 	int nm_idx = 0;
594 	int nm_max = max(dai_link->num_cpus, dai_link->num_codecs);
595 
596 	/*
597 	 * create ch_maps if CPU:Codec = N:M
598 	 * DPCM is out of scope
599 	 */
600 	if (gtype != GRAPH_DPCM && !dai_link->ch_maps &&
601 	    dai_link->num_cpus > 1 && dai_link->num_codecs > 1 &&
602 	    dai_link->num_cpus != dai_link->num_codecs) {
603 
604 		dai_link->ch_maps = devm_kcalloc(dev, nm_max,
605 					sizeof(struct snd_soc_dai_link_ch_map), GFP_KERNEL);
606 		if (!dai_link->ch_maps)
607 			goto multi_err;
608 	}
609 
610 	for (int idx = 0;; idx++) {
611 		/*
612 		 * multi {
613 		 *	ports {
614 		 * <port>	port@0 { ... 			    }; // to pair
615 		 *		port@1 { mcpu1_ep { ... = cpu1_ep };}; // Multi Element
616 		 *		port@2 { mcpu2_ep { ... = cpu2_ep };}; // Multi Element
617 		 *	};
618 		 * };
619 		 *
620 		 * cpu {
621 		 *	ports {
622 		 * <ep>		port@0 { cpu1_ep   { ... = mcpu1_ep };};
623 		 *	};
624 		 * };
625 		 */
626 		struct device_node *ep __free(device_node) = graph_get_next_multi_ep(&port, idx + 1);
627 		if (!ep)
628 			break;
629 
630 		ret = __graph_parse_node(priv, gtype, ep, li, is_cpu, idx);
631 		if (ret < 0)
632 			goto multi_err;
633 
634 		/* CPU:Codec = N:M */
635 		if (is_cpu && dai_link->ch_maps) {
636 			ret = graph_parse_node_multi_nm(dai_link, &nm_idx, idx, port);
637 			if (ret < 0)
638 				goto multi_err;
639 		}
640 	}
641 
642 	if (is_cpu && dai_link->ch_maps && (nm_idx != nm_max))
643 		ret = -EINVAL;
644 
645 multi_err:
646 	return ret;
647 }
648 
graph_parse_node_single(struct simple_util_priv * priv,enum graph_type gtype,struct device_node * ep,struct link_info * li,int is_cpu)649 static int graph_parse_node_single(struct simple_util_priv *priv,
650 				   enum graph_type gtype,
651 				   struct device_node *ep,
652 				   struct link_info *li, int is_cpu)
653 {
654 	return __graph_parse_node(priv, gtype, ep, li, is_cpu, 0);
655 }
656 
graph_parse_node(struct simple_util_priv * priv,enum graph_type gtype,struct device_node * ep,struct link_info * li,int is_cpu)657 static int graph_parse_node(struct simple_util_priv *priv,
658 			    enum graph_type gtype,
659 			    struct device_node *ep,
660 			    struct link_info *li, int is_cpu)
661 {
662 	struct device_node *port __free(device_node) = ep_to_port(ep);
663 
664 	if (graph_lnk_is_multi(port))
665 		return graph_parse_node_multi(priv, gtype, port, li, is_cpu);
666 	else
667 		return graph_parse_node_single(priv, gtype, ep, li, is_cpu);
668 }
669 
graph_parse_daifmt(struct device_node * node,unsigned int * daifmt)670 static void graph_parse_daifmt(struct device_node *node, unsigned int *daifmt)
671 {
672 	unsigned int fmt;
673 
674 	if (!node)
675 		return;
676 
677 	/*
678 	 * see also above "daifmt" explanation
679 	 * and samples.
680 	 */
681 
682 	/*
683 	 *	ports {
684 	 * (A)
685 	 *		port {
686 	 * (B)
687 	 *			endpoint {
688 	 * (C)
689 	 *			};
690 	 *		};
691 	 *	};
692 	 * };
693 	 */
694 
695 #define update_daifmt(name)					\
696 	if (!(*daifmt & SND_SOC_DAIFMT_##name##_MASK) &&	\
697 		 (fmt & SND_SOC_DAIFMT_##name##_MASK))		\
698 		*daifmt |= fmt & SND_SOC_DAIFMT_##name##_MASK
699 
700 	/*
701 	 * format
702 	 *
703 	 * This function is called by (C) -> (B) -> (A) order.
704 	 * Set if applicable part was not yet set.
705 	 */
706 	fmt = snd_soc_daifmt_parse_format(node, NULL);
707 	update_daifmt(FORMAT);
708 	update_daifmt(CLOCK);
709 	update_daifmt(INV);
710 }
711 
graph_parse_bitframe(struct device_node * ep)712 static unsigned int graph_parse_bitframe(struct device_node *ep)
713 {
714 	struct device_node *port  __free(device_node) = ep_to_port(ep);
715 	struct device_node *ports __free(device_node) = port_to_ports(port);
716 
717 	return	snd_soc_daifmt_clock_provider_from_bitmap(
718 			snd_soc_daifmt_parse_clock_provider_as_bitmap(ep,    NULL) |
719 			snd_soc_daifmt_parse_clock_provider_as_bitmap(port,  NULL) |
720 			snd_soc_daifmt_parse_clock_provider_as_bitmap(ports, NULL));
721 }
722 
graph_link_init(struct simple_util_priv * priv,struct device_node * lnk,struct device_node * ep_cpu,struct device_node * ep_codec,struct link_info * li,int is_cpu_node)723 static void graph_link_init(struct simple_util_priv *priv,
724 			    struct device_node *lnk,
725 			    struct device_node *ep_cpu,
726 			    struct device_node *ep_codec,
727 			    struct link_info *li,
728 			    int is_cpu_node)
729 {
730 	struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);
731 	struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link);
732 	struct device_node *port_cpu = ep_to_port(ep_cpu);
733 	struct device_node *port_codec = ep_to_port(ep_codec);
734 	struct device_node *multi_cpu_port = NULL, *multi_codec_port = NULL;
735 	struct snd_soc_dai_link_component *dlc;
736 	unsigned int daifmt = 0;
737 	bool playback_only = 0, capture_only = 0;
738 	enum snd_soc_trigger_order trigger_start = SND_SOC_TRIGGER_ORDER_DEFAULT;
739 	enum snd_soc_trigger_order trigger_stop  = SND_SOC_TRIGGER_ORDER_DEFAULT;
740 	int multi_cpu_port_idx = 1, multi_codec_port_idx = 1;
741 	int i;
742 
743 	if (graph_lnk_is_multi(port_cpu)) {
744 		multi_cpu_port = port_cpu;
745 		ep_cpu = graph_get_next_multi_ep(&multi_cpu_port, multi_cpu_port_idx++);
746 		of_node_put(port_cpu);
747 		port_cpu = ep_to_port(ep_cpu);
748 	} else {
749 		of_node_get(ep_cpu);
750 	}
751 	struct device_node *ports_cpu __free(device_node) = port_to_ports(port_cpu);
752 
753 	if (graph_lnk_is_multi(port_codec)) {
754 		multi_codec_port = port_codec;
755 		ep_codec = graph_get_next_multi_ep(&multi_codec_port, multi_codec_port_idx++);
756 		of_node_put(port_codec);
757 		port_codec = ep_to_port(ep_codec);
758 	} else {
759 		of_node_get(ep_codec);
760 	}
761 	struct device_node *ports_codec __free(device_node) = port_to_ports(port_codec);
762 
763 	graph_parse_daifmt(ep_cpu,	&daifmt);
764 	graph_parse_daifmt(ep_codec,	&daifmt);
765 	graph_parse_daifmt(port_cpu,	&daifmt);
766 	graph_parse_daifmt(port_codec,	&daifmt);
767 	graph_parse_daifmt(ports_cpu,	&daifmt);
768 	graph_parse_daifmt(ports_codec,	&daifmt);
769 	graph_parse_daifmt(lnk,		&daifmt);
770 
771 	graph_util_parse_link_direction(lnk,		&playback_only, &capture_only);
772 	graph_util_parse_link_direction(ports_cpu,	&playback_only, &capture_only);
773 	graph_util_parse_link_direction(ports_codec,	&playback_only, &capture_only);
774 	graph_util_parse_link_direction(port_cpu,	&playback_only, &capture_only);
775 	graph_util_parse_link_direction(port_codec,	&playback_only, &capture_only);
776 	graph_util_parse_link_direction(ep_cpu,		&playback_only, &capture_only);
777 	graph_util_parse_link_direction(ep_codec,	&playback_only, &capture_only);
778 
779 	of_property_read_u32(lnk,		"mclk-fs", &dai_props->mclk_fs);
780 	of_property_read_u32(ports_cpu,		"mclk-fs", &dai_props->mclk_fs);
781 	of_property_read_u32(ports_codec,	"mclk-fs", &dai_props->mclk_fs);
782 	of_property_read_u32(port_cpu,		"mclk-fs", &dai_props->mclk_fs);
783 	of_property_read_u32(port_codec,	"mclk-fs", &dai_props->mclk_fs);
784 	of_property_read_u32(ep_cpu,		"mclk-fs", &dai_props->mclk_fs);
785 	of_property_read_u32(ep_codec,		"mclk-fs", &dai_props->mclk_fs);
786 
787 	graph_util_parse_trigger_order(priv, lnk,		&trigger_start, &trigger_stop);
788 	graph_util_parse_trigger_order(priv, ports_cpu,		&trigger_start, &trigger_stop);
789 	graph_util_parse_trigger_order(priv, ports_codec,	&trigger_start, &trigger_stop);
790 	graph_util_parse_trigger_order(priv, port_cpu,		&trigger_start, &trigger_stop);
791 	graph_util_parse_trigger_order(priv, port_cpu,		&trigger_start, &trigger_stop);
792 	graph_util_parse_trigger_order(priv, ep_cpu,		&trigger_start, &trigger_stop);
793 	graph_util_parse_trigger_order(priv, ep_codec,		&trigger_start, &trigger_stop);
794 
795 	for_each_link_cpus(dai_link, i, dlc) {
796 		dlc->ext_fmt = graph_parse_bitframe(ep_cpu);
797 
798 		if (multi_cpu_port)
799 			ep_cpu = graph_get_next_multi_ep(&multi_cpu_port, multi_cpu_port_idx++);
800 	}
801 
802 	for_each_link_codecs(dai_link, i, dlc) {
803 		dlc->ext_fmt = graph_parse_bitframe(ep_codec);
804 
805 		if (multi_codec_port)
806 			ep_codec = graph_get_next_multi_ep(&multi_codec_port, multi_codec_port_idx++);
807 	}
808 
809 	/*** Don't use port_cpu / port_codec after here ***/
810 
811 	dai_link->playback_only	= playback_only;
812 	dai_link->capture_only	= capture_only;
813 
814 	dai_link->trigger_start	= trigger_start;
815 	dai_link->trigger_stop	= trigger_stop;
816 
817 	dai_link->dai_fmt	= daifmt;
818 	dai_link->init		= simple_util_dai_init;
819 	dai_link->ops		= &graph_ops;
820 	if (priv->ops)
821 		dai_link->ops	= priv->ops;
822 
823 	of_node_put(port_cpu);
824 	of_node_put(port_codec);
825 	of_node_put(ep_cpu);
826 	of_node_put(ep_codec);
827 }
828 
audio_graph2_link_normal(struct simple_util_priv * priv,struct device_node * lnk,struct link_info * li)829 int audio_graph2_link_normal(struct simple_util_priv *priv,
830 			     struct device_node *lnk,
831 			     struct link_info *li)
832 {
833 	struct device_node *cpu_port = lnk;
834 	struct device_node *cpu_ep	__free(device_node) = of_graph_get_next_port_endpoint(cpu_port, NULL);
835 	struct device_node *codec_ep	__free(device_node) = of_graph_get_remote_endpoint(cpu_ep);
836 	int ret;
837 
838 	/*
839 	 * call Codec first.
840 	 * see
841 	 *	__graph_parse_node() :: DAI Naming
842 	 */
843 	ret = graph_parse_node(priv, GRAPH_NORMAL, codec_ep, li, 0);
844 	if (ret < 0)
845 		return ret;
846 
847 	/*
848 	 * call CPU, and set DAI Name
849 	 */
850 	ret = graph_parse_node(priv, GRAPH_NORMAL, cpu_ep, li, 1);
851 	if (ret < 0)
852 		return ret;
853 
854 	graph_link_init(priv, lnk, cpu_ep, codec_ep, li, 1);
855 
856 	return ret;
857 }
858 EXPORT_SYMBOL_GPL(audio_graph2_link_normal);
859 
audio_graph2_link_dpcm(struct simple_util_priv * priv,struct device_node * lnk,struct link_info * li)860 int audio_graph2_link_dpcm(struct simple_util_priv *priv,
861 			   struct device_node *lnk,
862 			   struct link_info *li)
863 {
864 	struct device_node *ep	__free(device_node) = of_graph_get_next_port_endpoint(lnk, NULL);
865 	struct device_node *rep	__free(device_node) = of_graph_get_remote_endpoint(ep);
866 	struct device_node *cpu_ep = NULL;
867 	struct device_node *codec_ep = NULL;
868 	struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);
869 	struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link);
870 	int is_cpu = graph_util_is_ports0(lnk);
871 	int ret;
872 
873 	if (is_cpu) {
874 		cpu_ep = rep;
875 
876 		/*
877 		 * dpcm {
878 		 *	// Front-End
879 		 *	ports@0 {
880 		 * =>		lnk: port@0 { ep: { ... = rep }; };
881 		 *		 ...
882 		 *	};
883 		 *	// Back-End
884 		 *	ports@0 {
885 		 *		 ...
886 		 *	};
887 		 * };
888 		 *
889 		 * CPU {
890 		 *	rports: ports {
891 		 *		rport: port@0 { rep: { ... = ep } };
892 		 *	}
893 		 * }
894 		 */
895 		/*
896 		 * setup CPU here, Codec is already set as dummy.
897 		 * see
898 		 *	simple_util_init_priv()
899 		 */
900 		dai_link->dynamic		= 1;
901 		dai_link->dpcm_merged_format	= 1;
902 
903 		ret = graph_parse_node(priv, GRAPH_DPCM, cpu_ep, li, 1);
904 		if (ret)
905 			return ret;
906 
907 	} else {
908 		codec_ep = rep;
909 
910 		/*
911 		 * dpcm {
912 		 *	// Front-End
913 		 *	ports@0 {
914 		 *		 ...
915 		 *	};
916 		 *	// Back-End
917 		 *	ports@0 {
918 		 * =>		lnk: port@0 { ep: { ... = rep; }; };
919 		 *		 ...
920 		 *	};
921 		 * };
922 		 *
923 		 * Codec {
924 		 *	rports: ports {
925 		 *		rport: port@0 { rep: { ... = ep; }; };
926 		 *	}
927 		 * }
928 		 */
929 		/*
930 		 * setup Codec here, CPU is already set as dummy.
931 		 * see
932 		 *	simple_util_init_priv()
933 		 */
934 
935 		/* BE settings */
936 		dai_link->no_pcm		= 1;
937 		dai_link->be_hw_params_fixup	= simple_util_be_hw_params_fixup;
938 
939 		ret = graph_parse_node(priv, GRAPH_DPCM, codec_ep, li, 0);
940 		if (ret < 0)
941 			return ret;
942 	}
943 
944 	graph_parse_convert(ep,  dai_props); /* at node of <dpcm> */
945 	graph_parse_convert(rep, dai_props); /* at node of <CPU/Codec> */
946 
947 	graph_link_init(priv, lnk, cpu_ep, codec_ep, li, is_cpu);
948 
949 	return ret;
950 }
951 EXPORT_SYMBOL_GPL(audio_graph2_link_dpcm);
952 
audio_graph2_link_c2c(struct simple_util_priv * priv,struct device_node * lnk,struct link_info * li)953 int audio_graph2_link_c2c(struct simple_util_priv *priv,
954 			  struct device_node *lnk,
955 			  struct link_info *li)
956 {
957 	struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link);
958 	struct device_node *port0 = lnk;
959 	struct device_node *ports __free(device_node) = port_to_ports(port0);
960 	struct device_node *port1 __free(device_node) = of_graph_get_next_port(ports, port0);
961 	u32 val = 0;
962 	int ret = -EINVAL;
963 
964 	/*
965 	 * codec2codec {
966 	 *	ports {
967 	 *		rate = <48000>;
968 	 * =>	lnk:	port@0 { c2c0_ep: { ... = codec0_ep; }; };
969 	 *		port@1 { c2c1_ep: { ... = codec1_ep; }; };
970 	 *	};
971 	 * };
972 	 *
973 	 * Codec {
974 	 *	ports {
975 	 *		port@0 { codec0_ep: ... }; };
976 	 *		port@1 { codec1_ep: ... }; };
977 	 *	};
978 	 * };
979 	 */
980 
981 	/*
982 	 * Card2 can use original Codec2Codec settings if DT has.
983 	 * It will use default settings if no settings on DT.
984 	 * see
985 	 *	simple_util_init_for_codec2codec()
986 	 *
987 	 * Add more settings here if needed
988 	 */
989 	of_property_read_u32(ports, "rate", &val);
990 	if (val) {
991 		struct device *dev = simple_priv_to_dev(priv);
992 		struct snd_soc_pcm_stream *c2c_conf;
993 
994 		c2c_conf = devm_kzalloc(dev, sizeof(*c2c_conf), GFP_KERNEL);
995 		if (!c2c_conf)
996 			return ret;
997 
998 		c2c_conf->formats	= SNDRV_PCM_FMTBIT_S32_LE; /* update ME */
999 		c2c_conf->rates		= SNDRV_PCM_RATE_8000_384000;
1000 		c2c_conf->rate_min	=
1001 		c2c_conf->rate_max	= val;
1002 		c2c_conf->channels_min	=
1003 		c2c_conf->channels_max	= 2; /* update ME */
1004 
1005 		dai_link->c2c_params		= c2c_conf;
1006 		dai_link->num_c2c_params	= 1;
1007 	}
1008 
1009 	struct device_node *ep0 __free(device_node) = of_graph_get_next_port_endpoint(port0, NULL);
1010 	struct device_node *ep1 __free(device_node) = of_graph_get_next_port_endpoint(port1, NULL);
1011 
1012 	struct device_node *codec0_ep __free(device_node) = of_graph_get_remote_endpoint(ep0);
1013 	struct device_node *codec1_ep __free(device_node) = of_graph_get_remote_endpoint(ep1);
1014 
1015 	/*
1016 	 * call Codec first.
1017 	 * see
1018 	 *	__graph_parse_node() :: DAI Naming
1019 	 */
1020 	ret = graph_parse_node(priv, GRAPH_C2C, codec1_ep, li, 0);
1021 	if (ret < 0)
1022 		return ret;
1023 
1024 	/*
1025 	 * call CPU, and set DAI Name
1026 	 */
1027 	ret = graph_parse_node(priv, GRAPH_C2C, codec0_ep, li, 1);
1028 	if (ret < 0)
1029 		return ret;
1030 
1031 	graph_link_init(priv, lnk, codec0_ep, codec1_ep, li, 1);
1032 
1033 	return ret;
1034 }
1035 EXPORT_SYMBOL_GPL(audio_graph2_link_c2c);
1036 
graph_link(struct simple_util_priv * priv,struct graph2_custom_hooks * hooks,enum graph_type gtype,struct device_node * lnk,struct link_info * li)1037 static int graph_link(struct simple_util_priv *priv,
1038 		      struct graph2_custom_hooks *hooks,
1039 		      enum graph_type gtype,
1040 		      struct device_node *lnk,
1041 		      struct link_info *li)
1042 {
1043 	struct device *dev = simple_priv_to_dev(priv);
1044 	GRAPH2_CUSTOM func = NULL;
1045 	int ret = -EINVAL;
1046 
1047 	switch (gtype) {
1048 	case GRAPH_NORMAL:
1049 		if (hooks && hooks->custom_normal)
1050 			func = hooks->custom_normal;
1051 		else
1052 			func = audio_graph2_link_normal;
1053 		break;
1054 	case GRAPH_DPCM:
1055 		if (hooks && hooks->custom_dpcm)
1056 			func = hooks->custom_dpcm;
1057 		else
1058 			func = audio_graph2_link_dpcm;
1059 		break;
1060 	case GRAPH_C2C:
1061 		if (hooks && hooks->custom_c2c)
1062 			func = hooks->custom_c2c;
1063 		else
1064 			func = audio_graph2_link_c2c;
1065 		break;
1066 	default:
1067 		break;
1068 	}
1069 
1070 	if (!func) {
1071 		dev_err(dev, "non supported gtype (%d)\n", gtype);
1072 		goto err;
1073 	}
1074 
1075 	ret = func(priv, lnk, li);
1076 	if (ret < 0)
1077 		goto err;
1078 
1079 	li->link++;
1080 err:
1081 	return ret;
1082 }
1083 
graph_counter(struct device_node * lnk)1084 static int graph_counter(struct device_node *lnk)
1085 {
1086 	/*
1087 	 * Multi CPU / Codec
1088 	 *
1089 	 * multi {
1090 	 *	ports {
1091 	 * =>		lnk:	port@0 { ... }; // to pair
1092 	 *			port@1 { ... }; // Multi Element
1093 	 *			port@2 { ... }; // Multi Element
1094 	 *			...
1095 	 *	};
1096 	 * };
1097 	 *
1098 	 * ignore first lnk part
1099 	 */
1100 	if (graph_lnk_is_multi(lnk)) {
1101 		struct device_node *ports = port_to_ports(lnk);
1102 
1103 		/*
1104 		 * CPU/Codec = N:M case has many endpoints.
1105 		 * We can't use of_graph_get_endpoint_count() here
1106 		 */
1107 		return of_graph_get_port_count(ports) - 1;
1108 	}
1109 	/*
1110 	 * Single CPU / Codec
1111 	 */
1112 	else
1113 		return 1;
1114 }
1115 
graph_count_normal(struct simple_util_priv * priv,struct device_node * lnk,struct link_info * li)1116 static int graph_count_normal(struct simple_util_priv *priv,
1117 			      struct device_node *lnk,
1118 			      struct link_info *li)
1119 {
1120 	struct device_node *cpu_port = lnk;
1121 	struct device_node *cpu_ep	__free(device_node) = of_graph_get_next_port_endpoint(cpu_port, NULL);
1122 	struct device_node *codec_port	__free(device_node) = of_graph_get_remote_port(cpu_ep);
1123 
1124 	/*
1125 	 *	CPU {
1126 	 * =>		lnk: port { endpoint { .. }; };
1127 	 *	};
1128 	 */
1129 	/*
1130 	 * DON'T REMOVE platforms
1131 	 * see
1132 	 *	simple-card.c :: simple_count_noml()
1133 	 */
1134 	li->num[li->link].cpus		=
1135 	li->num[li->link].platforms	= graph_counter(cpu_port);
1136 
1137 	li->num[li->link].codecs	= graph_counter(codec_port);
1138 
1139 	return 0;
1140 }
1141 
graph_count_dpcm(struct simple_util_priv * priv,struct device_node * lnk,struct link_info * li)1142 static int graph_count_dpcm(struct simple_util_priv *priv,
1143 			    struct device_node *lnk,
1144 			    struct link_info *li)
1145 {
1146 	struct device_node *ep		__free(device_node) = of_graph_get_next_port_endpoint(lnk, NULL);
1147 	struct device_node *rport	__free(device_node) = of_graph_get_remote_port(ep);
1148 
1149 	/*
1150 	 * dpcm {
1151 	 *	// Front-End
1152 	 *	ports@0 {
1153 	 * =>		lnk: port@0 { endpoint { ... }; };
1154 	 *		 ...
1155 	 *	};
1156 	 *	// Back-End
1157 	 *	ports@1 {
1158 	 * =>		lnk: port@0 { endpoint { ... }; };
1159 	 *		 ...
1160 	 *	};
1161 	 * };
1162 	 */
1163 
1164 	if (graph_util_is_ports0(lnk)) {
1165 		/*
1166 		 * DON'T REMOVE platforms
1167 		 * see
1168 		 *	simple-card.c :: simple_count_noml()
1169 		 */
1170 		li->num[li->link].cpus		= graph_counter(rport); /* FE */
1171 		li->num[li->link].platforms	= graph_counter(rport);
1172 	} else {
1173 		li->num[li->link].codecs	= graph_counter(rport); /* BE */
1174 	}
1175 
1176 	return 0;
1177 }
1178 
graph_count_c2c(struct simple_util_priv * priv,struct device_node * lnk,struct link_info * li)1179 static int graph_count_c2c(struct simple_util_priv *priv,
1180 			   struct device_node *lnk,
1181 			   struct link_info *li)
1182 {
1183 	struct device_node *ports	__free(device_node) = port_to_ports(lnk);
1184 	struct device_node *port0	= of_node_get(lnk);
1185 	struct device_node *port1	= of_node_get(of_graph_get_next_port(ports, of_node_get(port0)));
1186 	struct device_node *ep0		__free(device_node) = of_graph_get_next_port_endpoint(port0, NULL);
1187 	struct device_node *ep1		__free(device_node) = of_graph_get_next_port_endpoint(port1, NULL);
1188 	struct device_node *codec0	__free(device_node) = of_graph_get_remote_port(ep0);
1189 	struct device_node *codec1	__free(device_node) = of_graph_get_remote_port(ep1);
1190 
1191 	/*
1192 	 * codec2codec {
1193 	 *	ports {
1194 	 * =>	lnk:	port@0 { endpoint { ... }; };
1195 	 *		port@1 { endpoint { ... }; };
1196 	 *	};
1197 	 * };
1198 	 */
1199 	/*
1200 	 * DON'T REMOVE platforms
1201 	 * see
1202 	 *	simple-card.c :: simple_count_noml()
1203 	 */
1204 	li->num[li->link].cpus		=
1205 	li->num[li->link].platforms	= graph_counter(codec0);
1206 
1207 	li->num[li->link].codecs	= graph_counter(codec1);
1208 
1209 	return 0;
1210 }
1211 
graph_count(struct simple_util_priv * priv,struct graph2_custom_hooks * hooks,enum graph_type gtype,struct device_node * lnk,struct link_info * li)1212 static int graph_count(struct simple_util_priv *priv,
1213 		       struct graph2_custom_hooks *hooks,
1214 		       enum graph_type gtype,
1215 		       struct device_node *lnk,
1216 		       struct link_info *li)
1217 {
1218 	struct device *dev = simple_priv_to_dev(priv);
1219 	GRAPH2_CUSTOM func = NULL;
1220 	int ret = -EINVAL;
1221 
1222 	if (li->link >= SNDRV_MAX_LINKS) {
1223 		dev_err(dev, "too many links\n");
1224 		return ret;
1225 	}
1226 
1227 	switch (gtype) {
1228 	case GRAPH_NORMAL:
1229 		func = graph_count_normal;
1230 		break;
1231 	case GRAPH_DPCM:
1232 		func = graph_count_dpcm;
1233 		break;
1234 	case GRAPH_C2C:
1235 		func = graph_count_c2c;
1236 		break;
1237 	default:
1238 		break;
1239 	}
1240 
1241 	if (!func) {
1242 		dev_err(dev, "non supported gtype (%d)\n", gtype);
1243 		goto err;
1244 	}
1245 
1246 	ret = func(priv, lnk, li);
1247 	if (ret < 0)
1248 		goto err;
1249 
1250 	li->link++;
1251 err:
1252 	return ret;
1253 }
1254 
graph_for_each_link(struct simple_util_priv * priv,struct graph2_custom_hooks * hooks,struct link_info * li,int (* func)(struct simple_util_priv * priv,struct graph2_custom_hooks * hooks,enum graph_type gtype,struct device_node * lnk,struct link_info * li))1255 static int graph_for_each_link(struct simple_util_priv *priv,
1256 			       struct graph2_custom_hooks *hooks,
1257 			       struct link_info *li,
1258 			       int (*func)(struct simple_util_priv *priv,
1259 					   struct graph2_custom_hooks *hooks,
1260 					   enum graph_type gtype,
1261 					   struct device_node *lnk,
1262 					   struct link_info *li))
1263 {
1264 	struct of_phandle_iterator it;
1265 	struct device *dev = simple_priv_to_dev(priv);
1266 	struct device_node *node = dev->of_node;
1267 	struct device_node *lnk;
1268 	enum graph_type gtype;
1269 	int rc, ret;
1270 
1271 	/* loop for all listed CPU port */
1272 	of_for_each_phandle(&it, rc, node, "links", NULL, 0) {
1273 		lnk = it.node;
1274 
1275 		gtype = graph_get_type(priv, lnk);
1276 
1277 		ret = func(priv, hooks, gtype, lnk, li);
1278 		if (ret < 0)
1279 			return ret;
1280 	}
1281 
1282 	return 0;
1283 }
1284 
audio_graph2_parse_of(struct simple_util_priv * priv,struct device * dev,struct graph2_custom_hooks * hooks)1285 int audio_graph2_parse_of(struct simple_util_priv *priv, struct device *dev,
1286 			  struct graph2_custom_hooks *hooks)
1287 {
1288 	struct snd_soc_card *card = simple_priv_to_card(priv);
1289 	int ret;
1290 
1291 	struct link_info *li __free(kfree) = kzalloc(sizeof(*li), GFP_KERNEL);
1292 	if (!li)
1293 		return -ENOMEM;
1294 
1295 	card->probe	= graph_util_card_probe;
1296 	card->owner	= THIS_MODULE;
1297 	card->dev	= dev;
1298 
1299 	if ((hooks) && (hooks)->hook_pre) {
1300 		ret = (hooks)->hook_pre(priv);
1301 		if (ret < 0)
1302 			goto err;
1303 	}
1304 
1305 	ret = graph_for_each_link(priv, hooks, li, graph_count);
1306 	if (!li->link)
1307 		ret = -EINVAL;
1308 	if (ret < 0)
1309 		goto err;
1310 
1311 	ret = simple_util_init_priv(priv, li);
1312 	if (ret < 0)
1313 		goto err;
1314 
1315 	priv->pa_gpio = devm_gpiod_get_optional(dev, "pa", GPIOD_OUT_LOW);
1316 	if (IS_ERR(priv->pa_gpio)) {
1317 		ret = PTR_ERR(priv->pa_gpio);
1318 		dev_err(dev, "failed to get amplifier gpio: %d\n", ret);
1319 		goto err;
1320 	}
1321 
1322 	ret = simple_util_parse_widgets(card, NULL);
1323 	if (ret < 0)
1324 		goto err;
1325 
1326 	ret = simple_util_parse_routing(card, NULL);
1327 	if (ret < 0)
1328 		goto err;
1329 
1330 	memset(li, 0, sizeof(*li));
1331 	ret = graph_for_each_link(priv, hooks, li, graph_link);
1332 	if (ret < 0)
1333 		goto err;
1334 
1335 	ret = simple_util_parse_card_name(card, NULL);
1336 	if (ret < 0)
1337 		goto err;
1338 
1339 	snd_soc_card_set_drvdata(card, priv);
1340 
1341 	if ((hooks) && (hooks)->hook_post) {
1342 		ret = (hooks)->hook_post(priv);
1343 		if (ret < 0)
1344 			goto err;
1345 	}
1346 
1347 	simple_util_debug_info(priv);
1348 
1349 	ret = snd_soc_of_parse_aux_devs(card, "aux-devs");
1350 	if (ret < 0)
1351 		goto err;
1352 
1353 	ret = devm_snd_soc_register_card(dev, card);
1354 err:
1355 	if (ret < 0)
1356 		dev_err_probe(dev, ret, "parse error\n");
1357 
1358 	return ret;
1359 }
1360 EXPORT_SYMBOL_GPL(audio_graph2_parse_of);
1361 
graph_probe(struct platform_device * pdev)1362 static int graph_probe(struct platform_device *pdev)
1363 {
1364 	struct simple_util_priv *priv;
1365 	struct device *dev = &pdev->dev;
1366 
1367 	/* Allocate the private data and the DAI link array */
1368 	priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
1369 	if (!priv)
1370 		return -ENOMEM;
1371 
1372 	return audio_graph2_parse_of(priv, dev, NULL);
1373 }
1374 
1375 static const struct of_device_id graph_of_match[] = {
1376 	{ .compatible = "audio-graph-card2", },
1377 	{},
1378 };
1379 MODULE_DEVICE_TABLE(of, graph_of_match);
1380 
1381 static struct platform_driver graph_card = {
1382 	.driver = {
1383 		.name = "asoc-audio-graph-card2",
1384 		.pm = &snd_soc_pm_ops,
1385 		.of_match_table = graph_of_match,
1386 	},
1387 	.probe	= graph_probe,
1388 	.remove = simple_util_remove,
1389 };
1390 module_platform_driver(graph_card);
1391 
1392 MODULE_ALIAS("platform:asoc-audio-graph-card2");
1393 MODULE_LICENSE("GPL v2");
1394 MODULE_DESCRIPTION("ASoC Audio Graph Card2");
1395 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
1396