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