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