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