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