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