blob: d75043ed7fc0551f66881675df110dede0d5ccf0 [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.
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00006 * Copyright (C) 2010 Slimlogic Ltd.
7 * Copyright (C) 2010 Texas Instruments Inc.
Liam Girdwood0664d882006-12-18 14:39:02 +01008 *
Liam Girdwoodd3311242008-10-12 13:17:36 +01009 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
Liam Girdwood0664d882006-12-18 14:39:02 +010010 * with code, comments and ideas from :-
11 * Richard Purdie <richard@openedhand.com>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020012 *
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2 of the License, or (at your
16 * option) any later version.
17 *
Frank Mandarinodb2a4162006-10-06 18:31:09 +020018 * TODO:
19 * o Add hw rules to enforce rates, etc.
20 * o More testing with other codecs/machines.
21 * o Add more codecs and platforms to ensure good API coverage.
22 * o Support TDM on PCM and I2S
23 */
24
25#include <linux/module.h>
26#include <linux/moduleparam.h>
27#include <linux/init.h>
28#include <linux/delay.h>
29#include <linux/pm.h>
30#include <linux/bitops.h>
Troy Kisky12ef1932008-10-13 17:42:14 -070031#include <linux/debugfs.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020032#include <linux/platform_device.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090033#include <linux/slab.h>
Marek Vasut474828a2009-07-22 13:01:03 +020034#include <sound/ac97_codec.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020035#include <sound/core.h>
Mark Brown3028eb82010-12-05 12:22:46 +000036#include <sound/jack.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020037#include <sound/pcm.h>
38#include <sound/pcm_params.h>
39#include <sound/soc.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020040#include <sound/initval.h>
41
Mark Browna8b1d342010-11-03 18:05:58 -040042#define CREATE_TRACE_POINTS
43#include <trace/events/asoc.h>
44
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +000045#define NAME_SIZE 32
46
Frank Mandarinodb2a4162006-10-06 18:31:09 +020047static DEFINE_MUTEX(pcm_mutex);
Frank Mandarinodb2a4162006-10-06 18:31:09 +020048static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
49
Mark Brown384c89e2008-12-03 17:34:03 +000050#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +000051struct dentry *snd_soc_debugfs_root;
52EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
Mark Brown384c89e2008-12-03 17:34:03 +000053#endif
54
Mark Brownc5af3a22008-11-28 13:29:45 +000055static DEFINE_MUTEX(client_mutex);
56static LIST_HEAD(card_list);
Mark Brown91151712008-11-30 23:31:24 +000057static LIST_HEAD(dai_list);
Mark Brown12a48a8c2008-12-03 19:40:30 +000058static LIST_HEAD(platform_list);
Mark Brown0d0cf002008-12-10 14:32:45 +000059static LIST_HEAD(codec_list);
Mark Brownc5af3a22008-11-28 13:29:45 +000060
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +000061static int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num);
Mark Brownc5af3a22008-11-28 13:29:45 +000062
Frank Mandarinodb2a4162006-10-06 18:31:09 +020063/*
64 * This is a timeout to do a DAPM powerdown after a stream is closed().
65 * It can be used to eliminate pops between different playback streams, e.g.
66 * between two audio tracks.
67 */
68static int pmdown_time = 5000;
69module_param(pmdown_time, int, 0);
70MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
71
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +000072/* returns the minimum number of bytes needed to represent
73 * a particular given value */
74static int min_bytes_needed(unsigned long val)
75{
76 int c = 0;
77 int i;
78
79 for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)
80 if (val & (1UL << i))
81 break;
82 c = (sizeof val * 8) - c;
83 if (!c || (c % 8))
84 c = (c + 8) / 8;
85 else
86 c /= 8;
87 return c;
88}
89
Dimitris Papastamos13fd1792011-02-02 13:58:58 +000090/* fill buf which is 'len' bytes with a formatted
91 * string of the form 'reg: value\n' */
92static int format_register_str(struct snd_soc_codec *codec,
93 unsigned int reg, char *buf, size_t len)
Mark Brown2624d5f2009-11-03 21:56:13 +000094{
Stephen Warren00b317a2011-04-01 14:50:44 -060095 int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
96 int regsize = codec->driver->reg_word_size * 2;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +000097 int ret;
98 char tmpbuf[len + 1];
99 char regbuf[regsize + 1];
100
101 /* since tmpbuf is allocated on the stack, warn the callers if they
102 * try to abuse this function */
103 WARN_ON(len > 63);
104
105 /* +2 for ': ' and + 1 for '\n' */
106 if (wordsize + regsize + 2 + 1 != len)
107 return -EINVAL;
108
109 ret = snd_soc_read(codec , reg);
110 if (ret < 0) {
111 memset(regbuf, 'X', regsize);
112 regbuf[regsize] = '\0';
113 } else {
114 snprintf(regbuf, regsize + 1, "%.*x", regsize, ret);
115 }
116
117 /* prepare the buffer */
118 snprintf(tmpbuf, len + 1, "%.*x: %s\n", wordsize, reg, regbuf);
119 /* copy it back to the caller without the '\0' */
120 memcpy(buf, tmpbuf, len);
121
122 return 0;
123}
124
125/* codec register dump */
126static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
127 size_t count, loff_t pos)
128{
129 int i, step = 1;
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +0000130 int wordsize, regsize;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000131 int len;
132 size_t total = 0;
133 loff_t p = 0;
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +0000134
Stephen Warren00b317a2011-04-01 14:50:44 -0600135 wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
136 regsize = codec->driver->reg_word_size * 2;
Mark Brown2624d5f2009-11-03 21:56:13 +0000137
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000138 len = wordsize + regsize + 2 + 1;
139
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000140 if (!codec->driver->reg_cache_size)
Mark Brown2624d5f2009-11-03 21:56:13 +0000141 return 0;
142
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000143 if (codec->driver->reg_cache_step)
144 step = codec->driver->reg_cache_step;
Mark Brown2624d5f2009-11-03 21:56:13 +0000145
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000146 for (i = 0; i < codec->driver->reg_cache_size; i += step) {
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +0000147 if (codec->readable_register && !codec->readable_register(codec, i))
Mark Brown2624d5f2009-11-03 21:56:13 +0000148 continue;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000149 if (codec->driver->display_register) {
150 count += codec->driver->display_register(codec, buf + count,
Mark Brown2624d5f2009-11-03 21:56:13 +0000151 PAGE_SIZE - count, i);
Mark Brown5164d742010-07-14 16:14:33 +0100152 } else {
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000153 /* only support larger than PAGE_SIZE bytes debugfs
154 * entries for the default case */
155 if (p >= pos) {
156 if (total + len >= count - 1)
157 break;
158 format_register_str(codec, i, buf + total, len);
159 total += len;
160 }
161 p += len;
Mark Brown5164d742010-07-14 16:14:33 +0100162 }
Mark Brown2624d5f2009-11-03 21:56:13 +0000163 }
164
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000165 total = min(total, count - 1);
Mark Brown2624d5f2009-11-03 21:56:13 +0000166
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000167 return total;
Mark Brown2624d5f2009-11-03 21:56:13 +0000168}
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000169
Mark Brown2624d5f2009-11-03 21:56:13 +0000170static ssize_t codec_reg_show(struct device *dev,
171 struct device_attribute *attr, char *buf)
172{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000173 struct snd_soc_pcm_runtime *rtd =
174 container_of(dev, struct snd_soc_pcm_runtime, dev);
175
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000176 return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);
Mark Brown2624d5f2009-11-03 21:56:13 +0000177}
178
179static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
180
Mark Browndbe21402010-02-12 11:37:24 +0000181static ssize_t pmdown_time_show(struct device *dev,
182 struct device_attribute *attr, char *buf)
183{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000184 struct snd_soc_pcm_runtime *rtd =
185 container_of(dev, struct snd_soc_pcm_runtime, dev);
Mark Browndbe21402010-02-12 11:37:24 +0000186
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000187 return sprintf(buf, "%ld\n", rtd->pmdown_time);
Mark Browndbe21402010-02-12 11:37:24 +0000188}
189
190static ssize_t pmdown_time_set(struct device *dev,
191 struct device_attribute *attr,
192 const char *buf, size_t count)
193{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000194 struct snd_soc_pcm_runtime *rtd =
195 container_of(dev, struct snd_soc_pcm_runtime, dev);
Mark Brownc593b522010-10-27 20:11:17 -0700196 int ret;
Mark Browndbe21402010-02-12 11:37:24 +0000197
Mark Brownc593b522010-10-27 20:11:17 -0700198 ret = strict_strtol(buf, 10, &rtd->pmdown_time);
199 if (ret)
200 return ret;
Mark Browndbe21402010-02-12 11:37:24 +0000201
202 return count;
203}
204
205static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
206
Mark Brown2624d5f2009-11-03 21:56:13 +0000207#ifdef CONFIG_DEBUG_FS
208static int codec_reg_open_file(struct inode *inode, struct file *file)
209{
210 file->private_data = inode->i_private;
211 return 0;
212}
213
214static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000215 size_t count, loff_t *ppos)
Mark Brown2624d5f2009-11-03 21:56:13 +0000216{
217 ssize_t ret;
218 struct snd_soc_codec *codec = file->private_data;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000219 char *buf;
220
221 if (*ppos < 0 || !count)
222 return -EINVAL;
223
224 buf = kmalloc(count, GFP_KERNEL);
Mark Brown2624d5f2009-11-03 21:56:13 +0000225 if (!buf)
226 return -ENOMEM;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000227
228 ret = soc_codec_reg_show(codec, buf, count, *ppos);
229 if (ret >= 0) {
230 if (copy_to_user(user_buf, buf, ret)) {
231 kfree(buf);
232 return -EFAULT;
233 }
234 *ppos += ret;
235 }
236
Mark Brown2624d5f2009-11-03 21:56:13 +0000237 kfree(buf);
238 return ret;
239}
240
241static ssize_t codec_reg_write_file(struct file *file,
242 const char __user *user_buf, size_t count, loff_t *ppos)
243{
244 char buf[32];
Stephen Boyd34e268d2011-05-12 16:50:10 -0700245 size_t buf_size;
Mark Brown2624d5f2009-11-03 21:56:13 +0000246 char *start = buf;
247 unsigned long reg, value;
248 int step = 1;
249 struct snd_soc_codec *codec = file->private_data;
250
251 buf_size = min(count, (sizeof(buf)-1));
252 if (copy_from_user(buf, user_buf, buf_size))
253 return -EFAULT;
254 buf[buf_size] = 0;
255
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000256 if (codec->driver->reg_cache_step)
257 step = codec->driver->reg_cache_step;
Mark Brown2624d5f2009-11-03 21:56:13 +0000258
259 while (*start == ' ')
260 start++;
261 reg = simple_strtoul(start, &start, 16);
Mark Brown2624d5f2009-11-03 21:56:13 +0000262 while (*start == ' ')
263 start++;
264 if (strict_strtoul(start, 16, &value))
265 return -EINVAL;
Mark Brown0d51a9c2011-01-06 16:04:57 +0000266
267 /* Userspace has been fiddling around behind the kernel's back */
268 add_taint(TAINT_USER);
269
Dimitris Papastamose4f078d2010-12-07 16:30:38 +0000270 snd_soc_write(codec, reg, value);
Mark Brown2624d5f2009-11-03 21:56:13 +0000271 return buf_size;
272}
273
274static const struct file_operations codec_reg_fops = {
275 .open = codec_reg_open_file,
276 .read = codec_reg_read_file,
277 .write = codec_reg_write_file,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200278 .llseek = default_llseek,
Mark Brown2624d5f2009-11-03 21:56:13 +0000279};
280
281static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
282{
Jarkko Nikulad6ce4cf2010-11-05 20:35:20 +0200283 struct dentry *debugfs_card_root = codec->card->debugfs_card_root;
284
285 codec->debugfs_codec_root = debugfs_create_dir(codec->name,
286 debugfs_card_root);
Mark Brown2624d5f2009-11-03 21:56:13 +0000287 if (!codec->debugfs_codec_root) {
288 printk(KERN_WARNING
289 "ASoC: Failed to create codec debugfs directory\n");
290 return;
291 }
292
Mark Brownaaee8ef2011-01-26 20:53:50 +0000293 debugfs_create_bool("cache_sync", 0444, codec->debugfs_codec_root,
294 &codec->cache_sync);
295 debugfs_create_bool("cache_only", 0444, codec->debugfs_codec_root,
296 &codec->cache_only);
297
Mark Brown2624d5f2009-11-03 21:56:13 +0000298 codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
299 codec->debugfs_codec_root,
300 codec, &codec_reg_fops);
301 if (!codec->debugfs_reg)
302 printk(KERN_WARNING
303 "ASoC: Failed to create codec register debugfs file\n");
304
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +0200305 snd_soc_dapm_debugfs_init(&codec->dapm, codec->debugfs_codec_root);
Mark Brown2624d5f2009-11-03 21:56:13 +0000306}
307
308static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
309{
310 debugfs_remove_recursive(codec->debugfs_codec_root);
311}
312
Mark Brownc3c5a192010-09-15 18:15:14 +0100313static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
314 size_t count, loff_t *ppos)
315{
316 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100317 ssize_t len, ret = 0;
Mark Brownc3c5a192010-09-15 18:15:14 +0100318 struct snd_soc_codec *codec;
319
320 if (!buf)
321 return -ENOMEM;
322
Mark Brown2b194f9d2010-10-13 10:52:16 +0100323 list_for_each_entry(codec, &codec_list, list) {
324 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
325 codec->name);
326 if (len >= 0)
327 ret += len;
328 if (ret > PAGE_SIZE) {
329 ret = PAGE_SIZE;
330 break;
331 }
332 }
Mark Brownc3c5a192010-09-15 18:15:14 +0100333
334 if (ret >= 0)
335 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
336
337 kfree(buf);
338
339 return ret;
340}
341
342static const struct file_operations codec_list_fops = {
343 .read = codec_list_read_file,
344 .llseek = default_llseek,/* read accesses f_pos */
345};
346
Mark Brownf3208782010-09-15 18:19:07 +0100347static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
348 size_t count, loff_t *ppos)
349{
350 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100351 ssize_t len, ret = 0;
Mark Brownf3208782010-09-15 18:19:07 +0100352 struct snd_soc_dai *dai;
353
354 if (!buf)
355 return -ENOMEM;
356
Mark Brown2b194f9d2010-10-13 10:52:16 +0100357 list_for_each_entry(dai, &dai_list, list) {
358 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", dai->name);
359 if (len >= 0)
360 ret += len;
361 if (ret > PAGE_SIZE) {
362 ret = PAGE_SIZE;
363 break;
364 }
365 }
Mark Brownf3208782010-09-15 18:19:07 +0100366
Mark Brown2b194f9d2010-10-13 10:52:16 +0100367 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
Mark Brownf3208782010-09-15 18:19:07 +0100368
369 kfree(buf);
370
371 return ret;
372}
373
374static const struct file_operations dai_list_fops = {
375 .read = dai_list_read_file,
376 .llseek = default_llseek,/* read accesses f_pos */
377};
378
Mark Brown19c7ac22010-09-15 18:22:40 +0100379static ssize_t platform_list_read_file(struct file *file,
380 char __user *user_buf,
381 size_t count, loff_t *ppos)
382{
383 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100384 ssize_t len, ret = 0;
Mark Brown19c7ac22010-09-15 18:22:40 +0100385 struct snd_soc_platform *platform;
386
387 if (!buf)
388 return -ENOMEM;
389
Mark Brown2b194f9d2010-10-13 10:52:16 +0100390 list_for_each_entry(platform, &platform_list, list) {
391 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
392 platform->name);
393 if (len >= 0)
394 ret += len;
395 if (ret > PAGE_SIZE) {
396 ret = PAGE_SIZE;
397 break;
398 }
399 }
Mark Brown19c7ac22010-09-15 18:22:40 +0100400
Mark Brown2b194f9d2010-10-13 10:52:16 +0100401 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
Mark Brown19c7ac22010-09-15 18:22:40 +0100402
403 kfree(buf);
404
405 return ret;
406}
407
408static const struct file_operations platform_list_fops = {
409 .read = platform_list_read_file,
410 .llseek = default_llseek,/* read accesses f_pos */
411};
412
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200413static void soc_init_card_debugfs(struct snd_soc_card *card)
414{
415 card->debugfs_card_root = debugfs_create_dir(card->name,
Mark Brown8a9dab12011-01-10 22:25:21 +0000416 snd_soc_debugfs_root);
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200417 if (!card->debugfs_card_root) {
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200418 dev_warn(card->dev,
419 "ASoC: Failed to create codec debugfs directory\n");
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200420 return;
421 }
422
423 card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
424 card->debugfs_card_root,
425 &card->pop_time);
426 if (!card->debugfs_pop_time)
427 dev_warn(card->dev,
428 "Failed to create pop time debugfs file\n");
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200429}
430
431static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
432{
433 debugfs_remove_recursive(card->debugfs_card_root);
434}
435
Mark Brown2624d5f2009-11-03 21:56:13 +0000436#else
437
438static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
439{
440}
441
442static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
443{
444}
Axel Linb95fccb2010-11-09 17:06:44 +0800445
446static inline void soc_init_card_debugfs(struct snd_soc_card *card)
447{
448}
449
450static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
451{
452}
Mark Brown2624d5f2009-11-03 21:56:13 +0000453#endif
454
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200455#ifdef CONFIG_SND_SOC_AC97_BUS
456/* unregister ac97 codec */
457static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
458{
459 if (codec->ac97->dev.bus)
460 device_unregister(&codec->ac97->dev);
461 return 0;
462}
463
464/* stop no dev release warning */
465static void soc_ac97_device_release(struct device *dev){}
466
467/* register ac97 codec to bus */
468static int soc_ac97_dev_register(struct snd_soc_codec *codec)
469{
470 int err;
471
472 codec->ac97->dev.bus = &ac97_bus_type;
Mark Brown4ac5c612009-04-01 19:35:01 +0100473 codec->ac97->dev.parent = codec->card->dev;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200474 codec->ac97->dev.release = soc_ac97_device_release;
475
Kay Sieversbb072bf2008-11-02 03:50:35 +0100476 dev_set_name(&codec->ac97->dev, "%d-%d:%s",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000477 codec->card->snd_card->number, 0, codec->name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200478 err = device_register(&codec->ac97->dev);
479 if (err < 0) {
480 snd_printk(KERN_ERR "Can't register ac97 bus\n");
481 codec->ac97->dev.bus = NULL;
482 return err;
483 }
484 return 0;
485}
486#endif
487
Mark Brown06f409d2009-04-07 18:10:13 +0100488static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream)
489{
490 struct snd_soc_pcm_runtime *rtd = substream->private_data;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000491 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
492 struct snd_soc_dai *codec_dai = rtd->codec_dai;
Mark Brown06f409d2009-04-07 18:10:13 +0100493 int ret;
494
Mark Brown4f333b22011-03-08 00:11:15 +0000495 if (!codec_dai->driver->symmetric_rates &&
496 !cpu_dai->driver->symmetric_rates &&
497 !rtd->dai_link->symmetric_rates)
498 return 0;
Mark Brown06f409d2009-04-07 18:10:13 +0100499
Mark Brownc4ef8782011-03-08 00:17:56 +0000500 /* This can happen if multiple streams are starting simultaneously -
501 * the second can need to get its constraints before the first has
502 * picked a rate. Complain and allow the application to carry on.
503 */
504 if (!rtd->rate) {
505 dev_warn(&rtd->dev,
506 "Not enforcing symmetric_rates due to race\n");
507 return 0;
508 }
509
Mark Brown4f333b22011-03-08 00:11:15 +0000510 dev_dbg(&rtd->dev, "Symmetry forces %dHz rate\n", rtd->rate);
511
512 ret = snd_pcm_hw_constraint_minmax(substream->runtime,
513 SNDRV_PCM_HW_PARAM_RATE,
514 rtd->rate, rtd->rate);
515 if (ret < 0) {
516 dev_err(&rtd->dev,
517 "Unable to apply rate symmetry constraint: %d\n", ret);
518 return ret;
Mark Brown06f409d2009-04-07 18:10:13 +0100519 }
520
521 return 0;
522}
523
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200524/*
525 * Called by ALSA when a PCM substream is opened, the runtime->hw record is
526 * then initialized and any private data can be allocated. This also calls
527 * startup for the cpu DAI, platform, machine and codec DAI.
528 */
529static int soc_pcm_open(struct snd_pcm_substream *substream)
530{
531 struct snd_soc_pcm_runtime *rtd = substream->private_data;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200532 struct snd_pcm_runtime *runtime = substream->runtime;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000533 struct snd_soc_platform *platform = rtd->platform;
534 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
535 struct snd_soc_dai *codec_dai = rtd->codec_dai;
536 struct snd_soc_dai_driver *cpu_dai_drv = cpu_dai->driver;
537 struct snd_soc_dai_driver *codec_dai_drv = codec_dai->driver;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200538 int ret = 0;
539
540 mutex_lock(&pcm_mutex);
541
542 /* startup the audio subsystem */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000543 if (cpu_dai->driver->ops->startup) {
544 ret = cpu_dai->driver->ops->startup(substream, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200545 if (ret < 0) {
546 printk(KERN_ERR "asoc: can't open interface %s\n",
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100547 cpu_dai->name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200548 goto out;
549 }
550 }
551
Mark Brown8842c722011-04-27 18:58:17 +0100552 if (platform->driver->ops && platform->driver->ops->open) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000553 ret = platform->driver->ops->open(substream);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200554 if (ret < 0) {
555 printk(KERN_ERR "asoc: can't open platform %s\n", platform->name);
556 goto platform_err;
557 }
558 }
559
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000560 if (codec_dai->driver->ops->startup) {
561 ret = codec_dai->driver->ops->startup(substream, codec_dai);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100562 if (ret < 0) {
563 printk(KERN_ERR "asoc: can't open codec %s\n",
564 codec_dai->name);
565 goto codec_dai_err;
566 }
567 }
568
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000569 if (rtd->dai_link->ops && rtd->dai_link->ops->startup) {
570 ret = rtd->dai_link->ops->startup(substream);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200571 if (ret < 0) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000572 printk(KERN_ERR "asoc: %s startup failed\n", rtd->dai_link->name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200573 goto machine_err;
574 }
575 }
576
Mark Browna00f90f2010-12-02 16:24:24 +0000577 /* Check that the codec and cpu DAIs are compatible */
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200578 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
579 runtime->hw.rate_min =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000580 max(codec_dai_drv->playback.rate_min,
581 cpu_dai_drv->playback.rate_min);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200582 runtime->hw.rate_max =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000583 min(codec_dai_drv->playback.rate_max,
584 cpu_dai_drv->playback.rate_max);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200585 runtime->hw.channels_min =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000586 max(codec_dai_drv->playback.channels_min,
587 cpu_dai_drv->playback.channels_min);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200588 runtime->hw.channels_max =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000589 min(codec_dai_drv->playback.channels_max,
590 cpu_dai_drv->playback.channels_max);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100591 runtime->hw.formats =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000592 codec_dai_drv->playback.formats & cpu_dai_drv->playback.formats;
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100593 runtime->hw.rates =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000594 codec_dai_drv->playback.rates & cpu_dai_drv->playback.rates;
595 if (codec_dai_drv->playback.rates
Jassi Brard9ad6292010-03-12 13:38:52 +0900596 & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000597 runtime->hw.rates |= cpu_dai_drv->playback.rates;
598 if (cpu_dai_drv->playback.rates
Jassi Brard9ad6292010-03-12 13:38:52 +0900599 & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000600 runtime->hw.rates |= codec_dai_drv->playback.rates;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200601 } else {
602 runtime->hw.rate_min =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000603 max(codec_dai_drv->capture.rate_min,
604 cpu_dai_drv->capture.rate_min);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200605 runtime->hw.rate_max =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000606 min(codec_dai_drv->capture.rate_max,
607 cpu_dai_drv->capture.rate_max);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200608 runtime->hw.channels_min =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000609 max(codec_dai_drv->capture.channels_min,
610 cpu_dai_drv->capture.channels_min);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200611 runtime->hw.channels_max =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000612 min(codec_dai_drv->capture.channels_max,
613 cpu_dai_drv->capture.channels_max);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100614 runtime->hw.formats =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000615 codec_dai_drv->capture.formats & cpu_dai_drv->capture.formats;
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100616 runtime->hw.rates =
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000617 codec_dai_drv->capture.rates & cpu_dai_drv->capture.rates;
618 if (codec_dai_drv->capture.rates
Jassi Brard9ad6292010-03-12 13:38:52 +0900619 & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000620 runtime->hw.rates |= cpu_dai_drv->capture.rates;
621 if (cpu_dai_drv->capture.rates
Jassi Brard9ad6292010-03-12 13:38:52 +0900622 & (SNDRV_PCM_RATE_KNOT | SNDRV_PCM_RATE_CONTINUOUS))
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000623 runtime->hw.rates |= codec_dai_drv->capture.rates;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200624 }
625
Lu Guanqunc51def62011-04-06 23:25:21 +0800626 ret = -EINVAL;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200627 snd_pcm_limit_hw_rates(runtime);
628 if (!runtime->hw.rates) {
629 printk(KERN_ERR "asoc: %s <-> %s No matching rates\n",
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100630 codec_dai->name, cpu_dai->name);
Jassi Brarbb1c0472010-02-25 11:24:53 +0900631 goto config_err;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200632 }
633 if (!runtime->hw.formats) {
634 printk(KERN_ERR "asoc: %s <-> %s No matching formats\n",
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100635 codec_dai->name, cpu_dai->name);
Jassi Brarbb1c0472010-02-25 11:24:53 +0900636 goto config_err;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200637 }
Lu Guanqunb04cfcf2011-04-06 23:25:11 +0800638 if (!runtime->hw.channels_min || !runtime->hw.channels_max ||
639 runtime->hw.channels_min > runtime->hw.channels_max) {
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200640 printk(KERN_ERR "asoc: %s <-> %s No matching channels\n",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000641 codec_dai->name, cpu_dai->name);
Jassi Brarbb1c0472010-02-25 11:24:53 +0900642 goto config_err;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200643 }
644
Mark Brown06f409d2009-04-07 18:10:13 +0100645 /* Symmetry only applies if we've already got an active stream. */
646 if (cpu_dai->active || codec_dai->active) {
647 ret = soc_pcm_apply_symmetry(substream);
648 if (ret != 0)
Jassi Brarbb1c0472010-02-25 11:24:53 +0900649 goto config_err;
Mark Brown06f409d2009-04-07 18:10:13 +0100650 }
651
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000652 pr_debug("asoc: %s <-> %s info:\n",
653 codec_dai->name, cpu_dai->name);
Mark Brownf24368c2008-10-21 21:45:08 +0100654 pr_debug("asoc: rate mask 0x%x\n", runtime->hw.rates);
655 pr_debug("asoc: min ch %d max ch %d\n", runtime->hw.channels_min,
656 runtime->hw.channels_max);
657 pr_debug("asoc: min rate %d max rate %d\n", runtime->hw.rate_min,
658 runtime->hw.rate_max);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200659
Jassi Brar14dc5732010-02-26 09:12:32 +0900660 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000661 cpu_dai->playback_active++;
662 codec_dai->playback_active++;
Jassi Brar14dc5732010-02-26 09:12:32 +0900663 } else {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000664 cpu_dai->capture_active++;
665 codec_dai->capture_active++;
Jassi Brar14dc5732010-02-26 09:12:32 +0900666 }
667 cpu_dai->active++;
668 codec_dai->active++;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000669 rtd->codec->active++;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200670 mutex_unlock(&pcm_mutex);
671 return 0;
672
Jassi Brarbb1c0472010-02-25 11:24:53 +0900673config_err:
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000674 if (rtd->dai_link->ops && rtd->dai_link->ops->shutdown)
675 rtd->dai_link->ops->shutdown(substream);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200676
Jassi Brarbb1c0472010-02-25 11:24:53 +0900677machine_err:
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000678 if (codec_dai->driver->ops->shutdown)
679 codec_dai->driver->ops->shutdown(substream, codec_dai);
Jassi Brarbb1c0472010-02-25 11:24:53 +0900680
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100681codec_dai_err:
Mark Brown8842c722011-04-27 18:58:17 +0100682 if (platform->driver->ops && platform->driver->ops->close)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000683 platform->driver->ops->close(substream);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200684
685platform_err:
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000686 if (cpu_dai->driver->ops->shutdown)
687 cpu_dai->driver->ops->shutdown(substream, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200688out:
689 mutex_unlock(&pcm_mutex);
690 return ret;
691}
692
693/*
Robert P. J. Day3a4fa0a2007-10-19 23:10:43 +0200694 * Power down the audio subsystem pmdown_time msecs after close is called.
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200695 * This is to ensure there are no pops or clicks in between any music tracks
696 * due to DAPM power cycling.
697 */
Andrew Morton4484bb22006-12-15 09:30:07 +0100698static void close_delayed_work(struct work_struct *work)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200699{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000700 struct snd_soc_pcm_runtime *rtd =
701 container_of(work, struct snd_soc_pcm_runtime, delayed_work.work);
702 struct snd_soc_dai *codec_dai = rtd->codec_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200703
704 mutex_lock(&pcm_mutex);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200705
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000706 pr_debug("pop wq checking: %s status: %s waiting: %s\n",
707 codec_dai->driver->playback.stream_name,
708 codec_dai->playback_active ? "active" : "inactive",
709 codec_dai->pop_wait ? "yes" : "no");
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200710
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000711 /* are we waiting on this codec DAI stream */
712 if (codec_dai->pop_wait == 1) {
713 codec_dai->pop_wait = 0;
714 snd_soc_dapm_stream_event(rtd,
715 codec_dai->driver->playback.stream_name,
716 SND_SOC_DAPM_STREAM_STOP);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200717 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000718
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200719 mutex_unlock(&pcm_mutex);
720}
721
722/*
723 * Called by ALSA when a PCM substream is closed. Private data can be
724 * freed here. The cpu DAI, codec DAI, machine and platform are also
725 * shutdown.
726 */
727static int soc_codec_close(struct snd_pcm_substream *substream)
728{
729 struct snd_soc_pcm_runtime *rtd = substream->private_data;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000730 struct snd_soc_platform *platform = rtd->platform;
731 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
732 struct snd_soc_dai *codec_dai = rtd->codec_dai;
733 struct snd_soc_codec *codec = rtd->codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200734
735 mutex_lock(&pcm_mutex);
736
Jassi Brar14dc5732010-02-26 09:12:32 +0900737 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000738 cpu_dai->playback_active--;
739 codec_dai->playback_active--;
Jassi Brar14dc5732010-02-26 09:12:32 +0900740 } else {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000741 cpu_dai->capture_active--;
742 codec_dai->capture_active--;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200743 }
Jassi Brar14dc5732010-02-26 09:12:32 +0900744
745 cpu_dai->active--;
746 codec_dai->active--;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200747 codec->active--;
748
Mark Brown6010b2d2008-09-06 18:33:24 +0100749 /* Muting the DAC suppresses artifacts caused during digital
750 * shutdown, for example from stopping clocks.
751 */
752 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
753 snd_soc_dai_digital_mute(codec_dai, 1);
754
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000755 if (cpu_dai->driver->ops->shutdown)
756 cpu_dai->driver->ops->shutdown(substream, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200757
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000758 if (codec_dai->driver->ops->shutdown)
759 codec_dai->driver->ops->shutdown(substream, codec_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200760
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000761 if (rtd->dai_link->ops && rtd->dai_link->ops->shutdown)
762 rtd->dai_link->ops->shutdown(substream);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200763
Mark Brown8842c722011-04-27 18:58:17 +0100764 if (platform->driver->ops && platform->driver->ops->close)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000765 platform->driver->ops->close(substream);
766 cpu_dai->runtime = NULL;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200767
768 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
769 /* start delayed pop wq here for playback streams */
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100770 codec_dai->pop_wait = 1;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000771 schedule_delayed_work(&rtd->delayed_work,
772 msecs_to_jiffies(rtd->pmdown_time));
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200773 } else {
774 /* capture streams can be powered down now */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000775 snd_soc_dapm_stream_event(rtd,
776 codec_dai->driver->capture.stream_name,
Liam Girdwood0b4d2212008-01-10 14:36:20 +0100777 SND_SOC_DAPM_STREAM_STOP);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200778 }
779
780 mutex_unlock(&pcm_mutex);
781 return 0;
782}
783
784/*
785 * Called by ALSA when the PCM substream is prepared, can set format, sample
786 * rate, etc. This function is non atomic and can be called multiple times,
787 * it can refer to the runtime info.
788 */
789static int soc_pcm_prepare(struct snd_pcm_substream *substream)
790{
791 struct snd_soc_pcm_runtime *rtd = substream->private_data;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000792 struct snd_soc_platform *platform = rtd->platform;
793 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
794 struct snd_soc_dai *codec_dai = rtd->codec_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200795 int ret = 0;
796
797 mutex_lock(&pcm_mutex);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100798
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000799 if (rtd->dai_link->ops && rtd->dai_link->ops->prepare) {
800 ret = rtd->dai_link->ops->prepare(substream);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100801 if (ret < 0) {
802 printk(KERN_ERR "asoc: machine prepare error\n");
803 goto out;
804 }
805 }
806
Mark Brown8842c722011-04-27 18:58:17 +0100807 if (platform->driver->ops && platform->driver->ops->prepare) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000808 ret = platform->driver->ops->prepare(substream);
Liam Girdwooda71a4682006-10-19 20:35:56 +0200809 if (ret < 0) {
810 printk(KERN_ERR "asoc: platform prepare error\n");
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200811 goto out;
Liam Girdwooda71a4682006-10-19 20:35:56 +0200812 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200813 }
814
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000815 if (codec_dai->driver->ops->prepare) {
816 ret = codec_dai->driver->ops->prepare(substream, codec_dai);
Liam Girdwooda71a4682006-10-19 20:35:56 +0200817 if (ret < 0) {
818 printk(KERN_ERR "asoc: codec DAI prepare error\n");
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200819 goto out;
Liam Girdwooda71a4682006-10-19 20:35:56 +0200820 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200821 }
822
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000823 if (cpu_dai->driver->ops->prepare) {
824 ret = cpu_dai->driver->ops->prepare(substream, cpu_dai);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100825 if (ret < 0) {
826 printk(KERN_ERR "asoc: cpu DAI prepare error\n");
827 goto out;
828 }
829 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200830
Mark Brownd45f6212008-10-14 13:58:36 +0100831 /* cancel any delayed stream shutdown that is pending */
832 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
833 codec_dai->pop_wait) {
834 codec_dai->pop_wait = 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000835 cancel_delayed_work(&rtd->delayed_work);
Mark Brownd45f6212008-10-14 13:58:36 +0100836 }
837
Mark Brown452c5ea2009-05-17 21:41:23 +0100838 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000839 snd_soc_dapm_stream_event(rtd,
840 codec_dai->driver->playback.stream_name,
Mark Brown452c5ea2009-05-17 21:41:23 +0100841 SND_SOC_DAPM_STREAM_START);
842 else
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000843 snd_soc_dapm_stream_event(rtd,
844 codec_dai->driver->capture.stream_name,
Mark Brown452c5ea2009-05-17 21:41:23 +0100845 SND_SOC_DAPM_STREAM_START);
Mark Brownd45f6212008-10-14 13:58:36 +0100846
Mark Brown452c5ea2009-05-17 21:41:23 +0100847 snd_soc_dai_digital_mute(codec_dai, 0);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200848
849out:
850 mutex_unlock(&pcm_mutex);
851 return ret;
852}
853
854/*
855 * Called by ALSA when the hardware params are set by application. This
856 * function can also be called multiple times and can allocate buffers
857 * (using snd_pcm_lib_* ). It's non-atomic.
858 */
859static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
860 struct snd_pcm_hw_params *params)
861{
862 struct snd_soc_pcm_runtime *rtd = substream->private_data;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000863 struct snd_soc_platform *platform = rtd->platform;
864 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
865 struct snd_soc_dai *codec_dai = rtd->codec_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200866 int ret = 0;
867
868 mutex_lock(&pcm_mutex);
869
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000870 if (rtd->dai_link->ops && rtd->dai_link->ops->hw_params) {
871 ret = rtd->dai_link->ops->hw_params(substream, params);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200872 if (ret < 0) {
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100873 printk(KERN_ERR "asoc: machine hw_params failed\n");
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200874 goto out;
875 }
876 }
877
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000878 if (codec_dai->driver->ops->hw_params) {
879 ret = codec_dai->driver->ops->hw_params(substream, params, codec_dai);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100880 if (ret < 0) {
881 printk(KERN_ERR "asoc: can't set codec %s hw params\n",
882 codec_dai->name);
883 goto codec_err;
884 }
885 }
886
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000887 if (cpu_dai->driver->ops->hw_params) {
888 ret = cpu_dai->driver->ops->hw_params(substream, params, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200889 if (ret < 0) {
Mark Brown3ff3f642008-05-19 12:32:25 +0200890 printk(KERN_ERR "asoc: interface %s hw params failed\n",
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100891 cpu_dai->name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200892 goto interface_err;
893 }
894 }
895
Mark Brown8842c722011-04-27 18:58:17 +0100896 if (platform->driver->ops && platform->driver->ops->hw_params) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000897 ret = platform->driver->ops->hw_params(substream, params);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200898 if (ret < 0) {
Mark Brown3ff3f642008-05-19 12:32:25 +0200899 printk(KERN_ERR "asoc: platform %s hw params failed\n",
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200900 platform->name);
901 goto platform_err;
902 }
903 }
904
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000905 rtd->rate = params_rate(params);
Mark Brown06f409d2009-04-07 18:10:13 +0100906
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200907out:
908 mutex_unlock(&pcm_mutex);
909 return ret;
910
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200911platform_err:
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000912 if (cpu_dai->driver->ops->hw_free)
913 cpu_dai->driver->ops->hw_free(substream, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200914
915interface_err:
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000916 if (codec_dai->driver->ops->hw_free)
917 codec_dai->driver->ops->hw_free(substream, codec_dai);
Liam Girdwoodcb666e52007-02-02 17:13:49 +0100918
919codec_err:
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000920 if (rtd->dai_link->ops && rtd->dai_link->ops->hw_free)
921 rtd->dai_link->ops->hw_free(substream);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200922
923 mutex_unlock(&pcm_mutex);
924 return ret;
925}
926
927/*
Mark Browna00f90f2010-12-02 16:24:24 +0000928 * Frees resources allocated by hw_params, can be called multiple times
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200929 */
930static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
931{
932 struct snd_soc_pcm_runtime *rtd = substream->private_data;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000933 struct snd_soc_platform *platform = rtd->platform;
934 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
935 struct snd_soc_dai *codec_dai = rtd->codec_dai;
936 struct snd_soc_codec *codec = rtd->codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200937
938 mutex_lock(&pcm_mutex);
939
940 /* apply codec digital mute */
Liam Girdwood8c6529d2008-07-08 13:19:13 +0100941 if (!codec->active)
942 snd_soc_dai_digital_mute(codec_dai, 1);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200943
944 /* free any machine hw params */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000945 if (rtd->dai_link->ops && rtd->dai_link->ops->hw_free)
946 rtd->dai_link->ops->hw_free(substream);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200947
948 /* free any DMA resources */
Mark Brown8842c722011-04-27 18:58:17 +0100949 if (platform->driver->ops && platform->driver->ops->hw_free)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000950 platform->driver->ops->hw_free(substream);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200951
Mark Browna00f90f2010-12-02 16:24:24 +0000952 /* now free hw params for the DAIs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000953 if (codec_dai->driver->ops->hw_free)
954 codec_dai->driver->ops->hw_free(substream, codec_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200955
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000956 if (cpu_dai->driver->ops->hw_free)
957 cpu_dai->driver->ops->hw_free(substream, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200958
959 mutex_unlock(&pcm_mutex);
960 return 0;
961}
962
963static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
964{
965 struct snd_soc_pcm_runtime *rtd = substream->private_data;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000966 struct snd_soc_platform *platform = rtd->platform;
967 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
968 struct snd_soc_dai *codec_dai = rtd->codec_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200969 int ret;
970
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000971 if (codec_dai->driver->ops->trigger) {
972 ret = codec_dai->driver->ops->trigger(substream, cmd, codec_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200973 if (ret < 0)
974 return ret;
975 }
976
Mark Brown8842c722011-04-27 18:58:17 +0100977 if (platform->driver->ops && platform->driver->ops->trigger) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000978 ret = platform->driver->ops->trigger(substream, cmd);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200979 if (ret < 0)
980 return ret;
981 }
982
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000983 if (cpu_dai->driver->ops->trigger) {
984 ret = cpu_dai->driver->ops->trigger(substream, cmd, cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200985 if (ret < 0)
986 return ret;
987 }
988 return 0;
989}
990
Peter Ujfalusi377b6f62010-03-03 15:08:06 +0200991/*
992 * soc level wrapper for pointer callback
Peter Ujfalusi258020d2010-03-03 15:08:07 +0200993 * If cpu_dai, codec_dai, platform driver has the delay callback, than
994 * the runtime->delay will be updated accordingly.
Peter Ujfalusi377b6f62010-03-03 15:08:06 +0200995 */
996static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
997{
998 struct snd_soc_pcm_runtime *rtd = substream->private_data;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000999 struct snd_soc_platform *platform = rtd->platform;
1000 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1001 struct snd_soc_dai *codec_dai = rtd->codec_dai;
Peter Ujfalusi258020d2010-03-03 15:08:07 +02001002 struct snd_pcm_runtime *runtime = substream->runtime;
Peter Ujfalusi377b6f62010-03-03 15:08:06 +02001003 snd_pcm_uframes_t offset = 0;
Peter Ujfalusi258020d2010-03-03 15:08:07 +02001004 snd_pcm_sframes_t delay = 0;
Peter Ujfalusi377b6f62010-03-03 15:08:06 +02001005
Mark Brown8842c722011-04-27 18:58:17 +01001006 if (platform->driver->ops && platform->driver->ops->pointer)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001007 offset = platform->driver->ops->pointer(substream);
Peter Ujfalusi377b6f62010-03-03 15:08:06 +02001008
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001009 if (cpu_dai->driver->ops->delay)
1010 delay += cpu_dai->driver->ops->delay(substream, cpu_dai);
Peter Ujfalusi258020d2010-03-03 15:08:07 +02001011
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001012 if (codec_dai->driver->ops->delay)
1013 delay += codec_dai->driver->ops->delay(substream, codec_dai);
Peter Ujfalusi258020d2010-03-03 15:08:07 +02001014
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001015 if (platform->driver->delay)
1016 delay += platform->driver->delay(substream, codec_dai);
Peter Ujfalusi258020d2010-03-03 15:08:07 +02001017
1018 runtime->delay = delay;
1019
Peter Ujfalusi377b6f62010-03-03 15:08:06 +02001020 return offset;
1021}
1022
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001023/* ASoC PCM operations */
1024static struct snd_pcm_ops soc_pcm_ops = {
1025 .open = soc_pcm_open,
1026 .close = soc_codec_close,
1027 .hw_params = soc_pcm_hw_params,
1028 .hw_free = soc_pcm_hw_free,
1029 .prepare = soc_pcm_prepare,
1030 .trigger = soc_pcm_trigger,
Peter Ujfalusi377b6f62010-03-03 15:08:06 +02001031 .pointer = soc_pcm_pointer,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001032};
1033
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001034#ifdef CONFIG_PM_SLEEP
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001035/* powers down audio subsystem for suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001036int snd_soc_suspend(struct device *dev)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001037{
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001038 struct snd_soc_card *card = dev_get_drvdata(dev);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001039 struct snd_soc_codec *codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001040 int i;
1041
Daniel Macke3509ff2009-06-03 17:44:49 +02001042 /* If the initialization of this soc device failed, there is no codec
1043 * associated with it. Just bail out in this case.
1044 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001045 if (list_empty(&card->codec_dev_list))
Daniel Macke3509ff2009-06-03 17:44:49 +02001046 return 0;
1047
Andy Green6ed25972008-06-13 16:24:05 +01001048 /* Due to the resume being scheduled into a workqueue we could
1049 * suspend before that's finished - wait for it to complete.
1050 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001051 snd_power_lock(card->snd_card);
1052 snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
1053 snd_power_unlock(card->snd_card);
Andy Green6ed25972008-06-13 16:24:05 +01001054
1055 /* we're going to block userspace touching us until resume completes */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001056 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
Andy Green6ed25972008-06-13 16:24:05 +01001057
Mark Browna00f90f2010-12-02 16:24:24 +00001058 /* mute any active DACs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001059 for (i = 0; i < card->num_rtd; i++) {
1060 struct snd_soc_dai *dai = card->rtd[i].codec_dai;
1061 struct snd_soc_dai_driver *drv = dai->driver;
Mark Brown3efab7d2010-05-09 13:25:43 +01001062
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001063 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +01001064 continue;
1065
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001066 if (drv->ops->digital_mute && dai->playback_active)
1067 drv->ops->digital_mute(dai, 1);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001068 }
1069
Liam Girdwood4ccab3e2008-01-10 14:39:01 +01001070 /* suspend all pcms */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001071 for (i = 0; i < card->num_rtd; i++) {
1072 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +01001073 continue;
1074
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001075 snd_pcm_suspend_all(card->rtd[i].pcm);
Mark Brown3efab7d2010-05-09 13:25:43 +01001076 }
Liam Girdwood4ccab3e2008-01-10 14:39:01 +01001077
Mark Brown87506542008-11-18 20:50:34 +00001078 if (card->suspend_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +00001079 card->suspend_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001080
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001081 for (i = 0; i < card->num_rtd; i++) {
1082 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1083 struct snd_soc_platform *platform = card->rtd[i].platform;
Mark Brown3efab7d2010-05-09 13:25:43 +01001084
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001085 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +01001086 continue;
1087
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001088 if (cpu_dai->driver->suspend && !cpu_dai->driver->ac97_control)
1089 cpu_dai->driver->suspend(cpu_dai);
1090 if (platform->driver->suspend && !platform->suspended) {
1091 platform->driver->suspend(cpu_dai);
1092 platform->suspended = 1;
Mark Brown1547aba2010-05-07 21:11:40 +01001093 }
1094 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001095
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001096 /* close any waiting streams and save state */
1097 for (i = 0; i < card->num_rtd; i++) {
Tejun Heo5b84ba22010-12-11 17:51:26 +01001098 flush_delayed_work_sync(&card->rtd[i].delayed_work);
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001099 card->rtd[i].codec->dapm.suspend_bias_level = card->rtd[i].codec->dapm.bias_level;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001100 }
Mark Brown3efab7d2010-05-09 13:25:43 +01001101
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001102 for (i = 0; i < card->num_rtd; i++) {
1103 struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;
1104
1105 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +01001106 continue;
1107
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001108 if (driver->playback.stream_name != NULL)
1109 snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,
1110 SND_SOC_DAPM_STREAM_SUSPEND);
1111
1112 if (driver->capture.stream_name != NULL)
1113 snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,
1114 SND_SOC_DAPM_STREAM_SUSPEND);
1115 }
1116
1117 /* suspend all CODECs */
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001118 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001119 /* If there are paths active then the CODEC will be held with
1120 * bias _ON and should not be suspended. */
1121 if (!codec->suspended && codec->driver->suspend) {
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001122 switch (codec->dapm.bias_level) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001123 case SND_SOC_BIAS_STANDBY:
1124 case SND_SOC_BIAS_OFF:
1125 codec->driver->suspend(codec, PMSG_SUSPEND);
1126 codec->suspended = 1;
1127 break;
1128 default:
1129 dev_dbg(codec->dev, "CODEC is on over suspend\n");
1130 break;
1131 }
1132 }
1133 }
1134
1135 for (i = 0; i < card->num_rtd; i++) {
1136 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1137
1138 if (card->rtd[i].dai_link->ignore_suspend)
1139 continue;
1140
1141 if (cpu_dai->driver->suspend && cpu_dai->driver->ac97_control)
1142 cpu_dai->driver->suspend(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001143 }
1144
Mark Brown87506542008-11-18 20:50:34 +00001145 if (card->suspend_post)
Mark Brown70b2ac12011-01-26 14:05:25 +00001146 card->suspend_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001147
1148 return 0;
1149}
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001150EXPORT_SYMBOL_GPL(snd_soc_suspend);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001151
Andy Green6ed25972008-06-13 16:24:05 +01001152/* deferred resume work, so resume can complete before we finished
1153 * setting our codec back up, which can be very slow on I2C
1154 */
1155static void soc_resume_deferred(struct work_struct *work)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001156{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001157 struct snd_soc_card *card =
1158 container_of(work, struct snd_soc_card, deferred_resume_work);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001159 struct snd_soc_codec *codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001160 int i;
1161
Andy Green6ed25972008-06-13 16:24:05 +01001162 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
1163 * so userspace apps are blocked from touching us
1164 */
1165
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001166 dev_dbg(card->dev, "starting resume work\n");
Andy Green6ed25972008-06-13 16:24:05 +01001167
Mark Brown99497882010-05-07 20:24:05 +01001168 /* Bring us up into D2 so that DAPM starts enabling things */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001169 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
Mark Brown99497882010-05-07 20:24:05 +01001170
Mark Brown87506542008-11-18 20:50:34 +00001171 if (card->resume_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +00001172 card->resume_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001173
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001174 /* resume AC97 DAIs */
1175 for (i = 0; i < card->num_rtd; i++) {
1176 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +01001177
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001178 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +01001179 continue;
1180
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001181 if (cpu_dai->driver->resume && cpu_dai->driver->ac97_control)
1182 cpu_dai->driver->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001183 }
1184
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001185 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001186 /* If the CODEC was idle over suspend then it will have been
1187 * left with bias OFF or STANDBY and suspended so we must now
1188 * resume. Otherwise the suspend was suppressed.
1189 */
1190 if (codec->driver->resume && codec->suspended) {
Liam Girdwoodce6120c2010-11-05 15:53:46 +02001191 switch (codec->dapm.bias_level) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001192 case SND_SOC_BIAS_STANDBY:
1193 case SND_SOC_BIAS_OFF:
1194 codec->driver->resume(codec);
1195 codec->suspended = 0;
1196 break;
1197 default:
1198 dev_dbg(codec->dev, "CODEC was on over suspend\n");
1199 break;
1200 }
Mark Brown1547aba2010-05-07 21:11:40 +01001201 }
1202 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001203
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001204 for (i = 0; i < card->num_rtd; i++) {
1205 struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;
Mark Brown3efab7d2010-05-09 13:25:43 +01001206
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001207 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +01001208 continue;
1209
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001210 if (driver->playback.stream_name != NULL)
1211 snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001212 SND_SOC_DAPM_STREAM_RESUME);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001213
1214 if (driver->capture.stream_name != NULL)
1215 snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001216 SND_SOC_DAPM_STREAM_RESUME);
1217 }
1218
Mark Brown3ff3f642008-05-19 12:32:25 +02001219 /* unmute any active DACs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001220 for (i = 0; i < card->num_rtd; i++) {
1221 struct snd_soc_dai *dai = card->rtd[i].codec_dai;
1222 struct snd_soc_dai_driver *drv = dai->driver;
Mark Brown3efab7d2010-05-09 13:25:43 +01001223
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001224 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +01001225 continue;
1226
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001227 if (drv->ops->digital_mute && dai->playback_active)
1228 drv->ops->digital_mute(dai, 0);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001229 }
1230
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001231 for (i = 0; i < card->num_rtd; i++) {
1232 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1233 struct snd_soc_platform *platform = card->rtd[i].platform;
Mark Brown3efab7d2010-05-09 13:25:43 +01001234
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001235 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +01001236 continue;
1237
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001238 if (cpu_dai->driver->resume && !cpu_dai->driver->ac97_control)
1239 cpu_dai->driver->resume(cpu_dai);
1240 if (platform->driver->resume && platform->suspended) {
1241 platform->driver->resume(cpu_dai);
1242 platform->suspended = 0;
1243 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001244 }
1245
Mark Brown87506542008-11-18 20:50:34 +00001246 if (card->resume_post)
Mark Brown70b2ac12011-01-26 14:05:25 +00001247 card->resume_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001248
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001249 dev_dbg(card->dev, "resume work completed\n");
Andy Green6ed25972008-06-13 16:24:05 +01001250
1251 /* userspace can access us now we are back as we were before */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001252 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
Andy Green6ed25972008-06-13 16:24:05 +01001253}
1254
1255/* powers up audio subsystem after a suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001256int snd_soc_resume(struct device *dev)
Andy Green6ed25972008-06-13 16:24:05 +01001257{
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001258 struct snd_soc_card *card = dev_get_drvdata(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001259 int i;
Peter Ujfalusib9dd94a2010-02-22 13:27:13 +02001260
Mark Brown64ab9ba2009-03-31 11:27:03 +01001261 /* AC97 devices might have other drivers hanging off them so
1262 * need to resume immediately. Other drivers don't have that
1263 * problem and may take a substantial amount of time to resume
1264 * due to I/O costs and anti-pop so handle them out of line.
1265 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001266 for (i = 0; i < card->num_rtd; i++) {
1267 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
1268 if (cpu_dai->driver->ac97_control) {
1269 dev_dbg(dev, "Resuming AC97 immediately\n");
1270 soc_resume_deferred(&card->deferred_resume_work);
1271 } else {
1272 dev_dbg(dev, "Scheduling resume work\n");
1273 if (!schedule_work(&card->deferred_resume_work))
1274 dev_err(dev, "resume work item may be lost\n");
1275 }
Mark Brown64ab9ba2009-03-31 11:27:03 +01001276 }
Andy Green6ed25972008-06-13 16:24:05 +01001277
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001278 return 0;
1279}
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001280EXPORT_SYMBOL_GPL(snd_soc_resume);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001281#else
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001282#define snd_soc_suspend NULL
1283#define snd_soc_resume NULL
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001284#endif
1285
Barry Song02a06d32009-10-16 18:13:38 +08001286static struct snd_soc_dai_ops null_dai_ops = {
1287};
1288
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001289static int soc_bind_dai_link(struct snd_soc_card *card, int num)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001290{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001291 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
1292 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
Mark Brownfe3e78e2009-11-03 22:13:13 +00001293 struct snd_soc_codec *codec;
Mark Brown435c5e22008-12-04 15:32:53 +00001294 struct snd_soc_platform *platform;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001295 struct snd_soc_dai *codec_dai, *cpu_dai;
Mark Brown848dd8b2011-04-27 18:16:32 +01001296 const char *platform_name;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001297
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001298 if (rtd->complete)
1299 return 1;
1300 dev_dbg(card->dev, "binding %s at idx %d\n", dai_link->name, num);
Mark Brown63084192008-12-02 15:08:03 +00001301
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001302 /* do we already have the CPU DAI for this link ? */
1303 if (rtd->cpu_dai) {
1304 goto find_codec;
1305 }
1306 /* no, then find CPU DAI from registered DAIs*/
1307 list_for_each_entry(cpu_dai, &dai_list, list) {
1308 if (!strcmp(cpu_dai->name, dai_link->cpu_dai_name)) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001309 rtd->cpu_dai = cpu_dai;
1310 goto find_codec;
Mark Brown435c5e22008-12-04 15:32:53 +00001311 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001312 }
1313 dev_dbg(card->dev, "CPU DAI %s not registered\n",
1314 dai_link->cpu_dai_name);
1315
1316find_codec:
1317 /* do we already have the CODEC for this link ? */
1318 if (rtd->codec) {
1319 goto find_platform;
Mark Brownc5af3a22008-11-28 13:29:45 +00001320 }
1321
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001322 /* no, then find CODEC from registered CODECs*/
1323 list_for_each_entry(codec, &codec_list, list) {
1324 if (!strcmp(codec->name, dai_link->codec_name)) {
1325 rtd->codec = codec;
Mark Brown6b05eda2008-12-08 19:26:48 +00001326
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001327 /* CODEC found, so find CODEC DAI from registered DAIs from this CODEC*/
1328 list_for_each_entry(codec_dai, &dai_list, list) {
1329 if (codec->dev == codec_dai->dev &&
1330 !strcmp(codec_dai->name, dai_link->codec_dai_name)) {
1331 rtd->codec_dai = codec_dai;
1332 goto find_platform;
Mark Brown6b05eda2008-12-08 19:26:48 +00001333 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001334 }
1335 dev_dbg(card->dev, "CODEC DAI %s not registered\n",
1336 dai_link->codec_dai_name);
1337
1338 goto find_platform;
1339 }
1340 }
1341 dev_dbg(card->dev, "CODEC %s not registered\n",
1342 dai_link->codec_name);
1343
1344find_platform:
Mark Brown848dd8b2011-04-27 18:16:32 +01001345 /* do we need a platform? */
1346 if (rtd->platform)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001347 goto out;
Mark Brown848dd8b2011-04-27 18:16:32 +01001348
1349 /* if there's no platform we match on the empty platform */
1350 platform_name = dai_link->platform_name;
1351 if (!platform_name)
1352 platform_name = "snd-soc-dummy";
1353
1354 /* no, then find one from the set of registered platforms */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001355 list_for_each_entry(platform, &platform_list, list) {
Mark Brown848dd8b2011-04-27 18:16:32 +01001356 if (!strcmp(platform->name, platform_name)) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001357 rtd->platform = platform;
1358 goto out;
1359 }
1360 }
1361
1362 dev_dbg(card->dev, "platform %s not registered\n",
1363 dai_link->platform_name);
1364 return 0;
1365
1366out:
1367 /* mark rtd as complete if we found all 4 of our client devices */
1368 if (rtd->codec && rtd->codec_dai && rtd->platform && rtd->cpu_dai) {
1369 rtd->complete = 1;
1370 card->num_rtd++;
1371 }
1372 return 1;
1373}
1374
Jarkko Nikula589c3562010-12-06 16:27:07 +02001375static void soc_remove_codec(struct snd_soc_codec *codec)
1376{
1377 int err;
1378
1379 if (codec->driver->remove) {
1380 err = codec->driver->remove(codec);
1381 if (err < 0)
1382 dev_err(codec->dev,
1383 "asoc: failed to remove %s: %d\n",
1384 codec->name, err);
1385 }
1386
1387 /* Make sure all DAPM widgets are freed */
1388 snd_soc_dapm_free(&codec->dapm);
1389
1390 soc_cleanup_codec_debugfs(codec);
1391 codec->probed = 0;
1392 list_del(&codec->card_list);
1393 module_put(codec->dev->driver->owner);
1394}
1395
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001396static void soc_remove_dai_link(struct snd_soc_card *card, int num)
1397{
1398 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1399 struct snd_soc_codec *codec = rtd->codec;
1400 struct snd_soc_platform *platform = rtd->platform;
1401 struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
1402 int err;
1403
1404 /* unregister the rtd device */
1405 if (rtd->dev_registered) {
1406 device_remove_file(&rtd->dev, &dev_attr_pmdown_time);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001407 device_remove_file(&rtd->dev, &dev_attr_codec_reg);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001408 device_unregister(&rtd->dev);
1409 rtd->dev_registered = 0;
1410 }
1411
1412 /* remove the CODEC DAI */
1413 if (codec_dai && codec_dai->probed) {
1414 if (codec_dai->driver->remove) {
1415 err = codec_dai->driver->remove(codec_dai);
1416 if (err < 0)
1417 printk(KERN_ERR "asoc: failed to remove %s\n", codec_dai->name);
1418 }
1419 codec_dai->probed = 0;
1420 list_del(&codec_dai->card_list);
1421 }
1422
1423 /* remove the platform */
1424 if (platform && platform->probed) {
1425 if (platform->driver->remove) {
1426 err = platform->driver->remove(platform);
1427 if (err < 0)
1428 printk(KERN_ERR "asoc: failed to remove %s\n", platform->name);
1429 }
1430 platform->probed = 0;
1431 list_del(&platform->card_list);
1432 module_put(platform->dev->driver->owner);
1433 }
1434
1435 /* remove the CODEC */
Jarkko Nikula589c3562010-12-06 16:27:07 +02001436 if (codec && codec->probed)
1437 soc_remove_codec(codec);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001438
1439 /* remove the cpu_dai */
1440 if (cpu_dai && cpu_dai->probed) {
1441 if (cpu_dai->driver->remove) {
1442 err = cpu_dai->driver->remove(cpu_dai);
1443 if (err < 0)
1444 printk(KERN_ERR "asoc: failed to remove %s\n", cpu_dai->name);
1445 }
1446 cpu_dai->probed = 0;
1447 list_del(&cpu_dai->card_list);
1448 module_put(cpu_dai->dev->driver->owner);
1449 }
1450}
1451
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001452static void soc_remove_dai_links(struct snd_soc_card *card)
1453{
1454 int i;
1455
1456 for (i = 0; i < card->num_rtd; i++)
1457 soc_remove_dai_link(card, i);
1458
1459 card->num_rtd = 0;
1460}
1461
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001462static void soc_set_name_prefix(struct snd_soc_card *card,
1463 struct snd_soc_codec *codec)
1464{
1465 int i;
1466
Dimitris Papastamosff819b82010-12-02 14:53:03 +00001467 if (card->codec_conf == NULL)
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001468 return;
1469
Dimitris Papastamosff819b82010-12-02 14:53:03 +00001470 for (i = 0; i < card->num_configs; i++) {
1471 struct snd_soc_codec_conf *map = &card->codec_conf[i];
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001472 if (map->dev_name && !strcmp(codec->name, map->dev_name)) {
1473 codec->name_prefix = map->name_prefix;
1474 break;
1475 }
1476 }
1477}
1478
Jarkko Nikula589c3562010-12-06 16:27:07 +02001479static int soc_probe_codec(struct snd_soc_card *card,
1480 struct snd_soc_codec *codec)
1481{
1482 int ret = 0;
Mark Brown89b95ac02011-03-07 16:38:44 +00001483 const struct snd_soc_codec_driver *driver = codec->driver;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001484
1485 codec->card = card;
1486 codec->dapm.card = card;
1487 soc_set_name_prefix(card, codec);
1488
Jarkko Nikula70d29332011-01-27 16:24:22 +02001489 if (!try_module_get(codec->dev->driver->owner))
1490 return -ENODEV;
1491
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001492 soc_init_codec_debugfs(codec);
1493
Lars-Peter Clausen77530152011-05-05 16:59:09 +02001494 if (driver->dapm_widgets)
1495 snd_soc_dapm_new_controls(&codec->dapm, driver->dapm_widgets,
1496 driver->num_dapm_widgets);
1497
Mark Brown89b95ac02011-03-07 16:38:44 +00001498 if (driver->probe) {
1499 ret = driver->probe(codec);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001500 if (ret < 0) {
1501 dev_err(codec->dev,
1502 "asoc: failed to probe CODEC %s: %d\n",
1503 codec->name, ret);
Jarkko Nikula70d29332011-01-27 16:24:22 +02001504 goto err_probe;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001505 }
1506 }
1507
Mark Brownb7af1da2011-04-07 19:18:44 +09001508 if (driver->controls)
1509 snd_soc_add_controls(codec, driver->controls,
1510 driver->num_controls);
Mark Brown89b95ac02011-03-07 16:38:44 +00001511 if (driver->dapm_routes)
1512 snd_soc_dapm_add_routes(&codec->dapm, driver->dapm_routes,
1513 driver->num_dapm_routes);
1514
Jarkko Nikula589c3562010-12-06 16:27:07 +02001515 /* mark codec as probed and add to card codec list */
1516 codec->probed = 1;
1517 list_add(&codec->card_list, &card->codec_dev_list);
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001518 list_add(&codec->dapm.list, &card->dapm_list);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001519
Jarkko Nikula70d29332011-01-27 16:24:22 +02001520 return 0;
1521
1522err_probe:
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001523 soc_cleanup_codec_debugfs(codec);
Jarkko Nikula70d29332011-01-27 16:24:22 +02001524 module_put(codec->dev->driver->owner);
1525
Jarkko Nikula589c3562010-12-06 16:27:07 +02001526 return ret;
1527}
1528
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001529static void rtd_release(struct device *dev) {}
1530
Jarkko Nikula589c3562010-12-06 16:27:07 +02001531static int soc_post_component_init(struct snd_soc_card *card,
1532 struct snd_soc_codec *codec,
1533 int num, int dailess)
1534{
1535 struct snd_soc_dai_link *dai_link = NULL;
1536 struct snd_soc_aux_dev *aux_dev = NULL;
1537 struct snd_soc_pcm_runtime *rtd;
1538 const char *temp, *name;
1539 int ret = 0;
1540
1541 if (!dailess) {
1542 dai_link = &card->dai_link[num];
1543 rtd = &card->rtd[num];
1544 name = dai_link->name;
1545 } else {
1546 aux_dev = &card->aux_dev[num];
1547 rtd = &card->rtd_aux[num];
1548 name = aux_dev->name;
1549 }
Janusz Krzysztofik0962bb22011-02-02 21:11:41 +01001550 rtd->card = card;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001551
1552 /* machine controls, routes and widgets are not prefixed */
1553 temp = codec->name_prefix;
1554 codec->name_prefix = NULL;
1555
1556 /* do machine specific initialization */
1557 if (!dailess && dai_link->init)
1558 ret = dai_link->init(rtd);
1559 else if (dailess && aux_dev->init)
1560 ret = aux_dev->init(&codec->dapm);
1561 if (ret < 0) {
1562 dev_err(card->dev, "asoc: failed to init %s: %d\n", name, ret);
1563 return ret;
1564 }
1565 codec->name_prefix = temp;
1566
1567 /* Make sure all DAPM widgets are instantiated */
1568 snd_soc_dapm_new_widgets(&codec->dapm);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001569
1570 /* register the rtd device */
1571 rtd->codec = codec;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001572 rtd->dev.parent = card->dev;
1573 rtd->dev.release = rtd_release;
1574 rtd->dev.init_name = name;
1575 ret = device_register(&rtd->dev);
1576 if (ret < 0) {
1577 dev_err(card->dev,
1578 "asoc: failed to register runtime device: %d\n", ret);
1579 return ret;
1580 }
1581 rtd->dev_registered = 1;
1582
1583 /* add DAPM sysfs entries for this codec */
1584 ret = snd_soc_dapm_sys_add(&rtd->dev);
1585 if (ret < 0)
1586 dev_err(codec->dev,
1587 "asoc: failed to add codec dapm sysfs entries: %d\n",
1588 ret);
1589
1590 /* add codec sysfs entries */
1591 ret = device_create_file(&rtd->dev, &dev_attr_codec_reg);
1592 if (ret < 0)
1593 dev_err(codec->dev,
1594 "asoc: failed to add codec sysfs files: %d\n", ret);
1595
1596 return 0;
1597}
1598
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001599static int soc_probe_dai_link(struct snd_soc_card *card, int num)
1600{
1601 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
1602 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1603 struct snd_soc_codec *codec = rtd->codec;
1604 struct snd_soc_platform *platform = rtd->platform;
1605 struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
1606 int ret;
1607
1608 dev_dbg(card->dev, "probe %s dai link %d\n", card->name, num);
1609
1610 /* config components */
1611 codec_dai->codec = codec;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001612 cpu_dai->platform = platform;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001613 codec_dai->card = card;
1614 cpu_dai->card = card;
1615
1616 /* set default power off timeout */
1617 rtd->pmdown_time = pmdown_time;
1618
1619 /* probe the cpu_dai */
1620 if (!cpu_dai->probed) {
Liam Girdwood61b61e32011-05-24 13:57:43 +01001621 if (!try_module_get(cpu_dai->dev->driver->owner))
1622 return -ENODEV;
1623
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001624 if (cpu_dai->driver->probe) {
1625 ret = cpu_dai->driver->probe(cpu_dai);
1626 if (ret < 0) {
1627 printk(KERN_ERR "asoc: failed to probe CPU DAI %s\n",
1628 cpu_dai->name);
Liam Girdwood61b61e32011-05-24 13:57:43 +01001629 module_put(cpu_dai->dev->driver->owner);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001630 return ret;
1631 }
1632 }
1633 cpu_dai->probed = 1;
1634 /* mark cpu_dai as probed and add to card cpu_dai list */
1635 list_add(&cpu_dai->card_list, &card->dai_dev_list);
1636 }
1637
1638 /* probe the CODEC */
1639 if (!codec->probed) {
Jarkko Nikula589c3562010-12-06 16:27:07 +02001640 ret = soc_probe_codec(card, codec);
1641 if (ret < 0)
1642 return ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001643 }
1644
1645 /* probe the platform */
1646 if (!platform->probed) {
Jarkko Nikula70d29332011-01-27 16:24:22 +02001647 if (!try_module_get(platform->dev->driver->owner))
1648 return -ENODEV;
1649
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001650 if (platform->driver->probe) {
1651 ret = platform->driver->probe(platform);
1652 if (ret < 0) {
1653 printk(KERN_ERR "asoc: failed to probe platform %s\n",
1654 platform->name);
Jarkko Nikula70d29332011-01-27 16:24:22 +02001655 module_put(platform->dev->driver->owner);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001656 return ret;
1657 }
1658 }
1659 /* mark platform as probed and add to card platform list */
1660 platform->probed = 1;
1661 list_add(&platform->card_list, &card->platform_dev_list);
1662 }
1663
1664 /* probe the CODEC DAI */
1665 if (!codec_dai->probed) {
1666 if (codec_dai->driver->probe) {
1667 ret = codec_dai->driver->probe(codec_dai);
1668 if (ret < 0) {
1669 printk(KERN_ERR "asoc: failed to probe CODEC DAI %s\n",
1670 codec_dai->name);
1671 return ret;
Mark Brown6b05eda2008-12-08 19:26:48 +00001672 }
1673 }
1674
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001675 /* mark cpu_dai as probed and add to card cpu_dai list */
1676 codec_dai->probed = 1;
1677 list_add(&codec_dai->card_list, &card->dai_dev_list);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001678 }
1679
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001680 /* DAPM dai link stream work */
1681 INIT_DELAYED_WORK(&rtd->delayed_work, close_delayed_work);
1682
Jarkko Nikula589c3562010-12-06 16:27:07 +02001683 ret = soc_post_component_init(card, codec, num, 0);
1684 if (ret)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001685 return ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001686
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001687 ret = device_create_file(&rtd->dev, &dev_attr_pmdown_time);
1688 if (ret < 0)
1689 printk(KERN_WARNING "asoc: failed to add pmdown_time sysfs\n");
1690
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001691 /* create the pcm */
1692 ret = soc_new_pcm(rtd, num);
1693 if (ret < 0) {
1694 printk(KERN_ERR "asoc: can't create pcm %s\n", dai_link->stream_name);
1695 return ret;
1696 }
1697
1698 /* add platform data for AC97 devices */
1699 if (rtd->codec_dai->driver->ac97_control)
1700 snd_ac97_dev_add_pdata(codec->ac97, rtd->cpu_dai->ac97_pdata);
1701
1702 return 0;
1703}
1704
1705#ifdef CONFIG_SND_SOC_AC97_BUS
1706static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime *rtd)
1707{
1708 int ret;
1709
1710 /* Only instantiate AC97 if not already done by the adaptor
1711 * for the generic AC97 subsystem.
1712 */
1713 if (rtd->codec_dai->driver->ac97_control && !rtd->codec->ac97_registered) {
Mika Westerberg0562f782010-10-13 11:30:32 +03001714 /*
1715 * It is possible that the AC97 device is already registered to
1716 * the device subsystem. This happens when the device is created
1717 * via snd_ac97_mixer(). Currently only SoC codec that does so
1718 * is the generic AC97 glue but others migh emerge.
1719 *
1720 * In those cases we don't try to register the device again.
1721 */
1722 if (!rtd->codec->ac97_created)
1723 return 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001724
1725 ret = soc_ac97_dev_register(rtd->codec);
1726 if (ret < 0) {
1727 printk(KERN_ERR "asoc: AC97 device register failed\n");
1728 return ret;
1729 }
1730
1731 rtd->codec->ac97_registered = 1;
1732 }
1733 return 0;
1734}
1735
1736static void soc_unregister_ac97_dai_link(struct snd_soc_codec *codec)
1737{
1738 if (codec->ac97_registered) {
1739 soc_ac97_dev_unregister(codec);
1740 codec->ac97_registered = 0;
1741 }
1742}
1743#endif
1744
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001745static int soc_probe_aux_dev(struct snd_soc_card *card, int num)
1746{
1747 struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001748 struct snd_soc_codec *codec;
Jarkko Nikula676ad982010-12-03 09:18:22 +02001749 int ret = -ENODEV;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001750
1751 /* find CODEC from registered CODECs*/
1752 list_for_each_entry(codec, &codec_list, list) {
1753 if (!strcmp(codec->name, aux_dev->codec_name)) {
1754 if (codec->probed) {
1755 dev_err(codec->dev,
1756 "asoc: codec already probed");
1757 ret = -EBUSY;
1758 goto out;
1759 }
Jarkko Nikula676ad982010-12-03 09:18:22 +02001760 goto found;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001761 }
1762 }
Jarkko Nikula676ad982010-12-03 09:18:22 +02001763 /* codec not found */
1764 dev_err(card->dev, "asoc: codec %s not found", aux_dev->codec_name);
1765 goto out;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001766
Jarkko Nikula676ad982010-12-03 09:18:22 +02001767found:
Jarkko Nikula589c3562010-12-06 16:27:07 +02001768 ret = soc_probe_codec(card, codec);
1769 if (ret < 0)
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001770 return ret;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001771
Jarkko Nikula589c3562010-12-06 16:27:07 +02001772 ret = soc_post_component_init(card, codec, num, 1);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001773
1774out:
1775 return ret;
1776}
1777
1778static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
1779{
1780 struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
1781 struct snd_soc_codec *codec = rtd->codec;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001782
1783 /* unregister the rtd device */
1784 if (rtd->dev_registered) {
Jarkko Nikula589c3562010-12-06 16:27:07 +02001785 device_remove_file(&rtd->dev, &dev_attr_codec_reg);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001786 device_unregister(&rtd->dev);
1787 rtd->dev_registered = 0;
1788 }
1789
Jarkko Nikula589c3562010-12-06 16:27:07 +02001790 if (codec && codec->probed)
1791 soc_remove_codec(codec);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001792}
1793
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001794static int snd_soc_init_codec_cache(struct snd_soc_codec *codec,
1795 enum snd_soc_compress_type compress_type)
1796{
1797 int ret;
1798
1799 if (codec->cache_init)
1800 return 0;
1801
1802 /* override the compress_type if necessary */
1803 if (compress_type && codec->compress_type != compress_type)
1804 codec->compress_type = compress_type;
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001805 ret = snd_soc_cache_init(codec);
1806 if (ret < 0) {
1807 dev_err(codec->dev, "Failed to set cache compression type: %d\n",
1808 ret);
1809 return ret;
1810 }
1811 codec->cache_init = 1;
1812 return 0;
1813}
1814
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001815static void snd_soc_instantiate_card(struct snd_soc_card *card)
1816{
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001817 struct snd_soc_codec *codec;
1818 struct snd_soc_codec_conf *codec_conf;
1819 enum snd_soc_compress_type compress_type;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001820 int ret, i;
1821
1822 mutex_lock(&card->mutex);
1823
1824 if (card->instantiated) {
1825 mutex_unlock(&card->mutex);
1826 return;
1827 }
1828
1829 /* bind DAIs */
1830 for (i = 0; i < card->num_links; i++)
1831 soc_bind_dai_link(card, i);
1832
1833 /* bind completed ? */
1834 if (card->num_rtd != card->num_links) {
1835 mutex_unlock(&card->mutex);
1836 return;
1837 }
1838
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001839 /* initialize the register cache for each available codec */
1840 list_for_each_entry(codec, &codec_list, list) {
1841 if (codec->cache_init)
1842 continue;
Dimitris Papastamos861f2fa2011-01-11 11:43:51 +00001843 /* by default we don't override the compress_type */
1844 compress_type = 0;
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001845 /* check to see if we need to override the compress_type */
1846 for (i = 0; i < card->num_configs; ++i) {
1847 codec_conf = &card->codec_conf[i];
1848 if (!strcmp(codec->name, codec_conf->dev_name)) {
1849 compress_type = codec_conf->compress_type;
1850 if (compress_type && compress_type
1851 != codec->compress_type)
1852 break;
1853 }
1854 }
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001855 ret = snd_soc_init_codec_cache(codec, compress_type);
1856 if (ret < 0) {
1857 mutex_unlock(&card->mutex);
1858 return;
1859 }
1860 }
1861
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001862 /* card bind complete so register a sound card */
1863 ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
1864 card->owner, 0, &card->snd_card);
1865 if (ret < 0) {
1866 printk(KERN_ERR "asoc: can't create sound card for card %s\n",
1867 card->name);
1868 mutex_unlock(&card->mutex);
1869 return;
1870 }
1871 card->snd_card->dev = card->dev;
1872
Mark Browne37a4972011-03-02 18:21:57 +00001873 card->dapm.bias_level = SND_SOC_BIAS_OFF;
1874 card->dapm.dev = card->dev;
1875 card->dapm.card = card;
1876 list_add(&card->dapm.list, &card->dapm_list);
1877
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001878#ifdef CONFIG_DEBUG_FS
1879 snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
1880#endif
1881
Mark Brown88ee1c62011-02-02 10:43:26 +00001882#ifdef CONFIG_PM_SLEEP
Andy Green6ed25972008-06-13 16:24:05 +01001883 /* deferred resume work */
Mark Brown63084192008-12-02 15:08:03 +00001884 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
Randy Dunlap1301a962008-06-17 19:19:34 +01001885#endif
Andy Green6ed25972008-06-13 16:24:05 +01001886
Mark Brown9a841eb2011-04-12 17:51:37 -07001887 if (card->dapm_widgets)
1888 snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
1889 card->num_dapm_widgets);
1890
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001891 /* initialise the sound card only once */
1892 if (card->probe) {
Mark Browne7361ec2011-01-26 14:17:20 +00001893 ret = card->probe(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001894 if (ret < 0)
1895 goto card_probe_error;
1896 }
1897
Mark Brownfe3e78e2009-11-03 22:13:13 +00001898 for (i = 0; i < card->num_links; i++) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001899 ret = soc_probe_dai_link(card, i);
1900 if (ret < 0) {
Mark Brown321de0d2010-09-21 15:09:37 +01001901 pr_err("asoc: failed to instantiate card %s: %d\n",
1902 card->name, ret);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001903 goto probe_dai_err;
1904 }
1905 }
1906
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001907 for (i = 0; i < card->num_aux_devs; i++) {
1908 ret = soc_probe_aux_dev(card, i);
1909 if (ret < 0) {
1910 pr_err("asoc: failed to add auxiliary devices %s: %d\n",
1911 card->name, ret);
1912 goto probe_aux_dev_err;
1913 }
1914 }
1915
Mark Brownb7af1da2011-04-07 19:18:44 +09001916 /* We should have a non-codec control add function but we don't */
1917 if (card->controls)
1918 snd_soc_add_controls(list_first_entry(&card->codec_dev_list,
1919 struct snd_soc_codec,
1920 card_list),
1921 card->controls,
1922 card->num_controls);
1923
Mark Brownb8ad29d2011-03-02 18:35:51 +00001924 if (card->dapm_routes)
1925 snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
1926 card->num_dapm_routes);
1927
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001928 snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001929 "%s", card->name);
Liam Girdwood22de71b2011-05-12 16:14:04 +01001930 snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
1931 "%s", card->long_name ? card->long_name : card->name);
1932 snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
Jarkko Nikula2b395352011-05-20 15:47:40 +03001933 "%s", card->driver_name ? card->driver_name : card->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001934
Mark Brown28e9ad92011-03-02 18:36:34 +00001935 if (card->late_probe) {
1936 ret = card->late_probe(card);
1937 if (ret < 0) {
1938 dev_err(card->dev, "%s late_probe() failed: %d\n",
1939 card->name, ret);
1940 goto probe_aux_dev_err;
1941 }
1942 }
1943
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001944 ret = snd_card_register(card->snd_card);
1945 if (ret < 0) {
1946 printk(KERN_ERR "asoc: failed to register soundcard for %s\n", card->name);
Axel Lin6b3ed782010-12-07 16:12:29 +08001947 goto probe_aux_dev_err;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001948 }
1949
1950#ifdef CONFIG_SND_SOC_AC97_BUS
1951 /* register any AC97 codecs */
1952 for (i = 0; i < card->num_rtd; i++) {
Axel Lin6b3ed782010-12-07 16:12:29 +08001953 ret = soc_register_ac97_dai_link(&card->rtd[i]);
1954 if (ret < 0) {
1955 printk(KERN_ERR "asoc: failed to register AC97 %s\n", card->name);
1956 while (--i >= 0)
Mark Brown7d8316d2010-12-13 17:03:27 +00001957 soc_unregister_ac97_dai_link(card->rtd[i].codec);
Axel Lin6b3ed782010-12-07 16:12:29 +08001958 goto probe_aux_dev_err;
Mark Brownfe3e78e2009-11-03 22:13:13 +00001959 }
Axel Lin6b3ed782010-12-07 16:12:29 +08001960 }
Mark Brownfe3e78e2009-11-03 22:13:13 +00001961#endif
1962
Mark Brown435c5e22008-12-04 15:32:53 +00001963 card->instantiated = 1;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001964 mutex_unlock(&card->mutex);
Mark Brown435c5e22008-12-04 15:32:53 +00001965 return;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001966
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001967probe_aux_dev_err:
1968 for (i = 0; i < card->num_aux_devs; i++)
1969 soc_remove_aux_dev(card, i);
1970
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001971probe_dai_err:
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001972 soc_remove_dai_links(card);
Mark Brownfe3e78e2009-11-03 22:13:13 +00001973
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001974card_probe_error:
Mark Brown87506542008-11-18 20:50:34 +00001975 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00001976 card->remove(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001977
1978 snd_card_free(card->snd_card);
1979
1980 mutex_unlock(&card->mutex);
Mark Brown435c5e22008-12-04 15:32:53 +00001981}
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001982
Mark Brown435c5e22008-12-04 15:32:53 +00001983/*
Uwe Kleine-König421f91d2010-06-11 12:17:00 +02001984 * Attempt to initialise any uninitialised cards. Must be called with
Mark Brown435c5e22008-12-04 15:32:53 +00001985 * client_mutex.
1986 */
1987static void snd_soc_instantiate_cards(void)
1988{
1989 struct snd_soc_card *card;
1990 list_for_each_entry(card, &card_list, list)
1991 snd_soc_instantiate_card(card);
1992}
1993
1994/* probes a new socdev */
1995static int soc_probe(struct platform_device *pdev)
1996{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001997 struct snd_soc_card *card = platform_get_drvdata(pdev);
Mark Brown435c5e22008-12-04 15:32:53 +00001998 int ret = 0;
Mark Brown435c5e22008-12-04 15:32:53 +00001999
Vinod Koul70a7ca32011-01-14 19:22:48 +05302000 /*
2001 * no card, so machine driver should be registering card
2002 * we should not be here in that case so ret error
2003 */
2004 if (!card)
2005 return -EINVAL;
2006
Mark Brown435c5e22008-12-04 15:32:53 +00002007 /* Bodge while we unpick instantiation */
2008 card->dev = &pdev->dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002009
Mark Brown435c5e22008-12-04 15:32:53 +00002010 ret = snd_soc_register_card(card);
2011 if (ret != 0) {
2012 dev_err(&pdev->dev, "Failed to register card\n");
2013 return ret;
2014 }
2015
2016 return 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002017}
2018
Vinod Koulb0e26482011-01-13 22:48:02 +05302019static int soc_cleanup_card_resources(struct snd_soc_card *card)
2020{
Vinod Koulb0e26482011-01-13 22:48:02 +05302021 int i;
2022
2023 /* make sure any delayed work runs */
2024 for (i = 0; i < card->num_rtd; i++) {
2025 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
2026 flush_delayed_work_sync(&rtd->delayed_work);
2027 }
2028
2029 /* remove auxiliary devices */
2030 for (i = 0; i < card->num_aux_devs; i++)
2031 soc_remove_aux_dev(card, i);
2032
2033 /* remove and free each DAI */
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09002034 soc_remove_dai_links(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05302035
2036 soc_cleanup_card_debugfs(card);
2037
2038 /* remove the card */
2039 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00002040 card->remove(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05302041
Lars-Peter Clausen0aaae522011-04-30 19:45:47 +02002042 snd_soc_dapm_free(&card->dapm);
2043
Vinod Koulb0e26482011-01-13 22:48:02 +05302044 kfree(card->rtd);
2045 snd_card_free(card->snd_card);
2046 return 0;
2047
2048}
2049
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002050/* removes a socdev */
2051static int soc_remove(struct platform_device *pdev)
2052{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002053 struct snd_soc_card *card = platform_get_drvdata(pdev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002054
Mark Brownc5af3a22008-11-28 13:29:45 +00002055 snd_soc_unregister_card(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002056 return 0;
2057}
2058
Mark Brown6f8ab4a2011-01-26 14:59:27 +00002059int snd_soc_poweroff(struct device *dev)
Mark Brown51737472009-06-22 13:16:51 +01002060{
Mark Brown6f8ab4a2011-01-26 14:59:27 +00002061 struct snd_soc_card *card = dev_get_drvdata(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002062 int i;
Mark Brown51737472009-06-22 13:16:51 +01002063
2064 if (!card->instantiated)
Mark Brown416356f2009-06-30 19:05:15 +01002065 return 0;
Mark Brown51737472009-06-22 13:16:51 +01002066
2067 /* Flush out pmdown_time work - we actually do want to run it
2068 * now, we're shutting down so no imminent restart. */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002069 for (i = 0; i < card->num_rtd; i++) {
2070 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
Tejun Heo5b84ba22010-12-11 17:51:26 +01002071 flush_delayed_work_sync(&rtd->delayed_work);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002072 }
Mark Brown51737472009-06-22 13:16:51 +01002073
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002074 snd_soc_dapm_shutdown(card);
Mark Brown416356f2009-06-30 19:05:15 +01002075
2076 return 0;
Mark Brown51737472009-06-22 13:16:51 +01002077}
Mark Brown6f8ab4a2011-01-26 14:59:27 +00002078EXPORT_SYMBOL_GPL(snd_soc_poweroff);
Mark Brown51737472009-06-22 13:16:51 +01002079
Mark Brown6f8ab4a2011-01-26 14:59:27 +00002080const struct dev_pm_ops snd_soc_pm_ops = {
2081 .suspend = snd_soc_suspend,
2082 .resume = snd_soc_resume,
2083 .poweroff = snd_soc_poweroff,
Mark Brown416356f2009-06-30 19:05:15 +01002084};
Stephen Warrendeb26072011-04-05 19:35:30 -06002085EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
Mark Brown416356f2009-06-30 19:05:15 +01002086
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002087/* ASoC platform driver */
2088static struct platform_driver soc_driver = {
2089 .driver = {
2090 .name = "soc-audio",
Kay Sievers8b45a202008-04-14 13:33:36 +02002091 .owner = THIS_MODULE,
Mark Brown6f8ab4a2011-01-26 14:59:27 +00002092 .pm = &snd_soc_pm_ops,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002093 },
2094 .probe = soc_probe,
2095 .remove = soc_remove,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002096};
2097
2098/* create a new pcm */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002099static int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002100{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002101 struct snd_soc_codec *codec = rtd->codec;
2102 struct snd_soc_platform *platform = rtd->platform;
2103 struct snd_soc_dai *codec_dai = rtd->codec_dai;
2104 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002105 struct snd_pcm *pcm;
2106 char new_name[64];
2107 int ret = 0, playback = 0, capture = 0;
2108
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002109 /* check client and interface hw capabilities */
Mark Brown40ca1142009-12-24 13:44:28 +00002110 snprintf(new_name, sizeof(new_name), "%s %s-%d",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002111 rtd->dai_link->stream_name, codec_dai->name, num);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002112
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002113 if (codec_dai->driver->playback.channels_min)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002114 playback = 1;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002115 if (codec_dai->driver->capture.channels_min)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002116 capture = 1;
2117
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002118 dev_dbg(rtd->card->dev, "registered pcm #%d %s\n",num,new_name);
2119 ret = snd_pcm_new(rtd->card->snd_card, new_name,
2120 num, playback, capture, &pcm);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002121 if (ret < 0) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002122 printk(KERN_ERR "asoc: can't create pcm for codec %s\n", codec->name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002123 return ret;
2124 }
2125
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002126 rtd->pcm = pcm;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002127 pcm->private_data = rtd;
Mark Brown8842c722011-04-27 18:58:17 +01002128 if (platform->driver->ops) {
2129 soc_pcm_ops.mmap = platform->driver->ops->mmap;
2130 soc_pcm_ops.pointer = platform->driver->ops->pointer;
2131 soc_pcm_ops.ioctl = platform->driver->ops->ioctl;
2132 soc_pcm_ops.copy = platform->driver->ops->copy;
2133 soc_pcm_ops.silence = platform->driver->ops->silence;
2134 soc_pcm_ops.ack = platform->driver->ops->ack;
2135 soc_pcm_ops.page = platform->driver->ops->page;
2136 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002137
2138 if (playback)
2139 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &soc_pcm_ops);
2140
2141 if (capture)
2142 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &soc_pcm_ops);
2143
Mark Brown8842c722011-04-27 18:58:17 +01002144 if (platform->driver->pcm_new) {
2145 ret = platform->driver->pcm_new(rtd->card->snd_card,
2146 codec_dai, pcm);
2147 if (ret < 0) {
2148 pr_err("asoc: platform pcm constructor failed\n");
2149 return ret;
2150 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002151 }
2152
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002153 pcm->private_free = platform->driver->pcm_free;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002154 printk(KERN_INFO "asoc: %s <-> %s mapping ok\n", codec_dai->name,
2155 cpu_dai->name);
2156 return ret;
2157}
2158
Mark Brown096e49d2009-07-05 15:12:22 +01002159/**
2160 * snd_soc_codec_volatile_register: Report if a register is volatile.
2161 *
2162 * @codec: CODEC to query.
2163 * @reg: Register to query.
2164 *
2165 * Boolean function indiciating if a CODEC register is volatile.
2166 */
Mark Brown181e0552011-01-24 14:05:25 +00002167int snd_soc_codec_volatile_register(struct snd_soc_codec *codec,
2168 unsigned int reg)
Mark Brown096e49d2009-07-05 15:12:22 +01002169{
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00002170 if (codec->volatile_register)
2171 return codec->volatile_register(codec, reg);
Mark Brown096e49d2009-07-05 15:12:22 +01002172 else
2173 return 0;
2174}
2175EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register);
2176
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002177/**
Dimitris Papastamos239c9702011-03-24 13:45:18 +00002178 * snd_soc_codec_readable_register: Report if a register is readable.
2179 *
2180 * @codec: CODEC to query.
2181 * @reg: Register to query.
2182 *
2183 * Boolean function indicating if a CODEC register is readable.
2184 */
2185int snd_soc_codec_readable_register(struct snd_soc_codec *codec,
2186 unsigned int reg)
2187{
2188 if (codec->readable_register)
2189 return codec->readable_register(codec, reg);
2190 else
2191 return 0;
2192}
2193EXPORT_SYMBOL_GPL(snd_soc_codec_readable_register);
2194
2195/**
2196 * snd_soc_codec_writable_register: Report if a register is writable.
2197 *
2198 * @codec: CODEC to query.
2199 * @reg: Register to query.
2200 *
2201 * Boolean function indicating if a CODEC register is writable.
2202 */
2203int snd_soc_codec_writable_register(struct snd_soc_codec *codec,
2204 unsigned int reg)
2205{
2206 if (codec->writable_register)
2207 return codec->writable_register(codec, reg);
2208 else
2209 return 0;
2210}
2211EXPORT_SYMBOL_GPL(snd_soc_codec_writable_register);
2212
2213/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002214 * snd_soc_new_ac97_codec - initailise AC97 device
2215 * @codec: audio codec
2216 * @ops: AC97 bus operations
2217 * @num: AC97 codec number
2218 *
2219 * Initialises AC97 codec resources for use by ad-hoc devices only.
2220 */
2221int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
2222 struct snd_ac97_bus_ops *ops, int num)
2223{
2224 mutex_lock(&codec->mutex);
2225
2226 codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
2227 if (codec->ac97 == NULL) {
2228 mutex_unlock(&codec->mutex);
2229 return -ENOMEM;
2230 }
2231
2232 codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
2233 if (codec->ac97->bus == NULL) {
2234 kfree(codec->ac97);
2235 codec->ac97 = NULL;
2236 mutex_unlock(&codec->mutex);
2237 return -ENOMEM;
2238 }
2239
2240 codec->ac97->bus->ops = ops;
2241 codec->ac97->num = num;
Mika Westerberg0562f782010-10-13 11:30:32 +03002242
2243 /*
2244 * Mark the AC97 device to be created by us. This way we ensure that the
2245 * device will be registered with the device subsystem later on.
2246 */
2247 codec->ac97_created = 1;
2248
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002249 mutex_unlock(&codec->mutex);
2250 return 0;
2251}
2252EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
2253
2254/**
2255 * snd_soc_free_ac97_codec - free AC97 codec device
2256 * @codec: audio codec
2257 *
2258 * Frees AC97 codec device resources.
2259 */
2260void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
2261{
2262 mutex_lock(&codec->mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002263#ifdef CONFIG_SND_SOC_AC97_BUS
2264 soc_unregister_ac97_dai_link(codec);
2265#endif
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002266 kfree(codec->ac97->bus);
2267 kfree(codec->ac97);
2268 codec->ac97 = NULL;
Mika Westerberg0562f782010-10-13 11:30:32 +03002269 codec->ac97_created = 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002270 mutex_unlock(&codec->mutex);
2271}
2272EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
2273
Mark Brownc3753702010-11-01 15:41:57 -04002274unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg)
2275{
2276 unsigned int ret;
2277
Mark Brownc3acec22010-12-02 16:15:29 +00002278 ret = codec->read(codec, reg);
Mark Brownc3753702010-11-01 15:41:57 -04002279 dev_dbg(codec->dev, "read %x => %x\n", reg, ret);
Mark Browna8b1d342010-11-03 18:05:58 -04002280 trace_snd_soc_reg_read(codec, reg, ret);
Mark Brownc3753702010-11-01 15:41:57 -04002281
2282 return ret;
2283}
2284EXPORT_SYMBOL_GPL(snd_soc_read);
2285
2286unsigned int snd_soc_write(struct snd_soc_codec *codec,
2287 unsigned int reg, unsigned int val)
2288{
2289 dev_dbg(codec->dev, "write %x = %x\n", reg, val);
Mark Browna8b1d342010-11-03 18:05:58 -04002290 trace_snd_soc_reg_write(codec, reg, val);
Mark Brownc3acec22010-12-02 16:15:29 +00002291 return codec->write(codec, reg, val);
Mark Brownc3753702010-11-01 15:41:57 -04002292}
2293EXPORT_SYMBOL_GPL(snd_soc_write);
2294
Dimitris Papastamos5fb609d2011-03-22 10:37:03 +00002295unsigned int snd_soc_bulk_write_raw(struct snd_soc_codec *codec,
2296 unsigned int reg, const void *data, size_t len)
2297{
2298 return codec->bulk_write_raw(codec, reg, data, len);
2299}
2300EXPORT_SYMBOL_GPL(snd_soc_bulk_write_raw);
2301
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002302/**
2303 * snd_soc_update_bits - update codec register bits
2304 * @codec: audio codec
2305 * @reg: codec register
2306 * @mask: register mask
2307 * @value: new value
2308 *
2309 * Writes new register value.
2310 *
Timur Tabi180c3292011-01-10 15:58:13 -06002311 * Returns 1 for change, 0 for no change, or negative error code.
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002312 */
2313int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002314 unsigned int mask, unsigned int value)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002315{
2316 int change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002317 unsigned int old, new;
Timur Tabi180c3292011-01-10 15:58:13 -06002318 int ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002319
Timur Tabi180c3292011-01-10 15:58:13 -06002320 ret = snd_soc_read(codec, reg);
2321 if (ret < 0)
2322 return ret;
2323
2324 old = ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002325 new = (old & ~mask) | value;
2326 change = old != new;
Timur Tabi180c3292011-01-10 15:58:13 -06002327 if (change) {
2328 ret = snd_soc_write(codec, reg, new);
2329 if (ret < 0)
2330 return ret;
2331 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002332
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002333 return change;
2334}
2335EXPORT_SYMBOL_GPL(snd_soc_update_bits);
2336
2337/**
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002338 * snd_soc_update_bits_locked - update codec register bits
2339 * @codec: audio codec
2340 * @reg: codec register
2341 * @mask: register mask
2342 * @value: new value
2343 *
2344 * Writes new register value, and takes the codec mutex.
2345 *
2346 * Returns 1 for change else 0.
2347 */
Mark Browndd1b3d52009-12-04 14:22:03 +00002348int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
2349 unsigned short reg, unsigned int mask,
2350 unsigned int value)
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002351{
2352 int change;
2353
2354 mutex_lock(&codec->mutex);
2355 change = snd_soc_update_bits(codec, reg, mask, value);
2356 mutex_unlock(&codec->mutex);
2357
2358 return change;
2359}
Mark Browndd1b3d52009-12-04 14:22:03 +00002360EXPORT_SYMBOL_GPL(snd_soc_update_bits_locked);
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002361
2362/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002363 * snd_soc_test_bits - test register for change
2364 * @codec: audio codec
2365 * @reg: codec register
2366 * @mask: register mask
2367 * @value: new value
2368 *
2369 * Tests a register with a new value and checks if the new value is
2370 * different from the old value.
2371 *
2372 * Returns 1 for change else 0.
2373 */
2374int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002375 unsigned int mask, unsigned int value)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002376{
2377 int change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002378 unsigned int old, new;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002379
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002380 old = snd_soc_read(codec, reg);
2381 new = (old & ~mask) | value;
2382 change = old != new;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002383
2384 return change;
2385}
2386EXPORT_SYMBOL_GPL(snd_soc_test_bits);
2387
2388/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002389 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
2390 * @substream: the pcm substream
2391 * @hw: the hardware parameters
2392 *
2393 * Sets the substream runtime hardware parameters.
2394 */
2395int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
2396 const struct snd_pcm_hardware *hw)
2397{
2398 struct snd_pcm_runtime *runtime = substream->runtime;
2399 runtime->hw.info = hw->info;
2400 runtime->hw.formats = hw->formats;
2401 runtime->hw.period_bytes_min = hw->period_bytes_min;
2402 runtime->hw.period_bytes_max = hw->period_bytes_max;
2403 runtime->hw.periods_min = hw->periods_min;
2404 runtime->hw.periods_max = hw->periods_max;
2405 runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
2406 runtime->hw.fifo_size = hw->fifo_size;
2407 return 0;
2408}
2409EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
2410
2411/**
2412 * snd_soc_cnew - create new control
2413 * @_template: control template
2414 * @data: control private data
Mark Brownac11a2b2009-01-01 12:18:17 +00002415 * @long_name: control long name
Mark Brownefb7ac32011-03-08 17:23:24 +00002416 * @prefix: control name prefix
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002417 *
2418 * Create a new mixer control from a template control.
2419 *
2420 * Returns 0 for success, else error.
2421 */
2422struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
Mark Brownefb7ac32011-03-08 17:23:24 +00002423 void *data, char *long_name,
2424 const char *prefix)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002425{
2426 struct snd_kcontrol_new template;
Mark Brownefb7ac32011-03-08 17:23:24 +00002427 struct snd_kcontrol *kcontrol;
2428 char *name = NULL;
2429 int name_len;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002430
2431 memcpy(&template, _template, sizeof(template));
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002432 template.index = 0;
2433
Mark Brownefb7ac32011-03-08 17:23:24 +00002434 if (!long_name)
2435 long_name = template.name;
2436
2437 if (prefix) {
2438 name_len = strlen(long_name) + strlen(prefix) + 2;
2439 name = kmalloc(name_len, GFP_ATOMIC);
2440 if (!name)
2441 return NULL;
2442
2443 snprintf(name, name_len, "%s %s", prefix, long_name);
2444
2445 template.name = name;
2446 } else {
2447 template.name = long_name;
2448 }
2449
2450 kcontrol = snd_ctl_new1(&template, data);
2451
2452 kfree(name);
2453
2454 return kcontrol;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002455}
2456EXPORT_SYMBOL_GPL(snd_soc_cnew);
2457
2458/**
Ian Molton3e8e1952009-01-09 00:23:21 +00002459 * snd_soc_add_controls - add an array of controls to a codec.
2460 * Convienience function to add a list of controls. Many codecs were
2461 * duplicating this code.
2462 *
2463 * @codec: codec to add controls to
2464 * @controls: array of controls to add
2465 * @num_controls: number of elements in the array
2466 *
2467 * Return 0 for success, else error.
2468 */
2469int snd_soc_add_controls(struct snd_soc_codec *codec,
2470 const struct snd_kcontrol_new *controls, int num_controls)
2471{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002472 struct snd_card *card = codec->card->snd_card;
Ian Molton3e8e1952009-01-09 00:23:21 +00002473 int err, i;
2474
2475 for (i = 0; i < num_controls; i++) {
2476 const struct snd_kcontrol_new *control = &controls[i];
Mark Brownefb7ac32011-03-08 17:23:24 +00002477 err = snd_ctl_add(card, snd_soc_cnew(control, codec,
2478 control->name,
2479 codec->name_prefix));
Ian Molton3e8e1952009-01-09 00:23:21 +00002480 if (err < 0) {
Mark Brown082100d2010-09-20 19:03:28 +01002481 dev_err(codec->dev, "%s: Failed to add %s: %d\n",
Mark Brownefb7ac32011-03-08 17:23:24 +00002482 codec->name, control->name, err);
Ian Molton3e8e1952009-01-09 00:23:21 +00002483 return err;
2484 }
2485 }
2486
2487 return 0;
2488}
2489EXPORT_SYMBOL_GPL(snd_soc_add_controls);
2490
2491/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002492 * snd_soc_info_enum_double - enumerated double mixer info callback
2493 * @kcontrol: mixer control
2494 * @uinfo: control element information
2495 *
2496 * Callback to provide information about a double enumerated
2497 * mixer control.
2498 *
2499 * Returns 0 for success.
2500 */
2501int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
2502 struct snd_ctl_elem_info *uinfo)
2503{
2504 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2505
2506 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2507 uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002508 uinfo->value.enumerated.items = e->max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002509
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002510 if (uinfo->value.enumerated.item > e->max - 1)
2511 uinfo->value.enumerated.item = e->max - 1;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002512 strcpy(uinfo->value.enumerated.name,
2513 e->texts[uinfo->value.enumerated.item]);
2514 return 0;
2515}
2516EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
2517
2518/**
2519 * snd_soc_get_enum_double - enumerated double mixer get callback
2520 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002521 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002522 *
2523 * Callback to get the value of a double enumerated mixer.
2524 *
2525 * Returns 0 for success.
2526 */
2527int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
2528 struct snd_ctl_elem_value *ucontrol)
2529{
2530 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2531 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002532 unsigned int val, bitmask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002533
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002534 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002535 ;
2536 val = snd_soc_read(codec, e->reg);
Mark Brown3ff3f642008-05-19 12:32:25 +02002537 ucontrol->value.enumerated.item[0]
2538 = (val >> e->shift_l) & (bitmask - 1);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002539 if (e->shift_l != e->shift_r)
2540 ucontrol->value.enumerated.item[1] =
2541 (val >> e->shift_r) & (bitmask - 1);
2542
2543 return 0;
2544}
2545EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
2546
2547/**
2548 * snd_soc_put_enum_double - enumerated double mixer put callback
2549 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002550 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002551 *
2552 * Callback to set the value of a double enumerated mixer.
2553 *
2554 * Returns 0 for success.
2555 */
2556int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
2557 struct snd_ctl_elem_value *ucontrol)
2558{
2559 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2560 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002561 unsigned int val;
2562 unsigned int mask, bitmask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002563
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002564 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002565 ;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002566 if (ucontrol->value.enumerated.item[0] > e->max - 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002567 return -EINVAL;
2568 val = ucontrol->value.enumerated.item[0] << e->shift_l;
2569 mask = (bitmask - 1) << e->shift_l;
2570 if (e->shift_l != e->shift_r) {
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002571 if (ucontrol->value.enumerated.item[1] > e->max - 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002572 return -EINVAL;
2573 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
2574 mask |= (bitmask - 1) << e->shift_r;
2575 }
2576
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002577 return snd_soc_update_bits_locked(codec, e->reg, mask, val);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002578}
2579EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
2580
2581/**
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002582 * snd_soc_get_value_enum_double - semi enumerated double mixer get callback
2583 * @kcontrol: mixer control
2584 * @ucontrol: control element information
2585 *
2586 * Callback to get the value of a double semi enumerated mixer.
2587 *
2588 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2589 * used for handling bitfield coded enumeration for example.
2590 *
2591 * Returns 0 for success.
2592 */
2593int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
2594 struct snd_ctl_elem_value *ucontrol)
2595{
2596 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Peter Ujfalusi74155552009-01-08 13:34:29 +02002597 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002598 unsigned int reg_val, val, mux;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002599
2600 reg_val = snd_soc_read(codec, e->reg);
2601 val = (reg_val >> e->shift_l) & e->mask;
2602 for (mux = 0; mux < e->max; mux++) {
2603 if (val == e->values[mux])
2604 break;
2605 }
2606 ucontrol->value.enumerated.item[0] = mux;
2607 if (e->shift_l != e->shift_r) {
2608 val = (reg_val >> e->shift_r) & e->mask;
2609 for (mux = 0; mux < e->max; mux++) {
2610 if (val == e->values[mux])
2611 break;
2612 }
2613 ucontrol->value.enumerated.item[1] = mux;
2614 }
2615
2616 return 0;
2617}
2618EXPORT_SYMBOL_GPL(snd_soc_get_value_enum_double);
2619
2620/**
2621 * snd_soc_put_value_enum_double - semi enumerated double mixer put callback
2622 * @kcontrol: mixer control
2623 * @ucontrol: control element information
2624 *
2625 * Callback to set the value of a double semi enumerated mixer.
2626 *
2627 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2628 * used for handling bitfield coded enumeration for example.
2629 *
2630 * Returns 0 for success.
2631 */
2632int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
2633 struct snd_ctl_elem_value *ucontrol)
2634{
2635 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Peter Ujfalusi74155552009-01-08 13:34:29 +02002636 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002637 unsigned int val;
2638 unsigned int mask;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002639
2640 if (ucontrol->value.enumerated.item[0] > e->max - 1)
2641 return -EINVAL;
2642 val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
2643 mask = e->mask << e->shift_l;
2644 if (e->shift_l != e->shift_r) {
2645 if (ucontrol->value.enumerated.item[1] > e->max - 1)
2646 return -EINVAL;
2647 val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
2648 mask |= e->mask << e->shift_r;
2649 }
2650
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002651 return snd_soc_update_bits_locked(codec, e->reg, mask, val);
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002652}
2653EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double);
2654
2655/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002656 * snd_soc_info_enum_ext - external enumerated single mixer info callback
2657 * @kcontrol: mixer control
2658 * @uinfo: control element information
2659 *
2660 * Callback to provide information about an external enumerated
2661 * single mixer.
2662 *
2663 * Returns 0 for success.
2664 */
2665int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
2666 struct snd_ctl_elem_info *uinfo)
2667{
2668 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2669
2670 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2671 uinfo->count = 1;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002672 uinfo->value.enumerated.items = e->max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002673
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002674 if (uinfo->value.enumerated.item > e->max - 1)
2675 uinfo->value.enumerated.item = e->max - 1;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002676 strcpy(uinfo->value.enumerated.name,
2677 e->texts[uinfo->value.enumerated.item]);
2678 return 0;
2679}
2680EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
2681
2682/**
2683 * snd_soc_info_volsw_ext - external single mixer info callback
2684 * @kcontrol: mixer control
2685 * @uinfo: control element information
2686 *
2687 * Callback to provide information about a single external mixer control.
2688 *
2689 * Returns 0 for success.
2690 */
2691int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
2692 struct snd_ctl_elem_info *uinfo)
2693{
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002694 int max = kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002695
Mark Brownfd5dfad2009-04-15 21:37:46 +01002696 if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002697 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2698 else
2699 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2700
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002701 uinfo->count = 1;
2702 uinfo->value.integer.min = 0;
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002703 uinfo->value.integer.max = max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002704 return 0;
2705}
2706EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
2707
2708/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002709 * snd_soc_info_volsw - single mixer info callback
2710 * @kcontrol: mixer control
2711 * @uinfo: control element information
2712 *
2713 * Callback to provide information about a single mixer control.
2714 *
2715 * Returns 0 for success.
2716 */
2717int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
2718 struct snd_ctl_elem_info *uinfo)
2719{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002720 struct soc_mixer_control *mc =
2721 (struct soc_mixer_control *)kcontrol->private_value;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002722 int platform_max;
Mark Brown762b8df2008-10-30 12:37:08 +00002723 unsigned int shift = mc->shift;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002724 unsigned int rshift = mc->rshift;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002725
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002726 if (!mc->platform_max)
2727 mc->platform_max = mc->max;
2728 platform_max = mc->platform_max;
2729
2730 if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002731 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2732 else
2733 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2734
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002735 uinfo->count = shift == rshift ? 1 : 2;
2736 uinfo->value.integer.min = 0;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002737 uinfo->value.integer.max = platform_max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002738 return 0;
2739}
2740EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
2741
2742/**
2743 * snd_soc_get_volsw - single mixer get callback
2744 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002745 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002746 *
2747 * Callback to get the value of a single mixer control.
2748 *
2749 * Returns 0 for success.
2750 */
2751int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
2752 struct snd_ctl_elem_value *ucontrol)
2753{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002754 struct soc_mixer_control *mc =
2755 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002756 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002757 unsigned int reg = mc->reg;
2758 unsigned int shift = mc->shift;
2759 unsigned int rshift = mc->rshift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002760 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002761 unsigned int mask = (1 << fls(max)) - 1;
2762 unsigned int invert = mc->invert;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002763
2764 ucontrol->value.integer.value[0] =
2765 (snd_soc_read(codec, reg) >> shift) & mask;
2766 if (shift != rshift)
2767 ucontrol->value.integer.value[1] =
2768 (snd_soc_read(codec, reg) >> rshift) & mask;
2769 if (invert) {
2770 ucontrol->value.integer.value[0] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002771 max - ucontrol->value.integer.value[0];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002772 if (shift != rshift)
2773 ucontrol->value.integer.value[1] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002774 max - ucontrol->value.integer.value[1];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002775 }
2776
2777 return 0;
2778}
2779EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
2780
2781/**
2782 * snd_soc_put_volsw - single mixer put callback
2783 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002784 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002785 *
2786 * Callback to set the value of a single mixer control.
2787 *
2788 * Returns 0 for success.
2789 */
2790int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
2791 struct snd_ctl_elem_value *ucontrol)
2792{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002793 struct soc_mixer_control *mc =
2794 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002795 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002796 unsigned int reg = mc->reg;
2797 unsigned int shift = mc->shift;
2798 unsigned int rshift = mc->rshift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002799 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002800 unsigned int mask = (1 << fls(max)) - 1;
2801 unsigned int invert = mc->invert;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002802 unsigned int val, val2, val_mask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002803
2804 val = (ucontrol->value.integer.value[0] & mask);
2805 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002806 val = max - val;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002807 val_mask = mask << shift;
2808 val = val << shift;
2809 if (shift != rshift) {
2810 val2 = (ucontrol->value.integer.value[1] & mask);
2811 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002812 val2 = max - val2;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002813 val_mask |= mask << rshift;
2814 val |= val2 << rshift;
2815 }
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002816 return snd_soc_update_bits_locked(codec, reg, val_mask, val);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002817}
2818EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
2819
2820/**
2821 * snd_soc_info_volsw_2r - double mixer info callback
2822 * @kcontrol: mixer control
2823 * @uinfo: control element information
2824 *
2825 * Callback to provide information about a double mixer control that
2826 * spans 2 codec registers.
2827 *
2828 * Returns 0 for success.
2829 */
2830int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
2831 struct snd_ctl_elem_info *uinfo)
2832{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002833 struct soc_mixer_control *mc =
2834 (struct soc_mixer_control *)kcontrol->private_value;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002835 int platform_max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002836
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002837 if (!mc->platform_max)
2838 mc->platform_max = mc->max;
2839 platform_max = mc->platform_max;
2840
2841 if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002842 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2843 else
2844 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2845
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002846 uinfo->count = 2;
2847 uinfo->value.integer.min = 0;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002848 uinfo->value.integer.max = platform_max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002849 return 0;
2850}
2851EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r);
2852
2853/**
2854 * snd_soc_get_volsw_2r - double mixer get callback
2855 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002856 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002857 *
2858 * Callback to get the value of a double mixer control that spans 2 registers.
2859 *
2860 * Returns 0 for success.
2861 */
2862int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
2863 struct snd_ctl_elem_value *ucontrol)
2864{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002865 struct soc_mixer_control *mc =
2866 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002867 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002868 unsigned int reg = mc->reg;
2869 unsigned int reg2 = mc->rreg;
2870 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002871 int max = mc->max;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002872 unsigned int mask = (1 << fls(max)) - 1;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002873 unsigned int invert = mc->invert;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002874
2875 ucontrol->value.integer.value[0] =
2876 (snd_soc_read(codec, reg) >> shift) & mask;
2877 ucontrol->value.integer.value[1] =
2878 (snd_soc_read(codec, reg2) >> shift) & mask;
2879 if (invert) {
2880 ucontrol->value.integer.value[0] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002881 max - ucontrol->value.integer.value[0];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002882 ucontrol->value.integer.value[1] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002883 max - ucontrol->value.integer.value[1];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002884 }
2885
2886 return 0;
2887}
2888EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r);
2889
2890/**
2891 * snd_soc_put_volsw_2r - double mixer set callback
2892 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002893 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002894 *
2895 * Callback to set the value of a double mixer control that spans 2 registers.
2896 *
2897 * Returns 0 for success.
2898 */
2899int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
2900 struct snd_ctl_elem_value *ucontrol)
2901{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002902 struct soc_mixer_control *mc =
2903 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002904 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002905 unsigned int reg = mc->reg;
2906 unsigned int reg2 = mc->rreg;
2907 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002908 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002909 unsigned int mask = (1 << fls(max)) - 1;
2910 unsigned int invert = mc->invert;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002911 int err;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002912 unsigned int val, val2, val_mask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002913
2914 val_mask = mask << shift;
2915 val = (ucontrol->value.integer.value[0] & mask);
2916 val2 = (ucontrol->value.integer.value[1] & mask);
2917
2918 if (invert) {
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002919 val = max - val;
2920 val2 = max - val2;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002921 }
2922
2923 val = val << shift;
2924 val2 = val2 << shift;
2925
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002926 err = snd_soc_update_bits_locked(codec, reg, val_mask, val);
Mark Brown3ff3f642008-05-19 12:32:25 +02002927 if (err < 0)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002928 return err;
2929
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002930 err = snd_soc_update_bits_locked(codec, reg2, val_mask, val2);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002931 return err;
2932}
2933EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r);
2934
Mark Browne13ac2e2008-05-28 17:58:05 +01002935/**
2936 * snd_soc_info_volsw_s8 - signed mixer info callback
2937 * @kcontrol: mixer control
2938 * @uinfo: control element information
2939 *
2940 * Callback to provide information about a signed mixer control.
2941 *
2942 * Returns 0 for success.
2943 */
2944int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
2945 struct snd_ctl_elem_info *uinfo)
2946{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002947 struct soc_mixer_control *mc =
2948 (struct soc_mixer_control *)kcontrol->private_value;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002949 int platform_max;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002950 int min = mc->min;
Mark Browne13ac2e2008-05-28 17:58:05 +01002951
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002952 if (!mc->platform_max)
2953 mc->platform_max = mc->max;
2954 platform_max = mc->platform_max;
2955
Mark Browne13ac2e2008-05-28 17:58:05 +01002956 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2957 uinfo->count = 2;
2958 uinfo->value.integer.min = 0;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002959 uinfo->value.integer.max = platform_max - min;
Mark Browne13ac2e2008-05-28 17:58:05 +01002960 return 0;
2961}
2962EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
2963
2964/**
2965 * snd_soc_get_volsw_s8 - signed mixer get callback
2966 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002967 * @ucontrol: control element information
Mark Browne13ac2e2008-05-28 17:58:05 +01002968 *
2969 * Callback to get the value of a signed mixer control.
2970 *
2971 * Returns 0 for success.
2972 */
2973int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
2974 struct snd_ctl_elem_value *ucontrol)
2975{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002976 struct soc_mixer_control *mc =
2977 (struct soc_mixer_control *)kcontrol->private_value;
Mark Browne13ac2e2008-05-28 17:58:05 +01002978 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002979 unsigned int reg = mc->reg;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002980 int min = mc->min;
Mark Browne13ac2e2008-05-28 17:58:05 +01002981 int val = snd_soc_read(codec, reg);
2982
2983 ucontrol->value.integer.value[0] =
2984 ((signed char)(val & 0xff))-min;
2985 ucontrol->value.integer.value[1] =
2986 ((signed char)((val >> 8) & 0xff))-min;
2987 return 0;
2988}
2989EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
2990
2991/**
2992 * snd_soc_put_volsw_sgn - signed mixer put callback
2993 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002994 * @ucontrol: control element information
Mark Browne13ac2e2008-05-28 17:58:05 +01002995 *
2996 * Callback to set the value of a signed mixer control.
2997 *
2998 * Returns 0 for success.
2999 */
3000int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
3001 struct snd_ctl_elem_value *ucontrol)
3002{
Jon Smirl4eaa9812008-07-29 11:42:26 +01003003 struct soc_mixer_control *mc =
3004 (struct soc_mixer_control *)kcontrol->private_value;
Mark Browne13ac2e2008-05-28 17:58:05 +01003005 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04003006 unsigned int reg = mc->reg;
Jon Smirl4eaa9812008-07-29 11:42:26 +01003007 int min = mc->min;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03003008 unsigned int val;
Mark Browne13ac2e2008-05-28 17:58:05 +01003009
3010 val = (ucontrol->value.integer.value[0]+min) & 0xff;
3011 val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
3012
Eero Nurkkala6c508c62009-10-30 13:34:03 +02003013 return snd_soc_update_bits_locked(codec, reg, 0xffff, val);
Mark Browne13ac2e2008-05-28 17:58:05 +01003014}
3015EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
3016
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003017/**
Peter Ujfalusi637d3842010-05-07 14:05:49 +03003018 * snd_soc_limit_volume - Set new limit to an existing volume control.
3019 *
3020 * @codec: where to look for the control
3021 * @name: Name of the control
3022 * @max: new maximum limit
3023 *
3024 * Return 0 for success, else error.
3025 */
3026int snd_soc_limit_volume(struct snd_soc_codec *codec,
3027 const char *name, int max)
3028{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003029 struct snd_card *card = codec->card->snd_card;
Peter Ujfalusi637d3842010-05-07 14:05:49 +03003030 struct snd_kcontrol *kctl;
3031 struct soc_mixer_control *mc;
3032 int found = 0;
3033 int ret = -EINVAL;
3034
3035 /* Sanity check for name and max */
3036 if (unlikely(!name || max <= 0))
3037 return -EINVAL;
3038
3039 list_for_each_entry(kctl, &card->controls, list) {
3040 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name))) {
3041 found = 1;
3042 break;
3043 }
3044 }
3045 if (found) {
3046 mc = (struct soc_mixer_control *)kctl->private_value;
3047 if (max <= mc->max) {
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03003048 mc->platform_max = max;
Peter Ujfalusi637d3842010-05-07 14:05:49 +03003049 ret = 0;
3050 }
3051 }
3052 return ret;
3053}
3054EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
3055
3056/**
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02003057 * snd_soc_info_volsw_2r_sx - double with tlv and variable data size
3058 * mixer info callback
3059 * @kcontrol: mixer control
3060 * @uinfo: control element information
3061 *
3062 * Returns 0 for success.
3063 */
3064int snd_soc_info_volsw_2r_sx(struct snd_kcontrol *kcontrol,
3065 struct snd_ctl_elem_info *uinfo)
3066{
3067 struct soc_mixer_control *mc =
3068 (struct soc_mixer_control *)kcontrol->private_value;
3069 int max = mc->max;
3070 int min = mc->min;
3071
3072 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
3073 uinfo->count = 2;
3074 uinfo->value.integer.min = 0;
3075 uinfo->value.integer.max = max-min;
3076
3077 return 0;
3078}
3079EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r_sx);
3080
3081/**
3082 * snd_soc_get_volsw_2r_sx - double with tlv and variable data size
3083 * mixer get callback
3084 * @kcontrol: mixer control
3085 * @uinfo: control element information
3086 *
3087 * Returns 0 for success.
3088 */
3089int snd_soc_get_volsw_2r_sx(struct snd_kcontrol *kcontrol,
3090 struct snd_ctl_elem_value *ucontrol)
3091{
3092 struct soc_mixer_control *mc =
3093 (struct soc_mixer_control *)kcontrol->private_value;
3094 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
3095 unsigned int mask = (1<<mc->shift)-1;
3096 int min = mc->min;
3097 int val = snd_soc_read(codec, mc->reg) & mask;
3098 int valr = snd_soc_read(codec, mc->rreg) & mask;
3099
Stuart Longland20630c72010-06-18 12:56:10 +10003100 ucontrol->value.integer.value[0] = ((val & 0xff)-min) & mask;
3101 ucontrol->value.integer.value[1] = ((valr & 0xff)-min) & mask;
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02003102 return 0;
3103}
3104EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r_sx);
3105
3106/**
3107 * snd_soc_put_volsw_2r_sx - double with tlv and variable data size
3108 * mixer put callback
3109 * @kcontrol: mixer control
3110 * @uinfo: control element information
3111 *
3112 * Returns 0 for success.
3113 */
3114int snd_soc_put_volsw_2r_sx(struct snd_kcontrol *kcontrol,
3115 struct snd_ctl_elem_value *ucontrol)
3116{
3117 struct soc_mixer_control *mc =
3118 (struct soc_mixer_control *)kcontrol->private_value;
3119 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
3120 unsigned int mask = (1<<mc->shift)-1;
3121 int min = mc->min;
3122 int ret;
3123 unsigned int val, valr, oval, ovalr;
3124
3125 val = ((ucontrol->value.integer.value[0]+min) & 0xff);
3126 val &= mask;
3127 valr = ((ucontrol->value.integer.value[1]+min) & 0xff);
3128 valr &= mask;
3129
3130 oval = snd_soc_read(codec, mc->reg) & mask;
3131 ovalr = snd_soc_read(codec, mc->rreg) & mask;
3132
3133 ret = 0;
3134 if (oval != val) {
3135 ret = snd_soc_write(codec, mc->reg, val);
3136 if (ret < 0)
Mark Brownf1df5ae2010-06-15 15:14:31 +01003137 return ret;
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02003138 }
3139 if (ovalr != valr) {
3140 ret = snd_soc_write(codec, mc->rreg, valr);
3141 if (ret < 0)
Mark Brownf1df5ae2010-06-15 15:14:31 +01003142 return ret;
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02003143 }
3144
3145 return 0;
3146}
3147EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r_sx);
3148
3149/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003150 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
3151 * @dai: DAI
3152 * @clk_id: DAI specific clock ID
3153 * @freq: new clock frequency in Hz
3154 * @dir: new clock direction - input/output.
3155 *
3156 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
3157 */
3158int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
3159 unsigned int freq, int dir)
3160{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003161 if (dai->driver && dai->driver->ops->set_sysclk)
3162 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
Mark Brownec4ee522011-03-07 20:58:11 +00003163 else if (dai->codec && dai->codec->driver->set_sysclk)
3164 return dai->codec->driver->set_sysclk(dai->codec, clk_id,
3165 freq, dir);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003166 else
3167 return -EINVAL;
3168}
3169EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
3170
3171/**
Mark Brownec4ee522011-03-07 20:58:11 +00003172 * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
3173 * @codec: CODEC
3174 * @clk_id: DAI specific clock ID
3175 * @freq: new clock frequency in Hz
3176 * @dir: new clock direction - input/output.
3177 *
3178 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
3179 */
3180int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
3181 unsigned int freq, int dir)
3182{
3183 if (codec->driver->set_sysclk)
3184 return codec->driver->set_sysclk(codec, clk_id, freq, dir);
3185 else
3186 return -EINVAL;
3187}
3188EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
3189
3190/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003191 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
3192 * @dai: DAI
Mark Brownac11a2b2009-01-01 12:18:17 +00003193 * @div_id: DAI specific clock divider ID
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003194 * @div: new clock divisor.
3195 *
3196 * Configures the clock dividers. This is used to derive the best DAI bit and
3197 * frame clocks from the system or master clock. It's best to set the DAI bit
3198 * and frame clocks as low as possible to save system power.
3199 */
3200int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
3201 int div_id, int div)
3202{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003203 if (dai->driver && dai->driver->ops->set_clkdiv)
3204 return dai->driver->ops->set_clkdiv(dai, div_id, div);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003205 else
3206 return -EINVAL;
3207}
3208EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
3209
3210/**
3211 * snd_soc_dai_set_pll - configure DAI PLL.
3212 * @dai: DAI
3213 * @pll_id: DAI specific PLL ID
Mark Brown85488032009-09-05 18:52:16 +01003214 * @source: DAI specific source for the PLL
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003215 * @freq_in: PLL input clock frequency in Hz
3216 * @freq_out: requested PLL output clock frequency in Hz
3217 *
3218 * Configures and enables PLL to generate output clock based on input clock.
3219 */
Mark Brown85488032009-09-05 18:52:16 +01003220int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
3221 unsigned int freq_in, unsigned int freq_out)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003222{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003223 if (dai->driver && dai->driver->ops->set_pll)
3224 return dai->driver->ops->set_pll(dai, pll_id, source,
Mark Brown85488032009-09-05 18:52:16 +01003225 freq_in, freq_out);
Mark Brownec4ee522011-03-07 20:58:11 +00003226 else if (dai->codec && dai->codec->driver->set_pll)
3227 return dai->codec->driver->set_pll(dai->codec, pll_id, source,
3228 freq_in, freq_out);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003229 else
3230 return -EINVAL;
3231}
3232EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
3233
Mark Brownec4ee522011-03-07 20:58:11 +00003234/*
3235 * snd_soc_codec_set_pll - configure codec PLL.
3236 * @codec: CODEC
3237 * @pll_id: DAI specific PLL ID
3238 * @source: DAI specific source for the PLL
3239 * @freq_in: PLL input clock frequency in Hz
3240 * @freq_out: requested PLL output clock frequency in Hz
3241 *
3242 * Configures and enables PLL to generate output clock based on input clock.
3243 */
3244int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
3245 unsigned int freq_in, unsigned int freq_out)
3246{
3247 if (codec->driver->set_pll)
3248 return codec->driver->set_pll(codec, pll_id, source,
3249 freq_in, freq_out);
3250 else
3251 return -EINVAL;
3252}
3253EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);
3254
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003255/**
3256 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
3257 * @dai: DAI
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003258 * @fmt: SND_SOC_DAIFMT_ format value.
3259 *
3260 * Configures the DAI hardware format and clocking.
3261 */
3262int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
3263{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003264 if (dai->driver && dai->driver->ops->set_fmt)
3265 return dai->driver->ops->set_fmt(dai, fmt);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003266 else
3267 return -EINVAL;
3268}
3269EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
3270
3271/**
3272 * snd_soc_dai_set_tdm_slot - configure DAI TDM.
3273 * @dai: DAI
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03003274 * @tx_mask: bitmask representing active TX slots.
3275 * @rx_mask: bitmask representing active RX slots.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003276 * @slots: Number of slots in use.
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03003277 * @slot_width: Width in bits for each slot.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003278 *
3279 * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
3280 * specific.
3281 */
3282int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03003283 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003284{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003285 if (dai->driver && dai->driver->ops->set_tdm_slot)
3286 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03003287 slots, slot_width);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003288 else
3289 return -EINVAL;
3290}
3291EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
3292
3293/**
Barry Song472df3c2009-09-12 01:16:29 +08003294 * snd_soc_dai_set_channel_map - configure DAI audio channel map
3295 * @dai: DAI
3296 * @tx_num: how many TX channels
3297 * @tx_slot: pointer to an array which imply the TX slot number channel
3298 * 0~num-1 uses
3299 * @rx_num: how many RX channels
3300 * @rx_slot: pointer to an array which imply the RX slot number channel
3301 * 0~num-1 uses
3302 *
3303 * configure the relationship between channel number and TDM slot number.
3304 */
3305int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
3306 unsigned int tx_num, unsigned int *tx_slot,
3307 unsigned int rx_num, unsigned int *rx_slot)
3308{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003309 if (dai->driver && dai->driver->ops->set_channel_map)
3310 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
Barry Song472df3c2009-09-12 01:16:29 +08003311 rx_num, rx_slot);
3312 else
3313 return -EINVAL;
3314}
3315EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
3316
3317/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003318 * snd_soc_dai_set_tristate - configure DAI system or master clock.
3319 * @dai: DAI
3320 * @tristate: tristate enable
3321 *
3322 * Tristates the DAI so that others can use it.
3323 */
3324int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
3325{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003326 if (dai->driver && dai->driver->ops->set_tristate)
3327 return dai->driver->ops->set_tristate(dai, tristate);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003328 else
3329 return -EINVAL;
3330}
3331EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
3332
3333/**
3334 * snd_soc_dai_digital_mute - configure DAI system or master clock.
3335 * @dai: DAI
3336 * @mute: mute enable
3337 *
3338 * Mutes the DAI DAC.
3339 */
3340int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
3341{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003342 if (dai->driver && dai->driver->ops->digital_mute)
3343 return dai->driver->ops->digital_mute(dai, mute);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003344 else
3345 return -EINVAL;
3346}
3347EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
3348
Mark Brownc5af3a22008-11-28 13:29:45 +00003349/**
3350 * snd_soc_register_card - Register a card with the ASoC core
3351 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003352 * @card: Card to register
Mark Brownc5af3a22008-11-28 13:29:45 +00003353 *
Mark Brownc5af3a22008-11-28 13:29:45 +00003354 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05303355int snd_soc_register_card(struct snd_soc_card *card)
Mark Brownc5af3a22008-11-28 13:29:45 +00003356{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003357 int i;
3358
Mark Brownc5af3a22008-11-28 13:29:45 +00003359 if (!card->name || !card->dev)
3360 return -EINVAL;
3361
Mark Browned77cc12011-05-03 18:25:34 +01003362 dev_set_drvdata(card->dev, card);
3363
Stephen Warren111c6412011-01-28 14:26:35 -07003364 snd_soc_initialize_card_lists(card);
3365
Vinod Koul150dd2f2011-01-13 22:48:32 +05303366 soc_init_card_debugfs(card);
3367
Jarkko Nikula2eea3922010-11-25 17:47:38 +02003368 card->rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime) *
3369 (card->num_links + card->num_aux_devs),
3370 GFP_KERNEL);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003371 if (card->rtd == NULL)
3372 return -ENOMEM;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02003373 card->rtd_aux = &card->rtd[card->num_links];
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003374
3375 for (i = 0; i < card->num_links; i++)
3376 card->rtd[i].dai_link = &card->dai_link[i];
3377
Mark Brownc5af3a22008-11-28 13:29:45 +00003378 INIT_LIST_HEAD(&card->list);
3379 card->instantiated = 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003380 mutex_init(&card->mutex);
Mark Brownc5af3a22008-11-28 13:29:45 +00003381
3382 mutex_lock(&client_mutex);
3383 list_add(&card->list, &card_list);
Mark Brown435c5e22008-12-04 15:32:53 +00003384 snd_soc_instantiate_cards();
Mark Brownc5af3a22008-11-28 13:29:45 +00003385 mutex_unlock(&client_mutex);
3386
3387 dev_dbg(card->dev, "Registered card '%s'\n", card->name);
3388
3389 return 0;
3390}
Vinod Koul70a7ca32011-01-14 19:22:48 +05303391EXPORT_SYMBOL_GPL(snd_soc_register_card);
Mark Brownc5af3a22008-11-28 13:29:45 +00003392
3393/**
3394 * snd_soc_unregister_card - Unregister a card with the ASoC core
3395 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003396 * @card: Card to unregister
Mark Brownc5af3a22008-11-28 13:29:45 +00003397 *
Mark Brownc5af3a22008-11-28 13:29:45 +00003398 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05303399int snd_soc_unregister_card(struct snd_soc_card *card)
Mark Brownc5af3a22008-11-28 13:29:45 +00003400{
Vinod Koulb0e26482011-01-13 22:48:02 +05303401 if (card->instantiated)
3402 soc_cleanup_card_resources(card);
Mark Brownc5af3a22008-11-28 13:29:45 +00003403 mutex_lock(&client_mutex);
3404 list_del(&card->list);
3405 mutex_unlock(&client_mutex);
Mark Brownc5af3a22008-11-28 13:29:45 +00003406 dev_dbg(card->dev, "Unregistered card '%s'\n", card->name);
3407
3408 return 0;
3409}
Vinod Koul70a7ca32011-01-14 19:22:48 +05303410EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
Mark Brownc5af3a22008-11-28 13:29:45 +00003411
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003412/*
3413 * Simplify DAI link configuration by removing ".-1" from device names
3414 * and sanitizing names.
3415 */
Dimitris Papastamos0b9a2142010-12-06 15:49:20 +00003416static char *fmt_single_name(struct device *dev, int *id)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003417{
3418 char *found, name[NAME_SIZE];
3419 int id1, id2;
3420
3421 if (dev_name(dev) == NULL)
3422 return NULL;
3423
Dimitris Papastamos58818a72010-12-06 15:42:17 +00003424 strlcpy(name, dev_name(dev), NAME_SIZE);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003425
3426 /* are we a "%s.%d" name (platform and SPI components) */
3427 found = strstr(name, dev->driver->name);
3428 if (found) {
3429 /* get ID */
3430 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
3431
3432 /* discard ID from name if ID == -1 */
3433 if (*id == -1)
3434 found[strlen(dev->driver->name)] = '\0';
3435 }
3436
3437 } else {
3438 /* I2C component devices are named "bus-addr" */
3439 if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
3440 char tmp[NAME_SIZE];
3441
3442 /* create unique ID number from I2C addr and bus */
Jarkko Nikula05899442010-10-19 11:10:45 +03003443 *id = ((id1 & 0xffff) << 16) + id2;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003444
3445 /* sanitize component name for DAI link creation */
3446 snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
Dimitris Papastamos58818a72010-12-06 15:42:17 +00003447 strlcpy(name, tmp, NAME_SIZE);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003448 } else
3449 *id = 0;
3450 }
3451
3452 return kstrdup(name, GFP_KERNEL);
3453}
3454
3455/*
3456 * Simplify DAI link naming for single devices with multiple DAIs by removing
3457 * any ".-1" and using the DAI name (instead of device name).
3458 */
3459static inline char *fmt_multiple_name(struct device *dev,
3460 struct snd_soc_dai_driver *dai_drv)
3461{
3462 if (dai_drv->name == NULL) {
3463 printk(KERN_ERR "asoc: error - multiple DAI %s registered with no name\n",
3464 dev_name(dev));
3465 return NULL;
3466 }
3467
3468 return kstrdup(dai_drv->name, GFP_KERNEL);
3469}
3470
Mark Brown91151712008-11-30 23:31:24 +00003471/**
3472 * snd_soc_register_dai - Register a DAI with the ASoC core
3473 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003474 * @dai: DAI to register
Mark Brown91151712008-11-30 23:31:24 +00003475 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003476int snd_soc_register_dai(struct device *dev,
3477 struct snd_soc_dai_driver *dai_drv)
Mark Brown91151712008-11-30 23:31:24 +00003478{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003479 struct snd_soc_dai *dai;
Mark Brown91151712008-11-30 23:31:24 +00003480
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003481 dev_dbg(dev, "dai register %s\n", dev_name(dev));
Mark Brown91151712008-11-30 23:31:24 +00003482
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003483 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
3484 if (dai == NULL)
Lu Guanquna7393622011-04-20 16:00:51 +08003485 return -ENOMEM;
Eric Miao6335d052009-03-03 09:41:00 +08003486
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003487 /* create DAI component name */
3488 dai->name = fmt_single_name(dev, &dai->id);
3489 if (dai->name == NULL) {
3490 kfree(dai);
3491 return -ENOMEM;
3492 }
3493
3494 dai->dev = dev;
3495 dai->driver = dai_drv;
3496 if (!dai->driver->ops)
3497 dai->driver->ops = &null_dai_ops;
Mark Brown91151712008-11-30 23:31:24 +00003498
3499 mutex_lock(&client_mutex);
3500 list_add(&dai->list, &dai_list);
Mark Brown435c5e22008-12-04 15:32:53 +00003501 snd_soc_instantiate_cards();
Mark Brown91151712008-11-30 23:31:24 +00003502 mutex_unlock(&client_mutex);
3503
3504 pr_debug("Registered DAI '%s'\n", dai->name);
3505
3506 return 0;
3507}
3508EXPORT_SYMBOL_GPL(snd_soc_register_dai);
3509
3510/**
3511 * snd_soc_unregister_dai - Unregister a DAI from the ASoC core
3512 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003513 * @dai: DAI to unregister
Mark Brown91151712008-11-30 23:31:24 +00003514 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003515void snd_soc_unregister_dai(struct device *dev)
Mark Brown91151712008-11-30 23:31:24 +00003516{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003517 struct snd_soc_dai *dai;
3518
3519 list_for_each_entry(dai, &dai_list, list) {
3520 if (dev == dai->dev)
3521 goto found;
3522 }
3523 return;
3524
3525found:
Mark Brown91151712008-11-30 23:31:24 +00003526 mutex_lock(&client_mutex);
3527 list_del(&dai->list);
3528 mutex_unlock(&client_mutex);
3529
3530 pr_debug("Unregistered DAI '%s'\n", dai->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003531 kfree(dai->name);
3532 kfree(dai);
Mark Brown91151712008-11-30 23:31:24 +00003533}
3534EXPORT_SYMBOL_GPL(snd_soc_unregister_dai);
3535
3536/**
3537 * snd_soc_register_dais - Register multiple DAIs with the ASoC core
3538 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003539 * @dai: Array of DAIs to register
3540 * @count: Number of DAIs
Mark Brown91151712008-11-30 23:31:24 +00003541 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003542int snd_soc_register_dais(struct device *dev,
3543 struct snd_soc_dai_driver *dai_drv, size_t count)
Mark Brown91151712008-11-30 23:31:24 +00003544{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003545 struct snd_soc_dai *dai;
3546 int i, ret = 0;
3547
Liam Girdwood720ffa42010-08-18 00:30:30 +01003548 dev_dbg(dev, "dai register %s #%Zu\n", dev_name(dev), count);
Mark Brown91151712008-11-30 23:31:24 +00003549
3550 for (i = 0; i < count; i++) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003551
3552 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
Axel Linc46e0072010-11-03 15:04:45 +08003553 if (dai == NULL) {
3554 ret = -ENOMEM;
3555 goto err;
3556 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003557
3558 /* create DAI component name */
3559 dai->name = fmt_multiple_name(dev, &dai_drv[i]);
3560 if (dai->name == NULL) {
3561 kfree(dai);
3562 ret = -EINVAL;
Mark Brown91151712008-11-30 23:31:24 +00003563 goto err;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003564 }
3565
3566 dai->dev = dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003567 dai->driver = &dai_drv[i];
Mark Brown0f9141c2010-10-12 15:43:21 +01003568 if (dai->driver->id)
3569 dai->id = dai->driver->id;
3570 else
3571 dai->id = i;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003572 if (!dai->driver->ops)
3573 dai->driver->ops = &null_dai_ops;
3574
3575 mutex_lock(&client_mutex);
3576 list_add(&dai->list, &dai_list);
3577 mutex_unlock(&client_mutex);
3578
3579 pr_debug("Registered DAI '%s'\n", dai->name);
Mark Brown91151712008-11-30 23:31:24 +00003580 }
3581
Axel Lin1dcb4f32010-12-06 16:48:03 +08003582 mutex_lock(&client_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003583 snd_soc_instantiate_cards();
Axel Lin1dcb4f32010-12-06 16:48:03 +08003584 mutex_unlock(&client_mutex);
Mark Brown91151712008-11-30 23:31:24 +00003585 return 0;
3586
3587err:
3588 for (i--; i >= 0; i--)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003589 snd_soc_unregister_dai(dev);
Mark Brown91151712008-11-30 23:31:24 +00003590
3591 return ret;
3592}
3593EXPORT_SYMBOL_GPL(snd_soc_register_dais);
3594
3595/**
3596 * snd_soc_unregister_dais - Unregister multiple DAIs from the ASoC core
3597 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003598 * @dai: Array of DAIs to unregister
3599 * @count: Number of DAIs
Mark Brown91151712008-11-30 23:31:24 +00003600 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003601void snd_soc_unregister_dais(struct device *dev, size_t count)
Mark Brown91151712008-11-30 23:31:24 +00003602{
3603 int i;
3604
3605 for (i = 0; i < count; i++)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003606 snd_soc_unregister_dai(dev);
Mark Brown91151712008-11-30 23:31:24 +00003607}
3608EXPORT_SYMBOL_GPL(snd_soc_unregister_dais);
3609
Mark Brown12a48a8c2008-12-03 19:40:30 +00003610/**
3611 * snd_soc_register_platform - Register a platform with the ASoC core
3612 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003613 * @platform: platform to register
Mark Brown12a48a8c2008-12-03 19:40:30 +00003614 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003615int snd_soc_register_platform(struct device *dev,
3616 struct snd_soc_platform_driver *platform_drv)
Mark Brown12a48a8c2008-12-03 19:40:30 +00003617{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003618 struct snd_soc_platform *platform;
Mark Brown12a48a8c2008-12-03 19:40:30 +00003619
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003620 dev_dbg(dev, "platform register %s\n", dev_name(dev));
3621
3622 platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
3623 if (platform == NULL)
Lu Guanquna7393622011-04-20 16:00:51 +08003624 return -ENOMEM;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003625
3626 /* create platform component name */
3627 platform->name = fmt_single_name(dev, &platform->id);
3628 if (platform->name == NULL) {
3629 kfree(platform);
3630 return -ENOMEM;
3631 }
3632
3633 platform->dev = dev;
3634 platform->driver = platform_drv;
Mark Brown12a48a8c2008-12-03 19:40:30 +00003635
3636 mutex_lock(&client_mutex);
3637 list_add(&platform->list, &platform_list);
Mark Brown435c5e22008-12-04 15:32:53 +00003638 snd_soc_instantiate_cards();
Mark Brown12a48a8c2008-12-03 19:40:30 +00003639 mutex_unlock(&client_mutex);
3640
3641 pr_debug("Registered platform '%s'\n", platform->name);
3642
3643 return 0;
3644}
3645EXPORT_SYMBOL_GPL(snd_soc_register_platform);
3646
3647/**
3648 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
3649 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003650 * @platform: platform to unregister
Mark Brown12a48a8c2008-12-03 19:40:30 +00003651 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003652void snd_soc_unregister_platform(struct device *dev)
Mark Brown12a48a8c2008-12-03 19:40:30 +00003653{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003654 struct snd_soc_platform *platform;
3655
3656 list_for_each_entry(platform, &platform_list, list) {
3657 if (dev == platform->dev)
3658 goto found;
3659 }
3660 return;
3661
3662found:
Mark Brown12a48a8c2008-12-03 19:40:30 +00003663 mutex_lock(&client_mutex);
3664 list_del(&platform->list);
3665 mutex_unlock(&client_mutex);
3666
3667 pr_debug("Unregistered platform '%s'\n", platform->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003668 kfree(platform->name);
3669 kfree(platform);
Mark Brown12a48a8c2008-12-03 19:40:30 +00003670}
3671EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
3672
Mark Brown151ab222009-05-09 16:22:58 +01003673static u64 codec_format_map[] = {
3674 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
3675 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
3676 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
3677 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
3678 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
3679 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
3680 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3681 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3682 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
3683 SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
3684 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
3685 SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
3686 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
3687 SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
3688 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
3689 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
3690};
3691
3692/* Fix up the DAI formats for endianness: codecs don't actually see
3693 * the endianness of the data but we're using the CPU format
3694 * definitions which do need to include endianness so we ensure that
3695 * codec DAIs always have both big and little endian variants set.
3696 */
3697static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
3698{
3699 int i;
3700
3701 for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
3702 if (stream->formats & codec_format_map[i])
3703 stream->formats |= codec_format_map[i];
3704}
3705
Mark Brown0d0cf002008-12-10 14:32:45 +00003706/**
3707 * snd_soc_register_codec - Register a codec with the ASoC core
3708 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003709 * @codec: codec to register
Mark Brown0d0cf002008-12-10 14:32:45 +00003710 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003711int snd_soc_register_codec(struct device *dev,
Mark Brown001ae4c2010-12-02 16:21:08 +00003712 const struct snd_soc_codec_driver *codec_drv,
3713 struct snd_soc_dai_driver *dai_drv,
3714 int num_dai)
Mark Brown0d0cf002008-12-10 14:32:45 +00003715{
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003716 size_t reg_size;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003717 struct snd_soc_codec *codec;
3718 int ret, i;
Mark Brown151ab222009-05-09 16:22:58 +01003719
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003720 dev_dbg(dev, "codec register %s\n", dev_name(dev));
Mark Brown0d0cf002008-12-10 14:32:45 +00003721
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003722 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
3723 if (codec == NULL)
3724 return -ENOMEM;
Mark Brown0d0cf002008-12-10 14:32:45 +00003725
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003726 /* create CODEC component name */
3727 codec->name = fmt_single_name(dev, &codec->id);
3728 if (codec->name == NULL) {
3729 kfree(codec);
3730 return -ENOMEM;
Mark Brown151ab222009-05-09 16:22:58 +01003731 }
3732
Dimitris Papastamos23bbce32010-12-02 14:53:01 +00003733 if (codec_drv->compress_type)
3734 codec->compress_type = codec_drv->compress_type;
3735 else
3736 codec->compress_type = SND_SOC_FLAT_COMPRESSION;
3737
Mark Brownc3acec22010-12-02 16:15:29 +00003738 codec->write = codec_drv->write;
3739 codec->read = codec_drv->read;
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00003740 codec->volatile_register = codec_drv->volatile_register;
3741 codec->readable_register = codec_drv->readable_register;
Dimitris Papastamos80204542011-03-24 13:45:17 +00003742 codec->writable_register = codec_drv->writable_register;
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003743 codec->dapm.bias_level = SND_SOC_BIAS_OFF;
3744 codec->dapm.dev = dev;
3745 codec->dapm.codec = codec;
Mark Brown474b62d2011-01-18 16:14:44 +00003746 codec->dapm.seq_notifier = codec_drv->seq_notifier;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003747 codec->dev = dev;
3748 codec->driver = codec_drv;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003749 codec->num_dai = num_dai;
3750 mutex_init(&codec->mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003751
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003752 /* allocate CODEC register cache */
3753 if (codec_drv->reg_cache_size && codec_drv->reg_word_size) {
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003754 reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
Dimitris Papastamosaea170a2011-01-12 10:38:58 +00003755 codec->reg_size = reg_size;
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003756 /* it is necessary to make a copy of the default register cache
3757 * because in the case of using a compression type that requires
3758 * the default register cache to be marked as __devinitconst the
3759 * kernel might have freed the array by the time we initialize
3760 * the cache.
3761 */
Dimitris Papastamos2aa86322011-01-10 10:10:56 +00003762 if (codec_drv->reg_cache_default) {
3763 codec->reg_def_copy = kmemdup(codec_drv->reg_cache_default,
3764 reg_size, GFP_KERNEL);
3765 if (!codec->reg_def_copy) {
3766 ret = -ENOMEM;
3767 goto fail;
3768 }
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003769 }
3770 }
3771
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00003772 if (codec_drv->reg_access_size && codec_drv->reg_access_default) {
3773 if (!codec->volatile_register)
3774 codec->volatile_register = snd_soc_default_volatile_register;
3775 if (!codec->readable_register)
3776 codec->readable_register = snd_soc_default_readable_register;
Dimitris Papastamos80204542011-03-24 13:45:17 +00003777 if (!codec->writable_register)
3778 codec->writable_register = snd_soc_default_writable_register;
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00003779 }
3780
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003781 for (i = 0; i < num_dai; i++) {
3782 fixup_codec_formats(&dai_drv[i].playback);
3783 fixup_codec_formats(&dai_drv[i].capture);
3784 }
3785
Mark Brown26b01cc2010-08-18 20:20:55 +01003786 /* register any DAIs */
3787 if (num_dai) {
3788 ret = snd_soc_register_dais(dev, dai_drv, num_dai);
3789 if (ret < 0)
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00003790 goto fail;
Mark Brown26b01cc2010-08-18 20:20:55 +01003791 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003792
Mark Brown0d0cf002008-12-10 14:32:45 +00003793 mutex_lock(&client_mutex);
3794 list_add(&codec->list, &codec_list);
3795 snd_soc_instantiate_cards();
3796 mutex_unlock(&client_mutex);
3797
3798 pr_debug("Registered codec '%s'\n", codec->name);
Mark Brown0d0cf002008-12-10 14:32:45 +00003799 return 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003800
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00003801fail:
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003802 kfree(codec->reg_def_copy);
3803 codec->reg_def_copy = NULL;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003804 kfree(codec->name);
3805 kfree(codec);
3806 return ret;
Mark Brown0d0cf002008-12-10 14:32:45 +00003807}
3808EXPORT_SYMBOL_GPL(snd_soc_register_codec);
3809
3810/**
3811 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
3812 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003813 * @codec: codec to unregister
Mark Brown0d0cf002008-12-10 14:32:45 +00003814 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003815void snd_soc_unregister_codec(struct device *dev)
Mark Brown0d0cf002008-12-10 14:32:45 +00003816{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003817 struct snd_soc_codec *codec;
3818 int i;
3819
3820 list_for_each_entry(codec, &codec_list, list) {
3821 if (dev == codec->dev)
3822 goto found;
3823 }
3824 return;
3825
3826found:
Mark Brown26b01cc2010-08-18 20:20:55 +01003827 if (codec->num_dai)
3828 for (i = 0; i < codec->num_dai; i++)
3829 snd_soc_unregister_dai(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003830
Mark Brown0d0cf002008-12-10 14:32:45 +00003831 mutex_lock(&client_mutex);
3832 list_del(&codec->list);
3833 mutex_unlock(&client_mutex);
3834
3835 pr_debug("Unregistered codec '%s'\n", codec->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003836
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003837 snd_soc_cache_exit(codec);
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003838 kfree(codec->reg_def_copy);
Dimitris Papastamos1aafcd42010-10-21 13:19:45 +01003839 kfree(codec->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003840 kfree(codec);
Mark Brown0d0cf002008-12-10 14:32:45 +00003841}
3842EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
3843
Takashi Iwaic9b3a402008-12-10 07:47:22 +01003844static int __init snd_soc_init(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003845{
Mark Brown384c89e2008-12-03 17:34:03 +00003846#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +00003847 snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
3848 if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
Mark Brown384c89e2008-12-03 17:34:03 +00003849 printk(KERN_WARNING
3850 "ASoC: Failed to create debugfs directory\n");
Mark Brown8a9dab12011-01-10 22:25:21 +00003851 snd_soc_debugfs_root = NULL;
Mark Brown384c89e2008-12-03 17:34:03 +00003852 }
Mark Brownc3c5a192010-09-15 18:15:14 +01003853
Mark Brown8a9dab12011-01-10 22:25:21 +00003854 if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
Mark Brownc3c5a192010-09-15 18:15:14 +01003855 &codec_list_fops))
3856 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
3857
Mark Brown8a9dab12011-01-10 22:25:21 +00003858 if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
Mark Brownf3208782010-09-15 18:19:07 +01003859 &dai_list_fops))
3860 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
Mark Brown19c7ac22010-09-15 18:22:40 +01003861
Mark Brown8a9dab12011-01-10 22:25:21 +00003862 if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
Mark Brown19c7ac22010-09-15 18:22:40 +01003863 &platform_list_fops))
3864 pr_warn("ASoC: Failed to create platform list debugfs file\n");
Mark Brown384c89e2008-12-03 17:34:03 +00003865#endif
3866
Mark Brownfb257892011-04-28 10:57:54 +01003867 snd_soc_util_init();
3868
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003869 return platform_driver_register(&soc_driver);
3870}
Mark Brown4abe8e12010-10-12 17:41:03 +01003871module_init(snd_soc_init);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003872
Mark Brown7d8c16a2008-11-30 22:11:24 +00003873static void __exit snd_soc_exit(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003874{
Mark Brownfb257892011-04-28 10:57:54 +01003875 snd_soc_util_exit();
3876
Mark Brown384c89e2008-12-03 17:34:03 +00003877#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +00003878 debugfs_remove_recursive(snd_soc_debugfs_root);
Mark Brown384c89e2008-12-03 17:34:03 +00003879#endif
Mark Brown3ff3f642008-05-19 12:32:25 +02003880 platform_driver_unregister(&soc_driver);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003881}
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003882module_exit(snd_soc_exit);
3883
3884/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01003885MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003886MODULE_DESCRIPTION("ALSA SoC Core");
3887MODULE_LICENSE("GPL");
Kay Sievers8b45a202008-04-14 13:33:36 +02003888MODULE_ALIAS("platform:soc-audio");