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  *  Revision history
  18  *    12th Aug 2005   Initial version.
  19  *    25th Oct 2005   Working Codec, Interface and Platform registration.
  20  *
  21  *  TODO:
  22  *   o Add hw rules to enforce rates, etc.
  23  *   o More testing with other codecs/machines.
  24  *   o Add more codecs and platforms to ensure good API coverage.
  25  *   o Support TDM on PCM and I2S
  26  */
  27
  28 #include <linux/module.h>
  29 #include <linux/moduleparam.h>
  30 #include <linux/init.h>
  31 #include <linux/delay.h>
  32 #include <linux/pm.h>
  33 #include <linux/bitops.h>
  34 #include <linux/platform_device.h>
  35 #include <sound/core.h>
  36 #include <sound/pcm.h>
  37 #include <sound/pcm_params.h>
  38 #include <sound/soc.h>
  39 #include <sound/soc-dapm.h>
  40 #include <sound/initval.h>
  41
  42 /* debug */
  43 #define SOC_DEBUG 0
  44 #if SOC_DEBUG
  45 #define dbg(format, arg...) printk(format, ## arg)
  46 #else
  47 #define dbg(format, arg...)
  48 #endif
  49
  50 static DEFINE_MUTEX(pcm_mutex);
  51 static DEFINE_MUTEX(io_mutex);
  52 static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
  53
  54 /*
  55  * This is a timeout to do a DAPM powerdown after a stream is closed().
  56  * It can be used to eliminate pops between different playback streams, e.g.
  57  * between two audio tracks.
  58  */
  59 static int pmdown_time = 5000;
  60 module_param(pmdown_time, int, 0);
  61 MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
  62
  63 /*
  64  * This function forces any delayed work to be queued and run.
  65  */
  66 static int run_delayed_work(struct delayed_work *dwork)
  67 {
  68         int ret;
  69
  70         /* cancel any work waiting to be queued. */
  71         ret = cancel_delayed_work(dwork);
  72
  73         /* if there was any work waiting then we run it now and
  74          * wait for it's completion */
  75         if (ret) {
  76                 schedule_delayed_work(dwork, 0);
  77                 flush_scheduled_work();
  78         }
  79         return ret;
  80 }
  81
  82 #ifdef CONFIG_SND_SOC_AC97_BUS
  83 /* unregister ac97 codec */
  84 static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
  85 {
  86         if (codec->ac97->dev.bus)
  87                 device_unregister(&codec->ac97->dev);
  88         return 0;
  89 }
  90
  91 /* stop no dev release warning */
  92 static void soc_ac97_device_release(struct device *dev){}
  93
  94 /* register ac97 codec to bus */
  95 static int soc_ac97_dev_register(struct snd_soc_codec *codec)
  96 {
  97         int err;
  98
  99         codec->ac97->dev.bus = &ac97_bus_type;
 100         codec->ac97->dev.parent = NULL;
 101         codec->ac97->dev.release = soc_ac97_device_release;
 102
 103         snprintf(codec->ac97->dev.bus_id, BUS_ID_SIZE, "%d-%d:%s",
 104                  codec->card->number, 0, codec->name);
 105         err = device_register(&codec->ac97->dev);
 106         if (err < 0) {
 107                 snd_printk(KERN_ERR "Can't register ac97 bus\n");
 108                 codec->ac97->dev.bus = NULL;
 109                 return err;
 110         }
 111         return 0;
 112 }
 113 #endif
 114
 115 static inline const char* get_dai_name(int type)
 116 {
 117         switch(type) {
 118         case SND_SOC_DAI_AC97_BUS:
 119         case SND_SOC_DAI_AC97:
 120                 return "AC97";
 121         case SND_SOC_DAI_I2S:
 122                 return "I2S";
 123         case SND_SOC_DAI_PCM:
 124                 return "PCM";
 125         }
 126         return NULL;
 127 }
 128
 129 /*
 130  * Called by ALSA when a PCM substream is opened, the runtime->hw record is
 131  * then initialized and any private data can be allocated. This also calls
 132  * startup for the cpu DAI, platform, machine and codec DAI.
 133  */
 134 static int soc_pcm_open(struct snd_pcm_substream *substream)
 135 {
 136         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 137         struct snd_soc_device *socdev = rtd->socdev;
 138         struct snd_pcm_runtime *runtime = substream->runtime;
 139         struct snd_soc_dai_link *machine = rtd->dai;
 140         struct snd_soc_platform *platform = socdev->platform;
 141         struct snd_soc_cpu_dai *cpu_dai = machine->cpu_dai;
 142         struct snd_soc_codec_dai *codec_dai = machine->codec_dai;
 143         int ret = 0;
 144
 145         mutex_lock(&pcm_mutex);
 146
 147         /* startup the audio subsystem */
 148         if (cpu_dai->ops.startup) {
 149                 ret = cpu_dai->ops.startup(substream);
 150                 if (ret < 0) {
 151                         printk(KERN_ERR "asoc: can't open interface %s\n",
 152                                 cpu_dai->name);
 153                         goto out;
 154                 }
 155         }
 156
 157         if (platform->pcm_ops->open) {
 158                 ret = platform->pcm_ops->open(substream);
 159                 if (ret < 0) {
 160                         printk(KERN_ERR "asoc: can't open platform %s\n", platform->name);
 161                         goto platform_err;
 162                 }
 163         }
 164
 165         if (codec_dai->ops.startup) {
 166                 ret = codec_dai->ops.startup(substream);
 167                 if (ret < 0) {
 168                         printk(KERN_ERR "asoc: can't open codec %s\n",
 169                                 codec_dai->name);
 170                         goto codec_dai_err;
 171                 }
 172         }
 173
 174         if (machine->ops && machine->ops->startup) {
 175                 ret = machine->ops->startup(substream);
 176                 if (ret < 0) {
 177                         printk(KERN_ERR "asoc: %s startup failed\n", machine->name);
 178                         goto machine_err;
 179                 }
 180         }
 181
 182         /* Check that the codec and cpu DAI's are compatible */
 183         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 184                 runtime->hw.rate_min =
 185                         max(codec_dai->playback.rate_min, cpu_dai->playback.rate_min);
 186                 runtime->hw.rate_max =
 187                         min(codec_dai->playback.rate_max, cpu_dai->playback.rate_max);
 188                 runtime->hw.channels_min =
 189                         max(codec_dai->playback.channels_min,
 190                                 cpu_dai->playback.channels_min);
 191                 runtime->hw.channels_max =
 192                         min(codec_dai->playback.channels_max,
 193                                 cpu_dai->playback.channels_max);
 194                 runtime->hw.formats =
 195                         codec_dai->playback.formats & cpu_dai->playback.formats;
 196                 runtime->hw.rates =
 197                         codec_dai->playback.rates & cpu_dai->playback.rates;
 198         } else {
 199                 runtime->hw.rate_min =
 200                         max(codec_dai->capture.rate_min, cpu_dai->capture.rate_min);
 201                 runtime->hw.rate_max =
 202                         min(codec_dai->capture.rate_max, 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_codec_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                         /* power down the codec to D1 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_device_event(socdev,
 295                                         SNDRV_CTL_POWER_D1);
 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                         /* power down the codec power domain 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_device_event(socdev,
 308                                         SNDRV_CTL_POWER_D3hot);
 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_cpu_dai *cpu_dai = machine->cpu_dai;
 327         struct snd_soc_codec_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_device_event(socdev,
 369                                                 SNDRV_CTL_POWER_D3hot);
 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_cpu_dai *cpu_dai = machine->cpu_dai;
 388         struct snd_soc_codec_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                         if (codec_dai->dai_ops.digital_mute)
 438                                 codec_dai->dai_ops.digital_mute(codec_dai, 0);
 439                 }
 440         } else {
 441                 /* no delayed work - do we need to power up codec */
 442                 if (codec->dapm_state != SNDRV_CTL_POWER_D0) {
 443
 444                         snd_soc_dapm_device_event(socdev,  SNDRV_CTL_POWER_D1);
 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_device_event(socdev, SNDRV_CTL_POWER_D0);
 456                         if (codec_dai->dai_ops.digital_mute)
 457                                 codec_dai->dai_ops.digital_mute(codec_dai, 0);
 458
 459                 } else {
 460                         /* codec already powered - power on widgets */
 461                         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 462                                 snd_soc_dapm_stream_event(codec,
 463                                         codec_dai->playback.stream_name,
 464                                         SND_SOC_DAPM_STREAM_START);
 465                         else
 466                                 snd_soc_dapm_stream_event(codec,
 467                                         codec_dai->capture.stream_name,
 468                                         SND_SOC_DAPM_STREAM_START);
 469                         if (codec_dai->dai_ops.digital_mute)
 470                                 codec_dai->dai_ops.digital_mute(codec_dai, 0);
 471                 }
 472         }
 473
 474 out:
 475         mutex_unlock(&pcm_mutex);
 476         return ret;
 477 }
 478
 479 /*
 480  * Called by ALSA when the hardware params are set by application. This
 481  * function can also be called multiple times and can allocate buffers
 482  * (using snd_pcm_lib_* ). It's non-atomic.
 483  */
 484 static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
 485                                 struct snd_pcm_hw_params *params)
 486 {
 487         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 488         struct snd_soc_device *socdev = rtd->socdev;
 489         struct snd_soc_dai_link *machine = rtd->dai;
 490         struct snd_soc_platform *platform = socdev->platform;
 491         struct snd_soc_cpu_dai *cpu_dai = machine->cpu_dai;
 492         struct snd_soc_codec_dai *codec_dai = machine->codec_dai;
 493         int ret = 0;
 494
 495         mutex_lock(&pcm_mutex);
 496
 497         if (machine->ops && machine->ops->hw_params) {
 498                 ret = machine->ops->hw_params(substream, params);
 499                 if (ret < 0) {
 500                         printk(KERN_ERR "asoc: machine hw_params failed\n");
 501                         goto out;
 502                 }
 503         }
 504
 505         if (codec_dai->ops.hw_params) {
 506                 ret = codec_dai->ops.hw_params(substream, params);
 507                 if (ret < 0) {
 508                         printk(KERN_ERR "asoc: can't set codec %s hw params\n",
 509                                 codec_dai->name);
 510                         goto codec_err;
 511                 }
 512         }
 513
 514         if (cpu_dai->ops.hw_params) {
 515                 ret = cpu_dai->ops.hw_params(substream, params);
 516                 if (ret < 0) {
 517                         printk(KERN_ERR "asoc: can't set interface %s hw params\n",
 518                                 cpu_dai->name);
 519                         goto interface_err;
 520                 }
 521         }
 522
 523         if (platform->pcm_ops->hw_params) {
 524                 ret = platform->pcm_ops->hw_params(substream, params);
 525                 if (ret < 0) {
 526                         printk(KERN_ERR "asoc: can't set platform %s hw params\n",
 527                                 platform->name);
 528                         goto platform_err;
 529                 }
 530         }
 531
 532 out:
 533         mutex_unlock(&pcm_mutex);
 534         return ret;
 535
 536 platform_err:
 537         if (cpu_dai->ops.hw_free)
 538                 cpu_dai->ops.hw_free(substream);
 539
 540 interface_err:
 541         if (codec_dai->ops.hw_free)
 542                 codec_dai->ops.hw_free(substream);
 543
 544 codec_err:
 545         if(machine->ops && machine->ops->hw_free)
 546                 machine->ops->hw_free(substream);
 547
 548         mutex_unlock(&pcm_mutex);
 549         return ret;
 550 }
 551
 552 /*
 553  * Free's resources allocated by hw_params, can be called multiple times
 554  */
 555 static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
 556 {
 557         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 558         struct snd_soc_device *socdev = rtd->socdev;
 559         struct snd_soc_dai_link *machine = rtd->dai;
 560         struct snd_soc_platform *platform = socdev->platform;
 561         struct snd_soc_cpu_dai *cpu_dai = machine->cpu_dai;
 562         struct snd_soc_codec_dai *codec_dai = machine->codec_dai;
 563         struct snd_soc_codec *codec = socdev->codec;
 564
 565         mutex_lock(&pcm_mutex);
 566
 567         /* apply codec digital mute */
 568         if (!codec->active && codec_dai->dai_ops.digital_mute)
 569                 codec_dai->dai_ops.digital_mute(codec_dai, 1);
 570
 571         /* free any machine hw params */
 572         if (machine->ops && machine->ops->hw_free)
 573                 machine->ops->hw_free(substream);
 574
 575         /* free any DMA resources */
 576         if (platform->pcm_ops->hw_free)
 577                 platform->pcm_ops->hw_free(substream);
 578
 579         /* now free hw params for the DAI's  */
 580         if (codec_dai->ops.hw_free)
 581                 codec_dai->ops.hw_free(substream);
 582
 583         if (cpu_dai->ops.hw_free)
 584                 cpu_dai->ops.hw_free(substream);
 585
 586         mutex_unlock(&pcm_mutex);
 587         return 0;
 588 }
 589
 590 static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 591 {
 592         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 593         struct snd_soc_device *socdev = rtd->socdev;
 594         struct snd_soc_dai_link *machine = rtd->dai;
 595         struct snd_soc_platform *platform = socdev->platform;
 596         struct snd_soc_cpu_dai *cpu_dai = machine->cpu_dai;
 597         struct snd_soc_codec_dai *codec_dai = machine->codec_dai;
 598         int ret;
 599
 600         if (codec_dai->ops.trigger) {
 601                 ret = codec_dai->ops.trigger(substream, cmd);
 602                 if (ret < 0)
 603                         return ret;
 604         }
 605
 606         if (platform->pcm_ops->trigger) {
 607                 ret = platform->pcm_ops->trigger(substream, cmd);
 608                 if (ret < 0)
 609                         return ret;
 610         }
 611
 612         if (cpu_dai->ops.trigger) {
 613                 ret = cpu_dai->ops.trigger(substream, cmd);
 614                 if (ret < 0)
 615                         return ret;
 616         }
 617         return 0;
 618 }
 619
 620 /* ASoC PCM operations */
 621 static struct snd_pcm_ops soc_pcm_ops = {
 622         .open           = soc_pcm_open,
 623         .close          = soc_codec_close,
 624         .hw_params      = soc_pcm_hw_params,
 625         .hw_free        = soc_pcm_hw_free,
 626         .prepare        = soc_pcm_prepare,
 627         .trigger        = soc_pcm_trigger,
 628 };
 629
 630 #ifdef CONFIG_PM
 631 /* powers down audio subsystem for suspend */
 632 static int soc_suspend(struct platform_device *pdev, pm_message_t state)
 633 {
 634         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 635         struct snd_soc_machine *machine = socdev->machine;
 636         struct snd_soc_platform *platform = socdev->platform;
 637         struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
 638         struct snd_soc_codec *codec = socdev->codec;
 639         int i;
 640
 641         /* mute any active DAC's */
 642         for(i = 0; i < machine->num_links; i++) {
 643                 struct snd_soc_codec_dai *dai = machine->dai_link[i].codec_dai;
 644                 if (dai->dai_ops.digital_mute && dai->playback.active)
 645                         dai->dai_ops.digital_mute(dai, 1);
 646         }
 647
 648         if (machine->suspend_pre)
 649                 machine->suspend_pre(pdev, state);
 650
 651         for(i = 0; i < machine->num_links; i++) {
 652                 struct snd_soc_cpu_dai  *cpu_dai = machine->dai_link[i].cpu_dai;
 653                 if (cpu_dai->suspend && cpu_dai->type != SND_SOC_DAI_AC97)
 654                         cpu_dai->suspend(pdev, cpu_dai);
 655                 if (platform->suspend)
 656                         platform->suspend(pdev, cpu_dai);
 657         }
 658
 659         /* close any waiting streams and save state */
 660         run_delayed_work(&socdev->delayed_work);
 661         codec->suspend_dapm_state = codec->dapm_state;
 662
 663         for(i = 0; i < codec->num_dai; i++) {
 664                 char *stream = codec->dai[i].playback.stream_name;
 665                 if (stream != NULL)
 666                         snd_soc_dapm_stream_event(codec, stream,
 667                                 SND_SOC_DAPM_STREAM_SUSPEND);
 668                 stream = codec->dai[i].capture.stream_name;
 669                 if (stream != NULL)
 670                         snd_soc_dapm_stream_event(codec, stream,
 671                                 SND_SOC_DAPM_STREAM_SUSPEND);
 672         }
 673
 674         if (codec_dev->suspend)
 675                 codec_dev->suspend(pdev, state);
 676
 677         for(i = 0; i < machine->num_links; i++) {
 678                 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 679                 if (cpu_dai->suspend && cpu_dai->type == SND_SOC_DAI_AC97)
 680                         cpu_dai->suspend(pdev, cpu_dai);
 681         }
 682
 683         if (machine->suspend_post)
 684                 machine->suspend_post(pdev, state);
 685
 686         return 0;
 687 }
 688
 689 /* powers up audio subsystem after a suspend */
 690 static int soc_resume(struct platform_device *pdev)
 691 {
 692         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 693         struct snd_soc_machine *machine = socdev->machine;
 694         struct snd_soc_platform *platform = socdev->platform;
 695         struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
 696         struct snd_soc_codec *codec = socdev->codec;
 697         int i;
 698
 699         if (machine->resume_pre)
 700                 machine->resume_pre(pdev);
 701
 702         for(i = 0; i < machine->num_links; i++) {
 703                 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 704                 if (cpu_dai->resume && cpu_dai->type == SND_SOC_DAI_AC97)
 705                         cpu_dai->resume(pdev, cpu_dai);
 706         }
 707
 708         if (codec_dev->resume)
 709                 codec_dev->resume(pdev);
 710
 711         for(i = 0; i < codec->num_dai; i++) {
 712                 char* stream = codec->dai[i].playback.stream_name;
 713                 if (stream != NULL)
 714                         snd_soc_dapm_stream_event(codec, stream,
 715                                 SND_SOC_DAPM_STREAM_RESUME);
 716                 stream = codec->dai[i].capture.stream_name;
 717                 if (stream != NULL)
 718                         snd_soc_dapm_stream_event(codec, stream,
 719                                 SND_SOC_DAPM_STREAM_RESUME);
 720         }
 721
 722         /* unmute any active DAC's */
 723         for(i = 0; i < machine->num_links; i++) {
 724                 struct snd_soc_codec_dai *dai = machine->dai_link[i].codec_dai;
 725                 if (dai->dai_ops.digital_mute && dai->playback.active)
 726                         dai->dai_ops.digital_mute(dai, 0);
 727         }
 728
 729         for(i = 0; i < machine->num_links; i++) {
 730                 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 731                 if (cpu_dai->resume && cpu_dai->type != SND_SOC_DAI_AC97)
 732                         cpu_dai->resume(pdev, cpu_dai);
 733                 if (platform->resume)
 734                         platform->resume(pdev, cpu_dai);
 735         }
 736
 737         if (machine->resume_post)
 738                 machine->resume_post(pdev);
 739
 740         return 0;
 741 }
 742
 743 #else
 744 #define soc_suspend     NULL
 745 #define soc_resume      NULL
 746 #endif
 747
 748 /* probes a new socdev */
 749 static int soc_probe(struct platform_device *pdev)
 750 {
 751         int ret = 0, i;
 752         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 753         struct snd_soc_machine *machine = socdev->machine;
 754         struct snd_soc_platform *platform = socdev->platform;
 755         struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
 756
 757         if (machine->probe) {
 758                 ret = machine->probe(pdev);
 759                 if(ret < 0)
 760                         return ret;
 761         }
 762
 763         for (i = 0; i < machine->num_links; i++) {
 764                 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 765                 if (cpu_dai->probe) {
 766                         ret = cpu_dai->probe(pdev);
 767                         if(ret < 0)
 768                                 goto cpu_dai_err;
 769                 }
 770         }
 771
 772         if (codec_dev->probe) {
 773                 ret = codec_dev->probe(pdev);
 774                 if(ret < 0)
 775                         goto cpu_dai_err;
 776         }
 777
 778         if (platform->probe) {
 779                 ret = platform->probe(pdev);
 780                 if(ret < 0)
 781                         goto platform_err;
 782         }
 783
 784         /* DAPM stream work */
 785         INIT_DELAYED_WORK(&socdev->delayed_work, close_delayed_work);
 786         return 0;
 787
 788 platform_err:
 789         if (codec_dev->remove)
 790                 codec_dev->remove(pdev);
 791
 792 cpu_dai_err:
 793         for (i--; i >= 0; i--) {
 794                 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 795                 if (cpu_dai->remove)
 796                         cpu_dai->remove(pdev);
 797         }
 798
 799         if (machine->remove)
 800                 machine->remove(pdev);
 801
 802         return ret;
 803 }
 804
 805 /* removes a socdev */
 806 static int soc_remove(struct platform_device *pdev)
 807 {
 808         int i;
 809         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
 810         struct snd_soc_machine *machine = socdev->machine;
 811         struct snd_soc_platform *platform = socdev->platform;
 812         struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
 813
 814         run_delayed_work(&socdev->delayed_work);
 815
 816         if (platform->remove)
 817                 platform->remove(pdev);
 818
 819         if (codec_dev->remove)
 820                 codec_dev->remove(pdev);
 821
 822         for (i = 0; i < machine->num_links; i++) {
 823                 struct snd_soc_cpu_dai *cpu_dai = machine->dai_link[i].cpu_dai;
 824                 if (cpu_dai->remove)
 825                         cpu_dai->remove(pdev);
 826         }
 827
 828         if (machine->remove)
 829                 machine->remove(pdev);
 830
 831         return 0;
 832 }
 833
 834 /* ASoC platform driver */
 835 static struct platform_driver soc_driver = {
 836         .driver         = {
 837                 .name           = "soc-audio",
 838         },
 839         .probe          = soc_probe,
 840         .remove         = soc_remove,
 841         .suspend        = soc_suspend,
 842         .resume         = soc_resume,
 843 };
 844
 845 /* create a new pcm */
 846 static int soc_new_pcm(struct snd_soc_device *socdev,
 847         struct snd_soc_dai_link *dai_link, int num)
 848 {
 849         struct snd_soc_codec *codec = socdev->codec;
 850         struct snd_soc_codec_dai *codec_dai = dai_link->codec_dai;
 851         struct snd_soc_cpu_dai *cpu_dai = dai_link->cpu_dai;
 852         struct snd_soc_pcm_runtime *rtd;
 853         struct snd_pcm *pcm;
 854         char new_name[64];
 855         int ret = 0, playback = 0, capture = 0;
 856
 857         rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
 858         if (rtd == NULL)
 859                 return -ENOMEM;
 860
 861         rtd->dai = dai_link;
 862         rtd->socdev = socdev;
 863         codec_dai->codec = socdev->codec;
 864
 865         /* check client and interface hw capabilities */
 866         sprintf(new_name, "%s %s-%s-%d",dai_link->stream_name, codec_dai->name,
 867                 get_dai_name(cpu_dai->type), num);
 868
 869         if (codec_dai->playback.channels_min)
 870                 playback = 1;
 871         if (codec_dai->capture.channels_min)
 872                 capture = 1;
 873
 874         ret = snd_pcm_new(codec->card, new_name, codec->pcm_devs++, playback,
 875                 capture, &pcm);
 876         if (ret < 0) {
 877                 printk(KERN_ERR "asoc: can't create pcm for codec %s\n", codec->name);
 878                 kfree(rtd);
 879                 return ret;
 880         }
 881
 882         pcm->private_data = rtd;
 883         soc_pcm_ops.mmap = socdev->platform->pcm_ops->mmap;
 884         soc_pcm_ops.pointer = socdev->platform->pcm_ops->pointer;
 885         soc_pcm_ops.ioctl = socdev->platform->pcm_ops->ioctl;
 886         soc_pcm_ops.copy = socdev->platform->pcm_ops->copy;
 887         soc_pcm_ops.silence = socdev->platform->pcm_ops->silence;
 888         soc_pcm_ops.ack = socdev->platform->pcm_ops->ack;
 889         soc_pcm_ops.page = socdev->platform->pcm_ops->page;
 890
 891         if (playback)
 892                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &soc_pcm_ops);
 893
 894         if (capture)
 895                 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &soc_pcm_ops);
 896
 897         ret = socdev->platform->pcm_new(codec->card, codec_dai, pcm);
 898         if (ret < 0) {
 899                 printk(KERN_ERR "asoc: platform pcm constructor failed\n");
 900                 kfree(rtd);
 901                 return ret;
 902         }
 903
 904         pcm->private_free = socdev->platform->pcm_free;
 905         printk(KERN_INFO "asoc: %s <-> %s mapping ok\n", codec_dai->name,
 906                 cpu_dai->name);
 907         return ret;
 908 }
 909
 910 /* codec register dump */
 911 static ssize_t codec_reg_show(struct device *dev,
 912         struct device_attribute *attr, char *buf)
 913 {
 914         struct snd_soc_device *devdata = dev_get_drvdata(dev);
 915         struct snd_soc_codec *codec = devdata->codec;
 916         int i, step = 1, count = 0;
 917
 918         if (!codec->reg_cache_size)
 919                 return 0;
 920
 921         if (codec->reg_cache_step)
 922                 step = codec->reg_cache_step;
 923
 924         count += sprintf(buf, "%s registers\n", codec->name);
 925         for(i = 0; i < codec->reg_cache_size; i += step)
 926                 count += sprintf(buf + count, "%2x: %4x\n", i, codec->read(codec, i));
 927
 928         return count;
 929 }
 930 static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
 931
 932 /**
 933  * snd_soc_new_ac97_codec - initailise AC97 device
 934  * @codec: audio codec
 935  * @ops: AC97 bus operations
 936  * @num: AC97 codec number
 937  *
 938  * Initialises AC97 codec resources for use by ad-hoc devices only.
 939  */
 940 int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
 941         struct snd_ac97_bus_ops *ops, int num)
 942 {
 943         mutex_lock(&codec->mutex);
 944
 945         codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
 946         if (codec->ac97 == NULL) {
 947                 mutex_unlock(&codec->mutex);
 948                 return -ENOMEM;
 949         }
 950
 951         codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
 952         if (codec->ac97->bus == NULL) {
 953                 kfree(codec->ac97);
 954                 codec->ac97 = NULL;
 955                 mutex_unlock(&codec->mutex);
 956                 return -ENOMEM;
 957         }
 958
 959         codec->ac97->bus->ops = ops;
 960         codec->ac97->num = num;
 961         mutex_unlock(&codec->mutex);
 962         return 0;
 963 }
 964 EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
 965
 966 /**
 967  * snd_soc_free_ac97_codec - free AC97 codec device
 968  * @codec: audio codec
 969  *
 970  * Frees AC97 codec device resources.
 971  */
 972 void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
 973 {
 974         mutex_lock(&codec->mutex);
 975         kfree(codec->ac97->bus);
 976         kfree(codec->ac97);
 977         codec->ac97 = NULL;
 978         mutex_unlock(&codec->mutex);
 979 }
 980 EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
 981
 982 /**
 983  * snd_soc_update_bits - update codec register bits
 984  * @codec: audio codec
 985  * @reg: codec register
 986  * @mask: register mask
 987  * @value: new value
 988  *
 989  * Writes new register value.
 990  *
 991  * Returns 1 for change else 0.
 992  */
 993 int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
 994                                 unsigned short mask, unsigned short value)
 995 {
 996         int change;
 997         unsigned short old, new;
 998
 999         mutex_lock(&io_mutex);
1000         old = snd_soc_read(codec, reg);
1001         new = (old & ~mask) | value;
1002         change = old != new;
1003         if (change)
1004                 snd_soc_write(codec, reg, new);
1005
1006         mutex_unlock(&io_mutex);
1007         return change;
1008 }
1009 EXPORT_SYMBOL_GPL(snd_soc_update_bits);
1010
1011 /**
1012  * snd_soc_test_bits - test register for change
1013  * @codec: audio codec
1014  * @reg: codec register
1015  * @mask: register mask
1016  * @value: new value
1017  *
1018  * Tests a register with a new value and checks if the new value is
1019  * different from the old value.
1020  *
1021  * Returns 1 for change else 0.
1022  */
1023 int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
1024                                 unsigned short mask, unsigned short value)
1025 {
1026         int change;
1027         unsigned short old, new;
1028
1029         mutex_lock(&io_mutex);
1030         old = snd_soc_read(codec, reg);
1031         new = (old & ~mask) | value;
1032         change = old != new;
1033         mutex_unlock(&io_mutex);
1034
1035         return change;
1036 }
1037 EXPORT_SYMBOL_GPL(snd_soc_test_bits);
1038
1039 /**
1040  * snd_soc_new_pcms - create new sound card and pcms
1041  * @socdev: the SoC audio device
1042  *
1043  * Create a new sound card based upon the codec and interface pcms.
1044  *
1045  * Returns 0 for success, else error.
1046  */
1047 int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid)
1048 {
1049         struct snd_soc_codec *codec = socdev->codec;
1050         struct snd_soc_machine *machine = socdev->machine;
1051         int ret = 0, i;
1052
1053         mutex_lock(&codec->mutex);
1054
1055         /* register a sound card */
1056         codec->card = snd_card_new(idx, xid, codec->owner, 0);
1057         if (!codec->card) {
1058                 printk(KERN_ERR "asoc: can't create sound card for codec %s\n",
1059                         codec->name);
1060                 mutex_unlock(&codec->mutex);
1061                 return -ENODEV;
1062         }
1063
1064         codec->card->dev = socdev->dev;
1065         codec->card->private_data = codec;
1066         strncpy(codec->card->driver, codec->name, sizeof(codec->card->driver));
1067
1068         /* create the pcms */
1069         for(i = 0; i < machine->num_links; i++) {
1070                 ret = soc_new_pcm(socdev, &machine->dai_link[i], i);
1071                 if (ret < 0) {
1072                         printk(KERN_ERR "asoc: can't create pcm %s\n",
1073                                 machine->dai_link[i].stream_name);
1074                         mutex_unlock(&codec->mutex);
1075                         return ret;
1076                 }
1077         }
1078
1079         mutex_unlock(&codec->mutex);
1080         return ret;
1081 }
1082 EXPORT_SYMBOL_GPL(snd_soc_new_pcms);
1083
1084 /**
1085  * snd_soc_register_card - register sound card
1086  * @socdev: the SoC audio device
1087  *
1088  * Register a SoC sound card. Also registers an AC97 device if the
1089  * codec is AC97 for ad hoc devices.
1090  *
1091  * Returns 0 for success, else error.
1092  */
1093 int snd_soc_register_card(struct snd_soc_device *socdev)
1094 {
1095         struct snd_soc_codec *codec = socdev->codec;
1096         struct snd_soc_machine *machine = socdev->machine;
1097         int ret = 0, i, ac97 = 0, err = 0;
1098
1099         mutex_lock(&codec->mutex);
1100         for(i = 0; i < machine->num_links; i++) {
1101                 if (socdev->machine->dai_link[i].init) {
1102                         err = socdev->machine->dai_link[i].init(codec);
1103                         if (err < 0) {
1104                                 printk(KERN_ERR "asoc: failed to init %s\n",
1105                                         socdev->machine->dai_link[i].stream_name);
1106                                 continue;
1107                         }
1108                 }
1109                 if (socdev->machine->dai_link[i].codec_dai->type ==
1110                         SND_SOC_DAI_AC97_BUS)
1111                         ac97 = 1;
1112         }
1113         snprintf(codec->card->shortname, sizeof(codec->card->shortname),
1114                  "%s", machine->name);
1115         snprintf(codec->card->longname, sizeof(codec->card->longname),
1116                  "%s (%s)", machine->name, codec->name);
1117
1118         ret = snd_card_register(codec->card);
1119         if (ret < 0) {
1120                 printk(KERN_ERR "asoc: failed to register soundcard for codec %s\n",
1121                                 codec->name);
1122                 goto out;
1123         }
1124
1125 #ifdef CONFIG_SND_SOC_AC97_BUS
1126         if (ac97) {
1127                 ret = soc_ac97_dev_register(codec);
1128                 if (ret < 0) {
1129                         printk(KERN_ERR "asoc: AC97 device register failed\n");
1130                         snd_card_free(codec->card);
1131                         goto out;
1132                 }
1133         }
1134 #endif
1135
1136         err = snd_soc_dapm_sys_add(socdev->dev);
1137         if (err < 0)
1138                 printk(KERN_WARNING "asoc: failed to add dapm sysfs entries\n");
1139
1140         err = device_create_file(socdev->dev, &dev_attr_codec_reg);
1141         if (err < 0)
1142                 printk(KERN_WARNING "asoc: failed to add codec sysfs entries\n");
1143 out:
1144         mutex_unlock(&codec->mutex);
1145         return ret;
1146 }
1147 EXPORT_SYMBOL_GPL(snd_soc_register_card);
1148
1149 /**
1150  * snd_soc_free_pcms - free sound card and pcms
1151  * @socdev: the SoC audio device
1152  *
1153  * Frees sound card and pcms associated with the socdev.
1154  * Also unregister the codec if it is an AC97 device.
1155  */
1156 void snd_soc_free_pcms(struct snd_soc_device *socdev)
1157 {
1158         struct snd_soc_codec *codec = socdev->codec;
1159 #ifdef CONFIG_SND_SOC_AC97_BUS
1160         struct snd_soc_codec_dai *codec_dai;
1161         int i;
1162 #endif
1163
1164         mutex_lock(&codec->mutex);
1165 #ifdef CONFIG_SND_SOC_AC97_BUS
1166         for(i = 0; i < codec->num_dai; i++) {
1167                 codec_dai = &codec->dai[i];
1168                 if (codec_dai->type == SND_SOC_DAI_AC97_BUS && codec->ac97) {
1169                         soc_ac97_dev_unregister(codec);
1170                         goto free_card;
1171                 }
1172         }
1173 free_card:
1174 #endif
1175
1176         if (codec->card)
1177                 snd_card_free(codec->card);
1178         device_remove_file(socdev->dev, &dev_attr_codec_reg);
1179         mutex_unlock(&codec->mutex);
1180 }
1181 EXPORT_SYMBOL_GPL(snd_soc_free_pcms);
1182
1183 /**
1184  * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
1185  * @substream: the pcm substream
1186  * @hw: the hardware parameters
1187  *
1188  * Sets the substream runtime hardware parameters.
1189  */
1190 int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
1191         const struct snd_pcm_hardware *hw)
1192 {
1193         struct snd_pcm_runtime *runtime = substream->runtime;
1194         runtime->hw.info = hw->info;
1195         runtime->hw.formats = hw->formats;
1196         runtime->hw.period_bytes_min = hw->period_bytes_min;
1197         runtime->hw.period_bytes_max = hw->period_bytes_max;
1198         runtime->hw.periods_min = hw->periods_min;
1199         runtime->hw.periods_max = hw->periods_max;
1200         runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
1201         runtime->hw.fifo_size = hw->fifo_size;
1202         return 0;
1203 }
1204 EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
1205
1206 /**
1207  * snd_soc_cnew - create new control
1208  * @_template: control template
1209  * @data: control private data
1210  * @lnng_name: control long name
1211  *
1212  * Create a new mixer control from a template control.
1213  *
1214  * Returns 0 for success, else error.
1215  */
1216 struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
1217         void *data, char *long_name)
1218 {
1219         struct snd_kcontrol_new template;
1220
1221         memcpy(&template, _template, sizeof(template));
1222         if (long_name)
1223                 template.name = long_name;
1224         template.index = 0;
1225
1226         return snd_ctl_new1(&template, data);
1227 }
1228 EXPORT_SYMBOL_GPL(snd_soc_cnew);
1229
1230 /**
1231  * snd_soc_info_enum_double - enumerated double mixer info callback
1232  * @kcontrol: mixer control
1233  * @uinfo: control element information
1234  *
1235  * Callback to provide information about a double enumerated
1236  * mixer control.
1237  *
1238  * Returns 0 for success.
1239  */
1240 int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
1241         struct snd_ctl_elem_info *uinfo)
1242 {
1243         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1244
1245         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1246         uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
1247         uinfo->value.enumerated.items = e->mask;
1248
1249         if (uinfo->value.enumerated.item > e->mask - 1)
1250                 uinfo->value.enumerated.item = e->mask - 1;
1251         strcpy(uinfo->value.enumerated.name,
1252                 e->texts[uinfo->value.enumerated.item]);
1253         return 0;
1254 }
1255 EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
1256
1257 /**
1258  * snd_soc_get_enum_double - enumerated double mixer get callback
1259  * @kcontrol: mixer control
1260  * @uinfo: control element information
1261  *
1262  * Callback to get the value of a double enumerated mixer.
1263  *
1264  * Returns 0 for success.
1265  */
1266 int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
1267         struct snd_ctl_elem_value *ucontrol)
1268 {
1269         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1270         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1271         unsigned short val, bitmask;
1272
1273         for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1274                 ;
1275         val = snd_soc_read(codec, e->reg);
1276         ucontrol->value.enumerated.item[0] = (val >> e->shift_l) & (bitmask - 1);
1277         if (e->shift_l != e->shift_r)
1278                 ucontrol->value.enumerated.item[1] =
1279                         (val >> e->shift_r) & (bitmask - 1);
1280
1281         return 0;
1282 }
1283 EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
1284
1285 /**
1286  * snd_soc_put_enum_double - enumerated double mixer put callback
1287  * @kcontrol: mixer control
1288  * @uinfo: control element information
1289  *
1290  * Callback to set the value of a double enumerated mixer.
1291  *
1292  * Returns 0 for success.
1293  */
1294 int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
1295         struct snd_ctl_elem_value *ucontrol)
1296 {
1297         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1298         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1299         unsigned short val;
1300         unsigned short mask, bitmask;
1301
1302         for (bitmask = 1; bitmask < e->mask; bitmask <<= 1)
1303                 ;
1304         if (ucontrol->value.enumerated.item[0] > e->mask - 1)
1305                 return -EINVAL;
1306         val = ucontrol->value.enumerated.item[0] << e->shift_l;
1307         mask = (bitmask - 1) << e->shift_l;
1308         if (e->shift_l != e->shift_r) {
1309                 if (ucontrol->value.enumerated.item[1] > e->mask - 1)
1310                         return -EINVAL;
1311                 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1312                 mask |= (bitmask - 1) << e->shift_r;
1313         }
1314
1315         return snd_soc_update_bits(codec, e->reg, mask, val);
1316 }
1317 EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
1318
1319 /**
1320  * snd_soc_info_enum_ext - external enumerated single mixer info callback
1321  * @kcontrol: mixer control
1322  * @uinfo: control element information
1323  *
1324  * Callback to provide information about an external enumerated
1325  * single mixer.
1326  *
1327  * Returns 0 for success.
1328  */
1329 int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
1330         struct snd_ctl_elem_info *uinfo)
1331 {
1332         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1333
1334         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1335         uinfo->count = 1;
1336         uinfo->value.enumerated.items = e->mask;
1337
1338         if (uinfo->value.enumerated.item > e->mask - 1)
1339                 uinfo->value.enumerated.item = e->mask - 1;
1340         strcpy(uinfo->value.enumerated.name,
1341                 e->texts[uinfo->value.enumerated.item]);
1342         return 0;
1343 }
1344 EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
1345
1346 /**
1347  * snd_soc_info_volsw_ext - external single mixer info callback
1348  * @kcontrol: mixer control
1349  * @uinfo: control element information
1350  *
1351  * Callback to provide information about a single external mixer control.
1352  *
1353  * Returns 0 for success.
1354  */
1355 int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
1356         struct snd_ctl_elem_info *uinfo)
1357 {
1358         int max = kcontrol->private_value;
1359
1360         if (max == 1)
1361                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1362         else
1363                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1364
1365         uinfo->count = 1;
1366         uinfo->value.integer.min = 0;
1367         uinfo->value.integer.max = max;
1368         return 0;
1369 }
1370 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
1371
1372 /**
1373  * snd_soc_info_volsw - single mixer info callback
1374  * @kcontrol: mixer control
1375  * @uinfo: control element information
1376  *
1377  * Callback to provide information about a single mixer control.
1378  *
1379  * Returns 0 for success.
1380  */
1381 int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
1382         struct snd_ctl_elem_info *uinfo)
1383 {
1384         int max = (kcontrol->private_value >> 16) & 0xff;
1385         int shift = (kcontrol->private_value >> 8) & 0x0f;
1386         int rshift = (kcontrol->private_value >> 12) & 0x0f;
1387
1388         if (max == 1)
1389                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1390         else
1391                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1392
1393         uinfo->count = shift == rshift ? 1 : 2;
1394         uinfo->value.integer.min = 0;
1395         uinfo->value.integer.max = max;
1396         return 0;
1397 }
1398 EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
1399
1400 /**
1401  * snd_soc_get_volsw - single mixer get callback
1402  * @kcontrol: mixer control
1403  * @uinfo: control element information
1404  *
1405  * Callback to get the value of a single mixer control.
1406  *
1407  * Returns 0 for success.
1408  */
1409 int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
1410         struct snd_ctl_elem_value *ucontrol)
1411 {
1412         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1413         int reg = kcontrol->private_value & 0xff;
1414         int shift = (kcontrol->private_value >> 8) & 0x0f;
1415         int rshift = (kcontrol->private_value >> 12) & 0x0f;
1416         int max = (kcontrol->private_value >> 16) & 0xff;
1417         int mask = (1 << fls(max)) - 1;
1418         int invert = (kcontrol->private_value >> 24) & 0x01;
1419
1420         ucontrol->value.integer.value[0] =
1421                 (snd_soc_read(codec, reg) >> shift) & mask;
1422         if (shift != rshift)
1423                 ucontrol->value.integer.value[1] =
1424                         (snd_soc_read(codec, reg) >> rshift) & mask;
1425         if (invert) {
1426                 ucontrol->value.integer.value[0] =
1427                         max - ucontrol->value.integer.value[0];
1428                 if (shift != rshift)
1429                         ucontrol->value.integer.value[1] =
1430                                 max - ucontrol->value.integer.value[1];
1431         }
1432
1433         return 0;
1434 }
1435 EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
1436
1437 /**
1438  * snd_soc_put_volsw - single mixer put callback
1439  * @kcontrol: mixer control
1440  * @uinfo: control element information
1441  *
1442  * Callback to set the value of a single mixer control.
1443  *
1444  * Returns 0 for success.
1445  */
1446 int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
1447         struct snd_ctl_elem_value *ucontrol)
1448 {
1449         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1450         int reg = kcontrol->private_value & 0xff;
1451         int shift = (kcontrol->private_value >> 8) & 0x0f;
1452         int rshift = (kcontrol->private_value >> 12) & 0x0f;
1453         int max = (kcontrol->private_value >> 16) & 0xff;
1454         int mask = (1 << fls(max)) - 1;
1455         int invert = (kcontrol->private_value >> 24) & 0x01;
1456         unsigned short val, val2, val_mask;
1457
1458         val = (ucontrol->value.integer.value[0] & mask);
1459         if (invert)
1460                 val = max - val;
1461         val_mask = mask << shift;
1462         val = val << shift;
1463         if (shift != rshift) {
1464                 val2 = (ucontrol->value.integer.value[1] & mask);
1465                 if (invert)
1466                         val2 = max - val2;
1467                 val_mask |= mask << rshift;
1468                 val |= val2 << rshift;
1469         }
1470         return snd_soc_update_bits(codec, reg, val_mask, val);
1471 }
1472 EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
1473
1474 /**
1475  * snd_soc_info_volsw_2r - double mixer info callback
1476  * @kcontrol: mixer control
1477  * @uinfo: control element information
1478  *
1479  * Callback to provide information about a double mixer control that
1480  * spans 2 codec registers.
1481  *
1482  * Returns 0 for success.
1483  */
1484 int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
1485         struct snd_ctl_elem_info *uinfo)
1486 {
1487         int max = (kcontrol->private_value >> 12) & 0xff;
1488
1489         if (max == 1)
1490                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1491         else
1492                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1493
1494         uinfo->count = 2;
1495         uinfo->value.integer.min = 0;
1496         uinfo->value.integer.max = max;
1497         return 0;
1498 }
1499 EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r);
1500
1501 /**
1502  * snd_soc_get_volsw_2r - double mixer get callback
1503  * @kcontrol: mixer control
1504  * @uinfo: control element information
1505  *
1506  * Callback to get the value of a double mixer control that spans 2 registers.
1507  *
1508  * Returns 0 for success.
1509  */
1510 int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
1511         struct snd_ctl_elem_value *ucontrol)
1512 {
1513         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1514         int reg = kcontrol->private_value & 0xff;
1515         int reg2 = (kcontrol->private_value >> 24) & 0xff;
1516         int shift = (kcontrol->private_value >> 8) & 0x0f;
1517         int max = (kcontrol->private_value >> 12) & 0xff;
1518         int mask = (1<<fls(max))-1;
1519         int invert = (kcontrol->private_value >> 20) & 0x01;
1520
1521         ucontrol->value.integer.value[0] =
1522                 (snd_soc_read(codec, reg) >> shift) & mask;
1523         ucontrol->value.integer.value[1] =
1524                 (snd_soc_read(codec, reg2) >> shift) & mask;
1525         if (invert) {
1526                 ucontrol->value.integer.value[0] =
1527                         max - ucontrol->value.integer.value[0];
1528                 ucontrol->value.integer.value[1] =
1529                         max - ucontrol->value.integer.value[1];
1530         }
1531
1532         return 0;
1533 }
1534 EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r);
1535
1536 /**
1537  * snd_soc_put_volsw_2r - double mixer set callback
1538  * @kcontrol: mixer control
1539  * @uinfo: control element information
1540  *
1541  * Callback to set the value of a double mixer control that spans 2 registers.
1542  *
1543  * Returns 0 for success.
1544  */
1545 int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
1546         struct snd_ctl_elem_value *ucontrol)
1547 {
1548         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1549         int reg = kcontrol->private_value & 0xff;
1550         int reg2 = (kcontrol->private_value >> 24) & 0xff;
1551         int shift = (kcontrol->private_value >> 8) & 0x0f;
1552         int max = (kcontrol->private_value >> 12) & 0xff;
1553         int mask = (1 << fls(max)) - 1;
1554         int invert = (kcontrol->private_value >> 20) & 0x01;
1555         int err;
1556         unsigned short val, val2, val_mask;
1557
1558         val_mask = mask << shift;
1559         val = (ucontrol->value.integer.value[0] & mask);
1560         val2 = (ucontrol->value.integer.value[1] & mask);
1561
1562         if (invert) {
1563                 val = max - val;
1564                 val2 = max - val2;
1565         }
1566
1567         val = val << shift;
1568         val2 = val2 << shift;
1569
1570         if ((err = snd_soc_update_bits(codec, reg, val_mask, val)) < 0)
1571                 return err;
1572
1573         err = snd_soc_update_bits(codec, reg2, val_mask, val2);
1574         return err;
1575 }
1576 EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r);
1577
1578 static int __devinit snd_soc_init(void)
1579 {
1580         printk(KERN_INFO "ASoC version %s\n", SND_SOC_VERSION);
1581         return platform_driver_register(&soc_driver);
1582 }
1583
1584 static void snd_soc_exit(void)
1585 {
1586         platform_driver_unregister(&soc_driver);
1587 }
1588
1589 module_init(snd_soc_init);
1590 module_exit(snd_soc_exit);
1591
1592 /* Module information */
1593 MODULE_AUTHOR("Liam Girdwood, liam.girdwood@wolfsonmicro.com, www.wolfsonmicro.com");
1594 MODULE_DESCRIPTION("ALSA SoC Core");
1595 MODULE_LICENSE("GPL");