1 // SPDX-License-Identifier: GPL-2.0+ 2 // 3 // soc-core.c -- ALSA SoC Audio Layer 4 // 5 // Copyright 2005 Wolfson Microelectronics PLC. 6 // Copyright 2005 Openedhand Ltd. 7 // Copyright (C) 2010 Slimlogic Ltd. 8 // Copyright (C) 2010 Texas Instruments Inc. 9 // 10 // Author: Liam Girdwood <lrg@slimlogic.co.uk> 11 // with code, comments and ideas from :- 12 // Richard Purdie <richard@openedhand.com> 13 // 14 // TODO: 15 // o Add hw rules to enforce rates, etc. 16 // o More testing with other codecs/machines. 17 // o Add more codecs and platforms to ensure good API coverage. 18 // o Support TDM on PCM and I2S 19 20 #include <linux/module.h> 21 #include <linux/moduleparam.h> 22 #include <linux/init.h> 23 #include <linux/delay.h> 24 #include <linux/pm.h> 25 #include <linux/bitops.h> 26 #include <linux/debugfs.h> 27 #include <linux/platform_device.h> 28 #include <linux/pinctrl/consumer.h> 29 #include <linux/ctype.h> 30 #include <linux/slab.h> 31 #include <linux/of.h> 32 #include <linux/of_graph.h> 33 #include <linux/dmi.h> 34 #include <linux/acpi.h> 35 #include <linux/string_choices.h> 36 #include <sound/core.h> 37 #include <sound/pcm.h> 38 #include <sound/pcm_params.h> 39 #include <sound/soc.h> 40 #include <sound/soc-dpcm.h> 41 #include <sound/soc-topology.h> 42 #include <sound/soc-link.h> 43 #include <sound/initval.h> 44 45 #define CREATE_TRACE_POINTS 46 #include <trace/events/asoc.h> 47 48 static DEFINE_MUTEX(client_mutex); 49 static LIST_HEAD(component_list); 50 static LIST_HEAD(unbind_card_list); 51 52 #define for_each_component(component) \ 53 list_for_each_entry(component, &component_list, list) 54 55 /* 56 * This is used if driver don't need to have CPU/Codec/Platform 57 * dai_link. see soc.h 58 */ 59 struct snd_soc_dai_link_component null_dailink_component[0]; 60 EXPORT_SYMBOL_GPL(null_dailink_component); 61 62 /* 63 * This is a timeout to do a DAPM powerdown after a stream is closed(). 64 * It can be used to eliminate pops between different playback streams, e.g. 65 * between two audio tracks. 66 */ 67 static int pmdown_time = 5000; 68 module_param(pmdown_time, int, 0); 69 MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)"); 70 71 static ssize_t pmdown_time_show(struct device *dev, 72 struct device_attribute *attr, char *buf) 73 { 74 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev); 75 76 return sysfs_emit(buf, "%ld\n", rtd->pmdown_time); 77 } 78 79 static ssize_t pmdown_time_store(struct device *dev, 80 struct device_attribute *attr, 81 const char *buf, size_t count) 82 { 83 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev); 84 int ret; 85 86 ret = kstrtol(buf, 10, &rtd->pmdown_time); 87 if (ret) 88 return ret; 89 90 return count; 91 } 92 93 static DEVICE_ATTR_RW(pmdown_time); 94 95 static struct attribute *soc_dev_attrs[] = { 96 &dev_attr_pmdown_time.attr, 97 NULL 98 }; 99 100 static umode_t soc_dev_attr_is_visible(struct kobject *kobj, 101 struct attribute *attr, int idx) 102 { 103 struct device *dev = kobj_to_dev(kobj); 104 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev); 105 106 if (!rtd) 107 return 0; 108 109 if (attr == &dev_attr_pmdown_time.attr) 110 return attr->mode; /* always visible */ 111 return rtd->dai_link->num_codecs ? attr->mode : 0; /* enabled only with codec */ 112 } 113 114 static const struct attribute_group soc_dapm_dev_group = { 115 .attrs = soc_dapm_dev_attrs, 116 .is_visible = soc_dev_attr_is_visible, 117 }; 118 119 static const struct attribute_group soc_dev_group = { 120 .attrs = soc_dev_attrs, 121 .is_visible = soc_dev_attr_is_visible, 122 }; 123 124 static const struct attribute_group *soc_dev_attr_groups[] = { 125 &soc_dapm_dev_group, 126 &soc_dev_group, 127 NULL 128 }; 129 130 #ifdef CONFIG_DEBUG_FS 131 struct dentry *snd_soc_debugfs_root; 132 EXPORT_SYMBOL_GPL(snd_soc_debugfs_root); 133 134 static void soc_init_component_debugfs(struct snd_soc_component *component) 135 { 136 if (!component->card->debugfs_card_root) 137 return; 138 139 if (component->debugfs_prefix) { 140 char *name; 141 142 name = kasprintf(GFP_KERNEL, "%s:%s", 143 component->debugfs_prefix, component->name); 144 if (name) { 145 component->debugfs_root = debugfs_create_dir(name, 146 component->card->debugfs_card_root); 147 kfree(name); 148 } 149 } else { 150 component->debugfs_root = debugfs_create_dir(component->name, 151 component->card->debugfs_card_root); 152 } 153 154 snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component), 155 component->debugfs_root); 156 } 157 158 static void soc_cleanup_component_debugfs(struct snd_soc_component *component) 159 { 160 if (!component->debugfs_root) 161 return; 162 debugfs_remove_recursive(component->debugfs_root); 163 component->debugfs_root = NULL; 164 } 165 166 static int dai_list_show(struct seq_file *m, void *v) 167 { 168 struct snd_soc_component *component; 169 struct snd_soc_dai *dai; 170 171 mutex_lock(&client_mutex); 172 173 for_each_component(component) 174 for_each_component_dais(component, dai) 175 seq_printf(m, "%s\n", dai->name); 176 177 mutex_unlock(&client_mutex); 178 179 return 0; 180 } 181 DEFINE_SHOW_ATTRIBUTE(dai_list); 182 183 static int component_list_show(struct seq_file *m, void *v) 184 { 185 struct snd_soc_component *component; 186 187 mutex_lock(&client_mutex); 188 189 for_each_component(component) 190 seq_printf(m, "%s\n", component->name); 191 192 mutex_unlock(&client_mutex); 193 194 return 0; 195 } 196 DEFINE_SHOW_ATTRIBUTE(component_list); 197 198 static void soc_init_card_debugfs(struct snd_soc_card *card) 199 { 200 card->debugfs_card_root = debugfs_create_dir(card->name, 201 snd_soc_debugfs_root); 202 203 debugfs_create_u32("dapm_pop_time", 0644, card->debugfs_card_root, 204 &card->pop_time); 205 206 snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root); 207 } 208 209 static void soc_cleanup_card_debugfs(struct snd_soc_card *card) 210 { 211 debugfs_remove_recursive(card->debugfs_card_root); 212 card->debugfs_card_root = NULL; 213 } 214 215 static void snd_soc_debugfs_init(void) 216 { 217 snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL); 218 219 debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL, 220 &dai_list_fops); 221 222 debugfs_create_file("components", 0444, snd_soc_debugfs_root, NULL, 223 &component_list_fops); 224 } 225 226 static void snd_soc_debugfs_exit(void) 227 { 228 debugfs_remove_recursive(snd_soc_debugfs_root); 229 } 230 231 #else 232 233 static inline void soc_init_component_debugfs(struct snd_soc_component *component) { } 234 static inline void soc_cleanup_component_debugfs(struct snd_soc_component *component) { } 235 static inline void soc_init_card_debugfs(struct snd_soc_card *card) { } 236 static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card) { } 237 static inline void snd_soc_debugfs_init(void) { } 238 static inline void snd_soc_debugfs_exit(void) { } 239 240 #endif 241 242 static int snd_soc_is_match_dai_args(const struct of_phandle_args *args1, 243 const struct of_phandle_args *args2) 244 { 245 if (!args1 || !args2) 246 return 0; 247 248 if (args1->np != args2->np) 249 return 0; 250 251 for (int i = 0; i < args1->args_count; i++) 252 if (args1->args[i] != args2->args[i]) 253 return 0; 254 255 return 1; 256 } 257 258 static inline int snd_soc_dlc_component_is_empty(struct snd_soc_dai_link_component *dlc) 259 { 260 return !(dlc->dai_args || dlc->name || dlc->of_node); 261 } 262 263 static inline int snd_soc_dlc_component_is_invalid(struct snd_soc_dai_link_component *dlc) 264 { 265 return (dlc->name && dlc->of_node); 266 } 267 268 static inline int snd_soc_dlc_dai_is_empty(struct snd_soc_dai_link_component *dlc) 269 { 270 return !(dlc->dai_args || dlc->dai_name); 271 } 272 273 static int snd_soc_is_matching_dai(const struct snd_soc_dai_link_component *dlc, 274 struct snd_soc_dai *dai) 275 { 276 if (!dlc) 277 return 0; 278 279 if (dlc->dai_args) 280 return snd_soc_is_match_dai_args(dai->driver->dai_args, dlc->dai_args); 281 282 if (!dlc->dai_name) 283 return 1; 284 285 /* see snd_soc_dai_name_get() */ 286 287 if (dai->driver->name && 288 strcmp(dlc->dai_name, dai->driver->name) == 0) 289 return 1; 290 291 if (strcmp(dlc->dai_name, dai->name) == 0) 292 return 1; 293 294 if (dai->component->name && 295 strcmp(dlc->dai_name, dai->component->name) == 0) 296 return 1; 297 298 return 0; 299 } 300 301 const char *snd_soc_dai_name_get(const struct snd_soc_dai *dai) 302 { 303 /* see snd_soc_is_matching_dai() */ 304 if (dai->driver->name) 305 return dai->driver->name; 306 307 if (dai->name) 308 return dai->name; 309 310 if (dai->component->name) 311 return dai->component->name; 312 313 return NULL; 314 } 315 EXPORT_SYMBOL_GPL(snd_soc_dai_name_get); 316 317 static int snd_soc_rtd_add_component(struct snd_soc_pcm_runtime *rtd, 318 struct snd_soc_component *component) 319 { 320 struct snd_soc_component *comp; 321 int i; 322 323 for_each_rtd_components(rtd, i, comp) { 324 /* already connected */ 325 if (comp == component) 326 return 0; 327 } 328 329 /* see for_each_rtd_components */ 330 rtd->num_components++; // increment flex array count at first 331 rtd->components[rtd->num_components - 1] = component; 332 333 return 0; 334 } 335 336 struct snd_soc_component *snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd, 337 const char *driver_name) 338 { 339 struct snd_soc_component *component; 340 int i; 341 342 if (!driver_name) 343 return NULL; 344 345 /* 346 * NOTE 347 * 348 * snd_soc_rtdcom_lookup() will find component from rtd by using 349 * specified driver name. 350 * But, if many components which have same driver name are connected 351 * to 1 rtd, this function will return 1st found component. 352 */ 353 for_each_rtd_components(rtd, i, component) { 354 const char *component_name = component->driver->name; 355 356 if (!component_name) 357 continue; 358 359 if ((component_name == driver_name) || 360 strcmp(component_name, driver_name) == 0) 361 return component; 362 } 363 364 return NULL; 365 } 366 EXPORT_SYMBOL_GPL(snd_soc_rtdcom_lookup); 367 368 struct snd_soc_component 369 *snd_soc_lookup_component_nolocked(struct device *dev, const char *driver_name) 370 { 371 struct snd_soc_component *component; 372 struct snd_soc_component *found_component; 373 374 found_component = NULL; 375 for_each_component(component) { 376 if ((dev == component->dev) && 377 (!driver_name || 378 (driver_name == component->driver->name) || 379 (strcmp(component->driver->name, driver_name) == 0))) { 380 found_component = component; 381 break; 382 } 383 } 384 385 return found_component; 386 } 387 EXPORT_SYMBOL_GPL(snd_soc_lookup_component_nolocked); 388 389 struct snd_soc_component *snd_soc_lookup_component(struct device *dev, 390 const char *driver_name) 391 { 392 struct snd_soc_component *component; 393 394 mutex_lock(&client_mutex); 395 component = snd_soc_lookup_component_nolocked(dev, driver_name); 396 mutex_unlock(&client_mutex); 397 398 return component; 399 } 400 EXPORT_SYMBOL_GPL(snd_soc_lookup_component); 401 402 struct snd_soc_pcm_runtime 403 *snd_soc_get_pcm_runtime(struct snd_soc_card *card, 404 struct snd_soc_dai_link *dai_link) 405 { 406 struct snd_soc_pcm_runtime *rtd; 407 408 for_each_card_rtds(card, rtd) { 409 if (rtd->dai_link == dai_link) 410 return rtd; 411 } 412 dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link->name); 413 return NULL; 414 } 415 EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime); 416 417 /* 418 * Power down the audio subsystem pmdown_time msecs after close is called. 419 * This is to ensure there are no pops or clicks in between any music tracks 420 * due to DAPM power cycling. 421 */ 422 void snd_soc_close_delayed_work(struct snd_soc_pcm_runtime *rtd) 423 { 424 struct snd_soc_dai *codec_dai = snd_soc_rtd_to_codec(rtd, 0); 425 int playback = SNDRV_PCM_STREAM_PLAYBACK; 426 427 snd_soc_dpcm_mutex_lock(rtd); 428 429 dev_dbg(rtd->dev, 430 "ASoC: pop wq checking: %s status: %s waiting: %s\n", 431 codec_dai->driver->playback.stream_name, 432 snd_soc_dai_stream_active(codec_dai, playback) ? 433 "active" : "inactive", 434 str_yes_no(rtd->pop_wait)); 435 436 /* are we waiting on this codec DAI stream */ 437 if (rtd->pop_wait == 1) { 438 rtd->pop_wait = 0; 439 snd_soc_dapm_stream_event(rtd, playback, 440 SND_SOC_DAPM_STREAM_STOP); 441 } 442 443 snd_soc_dpcm_mutex_unlock(rtd); 444 } 445 EXPORT_SYMBOL_GPL(snd_soc_close_delayed_work); 446 447 static void soc_release_rtd_dev(struct device *dev) 448 { 449 /* "dev" means "rtd->dev" */ 450 kfree(dev); 451 } 452 453 static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd) 454 { 455 if (!rtd) 456 return; 457 458 list_del(&rtd->list); 459 460 if (delayed_work_pending(&rtd->delayed_work)) 461 flush_delayed_work(&rtd->delayed_work); 462 snd_soc_pcm_component_free(rtd); 463 464 /* 465 * we don't need to call kfree() for rtd->dev 466 * see 467 * soc_release_rtd_dev() 468 * 469 * We don't need rtd->dev NULL check, because 470 * it is alloced *before* rtd. 471 * see 472 * soc_new_pcm_runtime() 473 * 474 * We don't need to mind freeing for rtd, 475 * because it was created from dev (= rtd->dev) 476 * see 477 * soc_new_pcm_runtime() 478 * 479 * rtd = devm_kzalloc(dev, ...); 480 * rtd->dev = dev 481 */ 482 device_unregister(rtd->dev); 483 } 484 485 static void close_delayed_work(struct work_struct *work) { 486 struct snd_soc_pcm_runtime *rtd = 487 container_of(work, struct snd_soc_pcm_runtime, 488 delayed_work.work); 489 490 if (rtd->close_delayed_work_func) 491 rtd->close_delayed_work_func(rtd); 492 } 493 494 static struct snd_soc_pcm_runtime *soc_new_pcm_runtime( 495 struct snd_soc_card *card, struct snd_soc_dai_link *dai_link) 496 { 497 struct snd_soc_pcm_runtime *rtd; 498 struct device *dev; 499 int ret; 500 int stream; 501 502 /* 503 * for rtd->dev 504 */ 505 dev = kzalloc(sizeof(struct device), GFP_KERNEL); 506 if (!dev) 507 return NULL; 508 509 dev->parent = card->dev; 510 dev->release = soc_release_rtd_dev; 511 512 dev_set_name(dev, "%s", dai_link->name); 513 514 ret = device_register(dev); 515 if (ret < 0) { 516 put_device(dev); /* soc_release_rtd_dev */ 517 return NULL; 518 } 519 520 /* 521 * for rtd 522 */ 523 rtd = devm_kzalloc(dev, 524 struct_size(rtd, components, 525 dai_link->num_cpus + 526 dai_link->num_codecs + 527 dai_link->num_platforms), 528 GFP_KERNEL); 529 if (!rtd) { 530 device_unregister(dev); 531 return NULL; 532 } 533 534 rtd->dev = dev; 535 INIT_LIST_HEAD(&rtd->list); 536 for_each_pcm_streams(stream) { 537 INIT_LIST_HEAD(&rtd->dpcm[stream].be_clients); 538 INIT_LIST_HEAD(&rtd->dpcm[stream].fe_clients); 539 } 540 dev_set_drvdata(dev, rtd); 541 INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work); 542 543 /* 544 * for rtd->dais 545 */ 546 rtd->dais = devm_kcalloc(dev, dai_link->num_cpus + dai_link->num_codecs, 547 sizeof(struct snd_soc_dai *), 548 GFP_KERNEL); 549 if (!rtd->dais) 550 goto free_rtd; 551 552 /* 553 * dais = [][][][][][][][][][][][][][][][][][] 554 * ^cpu_dais ^codec_dais 555 * |--- num_cpus ---|--- num_codecs --| 556 * see 557 * snd_soc_rtd_to_cpu() 558 * snd_soc_rtd_to_codec() 559 */ 560 rtd->card = card; 561 rtd->dai_link = dai_link; 562 rtd->id = card->num_rtd++; 563 rtd->pmdown_time = pmdown_time; /* default power off timeout */ 564 565 /* see for_each_card_rtds */ 566 list_add_tail(&rtd->list, &card->rtd_list); 567 568 ret = device_add_groups(dev, soc_dev_attr_groups); 569 if (ret < 0) 570 goto free_rtd; 571 572 return rtd; 573 574 free_rtd: 575 soc_free_pcm_runtime(rtd); 576 return NULL; 577 } 578 579 static void snd_soc_fill_dummy_dai(struct snd_soc_card *card) 580 { 581 struct snd_soc_dai_link *dai_link; 582 int i; 583 584 /* 585 * COMP_DUMMY() creates size 0 array on dai_link. 586 * Fill it as dummy DAI in case of CPU/Codec here. 587 * Do nothing for Platform. 588 */ 589 for_each_card_prelinks(card, i, dai_link) { 590 if (dai_link->num_cpus == 0 && dai_link->cpus) { 591 dai_link->num_cpus = 1; 592 dai_link->cpus = &snd_soc_dummy_dlc; 593 } 594 if (dai_link->num_codecs == 0 && dai_link->codecs) { 595 dai_link->num_codecs = 1; 596 dai_link->codecs = &snd_soc_dummy_dlc; 597 } 598 } 599 } 600 601 static void snd_soc_flush_all_delayed_work(struct snd_soc_card *card) 602 { 603 struct snd_soc_pcm_runtime *rtd; 604 605 for_each_card_rtds(card, rtd) 606 flush_delayed_work(&rtd->delayed_work); 607 } 608 609 #ifdef CONFIG_PM_SLEEP 610 static void soc_playback_digital_mute(struct snd_soc_card *card, int mute) 611 { 612 struct snd_soc_pcm_runtime *rtd; 613 struct snd_soc_dai *dai; 614 int playback = SNDRV_PCM_STREAM_PLAYBACK; 615 int i; 616 617 for_each_card_rtds(card, rtd) { 618 619 if (rtd->dai_link->ignore_suspend) 620 continue; 621 622 for_each_rtd_dais(rtd, i, dai) { 623 if (snd_soc_dai_stream_active(dai, playback)) 624 snd_soc_dai_digital_mute(dai, mute, playback); 625 } 626 } 627 } 628 629 static void soc_dapm_suspend_resume(struct snd_soc_card *card, int event) 630 { 631 struct snd_soc_pcm_runtime *rtd; 632 int stream; 633 634 for_each_card_rtds(card, rtd) { 635 636 if (rtd->dai_link->ignore_suspend) 637 continue; 638 639 for_each_pcm_streams(stream) 640 snd_soc_dapm_stream_event(rtd, stream, event); 641 } 642 } 643 644 /* powers down audio subsystem for suspend */ 645 int snd_soc_suspend(struct device *dev) 646 { 647 struct snd_soc_card *card = dev_get_drvdata(dev); 648 struct snd_soc_component *component; 649 struct snd_soc_pcm_runtime *rtd; 650 int i; 651 652 /* If the card is not initialized yet there is nothing to do */ 653 if (!snd_soc_card_is_instantiated(card)) 654 return 0; 655 656 /* 657 * Due to the resume being scheduled into a workqueue we could 658 * suspend before that's finished - wait for it to complete. 659 */ 660 snd_power_wait(card->snd_card); 661 662 /* we're going to block userspace touching us until resume completes */ 663 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot); 664 665 /* mute any active DACs */ 666 soc_playback_digital_mute(card, 1); 667 668 /* suspend all pcms */ 669 for_each_card_rtds(card, rtd) { 670 if (rtd->dai_link->ignore_suspend) 671 continue; 672 673 snd_pcm_suspend_all(rtd->pcm); 674 } 675 676 snd_soc_card_suspend_pre(card); 677 678 /* close any waiting streams */ 679 snd_soc_flush_all_delayed_work(card); 680 681 soc_dapm_suspend_resume(card, SND_SOC_DAPM_STREAM_SUSPEND); 682 683 /* Recheck all endpoints too, their state is affected by suspend */ 684 dapm_mark_endpoints_dirty(card); 685 snd_soc_dapm_sync(&card->dapm); 686 687 /* suspend all COMPONENTs */ 688 for_each_card_rtds(card, rtd) { 689 690 if (rtd->dai_link->ignore_suspend) 691 continue; 692 693 for_each_rtd_components(rtd, i, component) { 694 struct snd_soc_dapm_context *dapm = 695 snd_soc_component_get_dapm(component); 696 697 /* 698 * ignore if component was already suspended 699 */ 700 if (snd_soc_component_is_suspended(component)) 701 continue; 702 703 /* 704 * If there are paths active then the COMPONENT will be 705 * held with bias _ON and should not be suspended. 706 */ 707 switch (snd_soc_dapm_get_bias_level(dapm)) { 708 case SND_SOC_BIAS_STANDBY: 709 /* 710 * If the COMPONENT is capable of idle 711 * bias off then being in STANDBY 712 * means it's doing something, 713 * otherwise fall through. 714 */ 715 if (dapm->idle_bias_off) { 716 dev_dbg(component->dev, 717 "ASoC: idle_bias_off CODEC on over suspend\n"); 718 break; 719 } 720 fallthrough; 721 722 case SND_SOC_BIAS_OFF: 723 snd_soc_component_suspend(component); 724 if (component->regmap) 725 regcache_mark_dirty(component->regmap); 726 /* deactivate pins to sleep state */ 727 pinctrl_pm_select_sleep_state(component->dev); 728 break; 729 default: 730 dev_dbg(component->dev, 731 "ASoC: COMPONENT is on over suspend\n"); 732 break; 733 } 734 } 735 } 736 737 snd_soc_card_suspend_post(card); 738 739 return 0; 740 } 741 EXPORT_SYMBOL_GPL(snd_soc_suspend); 742 743 /* 744 * deferred resume work, so resume can complete before we finished 745 * setting our codec back up, which can be very slow on I2C 746 */ 747 static void soc_resume_deferred(struct work_struct *work) 748 { 749 struct snd_soc_card *card = 750 container_of(work, struct snd_soc_card, 751 deferred_resume_work); 752 struct snd_soc_component *component; 753 754 /* 755 * our power state is still SNDRV_CTL_POWER_D3hot from suspend time, 756 * so userspace apps are blocked from touching us 757 */ 758 759 dev_dbg(card->dev, "ASoC: starting resume work\n"); 760 761 /* Bring us up into D2 so that DAPM starts enabling things */ 762 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2); 763 764 snd_soc_card_resume_pre(card); 765 766 for_each_card_components(card, component) { 767 if (snd_soc_component_is_suspended(component)) 768 snd_soc_component_resume(component); 769 } 770 771 soc_dapm_suspend_resume(card, SND_SOC_DAPM_STREAM_RESUME); 772 773 /* unmute any active DACs */ 774 soc_playback_digital_mute(card, 0); 775 776 snd_soc_card_resume_post(card); 777 778 dev_dbg(card->dev, "ASoC: resume work completed\n"); 779 780 /* Recheck all endpoints too, their state is affected by suspend */ 781 dapm_mark_endpoints_dirty(card); 782 snd_soc_dapm_sync(&card->dapm); 783 784 /* userspace can access us now we are back as we were before */ 785 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0); 786 } 787 788 /* powers up audio subsystem after a suspend */ 789 int snd_soc_resume(struct device *dev) 790 { 791 struct snd_soc_card *card = dev_get_drvdata(dev); 792 struct snd_soc_component *component; 793 794 /* If the card is not initialized yet there is nothing to do */ 795 if (!snd_soc_card_is_instantiated(card)) 796 return 0; 797 798 /* activate pins from sleep state */ 799 for_each_card_components(card, component) 800 if (snd_soc_component_active(component)) 801 pinctrl_pm_select_default_state(component->dev); 802 803 dev_dbg(dev, "ASoC: Scheduling resume work\n"); 804 if (!schedule_work(&card->deferred_resume_work)) 805 dev_err(dev, "ASoC: resume work item may be lost\n"); 806 807 return 0; 808 } 809 EXPORT_SYMBOL_GPL(snd_soc_resume); 810 811 static void soc_resume_init(struct snd_soc_card *card) 812 { 813 /* deferred resume work */ 814 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred); 815 } 816 #else 817 #define snd_soc_suspend NULL 818 #define snd_soc_resume NULL 819 static inline void soc_resume_init(struct snd_soc_card *card) { } 820 #endif 821 822 static struct device_node 823 *soc_component_to_node(struct snd_soc_component *component) 824 { 825 struct device_node *of_node; 826 827 of_node = component->dev->of_node; 828 if (!of_node && component->dev->parent) 829 of_node = component->dev->parent->of_node; 830 831 return of_node; 832 } 833 834 struct of_phandle_args *snd_soc_copy_dai_args(struct device *dev, 835 const struct of_phandle_args *args) 836 { 837 struct of_phandle_args *ret = devm_kzalloc(dev, sizeof(*ret), GFP_KERNEL); 838 839 if (!ret) 840 return NULL; 841 842 *ret = *args; 843 844 return ret; 845 } 846 EXPORT_SYMBOL_GPL(snd_soc_copy_dai_args); 847 848 static int snd_soc_is_matching_component( 849 const struct snd_soc_dai_link_component *dlc, 850 struct snd_soc_component *component) 851 { 852 struct device_node *component_of_node; 853 854 if (!dlc) 855 return 0; 856 857 if (dlc->dai_args) { 858 struct snd_soc_dai *dai; 859 860 for_each_component_dais(component, dai) 861 if (snd_soc_is_matching_dai(dlc, dai)) 862 return 1; 863 return 0; 864 } 865 866 component_of_node = soc_component_to_node(component); 867 868 if (dlc->of_node && component_of_node != dlc->of_node) 869 return 0; 870 if (dlc->name && strcmp(component->name, dlc->name)) 871 return 0; 872 873 return 1; 874 } 875 876 static struct snd_soc_component *soc_find_component( 877 const struct snd_soc_dai_link_component *dlc) 878 { 879 struct snd_soc_component *component; 880 881 lockdep_assert_held(&client_mutex); 882 883 /* 884 * NOTE 885 * 886 * It returns *1st* found component, but some driver 887 * has few components by same of_node/name 888 * ex) 889 * CPU component and generic DMAEngine component 890 */ 891 for_each_component(component) 892 if (snd_soc_is_matching_component(dlc, component)) 893 return component; 894 895 return NULL; 896 } 897 898 /** 899 * snd_soc_find_dai - Find a registered DAI 900 * 901 * @dlc: name of the DAI or the DAI driver and optional component info to match 902 * 903 * This function will search all registered components and their DAIs to 904 * find the DAI of the same name. The component's of_node and name 905 * should also match if being specified. 906 * 907 * Return: pointer of DAI, or NULL if not found. 908 */ 909 struct snd_soc_dai *snd_soc_find_dai( 910 const struct snd_soc_dai_link_component *dlc) 911 { 912 struct snd_soc_component *component; 913 struct snd_soc_dai *dai; 914 915 lockdep_assert_held(&client_mutex); 916 917 /* Find CPU DAI from registered DAIs */ 918 for_each_component(component) 919 if (snd_soc_is_matching_component(dlc, component)) 920 for_each_component_dais(component, dai) 921 if (snd_soc_is_matching_dai(dlc, dai)) 922 return dai; 923 924 return NULL; 925 } 926 EXPORT_SYMBOL_GPL(snd_soc_find_dai); 927 928 struct snd_soc_dai *snd_soc_find_dai_with_mutex( 929 const struct snd_soc_dai_link_component *dlc) 930 { 931 struct snd_soc_dai *dai; 932 933 mutex_lock(&client_mutex); 934 dai = snd_soc_find_dai(dlc); 935 mutex_unlock(&client_mutex); 936 937 return dai; 938 } 939 EXPORT_SYMBOL_GPL(snd_soc_find_dai_with_mutex); 940 941 static int soc_dai_link_sanity_check(struct snd_soc_card *card, 942 struct snd_soc_dai_link *link) 943 { 944 int i; 945 struct snd_soc_dai_link_component *dlc; 946 947 /* Codec check */ 948 for_each_link_codecs(link, i, dlc) { 949 /* 950 * Codec must be specified by 1 of name or OF node, 951 * not both or neither. 952 */ 953 if (snd_soc_dlc_component_is_invalid(dlc)) 954 goto component_invalid; 955 956 if (snd_soc_dlc_component_is_empty(dlc)) 957 goto component_empty; 958 959 /* Codec DAI name must be specified */ 960 if (snd_soc_dlc_dai_is_empty(dlc)) 961 goto dai_empty; 962 963 /* 964 * Defer card registration if codec component is not added to 965 * component list. 966 */ 967 if (!soc_find_component(dlc)) 968 goto component_not_found; 969 } 970 971 /* Platform check */ 972 for_each_link_platforms(link, i, dlc) { 973 /* 974 * Platform may be specified by either name or OF node, but it 975 * can be left unspecified, then no components will be inserted 976 * in the rtdcom list 977 */ 978 if (snd_soc_dlc_component_is_invalid(dlc)) 979 goto component_invalid; 980 981 if (snd_soc_dlc_component_is_empty(dlc)) 982 goto component_empty; 983 984 /* 985 * Defer card registration if platform component is not added to 986 * component list. 987 */ 988 if (!soc_find_component(dlc)) 989 goto component_not_found; 990 } 991 992 /* CPU check */ 993 for_each_link_cpus(link, i, dlc) { 994 /* 995 * CPU device may be specified by either name or OF node, but 996 * can be left unspecified, and will be matched based on DAI 997 * name alone.. 998 */ 999 if (snd_soc_dlc_component_is_invalid(dlc)) 1000 goto component_invalid; 1001 1002 1003 if (snd_soc_dlc_component_is_empty(dlc)) { 1004 /* 1005 * At least one of CPU DAI name or CPU device name/node must be specified 1006 */ 1007 if (snd_soc_dlc_dai_is_empty(dlc)) 1008 goto component_dai_empty; 1009 } else { 1010 /* 1011 * Defer card registration if Component is not added 1012 */ 1013 if (!soc_find_component(dlc)) 1014 goto component_not_found; 1015 } 1016 } 1017 1018 return 0; 1019 1020 component_invalid: 1021 dev_err(card->dev, "ASoC: Both Component name/of_node are set for %s\n", link->name); 1022 return -EINVAL; 1023 1024 component_empty: 1025 dev_err(card->dev, "ASoC: Neither Component name/of_node are set for %s\n", link->name); 1026 return -EINVAL; 1027 1028 component_not_found: 1029 dev_dbg(card->dev, "ASoC: Component %s not found for link %s\n", dlc->name, link->name); 1030 return -EPROBE_DEFER; 1031 1032 dai_empty: 1033 dev_err(card->dev, "ASoC: DAI name is not set for %s\n", link->name); 1034 return -EINVAL; 1035 1036 component_dai_empty: 1037 dev_err(card->dev, "ASoC: Neither DAI/Component name/of_node are set for %s\n", link->name); 1038 return -EINVAL; 1039 } 1040 1041 #define MAX_DEFAULT_CH_MAP_SIZE 8 1042 static struct snd_soc_dai_link_ch_map default_ch_map_sync[MAX_DEFAULT_CH_MAP_SIZE] = { 1043 { .cpu = 0, .codec = 0 }, 1044 { .cpu = 1, .codec = 1 }, 1045 { .cpu = 2, .codec = 2 }, 1046 { .cpu = 3, .codec = 3 }, 1047 { .cpu = 4, .codec = 4 }, 1048 { .cpu = 5, .codec = 5 }, 1049 { .cpu = 6, .codec = 6 }, 1050 { .cpu = 7, .codec = 7 }, 1051 }; 1052 static struct snd_soc_dai_link_ch_map default_ch_map_1cpu[MAX_DEFAULT_CH_MAP_SIZE] = { 1053 { .cpu = 0, .codec = 0 }, 1054 { .cpu = 0, .codec = 1 }, 1055 { .cpu = 0, .codec = 2 }, 1056 { .cpu = 0, .codec = 3 }, 1057 { .cpu = 0, .codec = 4 }, 1058 { .cpu = 0, .codec = 5 }, 1059 { .cpu = 0, .codec = 6 }, 1060 { .cpu = 0, .codec = 7 }, 1061 }; 1062 static struct snd_soc_dai_link_ch_map default_ch_map_1codec[MAX_DEFAULT_CH_MAP_SIZE] = { 1063 { .cpu = 0, .codec = 0 }, 1064 { .cpu = 1, .codec = 0 }, 1065 { .cpu = 2, .codec = 0 }, 1066 { .cpu = 3, .codec = 0 }, 1067 { .cpu = 4, .codec = 0 }, 1068 { .cpu = 5, .codec = 0 }, 1069 { .cpu = 6, .codec = 0 }, 1070 { .cpu = 7, .codec = 0 }, 1071 }; 1072 static int snd_soc_compensate_channel_connection_map(struct snd_soc_card *card, 1073 struct snd_soc_dai_link *dai_link) 1074 { 1075 struct snd_soc_dai_link_ch_map *ch_maps; 1076 int i; 1077 1078 /* 1079 * dai_link->ch_maps indicates how CPU/Codec are connected. 1080 * It will be a map seen from a larger number of DAI. 1081 * see 1082 * soc.h :: [dai_link->ch_maps Image sample] 1083 */ 1084 1085 /* it should have ch_maps if connection was N:M */ 1086 if (dai_link->num_cpus > 1 && dai_link->num_codecs > 1 && 1087 dai_link->num_cpus != dai_link->num_codecs && !dai_link->ch_maps) { 1088 dev_err(card->dev, "need to have ch_maps when N:M connection (%s)", 1089 dai_link->name); 1090 return -EINVAL; 1091 } 1092 1093 /* do nothing if it has own maps */ 1094 if (dai_link->ch_maps) 1095 goto sanity_check; 1096 1097 /* check default map size */ 1098 if (dai_link->num_cpus > MAX_DEFAULT_CH_MAP_SIZE || 1099 dai_link->num_codecs > MAX_DEFAULT_CH_MAP_SIZE) { 1100 dev_err(card->dev, "soc-core.c needs update default_connection_maps"); 1101 return -EINVAL; 1102 } 1103 1104 /* Compensate missing map for ... */ 1105 if (dai_link->num_cpus == dai_link->num_codecs) 1106 dai_link->ch_maps = default_ch_map_sync; /* for 1:1 or N:N */ 1107 else if (dai_link->num_cpus < dai_link->num_codecs) 1108 dai_link->ch_maps = default_ch_map_1cpu; /* for 1:N */ 1109 else 1110 dai_link->ch_maps = default_ch_map_1codec; /* for N:1 */ 1111 1112 sanity_check: 1113 dev_dbg(card->dev, "dai_link %s\n", dai_link->stream_name); 1114 for_each_link_ch_maps(dai_link, i, ch_maps) { 1115 if ((ch_maps->cpu >= dai_link->num_cpus) || 1116 (ch_maps->codec >= dai_link->num_codecs)) { 1117 dev_err(card->dev, 1118 "unexpected dai_link->ch_maps[%d] index (cpu(%d/%d) codec(%d/%d))", 1119 i, 1120 ch_maps->cpu, dai_link->num_cpus, 1121 ch_maps->codec, dai_link->num_codecs); 1122 return -EINVAL; 1123 } 1124 1125 dev_dbg(card->dev, " [%d] cpu%d <-> codec%d\n", 1126 i, ch_maps->cpu, ch_maps->codec); 1127 } 1128 1129 return 0; 1130 } 1131 1132 /** 1133 * snd_soc_remove_pcm_runtime - Remove a pcm_runtime from card 1134 * @card: The ASoC card to which the pcm_runtime has 1135 * @rtd: The pcm_runtime to remove 1136 * 1137 * This function removes a pcm_runtime from the ASoC card. 1138 */ 1139 void snd_soc_remove_pcm_runtime(struct snd_soc_card *card, 1140 struct snd_soc_pcm_runtime *rtd) 1141 { 1142 lockdep_assert_held(&client_mutex); 1143 1144 /* 1145 * Notify the machine driver for extra destruction 1146 */ 1147 snd_soc_card_remove_dai_link(card, rtd->dai_link); 1148 1149 soc_free_pcm_runtime(rtd); 1150 } 1151 EXPORT_SYMBOL_GPL(snd_soc_remove_pcm_runtime); 1152 1153 /** 1154 * snd_soc_add_pcm_runtime - Add a pcm_runtime dynamically via dai_link 1155 * @card: The ASoC card to which the pcm_runtime is added 1156 * @dai_link: The DAI link to find pcm_runtime 1157 * 1158 * This function adds a pcm_runtime ASoC card by using dai_link. 1159 * 1160 * Note: Topology can use this API to add pcm_runtime when probing the 1161 * topology component. And machine drivers can still define static 1162 * DAI links in dai_link array. 1163 */ 1164 static int snd_soc_add_pcm_runtime(struct snd_soc_card *card, 1165 struct snd_soc_dai_link *dai_link) 1166 { 1167 struct snd_soc_pcm_runtime *rtd; 1168 struct snd_soc_dai_link_component *codec, *platform, *cpu; 1169 struct snd_soc_component *component; 1170 int i, id, ret; 1171 1172 lockdep_assert_held(&client_mutex); 1173 1174 /* 1175 * Notify the machine driver for extra initialization 1176 */ 1177 ret = snd_soc_card_add_dai_link(card, dai_link); 1178 if (ret < 0) 1179 return ret; 1180 1181 if (dai_link->ignore) 1182 return 0; 1183 1184 dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name); 1185 1186 ret = soc_dai_link_sanity_check(card, dai_link); 1187 if (ret < 0) 1188 return ret; 1189 1190 rtd = soc_new_pcm_runtime(card, dai_link); 1191 if (!rtd) 1192 return -ENOMEM; 1193 1194 for_each_link_cpus(dai_link, i, cpu) { 1195 snd_soc_rtd_to_cpu(rtd, i) = snd_soc_find_dai(cpu); 1196 if (!snd_soc_rtd_to_cpu(rtd, i)) { 1197 dev_info(card->dev, "ASoC: CPU DAI %s not registered\n", 1198 cpu->dai_name); 1199 goto _err_defer; 1200 } 1201 snd_soc_rtd_add_component(rtd, snd_soc_rtd_to_cpu(rtd, i)->component); 1202 } 1203 1204 /* Find CODEC from registered CODECs */ 1205 for_each_link_codecs(dai_link, i, codec) { 1206 snd_soc_rtd_to_codec(rtd, i) = snd_soc_find_dai(codec); 1207 if (!snd_soc_rtd_to_codec(rtd, i)) { 1208 dev_info(card->dev, "ASoC: CODEC DAI %s not registered\n", 1209 codec->dai_name); 1210 goto _err_defer; 1211 } 1212 1213 snd_soc_rtd_add_component(rtd, snd_soc_rtd_to_codec(rtd, i)->component); 1214 } 1215 1216 /* Find PLATFORM from registered PLATFORMs */ 1217 for_each_link_platforms(dai_link, i, platform) { 1218 for_each_component(component) { 1219 if (!snd_soc_is_matching_component(platform, component)) 1220 continue; 1221 1222 if (snd_soc_component_is_dummy(component) && component->num_dai) 1223 continue; 1224 1225 snd_soc_rtd_add_component(rtd, component); 1226 } 1227 } 1228 1229 /* 1230 * Most drivers will register their PCMs using DAI link ordering but 1231 * topology based drivers can use the DAI link id field to set PCM 1232 * device number and then use rtd + a base offset of the BEs. 1233 * 1234 * FIXME 1235 * 1236 * This should be implemented by using "dai_link" feature instead of 1237 * "component" feature. 1238 */ 1239 id = rtd->id; 1240 for_each_rtd_components(rtd, i, component) { 1241 if (!component->driver->use_dai_pcm_id) 1242 continue; 1243 1244 if (rtd->dai_link->no_pcm) 1245 id += component->driver->be_pcm_base; 1246 else 1247 id = rtd->dai_link->id; 1248 } 1249 rtd->id = id; 1250 1251 return 0; 1252 1253 _err_defer: 1254 snd_soc_remove_pcm_runtime(card, rtd); 1255 return -EPROBE_DEFER; 1256 } 1257 1258 int snd_soc_add_pcm_runtimes(struct snd_soc_card *card, 1259 struct snd_soc_dai_link *dai_link, 1260 int num_dai_link) 1261 { 1262 for (int i = 0; i < num_dai_link; i++) { 1263 int ret; 1264 1265 ret = snd_soc_compensate_channel_connection_map(card, dai_link + i); 1266 if (ret < 0) 1267 return ret; 1268 1269 ret = snd_soc_add_pcm_runtime(card, dai_link + i); 1270 if (ret < 0) 1271 return ret; 1272 } 1273 1274 return 0; 1275 } 1276 EXPORT_SYMBOL_GPL(snd_soc_add_pcm_runtimes); 1277 1278 static void snd_soc_runtime_get_dai_fmt(struct snd_soc_pcm_runtime *rtd) 1279 { 1280 struct snd_soc_dai_link *dai_link = rtd->dai_link; 1281 struct snd_soc_dai *dai, *not_used; 1282 u64 pos, possible_fmt; 1283 unsigned int mask = 0, dai_fmt = 0; 1284 int i, j, priority, pri, until; 1285 1286 /* 1287 * Get selectable format from each DAIs. 1288 * 1289 **************************** 1290 * NOTE 1291 * Using .auto_selectable_formats is not mandatory, 1292 * we can select format manually from Sound Card. 1293 * When use it, driver should list well tested format only. 1294 **************************** 1295 * 1296 * ex) 1297 * auto_selectable_formats (= SND_SOC_POSSIBLE_xxx) 1298 * (A) (B) (C) 1299 * DAI0_: { 0x000F, 0x00F0, 0x0F00 }; 1300 * DAI1 : { 0xF000, 0x0F00 }; 1301 * (X) (Y) 1302 * 1303 * "until" will be 3 in this case (MAX array size from DAI0 and DAI1) 1304 * Here is dev_dbg() message and comments 1305 * 1306 * priority = 1 1307 * DAI0: (pri, fmt) = (1, 000000000000000F) // 1st check (A) DAI1 is not selected 1308 * DAI1: (pri, fmt) = (0, 0000000000000000) // Necessary Waste 1309 * DAI0: (pri, fmt) = (1, 000000000000000F) // 2nd check (A) 1310 * DAI1: (pri, fmt) = (1, 000000000000F000) // (X) 1311 * priority = 2 1312 * DAI0: (pri, fmt) = (2, 00000000000000FF) // 3rd check (A) + (B) 1313 * DAI1: (pri, fmt) = (1, 000000000000F000) // (X) 1314 * DAI0: (pri, fmt) = (2, 00000000000000FF) // 4th check (A) + (B) 1315 * DAI1: (pri, fmt) = (2, 000000000000FF00) // (X) + (Y) 1316 * priority = 3 1317 * DAI0: (pri, fmt) = (3, 0000000000000FFF) // 5th check (A) + (B) + (C) 1318 * DAI1: (pri, fmt) = (2, 000000000000FF00) // (X) + (Y) 1319 * found auto selected format: 0000000000000F00 1320 */ 1321 until = snd_soc_dai_get_fmt_max_priority(rtd); 1322 for (priority = 1; priority <= until; priority++) { 1323 for_each_rtd_dais(rtd, j, not_used) { 1324 1325 possible_fmt = ULLONG_MAX; 1326 for_each_rtd_dais(rtd, i, dai) { 1327 u64 fmt = 0; 1328 1329 pri = (j >= i) ? priority : priority - 1; 1330 fmt = snd_soc_dai_get_fmt(dai, pri); 1331 possible_fmt &= fmt; 1332 } 1333 if (possible_fmt) 1334 goto found; 1335 } 1336 } 1337 /* Not Found */ 1338 return; 1339 found: 1340 /* 1341 * convert POSSIBLE_DAIFMT to DAIFMT 1342 * 1343 * Some basic/default settings on each is defined as 0. 1344 * see 1345 * SND_SOC_DAIFMT_NB_NF 1346 * SND_SOC_DAIFMT_GATED 1347 * 1348 * SND_SOC_DAIFMT_xxx_MASK can't notice it if Sound Card specify 1349 * these value, and will be overwrite to auto selected value. 1350 * 1351 * To avoid such issue, loop from 63 to 0 here. 1352 * Small number of SND_SOC_POSSIBLE_xxx will be Hi priority. 1353 * Basic/Default settings of each part and above are defined 1354 * as Hi priority (= small number) of SND_SOC_POSSIBLE_xxx. 1355 */ 1356 for (i = 63; i >= 0; i--) { 1357 pos = 1ULL << i; 1358 switch (possible_fmt & pos) { 1359 /* 1360 * for format 1361 */ 1362 case SND_SOC_POSSIBLE_DAIFMT_I2S: 1363 case SND_SOC_POSSIBLE_DAIFMT_RIGHT_J: 1364 case SND_SOC_POSSIBLE_DAIFMT_LEFT_J: 1365 case SND_SOC_POSSIBLE_DAIFMT_DSP_A: 1366 case SND_SOC_POSSIBLE_DAIFMT_DSP_B: 1367 case SND_SOC_POSSIBLE_DAIFMT_AC97: 1368 case SND_SOC_POSSIBLE_DAIFMT_PDM: 1369 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_FORMAT_MASK) | i; 1370 break; 1371 /* 1372 * for clock 1373 */ 1374 case SND_SOC_POSSIBLE_DAIFMT_CONT: 1375 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_MASK) | SND_SOC_DAIFMT_CONT; 1376 break; 1377 case SND_SOC_POSSIBLE_DAIFMT_GATED: 1378 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_MASK) | SND_SOC_DAIFMT_GATED; 1379 break; 1380 /* 1381 * for clock invert 1382 */ 1383 case SND_SOC_POSSIBLE_DAIFMT_NB_NF: 1384 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_NB_NF; 1385 break; 1386 case SND_SOC_POSSIBLE_DAIFMT_NB_IF: 1387 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_NB_IF; 1388 break; 1389 case SND_SOC_POSSIBLE_DAIFMT_IB_NF: 1390 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_IB_NF; 1391 break; 1392 case SND_SOC_POSSIBLE_DAIFMT_IB_IF: 1393 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_IB_IF; 1394 break; 1395 /* 1396 * for clock provider / consumer 1397 */ 1398 case SND_SOC_POSSIBLE_DAIFMT_CBP_CFP: 1399 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBP_CFP; 1400 break; 1401 case SND_SOC_POSSIBLE_DAIFMT_CBC_CFP: 1402 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBC_CFP; 1403 break; 1404 case SND_SOC_POSSIBLE_DAIFMT_CBP_CFC: 1405 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBP_CFC; 1406 break; 1407 case SND_SOC_POSSIBLE_DAIFMT_CBC_CFC: 1408 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBC_CFC; 1409 break; 1410 } 1411 } 1412 1413 /* 1414 * Some driver might have very complex limitation. 1415 * In such case, user want to auto-select non-limitation part, 1416 * and want to manually specify complex part. 1417 * 1418 * Or for example, if both CPU and Codec can be clock provider, 1419 * but because of its quality, user want to specify it manually. 1420 * 1421 * Use manually specified settings if sound card did. 1422 */ 1423 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_FORMAT_MASK)) 1424 mask |= SND_SOC_DAIFMT_FORMAT_MASK; 1425 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_CLOCK_MASK)) 1426 mask |= SND_SOC_DAIFMT_CLOCK_MASK; 1427 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_INV_MASK)) 1428 mask |= SND_SOC_DAIFMT_INV_MASK; 1429 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK)) 1430 mask |= SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK; 1431 1432 dai_link->dai_fmt |= (dai_fmt & mask); 1433 } 1434 1435 /** 1436 * snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime 1437 * @rtd: The runtime for which the DAI link format should be changed 1438 * @dai_fmt: The new DAI link format 1439 * 1440 * This function updates the DAI link format for all DAIs connected to the DAI 1441 * link for the specified runtime. 1442 * 1443 * Note: For setups with a static format set the dai_fmt field in the 1444 * corresponding snd_dai_link struct instead of using this function. 1445 * 1446 * Returns 0 on success, otherwise a negative error code. 1447 */ 1448 int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd, 1449 unsigned int dai_fmt) 1450 { 1451 struct snd_soc_dai *cpu_dai; 1452 struct snd_soc_dai *codec_dai; 1453 unsigned int ext_fmt; 1454 unsigned int i; 1455 int ret; 1456 1457 if (!dai_fmt) 1458 return 0; 1459 1460 /* 1461 * dai_fmt has 4 types 1462 * 1. SND_SOC_DAIFMT_FORMAT_MASK 1463 * 2. SND_SOC_DAIFMT_CLOCK 1464 * 3. SND_SOC_DAIFMT_INV 1465 * 4. SND_SOC_DAIFMT_CLOCK_PROVIDER 1466 * 1467 * 4. CLOCK_PROVIDER is set from Codec perspective in dai_fmt. So it will be flipped 1468 * when this function calls set_fmt() for CPU (CBx_CFx -> Bx_Cx). see below. 1469 * This mean, we can't set CPU/Codec both are clock consumer for example. 1470 * New idea handles 4. in each dai->ext_fmt. It can keep compatibility. 1471 * 1472 * Legacy 1473 * dai_fmt includes 1, 2, 3, 4 1474 * 1475 * New idea 1476 * dai_fmt includes 1, 2, 3 1477 * ext_fmt includes 4 1478 */ 1479 for_each_rtd_codec_dais(rtd, i, codec_dai) { 1480 ext_fmt = rtd->dai_link->codecs[i].ext_fmt; 1481 ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt | ext_fmt); 1482 if (ret != 0 && ret != -ENOTSUPP) 1483 return ret; 1484 } 1485 1486 /* Flip the polarity for the "CPU" end of link */ 1487 /* Will effect only for 4. SND_SOC_DAIFMT_CLOCK_PROVIDER */ 1488 dai_fmt = snd_soc_daifmt_clock_provider_flipped(dai_fmt); 1489 1490 for_each_rtd_cpu_dais(rtd, i, cpu_dai) { 1491 ext_fmt = rtd->dai_link->cpus[i].ext_fmt; 1492 ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt | ext_fmt); 1493 if (ret != 0 && ret != -ENOTSUPP) 1494 return ret; 1495 } 1496 1497 return 0; 1498 } 1499 EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt); 1500 1501 static int soc_init_pcm_runtime(struct snd_soc_card *card, 1502 struct snd_soc_pcm_runtime *rtd) 1503 { 1504 struct snd_soc_dai_link *dai_link = rtd->dai_link; 1505 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); 1506 int ret; 1507 1508 /* do machine specific initialization */ 1509 ret = snd_soc_link_init(rtd); 1510 if (ret < 0) 1511 return ret; 1512 1513 snd_soc_runtime_get_dai_fmt(rtd); 1514 ret = snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt); 1515 if (ret) 1516 goto err; 1517 1518 /* add DPCM sysfs entries */ 1519 soc_dpcm_debugfs_add(rtd); 1520 1521 /* create compress_device if possible */ 1522 ret = snd_soc_dai_compress_new(cpu_dai, rtd); 1523 if (ret != -ENOTSUPP) 1524 goto err; 1525 1526 /* create the pcm */ 1527 ret = soc_new_pcm(rtd); 1528 if (ret < 0) { 1529 dev_err(card->dev, "ASoC: can't create pcm %s :%d\n", 1530 dai_link->stream_name, ret); 1531 goto err; 1532 } 1533 1534 ret = snd_soc_pcm_dai_new(rtd); 1535 if (ret < 0) 1536 goto err; 1537 1538 rtd->initialized = true; 1539 1540 return 0; 1541 err: 1542 snd_soc_link_exit(rtd); 1543 return ret; 1544 } 1545 1546 static void soc_set_name_prefix(struct snd_soc_card *card, 1547 struct snd_soc_component *component) 1548 { 1549 struct device_node *of_node = soc_component_to_node(component); 1550 const char *str; 1551 int ret, i; 1552 1553 for (i = 0; i < card->num_configs; i++) { 1554 struct snd_soc_codec_conf *map = &card->codec_conf[i]; 1555 1556 if (snd_soc_is_matching_component(&map->dlc, component) && 1557 map->name_prefix) { 1558 component->name_prefix = map->name_prefix; 1559 return; 1560 } 1561 } 1562 1563 /* 1564 * If there is no configuration table or no match in the table, 1565 * check if a prefix is provided in the node 1566 */ 1567 ret = of_property_read_string(of_node, "sound-name-prefix", &str); 1568 if (ret < 0) 1569 return; 1570 1571 component->name_prefix = str; 1572 } 1573 1574 static void soc_remove_component(struct snd_soc_component *component, 1575 int probed) 1576 { 1577 1578 if (!component->card) 1579 return; 1580 1581 if (probed) 1582 snd_soc_component_remove(component); 1583 1584 list_del_init(&component->card_list); 1585 snd_soc_dapm_free(snd_soc_component_get_dapm(component)); 1586 soc_cleanup_component_debugfs(component); 1587 component->card = NULL; 1588 snd_soc_component_module_put_when_remove(component); 1589 } 1590 1591 static int soc_probe_component(struct snd_soc_card *card, 1592 struct snd_soc_component *component) 1593 { 1594 struct snd_soc_dapm_context *dapm = 1595 snd_soc_component_get_dapm(component); 1596 struct snd_soc_dai *dai; 1597 int probed = 0; 1598 int ret; 1599 1600 if (snd_soc_component_is_dummy(component)) 1601 return 0; 1602 1603 if (component->card) { 1604 if (component->card != card) { 1605 dev_err(component->dev, 1606 "Trying to bind component \"%s\" to card \"%s\" but is already bound to card \"%s\"\n", 1607 component->name, card->name, component->card->name); 1608 return -ENODEV; 1609 } 1610 return 0; 1611 } 1612 1613 ret = snd_soc_component_module_get_when_probe(component); 1614 if (ret < 0) 1615 return ret; 1616 1617 component->card = card; 1618 soc_set_name_prefix(card, component); 1619 1620 soc_init_component_debugfs(component); 1621 1622 snd_soc_dapm_init(dapm, card, component); 1623 1624 ret = snd_soc_dapm_new_controls(dapm, 1625 component->driver->dapm_widgets, 1626 component->driver->num_dapm_widgets); 1627 1628 if (ret != 0) { 1629 dev_err(component->dev, 1630 "Failed to create new controls %d\n", ret); 1631 goto err_probe; 1632 } 1633 1634 for_each_component_dais(component, dai) { 1635 ret = snd_soc_dapm_new_dai_widgets(dapm, dai); 1636 if (ret != 0) { 1637 dev_err(component->dev, 1638 "Failed to create DAI widgets %d\n", ret); 1639 goto err_probe; 1640 } 1641 } 1642 1643 ret = snd_soc_component_probe(component); 1644 if (ret < 0) 1645 goto err_probe; 1646 1647 WARN(dapm->idle_bias_off && 1648 dapm->bias_level != SND_SOC_BIAS_OFF, 1649 "codec %s can not start from non-off bias with idle_bias_off==1\n", 1650 component->name); 1651 probed = 1; 1652 1653 /* 1654 * machine specific init 1655 * see 1656 * snd_soc_component_set_aux() 1657 */ 1658 ret = snd_soc_component_init(component); 1659 if (ret < 0) 1660 goto err_probe; 1661 1662 ret = snd_soc_add_component_controls(component, 1663 component->driver->controls, 1664 component->driver->num_controls); 1665 if (ret < 0) 1666 goto err_probe; 1667 1668 ret = snd_soc_dapm_add_routes(dapm, 1669 component->driver->dapm_routes, 1670 component->driver->num_dapm_routes); 1671 if (ret < 0) 1672 goto err_probe; 1673 1674 /* see for_each_card_components */ 1675 list_add(&component->card_list, &card->component_dev_list); 1676 1677 err_probe: 1678 if (ret < 0) 1679 soc_remove_component(component, probed); 1680 1681 return ret; 1682 } 1683 1684 static void soc_remove_link_dais(struct snd_soc_card *card) 1685 { 1686 struct snd_soc_pcm_runtime *rtd; 1687 int order; 1688 1689 for_each_comp_order(order) { 1690 for_each_card_rtds(card, rtd) { 1691 /* remove all rtd connected DAIs in good order */ 1692 snd_soc_pcm_dai_remove(rtd, order); 1693 } 1694 } 1695 } 1696 1697 static int soc_probe_link_dais(struct snd_soc_card *card) 1698 { 1699 struct snd_soc_pcm_runtime *rtd; 1700 int order, ret; 1701 1702 for_each_comp_order(order) { 1703 for_each_card_rtds(card, rtd) { 1704 /* probe all rtd connected DAIs in good order */ 1705 ret = snd_soc_pcm_dai_probe(rtd, order); 1706 if (ret) 1707 return ret; 1708 } 1709 } 1710 1711 return 0; 1712 } 1713 1714 static void soc_remove_link_components(struct snd_soc_card *card) 1715 { 1716 struct snd_soc_component *component; 1717 struct snd_soc_pcm_runtime *rtd; 1718 int i, order; 1719 1720 for_each_comp_order(order) { 1721 for_each_card_rtds(card, rtd) { 1722 for_each_rtd_components(rtd, i, component) { 1723 if (component->driver->remove_order != order) 1724 continue; 1725 1726 soc_remove_component(component, 1); 1727 } 1728 } 1729 } 1730 } 1731 1732 static int soc_probe_link_components(struct snd_soc_card *card) 1733 { 1734 struct snd_soc_component *component; 1735 struct snd_soc_pcm_runtime *rtd; 1736 int i, ret, order; 1737 1738 for_each_comp_order(order) { 1739 for_each_card_rtds(card, rtd) { 1740 for_each_rtd_components(rtd, i, component) { 1741 if (component->driver->probe_order != order) 1742 continue; 1743 1744 ret = soc_probe_component(card, component); 1745 if (ret < 0) 1746 return ret; 1747 } 1748 } 1749 } 1750 1751 return 0; 1752 } 1753 1754 static void soc_unbind_aux_dev(struct snd_soc_card *card) 1755 { 1756 struct snd_soc_component *component, *_component; 1757 1758 for_each_card_auxs_safe(card, component, _component) { 1759 /* for snd_soc_component_init() */ 1760 snd_soc_component_set_aux(component, NULL); 1761 list_del(&component->card_aux_list); 1762 } 1763 } 1764 1765 static int soc_bind_aux_dev(struct snd_soc_card *card) 1766 { 1767 struct snd_soc_component *component; 1768 struct snd_soc_aux_dev *aux; 1769 int i; 1770 1771 for_each_card_pre_auxs(card, i, aux) { 1772 /* codecs, usually analog devices */ 1773 component = soc_find_component(&aux->dlc); 1774 if (!component) 1775 return -EPROBE_DEFER; 1776 1777 /* for snd_soc_component_init() */ 1778 snd_soc_component_set_aux(component, aux); 1779 /* see for_each_card_auxs */ 1780 list_add(&component->card_aux_list, &card->aux_comp_list); 1781 } 1782 return 0; 1783 } 1784 1785 static int soc_probe_aux_devices(struct snd_soc_card *card) 1786 { 1787 struct snd_soc_component *component; 1788 int order; 1789 int ret; 1790 1791 for_each_comp_order(order) { 1792 for_each_card_auxs(card, component) { 1793 if (component->driver->probe_order != order) 1794 continue; 1795 1796 ret = soc_probe_component(card, component); 1797 if (ret < 0) 1798 return ret; 1799 } 1800 } 1801 1802 return 0; 1803 } 1804 1805 static void soc_remove_aux_devices(struct snd_soc_card *card) 1806 { 1807 struct snd_soc_component *comp, *_comp; 1808 int order; 1809 1810 for_each_comp_order(order) { 1811 for_each_card_auxs_safe(card, comp, _comp) { 1812 if (comp->driver->remove_order == order) 1813 soc_remove_component(comp, 1); 1814 } 1815 } 1816 } 1817 1818 #ifdef CONFIG_DMI 1819 /* 1820 * If a DMI filed contain strings in this blacklist (e.g. 1821 * "Type2 - Board Manufacturer" or "Type1 - TBD by OEM"), it will be taken 1822 * as invalid and dropped when setting the card long name from DMI info. 1823 */ 1824 static const char * const dmi_blacklist[] = { 1825 "To be filled by OEM", 1826 "TBD by OEM", 1827 "Default String", 1828 "Board Manufacturer", 1829 "Board Vendor Name", 1830 "Board Product Name", 1831 NULL, /* terminator */ 1832 }; 1833 1834 /* 1835 * Trim special characters, and replace '-' with '_' since '-' is used to 1836 * separate different DMI fields in the card long name. Only number and 1837 * alphabet characters and a few separator characters are kept. 1838 */ 1839 static void cleanup_dmi_name(char *name) 1840 { 1841 int i, j = 0; 1842 1843 for (i = 0; name[i]; i++) { 1844 if (isalnum(name[i]) || (name[i] == '.') 1845 || (name[i] == '_')) 1846 name[j++] = name[i]; 1847 else if (name[i] == '-') 1848 name[j++] = '_'; 1849 } 1850 1851 name[j] = '\0'; 1852 } 1853 1854 /* 1855 * Check if a DMI field is valid, i.e. not containing any string 1856 * in the black list. 1857 */ 1858 static int is_dmi_valid(const char *field) 1859 { 1860 int i = 0; 1861 1862 while (dmi_blacklist[i]) { 1863 if (strstr(field, dmi_blacklist[i])) 1864 return 0; 1865 i++; 1866 } 1867 1868 return 1; 1869 } 1870 1871 /* 1872 * Append a string to card->dmi_longname with character cleanups. 1873 */ 1874 static void append_dmi_string(struct snd_soc_card *card, const char *str) 1875 { 1876 char *dst = card->dmi_longname; 1877 size_t dst_len = sizeof(card->dmi_longname); 1878 size_t len; 1879 1880 len = strlen(dst); 1881 snprintf(dst + len, dst_len - len, "-%s", str); 1882 1883 len++; /* skip the separator "-" */ 1884 if (len < dst_len) 1885 cleanup_dmi_name(dst + len); 1886 } 1887 1888 /** 1889 * snd_soc_set_dmi_name() - Register DMI names to card 1890 * @card: The card to register DMI names 1891 * 1892 * An Intel machine driver may be used by many different devices but are 1893 * difficult for userspace to differentiate, since machine drivers usually 1894 * use their own name as the card short name and leave the card long name 1895 * blank. To differentiate such devices and fix bugs due to lack of 1896 * device-specific configurations, this function allows DMI info to be used 1897 * as the sound card long name, in the format of 1898 * "vendor-product-version-board" 1899 * (Character '-' is used to separate different DMI fields here). 1900 * This will help the user space to load the device-specific Use Case Manager 1901 * (UCM) configurations for the card. 1902 * 1903 * Possible card long names may be: 1904 * DellInc.-XPS139343-01-0310JH 1905 * ASUSTeKCOMPUTERINC.-T100TA-1.0-T100TA 1906 * Circuitco-MinnowboardMaxD0PLATFORM-D0-MinnowBoardMAX 1907 * 1908 * This function also supports flavoring the card longname to provide 1909 * the extra differentiation, like "vendor-product-version-board-flavor". 1910 * 1911 * We only keep number and alphabet characters and a few separator characters 1912 * in the card long name since UCM in the user space uses the card long names 1913 * as card configuration directory names and AudoConf cannot support special 1914 * characters like SPACE. 1915 * 1916 * Returns 0 on success, otherwise a negative error code. 1917 */ 1918 static int snd_soc_set_dmi_name(struct snd_soc_card *card) 1919 { 1920 const char *vendor, *product, *board; 1921 1922 if (card->long_name) 1923 return 0; /* long name already set by driver or from DMI */ 1924 1925 if (!dmi_available) 1926 return 0; 1927 1928 /* make up dmi long name as: vendor-product-version-board */ 1929 vendor = dmi_get_system_info(DMI_BOARD_VENDOR); 1930 if (!vendor || !is_dmi_valid(vendor)) { 1931 dev_warn(card->dev, "ASoC: no DMI vendor name!\n"); 1932 return 0; 1933 } 1934 1935 snprintf(card->dmi_longname, sizeof(card->dmi_longname), "%s", vendor); 1936 cleanup_dmi_name(card->dmi_longname); 1937 1938 product = dmi_get_system_info(DMI_PRODUCT_NAME); 1939 if (product && is_dmi_valid(product)) { 1940 const char *product_version = dmi_get_system_info(DMI_PRODUCT_VERSION); 1941 1942 append_dmi_string(card, product); 1943 1944 /* 1945 * some vendors like Lenovo may only put a self-explanatory 1946 * name in the product version field 1947 */ 1948 if (product_version && is_dmi_valid(product_version)) 1949 append_dmi_string(card, product_version); 1950 } 1951 1952 board = dmi_get_system_info(DMI_BOARD_NAME); 1953 if (board && is_dmi_valid(board)) { 1954 if (!product || strcasecmp(board, product)) 1955 append_dmi_string(card, board); 1956 } else if (!product) { 1957 /* fall back to using legacy name */ 1958 dev_warn(card->dev, "ASoC: no DMI board/product name!\n"); 1959 return 0; 1960 } 1961 1962 /* set the card long name */ 1963 card->long_name = card->dmi_longname; 1964 1965 return 0; 1966 } 1967 #else 1968 static inline int snd_soc_set_dmi_name(struct snd_soc_card *card) 1969 { 1970 return 0; 1971 } 1972 #endif /* CONFIG_DMI */ 1973 1974 static void soc_check_tplg_fes(struct snd_soc_card *card) 1975 { 1976 struct snd_soc_component *component; 1977 const struct snd_soc_component_driver *comp_drv; 1978 struct snd_soc_dai_link *dai_link; 1979 int i; 1980 1981 for_each_component(component) { 1982 1983 /* does this component override BEs ? */ 1984 if (!component->driver->ignore_machine) 1985 continue; 1986 1987 /* for this machine ? */ 1988 if (!strcmp(component->driver->ignore_machine, 1989 card->dev->driver->name)) 1990 goto match; 1991 if (strcmp(component->driver->ignore_machine, 1992 dev_name(card->dev))) 1993 continue; 1994 match: 1995 /* machine matches, so override the rtd data */ 1996 for_each_card_prelinks(card, i, dai_link) { 1997 1998 /* ignore this FE */ 1999 if (dai_link->dynamic) { 2000 dai_link->ignore = true; 2001 continue; 2002 } 2003 2004 dev_dbg(card->dev, "info: override BE DAI link %s\n", 2005 card->dai_link[i].name); 2006 2007 /* override platform component */ 2008 if (!dai_link->platforms) { 2009 dev_err(card->dev, "init platform error"); 2010 continue; 2011 } 2012 2013 if (component->dev->of_node) 2014 dai_link->platforms->of_node = component->dev->of_node; 2015 else 2016 dai_link->platforms->name = component->name; 2017 2018 /* convert non BE into BE */ 2019 dai_link->no_pcm = 1; 2020 2021 /* 2022 * override any BE fixups 2023 * see 2024 * snd_soc_link_be_hw_params_fixup() 2025 */ 2026 dai_link->be_hw_params_fixup = 2027 component->driver->be_hw_params_fixup; 2028 2029 /* 2030 * most BE links don't set stream name, so set it to 2031 * dai link name if it's NULL to help bind widgets. 2032 */ 2033 if (!dai_link->stream_name) 2034 dai_link->stream_name = dai_link->name; 2035 } 2036 2037 /* Inform userspace we are using alternate topology */ 2038 if (component->driver->topology_name_prefix) { 2039 2040 /* topology shortname created? */ 2041 if (!card->topology_shortname_created) { 2042 comp_drv = component->driver; 2043 2044 snprintf(card->topology_shortname, 32, "%s-%s", 2045 comp_drv->topology_name_prefix, 2046 card->name); 2047 card->topology_shortname_created = true; 2048 } 2049 2050 /* use topology shortname */ 2051 card->name = card->topology_shortname; 2052 } 2053 } 2054 } 2055 2056 #define soc_setup_card_name(card, name, name1, name2) \ 2057 __soc_setup_card_name(card, name, sizeof(name), name1, name2) 2058 static void __soc_setup_card_name(struct snd_soc_card *card, 2059 char *name, int len, 2060 const char *name1, const char *name2) 2061 { 2062 const char *src = name1 ? name1 : name2; 2063 int i; 2064 2065 snprintf(name, len, "%s", src); 2066 2067 if (name != card->snd_card->driver) 2068 return; 2069 2070 /* 2071 * Name normalization (driver field) 2072 * 2073 * The driver name is somewhat special, as it's used as a key for 2074 * searches in the user-space. 2075 * 2076 * ex) 2077 * "abcd??efg" -> "abcd__efg" 2078 */ 2079 for (i = 0; i < len; i++) { 2080 switch (name[i]) { 2081 case '_': 2082 case '-': 2083 case '\0': 2084 break; 2085 default: 2086 if (!isalnum(name[i])) 2087 name[i] = '_'; 2088 break; 2089 } 2090 } 2091 2092 /* 2093 * The driver field should contain a valid string from the user view. 2094 * The wrapping usually does not work so well here. Set a smaller string 2095 * in the specific ASoC driver. 2096 */ 2097 if (strlen(src) > len - 1) 2098 dev_err(card->dev, "ASoC: driver name too long '%s' -> '%s'\n", src, name); 2099 } 2100 2101 static void soc_cleanup_card_resources(struct snd_soc_card *card) 2102 { 2103 struct snd_soc_pcm_runtime *rtd, *n; 2104 2105 if (card->snd_card) 2106 snd_card_disconnect_sync(card->snd_card); 2107 2108 snd_soc_dapm_shutdown(card); 2109 2110 /* release machine specific resources */ 2111 for_each_card_rtds(card, rtd) 2112 if (rtd->initialized) 2113 snd_soc_link_exit(rtd); 2114 /* remove and free each DAI */ 2115 soc_remove_link_dais(card); 2116 soc_remove_link_components(card); 2117 2118 for_each_card_rtds_safe(card, rtd, n) 2119 snd_soc_remove_pcm_runtime(card, rtd); 2120 2121 /* remove auxiliary devices */ 2122 soc_remove_aux_devices(card); 2123 soc_unbind_aux_dev(card); 2124 2125 snd_soc_dapm_free(&card->dapm); 2126 soc_cleanup_card_debugfs(card); 2127 2128 /* remove the card */ 2129 snd_soc_card_remove(card); 2130 2131 if (card->snd_card) { 2132 snd_card_free(card->snd_card); 2133 card->snd_card = NULL; 2134 } 2135 } 2136 2137 static void snd_soc_unbind_card(struct snd_soc_card *card) 2138 { 2139 if (snd_soc_card_is_instantiated(card)) { 2140 card->instantiated = false; 2141 snd_soc_flush_all_delayed_work(card); 2142 2143 soc_cleanup_card_resources(card); 2144 } 2145 } 2146 2147 static int snd_soc_bind_card(struct snd_soc_card *card) 2148 { 2149 struct snd_soc_pcm_runtime *rtd; 2150 struct snd_soc_component *component; 2151 int ret; 2152 2153 snd_soc_card_mutex_lock_root(card); 2154 snd_soc_fill_dummy_dai(card); 2155 2156 snd_soc_dapm_init(&card->dapm, card, NULL); 2157 2158 /* check whether any platform is ignore machine FE and using topology */ 2159 soc_check_tplg_fes(card); 2160 2161 /* bind aux_devs too */ 2162 ret = soc_bind_aux_dev(card); 2163 if (ret < 0) 2164 goto probe_end; 2165 2166 /* add predefined DAI links to the list */ 2167 card->num_rtd = 0; 2168 ret = snd_soc_add_pcm_runtimes(card, card->dai_link, card->num_links); 2169 if (ret < 0) 2170 goto probe_end; 2171 2172 /* card bind complete so register a sound card */ 2173 ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1, 2174 card->owner, 0, &card->snd_card); 2175 if (ret < 0) { 2176 dev_err(card->dev, 2177 "ASoC: can't create sound card for card %s: %d\n", 2178 card->name, ret); 2179 goto probe_end; 2180 } 2181 2182 soc_init_card_debugfs(card); 2183 2184 soc_resume_init(card); 2185 2186 ret = snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets, 2187 card->num_dapm_widgets); 2188 if (ret < 0) 2189 goto probe_end; 2190 2191 ret = snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets, 2192 card->num_of_dapm_widgets); 2193 if (ret < 0) 2194 goto probe_end; 2195 2196 /* initialise the sound card only once */ 2197 ret = snd_soc_card_probe(card); 2198 if (ret < 0) 2199 goto probe_end; 2200 2201 /* probe all components used by DAI links on this card */ 2202 ret = soc_probe_link_components(card); 2203 if (ret < 0) { 2204 if (ret != -EPROBE_DEFER) { 2205 dev_err(card->dev, 2206 "ASoC: failed to instantiate card %d\n", ret); 2207 } 2208 goto probe_end; 2209 } 2210 2211 /* probe auxiliary components */ 2212 ret = soc_probe_aux_devices(card); 2213 if (ret < 0) { 2214 dev_err(card->dev, 2215 "ASoC: failed to probe aux component %d\n", ret); 2216 goto probe_end; 2217 } 2218 2219 /* probe all DAI links on this card */ 2220 ret = soc_probe_link_dais(card); 2221 if (ret < 0) { 2222 dev_err(card->dev, 2223 "ASoC: failed to instantiate card %d\n", ret); 2224 goto probe_end; 2225 } 2226 2227 for_each_card_rtds(card, rtd) { 2228 ret = soc_init_pcm_runtime(card, rtd); 2229 if (ret < 0) 2230 goto probe_end; 2231 } 2232 2233 snd_soc_dapm_link_dai_widgets(card); 2234 snd_soc_dapm_connect_dai_link_widgets(card); 2235 2236 ret = snd_soc_add_card_controls(card, card->controls, 2237 card->num_controls); 2238 if (ret < 0) 2239 goto probe_end; 2240 2241 ret = snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes, 2242 card->num_dapm_routes); 2243 if (ret < 0) 2244 goto probe_end; 2245 2246 ret = snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes, 2247 card->num_of_dapm_routes); 2248 if (ret < 0) 2249 goto probe_end; 2250 2251 /* try to set some sane longname if DMI is available */ 2252 snd_soc_set_dmi_name(card); 2253 2254 soc_setup_card_name(card, card->snd_card->shortname, 2255 card->name, NULL); 2256 soc_setup_card_name(card, card->snd_card->longname, 2257 card->long_name, card->name); 2258 soc_setup_card_name(card, card->snd_card->driver, 2259 card->driver_name, card->name); 2260 2261 if (card->components) { 2262 /* the current implementation of snd_component_add() accepts */ 2263 /* multiple components in the string separated by space, */ 2264 /* but the string collision (identical string) check might */ 2265 /* not work correctly */ 2266 ret = snd_component_add(card->snd_card, card->components); 2267 if (ret < 0) { 2268 dev_err(card->dev, "ASoC: %s snd_component_add() failed: %d\n", 2269 card->name, ret); 2270 goto probe_end; 2271 } 2272 } 2273 2274 ret = snd_soc_card_late_probe(card); 2275 if (ret < 0) 2276 goto probe_end; 2277 2278 snd_soc_dapm_new_widgets(card); 2279 snd_soc_card_fixup_controls(card); 2280 2281 ret = snd_card_register(card->snd_card); 2282 if (ret < 0) { 2283 dev_err(card->dev, "ASoC: failed to register soundcard %d\n", 2284 ret); 2285 goto probe_end; 2286 } 2287 2288 card->instantiated = 1; 2289 dapm_mark_endpoints_dirty(card); 2290 snd_soc_dapm_sync(&card->dapm); 2291 2292 /* deactivate pins to sleep state */ 2293 for_each_card_components(card, component) 2294 if (!snd_soc_component_active(component)) 2295 pinctrl_pm_select_sleep_state(component->dev); 2296 2297 probe_end: 2298 if (ret < 0) 2299 soc_cleanup_card_resources(card); 2300 snd_soc_card_mutex_unlock(card); 2301 2302 return ret; 2303 } 2304 2305 static void devm_card_bind_release(struct device *dev, void *res) 2306 { 2307 snd_soc_unregister_card(*(struct snd_soc_card **)res); 2308 } 2309 2310 static int devm_snd_soc_bind_card(struct device *dev, struct snd_soc_card *card) 2311 { 2312 struct snd_soc_card **ptr; 2313 int ret; 2314 2315 ptr = devres_alloc(devm_card_bind_release, sizeof(*ptr), GFP_KERNEL); 2316 if (!ptr) 2317 return -ENOMEM; 2318 2319 ret = snd_soc_bind_card(card); 2320 if (ret == 0 || ret == -EPROBE_DEFER) { 2321 *ptr = card; 2322 devres_add(dev, ptr); 2323 } else { 2324 devres_free(ptr); 2325 } 2326 2327 return ret; 2328 } 2329 2330 static int snd_soc_rebind_card(struct snd_soc_card *card) 2331 { 2332 int ret; 2333 2334 if (card->devres_dev) { 2335 devres_destroy(card->devres_dev, devm_card_bind_release, NULL, NULL); 2336 ret = devm_snd_soc_bind_card(card->devres_dev, card); 2337 } else { 2338 ret = snd_soc_bind_card(card); 2339 } 2340 2341 if (ret != -EPROBE_DEFER) 2342 list_del_init(&card->list); 2343 2344 return ret; 2345 } 2346 2347 /* probes a new socdev */ 2348 static int soc_probe(struct platform_device *pdev) 2349 { 2350 struct snd_soc_card *card = platform_get_drvdata(pdev); 2351 2352 /* 2353 * no card, so machine driver should be registering card 2354 * we should not be here in that case so ret error 2355 */ 2356 if (!card) 2357 return -EINVAL; 2358 2359 dev_warn(&pdev->dev, 2360 "ASoC: machine %s should use snd_soc_register_card()\n", 2361 card->name); 2362 2363 /* Bodge while we unpick instantiation */ 2364 card->dev = &pdev->dev; 2365 2366 return devm_snd_soc_register_card(&pdev->dev, card); 2367 } 2368 2369 int snd_soc_poweroff(struct device *dev) 2370 { 2371 struct snd_soc_card *card = dev_get_drvdata(dev); 2372 struct snd_soc_component *component; 2373 2374 if (!snd_soc_card_is_instantiated(card)) 2375 return 0; 2376 2377 /* 2378 * Flush out pmdown_time work - we actually do want to run it 2379 * now, we're shutting down so no imminent restart. 2380 */ 2381 snd_soc_flush_all_delayed_work(card); 2382 2383 snd_soc_dapm_shutdown(card); 2384 2385 /* deactivate pins to sleep state */ 2386 for_each_card_components(card, component) 2387 pinctrl_pm_select_sleep_state(component->dev); 2388 2389 return 0; 2390 } 2391 EXPORT_SYMBOL_GPL(snd_soc_poweroff); 2392 2393 const struct dev_pm_ops snd_soc_pm_ops = { 2394 .suspend = snd_soc_suspend, 2395 .resume = snd_soc_resume, 2396 .freeze = snd_soc_suspend, 2397 .thaw = snd_soc_resume, 2398 .poweroff = snd_soc_poweroff, 2399 .restore = snd_soc_resume, 2400 }; 2401 EXPORT_SYMBOL_GPL(snd_soc_pm_ops); 2402 2403 /* ASoC platform driver */ 2404 static struct platform_driver soc_driver = { 2405 .driver = { 2406 .name = "soc-audio", 2407 .pm = &snd_soc_pm_ops, 2408 }, 2409 .probe = soc_probe, 2410 }; 2411 2412 /** 2413 * snd_soc_cnew - create new control 2414 * @_template: control template 2415 * @data: control private data 2416 * @long_name: control long name 2417 * @prefix: control name prefix 2418 * 2419 * Create a new mixer control from a template control. 2420 * 2421 * Returns 0 for success, else error. 2422 */ 2423 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template, 2424 void *data, const char *long_name, 2425 const char *prefix) 2426 { 2427 struct snd_kcontrol_new template; 2428 struct snd_kcontrol *kcontrol; 2429 char *name = NULL; 2430 2431 memcpy(&template, _template, sizeof(template)); 2432 template.index = 0; 2433 2434 if (!long_name) 2435 long_name = template.name; 2436 2437 if (prefix) { 2438 name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name); 2439 if (!name) 2440 return NULL; 2441 2442 template.name = name; 2443 } else { 2444 template.name = long_name; 2445 } 2446 2447 kcontrol = snd_ctl_new1(&template, data); 2448 2449 kfree(name); 2450 2451 return kcontrol; 2452 } 2453 EXPORT_SYMBOL_GPL(snd_soc_cnew); 2454 2455 static int snd_soc_add_controls(struct snd_card *card, struct device *dev, 2456 const struct snd_kcontrol_new *controls, int num_controls, 2457 const char *prefix, void *data) 2458 { 2459 int i; 2460 2461 for (i = 0; i < num_controls; i++) { 2462 const struct snd_kcontrol_new *control = &controls[i]; 2463 int err = snd_ctl_add(card, snd_soc_cnew(control, data, 2464 control->name, prefix)); 2465 if (err < 0) { 2466 dev_err(dev, "ASoC: Failed to add %s: %d\n", 2467 control->name, err); 2468 return err; 2469 } 2470 } 2471 2472 return 0; 2473 } 2474 2475 /** 2476 * snd_soc_add_component_controls - Add an array of controls to a component. 2477 * 2478 * @component: Component to add controls to 2479 * @controls: Array of controls to add 2480 * @num_controls: Number of elements in the array 2481 * 2482 * Return: 0 for success, else error. 2483 */ 2484 int snd_soc_add_component_controls(struct snd_soc_component *component, 2485 const struct snd_kcontrol_new *controls, unsigned int num_controls) 2486 { 2487 struct snd_card *card = component->card->snd_card; 2488 2489 return snd_soc_add_controls(card, component->dev, controls, 2490 num_controls, component->name_prefix, component); 2491 } 2492 EXPORT_SYMBOL_GPL(snd_soc_add_component_controls); 2493 2494 /** 2495 * snd_soc_add_card_controls - add an array of controls to a SoC card. 2496 * Convenience function to add a list of controls. 2497 * 2498 * @soc_card: SoC card to add controls to 2499 * @controls: array of controls to add 2500 * @num_controls: number of elements in the array 2501 * 2502 * Return 0 for success, else error. 2503 */ 2504 int snd_soc_add_card_controls(struct snd_soc_card *soc_card, 2505 const struct snd_kcontrol_new *controls, int num_controls) 2506 { 2507 struct snd_card *card = soc_card->snd_card; 2508 2509 return snd_soc_add_controls(card, soc_card->dev, controls, num_controls, 2510 NULL, soc_card); 2511 } 2512 EXPORT_SYMBOL_GPL(snd_soc_add_card_controls); 2513 2514 /** 2515 * snd_soc_add_dai_controls - add an array of controls to a DAI. 2516 * Convenience function to add a list of controls. 2517 * 2518 * @dai: DAI to add controls to 2519 * @controls: array of controls to add 2520 * @num_controls: number of elements in the array 2521 * 2522 * Return 0 for success, else error. 2523 */ 2524 int snd_soc_add_dai_controls(struct snd_soc_dai *dai, 2525 const struct snd_kcontrol_new *controls, int num_controls) 2526 { 2527 struct snd_card *card = dai->component->card->snd_card; 2528 2529 return snd_soc_add_controls(card, dai->dev, controls, num_controls, 2530 NULL, dai); 2531 } 2532 EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls); 2533 2534 /** 2535 * snd_soc_register_card - Register a card with the ASoC core 2536 * 2537 * @card: Card to register 2538 * 2539 */ 2540 int snd_soc_register_card(struct snd_soc_card *card) 2541 { 2542 int ret; 2543 2544 if (!card->name || !card->dev) 2545 return -EINVAL; 2546 2547 dev_set_drvdata(card->dev, card); 2548 2549 INIT_LIST_HEAD(&card->widgets); 2550 INIT_LIST_HEAD(&card->paths); 2551 INIT_LIST_HEAD(&card->dapm_list); 2552 INIT_LIST_HEAD(&card->aux_comp_list); 2553 INIT_LIST_HEAD(&card->component_dev_list); 2554 INIT_LIST_HEAD(&card->list); 2555 INIT_LIST_HEAD(&card->rtd_list); 2556 INIT_LIST_HEAD(&card->dapm_dirty); 2557 INIT_LIST_HEAD(&card->dobj_list); 2558 2559 card->instantiated = 0; 2560 mutex_init(&card->mutex); 2561 mutex_init(&card->dapm_mutex); 2562 mutex_init(&card->pcm_mutex); 2563 2564 mutex_lock(&client_mutex); 2565 2566 if (card->devres_dev) { 2567 ret = devm_snd_soc_bind_card(card->devres_dev, card); 2568 if (ret == -EPROBE_DEFER) { 2569 list_add(&card->list, &unbind_card_list); 2570 ret = 0; 2571 } 2572 } else { 2573 ret = snd_soc_bind_card(card); 2574 } 2575 2576 mutex_unlock(&client_mutex); 2577 2578 return ret; 2579 } 2580 EXPORT_SYMBOL_GPL(snd_soc_register_card); 2581 2582 /** 2583 * snd_soc_unregister_card - Unregister a card with the ASoC core 2584 * 2585 * @card: Card to unregister 2586 * 2587 */ 2588 void snd_soc_unregister_card(struct snd_soc_card *card) 2589 { 2590 mutex_lock(&client_mutex); 2591 snd_soc_unbind_card(card); 2592 list_del(&card->list); 2593 mutex_unlock(&client_mutex); 2594 dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name); 2595 } 2596 EXPORT_SYMBOL_GPL(snd_soc_unregister_card); 2597 2598 /* 2599 * Simplify DAI link configuration by removing ".-1" from device names 2600 * and sanitizing names. 2601 */ 2602 static char *fmt_single_name(struct device *dev, int *id) 2603 { 2604 const char *devname = dev_name(dev); 2605 char *found, *name; 2606 unsigned int id1, id2; 2607 2608 if (devname == NULL) 2609 return NULL; 2610 2611 name = devm_kstrdup(dev, devname, GFP_KERNEL); 2612 if (!name) 2613 return NULL; 2614 2615 /* are we a "%s.%d" name (platform and SPI components) */ 2616 found = strstr(name, dev->driver->name); 2617 if (found) { 2618 /* get ID */ 2619 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) { 2620 2621 /* discard ID from name if ID == -1 */ 2622 if (*id == -1) 2623 found[strlen(dev->driver->name)] = '\0'; 2624 } 2625 2626 /* I2C component devices are named "bus-addr" */ 2627 } else if (sscanf(name, "%x-%x", &id1, &id2) == 2) { 2628 2629 /* create unique ID number from I2C addr and bus */ 2630 *id = ((id1 & 0xffff) << 16) + id2; 2631 2632 devm_kfree(dev, name); 2633 2634 /* sanitize component name for DAI link creation */ 2635 name = devm_kasprintf(dev, GFP_KERNEL, "%s.%s", dev->driver->name, devname); 2636 } else { 2637 *id = 0; 2638 } 2639 2640 return name; 2641 } 2642 2643 /* 2644 * Simplify DAI link naming for single devices with multiple DAIs by removing 2645 * any ".-1" and using the DAI name (instead of device name). 2646 */ 2647 static inline char *fmt_multiple_name(struct device *dev, 2648 struct snd_soc_dai_driver *dai_drv) 2649 { 2650 if (dai_drv->name == NULL) { 2651 dev_err(dev, 2652 "ASoC: error - multiple DAI %s registered with no name\n", 2653 dev_name(dev)); 2654 return NULL; 2655 } 2656 2657 return devm_kstrdup(dev, dai_drv->name, GFP_KERNEL); 2658 } 2659 2660 void snd_soc_unregister_dai(struct snd_soc_dai *dai) 2661 { 2662 dev_dbg(dai->dev, "ASoC: Unregistered DAI '%s'\n", dai->name); 2663 list_del(&dai->list); 2664 } 2665 EXPORT_SYMBOL_GPL(snd_soc_unregister_dai); 2666 2667 /** 2668 * snd_soc_register_dai - Register a DAI dynamically & create its widgets 2669 * 2670 * @component: The component the DAIs are registered for 2671 * @dai_drv: DAI driver to use for the DAI 2672 * @legacy_dai_naming: if %true, use legacy single-name format; 2673 * if %false, use multiple-name format; 2674 * 2675 * Topology can use this API to register DAIs when probing a component. 2676 * These DAIs's widgets will be freed in the card cleanup and the DAIs 2677 * will be freed in the component cleanup. 2678 */ 2679 struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component, 2680 struct snd_soc_dai_driver *dai_drv, 2681 bool legacy_dai_naming) 2682 { 2683 struct device *dev = component->dev; 2684 struct snd_soc_dai *dai; 2685 2686 lockdep_assert_held(&client_mutex); 2687 2688 dai = devm_kzalloc(dev, sizeof(*dai), GFP_KERNEL); 2689 if (dai == NULL) 2690 return NULL; 2691 2692 /* 2693 * Back in the old days when we still had component-less DAIs, 2694 * instead of having a static name, component-less DAIs would 2695 * inherit the name of the parent device so it is possible to 2696 * register multiple instances of the DAI. We still need to keep 2697 * the same naming style even though those DAIs are not 2698 * component-less anymore. 2699 */ 2700 if (legacy_dai_naming && 2701 (dai_drv->id == 0 || dai_drv->name == NULL)) { 2702 dai->name = fmt_single_name(dev, &dai->id); 2703 } else { 2704 dai->name = fmt_multiple_name(dev, dai_drv); 2705 if (dai_drv->id) 2706 dai->id = dai_drv->id; 2707 else 2708 dai->id = component->num_dai; 2709 } 2710 if (!dai->name) 2711 return NULL; 2712 2713 dai->component = component; 2714 dai->dev = dev; 2715 dai->driver = dai_drv; 2716 2717 /* see for_each_component_dais */ 2718 list_add_tail(&dai->list, &component->dai_list); 2719 component->num_dai++; 2720 2721 dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name); 2722 return dai; 2723 } 2724 EXPORT_SYMBOL_GPL(snd_soc_register_dai); 2725 2726 /** 2727 * snd_soc_unregister_dais - Unregister DAIs from the ASoC core 2728 * 2729 * @component: The component for which the DAIs should be unregistered 2730 */ 2731 static void snd_soc_unregister_dais(struct snd_soc_component *component) 2732 { 2733 struct snd_soc_dai *dai, *_dai; 2734 2735 for_each_component_dais_safe(component, dai, _dai) 2736 snd_soc_unregister_dai(dai); 2737 } 2738 2739 /** 2740 * snd_soc_register_dais - Register a DAI with the ASoC core 2741 * 2742 * @component: The component the DAIs are registered for 2743 * @dai_drv: DAI driver to use for the DAIs 2744 * @count: Number of DAIs 2745 */ 2746 static int snd_soc_register_dais(struct snd_soc_component *component, 2747 struct snd_soc_dai_driver *dai_drv, 2748 size_t count) 2749 { 2750 struct snd_soc_dai *dai; 2751 unsigned int i; 2752 int ret; 2753 2754 for (i = 0; i < count; i++) { 2755 dai = snd_soc_register_dai(component, dai_drv + i, count == 1 && 2756 component->driver->legacy_dai_naming); 2757 if (dai == NULL) { 2758 ret = -ENOMEM; 2759 goto err; 2760 } 2761 } 2762 2763 return 0; 2764 2765 err: 2766 snd_soc_unregister_dais(component); 2767 2768 return ret; 2769 } 2770 2771 #define ENDIANNESS_MAP(name) \ 2772 (SNDRV_PCM_FMTBIT_##name##LE | SNDRV_PCM_FMTBIT_##name##BE) 2773 static u64 endianness_format_map[] = { 2774 ENDIANNESS_MAP(S16_), 2775 ENDIANNESS_MAP(U16_), 2776 ENDIANNESS_MAP(S24_), 2777 ENDIANNESS_MAP(U24_), 2778 ENDIANNESS_MAP(S32_), 2779 ENDIANNESS_MAP(U32_), 2780 ENDIANNESS_MAP(S24_3), 2781 ENDIANNESS_MAP(U24_3), 2782 ENDIANNESS_MAP(S20_3), 2783 ENDIANNESS_MAP(U20_3), 2784 ENDIANNESS_MAP(S18_3), 2785 ENDIANNESS_MAP(U18_3), 2786 ENDIANNESS_MAP(FLOAT_), 2787 ENDIANNESS_MAP(FLOAT64_), 2788 ENDIANNESS_MAP(IEC958_SUBFRAME_), 2789 }; 2790 2791 /* 2792 * Fix up the DAI formats for endianness: codecs don't actually see 2793 * the endianness of the data but we're using the CPU format 2794 * definitions which do need to include endianness so we ensure that 2795 * codec DAIs always have both big and little endian variants set. 2796 */ 2797 static void convert_endianness_formats(struct snd_soc_pcm_stream *stream) 2798 { 2799 int i; 2800 2801 for (i = 0; i < ARRAY_SIZE(endianness_format_map); i++) 2802 if (stream->formats & endianness_format_map[i]) 2803 stream->formats |= endianness_format_map[i]; 2804 } 2805 2806 static void snd_soc_del_component_unlocked(struct snd_soc_component *component) 2807 { 2808 struct snd_soc_card *card = component->card; 2809 bool instantiated; 2810 2811 snd_soc_unregister_dais(component); 2812 2813 if (card) { 2814 instantiated = card->instantiated; 2815 snd_soc_unbind_card(card); 2816 if (instantiated) 2817 list_add(&card->list, &unbind_card_list); 2818 } 2819 2820 list_del(&component->list); 2821 } 2822 2823 int snd_soc_component_initialize(struct snd_soc_component *component, 2824 const struct snd_soc_component_driver *driver, 2825 struct device *dev) 2826 { 2827 INIT_LIST_HEAD(&component->dai_list); 2828 INIT_LIST_HEAD(&component->dobj_list); 2829 INIT_LIST_HEAD(&component->card_list); 2830 INIT_LIST_HEAD(&component->list); 2831 mutex_init(&component->io_mutex); 2832 2833 if (!component->name) { 2834 component->name = fmt_single_name(dev, &component->id); 2835 if (!component->name) { 2836 dev_err(dev, "ASoC: Failed to allocate name\n"); 2837 return -ENOMEM; 2838 } 2839 } 2840 2841 component->dev = dev; 2842 component->driver = driver; 2843 2844 #ifdef CONFIG_DEBUG_FS 2845 if (!component->debugfs_prefix) 2846 component->debugfs_prefix = driver->debugfs_prefix; 2847 #endif 2848 2849 return 0; 2850 } 2851 EXPORT_SYMBOL_GPL(snd_soc_component_initialize); 2852 2853 int snd_soc_add_component(struct snd_soc_component *component, 2854 struct snd_soc_dai_driver *dai_drv, 2855 int num_dai) 2856 { 2857 struct snd_soc_card *card, *c; 2858 int ret; 2859 int i; 2860 2861 mutex_lock(&client_mutex); 2862 2863 if (component->driver->endianness) { 2864 for (i = 0; i < num_dai; i++) { 2865 convert_endianness_formats(&dai_drv[i].playback); 2866 convert_endianness_formats(&dai_drv[i].capture); 2867 } 2868 } 2869 2870 ret = snd_soc_register_dais(component, dai_drv, num_dai); 2871 if (ret < 0) { 2872 dev_err(component->dev, "ASoC: Failed to register DAIs: %d\n", 2873 ret); 2874 goto err_cleanup; 2875 } 2876 2877 if (!component->driver->write && !component->driver->read) { 2878 if (!component->regmap) 2879 component->regmap = dev_get_regmap(component->dev, 2880 NULL); 2881 if (component->regmap) 2882 snd_soc_component_setup_regmap(component); 2883 } 2884 2885 /* see for_each_component */ 2886 list_add(&component->list, &component_list); 2887 2888 list_for_each_entry_safe(card, c, &unbind_card_list, list) 2889 snd_soc_rebind_card(card); 2890 2891 err_cleanup: 2892 if (ret < 0) 2893 snd_soc_del_component_unlocked(component); 2894 2895 mutex_unlock(&client_mutex); 2896 return ret; 2897 } 2898 EXPORT_SYMBOL_GPL(snd_soc_add_component); 2899 2900 int snd_soc_register_component(struct device *dev, 2901 const struct snd_soc_component_driver *component_driver, 2902 struct snd_soc_dai_driver *dai_drv, 2903 int num_dai) 2904 { 2905 struct snd_soc_component *component; 2906 int ret; 2907 2908 component = devm_kzalloc(dev, sizeof(*component), GFP_KERNEL); 2909 if (!component) 2910 return -ENOMEM; 2911 2912 ret = snd_soc_component_initialize(component, component_driver, dev); 2913 if (ret < 0) 2914 return ret; 2915 2916 return snd_soc_add_component(component, dai_drv, num_dai); 2917 } 2918 EXPORT_SYMBOL_GPL(snd_soc_register_component); 2919 2920 /** 2921 * snd_soc_unregister_component_by_driver - Unregister component using a given driver 2922 * from the ASoC core 2923 * 2924 * @dev: The device to unregister 2925 * @component_driver: The component driver to unregister 2926 */ 2927 void snd_soc_unregister_component_by_driver(struct device *dev, 2928 const struct snd_soc_component_driver *component_driver) 2929 { 2930 const char *driver_name = NULL; 2931 2932 if (component_driver) 2933 driver_name = component_driver->name; 2934 2935 mutex_lock(&client_mutex); 2936 while (1) { 2937 struct snd_soc_component *component = snd_soc_lookup_component_nolocked(dev, driver_name); 2938 2939 if (!component) 2940 break; 2941 2942 snd_soc_del_component_unlocked(component); 2943 } 2944 mutex_unlock(&client_mutex); 2945 } 2946 EXPORT_SYMBOL_GPL(snd_soc_unregister_component_by_driver); 2947 2948 /* Retrieve a card's name from device tree */ 2949 int snd_soc_of_parse_card_name(struct snd_soc_card *card, 2950 const char *propname) 2951 { 2952 struct device_node *np; 2953 int ret; 2954 2955 if (!card->dev) { 2956 pr_err("card->dev is not set before calling %s\n", __func__); 2957 return -EINVAL; 2958 } 2959 2960 np = card->dev->of_node; 2961 2962 ret = of_property_read_string_index(np, propname, 0, &card->name); 2963 /* 2964 * EINVAL means the property does not exist. This is fine providing 2965 * card->name was previously set, which is checked later in 2966 * snd_soc_register_card. 2967 */ 2968 if (ret < 0 && ret != -EINVAL) { 2969 dev_err(card->dev, 2970 "ASoC: Property '%s' could not be read: %d\n", 2971 propname, ret); 2972 return ret; 2973 } 2974 2975 return 0; 2976 } 2977 EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name); 2978 2979 static const struct snd_soc_dapm_widget simple_widgets[] = { 2980 SND_SOC_DAPM_MIC("Microphone", NULL), 2981 SND_SOC_DAPM_LINE("Line", NULL), 2982 SND_SOC_DAPM_HP("Headphone", NULL), 2983 SND_SOC_DAPM_SPK("Speaker", NULL), 2984 }; 2985 2986 int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card, 2987 const char *propname) 2988 { 2989 struct device_node *np = card->dev->of_node; 2990 struct snd_soc_dapm_widget *widgets; 2991 const char *template, *wname; 2992 int i, j, num_widgets; 2993 2994 num_widgets = of_property_count_strings(np, propname); 2995 if (num_widgets < 0) { 2996 dev_err(card->dev, 2997 "ASoC: Property '%s' does not exist\n", propname); 2998 return -EINVAL; 2999 } 3000 if (!num_widgets) { 3001 dev_err(card->dev, "ASoC: Property '%s's length is zero\n", 3002 propname); 3003 return -EINVAL; 3004 } 3005 if (num_widgets & 1) { 3006 dev_err(card->dev, 3007 "ASoC: Property '%s' length is not even\n", propname); 3008 return -EINVAL; 3009 } 3010 3011 num_widgets /= 2; 3012 3013 widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets), 3014 GFP_KERNEL); 3015 if (!widgets) { 3016 dev_err(card->dev, 3017 "ASoC: Could not allocate memory for widgets\n"); 3018 return -ENOMEM; 3019 } 3020 3021 for (i = 0; i < num_widgets; i++) { 3022 int ret = of_property_read_string_index(np, propname, 3023 2 * i, &template); 3024 if (ret) { 3025 dev_err(card->dev, 3026 "ASoC: Property '%s' index %d read error:%d\n", 3027 propname, 2 * i, ret); 3028 return -EINVAL; 3029 } 3030 3031 for (j = 0; j < ARRAY_SIZE(simple_widgets); j++) { 3032 if (!strncmp(template, simple_widgets[j].name, 3033 strlen(simple_widgets[j].name))) { 3034 widgets[i] = simple_widgets[j]; 3035 break; 3036 } 3037 } 3038 3039 if (j >= ARRAY_SIZE(simple_widgets)) { 3040 dev_err(card->dev, 3041 "ASoC: DAPM widget '%s' is not supported\n", 3042 template); 3043 return -EINVAL; 3044 } 3045 3046 ret = of_property_read_string_index(np, propname, 3047 (2 * i) + 1, 3048 &wname); 3049 if (ret) { 3050 dev_err(card->dev, 3051 "ASoC: Property '%s' index %d read error:%d\n", 3052 propname, (2 * i) + 1, ret); 3053 return -EINVAL; 3054 } 3055 3056 widgets[i].name = wname; 3057 } 3058 3059 card->of_dapm_widgets = widgets; 3060 card->num_of_dapm_widgets = num_widgets; 3061 3062 return 0; 3063 } 3064 EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets); 3065 3066 int snd_soc_of_parse_pin_switches(struct snd_soc_card *card, const char *prop) 3067 { 3068 const unsigned int nb_controls_max = 16; 3069 const char **strings, *control_name; 3070 struct snd_kcontrol_new *controls; 3071 struct device *dev = card->dev; 3072 unsigned int i, nb_controls; 3073 int ret; 3074 3075 if (!of_property_present(dev->of_node, prop)) 3076 return 0; 3077 3078 strings = devm_kcalloc(dev, nb_controls_max, 3079 sizeof(*strings), GFP_KERNEL); 3080 if (!strings) 3081 return -ENOMEM; 3082 3083 ret = of_property_read_string_array(dev->of_node, prop, 3084 strings, nb_controls_max); 3085 if (ret < 0) 3086 return ret; 3087 3088 nb_controls = (unsigned int)ret; 3089 3090 controls = devm_kcalloc(dev, nb_controls, 3091 sizeof(*controls), GFP_KERNEL); 3092 if (!controls) 3093 return -ENOMEM; 3094 3095 for (i = 0; i < nb_controls; i++) { 3096 control_name = devm_kasprintf(dev, GFP_KERNEL, 3097 "%s Switch", strings[i]); 3098 if (!control_name) 3099 return -ENOMEM; 3100 3101 controls[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER; 3102 controls[i].name = control_name; 3103 controls[i].info = snd_soc_dapm_info_pin_switch; 3104 controls[i].get = snd_soc_dapm_get_pin_switch; 3105 controls[i].put = snd_soc_dapm_put_pin_switch; 3106 controls[i].private_value = (unsigned long)strings[i]; 3107 } 3108 3109 card->controls = controls; 3110 card->num_controls = nb_controls; 3111 3112 return 0; 3113 } 3114 EXPORT_SYMBOL_GPL(snd_soc_of_parse_pin_switches); 3115 3116 int snd_soc_of_get_slot_mask(struct device_node *np, 3117 const char *prop_name, 3118 unsigned int *mask) 3119 { 3120 u32 val; 3121 const __be32 *of_slot_mask = of_get_property(np, prop_name, &val); 3122 int i; 3123 3124 if (!of_slot_mask) 3125 return 0; 3126 val /= sizeof(u32); 3127 for (i = 0; i < val; i++) 3128 if (be32_to_cpup(&of_slot_mask[i])) 3129 *mask |= (1 << i); 3130 3131 return val; 3132 } 3133 EXPORT_SYMBOL_GPL(snd_soc_of_get_slot_mask); 3134 3135 int snd_soc_of_parse_tdm_slot(struct device_node *np, 3136 unsigned int *tx_mask, 3137 unsigned int *rx_mask, 3138 unsigned int *slots, 3139 unsigned int *slot_width) 3140 { 3141 u32 val; 3142 int ret; 3143 3144 if (tx_mask) 3145 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask", tx_mask); 3146 if (rx_mask) 3147 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask", rx_mask); 3148 3149 ret = of_property_read_u32(np, "dai-tdm-slot-num", &val); 3150 if (ret && ret != -EINVAL) 3151 return ret; 3152 if (!ret && slots) 3153 *slots = val; 3154 3155 ret = of_property_read_u32(np, "dai-tdm-slot-width", &val); 3156 if (ret && ret != -EINVAL) 3157 return ret; 3158 if (!ret && slot_width) 3159 *slot_width = val; 3160 3161 return 0; 3162 } 3163 EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot); 3164 3165 void snd_soc_dlc_use_cpu_as_platform(struct snd_soc_dai_link_component *platforms, 3166 struct snd_soc_dai_link_component *cpus) 3167 { 3168 platforms->of_node = cpus->of_node; 3169 platforms->dai_args = cpus->dai_args; 3170 } 3171 EXPORT_SYMBOL_GPL(snd_soc_dlc_use_cpu_as_platform); 3172 3173 void snd_soc_of_parse_node_prefix(struct device_node *np, 3174 struct snd_soc_codec_conf *codec_conf, 3175 struct device_node *of_node, 3176 const char *propname) 3177 { 3178 const char *str; 3179 int ret; 3180 3181 ret = of_property_read_string(np, propname, &str); 3182 if (ret < 0) { 3183 /* no prefix is not error */ 3184 return; 3185 } 3186 3187 codec_conf->dlc.of_node = of_node; 3188 codec_conf->name_prefix = str; 3189 } 3190 EXPORT_SYMBOL_GPL(snd_soc_of_parse_node_prefix); 3191 3192 int snd_soc_of_parse_audio_routing(struct snd_soc_card *card, 3193 const char *propname) 3194 { 3195 struct device_node *np = card->dev->of_node; 3196 int num_routes; 3197 struct snd_soc_dapm_route *routes; 3198 int i; 3199 3200 num_routes = of_property_count_strings(np, propname); 3201 if (num_routes < 0 || num_routes & 1) { 3202 dev_err(card->dev, 3203 "ASoC: Property '%s' does not exist or its length is not even\n", 3204 propname); 3205 return -EINVAL; 3206 } 3207 num_routes /= 2; 3208 3209 routes = devm_kcalloc(card->dev, num_routes, sizeof(*routes), 3210 GFP_KERNEL); 3211 if (!routes) { 3212 dev_err(card->dev, 3213 "ASoC: Could not allocate DAPM route table\n"); 3214 return -ENOMEM; 3215 } 3216 3217 for (i = 0; i < num_routes; i++) { 3218 int ret = of_property_read_string_index(np, propname, 3219 2 * i, &routes[i].sink); 3220 if (ret) { 3221 dev_err(card->dev, 3222 "ASoC: Property '%s' index %d could not be read: %d\n", 3223 propname, 2 * i, ret); 3224 return -EINVAL; 3225 } 3226 ret = of_property_read_string_index(np, propname, 3227 (2 * i) + 1, &routes[i].source); 3228 if (ret) { 3229 dev_err(card->dev, 3230 "ASoC: Property '%s' index %d could not be read: %d\n", 3231 propname, (2 * i) + 1, ret); 3232 return -EINVAL; 3233 } 3234 } 3235 3236 card->num_of_dapm_routes = num_routes; 3237 card->of_dapm_routes = routes; 3238 3239 return 0; 3240 } 3241 EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing); 3242 3243 int snd_soc_of_parse_aux_devs(struct snd_soc_card *card, const char *propname) 3244 { 3245 struct device_node *node = card->dev->of_node; 3246 struct snd_soc_aux_dev *aux; 3247 int num, i; 3248 3249 num = of_count_phandle_with_args(node, propname, NULL); 3250 if (num == -ENOENT) { 3251 return 0; 3252 } else if (num < 0) { 3253 dev_err(card->dev, "ASOC: Property '%s' could not be read: %d\n", 3254 propname, num); 3255 return num; 3256 } 3257 3258 aux = devm_kcalloc(card->dev, num, sizeof(*aux), GFP_KERNEL); 3259 if (!aux) 3260 return -ENOMEM; 3261 card->aux_dev = aux; 3262 card->num_aux_devs = num; 3263 3264 for_each_card_pre_auxs(card, i, aux) { 3265 aux->dlc.of_node = of_parse_phandle(node, propname, i); 3266 if (!aux->dlc.of_node) 3267 return -EINVAL; 3268 } 3269 3270 return 0; 3271 } 3272 EXPORT_SYMBOL_GPL(snd_soc_of_parse_aux_devs); 3273 3274 unsigned int snd_soc_daifmt_clock_provider_flipped(unsigned int dai_fmt) 3275 { 3276 unsigned int inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK; 3277 3278 switch (dai_fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) { 3279 case SND_SOC_DAIFMT_CBP_CFP: 3280 inv_dai_fmt |= SND_SOC_DAIFMT_CBC_CFC; 3281 break; 3282 case SND_SOC_DAIFMT_CBP_CFC: 3283 inv_dai_fmt |= SND_SOC_DAIFMT_CBC_CFP; 3284 break; 3285 case SND_SOC_DAIFMT_CBC_CFP: 3286 inv_dai_fmt |= SND_SOC_DAIFMT_CBP_CFC; 3287 break; 3288 case SND_SOC_DAIFMT_CBC_CFC: 3289 inv_dai_fmt |= SND_SOC_DAIFMT_CBP_CFP; 3290 break; 3291 } 3292 3293 return inv_dai_fmt; 3294 } 3295 EXPORT_SYMBOL_GPL(snd_soc_daifmt_clock_provider_flipped); 3296 3297 unsigned int snd_soc_daifmt_clock_provider_from_bitmap(unsigned int bit_frame) 3298 { 3299 /* 3300 * bit_frame is return value from 3301 * snd_soc_daifmt_parse_clock_provider_raw() 3302 */ 3303 3304 /* Codec base */ 3305 switch (bit_frame) { 3306 case 0x11: 3307 return SND_SOC_DAIFMT_CBP_CFP; 3308 case 0x10: 3309 return SND_SOC_DAIFMT_CBP_CFC; 3310 case 0x01: 3311 return SND_SOC_DAIFMT_CBC_CFP; 3312 default: 3313 return SND_SOC_DAIFMT_CBC_CFC; 3314 } 3315 3316 return 0; 3317 } 3318 EXPORT_SYMBOL_GPL(snd_soc_daifmt_clock_provider_from_bitmap); 3319 3320 unsigned int snd_soc_daifmt_parse_format(struct device_node *np, 3321 const char *prefix) 3322 { 3323 int ret; 3324 char prop[128]; 3325 unsigned int format = 0; 3326 int bit, frame; 3327 const char *str; 3328 struct { 3329 char *name; 3330 unsigned int val; 3331 } of_fmt_table[] = { 3332 { "i2s", SND_SOC_DAIFMT_I2S }, 3333 { "right_j", SND_SOC_DAIFMT_RIGHT_J }, 3334 { "left_j", SND_SOC_DAIFMT_LEFT_J }, 3335 { "dsp_a", SND_SOC_DAIFMT_DSP_A }, 3336 { "dsp_b", SND_SOC_DAIFMT_DSP_B }, 3337 { "ac97", SND_SOC_DAIFMT_AC97 }, 3338 { "pdm", SND_SOC_DAIFMT_PDM}, 3339 { "msb", SND_SOC_DAIFMT_MSB }, 3340 { "lsb", SND_SOC_DAIFMT_LSB }, 3341 }; 3342 3343 if (!prefix) 3344 prefix = ""; 3345 3346 /* 3347 * check "dai-format = xxx" 3348 * or "[prefix]format = xxx" 3349 * SND_SOC_DAIFMT_FORMAT_MASK area 3350 */ 3351 ret = of_property_read_string(np, "dai-format", &str); 3352 if (ret < 0) { 3353 snprintf(prop, sizeof(prop), "%sformat", prefix); 3354 ret = of_property_read_string(np, prop, &str); 3355 } 3356 if (ret == 0) { 3357 int i; 3358 3359 for (i = 0; i < ARRAY_SIZE(of_fmt_table); i++) { 3360 if (strcmp(str, of_fmt_table[i].name) == 0) { 3361 format |= of_fmt_table[i].val; 3362 break; 3363 } 3364 } 3365 } 3366 3367 /* 3368 * check "[prefix]continuous-clock" 3369 * SND_SOC_DAIFMT_CLOCK_MASK area 3370 */ 3371 snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix); 3372 if (of_property_read_bool(np, prop)) 3373 format |= SND_SOC_DAIFMT_CONT; 3374 else 3375 format |= SND_SOC_DAIFMT_GATED; 3376 3377 /* 3378 * check "[prefix]bitclock-inversion" 3379 * check "[prefix]frame-inversion" 3380 * SND_SOC_DAIFMT_INV_MASK area 3381 */ 3382 snprintf(prop, sizeof(prop), "%sbitclock-inversion", prefix); 3383 bit = of_property_read_bool(np, prop); 3384 3385 snprintf(prop, sizeof(prop), "%sframe-inversion", prefix); 3386 frame = of_property_read_bool(np, prop); 3387 3388 switch ((bit << 4) + frame) { 3389 case 0x11: 3390 format |= SND_SOC_DAIFMT_IB_IF; 3391 break; 3392 case 0x10: 3393 format |= SND_SOC_DAIFMT_IB_NF; 3394 break; 3395 case 0x01: 3396 format |= SND_SOC_DAIFMT_NB_IF; 3397 break; 3398 default: 3399 /* SND_SOC_DAIFMT_NB_NF is default */ 3400 break; 3401 } 3402 3403 return format; 3404 } 3405 EXPORT_SYMBOL_GPL(snd_soc_daifmt_parse_format); 3406 3407 unsigned int snd_soc_daifmt_parse_clock_provider_raw(struct device_node *np, 3408 const char *prefix, 3409 struct device_node **bitclkmaster, 3410 struct device_node **framemaster) 3411 { 3412 char prop[128]; 3413 unsigned int bit, frame; 3414 3415 if (!np) 3416 return 0; 3417 3418 if (!prefix) 3419 prefix = ""; 3420 3421 /* 3422 * check "[prefix]bitclock-master" 3423 * check "[prefix]frame-master" 3424 */ 3425 snprintf(prop, sizeof(prop), "%sbitclock-master", prefix); 3426 bit = of_property_present(np, prop); 3427 if (bit && bitclkmaster) 3428 *bitclkmaster = of_parse_phandle(np, prop, 0); 3429 3430 snprintf(prop, sizeof(prop), "%sframe-master", prefix); 3431 frame = of_property_present(np, prop); 3432 if (frame && framemaster) 3433 *framemaster = of_parse_phandle(np, prop, 0); 3434 3435 /* 3436 * return bitmap. 3437 * It will be parameter of 3438 * snd_soc_daifmt_clock_provider_from_bitmap() 3439 */ 3440 return (bit << 4) + frame; 3441 } 3442 EXPORT_SYMBOL_GPL(snd_soc_daifmt_parse_clock_provider_raw); 3443 3444 int snd_soc_get_stream_cpu(const struct snd_soc_dai_link *dai_link, int stream) 3445 { 3446 /* 3447 * [Normal] 3448 * 3449 * Playback 3450 * CPU : SNDRV_PCM_STREAM_PLAYBACK 3451 * Codec: SNDRV_PCM_STREAM_PLAYBACK 3452 * 3453 * Capture 3454 * CPU : SNDRV_PCM_STREAM_CAPTURE 3455 * Codec: SNDRV_PCM_STREAM_CAPTURE 3456 */ 3457 if (!dai_link->c2c_params) 3458 return stream; 3459 3460 /* 3461 * [Codec2Codec] 3462 * 3463 * Playback 3464 * CPU : SNDRV_PCM_STREAM_CAPTURE 3465 * Codec: SNDRV_PCM_STREAM_PLAYBACK 3466 * 3467 * Capture 3468 * CPU : SNDRV_PCM_STREAM_PLAYBACK 3469 * Codec: SNDRV_PCM_STREAM_CAPTURE 3470 */ 3471 if (stream == SNDRV_PCM_STREAM_CAPTURE) 3472 return SNDRV_PCM_STREAM_PLAYBACK; 3473 3474 return SNDRV_PCM_STREAM_CAPTURE; 3475 } 3476 EXPORT_SYMBOL_GPL(snd_soc_get_stream_cpu); 3477 3478 int snd_soc_get_dai_id(struct device_node *ep) 3479 { 3480 struct snd_soc_component *component; 3481 struct snd_soc_dai_link_component dlc = { 3482 .of_node = of_graph_get_port_parent(ep), 3483 }; 3484 int ret; 3485 3486 3487 /* 3488 * For example HDMI case, HDMI has video/sound port, 3489 * but ALSA SoC needs sound port number only. 3490 * Thus counting HDMI DT port/endpoint doesn't work. 3491 * Then, it should have .of_xlate_dai_id 3492 */ 3493 ret = -ENOTSUPP; 3494 mutex_lock(&client_mutex); 3495 component = soc_find_component(&dlc); 3496 if (component) 3497 ret = snd_soc_component_of_xlate_dai_id(component, ep); 3498 mutex_unlock(&client_mutex); 3499 3500 of_node_put(dlc.of_node); 3501 3502 return ret; 3503 } 3504 EXPORT_SYMBOL_GPL(snd_soc_get_dai_id); 3505 3506 int snd_soc_get_dlc(const struct of_phandle_args *args, struct snd_soc_dai_link_component *dlc) 3507 { 3508 struct snd_soc_component *pos; 3509 int ret = -EPROBE_DEFER; 3510 3511 mutex_lock(&client_mutex); 3512 for_each_component(pos) { 3513 struct device_node *component_of_node = soc_component_to_node(pos); 3514 3515 if (component_of_node != args->np || !pos->num_dai) 3516 continue; 3517 3518 ret = snd_soc_component_of_xlate_dai_name(pos, args, &dlc->dai_name); 3519 if (ret == -ENOTSUPP) { 3520 struct snd_soc_dai *dai; 3521 int id = -1; 3522 3523 switch (args->args_count) { 3524 case 0: 3525 id = 0; /* same as dai_drv[0] */ 3526 break; 3527 case 1: 3528 id = args->args[0]; 3529 break; 3530 default: 3531 /* not supported */ 3532 break; 3533 } 3534 3535 if (id < 0 || id >= pos->num_dai) { 3536 ret = -EINVAL; 3537 continue; 3538 } 3539 3540 ret = 0; 3541 3542 /* find target DAI */ 3543 for_each_component_dais(pos, dai) { 3544 if (id == 0) 3545 break; 3546 id--; 3547 } 3548 3549 dlc->dai_name = snd_soc_dai_name_get(dai); 3550 } else if (ret) { 3551 /* 3552 * if another error than ENOTSUPP is returned go on and 3553 * check if another component is provided with the same 3554 * node. This may happen if a device provides several 3555 * components 3556 */ 3557 continue; 3558 } 3559 3560 break; 3561 } 3562 3563 if (ret == 0) 3564 dlc->of_node = args->np; 3565 3566 mutex_unlock(&client_mutex); 3567 return ret; 3568 } 3569 EXPORT_SYMBOL_GPL(snd_soc_get_dlc); 3570 3571 int snd_soc_of_get_dlc(struct device_node *of_node, 3572 struct of_phandle_args *args, 3573 struct snd_soc_dai_link_component *dlc, 3574 int index) 3575 { 3576 struct of_phandle_args __args; 3577 int ret; 3578 3579 if (!args) 3580 args = &__args; 3581 3582 ret = of_parse_phandle_with_args(of_node, "sound-dai", 3583 "#sound-dai-cells", index, args); 3584 if (ret) 3585 return ret; 3586 3587 return snd_soc_get_dlc(args, dlc); 3588 } 3589 EXPORT_SYMBOL_GPL(snd_soc_of_get_dlc); 3590 3591 int snd_soc_get_dai_name(const struct of_phandle_args *args, 3592 const char **dai_name) 3593 { 3594 struct snd_soc_dai_link_component dlc; 3595 int ret = snd_soc_get_dlc(args, &dlc); 3596 3597 if (ret == 0) 3598 *dai_name = dlc.dai_name; 3599 3600 return ret; 3601 } 3602 EXPORT_SYMBOL_GPL(snd_soc_get_dai_name); 3603 3604 int snd_soc_of_get_dai_name(struct device_node *of_node, 3605 const char **dai_name, int index) 3606 { 3607 struct snd_soc_dai_link_component dlc; 3608 int ret = snd_soc_of_get_dlc(of_node, NULL, &dlc, index); 3609 3610 if (ret == 0) 3611 *dai_name = dlc.dai_name; 3612 3613 return ret; 3614 } 3615 EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name); 3616 3617 struct snd_soc_dai *snd_soc_get_dai_via_args(const struct of_phandle_args *dai_args) 3618 { 3619 struct snd_soc_dai *dai; 3620 struct snd_soc_component *component; 3621 3622 mutex_lock(&client_mutex); 3623 for_each_component(component) { 3624 for_each_component_dais(component, dai) 3625 if (snd_soc_is_match_dai_args(dai->driver->dai_args, dai_args)) 3626 goto found; 3627 } 3628 dai = NULL; 3629 found: 3630 mutex_unlock(&client_mutex); 3631 return dai; 3632 } 3633 EXPORT_SYMBOL_GPL(snd_soc_get_dai_via_args); 3634 3635 static void __snd_soc_of_put_component(struct snd_soc_dai_link_component *component) 3636 { 3637 if (component->of_node) { 3638 of_node_put(component->of_node); 3639 component->of_node = NULL; 3640 } 3641 } 3642 3643 static int __snd_soc_of_get_dai_link_component_alloc( 3644 struct device *dev, struct device_node *of_node, 3645 struct snd_soc_dai_link_component **ret_component, 3646 int *ret_num) 3647 { 3648 struct snd_soc_dai_link_component *component; 3649 int num; 3650 3651 /* Count the number of CPUs/CODECs */ 3652 num = of_count_phandle_with_args(of_node, "sound-dai", "#sound-dai-cells"); 3653 if (num <= 0) { 3654 if (num == -ENOENT) 3655 dev_err(dev, "No 'sound-dai' property\n"); 3656 else 3657 dev_err(dev, "Bad phandle in 'sound-dai'\n"); 3658 return num; 3659 } 3660 component = devm_kcalloc(dev, num, sizeof(*component), GFP_KERNEL); 3661 if (!component) 3662 return -ENOMEM; 3663 3664 *ret_component = component; 3665 *ret_num = num; 3666 3667 return 0; 3668 } 3669 3670 /* 3671 * snd_soc_of_put_dai_link_codecs - Dereference device nodes in the codecs array 3672 * @dai_link: DAI link 3673 * 3674 * Dereference device nodes acquired by snd_soc_of_get_dai_link_codecs(). 3675 */ 3676 void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link) 3677 { 3678 struct snd_soc_dai_link_component *component; 3679 int index; 3680 3681 for_each_link_codecs(dai_link, index, component) 3682 __snd_soc_of_put_component(component); 3683 } 3684 EXPORT_SYMBOL_GPL(snd_soc_of_put_dai_link_codecs); 3685 3686 /* 3687 * snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree 3688 * @dev: Card device 3689 * @of_node: Device node 3690 * @dai_link: DAI link 3691 * 3692 * Builds an array of CODEC DAI components from the DAI link property 3693 * 'sound-dai'. 3694 * The array is set in the DAI link and the number of DAIs is set accordingly. 3695 * The device nodes in the array (of_node) must be dereferenced by calling 3696 * snd_soc_of_put_dai_link_codecs() on @dai_link. 3697 * 3698 * Returns 0 for success 3699 */ 3700 int snd_soc_of_get_dai_link_codecs(struct device *dev, 3701 struct device_node *of_node, 3702 struct snd_soc_dai_link *dai_link) 3703 { 3704 struct snd_soc_dai_link_component *component; 3705 int index, ret; 3706 3707 ret = __snd_soc_of_get_dai_link_component_alloc(dev, of_node, 3708 &dai_link->codecs, &dai_link->num_codecs); 3709 if (ret < 0) 3710 return ret; 3711 3712 /* Parse the list */ 3713 for_each_link_codecs(dai_link, index, component) { 3714 ret = snd_soc_of_get_dlc(of_node, NULL, component, index); 3715 if (ret) 3716 goto err; 3717 } 3718 return 0; 3719 err: 3720 snd_soc_of_put_dai_link_codecs(dai_link); 3721 dai_link->codecs = NULL; 3722 dai_link->num_codecs = 0; 3723 return ret; 3724 } 3725 EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs); 3726 3727 /* 3728 * snd_soc_of_put_dai_link_cpus - Dereference device nodes in the codecs array 3729 * @dai_link: DAI link 3730 * 3731 * Dereference device nodes acquired by snd_soc_of_get_dai_link_cpus(). 3732 */ 3733 void snd_soc_of_put_dai_link_cpus(struct snd_soc_dai_link *dai_link) 3734 { 3735 struct snd_soc_dai_link_component *component; 3736 int index; 3737 3738 for_each_link_cpus(dai_link, index, component) 3739 __snd_soc_of_put_component(component); 3740 } 3741 EXPORT_SYMBOL_GPL(snd_soc_of_put_dai_link_cpus); 3742 3743 /* 3744 * snd_soc_of_get_dai_link_cpus - Parse a list of CPU DAIs in the devicetree 3745 * @dev: Card device 3746 * @of_node: Device node 3747 * @dai_link: DAI link 3748 * 3749 * Is analogous to snd_soc_of_get_dai_link_codecs but parses a list of CPU DAIs 3750 * instead. 3751 * 3752 * Returns 0 for success 3753 */ 3754 int snd_soc_of_get_dai_link_cpus(struct device *dev, 3755 struct device_node *of_node, 3756 struct snd_soc_dai_link *dai_link) 3757 { 3758 struct snd_soc_dai_link_component *component; 3759 int index, ret; 3760 3761 /* Count the number of CPUs */ 3762 ret = __snd_soc_of_get_dai_link_component_alloc(dev, of_node, 3763 &dai_link->cpus, &dai_link->num_cpus); 3764 if (ret < 0) 3765 return ret; 3766 3767 /* Parse the list */ 3768 for_each_link_cpus(dai_link, index, component) { 3769 ret = snd_soc_of_get_dlc(of_node, NULL, component, index); 3770 if (ret) 3771 goto err; 3772 } 3773 return 0; 3774 err: 3775 snd_soc_of_put_dai_link_cpus(dai_link); 3776 dai_link->cpus = NULL; 3777 dai_link->num_cpus = 0; 3778 return ret; 3779 } 3780 EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_cpus); 3781 3782 static int __init snd_soc_init(void) 3783 { 3784 int ret; 3785 3786 snd_soc_debugfs_init(); 3787 ret = snd_soc_util_init(); 3788 if (ret) 3789 goto err_util_init; 3790 3791 ret = platform_driver_register(&soc_driver); 3792 if (ret) 3793 goto err_register; 3794 return 0; 3795 3796 err_register: 3797 snd_soc_util_exit(); 3798 err_util_init: 3799 snd_soc_debugfs_exit(); 3800 return ret; 3801 } 3802 module_init(snd_soc_init); 3803 3804 static void __exit snd_soc_exit(void) 3805 { 3806 snd_soc_util_exit(); 3807 snd_soc_debugfs_exit(); 3808 3809 platform_driver_unregister(&soc_driver); 3810 } 3811 module_exit(snd_soc_exit); 3812 3813 /* Module information */ 3814 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk"); 3815 MODULE_DESCRIPTION("ALSA SoC Core"); 3816 MODULE_LICENSE("GPL"); 3817 MODULE_ALIAS("platform:soc-audio"); 3818