sound/soc/soc-core.c

   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
   8  *         liam.girdwood@wolfsonmicro.com or linux@wolfsonmicro.com
   9  *         with code, comments and ideas from :-
  10  *         Richard Purdie <richard@openedhand.com>
  11  *
  12  *  This program is free software; you can redistribute  it and/or modify it
  13  *  under  the terms of  the GNU General  Public License as published by the
  14  *  Free Software Foundation;  either version 2 of the  License, or (at your
  15  *  option) any later version.
  16  *
  17  *  TODO:
  18  *   o Add hw rules to enforce rates, etc.
  19  *   o More testing with other codecs/machines.
  20  *   o Add more codecs and platforms to ensure good API coverage.
  21  *   o Support TDM on PCM and I2S
  22  */
  23
  24 #include <linux/module.h>
  25 #include <linux/moduleparam.h>
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/pm.h>
  29 #include <linux/bitops.h>
  30 #include <linux/platform_device.h>
  31 #include <sound/core.h>
  32 #include <sound/pcm.h>
  33 #include <sound/pcm_params.h>
  34 #include <sound/soc.h>
  35 #include <sound/soc-dapm.h>
  36 #include <sound/initval.h>
  37
  38 /* debug */
  39 #define SOC_DEBUG 0
  40 #if SOC_DEBUG
  41 #define dbg(format, arg...) printk(format, ## arg)
  42 #else
  43 #define dbg(format, arg...)
  44 #endif
  45
  46 static DEFINE_MUTEX(pcm_mutex);
  47 static DEFINE_MUTEX(io_mutex);
  48 static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
  49
  50 /*
  51  * This is a timeout to do a DAPM powerdown after a stream is closed().
  52  * It can be used to eliminate pops between different playback streams, e.g.
  53  * between two audio tracks.
  54  */
  55 static int pmdown_time = 5000;
  56 module_param(pmdown_time, int, 0);
  57 MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
  58
  59 /*
  60  * This function forces any delayed work to be queued and run.
  61  */
  62 static int run_delayed_work(struct delayed_work *dwork)
  63 {
  64         int ret;
  65
  66         /* cancel any work waiting to be queued. */
  67         ret = cancel_delayed_work(dwork);
  68
  69         /* if there was any work waiting then we run it now and
  70          * wait for it's completion */
  71         if (ret) {
  72                 schedule_delayed_work(dwork, 0);
  73                 flush_scheduled_work();
  74         }
  75         return ret;
  76 }
  77
  78 #ifdef CONFIG_SND_SOC_AC97_BUS
  79 /* unregister ac97 codec */
  80 static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
  81 {
  82         if (codec->ac97->dev.bus)
  83                 device_unregister(&codec->ac97->dev);
  84         return 0;
  85 }
  86
  87 /* stop no dev release warning */
  88 static void soc_ac97_device_release(struct device *dev){}
  89
  90 /* register ac97 codec to bus */
  91 static int soc_ac97_dev_register(struct snd_soc_codec *codec)
  92 {
  93         int err;
  94
  95         codec->ac97->dev.bus = &ac97_bus_type;
  96         codec->ac97->dev.parent = NULL;
  97         codec->ac97->dev.release = soc_ac97_device_release;
  98
  99         snprintf(codec->ac97->dev.bus_id, BUS_ID_SIZE, "%d-%d:%s",
 100                  codec->card->number, 0, codec->name);
 101         err = device_register(&codec->ac97->dev);
 102         if (err < 0) {
 103                 snd_printk(KERN_ERR "Can't register ac97 bus\n");
 104                 codec->ac97->dev.bus = NULL;
 105                 return err;
 106         }
 107         return 0;
 108 }
 109 #endif
 110
 111 static inline const char *get_dai_name(int type)
 112 {
 113         switch (type) {
 114         case SND_SOC_DAI_AC97_BUS:
 115         case SND_SOC_DAI_AC97:
 116                 return "AC97";
 117         case SND_SOC_DAI_I2S:
 118                 return "I2S";
 119         case SND_SOC_DAI_PCM:
 120                 return "PCM";
 121         }
 122         return NULL;
 123 }
 124
 125 /*
 126  * Called by ALSA when a PCM substream is opened, the runtime->hw record is
 127  * then initialized and any private data can be allocated. This also calls
 128  * startup for the cpu DAI, platform, machine and codec DAI.
 129  */
 130 static int soc_pcm_open(struct snd_pcm_substream *substream)
 131 {
 132         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 133         struct snd_soc_device *socdev = rtd->socdev;
 134         struct snd_pcm_runtime *runtime = substream->runtime;
 135         struct snd_soc_dai_link *machine = rtd->dai;
 136         struct snd_soc_platform *platform = socdev->platform;
 137         struct snd_soc_dai *cpu_dai = machine->cpu_dai;
 138         struct snd_soc_dai *codec_dai = machine->codec_dai;
 139         int ret = 0;
 140
 141         mutex_lock(&pcm_mutex);
 142
 143         /* startup the audio subsystem */
 144         if (cpu_dai->ops.startup) {
 145                 ret = cpu_dai->ops.startup(substream);
 146                 if (ret < 0) {
 147                         printk(KERN_ERR "asoc: can't open interface %s\n",
 148                                 cpu_dai->name);
 149                         goto out;
 150                 }
 151         }
 152
 153         if (platform->pcm_ops->open) {
 154                 ret = platform->pcm_ops->open(substream);
 155                 if (ret < 0) {
 156                         printk(KERN_ERR "asoc: can't open platform %s\n", platform->name);
 157                         goto platform_err;
 158                 }
 159         }
 160
 161         if (codec_dai->ops.startup) {
 162                 ret = codec_dai->ops.startup(substream);
 163                 if (ret < 0) {
 164                         printk(KERN_ERR "asoc: can't open codec %s\n",
 165                                 codec_dai->name);
 166                         goto codec_dai_err;
 167                 }
 168         }
 169
 170         if (machine->ops && machine->ops->startup) {
 171                 ret = machine->ops->startup(substream);
 172                 if (ret < 0) {
 173                         printk(KERN_ERR "asoc: %s startup failed\n", machine->name);
 174                         goto machine_err;
 175                 }
 176         }
 177
 178         /* Check that the codec and cpu DAI's are compatible */
 179         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 180                 runtime->hw.rate_min =
 181                         max(codec_dai->playback.rate_min,
 182                             cpu_dai->playback.rate_min);
 183                 runtime->hw.rate_max =
 184                         min(codec_dai->playback.rate_max,
 185                             cpu_dai->playback.rate_max);
 186                 runtime->hw.channels_min =
 187                         max(codec_dai->playback.channels_min,
 188                                 cpu_dai->playback.channels_min);
 189                 runtime->hw.channels_max =
 190                         min(codec_dai->playback.channels_max,
 191                                 cpu_dai->playback.channels_max);
 192                 runtime->hw.formats =
 193                         codec_dai->playback.formats & cpu_dai->playback.formats;
 194                 runtime->hw.rates =
 195                         codec_dai->playback.rates & cpu_dai->playback.rates;
 196         } else {
 197                 runtime->hw.rate_min =
 198                         max(codec_dai->capture.rate_min,
 199                             cpu_dai->capture.rate_min);
 200                 runtime->hw.rate_max =
 201                         min(codec_dai->capture.rate_max,
 202                             cpu_dai->capture.rate_max);
 203                 runtime->hw.channels_min =
 204                         max(codec_dai->capture.channels_min,
 205                                 cpu_dai->capture.channels_min);
 206                 runtime->hw.channels_max =
 207                         min(codec_dai->capture.channels_max,
 208                                 cpu_dai->capture.channels_max);
 209                 runtime->hw.formats =
 210                         codec_dai->capture.formats & cpu_dai->capture.formats;
 211                 runtime->hw.rates =
 212                         codec_dai->capture.rates & cpu_dai->capture.rates;
 213         }
 214
 215         snd_pcm_limit_hw_rates(runtime);
 216         if (!runtime->hw.rates) {
 217                 printk(KERN_ERR "asoc: %s <-> %s No matching rates\n",
 218                         codec_dai->name, cpu_dai->name);
 219                 goto machine_err;
 220         }
 221         if (!runtime->hw.formats) {
 222                 printk(KERN_ERR "asoc: %s <-> %s No matching formats\n",
 223                         codec_dai->name, cpu_dai->name);
 224                 goto machine_err;
 225         }
 226         if (!runtime->hw.channels_min || !runtime->hw.channels_max) {
 227                 printk(KERN_ERR "asoc: %s <-> %s No matching channels\n",
 228                         codec_dai->name, cpu_dai->name);
 229                 goto machine_err;
 230         }
 231
 232         dbg("asoc: %s <-> %s info:\n", codec_dai->name, cpu_dai->name);
 233         dbg("asoc: rate mask 0x%x\n", runtime->hw.rates);
 234         dbg("asoc: min ch %d max ch %d\n", runtime->hw.channels_min,
 235                 runtime->hw.channels_max);
 236         dbg("asoc: min rate %d max rate %d\n", runtime->hw.rate_min,
 237                 runtime->hw.rate_max);
 238
 239         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 240                 cpu_dai->playback.active = codec_dai->playback.active = 1;
 241         else
 242                 cpu_dai->capture.active = codec_dai->capture.active = 1;
 243         cpu_dai->active = codec_dai->active = 1;
 244         cpu_dai->runtime = runtime;
 245         socdev->codec->active++;
 246         mutex_unlock(&pcm_mutex);
 247         return 0;
 248
 249 machine_err:
 250         if (machine->ops && machine->ops->shutdown)
 251                 machine->ops->shutdown(substream);
 252
 253 codec_dai_err:
 254         if (platform->pcm_ops->close)
 255                 platform->pcm_ops->close(substream);
 256
 257 platform_err:
 258         if (cpu_dai->ops.shutdown)
 259                 cpu_dai->ops.shutdown(substream);
 260 out:
 261         mutex_unlock(&pcm_mutex);
 262         return ret;
 263 }
 264
 265 /*
 266  * Power down the audio subsystem pmdown_time msecs after close is called.
 267  * This is to ensure there are no pops or clicks in between any music tracks
 268  * due to DAPM power cycling.
 269  */
 270 static void close_delayed_work(struct work_struct *work)
 271 {
 272         struct snd_soc_device *socdev =
 273                 container_of(work, struct snd_soc_device, delayed_work.work);
 274         struct snd_soc_codec *codec = socdev->codec;
 275         struct snd_soc_dai *codec_dai;
 276         int i;
 277
 278         mutex_lock(&pcm_mutex);
 279         for (i = 0; i < codec->num_dai; i++) {
 280                 codec_dai = &codec->dai[i];
 281
 282                 dbg("pop wq checking: %s status: %s waiting: %s\n",
 283                         codec_dai->playback.stream_name,
 284                         codec_dai->playback.active ? "active" : "inactive",
 285                         codec_dai->pop_wait ? "yes" : "no");
 286
 287                 /* are we waiting on this codec DAI stream */
 288                 if (codec_dai->pop_wait == 1) {
 289
 290                         /* Reduce power if no longer active */
 291                         if (codec->active == 0) {
 292                                 dbg("pop wq D1 %s %s\n", codec->name,
 293                                         codec_dai->playback.stream_name);
 294                                 snd_soc_dapm_set_bias_level(socdev,
 295                                         SND_SOC_BIAS_PREPARE);
 296                         }
 297
 298                         codec_dai->pop_wait = 0;
 299                         snd_soc_dapm_stream_event(codec,
 300                                 codec_dai->playback.stream_name,
 301                                 SND_SOC_DAPM_STREAM_STOP);
 302
 303                         /* Fall into standby if no longer active */
 304                         if (codec->active == 0) {
 305                                 dbg("pop wq D3 %s %s\n", codec->name,
 306                                         codec_dai->playback.stream_name);
 307                                 snd_soc_dapm_set_bias_level(socdev,
 308                                         SND_SOC_BIAS_STANDBY);
 309                         }
 310                 }
 311         }
 312         mutex_unlock(&pcm_mutex);
 313 }
 314
 315 /*
 316  * Called by ALSA when a PCM substream is closed. Private data can be
 317  * freed here. The cpu DAI, codec DAI, machine and platform are also
 318  * shutdown.
 319  */
 320 static int soc_codec_close(struct snd_pcm_substream *substream)
 321 {
 322         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 323         struct snd_soc_device *socdev = rtd->socdev;
 324         struct snd_soc_dai_link *machine = rtd->dai;
 325         struct snd_soc_platform *platform = socdev->platform;
 326         struct snd_soc_dai *cpu_dai = machine->cpu_dai;
 327         struct snd_soc_dai *codec_dai = machine->codec_dai;
 328         struct snd_soc_codec *codec = socdev->codec;
 329
 330         mutex_lock(&pcm_mutex);
 331
 332         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 333                 cpu_dai->playback.active = codec_dai->playback.active = 0;
 334         else
 335                 cpu_dai->capture.active = codec_dai->capture.active = 0;
 336
 337         if (codec_dai->playback.active == 0 &&
 338                 codec_dai->capture.active == 0) {
 339                 cpu_dai->active = codec_dai->active = 0;
 340         }
 341         codec->active--;
 342
 343         if (cpu_dai->ops.shutdown)
 344                 cpu_dai->ops.shutdown(substream);
 345
 346         if (codec_dai->ops.shutdown)
 347                 codec_dai->ops.shutdown(substream);
 348
 349         if (machine->ops && machine->ops->shutdown)
 350                 machine->ops->shutdown(substream);
 351
 352         if (platform->pcm_ops->close)
 353                 platform->pcm_ops->close(substream);
 354         cpu_dai->runtime = NULL;
 355
 356         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 357                 /* start delayed pop wq here for playback streams */
 358                 codec_dai->pop_wait = 1;
 359                 schedule_delayed_work(&socdev->delayed_work,
 360                         msecs_to_jiffies(pmdown_time));
 361         } else {
 362                 /* capture streams can be powered down now */
 363                 snd_soc_dapm_stream_event(codec,
 364                         codec_dai->capture.stream_name,
 365                         SND_SOC_DAPM_STREAM_STOP);
 366
 367                 if (codec->active == 0 && codec_dai->pop_wait == 0)
 368                         snd_soc_dapm_set_bias_level(socdev,
 369                                                 SND_SOC_BIAS_STANDBY);
 370         }
 371
 372         mutex_unlock(&pcm_mutex);
 373         return 0;
 374 }
 375
 376 /*
 377  * Called by ALSA when the PCM substream is prepared, can set format, sample
 378  * rate, etc.  This function is non atomic and can be called multiple times,
 379  * it can refer to the runtime info.
 380  */
 381 static int soc_pcm_prepare(struct snd_pcm_substream *substream)
 382 {
 383         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 384         struct snd_soc_device *socdev = rtd->socdev;
 385         struct snd_soc_dai_link *machine = rtd->dai;
 386         struct snd_soc_platform *platform = socdev->platform;
 387         struct snd_soc_dai *cpu_dai = machine->cpu_dai;
 388         struct snd_soc_dai *codec_dai = machine->codec_dai;
 389         struct snd_soc_codec *codec = socdev->codec;
 390         int ret = 0;
 391
 392         mutex_lock(&pcm_mutex);
 393
 394         if (machine->ops && machine->ops->prepare) {
 395                 ret = machine->ops->prepare(substream);
 396                 if (ret < 0) {
 397                         printk(KERN_ERR "asoc: machine prepare error\n");
 398                         goto out;
 399                 }
 400         }
 401
 402         if (platform->pcm_ops->prepare) {
 403                 ret = platform->pcm_ops->prepare(substream);
 404                 if (ret < 0) {
 405                         printk(KERN_ERR "asoc: platform prepare error\n");
 406                         goto out;
 407                 }
 408         }
 409
 410         if (codec_dai->ops.prepare) {
 411                 ret = codec_dai->ops.prepare(substream);
 412                 if (ret < 0) {
 413                         printk(KERN_ERR "asoc: codec DAI prepare error\n");
 414                         goto out;
 415                 }
 416         }
 417
 418         if (cpu_dai->ops.prepare) {
 419                 ret = cpu_dai->ops.prepare(substream);
 420                 if (ret < 0) {
 421                         printk(KERN_ERR "asoc: cpu DAI prepare error\n");
 422                         goto out;
 423                 }
 424         }
 425
 426         /* we only want to start a DAPM playback stream if we are not waiting
 427          * on an existing one stopping */
 428         if (codec_dai->pop_wait) {
 429                 /* we are waiting for the delayed work to start */
 430                 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 431                                 snd_soc_dapm_stream_event(socdev->codec,
 432                                         codec_dai->capture.stream_name,
 433                                         SND_SOC_DAPM_STREAM_START);
 434                 else {
 435                         codec_dai->pop_wait = 0;
 436                         cancel_delayed_work(&socdev->delayed_work);
 437                         snd_soc_dai_digital_mute(codec_dai, 0);
 438                 }
 439         } else {
 440                 /* no delayed work - do we need to power up codec */
 441                 if (codec->bias_level != SND_SOC_BIAS_ON) {
 442
 443                         snd_soc_dapm_set_bias_level(socdev,
 444                                                     SND_SOC_BIAS_PREPARE);
 445
 446                         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 447                                 snd_soc_dapm_stream_event(codec,
 448                                         codec_dai->playback.stream_name,
 449                                         SND_SOC_DAPM_STREAM_START);
 450                         else
 451                                 snd_soc_dapm_stream_event(codec,
 452                                         codec_dai->capture.stream_name,
 453                                         SND_SOC_DAPM_STREAM_START);
 454
 455                         snd_soc_dapm_set_bias_level(socdev, SND_SOC_BIAS_ON);
 456                         snd_soc_dai_digital_mute(codec_dai, 0);
 457
 458                 } else {
 459                         /* codec already powered - power on widgets */
 460                         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 461                                 snd_soc_dapm_stream_event(codec,
 462                                         codec_dai->playback.stream_name,
 463                                         SND_SOC_DAPM_STREAM_START);
 464                         else
 465                                 snd_soc_dapm_stream_event(codec,
 466                                         codec_dai->capture.stream_name,
 467                                         SND_SOC_DAPM_STREAM_START);
 468
 469                         snd_soc_dai_digital_mute(codec_dai, 0);
 470                 }
 471         }
 472
 473 out:
 474         mutex_unlock(&pcm_mutex);
 475         return ret;
 476 }
 477
 478 /*
 479  * Called by ALSA when the hardware params are set by application. This
 480  * function can also be called multiple times and can allocate buffers
 481  * (using snd_pcm_lib_* ). It's non-atomic.
 482  */
 483 static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
 484                                 struct snd_pcm_hw_params *params)
 485 {
 486         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 487         struct snd_soc_device *socdev = rtd->socdev;
 488         struct snd_soc_dai_link *machine = rtd->dai;
 489         struct snd_soc_platform *platform = socdev->platform;
 490         struct snd_soc_dai *cpu_dai = machine->cpu_dai;
 491         struct snd_soc_dai *codec_dai = machine->codec_dai;
 492         int ret = 0;
 493
 494         mutex_lock(&pcm_mutex);
 495
 496         if (machine->ops && machine->ops->hw_params) {
 497                 ret = machine->ops->hw_params(substream, params);
 498                 if (ret < 0) {
 499                         printk(KERN_ERR "asoc: machine hw_params failed\n");
 500                         goto out;
 501                 }
 502         }
 503
 504         if (codec_dai->ops.hw_params) {
 505                 ret = codec_dai->ops.hw_params(substream, params);
 506                 if (ret < 0) {
 507                         printk(KERN_ERR "asoc: can't set codec %s hw params\n",
 508                                 codec_dai->name);
 509                         goto codec_err;
 510                 }
 511         }
 512
 513         if (cpu_dai->ops.hw_params) {
 514                 ret = cpu_dai->ops.hw_params(substream, params);
 515                 if (ret < 0) {
 516                         printk(KERN_ERR "asoc: interface %s hw params failed\n",
 517                                 cpu_dai->name);
 518                         goto interface_err;
 519                 }
 520         }
 521
 522         if (platform->pcm_ops->hw_params) {
 523                 ret = platform->pcm_ops->hw_params(substream, params);
 524                 if (ret < 0) {
 525                         printk(KERN_ERR "asoc: platform %s hw params failed\n",
 526                                 platform->name);
 527                         goto platform_err;
 528                 }
 529         }
 530
 531 out:
 532         mutex_unlock(&pcm_mutex);
 533         return ret;
 534
 535 platform_err:
 536         if (cpu_dai->ops.hw_free)
 537                 cpu_dai->ops.hw_free(substream);
 538
 539 interface_err:
 540         if (codec_dai->ops.hw_free)
 541                 codec_dai->ops.hw_free(substream);
 542
 543 codec_err:
 544         if (machine->ops && machine->ops->hw_free)
 545                 machine->ops->hw_free(substream);
 546
 547         mutex_unlock(&pcm_mutex);
 548         return ret;
 549 }
 550
 551 /*
 552  * Free's resources allocated by hw_params, can be called multiple times
 553  */
 554 static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
 555 {
 556         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 557         struct snd_soc_device *socdev = rtd->socdev;
 558         struct snd_soc_dai_link *machine = rtd->dai;
 559         struct snd_soc_platform *platform = socdev->platform;
 560         struct snd_soc_dai *cpu_dai = machine->cpu_dai;
 561         struct snd_soc_dai *codec_dai = machine->codec_dai;
 562         struct snd_soc_codec *codec = socdev->codec;
 563
 564         mutex_lock(&pcm_mutex);
 565
 566         /* apply codec digital mute */
 567         if (!codec->active)
 568                 snd_soc_dai_digital_mute(codec_dai, 1);
 569
 570         /* free any machine hw params */
 571         if (machine->ops && machine->ops->hw_free)
 572                 machine->ops->hw_free(substream);
 573
 574         /* free any DMA resources */
 575         if (platform->pcm_ops->hw_free)
 576                 platform->pcm_ops->hw_free(substream);
 577
 578         /* now free hw params for the DAI's  */
 579         if (codec_dai->ops.hw_free)
 580                 codec_dai->ops.hw_free(substream);
 581
 582         if (cpu_dai->ops.hw_free)
 583                 cpu_dai->ops.hw_free(substream);
 584
 585         mutex_unlock(&pcm_mutex);
 586         return 0;
 587 }
 588
 589 static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 590 {
 591         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 592         struct snd_soc_device *socdev = rtd->socdev;
 593         struct snd_soc_dai_link *machine = rtd->dai;
 594         struct snd_soc_platform *platform = socdev->platform;
 595         struct snd_soc_dai *cpu_dai = machine->cpu_dai;
 596         struct snd_soc_dai *codec_dai = machine->codec_dai;
 597         int ret;
 598
 599         if (codec_dai->ops.trigger) {
 600                 ret = codec_dai->ops.trigger(substream, cmd);
 601                 if (ret < 0)
 602                         return ret;
 603         }
 604
 605         if (platform->pcm_ops->trigger) {
 606                 ret = platform->pcm_ops->trigger(substream, cmd);
 607                 if (ret < 0)
 608                         return ret;
 609         }
 610
 611         if (cpu_dai->ops.trigger) {
 612                 ret = cpu_dai->ops.trigger(substream, cmd);
 613                 if (ret < 0)
 614                         return ret;
 615         }
 616         return 0;
 617 }
 618
 619 /* ASoC PCM operations */
 620 static struct snd_pcm_ops soc_pcm_ops = {
 621         .open           = soc_pcm_open,
 622         .close          = soc_codec_close,
 623         .hw_params      = soc_pcm_hw_params,
 624         .hw_free        = soc_pcm_hw_free,
 625         .prepare        = soc_pcm_prepare,
 626         .trigger        = soc_pcm_trigger,
 627 };
 628
 629 #ifdef CONFIG_PM
 630 /* powers down audio subsystem for suspend */
 631 static int soc_suspend(struct platform_device *pdev, pm_message_t state)
 632 {
 633         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 634         struct snd_soc_machine *machine = socdev->machine;
 635         struct snd_soc_platform *platform = socdev->platform;
 636         struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
 637         struct snd_soc_codec *codec = socdev->codec;
 638         int i;
 639
 640         /* Due to the resume being scheduled into a workqueue we could
 641         * suspend before that's finished - wait for it to complete.
 642          */
 643         snd_power_lock(codec->card);
 644         snd_power_wait(codec->card, SNDRV_CTL_POWER_D0);
 645         snd_power_unlock(codec->card);
 646
 647         /* we're going to block userspace touching us until resume completes */
 648         snd_power_change_state(codec->card, SNDRV_CTL_POWER_D3hot);
 649
 650         /* mute any active DAC's */
 651         for (i = 0; i < machine->num_links; i++) {
 652                 struct snd_soc_dai *dai = machine->dai_link[i].codec_dai;
 653                 if (dai->dai_ops.digital_mute && dai->playback.active)
 654                         dai->dai_ops.digital_mute(dai, 1);
 655         }
 656
 657         /* suspend all pcms */
 658         for (i = 0; i < machine->num_links; i++)
 659                 snd_pcm_suspend_all(machine->dai_link[i].pcm);
 660
 661         if (machine->suspend_pre)
 662                 machine->suspend_pre(pdev, state);
 663
 664         for (i = 0; i < machine->num_links; i++) {
 665                 struct snd_soc_dai  *cpu_dai = machine->dai_link[i].cpu_dai;
 666                 if (cpu_dai->suspend && cpu_dai->type != SND_SOC_DAI_AC97)
 667                         cpu_dai->suspend(pdev, cpu_dai);
 668                 if (platform->suspend)
 669                         platform->suspend(pdev, cpu_dai);
 670         }
 671
 672         /* close any waiting streams and save state */
 673         run_delayed_work(&socdev->delayed_work);
 674         codec->suspend_bias_level = codec->bias_level;
 675
 676         for (i = 0; i < codec->num_dai; i++) {
 677                 char *stream = codec->dai[i].playback.stream_name;
 678                 if (stream != NULL)
 679                         snd_soc_dapm_stream_event(codec, stream,
 680                                 SND_SOC_DAPM_STREAM_SUSPEND);
 681                 stream = codec->dai[i].capture.stream_name;
 682                 if (stream != NULL)
 683                         snd_soc_dapm_stream_event(codec, stream,
 684                                 SND_SOC_DAPM_STREAM_SUSPEND);
 685         }
 686
 687         if (codec_dev->suspend)
 688                 codec_dev->suspend(pdev, state);
 689
 690         for (i = 0; i < machine->num_links; i++) {
 691                 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 692                 if (cpu_dai->suspend && cpu_dai->type == SND_SOC_DAI_AC97)
 693                         cpu_dai->suspend(pdev, cpu_dai);
 694         }
 695
 696         if (machine->suspend_post)
 697                 machine->suspend_post(pdev, state);
 698
 699         return 0;
 700 }
 701
 702 /* deferred resume work, so resume can complete before we finished
 703  * setting our codec back up, which can be very slow on I2C
 704  */
 705 static void soc_resume_deferred(struct work_struct *work)
 706 {
 707         struct snd_soc_device *socdev = container_of(work,
 708                                                      struct snd_soc_device,
 709                                                      deferred_resume_work);
 710         struct snd_soc_machine *machine = socdev->machine;
 711         struct snd_soc_platform *platform = socdev->platform;
 712         struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
 713         struct snd_soc_codec *codec = socdev->codec;
 714         struct platform_device *pdev = to_platform_device(socdev->dev);
 715         int i;
 716
 717         /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
 718          * so userspace apps are blocked from touching us
 719          */
 720
 721         dev_info(socdev->dev, "starting resume work\n");
 722
 723         if (machine->resume_pre)
 724                 machine->resume_pre(pdev);
 725
 726         for (i = 0; i < machine->num_links; i++) {
 727                 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 728                 if (cpu_dai->resume && cpu_dai->type == SND_SOC_DAI_AC97)
 729                         cpu_dai->resume(pdev, cpu_dai);
 730         }
 731
 732         if (codec_dev->resume)
 733                 codec_dev->resume(pdev);
 734
 735         for (i = 0; i < codec->num_dai; i++) {
 736                 char *stream = codec->dai[i].playback.stream_name;
 737                 if (stream != NULL)
 738                         snd_soc_dapm_stream_event(codec, stream,
 739                                 SND_SOC_DAPM_STREAM_RESUME);
 740                 stream = codec->dai[i].capture.stream_name;
 741                 if (stream != NULL)
 742                         snd_soc_dapm_stream_event(codec, stream,
 743                                 SND_SOC_DAPM_STREAM_RESUME);
 744         }
 745
 746         /* unmute any active DACs */
 747         for (i = 0; i < machine->num_links; i++) {
 748                 struct snd_soc_dai *dai = machine->dai_link[i].codec_dai;
 749                 if (dai->dai_ops.digital_mute && dai->playback.active)
 750                         dai->dai_ops.digital_mute(dai, 0);
 751         }
 752
 753         for (i = 0; i < machine->num_links; i++) {
 754                 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 755                 if (cpu_dai->resume && cpu_dai->type != SND_SOC_DAI_AC97)
 756                         cpu_dai->resume(pdev, cpu_dai);
 757                 if (platform->resume)
 758                         platform->resume(pdev, cpu_dai);
 759         }
 760
 761         if (machine->resume_post)
 762                 machine->resume_post(pdev);
 763
 764         dev_info(socdev->dev, "resume work completed\n");
 765
 766         /* userspace can access us now we are back as we were before */
 767         snd_power_change_state(codec->card, SNDRV_CTL_POWER_D0);
 768 }
 769
 770 /* powers up audio subsystem after a suspend */
 771 static int soc_resume(struct platform_device *pdev)
 772 {
 773         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 774
 775         dev_info(socdev->dev, "scheduling resume work\n");
 776
 777         if (!schedule_work(&socdev->deferred_resume_work))
 778                 dev_err(socdev->dev, "work item may be lost\n");
 779
 780         return 0;
 781 }
 782
 783 #else
 784 #define soc_suspend     NULL
 785 #define soc_resume      NULL
 786 #endif
 787
 788 /* probes a new socdev */
 789 static int soc_probe(struct platform_device *pdev)
 790 {
 791         int ret = 0, i;
 792         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 793         struct snd_soc_machine *machine = socdev->machine;
 794         struct snd_soc_platform *platform = socdev->platform;
 795         struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
 796
 797         if (machine->probe) {
 798                 ret = machine->probe(pdev);
 799                 if (ret < 0)
 800                         return ret;
 801         }
 802
 803         for (i = 0; i < machine->num_links; i++) {
 804                 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 805                 if (cpu_dai->probe) {
 806                         ret = cpu_dai->probe(pdev, cpu_dai);
 807                         if (ret < 0)
 808                                 goto cpu_dai_err;
 809                 }
 810         }
 811
 812         if (codec_dev->probe) {
 813                 ret = codec_dev->probe(pdev);
 814                 if (ret < 0)
 815                         goto cpu_dai_err;
 816         }
 817
 818         if (platform->probe) {
 819                 ret = platform->probe(pdev);
 820                 if (ret < 0)
 821                         goto platform_err;
 822         }
 823
 824         /* DAPM stream work */
 825         INIT_DELAYED_WORK(&socdev->delayed_work, close_delayed_work);
 826 #ifdef CONFIG_PM
 827         /* deferred resume work */
 828         INIT_WORK(&socdev->deferred_resume_work, soc_resume_deferred);
 829 #endif
 830
 831         return 0;
 832
 833 platform_err:
 834         if (codec_dev->remove)
 835                 codec_dev->remove(pdev);
 836
 837 cpu_dai_err:
 838         for (i--; i >= 0; i--) {
 839                 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 840                 if (cpu_dai->remove)
 841                         cpu_dai->remove(pdev, cpu_dai);
 842         }
 843
 844         if (machine->remove)
 845                 machine->remove(pdev);
 846
 847         return ret;
 848 }
 849
 850 /* removes a socdev */
 851 static int soc_remove(struct platform_device *pdev)
 852 {
 853         int i;
 854         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 855         struct snd_soc_machine *machine = socdev->machine;
 856         struct snd_soc_platform *platform = socdev->platform;
 857         struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
 858
 859         run_delayed_work(&socdev->delayed_work);
 860
 861         if (platform->remove)
 862                 platform->remove(pdev);
 863
 864         if (codec_dev->remove)
 865                 codec_dev->remove(pdev);
 866
 867         for (i = 0; i < machine->num_links; i++) {
 868                 struct snd_soc_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 869                 if (cpu_dai->remove)
 870                         cpu_dai->remove(pdev, cpu_dai);
 871         }
 872
 873         if (machine->remove)
 874                 machine->remove(pdev);
 875
 876         return 0;
 877 }
 878
 879 /* ASoC platform driver */
 880 static struct platform_driver soc_driver = {
 881         .driver         = {
 882                 .name           = "soc-audio",
 883                 .owner          = THIS_MODULE,
 884         },
 885         .probe          = soc_probe,
 886         .remove         = soc_remove,
 887         .suspend        = soc_suspend,
 888         .resume         = soc_resume,
 889 };
 890
 891 /* create a new pcm */
 892 static int soc_new_pcm(struct snd_soc_device *socdev,
 893         struct snd_soc_dai_link *dai_link, int num)
 894 {
 895         struct snd_soc_codec *codec = socdev->codec;
 896         struct snd_soc_dai *codec_dai = dai_link->codec_dai;
 897         struct snd_soc_dai *cpu_dai = dai_link->cpu_dai;
 898         struct snd_soc_pcm_runtime *rtd;
 899         struct snd_pcm *pcm;
 900         char new_name[64];
 901         int ret = 0, playback = 0, capture = 0;
 902
 903         rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
 904         if (rtd == NULL)
 905                 return -ENOMEM;
 906
 907         rtd->dai = dai_link;
 908         rtd->socdev = socdev;
 909         codec_dai->codec = socdev->codec;
 910
 911         /* check client and interface hw capabilities */
 912         sprintf(new_name, "%s %s-%s-%d", dai_link->stream_name, codec_dai->name,
 913                 get_dai_name(cpu_dai->type), num);
 914
 915         if (codec_dai->playback.channels_min)
 916                 playback = 1;
 917         if (codec_dai->capture.channels_min)
 918                 capture = 1;
 919
 920         ret = snd_pcm_new(codec->card, new_name, codec->pcm_devs++, playback,
 921                 capture, &pcm);
 922         if (ret < 0) {
 923                 printk(KERN_ERR "asoc: can't create pcm for codec %s\n",
 924                         codec->name);
 925                 kfree(rtd);
 926                 return ret;
 927         }
 928
 929         dai_link->pcm = pcm;
 930         pcm->private_data = rtd;
 931         soc_pcm_ops.mmap = socdev->platform->pcm_ops->mmap;
 932         soc_pcm_ops.pointer = socdev->platform->pcm_ops->pointer;
 933         soc_pcm_ops.ioctl = socdev->platform->pcm_ops->ioctl;
 934         soc_pcm_ops.copy = socdev->platform->pcm_ops->copy;
 935         soc_pcm_ops.silence = socdev->platform->pcm_ops->silence;
 936         soc_pcm_ops.ack = socdev->platform->pcm_ops->ack;
 937         soc_pcm_ops.page = socdev->platform->pcm_ops->page;
 938
 939         if (playback)
 940                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &soc_pcm_ops);
 941
 942         if (capture)
 943                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &soc_pcm_ops);
 944
 945         ret = socdev->platform->pcm_new(codec->card, codec_dai, pcm);
 946         if (ret < 0) {
 947                 printk(KERN_ERR "asoc: platform pcm constructor failed\n");
 948                 kfree(rtd);
 949                 return ret;
 950         }
 951
 952         pcm->private_free = socdev->platform->pcm_free;
 953         printk(KERN_INFO "asoc: %s <-> %s mapping ok\n", codec_dai->name,
 954                 cpu_dai->name);
 955         return ret;
 956 }
 957
 958 /* codec register dump */
 959 static ssize_t codec_reg_show(struct device *dev,
 960         struct device_attribute *attr, char *buf)
 961 {
 962         struct snd_soc_device *devdata = dev_get_drvdata(dev);
 963         struct snd_soc_codec *codec = devdata->codec;
 964         int i, step = 1, count = 0;
 965
 966         if (!codec->reg_cache_size)
 967                 return 0;
 968
 969         if (codec->reg_cache_step)
 970                 step = codec->reg_cache_step;
 971
 972         count += sprintf(buf, "%s registers\n", codec->name);
 973         for (i = 0; i < codec->reg_cache_size; i += step)
 974                 count += sprintf(buf + count, "%2x: %4x\n", i,
 975                         codec->read(codec, i));
 976
 977         return count;
 978 }
 979 static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
 980
 981 /**
 982  * snd_soc_new_ac97_codec - initailise AC97 device
 983  * @codec: audio codec
 984  * @ops: AC97 bus operations
 985  * @num: AC97 codec number
 986  *
 987  * Initialises AC97 codec resources for use by ad-hoc devices only.
 988  */
 989 int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
 990         struct snd_ac97_bus_ops *ops, int num)
 991 {
 992         mutex_lock(&codec->mutex);
 993
 994         codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
 995         if (codec->ac97 == NULL) {
 996                 mutex_unlock(&codec->mutex);
 997                 return -ENOMEM;
 998         }
 999
1000         codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
1001         if (codec->ac97->bus == NULL) {
1002                 kfree(codec->ac97);
1003                 codec->ac97 = NULL;
1004                 mutex_unlock(&codec->mutex);
1005                 return -ENOMEM;
1006         }
1007
1008         codec->ac97->bus->ops = ops;
1009         codec->ac97->num = num;
1010         mutex_unlock(&codec->mutex);
1011         return 0;
1012 }
1013 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
1014
1015 /**
1016  * snd_soc_free_ac97_codec - free AC97 codec device
1017  * @codec: audio codec
1018  *
1019  * Frees AC97 codec device resources.
1020  */
1021 void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
1022 {
1023         mutex_lock(&codec->mutex);
1024         kfree(codec->ac97->bus);
1025         kfree(codec->ac97);
1026         codec->ac97 = NULL;
1027         mutex_unlock(&codec->mutex);
1028 }
1029 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
1030
1031 /**
1032  * snd_soc_update_bits - update codec register bits
1033  * @codec: audio codec
1034  * @reg: codec register
1035  * @mask: register mask
1036  * @value: new value
1037  *
1038  * Writes new register value.
1039  *
1040  * Returns 1 for change else 0.
1041  */
1042 int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
1043                                 unsigned short mask, unsigned short value)
1044 {
1045         int change;
1046         unsigned short old, new;
1047
1048         mutex_lock(&io_mutex);
1049         old = snd_soc_read(codec, reg);
1050         new = (old & ~mask) | value;
1051         change = old != new;
1052         if (change)
1053                 snd_soc_write(codec, reg, new);
1054
1055         mutex_unlock(&io_mutex);
1056         return change;
1057 }
1058 EXPORT_SYMBOL_GPL(snd_soc_update_bits);
1059
1060 /**
1061  * snd_soc_test_bits - test register for change
1062  * @codec: audio codec
1063  * @reg: codec register
1064  * @mask: register mask
1065  * @value: new value
1066  *
1067  * Tests a register with a new value and checks if the new value is
1068  * different from the old value.
1069  *
1070  * Returns 1 for change else 0.
1071  */
1072 int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
1073                                 unsigned short mask, unsigned short value)
1074 {
1075         int change;
1076         unsigned short old, new;
1077
1078         mutex_lock(&io_mutex);
1079         old = snd_soc_read(codec, reg);
1080         new = (old & ~mask) | value;
1081         change = old != new;
1082         mutex_unlock(&io_mutex);
1083
1084         return change;
1085 }
1086 EXPORT_SYMBOL_GPL(snd_soc_test_bits);
1087
1088 /**
1089  * snd_soc_new_pcms - create new sound card and pcms
1090  * @socdev: the SoC audio device
1091  *
1092  * Create a new sound card based upon the codec and interface pcms.
1093  *
1094  * Returns 0 for success, else error.
1095  */
1096 int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid)
1097 {
1098         struct snd_soc_codec *codec = socdev->codec;
1099         struct snd_soc_machine *machine = socdev->machine;
1100         int ret = 0, i;
1101
1102         mutex_lock(&codec->mutex);
1103
1104         /* register a sound card */
1105         codec->card = snd_card_new(idx, xid, codec->owner, 0);
1106         if (!codec->card) {
1107                 printk(KERN_ERR "asoc: can't create sound card for codec %s\n",
1108                         codec->name);
1109                 mutex_unlock(&codec->mutex);
1110                 return -ENODEV;
1111         }
1112
1113         codec->card->dev = socdev->dev;
1114         codec->card->private_data = codec;
1115         strncpy(codec->card->driver, codec->name, sizeof(codec->card->driver));
1116
1117         /* create the pcms */
1118         for (i = 0; i < machine->num_links; i++) {
1119                 ret = soc_new_pcm(socdev, &machine->dai_link[i], i);
1120                 if (ret < 0) {
1121                         printk(KERN_ERR "asoc: can't create pcm %s\n",
1122                                 machine->dai_link[i].stream_name);
1123                         mutex_unlock(&codec->mutex);
1124                         return ret;
1125                 }
1126         }
1127
1128         mutex_unlock(&codec->mutex);
1129         return ret;
1130 }
1131 EXPORT_SYMBOL_GPL(snd_soc_new_pcms);
1132
1133 /**
1134  * snd_soc_register_card - register sound card
1135  * @socdev: the SoC audio device
1136  *
1137  * Register a SoC sound card. Also registers an AC97 device if the
1138  * codec is AC97 for ad hoc devices.
1139  *
1140  * Returns 0 for success, else error.
1141  */
1142 int snd_soc_register_card(struct snd_soc_device *socdev)
1143 {
1144         struct snd_soc_codec *codec = socdev->codec;
1145         struct snd_soc_machine *machine = socdev->machine;
1146         int ret = 0, i, ac97 = 0, err = 0;
1147
1148         for (i = 0; i < machine->num_links; i++) {
1149                 if (socdev->machine->dai_link[i].init) {
1150                         err = socdev->machine->dai_link[i].init(codec);
1151                         if (err < 0) {
1152                                 printk(KERN_ERR "asoc: failed to init %s\n",
1153                                         socdev->machine->dai_link[i].stream_name);
1154                                 continue;
1155                         }
1156                 }
1157                 if (socdev->machine->dai_link[i].codec_dai->type ==
1158                         SND_SOC_DAI_AC97_BUS)
1159                         ac97 = 1;
1160         }
1161         snprintf(codec->card->shortname, sizeof(codec->card->shortname),
1162                  "%s", machine->name);
1163         snprintf(codec->card->longname, sizeof(codec->card->longname),
1164                  "%s (%s)", machine->name, codec->name);
1165
1166         ret = snd_card_register(codec->card);
1167         if (ret < 0) {
1168                 printk(KERN_ERR "asoc: failed to register soundcard for %s\n",
1169                                 codec->name);
1170                 goto out;
1171         }
1172
1173         mutex_lock(&codec->mutex);
1174 #ifdef CONFIG_SND_SOC_AC97_BUS
1175         if (ac97) {
1176                 ret = soc_ac97_dev_register(codec);
1177                 if (ret < 0) {
1178                         printk(KERN_ERR "asoc: AC97 device register failed\n");
1179                         snd_card_free(codec->card);
1180                         mutex_unlock(&codec->mutex);
1181                         goto out;
1182                 }
1183         }
1184 #endif
1185
1186         err = snd_soc_dapm_sys_add(socdev->dev);
1187         if (err < 0)
1188                 printk(KERN_WARNING "asoc: failed to add dapm sysfs entries\n");
1189
1190         err = device_create_file(socdev->dev, &dev_attr_codec_reg);
1191         if (err < 0)
1192                 printk(KERN_WARNING "asoc: failed to add codec sysfs files\n");
1193
1194         mutex_unlock(&codec->mutex);
1195
1196 out:
1197         return ret;
1198 }
1199 EXPORT_SYMBOL_GPL(snd_soc_register_card);
1200
1201 /**
1202  * snd_soc_free_pcms - free sound card and pcms
1203  * @socdev: the SoC audio device
1204  *
1205  * Frees sound card and pcms associated with the socdev.
1206  * Also unregister the codec if it is an AC97 device.
1207  */
1208 void snd_soc_free_pcms(struct snd_soc_device *socdev)
1209 {
1210         struct snd_soc_codec *codec = socdev->codec;
1211 #ifdef CONFIG_SND_SOC_AC97_BUS
1212         struct snd_soc_dai *codec_dai;
1213         int i;
1214 #endif
1215
1216         mutex_lock(&codec->mutex);
1217 #ifdef CONFIG_SND_SOC_AC97_BUS
1218         for (i = 0; i < codec->num_dai; i++) {
1219                 codec_dai = &codec->dai[i];
1220                 if (codec_dai->type == SND_SOC_DAI_AC97_BUS && codec->ac97) {
1221                         soc_ac97_dev_unregister(codec);
1222                         goto free_card;
1223                 }
1224         }
1225 free_card:
1226 #endif
1227
1228         if (codec->card)
1229                 snd_card_free(codec->card);
1230         device_remove_file(socdev->dev, &dev_attr_codec_reg);
1231         mutex_unlock(&codec->mutex);
1232 }
1233 EXPORT_SYMBOL_GPL(snd_soc_free_pcms);
1234
1235 /**
1236  * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
1237  * @substream: the pcm substream
1238  * @hw: the hardware parameters
1239  *
1240  * Sets the substream runtime hardware parameters.
1241  */
1242 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
1243         const struct snd_pcm_hardware *hw)
1244 {
1245         struct snd_pcm_runtime *runtime = substream->runtime;
1246         runtime->hw.info = hw->info;
1247         runtime->hw.formats = hw->formats;
1248         runtime->hw.period_bytes_min = hw->period_bytes_min;
1249         runtime->hw.period_bytes_max = hw->period_bytes_max;
1250         runtime->hw.periods_min = hw->periods_min;
1251         runtime->hw.periods_max = hw->periods_max;
1252         runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
1253         runtime->hw.fifo_size = hw->fifo_size;
1254         return 0;
1255 }
1256 EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
1257
1258 /**
1259  * snd_soc_cnew - create new control
1260  * @_template: control template
1261  * @data: control private data
1262  * @lnng_name: control long name
1263  *
1264  * Create a new mixer control from a template control.
1265  *
1266  * Returns 0 for success, else error.
1267  */
1268 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
1269         void *data, char *long_name)
1270 {
1271         struct snd_kcontrol_new template;
1272
1273         memcpy(&template, _template, sizeof(template));
1274         if (long_name)
1275                 template.name = long_name;
1276         template.index = 0;
1277
1278         return snd_ctl_new1(&template, data);
1279 }
1280 EXPORT_SYMBOL_GPL(snd_soc_cnew);
1281
1282 /**
1283  * snd_soc_info_enum_double - enumerated double mixer info callback
1284  * @kcontrol: mixer control
1285  * @uinfo: control element information
1286  *
1287  * Callback to provide information about a double enumerated
1288  * mixer control.
1289  *
1290  * Returns 0 for success.
1291  */
1292 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
1293         struct snd_ctl_elem_info *uinfo)
1294 {
1295         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1296
1297         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1298         uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
1299         uinfo->value.enumerated.items = e->mask;
1300
1301         if (uinfo->value.enumerated.item > e->mask - 1)
1302                 uinfo->value.enumerated.item = e->mask - 1;
1303         strcpy(uinfo->value.enumerated.name,
1304                 e->texts[uinfo->value.enumerated.item]);
1305         return 0;
1306 }
1307 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
1308
1309 /**
1310  * snd_soc_get_enum_double - enumerated double mixer get callback
1311  * @kcontrol: mixer control
1312  * @uinfo: control element information
1313  *
1314  * Callback to get the value of a double enumerated mixer.
1315  *
1316  * Returns 0 for success.
1317  */
1318 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
1319         struct snd_ctl_elem_value *ucontrol)
1320 {
1321         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1322         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1323         unsigned short val, bitmask;
1324
1325         for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1326                 ;
1327         val = snd_soc_read(codec, e->reg);
1328         ucontrol->value.enumerated.item[0]
1329                 = (val >> e->shift_l) & (bitmask - 1);
1330         if (e->shift_l != e->shift_r)
1331                 ucontrol->value.enumerated.item[1] =
1332                         (val >> e->shift_r) & (bitmask - 1);
1333
1334         return 0;
1335 }
1336 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
1337
1338 /**
1339  * snd_soc_put_enum_double - enumerated double mixer put callback
1340  * @kcontrol: mixer control
1341  * @uinfo: control element information
1342  *
1343  * Callback to set the value of a double enumerated mixer.
1344  *
1345  * Returns 0 for success.
1346  */
1347 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
1348         struct snd_ctl_elem_value *ucontrol)
1349 {
1350         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1351         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1352         unsigned short val;
1353         unsigned short mask, bitmask;
1354
1355         for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1356                 ;
1357         if (ucontrol->value.enumerated.item[0] > e->mask - 1)
1358                 return -EINVAL;
1359         val = ucontrol->value.enumerated.item[0] << e->shift_l;
1360         mask = (bitmask - 1) << e->shift_l;
1361         if (e->shift_l != e->shift_r) {
1362                 if (ucontrol->value.enumerated.item[1] > e->mask - 1)
1363                         return -EINVAL;
1364                 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1365                 mask |= (bitmask - 1) << e->shift_r;
1366         }
1367
1368         return snd_soc_update_bits(codec, e->reg, mask, val);
1369 }
1370 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
1371
1372 /**
1373  * snd_soc_info_enum_ext - external enumerated single mixer info callback
1374  * @kcontrol: mixer control
1375  * @uinfo: control element information
1376  *
1377  * Callback to provide information about an external enumerated
1378  * single mixer.
1379  *
1380  * Returns 0 for success.
1381  */
1382 int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
1383         struct snd_ctl_elem_info *uinfo)
1384 {
1385         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1386
1387         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1388         uinfo->count = 1;
1389         uinfo->value.enumerated.items = e->mask;
1390
1391         if (uinfo->value.enumerated.item > e->mask - 1)
1392                 uinfo->value.enumerated.item = e->mask - 1;
1393         strcpy(uinfo->value.enumerated.name,
1394                 e->texts[uinfo->value.enumerated.item]);
1395         return 0;
1396 }
1397 EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
1398
1399 /**
1400  * snd_soc_info_volsw_ext - external single mixer info callback
1401  * @kcontrol: mixer control
1402  * @uinfo: control element information
1403  *
1404  * Callback to provide information about a single external mixer control.
1405  *
1406  * Returns 0 for success.
1407  */
1408 int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
1409         struct snd_ctl_elem_info *uinfo)
1410 {
1411         int max = kcontrol->private_value;
1412
1413         if (max == 1)
1414                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1415         else
1416                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1417
1418         uinfo->count = 1;
1419         uinfo->value.integer.min = 0;
1420         uinfo->value.integer.max = max;
1421         return 0;
1422 }
1423 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
1424
1425 /**
1426  * snd_soc_info_volsw - single mixer info callback
1427  * @kcontrol: mixer control
1428  * @uinfo: control element information
1429  *
1430  * Callback to provide information about a single mixer control.
1431  *
1432  * Returns 0 for success.
1433  */
1434 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
1435         struct snd_ctl_elem_info *uinfo)
1436 {
1437         int max = (kcontrol->private_value >> 16) & 0xff;
1438         int shift = (kcontrol->private_value >> 8) & 0x0f;
1439         int rshift = (kcontrol->private_value >> 12) & 0x0f;
1440
1441         if (max == 1)
1442                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1443         else
1444                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1445
1446         uinfo->count = shift == rshift ? 1 : 2;
1447         uinfo->value.integer.min = 0;
1448         uinfo->value.integer.max = max;
1449         return 0;
1450 }
1451 EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
1452
1453 /**
1454  * snd_soc_get_volsw - single mixer get callback
1455  * @kcontrol: mixer control
1456  * @uinfo: control element information
1457  *
1458  * Callback to get the value of a single mixer control.
1459  *
1460  * Returns 0 for success.
1461  */
1462 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
1463         struct snd_ctl_elem_value *ucontrol)
1464 {
1465         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1466         int reg = kcontrol->private_value & 0xff;
1467         int shift = (kcontrol->private_value >> 8) & 0x0f;
1468         int rshift = (kcontrol->private_value >> 12) & 0x0f;
1469         int max = (kcontrol->private_value >> 16) & 0xff;
1470         int mask = (1 << fls(max)) - 1;
1471         int invert = (kcontrol->private_value >> 24) & 0x01;
1472
1473         ucontrol->value.integer.value[0] =
1474                 (snd_soc_read(codec, reg) >> shift) & mask;
1475         if (shift != rshift)
1476                 ucontrol->value.integer.value[1] =
1477                         (snd_soc_read(codec, reg) >> rshift) & mask;
1478         if (invert) {
1479                 ucontrol->value.integer.value[0] =
1480                         max - ucontrol->value.integer.value[0];
1481                 if (shift != rshift)
1482                         ucontrol->value.integer.value[1] =
1483                                 max - ucontrol->value.integer.value[1];
1484         }
1485
1486         return 0;
1487 }
1488 EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
1489
1490 /**
1491  * snd_soc_put_volsw - single mixer put callback
1492  * @kcontrol: mixer control
1493  * @uinfo: control element information
1494  *
1495  * Callback to set the value of a single mixer control.
1496  *
1497  * Returns 0 for success.
1498  */
1499 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
1500         struct snd_ctl_elem_value *ucontrol)
1501 {
1502         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1503         int reg = kcontrol->private_value & 0xff;
1504         int shift = (kcontrol->private_value >> 8) & 0x0f;
1505         int rshift = (kcontrol->private_value >> 12) & 0x0f;
1506         int max = (kcontrol->private_value >> 16) & 0xff;
1507         int mask = (1 << fls(max)) - 1;
1508         int invert = (kcontrol->private_value >> 24) & 0x01;
1509         unsigned short val, val2, val_mask;
1510
1511         val = (ucontrol->value.integer.value[0] & mask);
1512         if (invert)
1513                 val = max - val;
1514         val_mask = mask << shift;
1515         val = val << shift;
1516         if (shift != rshift) {
1517                 val2 = (ucontrol->value.integer.value[1] & mask);
1518                 if (invert)
1519                         val2 = max - val2;
1520                 val_mask |= mask << rshift;
1521                 val |= val2 << rshift;
1522         }
1523         return snd_soc_update_bits(codec, reg, val_mask, val);
1524 }
1525 EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
1526
1527 /**
1528  * snd_soc_info_volsw_2r - double mixer info callback
1529  * @kcontrol: mixer control
1530  * @uinfo: control element information
1531  *
1532  * Callback to provide information about a double mixer control that
1533  * spans 2 codec registers.
1534  *
1535  * Returns 0 for success.
1536  */
1537 int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
1538         struct snd_ctl_elem_info *uinfo)
1539 {
1540         int max = (kcontrol->private_value >> 12) & 0xff;
1541
1542         if (max == 1)
1543                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1544         else
1545                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1546
1547         uinfo->count = 2;
1548         uinfo->value.integer.min = 0;
1549         uinfo->value.integer.max = max;
1550         return 0;
1551 }
1552 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r);
1553
1554 /**
1555  * snd_soc_get_volsw_2r - double mixer get callback
1556  * @kcontrol: mixer control
1557  * @uinfo: control element information
1558  *
1559  * Callback to get the value of a double mixer control that spans 2 registers.
1560  *
1561  * Returns 0 for success.
1562  */
1563 int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
1564         struct snd_ctl_elem_value *ucontrol)
1565 {
1566         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1567         int reg = kcontrol->private_value & 0xff;
1568         int reg2 = (kcontrol->private_value >> 24) & 0xff;
1569         int shift = (kcontrol->private_value >> 8) & 0x0f;
1570         int max = (kcontrol->private_value >> 12) & 0xff;
1571         int mask = (1<<fls(max))-1;
1572         int invert = (kcontrol->private_value >> 20) & 0x01;
1573
1574         ucontrol->value.integer.value[0] =
1575                 (snd_soc_read(codec, reg) >> shift) & mask;
1576         ucontrol->value.integer.value[1] =
1577                 (snd_soc_read(codec, reg2) >> shift) & mask;
1578         if (invert) {
1579                 ucontrol->value.integer.value[0] =
1580                         max - ucontrol->value.integer.value[0];
1581                 ucontrol->value.integer.value[1] =
1582                         max - ucontrol->value.integer.value[1];
1583         }
1584
1585         return 0;
1586 }
1587 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r);
1588
1589 /**
1590  * snd_soc_put_volsw_2r - double mixer set callback
1591  * @kcontrol: mixer control
1592  * @uinfo: control element information
1593  *
1594  * Callback to set the value of a double mixer control that spans 2 registers.
1595  *
1596  * Returns 0 for success.
1597  */
1598 int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
1599         struct snd_ctl_elem_value *ucontrol)
1600 {
1601         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1602         int reg = kcontrol->private_value & 0xff;
1603         int reg2 = (kcontrol->private_value >> 24) & 0xff;
1604         int shift = (kcontrol->private_value >> 8) & 0x0f;
1605         int max = (kcontrol->private_value >> 12) & 0xff;
1606         int mask = (1 << fls(max)) - 1;
1607         int invert = (kcontrol->private_value >> 20) & 0x01;
1608         int err;
1609         unsigned short val, val2, val_mask;
1610
1611         val_mask = mask << shift;
1612         val = (ucontrol->value.integer.value[0] & mask);
1613         val2 = (ucontrol->value.integer.value[1] & mask);
1614
1615         if (invert) {
1616                 val = max - val;
1617                 val2 = max - val2;
1618         }
1619
1620         val = val << shift;
1621         val2 = val2 << shift;
1622
1623         err = snd_soc_update_bits(codec, reg, val_mask, val);
1624         if (err < 0)
1625                 return err;
1626
1627         err = snd_soc_update_bits(codec, reg2, val_mask, val2);
1628         return err;
1629 }
1630 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r);
1631
1632 /**
1633  * snd_soc_info_volsw_s8 - signed mixer info callback
1634  * @kcontrol: mixer control
1635  * @uinfo: control element information
1636  *
1637  * Callback to provide information about a signed mixer control.
1638  *
1639  * Returns 0 for success.
1640  */
1641 int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
1642         struct snd_ctl_elem_info *uinfo)
1643 {
1644         int max = (signed char)((kcontrol->private_value >> 16) & 0xff);
1645         int min = (signed char)((kcontrol->private_value >> 24) & 0xff);
1646
1647         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1648         uinfo->count = 2;
1649         uinfo->value.integer.min = 0;
1650         uinfo->value.integer.max = max-min;
1651         return 0;
1652 }
1653 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
1654
1655 /**
1656  * snd_soc_get_volsw_s8 - signed mixer get callback
1657  * @kcontrol: mixer control
1658  * @uinfo: control element information
1659  *
1660  * Callback to get the value of a signed mixer control.
1661  *
1662  * Returns 0 for success.
1663  */
1664 int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
1665         struct snd_ctl_elem_value *ucontrol)
1666 {
1667         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1668         int reg = kcontrol->private_value & 0xff;
1669         int min = (signed char)((kcontrol->private_value >> 24) & 0xff);
1670         int val = snd_soc_read(codec, reg);
1671
1672         ucontrol->value.integer.value[0] =
1673                 ((signed char)(val & 0xff))-min;
1674         ucontrol->value.integer.value[1] =
1675                 ((signed char)((val >> 8) & 0xff))-min;
1676         return 0;
1677 }
1678 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
1679
1680 /**
1681  * snd_soc_put_volsw_sgn - signed mixer put callback
1682  * @kcontrol: mixer control
1683  * @uinfo: control element information
1684  *
1685  * Callback to set the value of a signed mixer control.
1686  *
1687  * Returns 0 for success.
1688  */
1689 int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
1690         struct snd_ctl_elem_value *ucontrol)
1691 {
1692         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1693         int reg = kcontrol->private_value & 0xff;
1694         int min = (signed char)((kcontrol->private_value >> 24) & 0xff);
1695         unsigned short val;
1696
1697         val = (ucontrol->value.integer.value[0]+min) & 0xff;
1698         val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
1699
1700         return snd_soc_update_bits(codec, reg, 0xffff, val);
1701 }
1702 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
1703
1704 /**
1705  * snd_soc_dai_set_sysclk - configure DAI system or master clock.
1706  * @dai: DAI
1707  * @clk_id: DAI specific clock ID
1708  * @freq: new clock frequency in Hz
1709  * @dir: new clock direction - input/output.
1710  *
1711  * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
1712  */
1713 int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
1714         unsigned int freq, int dir)
1715 {
1716         if (dai->dai_ops.set_sysclk)
1717                 return dai->dai_ops.set_sysclk(dai, clk_id, freq, dir);
1718         else
1719                 return -EINVAL;
1720 }
1721 EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
1722
1723 /**
1724  * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
1725  * @dai: DAI
1726  * @clk_id: DAI specific clock divider ID
1727  * @div: new clock divisor.
1728  *
1729  * Configures the clock dividers. This is used to derive the best DAI bit and
1730  * frame clocks from the system or master clock. It's best to set the DAI bit
1731  * and frame clocks as low as possible to save system power.
1732  */
1733 int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
1734         int div_id, int div)
1735 {
1736         if (dai->dai_ops.set_clkdiv)
1737                 return dai->dai_ops.set_clkdiv(dai, div_id, div);
1738         else
1739                 return -EINVAL;
1740 }
1741 EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
1742
1743 /**
1744  * snd_soc_dai_set_pll - configure DAI PLL.
1745  * @dai: DAI
1746  * @pll_id: DAI specific PLL ID
1747  * @freq_in: PLL input clock frequency in Hz
1748  * @freq_out: requested PLL output clock frequency in Hz
1749  *
1750  * Configures and enables PLL to generate output clock based on input clock.
1751  */
1752 int snd_soc_dai_set_pll(struct snd_soc_dai *dai,
1753         int pll_id, unsigned int freq_in, unsigned int freq_out)
1754 {
1755         if (dai->dai_ops.set_pll)
1756                 return dai->dai_ops.set_pll(dai, pll_id, freq_in, freq_out);
1757         else
1758                 return -EINVAL;
1759 }
1760 EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
1761
1762 /**
1763  * snd_soc_dai_set_fmt - configure DAI hardware audio format.
1764  * @dai: DAI
1765  * @clk_id: DAI specific clock ID
1766  * @fmt: SND_SOC_DAIFMT_ format value.
1767  *
1768  * Configures the DAI hardware format and clocking.
1769  */
1770 int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
1771 {
1772         if (dai->dai_ops.set_fmt)
1773                 return dai->dai_ops.set_fmt(dai, fmt);
1774         else
1775                 return -EINVAL;
1776 }
1777 EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
1778
1779 /**
1780  * snd_soc_dai_set_tdm_slot - configure DAI TDM.
1781  * @dai: DAI
1782  * @mask: DAI specific mask representing used slots.
1783  * @slots: Number of slots in use.
1784  *
1785  * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
1786  * specific.
1787  */
1788 int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
1789         unsigned int mask, int slots)
1790 {
1791         if (dai->dai_ops.set_sysclk)
1792                 return dai->dai_ops.set_tdm_slot(dai, mask, slots);
1793         else
1794                 return -EINVAL;
1795 }
1796 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
1797
1798 /**
1799  * snd_soc_dai_set_tristate - configure DAI system or master clock.
1800  * @dai: DAI
1801  * @tristate: tristate enable
1802  *
1803  * Tristates the DAI so that others can use it.
1804  */
1805 int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
1806 {
1807         if (dai->dai_ops.set_sysclk)
1808                 return dai->dai_ops.set_tristate(dai, tristate);
1809         else
1810                 return -EINVAL;
1811 }
1812 EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
1813
1814 /**
1815  * snd_soc_dai_digital_mute - configure DAI system or master clock.
1816  * @dai: DAI
1817  * @mute: mute enable
1818  *
1819  * Mutes the DAI DAC.
1820  */
1821 int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
1822 {
1823         if (dai->dai_ops.digital_mute)
1824                 return dai->dai_ops.digital_mute(dai, mute);
1825         else
1826                 return -EINVAL;
1827 }
1828 EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
1829
1830 static int __devinit snd_soc_init(void)
1831 {
1832         printk(KERN_INFO "ASoC version %s\n", SND_SOC_VERSION);
1833         return platform_driver_register(&soc_driver);
1834 }
1835
1836 static void snd_soc_exit(void)
1837 {
1838         platform_driver_unregister(&soc_driver);
1839 }
1840
1841 module_init(snd_soc_init);
1842 module_exit(snd_soc_exit);
1843
1844 /* Module information */
1845 MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com, www.wolfsonmicro.com");
1846 MODULE_DESCRIPTION("ALSA SoC Core");
1847 MODULE_LICENSE("GPL");
1848 MODULE_ALIAS("platform:soc-audio");