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