ASoC: simple-card: sync support · tjh.dev/kernel@522f88d

+1 -1

include/sound/simple_card_utils.h

··· 197 197 int graph_util_parse_dai(struct device *dev, struct device_node *ep, 198 198 struct snd_soc_dai_link_component *dlc, int *is_single_link); 199 199 200 - int graph_util_parse_link_direction(struct device_node *np, 200 + void graph_util_parse_link_direction(struct device_node *np, 201 201 bool *is_playback_only, bool *is_capture_only); 202 202 203 203 #ifdef DEBUG

+57 -38

sound/soc/generic/audio-graph-card.c

··· 19 19 20 20 #define DPCM_SELECTABLE 1 21 21 22 + #define ep_to_port(ep) of_get_parent(ep) 23 + static struct device_node *port_to_ports(struct device_node *port) 24 + { 25 + struct device_node *ports = of_get_parent(port); 26 + 27 + if (!of_node_name_eq(ports, "ports")) { 28 + of_node_put(ports); 29 + return NULL; 30 + } 31 + return ports; 32 + } 33 + 22 34 static int graph_outdrv_event(struct snd_soc_dapm_widget *w, 23 35 struct snd_kcontrol *kcontrol, 24 36 int event) ··· 80 68 struct simple_util_data *adata) 81 69 { 82 70 struct device_node *top = dev->of_node; 83 - struct device_node *port = of_get_parent(ep); 84 - struct device_node *ports = of_get_parent(port); 71 + struct device_node *port = ep_to_port(ep); 72 + struct device_node *ports = port_to_ports(port); 85 73 struct device_node *node = of_graph_get_port_parent(ep); 86 74 87 75 simple_util_parse_convert(top, NULL, adata); 88 - if (of_node_name_eq(ports, "ports")) 89 - simple_util_parse_convert(ports, NULL, adata); 76 + simple_util_parse_convert(ports, NULL, adata); 90 77 simple_util_parse_convert(port, NULL, adata); 91 78 simple_util_parse_convert(ep, NULL, adata); 92 79 ··· 94 83 of_node_put(node); 95 84 } 96 85 97 - static void graph_parse_mclk_fs(struct device_node *top, 98 - struct device_node *ep, 99 - struct simple_dai_props *props) 100 - { 101 - struct device_node *port = of_get_parent(ep); 102 - struct device_node *ports = of_get_parent(port); 103 - 104 - of_property_read_u32(top, "mclk-fs", &props->mclk_fs); 105 - if (of_node_name_eq(ports, "ports")) 106 - of_property_read_u32(ports, "mclk-fs", &props->mclk_fs); 107 - of_property_read_u32(port, "mclk-fs", &props->mclk_fs); 108 - of_property_read_u32(ep, "mclk-fs", &props->mclk_fs); 109 - 110 - of_node_put(port); 111 - of_node_put(ports); 112 - } 113 - 114 86 static int graph_parse_node(struct simple_util_priv *priv, 115 87 struct device_node *ep, 116 88 struct link_info *li, 117 89 int *cpu) 118 90 { 119 91 struct device *dev = simple_priv_to_dev(priv); 120 - struct device_node *top = dev->of_node; 121 92 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 122 93 struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 123 94 struct snd_soc_dai_link_component *dlc; ··· 113 120 dlc = snd_soc_link_to_codec(dai_link, 0); 114 121 dai = simple_props_to_dai_codec(dai_props, 0); 115 122 } 116 - 117 - graph_parse_mclk_fs(top, ep, dai_props); 118 123 119 124 ret = graph_util_parse_dai(dev, ep, dlc, cpu); 120 125 if (ret < 0) ··· 130 139 } 131 140 132 141 static int graph_link_init(struct simple_util_priv *priv, 133 - struct device_node *cpu_ep, 134 - struct device_node *codec_ep, 142 + struct device_node *ep_cpu, 143 + struct device_node *ep_codec, 135 144 struct link_info *li, 136 145 char *name) 137 146 { 138 147 struct device *dev = simple_priv_to_dev(priv); 148 + struct device_node *top = dev->of_node; 139 149 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 150 + struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 151 + struct device_node *port_cpu = ep_to_port(ep_cpu); 152 + struct device_node *port_codec = ep_to_port(ep_codec); 153 + struct device_node *ports_cpu = port_to_ports(port_cpu); 154 + struct device_node *ports_codec = port_to_ports(port_codec); 155 + bool playback_only = 0, capture_only = 0; 140 156 int ret; 141 157 142 - ret = simple_util_parse_daifmt(dev, cpu_ep, codec_ep, 158 + ret = simple_util_parse_daifmt(dev, ep_cpu, ep_codec, 143 159 NULL, &dai_link->dai_fmt); 144 160 if (ret < 0) 145 - return ret; 161 + goto init_end; 162 + 163 + graph_util_parse_link_direction(top, &playback_only, &capture_only); 164 + graph_util_parse_link_direction(port_cpu, &playback_only, &capture_only); 165 + graph_util_parse_link_direction(port_codec, &playback_only, &capture_only); 166 + graph_util_parse_link_direction(ep_cpu, &playback_only, &capture_only); 167 + graph_util_parse_link_direction(ep_codec, &playback_only, &capture_only); 168 + 169 + of_property_read_u32(top, "mclk-fs", &dai_props->mclk_fs); 170 + of_property_read_u32(ports_cpu, "mclk-fs", &dai_props->mclk_fs); 171 + of_property_read_u32(ports_codec, "mclk-fs", &dai_props->mclk_fs); 172 + of_property_read_u32(port_cpu, "mclk-fs", &dai_props->mclk_fs); 173 + of_property_read_u32(port_codec, "mclk-fs", &dai_props->mclk_fs); 174 + of_property_read_u32(ep_cpu, "mclk-fs", &dai_props->mclk_fs); 175 + of_property_read_u32(ep_codec, "mclk-fs", &dai_props->mclk_fs); 176 + 177 + dai_link->playback_only = playback_only; 178 + dai_link->capture_only = capture_only; 146 179 147 180 dai_link->init = simple_util_dai_init; 148 181 dai_link->ops = &graph_ops; 149 182 if (priv->ops) 150 183 dai_link->ops = priv->ops; 151 184 152 - return simple_util_set_dailink_name(dev, dai_link, name); 185 + ret = simple_util_set_dailink_name(dev, dai_link, name); 186 + init_end: 187 + of_node_put(ports_cpu); 188 + of_node_put(ports_codec); 189 + of_node_put(port_cpu); 190 + of_node_put(port_codec); 191 + 192 + return ret; 153 193 } 154 194 155 195 static int graph_dai_link_of_dpcm(struct simple_util_priv *priv, ··· 253 231 "be.%pOFP.%s", codecs->of_node, codecs->dai_name); 254 232 255 233 /* check "prefix" from top node */ 256 - port = of_get_parent(ep); 257 - ports = of_get_parent(port); 258 - snd_soc_of_parse_node_prefix(top, cconf, codecs->of_node, 259 - "prefix"); 260 - if (of_node_name_eq(ports, "ports")) 261 - snd_soc_of_parse_node_prefix(ports, cconf, codecs->of_node, "prefix"); 262 - snd_soc_of_parse_node_prefix(port, cconf, codecs->of_node, 263 - "prefix"); 234 + port = ep_to_port(ep); 235 + ports = port_to_ports(port); 236 + snd_soc_of_parse_node_prefix(top, cconf, codecs->of_node, "prefix"); 237 + snd_soc_of_parse_node_prefix(ports, cconf, codecs->of_node, "prefix"); 238 + snd_soc_of_parse_node_prefix(port, cconf, codecs->of_node, "prefix"); 264 239 265 240 of_node_put(ports); 266 241 of_node_put(port); ··· 369 350 370 351 /* get codec */ 371 352 codec_ep = of_graph_get_remote_endpoint(cpu_ep); 372 - codec_port = of_get_parent(codec_ep); 353 + codec_port = ep_to_port(codec_ep); 373 354 374 355 /* get convert-xxx property */ 375 356 memset(&adata, 0, sizeof(adata));

+99 -70

sound/soc/generic/audio-graph-card2.c

··· 236 236 237 237 #define port_to_endpoint(port) of_get_child_by_name(port, "endpoint") 238 238 239 + #define ep_to_port(ep) of_get_parent(ep) 240 + static struct device_node *port_to_ports(struct device_node *port) 241 + { 242 + struct device_node *ports = of_get_parent(port); 243 + 244 + if (!of_node_name_eq(ports, "ports")) { 245 + of_node_put(ports); 246 + return NULL; 247 + } 248 + return ports; 249 + } 250 + 239 251 static enum graph_type __graph_get_type(struct device_node *lnk) 240 252 { 241 253 struct device_node *np, *parent_np; ··· 332 320 333 321 static struct device_node *graph_get_next_multi_ep(struct device_node **port) 334 322 { 335 - struct device_node *ports = of_get_parent(*port); 323 + struct device_node *ports = port_to_ports(*port); 336 324 struct device_node *ep = NULL; 337 325 struct device_node *rep = NULL; 338 326 ··· 377 365 static void graph_parse_convert(struct device_node *ep, 378 366 struct simple_dai_props *props) 379 367 { 380 - struct device_node *port = of_get_parent(ep); 381 - struct device_node *ports = of_get_parent(port); 368 + struct device_node *port = ep_to_port(ep); 369 + struct device_node *ports = port_to_ports(port); 382 370 struct simple_util_data *adata = &props->adata; 383 371 384 - if (of_node_name_eq(ports, "ports")) 385 - simple_util_parse_convert(ports, NULL, adata); 372 + simple_util_parse_convert(ports, NULL, adata); 386 373 simple_util_parse_convert(port, NULL, adata); 387 374 simple_util_parse_convert(ep, NULL, adata); 388 - 389 - of_node_put(port); 390 - of_node_put(ports); 391 - } 392 - 393 - static void graph_parse_mclk_fs(struct device_node *ep, 394 - struct simple_dai_props *props) 395 - { 396 - struct device_node *port = of_get_parent(ep); 397 - struct device_node *ports = of_get_parent(port); 398 - 399 - if (of_node_name_eq(ports, "ports")) 400 - of_property_read_u32(ports, "mclk-fs", &props->mclk_fs); 401 - of_property_read_u32(port, "mclk-fs", &props->mclk_fs); 402 - of_property_read_u32(ep, "mclk-fs", &props->mclk_fs); 403 375 404 376 of_node_put(port); 405 377 of_node_put(ports); ··· 409 413 dlc = snd_soc_link_to_codec(dai_link, idx); 410 414 dai = simple_props_to_dai_codec(dai_props, idx); 411 415 } 412 - 413 - graph_parse_mclk_fs(ep, dai_props); 414 416 415 417 ret = graph_util_parse_dai(dev, ep, dlc, &is_single_links); 416 418 if (ret < 0) ··· 475 481 if (!is_cpu && gtype == GRAPH_DPCM) { 476 482 struct snd_soc_dai_link_component *codecs = snd_soc_link_to_codec(dai_link, idx); 477 483 struct snd_soc_codec_conf *cconf = simple_props_to_codec_conf(dai_props, idx); 478 - struct device_node *rport = of_get_parent(ep); 479 - struct device_node *rports = of_get_parent(rport); 484 + struct device_node *rport = ep_to_port(ep); 485 + struct device_node *rports = port_to_ports(rport); 480 486 481 - if (of_node_name_eq(rports, "ports")) 482 - snd_soc_of_parse_node_prefix(rports, cconf, codecs->of_node, "prefix"); 487 + snd_soc_of_parse_node_prefix(rports, cconf, codecs->of_node, "prefix"); 483 488 snd_soc_of_parse_node_prefix(rport, cconf, codecs->of_node, "prefix"); 484 489 485 490 of_node_put(rport); ··· 532 539 */ 533 540 struct device_node *mcpu_ep = port_to_endpoint(mcpu_port); 534 541 struct device_node *mcpu_ep_n = mcpu_ep; 535 - struct device_node *mcpu_port_top = of_get_next_child(of_get_parent(mcpu_port), NULL); 542 + struct device_node *mcpu_port_top = of_get_next_child(port_to_ports(mcpu_port), NULL); 536 543 struct device_node *mcpu_ep_top = port_to_endpoint(mcpu_port_top); 537 544 struct device_node *mcodec_ep_top = of_graph_get_remote_endpoint(mcpu_ep_top); 538 - struct device_node *mcodec_port_top = of_get_parent(mcodec_ep_top); 539 - struct device_node *mcodec_ports = of_get_parent(mcodec_port_top); 545 + struct device_node *mcodec_port_top = ep_to_port(mcodec_ep_top); 546 + struct device_node *mcodec_ports = port_to_ports(mcodec_port_top); 540 547 int nm_max = max(dai_link->num_cpus, dai_link->num_codecs); 541 548 int ret = -EINVAL; 542 549 ··· 559 566 } 560 567 561 568 mcodec_ep_n = of_graph_get_remote_endpoint(mcpu_ep_n); 562 - mcodec_port = of_get_parent(mcodec_ep_n); 569 + mcodec_port = ep_to_port(mcodec_ep_n); 563 570 564 - if (mcodec_ports != of_get_parent(mcodec_port)) 571 + if (mcodec_ports != port_to_ports(mcodec_port)) 565 572 goto mcpu_err; 566 573 567 574 codec_idx = 0; ··· 698 705 { 699 706 unsigned int fmt; 700 707 708 + if (!node) 709 + return; 710 + 701 711 /* 702 712 * see also above "daifmt" explanation 703 713 * and samples. ··· 747 751 } 748 752 749 753 static void graph_link_init(struct simple_util_priv *priv, 750 - struct device_node *port, 754 + struct device_node *lnk, 755 + struct device_node *port_cpu, 756 + struct device_node *port_codec, 751 757 struct link_info *li, 752 758 int is_cpu_node) 753 759 { 754 760 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 755 - struct device_node *ep; 756 - struct device_node *ports; 761 + struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 762 + struct device_node *ep_cpu, *ep_codec; 763 + struct device_node *ports_cpu, *ports_codec; 757 764 unsigned int daifmt = 0, daiclk = 0; 758 765 bool playback_only = 0, capture_only = 0; 759 766 unsigned int bit_frame = 0; 760 767 761 - if (graph_lnk_is_multi(port)) { 762 - of_node_get(port); 763 - ep = graph_get_next_multi_ep(&port); 764 - port = of_get_parent(ep); 768 + of_node_get(port_cpu); 769 + if (graph_lnk_is_multi(port_cpu)) { 770 + ep_cpu = graph_get_next_multi_ep(&port_cpu); 771 + of_node_put(port_cpu); 772 + port_cpu = ep_to_port(ep_cpu); 765 773 } else { 766 - ep = port_to_endpoint(port); 774 + ep_cpu = port_to_endpoint(port_cpu); 767 775 } 776 + ports_cpu = port_to_ports(port_cpu); 768 777 769 - ports = of_get_parent(port); 778 + of_node_get(port_codec); 779 + if (graph_lnk_is_multi(port_codec)) { 780 + ep_codec = graph_get_next_multi_ep(&port_codec); 781 + of_node_put(port_cpu); 782 + port_codec = ep_to_port(ep_codec); 783 + } else { 784 + ep_codec = port_to_endpoint(port_codec); 785 + } 786 + ports_codec = port_to_ports(port_codec); 770 787 771 - /* 772 - * ports { 773 - * (A) 774 - * port { 775 - * (B) 776 - * endpoint { 777 - * (C) 778 - * }; 779 - * }; 780 - * }; 781 - * }; 782 - */ 783 - graph_parse_daifmt(ep, &daifmt, &bit_frame); /* (C) */ 784 - graph_parse_daifmt(port, &daifmt, &bit_frame); /* (B) */ 785 - if (of_node_name_eq(ports, "ports")) 786 - graph_parse_daifmt(ports, &daifmt, &bit_frame); /* (A) */ 788 + 789 + graph_parse_daifmt(ep_cpu, &daifmt, &bit_frame); 790 + graph_parse_daifmt(ep_codec, &daifmt, &bit_frame); 791 + graph_parse_daifmt(port_cpu, &daifmt, &bit_frame); 792 + graph_parse_daifmt(port_codec, &daifmt, &bit_frame); 793 + graph_parse_daifmt(ports_cpu, &daifmt, &bit_frame); 794 + graph_parse_daifmt(ports_codec, &daifmt, &bit_frame); 795 + graph_parse_daifmt(lnk, &daifmt, &bit_frame); 796 + 797 + graph_util_parse_link_direction(lnk, &playback_only, &capture_only); 798 + graph_util_parse_link_direction(ports_cpu, &playback_only, &capture_only); 799 + graph_util_parse_link_direction(ports_codec, &playback_only, &capture_only); 800 + graph_util_parse_link_direction(port_cpu, &playback_only, &capture_only); 801 + graph_util_parse_link_direction(port_codec, &playback_only, &capture_only); 802 + graph_util_parse_link_direction(ep_cpu, &playback_only, &capture_only); 803 + graph_util_parse_link_direction(ep_codec, &playback_only, &capture_only); 804 + 805 + of_property_read_u32(lnk, "mclk-fs", &dai_props->mclk_fs); 806 + of_property_read_u32(ports_cpu, "mclk-fs", &dai_props->mclk_fs); 807 + of_property_read_u32(ports_codec, "mclk-fs", &dai_props->mclk_fs); 808 + of_property_read_u32(port_cpu, "mclk-fs", &dai_props->mclk_fs); 809 + of_property_read_u32(port_codec, "mclk-fs", &dai_props->mclk_fs); 810 + of_property_read_u32(ep_cpu, "mclk-fs", &dai_props->mclk_fs); 811 + of_property_read_u32(ep_codec, "mclk-fs", &dai_props->mclk_fs); 787 812 788 813 /* 789 814 * convert bit_frame ··· 815 798 if (is_cpu_node) 816 799 daiclk = snd_soc_daifmt_clock_provider_flipped(daiclk); 817 800 818 - graph_util_parse_link_direction(port, &playback_only, &capture_only); 819 - 820 - dai_link->playback_only = playback_only; 821 - dai_link->capture_only = capture_only; 801 + dai_link->playback_only = playback_only; 802 + dai_link->capture_only = capture_only; 822 803 823 804 dai_link->dai_fmt = daifmt | daiclk; 824 805 dai_link->init = simple_util_dai_init; 825 806 dai_link->ops = &graph_ops; 826 807 if (priv->ops) 827 808 dai_link->ops = priv->ops; 809 + 810 + of_node_put(ports_cpu); 811 + of_node_put(ports_codec); 812 + of_node_put(port_cpu); 813 + of_node_put(port_codec); 814 + of_node_put(ep_cpu); 815 + of_node_put(ep_codec); 828 816 } 829 817 830 818 int audio_graph2_link_normal(struct simple_util_priv *priv, ··· 857 835 if (ret < 0) 858 836 goto err; 859 837 860 - graph_link_init(priv, cpu_port, li, 1); 838 + graph_link_init(priv, lnk, cpu_port, codec_port, li, 1); 861 839 err: 862 840 of_node_put(codec_port); 863 841 of_node_put(cpu_ep); ··· 872 850 { 873 851 struct device_node *ep = port_to_endpoint(lnk); 874 852 struct device_node *rep = of_graph_get_remote_endpoint(ep); 875 - struct device_node *rport = of_graph_get_remote_port(ep); 853 + struct device_node *cpu_port = NULL; 854 + struct device_node *codec_port = NULL; 876 855 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 877 856 struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 878 857 int is_cpu = graph_util_is_ports0(lnk); 879 858 int ret; 880 859 881 860 if (is_cpu) { 861 + cpu_port = of_graph_get_remote_port(ep); /* rport */ 862 + 882 863 /* 883 864 * dpcm { 884 865 * // Front-End ··· 909 884 dai_link->dynamic = 1; 910 885 dai_link->dpcm_merged_format = 1; 911 886 912 - ret = graph_parse_node(priv, GRAPH_DPCM, rport, li, 1); 887 + ret = graph_parse_node(priv, GRAPH_DPCM, cpu_port, li, 1); 913 888 if (ret) 914 889 goto err; 890 + 915 891 } else { 892 + codec_port = of_graph_get_remote_port(ep); /* rport */ 893 + 916 894 /* 917 895 * dpcm { 918 896 * // Front-End ··· 945 917 dai_link->no_pcm = 1; 946 918 dai_link->be_hw_params_fixup = simple_util_be_hw_params_fixup; 947 919 948 - ret = graph_parse_node(priv, GRAPH_DPCM, rport, li, 0); 920 + ret = graph_parse_node(priv, GRAPH_DPCM, codec_port, li, 0); 949 921 if (ret < 0) 950 922 goto err; 951 923 } ··· 955 927 956 928 snd_soc_dai_link_set_capabilities(dai_link); 957 929 958 - graph_link_init(priv, rport, li, is_cpu); 930 + graph_link_init(priv, lnk, cpu_port, codec_port, li, is_cpu); 959 931 err: 960 932 of_node_put(ep); 961 933 of_node_put(rep); 962 - of_node_put(rport); 934 + of_node_put(cpu_port); 935 + of_node_put(codec_port); 963 936 964 937 return ret; 965 938 } ··· 995 966 */ 996 967 of_node_get(lnk); 997 968 port0 = lnk; 998 - ports = of_get_parent(port0); 969 + ports = port_to_ports(port0); 999 970 port1 = of_get_next_child(ports, lnk); 1000 971 1001 972 /* ··· 1048 1019 if (ret < 0) 1049 1020 goto err2; 1050 1021 1051 - graph_link_init(priv, codec0_port, li, 1); 1022 + graph_link_init(priv, lnk, codec0_port, codec1_port, li, 1); 1052 1023 err2: 1053 1024 of_node_put(ep0); 1054 1025 of_node_put(ep1); ··· 1127 1098 * ignore first lnk part 1128 1099 */ 1129 1100 if (graph_lnk_is_multi(lnk)) { 1130 - struct device_node *ports = of_get_parent(lnk); 1101 + struct device_node *ports = port_to_ports(lnk); 1131 1102 struct device_node *port = NULL; 1132 1103 int cnt = 0; 1133 1104 ··· 1224 1195 struct device_node *lnk, 1225 1196 struct link_info *li) 1226 1197 { 1227 - struct device_node *ports = of_get_parent(lnk); 1198 + struct device_node *ports = port_to_ports(lnk); 1228 1199 struct device_node *port0 = lnk; 1229 1200 struct device_node *port1 = of_get_next_child(ports, of_node_get(lnk)); 1230 1201 struct device_node *ep0 = port_to_endpoint(port0);

+10 -13

sound/soc/generic/simple-card-utils.c

··· 60 60 { 61 61 char prop[128]; 62 62 63 + if (!np) 64 + return; 65 + 63 66 if (!prefix) 64 67 prefix = ""; 65 68 ··· 1143 1140 } 1144 1141 EXPORT_SYMBOL_GPL(graph_util_parse_dai); 1145 1142 1146 - int graph_util_parse_link_direction(struct device_node *np, 1143 + void graph_util_parse_link_direction(struct device_node *np, 1147 1144 bool *playback_only, bool *capture_only) 1148 1145 { 1149 - bool is_playback_only = false; 1150 - bool is_capture_only = false; 1146 + bool is_playback_only = of_property_read_bool(np, "playback-only"); 1147 + bool is_capture_only = of_property_read_bool(np, "capture-only"); 1151 1148 1152 - is_playback_only = of_property_read_bool(np, "playback-only"); 1153 - is_capture_only = of_property_read_bool(np, "capture-only"); 1154 - 1155 - if (is_playback_only && is_capture_only) 1156 - return -EINVAL; 1157 - 1158 - *playback_only = is_playback_only; 1159 - *capture_only = is_capture_only; 1160 - 1161 - return 0; 1149 + if (is_playback_only) 1150 + *playback_only = is_playback_only; 1151 + if (is_capture_only) 1152 + *capture_only = is_capture_only; 1162 1153 } 1163 1154 EXPORT_SYMBOL_GPL(graph_util_parse_link_direction); 1164 1155

+30 -26

sound/soc/generic/simple-card.c

··· 129 129 of_node_put(node); 130 130 } 131 131 132 - static void simple_parse_mclk_fs(struct device_node *top, 133 - struct device_node *np, 134 - struct simple_dai_props *props, 135 - char *prefix) 136 - { 137 - struct device_node *node = of_get_parent(np); 138 - char prop[128]; 139 - 140 - snprintf(prop, sizeof(prop), "%smclk-fs", PREFIX); 141 - of_property_read_u32(top, prop, &props->mclk_fs); 142 - 143 - snprintf(prop, sizeof(prop), "%smclk-fs", prefix); 144 - of_property_read_u32(node, prop, &props->mclk_fs); 145 - of_property_read_u32(np, prop, &props->mclk_fs); 146 - 147 - of_node_put(node); 148 - } 149 - 150 132 static int simple_parse_node(struct simple_util_priv *priv, 151 133 struct device_node *np, 152 134 struct link_info *li, ··· 136 154 int *cpu) 137 155 { 138 156 struct device *dev = simple_priv_to_dev(priv); 139 - struct device_node *top = dev->of_node; 140 157 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 141 158 struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 142 159 struct snd_soc_dai_link_component *dlc; ··· 149 168 dlc = snd_soc_link_to_codec(dai_link, 0); 150 169 dai = simple_props_to_dai_codec(dai_props, 0); 151 170 } 152 - 153 - simple_parse_mclk_fs(top, np, dai_props, prefix); 154 171 155 172 ret = simple_parse_dai(dev, np, dlc, cpu); 156 173 if (ret) ··· 166 187 } 167 188 168 189 static int simple_link_init(struct simple_util_priv *priv, 169 - struct device_node *node, 190 + struct device_node *cpu, 170 191 struct device_node *codec, 171 192 struct link_info *li, 172 193 char *prefix, char *name) 173 194 { 174 195 struct device *dev = simple_priv_to_dev(priv); 196 + struct device_node *top = dev->of_node; 175 197 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 198 + struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 199 + struct device_node *node = of_get_parent(cpu); 200 + bool playback_only = 0, capture_only = 0; 176 201 int ret; 177 202 178 203 ret = simple_util_parse_daifmt(dev, node, codec, 179 204 prefix, &dai_link->dai_fmt); 180 205 if (ret < 0) 181 - return 0; 206 + goto init_end; 207 + 208 + graph_util_parse_link_direction(top, &playback_only, &capture_only); 209 + graph_util_parse_link_direction(node, &playback_only, &capture_only); 210 + graph_util_parse_link_direction(cpu, &playback_only, &capture_only); 211 + graph_util_parse_link_direction(codec, &playback_only, &capture_only); 212 + 213 + of_property_read_u32(top, "mclk-fs", &dai_props->mclk_fs); 214 + of_property_read_u32(top, PREFIX "mclk-fs", &dai_props->mclk_fs); 215 + of_property_read_u32(node, "mclk-fs", &dai_props->mclk_fs); 216 + of_property_read_u32(node, PREFIX "mclk-fs", &dai_props->mclk_fs); 217 + of_property_read_u32(cpu, "mclk-fs", &dai_props->mclk_fs); 218 + of_property_read_u32(cpu, PREFIX "mclk-fs", &dai_props->mclk_fs); 219 + of_property_read_u32(codec, "mclk-fs", &dai_props->mclk_fs); 220 + of_property_read_u32(codec, PREFIX "mclk-fs", &dai_props->mclk_fs); 221 + 222 + dai_link->playback_only = playback_only; 223 + dai_link->capture_only = capture_only; 182 224 183 225 dai_link->init = simple_util_dai_init; 184 226 dai_link->ops = &simple_ops; 185 227 186 - return simple_util_set_dailink_name(dev, dai_link, name); 228 + ret = simple_util_set_dailink_name(dev, dai_link, name); 229 + init_end: 230 + of_node_put(node); 231 + 232 + return ret; 187 233 } 188 234 189 235 static int simple_dai_link_of_dpcm(struct simple_util_priv *priv, ··· 282 278 283 279 snd_soc_dai_link_set_capabilities(dai_link); 284 280 285 - ret = simple_link_init(priv, node, codec, li, prefix, dai_name); 281 + ret = simple_link_init(priv, np, codec, li, prefix, dai_name); 286 282 287 283 out_put_node: 288 284 li->link++; ··· 340 336 simple_util_canonicalize_cpu(cpus, single_cpu); 341 337 simple_util_canonicalize_platform(platforms, cpus); 342 338 343 - ret = simple_link_init(priv, node, codec, li, prefix, dai_name); 339 + ret = simple_link_init(priv, cpu, codec, li, prefix, dai_name); 344 340 345 341 dai_link_of_err: 346 342 of_node_put(plat);

Configure Feed

Configure Feed