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