blob: 0a6440c6f54a80a9af52aa10ffe9d898fe5c456d [file] [log] [blame]
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001/*
2 * soc-core.c -- ALSA SoC Audio Layer
3 *
4 * Copyright 2005 Wolfson Microelectronics PLC.
Liam Girdwood0664d882006-12-18 14:39:02 +01005 * Copyright 2005 Openedhand Ltd.
6 *
Liam Girdwoodd3311242008-10-12 13:17:36 +01007 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
Liam Girdwood0664d882006-12-18 14:39:02 +01008 * with code, comments and ideas from :-
9 * Richard Purdie <richard@openedhand.com>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020010 *
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
15 *
Frank Mandarinodb2a4162006-10-06 18:31:09 +020016 * TODO:
17 * o Add hw rules to enforce rates, etc.
18 * o More testing with other codecs/machines.
19 * o Add more codecs and platforms to ensure good API coverage.
20 * o Support TDM on PCM and I2S
21 */
22
23#include <linux/module.h>
24#include <linux/moduleparam.h>
25#include <linux/init.h>
26#include <linux/delay.h>
27#include <linux/pm.h>
28#include <linux/bitops.h>
Troy Kisky12ef1932008-10-13 17:42:14 -070029#include <linux/debugfs.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020030#include <linux/platform_device.h>
Marek Vasut474828a2009-07-22 13:01:03 +020031#include <sound/ac97_codec.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020032#include <sound/core.h>
33#include <sound/pcm.h>
34#include <sound/pcm_params.h>
35#include <sound/soc.h>
36#include <sound/soc-dapm.h>
37#include <sound/initval.h>
38
Frank Mandarinodb2a4162006-10-06 18:31:09 +020039static DEFINE_MUTEX(pcm_mutex);
Frank Mandarinodb2a4162006-10-06 18:31:09 +020040static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
41
Mark Brown384c89e2008-12-03 17:34:03 +000042#ifdef CONFIG_DEBUG_FS
43static struct dentry *debugfs_root;
44#endif
45
Mark Brownc5af3a22008-11-28 13:29:45 +000046static DEFINE_MUTEX(client_mutex);
47static LIST_HEAD(card_list);
Mark Brown91151712008-11-30 23:31:24 +000048static LIST_HEAD(dai_list);
Mark Brown12a48a8c2008-12-03 19:40:30 +000049static LIST_HEAD(platform_list);
Mark Brown0d0cf002008-12-10 14:32:45 +000050static LIST_HEAD(codec_list);
Mark Brownc5af3a22008-11-28 13:29:45 +000051
52static int snd_soc_register_card(struct snd_soc_card *card);
53static int snd_soc_unregister_card(struct snd_soc_card *card);
54
Frank Mandarinodb2a4162006-10-06 18:31:09 +020055/*
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 */
60static int pmdown_time = 5000;
61module_param(pmdown_time, int, 0);
62MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
63
Liam Girdwood965ac422007-01-31 14:14:57 +010064/*
65 * This function forces any delayed work to be queued and run.
66 */
67static 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
Mark Brown2624d5f2009-11-03 21:56:13 +000083/* codec register dump */
84static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf)
85{
86 int i, step = 1, count = 0;
87
88 if (!codec->reg_cache_size)
89 return 0;
90
91 if (codec->reg_cache_step)
92 step = codec->reg_cache_step;
93
94 count += sprintf(buf, "%s registers\n", codec->name);
95 for (i = 0; i < codec->reg_cache_size; i += step) {
96 if (codec->readable_register && !codec->readable_register(i))
97 continue;
98
99 count += sprintf(buf + count, "%2x: ", i);
100 if (count >= PAGE_SIZE - 1)
101 break;
102
103 if (codec->display_register)
104 count += codec->display_register(codec, buf + count,
105 PAGE_SIZE - count, i);
106 else
107 count += snprintf(buf + count, PAGE_SIZE - count,
108 "%4x", codec->read(codec, i));
109
110 if (count >= PAGE_SIZE - 1)
111 break;
112
113 count += snprintf(buf + count, PAGE_SIZE - count, "\n");
114 if (count >= PAGE_SIZE - 1)
115 break;
116 }
117
118 /* Truncate count; min() would cause a warning */
119 if (count >= PAGE_SIZE)
120 count = PAGE_SIZE - 1;
121
122 return count;
123}
124static ssize_t codec_reg_show(struct device *dev,
125 struct device_attribute *attr, char *buf)
126{
127 struct snd_soc_device *devdata = dev_get_drvdata(dev);
128 return soc_codec_reg_show(devdata->card->codec, buf);
129}
130
131static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
132
133#ifdef CONFIG_DEBUG_FS
134static int codec_reg_open_file(struct inode *inode, struct file *file)
135{
136 file->private_data = inode->i_private;
137 return 0;
138}
139
140static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
141 size_t count, loff_t *ppos)
142{
143 ssize_t ret;
144 struct snd_soc_codec *codec = file->private_data;
145 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
146 if (!buf)
147 return -ENOMEM;
148 ret = soc_codec_reg_show(codec, buf);
149 if (ret >= 0)
150 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
151 kfree(buf);
152 return ret;
153}
154
155static ssize_t codec_reg_write_file(struct file *file,
156 const char __user *user_buf, size_t count, loff_t *ppos)
157{
158 char buf[32];
159 int buf_size;
160 char *start = buf;
161 unsigned long reg, value;
162 int step = 1;
163 struct snd_soc_codec *codec = file->private_data;
164
165 buf_size = min(count, (sizeof(buf)-1));
166 if (copy_from_user(buf, user_buf, buf_size))
167 return -EFAULT;
168 buf[buf_size] = 0;
169
170 if (codec->reg_cache_step)
171 step = codec->reg_cache_step;
172
173 while (*start == ' ')
174 start++;
175 reg = simple_strtoul(start, &start, 16);
176 if ((reg >= codec->reg_cache_size) || (reg % step))
177 return -EINVAL;
178 while (*start == ' ')
179 start++;
180 if (strict_strtoul(start, 16, &value))
181 return -EINVAL;
182 codec->write(codec, reg, value);
183 return buf_size;
184}
185
186static const struct file_operations codec_reg_fops = {
187 .open = codec_reg_open_file,
188 .read = codec_reg_read_file,
189 .write = codec_reg_write_file,
190};
191
192static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
193{
194 char codec_root[128];
195
196 if (codec->dev)
197 snprintf(codec_root, sizeof(codec_root),
198 "%s.%s", codec->name, dev_name(codec->dev));
199 else
200 snprintf(codec_root, sizeof(codec_root),
201 "%s", codec->name);
202
203 codec->debugfs_codec_root = debugfs_create_dir(codec_root,
204 debugfs_root);
205 if (!codec->debugfs_codec_root) {
206 printk(KERN_WARNING
207 "ASoC: Failed to create codec debugfs directory\n");
208 return;
209 }
210
211 codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
212 codec->debugfs_codec_root,
213 codec, &codec_reg_fops);
214 if (!codec->debugfs_reg)
215 printk(KERN_WARNING
216 "ASoC: Failed to create codec register debugfs file\n");
217
218 codec->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0744,
219 codec->debugfs_codec_root,
220 &codec->pop_time);
221 if (!codec->debugfs_pop_time)
222 printk(KERN_WARNING
223 "Failed to create pop time debugfs file\n");
224
225 codec->debugfs_dapm = debugfs_create_dir("dapm",
226 codec->debugfs_codec_root);
227 if (!codec->debugfs_dapm)
228 printk(KERN_WARNING
229 "Failed to create DAPM debugfs directory\n");
230
231 snd_soc_dapm_debugfs_init(codec);
232}
233
234static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
235{
236 debugfs_remove_recursive(codec->debugfs_codec_root);
237}
238
239#else
240
241static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
242{
243}
244
245static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
246{
247}
248#endif
249
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200250#ifdef CONFIG_SND_SOC_AC97_BUS
251/* unregister ac97 codec */
252static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
253{
254 if (codec->ac97->dev.bus)
255 device_unregister(&codec->ac97->dev);
256 return 0;
257}
258
259/* stop no dev release warning */
260static void soc_ac97_device_release(struct device *dev){}
261
262/* register ac97 codec to bus */
263static int soc_ac97_dev_register(struct snd_soc_codec *codec)
264{
265 int err;
266
267 codec->ac97->dev.bus = &ac97_bus_type;
Mark Brown4ac5c612009-04-01 19:35:01 +0100268 codec->ac97->dev.parent = codec->card->dev;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200269 codec->ac97->dev.release = soc_ac97_device_release;
270
Kay Sieversbb072bf2008-11-02 03:50:35 +0100271 dev_set_name(&codec->ac97->dev, "%d-%d:%s",
272 codec->card->number, 0, codec->name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200273 err = device_register(&codec->ac97->dev);
274 if (err < 0) {
275 snd_printk(KERN_ERR "Can't register ac97 bus\n");
276 codec->ac97->dev.bus = NULL;
277 return err;
278 }
279 return 0;
280}
281#endif
282
Mark Brown06f409d2009-04-07 18:10:13 +0100283static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream)
284{
285 struct snd_soc_pcm_runtime *rtd = substream->private_data;
286 struct snd_soc_device *socdev = rtd->socdev;
287 struct snd_soc_card *card = socdev->card;
288 struct snd_soc_dai_link *machine = rtd->dai;
289 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
290 struct snd_soc_dai *codec_dai = machine->codec_dai;
291 int ret;
292
293 if (codec_dai->symmetric_rates || cpu_dai->symmetric_rates ||
294 machine->symmetric_rates) {
295 dev_dbg(card->dev, "Symmetry forces %dHz rate\n",
296 machine->rate);
297
298 ret = snd_pcm_hw_constraint_minmax(substream->runtime,
299 SNDRV_PCM_HW_PARAM_RATE,
300 machine->rate,
301 machine->rate);
302 if (ret < 0) {
303 dev_err(card->dev,
304 "Unable to apply rate symmetry constraint: %d\n", ret);
305 return ret;
306 }
307 }
308
309 return 0;
310}
311
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200312/*
313 * Called by ALSA when a PCM substream is opened, the runtime->hw record is
314 * then initialized and any private data can be allocated. This also calls
315 * startup for the cpu DAI, platform, machine and codec DAI.
316 */
317static int soc_pcm_open(struct snd_pcm_substream *substream)
318{
319 struct snd_soc_pcm_runtime *rtd = substream->private_data;
320 struct snd_soc_device *socdev = rtd->socdev;
Mark Brown87689d52008-12-02 16:01:14 +0000321 struct snd_soc_card *card = socdev->card;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200322 struct snd_pcm_runtime *runtime = substream->runtime;
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100323 struct snd_soc_dai_link *machine = rtd->dai;
Mark Brown87689d52008-12-02 16:01:14 +0000324 struct snd_soc_platform *platform = card->platform;
Liam Girdwood3c4b2662008-07-07 16:07:17 +0100325 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
326 struct snd_soc_dai *codec_dai = machine->codec_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200327 int ret = 0;
328
329 mutex_lock(&pcm_mutex);
330
331 /* startup the audio subsystem */
Eric Miao6335d052009-03-03 09:41:00 +0800332 if (cpu_dai->ops->startup) {
333 ret = cpu_dai->ops->startup(substream, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200334 if (ret < 0) {
335 printk(KERN_ERR "asoc: can't open interface %s\n",
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100336 cpu_dai->name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200337 goto out;
338 }
339 }
340
341 if (platform->pcm_ops->open) {
342 ret = platform->pcm_ops->open(substream);
343 if (ret < 0) {
344 printk(KERN_ERR "asoc: can't open platform %s\n", platform->name);
345 goto platform_err;
346 }
347 }
348
Eric Miao6335d052009-03-03 09:41:00 +0800349 if (codec_dai->ops->startup) {
350 ret = codec_dai->ops->startup(substream, codec_dai);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100351 if (ret < 0) {
352 printk(KERN_ERR "asoc: can't open codec %s\n",
353 codec_dai->name);
354 goto codec_dai_err;
355 }
356 }
357
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200358 if (machine->ops && machine->ops->startup) {
359 ret = machine->ops->startup(substream);
360 if (ret < 0) {
361 printk(KERN_ERR "asoc: %s startup failed\n", machine->name);
362 goto machine_err;
363 }
364 }
365
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200366 /* Check that the codec and cpu DAI's are compatible */
367 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
368 runtime->hw.rate_min =
Mark Brown3ff3f642008-05-19 12:32:25 +0200369 max(codec_dai->playback.rate_min,
370 cpu_dai->playback.rate_min);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200371 runtime->hw.rate_max =
Mark Brown3ff3f642008-05-19 12:32:25 +0200372 min(codec_dai->playback.rate_max,
373 cpu_dai->playback.rate_max);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200374 runtime->hw.channels_min =
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100375 max(codec_dai->playback.channels_min,
376 cpu_dai->playback.channels_min);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200377 runtime->hw.channels_max =
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100378 min(codec_dai->playback.channels_max,
379 cpu_dai->playback.channels_max);
380 runtime->hw.formats =
381 codec_dai->playback.formats & cpu_dai->playback.formats;
382 runtime->hw.rates =
383 codec_dai->playback.rates & cpu_dai->playback.rates;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200384 } else {
385 runtime->hw.rate_min =
Mark Brown3ff3f642008-05-19 12:32:25 +0200386 max(codec_dai->capture.rate_min,
387 cpu_dai->capture.rate_min);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200388 runtime->hw.rate_max =
Mark Brown3ff3f642008-05-19 12:32:25 +0200389 min(codec_dai->capture.rate_max,
390 cpu_dai->capture.rate_max);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200391 runtime->hw.channels_min =
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100392 max(codec_dai->capture.channels_min,
393 cpu_dai->capture.channels_min);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200394 runtime->hw.channels_max =
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100395 min(codec_dai->capture.channels_max,
396 cpu_dai->capture.channels_max);
397 runtime->hw.formats =
398 codec_dai->capture.formats & cpu_dai->capture.formats;
399 runtime->hw.rates =
400 codec_dai->capture.rates & cpu_dai->capture.rates;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200401 }
402
403 snd_pcm_limit_hw_rates(runtime);
404 if (!runtime->hw.rates) {
405 printk(KERN_ERR "asoc: %s <-> %s No matching rates\n",
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100406 codec_dai->name, cpu_dai->name);
407 goto machine_err;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200408 }
409 if (!runtime->hw.formats) {
410 printk(KERN_ERR "asoc: %s <-> %s No matching formats\n",
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100411 codec_dai->name, cpu_dai->name);
412 goto machine_err;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200413 }
414 if (!runtime->hw.channels_min || !runtime->hw.channels_max) {
415 printk(KERN_ERR "asoc: %s <-> %s No matching channels\n",
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100416 codec_dai->name, cpu_dai->name);
417 goto machine_err;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200418 }
419
Mark Brown06f409d2009-04-07 18:10:13 +0100420 /* Symmetry only applies if we've already got an active stream. */
421 if (cpu_dai->active || codec_dai->active) {
422 ret = soc_pcm_apply_symmetry(substream);
423 if (ret != 0)
424 goto machine_err;
425 }
426
Mark Brownf24368c2008-10-21 21:45:08 +0100427 pr_debug("asoc: %s <-> %s info:\n", codec_dai->name, cpu_dai->name);
428 pr_debug("asoc: rate mask 0x%x\n", runtime->hw.rates);
429 pr_debug("asoc: min ch %d max ch %d\n", runtime->hw.channels_min,
430 runtime->hw.channels_max);
431 pr_debug("asoc: min rate %d max rate %d\n", runtime->hw.rate_min,
432 runtime->hw.rate_max);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200433
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200434 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100435 cpu_dai->playback.active = codec_dai->playback.active = 1;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200436 else
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100437 cpu_dai->capture.active = codec_dai->capture.active = 1;
438 cpu_dai->active = codec_dai->active = 1;
439 cpu_dai->runtime = runtime;
Mark Brown6627a652009-01-23 22:55:23 +0000440 card->codec->active++;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200441 mutex_unlock(&pcm_mutex);
442 return 0;
443
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100444machine_err:
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200445 if (machine->ops && machine->ops->shutdown)
446 machine->ops->shutdown(substream);
447
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100448codec_dai_err:
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200449 if (platform->pcm_ops->close)
450 platform->pcm_ops->close(substream);
451
452platform_err:
Eric Miao6335d052009-03-03 09:41:00 +0800453 if (cpu_dai->ops->shutdown)
454 cpu_dai->ops->shutdown(substream, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200455out:
456 mutex_unlock(&pcm_mutex);
457 return ret;
458}
459
460/*
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200461 * Power down the audio subsystem pmdown_time msecs after close is called.
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200462 * This is to ensure there are no pops or clicks in between any music tracks
463 * due to DAPM power cycling.
464 */
Andrew Morton4484bb22006-12-15 09:30:07 +0100465static void close_delayed_work(struct work_struct *work)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200466{
Mark Brown63084192008-12-02 15:08:03 +0000467 struct snd_soc_card *card = container_of(work, struct snd_soc_card,
468 delayed_work.work);
Mark Brown6627a652009-01-23 22:55:23 +0000469 struct snd_soc_codec *codec = card->codec;
Liam Girdwood3c4b2662008-07-07 16:07:17 +0100470 struct snd_soc_dai *codec_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200471 int i;
472
473 mutex_lock(&pcm_mutex);
Mark Brown3ff3f642008-05-19 12:32:25 +0200474 for (i = 0; i < codec->num_dai; i++) {
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200475 codec_dai = &codec->dai[i];
476
Mark Brownf24368c2008-10-21 21:45:08 +0100477 pr_debug("pop wq checking: %s status: %s waiting: %s\n",
478 codec_dai->playback.stream_name,
479 codec_dai->playback.active ? "active" : "inactive",
480 codec_dai->pop_wait ? "yes" : "no");
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200481
482 /* are we waiting on this codec DAI stream */
483 if (codec_dai->pop_wait == 1) {
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200484 codec_dai->pop_wait = 0;
Liam Girdwood0b4d2212008-01-10 14:36:20 +0100485 snd_soc_dapm_stream_event(codec,
486 codec_dai->playback.stream_name,
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200487 SND_SOC_DAPM_STREAM_STOP);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200488 }
489 }
490 mutex_unlock(&pcm_mutex);
491}
492
493/*
494 * Called by ALSA when a PCM substream is closed. Private data can be
495 * freed here. The cpu DAI, codec DAI, machine and platform are also
496 * shutdown.
497 */
498static int soc_codec_close(struct snd_pcm_substream *substream)
499{
500 struct snd_soc_pcm_runtime *rtd = substream->private_data;
501 struct snd_soc_device *socdev = rtd->socdev;
Mark Brown63084192008-12-02 15:08:03 +0000502 struct snd_soc_card *card = socdev->card;
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100503 struct snd_soc_dai_link *machine = rtd->dai;
Mark Brown87689d52008-12-02 16:01:14 +0000504 struct snd_soc_platform *platform = card->platform;
Liam Girdwood3c4b2662008-07-07 16:07:17 +0100505 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
506 struct snd_soc_dai *codec_dai = machine->codec_dai;
Mark Brown6627a652009-01-23 22:55:23 +0000507 struct snd_soc_codec *codec = card->codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200508
509 mutex_lock(&pcm_mutex);
510
511 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100512 cpu_dai->playback.active = codec_dai->playback.active = 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200513 else
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100514 cpu_dai->capture.active = codec_dai->capture.active = 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200515
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100516 if (codec_dai->playback.active == 0 &&
517 codec_dai->capture.active == 0) {
518 cpu_dai->active = codec_dai->active = 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200519 }
520 codec->active--;
521
Mark Brown6010b2d2008-09-06 18:33:24 +0100522 /* Muting the DAC suppresses artifacts caused during digital
523 * shutdown, for example from stopping clocks.
524 */
525 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
526 snd_soc_dai_digital_mute(codec_dai, 1);
527
Eric Miao6335d052009-03-03 09:41:00 +0800528 if (cpu_dai->ops->shutdown)
529 cpu_dai->ops->shutdown(substream, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200530
Eric Miao6335d052009-03-03 09:41:00 +0800531 if (codec_dai->ops->shutdown)
532 codec_dai->ops->shutdown(substream, codec_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200533
534 if (machine->ops && machine->ops->shutdown)
535 machine->ops->shutdown(substream);
536
537 if (platform->pcm_ops->close)
538 platform->pcm_ops->close(substream);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100539 cpu_dai->runtime = NULL;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200540
541 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
542 /* start delayed pop wq here for playback streams */
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100543 codec_dai->pop_wait = 1;
Mark Brown63084192008-12-02 15:08:03 +0000544 schedule_delayed_work(&card->delayed_work,
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200545 msecs_to_jiffies(pmdown_time));
546 } else {
547 /* capture streams can be powered down now */
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100548 snd_soc_dapm_stream_event(codec,
Liam Girdwood0b4d2212008-01-10 14:36:20 +0100549 codec_dai->capture.stream_name,
550 SND_SOC_DAPM_STREAM_STOP);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200551 }
552
553 mutex_unlock(&pcm_mutex);
554 return 0;
555}
556
557/*
558 * Called by ALSA when the PCM substream is prepared, can set format, sample
559 * rate, etc. This function is non atomic and can be called multiple times,
560 * it can refer to the runtime info.
561 */
562static int soc_pcm_prepare(struct snd_pcm_substream *substream)
563{
564 struct snd_soc_pcm_runtime *rtd = substream->private_data;
565 struct snd_soc_device *socdev = rtd->socdev;
Mark Brown63084192008-12-02 15:08:03 +0000566 struct snd_soc_card *card = socdev->card;
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100567 struct snd_soc_dai_link *machine = rtd->dai;
Mark Brown87689d52008-12-02 16:01:14 +0000568 struct snd_soc_platform *platform = card->platform;
Liam Girdwood3c4b2662008-07-07 16:07:17 +0100569 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
570 struct snd_soc_dai *codec_dai = machine->codec_dai;
Mark Brown6627a652009-01-23 22:55:23 +0000571 struct snd_soc_codec *codec = card->codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200572 int ret = 0;
573
574 mutex_lock(&pcm_mutex);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100575
576 if (machine->ops && machine->ops->prepare) {
577 ret = machine->ops->prepare(substream);
578 if (ret < 0) {
579 printk(KERN_ERR "asoc: machine prepare error\n");
580 goto out;
581 }
582 }
583
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200584 if (platform->pcm_ops->prepare) {
585 ret = platform->pcm_ops->prepare(substream);
Liam Girdwooda71a4682006-10-19 20:35:56 +0200586 if (ret < 0) {
587 printk(KERN_ERR "asoc: platform prepare error\n");
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200588 goto out;
Liam Girdwooda71a4682006-10-19 20:35:56 +0200589 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200590 }
591
Eric Miao6335d052009-03-03 09:41:00 +0800592 if (codec_dai->ops->prepare) {
593 ret = codec_dai->ops->prepare(substream, codec_dai);
Liam Girdwooda71a4682006-10-19 20:35:56 +0200594 if (ret < 0) {
595 printk(KERN_ERR "asoc: codec DAI prepare error\n");
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200596 goto out;
Liam Girdwooda71a4682006-10-19 20:35:56 +0200597 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200598 }
599
Eric Miao6335d052009-03-03 09:41:00 +0800600 if (cpu_dai->ops->prepare) {
601 ret = cpu_dai->ops->prepare(substream, cpu_dai);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100602 if (ret < 0) {
603 printk(KERN_ERR "asoc: cpu DAI prepare error\n");
604 goto out;
605 }
606 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200607
Mark Brownd45f6212008-10-14 13:58:36 +0100608 /* cancel any delayed stream shutdown that is pending */
609 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
610 codec_dai->pop_wait) {
611 codec_dai->pop_wait = 0;
Mark Brown63084192008-12-02 15:08:03 +0000612 cancel_delayed_work(&card->delayed_work);
Mark Brownd45f6212008-10-14 13:58:36 +0100613 }
614
Mark Brown452c5ea2009-05-17 21:41:23 +0100615 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
616 snd_soc_dapm_stream_event(codec,
617 codec_dai->playback.stream_name,
618 SND_SOC_DAPM_STREAM_START);
619 else
620 snd_soc_dapm_stream_event(codec,
621 codec_dai->capture.stream_name,
622 SND_SOC_DAPM_STREAM_START);
Mark Brownd45f6212008-10-14 13:58:36 +0100623
Mark Brown452c5ea2009-05-17 21:41:23 +0100624 snd_soc_dai_digital_mute(codec_dai, 0);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200625
626out:
627 mutex_unlock(&pcm_mutex);
628 return ret;
629}
630
631/*
632 * Called by ALSA when the hardware params are set by application. This
633 * function can also be called multiple times and can allocate buffers
634 * (using snd_pcm_lib_* ). It's non-atomic.
635 */
636static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
637 struct snd_pcm_hw_params *params)
638{
639 struct snd_soc_pcm_runtime *rtd = substream->private_data;
640 struct snd_soc_device *socdev = rtd->socdev;
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100641 struct snd_soc_dai_link *machine = rtd->dai;
Mark Brown87689d52008-12-02 16:01:14 +0000642 struct snd_soc_card *card = socdev->card;
643 struct snd_soc_platform *platform = card->platform;
Liam Girdwood3c4b2662008-07-07 16:07:17 +0100644 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
645 struct snd_soc_dai *codec_dai = machine->codec_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200646 int ret = 0;
647
648 mutex_lock(&pcm_mutex);
649
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100650 if (machine->ops && machine->ops->hw_params) {
651 ret = machine->ops->hw_params(substream, params);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200652 if (ret < 0) {
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100653 printk(KERN_ERR "asoc: machine hw_params failed\n");
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200654 goto out;
655 }
656 }
657
Eric Miao6335d052009-03-03 09:41:00 +0800658 if (codec_dai->ops->hw_params) {
659 ret = codec_dai->ops->hw_params(substream, params, codec_dai);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100660 if (ret < 0) {
661 printk(KERN_ERR "asoc: can't set codec %s hw params\n",
662 codec_dai->name);
663 goto codec_err;
664 }
665 }
666
Eric Miao6335d052009-03-03 09:41:00 +0800667 if (cpu_dai->ops->hw_params) {
668 ret = cpu_dai->ops->hw_params(substream, params, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200669 if (ret < 0) {
Mark Brown3ff3f642008-05-19 12:32:25 +0200670 printk(KERN_ERR "asoc: interface %s hw params failed\n",
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100671 cpu_dai->name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200672 goto interface_err;
673 }
674 }
675
676 if (platform->pcm_ops->hw_params) {
677 ret = platform->pcm_ops->hw_params(substream, params);
678 if (ret < 0) {
Mark Brown3ff3f642008-05-19 12:32:25 +0200679 printk(KERN_ERR "asoc: platform %s hw params failed\n",
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200680 platform->name);
681 goto platform_err;
682 }
683 }
684
Mark Brown06f409d2009-04-07 18:10:13 +0100685 machine->rate = params_rate(params);
686
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200687out:
688 mutex_unlock(&pcm_mutex);
689 return ret;
690
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200691platform_err:
Eric Miao6335d052009-03-03 09:41:00 +0800692 if (cpu_dai->ops->hw_free)
693 cpu_dai->ops->hw_free(substream, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200694
695interface_err:
Eric Miao6335d052009-03-03 09:41:00 +0800696 if (codec_dai->ops->hw_free)
697 codec_dai->ops->hw_free(substream, codec_dai);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100698
699codec_err:
Mark Brown3ff3f642008-05-19 12:32:25 +0200700 if (machine->ops && machine->ops->hw_free)
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100701 machine->ops->hw_free(substream);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200702
703 mutex_unlock(&pcm_mutex);
704 return ret;
705}
706
707/*
708 * Free's resources allocated by hw_params, can be called multiple times
709 */
710static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
711{
712 struct snd_soc_pcm_runtime *rtd = substream->private_data;
713 struct snd_soc_device *socdev = rtd->socdev;
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100714 struct snd_soc_dai_link *machine = rtd->dai;
Mark Brown87689d52008-12-02 16:01:14 +0000715 struct snd_soc_card *card = socdev->card;
716 struct snd_soc_platform *platform = card->platform;
Liam Girdwood3c4b2662008-07-07 16:07:17 +0100717 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
718 struct snd_soc_dai *codec_dai = machine->codec_dai;
Mark Brown6627a652009-01-23 22:55:23 +0000719 struct snd_soc_codec *codec = card->codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200720
721 mutex_lock(&pcm_mutex);
722
723 /* apply codec digital mute */
Liam Girdwood8c6529d2008-07-08 13:19:13 +0100724 if (!codec->active)
725 snd_soc_dai_digital_mute(codec_dai, 1);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200726
727 /* free any machine hw params */
728 if (machine->ops && machine->ops->hw_free)
729 machine->ops->hw_free(substream);
730
731 /* free any DMA resources */
732 if (platform->pcm_ops->hw_free)
733 platform->pcm_ops->hw_free(substream);
734
735 /* now free hw params for the DAI's */
Eric Miao6335d052009-03-03 09:41:00 +0800736 if (codec_dai->ops->hw_free)
737 codec_dai->ops->hw_free(substream, codec_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200738
Eric Miao6335d052009-03-03 09:41:00 +0800739 if (cpu_dai->ops->hw_free)
740 cpu_dai->ops->hw_free(substream, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200741
742 mutex_unlock(&pcm_mutex);
743 return 0;
744}
745
746static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
747{
748 struct snd_soc_pcm_runtime *rtd = substream->private_data;
749 struct snd_soc_device *socdev = rtd->socdev;
Mark Brown87689d52008-12-02 16:01:14 +0000750 struct snd_soc_card *card= socdev->card;
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100751 struct snd_soc_dai_link *machine = rtd->dai;
Mark Brown87689d52008-12-02 16:01:14 +0000752 struct snd_soc_platform *platform = card->platform;
Liam Girdwood3c4b2662008-07-07 16:07:17 +0100753 struct snd_soc_dai *cpu_dai = machine->cpu_dai;
754 struct snd_soc_dai *codec_dai = machine->codec_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200755 int ret;
756
Eric Miao6335d052009-03-03 09:41:00 +0800757 if (codec_dai->ops->trigger) {
758 ret = codec_dai->ops->trigger(substream, cmd, codec_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200759 if (ret < 0)
760 return ret;
761 }
762
763 if (platform->pcm_ops->trigger) {
764 ret = platform->pcm_ops->trigger(substream, cmd);
765 if (ret < 0)
766 return ret;
767 }
768
Eric Miao6335d052009-03-03 09:41:00 +0800769 if (cpu_dai->ops->trigger) {
770 ret = cpu_dai->ops->trigger(substream, cmd, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200771 if (ret < 0)
772 return ret;
773 }
774 return 0;
775}
776
777/* ASoC PCM operations */
778static struct snd_pcm_ops soc_pcm_ops = {
779 .open = soc_pcm_open,
780 .close = soc_codec_close,
781 .hw_params = soc_pcm_hw_params,
782 .hw_free = soc_pcm_hw_free,
783 .prepare = soc_pcm_prepare,
784 .trigger = soc_pcm_trigger,
785};
786
787#ifdef CONFIG_PM
788/* powers down audio subsystem for suspend */
Mark Brown416356f2009-06-30 19:05:15 +0100789static int soc_suspend(struct device *dev)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200790{
Mark Brown416356f2009-06-30 19:05:15 +0100791 struct platform_device *pdev = to_platform_device(dev);
Mark Brown3ff3f642008-05-19 12:32:25 +0200792 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
Mark Brown87506542008-11-18 20:50:34 +0000793 struct snd_soc_card *card = socdev->card;
Mark Brown87689d52008-12-02 16:01:14 +0000794 struct snd_soc_platform *platform = card->platform;
Mark Brown3ff3f642008-05-19 12:32:25 +0200795 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
Mark Brown6627a652009-01-23 22:55:23 +0000796 struct snd_soc_codec *codec = card->codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200797 int i;
798
Daniel Macke3509ff2009-06-03 17:44:49 +0200799 /* If the initialization of this soc device failed, there is no codec
800 * associated with it. Just bail out in this case.
801 */
802 if (!codec)
803 return 0;
804
Andy Green6ed25972008-06-13 16:24:05 +0100805 /* Due to the resume being scheduled into a workqueue we could
806 * suspend before that's finished - wait for it to complete.
807 */
808 snd_power_lock(codec->card);
809 snd_power_wait(codec->card, SNDRV_CTL_POWER_D0);
810 snd_power_unlock(codec->card);
811
812 /* we're going to block userspace touching us until resume completes */
813 snd_power_change_state(codec->card, SNDRV_CTL_POWER_D3hot);
814
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200815 /* mute any active DAC's */
Mark Browndee89c42008-11-18 22:11:38 +0000816 for (i = 0; i < card->num_links; i++) {
817 struct snd_soc_dai *dai = card->dai_link[i].codec_dai;
Eric Miao6335d052009-03-03 09:41:00 +0800818 if (dai->ops->digital_mute && dai->playback.active)
819 dai->ops->digital_mute(dai, 1);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200820 }
821
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100822 /* suspend all pcms */
Mark Brown87506542008-11-18 20:50:34 +0000823 for (i = 0; i < card->num_links; i++)
824 snd_pcm_suspend_all(card->dai_link[i].pcm);
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100825
Mark Brown87506542008-11-18 20:50:34 +0000826 if (card->suspend_pre)
Mark Brown416356f2009-06-30 19:05:15 +0100827 card->suspend_pre(pdev, PMSG_SUSPEND);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200828
Mark Brown87506542008-11-18 20:50:34 +0000829 for (i = 0; i < card->num_links; i++) {
830 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
Mark Brown3ba9e102008-11-24 18:01:05 +0000831 if (cpu_dai->suspend && !cpu_dai->ac97_control)
Mark Browndc7d7b82008-12-03 18:21:52 +0000832 cpu_dai->suspend(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200833 if (platform->suspend)
Mark Brown07c84d02008-12-03 18:17:28 +0000834 platform->suspend(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200835 }
836
837 /* close any waiting streams and save state */
Mark Brown63084192008-12-02 15:08:03 +0000838 run_delayed_work(&card->delayed_work);
Mark Brown0be98982008-05-19 12:31:28 +0200839 codec->suspend_bias_level = codec->bias_level;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200840
Mark Brown3ff3f642008-05-19 12:32:25 +0200841 for (i = 0; i < codec->num_dai; i++) {
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200842 char *stream = codec->dai[i].playback.stream_name;
843 if (stream != NULL)
844 snd_soc_dapm_stream_event(codec, stream,
845 SND_SOC_DAPM_STREAM_SUSPEND);
846 stream = codec->dai[i].capture.stream_name;
847 if (stream != NULL)
848 snd_soc_dapm_stream_event(codec, stream,
849 SND_SOC_DAPM_STREAM_SUSPEND);
850 }
851
852 if (codec_dev->suspend)
Mark Brown416356f2009-06-30 19:05:15 +0100853 codec_dev->suspend(pdev, PMSG_SUSPEND);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200854
Mark Brown87506542008-11-18 20:50:34 +0000855 for (i = 0; i < card->num_links; i++) {
856 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
Mark Brown3ba9e102008-11-24 18:01:05 +0000857 if (cpu_dai->suspend && cpu_dai->ac97_control)
Mark Browndc7d7b82008-12-03 18:21:52 +0000858 cpu_dai->suspend(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200859 }
860
Mark Brown87506542008-11-18 20:50:34 +0000861 if (card->suspend_post)
Mark Brown416356f2009-06-30 19:05:15 +0100862 card->suspend_post(pdev, PMSG_SUSPEND);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200863
864 return 0;
865}
866
Andy Green6ed25972008-06-13 16:24:05 +0100867/* deferred resume work, so resume can complete before we finished
868 * setting our codec back up, which can be very slow on I2C
869 */
870static void soc_resume_deferred(struct work_struct *work)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200871{
Mark Brown63084192008-12-02 15:08:03 +0000872 struct snd_soc_card *card = container_of(work,
873 struct snd_soc_card,
874 deferred_resume_work);
875 struct snd_soc_device *socdev = card->socdev;
Mark Brown87689d52008-12-02 16:01:14 +0000876 struct snd_soc_platform *platform = card->platform;
Mark Brown3ff3f642008-05-19 12:32:25 +0200877 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
Mark Brown6627a652009-01-23 22:55:23 +0000878 struct snd_soc_codec *codec = card->codec;
Andy Green6ed25972008-06-13 16:24:05 +0100879 struct platform_device *pdev = to_platform_device(socdev->dev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200880 int i;
881
Andy Green6ed25972008-06-13 16:24:05 +0100882 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
883 * so userspace apps are blocked from touching us
884 */
885
Mark Brownfde22f22008-11-24 18:08:18 +0000886 dev_dbg(socdev->dev, "starting resume work\n");
Andy Green6ed25972008-06-13 16:24:05 +0100887
Mark Brown87506542008-11-18 20:50:34 +0000888 if (card->resume_pre)
889 card->resume_pre(pdev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200890
Mark Brown87506542008-11-18 20:50:34 +0000891 for (i = 0; i < card->num_links; i++) {
892 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
Mark Brown3ba9e102008-11-24 18:01:05 +0000893 if (cpu_dai->resume && cpu_dai->ac97_control)
Mark Browndc7d7b82008-12-03 18:21:52 +0000894 cpu_dai->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200895 }
896
897 if (codec_dev->resume)
898 codec_dev->resume(pdev);
899
Mark Brown3ff3f642008-05-19 12:32:25 +0200900 for (i = 0; i < codec->num_dai; i++) {
901 char *stream = codec->dai[i].playback.stream_name;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200902 if (stream != NULL)
903 snd_soc_dapm_stream_event(codec, stream,
904 SND_SOC_DAPM_STREAM_RESUME);
905 stream = codec->dai[i].capture.stream_name;
906 if (stream != NULL)
907 snd_soc_dapm_stream_event(codec, stream,
908 SND_SOC_DAPM_STREAM_RESUME);
909 }
910
Mark Brown3ff3f642008-05-19 12:32:25 +0200911 /* unmute any active DACs */
Mark Browndee89c42008-11-18 22:11:38 +0000912 for (i = 0; i < card->num_links; i++) {
913 struct snd_soc_dai *dai = card->dai_link[i].codec_dai;
Eric Miao6335d052009-03-03 09:41:00 +0800914 if (dai->ops->digital_mute && dai->playback.active)
915 dai->ops->digital_mute(dai, 0);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200916 }
917
Mark Brown87506542008-11-18 20:50:34 +0000918 for (i = 0; i < card->num_links; i++) {
919 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
Mark Brown3ba9e102008-11-24 18:01:05 +0000920 if (cpu_dai->resume && !cpu_dai->ac97_control)
Mark Browndc7d7b82008-12-03 18:21:52 +0000921 cpu_dai->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200922 if (platform->resume)
Mark Brown07c84d02008-12-03 18:17:28 +0000923 platform->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200924 }
925
Mark Brown87506542008-11-18 20:50:34 +0000926 if (card->resume_post)
927 card->resume_post(pdev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200928
Mark Brownfde22f22008-11-24 18:08:18 +0000929 dev_dbg(socdev->dev, "resume work completed\n");
Andy Green6ed25972008-06-13 16:24:05 +0100930
931 /* userspace can access us now we are back as we were before */
932 snd_power_change_state(codec->card, SNDRV_CTL_POWER_D0);
933}
934
935/* powers up audio subsystem after a suspend */
Mark Brown416356f2009-06-30 19:05:15 +0100936static int soc_resume(struct device *dev)
Andy Green6ed25972008-06-13 16:24:05 +0100937{
Mark Brown416356f2009-06-30 19:05:15 +0100938 struct platform_device *pdev = to_platform_device(dev);
Andy Green6ed25972008-06-13 16:24:05 +0100939 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
Mark Brown63084192008-12-02 15:08:03 +0000940 struct snd_soc_card *card = socdev->card;
Mark Brown64ab9ba2009-03-31 11:27:03 +0100941 struct snd_soc_dai *cpu_dai = card->dai_link[0].cpu_dai;
Andy Green6ed25972008-06-13 16:24:05 +0100942
Mark Brown64ab9ba2009-03-31 11:27:03 +0100943 /* AC97 devices might have other drivers hanging off them so
944 * need to resume immediately. Other drivers don't have that
945 * problem and may take a substantial amount of time to resume
946 * due to I/O costs and anti-pop so handle them out of line.
947 */
948 if (cpu_dai->ac97_control) {
949 dev_dbg(socdev->dev, "Resuming AC97 immediately\n");
950 soc_resume_deferred(&card->deferred_resume_work);
951 } else {
952 dev_dbg(socdev->dev, "Scheduling resume work\n");
953 if (!schedule_work(&card->deferred_resume_work))
954 dev_err(socdev->dev, "resume work item may be lost\n");
955 }
Andy Green6ed25972008-06-13 16:24:05 +0100956
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200957 return 0;
958}
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200959#else
960#define soc_suspend NULL
961#define soc_resume NULL
962#endif
963
Barry Song02a06d32009-10-16 18:13:38 +0800964static struct snd_soc_dai_ops null_dai_ops = {
965};
966
Mark Brown435c5e22008-12-04 15:32:53 +0000967static void snd_soc_instantiate_card(struct snd_soc_card *card)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200968{
Mark Brown435c5e22008-12-04 15:32:53 +0000969 struct platform_device *pdev = container_of(card->dev,
970 struct platform_device,
971 dev);
972 struct snd_soc_codec_device *codec_dev = card->socdev->codec_dev;
Mark Brownfe3e78e2009-11-03 22:13:13 +0000973 struct snd_soc_codec *codec;
Mark Brown435c5e22008-12-04 15:32:53 +0000974 struct snd_soc_platform *platform;
975 struct snd_soc_dai *dai;
Mark Brown6b05eda2008-12-08 19:26:48 +0000976 int i, found, ret, ac97;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200977
Mark Brown435c5e22008-12-04 15:32:53 +0000978 if (card->instantiated)
979 return;
Mark Brown63084192008-12-02 15:08:03 +0000980
Mark Brown435c5e22008-12-04 15:32:53 +0000981 found = 0;
982 list_for_each_entry(platform, &platform_list, list)
983 if (card->platform == platform) {
984 found = 1;
985 break;
986 }
987 if (!found) {
988 dev_dbg(card->dev, "Platform %s not registered\n",
989 card->platform->name);
990 return;
Mark Brownc5af3a22008-11-28 13:29:45 +0000991 }
992
Mark Brown6b05eda2008-12-08 19:26:48 +0000993 ac97 = 0;
Mark Brown435c5e22008-12-04 15:32:53 +0000994 for (i = 0; i < card->num_links; i++) {
995 found = 0;
996 list_for_each_entry(dai, &dai_list, list)
997 if (card->dai_link[i].cpu_dai == dai) {
998 found = 1;
999 break;
1000 }
1001 if (!found) {
1002 dev_dbg(card->dev, "DAI %s not registered\n",
1003 card->dai_link[i].cpu_dai->name);
1004 return;
1005 }
Mark Brown6b05eda2008-12-08 19:26:48 +00001006
1007 if (card->dai_link[i].cpu_dai->ac97_control)
1008 ac97 = 1;
Mark Brown435c5e22008-12-04 15:32:53 +00001009 }
1010
Barry Song02a06d32009-10-16 18:13:38 +08001011 for (i = 0; i < card->num_links; i++) {
1012 if (!card->dai_link[i].codec_dai->ops)
1013 card->dai_link[i].codec_dai->ops = &null_dai_ops;
1014 }
1015
Mark Brown6b05eda2008-12-08 19:26:48 +00001016 /* If we have AC97 in the system then don't wait for the
1017 * codec. This will need revisiting if we have to handle
1018 * systems with mixed AC97 and non-AC97 parts. Only check for
1019 * DAIs currently; we can't do this per link since some AC97
1020 * codecs have non-AC97 DAIs.
1021 */
1022 if (!ac97)
1023 for (i = 0; i < card->num_links; i++) {
1024 found = 0;
1025 list_for_each_entry(dai, &dai_list, list)
1026 if (card->dai_link[i].codec_dai == dai) {
1027 found = 1;
1028 break;
1029 }
1030 if (!found) {
1031 dev_dbg(card->dev, "DAI %s not registered\n",
1032 card->dai_link[i].codec_dai->name);
1033 return;
1034 }
1035 }
1036
Mark Brown435c5e22008-12-04 15:32:53 +00001037 /* Note that we do not current check for codec components */
1038
1039 dev_dbg(card->dev, "All components present, instantiating\n");
1040
1041 /* Found everything, bring it up */
Mark Brown87506542008-11-18 20:50:34 +00001042 if (card->probe) {
1043 ret = card->probe(pdev);
Mark Brown3ff3f642008-05-19 12:32:25 +02001044 if (ret < 0)
Mark Brown435c5e22008-12-04 15:32:53 +00001045 return;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001046 }
1047
Mark Brown87506542008-11-18 20:50:34 +00001048 for (i = 0; i < card->num_links; i++) {
1049 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001050 if (cpu_dai->probe) {
Mark Brownbdb92872008-06-11 13:47:10 +01001051 ret = cpu_dai->probe(pdev, cpu_dai);
Mark Brown3ff3f642008-05-19 12:32:25 +02001052 if (ret < 0)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001053 goto cpu_dai_err;
1054 }
1055 }
1056
1057 if (codec_dev->probe) {
1058 ret = codec_dev->probe(pdev);
Mark Brown3ff3f642008-05-19 12:32:25 +02001059 if (ret < 0)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001060 goto cpu_dai_err;
1061 }
Mark Brownfe3e78e2009-11-03 22:13:13 +00001062 codec = card->codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001063
1064 if (platform->probe) {
1065 ret = platform->probe(pdev);
Mark Brown3ff3f642008-05-19 12:32:25 +02001066 if (ret < 0)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001067 goto platform_err;
1068 }
1069
1070 /* DAPM stream work */
Mark Brown63084192008-12-02 15:08:03 +00001071 INIT_DELAYED_WORK(&card->delayed_work, close_delayed_work);
Randy Dunlap1301a962008-06-17 19:19:34 +01001072#ifdef CONFIG_PM
Andy Green6ed25972008-06-13 16:24:05 +01001073 /* deferred resume work */
Mark Brown63084192008-12-02 15:08:03 +00001074 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
Randy Dunlap1301a962008-06-17 19:19:34 +01001075#endif
Andy Green6ed25972008-06-13 16:24:05 +01001076
Mark Brownfe3e78e2009-11-03 22:13:13 +00001077 for (i = 0; i < card->num_links; i++) {
1078 if (card->dai_link[i].init) {
1079 ret = card->dai_link[i].init(codec);
1080 if (ret < 0) {
1081 printk(KERN_ERR "asoc: failed to init %s\n",
1082 card->dai_link[i].stream_name);
1083 continue;
1084 }
1085 }
Barry Songf7732052009-11-12 12:01:47 +08001086 if (card->dai_link[i].codec_dai->ac97_control)
Mark Brownfe3e78e2009-11-03 22:13:13 +00001087 ac97 = 1;
Mark Brownfe3e78e2009-11-03 22:13:13 +00001088 }
1089
1090 snprintf(codec->card->shortname, sizeof(codec->card->shortname),
1091 "%s", card->name);
1092 snprintf(codec->card->longname, sizeof(codec->card->longname),
1093 "%s (%s)", card->name, codec->name);
1094
1095 /* Make sure all DAPM widgets are instantiated */
1096 snd_soc_dapm_new_widgets(codec);
1097
1098 ret = snd_card_register(codec->card);
1099 if (ret < 0) {
1100 printk(KERN_ERR "asoc: failed to register soundcard for %s\n",
1101 codec->name);
1102 goto card_err;
1103 }
1104
1105 mutex_lock(&codec->mutex);
1106#ifdef CONFIG_SND_SOC_AC97_BUS
1107 /* Only instantiate AC97 if not already done by the adaptor
1108 * for the generic AC97 subsystem.
1109 */
1110 if (ac97 && strcmp(codec->name, "AC97") != 0) {
1111 ret = soc_ac97_dev_register(codec);
1112 if (ret < 0) {
1113 printk(KERN_ERR "asoc: AC97 device register failed\n");
1114 snd_card_free(codec->card);
1115 mutex_unlock(&codec->mutex);
1116 goto card_err;
1117 }
1118 }
1119#endif
1120
1121 ret = snd_soc_dapm_sys_add(card->socdev->dev);
1122 if (ret < 0)
1123 printk(KERN_WARNING "asoc: failed to add dapm sysfs entries\n");
1124
1125 ret = device_create_file(card->socdev->dev, &dev_attr_codec_reg);
1126 if (ret < 0)
1127 printk(KERN_WARNING "asoc: failed to add codec sysfs files\n");
1128
1129 soc_init_codec_debugfs(codec);
1130 mutex_unlock(&codec->mutex);
1131
Mark Brown435c5e22008-12-04 15:32:53 +00001132 card->instantiated = 1;
1133
1134 return;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001135
Mark Brownfe3e78e2009-11-03 22:13:13 +00001136card_err:
1137 if (platform->remove)
1138 platform->remove(pdev);
1139
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001140platform_err:
1141 if (codec_dev->remove)
1142 codec_dev->remove(pdev);
1143
1144cpu_dai_err:
Liam Girdwood18b9b3d2007-01-30 17:18:45 +01001145 for (i--; i >= 0; i--) {
Mark Brown87506542008-11-18 20:50:34 +00001146 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001147 if (cpu_dai->remove)
Mark Brownbdb92872008-06-11 13:47:10 +01001148 cpu_dai->remove(pdev, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001149 }
1150
Mark Brown87506542008-11-18 20:50:34 +00001151 if (card->remove)
1152 card->remove(pdev);
Mark Brown435c5e22008-12-04 15:32:53 +00001153}
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001154
Mark Brown435c5e22008-12-04 15:32:53 +00001155/*
1156 * Attempt to initialise any uninitalised cards. Must be called with
1157 * client_mutex.
1158 */
1159static void snd_soc_instantiate_cards(void)
1160{
1161 struct snd_soc_card *card;
1162 list_for_each_entry(card, &card_list, list)
1163 snd_soc_instantiate_card(card);
1164}
1165
1166/* probes a new socdev */
1167static int soc_probe(struct platform_device *pdev)
1168{
1169 int ret = 0;
1170 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1171 struct snd_soc_card *card = socdev->card;
1172
1173 /* Bodge while we push things out of socdev */
1174 card->socdev = socdev;
1175
1176 /* Bodge while we unpick instantiation */
1177 card->dev = &pdev->dev;
1178 ret = snd_soc_register_card(card);
1179 if (ret != 0) {
1180 dev_err(&pdev->dev, "Failed to register card\n");
1181 return ret;
1182 }
1183
1184 return 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001185}
1186
1187/* removes a socdev */
1188static int soc_remove(struct platform_device *pdev)
1189{
1190 int i;
1191 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
Mark Brown87506542008-11-18 20:50:34 +00001192 struct snd_soc_card *card = socdev->card;
Mark Brown87689d52008-12-02 16:01:14 +00001193 struct snd_soc_platform *platform = card->platform;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001194 struct snd_soc_codec_device *codec_dev = socdev->codec_dev;
1195
Mike Rapoport914dc182009-05-11 13:04:55 +03001196 if (!card->instantiated)
1197 return 0;
1198
Mark Brown63084192008-12-02 15:08:03 +00001199 run_delayed_work(&card->delayed_work);
Liam Girdwood965ac422007-01-31 14:14:57 +01001200
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001201 if (platform->remove)
1202 platform->remove(pdev);
1203
1204 if (codec_dev->remove)
1205 codec_dev->remove(pdev);
1206
Mark Brown87506542008-11-18 20:50:34 +00001207 for (i = 0; i < card->num_links; i++) {
1208 struct snd_soc_dai *cpu_dai = card->dai_link[i].cpu_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001209 if (cpu_dai->remove)
Mark Brownbdb92872008-06-11 13:47:10 +01001210 cpu_dai->remove(pdev, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001211 }
1212
Mark Brown87506542008-11-18 20:50:34 +00001213 if (card->remove)
1214 card->remove(pdev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001215
Mark Brownc5af3a22008-11-28 13:29:45 +00001216 snd_soc_unregister_card(card);
1217
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001218 return 0;
1219}
1220
Mark Brown416356f2009-06-30 19:05:15 +01001221static int soc_poweroff(struct device *dev)
Mark Brown51737472009-06-22 13:16:51 +01001222{
Mark Brown416356f2009-06-30 19:05:15 +01001223 struct platform_device *pdev = to_platform_device(dev);
Mark Brown51737472009-06-22 13:16:51 +01001224 struct snd_soc_device *socdev = platform_get_drvdata(pdev);
1225 struct snd_soc_card *card = socdev->card;
1226
1227 if (!card->instantiated)
Mark Brown416356f2009-06-30 19:05:15 +01001228 return 0;
Mark Brown51737472009-06-22 13:16:51 +01001229
1230 /* Flush out pmdown_time work - we actually do want to run it
1231 * now, we're shutting down so no imminent restart. */
1232 run_delayed_work(&card->delayed_work);
1233
1234 snd_soc_dapm_shutdown(socdev);
Mark Brown416356f2009-06-30 19:05:15 +01001235
1236 return 0;
Mark Brown51737472009-06-22 13:16:51 +01001237}
1238
Alexey Dobriyan47145212009-12-14 18:00:08 -08001239static const struct dev_pm_ops soc_pm_ops = {
Mark Brown416356f2009-06-30 19:05:15 +01001240 .suspend = soc_suspend,
1241 .resume = soc_resume,
1242 .poweroff = soc_poweroff,
1243};
1244
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001245/* ASoC platform driver */
1246static struct platform_driver soc_driver = {
1247 .driver = {
1248 .name = "soc-audio",
Kay Sievers8b45a202008-04-14 13:33:36 +02001249 .owner = THIS_MODULE,
Mark Brown416356f2009-06-30 19:05:15 +01001250 .pm = &soc_pm_ops,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001251 },
1252 .probe = soc_probe,
1253 .remove = soc_remove,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001254};
1255
1256/* create a new pcm */
1257static int soc_new_pcm(struct snd_soc_device *socdev,
1258 struct snd_soc_dai_link *dai_link, int num)
1259{
Mark Brown87689d52008-12-02 16:01:14 +00001260 struct snd_soc_card *card = socdev->card;
Mark Brown6627a652009-01-23 22:55:23 +00001261 struct snd_soc_codec *codec = card->codec;
Mark Brown87689d52008-12-02 16:01:14 +00001262 struct snd_soc_platform *platform = card->platform;
Liam Girdwood3c4b2662008-07-07 16:07:17 +01001263 struct snd_soc_dai *codec_dai = dai_link->codec_dai;
1264 struct snd_soc_dai *cpu_dai = dai_link->cpu_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001265 struct snd_soc_pcm_runtime *rtd;
1266 struct snd_pcm *pcm;
1267 char new_name[64];
1268 int ret = 0, playback = 0, capture = 0;
1269
1270 rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
1271 if (rtd == NULL)
1272 return -ENOMEM;
Liam Girdwoodcb666e52007-02-02 17:13:49 +01001273
1274 rtd->dai = dai_link;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001275 rtd->socdev = socdev;
Mark Brown6627a652009-01-23 22:55:23 +00001276 codec_dai->codec = card->codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001277
1278 /* check client and interface hw capabilities */
Mark Brown3ba9e102008-11-24 18:01:05 +00001279 sprintf(new_name, "%s %s-%d", dai_link->stream_name, codec_dai->name,
1280 num);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001281
1282 if (codec_dai->playback.channels_min)
1283 playback = 1;
1284 if (codec_dai->capture.channels_min)
1285 capture = 1;
1286
1287 ret = snd_pcm_new(codec->card, new_name, codec->pcm_devs++, playback,
1288 capture, &pcm);
1289 if (ret < 0) {
Mark Brown3ff3f642008-05-19 12:32:25 +02001290 printk(KERN_ERR "asoc: can't create pcm for codec %s\n",
1291 codec->name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001292 kfree(rtd);
1293 return ret;
1294 }
1295
Liam Girdwood4ccab3e2008-01-10 14:39:01 +01001296 dai_link->pcm = pcm;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001297 pcm->private_data = rtd;
Mark Brown87689d52008-12-02 16:01:14 +00001298 soc_pcm_ops.mmap = platform->pcm_ops->mmap;
1299 soc_pcm_ops.pointer = platform->pcm_ops->pointer;
1300 soc_pcm_ops.ioctl = platform->pcm_ops->ioctl;
1301 soc_pcm_ops.copy = platform->pcm_ops->copy;
1302 soc_pcm_ops.silence = platform->pcm_ops->silence;
1303 soc_pcm_ops.ack = platform->pcm_ops->ack;
1304 soc_pcm_ops.page = platform->pcm_ops->page;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001305
1306 if (playback)
1307 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &soc_pcm_ops);
1308
1309 if (capture)
1310 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &soc_pcm_ops);
1311
Mark Brown87689d52008-12-02 16:01:14 +00001312 ret = platform->pcm_new(codec->card, codec_dai, pcm);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001313 if (ret < 0) {
1314 printk(KERN_ERR "asoc: platform pcm constructor failed\n");
1315 kfree(rtd);
1316 return ret;
1317 }
1318
Mark Brown87689d52008-12-02 16:01:14 +00001319 pcm->private_free = platform->pcm_free;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001320 printk(KERN_INFO "asoc: %s <-> %s mapping ok\n", codec_dai->name,
1321 cpu_dai->name);
1322 return ret;
1323}
1324
Mark Brown096e49d2009-07-05 15:12:22 +01001325/**
1326 * snd_soc_codec_volatile_register: Report if a register is volatile.
1327 *
1328 * @codec: CODEC to query.
1329 * @reg: Register to query.
1330 *
1331 * Boolean function indiciating if a CODEC register is volatile.
1332 */
1333int snd_soc_codec_volatile_register(struct snd_soc_codec *codec, int reg)
1334{
1335 if (codec->volatile_register)
1336 return codec->volatile_register(reg);
1337 else
1338 return 0;
1339}
1340EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register);
1341
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001342/**
1343 * snd_soc_new_ac97_codec - initailise AC97 device
1344 * @codec: audio codec
1345 * @ops: AC97 bus operations
1346 * @num: AC97 codec number
1347 *
1348 * Initialises AC97 codec resources for use by ad-hoc devices only.
1349 */
1350int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
1351 struct snd_ac97_bus_ops *ops, int num)
1352{
1353 mutex_lock(&codec->mutex);
1354
1355 codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
1356 if (codec->ac97 == NULL) {
1357 mutex_unlock(&codec->mutex);
1358 return -ENOMEM;
1359 }
1360
1361 codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
1362 if (codec->ac97->bus == NULL) {
1363 kfree(codec->ac97);
1364 codec->ac97 = NULL;
1365 mutex_unlock(&codec->mutex);
1366 return -ENOMEM;
1367 }
1368
1369 codec->ac97->bus->ops = ops;
1370 codec->ac97->num = num;
1371 mutex_unlock(&codec->mutex);
1372 return 0;
1373}
1374EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
1375
1376/**
1377 * snd_soc_free_ac97_codec - free AC97 codec device
1378 * @codec: audio codec
1379 *
1380 * Frees AC97 codec device resources.
1381 */
1382void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
1383{
1384 mutex_lock(&codec->mutex);
1385 kfree(codec->ac97->bus);
1386 kfree(codec->ac97);
1387 codec->ac97 = NULL;
1388 mutex_unlock(&codec->mutex);
1389}
1390EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
1391
1392/**
1393 * snd_soc_update_bits - update codec register bits
1394 * @codec: audio codec
1395 * @reg: codec register
1396 * @mask: register mask
1397 * @value: new value
1398 *
1399 * Writes new register value.
1400 *
1401 * Returns 1 for change else 0.
1402 */
1403int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001404 unsigned int mask, unsigned int value)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001405{
1406 int change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001407 unsigned int old, new;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001408
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001409 old = snd_soc_read(codec, reg);
1410 new = (old & ~mask) | value;
1411 change = old != new;
1412 if (change)
1413 snd_soc_write(codec, reg, new);
1414
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001415 return change;
1416}
1417EXPORT_SYMBOL_GPL(snd_soc_update_bits);
1418
1419/**
Eero Nurkkala6c508c62009-10-30 13:34:03 +02001420 * snd_soc_update_bits_locked - update codec register bits
1421 * @codec: audio codec
1422 * @reg: codec register
1423 * @mask: register mask
1424 * @value: new value
1425 *
1426 * Writes new register value, and takes the codec mutex.
1427 *
1428 * Returns 1 for change else 0.
1429 */
1430static int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
1431 unsigned short reg, unsigned int mask,
1432 unsigned int value)
1433{
1434 int change;
1435
1436 mutex_lock(&codec->mutex);
1437 change = snd_soc_update_bits(codec, reg, mask, value);
1438 mutex_unlock(&codec->mutex);
1439
1440 return change;
1441}
1442
1443/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001444 * snd_soc_test_bits - test register for change
1445 * @codec: audio codec
1446 * @reg: codec register
1447 * @mask: register mask
1448 * @value: new value
1449 *
1450 * Tests a register with a new value and checks if the new value is
1451 * different from the old value.
1452 *
1453 * Returns 1 for change else 0.
1454 */
1455int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001456 unsigned int mask, unsigned int value)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001457{
1458 int change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001459 unsigned int old, new;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001460
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001461 old = snd_soc_read(codec, reg);
1462 new = (old & ~mask) | value;
1463 change = old != new;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001464
1465 return change;
1466}
1467EXPORT_SYMBOL_GPL(snd_soc_test_bits);
1468
1469/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001470 * snd_soc_new_pcms - create new sound card and pcms
1471 * @socdev: the SoC audio device
Mark Brownac11a2b2009-01-01 12:18:17 +00001472 * @idx: ALSA card index
1473 * @xid: card identification
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001474 *
1475 * Create a new sound card based upon the codec and interface pcms.
1476 *
1477 * Returns 0 for success, else error.
1478 */
Liam Girdwoodbc7320c2007-02-01 12:26:07 +01001479int snd_soc_new_pcms(struct snd_soc_device *socdev, int idx, const char *xid)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001480{
Mark Brown87506542008-11-18 20:50:34 +00001481 struct snd_soc_card *card = socdev->card;
Mark Brown6627a652009-01-23 22:55:23 +00001482 struct snd_soc_codec *codec = card->codec;
Takashi Iwaibd7dd772008-12-28 16:45:02 +01001483 int ret, i;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001484
1485 mutex_lock(&codec->mutex);
1486
1487 /* register a sound card */
Takashi Iwaibd7dd772008-12-28 16:45:02 +01001488 ret = snd_card_create(idx, xid, codec->owner, 0, &codec->card);
1489 if (ret < 0) {
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001490 printk(KERN_ERR "asoc: can't create sound card for codec %s\n",
1491 codec->name);
1492 mutex_unlock(&codec->mutex);
Takashi Iwaibd7dd772008-12-28 16:45:02 +01001493 return ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001494 }
1495
Mark Brown452c5ea2009-05-17 21:41:23 +01001496 codec->socdev = socdev;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001497 codec->card->dev = socdev->dev;
1498 codec->card->private_data = codec;
1499 strncpy(codec->card->driver, codec->name, sizeof(codec->card->driver));
1500
1501 /* create the pcms */
Mark Brown87506542008-11-18 20:50:34 +00001502 for (i = 0; i < card->num_links; i++) {
1503 ret = soc_new_pcm(socdev, &card->dai_link[i], i);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001504 if (ret < 0) {
1505 printk(KERN_ERR "asoc: can't create pcm %s\n",
Mark Brown87506542008-11-18 20:50:34 +00001506 card->dai_link[i].stream_name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001507 mutex_unlock(&codec->mutex);
1508 return ret;
1509 }
Barry Songf7732052009-11-12 12:01:47 +08001510 if (card->dai_link[i].codec_dai->ac97_control) {
1511 snd_ac97_dev_add_pdata(codec->ac97,
1512 card->dai_link[i].cpu_dai->ac97_pdata);
1513 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001514 }
1515
1516 mutex_unlock(&codec->mutex);
1517 return ret;
1518}
1519EXPORT_SYMBOL_GPL(snd_soc_new_pcms);
1520
1521/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001522 * snd_soc_free_pcms - free sound card and pcms
1523 * @socdev: the SoC audio device
1524 *
1525 * Frees sound card and pcms associated with the socdev.
1526 * Also unregister the codec if it is an AC97 device.
1527 */
1528void snd_soc_free_pcms(struct snd_soc_device *socdev)
1529{
Mark Brown6627a652009-01-23 22:55:23 +00001530 struct snd_soc_codec *codec = socdev->card->codec;
Liam Girdwooda68660e2007-05-10 19:27:27 +02001531#ifdef CONFIG_SND_SOC_AC97_BUS
Liam Girdwood3c4b2662008-07-07 16:07:17 +01001532 struct snd_soc_dai *codec_dai;
Liam Girdwooda68660e2007-05-10 19:27:27 +02001533 int i;
1534#endif
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001535
1536 mutex_lock(&codec->mutex);
Mark Brown6627a652009-01-23 22:55:23 +00001537 soc_cleanup_codec_debugfs(codec);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001538#ifdef CONFIG_SND_SOC_AC97_BUS
Mark Brown3ff3f642008-05-19 12:32:25 +02001539 for (i = 0; i < codec->num_dai; i++) {
Liam Girdwooda68660e2007-05-10 19:27:27 +02001540 codec_dai = &codec->dai[i];
Atsushi Nemotod2314e02009-03-16 23:26:20 +09001541 if (codec_dai->ac97_control && codec->ac97 &&
1542 strcmp(codec->name, "AC97") != 0) {
Liam Girdwooda68660e2007-05-10 19:27:27 +02001543 soc_ac97_dev_unregister(codec);
1544 goto free_card;
1545 }
1546 }
1547free_card:
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001548#endif
1549
1550 if (codec->card)
1551 snd_card_free(codec->card);
1552 device_remove_file(socdev->dev, &dev_attr_codec_reg);
1553 mutex_unlock(&codec->mutex);
1554}
1555EXPORT_SYMBOL_GPL(snd_soc_free_pcms);
1556
1557/**
1558 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
1559 * @substream: the pcm substream
1560 * @hw: the hardware parameters
1561 *
1562 * Sets the substream runtime hardware parameters.
1563 */
1564int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
1565 const struct snd_pcm_hardware *hw)
1566{
1567 struct snd_pcm_runtime *runtime = substream->runtime;
1568 runtime->hw.info = hw->info;
1569 runtime->hw.formats = hw->formats;
1570 runtime->hw.period_bytes_min = hw->period_bytes_min;
1571 runtime->hw.period_bytes_max = hw->period_bytes_max;
1572 runtime->hw.periods_min = hw->periods_min;
1573 runtime->hw.periods_max = hw->periods_max;
1574 runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
1575 runtime->hw.fifo_size = hw->fifo_size;
1576 return 0;
1577}
1578EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
1579
1580/**
1581 * snd_soc_cnew - create new control
1582 * @_template: control template
1583 * @data: control private data
Mark Brownac11a2b2009-01-01 12:18:17 +00001584 * @long_name: control long name
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001585 *
1586 * Create a new mixer control from a template control.
1587 *
1588 * Returns 0 for success, else error.
1589 */
1590struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
1591 void *data, char *long_name)
1592{
1593 struct snd_kcontrol_new template;
1594
1595 memcpy(&template, _template, sizeof(template));
1596 if (long_name)
1597 template.name = long_name;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001598 template.index = 0;
1599
1600 return snd_ctl_new1(&template, data);
1601}
1602EXPORT_SYMBOL_GPL(snd_soc_cnew);
1603
1604/**
Ian Molton3e8e1952009-01-09 00:23:21 +00001605 * snd_soc_add_controls - add an array of controls to a codec.
1606 * Convienience function to add a list of controls. Many codecs were
1607 * duplicating this code.
1608 *
1609 * @codec: codec to add controls to
1610 * @controls: array of controls to add
1611 * @num_controls: number of elements in the array
1612 *
1613 * Return 0 for success, else error.
1614 */
1615int snd_soc_add_controls(struct snd_soc_codec *codec,
1616 const struct snd_kcontrol_new *controls, int num_controls)
1617{
1618 struct snd_card *card = codec->card;
1619 int err, i;
1620
1621 for (i = 0; i < num_controls; i++) {
1622 const struct snd_kcontrol_new *control = &controls[i];
1623 err = snd_ctl_add(card, snd_soc_cnew(control, codec, NULL));
1624 if (err < 0) {
1625 dev_err(codec->dev, "%s: Failed to add %s\n",
1626 codec->name, control->name);
1627 return err;
1628 }
1629 }
1630
1631 return 0;
1632}
1633EXPORT_SYMBOL_GPL(snd_soc_add_controls);
1634
1635/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001636 * snd_soc_info_enum_double - enumerated double mixer info callback
1637 * @kcontrol: mixer control
1638 * @uinfo: control element information
1639 *
1640 * Callback to provide information about a double enumerated
1641 * mixer control.
1642 *
1643 * Returns 0 for success.
1644 */
1645int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
1646 struct snd_ctl_elem_info *uinfo)
1647{
1648 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1649
1650 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1651 uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01001652 uinfo->value.enumerated.items = e->max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001653
Jon Smirlf8ba0b72008-07-29 11:42:27 +01001654 if (uinfo->value.enumerated.item > e->max - 1)
1655 uinfo->value.enumerated.item = e->max - 1;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001656 strcpy(uinfo->value.enumerated.name,
1657 e->texts[uinfo->value.enumerated.item]);
1658 return 0;
1659}
1660EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
1661
1662/**
1663 * snd_soc_get_enum_double - enumerated double mixer get callback
1664 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00001665 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001666 *
1667 * Callback to get the value of a double enumerated mixer.
1668 *
1669 * Returns 0 for success.
1670 */
1671int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
1672 struct snd_ctl_elem_value *ucontrol)
1673{
1674 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1675 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001676 unsigned int val, bitmask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001677
Jon Smirlf8ba0b72008-07-29 11:42:27 +01001678 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001679 ;
1680 val = snd_soc_read(codec, e->reg);
Mark Brown3ff3f642008-05-19 12:32:25 +02001681 ucontrol->value.enumerated.item[0]
1682 = (val >> e->shift_l) & (bitmask - 1);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001683 if (e->shift_l != e->shift_r)
1684 ucontrol->value.enumerated.item[1] =
1685 (val >> e->shift_r) & (bitmask - 1);
1686
1687 return 0;
1688}
1689EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
1690
1691/**
1692 * snd_soc_put_enum_double - enumerated double mixer put callback
1693 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00001694 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001695 *
1696 * Callback to set the value of a double enumerated mixer.
1697 *
1698 * Returns 0 for success.
1699 */
1700int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
1701 struct snd_ctl_elem_value *ucontrol)
1702{
1703 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1704 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001705 unsigned int val;
1706 unsigned int mask, bitmask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001707
Jon Smirlf8ba0b72008-07-29 11:42:27 +01001708 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001709 ;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01001710 if (ucontrol->value.enumerated.item[0] > e->max - 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001711 return -EINVAL;
1712 val = ucontrol->value.enumerated.item[0] << e->shift_l;
1713 mask = (bitmask - 1) << e->shift_l;
1714 if (e->shift_l != e->shift_r) {
Jon Smirlf8ba0b72008-07-29 11:42:27 +01001715 if (ucontrol->value.enumerated.item[1] > e->max - 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001716 return -EINVAL;
1717 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
1718 mask |= (bitmask - 1) << e->shift_r;
1719 }
1720
Eero Nurkkala6c508c62009-10-30 13:34:03 +02001721 return snd_soc_update_bits_locked(codec, e->reg, mask, val);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001722}
1723EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
1724
1725/**
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02001726 * snd_soc_get_value_enum_double - semi enumerated double mixer get callback
1727 * @kcontrol: mixer control
1728 * @ucontrol: control element information
1729 *
1730 * Callback to get the value of a double semi enumerated mixer.
1731 *
1732 * Semi enumerated mixer: the enumerated items are referred as values. Can be
1733 * used for handling bitfield coded enumeration for example.
1734 *
1735 * Returns 0 for success.
1736 */
1737int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
1738 struct snd_ctl_elem_value *ucontrol)
1739{
1740 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Peter Ujfalusi74155552009-01-08 13:34:29 +02001741 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001742 unsigned int reg_val, val, mux;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02001743
1744 reg_val = snd_soc_read(codec, e->reg);
1745 val = (reg_val >> e->shift_l) & e->mask;
1746 for (mux = 0; mux < e->max; mux++) {
1747 if (val == e->values[mux])
1748 break;
1749 }
1750 ucontrol->value.enumerated.item[0] = mux;
1751 if (e->shift_l != e->shift_r) {
1752 val = (reg_val >> e->shift_r) & e->mask;
1753 for (mux = 0; mux < e->max; mux++) {
1754 if (val == e->values[mux])
1755 break;
1756 }
1757 ucontrol->value.enumerated.item[1] = mux;
1758 }
1759
1760 return 0;
1761}
1762EXPORT_SYMBOL_GPL(snd_soc_get_value_enum_double);
1763
1764/**
1765 * snd_soc_put_value_enum_double - semi enumerated double mixer put callback
1766 * @kcontrol: mixer control
1767 * @ucontrol: control element information
1768 *
1769 * Callback to set the value of a double semi enumerated mixer.
1770 *
1771 * Semi enumerated mixer: the enumerated items are referred as values. Can be
1772 * used for handling bitfield coded enumeration for example.
1773 *
1774 * Returns 0 for success.
1775 */
1776int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
1777 struct snd_ctl_elem_value *ucontrol)
1778{
1779 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Peter Ujfalusi74155552009-01-08 13:34:29 +02001780 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001781 unsigned int val;
1782 unsigned int mask;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02001783
1784 if (ucontrol->value.enumerated.item[0] > e->max - 1)
1785 return -EINVAL;
1786 val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
1787 mask = e->mask << e->shift_l;
1788 if (e->shift_l != e->shift_r) {
1789 if (ucontrol->value.enumerated.item[1] > e->max - 1)
1790 return -EINVAL;
1791 val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
1792 mask |= e->mask << e->shift_r;
1793 }
1794
Eero Nurkkala6c508c62009-10-30 13:34:03 +02001795 return snd_soc_update_bits_locked(codec, e->reg, mask, val);
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02001796}
1797EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double);
1798
1799/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001800 * snd_soc_info_enum_ext - external enumerated single mixer info callback
1801 * @kcontrol: mixer control
1802 * @uinfo: control element information
1803 *
1804 * Callback to provide information about an external enumerated
1805 * single mixer.
1806 *
1807 * Returns 0 for success.
1808 */
1809int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
1810 struct snd_ctl_elem_info *uinfo)
1811{
1812 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1813
1814 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1815 uinfo->count = 1;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01001816 uinfo->value.enumerated.items = e->max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001817
Jon Smirlf8ba0b72008-07-29 11:42:27 +01001818 if (uinfo->value.enumerated.item > e->max - 1)
1819 uinfo->value.enumerated.item = e->max - 1;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001820 strcpy(uinfo->value.enumerated.name,
1821 e->texts[uinfo->value.enumerated.item]);
1822 return 0;
1823}
1824EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
1825
1826/**
1827 * snd_soc_info_volsw_ext - external single mixer info callback
1828 * @kcontrol: mixer control
1829 * @uinfo: control element information
1830 *
1831 * Callback to provide information about a single external mixer control.
1832 *
1833 * Returns 0 for success.
1834 */
1835int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
1836 struct snd_ctl_elem_info *uinfo)
1837{
Philipp Zabela7a4ac82008-01-10 14:37:42 +01001838 int max = kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001839
Mark Brownfd5dfad2009-04-15 21:37:46 +01001840 if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
Philipp Zabela7a4ac82008-01-10 14:37:42 +01001841 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1842 else
1843 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1844
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001845 uinfo->count = 1;
1846 uinfo->value.integer.min = 0;
Philipp Zabela7a4ac82008-01-10 14:37:42 +01001847 uinfo->value.integer.max = max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001848 return 0;
1849}
1850EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
1851
1852/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001853 * snd_soc_info_volsw - single mixer info callback
1854 * @kcontrol: mixer control
1855 * @uinfo: control element information
1856 *
1857 * Callback to provide information about a single mixer control.
1858 *
1859 * Returns 0 for success.
1860 */
1861int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
1862 struct snd_ctl_elem_info *uinfo)
1863{
Jon Smirl4eaa9812008-07-29 11:42:26 +01001864 struct soc_mixer_control *mc =
1865 (struct soc_mixer_control *)kcontrol->private_value;
1866 int max = mc->max;
Mark Brown762b8df2008-10-30 12:37:08 +00001867 unsigned int shift = mc->shift;
Jon Smirl815ecf82008-07-29 10:22:24 -04001868 unsigned int rshift = mc->rshift;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001869
Mark Brownfd5dfad2009-04-15 21:37:46 +01001870 if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
Philipp Zabela7a4ac82008-01-10 14:37:42 +01001871 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1872 else
1873 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1874
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001875 uinfo->count = shift == rshift ? 1 : 2;
1876 uinfo->value.integer.min = 0;
Philipp Zabela7a4ac82008-01-10 14:37:42 +01001877 uinfo->value.integer.max = max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001878 return 0;
1879}
1880EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
1881
1882/**
1883 * snd_soc_get_volsw - single mixer get callback
1884 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00001885 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001886 *
1887 * Callback to get the value of a single mixer control.
1888 *
1889 * Returns 0 for success.
1890 */
1891int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
1892 struct snd_ctl_elem_value *ucontrol)
1893{
Jon Smirl4eaa9812008-07-29 11:42:26 +01001894 struct soc_mixer_control *mc =
1895 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001896 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf82008-07-29 10:22:24 -04001897 unsigned int reg = mc->reg;
1898 unsigned int shift = mc->shift;
1899 unsigned int rshift = mc->rshift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01001900 int max = mc->max;
Jon Smirl815ecf82008-07-29 10:22:24 -04001901 unsigned int mask = (1 << fls(max)) - 1;
1902 unsigned int invert = mc->invert;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001903
1904 ucontrol->value.integer.value[0] =
1905 (snd_soc_read(codec, reg) >> shift) & mask;
1906 if (shift != rshift)
1907 ucontrol->value.integer.value[1] =
1908 (snd_soc_read(codec, reg) >> rshift) & mask;
1909 if (invert) {
1910 ucontrol->value.integer.value[0] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01001911 max - ucontrol->value.integer.value[0];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001912 if (shift != rshift)
1913 ucontrol->value.integer.value[1] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01001914 max - ucontrol->value.integer.value[1];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001915 }
1916
1917 return 0;
1918}
1919EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
1920
1921/**
1922 * snd_soc_put_volsw - single mixer put callback
1923 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00001924 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001925 *
1926 * Callback to set the value of a single mixer control.
1927 *
1928 * Returns 0 for success.
1929 */
1930int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
1931 struct snd_ctl_elem_value *ucontrol)
1932{
Jon Smirl4eaa9812008-07-29 11:42:26 +01001933 struct soc_mixer_control *mc =
1934 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001935 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf82008-07-29 10:22:24 -04001936 unsigned int reg = mc->reg;
1937 unsigned int shift = mc->shift;
1938 unsigned int rshift = mc->rshift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01001939 int max = mc->max;
Jon Smirl815ecf82008-07-29 10:22:24 -04001940 unsigned int mask = (1 << fls(max)) - 1;
1941 unsigned int invert = mc->invert;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001942 unsigned int val, val2, val_mask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001943
1944 val = (ucontrol->value.integer.value[0] & mask);
1945 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01001946 val = max - val;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001947 val_mask = mask << shift;
1948 val = val << shift;
1949 if (shift != rshift) {
1950 val2 = (ucontrol->value.integer.value[1] & mask);
1951 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01001952 val2 = max - val2;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001953 val_mask |= mask << rshift;
1954 val |= val2 << rshift;
1955 }
Eero Nurkkala6c508c62009-10-30 13:34:03 +02001956 return snd_soc_update_bits_locked(codec, reg, val_mask, val);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001957}
1958EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
1959
1960/**
1961 * snd_soc_info_volsw_2r - double mixer info callback
1962 * @kcontrol: mixer control
1963 * @uinfo: control element information
1964 *
1965 * Callback to provide information about a double mixer control that
1966 * spans 2 codec registers.
1967 *
1968 * Returns 0 for success.
1969 */
1970int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
1971 struct snd_ctl_elem_info *uinfo)
1972{
Jon Smirl4eaa9812008-07-29 11:42:26 +01001973 struct soc_mixer_control *mc =
1974 (struct soc_mixer_control *)kcontrol->private_value;
1975 int max = mc->max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001976
Mark Brownfd5dfad2009-04-15 21:37:46 +01001977 if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
Philipp Zabela7a4ac82008-01-10 14:37:42 +01001978 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1979 else
1980 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1981
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001982 uinfo->count = 2;
1983 uinfo->value.integer.min = 0;
Philipp Zabela7a4ac82008-01-10 14:37:42 +01001984 uinfo->value.integer.max = max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001985 return 0;
1986}
1987EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r);
1988
1989/**
1990 * snd_soc_get_volsw_2r - double mixer get callback
1991 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00001992 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001993 *
1994 * Callback to get the value of a double mixer control that spans 2 registers.
1995 *
1996 * Returns 0 for success.
1997 */
1998int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
1999 struct snd_ctl_elem_value *ucontrol)
2000{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002001 struct soc_mixer_control *mc =
2002 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002003 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf82008-07-29 10:22:24 -04002004 unsigned int reg = mc->reg;
2005 unsigned int reg2 = mc->rreg;
2006 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002007 int max = mc->max;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002008 unsigned int mask = (1 << fls(max)) - 1;
Jon Smirl815ecf82008-07-29 10:22:24 -04002009 unsigned int invert = mc->invert;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002010
2011 ucontrol->value.integer.value[0] =
2012 (snd_soc_read(codec, reg) >> shift) & mask;
2013 ucontrol->value.integer.value[1] =
2014 (snd_soc_read(codec, reg2) >> shift) & mask;
2015 if (invert) {
2016 ucontrol->value.integer.value[0] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002017 max - ucontrol->value.integer.value[0];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002018 ucontrol->value.integer.value[1] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002019 max - ucontrol->value.integer.value[1];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002020 }
2021
2022 return 0;
2023}
2024EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r);
2025
2026/**
2027 * snd_soc_put_volsw_2r - double mixer set callback
2028 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002029 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002030 *
2031 * Callback to set the value of a double mixer control that spans 2 registers.
2032 *
2033 * Returns 0 for success.
2034 */
2035int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
2036 struct snd_ctl_elem_value *ucontrol)
2037{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002038 struct soc_mixer_control *mc =
2039 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002040 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf82008-07-29 10:22:24 -04002041 unsigned int reg = mc->reg;
2042 unsigned int reg2 = mc->rreg;
2043 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002044 int max = mc->max;
Jon Smirl815ecf82008-07-29 10:22:24 -04002045 unsigned int mask = (1 << fls(max)) - 1;
2046 unsigned int invert = mc->invert;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002047 int err;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002048 unsigned int val, val2, val_mask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002049
2050 val_mask = mask << shift;
2051 val = (ucontrol->value.integer.value[0] & mask);
2052 val2 = (ucontrol->value.integer.value[1] & mask);
2053
2054 if (invert) {
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002055 val = max - val;
2056 val2 = max - val2;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002057 }
2058
2059 val = val << shift;
2060 val2 = val2 << shift;
2061
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002062 err = snd_soc_update_bits_locked(codec, reg, val_mask, val);
Mark Brown3ff3f642008-05-19 12:32:25 +02002063 if (err < 0)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002064 return err;
2065
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002066 err = snd_soc_update_bits_locked(codec, reg2, val_mask, val2);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002067 return err;
2068}
2069EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r);
2070
Mark Browne13ac2e2008-05-28 17:58:05 +01002071/**
2072 * snd_soc_info_volsw_s8 - signed mixer info callback
2073 * @kcontrol: mixer control
2074 * @uinfo: control element information
2075 *
2076 * Callback to provide information about a signed mixer control.
2077 *
2078 * Returns 0 for success.
2079 */
2080int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
2081 struct snd_ctl_elem_info *uinfo)
2082{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002083 struct soc_mixer_control *mc =
2084 (struct soc_mixer_control *)kcontrol->private_value;
2085 int max = mc->max;
2086 int min = mc->min;
Mark Browne13ac2e2008-05-28 17:58:05 +01002087
2088 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2089 uinfo->count = 2;
2090 uinfo->value.integer.min = 0;
2091 uinfo->value.integer.max = max-min;
2092 return 0;
2093}
2094EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
2095
2096/**
2097 * snd_soc_get_volsw_s8 - signed mixer get callback
2098 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002099 * @ucontrol: control element information
Mark Browne13ac2e2008-05-28 17:58:05 +01002100 *
2101 * Callback to get the value of a signed mixer control.
2102 *
2103 * Returns 0 for success.
2104 */
2105int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
2106 struct snd_ctl_elem_value *ucontrol)
2107{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002108 struct soc_mixer_control *mc =
2109 (struct soc_mixer_control *)kcontrol->private_value;
Mark Browne13ac2e2008-05-28 17:58:05 +01002110 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf82008-07-29 10:22:24 -04002111 unsigned int reg = mc->reg;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002112 int min = mc->min;
Mark Browne13ac2e2008-05-28 17:58:05 +01002113 int val = snd_soc_read(codec, reg);
2114
2115 ucontrol->value.integer.value[0] =
2116 ((signed char)(val & 0xff))-min;
2117 ucontrol->value.integer.value[1] =
2118 ((signed char)((val >> 8) & 0xff))-min;
2119 return 0;
2120}
2121EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
2122
2123/**
2124 * snd_soc_put_volsw_sgn - signed mixer put callback
2125 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002126 * @ucontrol: control element information
Mark Browne13ac2e2008-05-28 17:58:05 +01002127 *
2128 * Callback to set the value of a signed mixer control.
2129 *
2130 * Returns 0 for success.
2131 */
2132int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
2133 struct snd_ctl_elem_value *ucontrol)
2134{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002135 struct soc_mixer_control *mc =
2136 (struct soc_mixer_control *)kcontrol->private_value;
Mark Browne13ac2e2008-05-28 17:58:05 +01002137 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf82008-07-29 10:22:24 -04002138 unsigned int reg = mc->reg;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002139 int min = mc->min;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002140 unsigned int val;
Mark Browne13ac2e2008-05-28 17:58:05 +01002141
2142 val = (ucontrol->value.integer.value[0]+min) & 0xff;
2143 val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
2144
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002145 return snd_soc_update_bits_locked(codec, reg, 0xffff, val);
Mark Browne13ac2e2008-05-28 17:58:05 +01002146}
2147EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
2148
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002149/**
2150 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2151 * @dai: DAI
2152 * @clk_id: DAI specific clock ID
2153 * @freq: new clock frequency in Hz
2154 * @dir: new clock direction - input/output.
2155 *
2156 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2157 */
2158int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2159 unsigned int freq, int dir)
2160{
Mark Brown3f1a4d82009-04-15 21:35:26 +01002161 if (dai->ops && dai->ops->set_sysclk)
Eric Miao6335d052009-03-03 09:41:00 +08002162 return dai->ops->set_sysclk(dai, clk_id, freq, dir);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002163 else
2164 return -EINVAL;
2165}
2166EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
2167
2168/**
2169 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
2170 * @dai: DAI
Mark Brownac11a2b2009-01-01 12:18:17 +00002171 * @div_id: DAI specific clock divider ID
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002172 * @div: new clock divisor.
2173 *
2174 * Configures the clock dividers. This is used to derive the best DAI bit and
2175 * frame clocks from the system or master clock. It's best to set the DAI bit
2176 * and frame clocks as low as possible to save system power.
2177 */
2178int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2179 int div_id, int div)
2180{
Mark Brown3f1a4d82009-04-15 21:35:26 +01002181 if (dai->ops && dai->ops->set_clkdiv)
Eric Miao6335d052009-03-03 09:41:00 +08002182 return dai->ops->set_clkdiv(dai, div_id, div);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002183 else
2184 return -EINVAL;
2185}
2186EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
2187
2188/**
2189 * snd_soc_dai_set_pll - configure DAI PLL.
2190 * @dai: DAI
2191 * @pll_id: DAI specific PLL ID
Mark Brown85488032009-09-05 18:52:16 +01002192 * @source: DAI specific source for the PLL
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002193 * @freq_in: PLL input clock frequency in Hz
2194 * @freq_out: requested PLL output clock frequency in Hz
2195 *
2196 * Configures and enables PLL to generate output clock based on input clock.
2197 */
Mark Brown85488032009-09-05 18:52:16 +01002198int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
2199 unsigned int freq_in, unsigned int freq_out)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002200{
Mark Brown3f1a4d82009-04-15 21:35:26 +01002201 if (dai->ops && dai->ops->set_pll)
Mark Brown85488032009-09-05 18:52:16 +01002202 return dai->ops->set_pll(dai, pll_id, source,
2203 freq_in, freq_out);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002204 else
2205 return -EINVAL;
2206}
2207EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
2208
2209/**
2210 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
2211 * @dai: DAI
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002212 * @fmt: SND_SOC_DAIFMT_ format value.
2213 *
2214 * Configures the DAI hardware format and clocking.
2215 */
2216int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2217{
Mark Brown3f1a4d82009-04-15 21:35:26 +01002218 if (dai->ops && dai->ops->set_fmt)
Eric Miao6335d052009-03-03 09:41:00 +08002219 return dai->ops->set_fmt(dai, fmt);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002220 else
2221 return -EINVAL;
2222}
2223EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
2224
2225/**
2226 * snd_soc_dai_set_tdm_slot - configure DAI TDM.
2227 * @dai: DAI
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002228 * @tx_mask: bitmask representing active TX slots.
2229 * @rx_mask: bitmask representing active RX slots.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002230 * @slots: Number of slots in use.
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002231 * @slot_width: Width in bits for each slot.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002232 *
2233 * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
2234 * specific.
2235 */
2236int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002237 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002238{
Mark Brown3f1a4d82009-04-15 21:35:26 +01002239 if (dai->ops && dai->ops->set_tdm_slot)
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002240 return dai->ops->set_tdm_slot(dai, tx_mask, rx_mask,
2241 slots, slot_width);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002242 else
2243 return -EINVAL;
2244}
2245EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
2246
2247/**
Barry Song472df3c2009-09-12 01:16:29 +08002248 * snd_soc_dai_set_channel_map - configure DAI audio channel map
2249 * @dai: DAI
2250 * @tx_num: how many TX channels
2251 * @tx_slot: pointer to an array which imply the TX slot number channel
2252 * 0~num-1 uses
2253 * @rx_num: how many RX channels
2254 * @rx_slot: pointer to an array which imply the RX slot number channel
2255 * 0~num-1 uses
2256 *
2257 * configure the relationship between channel number and TDM slot number.
2258 */
2259int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
2260 unsigned int tx_num, unsigned int *tx_slot,
2261 unsigned int rx_num, unsigned int *rx_slot)
2262{
2263 if (dai->ops && dai->ops->set_channel_map)
2264 return dai->ops->set_channel_map(dai, tx_num, tx_slot,
2265 rx_num, rx_slot);
2266 else
2267 return -EINVAL;
2268}
2269EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
2270
2271/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002272 * snd_soc_dai_set_tristate - configure DAI system or master clock.
2273 * @dai: DAI
2274 * @tristate: tristate enable
2275 *
2276 * Tristates the DAI so that others can use it.
2277 */
2278int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
2279{
Mark Brown3f1a4d82009-04-15 21:35:26 +01002280 if (dai->ops && dai->ops->set_tristate)
Eric Miao6335d052009-03-03 09:41:00 +08002281 return dai->ops->set_tristate(dai, tristate);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002282 else
2283 return -EINVAL;
2284}
2285EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
2286
2287/**
2288 * snd_soc_dai_digital_mute - configure DAI system or master clock.
2289 * @dai: DAI
2290 * @mute: mute enable
2291 *
2292 * Mutes the DAI DAC.
2293 */
2294int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
2295{
Mark Brown3f1a4d82009-04-15 21:35:26 +01002296 if (dai->ops && dai->ops->digital_mute)
Eric Miao6335d052009-03-03 09:41:00 +08002297 return dai->ops->digital_mute(dai, mute);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002298 else
2299 return -EINVAL;
2300}
2301EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
2302
Mark Brownc5af3a22008-11-28 13:29:45 +00002303/**
2304 * snd_soc_register_card - Register a card with the ASoC core
2305 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002306 * @card: Card to register
Mark Brownc5af3a22008-11-28 13:29:45 +00002307 *
2308 * Note that currently this is an internal only function: it will be
2309 * exposed to machine drivers after further backporting of ASoC v2
2310 * registration APIs.
2311 */
2312static int snd_soc_register_card(struct snd_soc_card *card)
2313{
2314 if (!card->name || !card->dev)
2315 return -EINVAL;
2316
2317 INIT_LIST_HEAD(&card->list);
2318 card->instantiated = 0;
2319
2320 mutex_lock(&client_mutex);
2321 list_add(&card->list, &card_list);
Mark Brown435c5e22008-12-04 15:32:53 +00002322 snd_soc_instantiate_cards();
Mark Brownc5af3a22008-11-28 13:29:45 +00002323 mutex_unlock(&client_mutex);
2324
2325 dev_dbg(card->dev, "Registered card '%s'\n", card->name);
2326
2327 return 0;
2328}
2329
2330/**
2331 * snd_soc_unregister_card - Unregister a card with the ASoC core
2332 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002333 * @card: Card to unregister
Mark Brownc5af3a22008-11-28 13:29:45 +00002334 *
2335 * Note that currently this is an internal only function: it will be
2336 * exposed to machine drivers after further backporting of ASoC v2
2337 * registration APIs.
2338 */
2339static int snd_soc_unregister_card(struct snd_soc_card *card)
2340{
2341 mutex_lock(&client_mutex);
2342 list_del(&card->list);
2343 mutex_unlock(&client_mutex);
2344
2345 dev_dbg(card->dev, "Unregistered card '%s'\n", card->name);
2346
2347 return 0;
2348}
2349
Mark Brown91151712008-11-30 23:31:24 +00002350/**
2351 * snd_soc_register_dai - Register a DAI with the ASoC core
2352 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002353 * @dai: DAI to register
Mark Brown91151712008-11-30 23:31:24 +00002354 */
2355int snd_soc_register_dai(struct snd_soc_dai *dai)
2356{
2357 if (!dai->name)
2358 return -EINVAL;
2359
2360 /* The device should become mandatory over time */
2361 if (!dai->dev)
2362 printk(KERN_WARNING "No device for DAI %s\n", dai->name);
2363
Eric Miao6335d052009-03-03 09:41:00 +08002364 if (!dai->ops)
2365 dai->ops = &null_dai_ops;
2366
Mark Brown91151712008-11-30 23:31:24 +00002367 INIT_LIST_HEAD(&dai->list);
2368
2369 mutex_lock(&client_mutex);
2370 list_add(&dai->list, &dai_list);
Mark Brown435c5e22008-12-04 15:32:53 +00002371 snd_soc_instantiate_cards();
Mark Brown91151712008-11-30 23:31:24 +00002372 mutex_unlock(&client_mutex);
2373
2374 pr_debug("Registered DAI '%s'\n", dai->name);
2375
2376 return 0;
2377}
2378EXPORT_SYMBOL_GPL(snd_soc_register_dai);
2379
2380/**
2381 * snd_soc_unregister_dai - Unregister a DAI from the ASoC core
2382 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002383 * @dai: DAI to unregister
Mark Brown91151712008-11-30 23:31:24 +00002384 */
2385void snd_soc_unregister_dai(struct snd_soc_dai *dai)
2386{
2387 mutex_lock(&client_mutex);
2388 list_del(&dai->list);
2389 mutex_unlock(&client_mutex);
2390
2391 pr_debug("Unregistered DAI '%s'\n", dai->name);
2392}
2393EXPORT_SYMBOL_GPL(snd_soc_unregister_dai);
2394
2395/**
2396 * snd_soc_register_dais - Register multiple DAIs with the ASoC core
2397 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002398 * @dai: Array of DAIs to register
2399 * @count: Number of DAIs
Mark Brown91151712008-11-30 23:31:24 +00002400 */
2401int snd_soc_register_dais(struct snd_soc_dai *dai, size_t count)
2402{
2403 int i, ret;
2404
2405 for (i = 0; i < count; i++) {
2406 ret = snd_soc_register_dai(&dai[i]);
2407 if (ret != 0)
2408 goto err;
2409 }
2410
2411 return 0;
2412
2413err:
2414 for (i--; i >= 0; i--)
2415 snd_soc_unregister_dai(&dai[i]);
2416
2417 return ret;
2418}
2419EXPORT_SYMBOL_GPL(snd_soc_register_dais);
2420
2421/**
2422 * snd_soc_unregister_dais - Unregister multiple DAIs from the ASoC core
2423 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002424 * @dai: Array of DAIs to unregister
2425 * @count: Number of DAIs
Mark Brown91151712008-11-30 23:31:24 +00002426 */
2427void snd_soc_unregister_dais(struct snd_soc_dai *dai, size_t count)
2428{
2429 int i;
2430
2431 for (i = 0; i < count; i++)
2432 snd_soc_unregister_dai(&dai[i]);
2433}
2434EXPORT_SYMBOL_GPL(snd_soc_unregister_dais);
2435
Mark Brown12a48a8c2008-12-03 19:40:30 +00002436/**
2437 * snd_soc_register_platform - Register a platform with the ASoC core
2438 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002439 * @platform: platform to register
Mark Brown12a48a8c2008-12-03 19:40:30 +00002440 */
2441int snd_soc_register_platform(struct snd_soc_platform *platform)
2442{
2443 if (!platform->name)
2444 return -EINVAL;
2445
2446 INIT_LIST_HEAD(&platform->list);
2447
2448 mutex_lock(&client_mutex);
2449 list_add(&platform->list, &platform_list);
Mark Brown435c5e22008-12-04 15:32:53 +00002450 snd_soc_instantiate_cards();
Mark Brown12a48a8c2008-12-03 19:40:30 +00002451 mutex_unlock(&client_mutex);
2452
2453 pr_debug("Registered platform '%s'\n", platform->name);
2454
2455 return 0;
2456}
2457EXPORT_SYMBOL_GPL(snd_soc_register_platform);
2458
2459/**
2460 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
2461 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002462 * @platform: platform to unregister
Mark Brown12a48a8c2008-12-03 19:40:30 +00002463 */
2464void snd_soc_unregister_platform(struct snd_soc_platform *platform)
2465{
2466 mutex_lock(&client_mutex);
2467 list_del(&platform->list);
2468 mutex_unlock(&client_mutex);
2469
2470 pr_debug("Unregistered platform '%s'\n", platform->name);
2471}
2472EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
2473
Mark Brown151ab222009-05-09 16:22:58 +01002474static u64 codec_format_map[] = {
2475 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
2476 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
2477 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
2478 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
2479 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
2480 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
2481 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
2482 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
2483 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
2484 SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
2485 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
2486 SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
2487 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
2488 SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
2489 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
2490 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
2491};
2492
2493/* Fix up the DAI formats for endianness: codecs don't actually see
2494 * the endianness of the data but we're using the CPU format
2495 * definitions which do need to include endianness so we ensure that
2496 * codec DAIs always have both big and little endian variants set.
2497 */
2498static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
2499{
2500 int i;
2501
2502 for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
2503 if (stream->formats & codec_format_map[i])
2504 stream->formats |= codec_format_map[i];
2505}
2506
Mark Brown0d0cf002008-12-10 14:32:45 +00002507/**
2508 * snd_soc_register_codec - Register a codec with the ASoC core
2509 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002510 * @codec: codec to register
Mark Brown0d0cf002008-12-10 14:32:45 +00002511 */
2512int snd_soc_register_codec(struct snd_soc_codec *codec)
2513{
Mark Brown151ab222009-05-09 16:22:58 +01002514 int i;
2515
Mark Brown0d0cf002008-12-10 14:32:45 +00002516 if (!codec->name)
2517 return -EINVAL;
2518
2519 /* The device should become mandatory over time */
2520 if (!codec->dev)
2521 printk(KERN_WARNING "No device for codec %s\n", codec->name);
2522
2523 INIT_LIST_HEAD(&codec->list);
2524
Mark Brown151ab222009-05-09 16:22:58 +01002525 for (i = 0; i < codec->num_dai; i++) {
2526 fixup_codec_formats(&codec->dai[i].playback);
2527 fixup_codec_formats(&codec->dai[i].capture);
2528 }
2529
Mark Brown0d0cf002008-12-10 14:32:45 +00002530 mutex_lock(&client_mutex);
2531 list_add(&codec->list, &codec_list);
2532 snd_soc_instantiate_cards();
2533 mutex_unlock(&client_mutex);
2534
2535 pr_debug("Registered codec '%s'\n", codec->name);
2536
2537 return 0;
2538}
2539EXPORT_SYMBOL_GPL(snd_soc_register_codec);
2540
2541/**
2542 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
2543 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002544 * @codec: codec to unregister
Mark Brown0d0cf002008-12-10 14:32:45 +00002545 */
2546void snd_soc_unregister_codec(struct snd_soc_codec *codec)
2547{
2548 mutex_lock(&client_mutex);
2549 list_del(&codec->list);
2550 mutex_unlock(&client_mutex);
2551
2552 pr_debug("Unregistered codec '%s'\n", codec->name);
2553}
2554EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
2555
Takashi Iwaic9b3a402008-12-10 07:47:22 +01002556static int __init snd_soc_init(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002557{
Mark Brown384c89e2008-12-03 17:34:03 +00002558#ifdef CONFIG_DEBUG_FS
2559 debugfs_root = debugfs_create_dir("asoc", NULL);
2560 if (IS_ERR(debugfs_root) || !debugfs_root) {
2561 printk(KERN_WARNING
2562 "ASoC: Failed to create debugfs directory\n");
2563 debugfs_root = NULL;
2564 }
2565#endif
2566
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002567 return platform_driver_register(&soc_driver);
2568}
2569
Mark Brown7d8c16a2008-11-30 22:11:24 +00002570static void __exit snd_soc_exit(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002571{
Mark Brown384c89e2008-12-03 17:34:03 +00002572#ifdef CONFIG_DEBUG_FS
2573 debugfs_remove_recursive(debugfs_root);
2574#endif
Mark Brown3ff3f642008-05-19 12:32:25 +02002575 platform_driver_unregister(&soc_driver);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002576}
2577
2578module_init(snd_soc_init);
2579module_exit(snd_soc_exit);
2580
2581/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01002582MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002583MODULE_DESCRIPTION("ALSA SoC Core");
2584MODULE_LICENSE("GPL");
Kay Sievers8b45a202008-04-14 13:33:36 +02002585MODULE_ALIAS("platform:soc-audio");