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