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