1 /* 2 * soc-core.c -- ALSA SoC Audio Layer 3 * 4 * Copyright 2005 Wolfson Microelectronics PLC. 5 * Copyright 2005 Openedhand Ltd. 6 * 7 * Author: Liam Girdwood <lrg@slimlogic.co.uk> 8 * with code, comments and ideas from :- 9 * Richard Purdie <richard@openedhand.com> 10 * 11 * This program is free software; you can redistribute it and/or modify it 12 * under the terms of the GNU General Public License as published by the 13 * Free Software Foundation; either version 2 of the License, or (at your 14 * option) any later version. 15 * 16 * TODO: 17 * o Add hw rules to enforce rates, etc. 18 * o More testing with other codecs/machines. 19 * o Add more codecs and platforms to ensure good API coverage. 20 * o Support TDM on PCM and I2S 21 */ 22 23 #include <linux/module.h> 24 #include <linux/moduleparam.h> 25 #include <linux/init.h> 26 #include <linux/delay.h> 27 #include <linux/pm.h> 28 #include <linux/bitops.h> 29 #include <linux/debugfs.h> 30 #include <linux/platform_device.h> 31 #include <sound/ac97_codec.h> 32 #include <sound/core.h> 33 #include <sound/pcm.h> 34 #include <sound/pcm_params.h> 35 #include <sound/soc.h> 36 #include <sound/soc-dapm.h> 37 #include <sound/initval.h> 38 39 static DEFINE_MUTEX(pcm_mutex); 40 static DEFINE_MUTEX(io_mutex); 41 static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq); 42 43 #ifdef CONFIG_DEBUG_FS 44 static struct dentry *debugfs_root; 45 #endif 46 47 static DEFINE_MUTEX(client_mutex); 48 static LIST_HEAD(card_list); 49 static LIST_HEAD(dai_list); 50 static LIST_HEAD(platform_list); 51 static LIST_HEAD(codec_list); 52 53 static int snd_soc_register_card(struct snd_soc_card *card); 54 static int snd_soc_unregister_card(struct snd_soc_card *card); 55 56 /* 57 * This is a timeout to do a DAPM powerdown after a stream is closed(). 58 * It can be used to eliminate pops between different playback streams, e.g. 59 * between two audio tracks. 60 */ 61 static int pmdown_time = 5000; 62 module_param(pmdown_time, int, 0); 63 MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)"); 64 65 /* 66 * This function forces any delayed work to be queued and run. 67 */ 68 static int run_delayed_work(struct delayed_work *dwork) 69 { 70 int ret; 71 72 /* cancel any work waiting to be queued. */ 73 ret = cancel_delayed_work(dwork); 74 75 /* if there was any work waiting then we run it now and 76 * wait for it's completion */ 77 if (ret) { 78 schedule_delayed_work(dwork, 0); 79 flush_scheduled_work(); 80 } 81 return ret; 82 } 83 84 #ifdef CONFIG_SND_SOC_AC97_BUS 85 /* unregister ac97 codec */ 86 static int soc_ac97_dev_unregister(struct snd_soc_codec *codec) 87 { 88 if (codec->ac97->dev.bus) 89 device_unregister(&codec->ac97->dev); 90 return 0; 91 } 92 93 /* stop no dev release warning */ 94 static void soc_ac97_device_release(struct device *dev){} 95 96 /* register ac97 codec to bus */ 97 static int soc_ac97_dev_register(struct snd_soc_codec *codec) 98 { 99 int err; 100 101 codec->ac97->dev.bus = &ac97_bus_type; 102 codec->ac97->dev.parent = codec->card->dev; 103 codec->ac97->dev.release = soc_ac97_device_release; 104 105 dev_set_name(&codec->ac97->dev, "%d-%d:%s", 106 codec->card->number, 0, codec->name); 107 err = device_register(&codec->ac97->dev); 108 if (err < 0) { 109 snd_printk(KERN_ERR "Can't register ac97 bus\n"); 110 codec->ac97->dev.bus = NULL; 111 return err; 112 } 113 return 0; 114 } 115 #endif 116 117 static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream) 118 { 119 struct snd_soc_pcm_runtime *rtd = substream->private_data; 120 struct snd_soc_device *socdev = rtd->socdev; 121 struct snd_soc_card *card = socdev->card; 122 struct snd_soc_dai_link *machine = rtd->dai; 123 struct snd_soc_dai *cpu_dai = machine->cpu_dai; 124 struct snd_soc_dai *codec_dai = machine->codec_dai; 125 int ret; 126 127 if (codec_dai->symmetric_rates || cpu_dai->symmetric_rates || 128 machine->symmetric_rates) { 129 dev_dbg(card->dev, "Symmetry forces %dHz rate\n", 130 machine->rate); 131 132 ret = snd_pcm_hw_constraint_minmax(substream->runtime, 133 SNDRV_PCM_HW_PARAM_RATE, 134 machine->rate, 135 machine->rate); 136 if (ret < 0) { 137 dev_err(card->dev, 138 "Unable to apply rate symmetry constraint: %d\n", ret); 139 return ret; 140 } 141 } 142 143 return 0; 144 } 145 146 /* 147 * Called by ALSA when a PCM substream is opened, the runtime->hw record is 148 * then initialized and any private data can be allocated. This also calls 149 * startup for the cpu DAI, platform, machine and codec DAI. 150 */ 151 static int soc_pcm_open(struct snd_pcm_substream *substream) 152 { 153 struct snd_soc_pcm_runtime *rtd = substream->private_data; 154 struct snd_soc_device *socdev = rtd->socdev; 155 struct snd_soc_card *card = socdev->card; 156 struct snd_pcm_runtime *runtime = substream->runtime; 157 struct snd_soc_dai_link *machine = rtd->dai; 158 struct snd_soc_platform *platform = card->platform; 159 struct snd_soc_dai *cpu_dai = machine->cpu_dai; 160 struct snd_soc_dai *codec_dai = machine->codec_dai; 161 int ret = 0; 162 163 mutex_lock(&pcm_mutex); 164 165 /* startup the audio subsystem */ 166 if (cpu_dai->ops->startup) { 167 ret = cpu_dai->ops->startup(substream, cpu_dai); 168 if (ret < 0) { 169 printk(KERN_ERR "asoc: can't open interface %s\n", 170 cpu_dai->name); 171 goto out; 172 } 173 } 174 175 if (platform->pcm_ops->open) { 176 ret = platform->pcm_ops->open(substream); 177 if (ret < 0) { 178 printk(KERN_ERR "asoc: can't open platform %s\n", platform->name); 179 goto platform_err; 180 } 181 } 182 183 if (codec_dai->ops->startup) { 184 ret = codec_dai->ops->startup(substream, codec_dai); 185 if (ret < 0) { 186 printk(KERN_ERR "asoc: can't open codec %s\n", 187 codec_dai->name); 188 goto codec_dai_err; 189 } 190 } 191 192 if (machine->ops && machine->ops->startup) { 193 ret = machine->ops->startup(substream); 194 if (ret < 0) { 195 printk(KERN_ERR "asoc: %s startup failed\n", machine->name); 196 goto machine_err; 197 } 198 } 199 200 /* Check that the codec and cpu DAI's are compatible */ 201 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 202 runtime->hw.rate_min = 203 max(codec_dai->playback.rate_min, 204 cpu_dai->playback.rate_min); 205 runtime->hw.rate_max = 206 min(codec_dai->playback.rate_max, 207 cpu_dai->playback.rate_max); 208 runtime->hw.channels_min = 209 max(codec_dai->playback.channels_min, 210 cpu_dai->playback.channels_min); 211 runtime->hw.channels_max = 212 min(codec_dai->playback.channels_max, 213 cpu_dai->playback.channels_max); 214 runtime->hw.formats = 215 codec_dai->playback.formats & cpu_dai->playback.formats; 216 runtime->hw.rates = 217 codec_dai->playback.rates & cpu_dai->playback.rates; 218 } else { 219 runtime->hw.rate_min = 220 max(codec_dai->capture.rate_min, 221 cpu_dai->capture.rate_min); 222 runtime->hw.rate_max = 223 min(codec_dai->capture.rate_max, 224 cpu_dai->capture.rate_max); 225 runtime->hw.channels_min = 226 max(codec_dai->capture.channels_min, 227 cpu_dai->capture.channels_min); 228 runtime->hw.channels_max = 229 min(codec_dai->capture.channels_max, 230 cpu_dai->capture.channels_max); 231 runtime->hw.formats = 232 codec_dai->capture.formats & cpu_dai->capture.formats; 233 runtime->hw.rates = 234 codec_dai->capture.rates & cpu_dai->capture.rates; 235 } 236 237 snd_pcm_limit_hw_rates(runtime); 238 if (!runtime->hw.rates) { 239 printk(KERN_ERR "asoc: %s <-> %s No matching rates\n", 240 codec_dai->name, cpu_dai->name); 241 goto machine_err; 242 } 243 if (!runtime->hw.formats) { 244 printk(KERN_ERR "asoc: %s <-> %s No matching formats\n", 245 codec_dai->name, cpu_dai->name); 246 goto machine_err; 247 } 248 if (!runtime->hw.channels_min || !runtime->hw.channels_max) { 249 printk(KERN_ERR "asoc: %s <-> %s No matching channels\n", 250 codec_dai->name, cpu_dai->name); 251 goto machine_err; 252 } 253 254 /* Symmetry only applies if we've already got an active stream. */ 255 if (cpu_dai->active || codec_dai->active) { 256 ret = soc_pcm_apply_symmetry(substream); 257 if (ret != 0) 258 goto machine_err; 259 } 260 261 pr_debug("asoc: %s <-> %s info:\n", codec_dai->name, cpu_dai->name); 262 pr_debug("asoc: rate mask 0x%x\n", runtime->hw.rates); 263 pr_debug("asoc: min ch %d max ch %d\n", runtime->hw.channels_min, 264 runtime->hw.channels_max); 265 pr_debug("asoc: min rate %d max rate %d\n", runtime->hw.rate_min, 266 runtime->hw.rate_max); 267 268 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 269 cpu_dai->playback.active = codec_dai->playback.active = 1; 270 else 271 cpu_dai->capture.active = codec_dai->capture.active = 1; 272 cpu_dai->active = codec_dai->active = 1; 273 cpu_dai->runtime = runtime; 274 card->codec->active++; 275 mutex_unlock(&pcm_mutex); 276 return 0; 277 278 machine_err: 279 if (machine->ops && machine->ops->shutdown) 280 machine->ops->shutdown(substream); 281 282 codec_dai_err: 283 if (platform->pcm_ops->close) 284 platform->pcm_ops->close(substream); 285 286 platform_err: 287 if (cpu_dai->ops->shutdown) 288 cpu_dai->ops->shutdown(substream, cpu_dai); 289 out: 290 mutex_unlock(&pcm_mutex); 291 return ret; 292 } 293 294 /* 295 * Power down the audio subsystem pmdown_time msecs after close is called. 296 * This is to ensure there are no pops or clicks in between any music tracks 297 * due to DAPM power cycling. 298 */ 299 static void close_delayed_work(struct work_struct *work) 300 { 301 struct snd_soc_card *card = container_of(work, struct snd_soc_card, 302 delayed_work.work); 303 struct snd_soc_codec *codec = card->codec; 304 struct snd_soc_dai *codec_dai; 305 int i; 306 307 mutex_lock(&pcm_mutex); 308 for (i = 0; i < codec->num_dai; i++) { 309 codec_dai = &codec->dai[i]; 310 311 pr_debug("pop wq checking: %s status: %s waiting: %s\n", 312 codec_dai->playback.stream_name, 313 codec_dai->playback.active ? "active" : "inactive", 314 codec_dai->pop_wait ? "yes" : "no"); 315 316 /* are we waiting on this codec DAI stream */ 317 if (codec_dai->pop_wait == 1) { 318 codec_dai->pop_wait = 0; 319 snd_soc_dapm_stream_event(codec, 320 codec_dai->playback.stream_name, 321 SND_SOC_DAPM_STREAM_STOP); 322 } 323 } 324 mutex_unlock(&pcm_mutex); 325 } 326 327 /* 328 * Called by ALSA when a PCM substream is closed. Private data can be 329 * freed here. The cpu DAI, codec DAI, machine and platform are also 330 * shutdown. 331 */ 332 static int soc_codec_close(struct snd_pcm_substream *substream) 333 { 334 struct snd_soc_pcm_runtime *rtd = substream->private_data; 335 struct snd_soc_device *socdev = rtd->socdev; 336 struct snd_soc_card *card = socdev->card; 337 struct snd_soc_dai_link *machine = rtd->dai; 338 struct snd_soc_platform *platform = card->platform; 339 struct snd_soc_dai *cpu_dai = machine->cpu_dai; 340 struct snd_soc_dai *codec_dai = machine->codec_dai; 341 struct snd_soc_codec *codec = card->codec; 342 343 mutex_lock(&pcm_mutex); 344 345 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 346 cpu_dai->playback.active = codec_dai->playback.active = 0; 347 else 348 cpu_dai->capture.active = codec_dai->capture.active = 0; 349 350 if (codec_dai->playback.active == 0 && 351 codec_dai->capture.active == 0) { 352 cpu_dai->active = codec_dai->active = 0; 353 } 354 codec->active--; 355 356 /* Muting the DAC suppresses artifacts caused during digital 357 * shutdown, for example from stopping clocks. 358 */ 359 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 360 snd_soc_dai_digital_mute(codec_dai, 1); 361 362 if (cpu_dai->ops->shutdown) 363 cpu_dai->ops->shutdown(substream, cpu_dai); 364 365 if (codec_dai->ops->shutdown) 366 codec_dai->ops->shutdown(substream, codec_dai); 367 368 if (machine->ops && machine->ops->shutdown) 369 machine->ops->shutdown(substream); 370 371 if (platform->pcm_ops->close) 372 platform->pcm_ops->close(substream); 373 cpu_dai->runtime = NULL; 374 375 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 376 /* start delayed pop wq here for playback streams */ 377 codec_dai->pop_wait = 1; 378 schedule_delayed_work(&card->delayed_work, 379 msecs_to_jiffies(pmdown_time)); 380 } else { 381 /* capture streams can be powered down now */ 382 snd_soc_dapm_stream_event(codec, 383 codec_dai->capture.stream_name, 384 SND_SOC_DAPM_STREAM_STOP); 385 } 386 387 mutex_unlock(&pcm_mutex); 388 return 0; 389 } 390 391 /* 392 * Called by ALSA when the PCM substream is prepared, can set format, sample 393 * rate, etc. This function is non atomic and can be called multiple times, 394 * it can refer to the runtime info. 395 */ 396 static int soc_pcm_prepare(struct snd_pcm_substream *substream) 397 { 398 struct snd_soc_pcm_runtime *rtd = substream->private_data; 399 struct snd_soc_device *socdev = rtd->socdev; 400 struct snd_soc_card *card = socdev->card; 401 struct snd_soc_dai_link *machine = rtd->dai; 402 struct snd_soc_platform *platform = card->platform; 403 struct snd_soc_dai *cpu_dai = machine->cpu_dai; 404 struct snd_soc_dai *codec_dai = machine->codec_dai; 405 struct snd_soc_codec *codec = card->codec; 406 int ret = 0; 407 408 mutex_lock(&pcm_mutex); 409 410 if (machine->ops && machine->ops->prepare) { 411 ret = machine->ops->prepare(substream); 412 if (ret < 0) { 413 printk(KERN_ERR "asoc: machine prepare error\n"); 414 goto out; 415 } 416 } 417 418 if (platform->pcm_ops->prepare) { 419 ret = platform->pcm_ops->prepare(substream); 420 if (ret < 0) { 421 printk(KERN_ERR "asoc: platform prepare error\n"); 422 goto out; 423 } 424 } 425 426 if (codec_dai->ops->prepare) { 427 ret = codec_dai->ops->prepare(substream, codec_dai); 428 if (ret < 0) { 429 printk(KERN_ERR "asoc: codec DAI prepare error\n"); 430 goto out; 431 } 432 } 433 434 if (cpu_dai->ops->prepare) { 435 ret = cpu_dai->ops->prepare(substream, cpu_dai); 436 if (ret < 0) { 437 printk(KERN_ERR "asoc: cpu DAI prepare error\n"); 438 goto out; 439 } 440 } 441 442 /* cancel any delayed stream shutdown that is pending */ 443 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && 444 codec_dai->pop_wait) { 445 codec_dai->pop_wait = 0; 446 cancel_delayed_work(&card->delayed_work); 447 } 448 449 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 450 snd_soc_dapm_stream_event(codec, 451 codec_dai->playback.stream_name, 452 SND_SOC_DAPM_STREAM_START); 453 else 454 snd_soc_dapm_stream_event(codec, 455 codec_dai->capture.stream_name, 456 SND_SOC_DAPM_STREAM_START); 457 458 snd_soc_dai_digital_mute(codec_dai, 0); 459 460 out: 461 mutex_unlock(&pcm_mutex); 462 return ret; 463 } 464 465 /* 466 * Called by ALSA when the hardware params are set by application. This 467 * function can also be called multiple times and can allocate buffers 468 * (using snd_pcm_lib_* ). It's non-atomic. 469 */ 470 static int soc_pcm_hw_params(struct snd_pcm_substream *substream, 471 struct snd_pcm_hw_params *params) 472 { 473 struct snd_soc_pcm_runtime *rtd = substream->private_data; 474 struct snd_soc_device *socdev = rtd->socdev; 475 struct snd_soc_dai_link *machine = rtd->dai; 476 struct snd_soc_card *card = socdev->card; 477 struct snd_soc_platform *platform = card->platform; 478 struct snd_soc_dai *cpu_dai = machine->cpu_dai; 479 struct snd_soc_dai *codec_dai = machine->codec_dai; 480 int ret = 0; 481 482 mutex_lock(&pcm_mutex); 483 484 if (machine->ops && machine->ops->hw_params) { 485 ret = machine->ops->hw_params(substream, params); 486 if (ret < 0) { 487 printk(KERN_ERR "asoc: machine hw_params failed\n"); 488 goto out; 489 } 490 } 491 492 if (codec_dai->ops->hw_params) { 493 ret = codec_dai->ops->hw_params(substream, params, codec_dai); 494 if (ret < 0) { 495 printk(KERN_ERR "asoc: can't set codec %s hw params\n", 496 codec_dai->name); 497 goto codec_err; 498 } 499 } 500 501 if (cpu_dai->ops->hw_params) { 502 ret = cpu_dai->ops->hw_params(substream, params, cpu_dai); 503 if (ret < 0) { 504 printk(KERN_ERR "asoc: interface %s hw params failed\n", 505 cpu_dai->name); 506 goto interface_err; 507 } 508 } 509 510 if (platform->pcm_ops->hw_params) { 511 ret = platform->pcm_ops->hw_params(substream, params); 512 if (ret < 0) { 513 printk(KERN_ERR "asoc: platform %s hw params failed\n", 514 platform->name); 515 goto platform_err; 516 } 517 } 518 519 machine->rate = params_rate(params); 520 521 out: 522 mutex_unlock(&pcm_mutex); 523 return ret; 524 525 platform_err: 526 if (cpu_dai->ops->hw_free) 527 cpu_dai->ops->hw_free(substream, cpu_dai); 528 529 interface_err: 530 if (codec_dai->ops->hw_free) 531 codec_dai->ops->hw_free(substream, codec_dai); 532 533 codec_err: 534 if (machine->ops && machine->ops->hw_free) 535 machine->ops->hw_free(substream); 536 537 mutex_unlock(&pcm_mutex); 538 return ret; 539 } 540 541 /* 542 * Free's resources allocated by hw_params, can be called multiple times 543 */ 544 static int soc_pcm_hw_free(struct snd_pcm_substream *substream) 545 { 546 struct snd_soc_pcm_runtime *rtd = substream->private_data; 547 struct snd_soc_device *socdev = rtd->socdev; 548 struct snd_soc_dai_link *machine = rtd->dai; 549 struct snd_soc_card *card = socdev->card; 550 struct snd_soc_platform *platform = card->platform; 551 struct snd_soc_dai *cpu_dai = machine->cpu_dai; 552 struct snd_soc_dai *codec_dai = machine->codec_dai; 553 struct snd_soc_codec *codec = card->codec; 554 555 mutex_lock(&pcm_mutex); 556 557 /* apply codec digital mute */ 558 if (!codec->active) 559 snd_soc_dai_digital_mute(codec_dai, 1); 560 561 /* free any machine hw params */ 562 if (machine->ops && machine->ops->hw_free) 563 machine->ops->hw_free(substream); 564 565 /* free any DMA resources */ 566 if (platform->pcm_ops->hw_free) 567 platform->pcm_ops->hw_free(substream); 568 569 /* now free hw params for the DAI's */ 570 if (codec_dai->ops->hw_free) 571 codec_dai->ops->hw_free(substream, codec_dai); 572 573 if (cpu_dai->ops->hw_free) 574 cpu_dai->ops->hw_free(substream, cpu_dai); 575 576 mutex_unlock(&pcm_mutex); 577 return 0; 578 } 579 580 static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 581 { 582 struct snd_soc_pcm_runtime *rtd = substream->private_data; 583 struct snd_soc_device *socdev = rtd->socdev; 584 struct snd_soc_card *card= socdev->card; 585 struct snd_soc_dai_link *machine = rtd->dai; 586 struct snd_soc_platform *platform = card->platform; 587 struct snd_soc_dai *cpu_dai = machine->cpu_dai; 588 struct snd_soc_dai *codec_dai = machine->codec_dai; 589 int ret; 590 591 if (codec_dai->ops->trigger) { 592 ret = codec_dai->ops->trigger(substream, cmd, codec_dai); 593 if (ret < 0) 594 return ret; 595 } 596 597 if (platform->pcm_ops->trigger) { 598 ret = platform->pcm_ops->trigger(substream, cmd); 599 if (ret < 0) 600 return ret; 601 } 602 603 if (cpu_dai->ops->trigger) { 604 ret = cpu_dai->ops->trigger(substream, cmd, cpu_dai); 605 if (ret < 0) 606 return ret; 607 } 608 return 0; 609 } 610 611 /* ASoC PCM operations */ 612 static struct snd_pcm_ops soc_pcm_ops = { 613 .open = soc_pcm_open, 614 .close = soc_codec_close, 615 .hw_params = soc_pcm_hw_params, 616 .hw_free = soc_pcm_hw_free, 617 .prepare = soc_pcm_prepare, 618 .trigger = soc_pcm_trigger, 619 }; 620 621 #ifdef CONFIG_PM 622 /* powers down audio subsystem for suspend */ 623 static int soc_suspend(struct device *dev) 624 { 625 struct platform_device *pdev = to_platform_device(dev); 626 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 627 struct snd_soc_card *card = socdev->card; 628 struct snd_soc_platform *platform = card->platform; 629 struct snd_soc_codec_device *codec_dev = socdev->codec_dev; 630 struct snd_soc_codec *codec = card->codec; 631 int i; 632 633 /* If the initialization of this soc device failed, there is no codec 634 * associated with it. Just bail out in this case. 635 */ 636 if (!codec) 637 return 0; 638 639 /* Due to the resume being scheduled into a workqueue we could 640 * suspend before that's finished - wait for it to complete. 641 */ 642 snd_power_lock(codec->card); 643 snd_power_wait(codec->card, SNDRV_CTL_POWER_D0); 644 snd_power_unlock(codec->card); 645 646 /* we're going to block userspace touching us until resume completes */ 647 snd_power_change_state(codec->card, SNDRV_CTL_POWER_D3hot); 648 649 /* mute any active DAC's */ 650 for (i = 0; i < card->num_links; i++) { 651 struct snd_soc_dai *dai = card->dai_link[i].codec_dai; 652 if (dai->ops->digital_mute && dai->playback.active) 653 dai->ops->digital_mute(dai, 1); 654 } 655 656 /* suspend all pcms */ 657 for (i = 0; i < card->num_links; i++) 658 snd_pcm_suspend_all(card->dai_link[i].pcm); 659 660 if (card->suspend_pre) 661 card->suspend_pre(pdev, PMSG_SUSPEND); 662 663 for (i = 0; i < card->num_links; i++) { 664 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai; 665 if (cpu_dai->suspend && !cpu_dai->ac97_control) 666 cpu_dai->suspend(cpu_dai); 667 if (platform->suspend) 668 platform->suspend(cpu_dai); 669 } 670 671 /* close any waiting streams and save state */ 672 run_delayed_work(&card->delayed_work); 673 codec->suspend_bias_level = codec->bias_level; 674 675 for (i = 0; i < codec->num_dai; i++) { 676 char *stream = codec->dai[i].playback.stream_name; 677 if (stream != NULL) 678 snd_soc_dapm_stream_event(codec, stream, 679 SND_SOC_DAPM_STREAM_SUSPEND); 680 stream = codec->dai[i].capture.stream_name; 681 if (stream != NULL) 682 snd_soc_dapm_stream_event(codec, stream, 683 SND_SOC_DAPM_STREAM_SUSPEND); 684 } 685 686 if (codec_dev->suspend) 687 codec_dev->suspend(pdev, PMSG_SUSPEND); 688 689 for (i = 0; i < card->num_links; i++) { 690 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai; 691 if (cpu_dai->suspend && cpu_dai->ac97_control) 692 cpu_dai->suspend(cpu_dai); 693 } 694 695 if (card->suspend_post) 696 card->suspend_post(pdev, PMSG_SUSPEND); 697 698 return 0; 699 } 700 701 /* deferred resume work, so resume can complete before we finished 702 * setting our codec back up, which can be very slow on I2C 703 */ 704 static void soc_resume_deferred(struct work_struct *work) 705 { 706 struct snd_soc_card *card = container_of(work, 707 struct snd_soc_card, 708 deferred_resume_work); 709 struct snd_soc_device *socdev = card->socdev; 710 struct snd_soc_platform *platform = card->platform; 711 struct snd_soc_codec_device *codec_dev = socdev->codec_dev; 712 struct snd_soc_codec *codec = card->codec; 713 struct platform_device *pdev = to_platform_device(socdev->dev); 714 int i; 715 716 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time, 717 * so userspace apps are blocked from touching us 718 */ 719 720 dev_dbg(socdev->dev, "starting resume work\n"); 721 722 if (card->resume_pre) 723 card->resume_pre(pdev); 724 725 for (i = 0; i < card->num_links; i++) { 726 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai; 727 if (cpu_dai->resume && cpu_dai->ac97_control) 728 cpu_dai->resume(cpu_dai); 729 } 730 731 if (codec_dev->resume) 732 codec_dev->resume(pdev); 733 734 for (i = 0; i < codec->num_dai; i++) { 735 char *stream = codec->dai[i].playback.stream_name; 736 if (stream != NULL) 737 snd_soc_dapm_stream_event(codec, stream, 738 SND_SOC_DAPM_STREAM_RESUME); 739 stream = codec->dai[i].capture.stream_name; 740 if (stream != NULL) 741 snd_soc_dapm_stream_event(codec, stream, 742 SND_SOC_DAPM_STREAM_RESUME); 743 } 744 745 /* unmute any active DACs */ 746 for (i = 0; i < card->num_links; i++) { 747 struct snd_soc_dai *dai = card->dai_link[i].codec_dai; 748 if (dai->ops->digital_mute && dai->playback.active) 749 dai->ops->digital_mute(dai, 0); 750 } 751 752 for (i = 0; i < card->num_links; i++) { 753 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai; 754 if (cpu_dai->resume && !cpu_dai->ac97_control) 755 cpu_dai->resume(cpu_dai); 756 if (platform->resume) 757 platform->resume(cpu_dai); 758 } 759 760 if (card->resume_post) 761 card->resume_post(pdev); 762 763 dev_dbg(socdev->dev, "resume work completed\n"); 764 765 /* userspace can access us now we are back as we were before */ 766 snd_power_change_state(codec->card, SNDRV_CTL_POWER_D0); 767 } 768 769 /* powers up audio subsystem after a suspend */ 770 static int soc_resume(struct device *dev) 771 { 772 struct platform_device *pdev = to_platform_device(dev); 773 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 774 struct snd_soc_card *card = socdev->card; 775 struct snd_soc_dai *cpu_dai = card->dai_link[0].cpu_dai; 776 777 /* AC97 devices might have other drivers hanging off them so 778 * need to resume immediately. Other drivers don't have that 779 * problem and may take a substantial amount of time to resume 780 * due to I/O costs and anti-pop so handle them out of line. 781 */ 782 if (cpu_dai->ac97_control) { 783 dev_dbg(socdev->dev, "Resuming AC97 immediately\n"); 784 soc_resume_deferred(&card->deferred_resume_work); 785 } else { 786 dev_dbg(socdev->dev, "Scheduling resume work\n"); 787 if (!schedule_work(&card->deferred_resume_work)) 788 dev_err(socdev->dev, "resume work item may be lost\n"); 789 } 790 791 return 0; 792 } 793 794 /** 795 * snd_soc_suspend_device: Notify core of device suspend 796 * 797 * @dev: Device being suspended. 798 * 799 * In order to ensure that the entire audio subsystem is suspended in a 800 * coordinated fashion ASoC devices should suspend themselves when 801 * called by ASoC. When the standard kernel suspend process asks the 802 * device to suspend it should call this function to initiate a suspend 803 * of the entire ASoC card. 804 * 805 * \note Currently this function is stubbed out. 806 */ 807 int snd_soc_suspend_device(struct device *dev) 808 { 809 return 0; 810 } 811 EXPORT_SYMBOL_GPL(snd_soc_suspend_device); 812 813 /** 814 * snd_soc_resume_device: Notify core of device resume 815 * 816 * @dev: Device being resumed. 817 * 818 * In order to ensure that the entire audio subsystem is resumed in a 819 * coordinated fashion ASoC devices should resume themselves when called 820 * by ASoC. When the standard kernel resume process asks the device 821 * to resume it should call this function. Once all the components of 822 * the card have notified that they are ready to be resumed the card 823 * will be resumed. 824 * 825 * \note Currently this function is stubbed out. 826 */ 827 int snd_soc_resume_device(struct device *dev) 828 { 829 return 0; 830 } 831 EXPORT_SYMBOL_GPL(snd_soc_resume_device); 832 #else 833 #define soc_suspend NULL 834 #define soc_resume NULL 835 #endif 836 837 static struct snd_soc_dai_ops null_dai_ops = { 838 }; 839 840 static void snd_soc_instantiate_card(struct snd_soc_card *card) 841 { 842 struct platform_device *pdev = container_of(card->dev, 843 struct platform_device, 844 dev); 845 struct snd_soc_codec_device *codec_dev = card->socdev->codec_dev; 846 struct snd_soc_platform *platform; 847 struct snd_soc_dai *dai; 848 int i, found, ret, ac97; 849 850 if (card->instantiated) 851 return; 852 853 found = 0; 854 list_for_each_entry(platform, &platform_list, list) 855 if (card->platform == platform) { 856 found = 1; 857 break; 858 } 859 if (!found) { 860 dev_dbg(card->dev, "Platform %s not registered\n", 861 card->platform->name); 862 return; 863 } 864 865 ac97 = 0; 866 for (i = 0; i < card->num_links; i++) { 867 found = 0; 868 list_for_each_entry(dai, &dai_list, list) 869 if (card->dai_link[i].cpu_dai == dai) { 870 found = 1; 871 break; 872 } 873 if (!found) { 874 dev_dbg(card->dev, "DAI %s not registered\n", 875 card->dai_link[i].cpu_dai->name); 876 return; 877 } 878 879 if (card->dai_link[i].cpu_dai->ac97_control) 880 ac97 = 1; 881 } 882 883 for (i = 0; i < card->num_links; i++) { 884 if (!card->dai_link[i].codec_dai->ops) 885 card->dai_link[i].codec_dai->ops = &null_dai_ops; 886 } 887 888 /* If we have AC97 in the system then don't wait for the 889 * codec. This will need revisiting if we have to handle 890 * systems with mixed AC97 and non-AC97 parts. Only check for 891 * DAIs currently; we can't do this per link since some AC97 892 * codecs have non-AC97 DAIs. 893 */ 894 if (!ac97) 895 for (i = 0; i < card->num_links; i++) { 896 found = 0; 897 list_for_each_entry(dai, &dai_list, list) 898 if (card->dai_link[i].codec_dai == dai) { 899 found = 1; 900 break; 901 } 902 if (!found) { 903 dev_dbg(card->dev, "DAI %s not registered\n", 904 card->dai_link[i].codec_dai->name); 905 return; 906 } 907 } 908 909 /* Note that we do not current check for codec components */ 910 911 dev_dbg(card->dev, "All components present, instantiating\n"); 912 913 /* Found everything, bring it up */ 914 if (card->probe) { 915 ret = card->probe(pdev); 916 if (ret < 0) 917 return; 918 } 919 920 for (i = 0; i < card->num_links; i++) { 921 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai; 922 if (cpu_dai->probe) { 923 ret = cpu_dai->probe(pdev, cpu_dai); 924 if (ret < 0) 925 goto cpu_dai_err; 926 } 927 } 928 929 if (codec_dev->probe) { 930 ret = codec_dev->probe(pdev); 931 if (ret < 0) 932 goto cpu_dai_err; 933 } 934 935 if (platform->probe) { 936 ret = platform->probe(pdev); 937 if (ret < 0) 938 goto platform_err; 939 } 940 941 /* DAPM stream work */ 942 INIT_DELAYED_WORK(&card->delayed_work, close_delayed_work); 943 #ifdef CONFIG_PM 944 /* deferred resume work */ 945 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred); 946 #endif 947 948 card->instantiated = 1; 949 950 return; 951 952 platform_err: 953 if (codec_dev->remove) 954 codec_dev->remove(pdev); 955 956 cpu_dai_err: 957 for (i--; i >= 0; i--) { 958 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai; 959 if (cpu_dai->remove) 960 cpu_dai->remove(pdev, cpu_dai); 961 } 962 963 if (card->remove) 964 card->remove(pdev); 965 } 966 967 /* 968 * Attempt to initialise any uninitalised cards. Must be called with 969 * client_mutex. 970 */ 971 static void snd_soc_instantiate_cards(void) 972 { 973 struct snd_soc_card *card; 974 list_for_each_entry(card, &card_list, list) 975 snd_soc_instantiate_card(card); 976 } 977 978 /* probes a new socdev */ 979 static int soc_probe(struct platform_device *pdev) 980 { 981 int ret = 0; 982 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 983 struct snd_soc_card *card = socdev->card; 984 985 /* Bodge while we push things out of socdev */ 986 card->socdev = socdev; 987 988 /* Bodge while we unpick instantiation */ 989 card->dev = &pdev->dev; 990 ret = snd_soc_register_card(card); 991 if (ret != 0) { 992 dev_err(&pdev->dev, "Failed to register card\n"); 993 return ret; 994 } 995 996 return 0; 997 } 998 999 /* removes a socdev */ 1000 static int soc_remove(struct platform_device *pdev) 1001 { 1002 int i; 1003 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 1004 struct snd_soc_card *card = socdev->card; 1005 struct snd_soc_platform *platform = card->platform; 1006 struct snd_soc_codec_device *codec_dev = socdev->codec_dev; 1007 1008 if (!card->instantiated) 1009 return 0; 1010 1011 run_delayed_work(&card->delayed_work); 1012 1013 if (platform->remove) 1014 platform->remove(pdev); 1015 1016 if (codec_dev->remove) 1017 codec_dev->remove(pdev); 1018 1019 for (i = 0; i < card->num_links; i++) { 1020 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai; 1021 if (cpu_dai->remove) 1022 cpu_dai->remove(pdev, cpu_dai); 1023 } 1024 1025 if (card->remove) 1026 card->remove(pdev); 1027 1028 snd_soc_unregister_card(card); 1029 1030 return 0; 1031 } 1032 1033 static int soc_poweroff(struct device *dev) 1034 { 1035 struct platform_device *pdev = to_platform_device(dev); 1036 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 1037 struct snd_soc_card *card = socdev->card; 1038 1039 if (!card->instantiated) 1040 return 0; 1041 1042 /* Flush out pmdown_time work - we actually do want to run it 1043 * now, we're shutting down so no imminent restart. */ 1044 run_delayed_work(&card->delayed_work); 1045 1046 snd_soc_dapm_shutdown(socdev); 1047 1048 return 0; 1049 } 1050 1051 static struct dev_pm_ops soc_pm_ops = { 1052 .suspend = soc_suspend, 1053 .resume = soc_resume, 1054 .poweroff = soc_poweroff, 1055 }; 1056 1057 /* ASoC platform driver */ 1058 static struct platform_driver soc_driver = { 1059 .driver = { 1060 .name = "soc-audio", 1061 .owner = THIS_MODULE, 1062 .pm = &soc_pm_ops, 1063 }, 1064 .probe = soc_probe, 1065 .remove = soc_remove, 1066 }; 1067 1068 /* create a new pcm */ 1069 static int soc_new_pcm(struct snd_soc_device *socdev, 1070 struct snd_soc_dai_link *dai_link, int num) 1071 { 1072 struct snd_soc_card *card = socdev->card; 1073 struct snd_soc_codec *codec = card->codec; 1074 struct snd_soc_platform *platform = card->platform; 1075 struct snd_soc_dai *codec_dai = dai_link->codec_dai; 1076 struct snd_soc_dai *cpu_dai = dai_link->cpu_dai; 1077 struct snd_soc_pcm_runtime *rtd; 1078 struct snd_pcm *pcm; 1079 char new_name[64]; 1080 int ret = 0, playback = 0, capture = 0; 1081 1082 rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL); 1083 if (rtd == NULL) 1084 return -ENOMEM; 1085 1086 rtd->dai = dai_link; 1087 rtd->socdev = socdev; 1088 codec_dai->codec = card->codec; 1089 1090 /* check client and interface hw capabilities */ 1091 sprintf(new_name, "%s %s-%d", dai_link->stream_name, codec_dai->name, 1092 num); 1093 1094 if (codec_dai->playback.channels_min) 1095 playback = 1; 1096 if (codec_dai->capture.channels_min) 1097 capture = 1; 1098 1099 ret = snd_pcm_new(codec->card, new_name, codec->pcm_devs++, playback, 1100 capture, &pcm); 1101 if (ret < 0) { 1102 printk(KERN_ERR "asoc: can't create pcm for codec %s\n", 1103 codec->name); 1104 kfree(rtd); 1105 return ret; 1106 } 1107 1108 dai_link->pcm = pcm; 1109 pcm->private_data = rtd; 1110 soc_pcm_ops.mmap = platform->pcm_ops->mmap; 1111 soc_pcm_ops.pointer = platform->pcm_ops->pointer; 1112 soc_pcm_ops.ioctl = platform->pcm_ops->ioctl; 1113 soc_pcm_ops.copy = platform->pcm_ops->copy; 1114 soc_pcm_ops.silence = platform->pcm_ops->silence; 1115 soc_pcm_ops.ack = platform->pcm_ops->ack; 1116 soc_pcm_ops.page = platform->pcm_ops->page; 1117 1118 if (playback) 1119 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &soc_pcm_ops); 1120 1121 if (capture) 1122 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &soc_pcm_ops); 1123 1124 ret = platform->pcm_new(codec->card, codec_dai, pcm); 1125 if (ret < 0) { 1126 printk(KERN_ERR "asoc: platform pcm constructor failed\n"); 1127 kfree(rtd); 1128 return ret; 1129 } 1130 1131 pcm->private_free = platform->pcm_free; 1132 printk(KERN_INFO "asoc: %s <-> %s mapping ok\n", codec_dai->name, 1133 cpu_dai->name); 1134 return ret; 1135 } 1136 1137 /** 1138 * snd_soc_codec_volatile_register: Report if a register is volatile. 1139 * 1140 * @codec: CODEC to query. 1141 * @reg: Register to query. 1142 * 1143 * Boolean function indiciating if a CODEC register is volatile. 1144 */ 1145 int snd_soc_codec_volatile_register(struct snd_soc_codec *codec, int reg) 1146 { 1147 if (codec->volatile_register) 1148 return codec->volatile_register(reg); 1149 else 1150 return 0; 1151 } 1152 EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register); 1153 1154 /* codec register dump */ 1155 static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf) 1156 { 1157 int i, step = 1, count = 0; 1158 1159 if (!codec->reg_cache_size) 1160 return 0; 1161 1162 if (codec->reg_cache_step) 1163 step = codec->reg_cache_step; 1164 1165 count += sprintf(buf, "%s registers\n", codec->name); 1166 for (i = 0; i < codec->reg_cache_size; i += step) { 1167 if (codec->readable_register && !codec->readable_register(i)) 1168 continue; 1169 1170 count += sprintf(buf + count, "%2x: ", i); 1171 if (count >= PAGE_SIZE - 1) 1172 break; 1173 1174 if (codec->display_register) 1175 count += codec->display_register(codec, buf + count, 1176 PAGE_SIZE - count, i); 1177 else 1178 count += snprintf(buf + count, PAGE_SIZE - count, 1179 "%4x", codec->read(codec, i)); 1180 1181 if (count >= PAGE_SIZE - 1) 1182 break; 1183 1184 count += snprintf(buf + count, PAGE_SIZE - count, "\n"); 1185 if (count >= PAGE_SIZE - 1) 1186 break; 1187 } 1188 1189 /* Truncate count; min() would cause a warning */ 1190 if (count >= PAGE_SIZE) 1191 count = PAGE_SIZE - 1; 1192 1193 return count; 1194 } 1195 static ssize_t codec_reg_show(struct device *dev, 1196 struct device_attribute *attr, char *buf) 1197 { 1198 struct snd_soc_device *devdata = dev_get_drvdata(dev); 1199 return soc_codec_reg_show(devdata->card->codec, buf); 1200 } 1201 1202 static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL); 1203 1204 #ifdef CONFIG_DEBUG_FS 1205 static int codec_reg_open_file(struct inode *inode, struct file *file) 1206 { 1207 file->private_data = inode->i_private; 1208 return 0; 1209 } 1210 1211 static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf, 1212 size_t count, loff_t *ppos) 1213 { 1214 ssize_t ret; 1215 struct snd_soc_codec *codec = file->private_data; 1216 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL); 1217 if (!buf) 1218 return -ENOMEM; 1219 ret = soc_codec_reg_show(codec, buf); 1220 if (ret >= 0) 1221 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret); 1222 kfree(buf); 1223 return ret; 1224 } 1225 1226 static ssize_t codec_reg_write_file(struct file *file, 1227 const char __user *user_buf, size_t count, loff_t *ppos) 1228 { 1229 char buf[32]; 1230 int buf_size; 1231 char *start = buf; 1232 unsigned long reg, value; 1233 int step = 1; 1234 struct snd_soc_codec *codec = file->private_data; 1235 1236 buf_size = min(count, (sizeof(buf)-1)); 1237 if (copy_from_user(buf, user_buf, buf_size)) 1238 return -EFAULT; 1239 buf[buf_size] = 0; 1240 1241 if (codec->reg_cache_step) 1242 step = codec->reg_cache_step; 1243 1244 while (*start == ' ') 1245 start++; 1246 reg = simple_strtoul(start, &start, 16); 1247 if ((reg >= codec->reg_cache_size) || (reg % step)) 1248 return -EINVAL; 1249 while (*start == ' ') 1250 start++; 1251 if (strict_strtoul(start, 16, &value)) 1252 return -EINVAL; 1253 codec->write(codec, reg, value); 1254 return buf_size; 1255 } 1256 1257 static const struct file_operations codec_reg_fops = { 1258 .open = codec_reg_open_file, 1259 .read = codec_reg_read_file, 1260 .write = codec_reg_write_file, 1261 }; 1262 1263 static void soc_init_codec_debugfs(struct snd_soc_codec *codec) 1264 { 1265 codec->debugfs_reg = debugfs_create_file("codec_reg", 0644, 1266 debugfs_root, codec, 1267 &codec_reg_fops); 1268 if (!codec->debugfs_reg) 1269 printk(KERN_WARNING 1270 "ASoC: Failed to create codec register debugfs file\n"); 1271 1272 codec->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0744, 1273 debugfs_root, 1274 &codec->pop_time); 1275 if (!codec->debugfs_pop_time) 1276 printk(KERN_WARNING 1277 "Failed to create pop time debugfs file\n"); 1278 1279 codec->debugfs_dapm = debugfs_create_dir("dapm", debugfs_root); 1280 if (!codec->debugfs_dapm) 1281 printk(KERN_WARNING 1282 "Failed to create DAPM debugfs directory\n"); 1283 1284 snd_soc_dapm_debugfs_init(codec); 1285 } 1286 1287 static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec) 1288 { 1289 debugfs_remove_recursive(codec->debugfs_dapm); 1290 debugfs_remove(codec->debugfs_pop_time); 1291 debugfs_remove(codec->debugfs_reg); 1292 } 1293 1294 #else 1295 1296 static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec) 1297 { 1298 } 1299 1300 static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec) 1301 { 1302 } 1303 #endif 1304 1305 /** 1306 * snd_soc_new_ac97_codec - initailise AC97 device 1307 * @codec: audio codec 1308 * @ops: AC97 bus operations 1309 * @num: AC97 codec number 1310 * 1311 * Initialises AC97 codec resources for use by ad-hoc devices only. 1312 */ 1313 int snd_soc_new_ac97_codec(struct snd_soc_codec *codec, 1314 struct snd_ac97_bus_ops *ops, int num) 1315 { 1316 mutex_lock(&codec->mutex); 1317 1318 codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL); 1319 if (codec->ac97 == NULL) { 1320 mutex_unlock(&codec->mutex); 1321 return -ENOMEM; 1322 } 1323 1324 codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL); 1325 if (codec->ac97->bus == NULL) { 1326 kfree(codec->ac97); 1327 codec->ac97 = NULL; 1328 mutex_unlock(&codec->mutex); 1329 return -ENOMEM; 1330 } 1331 1332 codec->ac97->bus->ops = ops; 1333 codec->ac97->num = num; 1334 mutex_unlock(&codec->mutex); 1335 return 0; 1336 } 1337 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec); 1338 1339 /** 1340 * snd_soc_free_ac97_codec - free AC97 codec device 1341 * @codec: audio codec 1342 * 1343 * Frees AC97 codec device resources. 1344 */ 1345 void snd_soc_free_ac97_codec(struct snd_soc_codec *codec) 1346 { 1347 mutex_lock(&codec->mutex); 1348 kfree(codec->ac97->bus); 1349 kfree(codec->ac97); 1350 codec->ac97 = NULL; 1351 mutex_unlock(&codec->mutex); 1352 } 1353 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec); 1354 1355 /** 1356 * snd_soc_update_bits - update codec register bits 1357 * @codec: audio codec 1358 * @reg: codec register 1359 * @mask: register mask 1360 * @value: new value 1361 * 1362 * Writes new register value. 1363 * 1364 * Returns 1 for change else 0. 1365 */ 1366 int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg, 1367 unsigned int mask, unsigned int value) 1368 { 1369 int change; 1370 unsigned int old, new; 1371 1372 mutex_lock(&io_mutex); 1373 old = snd_soc_read(codec, reg); 1374 new = (old & ~mask) | value; 1375 change = old != new; 1376 if (change) 1377 snd_soc_write(codec, reg, new); 1378 1379 mutex_unlock(&io_mutex); 1380 return change; 1381 } 1382 EXPORT_SYMBOL_GPL(snd_soc_update_bits); 1383 1384 /** 1385 * snd_soc_test_bits - test register for change 1386 * @codec: audio codec 1387 * @reg: codec register 1388 * @mask: register mask 1389 * @value: new value 1390 * 1391 * Tests a register with a new value and checks if the new value is 1392 * different from the old value. 1393 * 1394 * Returns 1 for change else 0. 1395 */ 1396 int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg, 1397 unsigned int mask, unsigned int value) 1398 { 1399 int change; 1400 unsigned int old, new; 1401 1402 mutex_lock(&io_mutex); 1403 old = snd_soc_read(codec, reg); 1404 new = (old & ~mask) | value; 1405 change = old != new; 1406 mutex_unlock(&io_mutex); 1407 1408 return change; 1409 } 1410 EXPORT_SYMBOL_GPL(snd_soc_test_bits); 1411 1412 /** 1413 * snd_soc_new_pcms - create new sound card and pcms 1414 * @socdev: the SoC audio device 1415 * @idx: ALSA card index 1416 * @xid: card identification 1417 * 1418 * Create a new sound card based upon the codec and interface pcms. 1419 * 1420 * Returns 0 for success, else error. 1421 */ 1422 int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid) 1423 { 1424 struct snd_soc_card *card = socdev->card; 1425 struct snd_soc_codec *codec = card->codec; 1426 int ret, i; 1427 1428 mutex_lock(&codec->mutex); 1429 1430 /* register a sound card */ 1431 ret = snd_card_create(idx, xid, codec->owner, 0, &codec->card); 1432 if (ret < 0) { 1433 printk(KERN_ERR "asoc: can't create sound card for codec %s\n", 1434 codec->name); 1435 mutex_unlock(&codec->mutex); 1436 return ret; 1437 } 1438 1439 codec->socdev = socdev; 1440 codec->card->dev = socdev->dev; 1441 codec->card->private_data = codec; 1442 strncpy(codec->card->driver, codec->name, sizeof(codec->card->driver)); 1443 1444 /* create the pcms */ 1445 for (i = 0; i < card->num_links; i++) { 1446 ret = soc_new_pcm(socdev, &card->dai_link[i], i); 1447 if (ret < 0) { 1448 printk(KERN_ERR "asoc: can't create pcm %s\n", 1449 card->dai_link[i].stream_name); 1450 mutex_unlock(&codec->mutex); 1451 return ret; 1452 } 1453 } 1454 1455 mutex_unlock(&codec->mutex); 1456 return ret; 1457 } 1458 EXPORT_SYMBOL_GPL(snd_soc_new_pcms); 1459 1460 /** 1461 * snd_soc_init_card - register sound card 1462 * @socdev: the SoC audio device 1463 * 1464 * Register a SoC sound card. Also registers an AC97 device if the 1465 * codec is AC97 for ad hoc devices. 1466 * 1467 * Returns 0 for success, else error. 1468 */ 1469 int snd_soc_init_card(struct snd_soc_device *socdev) 1470 { 1471 struct snd_soc_card *card = socdev->card; 1472 struct snd_soc_codec *codec = card->codec; 1473 int ret = 0, i, ac97 = 0, err = 0; 1474 1475 for (i = 0; i < card->num_links; i++) { 1476 if (card->dai_link[i].init) { 1477 err = card->dai_link[i].init(codec); 1478 if (err < 0) { 1479 printk(KERN_ERR "asoc: failed to init %s\n", 1480 card->dai_link[i].stream_name); 1481 continue; 1482 } 1483 } 1484 if (card->dai_link[i].codec_dai->ac97_control) { 1485 ac97 = 1; 1486 snd_ac97_dev_add_pdata(codec->ac97, 1487 card->dai_link[i].cpu_dai->ac97_pdata); 1488 } 1489 } 1490 snprintf(codec->card->shortname, sizeof(codec->card->shortname), 1491 "%s", card->name); 1492 snprintf(codec->card->longname, sizeof(codec->card->longname), 1493 "%s (%s)", card->name, codec->name); 1494 1495 /* Make sure all DAPM widgets are instantiated */ 1496 snd_soc_dapm_new_widgets(codec); 1497 1498 ret = snd_card_register(codec->card); 1499 if (ret < 0) { 1500 printk(KERN_ERR "asoc: failed to register soundcard for %s\n", 1501 codec->name); 1502 goto out; 1503 } 1504 1505 mutex_lock(&codec->mutex); 1506 #ifdef CONFIG_SND_SOC_AC97_BUS 1507 /* Only instantiate AC97 if not already done by the adaptor 1508 * for the generic AC97 subsystem. 1509 */ 1510 if (ac97 && strcmp(codec->name, "AC97") != 0) { 1511 ret = soc_ac97_dev_register(codec); 1512 if (ret < 0) { 1513 printk(KERN_ERR "asoc: AC97 device register failed\n"); 1514 snd_card_free(codec->card); 1515 mutex_unlock(&codec->mutex); 1516 goto out; 1517 } 1518 } 1519 #endif 1520 1521 err = snd_soc_dapm_sys_add(socdev->dev); 1522 if (err < 0) 1523 printk(KERN_WARNING "asoc: failed to add dapm sysfs entries\n"); 1524 1525 err = device_create_file(socdev->dev, &dev_attr_codec_reg); 1526 if (err < 0) 1527 printk(KERN_WARNING "asoc: failed to add codec sysfs files\n"); 1528 1529 soc_init_codec_debugfs(codec); 1530 mutex_unlock(&codec->mutex); 1531 1532 out: 1533 return ret; 1534 } 1535 EXPORT_SYMBOL_GPL(snd_soc_init_card); 1536 1537 /** 1538 * snd_soc_free_pcms - free sound card and pcms 1539 * @socdev: the SoC audio device 1540 * 1541 * Frees sound card and pcms associated with the socdev. 1542 * Also unregister the codec if it is an AC97 device. 1543 */ 1544 void snd_soc_free_pcms(struct snd_soc_device *socdev) 1545 { 1546 struct snd_soc_codec *codec = socdev->card->codec; 1547 #ifdef CONFIG_SND_SOC_AC97_BUS 1548 struct snd_soc_dai *codec_dai; 1549 int i; 1550 #endif 1551 1552 mutex_lock(&codec->mutex); 1553 soc_cleanup_codec_debugfs(codec); 1554 #ifdef CONFIG_SND_SOC_AC97_BUS 1555 for (i = 0; i < codec->num_dai; i++) { 1556 codec_dai = &codec->dai[i]; 1557 if (codec_dai->ac97_control && codec->ac97 && 1558 strcmp(codec->name, "AC97") != 0) { 1559 soc_ac97_dev_unregister(codec); 1560 goto free_card; 1561 } 1562 } 1563 free_card: 1564 #endif 1565 1566 if (codec->card) 1567 snd_card_free(codec->card); 1568 device_remove_file(socdev->dev, &dev_attr_codec_reg); 1569 mutex_unlock(&codec->mutex); 1570 } 1571 EXPORT_SYMBOL_GPL(snd_soc_free_pcms); 1572 1573 /** 1574 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters 1575 * @substream: the pcm substream 1576 * @hw: the hardware parameters 1577 * 1578 * Sets the substream runtime hardware parameters. 1579 */ 1580 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream, 1581 const struct snd_pcm_hardware *hw) 1582 { 1583 struct snd_pcm_runtime *runtime = substream->runtime; 1584 runtime->hw.info = hw->info; 1585 runtime->hw.formats = hw->formats; 1586 runtime->hw.period_bytes_min = hw->period_bytes_min; 1587 runtime->hw.period_bytes_max = hw->period_bytes_max; 1588 runtime->hw.periods_min = hw->periods_min; 1589 runtime->hw.periods_max = hw->periods_max; 1590 runtime->hw.buffer_bytes_max = hw->buffer_bytes_max; 1591 runtime->hw.fifo_size = hw->fifo_size; 1592 return 0; 1593 } 1594 EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams); 1595 1596 /** 1597 * snd_soc_cnew - create new control 1598 * @_template: control template 1599 * @data: control private data 1600 * @long_name: control long name 1601 * 1602 * Create a new mixer control from a template control. 1603 * 1604 * Returns 0 for success, else error. 1605 */ 1606 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template, 1607 void *data, char *long_name) 1608 { 1609 struct snd_kcontrol_new template; 1610 1611 memcpy(&template, _template, sizeof(template)); 1612 if (long_name) 1613 template.name = long_name; 1614 template.index = 0; 1615 1616 return snd_ctl_new1(&template, data); 1617 } 1618 EXPORT_SYMBOL_GPL(snd_soc_cnew); 1619 1620 /** 1621 * snd_soc_add_controls - add an array of controls to a codec. 1622 * Convienience function to add a list of controls. Many codecs were 1623 * duplicating this code. 1624 * 1625 * @codec: codec to add controls to 1626 * @controls: array of controls to add 1627 * @num_controls: number of elements in the array 1628 * 1629 * Return 0 for success, else error. 1630 */ 1631 int snd_soc_add_controls(struct snd_soc_codec *codec, 1632 const struct snd_kcontrol_new *controls, int num_controls) 1633 { 1634 struct snd_card *card = codec->card; 1635 int err, i; 1636 1637 for (i = 0; i < num_controls; i++) { 1638 const struct snd_kcontrol_new *control = &controls[i]; 1639 err = snd_ctl_add(card, snd_soc_cnew(control, codec, NULL)); 1640 if (err < 0) { 1641 dev_err(codec->dev, "%s: Failed to add %s\n", 1642 codec->name, control->name); 1643 return err; 1644 } 1645 } 1646 1647 return 0; 1648 } 1649 EXPORT_SYMBOL_GPL(snd_soc_add_controls); 1650 1651 /** 1652 * snd_soc_info_enum_double - enumerated double mixer info callback 1653 * @kcontrol: mixer control 1654 * @uinfo: control element information 1655 * 1656 * Callback to provide information about a double enumerated 1657 * mixer control. 1658 * 1659 * Returns 0 for success. 1660 */ 1661 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol, 1662 struct snd_ctl_elem_info *uinfo) 1663 { 1664 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 1665 1666 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1667 uinfo->count = e->shift_l == e->shift_r ? 1 : 2; 1668 uinfo->value.enumerated.items = e->max; 1669 1670 if (uinfo->value.enumerated.item > e->max - 1) 1671 uinfo->value.enumerated.item = e->max - 1; 1672 strcpy(uinfo->value.enumerated.name, 1673 e->texts[uinfo->value.enumerated.item]); 1674 return 0; 1675 } 1676 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double); 1677 1678 /** 1679 * snd_soc_get_enum_double - enumerated double mixer get callback 1680 * @kcontrol: mixer control 1681 * @ucontrol: control element information 1682 * 1683 * Callback to get the value of a double enumerated mixer. 1684 * 1685 * Returns 0 for success. 1686 */ 1687 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol, 1688 struct snd_ctl_elem_value *ucontrol) 1689 { 1690 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 1691 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 1692 unsigned int val, bitmask; 1693 1694 for (bitmask = 1; bitmask < e->max; bitmask <<= 1) 1695 ; 1696 val = snd_soc_read(codec, e->reg); 1697 ucontrol->value.enumerated.item[0] 1698 = (val >> e->shift_l) & (bitmask - 1); 1699 if (e->shift_l != e->shift_r) 1700 ucontrol->value.enumerated.item[1] = 1701 (val >> e->shift_r) & (bitmask - 1); 1702 1703 return 0; 1704 } 1705 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double); 1706 1707 /** 1708 * snd_soc_put_enum_double - enumerated double mixer put callback 1709 * @kcontrol: mixer control 1710 * @ucontrol: control element information 1711 * 1712 * Callback to set the value of a double enumerated mixer. 1713 * 1714 * Returns 0 for success. 1715 */ 1716 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol, 1717 struct snd_ctl_elem_value *ucontrol) 1718 { 1719 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 1720 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 1721 unsigned int val; 1722 unsigned int mask, bitmask; 1723 1724 for (bitmask = 1; bitmask < e->max; bitmask <<= 1) 1725 ; 1726 if (ucontrol->value.enumerated.item[0] > e->max - 1) 1727 return -EINVAL; 1728 val = ucontrol->value.enumerated.item[0] << e->shift_l; 1729 mask = (bitmask - 1) << e->shift_l; 1730 if (e->shift_l != e->shift_r) { 1731 if (ucontrol->value.enumerated.item[1] > e->max - 1) 1732 return -EINVAL; 1733 val |= ucontrol->value.enumerated.item[1] << e->shift_r; 1734 mask |= (bitmask - 1) << e->shift_r; 1735 } 1736 1737 return snd_soc_update_bits(codec, e->reg, mask, val); 1738 } 1739 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double); 1740 1741 /** 1742 * snd_soc_get_value_enum_double - semi enumerated double mixer get callback 1743 * @kcontrol: mixer control 1744 * @ucontrol: control element information 1745 * 1746 * Callback to get the value of a double semi enumerated mixer. 1747 * 1748 * Semi enumerated mixer: the enumerated items are referred as values. Can be 1749 * used for handling bitfield coded enumeration for example. 1750 * 1751 * Returns 0 for success. 1752 */ 1753 int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol, 1754 struct snd_ctl_elem_value *ucontrol) 1755 { 1756 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 1757 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 1758 unsigned int reg_val, val, mux; 1759 1760 reg_val = snd_soc_read(codec, e->reg); 1761 val = (reg_val >> e->shift_l) & e->mask; 1762 for (mux = 0; mux < e->max; mux++) { 1763 if (val == e->values[mux]) 1764 break; 1765 } 1766 ucontrol->value.enumerated.item[0] = mux; 1767 if (e->shift_l != e->shift_r) { 1768 val = (reg_val >> e->shift_r) & e->mask; 1769 for (mux = 0; mux < e->max; mux++) { 1770 if (val == e->values[mux]) 1771 break; 1772 } 1773 ucontrol->value.enumerated.item[1] = mux; 1774 } 1775 1776 return 0; 1777 } 1778 EXPORT_SYMBOL_GPL(snd_soc_get_value_enum_double); 1779 1780 /** 1781 * snd_soc_put_value_enum_double - semi enumerated double mixer put callback 1782 * @kcontrol: mixer control 1783 * @ucontrol: control element information 1784 * 1785 * Callback to set the value of a double semi enumerated mixer. 1786 * 1787 * Semi enumerated mixer: the enumerated items are referred as values. Can be 1788 * used for handling bitfield coded enumeration for example. 1789 * 1790 * Returns 0 for success. 1791 */ 1792 int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol, 1793 struct snd_ctl_elem_value *ucontrol) 1794 { 1795 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 1796 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 1797 unsigned int val; 1798 unsigned int mask; 1799 1800 if (ucontrol->value.enumerated.item[0] > e->max - 1) 1801 return -EINVAL; 1802 val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l; 1803 mask = e->mask << e->shift_l; 1804 if (e->shift_l != e->shift_r) { 1805 if (ucontrol->value.enumerated.item[1] > e->max - 1) 1806 return -EINVAL; 1807 val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r; 1808 mask |= e->mask << e->shift_r; 1809 } 1810 1811 return snd_soc_update_bits(codec, e->reg, mask, val); 1812 } 1813 EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double); 1814 1815 /** 1816 * snd_soc_info_enum_ext - external enumerated single mixer info callback 1817 * @kcontrol: mixer control 1818 * @uinfo: control element information 1819 * 1820 * Callback to provide information about an external enumerated 1821 * single mixer. 1822 * 1823 * Returns 0 for success. 1824 */ 1825 int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol, 1826 struct snd_ctl_elem_info *uinfo) 1827 { 1828 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value; 1829 1830 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1831 uinfo->count = 1; 1832 uinfo->value.enumerated.items = e->max; 1833 1834 if (uinfo->value.enumerated.item > e->max - 1) 1835 uinfo->value.enumerated.item = e->max - 1; 1836 strcpy(uinfo->value.enumerated.name, 1837 e->texts[uinfo->value.enumerated.item]); 1838 return 0; 1839 } 1840 EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext); 1841 1842 /** 1843 * snd_soc_info_volsw_ext - external single mixer info callback 1844 * @kcontrol: mixer control 1845 * @uinfo: control element information 1846 * 1847 * Callback to provide information about a single external mixer control. 1848 * 1849 * Returns 0 for success. 1850 */ 1851 int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol, 1852 struct snd_ctl_elem_info *uinfo) 1853 { 1854 int max = kcontrol->private_value; 1855 1856 if (max == 1 && !strstr(kcontrol->id.name, " Volume")) 1857 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 1858 else 1859 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1860 1861 uinfo->count = 1; 1862 uinfo->value.integer.min = 0; 1863 uinfo->value.integer.max = max; 1864 return 0; 1865 } 1866 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext); 1867 1868 /** 1869 * snd_soc_info_volsw - single mixer info callback 1870 * @kcontrol: mixer control 1871 * @uinfo: control element information 1872 * 1873 * Callback to provide information about a single mixer control. 1874 * 1875 * Returns 0 for success. 1876 */ 1877 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol, 1878 struct snd_ctl_elem_info *uinfo) 1879 { 1880 struct soc_mixer_control *mc = 1881 (struct soc_mixer_control *)kcontrol->private_value; 1882 int max = mc->max; 1883 unsigned int shift = mc->shift; 1884 unsigned int rshift = mc->rshift; 1885 1886 if (max == 1 && !strstr(kcontrol->id.name, " Volume")) 1887 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 1888 else 1889 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1890 1891 uinfo->count = shift == rshift ? 1 : 2; 1892 uinfo->value.integer.min = 0; 1893 uinfo->value.integer.max = max; 1894 return 0; 1895 } 1896 EXPORT_SYMBOL_GPL(snd_soc_info_volsw); 1897 1898 /** 1899 * snd_soc_get_volsw - single mixer get callback 1900 * @kcontrol: mixer control 1901 * @ucontrol: control element information 1902 * 1903 * Callback to get the value of a single mixer control. 1904 * 1905 * Returns 0 for success. 1906 */ 1907 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol, 1908 struct snd_ctl_elem_value *ucontrol) 1909 { 1910 struct soc_mixer_control *mc = 1911 (struct soc_mixer_control *)kcontrol->private_value; 1912 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 1913 unsigned int reg = mc->reg; 1914 unsigned int shift = mc->shift; 1915 unsigned int rshift = mc->rshift; 1916 int max = mc->max; 1917 unsigned int mask = (1 << fls(max)) - 1; 1918 unsigned int invert = mc->invert; 1919 1920 ucontrol->value.integer.value[0] = 1921 (snd_soc_read(codec, reg) >> shift) & mask; 1922 if (shift != rshift) 1923 ucontrol->value.integer.value[1] = 1924 (snd_soc_read(codec, reg) >> rshift) & mask; 1925 if (invert) { 1926 ucontrol->value.integer.value[0] = 1927 max - ucontrol->value.integer.value[0]; 1928 if (shift != rshift) 1929 ucontrol->value.integer.value[1] = 1930 max - ucontrol->value.integer.value[1]; 1931 } 1932 1933 return 0; 1934 } 1935 EXPORT_SYMBOL_GPL(snd_soc_get_volsw); 1936 1937 /** 1938 * snd_soc_put_volsw - single mixer put callback 1939 * @kcontrol: mixer control 1940 * @ucontrol: control element information 1941 * 1942 * Callback to set the value of a single mixer control. 1943 * 1944 * Returns 0 for success. 1945 */ 1946 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol, 1947 struct snd_ctl_elem_value *ucontrol) 1948 { 1949 struct soc_mixer_control *mc = 1950 (struct soc_mixer_control *)kcontrol->private_value; 1951 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 1952 unsigned int reg = mc->reg; 1953 unsigned int shift = mc->shift; 1954 unsigned int rshift = mc->rshift; 1955 int max = mc->max; 1956 unsigned int mask = (1 << fls(max)) - 1; 1957 unsigned int invert = mc->invert; 1958 unsigned int val, val2, val_mask; 1959 1960 val = (ucontrol->value.integer.value[0] & mask); 1961 if (invert) 1962 val = max - val; 1963 val_mask = mask << shift; 1964 val = val << shift; 1965 if (shift != rshift) { 1966 val2 = (ucontrol->value.integer.value[1] & mask); 1967 if (invert) 1968 val2 = max - val2; 1969 val_mask |= mask << rshift; 1970 val |= val2 << rshift; 1971 } 1972 return snd_soc_update_bits(codec, reg, val_mask, val); 1973 } 1974 EXPORT_SYMBOL_GPL(snd_soc_put_volsw); 1975 1976 /** 1977 * snd_soc_info_volsw_2r - double mixer info callback 1978 * @kcontrol: mixer control 1979 * @uinfo: control element information 1980 * 1981 * Callback to provide information about a double mixer control that 1982 * spans 2 codec registers. 1983 * 1984 * Returns 0 for success. 1985 */ 1986 int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol, 1987 struct snd_ctl_elem_info *uinfo) 1988 { 1989 struct soc_mixer_control *mc = 1990 (struct soc_mixer_control *)kcontrol->private_value; 1991 int max = mc->max; 1992 1993 if (max == 1 && !strstr(kcontrol->id.name, " Volume")) 1994 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 1995 else 1996 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 1997 1998 uinfo->count = 2; 1999 uinfo->value.integer.min = 0; 2000 uinfo->value.integer.max = max; 2001 return 0; 2002 } 2003 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r); 2004 2005 /** 2006 * snd_soc_get_volsw_2r - double mixer get callback 2007 * @kcontrol: mixer control 2008 * @ucontrol: control element information 2009 * 2010 * Callback to get the value of a double mixer control that spans 2 registers. 2011 * 2012 * Returns 0 for success. 2013 */ 2014 int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol, 2015 struct snd_ctl_elem_value *ucontrol) 2016 { 2017 struct soc_mixer_control *mc = 2018 (struct soc_mixer_control *)kcontrol->private_value; 2019 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 2020 unsigned int reg = mc->reg; 2021 unsigned int reg2 = mc->rreg; 2022 unsigned int shift = mc->shift; 2023 int max = mc->max; 2024 unsigned int mask = (1 << fls(max)) - 1; 2025 unsigned int invert = mc->invert; 2026 2027 ucontrol->value.integer.value[0] = 2028 (snd_soc_read(codec, reg) >> shift) & mask; 2029 ucontrol->value.integer.value[1] = 2030 (snd_soc_read(codec, reg2) >> shift) & mask; 2031 if (invert) { 2032 ucontrol->value.integer.value[0] = 2033 max - ucontrol->value.integer.value[0]; 2034 ucontrol->value.integer.value[1] = 2035 max - ucontrol->value.integer.value[1]; 2036 } 2037 2038 return 0; 2039 } 2040 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r); 2041 2042 /** 2043 * snd_soc_put_volsw_2r - double mixer set callback 2044 * @kcontrol: mixer control 2045 * @ucontrol: control element information 2046 * 2047 * Callback to set the value of a double mixer control that spans 2 registers. 2048 * 2049 * Returns 0 for success. 2050 */ 2051 int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol, 2052 struct snd_ctl_elem_value *ucontrol) 2053 { 2054 struct soc_mixer_control *mc = 2055 (struct soc_mixer_control *)kcontrol->private_value; 2056 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 2057 unsigned int reg = mc->reg; 2058 unsigned int reg2 = mc->rreg; 2059 unsigned int shift = mc->shift; 2060 int max = mc->max; 2061 unsigned int mask = (1 << fls(max)) - 1; 2062 unsigned int invert = mc->invert; 2063 int err; 2064 unsigned int val, val2, val_mask; 2065 2066 val_mask = mask << shift; 2067 val = (ucontrol->value.integer.value[0] & mask); 2068 val2 = (ucontrol->value.integer.value[1] & mask); 2069 2070 if (invert) { 2071 val = max - val; 2072 val2 = max - val2; 2073 } 2074 2075 val = val << shift; 2076 val2 = val2 << shift; 2077 2078 err = snd_soc_update_bits(codec, reg, val_mask, val); 2079 if (err < 0) 2080 return err; 2081 2082 err = snd_soc_update_bits(codec, reg2, val_mask, val2); 2083 return err; 2084 } 2085 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r); 2086 2087 /** 2088 * snd_soc_info_volsw_s8 - signed mixer info callback 2089 * @kcontrol: mixer control 2090 * @uinfo: control element information 2091 * 2092 * Callback to provide information about a signed mixer control. 2093 * 2094 * Returns 0 for success. 2095 */ 2096 int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol, 2097 struct snd_ctl_elem_info *uinfo) 2098 { 2099 struct soc_mixer_control *mc = 2100 (struct soc_mixer_control *)kcontrol->private_value; 2101 int max = mc->max; 2102 int min = mc->min; 2103 2104 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 2105 uinfo->count = 2; 2106 uinfo->value.integer.min = 0; 2107 uinfo->value.integer.max = max-min; 2108 return 0; 2109 } 2110 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8); 2111 2112 /** 2113 * snd_soc_get_volsw_s8 - signed mixer get callback 2114 * @kcontrol: mixer control 2115 * @ucontrol: control element information 2116 * 2117 * Callback to get the value of a signed mixer control. 2118 * 2119 * Returns 0 for success. 2120 */ 2121 int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol, 2122 struct snd_ctl_elem_value *ucontrol) 2123 { 2124 struct soc_mixer_control *mc = 2125 (struct soc_mixer_control *)kcontrol->private_value; 2126 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 2127 unsigned int reg = mc->reg; 2128 int min = mc->min; 2129 int val = snd_soc_read(codec, reg); 2130 2131 ucontrol->value.integer.value[0] = 2132 ((signed char)(val & 0xff))-min; 2133 ucontrol->value.integer.value[1] = 2134 ((signed char)((val >> 8) & 0xff))-min; 2135 return 0; 2136 } 2137 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8); 2138 2139 /** 2140 * snd_soc_put_volsw_sgn - signed mixer put callback 2141 * @kcontrol: mixer control 2142 * @ucontrol: control element information 2143 * 2144 * Callback to set the value of a signed mixer control. 2145 * 2146 * Returns 0 for success. 2147 */ 2148 int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol, 2149 struct snd_ctl_elem_value *ucontrol) 2150 { 2151 struct soc_mixer_control *mc = 2152 (struct soc_mixer_control *)kcontrol->private_value; 2153 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 2154 unsigned int reg = mc->reg; 2155 int min = mc->min; 2156 unsigned int val; 2157 2158 val = (ucontrol->value.integer.value[0]+min) & 0xff; 2159 val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8; 2160 2161 return snd_soc_update_bits(codec, reg, 0xffff, val); 2162 } 2163 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8); 2164 2165 /** 2166 * snd_soc_dai_set_sysclk - configure DAI system or master clock. 2167 * @dai: DAI 2168 * @clk_id: DAI specific clock ID 2169 * @freq: new clock frequency in Hz 2170 * @dir: new clock direction - input/output. 2171 * 2172 * Configures the DAI master (MCLK) or system (SYSCLK) clocking. 2173 */ 2174 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id, 2175 unsigned int freq, int dir) 2176 { 2177 if (dai->ops && dai->ops->set_sysclk) 2178 return dai->ops->set_sysclk(dai, clk_id, freq, dir); 2179 else 2180 return -EINVAL; 2181 } 2182 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk); 2183 2184 /** 2185 * snd_soc_dai_set_clkdiv - configure DAI clock dividers. 2186 * @dai: DAI 2187 * @div_id: DAI specific clock divider ID 2188 * @div: new clock divisor. 2189 * 2190 * Configures the clock dividers. This is used to derive the best DAI bit and 2191 * frame clocks from the system or master clock. It's best to set the DAI bit 2192 * and frame clocks as low as possible to save system power. 2193 */ 2194 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai, 2195 int div_id, int div) 2196 { 2197 if (dai->ops && dai->ops->set_clkdiv) 2198 return dai->ops->set_clkdiv(dai, div_id, div); 2199 else 2200 return -EINVAL; 2201 } 2202 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv); 2203 2204 /** 2205 * snd_soc_dai_set_pll - configure DAI PLL. 2206 * @dai: DAI 2207 * @pll_id: DAI specific PLL ID 2208 * @freq_in: PLL input clock frequency in Hz 2209 * @freq_out: requested PLL output clock frequency in Hz 2210 * 2211 * Configures and enables PLL to generate output clock based on input clock. 2212 */ 2213 int snd_soc_dai_set_pll(struct snd_soc_dai *dai, 2214 int pll_id, unsigned int freq_in, unsigned int freq_out) 2215 { 2216 if (dai->ops && dai->ops->set_pll) 2217 return dai->ops->set_pll(dai, pll_id, freq_in, freq_out); 2218 else 2219 return -EINVAL; 2220 } 2221 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll); 2222 2223 /** 2224 * snd_soc_dai_set_fmt - configure DAI hardware audio format. 2225 * @dai: DAI 2226 * @fmt: SND_SOC_DAIFMT_ format value. 2227 * 2228 * Configures the DAI hardware format and clocking. 2229 */ 2230 int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) 2231 { 2232 if (dai->ops && dai->ops->set_fmt) 2233 return dai->ops->set_fmt(dai, fmt); 2234 else 2235 return -EINVAL; 2236 } 2237 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt); 2238 2239 /** 2240 * snd_soc_dai_set_tdm_slot - configure DAI TDM. 2241 * @dai: DAI 2242 * @tx_mask: bitmask representing active TX slots. 2243 * @rx_mask: bitmask representing active RX slots. 2244 * @slots: Number of slots in use. 2245 * @slot_width: Width in bits for each slot. 2246 * 2247 * Configures a DAI for TDM operation. Both mask and slots are codec and DAI 2248 * specific. 2249 */ 2250 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai, 2251 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width) 2252 { 2253 if (dai->ops && dai->ops->set_tdm_slot) 2254 return dai->ops->set_tdm_slot(dai, tx_mask, rx_mask, 2255 slots, slot_width); 2256 else 2257 return -EINVAL; 2258 } 2259 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot); 2260 2261 /** 2262 * snd_soc_dai_set_tristate - configure DAI system or master clock. 2263 * @dai: DAI 2264 * @tristate: tristate enable 2265 * 2266 * Tristates the DAI so that others can use it. 2267 */ 2268 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate) 2269 { 2270 if (dai->ops && dai->ops->set_tristate) 2271 return dai->ops->set_tristate(dai, tristate); 2272 else 2273 return -EINVAL; 2274 } 2275 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate); 2276 2277 /** 2278 * snd_soc_dai_digital_mute - configure DAI system or master clock. 2279 * @dai: DAI 2280 * @mute: mute enable 2281 * 2282 * Mutes the DAI DAC. 2283 */ 2284 int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute) 2285 { 2286 if (dai->ops && dai->ops->digital_mute) 2287 return dai->ops->digital_mute(dai, mute); 2288 else 2289 return -EINVAL; 2290 } 2291 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute); 2292 2293 /** 2294 * snd_soc_register_card - Register a card with the ASoC core 2295 * 2296 * @card: Card to register 2297 * 2298 * Note that currently this is an internal only function: it will be 2299 * exposed to machine drivers after further backporting of ASoC v2 2300 * registration APIs. 2301 */ 2302 static int snd_soc_register_card(struct snd_soc_card *card) 2303 { 2304 if (!card->name || !card->dev) 2305 return -EINVAL; 2306 2307 INIT_LIST_HEAD(&card->list); 2308 card->instantiated = 0; 2309 2310 mutex_lock(&client_mutex); 2311 list_add(&card->list, &card_list); 2312 snd_soc_instantiate_cards(); 2313 mutex_unlock(&client_mutex); 2314 2315 dev_dbg(card->dev, "Registered card '%s'\n", card->name); 2316 2317 return 0; 2318 } 2319 2320 /** 2321 * snd_soc_unregister_card - Unregister a card with the ASoC core 2322 * 2323 * @card: Card to unregister 2324 * 2325 * Note that currently this is an internal only function: it will be 2326 * exposed to machine drivers after further backporting of ASoC v2 2327 * registration APIs. 2328 */ 2329 static int snd_soc_unregister_card(struct snd_soc_card *card) 2330 { 2331 mutex_lock(&client_mutex); 2332 list_del(&card->list); 2333 mutex_unlock(&client_mutex); 2334 2335 dev_dbg(card->dev, "Unregistered card '%s'\n", card->name); 2336 2337 return 0; 2338 } 2339 2340 /** 2341 * snd_soc_register_dai - Register a DAI with the ASoC core 2342 * 2343 * @dai: DAI to register 2344 */ 2345 int snd_soc_register_dai(struct snd_soc_dai *dai) 2346 { 2347 if (!dai->name) 2348 return -EINVAL; 2349 2350 /* The device should become mandatory over time */ 2351 if (!dai->dev) 2352 printk(KERN_WARNING "No device for DAI %s\n", dai->name); 2353 2354 if (!dai->ops) 2355 dai->ops = &null_dai_ops; 2356 2357 INIT_LIST_HEAD(&dai->list); 2358 2359 mutex_lock(&client_mutex); 2360 list_add(&dai->list, &dai_list); 2361 snd_soc_instantiate_cards(); 2362 mutex_unlock(&client_mutex); 2363 2364 pr_debug("Registered DAI '%s'\n", dai->name); 2365 2366 return 0; 2367 } 2368 EXPORT_SYMBOL_GPL(snd_soc_register_dai); 2369 2370 /** 2371 * snd_soc_unregister_dai - Unregister a DAI from the ASoC core 2372 * 2373 * @dai: DAI to unregister 2374 */ 2375 void snd_soc_unregister_dai(struct snd_soc_dai *dai) 2376 { 2377 mutex_lock(&client_mutex); 2378 list_del(&dai->list); 2379 mutex_unlock(&client_mutex); 2380 2381 pr_debug("Unregistered DAI '%s'\n", dai->name); 2382 } 2383 EXPORT_SYMBOL_GPL(snd_soc_unregister_dai); 2384 2385 /** 2386 * snd_soc_register_dais - Register multiple DAIs with the ASoC core 2387 * 2388 * @dai: Array of DAIs to register 2389 * @count: Number of DAIs 2390 */ 2391 int snd_soc_register_dais(struct snd_soc_dai *dai, size_t count) 2392 { 2393 int i, ret; 2394 2395 for (i = 0; i < count; i++) { 2396 ret = snd_soc_register_dai(&dai[i]); 2397 if (ret != 0) 2398 goto err; 2399 } 2400 2401 return 0; 2402 2403 err: 2404 for (i--; i >= 0; i--) 2405 snd_soc_unregister_dai(&dai[i]); 2406 2407 return ret; 2408 } 2409 EXPORT_SYMBOL_GPL(snd_soc_register_dais); 2410 2411 /** 2412 * snd_soc_unregister_dais - Unregister multiple DAIs from the ASoC core 2413 * 2414 * @dai: Array of DAIs to unregister 2415 * @count: Number of DAIs 2416 */ 2417 void snd_soc_unregister_dais(struct snd_soc_dai *dai, size_t count) 2418 { 2419 int i; 2420 2421 for (i = 0; i < count; i++) 2422 snd_soc_unregister_dai(&dai[i]); 2423 } 2424 EXPORT_SYMBOL_GPL(snd_soc_unregister_dais); 2425 2426 /** 2427 * snd_soc_register_platform - Register a platform with the ASoC core 2428 * 2429 * @platform: platform to register 2430 */ 2431 int snd_soc_register_platform(struct snd_soc_platform *platform) 2432 { 2433 if (!platform->name) 2434 return -EINVAL; 2435 2436 INIT_LIST_HEAD(&platform->list); 2437 2438 mutex_lock(&client_mutex); 2439 list_add(&platform->list, &platform_list); 2440 snd_soc_instantiate_cards(); 2441 mutex_unlock(&client_mutex); 2442 2443 pr_debug("Registered platform '%s'\n", platform->name); 2444 2445 return 0; 2446 } 2447 EXPORT_SYMBOL_GPL(snd_soc_register_platform); 2448 2449 /** 2450 * snd_soc_unregister_platform - Unregister a platform from the ASoC core 2451 * 2452 * @platform: platform to unregister 2453 */ 2454 void snd_soc_unregister_platform(struct snd_soc_platform *platform) 2455 { 2456 mutex_lock(&client_mutex); 2457 list_del(&platform->list); 2458 mutex_unlock(&client_mutex); 2459 2460 pr_debug("Unregistered platform '%s'\n", platform->name); 2461 } 2462 EXPORT_SYMBOL_GPL(snd_soc_unregister_platform); 2463 2464 static u64 codec_format_map[] = { 2465 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE, 2466 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE, 2467 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE, 2468 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE, 2469 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE, 2470 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE, 2471 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE, 2472 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE, 2473 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE, 2474 SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE, 2475 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE, 2476 SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE, 2477 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE, 2478 SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE, 2479 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE 2480 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE, 2481 }; 2482 2483 /* Fix up the DAI formats for endianness: codecs don't actually see 2484 * the endianness of the data but we're using the CPU format 2485 * definitions which do need to include endianness so we ensure that 2486 * codec DAIs always have both big and little endian variants set. 2487 */ 2488 static void fixup_codec_formats(struct snd_soc_pcm_stream *stream) 2489 { 2490 int i; 2491 2492 for (i = 0; i < ARRAY_SIZE(codec_format_map); i++) 2493 if (stream->formats & codec_format_map[i]) 2494 stream->formats |= codec_format_map[i]; 2495 } 2496 2497 /** 2498 * snd_soc_register_codec - Register a codec with the ASoC core 2499 * 2500 * @codec: codec to register 2501 */ 2502 int snd_soc_register_codec(struct snd_soc_codec *codec) 2503 { 2504 int i; 2505 2506 if (!codec->name) 2507 return -EINVAL; 2508 2509 /* The device should become mandatory over time */ 2510 if (!codec->dev) 2511 printk(KERN_WARNING "No device for codec %s\n", codec->name); 2512 2513 INIT_LIST_HEAD(&codec->list); 2514 2515 for (i = 0; i < codec->num_dai; i++) { 2516 fixup_codec_formats(&codec->dai[i].playback); 2517 fixup_codec_formats(&codec->dai[i].capture); 2518 } 2519 2520 mutex_lock(&client_mutex); 2521 list_add(&codec->list, &codec_list); 2522 snd_soc_instantiate_cards(); 2523 mutex_unlock(&client_mutex); 2524 2525 pr_debug("Registered codec '%s'\n", codec->name); 2526 2527 return 0; 2528 } 2529 EXPORT_SYMBOL_GPL(snd_soc_register_codec); 2530 2531 /** 2532 * snd_soc_unregister_codec - Unregister a codec from the ASoC core 2533 * 2534 * @codec: codec to unregister 2535 */ 2536 void snd_soc_unregister_codec(struct snd_soc_codec *codec) 2537 { 2538 mutex_lock(&client_mutex); 2539 list_del(&codec->list); 2540 mutex_unlock(&client_mutex); 2541 2542 pr_debug("Unregistered codec '%s'\n", codec->name); 2543 } 2544 EXPORT_SYMBOL_GPL(snd_soc_unregister_codec); 2545 2546 static int __init snd_soc_init(void) 2547 { 2548 #ifdef CONFIG_DEBUG_FS 2549 debugfs_root = debugfs_create_dir("asoc", NULL); 2550 if (IS_ERR(debugfs_root) || !debugfs_root) { 2551 printk(KERN_WARNING 2552 "ASoC: Failed to create debugfs directory\n"); 2553 debugfs_root = NULL; 2554 } 2555 #endif 2556 2557 return platform_driver_register(&soc_driver); 2558 } 2559 2560 static void __exit snd_soc_exit(void) 2561 { 2562 #ifdef CONFIG_DEBUG_FS 2563 debugfs_remove_recursive(debugfs_root); 2564 #endif 2565 platform_driver_unregister(&soc_driver); 2566 } 2567 2568 module_init(snd_soc_init); 2569 module_exit(snd_soc_exit); 2570 2571 /* Module information */ 2572 MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk"); 2573 MODULE_DESCRIPTION("ALSA SoC Core"); 2574 MODULE_LICENSE("GPL"); 2575 MODULE_ALIAS("platform:soc-audio"); 2576