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