Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
ASoC: audio-graph-card2: use new of_graph functions
Now we can use new port related functions for port parsing. Use it.
Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
Acked-by: Mark Brown <broonie@kernel.org>
Link: https://lore.kernel.org/r/87ed46b5sm.wl-kuninori.morimoto.gx@renesas.com
Signed-off-by: Rob Herring (Arm) <robh@kernel.org>
authored by
Kuninori Morimoto
and committed by
Rob Herring (Arm)
0d4f080e
75e3d962
+52
-60
+52
-60
sound/soc/generic/audio-graph-card2.c
+52
-60
sound/soc/generic/audio-graph-card2.c
···
234
234
#define GRAPH_NODENAME_DPCM "dpcm"
235
235
#define GRAPH_NODENAME_C2C "codec2codec"
236
236
237
-
#define port_to_endpoint(port) of_get_child_by_name(port, "endpoint")
238
-
239
237
#define ep_to_port(ep) of_get_parent(ep)
240
238
static struct device_node *port_to_ports(struct device_node *port)
241
239
{
···
349
351
* port@1 { rep1 };
350
352
* };
351
353
*/
352
-
do {
353
-
*port = of_get_next_child(ports, *port);
354
-
if (!*port)
355
-
break;
356
-
} while (!of_node_name_eq(*port, "port"));
357
-
354
+
*port = of_graph_get_next_port(ports, *port);
358
355
if (*port) {
359
-
ep = port_to_endpoint(*port);
356
+
ep = of_graph_get_next_port_endpoint(*port, NULL);
360
357
rep = of_graph_get_remote_endpoint(ep);
361
358
}
362
359
···
523
530
* };
524
531
* };
525
532
*/
526
-
struct device_node *mcpu_ep = port_to_endpoint(mcpu_port);
527
-
struct device_node *mcpu_ep_n = mcpu_ep;
528
-
struct device_node *mcpu_port_top = of_get_next_child(port_to_ports(mcpu_port), NULL);
529
-
struct device_node *mcpu_ep_top = port_to_endpoint(mcpu_port_top);
533
+
struct device_node *mcpu_ep = of_graph_get_next_port_endpoint(mcpu_port, NULL);
534
+
struct device_node *mcpu_ports = port_to_ports(mcpu_port);
535
+
struct device_node *mcpu_port_top = of_graph_get_next_port(mcpu_ports, NULL);
536
+
struct device_node *mcpu_ep_top = of_graph_get_next_port_endpoint(mcpu_port_top, NULL);
530
537
struct device_node *mcodec_ep_top = of_graph_get_remote_endpoint(mcpu_ep_top);
531
538
struct device_node *mcodec_port_top = ep_to_port(mcodec_ep_top);
532
539
struct device_node *mcodec_ports = port_to_ports(mcodec_port_top);
533
540
int nm_max = max(dai_link->num_cpus, dai_link->num_codecs);
534
-
int ret = -EINVAL;
541
+
int ret = 0;
535
542
536
-
if (cpu_idx > dai_link->num_cpus)
543
+
if (cpu_idx > dai_link->num_cpus) {
544
+
ret = -EINVAL;
537
545
goto mcpu_err;
546
+
}
538
547
539
-
while (1) {
548
+
for_each_of_graph_port_endpoint(mcpu_port, mcpu_ep_n) {
540
549
struct device_node *mcodec_ep_n;
541
-
struct device_node *mcodec_port_i;
542
550
struct device_node *mcodec_port;
543
551
int codec_idx;
552
+
553
+
/* ignore 1st ep which is for element */
554
+
if (mcpu_ep_n == mcpu_ep)
555
+
continue;
544
556
545
557
if (*nm_idx > nm_max)
546
558
break;
547
559
548
-
mcpu_ep_n = of_get_next_child(mcpu_port, mcpu_ep_n);
549
-
if (!mcpu_ep_n) {
550
-
ret = 0;
551
-
break;
552
-
}
553
-
554
560
mcodec_ep_n = of_graph_get_remote_endpoint(mcpu_ep_n);
555
561
mcodec_port = ep_to_port(mcodec_ep_n);
556
562
557
-
if (mcodec_ports != port_to_ports(mcodec_port))
563
+
if (mcodec_ports != port_to_ports(mcodec_port)) {
564
+
ret = -EINVAL;
558
565
goto mcpu_err;
559
-
560
-
codec_idx = 0;
561
-
mcodec_port_i = of_get_next_child(mcodec_ports, NULL);
562
-
while (1) {
563
-
if (codec_idx > dai_link->num_codecs)
564
-
goto mcodec_err;
565
-
566
-
mcodec_port_i = of_get_next_child(mcodec_ports, mcodec_port_i);
567
-
568
-
if (!mcodec_port_i)
569
-
goto mcodec_err;
570
-
571
-
if (mcodec_port_i == mcodec_port)
572
-
break;
573
-
574
-
codec_idx++;
575
566
}
576
567
577
-
dai_link->ch_maps[*nm_idx].cpu = cpu_idx;
578
-
dai_link->ch_maps[*nm_idx].codec = codec_idx;
568
+
codec_idx = 0;
569
+
ret = -EINVAL;
570
+
for_each_of_graph_port(mcodec_ports, mcodec_port_i) {
579
571
580
-
(*nm_idx)++;
572
+
/* ignore 1st port which is for pair connection */
573
+
if (mcodec_port_top == mcodec_port_i)
574
+
continue;
581
575
582
-
of_node_put(mcodec_port_i);
583
-
mcodec_err:
576
+
if (codec_idx > dai_link->num_codecs)
577
+
break;
578
+
579
+
if (mcodec_port_i == mcodec_port) {
580
+
dai_link->ch_maps[*nm_idx].cpu = cpu_idx;
581
+
dai_link->ch_maps[*nm_idx].codec = codec_idx;
582
+
583
+
(*nm_idx)++;
584
+
ret = 0;
585
+
break;
586
+
}
587
+
codec_idx++;
588
+
}
584
589
of_node_put(mcodec_port);
585
-
of_node_put(mcpu_ep_n);
586
590
of_node_put(mcodec_ep_n);
591
+
if (ret < 0)
592
+
break;
587
593
}
588
594
mcpu_err:
589
595
of_node_put(mcpu_ep);
···
666
674
struct device_node *port,
667
675
struct link_info *li, int is_cpu)
668
676
{
669
-
struct device_node *ep = port_to_endpoint(port);
677
+
struct device_node *ep = of_graph_get_next_port_endpoint(port, NULL);
670
678
int ret = __graph_parse_node(priv, gtype, ep, li, is_cpu, 0);
671
679
672
680
of_node_put(ep);
···
761
769
of_node_put(port_cpu);
762
770
port_cpu = ep_to_port(ep_cpu);
763
771
} else {
764
-
ep_cpu = port_to_endpoint(port_cpu);
772
+
ep_cpu = of_graph_get_next_port_endpoint(port_cpu, NULL);
765
773
}
766
774
ports_cpu = port_to_ports(port_cpu);
767
775
···
771
779
of_node_put(port_cpu);
772
780
port_codec = ep_to_port(ep_codec);
773
781
} else {
774
-
ep_codec = port_to_endpoint(port_codec);
782
+
ep_codec = of_graph_get_next_port_endpoint(port_codec, NULL);
775
783
}
776
784
ports_codec = port_to_ports(port_codec);
777
785
···
842
850
struct link_info *li)
843
851
{
844
852
struct device_node *cpu_port = lnk;
845
-
struct device_node *cpu_ep = port_to_endpoint(cpu_port);
853
+
struct device_node *cpu_ep = of_graph_get_next_port_endpoint(cpu_port, NULL);
846
854
struct device_node *codec_port = of_graph_get_remote_port(cpu_ep);
847
855
int ret;
848
856
···
875
883
struct device_node *lnk,
876
884
struct link_info *li)
877
885
{
878
-
struct device_node *ep = port_to_endpoint(lnk);
886
+
struct device_node *ep = of_graph_get_next_port_endpoint(lnk, NULL);
879
887
struct device_node *rep = of_graph_get_remote_endpoint(ep);
880
888
struct device_node *cpu_port = NULL;
881
889
struct device_node *codec_port = NULL;
···
999
1007
of_node_get(lnk);
1000
1008
port0 = lnk;
1001
1009
ports = port_to_ports(port0);
1002
-
port1 = of_get_next_child(ports, lnk);
1010
+
port1 = of_graph_get_next_port(ports, port0);
1003
1011
1004
1012
/*
1005
1013
* Card2 can use original Codec2Codec settings if DT has.
···
1029
1037
dai_link->num_c2c_params = 1;
1030
1038
}
1031
1039
1032
-
ep0 = port_to_endpoint(port0);
1033
-
ep1 = port_to_endpoint(port1);
1040
+
ep0 = of_graph_get_next_port_endpoint(port0, NULL);
1041
+
ep1 = of_graph_get_next_port_endpoint(port1, NULL);
1034
1042
1035
1043
codec0_port = of_graph_get_remote_port(ep0);
1036
1044
codec1_port = of_graph_get_remote_port(ep1);
···
1136
1144
* CPU/Codec = N:M case has many endpoints.
1137
1145
* We can't use of_graph_get_endpoint_count() here
1138
1146
*/
1139
-
return of_get_child_count(ports) - 1;
1147
+
return of_graph_get_port_count(ports) - 1;
1140
1148
}
1141
1149
/*
1142
1150
* Single CPU / Codec
···
1150
1158
struct link_info *li)
1151
1159
{
1152
1160
struct device_node *cpu_port = lnk;
1153
-
struct device_node *cpu_ep = port_to_endpoint(cpu_port);
1161
+
struct device_node *cpu_ep = of_graph_get_next_port_endpoint(cpu_port, NULL);
1154
1162
struct device_node *codec_port = of_graph_get_remote_port(cpu_ep);
1155
1163
1156
1164
/*
···
1178
1186
struct device_node *lnk,
1179
1187
struct link_info *li)
1180
1188
{
1181
-
struct device_node *ep = port_to_endpoint(lnk);
1189
+
struct device_node *ep = of_graph_get_next_port_endpoint(lnk, NULL);
1182
1190
struct device_node *rport = of_graph_get_remote_port(ep);
1183
1191
1184
1192
/*
···
1220
1228
{
1221
1229
struct device_node *ports = port_to_ports(lnk);
1222
1230
struct device_node *port0 = lnk;
1223
-
struct device_node *port1 = of_get_next_child(ports, of_node_get(lnk));
1224
-
struct device_node *ep0 = port_to_endpoint(port0);
1225
-
struct device_node *ep1 = port_to_endpoint(port1);
1231
+
struct device_node *port1 = of_graph_get_next_port(ports, of_node_get(port0));
1232
+
struct device_node *ep0 = of_graph_get_next_port_endpoint(port0, NULL);
1233
+
struct device_node *ep1 = of_graph_get_next_port_endpoint(port1, NULL);
1226
1234
struct device_node *codec0 = of_graph_get_remote_port(ep0);
1227
1235
struct device_node *codec1 = of_graph_get_remote_port(ep1);
1228
1236