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/renesas/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 fw_devlink_purge_absent_suppliers(&np->fwnode); 272 goto out_put; 273 } 274 275 if (of_node_name_eq(np, GRAPH_NODENAME_DPCM)) { 276 ret = GRAPH_DPCM; 277 fw_devlink_purge_absent_suppliers(&np->fwnode); 278 goto out_put; 279 } 280 281 if (of_node_name_eq(np, GRAPH_NODENAME_C2C)) { 282 ret = GRAPH_C2C; 283 fw_devlink_purge_absent_suppliers(&np->fwnode); 284 goto out_put; 285 } 286 287 ret = GRAPH_NORMAL; 288 289 out_put: 290 of_node_put(np); 291 return ret; 292 293 } 294 295 static enum graph_type graph_get_type(struct simple_util_priv *priv, 296 struct device_node *lnk) 297 { 298 enum graph_type type = __graph_get_type(lnk); 299 300 /* GRAPH_MULTI here means GRAPH_NORMAL */ 301 if (type == GRAPH_MULTI) 302 type = GRAPH_NORMAL; 303 304 #ifdef DEBUG 305 { 306 struct device *dev = simple_priv_to_dev(priv); 307 const char *str = "Normal"; 308 309 switch (type) { 310 case GRAPH_DPCM: 311 if (graph_util_is_ports0(lnk)) 312 str = "DPCM Front-End"; 313 else 314 str = "DPCM Back-End"; 315 break; 316 case GRAPH_C2C: 317 str = "Codec2Codec"; 318 break; 319 default: 320 break; 321 } 322 323 dev_dbg(dev, "%pOF (%s)", lnk, str); 324 } 325 #endif 326 return type; 327 } 328 329 static int graph_lnk_is_multi(struct device_node *lnk) 330 { 331 return __graph_get_type(lnk) == GRAPH_MULTI; 332 } 333 334 static struct device_node *graph_get_next_multi_ep(struct device_node **port, int idx) 335 { 336 struct device_node *ports __free(device_node) = port_to_ports(*port); 337 struct device_node *rep = NULL; 338 339 /* 340 * multi { 341 * ports { 342 * => lnk: port@0 { ... }; // to pair 343 * port@1 { ep { ... = rep0 } }; // Multi Element 344 * port@2 { ep { ... = rep1 } }; // Multi Element 345 * ... 346 * }; 347 * }; 348 * 349 * xxx { 350 * port@0 { rep0 }; 351 * port@1 { rep1 }; 352 * }; 353 */ 354 355 /* 356 * Don't use of_graph_get_next_port() here 357 * 358 * In overlay case, "port" are not necessarily in order. So we need to use 359 * of_graph_get_port_by_id() instead 360 */ 361 of_node_put(*port); 362 363 *port = of_graph_get_port_by_id(ports, idx); 364 if (*port) { 365 struct device_node *ep __free(device_node) = of_graph_get_next_port_endpoint(*port, NULL); 366 367 rep = of_graph_get_remote_endpoint(ep); 368 } 369 370 return rep; 371 } 372 373 static const struct snd_soc_ops graph_ops = { 374 .startup = simple_util_startup, 375 .shutdown = simple_util_shutdown, 376 .hw_params = simple_util_hw_params, 377 }; 378 379 static void graph_parse_convert(struct device_node *ep, 380 struct simple_dai_props *props) 381 { 382 struct device_node *port __free(device_node) = ep_to_port(ep); 383 struct device_node *ports __free(device_node) = port_to_ports(port); 384 struct simple_util_data *adata = &props->adata; 385 386 simple_util_parse_convert(ports, NULL, adata); 387 simple_util_parse_convert(port, NULL, adata); 388 simple_util_parse_convert(ep, NULL, adata); 389 } 390 391 static int __graph_parse_node(struct simple_util_priv *priv, 392 enum graph_type gtype, 393 struct device_node *ep, 394 struct link_info *li, 395 int is_cpu, int idx) 396 { 397 struct device *dev = simple_priv_to_dev(priv); 398 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 399 struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 400 struct snd_soc_dai_link_component *dlc; 401 struct simple_util_dai *dai; 402 int ret, is_single_links = 0; 403 404 if (is_cpu) { 405 dlc = snd_soc_link_to_cpu(dai_link, idx); 406 dai = simple_props_to_dai_cpu(dai_props, idx); 407 } else { 408 dlc = snd_soc_link_to_codec(dai_link, idx); 409 dai = simple_props_to_dai_codec(dai_props, idx); 410 } 411 412 ret = graph_util_parse_dai(dev, ep, dlc, &is_single_links); 413 if (ret < 0) 414 return ret; 415 416 ret = simple_util_parse_tdm(ep, dai); 417 if (ret < 0) 418 return ret; 419 420 ret = simple_util_parse_tdm_width_map(dev, ep, dai); 421 if (ret < 0) 422 return ret; 423 424 ret = simple_util_parse_clk(dev, ep, dai, dlc); 425 if (ret < 0) 426 return ret; 427 428 /* 429 * set DAI Name 430 */ 431 if (!dai_link->name) { 432 struct snd_soc_dai_link_component *cpus = dlc; 433 struct snd_soc_dai_link_component *codecs = snd_soc_link_to_codec(dai_link, idx); 434 char *cpu_multi = ""; 435 char *codec_multi = ""; 436 437 if (dai_link->num_cpus > 1) 438 cpu_multi = "_multi"; 439 if (dai_link->num_codecs > 1) 440 codec_multi = "_multi"; 441 442 switch (gtype) { 443 case GRAPH_NORMAL: 444 /* run is_cpu only. see audio_graph2_link_normal() */ 445 if (is_cpu) 446 simple_util_set_dailink_name(dev, dai_link, "%s%s-%s%s", 447 cpus->dai_name, cpu_multi, 448 codecs->dai_name, codec_multi); 449 break; 450 case GRAPH_DPCM: 451 if (is_cpu) 452 simple_util_set_dailink_name(dev, dai_link, "fe.%pOFP.%s%s", 453 cpus->of_node, cpus->dai_name, cpu_multi); 454 else 455 simple_util_set_dailink_name(dev, dai_link, "be.%pOFP.%s%s", 456 codecs->of_node, codecs->dai_name, codec_multi); 457 break; 458 case GRAPH_C2C: 459 /* run is_cpu only. see audio_graph2_link_c2c() */ 460 if (is_cpu) 461 simple_util_set_dailink_name(dev, dai_link, "c2c.%s%s-%s%s", 462 cpus->dai_name, cpu_multi, 463 codecs->dai_name, codec_multi); 464 break; 465 default: 466 break; 467 } 468 } 469 470 /* 471 * Check "prefix" from top node 472 * if DPCM-BE case 473 */ 474 if (!is_cpu && gtype == GRAPH_DPCM) { 475 struct snd_soc_dai_link_component *codecs = snd_soc_link_to_codec(dai_link, idx); 476 struct snd_soc_codec_conf *cconf = simple_props_to_codec_conf(dai_props, idx); 477 struct device_node *rport __free(device_node) = ep_to_port(ep); 478 struct device_node *rports __free(device_node) = port_to_ports(rport); 479 480 snd_soc_of_parse_node_prefix(rports, cconf, codecs->of_node, "prefix"); 481 snd_soc_of_parse_node_prefix(rport, cconf, codecs->of_node, "prefix"); 482 } 483 484 if (is_cpu) { 485 struct snd_soc_dai_link_component *cpus = dlc; 486 struct snd_soc_dai_link_component *platforms = snd_soc_link_to_platform(dai_link, idx); 487 488 simple_util_canonicalize_cpu(cpus, is_single_links); 489 simple_util_canonicalize_platform(platforms, cpus); 490 } 491 492 return 0; 493 } 494 495 static int graph_parse_node_multi_nm(struct snd_soc_dai_link *dai_link, 496 int *nm_idx, int cpu_idx, 497 struct device_node *mcpu_port) 498 { 499 /* 500 * +---+ +---+ 501 * | X|<-@------->|x | 502 * | | | | 503 * cpu0 <--|A 1|<--------->|4 a|-> codec0 504 * cpu1 <--|B 2|<-----+--->|5 b|-> codec1 505 * cpu2 <--|C 3|<----/ +---+ 506 * +---+ 507 * 508 * multi { 509 * ports { 510 * port@0 { mcpu_top_ep {... = mcodec_ep; }; }; // (X) to pair 511 * <mcpu_port> port@1 { mcpu0_ep { ... = cpu0_ep; }; // (A) Multi Element 512 * mcpu0_ep_0 { ... = mcodec0_ep_0; }; }; // (1) connected Codec 513 * port@2 { mcpu1_ep { ... = cpu1_ep; }; // (B) Multi Element 514 * mcpu1_ep_0 { ... = mcodec1_ep_0; }; }; // (2) connected Codec 515 * port@3 { mcpu2_ep { ... = cpu2_ep; }; // (C) Multi Element 516 * mcpu2_ep_0 { ... = mcodec1_ep_1; }; }; // (3) connected Codec 517 * }; 518 * 519 * ports { 520 * port@0 { mcodec_top_ep {... = mcpu_ep; }; }; // (x) to pair 521 * <mcodec_port>port@1 { mcodec0_ep { ... = codec0_ep; }; // (a) Multi Element 522 * mcodec0_ep_0 { ... = mcpu0_ep_0; }; }; // (4) connected CPU 523 * port@2 { mcodec1_ep { ... = codec1_ep; }; // (b) Multi Element 524 * mcodec1_ep_0 { ... = mcpu1_ep_0; }; // (5) connected CPU 525 * mcodec1_ep_1 { ... = mcpu2_ep_0; }; }; // (5) connected CPU 526 * }; 527 * }; 528 */ 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 int nm_max = max(dai_link->num_cpus, dai_link->num_codecs); 537 int ret = 0; 538 539 if (cpu_idx > dai_link->num_cpus) 540 return -EINVAL; 541 542 for_each_of_graph_port_endpoint(mcpu_port, mcpu_ep_n) { 543 int codec_idx = 0; 544 545 /* ignore 1st ep which is for element */ 546 if (mcpu_ep_n == mcpu_ep) 547 continue; 548 549 if (*nm_idx > nm_max) 550 break; 551 552 struct device_node *mcodec_ep_n __free(device_node) = of_graph_get_remote_endpoint(mcpu_ep_n); 553 struct device_node *mcodec_port __free(device_node) = ep_to_port(mcodec_ep_n); 554 555 ret = -EINVAL; 556 if (mcodec_ports != port_to_ports(mcodec_port)) 557 break; 558 559 for_each_of_graph_port(mcodec_ports, mcodec_port_i) { 560 561 /* ignore 1st port which is for pair connection */ 562 if (mcodec_port_top == mcodec_port_i) 563 continue; 564 565 if (codec_idx > dai_link->num_codecs) 566 break; 567 568 if (mcodec_port_i == mcodec_port) { 569 dai_link->ch_maps[*nm_idx].cpu = cpu_idx; 570 dai_link->ch_maps[*nm_idx].codec = codec_idx; 571 572 (*nm_idx)++; 573 ret = 0; 574 break; 575 } 576 codec_idx++; 577 } 578 if (ret < 0) 579 break; 580 } 581 582 return ret; 583 } 584 585 static int graph_parse_node_multi(struct simple_util_priv *priv, 586 enum graph_type gtype, 587 struct device_node *port, 588 struct link_info *li, int is_cpu) 589 { 590 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 591 struct device *dev = simple_priv_to_dev(priv); 592 int ret = -ENOMEM; 593 int nm_idx = 0; 594 int nm_max = max(dai_link->num_cpus, dai_link->num_codecs); 595 596 /* 597 * create ch_maps if CPU:Codec = N:M 598 * DPCM is out of scope 599 */ 600 if (gtype != GRAPH_DPCM && !dai_link->ch_maps && 601 dai_link->num_cpus > 1 && dai_link->num_codecs > 1 && 602 dai_link->num_cpus != dai_link->num_codecs) { 603 604 dai_link->ch_maps = devm_kcalloc(dev, nm_max, 605 sizeof(struct snd_soc_dai_link_ch_map), GFP_KERNEL); 606 if (!dai_link->ch_maps) 607 goto multi_err; 608 } 609 610 for (int idx = 0;; idx++) { 611 /* 612 * multi { 613 * ports { 614 * <port> port@0 { ... }; // to pair 615 * port@1 { mcpu1_ep { ... = cpu1_ep };}; // Multi Element 616 * port@2 { mcpu2_ep { ... = cpu2_ep };}; // Multi Element 617 * }; 618 * }; 619 * 620 * cpu { 621 * ports { 622 * <ep> port@0 { cpu1_ep { ... = mcpu1_ep };}; 623 * }; 624 * }; 625 */ 626 struct device_node *ep __free(device_node) = graph_get_next_multi_ep(&port, idx + 1); 627 if (!ep) 628 break; 629 630 ret = __graph_parse_node(priv, gtype, ep, li, is_cpu, idx); 631 if (ret < 0) 632 goto multi_err; 633 634 /* CPU:Codec = N:M */ 635 if (is_cpu && dai_link->ch_maps) { 636 ret = graph_parse_node_multi_nm(dai_link, &nm_idx, idx, port); 637 if (ret < 0) 638 goto multi_err; 639 } 640 } 641 642 if (is_cpu && dai_link->ch_maps && (nm_idx != nm_max)) 643 ret = -EINVAL; 644 645 multi_err: 646 return ret; 647 } 648 649 static int graph_parse_node_single(struct simple_util_priv *priv, 650 enum graph_type gtype, 651 struct device_node *port, 652 struct link_info *li, int is_cpu) 653 { 654 struct device_node *ep __free(device_node) = of_graph_get_next_port_endpoint(port, NULL); 655 656 return __graph_parse_node(priv, gtype, ep, li, is_cpu, 0); 657 } 658 659 static int graph_parse_node(struct simple_util_priv *priv, 660 enum graph_type gtype, 661 struct device_node *port, 662 struct link_info *li, int is_cpu) 663 { 664 if (graph_lnk_is_multi(port)) 665 return graph_parse_node_multi(priv, gtype, port, li, is_cpu); 666 else 667 return graph_parse_node_single(priv, gtype, port, li, is_cpu); 668 } 669 670 static void graph_parse_daifmt(struct device_node *node, unsigned int *daifmt) 671 { 672 unsigned int fmt; 673 674 if (!node) 675 return; 676 677 /* 678 * see also above "daifmt" explanation 679 * and samples. 680 */ 681 682 /* 683 * ports { 684 * (A) 685 * port { 686 * (B) 687 * endpoint { 688 * (C) 689 * }; 690 * }; 691 * }; 692 * }; 693 */ 694 695 #define update_daifmt(name) \ 696 if (!(*daifmt & SND_SOC_DAIFMT_##name##_MASK) && \ 697 (fmt & SND_SOC_DAIFMT_##name##_MASK)) \ 698 *daifmt |= fmt & SND_SOC_DAIFMT_##name##_MASK 699 700 /* 701 * format 702 * 703 * This function is called by (C) -> (B) -> (A) order. 704 * Set if applicable part was not yet set. 705 */ 706 fmt = snd_soc_daifmt_parse_format(node, NULL); 707 update_daifmt(FORMAT); 708 update_daifmt(CLOCK); 709 update_daifmt(INV); 710 } 711 712 static unsigned int graph_parse_bitframe(struct device_node *ep) 713 { 714 struct device_node *port __free(device_node) = ep_to_port(ep); 715 struct device_node *ports __free(device_node) = port_to_ports(port); 716 717 return snd_soc_daifmt_clock_provider_from_bitmap( 718 snd_soc_daifmt_parse_clock_provider_as_bitmap(ep, NULL) | 719 snd_soc_daifmt_parse_clock_provider_as_bitmap(port, NULL) | 720 snd_soc_daifmt_parse_clock_provider_as_bitmap(ports, NULL)); 721 } 722 723 static void graph_link_init(struct simple_util_priv *priv, 724 struct device_node *lnk, 725 struct device_node *port_cpu, 726 struct device_node *port_codec, 727 struct link_info *li, 728 int is_cpu_node) 729 { 730 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 731 struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 732 struct device_node *ep_cpu, *ep_codec; 733 struct device_node *multi_cpu_port = NULL, *multi_codec_port = NULL; 734 struct snd_soc_dai_link_component *dlc; 735 unsigned int daifmt = 0; 736 bool playback_only = 0, capture_only = 0; 737 enum snd_soc_trigger_order trigger_start = SND_SOC_TRIGGER_ORDER_DEFAULT; 738 enum snd_soc_trigger_order trigger_stop = SND_SOC_TRIGGER_ORDER_DEFAULT; 739 int multi_cpu_port_idx = 1, multi_codec_port_idx = 1; 740 int i; 741 742 of_node_get(port_cpu); 743 if (graph_lnk_is_multi(port_cpu)) { 744 multi_cpu_port = port_cpu; 745 ep_cpu = graph_get_next_multi_ep(&multi_cpu_port, multi_cpu_port_idx++); 746 of_node_put(port_cpu); 747 port_cpu = ep_to_port(ep_cpu); 748 } else { 749 ep_cpu = of_graph_get_next_port_endpoint(port_cpu, NULL); 750 } 751 struct device_node *ports_cpu __free(device_node) = port_to_ports(port_cpu); 752 753 of_node_get(port_codec); 754 if (graph_lnk_is_multi(port_codec)) { 755 multi_codec_port = port_codec; 756 ep_codec = graph_get_next_multi_ep(&multi_codec_port, multi_codec_port_idx++); 757 of_node_put(port_codec); 758 port_codec = ep_to_port(ep_codec); 759 } else { 760 ep_codec = of_graph_get_next_port_endpoint(port_codec, NULL); 761 } 762 struct device_node *ports_codec __free(device_node) = port_to_ports(port_codec); 763 764 graph_parse_daifmt(ep_cpu, &daifmt); 765 graph_parse_daifmt(ep_codec, &daifmt); 766 graph_parse_daifmt(port_cpu, &daifmt); 767 graph_parse_daifmt(port_codec, &daifmt); 768 graph_parse_daifmt(ports_cpu, &daifmt); 769 graph_parse_daifmt(ports_codec, &daifmt); 770 graph_parse_daifmt(lnk, &daifmt); 771 772 graph_util_parse_link_direction(lnk, &playback_only, &capture_only); 773 graph_util_parse_link_direction(ports_cpu, &playback_only, &capture_only); 774 graph_util_parse_link_direction(ports_codec, &playback_only, &capture_only); 775 graph_util_parse_link_direction(port_cpu, &playback_only, &capture_only); 776 graph_util_parse_link_direction(port_codec, &playback_only, &capture_only); 777 graph_util_parse_link_direction(ep_cpu, &playback_only, &capture_only); 778 graph_util_parse_link_direction(ep_codec, &playback_only, &capture_only); 779 780 of_property_read_u32(lnk, "mclk-fs", &dai_props->mclk_fs); 781 of_property_read_u32(ports_cpu, "mclk-fs", &dai_props->mclk_fs); 782 of_property_read_u32(ports_codec, "mclk-fs", &dai_props->mclk_fs); 783 of_property_read_u32(port_cpu, "mclk-fs", &dai_props->mclk_fs); 784 of_property_read_u32(port_codec, "mclk-fs", &dai_props->mclk_fs); 785 of_property_read_u32(ep_cpu, "mclk-fs", &dai_props->mclk_fs); 786 of_property_read_u32(ep_codec, "mclk-fs", &dai_props->mclk_fs); 787 788 graph_util_parse_trigger_order(priv, lnk, &trigger_start, &trigger_stop); 789 graph_util_parse_trigger_order(priv, ports_cpu, &trigger_start, &trigger_stop); 790 graph_util_parse_trigger_order(priv, ports_codec, &trigger_start, &trigger_stop); 791 graph_util_parse_trigger_order(priv, port_cpu, &trigger_start, &trigger_stop); 792 graph_util_parse_trigger_order(priv, port_cpu, &trigger_start, &trigger_stop); 793 graph_util_parse_trigger_order(priv, ep_cpu, &trigger_start, &trigger_stop); 794 graph_util_parse_trigger_order(priv, ep_codec, &trigger_start, &trigger_stop); 795 796 for_each_link_cpus(dai_link, i, dlc) { 797 dlc->ext_fmt = graph_parse_bitframe(ep_cpu); 798 799 if (multi_cpu_port) 800 ep_cpu = graph_get_next_multi_ep(&multi_cpu_port, multi_cpu_port_idx++); 801 } 802 803 for_each_link_codecs(dai_link, i, dlc) { 804 dlc->ext_fmt = graph_parse_bitframe(ep_codec); 805 806 if (multi_codec_port) 807 ep_codec = graph_get_next_multi_ep(&multi_codec_port, multi_codec_port_idx++); 808 } 809 810 /*** Don't use port_cpu / port_codec after here ***/ 811 812 dai_link->playback_only = playback_only; 813 dai_link->capture_only = capture_only; 814 815 dai_link->trigger_start = trigger_start; 816 dai_link->trigger_stop = trigger_stop; 817 818 dai_link->dai_fmt = daifmt; 819 dai_link->init = simple_util_dai_init; 820 dai_link->ops = &graph_ops; 821 if (priv->ops) 822 dai_link->ops = priv->ops; 823 824 of_node_put(port_cpu); 825 of_node_put(port_codec); 826 of_node_put(ep_cpu); 827 of_node_put(ep_codec); 828 } 829 830 int audio_graph2_link_normal(struct simple_util_priv *priv, 831 struct device_node *lnk, 832 struct link_info *li) 833 { 834 struct device_node *cpu_port = lnk; 835 struct device_node *cpu_ep __free(device_node) = of_graph_get_next_port_endpoint(cpu_port, NULL); 836 struct device_node *codec_port __free(device_node) = of_graph_get_remote_port(cpu_ep); 837 int ret; 838 839 /* 840 * call Codec first. 841 * see 842 * __graph_parse_node() :: DAI Naming 843 */ 844 ret = graph_parse_node(priv, GRAPH_NORMAL, codec_port, li, 0); 845 if (ret < 0) 846 return ret; 847 848 /* 849 * call CPU, and set DAI Name 850 */ 851 ret = graph_parse_node(priv, GRAPH_NORMAL, cpu_port, li, 1); 852 if (ret < 0) 853 return ret; 854 855 graph_link_init(priv, lnk, cpu_port, codec_port, li, 1); 856 857 return ret; 858 } 859 EXPORT_SYMBOL_GPL(audio_graph2_link_normal); 860 861 int audio_graph2_link_dpcm(struct simple_util_priv *priv, 862 struct device_node *lnk, 863 struct link_info *li) 864 { 865 struct device_node *ep __free(device_node) = of_graph_get_next_port_endpoint(lnk, NULL); 866 struct device_node *rep __free(device_node) = of_graph_get_remote_endpoint(ep); 867 struct device_node *cpu_port = NULL; 868 struct device_node *codec_port = NULL; 869 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 870 struct simple_dai_props *dai_props = simple_priv_to_props(priv, li->link); 871 int is_cpu = graph_util_is_ports0(lnk); 872 int ret; 873 874 if (is_cpu) { 875 cpu_port = of_graph_get_remote_port(ep); /* rport */ 876 877 /* 878 * dpcm { 879 * // Front-End 880 * ports@0 { 881 * => lnk: port@0 { ep: { ... = rep }; }; 882 * ... 883 * }; 884 * // Back-End 885 * ports@0 { 886 * ... 887 * }; 888 * }; 889 * 890 * CPU { 891 * rports: ports { 892 * rport: port@0 { rep: { ... = ep } }; 893 * } 894 * } 895 */ 896 /* 897 * setup CPU here, Codec is already set as dummy. 898 * see 899 * simple_util_init_priv() 900 */ 901 dai_link->dynamic = 1; 902 dai_link->dpcm_merged_format = 1; 903 904 ret = graph_parse_node(priv, GRAPH_DPCM, cpu_port, li, 1); 905 if (ret) 906 goto err; 907 908 } else { 909 codec_port = of_graph_get_remote_port(ep); /* rport */ 910 911 /* 912 * dpcm { 913 * // Front-End 914 * ports@0 { 915 * ... 916 * }; 917 * // Back-End 918 * ports@0 { 919 * => lnk: port@0 { ep: { ... = rep; }; }; 920 * ... 921 * }; 922 * }; 923 * 924 * Codec { 925 * rports: ports { 926 * rport: port@0 { rep: { ... = ep; }; }; 927 * } 928 * } 929 */ 930 /* 931 * setup Codec here, CPU is already set as dummy. 932 * see 933 * simple_util_init_priv() 934 */ 935 936 /* BE settings */ 937 dai_link->no_pcm = 1; 938 dai_link->be_hw_params_fixup = simple_util_be_hw_params_fixup; 939 940 ret = graph_parse_node(priv, GRAPH_DPCM, codec_port, li, 0); 941 if (ret < 0) 942 goto err; 943 } 944 945 graph_parse_convert(ep, dai_props); /* at node of <dpcm> */ 946 graph_parse_convert(rep, dai_props); /* at node of <CPU/Codec> */ 947 948 graph_link_init(priv, lnk, cpu_port, codec_port, li, is_cpu); 949 err: 950 of_node_put(cpu_port); 951 of_node_put(codec_port); 952 953 return ret; 954 } 955 EXPORT_SYMBOL_GPL(audio_graph2_link_dpcm); 956 957 int audio_graph2_link_c2c(struct simple_util_priv *priv, 958 struct device_node *lnk, 959 struct link_info *li) 960 { 961 struct snd_soc_dai_link *dai_link = simple_priv_to_link(priv, li->link); 962 struct device_node *port0 = lnk; 963 struct device_node *ports __free(device_node) = port_to_ports(port0); 964 struct device_node *port1 __free(device_node) = of_graph_get_next_port(ports, port0); 965 u32 val = 0; 966 int ret = -EINVAL; 967 968 /* 969 * codec2codec { 970 * ports { 971 * rate = <48000>; 972 * => lnk: port@0 { c2c0_ep: { ... = codec0_ep; }; }; 973 * port@1 { c2c1_ep: { ... = codec1_ep; }; }; 974 * }; 975 * }; 976 * 977 * Codec { 978 * ports { 979 * port@0 { codec0_ep: ... }; }; 980 * port@1 { codec1_ep: ... }; }; 981 * }; 982 * }; 983 */ 984 985 /* 986 * Card2 can use original Codec2Codec settings if DT has. 987 * It will use default settings if no settings on DT. 988 * see 989 * simple_util_init_for_codec2codec() 990 * 991 * Add more settings here if needed 992 */ 993 of_property_read_u32(ports, "rate", &val); 994 if (val) { 995 struct device *dev = simple_priv_to_dev(priv); 996 struct snd_soc_pcm_stream *c2c_conf; 997 998 c2c_conf = devm_kzalloc(dev, sizeof(*c2c_conf), GFP_KERNEL); 999 if (!c2c_conf) 1000 return ret; 1001 1002 c2c_conf->formats = SNDRV_PCM_FMTBIT_S32_LE; /* update ME */ 1003 c2c_conf->rates = SNDRV_PCM_RATE_8000_384000; 1004 c2c_conf->rate_min = 1005 c2c_conf->rate_max = val; 1006 c2c_conf->channels_min = 1007 c2c_conf->channels_max = 2; /* update ME */ 1008 1009 dai_link->c2c_params = c2c_conf; 1010 dai_link->num_c2c_params = 1; 1011 } 1012 1013 struct device_node *ep0 __free(device_node) = of_graph_get_next_port_endpoint(port0, NULL); 1014 struct device_node *ep1 __free(device_node) = of_graph_get_next_port_endpoint(port1, NULL); 1015 1016 struct device_node *codec0_port __free(device_node) = of_graph_get_remote_port(ep0); 1017 struct device_node *codec1_port __free(device_node) = of_graph_get_remote_port(ep1); 1018 1019 /* 1020 * call Codec first. 1021 * see 1022 * __graph_parse_node() :: DAI Naming 1023 */ 1024 ret = graph_parse_node(priv, GRAPH_C2C, codec1_port, li, 0); 1025 if (ret < 0) 1026 return ret; 1027 1028 /* 1029 * call CPU, and set DAI Name 1030 */ 1031 ret = graph_parse_node(priv, GRAPH_C2C, codec0_port, li, 1); 1032 if (ret < 0) 1033 return ret; 1034 1035 graph_link_init(priv, lnk, codec0_port, codec1_port, li, 1); 1036 1037 return ret; 1038 } 1039 EXPORT_SYMBOL_GPL(audio_graph2_link_c2c); 1040 1041 static int graph_link(struct simple_util_priv *priv, 1042 struct graph2_custom_hooks *hooks, 1043 enum graph_type gtype, 1044 struct device_node *lnk, 1045 struct link_info *li) 1046 { 1047 struct device *dev = simple_priv_to_dev(priv); 1048 GRAPH2_CUSTOM func = NULL; 1049 int ret = -EINVAL; 1050 1051 switch (gtype) { 1052 case GRAPH_NORMAL: 1053 if (hooks && hooks->custom_normal) 1054 func = hooks->custom_normal; 1055 else 1056 func = audio_graph2_link_normal; 1057 break; 1058 case GRAPH_DPCM: 1059 if (hooks && hooks->custom_dpcm) 1060 func = hooks->custom_dpcm; 1061 else 1062 func = audio_graph2_link_dpcm; 1063 break; 1064 case GRAPH_C2C: 1065 if (hooks && hooks->custom_c2c) 1066 func = hooks->custom_c2c; 1067 else 1068 func = audio_graph2_link_c2c; 1069 break; 1070 default: 1071 break; 1072 } 1073 1074 if (!func) { 1075 dev_err(dev, "non supported gtype (%d)\n", gtype); 1076 goto err; 1077 } 1078 1079 ret = func(priv, lnk, li); 1080 if (ret < 0) 1081 goto err; 1082 1083 li->link++; 1084 err: 1085 return ret; 1086 } 1087 1088 static int graph_counter(struct device_node *lnk) 1089 { 1090 /* 1091 * Multi CPU / Codec 1092 * 1093 * multi { 1094 * ports { 1095 * => lnk: port@0 { ... }; // to pair 1096 * port@1 { ... }; // Multi Element 1097 * port@2 { ... }; // Multi Element 1098 * ... 1099 * }; 1100 * }; 1101 * 1102 * ignore first lnk part 1103 */ 1104 if (graph_lnk_is_multi(lnk)) { 1105 struct device_node *ports = port_to_ports(lnk); 1106 1107 /* 1108 * CPU/Codec = N:M case has many endpoints. 1109 * We can't use of_graph_get_endpoint_count() here 1110 */ 1111 return of_graph_get_port_count(ports) - 1; 1112 } 1113 /* 1114 * Single CPU / Codec 1115 */ 1116 else 1117 return 1; 1118 } 1119 1120 static int graph_count_normal(struct simple_util_priv *priv, 1121 struct device_node *lnk, 1122 struct link_info *li) 1123 { 1124 struct device_node *cpu_port = lnk; 1125 struct device_node *cpu_ep __free(device_node) = of_graph_get_next_port_endpoint(cpu_port, NULL); 1126 struct device_node *codec_port __free(device_node) = of_graph_get_remote_port(cpu_ep); 1127 1128 /* 1129 * CPU { 1130 * => lnk: port { endpoint { .. }; }; 1131 * }; 1132 */ 1133 /* 1134 * DON'T REMOVE platforms 1135 * see 1136 * simple-card.c :: simple_count_noml() 1137 */ 1138 li->num[li->link].cpus = 1139 li->num[li->link].platforms = graph_counter(cpu_port); 1140 1141 li->num[li->link].codecs = graph_counter(codec_port); 1142 1143 return 0; 1144 } 1145 1146 static int graph_count_dpcm(struct simple_util_priv *priv, 1147 struct device_node *lnk, 1148 struct link_info *li) 1149 { 1150 struct device_node *ep __free(device_node) = of_graph_get_next_port_endpoint(lnk, NULL); 1151 struct device_node *rport __free(device_node) = of_graph_get_remote_port(ep); 1152 1153 /* 1154 * dpcm { 1155 * // Front-End 1156 * ports@0 { 1157 * => lnk: port@0 { endpoint { ... }; }; 1158 * ... 1159 * }; 1160 * // Back-End 1161 * ports@1 { 1162 * => lnk: port@0 { endpoint { ... }; }; 1163 * ... 1164 * }; 1165 * }; 1166 */ 1167 1168 if (graph_util_is_ports0(lnk)) { 1169 /* 1170 * DON'T REMOVE platforms 1171 * see 1172 * simple-card.c :: simple_count_noml() 1173 */ 1174 li->num[li->link].cpus = graph_counter(rport); /* FE */ 1175 li->num[li->link].platforms = graph_counter(rport); 1176 } else { 1177 li->num[li->link].codecs = graph_counter(rport); /* BE */ 1178 } 1179 1180 return 0; 1181 } 1182 1183 static int graph_count_c2c(struct simple_util_priv *priv, 1184 struct device_node *lnk, 1185 struct link_info *li) 1186 { 1187 struct device_node *ports __free(device_node) = port_to_ports(lnk); 1188 struct device_node *port0 = of_node_get(lnk); 1189 struct device_node *port1 = of_node_get(of_graph_get_next_port(ports, of_node_get(port0))); 1190 struct device_node *ep0 __free(device_node) = of_graph_get_next_port_endpoint(port0, NULL); 1191 struct device_node *ep1 __free(device_node) = of_graph_get_next_port_endpoint(port1, NULL); 1192 struct device_node *codec0 __free(device_node) = of_graph_get_remote_port(ep0); 1193 struct device_node *codec1 __free(device_node) = of_graph_get_remote_port(ep1); 1194 1195 /* 1196 * codec2codec { 1197 * ports { 1198 * => lnk: port@0 { endpoint { ... }; }; 1199 * port@1 { endpoint { ... }; }; 1200 * }; 1201 * }; 1202 */ 1203 /* 1204 * DON'T REMOVE platforms 1205 * see 1206 * simple-card.c :: simple_count_noml() 1207 */ 1208 li->num[li->link].cpus = 1209 li->num[li->link].platforms = graph_counter(codec0); 1210 1211 li->num[li->link].codecs = graph_counter(codec1); 1212 1213 return 0; 1214 } 1215 1216 static int graph_count(struct simple_util_priv *priv, 1217 struct graph2_custom_hooks *hooks, 1218 enum graph_type gtype, 1219 struct device_node *lnk, 1220 struct link_info *li) 1221 { 1222 struct device *dev = simple_priv_to_dev(priv); 1223 GRAPH2_CUSTOM func = NULL; 1224 int ret = -EINVAL; 1225 1226 if (li->link >= SNDRV_MAX_LINKS) { 1227 dev_err(dev, "too many links\n"); 1228 return ret; 1229 } 1230 1231 switch (gtype) { 1232 case GRAPH_NORMAL: 1233 func = graph_count_normal; 1234 break; 1235 case GRAPH_DPCM: 1236 func = graph_count_dpcm; 1237 break; 1238 case GRAPH_C2C: 1239 func = graph_count_c2c; 1240 break; 1241 default: 1242 break; 1243 } 1244 1245 if (!func) { 1246 dev_err(dev, "non supported gtype (%d)\n", gtype); 1247 goto err; 1248 } 1249 1250 ret = func(priv, lnk, li); 1251 if (ret < 0) 1252 goto err; 1253 1254 li->link++; 1255 err: 1256 return ret; 1257 } 1258 1259 static int graph_for_each_link(struct simple_util_priv *priv, 1260 struct graph2_custom_hooks *hooks, 1261 struct link_info *li, 1262 int (*func)(struct simple_util_priv *priv, 1263 struct graph2_custom_hooks *hooks, 1264 enum graph_type gtype, 1265 struct device_node *lnk, 1266 struct link_info *li)) 1267 { 1268 struct of_phandle_iterator it; 1269 struct device *dev = simple_priv_to_dev(priv); 1270 struct device_node *node = dev->of_node; 1271 struct device_node *lnk; 1272 enum graph_type gtype; 1273 int rc, ret; 1274 1275 /* loop for all listed CPU port */ 1276 of_for_each_phandle(&it, rc, node, "links", NULL, 0) { 1277 lnk = it.node; 1278 1279 gtype = graph_get_type(priv, lnk); 1280 1281 ret = func(priv, hooks, gtype, lnk, li); 1282 if (ret < 0) 1283 return ret; 1284 } 1285 1286 return 0; 1287 } 1288 1289 int audio_graph2_parse_of(struct simple_util_priv *priv, struct device *dev, 1290 struct graph2_custom_hooks *hooks) 1291 { 1292 struct snd_soc_card *card = simple_priv_to_card(priv); 1293 int ret; 1294 1295 struct link_info *li __free(kfree) = kzalloc(sizeof(*li), GFP_KERNEL); 1296 if (!li) 1297 return -ENOMEM; 1298 1299 card->probe = graph_util_card_probe; 1300 card->owner = THIS_MODULE; 1301 card->dev = dev; 1302 1303 if ((hooks) && (hooks)->hook_pre) { 1304 ret = (hooks)->hook_pre(priv); 1305 if (ret < 0) 1306 goto err; 1307 } 1308 1309 ret = graph_for_each_link(priv, hooks, li, graph_count); 1310 if (!li->link) 1311 ret = -EINVAL; 1312 if (ret < 0) 1313 goto err; 1314 1315 ret = simple_util_init_priv(priv, li); 1316 if (ret < 0) 1317 goto err; 1318 1319 priv->pa_gpio = devm_gpiod_get_optional(dev, "pa", GPIOD_OUT_LOW); 1320 if (IS_ERR(priv->pa_gpio)) { 1321 ret = PTR_ERR(priv->pa_gpio); 1322 dev_err(dev, "failed to get amplifier gpio: %d\n", ret); 1323 goto err; 1324 } 1325 1326 ret = simple_util_parse_widgets(card, NULL); 1327 if (ret < 0) 1328 goto err; 1329 1330 ret = simple_util_parse_routing(card, NULL); 1331 if (ret < 0) 1332 goto err; 1333 1334 memset(li, 0, sizeof(*li)); 1335 ret = graph_for_each_link(priv, hooks, li, graph_link); 1336 if (ret < 0) 1337 goto err; 1338 1339 ret = simple_util_parse_card_name(card, NULL); 1340 if (ret < 0) 1341 goto err; 1342 1343 snd_soc_card_set_drvdata(card, priv); 1344 1345 if ((hooks) && (hooks)->hook_post) { 1346 ret = (hooks)->hook_post(priv); 1347 if (ret < 0) 1348 goto err; 1349 } 1350 1351 simple_util_debug_info(priv); 1352 1353 ret = snd_soc_of_parse_aux_devs(card, "aux-devs"); 1354 if (ret < 0) 1355 goto err; 1356 1357 ret = devm_snd_soc_register_card(dev, card); 1358 err: 1359 if (ret < 0) 1360 dev_err_probe(dev, ret, "parse error\n"); 1361 1362 return ret; 1363 } 1364 EXPORT_SYMBOL_GPL(audio_graph2_parse_of); 1365 1366 static int graph_probe(struct platform_device *pdev) 1367 { 1368 struct simple_util_priv *priv; 1369 struct device *dev = &pdev->dev; 1370 1371 /* Allocate the private data and the DAI link array */ 1372 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 1373 if (!priv) 1374 return -ENOMEM; 1375 1376 return audio_graph2_parse_of(priv, dev, NULL); 1377 } 1378 1379 static const struct of_device_id graph_of_match[] = { 1380 { .compatible = "audio-graph-card2", }, 1381 {}, 1382 }; 1383 MODULE_DEVICE_TABLE(of, graph_of_match); 1384 1385 static struct platform_driver graph_card = { 1386 .driver = { 1387 .name = "asoc-audio-graph-card2", 1388 .pm = &snd_soc_pm_ops, 1389 .of_match_table = graph_of_match, 1390 }, 1391 .probe = graph_probe, 1392 .remove = simple_util_remove, 1393 }; 1394 module_platform_driver(graph_card); 1395 1396 MODULE_ALIAS("platform:asoc-audio-graph-card2"); 1397 MODULE_LICENSE("GPL v2"); 1398 MODULE_DESCRIPTION("ASoC Audio Graph Card2"); 1399 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 1400