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 = snd_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 snd_soc_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 snd_soc_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 if (!rtd) 1143 return; 1144 1145 lockdep_assert_held(&client_mutex); 1146 1147 /* 1148 * Notify the machine driver for extra destruction 1149 */ 1150 snd_soc_card_remove_dai_link(card, rtd->dai_link); 1151 1152 soc_free_pcm_runtime(rtd); 1153 } 1154 EXPORT_SYMBOL_GPL(snd_soc_remove_pcm_runtime); 1155 1156 /** 1157 * snd_soc_add_pcm_runtime - Add a pcm_runtime dynamically via dai_link 1158 * @card: The ASoC card to which the pcm_runtime is added 1159 * @dai_link: The DAI link to find pcm_runtime 1160 * 1161 * This function adds a pcm_runtime ASoC card by using dai_link. 1162 * 1163 * Note: Topology can use this API to add pcm_runtime when probing the 1164 * topology component. And machine drivers can still define static 1165 * DAI links in dai_link array. 1166 */ 1167 static int snd_soc_add_pcm_runtime(struct snd_soc_card *card, 1168 struct snd_soc_dai_link *dai_link) 1169 { 1170 struct snd_soc_pcm_runtime *rtd; 1171 struct snd_soc_dai_link_component *codec, *platform, *cpu; 1172 struct snd_soc_component *component; 1173 int i, id, ret; 1174 1175 lockdep_assert_held(&client_mutex); 1176 1177 /* 1178 * Notify the machine driver for extra initialization 1179 */ 1180 ret = snd_soc_card_add_dai_link(card, dai_link); 1181 if (ret < 0) 1182 return ret; 1183 1184 if (dai_link->ignore) 1185 return 0; 1186 1187 dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name); 1188 1189 ret = soc_dai_link_sanity_check(card, dai_link); 1190 if (ret < 0) 1191 return ret; 1192 1193 rtd = soc_new_pcm_runtime(card, dai_link); 1194 if (!rtd) 1195 return -ENOMEM; 1196 1197 for_each_link_cpus(dai_link, i, cpu) { 1198 snd_soc_rtd_to_cpu(rtd, i) = snd_soc_find_dai(cpu); 1199 if (!snd_soc_rtd_to_cpu(rtd, i)) { 1200 dev_info(card->dev, "ASoC: CPU DAI %s not registered\n", 1201 cpu->dai_name); 1202 goto _err_defer; 1203 } 1204 snd_soc_rtd_add_component(rtd, snd_soc_rtd_to_cpu(rtd, i)->component); 1205 } 1206 1207 /* Find CODEC from registered CODECs */ 1208 for_each_link_codecs(dai_link, i, codec) { 1209 snd_soc_rtd_to_codec(rtd, i) = snd_soc_find_dai(codec); 1210 if (!snd_soc_rtd_to_codec(rtd, i)) { 1211 dev_info(card->dev, "ASoC: CODEC DAI %s not registered\n", 1212 codec->dai_name); 1213 goto _err_defer; 1214 } 1215 1216 snd_soc_rtd_add_component(rtd, snd_soc_rtd_to_codec(rtd, i)->component); 1217 } 1218 1219 /* Find PLATFORM from registered PLATFORMs */ 1220 for_each_link_platforms(dai_link, i, platform) { 1221 for_each_component(component) { 1222 if (!snd_soc_is_matching_component(platform, component)) 1223 continue; 1224 1225 if (snd_soc_component_is_dummy(component) && component->num_dai) 1226 continue; 1227 1228 snd_soc_rtd_add_component(rtd, component); 1229 } 1230 } 1231 1232 /* 1233 * Most drivers will register their PCMs using DAI link ordering but 1234 * topology based drivers can use the DAI link id field to set PCM 1235 * device number and then use rtd + a base offset of the BEs. 1236 * 1237 * FIXME 1238 * 1239 * This should be implemented by using "dai_link" feature instead of 1240 * "component" feature. 1241 */ 1242 id = rtd->id; 1243 for_each_rtd_components(rtd, i, component) { 1244 if (!component->driver->use_dai_pcm_id) 1245 continue; 1246 1247 if (rtd->dai_link->no_pcm) 1248 id += component->driver->be_pcm_base; 1249 else 1250 id = rtd->dai_link->id; 1251 } 1252 rtd->id = id; 1253 1254 return 0; 1255 1256 _err_defer: 1257 snd_soc_remove_pcm_runtime(card, rtd); 1258 return -EPROBE_DEFER; 1259 } 1260 1261 int snd_soc_add_pcm_runtimes(struct snd_soc_card *card, 1262 struct snd_soc_dai_link *dai_link, 1263 int num_dai_link) 1264 { 1265 for (int i = 0; i < num_dai_link; i++) { 1266 int ret; 1267 1268 ret = snd_soc_compensate_channel_connection_map(card, dai_link + i); 1269 if (ret < 0) 1270 return ret; 1271 1272 ret = snd_soc_add_pcm_runtime(card, dai_link + i); 1273 if (ret < 0) 1274 return ret; 1275 } 1276 1277 return 0; 1278 } 1279 EXPORT_SYMBOL_GPL(snd_soc_add_pcm_runtimes); 1280 1281 static void snd_soc_runtime_get_dai_fmt(struct snd_soc_pcm_runtime *rtd) 1282 { 1283 struct snd_soc_dai_link *dai_link = rtd->dai_link; 1284 struct snd_soc_dai *dai, *not_used; 1285 u64 pos, possible_fmt; 1286 unsigned int mask = 0, dai_fmt = 0; 1287 int i, j, priority, pri, until; 1288 1289 /* 1290 * Get selectable format from each DAIs. 1291 * 1292 **************************** 1293 * NOTE 1294 * Using .auto_selectable_formats is not mandatory, 1295 * we can select format manually from Sound Card. 1296 * When use it, driver should list well tested format only. 1297 **************************** 1298 * 1299 * ex) 1300 * auto_selectable_formats (= SND_SOC_POSSIBLE_xxx) 1301 * (A) (B) (C) 1302 * DAI0_: { 0x000F, 0x00F0, 0x0F00 }; 1303 * DAI1 : { 0xF000, 0x0F00 }; 1304 * (X) (Y) 1305 * 1306 * "until" will be 3 in this case (MAX array size from DAI0 and DAI1) 1307 * Here is dev_dbg() message and comments 1308 * 1309 * priority = 1 1310 * DAI0: (pri, fmt) = (1, 000000000000000F) // 1st check (A) DAI1 is not selected 1311 * DAI1: (pri, fmt) = (0, 0000000000000000) // Necessary Waste 1312 * DAI0: (pri, fmt) = (1, 000000000000000F) // 2nd check (A) 1313 * DAI1: (pri, fmt) = (1, 000000000000F000) // (X) 1314 * priority = 2 1315 * DAI0: (pri, fmt) = (2, 00000000000000FF) // 3rd check (A) + (B) 1316 * DAI1: (pri, fmt) = (1, 000000000000F000) // (X) 1317 * DAI0: (pri, fmt) = (2, 00000000000000FF) // 4th check (A) + (B) 1318 * DAI1: (pri, fmt) = (2, 000000000000FF00) // (X) + (Y) 1319 * priority = 3 1320 * DAI0: (pri, fmt) = (3, 0000000000000FFF) // 5th check (A) + (B) + (C) 1321 * DAI1: (pri, fmt) = (2, 000000000000FF00) // (X) + (Y) 1322 * found auto selected format: 0000000000000F00 1323 */ 1324 until = snd_soc_dai_get_fmt_max_priority(rtd); 1325 for (priority = 1; priority <= until; priority++) { 1326 for_each_rtd_dais(rtd, j, not_used) { 1327 1328 possible_fmt = ULLONG_MAX; 1329 for_each_rtd_dais(rtd, i, dai) { 1330 u64 fmt = 0; 1331 1332 pri = (j >= i) ? priority : priority - 1; 1333 fmt = snd_soc_dai_get_fmt(dai, pri); 1334 possible_fmt &= fmt; 1335 } 1336 if (possible_fmt) 1337 goto found; 1338 } 1339 } 1340 /* Not Found */ 1341 return; 1342 found: 1343 /* 1344 * convert POSSIBLE_DAIFMT to DAIFMT 1345 * 1346 * Some basic/default settings on each is defined as 0. 1347 * see 1348 * SND_SOC_DAIFMT_NB_NF 1349 * SND_SOC_DAIFMT_GATED 1350 * 1351 * SND_SOC_DAIFMT_xxx_MASK can't notice it if Sound Card specify 1352 * these value, and will be overwrite to auto selected value. 1353 * 1354 * To avoid such issue, loop from 63 to 0 here. 1355 * Small number of SND_SOC_POSSIBLE_xxx will be Hi priority. 1356 * Basic/Default settings of each part and above are defined 1357 * as Hi priority (= small number) of SND_SOC_POSSIBLE_xxx. 1358 */ 1359 for (i = 63; i >= 0; i--) { 1360 pos = 1ULL << i; 1361 switch (possible_fmt & pos) { 1362 /* 1363 * for format 1364 */ 1365 case SND_SOC_POSSIBLE_DAIFMT_I2S: 1366 case SND_SOC_POSSIBLE_DAIFMT_RIGHT_J: 1367 case SND_SOC_POSSIBLE_DAIFMT_LEFT_J: 1368 case SND_SOC_POSSIBLE_DAIFMT_DSP_A: 1369 case SND_SOC_POSSIBLE_DAIFMT_DSP_B: 1370 case SND_SOC_POSSIBLE_DAIFMT_AC97: 1371 case SND_SOC_POSSIBLE_DAIFMT_PDM: 1372 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_FORMAT_MASK) | i; 1373 break; 1374 /* 1375 * for clock 1376 */ 1377 case SND_SOC_POSSIBLE_DAIFMT_CONT: 1378 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_MASK) | SND_SOC_DAIFMT_CONT; 1379 break; 1380 case SND_SOC_POSSIBLE_DAIFMT_GATED: 1381 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_MASK) | SND_SOC_DAIFMT_GATED; 1382 break; 1383 /* 1384 * for clock invert 1385 */ 1386 case SND_SOC_POSSIBLE_DAIFMT_NB_NF: 1387 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_NB_NF; 1388 break; 1389 case SND_SOC_POSSIBLE_DAIFMT_NB_IF: 1390 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_NB_IF; 1391 break; 1392 case SND_SOC_POSSIBLE_DAIFMT_IB_NF: 1393 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_IB_NF; 1394 break; 1395 case SND_SOC_POSSIBLE_DAIFMT_IB_IF: 1396 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_INV_MASK) | SND_SOC_DAIFMT_IB_IF; 1397 break; 1398 /* 1399 * for clock provider / consumer 1400 */ 1401 case SND_SOC_POSSIBLE_DAIFMT_CBP_CFP: 1402 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBP_CFP; 1403 break; 1404 case SND_SOC_POSSIBLE_DAIFMT_CBC_CFP: 1405 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBC_CFP; 1406 break; 1407 case SND_SOC_POSSIBLE_DAIFMT_CBP_CFC: 1408 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBP_CFC; 1409 break; 1410 case SND_SOC_POSSIBLE_DAIFMT_CBC_CFC: 1411 dai_fmt = (dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) | SND_SOC_DAIFMT_CBC_CFC; 1412 break; 1413 } 1414 } 1415 1416 /* 1417 * Some driver might have very complex limitation. 1418 * In such case, user want to auto-select non-limitation part, 1419 * and want to manually specify complex part. 1420 * 1421 * Or for example, if both CPU and Codec can be clock provider, 1422 * but because of its quality, user want to specify it manually. 1423 * 1424 * Use manually specified settings if sound card did. 1425 */ 1426 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_FORMAT_MASK)) 1427 mask |= SND_SOC_DAIFMT_FORMAT_MASK; 1428 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_CLOCK_MASK)) 1429 mask |= SND_SOC_DAIFMT_CLOCK_MASK; 1430 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_INV_MASK)) 1431 mask |= SND_SOC_DAIFMT_INV_MASK; 1432 if (!(dai_link->dai_fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK)) 1433 mask |= SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK; 1434 1435 dai_link->dai_fmt |= (dai_fmt & mask); 1436 } 1437 1438 /** 1439 * snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime 1440 * @rtd: The runtime for which the DAI link format should be changed 1441 * @dai_fmt: The new DAI link format 1442 * 1443 * This function updates the DAI link format for all DAIs connected to the DAI 1444 * link for the specified runtime. 1445 * 1446 * Note: For setups with a static format set the dai_fmt field in the 1447 * corresponding snd_dai_link struct instead of using this function. 1448 * 1449 * Returns 0 on success, otherwise a negative error code. 1450 */ 1451 int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd, 1452 unsigned int dai_fmt) 1453 { 1454 struct snd_soc_dai *cpu_dai; 1455 struct snd_soc_dai *codec_dai; 1456 unsigned int ext_fmt; 1457 unsigned int i; 1458 int ret; 1459 1460 if (!dai_fmt) 1461 return 0; 1462 1463 /* 1464 * dai_fmt has 4 types 1465 * 1. SND_SOC_DAIFMT_FORMAT_MASK 1466 * 2. SND_SOC_DAIFMT_CLOCK 1467 * 3. SND_SOC_DAIFMT_INV 1468 * 4. SND_SOC_DAIFMT_CLOCK_PROVIDER 1469 * 1470 * 4. CLOCK_PROVIDER is set from Codec perspective in dai_fmt. So it will be flipped 1471 * when this function calls set_fmt() for CPU (CBx_CFx -> Bx_Cx). see below. 1472 * This mean, we can't set CPU/Codec both are clock consumer for example. 1473 * New idea handles 4. in each dai->ext_fmt. It can keep compatibility. 1474 * 1475 * Legacy 1476 * dai_fmt includes 1, 2, 3, 4 1477 * 1478 * New idea 1479 * dai_fmt includes 1, 2, 3 1480 * ext_fmt includes 4 1481 */ 1482 for_each_rtd_codec_dais(rtd, i, codec_dai) { 1483 ext_fmt = rtd->dai_link->codecs[i].ext_fmt; 1484 ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt | ext_fmt); 1485 if (ret != 0 && ret != -ENOTSUPP) 1486 return ret; 1487 } 1488 1489 /* Flip the polarity for the "CPU" end of link */ 1490 /* Will effect only for 4. SND_SOC_DAIFMT_CLOCK_PROVIDER */ 1491 dai_fmt = snd_soc_daifmt_clock_provider_flipped(dai_fmt); 1492 1493 for_each_rtd_cpu_dais(rtd, i, cpu_dai) { 1494 ext_fmt = rtd->dai_link->cpus[i].ext_fmt; 1495 ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt | ext_fmt); 1496 if (ret != 0 && ret != -ENOTSUPP) 1497 return ret; 1498 } 1499 1500 return 0; 1501 } 1502 EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt); 1503 1504 static int soc_init_pcm_runtime(struct snd_soc_card *card, 1505 struct snd_soc_pcm_runtime *rtd) 1506 { 1507 struct snd_soc_dai_link *dai_link = rtd->dai_link; 1508 struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(rtd, 0); 1509 int ret; 1510 1511 /* do machine specific initialization */ 1512 ret = snd_soc_link_init(rtd); 1513 if (ret < 0) 1514 return ret; 1515 1516 snd_soc_runtime_get_dai_fmt(rtd); 1517 ret = snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt); 1518 if (ret) 1519 goto err; 1520 1521 /* add DPCM sysfs entries */ 1522 soc_dpcm_debugfs_add(rtd); 1523 1524 /* create compress_device if possible */ 1525 ret = snd_soc_dai_compress_new(cpu_dai, rtd); 1526 if (ret != -ENOTSUPP) 1527 goto err; 1528 1529 /* create the pcm */ 1530 ret = soc_new_pcm(rtd); 1531 if (ret < 0) { 1532 dev_err(card->dev, "ASoC: can't create pcm %s :%d\n", 1533 dai_link->stream_name, ret); 1534 goto err; 1535 } 1536 1537 ret = snd_soc_pcm_dai_new(rtd); 1538 if (ret < 0) 1539 goto err; 1540 1541 rtd->initialized = true; 1542 1543 return 0; 1544 err: 1545 snd_soc_link_exit(rtd); 1546 return ret; 1547 } 1548 1549 static void soc_set_name_prefix(struct snd_soc_card *card, 1550 struct snd_soc_component *component) 1551 { 1552 struct device_node *of_node = soc_component_to_node(component); 1553 const char *str; 1554 int ret, i; 1555 1556 for (i = 0; i < card->num_configs; i++) { 1557 struct snd_soc_codec_conf *map = &card->codec_conf[i]; 1558 1559 if (snd_soc_is_matching_component(&map->dlc, component) && 1560 map->name_prefix) { 1561 component->name_prefix = map->name_prefix; 1562 return; 1563 } 1564 } 1565 1566 /* 1567 * If there is no configuration table or no match in the table, 1568 * check if a prefix is provided in the node 1569 */ 1570 ret = of_property_read_string(of_node, "sound-name-prefix", &str); 1571 if (ret < 0) 1572 return; 1573 1574 component->name_prefix = str; 1575 } 1576 1577 static void soc_remove_component(struct snd_soc_component *component, 1578 int probed) 1579 { 1580 1581 if (!component->card) 1582 return; 1583 1584 if (probed) 1585 snd_soc_component_remove(component); 1586 1587 list_del_init(&component->card_list); 1588 snd_soc_dapm_free(snd_soc_component_get_dapm(component)); 1589 soc_cleanup_component_debugfs(component); 1590 component->card = NULL; 1591 snd_soc_component_module_put_when_remove(component); 1592 } 1593 1594 static int soc_probe_component(struct snd_soc_card *card, 1595 struct snd_soc_component *component) 1596 { 1597 struct snd_soc_dapm_context *dapm = 1598 snd_soc_component_get_dapm(component); 1599 struct snd_soc_dai *dai; 1600 int probed = 0; 1601 int ret; 1602 1603 if (snd_soc_component_is_dummy(component)) 1604 return 0; 1605 1606 if (component->card) { 1607 if (component->card != card) { 1608 dev_err(component->dev, 1609 "Trying to bind component \"%s\" to card \"%s\" but is already bound to card \"%s\"\n", 1610 component->name, card->name, component->card->name); 1611 return -ENODEV; 1612 } 1613 return 0; 1614 } 1615 1616 ret = snd_soc_component_module_get_when_probe(component); 1617 if (ret < 0) 1618 return ret; 1619 1620 component->card = card; 1621 soc_set_name_prefix(card, component); 1622 1623 soc_init_component_debugfs(component); 1624 1625 snd_soc_dapm_init(dapm, card, component); 1626 1627 ret = snd_soc_dapm_new_controls(dapm, 1628 component->driver->dapm_widgets, 1629 component->driver->num_dapm_widgets); 1630 1631 if (ret != 0) { 1632 dev_err(component->dev, 1633 "Failed to create new controls %d\n", ret); 1634 goto err_probe; 1635 } 1636 1637 for_each_component_dais(component, dai) { 1638 ret = snd_soc_dapm_new_dai_widgets(dapm, dai); 1639 if (ret != 0) { 1640 dev_err(component->dev, 1641 "Failed to create DAI widgets %d\n", ret); 1642 goto err_probe; 1643 } 1644 } 1645 1646 ret = snd_soc_component_probe(component); 1647 if (ret < 0) 1648 goto err_probe; 1649 1650 WARN(dapm->idle_bias_off && 1651 dapm->bias_level != SND_SOC_BIAS_OFF, 1652 "codec %s can not start from non-off bias with idle_bias_off==1\n", 1653 component->name); 1654 probed = 1; 1655 1656 /* 1657 * machine specific init 1658 * see 1659 * snd_soc_component_set_aux() 1660 */ 1661 ret = snd_soc_component_init(component); 1662 if (ret < 0) 1663 goto err_probe; 1664 1665 ret = snd_soc_add_component_controls(component, 1666 component->driver->controls, 1667 component->driver->num_controls); 1668 if (ret < 0) 1669 goto err_probe; 1670 1671 ret = snd_soc_dapm_add_routes(dapm, 1672 component->driver->dapm_routes, 1673 component->driver->num_dapm_routes); 1674 if (ret < 0) 1675 goto err_probe; 1676 1677 /* see for_each_card_components */ 1678 list_add(&component->card_list, &card->component_dev_list); 1679 1680 err_probe: 1681 if (ret < 0) 1682 soc_remove_component(component, probed); 1683 1684 return ret; 1685 } 1686 1687 static void soc_remove_link_dais(struct snd_soc_card *card) 1688 { 1689 struct snd_soc_pcm_runtime *rtd; 1690 int order; 1691 1692 for_each_comp_order(order) { 1693 for_each_card_rtds(card, rtd) { 1694 /* remove all rtd connected DAIs in good order */ 1695 snd_soc_pcm_dai_remove(rtd, order); 1696 } 1697 } 1698 } 1699 1700 static int soc_probe_link_dais(struct snd_soc_card *card) 1701 { 1702 struct snd_soc_pcm_runtime *rtd; 1703 int order, ret; 1704 1705 for_each_comp_order(order) { 1706 for_each_card_rtds(card, rtd) { 1707 /* probe all rtd connected DAIs in good order */ 1708 ret = snd_soc_pcm_dai_probe(rtd, order); 1709 if (ret) 1710 return ret; 1711 } 1712 } 1713 1714 return 0; 1715 } 1716 1717 static void soc_remove_link_components(struct snd_soc_card *card) 1718 { 1719 struct snd_soc_component *component; 1720 struct snd_soc_pcm_runtime *rtd; 1721 int i, order; 1722 1723 for_each_comp_order(order) { 1724 for_each_card_rtds(card, rtd) { 1725 for_each_rtd_components(rtd, i, component) { 1726 if (component->driver->remove_order != order) 1727 continue; 1728 1729 soc_remove_component(component, 1); 1730 } 1731 } 1732 } 1733 } 1734 1735 static int soc_probe_link_components(struct snd_soc_card *card) 1736 { 1737 struct snd_soc_component *component; 1738 struct snd_soc_pcm_runtime *rtd; 1739 int i, ret, order; 1740 1741 for_each_comp_order(order) { 1742 for_each_card_rtds(card, rtd) { 1743 for_each_rtd_components(rtd, i, component) { 1744 if (component->driver->probe_order != order) 1745 continue; 1746 1747 ret = soc_probe_component(card, component); 1748 if (ret < 0) 1749 return ret; 1750 } 1751 } 1752 } 1753 1754 return 0; 1755 } 1756 1757 static void soc_unbind_aux_dev(struct snd_soc_card *card) 1758 { 1759 struct snd_soc_component *component, *_component; 1760 1761 for_each_card_auxs_safe(card, component, _component) { 1762 /* for snd_soc_component_init() */ 1763 snd_soc_component_set_aux(component, NULL); 1764 list_del(&component->card_aux_list); 1765 } 1766 } 1767 1768 static int soc_bind_aux_dev(struct snd_soc_card *card) 1769 { 1770 struct snd_soc_component *component; 1771 struct snd_soc_aux_dev *aux; 1772 int i; 1773 1774 for_each_card_pre_auxs(card, i, aux) { 1775 /* codecs, usually analog devices */ 1776 component = soc_find_component(&aux->dlc); 1777 if (!component) 1778 return -EPROBE_DEFER; 1779 1780 /* for snd_soc_component_init() */ 1781 snd_soc_component_set_aux(component, aux); 1782 /* see for_each_card_auxs */ 1783 list_add(&component->card_aux_list, &card->aux_comp_list); 1784 } 1785 return 0; 1786 } 1787 1788 static int soc_probe_aux_devices(struct snd_soc_card *card) 1789 { 1790 struct snd_soc_component *component; 1791 int order; 1792 int ret; 1793 1794 for_each_comp_order(order) { 1795 for_each_card_auxs(card, component) { 1796 if (component->driver->probe_order != order) 1797 continue; 1798 1799 ret = soc_probe_component(card, component); 1800 if (ret < 0) 1801 return ret; 1802 } 1803 } 1804 1805 return 0; 1806 } 1807 1808 static void soc_remove_aux_devices(struct snd_soc_card *card) 1809 { 1810 struct snd_soc_component *comp, *_comp; 1811 int order; 1812 1813 for_each_comp_order(order) { 1814 for_each_card_auxs_safe(card, comp, _comp) { 1815 if (comp->driver->remove_order == order) 1816 soc_remove_component(comp, 1); 1817 } 1818 } 1819 } 1820 1821 #ifdef CONFIG_DMI 1822 /* 1823 * If a DMI filed contain strings in this blacklist (e.g. 1824 * "Type2 - Board Manufacturer" or "Type1 - TBD by OEM"), it will be taken 1825 * as invalid and dropped when setting the card long name from DMI info. 1826 */ 1827 static const char * const dmi_blacklist[] = { 1828 "To be filled by OEM", 1829 "TBD by OEM", 1830 "Default String", 1831 "Board Manufacturer", 1832 "Board Vendor Name", 1833 "Board Product Name", 1834 NULL, /* terminator */ 1835 }; 1836 1837 /* 1838 * Trim special characters, and replace '-' with '_' since '-' is used to 1839 * separate different DMI fields in the card long name. Only number and 1840 * alphabet characters and a few separator characters are kept. 1841 */ 1842 static void cleanup_dmi_name(char *name) 1843 { 1844 int i, j = 0; 1845 1846 for (i = 0; name[i]; i++) { 1847 if (isalnum(name[i]) || (name[i] == '.') 1848 || (name[i] == '_')) 1849 name[j++] = name[i]; 1850 else if (name[i] == '-') 1851 name[j++] = '_'; 1852 } 1853 1854 name[j] = '\0'; 1855 } 1856 1857 /* 1858 * Check if a DMI field is valid, i.e. not containing any string 1859 * in the black list. 1860 */ 1861 static int is_dmi_valid(const char *field) 1862 { 1863 int i = 0; 1864 1865 while (dmi_blacklist[i]) { 1866 if (strstr(field, dmi_blacklist[i])) 1867 return 0; 1868 i++; 1869 } 1870 1871 return 1; 1872 } 1873 1874 /* 1875 * Append a string to card->dmi_longname with character cleanups. 1876 */ 1877 static void append_dmi_string(struct snd_soc_card *card, const char *str) 1878 { 1879 char *dst = card->dmi_longname; 1880 size_t dst_len = sizeof(card->dmi_longname); 1881 size_t len; 1882 1883 len = strlen(dst); 1884 snprintf(dst + len, dst_len - len, "-%s", str); 1885 1886 len++; /* skip the separator "-" */ 1887 if (len < dst_len) 1888 cleanup_dmi_name(dst + len); 1889 } 1890 1891 /** 1892 * snd_soc_set_dmi_name() - Register DMI names to card 1893 * @card: The card to register DMI names 1894 * 1895 * An Intel machine driver may be used by many different devices but are 1896 * difficult for userspace to differentiate, since machine drivers usually 1897 * use their own name as the card short name and leave the card long name 1898 * blank. To differentiate such devices and fix bugs due to lack of 1899 * device-specific configurations, this function allows DMI info to be used 1900 * as the sound card long name, in the format of 1901 * "vendor-product-version-board" 1902 * (Character '-' is used to separate different DMI fields here). 1903 * This will help the user space to load the device-specific Use Case Manager 1904 * (UCM) configurations for the card. 1905 * 1906 * Possible card long names may be: 1907 * DellInc.-XPS139343-01-0310JH 1908 * ASUSTeKCOMPUTERINC.-T100TA-1.0-T100TA 1909 * Circuitco-MinnowboardMaxD0PLATFORM-D0-MinnowBoardMAX 1910 * 1911 * This function also supports flavoring the card longname to provide 1912 * the extra differentiation, like "vendor-product-version-board-flavor". 1913 * 1914 * We only keep number and alphabet characters and a few separator characters 1915 * in the card long name since UCM in the user space uses the card long names 1916 * as card configuration directory names and AudoConf cannot support special 1917 * characters like SPACE. 1918 * 1919 * Returns 0 on success, otherwise a negative error code. 1920 */ 1921 static int snd_soc_set_dmi_name(struct snd_soc_card *card) 1922 { 1923 const char *vendor, *product, *board; 1924 1925 if (card->long_name) 1926 return 0; /* long name already set by driver or from DMI */ 1927 1928 if (!dmi_available) 1929 return 0; 1930 1931 /* make up dmi long name as: vendor-product-version-board */ 1932 vendor = dmi_get_system_info(DMI_BOARD_VENDOR); 1933 if (!vendor || !is_dmi_valid(vendor)) { 1934 dev_warn(card->dev, "ASoC: no DMI vendor name!\n"); 1935 return 0; 1936 } 1937 1938 snprintf(card->dmi_longname, sizeof(card->dmi_longname), "%s", vendor); 1939 cleanup_dmi_name(card->dmi_longname); 1940 1941 product = dmi_get_system_info(DMI_PRODUCT_NAME); 1942 if (product && is_dmi_valid(product)) { 1943 const char *product_version = dmi_get_system_info(DMI_PRODUCT_VERSION); 1944 1945 append_dmi_string(card, product); 1946 1947 /* 1948 * some vendors like Lenovo may only put a self-explanatory 1949 * name in the product version field 1950 */ 1951 if (product_version && is_dmi_valid(product_version)) 1952 append_dmi_string(card, product_version); 1953 } 1954 1955 board = dmi_get_system_info(DMI_BOARD_NAME); 1956 if (board && is_dmi_valid(board)) { 1957 if (!product || strcasecmp(board, product)) 1958 append_dmi_string(card, board); 1959 } else if (!product) { 1960 /* fall back to using legacy name */ 1961 dev_warn(card->dev, "ASoC: no DMI board/product name!\n"); 1962 return 0; 1963 } 1964 1965 /* set the card long name */ 1966 card->long_name = card->dmi_longname; 1967 1968 return 0; 1969 } 1970 #else 1971 static inline int snd_soc_set_dmi_name(struct snd_soc_card *card) 1972 { 1973 return 0; 1974 } 1975 #endif /* CONFIG_DMI */ 1976 1977 static void soc_check_tplg_fes(struct snd_soc_card *card) 1978 { 1979 struct snd_soc_component *component; 1980 const struct snd_soc_component_driver *comp_drv; 1981 struct snd_soc_dai_link *dai_link; 1982 int i; 1983 1984 for_each_component(component) { 1985 1986 /* does this component override BEs ? */ 1987 if (!component->driver->ignore_machine) 1988 continue; 1989 1990 /* for this machine ? */ 1991 if (!strcmp(component->driver->ignore_machine, 1992 card->dev->driver->name)) 1993 goto match; 1994 if (strcmp(component->driver->ignore_machine, 1995 dev_name(card->dev))) 1996 continue; 1997 match: 1998 /* machine matches, so override the rtd data */ 1999 for_each_card_prelinks(card, i, dai_link) { 2000 2001 /* ignore this FE */ 2002 if (dai_link->dynamic) { 2003 dai_link->ignore = true; 2004 continue; 2005 } 2006 2007 dev_dbg(card->dev, "info: override BE DAI link %s\n", 2008 card->dai_link[i].name); 2009 2010 /* override platform component */ 2011 if (!dai_link->platforms) { 2012 dev_err(card->dev, "init platform error"); 2013 continue; 2014 } 2015 2016 if (component->dev->of_node) 2017 dai_link->platforms->of_node = component->dev->of_node; 2018 else 2019 dai_link->platforms->name = component->name; 2020 2021 /* convert non BE into BE */ 2022 dai_link->no_pcm = 1; 2023 2024 /* 2025 * override any BE fixups 2026 * see 2027 * snd_soc_link_be_hw_params_fixup() 2028 */ 2029 dai_link->be_hw_params_fixup = 2030 component->driver->be_hw_params_fixup; 2031 2032 /* 2033 * most BE links don't set stream name, so set it to 2034 * dai link name if it's NULL to help bind widgets. 2035 */ 2036 if (!dai_link->stream_name) 2037 dai_link->stream_name = dai_link->name; 2038 } 2039 2040 /* Inform userspace we are using alternate topology */ 2041 if (component->driver->topology_name_prefix) { 2042 2043 /* topology shortname created? */ 2044 if (!card->topology_shortname_created) { 2045 comp_drv = component->driver; 2046 2047 snprintf(card->topology_shortname, 32, "%s-%s", 2048 comp_drv->topology_name_prefix, 2049 card->name); 2050 card->topology_shortname_created = true; 2051 } 2052 2053 /* use topology shortname */ 2054 card->name = card->topology_shortname; 2055 } 2056 } 2057 } 2058 2059 #define soc_setup_card_name(card, name, name1, name2) \ 2060 __soc_setup_card_name(card, name, sizeof(name), name1, name2) 2061 static void __soc_setup_card_name(struct snd_soc_card *card, 2062 char *name, int len, 2063 const char *name1, const char *name2) 2064 { 2065 const char *src = name1 ? name1 : name2; 2066 int i; 2067 2068 snprintf(name, len, "%s", src); 2069 2070 if (name != card->snd_card->driver) 2071 return; 2072 2073 /* 2074 * Name normalization (driver field) 2075 * 2076 * The driver name is somewhat special, as it's used as a key for 2077 * searches in the user-space. 2078 * 2079 * ex) 2080 * "abcd??efg" -> "abcd__efg" 2081 */ 2082 for (i = 0; i < len; i++) { 2083 switch (name[i]) { 2084 case '_': 2085 case '-': 2086 case '\0': 2087 break; 2088 default: 2089 if (!isalnum(name[i])) 2090 name[i] = '_'; 2091 break; 2092 } 2093 } 2094 2095 /* 2096 * The driver field should contain a valid string from the user view. 2097 * The wrapping usually does not work so well here. Set a smaller string 2098 * in the specific ASoC driver. 2099 */ 2100 if (strlen(src) > len - 1) 2101 dev_err(card->dev, "ASoC: driver name too long '%s' -> '%s'\n", src, name); 2102 } 2103 2104 static void soc_cleanup_card_resources(struct snd_soc_card *card) 2105 { 2106 struct snd_soc_pcm_runtime *rtd, *n; 2107 2108 if (card->snd_card) 2109 snd_card_disconnect_sync(card->snd_card); 2110 2111 snd_soc_dapm_shutdown(card); 2112 2113 /* release machine specific resources */ 2114 for_each_card_rtds(card, rtd) 2115 if (rtd->initialized) 2116 snd_soc_link_exit(rtd); 2117 /* remove and free each DAI */ 2118 soc_remove_link_dais(card); 2119 soc_remove_link_components(card); 2120 2121 for_each_card_rtds_safe(card, rtd, n) 2122 snd_soc_remove_pcm_runtime(card, rtd); 2123 2124 /* remove auxiliary devices */ 2125 soc_remove_aux_devices(card); 2126 soc_unbind_aux_dev(card); 2127 2128 snd_soc_dapm_free(&card->dapm); 2129 soc_cleanup_card_debugfs(card); 2130 2131 /* remove the card */ 2132 snd_soc_card_remove(card); 2133 2134 if (card->snd_card) { 2135 snd_card_free(card->snd_card); 2136 card->snd_card = NULL; 2137 } 2138 } 2139 2140 static void snd_soc_unbind_card(struct snd_soc_card *card) 2141 { 2142 if (snd_soc_card_is_instantiated(card)) { 2143 card->instantiated = false; 2144 snd_soc_flush_all_delayed_work(card); 2145 2146 soc_cleanup_card_resources(card); 2147 } 2148 } 2149 2150 static int snd_soc_bind_card(struct snd_soc_card *card) 2151 { 2152 struct snd_soc_pcm_runtime *rtd; 2153 struct snd_soc_component *component; 2154 int ret; 2155 2156 snd_soc_card_mutex_lock_root(card); 2157 snd_soc_fill_dummy_dai(card); 2158 2159 snd_soc_dapm_init(&card->dapm, card, NULL); 2160 2161 /* check whether any platform is ignore machine FE and using topology */ 2162 soc_check_tplg_fes(card); 2163 2164 /* bind aux_devs too */ 2165 ret = soc_bind_aux_dev(card); 2166 if (ret < 0) 2167 goto probe_end; 2168 2169 /* add predefined DAI links to the list */ 2170 card->num_rtd = 0; 2171 ret = snd_soc_add_pcm_runtimes(card, card->dai_link, card->num_links); 2172 if (ret < 0) 2173 goto probe_end; 2174 2175 /* card bind complete so register a sound card */ 2176 ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1, 2177 card->owner, 0, &card->snd_card); 2178 if (ret < 0) { 2179 dev_err(card->dev, 2180 "ASoC: can't create sound card for card %s: %d\n", 2181 card->name, ret); 2182 goto probe_end; 2183 } 2184 2185 soc_init_card_debugfs(card); 2186 2187 soc_resume_init(card); 2188 2189 ret = snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets, 2190 card->num_dapm_widgets); 2191 if (ret < 0) 2192 goto probe_end; 2193 2194 ret = snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets, 2195 card->num_of_dapm_widgets); 2196 if (ret < 0) 2197 goto probe_end; 2198 2199 /* initialise the sound card only once */ 2200 ret = snd_soc_card_probe(card); 2201 if (ret < 0) 2202 goto probe_end; 2203 2204 /* probe all components used by DAI links on this card */ 2205 ret = soc_probe_link_components(card); 2206 if (ret < 0) { 2207 if (ret != -EPROBE_DEFER) { 2208 dev_err(card->dev, 2209 "ASoC: failed to instantiate card %d\n", ret); 2210 } 2211 goto probe_end; 2212 } 2213 2214 /* probe auxiliary components */ 2215 ret = soc_probe_aux_devices(card); 2216 if (ret < 0) { 2217 dev_err(card->dev, 2218 "ASoC: failed to probe aux component %d\n", ret); 2219 goto probe_end; 2220 } 2221 2222 /* probe all DAI links on this card */ 2223 ret = soc_probe_link_dais(card); 2224 if (ret < 0) { 2225 dev_err(card->dev, 2226 "ASoC: failed to instantiate card %d\n", ret); 2227 goto probe_end; 2228 } 2229 2230 for_each_card_rtds(card, rtd) { 2231 ret = soc_init_pcm_runtime(card, rtd); 2232 if (ret < 0) 2233 goto probe_end; 2234 } 2235 2236 snd_soc_dapm_link_dai_widgets(card); 2237 snd_soc_dapm_connect_dai_link_widgets(card); 2238 2239 ret = snd_soc_add_card_controls(card, card->controls, 2240 card->num_controls); 2241 if (ret < 0) 2242 goto probe_end; 2243 2244 ret = snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes, 2245 card->num_dapm_routes); 2246 if (ret < 0) 2247 goto probe_end; 2248 2249 ret = snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes, 2250 card->num_of_dapm_routes); 2251 if (ret < 0) 2252 goto probe_end; 2253 2254 /* try to set some sane longname if DMI is available */ 2255 snd_soc_set_dmi_name(card); 2256 2257 soc_setup_card_name(card, card->snd_card->shortname, 2258 card->name, NULL); 2259 soc_setup_card_name(card, card->snd_card->longname, 2260 card->long_name, card->name); 2261 soc_setup_card_name(card, card->snd_card->driver, 2262 card->driver_name, card->name); 2263 2264 if (card->components) { 2265 /* the current implementation of snd_component_add() accepts */ 2266 /* multiple components in the string separated by space, */ 2267 /* but the string collision (identical string) check might */ 2268 /* not work correctly */ 2269 ret = snd_component_add(card->snd_card, card->components); 2270 if (ret < 0) { 2271 dev_err(card->dev, "ASoC: %s snd_component_add() failed: %d\n", 2272 card->name, ret); 2273 goto probe_end; 2274 } 2275 } 2276 2277 ret = snd_soc_card_late_probe(card); 2278 if (ret < 0) 2279 goto probe_end; 2280 2281 snd_soc_dapm_new_widgets(card); 2282 snd_soc_card_fixup_controls(card); 2283 2284 ret = snd_card_register(card->snd_card); 2285 if (ret < 0) { 2286 dev_err(card->dev, "ASoC: failed to register soundcard %d\n", 2287 ret); 2288 goto probe_end; 2289 } 2290 2291 card->instantiated = 1; 2292 snd_soc_dapm_mark_endpoints_dirty(card); 2293 snd_soc_dapm_sync(&card->dapm); 2294 2295 /* deactivate pins to sleep state */ 2296 for_each_card_components(card, component) 2297 if (!snd_soc_component_active(component)) 2298 pinctrl_pm_select_sleep_state(component->dev); 2299 2300 probe_end: 2301 if (ret < 0) 2302 soc_cleanup_card_resources(card); 2303 snd_soc_card_mutex_unlock(card); 2304 2305 return ret; 2306 } 2307 2308 static void devm_card_bind_release(struct device *dev, void *res) 2309 { 2310 snd_soc_unregister_card(*(struct snd_soc_card **)res); 2311 } 2312 2313 static int devm_snd_soc_bind_card(struct device *dev, struct snd_soc_card *card) 2314 { 2315 struct snd_soc_card **ptr; 2316 int ret; 2317 2318 ptr = devres_alloc(devm_card_bind_release, sizeof(*ptr), GFP_KERNEL); 2319 if (!ptr) 2320 return -ENOMEM; 2321 2322 ret = snd_soc_bind_card(card); 2323 if (ret == 0 || ret == -EPROBE_DEFER) { 2324 *ptr = card; 2325 devres_add(dev, ptr); 2326 } else { 2327 devres_free(ptr); 2328 } 2329 2330 return ret; 2331 } 2332 2333 static int snd_soc_rebind_card(struct snd_soc_card *card) 2334 { 2335 int ret; 2336 2337 if (card->devres_dev) { 2338 devres_destroy(card->devres_dev, devm_card_bind_release, NULL, NULL); 2339 ret = devm_snd_soc_bind_card(card->devres_dev, card); 2340 } else { 2341 ret = snd_soc_bind_card(card); 2342 } 2343 2344 if (ret != -EPROBE_DEFER) 2345 list_del_init(&card->list); 2346 2347 return ret; 2348 } 2349 2350 /* probes a new socdev */ 2351 static int soc_probe(struct platform_device *pdev) 2352 { 2353 struct snd_soc_card *card = platform_get_drvdata(pdev); 2354 2355 /* 2356 * no card, so machine driver should be registering card 2357 * we should not be here in that case so ret error 2358 */ 2359 if (!card) 2360 return -EINVAL; 2361 2362 dev_warn(&pdev->dev, 2363 "ASoC: machine %s should use snd_soc_register_card()\n", 2364 card->name); 2365 2366 /* Bodge while we unpick instantiation */ 2367 card->dev = &pdev->dev; 2368 2369 return devm_snd_soc_register_card(&pdev->dev, card); 2370 } 2371 2372 int snd_soc_poweroff(struct device *dev) 2373 { 2374 struct snd_soc_card *card = dev_get_drvdata(dev); 2375 struct snd_soc_component *component; 2376 2377 if (!snd_soc_card_is_instantiated(card)) 2378 return 0; 2379 2380 /* 2381 * Flush out pmdown_time work - we actually do want to run it 2382 * now, we're shutting down so no imminent restart. 2383 */ 2384 snd_soc_flush_all_delayed_work(card); 2385 2386 snd_soc_dapm_shutdown(card); 2387 2388 /* deactivate pins to sleep state */ 2389 for_each_card_components(card, component) 2390 pinctrl_pm_select_sleep_state(component->dev); 2391 2392 return 0; 2393 } 2394 EXPORT_SYMBOL_GPL(snd_soc_poweroff); 2395 2396 const struct dev_pm_ops snd_soc_pm_ops = { 2397 .suspend = snd_soc_suspend, 2398 .resume = snd_soc_resume, 2399 .freeze = snd_soc_suspend, 2400 .thaw = snd_soc_resume, 2401 .poweroff = snd_soc_poweroff, 2402 .restore = snd_soc_resume, 2403 }; 2404 EXPORT_SYMBOL_GPL(snd_soc_pm_ops); 2405 2406 /* ASoC platform driver */ 2407 static struct platform_driver soc_driver = { 2408 .driver = { 2409 .name = "soc-audio", 2410 .pm = &snd_soc_pm_ops, 2411 }, 2412 .probe = soc_probe, 2413 }; 2414 2415 /** 2416 * snd_soc_cnew - create new control 2417 * @_template: control template 2418 * @data: control private data 2419 * @long_name: control long name 2420 * @prefix: control name prefix 2421 * 2422 * Create a new mixer control from a template control. 2423 * 2424 * Returns 0 for success, else error. 2425 */ 2426 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template, 2427 void *data, const char *long_name, 2428 const char *prefix) 2429 { 2430 struct snd_kcontrol_new template; 2431 struct snd_kcontrol *kcontrol; 2432 char *name = NULL; 2433 2434 memcpy(&template, _template, sizeof(template)); 2435 template.index = 0; 2436 2437 if (!long_name) 2438 long_name = template.name; 2439 2440 if (prefix) { 2441 name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name); 2442 if (!name) 2443 return NULL; 2444 2445 template.name = name; 2446 } else { 2447 template.name = long_name; 2448 } 2449 2450 kcontrol = snd_ctl_new1(&template, data); 2451 2452 kfree(name); 2453 2454 return kcontrol; 2455 } 2456 EXPORT_SYMBOL_GPL(snd_soc_cnew); 2457 2458 static int snd_soc_add_controls(struct snd_card *card, struct device *dev, 2459 const struct snd_kcontrol_new *controls, int num_controls, 2460 const char *prefix, void *data) 2461 { 2462 int i; 2463 2464 for (i = 0; i < num_controls; i++) { 2465 const struct snd_kcontrol_new *control = &controls[i]; 2466 int err = snd_ctl_add(card, snd_soc_cnew(control, data, 2467 control->name, prefix)); 2468 if (err < 0) { 2469 dev_err(dev, "ASoC: Failed to add %s: %d\n", 2470 control->name, err); 2471 return err; 2472 } 2473 } 2474 2475 return 0; 2476 } 2477 2478 /** 2479 * snd_soc_add_component_controls - Add an array of controls to a component. 2480 * 2481 * @component: Component to add controls to 2482 * @controls: Array of controls to add 2483 * @num_controls: Number of elements in the array 2484 * 2485 * Return: 0 for success, else error. 2486 */ 2487 int snd_soc_add_component_controls(struct snd_soc_component *component, 2488 const struct snd_kcontrol_new *controls, unsigned int num_controls) 2489 { 2490 struct snd_card *card = component->card->snd_card; 2491 2492 return snd_soc_add_controls(card, component->dev, controls, 2493 num_controls, component->name_prefix, component); 2494 } 2495 EXPORT_SYMBOL_GPL(snd_soc_add_component_controls); 2496 2497 /** 2498 * snd_soc_add_card_controls - add an array of controls to a SoC card. 2499 * Convenience function to add a list of controls. 2500 * 2501 * @soc_card: SoC card to add controls to 2502 * @controls: array of controls to add 2503 * @num_controls: number of elements in the array 2504 * 2505 * Return 0 for success, else error. 2506 */ 2507 int snd_soc_add_card_controls(struct snd_soc_card *soc_card, 2508 const struct snd_kcontrol_new *controls, int num_controls) 2509 { 2510 struct snd_card *card = soc_card->snd_card; 2511 2512 return snd_soc_add_controls(card, soc_card->dev, controls, num_controls, 2513 NULL, soc_card); 2514 } 2515 EXPORT_SYMBOL_GPL(snd_soc_add_card_controls); 2516 2517 /** 2518 * snd_soc_add_dai_controls - add an array of controls to a DAI. 2519 * Convenience function to add a list of controls. 2520 * 2521 * @dai: DAI to add controls to 2522 * @controls: array of controls to add 2523 * @num_controls: number of elements in the array 2524 * 2525 * Return 0 for success, else error. 2526 */ 2527 int snd_soc_add_dai_controls(struct snd_soc_dai *dai, 2528 const struct snd_kcontrol_new *controls, int num_controls) 2529 { 2530 struct snd_card *card = dai->component->card->snd_card; 2531 2532 return snd_soc_add_controls(card, dai->dev, controls, num_controls, 2533 NULL, dai); 2534 } 2535 EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls); 2536 2537 /** 2538 * snd_soc_register_card - Register a card with the ASoC core 2539 * 2540 * @card: Card to register 2541 * 2542 */ 2543 int snd_soc_register_card(struct snd_soc_card *card) 2544 { 2545 int ret; 2546 2547 if (!card->name || !card->dev) 2548 return -EINVAL; 2549 2550 dev_set_drvdata(card->dev, card); 2551 2552 INIT_LIST_HEAD(&card->widgets); 2553 INIT_LIST_HEAD(&card->paths); 2554 INIT_LIST_HEAD(&card->dapm_list); 2555 INIT_LIST_HEAD(&card->aux_comp_list); 2556 INIT_LIST_HEAD(&card->component_dev_list); 2557 INIT_LIST_HEAD(&card->list); 2558 INIT_LIST_HEAD(&card->rtd_list); 2559 INIT_LIST_HEAD(&card->dapm_dirty); 2560 INIT_LIST_HEAD(&card->dobj_list); 2561 2562 card->instantiated = 0; 2563 mutex_init(&card->mutex); 2564 mutex_init(&card->dapm_mutex); 2565 mutex_init(&card->pcm_mutex); 2566 2567 mutex_lock(&client_mutex); 2568 2569 if (card->devres_dev) { 2570 ret = devm_snd_soc_bind_card(card->devres_dev, card); 2571 if (ret == -EPROBE_DEFER) { 2572 list_add(&card->list, &unbind_card_list); 2573 ret = 0; 2574 } 2575 } else { 2576 ret = snd_soc_bind_card(card); 2577 } 2578 2579 mutex_unlock(&client_mutex); 2580 2581 return ret; 2582 } 2583 EXPORT_SYMBOL_GPL(snd_soc_register_card); 2584 2585 /** 2586 * snd_soc_unregister_card - Unregister a card with the ASoC core 2587 * 2588 * @card: Card to unregister 2589 * 2590 */ 2591 void snd_soc_unregister_card(struct snd_soc_card *card) 2592 { 2593 mutex_lock(&client_mutex); 2594 snd_soc_unbind_card(card); 2595 list_del(&card->list); 2596 mutex_unlock(&client_mutex); 2597 dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name); 2598 } 2599 EXPORT_SYMBOL_GPL(snd_soc_unregister_card); 2600 2601 /* 2602 * Simplify DAI link configuration by removing ".-1" from device names 2603 * and sanitizing names. 2604 */ 2605 static char *fmt_single_name(struct device *dev, int *id) 2606 { 2607 const char *devname = dev_name(dev); 2608 char *found, *name; 2609 unsigned int id1, id2; 2610 int __id; 2611 2612 if (devname == NULL) 2613 return NULL; 2614 2615 name = devm_kstrdup(dev, devname, GFP_KERNEL); 2616 if (!name) 2617 return NULL; 2618 2619 /* are we a "%s.%d" name (platform and SPI components) */ 2620 found = strstr(name, dev->driver->name); 2621 if (found) { 2622 /* get ID */ 2623 if (sscanf(&found[strlen(dev->driver->name)], ".%d", &__id) == 1) { 2624 2625 /* discard ID from name if ID == -1 */ 2626 if (__id == -1) 2627 found[strlen(dev->driver->name)] = '\0'; 2628 } 2629 2630 /* I2C component devices are named "bus-addr" */ 2631 } else if (sscanf(name, "%x-%x", &id1, &id2) == 2) { 2632 2633 /* create unique ID number from I2C addr and bus */ 2634 __id = ((id1 & 0xffff) << 16) + id2; 2635 2636 devm_kfree(dev, name); 2637 2638 /* sanitize component name for DAI link creation */ 2639 name = devm_kasprintf(dev, GFP_KERNEL, "%s.%s", dev->driver->name, devname); 2640 } else { 2641 __id = 0; 2642 } 2643 2644 if (id) 2645 *id = __id; 2646 2647 return name; 2648 } 2649 2650 /* 2651 * Simplify DAI link naming for single devices with multiple DAIs by removing 2652 * any ".-1" and using the DAI name (instead of device name). 2653 */ 2654 static inline char *fmt_multiple_name(struct device *dev, 2655 struct snd_soc_dai_driver *dai_drv) 2656 { 2657 if (dai_drv->name == NULL) { 2658 dev_err(dev, 2659 "ASoC: error - multiple DAI %s registered with no name\n", 2660 dev_name(dev)); 2661 return NULL; 2662 } 2663 2664 return devm_kstrdup(dev, dai_drv->name, GFP_KERNEL); 2665 } 2666 2667 void snd_soc_unregister_dai(struct snd_soc_dai *dai) 2668 { 2669 dev_dbg(dai->dev, "ASoC: Unregistered DAI '%s'\n", dai->name); 2670 list_del(&dai->list); 2671 } 2672 EXPORT_SYMBOL_GPL(snd_soc_unregister_dai); 2673 2674 /** 2675 * snd_soc_register_dai - Register a DAI dynamically & create its widgets 2676 * 2677 * @component: The component the DAIs are registered for 2678 * @dai_drv: DAI driver to use for the DAI 2679 * @legacy_dai_naming: if %true, use legacy single-name format; 2680 * if %false, use multiple-name format; 2681 * 2682 * Topology can use this API to register DAIs when probing a component. 2683 * These DAIs's widgets will be freed in the card cleanup and the DAIs 2684 * will be freed in the component cleanup. 2685 */ 2686 struct snd_soc_dai *snd_soc_register_dai(struct snd_soc_component *component, 2687 struct snd_soc_dai_driver *dai_drv, 2688 bool legacy_dai_naming) 2689 { 2690 struct device *dev = component->dev; 2691 struct snd_soc_dai *dai; 2692 2693 lockdep_assert_held(&client_mutex); 2694 2695 dai = devm_kzalloc(dev, sizeof(*dai), GFP_KERNEL); 2696 if (dai == NULL) 2697 return NULL; 2698 2699 /* 2700 * Back in the old days when we still had component-less DAIs, 2701 * instead of having a static name, component-less DAIs would 2702 * inherit the name of the parent device so it is possible to 2703 * register multiple instances of the DAI. We still need to keep 2704 * the same naming style even though those DAIs are not 2705 * component-less anymore. 2706 */ 2707 if (legacy_dai_naming && 2708 (dai_drv->id == 0 || dai_drv->name == NULL)) { 2709 dai->name = fmt_single_name(dev, &dai->id); 2710 } else { 2711 dai->name = fmt_multiple_name(dev, dai_drv); 2712 if (dai_drv->id) 2713 dai->id = dai_drv->id; 2714 else 2715 dai->id = component->num_dai; 2716 } 2717 if (!dai->name) 2718 return NULL; 2719 2720 dai->component = component; 2721 dai->dev = dev; 2722 dai->driver = dai_drv; 2723 2724 /* see for_each_component_dais */ 2725 list_add_tail(&dai->list, &component->dai_list); 2726 component->num_dai++; 2727 2728 dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name); 2729 return dai; 2730 } 2731 EXPORT_SYMBOL_GPL(snd_soc_register_dai); 2732 2733 /** 2734 * snd_soc_unregister_dais - Unregister DAIs from the ASoC core 2735 * 2736 * @component: The component for which the DAIs should be unregistered 2737 */ 2738 static void snd_soc_unregister_dais(struct snd_soc_component *component) 2739 { 2740 struct snd_soc_dai *dai, *_dai; 2741 2742 for_each_component_dais_safe(component, dai, _dai) 2743 snd_soc_unregister_dai(dai); 2744 } 2745 2746 /** 2747 * snd_soc_register_dais - Register a DAI with the ASoC core 2748 * 2749 * @component: The component the DAIs are registered for 2750 * @dai_drv: DAI driver to use for the DAIs 2751 * @count: Number of DAIs 2752 */ 2753 static int snd_soc_register_dais(struct snd_soc_component *component, 2754 struct snd_soc_dai_driver *dai_drv, 2755 size_t count) 2756 { 2757 struct snd_soc_dai *dai; 2758 unsigned int i; 2759 int ret; 2760 2761 for (i = 0; i < count; i++) { 2762 dai = snd_soc_register_dai(component, dai_drv + i, count == 1 && 2763 component->driver->legacy_dai_naming); 2764 if (dai == NULL) { 2765 ret = -ENOMEM; 2766 goto err; 2767 } 2768 } 2769 2770 return 0; 2771 2772 err: 2773 snd_soc_unregister_dais(component); 2774 2775 return ret; 2776 } 2777 2778 #define ENDIANNESS_MAP(name) \ 2779 (SNDRV_PCM_FMTBIT_##name##LE | SNDRV_PCM_FMTBIT_##name##BE) 2780 static u64 endianness_format_map[] = { 2781 ENDIANNESS_MAP(S16_), 2782 ENDIANNESS_MAP(U16_), 2783 ENDIANNESS_MAP(S24_), 2784 ENDIANNESS_MAP(U24_), 2785 ENDIANNESS_MAP(S32_), 2786 ENDIANNESS_MAP(U32_), 2787 ENDIANNESS_MAP(S24_3), 2788 ENDIANNESS_MAP(U24_3), 2789 ENDIANNESS_MAP(S20_3), 2790 ENDIANNESS_MAP(U20_3), 2791 ENDIANNESS_MAP(S18_3), 2792 ENDIANNESS_MAP(U18_3), 2793 ENDIANNESS_MAP(FLOAT_), 2794 ENDIANNESS_MAP(FLOAT64_), 2795 ENDIANNESS_MAP(IEC958_SUBFRAME_), 2796 }; 2797 2798 /* 2799 * Fix up the DAI formats for endianness: codecs don't actually see 2800 * the endianness of the data but we're using the CPU format 2801 * definitions which do need to include endianness so we ensure that 2802 * codec DAIs always have both big and little endian variants set. 2803 */ 2804 static void convert_endianness_formats(struct snd_soc_pcm_stream *stream) 2805 { 2806 int i; 2807 2808 for (i = 0; i < ARRAY_SIZE(endianness_format_map); i++) 2809 if (stream->formats & endianness_format_map[i]) 2810 stream->formats |= endianness_format_map[i]; 2811 } 2812 2813 static void snd_soc_del_component_unlocked(struct snd_soc_component *component) 2814 { 2815 struct snd_soc_card *card = component->card; 2816 bool instantiated; 2817 2818 snd_soc_unregister_dais(component); 2819 2820 if (card) { 2821 instantiated = card->instantiated; 2822 snd_soc_unbind_card(card); 2823 if (instantiated) 2824 list_add(&card->list, &unbind_card_list); 2825 } 2826 2827 list_del(&component->list); 2828 } 2829 2830 int snd_soc_component_initialize(struct snd_soc_component *component, 2831 const struct snd_soc_component_driver *driver, 2832 struct device *dev) 2833 { 2834 INIT_LIST_HEAD(&component->dai_list); 2835 INIT_LIST_HEAD(&component->dobj_list); 2836 INIT_LIST_HEAD(&component->card_list); 2837 INIT_LIST_HEAD(&component->list); 2838 mutex_init(&component->io_mutex); 2839 2840 if (!component->name) { 2841 component->name = fmt_single_name(dev, NULL); 2842 if (!component->name) { 2843 dev_err(dev, "ASoC: Failed to allocate name\n"); 2844 return -ENOMEM; 2845 } 2846 } 2847 2848 component->dev = dev; 2849 component->driver = driver; 2850 2851 #ifdef CONFIG_DEBUG_FS 2852 if (!component->debugfs_prefix) 2853 component->debugfs_prefix = driver->debugfs_prefix; 2854 #endif 2855 2856 return 0; 2857 } 2858 EXPORT_SYMBOL_GPL(snd_soc_component_initialize); 2859 2860 int snd_soc_add_component(struct snd_soc_component *component, 2861 struct snd_soc_dai_driver *dai_drv, 2862 int num_dai) 2863 { 2864 struct snd_soc_card *card, *c; 2865 int ret; 2866 int i; 2867 2868 mutex_lock(&client_mutex); 2869 2870 if (component->driver->endianness) { 2871 for (i = 0; i < num_dai; i++) { 2872 convert_endianness_formats(&dai_drv[i].playback); 2873 convert_endianness_formats(&dai_drv[i].capture); 2874 } 2875 } 2876 2877 ret = snd_soc_register_dais(component, dai_drv, num_dai); 2878 if (ret < 0) { 2879 dev_err(component->dev, "ASoC: Failed to register DAIs: %d\n", 2880 ret); 2881 goto err_cleanup; 2882 } 2883 2884 if (!component->driver->write && !component->driver->read) { 2885 if (!component->regmap) 2886 component->regmap = dev_get_regmap(component->dev, 2887 NULL); 2888 if (component->regmap) 2889 snd_soc_component_setup_regmap(component); 2890 } 2891 2892 /* see for_each_component */ 2893 list_add(&component->list, &component_list); 2894 2895 list_for_each_entry_safe(card, c, &unbind_card_list, list) 2896 snd_soc_rebind_card(card); 2897 2898 err_cleanup: 2899 if (ret < 0) 2900 snd_soc_del_component_unlocked(component); 2901 2902 mutex_unlock(&client_mutex); 2903 return ret; 2904 } 2905 EXPORT_SYMBOL_GPL(snd_soc_add_component); 2906 2907 int snd_soc_register_component(struct device *dev, 2908 const struct snd_soc_component_driver *component_driver, 2909 struct snd_soc_dai_driver *dai_drv, 2910 int num_dai) 2911 { 2912 struct snd_soc_component *component; 2913 int ret; 2914 2915 component = devm_kzalloc(dev, sizeof(*component), GFP_KERNEL); 2916 if (!component) 2917 return -ENOMEM; 2918 2919 ret = snd_soc_component_initialize(component, component_driver, dev); 2920 if (ret < 0) 2921 return ret; 2922 2923 return snd_soc_add_component(component, dai_drv, num_dai); 2924 } 2925 EXPORT_SYMBOL_GPL(snd_soc_register_component); 2926 2927 /** 2928 * snd_soc_unregister_component_by_driver - Unregister component using a given driver 2929 * from the ASoC core 2930 * 2931 * @dev: The device to unregister 2932 * @component_driver: The component driver to unregister 2933 */ 2934 void snd_soc_unregister_component_by_driver(struct device *dev, 2935 const struct snd_soc_component_driver *component_driver) 2936 { 2937 const char *driver_name = NULL; 2938 2939 if (component_driver) 2940 driver_name = component_driver->name; 2941 2942 mutex_lock(&client_mutex); 2943 while (1) { 2944 struct snd_soc_component *component = snd_soc_lookup_component_nolocked(dev, driver_name); 2945 2946 if (!component) 2947 break; 2948 2949 snd_soc_del_component_unlocked(component); 2950 } 2951 mutex_unlock(&client_mutex); 2952 } 2953 EXPORT_SYMBOL_GPL(snd_soc_unregister_component_by_driver); 2954 2955 /* Retrieve a card's name from device tree */ 2956 int snd_soc_of_parse_card_name(struct snd_soc_card *card, 2957 const char *propname) 2958 { 2959 struct device_node *np; 2960 int ret; 2961 2962 if (!card->dev) { 2963 pr_err("card->dev is not set before calling %s\n", __func__); 2964 return -EINVAL; 2965 } 2966 2967 np = card->dev->of_node; 2968 2969 ret = of_property_read_string_index(np, propname, 0, &card->name); 2970 /* 2971 * EINVAL means the property does not exist. This is fine providing 2972 * card->name was previously set, which is checked later in 2973 * snd_soc_register_card. 2974 */ 2975 if (ret < 0 && ret != -EINVAL) { 2976 dev_err(card->dev, 2977 "ASoC: Property '%s' could not be read: %d\n", 2978 propname, ret); 2979 return ret; 2980 } 2981 2982 return 0; 2983 } 2984 EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name); 2985 2986 static const struct snd_soc_dapm_widget simple_widgets[] = { 2987 SND_SOC_DAPM_MIC("Microphone", NULL), 2988 SND_SOC_DAPM_LINE("Line", NULL), 2989 SND_SOC_DAPM_HP("Headphone", NULL), 2990 SND_SOC_DAPM_SPK("Speaker", NULL), 2991 }; 2992 2993 int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card, 2994 const char *propname) 2995 { 2996 struct device_node *np = card->dev->of_node; 2997 struct snd_soc_dapm_widget *widgets; 2998 const char *template, *wname; 2999 int i, j, num_widgets; 3000 3001 num_widgets = of_property_count_strings(np, propname); 3002 if (num_widgets < 0) { 3003 dev_err(card->dev, 3004 "ASoC: Property '%s' does not exist\n", propname); 3005 return -EINVAL; 3006 } 3007 if (!num_widgets) { 3008 dev_err(card->dev, "ASoC: Property '%s's length is zero\n", 3009 propname); 3010 return -EINVAL; 3011 } 3012 if (num_widgets & 1) { 3013 dev_err(card->dev, 3014 "ASoC: Property '%s' length is not even\n", propname); 3015 return -EINVAL; 3016 } 3017 3018 num_widgets /= 2; 3019 3020 widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets), 3021 GFP_KERNEL); 3022 if (!widgets) { 3023 dev_err(card->dev, 3024 "ASoC: Could not allocate memory for widgets\n"); 3025 return -ENOMEM; 3026 } 3027 3028 for (i = 0; i < num_widgets; i++) { 3029 int ret = of_property_read_string_index(np, propname, 3030 2 * i, &template); 3031 if (ret) { 3032 dev_err(card->dev, 3033 "ASoC: Property '%s' index %d read error:%d\n", 3034 propname, 2 * i, ret); 3035 return -EINVAL; 3036 } 3037 3038 for (j = 0; j < ARRAY_SIZE(simple_widgets); j++) { 3039 if (!strncmp(template, simple_widgets[j].name, 3040 strlen(simple_widgets[j].name))) { 3041 widgets[i] = simple_widgets[j]; 3042 break; 3043 } 3044 } 3045 3046 if (j >= ARRAY_SIZE(simple_widgets)) { 3047 dev_err(card->dev, 3048 "ASoC: DAPM widget '%s' is not supported\n", 3049 template); 3050 return -EINVAL; 3051 } 3052 3053 ret = of_property_read_string_index(np, propname, 3054 (2 * i) + 1, 3055 &wname); 3056 if (ret) { 3057 dev_err(card->dev, 3058 "ASoC: Property '%s' index %d read error:%d\n", 3059 propname, (2 * i) + 1, ret); 3060 return -EINVAL; 3061 } 3062 3063 widgets[i].name = wname; 3064 } 3065 3066 card->of_dapm_widgets = widgets; 3067 card->num_of_dapm_widgets = num_widgets; 3068 3069 return 0; 3070 } 3071 EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets); 3072 3073 int snd_soc_of_parse_pin_switches(struct snd_soc_card *card, const char *prop) 3074 { 3075 const unsigned int nb_controls_max = 16; 3076 const char **strings, *control_name; 3077 struct snd_kcontrol_new *controls; 3078 struct device *dev = card->dev; 3079 unsigned int i, nb_controls; 3080 int ret; 3081 3082 if (!of_property_present(dev->of_node, prop)) 3083 return 0; 3084 3085 strings = devm_kcalloc(dev, nb_controls_max, 3086 sizeof(*strings), GFP_KERNEL); 3087 if (!strings) 3088 return -ENOMEM; 3089 3090 ret = of_property_read_string_array(dev->of_node, prop, 3091 strings, nb_controls_max); 3092 if (ret < 0) 3093 return ret; 3094 3095 nb_controls = (unsigned int)ret; 3096 3097 controls = devm_kcalloc(dev, nb_controls, 3098 sizeof(*controls), GFP_KERNEL); 3099 if (!controls) 3100 return -ENOMEM; 3101 3102 for (i = 0; i < nb_controls; i++) { 3103 control_name = devm_kasprintf(dev, GFP_KERNEL, 3104 "%s Switch", strings[i]); 3105 if (!control_name) 3106 return -ENOMEM; 3107 3108 controls[i].iface = SNDRV_CTL_ELEM_IFACE_MIXER; 3109 controls[i].name = control_name; 3110 controls[i].info = snd_soc_dapm_info_pin_switch; 3111 controls[i].get = snd_soc_dapm_get_pin_switch; 3112 controls[i].put = snd_soc_dapm_put_pin_switch; 3113 controls[i].private_value = (unsigned long)strings[i]; 3114 } 3115 3116 card->controls = controls; 3117 card->num_controls = nb_controls; 3118 3119 return 0; 3120 } 3121 EXPORT_SYMBOL_GPL(snd_soc_of_parse_pin_switches); 3122 3123 int snd_soc_of_get_slot_mask(struct device_node *np, 3124 const char *prop_name, 3125 unsigned int *mask) 3126 { 3127 u32 val; 3128 const __be32 *of_slot_mask = of_get_property(np, prop_name, &val); 3129 int i; 3130 3131 if (!of_slot_mask) 3132 return 0; 3133 val /= sizeof(u32); 3134 for (i = 0; i < val; i++) 3135 if (be32_to_cpup(&of_slot_mask[i])) 3136 *mask |= (1 << i); 3137 3138 return val; 3139 } 3140 EXPORT_SYMBOL_GPL(snd_soc_of_get_slot_mask); 3141 3142 int snd_soc_of_parse_tdm_slot(struct device_node *np, 3143 unsigned int *tx_mask, 3144 unsigned int *rx_mask, 3145 unsigned int *slots, 3146 unsigned int *slot_width) 3147 { 3148 u32 val; 3149 int ret; 3150 3151 if (tx_mask) 3152 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask", tx_mask); 3153 if (rx_mask) 3154 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask", rx_mask); 3155 3156 ret = of_property_read_u32(np, "dai-tdm-slot-num", &val); 3157 if (ret && ret != -EINVAL) 3158 return ret; 3159 if (!ret && slots) 3160 *slots = val; 3161 3162 ret = of_property_read_u32(np, "dai-tdm-slot-width", &val); 3163 if (ret && ret != -EINVAL) 3164 return ret; 3165 if (!ret && slot_width) 3166 *slot_width = val; 3167 3168 return 0; 3169 } 3170 EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot); 3171 3172 void snd_soc_dlc_use_cpu_as_platform(struct snd_soc_dai_link_component *platforms, 3173 struct snd_soc_dai_link_component *cpus) 3174 { 3175 platforms->of_node = cpus->of_node; 3176 platforms->dai_args = cpus->dai_args; 3177 } 3178 EXPORT_SYMBOL_GPL(snd_soc_dlc_use_cpu_as_platform); 3179 3180 void snd_soc_of_parse_node_prefix(struct device_node *np, 3181 struct snd_soc_codec_conf *codec_conf, 3182 struct device_node *of_node, 3183 const char *propname) 3184 { 3185 const char *str; 3186 int ret; 3187 3188 ret = of_property_read_string(np, propname, &str); 3189 if (ret < 0) { 3190 /* no prefix is not error */ 3191 return; 3192 } 3193 3194 codec_conf->dlc.of_node = of_node; 3195 codec_conf->name_prefix = str; 3196 } 3197 EXPORT_SYMBOL_GPL(snd_soc_of_parse_node_prefix); 3198 3199 int snd_soc_of_parse_audio_routing(struct snd_soc_card *card, 3200 const char *propname) 3201 { 3202 struct device_node *np = card->dev->of_node; 3203 int num_routes; 3204 struct snd_soc_dapm_route *routes; 3205 int i; 3206 3207 num_routes = of_property_count_strings(np, propname); 3208 if (num_routes < 0 || num_routes & 1) { 3209 dev_err(card->dev, 3210 "ASoC: Property '%s' does not exist or its length is not even\n", 3211 propname); 3212 return -EINVAL; 3213 } 3214 num_routes /= 2; 3215 3216 routes = devm_kcalloc(card->dev, num_routes, sizeof(*routes), 3217 GFP_KERNEL); 3218 if (!routes) { 3219 dev_err(card->dev, 3220 "ASoC: Could not allocate DAPM route table\n"); 3221 return -ENOMEM; 3222 } 3223 3224 for (i = 0; i < num_routes; i++) { 3225 int ret = of_property_read_string_index(np, propname, 3226 2 * i, &routes[i].sink); 3227 if (ret) { 3228 dev_err(card->dev, 3229 "ASoC: Property '%s' index %d could not be read: %d\n", 3230 propname, 2 * i, ret); 3231 return -EINVAL; 3232 } 3233 ret = of_property_read_string_index(np, propname, 3234 (2 * i) + 1, &routes[i].source); 3235 if (ret) { 3236 dev_err(card->dev, 3237 "ASoC: Property '%s' index %d could not be read: %d\n", 3238 propname, (2 * i) + 1, ret); 3239 return -EINVAL; 3240 } 3241 } 3242 3243 card->num_of_dapm_routes = num_routes; 3244 card->of_dapm_routes = routes; 3245 3246 return 0; 3247 } 3248 EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing); 3249 3250 int snd_soc_of_parse_aux_devs(struct snd_soc_card *card, const char *propname) 3251 { 3252 struct device_node *node = card->dev->of_node; 3253 struct snd_soc_aux_dev *aux; 3254 int num, i; 3255 3256 num = of_count_phandle_with_args(node, propname, NULL); 3257 if (num == -ENOENT) { 3258 return 0; 3259 } else if (num < 0) { 3260 dev_err(card->dev, "ASOC: Property '%s' could not be read: %d\n", 3261 propname, num); 3262 return num; 3263 } 3264 3265 aux = devm_kcalloc(card->dev, num, sizeof(*aux), GFP_KERNEL); 3266 if (!aux) 3267 return -ENOMEM; 3268 card->aux_dev = aux; 3269 card->num_aux_devs = num; 3270 3271 for_each_card_pre_auxs(card, i, aux) { 3272 aux->dlc.of_node = of_parse_phandle(node, propname, i); 3273 if (!aux->dlc.of_node) 3274 return -EINVAL; 3275 } 3276 3277 return 0; 3278 } 3279 EXPORT_SYMBOL_GPL(snd_soc_of_parse_aux_devs); 3280 3281 unsigned int snd_soc_daifmt_clock_provider_flipped(unsigned int dai_fmt) 3282 { 3283 unsigned int inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK; 3284 3285 switch (dai_fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) { 3286 case SND_SOC_DAIFMT_CBP_CFP: 3287 inv_dai_fmt |= SND_SOC_DAIFMT_CBC_CFC; 3288 break; 3289 case SND_SOC_DAIFMT_CBP_CFC: 3290 inv_dai_fmt |= SND_SOC_DAIFMT_CBC_CFP; 3291 break; 3292 case SND_SOC_DAIFMT_CBC_CFP: 3293 inv_dai_fmt |= SND_SOC_DAIFMT_CBP_CFC; 3294 break; 3295 case SND_SOC_DAIFMT_CBC_CFC: 3296 inv_dai_fmt |= SND_SOC_DAIFMT_CBP_CFP; 3297 break; 3298 } 3299 3300 return inv_dai_fmt; 3301 } 3302 EXPORT_SYMBOL_GPL(snd_soc_daifmt_clock_provider_flipped); 3303 3304 unsigned int snd_soc_daifmt_clock_provider_from_bitmap(unsigned int bit_frame) 3305 { 3306 /* 3307 * bit_frame is return value from 3308 * snd_soc_daifmt_parse_clock_provider_raw() 3309 */ 3310 3311 /* Codec base */ 3312 switch (bit_frame) { 3313 case 0x11: 3314 return SND_SOC_DAIFMT_CBP_CFP; 3315 case 0x10: 3316 return SND_SOC_DAIFMT_CBP_CFC; 3317 case 0x01: 3318 return SND_SOC_DAIFMT_CBC_CFP; 3319 default: 3320 return SND_SOC_DAIFMT_CBC_CFC; 3321 } 3322 3323 return 0; 3324 } 3325 EXPORT_SYMBOL_GPL(snd_soc_daifmt_clock_provider_from_bitmap); 3326 3327 unsigned int snd_soc_daifmt_parse_format(struct device_node *np, 3328 const char *prefix) 3329 { 3330 int ret; 3331 char prop[128]; 3332 unsigned int format = 0; 3333 int bit, frame; 3334 const char *str; 3335 struct { 3336 char *name; 3337 unsigned int val; 3338 } of_fmt_table[] = { 3339 { "i2s", SND_SOC_DAIFMT_I2S }, 3340 { "right_j", SND_SOC_DAIFMT_RIGHT_J }, 3341 { "left_j", SND_SOC_DAIFMT_LEFT_J }, 3342 { "dsp_a", SND_SOC_DAIFMT_DSP_A }, 3343 { "dsp_b", SND_SOC_DAIFMT_DSP_B }, 3344 { "ac97", SND_SOC_DAIFMT_AC97 }, 3345 { "pdm", SND_SOC_DAIFMT_PDM}, 3346 { "msb", SND_SOC_DAIFMT_MSB }, 3347 { "lsb", SND_SOC_DAIFMT_LSB }, 3348 }; 3349 3350 if (!prefix) 3351 prefix = ""; 3352 3353 /* 3354 * check "dai-format = xxx" 3355 * or "[prefix]format = xxx" 3356 * SND_SOC_DAIFMT_FORMAT_MASK area 3357 */ 3358 ret = of_property_read_string(np, "dai-format", &str); 3359 if (ret < 0) { 3360 snprintf(prop, sizeof(prop), "%sformat", prefix); 3361 ret = of_property_read_string(np, prop, &str); 3362 } 3363 if (ret == 0) { 3364 int i; 3365 3366 for (i = 0; i < ARRAY_SIZE(of_fmt_table); i++) { 3367 if (strcmp(str, of_fmt_table[i].name) == 0) { 3368 format |= of_fmt_table[i].val; 3369 break; 3370 } 3371 } 3372 } 3373 3374 /* 3375 * check "[prefix]continuous-clock" 3376 * SND_SOC_DAIFMT_CLOCK_MASK area 3377 */ 3378 snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix); 3379 if (of_property_read_bool(np, prop)) 3380 format |= SND_SOC_DAIFMT_CONT; 3381 else 3382 format |= SND_SOC_DAIFMT_GATED; 3383 3384 /* 3385 * check "[prefix]bitclock-inversion" 3386 * check "[prefix]frame-inversion" 3387 * SND_SOC_DAIFMT_INV_MASK area 3388 */ 3389 snprintf(prop, sizeof(prop), "%sbitclock-inversion", prefix); 3390 bit = of_property_read_bool(np, prop); 3391 3392 snprintf(prop, sizeof(prop), "%sframe-inversion", prefix); 3393 frame = of_property_read_bool(np, prop); 3394 3395 switch ((bit << 4) + frame) { 3396 case 0x11: 3397 format |= SND_SOC_DAIFMT_IB_IF; 3398 break; 3399 case 0x10: 3400 format |= SND_SOC_DAIFMT_IB_NF; 3401 break; 3402 case 0x01: 3403 format |= SND_SOC_DAIFMT_NB_IF; 3404 break; 3405 default: 3406 /* SND_SOC_DAIFMT_NB_NF is default */ 3407 break; 3408 } 3409 3410 return format; 3411 } 3412 EXPORT_SYMBOL_GPL(snd_soc_daifmt_parse_format); 3413 3414 unsigned int snd_soc_daifmt_parse_clock_provider_raw(struct device_node *np, 3415 const char *prefix, 3416 struct device_node **bitclkmaster, 3417 struct device_node **framemaster) 3418 { 3419 char prop[128]; 3420 unsigned int bit, frame; 3421 3422 if (!np) 3423 return 0; 3424 3425 if (!prefix) 3426 prefix = ""; 3427 3428 /* 3429 * check "[prefix]bitclock-master" 3430 * check "[prefix]frame-master" 3431 */ 3432 snprintf(prop, sizeof(prop), "%sbitclock-master", prefix); 3433 bit = of_property_present(np, prop); 3434 if (bit && bitclkmaster) 3435 *bitclkmaster = of_parse_phandle(np, prop, 0); 3436 3437 snprintf(prop, sizeof(prop), "%sframe-master", prefix); 3438 frame = of_property_present(np, prop); 3439 if (frame && framemaster) 3440 *framemaster = of_parse_phandle(np, prop, 0); 3441 3442 /* 3443 * return bitmap. 3444 * It will be parameter of 3445 * snd_soc_daifmt_clock_provider_from_bitmap() 3446 */ 3447 return (bit << 4) + frame; 3448 } 3449 EXPORT_SYMBOL_GPL(snd_soc_daifmt_parse_clock_provider_raw); 3450 3451 int snd_soc_get_stream_cpu(const struct snd_soc_dai_link *dai_link, int stream) 3452 { 3453 /* 3454 * [Normal] 3455 * 3456 * Playback 3457 * CPU : SNDRV_PCM_STREAM_PLAYBACK 3458 * Codec: SNDRV_PCM_STREAM_PLAYBACK 3459 * 3460 * Capture 3461 * CPU : SNDRV_PCM_STREAM_CAPTURE 3462 * Codec: SNDRV_PCM_STREAM_CAPTURE 3463 */ 3464 if (!dai_link->c2c_params) 3465 return stream; 3466 3467 /* 3468 * [Codec2Codec] 3469 * 3470 * Playback 3471 * CPU : SNDRV_PCM_STREAM_CAPTURE 3472 * Codec: SNDRV_PCM_STREAM_PLAYBACK 3473 * 3474 * Capture 3475 * CPU : SNDRV_PCM_STREAM_PLAYBACK 3476 * Codec: SNDRV_PCM_STREAM_CAPTURE 3477 */ 3478 if (stream == SNDRV_PCM_STREAM_CAPTURE) 3479 return SNDRV_PCM_STREAM_PLAYBACK; 3480 3481 return SNDRV_PCM_STREAM_CAPTURE; 3482 } 3483 EXPORT_SYMBOL_GPL(snd_soc_get_stream_cpu); 3484 3485 int snd_soc_get_dai_id(struct device_node *ep) 3486 { 3487 struct snd_soc_component *component; 3488 struct snd_soc_dai_link_component dlc = { 3489 .of_node = of_graph_get_port_parent(ep), 3490 }; 3491 int ret; 3492 3493 3494 /* 3495 * For example HDMI case, HDMI has video/sound port, 3496 * but ALSA SoC needs sound port number only. 3497 * Thus counting HDMI DT port/endpoint doesn't work. 3498 * Then, it should have .of_xlate_dai_id 3499 */ 3500 ret = -ENOTSUPP; 3501 mutex_lock(&client_mutex); 3502 component = soc_find_component(&dlc); 3503 if (component) 3504 ret = snd_soc_component_of_xlate_dai_id(component, ep); 3505 mutex_unlock(&client_mutex); 3506 3507 of_node_put(dlc.of_node); 3508 3509 return ret; 3510 } 3511 EXPORT_SYMBOL_GPL(snd_soc_get_dai_id); 3512 3513 int snd_soc_get_dlc(const struct of_phandle_args *args, struct snd_soc_dai_link_component *dlc) 3514 { 3515 struct snd_soc_component *pos; 3516 int ret = -EPROBE_DEFER; 3517 3518 mutex_lock(&client_mutex); 3519 for_each_component(pos) { 3520 struct device_node *component_of_node = soc_component_to_node(pos); 3521 3522 if (component_of_node != args->np || !pos->num_dai) 3523 continue; 3524 3525 ret = snd_soc_component_of_xlate_dai_name(pos, args, &dlc->dai_name); 3526 if (ret == -ENOTSUPP) { 3527 struct snd_soc_dai *dai; 3528 int id = -1; 3529 3530 switch (args->args_count) { 3531 case 0: 3532 id = 0; /* same as dai_drv[0] */ 3533 break; 3534 case 1: 3535 id = args->args[0]; 3536 break; 3537 default: 3538 /* not supported */ 3539 break; 3540 } 3541 3542 if (id < 0 || id >= pos->num_dai) { 3543 ret = -EINVAL; 3544 continue; 3545 } 3546 3547 ret = 0; 3548 3549 /* find target DAI */ 3550 for_each_component_dais(pos, dai) { 3551 if (id == 0) 3552 break; 3553 id--; 3554 } 3555 3556 dlc->dai_name = snd_soc_dai_name_get(dai); 3557 } else if (ret) { 3558 /* 3559 * if another error than ENOTSUPP is returned go on and 3560 * check if another component is provided with the same 3561 * node. This may happen if a device provides several 3562 * components 3563 */ 3564 continue; 3565 } 3566 3567 break; 3568 } 3569 3570 if (ret == 0) 3571 dlc->of_node = args->np; 3572 3573 mutex_unlock(&client_mutex); 3574 return ret; 3575 } 3576 EXPORT_SYMBOL_GPL(snd_soc_get_dlc); 3577 3578 int snd_soc_of_get_dlc(struct device_node *of_node, 3579 struct of_phandle_args *args, 3580 struct snd_soc_dai_link_component *dlc, 3581 int index) 3582 { 3583 struct of_phandle_args __args; 3584 int ret; 3585 3586 if (!args) 3587 args = &__args; 3588 3589 ret = of_parse_phandle_with_args(of_node, "sound-dai", 3590 "#sound-dai-cells", index, args); 3591 if (ret) 3592 return ret; 3593 3594 return snd_soc_get_dlc(args, dlc); 3595 } 3596 EXPORT_SYMBOL_GPL(snd_soc_of_get_dlc); 3597 3598 int snd_soc_get_dai_name(const struct of_phandle_args *args, 3599 const char **dai_name) 3600 { 3601 struct snd_soc_dai_link_component dlc; 3602 int ret = snd_soc_get_dlc(args, &dlc); 3603 3604 if (ret == 0) 3605 *dai_name = dlc.dai_name; 3606 3607 return ret; 3608 } 3609 EXPORT_SYMBOL_GPL(snd_soc_get_dai_name); 3610 3611 int snd_soc_of_get_dai_name(struct device_node *of_node, 3612 const char **dai_name, int index) 3613 { 3614 struct snd_soc_dai_link_component dlc; 3615 int ret = snd_soc_of_get_dlc(of_node, NULL, &dlc, index); 3616 3617 if (ret == 0) 3618 *dai_name = dlc.dai_name; 3619 3620 return ret; 3621 } 3622 EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name); 3623 3624 struct snd_soc_dai *snd_soc_get_dai_via_args(const struct of_phandle_args *dai_args) 3625 { 3626 struct snd_soc_dai *dai; 3627 struct snd_soc_component *component; 3628 3629 mutex_lock(&client_mutex); 3630 for_each_component(component) { 3631 for_each_component_dais(component, dai) 3632 if (snd_soc_is_match_dai_args(dai->driver->dai_args, dai_args)) 3633 goto found; 3634 } 3635 dai = NULL; 3636 found: 3637 mutex_unlock(&client_mutex); 3638 return dai; 3639 } 3640 EXPORT_SYMBOL_GPL(snd_soc_get_dai_via_args); 3641 3642 static void __snd_soc_of_put_component(struct snd_soc_dai_link_component *component) 3643 { 3644 if (component->of_node) { 3645 of_node_put(component->of_node); 3646 component->of_node = NULL; 3647 } 3648 } 3649 3650 static int __snd_soc_of_get_dai_link_component_alloc( 3651 struct device *dev, struct device_node *of_node, 3652 struct snd_soc_dai_link_component **ret_component, 3653 int *ret_num) 3654 { 3655 struct snd_soc_dai_link_component *component; 3656 int num; 3657 3658 /* Count the number of CPUs/CODECs */ 3659 num = of_count_phandle_with_args(of_node, "sound-dai", "#sound-dai-cells"); 3660 if (num <= 0) { 3661 if (num == -ENOENT) 3662 dev_err(dev, "No 'sound-dai' property\n"); 3663 else 3664 dev_err(dev, "Bad phandle in 'sound-dai'\n"); 3665 return num; 3666 } 3667 component = devm_kcalloc(dev, num, sizeof(*component), GFP_KERNEL); 3668 if (!component) 3669 return -ENOMEM; 3670 3671 *ret_component = component; 3672 *ret_num = num; 3673 3674 return 0; 3675 } 3676 3677 /* 3678 * snd_soc_of_put_dai_link_codecs - Dereference device nodes in the codecs array 3679 * @dai_link: DAI link 3680 * 3681 * Dereference device nodes acquired by snd_soc_of_get_dai_link_codecs(). 3682 */ 3683 void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link) 3684 { 3685 struct snd_soc_dai_link_component *component; 3686 int index; 3687 3688 for_each_link_codecs(dai_link, index, component) 3689 __snd_soc_of_put_component(component); 3690 } 3691 EXPORT_SYMBOL_GPL(snd_soc_of_put_dai_link_codecs); 3692 3693 /* 3694 * snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree 3695 * @dev: Card device 3696 * @of_node: Device node 3697 * @dai_link: DAI link 3698 * 3699 * Builds an array of CODEC DAI components from the DAI link property 3700 * 'sound-dai'. 3701 * The array is set in the DAI link and the number of DAIs is set accordingly. 3702 * The device nodes in the array (of_node) must be dereferenced by calling 3703 * snd_soc_of_put_dai_link_codecs() on @dai_link. 3704 * 3705 * Returns 0 for success 3706 */ 3707 int snd_soc_of_get_dai_link_codecs(struct device *dev, 3708 struct device_node *of_node, 3709 struct snd_soc_dai_link *dai_link) 3710 { 3711 struct snd_soc_dai_link_component *component; 3712 int index, ret; 3713 3714 ret = __snd_soc_of_get_dai_link_component_alloc(dev, of_node, 3715 &dai_link->codecs, &dai_link->num_codecs); 3716 if (ret < 0) 3717 return ret; 3718 3719 /* Parse the list */ 3720 for_each_link_codecs(dai_link, index, component) { 3721 ret = snd_soc_of_get_dlc(of_node, NULL, component, index); 3722 if (ret) 3723 goto err; 3724 } 3725 return 0; 3726 err: 3727 snd_soc_of_put_dai_link_codecs(dai_link); 3728 dai_link->codecs = NULL; 3729 dai_link->num_codecs = 0; 3730 return ret; 3731 } 3732 EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs); 3733 3734 /* 3735 * snd_soc_of_put_dai_link_cpus - Dereference device nodes in the codecs array 3736 * @dai_link: DAI link 3737 * 3738 * Dereference device nodes acquired by snd_soc_of_get_dai_link_cpus(). 3739 */ 3740 void snd_soc_of_put_dai_link_cpus(struct snd_soc_dai_link *dai_link) 3741 { 3742 struct snd_soc_dai_link_component *component; 3743 int index; 3744 3745 for_each_link_cpus(dai_link, index, component) 3746 __snd_soc_of_put_component(component); 3747 } 3748 EXPORT_SYMBOL_GPL(snd_soc_of_put_dai_link_cpus); 3749 3750 /* 3751 * snd_soc_of_get_dai_link_cpus - Parse a list of CPU DAIs in the devicetree 3752 * @dev: Card device 3753 * @of_node: Device node 3754 * @dai_link: DAI link 3755 * 3756 * Is analogous to snd_soc_of_get_dai_link_codecs but parses a list of CPU DAIs 3757 * instead. 3758 * 3759 * Returns 0 for success 3760 */ 3761 int snd_soc_of_get_dai_link_cpus(struct device *dev, 3762 struct device_node *of_node, 3763 struct snd_soc_dai_link *dai_link) 3764 { 3765 struct snd_soc_dai_link_component *component; 3766 int index, ret; 3767 3768 /* Count the number of CPUs */ 3769 ret = __snd_soc_of_get_dai_link_component_alloc(dev, of_node, 3770 &dai_link->cpus, &dai_link->num_cpus); 3771 if (ret < 0) 3772 return ret; 3773 3774 /* Parse the list */ 3775 for_each_link_cpus(dai_link, index, component) { 3776 ret = snd_soc_of_get_dlc(of_node, NULL, component, index); 3777 if (ret) 3778 goto err; 3779 } 3780 return 0; 3781 err: 3782 snd_soc_of_put_dai_link_cpus(dai_link); 3783 dai_link->cpus = NULL; 3784 dai_link->num_cpus = 0; 3785 return ret; 3786 } 3787 EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_cpus); 3788 3789 static int __init snd_soc_init(void) 3790 { 3791 int ret; 3792 3793 snd_soc_debugfs_init(); 3794 ret = snd_soc_util_init(); 3795 if (ret) 3796 goto err_util_init; 3797 3798 ret = platform_driver_register(&soc_driver); 3799 if (ret) 3800 goto err_register; 3801 return 0; 3802 3803 err_register: 3804 snd_soc_util_exit(); 3805 err_util_init: 3806 snd_soc_debugfs_exit(); 3807 return ret; 3808 } 3809 module_init(snd_soc_init); 3810 3811 static void __exit snd_soc_exit(void) 3812 { 3813 snd_soc_util_exit(); 3814 snd_soc_debugfs_exit(); 3815 3816 platform_driver_unregister(&soc_driver); 3817 } 3818 module_exit(snd_soc_exit); 3819 3820 /* Module information */ 3821 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk"); 3822 MODULE_DESCRIPTION("ALSA SoC Core"); 3823 MODULE_LICENSE("GPL"); 3824 MODULE_ALIAS("platform:soc-audio"); 3825