blob: a58c1fc966eb69d44762c83e0f5a6936082bf071 [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>
Mark Brownf0e8ed82011-09-20 11:41:54 +010033#include <linux/ctype.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090034#include <linux/slab.h>
Marek Vasut474828a2009-07-22 13:01:03 +020035#include <sound/ac97_codec.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020036#include <sound/core.h>
Mark Brown3028eb82010-12-05 12:22:46 +000037#include <sound/jack.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020038#include <sound/pcm.h>
39#include <sound/pcm_params.h>
40#include <sound/soc.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020041#include <sound/initval.h>
42
Mark Browna8b1d342010-11-03 18:05:58 -040043#define CREATE_TRACE_POINTS
44#include <trace/events/asoc.h>
45
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +000046#define NAME_SIZE 32
47
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 Girdwoodddee6272011-06-09 14:45:53 +010061int 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
Mark Brown25032c12011-08-01 13:52:48 +0900109 ret = snd_soc_read(codec, reg);
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000110 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) {
Lars-Peter Clausenb92d1502011-08-27 18:24:14 +0200147 if (!snd_soc_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;
Mark Brown2624d5f2009-11-03 21:56:13 +0000248 struct snd_soc_codec *codec = file->private_data;
249
250 buf_size = min(count, (sizeof(buf)-1));
251 if (copy_from_user(buf, user_buf, buf_size))
252 return -EFAULT;
253 buf[buf_size] = 0;
254
Mark Brown2624d5f2009-11-03 21:56:13 +0000255 while (*start == ' ')
256 start++;
257 reg = simple_strtoul(start, &start, 16);
Mark Brown2624d5f2009-11-03 21:56:13 +0000258 while (*start == ' ')
259 start++;
260 if (strict_strtoul(start, 16, &value))
261 return -EINVAL;
Mark Brown0d51a9c2011-01-06 16:04:57 +0000262
263 /* Userspace has been fiddling around behind the kernel's back */
264 add_taint(TAINT_USER);
265
Dimitris Papastamose4f078d2010-12-07 16:30:38 +0000266 snd_soc_write(codec, reg, value);
Mark Brown2624d5f2009-11-03 21:56:13 +0000267 return buf_size;
268}
269
270static const struct file_operations codec_reg_fops = {
271 .open = codec_reg_open_file,
272 .read = codec_reg_read_file,
273 .write = codec_reg_write_file,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200274 .llseek = default_llseek,
Mark Brown2624d5f2009-11-03 21:56:13 +0000275};
276
277static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
278{
Jarkko Nikulad6ce4cf2010-11-05 20:35:20 +0200279 struct dentry *debugfs_card_root = codec->card->debugfs_card_root;
280
281 codec->debugfs_codec_root = debugfs_create_dir(codec->name,
282 debugfs_card_root);
Mark Brown2624d5f2009-11-03 21:56:13 +0000283 if (!codec->debugfs_codec_root) {
284 printk(KERN_WARNING
285 "ASoC: Failed to create codec debugfs directory\n");
286 return;
287 }
288
Mark Brownaaee8ef2011-01-26 20:53:50 +0000289 debugfs_create_bool("cache_sync", 0444, codec->debugfs_codec_root,
290 &codec->cache_sync);
291 debugfs_create_bool("cache_only", 0444, codec->debugfs_codec_root,
292 &codec->cache_only);
293
Mark Brown2624d5f2009-11-03 21:56:13 +0000294 codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
295 codec->debugfs_codec_root,
296 codec, &codec_reg_fops);
297 if (!codec->debugfs_reg)
298 printk(KERN_WARNING
299 "ASoC: Failed to create codec register debugfs file\n");
300
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +0200301 snd_soc_dapm_debugfs_init(&codec->dapm, codec->debugfs_codec_root);
Mark Brown2624d5f2009-11-03 21:56:13 +0000302}
303
304static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
305{
306 debugfs_remove_recursive(codec->debugfs_codec_root);
307}
308
Mark Brownc3c5a192010-09-15 18:15:14 +0100309static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
310 size_t count, loff_t *ppos)
311{
312 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100313 ssize_t len, ret = 0;
Mark Brownc3c5a192010-09-15 18:15:14 +0100314 struct snd_soc_codec *codec;
315
316 if (!buf)
317 return -ENOMEM;
318
Mark Brown2b194f9d2010-10-13 10:52:16 +0100319 list_for_each_entry(codec, &codec_list, list) {
320 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
321 codec->name);
322 if (len >= 0)
323 ret += len;
324 if (ret > PAGE_SIZE) {
325 ret = PAGE_SIZE;
326 break;
327 }
328 }
Mark Brownc3c5a192010-09-15 18:15:14 +0100329
330 if (ret >= 0)
331 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
332
333 kfree(buf);
334
335 return ret;
336}
337
338static const struct file_operations codec_list_fops = {
339 .read = codec_list_read_file,
340 .llseek = default_llseek,/* read accesses f_pos */
341};
342
Mark Brownf3208782010-09-15 18:19:07 +0100343static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
344 size_t count, loff_t *ppos)
345{
346 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100347 ssize_t len, ret = 0;
Mark Brownf3208782010-09-15 18:19:07 +0100348 struct snd_soc_dai *dai;
349
350 if (!buf)
351 return -ENOMEM;
352
Mark Brown2b194f9d2010-10-13 10:52:16 +0100353 list_for_each_entry(dai, &dai_list, list) {
354 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", dai->name);
355 if (len >= 0)
356 ret += len;
357 if (ret > PAGE_SIZE) {
358 ret = PAGE_SIZE;
359 break;
360 }
361 }
Mark Brownf3208782010-09-15 18:19:07 +0100362
Mark Brown2b194f9d2010-10-13 10:52:16 +0100363 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
Mark Brownf3208782010-09-15 18:19:07 +0100364
365 kfree(buf);
366
367 return ret;
368}
369
370static const struct file_operations dai_list_fops = {
371 .read = dai_list_read_file,
372 .llseek = default_llseek,/* read accesses f_pos */
373};
374
Mark Brown19c7ac22010-09-15 18:22:40 +0100375static ssize_t platform_list_read_file(struct file *file,
376 char __user *user_buf,
377 size_t count, loff_t *ppos)
378{
379 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100380 ssize_t len, ret = 0;
Mark Brown19c7ac22010-09-15 18:22:40 +0100381 struct snd_soc_platform *platform;
382
383 if (!buf)
384 return -ENOMEM;
385
Mark Brown2b194f9d2010-10-13 10:52:16 +0100386 list_for_each_entry(platform, &platform_list, list) {
387 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
388 platform->name);
389 if (len >= 0)
390 ret += len;
391 if (ret > PAGE_SIZE) {
392 ret = PAGE_SIZE;
393 break;
394 }
395 }
Mark Brown19c7ac22010-09-15 18:22:40 +0100396
Mark Brown2b194f9d2010-10-13 10:52:16 +0100397 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
Mark Brown19c7ac22010-09-15 18:22:40 +0100398
399 kfree(buf);
400
401 return ret;
402}
403
404static const struct file_operations platform_list_fops = {
405 .read = platform_list_read_file,
406 .llseek = default_llseek,/* read accesses f_pos */
407};
408
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200409static void soc_init_card_debugfs(struct snd_soc_card *card)
410{
411 card->debugfs_card_root = debugfs_create_dir(card->name,
Mark Brown8a9dab12011-01-10 22:25:21 +0000412 snd_soc_debugfs_root);
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200413 if (!card->debugfs_card_root) {
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200414 dev_warn(card->dev,
415 "ASoC: Failed to create codec debugfs directory\n");
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200416 return;
417 }
418
419 card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
420 card->debugfs_card_root,
421 &card->pop_time);
422 if (!card->debugfs_pop_time)
423 dev_warn(card->dev,
424 "Failed to create pop time debugfs file\n");
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200425}
426
427static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
428{
429 debugfs_remove_recursive(card->debugfs_card_root);
430}
431
Mark Brown2624d5f2009-11-03 21:56:13 +0000432#else
433
434static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
435{
436}
437
438static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
439{
440}
Axel Linb95fccb2010-11-09 17:06:44 +0800441
442static inline void soc_init_card_debugfs(struct snd_soc_card *card)
443{
444}
445
446static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
447{
448}
Mark Brown2624d5f2009-11-03 21:56:13 +0000449#endif
450
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200451#ifdef CONFIG_SND_SOC_AC97_BUS
452/* unregister ac97 codec */
453static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
454{
455 if (codec->ac97->dev.bus)
456 device_unregister(&codec->ac97->dev);
457 return 0;
458}
459
460/* stop no dev release warning */
461static void soc_ac97_device_release(struct device *dev){}
462
463/* register ac97 codec to bus */
464static int soc_ac97_dev_register(struct snd_soc_codec *codec)
465{
466 int err;
467
468 codec->ac97->dev.bus = &ac97_bus_type;
Mark Brown4ac5c612009-04-01 19:35:01 +0100469 codec->ac97->dev.parent = codec->card->dev;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200470 codec->ac97->dev.release = soc_ac97_device_release;
471
Kay Sieversbb072bf2008-11-02 03:50:35 +0100472 dev_set_name(&codec->ac97->dev, "%d-%d:%s",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000473 codec->card->snd_card->number, 0, codec->name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200474 err = device_register(&codec->ac97->dev);
475 if (err < 0) {
476 snd_printk(KERN_ERR "Can't register ac97 bus\n");
477 codec->ac97->dev.bus = NULL;
478 return err;
479 }
480 return 0;
481}
482#endif
483
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000484#ifdef CONFIG_PM_SLEEP
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200485/* powers down audio subsystem for suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000486int snd_soc_suspend(struct device *dev)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200487{
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000488 struct snd_soc_card *card = dev_get_drvdata(dev);
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200489 struct snd_soc_codec *codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200490 int i;
491
Daniel Macke3509ff2009-06-03 17:44:49 +0200492 /* If the initialization of this soc device failed, there is no codec
493 * associated with it. Just bail out in this case.
494 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000495 if (list_empty(&card->codec_dev_list))
Daniel Macke3509ff2009-06-03 17:44:49 +0200496 return 0;
497
Andy Green6ed25972008-06-13 16:24:05 +0100498 /* Due to the resume being scheduled into a workqueue we could
499 * suspend before that's finished - wait for it to complete.
500 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000501 snd_power_lock(card->snd_card);
502 snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
503 snd_power_unlock(card->snd_card);
Andy Green6ed25972008-06-13 16:24:05 +0100504
505 /* we're going to block userspace touching us until resume completes */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000506 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
Andy Green6ed25972008-06-13 16:24:05 +0100507
Mark Browna00f90f2010-12-02 16:24:24 +0000508 /* mute any active DACs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000509 for (i = 0; i < card->num_rtd; i++) {
510 struct snd_soc_dai *dai = card->rtd[i].codec_dai;
511 struct snd_soc_dai_driver *drv = dai->driver;
Mark Brown3efab7d2010-05-09 13:25:43 +0100512
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000513 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100514 continue;
515
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000516 if (drv->ops->digital_mute && dai->playback_active)
517 drv->ops->digital_mute(dai, 1);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200518 }
519
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100520 /* suspend all pcms */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000521 for (i = 0; i < card->num_rtd; i++) {
522 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100523 continue;
524
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000525 snd_pcm_suspend_all(card->rtd[i].pcm);
Mark Brown3efab7d2010-05-09 13:25:43 +0100526 }
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100527
Mark Brown87506542008-11-18 20:50:34 +0000528 if (card->suspend_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +0000529 card->suspend_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200530
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000531 for (i = 0; i < card->num_rtd; i++) {
532 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
533 struct snd_soc_platform *platform = card->rtd[i].platform;
Mark Brown3efab7d2010-05-09 13:25:43 +0100534
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000535 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100536 continue;
537
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000538 if (cpu_dai->driver->suspend && !cpu_dai->driver->ac97_control)
539 cpu_dai->driver->suspend(cpu_dai);
540 if (platform->driver->suspend && !platform->suspended) {
541 platform->driver->suspend(cpu_dai);
542 platform->suspended = 1;
Mark Brown1547aba2010-05-07 21:11:40 +0100543 }
544 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200545
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000546 /* close any waiting streams and save state */
547 for (i = 0; i < card->num_rtd; i++) {
Tejun Heo5b84ba22010-12-11 17:51:26 +0100548 flush_delayed_work_sync(&card->rtd[i].delayed_work);
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200549 card->rtd[i].codec->dapm.suspend_bias_level = card->rtd[i].codec->dapm.bias_level;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000550 }
Mark Brown3efab7d2010-05-09 13:25:43 +0100551
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000552 for (i = 0; i < card->num_rtd; i++) {
553 struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;
554
555 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100556 continue;
557
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000558 if (driver->playback.stream_name != NULL)
559 snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,
560 SND_SOC_DAPM_STREAM_SUSPEND);
561
562 if (driver->capture.stream_name != NULL)
563 snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,
564 SND_SOC_DAPM_STREAM_SUSPEND);
565 }
566
567 /* suspend all CODECs */
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200568 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000569 /* If there are paths active then the CODEC will be held with
570 * bias _ON and should not be suspended. */
571 if (!codec->suspended && codec->driver->suspend) {
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200572 switch (codec->dapm.bias_level) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000573 case SND_SOC_BIAS_STANDBY:
574 case SND_SOC_BIAS_OFF:
575 codec->driver->suspend(codec, PMSG_SUSPEND);
576 codec->suspended = 1;
Mark Brown7be4ba22011-07-18 13:17:13 +0900577 codec->cache_sync = 1;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000578 break;
579 default:
580 dev_dbg(codec->dev, "CODEC is on over suspend\n");
581 break;
582 }
583 }
584 }
585
586 for (i = 0; i < card->num_rtd; i++) {
587 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
588
589 if (card->rtd[i].dai_link->ignore_suspend)
590 continue;
591
592 if (cpu_dai->driver->suspend && cpu_dai->driver->ac97_control)
593 cpu_dai->driver->suspend(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200594 }
595
Mark Brown87506542008-11-18 20:50:34 +0000596 if (card->suspend_post)
Mark Brown70b2ac12011-01-26 14:05:25 +0000597 card->suspend_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200598
599 return 0;
600}
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000601EXPORT_SYMBOL_GPL(snd_soc_suspend);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200602
Andy Green6ed25972008-06-13 16:24:05 +0100603/* deferred resume work, so resume can complete before we finished
604 * setting our codec back up, which can be very slow on I2C
605 */
606static void soc_resume_deferred(struct work_struct *work)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200607{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000608 struct snd_soc_card *card =
609 container_of(work, struct snd_soc_card, deferred_resume_work);
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200610 struct snd_soc_codec *codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200611 int i;
612
Andy Green6ed25972008-06-13 16:24:05 +0100613 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
614 * so userspace apps are blocked from touching us
615 */
616
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000617 dev_dbg(card->dev, "starting resume work\n");
Andy Green6ed25972008-06-13 16:24:05 +0100618
Mark Brown99497882010-05-07 20:24:05 +0100619 /* Bring us up into D2 so that DAPM starts enabling things */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000620 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
Mark Brown99497882010-05-07 20:24:05 +0100621
Mark Brown87506542008-11-18 20:50:34 +0000622 if (card->resume_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +0000623 card->resume_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200624
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000625 /* resume AC97 DAIs */
626 for (i = 0; i < card->num_rtd; i++) {
627 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100628
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000629 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100630 continue;
631
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000632 if (cpu_dai->driver->resume && cpu_dai->driver->ac97_control)
633 cpu_dai->driver->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200634 }
635
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200636 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000637 /* If the CODEC was idle over suspend then it will have been
638 * left with bias OFF or STANDBY and suspended so we must now
639 * resume. Otherwise the suspend was suppressed.
640 */
641 if (codec->driver->resume && codec->suspended) {
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200642 switch (codec->dapm.bias_level) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000643 case SND_SOC_BIAS_STANDBY:
644 case SND_SOC_BIAS_OFF:
645 codec->driver->resume(codec);
646 codec->suspended = 0;
647 break;
648 default:
649 dev_dbg(codec->dev, "CODEC was on over suspend\n");
650 break;
651 }
Mark Brown1547aba2010-05-07 21:11:40 +0100652 }
653 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200654
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000655 for (i = 0; i < card->num_rtd; i++) {
656 struct snd_soc_dai_driver *driver = card->rtd[i].codec_dai->driver;
Mark Brown3efab7d2010-05-09 13:25:43 +0100657
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000658 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100659 continue;
660
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000661 if (driver->playback.stream_name != NULL)
662 snd_soc_dapm_stream_event(&card->rtd[i], driver->playback.stream_name,
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200663 SND_SOC_DAPM_STREAM_RESUME);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000664
665 if (driver->capture.stream_name != NULL)
666 snd_soc_dapm_stream_event(&card->rtd[i], driver->capture.stream_name,
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200667 SND_SOC_DAPM_STREAM_RESUME);
668 }
669
Mark Brown3ff3f642008-05-19 12:32:25 +0200670 /* unmute any active DACs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000671 for (i = 0; i < card->num_rtd; i++) {
672 struct snd_soc_dai *dai = card->rtd[i].codec_dai;
673 struct snd_soc_dai_driver *drv = dai->driver;
Mark Brown3efab7d2010-05-09 13:25:43 +0100674
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000675 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100676 continue;
677
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000678 if (drv->ops->digital_mute && dai->playback_active)
679 drv->ops->digital_mute(dai, 0);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200680 }
681
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000682 for (i = 0; i < card->num_rtd; i++) {
683 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
684 struct snd_soc_platform *platform = card->rtd[i].platform;
Mark Brown3efab7d2010-05-09 13:25:43 +0100685
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000686 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100687 continue;
688
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000689 if (cpu_dai->driver->resume && !cpu_dai->driver->ac97_control)
690 cpu_dai->driver->resume(cpu_dai);
691 if (platform->driver->resume && platform->suspended) {
692 platform->driver->resume(cpu_dai);
693 platform->suspended = 0;
694 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200695 }
696
Mark Brown87506542008-11-18 20:50:34 +0000697 if (card->resume_post)
Mark Brown70b2ac12011-01-26 14:05:25 +0000698 card->resume_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200699
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000700 dev_dbg(card->dev, "resume work completed\n");
Andy Green6ed25972008-06-13 16:24:05 +0100701
702 /* userspace can access us now we are back as we were before */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000703 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
Andy Green6ed25972008-06-13 16:24:05 +0100704}
705
706/* powers up audio subsystem after a suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000707int snd_soc_resume(struct device *dev)
Andy Green6ed25972008-06-13 16:24:05 +0100708{
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000709 struct snd_soc_card *card = dev_get_drvdata(dev);
Stephen Warren82e14e82011-05-25 14:06:41 -0600710 int i, ac97_control = 0;
Peter Ujfalusib9dd94a2010-02-22 13:27:13 +0200711
Mark Brown64ab9ba2009-03-31 11:27:03 +0100712 /* AC97 devices might have other drivers hanging off them so
713 * need to resume immediately. Other drivers don't have that
714 * problem and may take a substantial amount of time to resume
715 * due to I/O costs and anti-pop so handle them out of line.
716 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000717 for (i = 0; i < card->num_rtd; i++) {
718 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Stephen Warren82e14e82011-05-25 14:06:41 -0600719 ac97_control |= cpu_dai->driver->ac97_control;
720 }
721 if (ac97_control) {
722 dev_dbg(dev, "Resuming AC97 immediately\n");
723 soc_resume_deferred(&card->deferred_resume_work);
724 } else {
725 dev_dbg(dev, "Scheduling resume work\n");
726 if (!schedule_work(&card->deferred_resume_work))
727 dev_err(dev, "resume work item may be lost\n");
Mark Brown64ab9ba2009-03-31 11:27:03 +0100728 }
Andy Green6ed25972008-06-13 16:24:05 +0100729
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200730 return 0;
731}
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000732EXPORT_SYMBOL_GPL(snd_soc_resume);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200733#else
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000734#define snd_soc_suspend NULL
735#define snd_soc_resume NULL
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200736#endif
737
Barry Song02a06d32009-10-16 18:13:38 +0800738static struct snd_soc_dai_ops null_dai_ops = {
739};
740
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000741static int soc_bind_dai_link(struct snd_soc_card *card, int num)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200742{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000743 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
744 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
Mark Brownfe3e78e2009-11-03 22:13:13 +0000745 struct snd_soc_codec *codec;
Mark Brown435c5e22008-12-04 15:32:53 +0000746 struct snd_soc_platform *platform;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000747 struct snd_soc_dai *codec_dai, *cpu_dai;
Mark Brown848dd8b2011-04-27 18:16:32 +0100748 const char *platform_name;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200749
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000750 if (rtd->complete)
751 return 1;
752 dev_dbg(card->dev, "binding %s at idx %d\n", dai_link->name, num);
Mark Brown63084192008-12-02 15:08:03 +0000753
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000754 /* do we already have the CPU DAI for this link ? */
755 if (rtd->cpu_dai) {
756 goto find_codec;
757 }
758 /* no, then find CPU DAI from registered DAIs*/
759 list_for_each_entry(cpu_dai, &dai_list, list) {
760 if (!strcmp(cpu_dai->name, dai_link->cpu_dai_name)) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000761 rtd->cpu_dai = cpu_dai;
762 goto find_codec;
Mark Brown435c5e22008-12-04 15:32:53 +0000763 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000764 }
765 dev_dbg(card->dev, "CPU DAI %s not registered\n",
766 dai_link->cpu_dai_name);
767
768find_codec:
769 /* do we already have the CODEC for this link ? */
770 if (rtd->codec) {
771 goto find_platform;
Mark Brownc5af3a22008-11-28 13:29:45 +0000772 }
773
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000774 /* no, then find CODEC from registered CODECs*/
775 list_for_each_entry(codec, &codec_list, list) {
776 if (!strcmp(codec->name, dai_link->codec_name)) {
777 rtd->codec = codec;
Mark Brown6b05eda2008-12-08 19:26:48 +0000778
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000779 /* CODEC found, so find CODEC DAI from registered DAIs from this CODEC*/
780 list_for_each_entry(codec_dai, &dai_list, list) {
781 if (codec->dev == codec_dai->dev &&
782 !strcmp(codec_dai->name, dai_link->codec_dai_name)) {
783 rtd->codec_dai = codec_dai;
784 goto find_platform;
Mark Brown6b05eda2008-12-08 19:26:48 +0000785 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000786 }
787 dev_dbg(card->dev, "CODEC DAI %s not registered\n",
788 dai_link->codec_dai_name);
789
790 goto find_platform;
791 }
792 }
793 dev_dbg(card->dev, "CODEC %s not registered\n",
794 dai_link->codec_name);
795
796find_platform:
Mark Brown848dd8b2011-04-27 18:16:32 +0100797 /* do we need a platform? */
798 if (rtd->platform)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000799 goto out;
Mark Brown848dd8b2011-04-27 18:16:32 +0100800
801 /* if there's no platform we match on the empty platform */
802 platform_name = dai_link->platform_name;
803 if (!platform_name)
804 platform_name = "snd-soc-dummy";
805
806 /* no, then find one from the set of registered platforms */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000807 list_for_each_entry(platform, &platform_list, list) {
Mark Brown848dd8b2011-04-27 18:16:32 +0100808 if (!strcmp(platform->name, platform_name)) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000809 rtd->platform = platform;
810 goto out;
811 }
812 }
813
814 dev_dbg(card->dev, "platform %s not registered\n",
815 dai_link->platform_name);
816 return 0;
817
818out:
819 /* mark rtd as complete if we found all 4 of our client devices */
820 if (rtd->codec && rtd->codec_dai && rtd->platform && rtd->cpu_dai) {
821 rtd->complete = 1;
822 card->num_rtd++;
823 }
824 return 1;
825}
826
Jarkko Nikula589c3562010-12-06 16:27:07 +0200827static void soc_remove_codec(struct snd_soc_codec *codec)
828{
829 int err;
830
831 if (codec->driver->remove) {
832 err = codec->driver->remove(codec);
833 if (err < 0)
834 dev_err(codec->dev,
835 "asoc: failed to remove %s: %d\n",
836 codec->name, err);
837 }
838
839 /* Make sure all DAPM widgets are freed */
840 snd_soc_dapm_free(&codec->dapm);
841
842 soc_cleanup_codec_debugfs(codec);
843 codec->probed = 0;
844 list_del(&codec->card_list);
845 module_put(codec->dev->driver->owner);
846}
847
Liam Girdwood0168bf02011-06-07 16:08:05 +0100848static void soc_remove_dai_link(struct snd_soc_card *card, int num, int order)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000849{
850 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
851 struct snd_soc_codec *codec = rtd->codec;
852 struct snd_soc_platform *platform = rtd->platform;
853 struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
854 int err;
855
856 /* unregister the rtd device */
857 if (rtd->dev_registered) {
858 device_remove_file(&rtd->dev, &dev_attr_pmdown_time);
Jarkko Nikula589c3562010-12-06 16:27:07 +0200859 device_remove_file(&rtd->dev, &dev_attr_codec_reg);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000860 device_unregister(&rtd->dev);
861 rtd->dev_registered = 0;
862 }
863
864 /* remove the CODEC DAI */
Liam Girdwood0168bf02011-06-07 16:08:05 +0100865 if (codec_dai && codec_dai->probed &&
866 codec_dai->driver->remove_order == order) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000867 if (codec_dai->driver->remove) {
868 err = codec_dai->driver->remove(codec_dai);
869 if (err < 0)
870 printk(KERN_ERR "asoc: failed to remove %s\n", codec_dai->name);
871 }
872 codec_dai->probed = 0;
873 list_del(&codec_dai->card_list);
874 }
875
876 /* remove the platform */
Liam Girdwood0168bf02011-06-07 16:08:05 +0100877 if (platform && platform->probed &&
878 platform->driver->remove_order == order) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000879 if (platform->driver->remove) {
880 err = platform->driver->remove(platform);
881 if (err < 0)
882 printk(KERN_ERR "asoc: failed to remove %s\n", platform->name);
883 }
884 platform->probed = 0;
885 list_del(&platform->card_list);
886 module_put(platform->dev->driver->owner);
887 }
888
889 /* remove the CODEC */
Liam Girdwood0168bf02011-06-07 16:08:05 +0100890 if (codec && codec->probed &&
891 codec->driver->remove_order == order)
Jarkko Nikula589c3562010-12-06 16:27:07 +0200892 soc_remove_codec(codec);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000893
894 /* remove the cpu_dai */
Liam Girdwood0168bf02011-06-07 16:08:05 +0100895 if (cpu_dai && cpu_dai->probed &&
896 cpu_dai->driver->remove_order == order) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000897 if (cpu_dai->driver->remove) {
898 err = cpu_dai->driver->remove(cpu_dai);
899 if (err < 0)
900 printk(KERN_ERR "asoc: failed to remove %s\n", cpu_dai->name);
901 }
902 cpu_dai->probed = 0;
903 list_del(&cpu_dai->card_list);
904 module_put(cpu_dai->dev->driver->owner);
905 }
906}
907
Kuninori Morimoto0671fd82011-04-08 14:50:44 +0900908static void soc_remove_dai_links(struct snd_soc_card *card)
909{
Liam Girdwood0168bf02011-06-07 16:08:05 +0100910 int dai, order;
Kuninori Morimoto0671fd82011-04-08 14:50:44 +0900911
Liam Girdwood0168bf02011-06-07 16:08:05 +0100912 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
913 order++) {
914 for (dai = 0; dai < card->num_rtd; dai++)
915 soc_remove_dai_link(card, dai, order);
916 }
Kuninori Morimoto0671fd82011-04-08 14:50:44 +0900917 card->num_rtd = 0;
918}
919
Jarkko Nikulaead9b912010-11-13 20:40:44 +0200920static void soc_set_name_prefix(struct snd_soc_card *card,
921 struct snd_soc_codec *codec)
922{
923 int i;
924
Dimitris Papastamosff819b82010-12-02 14:53:03 +0000925 if (card->codec_conf == NULL)
Jarkko Nikulaead9b912010-11-13 20:40:44 +0200926 return;
927
Dimitris Papastamosff819b82010-12-02 14:53:03 +0000928 for (i = 0; i < card->num_configs; i++) {
929 struct snd_soc_codec_conf *map = &card->codec_conf[i];
Jarkko Nikulaead9b912010-11-13 20:40:44 +0200930 if (map->dev_name && !strcmp(codec->name, map->dev_name)) {
931 codec->name_prefix = map->name_prefix;
932 break;
933 }
934 }
935}
936
Jarkko Nikula589c3562010-12-06 16:27:07 +0200937static int soc_probe_codec(struct snd_soc_card *card,
938 struct snd_soc_codec *codec)
939{
940 int ret = 0;
Mark Brown89b95ac02011-03-07 16:38:44 +0000941 const struct snd_soc_codec_driver *driver = codec->driver;
Jarkko Nikula589c3562010-12-06 16:27:07 +0200942
943 codec->card = card;
944 codec->dapm.card = card;
945 soc_set_name_prefix(card, codec);
946
Jarkko Nikula70d29332011-01-27 16:24:22 +0200947 if (!try_module_get(codec->dev->driver->owner))
948 return -ENODEV;
949
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +0200950 soc_init_codec_debugfs(codec);
951
Lars-Peter Clausen77530152011-05-05 16:59:09 +0200952 if (driver->dapm_widgets)
953 snd_soc_dapm_new_controls(&codec->dapm, driver->dapm_widgets,
954 driver->num_dapm_widgets);
955
Mark Brown33c5f962011-08-22 18:40:30 +0100956 codec->dapm.idle_bias_off = driver->idle_bias_off;
957
Mark Brown89b95ac02011-03-07 16:38:44 +0000958 if (driver->probe) {
959 ret = driver->probe(codec);
Jarkko Nikula589c3562010-12-06 16:27:07 +0200960 if (ret < 0) {
961 dev_err(codec->dev,
962 "asoc: failed to probe CODEC %s: %d\n",
963 codec->name, ret);
Jarkko Nikula70d29332011-01-27 16:24:22 +0200964 goto err_probe;
Jarkko Nikula589c3562010-12-06 16:27:07 +0200965 }
966 }
967
Mark Brownb7af1da2011-04-07 19:18:44 +0900968 if (driver->controls)
969 snd_soc_add_controls(codec, driver->controls,
970 driver->num_controls);
Mark Brown89b95ac02011-03-07 16:38:44 +0000971 if (driver->dapm_routes)
972 snd_soc_dapm_add_routes(&codec->dapm, driver->dapm_routes,
973 driver->num_dapm_routes);
974
Jarkko Nikula589c3562010-12-06 16:27:07 +0200975 /* mark codec as probed and add to card codec list */
976 codec->probed = 1;
977 list_add(&codec->card_list, &card->codec_dev_list);
Jarkko Nikula7be31be82010-12-14 12:18:32 +0200978 list_add(&codec->dapm.list, &card->dapm_list);
Jarkko Nikula589c3562010-12-06 16:27:07 +0200979
Jarkko Nikula70d29332011-01-27 16:24:22 +0200980 return 0;
981
982err_probe:
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +0200983 soc_cleanup_codec_debugfs(codec);
Jarkko Nikula70d29332011-01-27 16:24:22 +0200984 module_put(codec->dev->driver->owner);
985
Jarkko Nikula589c3562010-12-06 16:27:07 +0200986 return ret;
987}
988
Liam Girdwood956245e2011-07-01 16:54:08 +0100989static int soc_probe_platform(struct snd_soc_card *card,
990 struct snd_soc_platform *platform)
991{
992 int ret = 0;
993 const struct snd_soc_platform_driver *driver = platform->driver;
994
995 platform->card = card;
Liam Girdwoodb7950642011-07-04 22:10:52 +0100996 platform->dapm.card = card;
Liam Girdwood956245e2011-07-01 16:54:08 +0100997
998 if (!try_module_get(platform->dev->driver->owner))
999 return -ENODEV;
1000
Liam Girdwoodcb2cf612011-07-04 22:10:53 +01001001 if (driver->dapm_widgets)
1002 snd_soc_dapm_new_controls(&platform->dapm,
1003 driver->dapm_widgets, driver->num_dapm_widgets);
1004
Liam Girdwood956245e2011-07-01 16:54:08 +01001005 if (driver->probe) {
1006 ret = driver->probe(platform);
1007 if (ret < 0) {
1008 dev_err(platform->dev,
1009 "asoc: failed to probe platform %s: %d\n",
1010 platform->name, ret);
1011 goto err_probe;
1012 }
1013 }
1014
Liam Girdwoodcb2cf612011-07-04 22:10:53 +01001015 if (driver->controls)
1016 snd_soc_add_platform_controls(platform, driver->controls,
1017 driver->num_controls);
1018 if (driver->dapm_routes)
1019 snd_soc_dapm_add_routes(&platform->dapm, driver->dapm_routes,
1020 driver->num_dapm_routes);
1021
Liam Girdwood956245e2011-07-01 16:54:08 +01001022 /* mark platform as probed and add to card platform list */
1023 platform->probed = 1;
1024 list_add(&platform->card_list, &card->platform_dev_list);
Liam Girdwoodb7950642011-07-04 22:10:52 +01001025 list_add(&platform->dapm.list, &card->dapm_list);
Liam Girdwood956245e2011-07-01 16:54:08 +01001026
1027 return 0;
1028
1029err_probe:
1030 module_put(platform->dev->driver->owner);
1031
1032 return ret;
1033}
1034
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001035static void rtd_release(struct device *dev) {}
1036
Jarkko Nikula589c3562010-12-06 16:27:07 +02001037static int soc_post_component_init(struct snd_soc_card *card,
1038 struct snd_soc_codec *codec,
1039 int num, int dailess)
1040{
1041 struct snd_soc_dai_link *dai_link = NULL;
1042 struct snd_soc_aux_dev *aux_dev = NULL;
1043 struct snd_soc_pcm_runtime *rtd;
1044 const char *temp, *name;
1045 int ret = 0;
1046
1047 if (!dailess) {
1048 dai_link = &card->dai_link[num];
1049 rtd = &card->rtd[num];
1050 name = dai_link->name;
1051 } else {
1052 aux_dev = &card->aux_dev[num];
1053 rtd = &card->rtd_aux[num];
1054 name = aux_dev->name;
1055 }
Janusz Krzysztofik0962bb22011-02-02 21:11:41 +01001056 rtd->card = card;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001057
1058 /* machine controls, routes and widgets are not prefixed */
1059 temp = codec->name_prefix;
1060 codec->name_prefix = NULL;
1061
1062 /* do machine specific initialization */
1063 if (!dailess && dai_link->init)
1064 ret = dai_link->init(rtd);
1065 else if (dailess && aux_dev->init)
1066 ret = aux_dev->init(&codec->dapm);
1067 if (ret < 0) {
1068 dev_err(card->dev, "asoc: failed to init %s: %d\n", name, ret);
1069 return ret;
1070 }
1071 codec->name_prefix = temp;
1072
1073 /* Make sure all DAPM widgets are instantiated */
1074 snd_soc_dapm_new_widgets(&codec->dapm);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001075
1076 /* register the rtd device */
1077 rtd->codec = codec;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001078 rtd->dev.parent = card->dev;
1079 rtd->dev.release = rtd_release;
1080 rtd->dev.init_name = name;
Liam Girdwoodb8c0dab2011-06-09 17:04:39 +01001081 mutex_init(&rtd->pcm_mutex);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001082 ret = device_register(&rtd->dev);
1083 if (ret < 0) {
1084 dev_err(card->dev,
1085 "asoc: failed to register runtime device: %d\n", ret);
1086 return ret;
1087 }
1088 rtd->dev_registered = 1;
1089
1090 /* add DAPM sysfs entries for this codec */
1091 ret = snd_soc_dapm_sys_add(&rtd->dev);
1092 if (ret < 0)
1093 dev_err(codec->dev,
1094 "asoc: failed to add codec dapm sysfs entries: %d\n",
1095 ret);
1096
1097 /* add codec sysfs entries */
1098 ret = device_create_file(&rtd->dev, &dev_attr_codec_reg);
1099 if (ret < 0)
1100 dev_err(codec->dev,
1101 "asoc: failed to add codec sysfs files: %d\n", ret);
1102
1103 return 0;
1104}
1105
Liam Girdwood0168bf02011-06-07 16:08:05 +01001106static int soc_probe_dai_link(struct snd_soc_card *card, int num, int order)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001107{
1108 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
1109 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1110 struct snd_soc_codec *codec = rtd->codec;
1111 struct snd_soc_platform *platform = rtd->platform;
1112 struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
1113 int ret;
1114
Liam Girdwood0168bf02011-06-07 16:08:05 +01001115 dev_dbg(card->dev, "probe %s dai link %d late %d\n",
1116 card->name, num, order);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001117
1118 /* config components */
1119 codec_dai->codec = codec;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001120 cpu_dai->platform = platform;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001121 codec_dai->card = card;
1122 cpu_dai->card = card;
1123
1124 /* set default power off timeout */
1125 rtd->pmdown_time = pmdown_time;
1126
1127 /* probe the cpu_dai */
Liam Girdwood0168bf02011-06-07 16:08:05 +01001128 if (!cpu_dai->probed &&
1129 cpu_dai->driver->probe_order == order) {
Liam Girdwood61b61e32011-05-24 13:57:43 +01001130 if (!try_module_get(cpu_dai->dev->driver->owner))
1131 return -ENODEV;
1132
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001133 if (cpu_dai->driver->probe) {
1134 ret = cpu_dai->driver->probe(cpu_dai);
1135 if (ret < 0) {
1136 printk(KERN_ERR "asoc: failed to probe CPU DAI %s\n",
1137 cpu_dai->name);
Liam Girdwood61b61e32011-05-24 13:57:43 +01001138 module_put(cpu_dai->dev->driver->owner);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001139 return ret;
1140 }
1141 }
1142 cpu_dai->probed = 1;
Wolfram Sang1c8371d2011-07-17 18:00:26 +02001143 /* mark cpu_dai as probed and add to card dai list */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001144 list_add(&cpu_dai->card_list, &card->dai_dev_list);
1145 }
1146
1147 /* probe the CODEC */
Liam Girdwood0168bf02011-06-07 16:08:05 +01001148 if (!codec->probed &&
1149 codec->driver->probe_order == order) {
Jarkko Nikula589c3562010-12-06 16:27:07 +02001150 ret = soc_probe_codec(card, codec);
1151 if (ret < 0)
1152 return ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001153 }
1154
1155 /* probe the platform */
Liam Girdwood0168bf02011-06-07 16:08:05 +01001156 if (!platform->probed &&
1157 platform->driver->probe_order == order) {
Liam Girdwood956245e2011-07-01 16:54:08 +01001158 ret = soc_probe_platform(card, platform);
1159 if (ret < 0)
1160 return ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001161 }
1162
1163 /* probe the CODEC DAI */
Liam Girdwood0168bf02011-06-07 16:08:05 +01001164 if (!codec_dai->probed && codec_dai->driver->probe_order == order) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001165 if (codec_dai->driver->probe) {
1166 ret = codec_dai->driver->probe(codec_dai);
1167 if (ret < 0) {
1168 printk(KERN_ERR "asoc: failed to probe CODEC DAI %s\n",
1169 codec_dai->name);
1170 return ret;
Mark Brown6b05eda2008-12-08 19:26:48 +00001171 }
1172 }
1173
Wolfram Sang1c8371d2011-07-17 18:00:26 +02001174 /* mark codec_dai as probed and add to card dai list */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001175 codec_dai->probed = 1;
1176 list_add(&codec_dai->card_list, &card->dai_dev_list);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001177 }
1178
Liam Girdwood0168bf02011-06-07 16:08:05 +01001179 /* complete DAI probe during last probe */
1180 if (order != SND_SOC_COMP_ORDER_LAST)
1181 return 0;
1182
Jarkko Nikula589c3562010-12-06 16:27:07 +02001183 ret = soc_post_component_init(card, codec, num, 0);
1184 if (ret)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001185 return ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001186
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001187 ret = device_create_file(&rtd->dev, &dev_attr_pmdown_time);
1188 if (ret < 0)
1189 printk(KERN_WARNING "asoc: failed to add pmdown_time sysfs\n");
1190
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001191 /* create the pcm */
1192 ret = soc_new_pcm(rtd, num);
1193 if (ret < 0) {
1194 printk(KERN_ERR "asoc: can't create pcm %s\n", dai_link->stream_name);
1195 return ret;
1196 }
1197
1198 /* add platform data for AC97 devices */
1199 if (rtd->codec_dai->driver->ac97_control)
1200 snd_ac97_dev_add_pdata(codec->ac97, rtd->cpu_dai->ac97_pdata);
1201
1202 return 0;
1203}
1204
1205#ifdef CONFIG_SND_SOC_AC97_BUS
1206static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime *rtd)
1207{
1208 int ret;
1209
1210 /* Only instantiate AC97 if not already done by the adaptor
1211 * for the generic AC97 subsystem.
1212 */
1213 if (rtd->codec_dai->driver->ac97_control && !rtd->codec->ac97_registered) {
Mika Westerberg0562f782010-10-13 11:30:32 +03001214 /*
1215 * It is possible that the AC97 device is already registered to
1216 * the device subsystem. This happens when the device is created
1217 * via snd_ac97_mixer(). Currently only SoC codec that does so
1218 * is the generic AC97 glue but others migh emerge.
1219 *
1220 * In those cases we don't try to register the device again.
1221 */
1222 if (!rtd->codec->ac97_created)
1223 return 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001224
1225 ret = soc_ac97_dev_register(rtd->codec);
1226 if (ret < 0) {
1227 printk(KERN_ERR "asoc: AC97 device register failed\n");
1228 return ret;
1229 }
1230
1231 rtd->codec->ac97_registered = 1;
1232 }
1233 return 0;
1234}
1235
1236static void soc_unregister_ac97_dai_link(struct snd_soc_codec *codec)
1237{
1238 if (codec->ac97_registered) {
1239 soc_ac97_dev_unregister(codec);
1240 codec->ac97_registered = 0;
1241 }
1242}
1243#endif
1244
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001245static int soc_probe_aux_dev(struct snd_soc_card *card, int num)
1246{
1247 struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001248 struct snd_soc_codec *codec;
Jarkko Nikula676ad982010-12-03 09:18:22 +02001249 int ret = -ENODEV;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001250
1251 /* find CODEC from registered CODECs*/
1252 list_for_each_entry(codec, &codec_list, list) {
1253 if (!strcmp(codec->name, aux_dev->codec_name)) {
1254 if (codec->probed) {
1255 dev_err(codec->dev,
1256 "asoc: codec already probed");
1257 ret = -EBUSY;
1258 goto out;
1259 }
Jarkko Nikula676ad982010-12-03 09:18:22 +02001260 goto found;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001261 }
1262 }
Jarkko Nikula676ad982010-12-03 09:18:22 +02001263 /* codec not found */
1264 dev_err(card->dev, "asoc: codec %s not found", aux_dev->codec_name);
1265 goto out;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001266
Jarkko Nikula676ad982010-12-03 09:18:22 +02001267found:
Jarkko Nikula589c3562010-12-06 16:27:07 +02001268 ret = soc_probe_codec(card, codec);
1269 if (ret < 0)
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001270 return ret;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001271
Jarkko Nikula589c3562010-12-06 16:27:07 +02001272 ret = soc_post_component_init(card, codec, num, 1);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001273
1274out:
1275 return ret;
1276}
1277
1278static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
1279{
1280 struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
1281 struct snd_soc_codec *codec = rtd->codec;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001282
1283 /* unregister the rtd device */
1284 if (rtd->dev_registered) {
Jarkko Nikula589c3562010-12-06 16:27:07 +02001285 device_remove_file(&rtd->dev, &dev_attr_codec_reg);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001286 device_unregister(&rtd->dev);
1287 rtd->dev_registered = 0;
1288 }
1289
Jarkko Nikula589c3562010-12-06 16:27:07 +02001290 if (codec && codec->probed)
1291 soc_remove_codec(codec);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001292}
1293
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001294static int snd_soc_init_codec_cache(struct snd_soc_codec *codec,
1295 enum snd_soc_compress_type compress_type)
1296{
1297 int ret;
1298
1299 if (codec->cache_init)
1300 return 0;
1301
1302 /* override the compress_type if necessary */
1303 if (compress_type && codec->compress_type != compress_type)
1304 codec->compress_type = compress_type;
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001305 ret = snd_soc_cache_init(codec);
1306 if (ret < 0) {
1307 dev_err(codec->dev, "Failed to set cache compression type: %d\n",
1308 ret);
1309 return ret;
1310 }
1311 codec->cache_init = 1;
1312 return 0;
1313}
1314
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001315static void snd_soc_instantiate_card(struct snd_soc_card *card)
1316{
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001317 struct snd_soc_codec *codec;
1318 struct snd_soc_codec_conf *codec_conf;
1319 enum snd_soc_compress_type compress_type;
Mark Brown75d9ac42011-09-27 16:41:01 +01001320 struct snd_soc_dai_link *dai_link;
Liam Girdwood0168bf02011-06-07 16:08:05 +01001321 int ret, i, order;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001322
1323 mutex_lock(&card->mutex);
1324
1325 if (card->instantiated) {
1326 mutex_unlock(&card->mutex);
1327 return;
1328 }
1329
1330 /* bind DAIs */
1331 for (i = 0; i < card->num_links; i++)
1332 soc_bind_dai_link(card, i);
1333
1334 /* bind completed ? */
1335 if (card->num_rtd != card->num_links) {
1336 mutex_unlock(&card->mutex);
1337 return;
1338 }
1339
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001340 /* initialize the register cache for each available codec */
1341 list_for_each_entry(codec, &codec_list, list) {
1342 if (codec->cache_init)
1343 continue;
Dimitris Papastamos861f2fa2011-01-11 11:43:51 +00001344 /* by default we don't override the compress_type */
1345 compress_type = 0;
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001346 /* check to see if we need to override the compress_type */
1347 for (i = 0; i < card->num_configs; ++i) {
1348 codec_conf = &card->codec_conf[i];
1349 if (!strcmp(codec->name, codec_conf->dev_name)) {
1350 compress_type = codec_conf->compress_type;
1351 if (compress_type && compress_type
1352 != codec->compress_type)
1353 break;
1354 }
1355 }
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001356 ret = snd_soc_init_codec_cache(codec, compress_type);
1357 if (ret < 0) {
1358 mutex_unlock(&card->mutex);
1359 return;
1360 }
1361 }
1362
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001363 /* card bind complete so register a sound card */
1364 ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
1365 card->owner, 0, &card->snd_card);
1366 if (ret < 0) {
1367 printk(KERN_ERR "asoc: can't create sound card for card %s\n",
1368 card->name);
1369 mutex_unlock(&card->mutex);
1370 return;
1371 }
1372 card->snd_card->dev = card->dev;
1373
Mark Browne37a4972011-03-02 18:21:57 +00001374 card->dapm.bias_level = SND_SOC_BIAS_OFF;
1375 card->dapm.dev = card->dev;
1376 card->dapm.card = card;
1377 list_add(&card->dapm.list, &card->dapm_list);
1378
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001379#ifdef CONFIG_DEBUG_FS
1380 snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
1381#endif
1382
Mark Brown88ee1c62011-02-02 10:43:26 +00001383#ifdef CONFIG_PM_SLEEP
Andy Green6ed25972008-06-13 16:24:05 +01001384 /* deferred resume work */
Mark Brown63084192008-12-02 15:08:03 +00001385 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
Randy Dunlap1301a962008-06-17 19:19:34 +01001386#endif
Andy Green6ed25972008-06-13 16:24:05 +01001387
Mark Brown9a841eb2011-04-12 17:51:37 -07001388 if (card->dapm_widgets)
1389 snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
1390 card->num_dapm_widgets);
1391
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001392 /* initialise the sound card only once */
1393 if (card->probe) {
Mark Browne7361ec2011-01-26 14:17:20 +00001394 ret = card->probe(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001395 if (ret < 0)
1396 goto card_probe_error;
1397 }
1398
Liam Girdwood0168bf02011-06-07 16:08:05 +01001399 /* early DAI link probe */
1400 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1401 order++) {
1402 for (i = 0; i < card->num_links; i++) {
1403 ret = soc_probe_dai_link(card, i, order);
1404 if (ret < 0) {
1405 pr_err("asoc: failed to instantiate card %s: %d\n",
Mark Brown321de0d2010-09-21 15:09:37 +01001406 card->name, ret);
Liam Girdwood0168bf02011-06-07 16:08:05 +01001407 goto probe_dai_err;
1408 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001409 }
1410 }
1411
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001412 for (i = 0; i < card->num_aux_devs; i++) {
1413 ret = soc_probe_aux_dev(card, i);
1414 if (ret < 0) {
1415 pr_err("asoc: failed to add auxiliary devices %s: %d\n",
1416 card->name, ret);
1417 goto probe_aux_dev_err;
1418 }
1419 }
1420
Mark Brownb7af1da2011-04-07 19:18:44 +09001421 /* We should have a non-codec control add function but we don't */
1422 if (card->controls)
1423 snd_soc_add_controls(list_first_entry(&card->codec_dev_list,
1424 struct snd_soc_codec,
1425 card_list),
1426 card->controls,
1427 card->num_controls);
1428
Mark Brownb8ad29d2011-03-02 18:35:51 +00001429 if (card->dapm_routes)
1430 snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
1431 card->num_dapm_routes);
1432
Mark Brown75d9ac42011-09-27 16:41:01 +01001433 for (i = 0; i < card->num_links; i++) {
1434 dai_link = &card->dai_link[i];
1435
1436 if (dai_link->dai_fmt) {
1437 ret = snd_soc_dai_set_fmt(card->rtd[i].codec_dai,
1438 dai_link->dai_fmt);
1439 if (ret != 0)
1440 dev_warn(card->rtd[i].codec_dai->dev,
1441 "Failed to set DAI format: %d\n",
1442 ret);
1443
1444 ret = snd_soc_dai_set_fmt(card->rtd[i].cpu_dai,
1445 dai_link->dai_fmt);
1446 if (ret != 0)
1447 dev_warn(card->rtd[i].cpu_dai->dev,
1448 "Failed to set DAI format: %d\n",
1449 ret);
1450 }
1451 }
1452
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001453 snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001454 "%s", card->name);
Liam Girdwood22de71b2011-05-12 16:14:04 +01001455 snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
1456 "%s", card->long_name ? card->long_name : card->name);
Mark Brownf0e8ed82011-09-20 11:41:54 +01001457 snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
1458 "%s", card->driver_name ? card->driver_name : card->name);
1459 for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
1460 switch (card->snd_card->driver[i]) {
1461 case '_':
1462 case '-':
1463 case '\0':
1464 break;
1465 default:
1466 if (!isalnum(card->snd_card->driver[i]))
1467 card->snd_card->driver[i] = '_';
1468 break;
1469 }
1470 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001471
Mark Brown28e9ad92011-03-02 18:36:34 +00001472 if (card->late_probe) {
1473 ret = card->late_probe(card);
1474 if (ret < 0) {
1475 dev_err(card->dev, "%s late_probe() failed: %d\n",
1476 card->name, ret);
1477 goto probe_aux_dev_err;
1478 }
1479 }
1480
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001481 ret = snd_card_register(card->snd_card);
1482 if (ret < 0) {
1483 printk(KERN_ERR "asoc: failed to register soundcard for %s\n", card->name);
Axel Lin6b3ed782010-12-07 16:12:29 +08001484 goto probe_aux_dev_err;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001485 }
1486
1487#ifdef CONFIG_SND_SOC_AC97_BUS
1488 /* register any AC97 codecs */
1489 for (i = 0; i < card->num_rtd; i++) {
Axel Lin6b3ed782010-12-07 16:12:29 +08001490 ret = soc_register_ac97_dai_link(&card->rtd[i]);
1491 if (ret < 0) {
1492 printk(KERN_ERR "asoc: failed to register AC97 %s\n", card->name);
1493 while (--i >= 0)
Mark Brown7d8316d2010-12-13 17:03:27 +00001494 soc_unregister_ac97_dai_link(card->rtd[i].codec);
Axel Lin6b3ed782010-12-07 16:12:29 +08001495 goto probe_aux_dev_err;
Mark Brownfe3e78e2009-11-03 22:13:13 +00001496 }
Axel Lin6b3ed782010-12-07 16:12:29 +08001497 }
Mark Brownfe3e78e2009-11-03 22:13:13 +00001498#endif
1499
Mark Brown435c5e22008-12-04 15:32:53 +00001500 card->instantiated = 1;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001501 mutex_unlock(&card->mutex);
Mark Brown435c5e22008-12-04 15:32:53 +00001502 return;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001503
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001504probe_aux_dev_err:
1505 for (i = 0; i < card->num_aux_devs; i++)
1506 soc_remove_aux_dev(card, i);
1507
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001508probe_dai_err:
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001509 soc_remove_dai_links(card);
Mark Brownfe3e78e2009-11-03 22:13:13 +00001510
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001511card_probe_error:
Mark Brown87506542008-11-18 20:50:34 +00001512 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00001513 card->remove(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001514
1515 snd_card_free(card->snd_card);
1516
1517 mutex_unlock(&card->mutex);
Mark Brown435c5e22008-12-04 15:32:53 +00001518}
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001519
Mark Brown435c5e22008-12-04 15:32:53 +00001520/*
Uwe Kleine-König421f91d2010-06-11 12:17:00 +02001521 * Attempt to initialise any uninitialised cards. Must be called with
Mark Brown435c5e22008-12-04 15:32:53 +00001522 * client_mutex.
1523 */
1524static void snd_soc_instantiate_cards(void)
1525{
1526 struct snd_soc_card *card;
1527 list_for_each_entry(card, &card_list, list)
1528 snd_soc_instantiate_card(card);
1529}
1530
1531/* probes a new socdev */
1532static int soc_probe(struct platform_device *pdev)
1533{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001534 struct snd_soc_card *card = platform_get_drvdata(pdev);
Mark Brown435c5e22008-12-04 15:32:53 +00001535 int ret = 0;
Mark Brown435c5e22008-12-04 15:32:53 +00001536
Vinod Koul70a7ca32011-01-14 19:22:48 +05301537 /*
1538 * no card, so machine driver should be registering card
1539 * we should not be here in that case so ret error
1540 */
1541 if (!card)
1542 return -EINVAL;
1543
Mark Brown435c5e22008-12-04 15:32:53 +00001544 /* Bodge while we unpick instantiation */
1545 card->dev = &pdev->dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001546
Mark Brown435c5e22008-12-04 15:32:53 +00001547 ret = snd_soc_register_card(card);
1548 if (ret != 0) {
1549 dev_err(&pdev->dev, "Failed to register card\n");
1550 return ret;
1551 }
1552
1553 return 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001554}
1555
Vinod Koulb0e26482011-01-13 22:48:02 +05301556static int soc_cleanup_card_resources(struct snd_soc_card *card)
1557{
Vinod Koulb0e26482011-01-13 22:48:02 +05301558 int i;
1559
1560 /* make sure any delayed work runs */
1561 for (i = 0; i < card->num_rtd; i++) {
1562 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1563 flush_delayed_work_sync(&rtd->delayed_work);
1564 }
1565
1566 /* remove auxiliary devices */
1567 for (i = 0; i < card->num_aux_devs; i++)
1568 soc_remove_aux_dev(card, i);
1569
1570 /* remove and free each DAI */
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001571 soc_remove_dai_links(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05301572
1573 soc_cleanup_card_debugfs(card);
1574
1575 /* remove the card */
1576 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00001577 card->remove(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05301578
Lars-Peter Clausen0aaae522011-04-30 19:45:47 +02001579 snd_soc_dapm_free(&card->dapm);
1580
Vinod Koulb0e26482011-01-13 22:48:02 +05301581 kfree(card->rtd);
1582 snd_card_free(card->snd_card);
1583 return 0;
1584
1585}
1586
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001587/* removes a socdev */
1588static int soc_remove(struct platform_device *pdev)
1589{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001590 struct snd_soc_card *card = platform_get_drvdata(pdev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001591
Mark Brownc5af3a22008-11-28 13:29:45 +00001592 snd_soc_unregister_card(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001593 return 0;
1594}
1595
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001596int snd_soc_poweroff(struct device *dev)
Mark Brown51737472009-06-22 13:16:51 +01001597{
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001598 struct snd_soc_card *card = dev_get_drvdata(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001599 int i;
Mark Brown51737472009-06-22 13:16:51 +01001600
1601 if (!card->instantiated)
Mark Brown416356f2009-06-30 19:05:15 +01001602 return 0;
Mark Brown51737472009-06-22 13:16:51 +01001603
1604 /* Flush out pmdown_time work - we actually do want to run it
1605 * now, we're shutting down so no imminent restart. */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001606 for (i = 0; i < card->num_rtd; i++) {
1607 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
Tejun Heo5b84ba22010-12-11 17:51:26 +01001608 flush_delayed_work_sync(&rtd->delayed_work);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001609 }
Mark Brown51737472009-06-22 13:16:51 +01001610
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001611 snd_soc_dapm_shutdown(card);
Mark Brown416356f2009-06-30 19:05:15 +01001612
1613 return 0;
Mark Brown51737472009-06-22 13:16:51 +01001614}
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001615EXPORT_SYMBOL_GPL(snd_soc_poweroff);
Mark Brown51737472009-06-22 13:16:51 +01001616
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001617const struct dev_pm_ops snd_soc_pm_ops = {
1618 .suspend = snd_soc_suspend,
1619 .resume = snd_soc_resume,
1620 .poweroff = snd_soc_poweroff,
Mark Brown416356f2009-06-30 19:05:15 +01001621};
Stephen Warrendeb26072011-04-05 19:35:30 -06001622EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
Mark Brown416356f2009-06-30 19:05:15 +01001623
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001624/* ASoC platform driver */
1625static struct platform_driver soc_driver = {
1626 .driver = {
1627 .name = "soc-audio",
Kay Sievers8b45a202008-04-14 13:33:36 +02001628 .owner = THIS_MODULE,
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001629 .pm = &snd_soc_pm_ops,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001630 },
1631 .probe = soc_probe,
1632 .remove = soc_remove,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001633};
1634
Mark Brown096e49d2009-07-05 15:12:22 +01001635/**
1636 * snd_soc_codec_volatile_register: Report if a register is volatile.
1637 *
1638 * @codec: CODEC to query.
1639 * @reg: Register to query.
1640 *
1641 * Boolean function indiciating if a CODEC register is volatile.
1642 */
Mark Brown181e0552011-01-24 14:05:25 +00001643int snd_soc_codec_volatile_register(struct snd_soc_codec *codec,
1644 unsigned int reg)
Mark Brown096e49d2009-07-05 15:12:22 +01001645{
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00001646 if (codec->volatile_register)
1647 return codec->volatile_register(codec, reg);
Mark Brown096e49d2009-07-05 15:12:22 +01001648 else
1649 return 0;
1650}
1651EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register);
1652
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001653/**
Dimitris Papastamos239c9702011-03-24 13:45:18 +00001654 * snd_soc_codec_readable_register: Report if a register is readable.
1655 *
1656 * @codec: CODEC to query.
1657 * @reg: Register to query.
1658 *
1659 * Boolean function indicating if a CODEC register is readable.
1660 */
1661int snd_soc_codec_readable_register(struct snd_soc_codec *codec,
1662 unsigned int reg)
1663{
1664 if (codec->readable_register)
1665 return codec->readable_register(codec, reg);
1666 else
Lars-Peter Clausen63fa0a22011-08-27 18:24:12 +02001667 return 1;
Dimitris Papastamos239c9702011-03-24 13:45:18 +00001668}
1669EXPORT_SYMBOL_GPL(snd_soc_codec_readable_register);
1670
1671/**
1672 * snd_soc_codec_writable_register: Report if a register is writable.
1673 *
1674 * @codec: CODEC to query.
1675 * @reg: Register to query.
1676 *
1677 * Boolean function indicating if a CODEC register is writable.
1678 */
1679int snd_soc_codec_writable_register(struct snd_soc_codec *codec,
1680 unsigned int reg)
1681{
1682 if (codec->writable_register)
1683 return codec->writable_register(codec, reg);
1684 else
Lars-Peter Clausen63fa0a22011-08-27 18:24:12 +02001685 return 1;
Dimitris Papastamos239c9702011-03-24 13:45:18 +00001686}
1687EXPORT_SYMBOL_GPL(snd_soc_codec_writable_register);
1688
Liam Girdwoodf1442bc2011-07-04 11:10:15 +01001689int snd_soc_platform_read(struct snd_soc_platform *platform,
1690 unsigned int reg)
1691{
1692 unsigned int ret;
1693
1694 if (!platform->driver->read) {
1695 dev_err(platform->dev, "platform has no read back\n");
1696 return -1;
1697 }
1698
1699 ret = platform->driver->read(platform, reg);
1700 dev_dbg(platform->dev, "read %x => %x\n", reg, ret);
Liam Girdwooda82ce2a2011-07-04 22:10:50 +01001701 trace_snd_soc_preg_read(platform, reg, ret);
Liam Girdwoodf1442bc2011-07-04 11:10:15 +01001702
1703 return ret;
1704}
1705EXPORT_SYMBOL_GPL(snd_soc_platform_read);
1706
1707int snd_soc_platform_write(struct snd_soc_platform *platform,
1708 unsigned int reg, unsigned int val)
1709{
1710 if (!platform->driver->write) {
1711 dev_err(platform->dev, "platform has no write back\n");
1712 return -1;
1713 }
1714
1715 dev_dbg(platform->dev, "write %x = %x\n", reg, val);
Liam Girdwooda82ce2a2011-07-04 22:10:50 +01001716 trace_snd_soc_preg_write(platform, reg, val);
Liam Girdwoodf1442bc2011-07-04 11:10:15 +01001717 return platform->driver->write(platform, reg, val);
1718}
1719EXPORT_SYMBOL_GPL(snd_soc_platform_write);
1720
Dimitris Papastamos239c9702011-03-24 13:45:18 +00001721/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001722 * snd_soc_new_ac97_codec - initailise AC97 device
1723 * @codec: audio codec
1724 * @ops: AC97 bus operations
1725 * @num: AC97 codec number
1726 *
1727 * Initialises AC97 codec resources for use by ad-hoc devices only.
1728 */
1729int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
1730 struct snd_ac97_bus_ops *ops, int num)
1731{
1732 mutex_lock(&codec->mutex);
1733
1734 codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
1735 if (codec->ac97 == NULL) {
1736 mutex_unlock(&codec->mutex);
1737 return -ENOMEM;
1738 }
1739
1740 codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
1741 if (codec->ac97->bus == NULL) {
1742 kfree(codec->ac97);
1743 codec->ac97 = NULL;
1744 mutex_unlock(&codec->mutex);
1745 return -ENOMEM;
1746 }
1747
1748 codec->ac97->bus->ops = ops;
1749 codec->ac97->num = num;
Mika Westerberg0562f782010-10-13 11:30:32 +03001750
1751 /*
1752 * Mark the AC97 device to be created by us. This way we ensure that the
1753 * device will be registered with the device subsystem later on.
1754 */
1755 codec->ac97_created = 1;
1756
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001757 mutex_unlock(&codec->mutex);
1758 return 0;
1759}
1760EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
1761
1762/**
1763 * snd_soc_free_ac97_codec - free AC97 codec device
1764 * @codec: audio codec
1765 *
1766 * Frees AC97 codec device resources.
1767 */
1768void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
1769{
1770 mutex_lock(&codec->mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001771#ifdef CONFIG_SND_SOC_AC97_BUS
1772 soc_unregister_ac97_dai_link(codec);
1773#endif
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001774 kfree(codec->ac97->bus);
1775 kfree(codec->ac97);
1776 codec->ac97 = NULL;
Mika Westerberg0562f782010-10-13 11:30:32 +03001777 codec->ac97_created = 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001778 mutex_unlock(&codec->mutex);
1779}
1780EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
1781
Mark Brownc3753702010-11-01 15:41:57 -04001782unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg)
1783{
1784 unsigned int ret;
1785
Mark Brownc3acec22010-12-02 16:15:29 +00001786 ret = codec->read(codec, reg);
Mark Brownc3753702010-11-01 15:41:57 -04001787 dev_dbg(codec->dev, "read %x => %x\n", reg, ret);
Mark Browna8b1d342010-11-03 18:05:58 -04001788 trace_snd_soc_reg_read(codec, reg, ret);
Mark Brownc3753702010-11-01 15:41:57 -04001789
1790 return ret;
1791}
1792EXPORT_SYMBOL_GPL(snd_soc_read);
1793
1794unsigned int snd_soc_write(struct snd_soc_codec *codec,
1795 unsigned int reg, unsigned int val)
1796{
1797 dev_dbg(codec->dev, "write %x = %x\n", reg, val);
Mark Browna8b1d342010-11-03 18:05:58 -04001798 trace_snd_soc_reg_write(codec, reg, val);
Mark Brownc3acec22010-12-02 16:15:29 +00001799 return codec->write(codec, reg, val);
Mark Brownc3753702010-11-01 15:41:57 -04001800}
1801EXPORT_SYMBOL_GPL(snd_soc_write);
1802
Dimitris Papastamos5fb609d2011-03-22 10:37:03 +00001803unsigned int snd_soc_bulk_write_raw(struct snd_soc_codec *codec,
1804 unsigned int reg, const void *data, size_t len)
1805{
1806 return codec->bulk_write_raw(codec, reg, data, len);
1807}
1808EXPORT_SYMBOL_GPL(snd_soc_bulk_write_raw);
1809
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001810/**
1811 * snd_soc_update_bits - update codec register bits
1812 * @codec: audio codec
1813 * @reg: codec register
1814 * @mask: register mask
1815 * @value: new value
1816 *
1817 * Writes new register value.
1818 *
Timur Tabi180c3292011-01-10 15:58:13 -06001819 * Returns 1 for change, 0 for no change, or negative error code.
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001820 */
1821int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001822 unsigned int mask, unsigned int value)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001823{
1824 int change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001825 unsigned int old, new;
Timur Tabi180c3292011-01-10 15:58:13 -06001826 int ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001827
Timur Tabi180c3292011-01-10 15:58:13 -06001828 ret = snd_soc_read(codec, reg);
1829 if (ret < 0)
1830 return ret;
1831
1832 old = ret;
Mark Brown78bf3c92011-06-03 17:09:14 +01001833 new = (old & ~mask) | (value & mask);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001834 change = old != new;
Timur Tabi180c3292011-01-10 15:58:13 -06001835 if (change) {
1836 ret = snd_soc_write(codec, reg, new);
1837 if (ret < 0)
1838 return ret;
1839 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001840
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001841 return change;
1842}
1843EXPORT_SYMBOL_GPL(snd_soc_update_bits);
1844
1845/**
Eero Nurkkala6c508c62009-10-30 13:34:03 +02001846 * snd_soc_update_bits_locked - update codec register bits
1847 * @codec: audio codec
1848 * @reg: codec register
1849 * @mask: register mask
1850 * @value: new value
1851 *
1852 * Writes new register value, and takes the codec mutex.
1853 *
1854 * Returns 1 for change else 0.
1855 */
Mark Browndd1b3d52009-12-04 14:22:03 +00001856int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
1857 unsigned short reg, unsigned int mask,
1858 unsigned int value)
Eero Nurkkala6c508c62009-10-30 13:34:03 +02001859{
1860 int change;
1861
1862 mutex_lock(&codec->mutex);
1863 change = snd_soc_update_bits(codec, reg, mask, value);
1864 mutex_unlock(&codec->mutex);
1865
1866 return change;
1867}
Mark Browndd1b3d52009-12-04 14:22:03 +00001868EXPORT_SYMBOL_GPL(snd_soc_update_bits_locked);
Eero Nurkkala6c508c62009-10-30 13:34:03 +02001869
1870/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001871 * snd_soc_test_bits - test register for change
1872 * @codec: audio codec
1873 * @reg: codec register
1874 * @mask: register mask
1875 * @value: new value
1876 *
1877 * Tests a register with a new value and checks if the new value is
1878 * different from the old value.
1879 *
1880 * Returns 1 for change else 0.
1881 */
1882int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001883 unsigned int mask, unsigned int value)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001884{
1885 int change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001886 unsigned int old, new;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001887
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001888 old = snd_soc_read(codec, reg);
1889 new = (old & ~mask) | value;
1890 change = old != new;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001891
1892 return change;
1893}
1894EXPORT_SYMBOL_GPL(snd_soc_test_bits);
1895
1896/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001897 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
1898 * @substream: the pcm substream
1899 * @hw: the hardware parameters
1900 *
1901 * Sets the substream runtime hardware parameters.
1902 */
1903int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
1904 const struct snd_pcm_hardware *hw)
1905{
1906 struct snd_pcm_runtime *runtime = substream->runtime;
1907 runtime->hw.info = hw->info;
1908 runtime->hw.formats = hw->formats;
1909 runtime->hw.period_bytes_min = hw->period_bytes_min;
1910 runtime->hw.period_bytes_max = hw->period_bytes_max;
1911 runtime->hw.periods_min = hw->periods_min;
1912 runtime->hw.periods_max = hw->periods_max;
1913 runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
1914 runtime->hw.fifo_size = hw->fifo_size;
1915 return 0;
1916}
1917EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
1918
1919/**
1920 * snd_soc_cnew - create new control
1921 * @_template: control template
1922 * @data: control private data
Mark Brownac11a2b2009-01-01 12:18:17 +00001923 * @long_name: control long name
Mark Brownefb7ac32011-03-08 17:23:24 +00001924 * @prefix: control name prefix
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001925 *
1926 * Create a new mixer control from a template control.
1927 *
1928 * Returns 0 for success, else error.
1929 */
1930struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
Mark Brownefb7ac32011-03-08 17:23:24 +00001931 void *data, char *long_name,
1932 const char *prefix)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001933{
1934 struct snd_kcontrol_new template;
Mark Brownefb7ac32011-03-08 17:23:24 +00001935 struct snd_kcontrol *kcontrol;
1936 char *name = NULL;
1937 int name_len;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001938
1939 memcpy(&template, _template, sizeof(template));
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001940 template.index = 0;
1941
Mark Brownefb7ac32011-03-08 17:23:24 +00001942 if (!long_name)
1943 long_name = template.name;
1944
1945 if (prefix) {
1946 name_len = strlen(long_name) + strlen(prefix) + 2;
Axel Lin57cf9d42011-08-20 11:03:44 +08001947 name = kmalloc(name_len, GFP_KERNEL);
Mark Brownefb7ac32011-03-08 17:23:24 +00001948 if (!name)
1949 return NULL;
1950
1951 snprintf(name, name_len, "%s %s", prefix, long_name);
1952
1953 template.name = name;
1954 } else {
1955 template.name = long_name;
1956 }
1957
1958 kcontrol = snd_ctl_new1(&template, data);
1959
1960 kfree(name);
1961
1962 return kcontrol;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001963}
1964EXPORT_SYMBOL_GPL(snd_soc_cnew);
1965
1966/**
Ian Molton3e8e1952009-01-09 00:23:21 +00001967 * snd_soc_add_controls - add an array of controls to a codec.
1968 * Convienience function to add a list of controls. Many codecs were
1969 * duplicating this code.
1970 *
1971 * @codec: codec to add controls to
1972 * @controls: array of controls to add
1973 * @num_controls: number of elements in the array
1974 *
1975 * Return 0 for success, else error.
1976 */
1977int snd_soc_add_controls(struct snd_soc_codec *codec,
1978 const struct snd_kcontrol_new *controls, int num_controls)
1979{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001980 struct snd_card *card = codec->card->snd_card;
Ian Molton3e8e1952009-01-09 00:23:21 +00001981 int err, i;
1982
1983 for (i = 0; i < num_controls; i++) {
1984 const struct snd_kcontrol_new *control = &controls[i];
Mark Brownefb7ac32011-03-08 17:23:24 +00001985 err = snd_ctl_add(card, snd_soc_cnew(control, codec,
1986 control->name,
1987 codec->name_prefix));
Ian Molton3e8e1952009-01-09 00:23:21 +00001988 if (err < 0) {
Mark Brown082100d2010-09-20 19:03:28 +01001989 dev_err(codec->dev, "%s: Failed to add %s: %d\n",
Mark Brownefb7ac32011-03-08 17:23:24 +00001990 codec->name, control->name, err);
Ian Molton3e8e1952009-01-09 00:23:21 +00001991 return err;
1992 }
1993 }
1994
1995 return 0;
1996}
1997EXPORT_SYMBOL_GPL(snd_soc_add_controls);
1998
1999/**
Liam Girdwooda491a5c2011-07-04 22:10:51 +01002000 * snd_soc_add_platform_controls - add an array of controls to a platform.
2001 * Convienience function to add a list of controls.
2002 *
2003 * @platform: platform to add controls to
2004 * @controls: array of controls to add
2005 * @num_controls: number of elements in the array
2006 *
2007 * Return 0 for success, else error.
2008 */
2009int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
2010 const struct snd_kcontrol_new *controls, int num_controls)
2011{
2012 struct snd_card *card = platform->card->snd_card;
2013 int err, i;
2014
2015 for (i = 0; i < num_controls; i++) {
2016 const struct snd_kcontrol_new *control = &controls[i];
2017 err = snd_ctl_add(card, snd_soc_cnew(control, platform,
2018 control->name, NULL));
2019 if (err < 0) {
2020 dev_err(platform->dev, "Failed to add %s %d\n",control->name, err);
2021 return err;
2022 }
2023 }
2024
2025 return 0;
2026}
2027EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
2028
2029/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002030 * snd_soc_info_enum_double - enumerated double mixer info callback
2031 * @kcontrol: mixer control
2032 * @uinfo: control element information
2033 *
2034 * Callback to provide information about a double enumerated
2035 * mixer control.
2036 *
2037 * Returns 0 for success.
2038 */
2039int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
2040 struct snd_ctl_elem_info *uinfo)
2041{
2042 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2043
2044 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2045 uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002046 uinfo->value.enumerated.items = e->max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002047
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002048 if (uinfo->value.enumerated.item > e->max - 1)
2049 uinfo->value.enumerated.item = e->max - 1;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002050 strcpy(uinfo->value.enumerated.name,
2051 e->texts[uinfo->value.enumerated.item]);
2052 return 0;
2053}
2054EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
2055
2056/**
2057 * snd_soc_get_enum_double - enumerated double mixer get callback
2058 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002059 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002060 *
2061 * Callback to get the value of a double enumerated mixer.
2062 *
2063 * Returns 0 for success.
2064 */
2065int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
2066 struct snd_ctl_elem_value *ucontrol)
2067{
2068 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2069 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002070 unsigned int val, bitmask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002071
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002072 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002073 ;
2074 val = snd_soc_read(codec, e->reg);
Mark Brown3ff3f642008-05-19 12:32:25 +02002075 ucontrol->value.enumerated.item[0]
2076 = (val >> e->shift_l) & (bitmask - 1);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002077 if (e->shift_l != e->shift_r)
2078 ucontrol->value.enumerated.item[1] =
2079 (val >> e->shift_r) & (bitmask - 1);
2080
2081 return 0;
2082}
2083EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
2084
2085/**
2086 * snd_soc_put_enum_double - enumerated double mixer put callback
2087 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002088 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002089 *
2090 * Callback to set the value of a double enumerated mixer.
2091 *
2092 * Returns 0 for success.
2093 */
2094int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
2095 struct snd_ctl_elem_value *ucontrol)
2096{
2097 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2098 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002099 unsigned int val;
2100 unsigned int mask, bitmask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002101
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002102 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002103 ;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002104 if (ucontrol->value.enumerated.item[0] > e->max - 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002105 return -EINVAL;
2106 val = ucontrol->value.enumerated.item[0] << e->shift_l;
2107 mask = (bitmask - 1) << e->shift_l;
2108 if (e->shift_l != e->shift_r) {
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002109 if (ucontrol->value.enumerated.item[1] > e->max - 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002110 return -EINVAL;
2111 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
2112 mask |= (bitmask - 1) << e->shift_r;
2113 }
2114
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002115 return snd_soc_update_bits_locked(codec, e->reg, mask, val);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002116}
2117EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
2118
2119/**
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002120 * snd_soc_get_value_enum_double - semi enumerated double mixer get callback
2121 * @kcontrol: mixer control
2122 * @ucontrol: control element information
2123 *
2124 * Callback to get the value of a double semi enumerated mixer.
2125 *
2126 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2127 * used for handling bitfield coded enumeration for example.
2128 *
2129 * Returns 0 for success.
2130 */
2131int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
2132 struct snd_ctl_elem_value *ucontrol)
2133{
2134 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Peter Ujfalusi74155552009-01-08 13:34:29 +02002135 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002136 unsigned int reg_val, val, mux;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002137
2138 reg_val = snd_soc_read(codec, e->reg);
2139 val = (reg_val >> e->shift_l) & e->mask;
2140 for (mux = 0; mux < e->max; mux++) {
2141 if (val == e->values[mux])
2142 break;
2143 }
2144 ucontrol->value.enumerated.item[0] = mux;
2145 if (e->shift_l != e->shift_r) {
2146 val = (reg_val >> e->shift_r) & e->mask;
2147 for (mux = 0; mux < e->max; mux++) {
2148 if (val == e->values[mux])
2149 break;
2150 }
2151 ucontrol->value.enumerated.item[1] = mux;
2152 }
2153
2154 return 0;
2155}
2156EXPORT_SYMBOL_GPL(snd_soc_get_value_enum_double);
2157
2158/**
2159 * snd_soc_put_value_enum_double - semi enumerated double mixer put callback
2160 * @kcontrol: mixer control
2161 * @ucontrol: control element information
2162 *
2163 * Callback to set the value of a double semi enumerated mixer.
2164 *
2165 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2166 * used for handling bitfield coded enumeration for example.
2167 *
2168 * Returns 0 for success.
2169 */
2170int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
2171 struct snd_ctl_elem_value *ucontrol)
2172{
2173 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Peter Ujfalusi74155552009-01-08 13:34:29 +02002174 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002175 unsigned int val;
2176 unsigned int mask;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002177
2178 if (ucontrol->value.enumerated.item[0] > e->max - 1)
2179 return -EINVAL;
2180 val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
2181 mask = e->mask << e->shift_l;
2182 if (e->shift_l != e->shift_r) {
2183 if (ucontrol->value.enumerated.item[1] > e->max - 1)
2184 return -EINVAL;
2185 val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
2186 mask |= e->mask << e->shift_r;
2187 }
2188
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002189 return snd_soc_update_bits_locked(codec, e->reg, mask, val);
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002190}
2191EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double);
2192
2193/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002194 * snd_soc_info_enum_ext - external enumerated single mixer info callback
2195 * @kcontrol: mixer control
2196 * @uinfo: control element information
2197 *
2198 * Callback to provide information about an external enumerated
2199 * single mixer.
2200 *
2201 * Returns 0 for success.
2202 */
2203int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
2204 struct snd_ctl_elem_info *uinfo)
2205{
2206 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2207
2208 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2209 uinfo->count = 1;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002210 uinfo->value.enumerated.items = e->max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002211
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002212 if (uinfo->value.enumerated.item > e->max - 1)
2213 uinfo->value.enumerated.item = e->max - 1;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002214 strcpy(uinfo->value.enumerated.name,
2215 e->texts[uinfo->value.enumerated.item]);
2216 return 0;
2217}
2218EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
2219
2220/**
2221 * snd_soc_info_volsw_ext - external single mixer info callback
2222 * @kcontrol: mixer control
2223 * @uinfo: control element information
2224 *
2225 * Callback to provide information about a single external mixer control.
2226 *
2227 * Returns 0 for success.
2228 */
2229int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
2230 struct snd_ctl_elem_info *uinfo)
2231{
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002232 int max = kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002233
Mark Brownfd5dfad2009-04-15 21:37:46 +01002234 if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002235 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2236 else
2237 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2238
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002239 uinfo->count = 1;
2240 uinfo->value.integer.min = 0;
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002241 uinfo->value.integer.max = max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002242 return 0;
2243}
2244EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
2245
2246/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002247 * snd_soc_info_volsw - single mixer info callback
2248 * @kcontrol: mixer control
2249 * @uinfo: control element information
2250 *
2251 * Callback to provide information about a single mixer control.
2252 *
2253 * Returns 0 for success.
2254 */
2255int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
2256 struct snd_ctl_elem_info *uinfo)
2257{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002258 struct soc_mixer_control *mc =
2259 (struct soc_mixer_control *)kcontrol->private_value;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002260 int platform_max;
Mark Brown762b8df2008-10-30 12:37:08 +00002261 unsigned int shift = mc->shift;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002262 unsigned int rshift = mc->rshift;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002263
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002264 if (!mc->platform_max)
2265 mc->platform_max = mc->max;
2266 platform_max = mc->platform_max;
2267
2268 if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002269 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2270 else
2271 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2272
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002273 uinfo->count = shift == rshift ? 1 : 2;
2274 uinfo->value.integer.min = 0;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002275 uinfo->value.integer.max = platform_max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002276 return 0;
2277}
2278EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
2279
2280/**
2281 * snd_soc_get_volsw - single mixer get callback
2282 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002283 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002284 *
2285 * Callback to get the value of a single mixer control.
2286 *
2287 * Returns 0 for success.
2288 */
2289int snd_soc_get_volsw(struct snd_kcontrol *kcontrol,
2290 struct snd_ctl_elem_value *ucontrol)
2291{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002292 struct soc_mixer_control *mc =
2293 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002294 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002295 unsigned int reg = mc->reg;
2296 unsigned int shift = mc->shift;
2297 unsigned int rshift = mc->rshift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002298 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002299 unsigned int mask = (1 << fls(max)) - 1;
2300 unsigned int invert = mc->invert;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002301
2302 ucontrol->value.integer.value[0] =
2303 (snd_soc_read(codec, reg) >> shift) & mask;
2304 if (shift != rshift)
2305 ucontrol->value.integer.value[1] =
2306 (snd_soc_read(codec, reg) >> rshift) & mask;
2307 if (invert) {
2308 ucontrol->value.integer.value[0] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002309 max - ucontrol->value.integer.value[0];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002310 if (shift != rshift)
2311 ucontrol->value.integer.value[1] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002312 max - ucontrol->value.integer.value[1];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002313 }
2314
2315 return 0;
2316}
2317EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
2318
2319/**
2320 * snd_soc_put_volsw - single mixer put callback
2321 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002322 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002323 *
2324 * Callback to set the value of a single mixer control.
2325 *
2326 * Returns 0 for success.
2327 */
2328int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
2329 struct snd_ctl_elem_value *ucontrol)
2330{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002331 struct soc_mixer_control *mc =
2332 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002333 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002334 unsigned int reg = mc->reg;
2335 unsigned int shift = mc->shift;
2336 unsigned int rshift = mc->rshift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002337 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002338 unsigned int mask = (1 << fls(max)) - 1;
2339 unsigned int invert = mc->invert;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002340 unsigned int val, val2, val_mask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002341
2342 val = (ucontrol->value.integer.value[0] & mask);
2343 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002344 val = max - val;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002345 val_mask = mask << shift;
2346 val = val << shift;
2347 if (shift != rshift) {
2348 val2 = (ucontrol->value.integer.value[1] & mask);
2349 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002350 val2 = max - val2;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002351 val_mask |= mask << rshift;
2352 val |= val2 << rshift;
2353 }
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002354 return snd_soc_update_bits_locked(codec, reg, val_mask, val);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002355}
2356EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
2357
2358/**
2359 * snd_soc_info_volsw_2r - double mixer info callback
2360 * @kcontrol: mixer control
2361 * @uinfo: control element information
2362 *
2363 * Callback to provide information about a double mixer control that
2364 * spans 2 codec registers.
2365 *
2366 * Returns 0 for success.
2367 */
2368int snd_soc_info_volsw_2r(struct snd_kcontrol *kcontrol,
2369 struct snd_ctl_elem_info *uinfo)
2370{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002371 struct soc_mixer_control *mc =
2372 (struct soc_mixer_control *)kcontrol->private_value;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002373 int platform_max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002374
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002375 if (!mc->platform_max)
2376 mc->platform_max = mc->max;
2377 platform_max = mc->platform_max;
2378
2379 if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002380 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2381 else
2382 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2383
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002384 uinfo->count = 2;
2385 uinfo->value.integer.min = 0;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002386 uinfo->value.integer.max = platform_max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002387 return 0;
2388}
2389EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r);
2390
2391/**
2392 * snd_soc_get_volsw_2r - double mixer get callback
2393 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002394 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002395 *
2396 * Callback to get the value of a double mixer control that spans 2 registers.
2397 *
2398 * Returns 0 for success.
2399 */
2400int snd_soc_get_volsw_2r(struct snd_kcontrol *kcontrol,
2401 struct snd_ctl_elem_value *ucontrol)
2402{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002403 struct soc_mixer_control *mc =
2404 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002405 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002406 unsigned int reg = mc->reg;
2407 unsigned int reg2 = mc->rreg;
2408 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002409 int max = mc->max;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002410 unsigned int mask = (1 << fls(max)) - 1;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002411 unsigned int invert = mc->invert;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002412
2413 ucontrol->value.integer.value[0] =
2414 (snd_soc_read(codec, reg) >> shift) & mask;
2415 ucontrol->value.integer.value[1] =
2416 (snd_soc_read(codec, reg2) >> shift) & mask;
2417 if (invert) {
2418 ucontrol->value.integer.value[0] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002419 max - ucontrol->value.integer.value[0];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002420 ucontrol->value.integer.value[1] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002421 max - ucontrol->value.integer.value[1];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002422 }
2423
2424 return 0;
2425}
2426EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r);
2427
2428/**
2429 * snd_soc_put_volsw_2r - double mixer set callback
2430 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002431 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002432 *
2433 * Callback to set the value of a double mixer control that spans 2 registers.
2434 *
2435 * Returns 0 for success.
2436 */
2437int snd_soc_put_volsw_2r(struct snd_kcontrol *kcontrol,
2438 struct snd_ctl_elem_value *ucontrol)
2439{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002440 struct soc_mixer_control *mc =
2441 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002442 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002443 unsigned int reg = mc->reg;
2444 unsigned int reg2 = mc->rreg;
2445 unsigned int shift = mc->shift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002446 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002447 unsigned int mask = (1 << fls(max)) - 1;
2448 unsigned int invert = mc->invert;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002449 int err;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002450 unsigned int val, val2, val_mask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002451
2452 val_mask = mask << shift;
2453 val = (ucontrol->value.integer.value[0] & mask);
2454 val2 = (ucontrol->value.integer.value[1] & mask);
2455
2456 if (invert) {
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002457 val = max - val;
2458 val2 = max - val2;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002459 }
2460
2461 val = val << shift;
2462 val2 = val2 << shift;
2463
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002464 err = snd_soc_update_bits_locked(codec, reg, val_mask, val);
Mark Brown3ff3f642008-05-19 12:32:25 +02002465 if (err < 0)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002466 return err;
2467
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002468 err = snd_soc_update_bits_locked(codec, reg2, val_mask, val2);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002469 return err;
2470}
2471EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r);
2472
Mark Browne13ac2e2008-05-28 17:58:05 +01002473/**
2474 * snd_soc_info_volsw_s8 - signed mixer info callback
2475 * @kcontrol: mixer control
2476 * @uinfo: control element information
2477 *
2478 * Callback to provide information about a signed mixer control.
2479 *
2480 * Returns 0 for success.
2481 */
2482int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
2483 struct snd_ctl_elem_info *uinfo)
2484{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002485 struct soc_mixer_control *mc =
2486 (struct soc_mixer_control *)kcontrol->private_value;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002487 int platform_max;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002488 int min = mc->min;
Mark Browne13ac2e2008-05-28 17:58:05 +01002489
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002490 if (!mc->platform_max)
2491 mc->platform_max = mc->max;
2492 platform_max = mc->platform_max;
2493
Mark Browne13ac2e2008-05-28 17:58:05 +01002494 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2495 uinfo->count = 2;
2496 uinfo->value.integer.min = 0;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002497 uinfo->value.integer.max = platform_max - min;
Mark Browne13ac2e2008-05-28 17:58:05 +01002498 return 0;
2499}
2500EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
2501
2502/**
2503 * snd_soc_get_volsw_s8 - signed mixer get callback
2504 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002505 * @ucontrol: control element information
Mark Browne13ac2e2008-05-28 17:58:05 +01002506 *
2507 * Callback to get the value of a signed mixer control.
2508 *
2509 * Returns 0 for success.
2510 */
2511int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
2512 struct snd_ctl_elem_value *ucontrol)
2513{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002514 struct soc_mixer_control *mc =
2515 (struct soc_mixer_control *)kcontrol->private_value;
Mark Browne13ac2e2008-05-28 17:58:05 +01002516 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002517 unsigned int reg = mc->reg;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002518 int min = mc->min;
Mark Browne13ac2e2008-05-28 17:58:05 +01002519 int val = snd_soc_read(codec, reg);
2520
2521 ucontrol->value.integer.value[0] =
2522 ((signed char)(val & 0xff))-min;
2523 ucontrol->value.integer.value[1] =
2524 ((signed char)((val >> 8) & 0xff))-min;
2525 return 0;
2526}
2527EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
2528
2529/**
2530 * snd_soc_put_volsw_sgn - signed mixer put callback
2531 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002532 * @ucontrol: control element information
Mark Browne13ac2e2008-05-28 17:58:05 +01002533 *
2534 * Callback to set the value of a signed mixer control.
2535 *
2536 * Returns 0 for success.
2537 */
2538int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
2539 struct snd_ctl_elem_value *ucontrol)
2540{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002541 struct soc_mixer_control *mc =
2542 (struct soc_mixer_control *)kcontrol->private_value;
Mark Browne13ac2e2008-05-28 17:58:05 +01002543 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002544 unsigned int reg = mc->reg;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002545 int min = mc->min;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002546 unsigned int val;
Mark Browne13ac2e2008-05-28 17:58:05 +01002547
2548 val = (ucontrol->value.integer.value[0]+min) & 0xff;
2549 val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
2550
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002551 return snd_soc_update_bits_locked(codec, reg, 0xffff, val);
Mark Browne13ac2e2008-05-28 17:58:05 +01002552}
2553EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
2554
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002555/**
Peter Ujfalusi637d3842010-05-07 14:05:49 +03002556 * snd_soc_limit_volume - Set new limit to an existing volume control.
2557 *
2558 * @codec: where to look for the control
2559 * @name: Name of the control
2560 * @max: new maximum limit
2561 *
2562 * Return 0 for success, else error.
2563 */
2564int snd_soc_limit_volume(struct snd_soc_codec *codec,
2565 const char *name, int max)
2566{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002567 struct snd_card *card = codec->card->snd_card;
Peter Ujfalusi637d3842010-05-07 14:05:49 +03002568 struct snd_kcontrol *kctl;
2569 struct soc_mixer_control *mc;
2570 int found = 0;
2571 int ret = -EINVAL;
2572
2573 /* Sanity check for name and max */
2574 if (unlikely(!name || max <= 0))
2575 return -EINVAL;
2576
2577 list_for_each_entry(kctl, &card->controls, list) {
2578 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name))) {
2579 found = 1;
2580 break;
2581 }
2582 }
2583 if (found) {
2584 mc = (struct soc_mixer_control *)kctl->private_value;
2585 if (max <= mc->max) {
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002586 mc->platform_max = max;
Peter Ujfalusi637d3842010-05-07 14:05:49 +03002587 ret = 0;
2588 }
2589 }
2590 return ret;
2591}
2592EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
2593
2594/**
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02002595 * snd_soc_info_volsw_2r_sx - double with tlv and variable data size
2596 * mixer info callback
2597 * @kcontrol: mixer control
2598 * @uinfo: control element information
2599 *
2600 * Returns 0 for success.
2601 */
2602int snd_soc_info_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2603 struct snd_ctl_elem_info *uinfo)
2604{
2605 struct soc_mixer_control *mc =
2606 (struct soc_mixer_control *)kcontrol->private_value;
2607 int max = mc->max;
2608 int min = mc->min;
2609
2610 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2611 uinfo->count = 2;
2612 uinfo->value.integer.min = 0;
2613 uinfo->value.integer.max = max-min;
2614
2615 return 0;
2616}
2617EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r_sx);
2618
2619/**
2620 * snd_soc_get_volsw_2r_sx - double with tlv and variable data size
2621 * mixer get callback
2622 * @kcontrol: mixer control
2623 * @uinfo: control element information
2624 *
2625 * Returns 0 for success.
2626 */
2627int snd_soc_get_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2628 struct snd_ctl_elem_value *ucontrol)
2629{
2630 struct soc_mixer_control *mc =
2631 (struct soc_mixer_control *)kcontrol->private_value;
2632 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2633 unsigned int mask = (1<<mc->shift)-1;
2634 int min = mc->min;
2635 int val = snd_soc_read(codec, mc->reg) & mask;
2636 int valr = snd_soc_read(codec, mc->rreg) & mask;
2637
Stuart Longland20630c72010-06-18 12:56:10 +10002638 ucontrol->value.integer.value[0] = ((val & 0xff)-min) & mask;
2639 ucontrol->value.integer.value[1] = ((valr & 0xff)-min) & mask;
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02002640 return 0;
2641}
2642EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r_sx);
2643
2644/**
2645 * snd_soc_put_volsw_2r_sx - double with tlv and variable data size
2646 * mixer put callback
2647 * @kcontrol: mixer control
2648 * @uinfo: control element information
2649 *
2650 * Returns 0 for success.
2651 */
2652int snd_soc_put_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2653 struct snd_ctl_elem_value *ucontrol)
2654{
2655 struct soc_mixer_control *mc =
2656 (struct soc_mixer_control *)kcontrol->private_value;
2657 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2658 unsigned int mask = (1<<mc->shift)-1;
2659 int min = mc->min;
2660 int ret;
2661 unsigned int val, valr, oval, ovalr;
2662
2663 val = ((ucontrol->value.integer.value[0]+min) & 0xff);
2664 val &= mask;
2665 valr = ((ucontrol->value.integer.value[1]+min) & 0xff);
2666 valr &= mask;
2667
2668 oval = snd_soc_read(codec, mc->reg) & mask;
2669 ovalr = snd_soc_read(codec, mc->rreg) & mask;
2670
2671 ret = 0;
2672 if (oval != val) {
2673 ret = snd_soc_write(codec, mc->reg, val);
2674 if (ret < 0)
Mark Brownf1df5ae2010-06-15 15:14:31 +01002675 return ret;
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02002676 }
2677 if (ovalr != valr) {
2678 ret = snd_soc_write(codec, mc->rreg, valr);
2679 if (ret < 0)
Mark Brownf1df5ae2010-06-15 15:14:31 +01002680 return ret;
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02002681 }
2682
2683 return 0;
2684}
2685EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r_sx);
2686
2687/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002688 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2689 * @dai: DAI
2690 * @clk_id: DAI specific clock ID
2691 * @freq: new clock frequency in Hz
2692 * @dir: new clock direction - input/output.
2693 *
2694 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2695 */
2696int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2697 unsigned int freq, int dir)
2698{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002699 if (dai->driver && dai->driver->ops->set_sysclk)
2700 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
Mark Brownec4ee522011-03-07 20:58:11 +00002701 else if (dai->codec && dai->codec->driver->set_sysclk)
Mark Brownda1c6ea2011-08-24 20:09:01 +01002702 return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,
Mark Brownec4ee522011-03-07 20:58:11 +00002703 freq, dir);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002704 else
2705 return -EINVAL;
2706}
2707EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
2708
2709/**
Mark Brownec4ee522011-03-07 20:58:11 +00002710 * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
2711 * @codec: CODEC
2712 * @clk_id: DAI specific clock ID
Mark Brownda1c6ea2011-08-24 20:09:01 +01002713 * @source: Source for the clock
Mark Brownec4ee522011-03-07 20:58:11 +00002714 * @freq: new clock frequency in Hz
2715 * @dir: new clock direction - input/output.
2716 *
2717 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
2718 */
2719int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
Mark Brownda1c6ea2011-08-24 20:09:01 +01002720 int source, unsigned int freq, int dir)
Mark Brownec4ee522011-03-07 20:58:11 +00002721{
2722 if (codec->driver->set_sysclk)
Mark Brownda1c6ea2011-08-24 20:09:01 +01002723 return codec->driver->set_sysclk(codec, clk_id, source,
2724 freq, dir);
Mark Brownec4ee522011-03-07 20:58:11 +00002725 else
2726 return -EINVAL;
2727}
2728EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
2729
2730/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002731 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
2732 * @dai: DAI
Mark Brownac11a2b2009-01-01 12:18:17 +00002733 * @div_id: DAI specific clock divider ID
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002734 * @div: new clock divisor.
2735 *
2736 * Configures the clock dividers. This is used to derive the best DAI bit and
2737 * frame clocks from the system or master clock. It's best to set the DAI bit
2738 * and frame clocks as low as possible to save system power.
2739 */
2740int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2741 int div_id, int div)
2742{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002743 if (dai->driver && dai->driver->ops->set_clkdiv)
2744 return dai->driver->ops->set_clkdiv(dai, div_id, div);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002745 else
2746 return -EINVAL;
2747}
2748EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
2749
2750/**
2751 * snd_soc_dai_set_pll - configure DAI PLL.
2752 * @dai: DAI
2753 * @pll_id: DAI specific PLL ID
Mark Brown85488032009-09-05 18:52:16 +01002754 * @source: DAI specific source for the PLL
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002755 * @freq_in: PLL input clock frequency in Hz
2756 * @freq_out: requested PLL output clock frequency in Hz
2757 *
2758 * Configures and enables PLL to generate output clock based on input clock.
2759 */
Mark Brown85488032009-09-05 18:52:16 +01002760int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
2761 unsigned int freq_in, unsigned int freq_out)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002762{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002763 if (dai->driver && dai->driver->ops->set_pll)
2764 return dai->driver->ops->set_pll(dai, pll_id, source,
Mark Brown85488032009-09-05 18:52:16 +01002765 freq_in, freq_out);
Mark Brownec4ee522011-03-07 20:58:11 +00002766 else if (dai->codec && dai->codec->driver->set_pll)
2767 return dai->codec->driver->set_pll(dai->codec, pll_id, source,
2768 freq_in, freq_out);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002769 else
2770 return -EINVAL;
2771}
2772EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
2773
Mark Brownec4ee522011-03-07 20:58:11 +00002774/*
2775 * snd_soc_codec_set_pll - configure codec PLL.
2776 * @codec: CODEC
2777 * @pll_id: DAI specific PLL ID
2778 * @source: DAI specific source for the PLL
2779 * @freq_in: PLL input clock frequency in Hz
2780 * @freq_out: requested PLL output clock frequency in Hz
2781 *
2782 * Configures and enables PLL to generate output clock based on input clock.
2783 */
2784int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
2785 unsigned int freq_in, unsigned int freq_out)
2786{
2787 if (codec->driver->set_pll)
2788 return codec->driver->set_pll(codec, pll_id, source,
2789 freq_in, freq_out);
2790 else
2791 return -EINVAL;
2792}
2793EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);
2794
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002795/**
2796 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
2797 * @dai: DAI
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002798 * @fmt: SND_SOC_DAIFMT_ format value.
2799 *
2800 * Configures the DAI hardware format and clocking.
2801 */
2802int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2803{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002804 if (dai->driver && dai->driver->ops->set_fmt)
2805 return dai->driver->ops->set_fmt(dai, fmt);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002806 else
2807 return -EINVAL;
2808}
2809EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
2810
2811/**
2812 * snd_soc_dai_set_tdm_slot - configure DAI TDM.
2813 * @dai: DAI
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002814 * @tx_mask: bitmask representing active TX slots.
2815 * @rx_mask: bitmask representing active RX slots.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002816 * @slots: Number of slots in use.
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002817 * @slot_width: Width in bits for each slot.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002818 *
2819 * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
2820 * specific.
2821 */
2822int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002823 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002824{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002825 if (dai->driver && dai->driver->ops->set_tdm_slot)
2826 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002827 slots, slot_width);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002828 else
2829 return -EINVAL;
2830}
2831EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
2832
2833/**
Barry Song472df3c2009-09-12 01:16:29 +08002834 * snd_soc_dai_set_channel_map - configure DAI audio channel map
2835 * @dai: DAI
2836 * @tx_num: how many TX channels
2837 * @tx_slot: pointer to an array which imply the TX slot number channel
2838 * 0~num-1 uses
2839 * @rx_num: how many RX channels
2840 * @rx_slot: pointer to an array which imply the RX slot number channel
2841 * 0~num-1 uses
2842 *
2843 * configure the relationship between channel number and TDM slot number.
2844 */
2845int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
2846 unsigned int tx_num, unsigned int *tx_slot,
2847 unsigned int rx_num, unsigned int *rx_slot)
2848{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002849 if (dai->driver && dai->driver->ops->set_channel_map)
2850 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
Barry Song472df3c2009-09-12 01:16:29 +08002851 rx_num, rx_slot);
2852 else
2853 return -EINVAL;
2854}
2855EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
2856
2857/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002858 * snd_soc_dai_set_tristate - configure DAI system or master clock.
2859 * @dai: DAI
2860 * @tristate: tristate enable
2861 *
2862 * Tristates the DAI so that others can use it.
2863 */
2864int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
2865{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002866 if (dai->driver && dai->driver->ops->set_tristate)
2867 return dai->driver->ops->set_tristate(dai, tristate);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002868 else
2869 return -EINVAL;
2870}
2871EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
2872
2873/**
2874 * snd_soc_dai_digital_mute - configure DAI system or master clock.
2875 * @dai: DAI
2876 * @mute: mute enable
2877 *
2878 * Mutes the DAI DAC.
2879 */
2880int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
2881{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002882 if (dai->driver && dai->driver->ops->digital_mute)
2883 return dai->driver->ops->digital_mute(dai, mute);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002884 else
2885 return -EINVAL;
2886}
2887EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
2888
Mark Brownc5af3a22008-11-28 13:29:45 +00002889/**
2890 * snd_soc_register_card - Register a card with the ASoC core
2891 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002892 * @card: Card to register
Mark Brownc5af3a22008-11-28 13:29:45 +00002893 *
Mark Brownc5af3a22008-11-28 13:29:45 +00002894 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05302895int snd_soc_register_card(struct snd_soc_card *card)
Mark Brownc5af3a22008-11-28 13:29:45 +00002896{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002897 int i;
2898
Mark Brownc5af3a22008-11-28 13:29:45 +00002899 if (!card->name || !card->dev)
2900 return -EINVAL;
2901
Mark Browned77cc12011-05-03 18:25:34 +01002902 dev_set_drvdata(card->dev, card);
2903
Stephen Warren111c6412011-01-28 14:26:35 -07002904 snd_soc_initialize_card_lists(card);
2905
Vinod Koul150dd2f2011-01-13 22:48:32 +05302906 soc_init_card_debugfs(card);
2907
Jarkko Nikula2eea3922010-11-25 17:47:38 +02002908 card->rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime) *
2909 (card->num_links + card->num_aux_devs),
2910 GFP_KERNEL);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002911 if (card->rtd == NULL)
2912 return -ENOMEM;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02002913 card->rtd_aux = &card->rtd[card->num_links];
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002914
2915 for (i = 0; i < card->num_links; i++)
2916 card->rtd[i].dai_link = &card->dai_link[i];
2917
Mark Brownc5af3a22008-11-28 13:29:45 +00002918 INIT_LIST_HEAD(&card->list);
2919 card->instantiated = 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002920 mutex_init(&card->mutex);
Mark Brownc5af3a22008-11-28 13:29:45 +00002921
2922 mutex_lock(&client_mutex);
2923 list_add(&card->list, &card_list);
Mark Brown435c5e22008-12-04 15:32:53 +00002924 snd_soc_instantiate_cards();
Mark Brownc5af3a22008-11-28 13:29:45 +00002925 mutex_unlock(&client_mutex);
2926
2927 dev_dbg(card->dev, "Registered card '%s'\n", card->name);
2928
2929 return 0;
2930}
Vinod Koul70a7ca32011-01-14 19:22:48 +05302931EXPORT_SYMBOL_GPL(snd_soc_register_card);
Mark Brownc5af3a22008-11-28 13:29:45 +00002932
2933/**
2934 * snd_soc_unregister_card - Unregister a card with the ASoC core
2935 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002936 * @card: Card to unregister
Mark Brownc5af3a22008-11-28 13:29:45 +00002937 *
Mark Brownc5af3a22008-11-28 13:29:45 +00002938 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05302939int snd_soc_unregister_card(struct snd_soc_card *card)
Mark Brownc5af3a22008-11-28 13:29:45 +00002940{
Vinod Koulb0e26482011-01-13 22:48:02 +05302941 if (card->instantiated)
2942 soc_cleanup_card_resources(card);
Mark Brownc5af3a22008-11-28 13:29:45 +00002943 mutex_lock(&client_mutex);
2944 list_del(&card->list);
2945 mutex_unlock(&client_mutex);
Mark Brownc5af3a22008-11-28 13:29:45 +00002946 dev_dbg(card->dev, "Unregistered card '%s'\n", card->name);
2947
2948 return 0;
2949}
Vinod Koul70a7ca32011-01-14 19:22:48 +05302950EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
Mark Brownc5af3a22008-11-28 13:29:45 +00002951
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002952/*
2953 * Simplify DAI link configuration by removing ".-1" from device names
2954 * and sanitizing names.
2955 */
Dimitris Papastamos0b9a2142010-12-06 15:49:20 +00002956static char *fmt_single_name(struct device *dev, int *id)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002957{
2958 char *found, name[NAME_SIZE];
2959 int id1, id2;
2960
2961 if (dev_name(dev) == NULL)
2962 return NULL;
2963
Dimitris Papastamos58818a72010-12-06 15:42:17 +00002964 strlcpy(name, dev_name(dev), NAME_SIZE);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002965
2966 /* are we a "%s.%d" name (platform and SPI components) */
2967 found = strstr(name, dev->driver->name);
2968 if (found) {
2969 /* get ID */
2970 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
2971
2972 /* discard ID from name if ID == -1 */
2973 if (*id == -1)
2974 found[strlen(dev->driver->name)] = '\0';
2975 }
2976
2977 } else {
2978 /* I2C component devices are named "bus-addr" */
2979 if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
2980 char tmp[NAME_SIZE];
2981
2982 /* create unique ID number from I2C addr and bus */
Jarkko Nikula05899442010-10-19 11:10:45 +03002983 *id = ((id1 & 0xffff) << 16) + id2;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002984
2985 /* sanitize component name for DAI link creation */
2986 snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
Dimitris Papastamos58818a72010-12-06 15:42:17 +00002987 strlcpy(name, tmp, NAME_SIZE);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002988 } else
2989 *id = 0;
2990 }
2991
2992 return kstrdup(name, GFP_KERNEL);
2993}
2994
2995/*
2996 * Simplify DAI link naming for single devices with multiple DAIs by removing
2997 * any ".-1" and using the DAI name (instead of device name).
2998 */
2999static inline char *fmt_multiple_name(struct device *dev,
3000 struct snd_soc_dai_driver *dai_drv)
3001{
3002 if (dai_drv->name == NULL) {
3003 printk(KERN_ERR "asoc: error - multiple DAI %s registered with no name\n",
3004 dev_name(dev));
3005 return NULL;
3006 }
3007
3008 return kstrdup(dai_drv->name, GFP_KERNEL);
3009}
3010
Mark Brown91151712008-11-30 23:31:24 +00003011/**
3012 * snd_soc_register_dai - Register a DAI with the ASoC core
3013 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003014 * @dai: DAI to register
Mark Brown91151712008-11-30 23:31:24 +00003015 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003016int snd_soc_register_dai(struct device *dev,
3017 struct snd_soc_dai_driver *dai_drv)
Mark Brown91151712008-11-30 23:31:24 +00003018{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003019 struct snd_soc_dai *dai;
Mark Brown91151712008-11-30 23:31:24 +00003020
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003021 dev_dbg(dev, "dai register %s\n", dev_name(dev));
Mark Brown91151712008-11-30 23:31:24 +00003022
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003023 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
3024 if (dai == NULL)
Lu Guanquna7393622011-04-20 16:00:51 +08003025 return -ENOMEM;
Eric Miao6335d052009-03-03 09:41:00 +08003026
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003027 /* create DAI component name */
3028 dai->name = fmt_single_name(dev, &dai->id);
3029 if (dai->name == NULL) {
3030 kfree(dai);
3031 return -ENOMEM;
3032 }
3033
3034 dai->dev = dev;
3035 dai->driver = dai_drv;
3036 if (!dai->driver->ops)
3037 dai->driver->ops = &null_dai_ops;
Mark Brown91151712008-11-30 23:31:24 +00003038
3039 mutex_lock(&client_mutex);
3040 list_add(&dai->list, &dai_list);
Mark Brown435c5e22008-12-04 15:32:53 +00003041 snd_soc_instantiate_cards();
Mark Brown91151712008-11-30 23:31:24 +00003042 mutex_unlock(&client_mutex);
3043
3044 pr_debug("Registered DAI '%s'\n", dai->name);
3045
3046 return 0;
3047}
3048EXPORT_SYMBOL_GPL(snd_soc_register_dai);
3049
3050/**
3051 * snd_soc_unregister_dai - Unregister a DAI from the ASoC core
3052 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003053 * @dai: DAI to unregister
Mark Brown91151712008-11-30 23:31:24 +00003054 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003055void snd_soc_unregister_dai(struct device *dev)
Mark Brown91151712008-11-30 23:31:24 +00003056{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003057 struct snd_soc_dai *dai;
3058
3059 list_for_each_entry(dai, &dai_list, list) {
3060 if (dev == dai->dev)
3061 goto found;
3062 }
3063 return;
3064
3065found:
Mark Brown91151712008-11-30 23:31:24 +00003066 mutex_lock(&client_mutex);
3067 list_del(&dai->list);
3068 mutex_unlock(&client_mutex);
3069
3070 pr_debug("Unregistered DAI '%s'\n", dai->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003071 kfree(dai->name);
3072 kfree(dai);
Mark Brown91151712008-11-30 23:31:24 +00003073}
3074EXPORT_SYMBOL_GPL(snd_soc_unregister_dai);
3075
3076/**
3077 * snd_soc_register_dais - Register multiple DAIs with the ASoC core
3078 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003079 * @dai: Array of DAIs to register
3080 * @count: Number of DAIs
Mark Brown91151712008-11-30 23:31:24 +00003081 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003082int snd_soc_register_dais(struct device *dev,
3083 struct snd_soc_dai_driver *dai_drv, size_t count)
Mark Brown91151712008-11-30 23:31:24 +00003084{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003085 struct snd_soc_dai *dai;
3086 int i, ret = 0;
3087
Liam Girdwood720ffa42010-08-18 00:30:30 +01003088 dev_dbg(dev, "dai register %s #%Zu\n", dev_name(dev), count);
Mark Brown91151712008-11-30 23:31:24 +00003089
3090 for (i = 0; i < count; i++) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003091
3092 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
Axel Linc46e0072010-11-03 15:04:45 +08003093 if (dai == NULL) {
3094 ret = -ENOMEM;
3095 goto err;
3096 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003097
3098 /* create DAI component name */
3099 dai->name = fmt_multiple_name(dev, &dai_drv[i]);
3100 if (dai->name == NULL) {
3101 kfree(dai);
3102 ret = -EINVAL;
Mark Brown91151712008-11-30 23:31:24 +00003103 goto err;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003104 }
3105
3106 dai->dev = dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003107 dai->driver = &dai_drv[i];
Mark Brown0f9141c2010-10-12 15:43:21 +01003108 if (dai->driver->id)
3109 dai->id = dai->driver->id;
3110 else
3111 dai->id = i;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003112 if (!dai->driver->ops)
3113 dai->driver->ops = &null_dai_ops;
3114
3115 mutex_lock(&client_mutex);
3116 list_add(&dai->list, &dai_list);
3117 mutex_unlock(&client_mutex);
3118
3119 pr_debug("Registered DAI '%s'\n", dai->name);
Mark Brown91151712008-11-30 23:31:24 +00003120 }
3121
Axel Lin1dcb4f32010-12-06 16:48:03 +08003122 mutex_lock(&client_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003123 snd_soc_instantiate_cards();
Axel Lin1dcb4f32010-12-06 16:48:03 +08003124 mutex_unlock(&client_mutex);
Mark Brown91151712008-11-30 23:31:24 +00003125 return 0;
3126
3127err:
3128 for (i--; i >= 0; i--)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003129 snd_soc_unregister_dai(dev);
Mark Brown91151712008-11-30 23:31:24 +00003130
3131 return ret;
3132}
3133EXPORT_SYMBOL_GPL(snd_soc_register_dais);
3134
3135/**
3136 * snd_soc_unregister_dais - Unregister multiple DAIs from the ASoC core
3137 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003138 * @dai: Array of DAIs to unregister
3139 * @count: Number of DAIs
Mark Brown91151712008-11-30 23:31:24 +00003140 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003141void snd_soc_unregister_dais(struct device *dev, size_t count)
Mark Brown91151712008-11-30 23:31:24 +00003142{
3143 int i;
3144
3145 for (i = 0; i < count; i++)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003146 snd_soc_unregister_dai(dev);
Mark Brown91151712008-11-30 23:31:24 +00003147}
3148EXPORT_SYMBOL_GPL(snd_soc_unregister_dais);
3149
Mark Brown12a48a8c2008-12-03 19:40:30 +00003150/**
3151 * snd_soc_register_platform - Register a platform with the ASoC core
3152 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003153 * @platform: platform to register
Mark Brown12a48a8c2008-12-03 19:40:30 +00003154 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003155int snd_soc_register_platform(struct device *dev,
3156 struct snd_soc_platform_driver *platform_drv)
Mark Brown12a48a8c2008-12-03 19:40:30 +00003157{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003158 struct snd_soc_platform *platform;
Mark Brown12a48a8c2008-12-03 19:40:30 +00003159
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003160 dev_dbg(dev, "platform register %s\n", dev_name(dev));
3161
3162 platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
3163 if (platform == NULL)
Lu Guanquna7393622011-04-20 16:00:51 +08003164 return -ENOMEM;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003165
3166 /* create platform component name */
3167 platform->name = fmt_single_name(dev, &platform->id);
3168 if (platform->name == NULL) {
3169 kfree(platform);
3170 return -ENOMEM;
3171 }
3172
3173 platform->dev = dev;
3174 platform->driver = platform_drv;
Liam Girdwoodb7950642011-07-04 22:10:52 +01003175 platform->dapm.dev = dev;
3176 platform->dapm.platform = platform;
Liam Girdwood64a648c2011-07-25 11:15:15 +01003177 platform->dapm.stream_event = platform_drv->stream_event;
Mark Brown12a48a8c2008-12-03 19:40:30 +00003178
3179 mutex_lock(&client_mutex);
3180 list_add(&platform->list, &platform_list);
Mark Brown435c5e22008-12-04 15:32:53 +00003181 snd_soc_instantiate_cards();
Mark Brown12a48a8c2008-12-03 19:40:30 +00003182 mutex_unlock(&client_mutex);
3183
3184 pr_debug("Registered platform '%s'\n", platform->name);
3185
3186 return 0;
3187}
3188EXPORT_SYMBOL_GPL(snd_soc_register_platform);
3189
3190/**
3191 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
3192 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003193 * @platform: platform to unregister
Mark Brown12a48a8c2008-12-03 19:40:30 +00003194 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003195void snd_soc_unregister_platform(struct device *dev)
Mark Brown12a48a8c2008-12-03 19:40:30 +00003196{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003197 struct snd_soc_platform *platform;
3198
3199 list_for_each_entry(platform, &platform_list, list) {
3200 if (dev == platform->dev)
3201 goto found;
3202 }
3203 return;
3204
3205found:
Mark Brown12a48a8c2008-12-03 19:40:30 +00003206 mutex_lock(&client_mutex);
3207 list_del(&platform->list);
3208 mutex_unlock(&client_mutex);
3209
3210 pr_debug("Unregistered platform '%s'\n", platform->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003211 kfree(platform->name);
3212 kfree(platform);
Mark Brown12a48a8c2008-12-03 19:40:30 +00003213}
3214EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
3215
Mark Brown151ab222009-05-09 16:22:58 +01003216static u64 codec_format_map[] = {
3217 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
3218 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
3219 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
3220 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
3221 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
3222 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
3223 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3224 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3225 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
3226 SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
3227 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
3228 SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
3229 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
3230 SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
3231 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
3232 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
3233};
3234
3235/* Fix up the DAI formats for endianness: codecs don't actually see
3236 * the endianness of the data but we're using the CPU format
3237 * definitions which do need to include endianness so we ensure that
3238 * codec DAIs always have both big and little endian variants set.
3239 */
3240static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
3241{
3242 int i;
3243
3244 for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
3245 if (stream->formats & codec_format_map[i])
3246 stream->formats |= codec_format_map[i];
3247}
3248
Mark Brown0d0cf002008-12-10 14:32:45 +00003249/**
3250 * snd_soc_register_codec - Register a codec with the ASoC core
3251 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003252 * @codec: codec to register
Mark Brown0d0cf002008-12-10 14:32:45 +00003253 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003254int snd_soc_register_codec(struct device *dev,
Mark Brown001ae4c2010-12-02 16:21:08 +00003255 const struct snd_soc_codec_driver *codec_drv,
3256 struct snd_soc_dai_driver *dai_drv,
3257 int num_dai)
Mark Brown0d0cf002008-12-10 14:32:45 +00003258{
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003259 size_t reg_size;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003260 struct snd_soc_codec *codec;
3261 int ret, i;
Mark Brown151ab222009-05-09 16:22:58 +01003262
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003263 dev_dbg(dev, "codec register %s\n", dev_name(dev));
Mark Brown0d0cf002008-12-10 14:32:45 +00003264
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003265 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
3266 if (codec == NULL)
3267 return -ENOMEM;
Mark Brown0d0cf002008-12-10 14:32:45 +00003268
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003269 /* create CODEC component name */
3270 codec->name = fmt_single_name(dev, &codec->id);
3271 if (codec->name == NULL) {
3272 kfree(codec);
3273 return -ENOMEM;
Mark Brown151ab222009-05-09 16:22:58 +01003274 }
3275
Dimitris Papastamos23bbce32010-12-02 14:53:01 +00003276 if (codec_drv->compress_type)
3277 codec->compress_type = codec_drv->compress_type;
3278 else
3279 codec->compress_type = SND_SOC_FLAT_COMPRESSION;
3280
Mark Brownc3acec22010-12-02 16:15:29 +00003281 codec->write = codec_drv->write;
3282 codec->read = codec_drv->read;
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00003283 codec->volatile_register = codec_drv->volatile_register;
3284 codec->readable_register = codec_drv->readable_register;
Dimitris Papastamos80204542011-03-24 13:45:17 +00003285 codec->writable_register = codec_drv->writable_register;
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003286 codec->dapm.bias_level = SND_SOC_BIAS_OFF;
3287 codec->dapm.dev = dev;
3288 codec->dapm.codec = codec;
Mark Brown474b62d2011-01-18 16:14:44 +00003289 codec->dapm.seq_notifier = codec_drv->seq_notifier;
Liam Girdwood64a648c2011-07-25 11:15:15 +01003290 codec->dapm.stream_event = codec_drv->stream_event;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003291 codec->dev = dev;
3292 codec->driver = codec_drv;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003293 codec->num_dai = num_dai;
3294 mutex_init(&codec->mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003295
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003296 /* allocate CODEC register cache */
3297 if (codec_drv->reg_cache_size && codec_drv->reg_word_size) {
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003298 reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
Dimitris Papastamosaea170a2011-01-12 10:38:58 +00003299 codec->reg_size = reg_size;
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003300 /* it is necessary to make a copy of the default register cache
3301 * because in the case of using a compression type that requires
3302 * the default register cache to be marked as __devinitconst the
3303 * kernel might have freed the array by the time we initialize
3304 * the cache.
3305 */
Dimitris Papastamos2aa86322011-01-10 10:10:56 +00003306 if (codec_drv->reg_cache_default) {
3307 codec->reg_def_copy = kmemdup(codec_drv->reg_cache_default,
3308 reg_size, GFP_KERNEL);
3309 if (!codec->reg_def_copy) {
3310 ret = -ENOMEM;
3311 goto fail;
3312 }
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003313 }
3314 }
3315
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00003316 if (codec_drv->reg_access_size && codec_drv->reg_access_default) {
3317 if (!codec->volatile_register)
3318 codec->volatile_register = snd_soc_default_volatile_register;
3319 if (!codec->readable_register)
3320 codec->readable_register = snd_soc_default_readable_register;
Dimitris Papastamos80204542011-03-24 13:45:17 +00003321 if (!codec->writable_register)
3322 codec->writable_register = snd_soc_default_writable_register;
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00003323 }
3324
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003325 for (i = 0; i < num_dai; i++) {
3326 fixup_codec_formats(&dai_drv[i].playback);
3327 fixup_codec_formats(&dai_drv[i].capture);
3328 }
3329
Mark Brown26b01cc2010-08-18 20:20:55 +01003330 /* register any DAIs */
3331 if (num_dai) {
3332 ret = snd_soc_register_dais(dev, dai_drv, num_dai);
3333 if (ret < 0)
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00003334 goto fail;
Mark Brown26b01cc2010-08-18 20:20:55 +01003335 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003336
Mark Brown0d0cf002008-12-10 14:32:45 +00003337 mutex_lock(&client_mutex);
3338 list_add(&codec->list, &codec_list);
3339 snd_soc_instantiate_cards();
3340 mutex_unlock(&client_mutex);
3341
3342 pr_debug("Registered codec '%s'\n", codec->name);
Mark Brown0d0cf002008-12-10 14:32:45 +00003343 return 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003344
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00003345fail:
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003346 kfree(codec->reg_def_copy);
3347 codec->reg_def_copy = NULL;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003348 kfree(codec->name);
3349 kfree(codec);
3350 return ret;
Mark Brown0d0cf002008-12-10 14:32:45 +00003351}
3352EXPORT_SYMBOL_GPL(snd_soc_register_codec);
3353
3354/**
3355 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
3356 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003357 * @codec: codec to unregister
Mark Brown0d0cf002008-12-10 14:32:45 +00003358 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003359void snd_soc_unregister_codec(struct device *dev)
Mark Brown0d0cf002008-12-10 14:32:45 +00003360{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003361 struct snd_soc_codec *codec;
3362 int i;
3363
3364 list_for_each_entry(codec, &codec_list, list) {
3365 if (dev == codec->dev)
3366 goto found;
3367 }
3368 return;
3369
3370found:
Mark Brown26b01cc2010-08-18 20:20:55 +01003371 if (codec->num_dai)
3372 for (i = 0; i < codec->num_dai; i++)
3373 snd_soc_unregister_dai(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003374
Mark Brown0d0cf002008-12-10 14:32:45 +00003375 mutex_lock(&client_mutex);
3376 list_del(&codec->list);
3377 mutex_unlock(&client_mutex);
3378
3379 pr_debug("Unregistered codec '%s'\n", codec->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003380
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003381 snd_soc_cache_exit(codec);
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003382 kfree(codec->reg_def_copy);
Dimitris Papastamos1aafcd42010-10-21 13:19:45 +01003383 kfree(codec->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003384 kfree(codec);
Mark Brown0d0cf002008-12-10 14:32:45 +00003385}
3386EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
3387
Takashi Iwaic9b3a402008-12-10 07:47:22 +01003388static int __init snd_soc_init(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003389{
Mark Brown384c89e2008-12-03 17:34:03 +00003390#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +00003391 snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
3392 if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
Mark Brown384c89e2008-12-03 17:34:03 +00003393 printk(KERN_WARNING
3394 "ASoC: Failed to create debugfs directory\n");
Mark Brown8a9dab12011-01-10 22:25:21 +00003395 snd_soc_debugfs_root = NULL;
Mark Brown384c89e2008-12-03 17:34:03 +00003396 }
Mark Brownc3c5a192010-09-15 18:15:14 +01003397
Mark Brown8a9dab12011-01-10 22:25:21 +00003398 if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
Mark Brownc3c5a192010-09-15 18:15:14 +01003399 &codec_list_fops))
3400 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
3401
Mark Brown8a9dab12011-01-10 22:25:21 +00003402 if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
Mark Brownf3208782010-09-15 18:19:07 +01003403 &dai_list_fops))
3404 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
Mark Brown19c7ac22010-09-15 18:22:40 +01003405
Mark Brown8a9dab12011-01-10 22:25:21 +00003406 if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
Mark Brown19c7ac22010-09-15 18:22:40 +01003407 &platform_list_fops))
3408 pr_warn("ASoC: Failed to create platform list debugfs file\n");
Mark Brown384c89e2008-12-03 17:34:03 +00003409#endif
3410
Mark Brownfb257892011-04-28 10:57:54 +01003411 snd_soc_util_init();
3412
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003413 return platform_driver_register(&soc_driver);
3414}
Mark Brown4abe8e12010-10-12 17:41:03 +01003415module_init(snd_soc_init);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003416
Mark Brown7d8c16a2008-11-30 22:11:24 +00003417static void __exit snd_soc_exit(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003418{
Mark Brownfb257892011-04-28 10:57:54 +01003419 snd_soc_util_exit();
3420
Mark Brown384c89e2008-12-03 17:34:03 +00003421#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +00003422 debugfs_remove_recursive(snd_soc_debugfs_root);
Mark Brown384c89e2008-12-03 17:34:03 +00003423#endif
Mark Brown3ff3f642008-05-19 12:32:25 +02003424 platform_driver_unregister(&soc_driver);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003425}
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003426module_exit(snd_soc_exit);
3427
3428/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01003429MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003430MODULE_DESCRIPTION("ALSA SoC Core");
3431MODULE_LICENSE("GPL");
Kay Sievers8b45a202008-04-14 13:33:36 +02003432MODULE_ALIAS("platform:soc-audio");