ASoC: extra format on each DAI · tjh.dev/kernel@9d49925

+11

include/sound/soc.h

··· 681 681 struct device_node *of_node; 682 682 const char *dai_name; 683 683 const struct of_phandle_args *dai_args; 684 + 685 + /* 686 + * Extra format = SND_SOC_DAIFMT_Bx_Fx 687 + * 688 + * [Note] it is Bx_Fx base, not CBx_CFx 689 + * 690 + * It will be used with dai_link->dai_fmt 691 + * see 692 + * snd_soc_runtime_set_dai_fmt() 693 + */ 694 + unsigned int ext_fmt; 684 695 }; 685 696 686 697 /*

+14 -34

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

··· 81 81 struct simple_util_data *adata) 82 82 { 83 83 struct device_node *top = dev->of_node; 84 - struct device_node *port = ep_to_port(ep); 85 - struct device_node *ports = port_to_ports(port); 86 - struct device_node *node = of_graph_get_port_parent(ep); 84 + struct device_node *port __free(device_node) = ep_to_port(ep); 85 + struct device_node *ports __free(device_node) = port_to_ports(port); 86 + struct device_node *node __free(device_node) = of_graph_get_port_parent(ep); 87 87 88 88 simple_util_parse_convert(top, NULL, adata); 89 89 simple_util_parse_convert(ports, NULL, adata); 90 90 simple_util_parse_convert(port, NULL, adata); 91 91 simple_util_parse_convert(ep, NULL, adata); 92 - 93 - of_node_put(port); 94 - of_node_put(ports); 95 - of_node_put(node); 96 92 } 97 93 98 94 static int graph_parse_node(struct simple_util_priv *priv, ··· 136 140 struct device_node *top = dev->of_node; 137 141 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 138 142 struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 139 - struct device_node *port_cpu = ep_to_port(ep_cpu); 140 - struct device_node *port_codec = ep_to_port(ep_codec); 141 - struct device_node *ports_cpu = port_to_ports(port_cpu); 142 - struct device_node *ports_codec = port_to_ports(port_codec); 143 + struct device_node *port_cpu __free(device_node) = ep_to_port(ep_cpu); 144 + struct device_node *port_codec __free(device_node) = ep_to_port(ep_codec); 145 + struct device_node *ports_cpu __free(device_node) = port_to_ports(port_cpu); 146 + struct device_node *ports_codec __free(device_node) = port_to_ports(port_codec); 143 147 enum snd_soc_trigger_order trigger_start = SND_SOC_TRIGGER_ORDER_DEFAULT; 144 148 enum snd_soc_trigger_order trigger_stop = SND_SOC_TRIGGER_ORDER_DEFAULT; 145 149 bool playback_only = 0, capture_only = 0; ··· 148 152 ret = simple_util_parse_daifmt(dev, ep_cpu, ep_codec, 149 153 NULL, &dai_link->dai_fmt); 150 154 if (ret < 0) 151 - goto init_end; 155 + return ret; 152 156 153 157 graph_util_parse_link_direction(top, &playback_only, &capture_only); 154 158 graph_util_parse_link_direction(port_cpu, &playback_only, &capture_only); ··· 183 187 if (priv->ops) 184 188 dai_link->ops = priv->ops; 185 189 186 - ret = simple_util_set_dailink_name(dev, dai_link, name); 187 - init_end: 188 - of_node_put(ports_cpu); 189 - of_node_put(ports_codec); 190 - of_node_put(port_cpu); 191 - of_node_put(port_codec); 192 - 193 - return ret; 190 + return simple_util_set_dailink_name(dev, dai_link, name); 194 191 } 195 192 196 193 static int graph_dai_link_of_dpcm(struct simple_util_priv *priv, ··· 239 250 } else { 240 251 struct snd_soc_codec_conf *cconf = simple_props_to_codec_conf(dai_props, 0); 241 252 struct snd_soc_dai_link_component *codecs = snd_soc_link_to_codec(dai_link, 0); 242 - struct device_node *port; 243 - struct device_node *ports; 244 253 245 254 /* CPU is dummy */ 246 255 ··· 254 267 "be.%pOFP.%s", codecs->of_node, codecs->dai_name); 255 268 256 269 /* check "prefix" from top node */ 257 - port = ep_to_port(ep); 258 - ports = port_to_ports(port); 270 + struct device_node *port __free(device_node) = ep_to_port(ep); 271 + struct device_node *ports __free(device_node) = port_to_ports(port); 272 + 259 273 snd_soc_of_parse_node_prefix(top, cconf, codecs->of_node, "prefix"); 260 274 snd_soc_of_parse_node_prefix(ports, cconf, codecs->of_node, "prefix"); 261 275 snd_soc_of_parse_node_prefix(port, cconf, codecs->of_node, "prefix"); 262 - 263 - of_node_put(ports); 264 - of_node_put(port); 265 276 } 266 277 267 278 graph_parse_convert(dev, ep, &dai_props->adata); ··· 346 361 struct device *dev = simple_priv_to_dev(priv); 347 362 struct device_node *node = dev->of_node; 348 363 struct device_node *cpu_port; 349 - struct device_node *codec_ep; 350 - struct device_node *codec_port; 351 364 struct device_node *codec_port_old = NULL; 352 365 struct simple_util_data adata; 353 366 int rc, ret = 0; ··· 357 374 /* loop for all CPU endpoint */ 358 375 for_each_of_graph_port_endpoint(cpu_port, cpu_ep) { 359 376 /* get codec */ 360 - codec_ep = of_graph_get_remote_endpoint(cpu_ep); 361 - codec_port = ep_to_port(codec_ep); 377 + struct device_node *codec_ep __free(device_node) = of_graph_get_remote_endpoint(cpu_ep); 378 + struct device_node *codec_port __free(device_node) = ep_to_port(codec_ep); 362 379 363 380 /* get convert-xxx property */ 364 381 memset(&adata, 0, sizeof(adata)); ··· 381 398 if (li->cpu) 382 399 ret = func_noml(priv, cpu_ep, codec_ep, li); 383 400 } 384 - 385 - of_node_put(codec_ep); 386 - of_node_put(codec_port); 387 401 388 402 if (ret < 0) 389 403 return ret;

+109 -153

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

··· 331 331 return __graph_get_type(lnk) == GRAPH_MULTI; 332 332 } 333 333 334 - static struct device_node *graph_get_next_multi_ep(struct device_node **port) 334 + static struct device_node *graph_get_next_multi_ep(struct device_node **port, int idx) 335 335 { 336 - struct device_node *ports = port_to_ports(*port); 337 - struct device_node *ep = NULL; 336 + struct device_node *ports __free(device_node) = port_to_ports(*port); 338 337 struct device_node *rep = NULL; 339 338 340 339 /* ··· 351 352 * port@1 { rep1 }; 352 353 * }; 353 354 */ 354 - *port = of_graph_get_next_port(ports, *port); 355 + 356 + /* 357 + * Don't use of_graph_get_next_port() here 358 + * 359 + * In overlay case, "port" are not necessarily in order. So we need to use 360 + * of_graph_get_port_by_id() instead 361 + */ 362 + of_node_put(*port); 363 + 364 + *port = of_graph_get_port_by_id(ports, idx); 355 365 if (*port) { 356 - ep = of_graph_get_next_port_endpoint(*port, NULL); 366 + struct device_node *ep __free(device_node) = of_graph_get_next_port_endpoint(*port, NULL); 367 + 357 368 rep = of_graph_get_remote_endpoint(ep); 358 369 } 359 - 360 - of_node_put(ep); 361 - of_node_put(ports); 362 370 363 371 return rep; 364 372 } ··· 379 373 static void graph_parse_convert(struct device_node *ep, 380 374 struct simple_dai_props *props) 381 375 { 382 - struct device_node *port = ep_to_port(ep); 383 - struct device_node *ports = port_to_ports(port); 376 + struct device_node *port __free(device_node) = ep_to_port(ep); 377 + struct device_node *ports __free(device_node) = port_to_ports(port); 384 378 struct simple_util_data *adata = &props->adata; 385 379 386 380 simple_util_parse_convert(ports, NULL, adata); 387 381 simple_util_parse_convert(port, NULL, adata); 388 382 simple_util_parse_convert(ep, NULL, adata); 389 - 390 - of_node_put(port); 391 - of_node_put(ports); 392 383 } 393 384 394 385 static int __graph_parse_node(struct simple_util_priv *priv, ··· 474 471 if (!is_cpu && gtype == GRAPH_DPCM) { 475 472 struct snd_soc_dai_link_component *codecs = snd_soc_link_to_codec(dai_link, idx); 476 473 struct snd_soc_codec_conf *cconf = simple_props_to_codec_conf(dai_props, idx); 477 - struct device_node *rport = ep_to_port(ep); 478 - struct device_node *rports = port_to_ports(rport); 474 + struct device_node *rport __free(device_node) = ep_to_port(ep); 475 + struct device_node *rports __free(device_node) = port_to_ports(rport); 479 476 480 477 snd_soc_of_parse_node_prefix(rports, cconf, codecs->of_node, "prefix"); 481 478 snd_soc_of_parse_node_prefix(rport, cconf, codecs->of_node, "prefix"); 482 - 483 - of_node_put(rport); 484 - of_node_put(rports); 485 479 } 486 480 487 481 if (is_cpu) { ··· 526 526 * }; 527 527 * }; 528 528 */ 529 - struct device_node *mcpu_ep = of_graph_get_next_port_endpoint(mcpu_port, NULL); 530 - struct device_node *mcpu_ports = port_to_ports(mcpu_port); 531 - struct device_node *mcpu_port_top = of_graph_get_next_port(mcpu_ports, NULL); 532 - struct device_node *mcpu_ep_top = of_graph_get_next_port_endpoint(mcpu_port_top, NULL); 533 - struct device_node *mcodec_ep_top = of_graph_get_remote_endpoint(mcpu_ep_top); 534 - struct device_node *mcodec_port_top = ep_to_port(mcodec_ep_top); 535 - struct device_node *mcodec_ports = port_to_ports(mcodec_port_top); 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 536 int nm_max = max(dai_link->num_cpus, dai_link->num_codecs); 537 537 int ret = 0; 538 538 539 - if (cpu_idx > dai_link->num_cpus) { 540 - ret = -EINVAL; 541 - goto mcpu_err; 542 - } 539 + if (cpu_idx > dai_link->num_cpus) 540 + return -EINVAL; 543 541 544 542 for_each_of_graph_port_endpoint(mcpu_port, mcpu_ep_n) { 545 - struct device_node *mcodec_ep_n; 546 - struct device_node *mcodec_port; 547 - int codec_idx; 543 + int codec_idx = 0; 548 544 549 545 /* ignore 1st ep which is for element */ 550 546 if (mcpu_ep_n == mcpu_ep) ··· 549 553 if (*nm_idx > nm_max) 550 554 break; 551 555 552 - mcodec_ep_n = of_graph_get_remote_endpoint(mcpu_ep_n); 553 - mcodec_port = ep_to_port(mcodec_ep_n); 556 + struct device_node *mcodec_ep_n __free(device_node) = of_graph_get_remote_endpoint(mcpu_ep_n); 557 + struct device_node *mcodec_port __free(device_node) = ep_to_port(mcodec_ep_n); 554 558 555 - if (mcodec_ports != port_to_ports(mcodec_port)) { 556 - ret = -EINVAL; 557 - goto mcpu_err; 558 - } 559 - 560 - codec_idx = 0; 561 559 ret = -EINVAL; 560 + if (mcodec_ports != port_to_ports(mcodec_port)) 561 + break; 562 + 562 563 for_each_of_graph_port(mcodec_ports, mcodec_port_i) { 563 564 564 565 /* ignore 1st port which is for pair connection */ ··· 575 582 } 576 583 codec_idx++; 577 584 } 578 - of_node_put(mcodec_port); 579 - of_node_put(mcodec_ep_n); 580 585 if (ret < 0) 581 586 break; 582 587 } 583 - mcpu_err: 584 - of_node_put(mcpu_ep); 585 - of_node_put(mcpu_port_top); 586 - of_node_put(mcpu_ep_top); 587 - of_node_put(mcodec_ep_top); 588 - of_node_put(mcodec_port_top); 589 - of_node_put(mcodec_ports); 590 588 591 589 return ret; 592 590 } ··· 589 605 { 590 606 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 591 607 struct device *dev = simple_priv_to_dev(priv); 592 - struct device_node *ep; 593 608 int ret = -ENOMEM; 594 609 int nm_idx = 0; 595 610 int nm_max = max(dai_link->num_cpus, dai_link->num_codecs); ··· 623 640 * }; 624 641 * }; 625 642 */ 626 - ep = graph_get_next_multi_ep(&port); 643 + struct device_node *ep __free(device_node) = graph_get_next_multi_ep(&port, idx + 1); 627 644 if (!ep) 628 645 break; 629 646 630 647 ret = __graph_parse_node(priv, gtype, ep, li, is_cpu, idx); 631 - of_node_put(ep); 632 648 if (ret < 0) 633 649 goto multi_err; 634 650 ··· 651 669 struct device_node *port, 652 670 struct link_info *li, int is_cpu) 653 671 { 654 - struct device_node *ep = of_graph_get_next_port_endpoint(port, NULL); 655 - int ret = __graph_parse_node(priv, gtype, ep, li, is_cpu, 0); 672 + struct device_node *ep __free(device_node) = of_graph_get_next_port_endpoint(port, NULL); 656 673 657 - of_node_put(ep); 658 - 659 - return ret; 674 + return __graph_parse_node(priv, gtype, ep, li, is_cpu, 0); 660 675 } 661 676 662 677 static int graph_parse_node(struct simple_util_priv *priv, ··· 667 688 return graph_parse_node_single(priv, gtype, port, li, is_cpu); 668 689 } 669 690 670 - static void graph_parse_daifmt(struct device_node *node, 671 - unsigned int *daifmt, unsigned int *bit_frame) 691 + static void graph_parse_daifmt(struct device_node *node, unsigned int *daifmt) 672 692 { 673 693 unsigned int fmt; 674 694 ··· 692 714 * }; 693 715 */ 694 716 695 - /* 696 - * clock_provider: 697 - * 698 - * It can be judged it is provider 699 - * if (A) or (B) or (C) has bitclock-master / frame-master flag. 700 - * 701 - * use "or" 702 - */ 703 - *bit_frame |= snd_soc_daifmt_parse_clock_provider_as_bitmap(node, NULL); 704 - 705 717 #define update_daifmt(name) \ 706 718 if (!(*daifmt & SND_SOC_DAIFMT_##name##_MASK) && \ 707 719 (fmt & SND_SOC_DAIFMT_##name##_MASK)) \ ··· 709 741 update_daifmt(INV); 710 742 } 711 743 744 + static unsigned int graph_parse_bitframe(struct device_node *ep) 745 + { 746 + struct device_node *port __free(device_node) = ep_to_port(ep); 747 + struct device_node *ports __free(device_node) = port_to_ports(port); 748 + 749 + return snd_soc_daifmt_clock_provider_from_bitmap( 750 + snd_soc_daifmt_parse_clock_provider_as_bitmap(ep, NULL) | 751 + snd_soc_daifmt_parse_clock_provider_as_bitmap(port, NULL) | 752 + snd_soc_daifmt_parse_clock_provider_as_bitmap(ports, NULL)); 753 + } 754 + 712 755 static void graph_link_init(struct simple_util_priv *priv, 713 756 struct device_node *lnk, 714 757 struct device_node *port_cpu, ··· 730 751 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 731 752 struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 732 753 struct device_node *ep_cpu, *ep_codec; 733 - struct device_node *ports_cpu, *ports_codec; 734 - unsigned int daifmt = 0, daiclk = 0; 754 + struct device_node *multi_cpu_port = NULL, *multi_codec_port = NULL; 755 + struct snd_soc_dai_link_component *dlc; 756 + unsigned int daifmt = 0; 735 757 bool playback_only = 0, capture_only = 0; 736 758 enum snd_soc_trigger_order trigger_start = SND_SOC_TRIGGER_ORDER_DEFAULT; 737 759 enum snd_soc_trigger_order trigger_stop = SND_SOC_TRIGGER_ORDER_DEFAULT; 738 - unsigned int bit_frame = 0; 760 + int multi_cpu_port_idx = 1, multi_codec_port_idx = 1; 761 + int i; 739 762 740 763 of_node_get(port_cpu); 741 764 if (graph_lnk_is_multi(port_cpu)) { 742 - ep_cpu = graph_get_next_multi_ep(&port_cpu); 765 + multi_cpu_port = port_cpu; 766 + ep_cpu = graph_get_next_multi_ep(&multi_cpu_port, multi_cpu_port_idx++); 743 767 of_node_put(port_cpu); 744 768 port_cpu = ep_to_port(ep_cpu); 745 769 } else { 746 770 ep_cpu = of_graph_get_next_port_endpoint(port_cpu, NULL); 747 771 } 748 - ports_cpu = port_to_ports(port_cpu); 772 + struct device_node *ports_cpu __free(device_node) = port_to_ports(port_cpu); 749 773 750 774 of_node_get(port_codec); 751 775 if (graph_lnk_is_multi(port_codec)) { 752 - ep_codec = graph_get_next_multi_ep(&port_codec); 776 + multi_codec_port = port_codec; 777 + ep_codec = graph_get_next_multi_ep(&multi_codec_port, multi_codec_port_idx++); 753 778 of_node_put(port_codec); 754 779 port_codec = ep_to_port(ep_codec); 755 780 } else { 756 781 ep_codec = of_graph_get_next_port_endpoint(port_codec, NULL); 757 782 } 758 - ports_codec = port_to_ports(port_codec); 783 + struct device_node *ports_codec __free(device_node) = port_to_ports(port_codec); 759 784 760 - 761 - graph_parse_daifmt(ep_cpu, &daifmt, &bit_frame); 762 - graph_parse_daifmt(ep_codec, &daifmt, &bit_frame); 763 - graph_parse_daifmt(port_cpu, &daifmt, &bit_frame); 764 - graph_parse_daifmt(port_codec, &daifmt, &bit_frame); 765 - graph_parse_daifmt(ports_cpu, &daifmt, &bit_frame); 766 - graph_parse_daifmt(ports_codec, &daifmt, &bit_frame); 767 - graph_parse_daifmt(lnk, &daifmt, &bit_frame); 785 + graph_parse_daifmt(ep_cpu, &daifmt); 786 + graph_parse_daifmt(ep_codec, &daifmt); 787 + graph_parse_daifmt(port_cpu, &daifmt); 788 + graph_parse_daifmt(port_codec, &daifmt); 789 + graph_parse_daifmt(ports_cpu, &daifmt); 790 + graph_parse_daifmt(ports_codec, &daifmt); 791 + graph_parse_daifmt(lnk, &daifmt); 768 792 769 793 graph_util_parse_link_direction(lnk, &playback_only, &capture_only); 770 794 graph_util_parse_link_direction(ports_cpu, &playback_only, &capture_only); ··· 793 811 graph_util_parse_trigger_order(priv, ep_cpu, &trigger_start, &trigger_stop); 794 812 graph_util_parse_trigger_order(priv, ep_codec, &trigger_start, &trigger_stop); 795 813 796 - /* 797 - * convert bit_frame 798 - * We need to flip clock_provider if it was CPU node, 799 - * because it is Codec base. 800 - */ 801 - daiclk = snd_soc_daifmt_clock_provider_from_bitmap(bit_frame); 802 - if (is_cpu_node) 803 - daiclk = snd_soc_daifmt_clock_provider_flipped(daiclk); 814 + for_each_link_cpus(dai_link, i, dlc) { 815 + dlc->ext_fmt = graph_parse_bitframe(ep_cpu); 816 + 817 + if (multi_cpu_port) 818 + ep_cpu = graph_get_next_multi_ep(&multi_cpu_port, multi_cpu_port_idx++); 819 + } 820 + 821 + for_each_link_codecs(dai_link, i, dlc) { 822 + dlc->ext_fmt = graph_parse_bitframe(ep_codec); 823 + 824 + if (multi_codec_port) 825 + ep_codec = graph_get_next_multi_ep(&multi_codec_port, multi_codec_port_idx++); 826 + } 827 + 828 + /*** Don't use port_cpu / port_codec after here ***/ 804 829 805 830 dai_link->playback_only = playback_only; 806 831 dai_link->capture_only = capture_only; ··· 815 826 dai_link->trigger_start = trigger_start; 816 827 dai_link->trigger_stop = trigger_stop; 817 828 818 - dai_link->dai_fmt = daifmt | daiclk; 829 + dai_link->dai_fmt = daifmt; 819 830 dai_link->init = simple_util_dai_init; 820 831 dai_link->ops = &graph_ops; 821 832 if (priv->ops) 822 833 dai_link->ops = priv->ops; 823 834 824 - of_node_put(ports_cpu); 825 - of_node_put(ports_codec); 826 835 of_node_put(port_cpu); 827 836 of_node_put(port_codec); 828 837 of_node_put(ep_cpu); ··· 832 845 struct link_info *li) 833 846 { 834 847 struct device_node *cpu_port = lnk; 835 - struct device_node *cpu_ep = of_graph_get_next_port_endpoint(cpu_port, NULL); 836 - struct device_node *codec_port = of_graph_get_remote_port(cpu_ep); 848 + struct device_node *cpu_ep __free(device_node) = of_graph_get_next_port_endpoint(cpu_port, NULL); 849 + struct device_node *codec_port __free(device_node) = of_graph_get_remote_port(cpu_ep); 837 850 int ret; 838 851 839 852 /* ··· 843 856 */ 844 857 ret = graph_parse_node(priv, GRAPH_NORMAL, codec_port, li, 0); 845 858 if (ret < 0) 846 - goto err; 859 + return ret; 847 860 848 861 /* 849 862 * call CPU, and set DAI Name 850 863 */ 851 864 ret = graph_parse_node(priv, GRAPH_NORMAL, cpu_port, li, 1); 852 865 if (ret < 0) 853 - goto err; 866 + return ret; 854 867 855 868 graph_link_init(priv, lnk, cpu_port, codec_port, li, 1); 856 - err: 857 - of_node_put(codec_port); 858 - of_node_put(cpu_ep); 859 869 860 870 return ret; 861 871 } ··· 862 878 struct device_node *lnk, 863 879 struct link_info *li) 864 880 { 865 - struct device_node *ep = of_graph_get_next_port_endpoint(lnk, NULL); 866 - struct device_node *rep = of_graph_get_remote_endpoint(ep); 881 + struct device_node *ep __free(device_node) = of_graph_get_next_port_endpoint(lnk, NULL); 882 + struct device_node *rep __free(device_node) = of_graph_get_remote_endpoint(ep); 867 883 struct device_node *cpu_port = NULL; 868 884 struct device_node *codec_port = NULL; 869 885 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); ··· 947 963 948 964 graph_link_init(priv, lnk, cpu_port, codec_port, li, is_cpu); 949 965 err: 950 - of_node_put(ep); 951 - of_node_put(rep); 952 966 of_node_put(cpu_port); 953 967 of_node_put(codec_port); 954 968 ··· 959 977 struct link_info *li) 960 978 { 961 979 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 962 - struct device_node *port0, *port1, *ports; 963 - struct device_node *codec0_port, *codec1_port; 964 - struct device_node *ep0, *ep1; 980 + struct device_node *port0 = lnk; 981 + struct device_node *ports __free(device_node) = port_to_ports(port0); 982 + struct device_node *port1 __free(device_node) = of_graph_get_next_port(ports, port0); 965 983 u32 val = 0; 966 984 int ret = -EINVAL; 967 985 ··· 981 999 * }; 982 1000 * }; 983 1001 */ 984 - of_node_get(lnk); 985 - port0 = lnk; 986 - ports = port_to_ports(port0); 987 - port1 = of_graph_get_next_port(ports, port0); 988 1002 989 1003 /* 990 1004 * Card2 can use original Codec2Codec settings if DT has. ··· 997 1019 998 1020 c2c_conf = devm_kzalloc(dev, sizeof(*c2c_conf), GFP_KERNEL); 999 1021 if (!c2c_conf) 1000 - goto err1; 1022 + return ret; 1001 1023 1002 1024 c2c_conf->formats = SNDRV_PCM_FMTBIT_S32_LE; /* update ME */ 1003 1025 c2c_conf->rates = SNDRV_PCM_RATE_8000_384000; ··· 1010 1032 dai_link->num_c2c_params = 1; 1011 1033 } 1012 1034 1013 - ep0 = of_graph_get_next_port_endpoint(port0, NULL); 1014 - ep1 = of_graph_get_next_port_endpoint(port1, NULL); 1035 + struct device_node *ep0 __free(device_node) = of_graph_get_next_port_endpoint(port0, NULL); 1036 + struct device_node *ep1 __free(device_node) = of_graph_get_next_port_endpoint(port1, NULL); 1015 1037 1016 - codec0_port = of_graph_get_remote_port(ep0); 1017 - codec1_port = of_graph_get_remote_port(ep1); 1038 + struct device_node *codec0_port __free(device_node) = of_graph_get_remote_port(ep0); 1039 + struct device_node *codec1_port __free(device_node) = of_graph_get_remote_port(ep1); 1018 1040 1019 1041 /* 1020 1042 * call Codec first. ··· 1023 1045 */ 1024 1046 ret = graph_parse_node(priv, GRAPH_C2C, codec1_port, li, 0); 1025 1047 if (ret < 0) 1026 - goto err2; 1048 + return ret; 1027 1049 1028 1050 /* 1029 1051 * call CPU, and set DAI Name 1030 1052 */ 1031 1053 ret = graph_parse_node(priv, GRAPH_C2C, codec0_port, li, 1); 1032 1054 if (ret < 0) 1033 - goto err2; 1055 + return ret; 1034 1056 1035 1057 graph_link_init(priv, lnk, codec0_port, codec1_port, li, 1); 1036 - err2: 1037 - of_node_put(ep0); 1038 - of_node_put(ep1); 1039 - of_node_put(codec0_port); 1040 - of_node_put(codec1_port); 1041 - err1: 1042 - of_node_put(ports); 1043 - of_node_put(port0); 1044 - of_node_put(port1); 1045 1058 1046 1059 return ret; 1047 1060 } ··· 1122 1153 struct link_info *li) 1123 1154 { 1124 1155 struct device_node *cpu_port = lnk; 1125 - struct device_node *cpu_ep = of_graph_get_next_port_endpoint(cpu_port, NULL); 1126 - struct device_node *codec_port = of_graph_get_remote_port(cpu_ep); 1156 + struct device_node *cpu_ep __free(device_node) = of_graph_get_next_port_endpoint(cpu_port, NULL); 1157 + struct device_node *codec_port __free(device_node) = of_graph_get_remote_port(cpu_ep); 1127 1158 1128 1159 /* 1129 1160 * CPU { ··· 1140 1171 1141 1172 li->num[li->link].codecs = graph_counter(codec_port); 1142 1173 1143 - of_node_put(cpu_ep); 1144 - of_node_put(codec_port); 1145 - 1146 1174 return 0; 1147 1175 } 1148 1176 ··· 1147 1181 struct device_node *lnk, 1148 1182 struct link_info *li) 1149 1183 { 1150 - struct device_node *ep = of_graph_get_next_port_endpoint(lnk, NULL); 1151 - struct device_node *rport = of_graph_get_remote_port(ep); 1184 + struct device_node *ep __free(device_node) = of_graph_get_next_port_endpoint(lnk, NULL); 1185 + struct device_node *rport __free(device_node) = of_graph_get_remote_port(ep); 1152 1186 1153 1187 /* 1154 1188 * dpcm { ··· 1177 1211 li->num[li->link].codecs = graph_counter(rport); /* BE */ 1178 1212 } 1179 1213 1180 - of_node_put(ep); 1181 - of_node_put(rport); 1182 - 1183 1214 return 0; 1184 1215 } 1185 1216 ··· 1184 1221 struct device_node *lnk, 1185 1222 struct link_info *li) 1186 1223 { 1187 - struct device_node *ports = port_to_ports(lnk); 1188 - struct device_node *port0 = lnk; 1189 - struct device_node *port1 = of_graph_get_next_port(ports, of_node_get(port0)); 1190 - struct device_node *ep0 = of_graph_get_next_port_endpoint(port0, NULL); 1191 - struct device_node *ep1 = of_graph_get_next_port_endpoint(port1, NULL); 1192 - struct device_node *codec0 = of_graph_get_remote_port(ep0); 1193 - struct device_node *codec1 = of_graph_get_remote_port(ep1); 1224 + struct device_node *ports __free(device_node) = port_to_ports(lnk); 1225 + struct device_node *port0 = of_node_get(lnk); 1226 + struct device_node *port1 = of_node_get(of_graph_get_next_port(ports, of_node_get(port0))); 1227 + struct device_node *ep0 __free(device_node) = of_graph_get_next_port_endpoint(port0, NULL); 1228 + struct device_node *ep1 __free(device_node) = of_graph_get_next_port_endpoint(port1, NULL); 1229 + struct device_node *codec0 __free(device_node) = of_graph_get_remote_port(ep0); 1230 + struct device_node *codec1 __free(device_node) = of_graph_get_remote_port(ep1); 1194 1231 1195 1232 /* 1196 1233 * codec2codec { ··· 1209 1246 li->num[li->link].platforms = graph_counter(codec0); 1210 1247 1211 1248 li->num[li->link].codecs = graph_counter(codec1); 1212 - 1213 - of_node_put(ports); 1214 - of_node_put(port1); 1215 - of_node_put(ep0); 1216 - of_node_put(ep1); 1217 - of_node_put(codec0); 1218 - of_node_put(codec1); 1219 1249 1220 1250 return 0; 1221 1251 }

+17 -41

sound/soc/generic/simple-card.c

··· 120 120 struct simple_util_data *adata) 121 121 { 122 122 struct device_node *top = dev->of_node; 123 - struct device_node *node = of_get_parent(np); 123 + struct device_node *node __free(device_node) = of_get_parent(np); 124 124 125 125 simple_util_parse_convert(top, PREFIX, adata); 126 126 simple_util_parse_convert(node, PREFIX, adata); 127 127 simple_util_parse_convert(node, NULL, adata); 128 128 simple_util_parse_convert(np, NULL, adata); 129 - 130 - of_node_put(node); 131 129 } 132 130 133 131 static int simple_parse_node(struct simple_util_priv *priv, ··· 174 176 struct device_node *top = dev->of_node; 175 177 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 176 178 struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 177 - struct device_node *node = of_get_parent(cpu); 179 + struct device_node *node __free(device_node) = of_get_parent(cpu); 178 180 enum snd_soc_trigger_order trigger_start = SND_SOC_TRIGGER_ORDER_DEFAULT; 179 181 enum snd_soc_trigger_order trigger_stop = SND_SOC_TRIGGER_ORDER_DEFAULT; 180 182 bool playback_only = 0, capture_only = 0; ··· 183 185 ret = simple_util_parse_daifmt(dev, node, codec, 184 186 prefix, &dai_link->dai_fmt); 185 187 if (ret < 0) 186 - goto init_end; 188 + return ret; 187 189 188 190 graph_util_parse_link_direction(top, &playback_only, &capture_only); 189 191 graph_util_parse_link_direction(node, &playback_only, &capture_only); ··· 213 215 dai_link->init = simple_util_dai_init; 214 216 dai_link->ops = &simple_ops; 215 217 216 - ret = simple_util_set_dailink_name(dev, dai_link, name); 217 - init_end: 218 - of_node_put(node); 219 - 220 - return ret; 218 + return simple_util_set_dailink_name(dev, dai_link, name); 221 219 } 222 220 223 221 static int simple_dai_link_of_dpcm(struct simple_util_priv *priv, ··· 226 232 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 227 233 struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 228 234 struct device_node *top = dev->of_node; 229 - struct device_node *node = of_get_parent(np); 235 + struct device_node *node __free(device_node) = of_get_parent(np); 230 236 char *prefix = ""; 231 237 char dai_name[64]; 232 238 int ret; ··· 290 296 out_put_node: 291 297 li->link++; 292 298 293 - of_node_put(node); 294 299 return ret; 295 300 } 296 301 ··· 305 312 struct snd_soc_dai_link_component *codecs = snd_soc_link_to_codec(dai_link, 0); 306 313 struct snd_soc_dai_link_component *platforms = snd_soc_link_to_platform(dai_link, 0); 307 314 struct device_node *cpu = NULL; 308 - struct device_node *node = NULL; 309 - struct device_node *plat = NULL; 310 315 char dai_name[64]; 311 316 char prop[128]; 312 317 char *prefix = ""; 313 318 int ret, single_cpu = 0; 314 319 315 320 cpu = np; 316 - node = of_get_parent(np); 321 + struct device_node *node __free(device_node) = of_get_parent(np); 317 322 318 323 dev_dbg(dev, "link_of (%pOF)\n", node); 319 324 ··· 320 329 prefix = PREFIX; 321 330 322 331 snprintf(prop, sizeof(prop), "%splat", prefix); 323 - plat = of_get_child_by_name(node, prop); 332 + struct device_node *plat __free(device_node) = of_get_child_by_name(node, prop); 324 333 325 334 ret = simple_parse_node(priv, cpu, li, prefix, &single_cpu); 326 335 if (ret < 0) ··· 343 352 ret = simple_link_init(priv, cpu, codec, li, prefix, dai_name); 344 353 345 354 dai_link_of_err: 346 - of_node_put(plat); 347 - of_node_put(node); 348 - 349 355 li->link++; 350 356 351 357 return ret; ··· 362 374 struct device *dev = simple_priv_to_dev(priv); 363 375 struct device_node *top = dev->of_node; 364 376 struct device_node *node; 365 - struct device_node *add_devs; 366 377 uintptr_t dpcm_selectable = (uintptr_t)of_device_get_match_data(dev); 367 378 bool is_top = 0; 368 379 int ret = 0; ··· 373 386 is_top = 1; 374 387 } 375 388 376 - add_devs = of_get_child_by_name(top, PREFIX "additional-devs"); 389 + struct device_node *add_devs __free(device_node) = of_get_child_by_name(top, PREFIX "additional-devs"); 377 390 378 391 /* loop for all dai-link */ 379 392 do { 380 393 struct simple_util_data adata; 381 - struct device_node *codec; 382 - struct device_node *plat; 383 - struct device_node *np; 384 394 int num = of_get_child_count(node); 385 395 386 396 /* Skip additional-devs node */ ··· 387 403 } 388 404 389 405 /* get codec */ 390 - codec = of_get_child_by_name(node, is_top ? 391 - PREFIX "codec" : "codec"); 406 + struct device_node *codec __free(device_node) = 407 + of_get_child_by_name(node, is_top ? PREFIX "codec" : "codec"); 392 408 if (!codec) { 393 409 ret = -ENODEV; 394 410 goto error; 395 411 } 396 412 /* get platform */ 397 - plat = of_get_child_by_name(node, is_top ? 398 - PREFIX "plat" : "plat"); 413 + struct device_node *plat __free(device_node) = 414 + of_get_child_by_name(node, is_top ? PREFIX "plat" : "plat"); 399 415 400 416 /* get convert-xxx property */ 401 417 memset(&adata, 0, sizeof(adata)); 402 - for_each_child_of_node(node, np) { 418 + for_each_child_of_node_scoped(node, np) { 403 419 if (np == add_devs) 404 420 continue; 405 421 simple_parse_convert(dev, np, &adata); 406 422 } 407 423 408 424 /* loop for all CPU/Codec node */ 409 - for_each_child_of_node(node, np) { 425 + for_each_child_of_node_scoped(node, np) { 410 426 if (plat == np || add_devs == np) 411 427 continue; 412 428 /* ··· 436 452 ret = func_noml(priv, np, codec, li, is_top); 437 453 } 438 454 439 - if (ret < 0) { 440 - of_node_put(codec); 441 - of_node_put(plat); 442 - of_node_put(np); 455 + if (ret < 0) 443 456 goto error; 444 - } 445 457 } 446 458 447 - of_node_put(codec); 448 - of_node_put(plat); 449 459 node = of_get_next_child(top, node); 450 460 } while (!is_top && node); 451 461 452 462 error: 453 - of_node_put(add_devs); 454 463 of_node_put(node); 464 + 455 465 return ret; 456 466 } 457 467 ··· 492 514 static int simple_populate_aux(struct simple_util_priv *priv) 493 515 { 494 516 struct device *dev = simple_priv_to_dev(priv); 495 - struct device_node *node; 517 + struct device_node *node __free(device_node) = of_get_child_by_name(dev->of_node, PREFIX "additional-devs"); 496 518 int ret; 497 519 498 - node = of_get_child_by_name(dev->of_node, PREFIX "additional-devs"); 499 520 if (!node) 500 521 return 0; 501 522 502 523 ret = of_platform_populate(node, NULL, NULL, dev); 503 - of_node_put(node); 504 524 if (ret) 505 525 return ret; 506 526

+28 -2

sound/soc/soc-core.c

··· 1449 1449 { 1450 1450 struct snd_soc_dai *cpu_dai; 1451 1451 struct snd_soc_dai *codec_dai; 1452 + unsigned int ext_fmt; 1452 1453 unsigned int i; 1453 1454 int ret; 1454 1455 1455 1456 if (!dai_fmt) 1456 1457 return 0; 1457 1458 1459 + /* 1460 + * dai_fmt has 4 types 1461 + * 1. SND_SOC_DAIFMT_FORMAT_MASK 1462 + * 2. SND_SOC_DAIFMT_CLOCK 1463 + * 3. SND_SOC_DAIFMT_INV 1464 + * 4. SND_SOC_DAIFMT_CLOCK_PROVIDER 1465 + * 1466 + * 4. CLOCK_PROVIDER is set from Codec perspective in dai_fmt. So it will be flipped 1467 + * when this function calls set_fmt() for CPU (CBx_CFx -> Bx_Cx). see below. 1468 + * This mean, we can't set CPU/Codec both are clock consumer for example. 1469 + * New idea handles 4. in each dai->ext_fmt. It can keep compatibility. 1470 + * 1471 + * Legacy 1472 + * dai_fmt includes 1, 2, 3, 4 1473 + * 1474 + * New idea 1475 + * dai_fmt includes 1, 2, 3 1476 + * ext_fmt includes 4 1477 + */ 1458 1478 for_each_rtd_codec_dais(rtd, i, codec_dai) { 1459 - ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt); 1479 + ext_fmt = rtd->dai_link->codecs[i].ext_fmt; 1480 + ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt | ext_fmt); 1460 1481 if (ret != 0 && ret != -ENOTSUPP) 1461 1482 return ret; 1462 1483 } 1463 1484 1464 1485 /* Flip the polarity for the "CPU" end of link */ 1486 + /* Will effect only for 4. SND_SOC_DAIFMT_CLOCK_PROVIDER */ 1465 1487 dai_fmt = snd_soc_daifmt_clock_provider_flipped(dai_fmt); 1466 1488 1467 1489 for_each_rtd_cpu_dais(rtd, i, cpu_dai) { 1468 - ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt); 1490 + ext_fmt = rtd->dai_link->cpus[i].ext_fmt; 1491 + ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt | ext_fmt); 1469 1492 if (ret != 0 && ret != -ENOTSUPP) 1470 1493 return ret; 1471 1494 } ··· 3391 3368 { 3392 3369 char prop[128]; 3393 3370 unsigned int bit, frame; 3371 + 3372 + if (!np) 3373 + return 0; 3394 3374 3395 3375 if (!prefix) 3396 3376 prefix = "";

Configure Feed

Configure Feed