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