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