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