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