blob: c88d9741b9e7942e60ba17e3d98231136b607dc9 [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>
Stephen Warrenbec4fa02011-12-12 15:55:34 -070035#include <linux/of.h>
Marek Vasut474828a2009-07-22 13:01:03 +020036#include <sound/ac97_codec.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020037#include <sound/core.h>
Mark Brown3028eb82010-12-05 12:22:46 +000038#include <sound/jack.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020039#include <sound/pcm.h>
40#include <sound/pcm_params.h>
41#include <sound/soc.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020042#include <sound/initval.h>
43
Mark Browna8b1d342010-11-03 18:05:58 -040044#define CREATE_TRACE_POINTS
45#include <trace/events/asoc.h>
46
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +000047#define NAME_SIZE 32
48
Frank Mandarinodb2a4162006-10-06 18:31:09 +020049static DECLARE_WAIT_QUEUE_HEAD(soc_pm_waitq);
50
Mark Brown384c89e2008-12-03 17:34:03 +000051#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +000052struct dentry *snd_soc_debugfs_root;
53EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
Mark Brown384c89e2008-12-03 17:34:03 +000054#endif
55
Mark Brownc5af3a22008-11-28 13:29:45 +000056static DEFINE_MUTEX(client_mutex);
57static LIST_HEAD(card_list);
Mark Brown91151712008-11-30 23:31:24 +000058static LIST_HEAD(dai_list);
Mark Brown12a48a8c2008-12-03 19:40:30 +000059static LIST_HEAD(platform_list);
Mark Brown0d0cf002008-12-10 14:32:45 +000060static LIST_HEAD(codec_list);
Mark Brownc5af3a22008-11-28 13:29:45 +000061
Frank Mandarinodb2a4162006-10-06 18:31:09 +020062/*
63 * This is a timeout to do a DAPM powerdown after a stream is closed().
64 * It can be used to eliminate pops between different playback streams, e.g.
65 * between two audio tracks.
66 */
67static int pmdown_time = 5000;
68module_param(pmdown_time, int, 0);
69MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
70
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +000071/* returns the minimum number of bytes needed to represent
72 * a particular given value */
73static int min_bytes_needed(unsigned long val)
74{
75 int c = 0;
76 int i;
77
78 for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)
79 if (val & (1UL << i))
80 break;
81 c = (sizeof val * 8) - c;
82 if (!c || (c % 8))
83 c = (c + 8) / 8;
84 else
85 c /= 8;
86 return c;
87}
88
Dimitris Papastamos13fd1792011-02-02 13:58:58 +000089/* fill buf which is 'len' bytes with a formatted
90 * string of the form 'reg: value\n' */
91static int format_register_str(struct snd_soc_codec *codec,
92 unsigned int reg, char *buf, size_t len)
Mark Brown2624d5f2009-11-03 21:56:13 +000093{
Stephen Warren00b317a2011-04-01 14:50:44 -060094 int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
95 int regsize = codec->driver->reg_word_size * 2;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +000096 int ret;
97 char tmpbuf[len + 1];
98 char regbuf[regsize + 1];
99
100 /* since tmpbuf is allocated on the stack, warn the callers if they
101 * try to abuse this function */
102 WARN_ON(len > 63);
103
104 /* +2 for ': ' and + 1 for '\n' */
105 if (wordsize + regsize + 2 + 1 != len)
106 return -EINVAL;
107
Mark Brown25032c12011-08-01 13:52:48 +0900108 ret = snd_soc_read(codec, reg);
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000109 if (ret < 0) {
110 memset(regbuf, 'X', regsize);
111 regbuf[regsize] = '\0';
112 } else {
113 snprintf(regbuf, regsize + 1, "%.*x", regsize, ret);
114 }
115
116 /* prepare the buffer */
117 snprintf(tmpbuf, len + 1, "%.*x: %s\n", wordsize, reg, regbuf);
118 /* copy it back to the caller without the '\0' */
119 memcpy(buf, tmpbuf, len);
120
121 return 0;
122}
123
124/* codec register dump */
125static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
126 size_t count, loff_t pos)
127{
128 int i, step = 1;
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +0000129 int wordsize, regsize;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000130 int len;
131 size_t total = 0;
132 loff_t p = 0;
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +0000133
Stephen Warren00b317a2011-04-01 14:50:44 -0600134 wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
135 regsize = codec->driver->reg_word_size * 2;
Mark Brown2624d5f2009-11-03 21:56:13 +0000136
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000137 len = wordsize + regsize + 2 + 1;
138
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000139 if (!codec->driver->reg_cache_size)
Mark Brown2624d5f2009-11-03 21:56:13 +0000140 return 0;
141
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000142 if (codec->driver->reg_cache_step)
143 step = codec->driver->reg_cache_step;
Mark Brown2624d5f2009-11-03 21:56:13 +0000144
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000145 for (i = 0; i < codec->driver->reg_cache_size; i += step) {
Lars-Peter Clausenb92d1502011-08-27 18:24:14 +0200146 if (!snd_soc_codec_readable_register(codec, i))
Mark Brown2624d5f2009-11-03 21:56:13 +0000147 continue;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000148 if (codec->driver->display_register) {
149 count += codec->driver->display_register(codec, buf + count,
Mark Brown2624d5f2009-11-03 21:56:13 +0000150 PAGE_SIZE - count, i);
Mark Brown5164d742010-07-14 16:14:33 +0100151 } else {
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000152 /* only support larger than PAGE_SIZE bytes debugfs
153 * entries for the default case */
154 if (p >= pos) {
155 if (total + len >= count - 1)
156 break;
157 format_register_str(codec, i, buf + total, len);
158 total += len;
159 }
160 p += len;
Mark Brown5164d742010-07-14 16:14:33 +0100161 }
Mark Brown2624d5f2009-11-03 21:56:13 +0000162 }
163
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000164 total = min(total, count - 1);
Mark Brown2624d5f2009-11-03 21:56:13 +0000165
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000166 return total;
Mark Brown2624d5f2009-11-03 21:56:13 +0000167}
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000168
Mark Brown2624d5f2009-11-03 21:56:13 +0000169static ssize_t codec_reg_show(struct device *dev,
170 struct device_attribute *attr, char *buf)
171{
Mark Brown36ae1a92012-01-06 17:12:45 -0800172 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000173
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000174 return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);
Mark Brown2624d5f2009-11-03 21:56:13 +0000175}
176
177static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
178
Mark Browndbe21402010-02-12 11:37:24 +0000179static ssize_t pmdown_time_show(struct device *dev,
180 struct device_attribute *attr, char *buf)
181{
Mark Brown36ae1a92012-01-06 17:12:45 -0800182 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
Mark Browndbe21402010-02-12 11:37:24 +0000183
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000184 return sprintf(buf, "%ld\n", rtd->pmdown_time);
Mark Browndbe21402010-02-12 11:37:24 +0000185}
186
187static ssize_t pmdown_time_set(struct device *dev,
188 struct device_attribute *attr,
189 const char *buf, size_t count)
190{
Mark Brown36ae1a92012-01-06 17:12:45 -0800191 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
Mark Brownc593b522010-10-27 20:11:17 -0700192 int ret;
Mark Browndbe21402010-02-12 11:37:24 +0000193
Mark Brownc593b522010-10-27 20:11:17 -0700194 ret = strict_strtol(buf, 10, &rtd->pmdown_time);
195 if (ret)
196 return ret;
Mark Browndbe21402010-02-12 11:37:24 +0000197
198 return count;
199}
200
201static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
202
Mark Brown2624d5f2009-11-03 21:56:13 +0000203#ifdef CONFIG_DEBUG_FS
Mark Brown2624d5f2009-11-03 21:56:13 +0000204static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000205 size_t count, loff_t *ppos)
Mark Brown2624d5f2009-11-03 21:56:13 +0000206{
207 ssize_t ret;
208 struct snd_soc_codec *codec = file->private_data;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000209 char *buf;
210
211 if (*ppos < 0 || !count)
212 return -EINVAL;
213
214 buf = kmalloc(count, GFP_KERNEL);
Mark Brown2624d5f2009-11-03 21:56:13 +0000215 if (!buf)
216 return -ENOMEM;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000217
218 ret = soc_codec_reg_show(codec, buf, count, *ppos);
219 if (ret >= 0) {
220 if (copy_to_user(user_buf, buf, ret)) {
221 kfree(buf);
222 return -EFAULT;
223 }
224 *ppos += ret;
225 }
226
Mark Brown2624d5f2009-11-03 21:56:13 +0000227 kfree(buf);
228 return ret;
229}
230
231static ssize_t codec_reg_write_file(struct file *file,
232 const char __user *user_buf, size_t count, loff_t *ppos)
233{
234 char buf[32];
Stephen Boyd34e268d2011-05-12 16:50:10 -0700235 size_t buf_size;
Mark Brown2624d5f2009-11-03 21:56:13 +0000236 char *start = buf;
237 unsigned long reg, value;
Mark Brown2624d5f2009-11-03 21:56:13 +0000238 struct snd_soc_codec *codec = file->private_data;
239
240 buf_size = min(count, (sizeof(buf)-1));
241 if (copy_from_user(buf, user_buf, buf_size))
242 return -EFAULT;
243 buf[buf_size] = 0;
244
Mark Brown2624d5f2009-11-03 21:56:13 +0000245 while (*start == ' ')
246 start++;
247 reg = simple_strtoul(start, &start, 16);
Mark Brown2624d5f2009-11-03 21:56:13 +0000248 while (*start == ' ')
249 start++;
250 if (strict_strtoul(start, 16, &value))
251 return -EINVAL;
Mark Brown0d51a9c2011-01-06 16:04:57 +0000252
253 /* Userspace has been fiddling around behind the kernel's back */
254 add_taint(TAINT_USER);
255
Dimitris Papastamose4f078d2010-12-07 16:30:38 +0000256 snd_soc_write(codec, reg, value);
Mark Brown2624d5f2009-11-03 21:56:13 +0000257 return buf_size;
258}
259
260static const struct file_operations codec_reg_fops = {
Stephen Boyd234e3402012-04-05 14:25:11 -0700261 .open = simple_open,
Mark Brown2624d5f2009-11-03 21:56:13 +0000262 .read = codec_reg_read_file,
263 .write = codec_reg_write_file,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200264 .llseek = default_llseek,
Mark Brown2624d5f2009-11-03 21:56:13 +0000265};
266
267static void soc_init_codec_debugfs(struct snd_soc_codec *codec)
268{
Jarkko Nikulad6ce4cf2010-11-05 20:35:20 +0200269 struct dentry *debugfs_card_root = codec->card->debugfs_card_root;
270
271 codec->debugfs_codec_root = debugfs_create_dir(codec->name,
272 debugfs_card_root);
Mark Brown2624d5f2009-11-03 21:56:13 +0000273 if (!codec->debugfs_codec_root) {
Liam Girdwood64e60f92012-02-15 15:15:37 +0000274 dev_warn(codec->dev, "Failed to create codec debugfs directory\n");
Mark Brown2624d5f2009-11-03 21:56:13 +0000275 return;
276 }
277
Mark Brownaaee8ef2011-01-26 20:53:50 +0000278 debugfs_create_bool("cache_sync", 0444, codec->debugfs_codec_root,
279 &codec->cache_sync);
280 debugfs_create_bool("cache_only", 0444, codec->debugfs_codec_root,
281 &codec->cache_only);
282
Mark Brown2624d5f2009-11-03 21:56:13 +0000283 codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
284 codec->debugfs_codec_root,
285 codec, &codec_reg_fops);
286 if (!codec->debugfs_reg)
Liam Girdwood64e60f92012-02-15 15:15:37 +0000287 dev_warn(codec->dev, "Failed to create codec register debugfs file\n");
Mark Brown2624d5f2009-11-03 21:56:13 +0000288
Lars-Peter Clausen8eecaf62011-04-30 19:45:48 +0200289 snd_soc_dapm_debugfs_init(&codec->dapm, codec->debugfs_codec_root);
Mark Brown2624d5f2009-11-03 21:56:13 +0000290}
291
292static void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
293{
294 debugfs_remove_recursive(codec->debugfs_codec_root);
295}
296
Sebastien Guiriec731f1ab2012-02-15 15:25:31 +0000297static void soc_init_platform_debugfs(struct snd_soc_platform *platform)
298{
299 struct dentry *debugfs_card_root = platform->card->debugfs_card_root;
300
301 platform->debugfs_platform_root = debugfs_create_dir(platform->name,
302 debugfs_card_root);
303 if (!platform->debugfs_platform_root) {
304 dev_warn(platform->dev,
305 "Failed to create platform debugfs directory\n");
306 return;
307 }
308
309 snd_soc_dapm_debugfs_init(&platform->dapm,
310 platform->debugfs_platform_root);
311}
312
313static void soc_cleanup_platform_debugfs(struct snd_soc_platform *platform)
314{
315 debugfs_remove_recursive(platform->debugfs_platform_root);
316}
317
Mark Brownc3c5a192010-09-15 18:15:14 +0100318static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
319 size_t count, loff_t *ppos)
320{
321 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100322 ssize_t len, ret = 0;
Mark Brownc3c5a192010-09-15 18:15:14 +0100323 struct snd_soc_codec *codec;
324
325 if (!buf)
326 return -ENOMEM;
327
Mark Brown2b194f9d2010-10-13 10:52:16 +0100328 list_for_each_entry(codec, &codec_list, list) {
329 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
330 codec->name);
331 if (len >= 0)
332 ret += len;
333 if (ret > PAGE_SIZE) {
334 ret = PAGE_SIZE;
335 break;
336 }
337 }
Mark Brownc3c5a192010-09-15 18:15:14 +0100338
339 if (ret >= 0)
340 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
341
342 kfree(buf);
343
344 return ret;
345}
346
347static const struct file_operations codec_list_fops = {
348 .read = codec_list_read_file,
349 .llseek = default_llseek,/* read accesses f_pos */
350};
351
Mark Brownf3208782010-09-15 18:19:07 +0100352static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
353 size_t count, loff_t *ppos)
354{
355 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100356 ssize_t len, ret = 0;
Mark Brownf3208782010-09-15 18:19:07 +0100357 struct snd_soc_dai *dai;
358
359 if (!buf)
360 return -ENOMEM;
361
Mark Brown2b194f9d2010-10-13 10:52:16 +0100362 list_for_each_entry(dai, &dai_list, list) {
363 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n", dai->name);
364 if (len >= 0)
365 ret += len;
366 if (ret > PAGE_SIZE) {
367 ret = PAGE_SIZE;
368 break;
369 }
370 }
Mark Brownf3208782010-09-15 18:19:07 +0100371
Mark Brown2b194f9d2010-10-13 10:52:16 +0100372 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
Mark Brownf3208782010-09-15 18:19:07 +0100373
374 kfree(buf);
375
376 return ret;
377}
378
379static const struct file_operations dai_list_fops = {
380 .read = dai_list_read_file,
381 .llseek = default_llseek,/* read accesses f_pos */
382};
383
Mark Brown19c7ac22010-09-15 18:22:40 +0100384static ssize_t platform_list_read_file(struct file *file,
385 char __user *user_buf,
386 size_t count, loff_t *ppos)
387{
388 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100389 ssize_t len, ret = 0;
Mark Brown19c7ac22010-09-15 18:22:40 +0100390 struct snd_soc_platform *platform;
391
392 if (!buf)
393 return -ENOMEM;
394
Mark Brown2b194f9d2010-10-13 10:52:16 +0100395 list_for_each_entry(platform, &platform_list, list) {
396 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
397 platform->name);
398 if (len >= 0)
399 ret += len;
400 if (ret > PAGE_SIZE) {
401 ret = PAGE_SIZE;
402 break;
403 }
404 }
Mark Brown19c7ac22010-09-15 18:22:40 +0100405
Mark Brown2b194f9d2010-10-13 10:52:16 +0100406 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
Mark Brown19c7ac22010-09-15 18:22:40 +0100407
408 kfree(buf);
409
410 return ret;
411}
412
413static const struct file_operations platform_list_fops = {
414 .read = platform_list_read_file,
415 .llseek = default_llseek,/* read accesses f_pos */
416};
417
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200418static void soc_init_card_debugfs(struct snd_soc_card *card)
419{
420 card->debugfs_card_root = debugfs_create_dir(card->name,
Mark Brown8a9dab12011-01-10 22:25:21 +0000421 snd_soc_debugfs_root);
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200422 if (!card->debugfs_card_root) {
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200423 dev_warn(card->dev,
Lothar Waßmann7c08be82011-12-09 14:16:29 +0100424 "ASoC: Failed to create card debugfs directory\n");
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200425 return;
426 }
427
428 card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
429 card->debugfs_card_root,
430 &card->pop_time);
431 if (!card->debugfs_pop_time)
432 dev_warn(card->dev,
433 "Failed to create pop time debugfs file\n");
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200434}
435
436static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
437{
438 debugfs_remove_recursive(card->debugfs_card_root);
439}
440
Mark Brown2624d5f2009-11-03 21:56:13 +0000441#else
442
443static inline void soc_init_codec_debugfs(struct snd_soc_codec *codec)
444{
445}
446
447static inline void soc_cleanup_codec_debugfs(struct snd_soc_codec *codec)
448{
449}
Axel Linb95fccb2010-11-09 17:06:44 +0800450
Sebastien Guiriec731f1ab2012-02-15 15:25:31 +0000451static inline void soc_init_platform_debugfs(struct snd_soc_platform *platform)
452{
453}
454
455static inline void soc_cleanup_platform_debugfs(struct snd_soc_platform *platform)
456{
457}
458
Axel Linb95fccb2010-11-09 17:06:44 +0800459static inline void soc_init_card_debugfs(struct snd_soc_card *card)
460{
461}
462
463static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
464{
465}
Mark Brown2624d5f2009-11-03 21:56:13 +0000466#endif
467
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200468#ifdef CONFIG_SND_SOC_AC97_BUS
469/* unregister ac97 codec */
470static int soc_ac97_dev_unregister(struct snd_soc_codec *codec)
471{
472 if (codec->ac97->dev.bus)
473 device_unregister(&codec->ac97->dev);
474 return 0;
475}
476
477/* stop no dev release warning */
478static void soc_ac97_device_release(struct device *dev){}
479
480/* register ac97 codec to bus */
481static int soc_ac97_dev_register(struct snd_soc_codec *codec)
482{
483 int err;
484
485 codec->ac97->dev.bus = &ac97_bus_type;
Mark Brown4ac5c612009-04-01 19:35:01 +0100486 codec->ac97->dev.parent = codec->card->dev;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200487 codec->ac97->dev.release = soc_ac97_device_release;
488
Kay Sieversbb072bf2008-11-02 03:50:35 +0100489 dev_set_name(&codec->ac97->dev, "%d-%d:%s",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000490 codec->card->snd_card->number, 0, codec->name);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200491 err = device_register(&codec->ac97->dev);
492 if (err < 0) {
493 snd_printk(KERN_ERR "Can't register ac97 bus\n");
494 codec->ac97->dev.bus = NULL;
495 return err;
496 }
497 return 0;
498}
499#endif
500
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000501#ifdef CONFIG_PM_SLEEP
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200502/* powers down audio subsystem for suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000503int snd_soc_suspend(struct device *dev)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200504{
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000505 struct snd_soc_card *card = dev_get_drvdata(dev);
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200506 struct snd_soc_codec *codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200507 int i;
508
Daniel Macke3509ff2009-06-03 17:44:49 +0200509 /* If the initialization of this soc device failed, there is no codec
510 * associated with it. Just bail out in this case.
511 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000512 if (list_empty(&card->codec_dev_list))
Daniel Macke3509ff2009-06-03 17:44:49 +0200513 return 0;
514
Andy Green6ed25972008-06-13 16:24:05 +0100515 /* Due to the resume being scheduled into a workqueue we could
516 * suspend before that's finished - wait for it to complete.
517 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000518 snd_power_lock(card->snd_card);
519 snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
520 snd_power_unlock(card->snd_card);
Andy Green6ed25972008-06-13 16:24:05 +0100521
522 /* we're going to block userspace touching us until resume completes */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000523 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
Andy Green6ed25972008-06-13 16:24:05 +0100524
Mark Browna00f90f2010-12-02 16:24:24 +0000525 /* mute any active DACs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000526 for (i = 0; i < card->num_rtd; i++) {
527 struct snd_soc_dai *dai = card->rtd[i].codec_dai;
528 struct snd_soc_dai_driver *drv = dai->driver;
Mark Brown3efab7d2010-05-09 13:25:43 +0100529
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000530 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100531 continue;
532
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000533 if (drv->ops->digital_mute && dai->playback_active)
534 drv->ops->digital_mute(dai, 1);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200535 }
536
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100537 /* suspend all pcms */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000538 for (i = 0; i < card->num_rtd; i++) {
539 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100540 continue;
541
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000542 snd_pcm_suspend_all(card->rtd[i].pcm);
Mark Brown3efab7d2010-05-09 13:25:43 +0100543 }
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100544
Mark Brown87506542008-11-18 20:50:34 +0000545 if (card->suspend_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +0000546 card->suspend_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200547
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000548 for (i = 0; i < card->num_rtd; i++) {
549 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
550 struct snd_soc_platform *platform = card->rtd[i].platform;
Mark Brown3efab7d2010-05-09 13:25:43 +0100551
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000552 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100553 continue;
554
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000555 if (cpu_dai->driver->suspend && !cpu_dai->driver->ac97_control)
556 cpu_dai->driver->suspend(cpu_dai);
557 if (platform->driver->suspend && !platform->suspended) {
558 platform->driver->suspend(cpu_dai);
559 platform->suspended = 1;
Mark Brown1547aba2010-05-07 21:11:40 +0100560 }
561 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200562
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000563 /* close any waiting streams and save state */
564 for (i = 0; i < card->num_rtd; i++) {
Tejun Heo5b84ba22010-12-11 17:51:26 +0100565 flush_delayed_work_sync(&card->rtd[i].delayed_work);
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200566 card->rtd[i].codec->dapm.suspend_bias_level = card->rtd[i].codec->dapm.bias_level;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000567 }
Mark Brown3efab7d2010-05-09 13:25:43 +0100568
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000569 for (i = 0; i < card->num_rtd; i++) {
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800570 struct snd_soc_dai *codec_dai = card->rtd[i].codec_dai;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000571
572 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100573 continue;
574
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800575 snd_soc_dapm_stream_event(&card->rtd[i],
576 SNDRV_PCM_STREAM_PLAYBACK,
577 codec_dai,
578 SND_SOC_DAPM_STREAM_SUSPEND);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000579
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800580 snd_soc_dapm_stream_event(&card->rtd[i],
581 SNDRV_PCM_STREAM_CAPTURE,
582 codec_dai,
583 SND_SOC_DAPM_STREAM_SUSPEND);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000584 }
585
586 /* suspend all CODECs */
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200587 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000588 /* If there are paths active then the CODEC will be held with
589 * bias _ON and should not be suspended. */
590 if (!codec->suspended && codec->driver->suspend) {
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200591 switch (codec->dapm.bias_level) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000592 case SND_SOC_BIAS_STANDBY:
Mark Brown125a25d2012-01-31 15:49:10 +0000593 /*
594 * If the CODEC is capable of idle
595 * bias off then being in STANDBY
596 * means it's doing something,
597 * otherwise fall through.
598 */
599 if (codec->dapm.idle_bias_off) {
600 dev_dbg(codec->dev,
601 "idle_bias_off CODEC on over suspend\n");
602 break;
603 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000604 case SND_SOC_BIAS_OFF:
Lars-Peter Clausen84b315e2011-12-02 10:18:28 +0100605 codec->driver->suspend(codec);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000606 codec->suspended = 1;
Mark Brown7be4ba22011-07-18 13:17:13 +0900607 codec->cache_sync = 1;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000608 break;
609 default:
610 dev_dbg(codec->dev, "CODEC is on over suspend\n");
611 break;
612 }
613 }
614 }
615
616 for (i = 0; i < card->num_rtd; i++) {
617 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
618
619 if (card->rtd[i].dai_link->ignore_suspend)
620 continue;
621
622 if (cpu_dai->driver->suspend && cpu_dai->driver->ac97_control)
623 cpu_dai->driver->suspend(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200624 }
625
Mark Brown87506542008-11-18 20:50:34 +0000626 if (card->suspend_post)
Mark Brown70b2ac12011-01-26 14:05:25 +0000627 card->suspend_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200628
629 return 0;
630}
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000631EXPORT_SYMBOL_GPL(snd_soc_suspend);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200632
Andy Green6ed25972008-06-13 16:24:05 +0100633/* deferred resume work, so resume can complete before we finished
634 * setting our codec back up, which can be very slow on I2C
635 */
636static void soc_resume_deferred(struct work_struct *work)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200637{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000638 struct snd_soc_card *card =
639 container_of(work, struct snd_soc_card, deferred_resume_work);
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200640 struct snd_soc_codec *codec;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200641 int i;
642
Andy Green6ed25972008-06-13 16:24:05 +0100643 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
644 * so userspace apps are blocked from touching us
645 */
646
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000647 dev_dbg(card->dev, "starting resume work\n");
Andy Green6ed25972008-06-13 16:24:05 +0100648
Mark Brown99497882010-05-07 20:24:05 +0100649 /* Bring us up into D2 so that DAPM starts enabling things */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000650 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
Mark Brown99497882010-05-07 20:24:05 +0100651
Mark Brown87506542008-11-18 20:50:34 +0000652 if (card->resume_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +0000653 card->resume_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200654
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000655 /* resume AC97 DAIs */
656 for (i = 0; i < card->num_rtd; i++) {
657 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100658
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000659 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100660 continue;
661
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000662 if (cpu_dai->driver->resume && cpu_dai->driver->ac97_control)
663 cpu_dai->driver->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200664 }
665
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200666 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000667 /* If the CODEC was idle over suspend then it will have been
668 * left with bias OFF or STANDBY and suspended so we must now
669 * resume. Otherwise the suspend was suppressed.
670 */
671 if (codec->driver->resume && codec->suspended) {
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200672 switch (codec->dapm.bias_level) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000673 case SND_SOC_BIAS_STANDBY:
674 case SND_SOC_BIAS_OFF:
675 codec->driver->resume(codec);
676 codec->suspended = 0;
677 break;
678 default:
679 dev_dbg(codec->dev, "CODEC was on over suspend\n");
680 break;
681 }
Mark Brown1547aba2010-05-07 21:11:40 +0100682 }
683 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200684
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000685 for (i = 0; i < card->num_rtd; i++) {
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800686 struct snd_soc_dai *codec_dai = card->rtd[i].codec_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100687
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000688 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100689 continue;
690
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800691 snd_soc_dapm_stream_event(&card->rtd[i],
692 SNDRV_PCM_STREAM_PLAYBACK, codec_dai,
693 SND_SOC_DAPM_STREAM_RESUME);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000694
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800695 snd_soc_dapm_stream_event(&card->rtd[i],
696 SNDRV_PCM_STREAM_CAPTURE, codec_dai,
697 SND_SOC_DAPM_STREAM_RESUME);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200698 }
699
Mark Brown3ff3f642008-05-19 12:32:25 +0200700 /* unmute any active DACs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000701 for (i = 0; i < card->num_rtd; i++) {
702 struct snd_soc_dai *dai = card->rtd[i].codec_dai;
703 struct snd_soc_dai_driver *drv = dai->driver;
Mark Brown3efab7d2010-05-09 13:25:43 +0100704
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000705 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100706 continue;
707
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000708 if (drv->ops->digital_mute && dai->playback_active)
709 drv->ops->digital_mute(dai, 0);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200710 }
711
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000712 for (i = 0; i < card->num_rtd; i++) {
713 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
714 struct snd_soc_platform *platform = card->rtd[i].platform;
Mark Brown3efab7d2010-05-09 13:25:43 +0100715
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000716 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100717 continue;
718
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000719 if (cpu_dai->driver->resume && !cpu_dai->driver->ac97_control)
720 cpu_dai->driver->resume(cpu_dai);
721 if (platform->driver->resume && platform->suspended) {
722 platform->driver->resume(cpu_dai);
723 platform->suspended = 0;
724 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200725 }
726
Mark Brown87506542008-11-18 20:50:34 +0000727 if (card->resume_post)
Mark Brown70b2ac12011-01-26 14:05:25 +0000728 card->resume_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200729
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000730 dev_dbg(card->dev, "resume work completed\n");
Andy Green6ed25972008-06-13 16:24:05 +0100731
732 /* userspace can access us now we are back as we were before */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000733 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
Andy Green6ed25972008-06-13 16:24:05 +0100734}
735
736/* powers up audio subsystem after a suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000737int snd_soc_resume(struct device *dev)
Andy Green6ed25972008-06-13 16:24:05 +0100738{
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000739 struct snd_soc_card *card = dev_get_drvdata(dev);
Stephen Warren82e14e82011-05-25 14:06:41 -0600740 int i, ac97_control = 0;
Peter Ujfalusib9dd94a2010-02-22 13:27:13 +0200741
Eric Miao5ff1ddf2011-11-23 22:37:00 +0800742 /* If the initialization of this soc device failed, there is no codec
743 * associated with it. Just bail out in this case.
744 */
745 if (list_empty(&card->codec_dev_list))
746 return 0;
747
Mark Brown64ab9ba2009-03-31 11:27:03 +0100748 /* AC97 devices might have other drivers hanging off them so
749 * need to resume immediately. Other drivers don't have that
750 * problem and may take a substantial amount of time to resume
751 * due to I/O costs and anti-pop so handle them out of line.
752 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000753 for (i = 0; i < card->num_rtd; i++) {
754 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Stephen Warren82e14e82011-05-25 14:06:41 -0600755 ac97_control |= cpu_dai->driver->ac97_control;
756 }
757 if (ac97_control) {
758 dev_dbg(dev, "Resuming AC97 immediately\n");
759 soc_resume_deferred(&card->deferred_resume_work);
760 } else {
761 dev_dbg(dev, "Scheduling resume work\n");
762 if (!schedule_work(&card->deferred_resume_work))
763 dev_err(dev, "resume work item may be lost\n");
Mark Brown64ab9ba2009-03-31 11:27:03 +0100764 }
Andy Green6ed25972008-06-13 16:24:05 +0100765
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200766 return 0;
767}
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000768EXPORT_SYMBOL_GPL(snd_soc_resume);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200769#else
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000770#define snd_soc_suspend NULL
771#define snd_soc_resume NULL
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200772#endif
773
Lars-Peter Clausen85e76522011-11-23 11:40:40 +0100774static const struct snd_soc_dai_ops null_dai_ops = {
Barry Song02a06d32009-10-16 18:13:38 +0800775};
776
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000777static int soc_bind_dai_link(struct snd_soc_card *card, int num)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200778{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000779 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
780 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
Mark Brownfe3e78e2009-11-03 22:13:13 +0000781 struct snd_soc_codec *codec;
Mark Brown435c5e22008-12-04 15:32:53 +0000782 struct snd_soc_platform *platform;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000783 struct snd_soc_dai *codec_dai, *cpu_dai;
Mark Brown848dd8b2011-04-27 18:16:32 +0100784 const char *platform_name;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200785
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000786 if (rtd->complete)
787 return 1;
788 dev_dbg(card->dev, "binding %s at idx %d\n", dai_link->name, num);
Mark Brown63084192008-12-02 15:08:03 +0000789
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000790 /* do we already have the CPU DAI for this link ? */
791 if (rtd->cpu_dai) {
792 goto find_codec;
793 }
794 /* no, then find CPU DAI from registered DAIs*/
795 list_for_each_entry(cpu_dai, &dai_list, list) {
Stephen Warren5a504962011-12-21 10:40:59 -0700796 if (dai_link->cpu_dai_of_node) {
797 if (cpu_dai->dev->of_node != dai_link->cpu_dai_of_node)
798 continue;
799 } else {
800 if (strcmp(cpu_dai->name, dai_link->cpu_dai_name))
801 continue;
802 }
Stephen Warren2610ab72011-12-07 13:58:27 -0700803
804 rtd->cpu_dai = cpu_dai;
805 goto find_codec;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000806 }
807 dev_dbg(card->dev, "CPU DAI %s not registered\n",
808 dai_link->cpu_dai_name);
809
810find_codec:
811 /* do we already have the CODEC for this link ? */
812 if (rtd->codec) {
813 goto find_platform;
Mark Brownc5af3a22008-11-28 13:29:45 +0000814 }
815
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000816 /* no, then find CODEC from registered CODECs*/
817 list_for_each_entry(codec, &codec_list, list) {
Stephen Warren5a504962011-12-21 10:40:59 -0700818 if (dai_link->codec_of_node) {
819 if (codec->dev->of_node != dai_link->codec_of_node)
820 continue;
821 } else {
822 if (strcmp(codec->name, dai_link->codec_name))
823 continue;
824 }
Mark Brown6b05eda2008-12-08 19:26:48 +0000825
Stephen Warren2610ab72011-12-07 13:58:27 -0700826 rtd->codec = codec;
827
828 /*
829 * CODEC found, so find CODEC DAI from registered DAIs from
830 * this CODEC
831 */
832 list_for_each_entry(codec_dai, &dai_list, list) {
833 if (codec->dev == codec_dai->dev &&
834 !strcmp(codec_dai->name,
835 dai_link->codec_dai_name)) {
836
837 rtd->codec_dai = codec_dai;
838 goto find_platform;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000839 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000840 }
Stephen Warren2610ab72011-12-07 13:58:27 -0700841 dev_dbg(card->dev, "CODEC DAI %s not registered\n",
842 dai_link->codec_dai_name);
843
844 goto find_platform;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000845 }
846 dev_dbg(card->dev, "CODEC %s not registered\n",
847 dai_link->codec_name);
848
849find_platform:
Mark Brown848dd8b2011-04-27 18:16:32 +0100850 /* do we need a platform? */
851 if (rtd->platform)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000852 goto out;
Mark Brown848dd8b2011-04-27 18:16:32 +0100853
854 /* if there's no platform we match on the empty platform */
855 platform_name = dai_link->platform_name;
Stephen Warren5a504962011-12-21 10:40:59 -0700856 if (!platform_name && !dai_link->platform_of_node)
Mark Brown848dd8b2011-04-27 18:16:32 +0100857 platform_name = "snd-soc-dummy";
858
859 /* no, then find one from the set of registered platforms */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000860 list_for_each_entry(platform, &platform_list, list) {
Stephen Warren5a504962011-12-21 10:40:59 -0700861 if (dai_link->platform_of_node) {
862 if (platform->dev->of_node !=
863 dai_link->platform_of_node)
864 continue;
865 } else {
866 if (strcmp(platform->name, platform_name))
867 continue;
868 }
Stephen Warren2610ab72011-12-07 13:58:27 -0700869
870 rtd->platform = platform;
871 goto out;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000872 }
873
874 dev_dbg(card->dev, "platform %s not registered\n",
875 dai_link->platform_name);
876 return 0;
877
878out:
879 /* mark rtd as complete if we found all 4 of our client devices */
880 if (rtd->codec && rtd->codec_dai && rtd->platform && rtd->cpu_dai) {
881 rtd->complete = 1;
882 card->num_rtd++;
883 }
884 return 1;
885}
886
Jarkko Nikula589c3562010-12-06 16:27:07 +0200887static void soc_remove_codec(struct snd_soc_codec *codec)
888{
889 int err;
890
891 if (codec->driver->remove) {
892 err = codec->driver->remove(codec);
893 if (err < 0)
894 dev_err(codec->dev,
895 "asoc: failed to remove %s: %d\n",
896 codec->name, err);
897 }
898
899 /* Make sure all DAPM widgets are freed */
900 snd_soc_dapm_free(&codec->dapm);
901
902 soc_cleanup_codec_debugfs(codec);
903 codec->probed = 0;
904 list_del(&codec->card_list);
905 module_put(codec->dev->driver->owner);
906}
907
Liam Girdwood0168bf02011-06-07 16:08:05 +0100908static void soc_remove_dai_link(struct snd_soc_card *card, int num, int order)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000909{
910 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
911 struct snd_soc_codec *codec = rtd->codec;
912 struct snd_soc_platform *platform = rtd->platform;
913 struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
914 int err;
915
916 /* unregister the rtd device */
917 if (rtd->dev_registered) {
Mark Brown36ae1a92012-01-06 17:12:45 -0800918 device_remove_file(rtd->dev, &dev_attr_pmdown_time);
919 device_remove_file(rtd->dev, &dev_attr_codec_reg);
920 device_unregister(rtd->dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000921 rtd->dev_registered = 0;
922 }
923
924 /* remove the CODEC DAI */
Liam Girdwood0168bf02011-06-07 16:08:05 +0100925 if (codec_dai && codec_dai->probed &&
926 codec_dai->driver->remove_order == order) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000927 if (codec_dai->driver->remove) {
928 err = codec_dai->driver->remove(codec_dai);
929 if (err < 0)
Fabio Estevam0837fc62012-02-17 19:40:38 -0200930 pr_err("asoc: failed to remove %s: %d\n",
931 codec_dai->name, err);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000932 }
933 codec_dai->probed = 0;
934 list_del(&codec_dai->card_list);
935 }
936
937 /* remove the platform */
Liam Girdwood0168bf02011-06-07 16:08:05 +0100938 if (platform && platform->probed &&
939 platform->driver->remove_order == order) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000940 if (platform->driver->remove) {
941 err = platform->driver->remove(platform);
942 if (err < 0)
Fabio Estevam0837fc62012-02-17 19:40:38 -0200943 pr_err("asoc: failed to remove %s: %d\n",
944 platform->name, err);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000945 }
Liam Girdwood675c4962012-01-16 15:25:37 +0000946
947 /* Make sure all DAPM widgets are freed */
948 snd_soc_dapm_free(&platform->dapm);
949
Sebastien Guiriec731f1ab2012-02-15 15:25:31 +0000950 soc_cleanup_platform_debugfs(platform);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000951 platform->probed = 0;
952 list_del(&platform->card_list);
953 module_put(platform->dev->driver->owner);
954 }
955
956 /* remove the CODEC */
Liam Girdwood0168bf02011-06-07 16:08:05 +0100957 if (codec && codec->probed &&
958 codec->driver->remove_order == order)
Jarkko Nikula589c3562010-12-06 16:27:07 +0200959 soc_remove_codec(codec);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000960
961 /* remove the cpu_dai */
Liam Girdwood0168bf02011-06-07 16:08:05 +0100962 if (cpu_dai && cpu_dai->probed &&
963 cpu_dai->driver->remove_order == order) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000964 if (cpu_dai->driver->remove) {
965 err = cpu_dai->driver->remove(cpu_dai);
966 if (err < 0)
Fabio Estevam0837fc62012-02-17 19:40:38 -0200967 pr_err("asoc: failed to remove %s: %d\n",
968 cpu_dai->name, err);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000969 }
970 cpu_dai->probed = 0;
971 list_del(&cpu_dai->card_list);
972 module_put(cpu_dai->dev->driver->owner);
973 }
974}
975
Kuninori Morimoto0671fd82011-04-08 14:50:44 +0900976static void soc_remove_dai_links(struct snd_soc_card *card)
977{
Liam Girdwood0168bf02011-06-07 16:08:05 +0100978 int dai, order;
Kuninori Morimoto0671fd82011-04-08 14:50:44 +0900979
Liam Girdwood0168bf02011-06-07 16:08:05 +0100980 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
981 order++) {
982 for (dai = 0; dai < card->num_rtd; dai++)
983 soc_remove_dai_link(card, dai, order);
984 }
Kuninori Morimoto0671fd82011-04-08 14:50:44 +0900985 card->num_rtd = 0;
986}
987
Jarkko Nikulaead9b912010-11-13 20:40:44 +0200988static void soc_set_name_prefix(struct snd_soc_card *card,
989 struct snd_soc_codec *codec)
990{
991 int i;
992
Dimitris Papastamosff819b82010-12-02 14:53:03 +0000993 if (card->codec_conf == NULL)
Jarkko Nikulaead9b912010-11-13 20:40:44 +0200994 return;
995
Dimitris Papastamosff819b82010-12-02 14:53:03 +0000996 for (i = 0; i < card->num_configs; i++) {
997 struct snd_soc_codec_conf *map = &card->codec_conf[i];
Jarkko Nikulaead9b912010-11-13 20:40:44 +0200998 if (map->dev_name && !strcmp(codec->name, map->dev_name)) {
999 codec->name_prefix = map->name_prefix;
1000 break;
1001 }
1002 }
1003}
1004
Jarkko Nikula589c3562010-12-06 16:27:07 +02001005static int soc_probe_codec(struct snd_soc_card *card,
1006 struct snd_soc_codec *codec)
1007{
1008 int ret = 0;
Mark Brown89b95ac02011-03-07 16:38:44 +00001009 const struct snd_soc_codec_driver *driver = codec->driver;
Mark Brown888df392012-02-16 19:37:51 -08001010 struct snd_soc_dai *dai;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001011
1012 codec->card = card;
1013 codec->dapm.card = card;
1014 soc_set_name_prefix(card, codec);
1015
Jarkko Nikula70d29332011-01-27 16:24:22 +02001016 if (!try_module_get(codec->dev->driver->owner))
1017 return -ENODEV;
1018
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001019 soc_init_codec_debugfs(codec);
1020
Lars-Peter Clausen77530152011-05-05 16:59:09 +02001021 if (driver->dapm_widgets)
1022 snd_soc_dapm_new_controls(&codec->dapm, driver->dapm_widgets,
1023 driver->num_dapm_widgets);
1024
Mark Brown888df392012-02-16 19:37:51 -08001025 /* Create DAPM widgets for each DAI stream */
1026 list_for_each_entry(dai, &dai_list, list) {
1027 if (dai->dev != codec->dev)
1028 continue;
1029
1030 snd_soc_dapm_new_dai_widgets(&codec->dapm, dai);
1031 }
1032
Mark Brown33c5f962011-08-22 18:40:30 +01001033 codec->dapm.idle_bias_off = driver->idle_bias_off;
1034
Mark Brown89b95ac02011-03-07 16:38:44 +00001035 if (driver->probe) {
1036 ret = driver->probe(codec);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001037 if (ret < 0) {
1038 dev_err(codec->dev,
1039 "asoc: failed to probe CODEC %s: %d\n",
1040 codec->name, ret);
Jarkko Nikula70d29332011-01-27 16:24:22 +02001041 goto err_probe;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001042 }
1043 }
1044
Mark Brownb7af1da2011-04-07 19:18:44 +09001045 if (driver->controls)
Liam Girdwood022658b2012-02-03 17:43:09 +00001046 snd_soc_add_codec_controls(codec, driver->controls,
Mark Brownb7af1da2011-04-07 19:18:44 +09001047 driver->num_controls);
Mark Brown89b95ac02011-03-07 16:38:44 +00001048 if (driver->dapm_routes)
1049 snd_soc_dapm_add_routes(&codec->dapm, driver->dapm_routes,
1050 driver->num_dapm_routes);
1051
Jarkko Nikula589c3562010-12-06 16:27:07 +02001052 /* mark codec as probed and add to card codec list */
1053 codec->probed = 1;
1054 list_add(&codec->card_list, &card->codec_dev_list);
Jarkko Nikula7be31be82010-12-14 12:18:32 +02001055 list_add(&codec->dapm.list, &card->dapm_list);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001056
Jarkko Nikula70d29332011-01-27 16:24:22 +02001057 return 0;
1058
1059err_probe:
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001060 soc_cleanup_codec_debugfs(codec);
Jarkko Nikula70d29332011-01-27 16:24:22 +02001061 module_put(codec->dev->driver->owner);
1062
Jarkko Nikula589c3562010-12-06 16:27:07 +02001063 return ret;
1064}
1065
Liam Girdwood956245e2011-07-01 16:54:08 +01001066static int soc_probe_platform(struct snd_soc_card *card,
1067 struct snd_soc_platform *platform)
1068{
1069 int ret = 0;
1070 const struct snd_soc_platform_driver *driver = platform->driver;
1071
1072 platform->card = card;
Liam Girdwoodb7950642011-07-04 22:10:52 +01001073 platform->dapm.card = card;
Liam Girdwood956245e2011-07-01 16:54:08 +01001074
1075 if (!try_module_get(platform->dev->driver->owner))
1076 return -ENODEV;
1077
Sebastien Guiriec731f1ab2012-02-15 15:25:31 +00001078 soc_init_platform_debugfs(platform);
1079
Liam Girdwoodcb2cf612011-07-04 22:10:53 +01001080 if (driver->dapm_widgets)
1081 snd_soc_dapm_new_controls(&platform->dapm,
1082 driver->dapm_widgets, driver->num_dapm_widgets);
1083
Stephen Warren3fec6b62012-04-05 12:28:01 -06001084 platform->dapm.idle_bias_off = 1;
1085
Liam Girdwood956245e2011-07-01 16:54:08 +01001086 if (driver->probe) {
1087 ret = driver->probe(platform);
1088 if (ret < 0) {
1089 dev_err(platform->dev,
1090 "asoc: failed to probe platform %s: %d\n",
1091 platform->name, ret);
1092 goto err_probe;
1093 }
1094 }
1095
Liam Girdwoodcb2cf612011-07-04 22:10:53 +01001096 if (driver->controls)
1097 snd_soc_add_platform_controls(platform, driver->controls,
1098 driver->num_controls);
1099 if (driver->dapm_routes)
1100 snd_soc_dapm_add_routes(&platform->dapm, driver->dapm_routes,
1101 driver->num_dapm_routes);
1102
Liam Girdwood956245e2011-07-01 16:54:08 +01001103 /* mark platform as probed and add to card platform list */
1104 platform->probed = 1;
1105 list_add(&platform->card_list, &card->platform_dev_list);
Liam Girdwoodb7950642011-07-04 22:10:52 +01001106 list_add(&platform->dapm.list, &card->dapm_list);
Liam Girdwood956245e2011-07-01 16:54:08 +01001107
1108 return 0;
1109
1110err_probe:
Liam Girdwood02db1102012-03-02 16:13:44 +00001111 soc_cleanup_platform_debugfs(platform);
Liam Girdwood956245e2011-07-01 16:54:08 +01001112 module_put(platform->dev->driver->owner);
1113
1114 return ret;
1115}
1116
Mark Brown36ae1a92012-01-06 17:12:45 -08001117static void rtd_release(struct device *dev)
1118{
1119 kfree(dev);
1120}
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001121
Jarkko Nikula589c3562010-12-06 16:27:07 +02001122static int soc_post_component_init(struct snd_soc_card *card,
1123 struct snd_soc_codec *codec,
1124 int num, int dailess)
1125{
1126 struct snd_soc_dai_link *dai_link = NULL;
1127 struct snd_soc_aux_dev *aux_dev = NULL;
1128 struct snd_soc_pcm_runtime *rtd;
1129 const char *temp, *name;
1130 int ret = 0;
1131
1132 if (!dailess) {
1133 dai_link = &card->dai_link[num];
1134 rtd = &card->rtd[num];
1135 name = dai_link->name;
1136 } else {
1137 aux_dev = &card->aux_dev[num];
1138 rtd = &card->rtd_aux[num];
1139 name = aux_dev->name;
1140 }
Janusz Krzysztofik0962bb22011-02-02 21:11:41 +01001141 rtd->card = card;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001142
Mark Brown4b1cfcb2011-10-18 00:11:49 +01001143 /* Make sure all DAPM widgets are instantiated */
1144 snd_soc_dapm_new_widgets(&codec->dapm);
1145
Jarkko Nikula589c3562010-12-06 16:27:07 +02001146 /* machine controls, routes and widgets are not prefixed */
1147 temp = codec->name_prefix;
1148 codec->name_prefix = NULL;
1149
1150 /* do machine specific initialization */
1151 if (!dailess && dai_link->init)
1152 ret = dai_link->init(rtd);
1153 else if (dailess && aux_dev->init)
1154 ret = aux_dev->init(&codec->dapm);
1155 if (ret < 0) {
1156 dev_err(card->dev, "asoc: failed to init %s: %d\n", name, ret);
1157 return ret;
1158 }
1159 codec->name_prefix = temp;
1160
Jarkko Nikula589c3562010-12-06 16:27:07 +02001161 /* register the rtd device */
1162 rtd->codec = codec;
Mark Brown36ae1a92012-01-06 17:12:45 -08001163
1164 rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1165 if (!rtd->dev)
1166 return -ENOMEM;
1167 device_initialize(rtd->dev);
1168 rtd->dev->parent = card->dev;
1169 rtd->dev->release = rtd_release;
1170 rtd->dev->init_name = name;
1171 dev_set_drvdata(rtd->dev, rtd);
Liam Girdwoodb8c0dab2011-06-09 17:04:39 +01001172 mutex_init(&rtd->pcm_mutex);
Mark Brown36ae1a92012-01-06 17:12:45 -08001173 ret = device_add(rtd->dev);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001174 if (ret < 0) {
1175 dev_err(card->dev,
1176 "asoc: failed to register runtime device: %d\n", ret);
1177 return ret;
1178 }
1179 rtd->dev_registered = 1;
1180
1181 /* add DAPM sysfs entries for this codec */
Mark Brown36ae1a92012-01-06 17:12:45 -08001182 ret = snd_soc_dapm_sys_add(rtd->dev);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001183 if (ret < 0)
1184 dev_err(codec->dev,
1185 "asoc: failed to add codec dapm sysfs entries: %d\n",
1186 ret);
1187
1188 /* add codec sysfs entries */
Mark Brown36ae1a92012-01-06 17:12:45 -08001189 ret = device_create_file(rtd->dev, &dev_attr_codec_reg);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001190 if (ret < 0)
1191 dev_err(codec->dev,
1192 "asoc: failed to add codec sysfs files: %d\n", ret);
1193
1194 return 0;
1195}
1196
Liam Girdwood0168bf02011-06-07 16:08:05 +01001197static int soc_probe_dai_link(struct snd_soc_card *card, int num, int order)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001198{
1199 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
1200 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1201 struct snd_soc_codec *codec = rtd->codec;
1202 struct snd_soc_platform *platform = rtd->platform;
1203 struct snd_soc_dai *codec_dai = rtd->codec_dai, *cpu_dai = rtd->cpu_dai;
1204 int ret;
1205
Liam Girdwood0168bf02011-06-07 16:08:05 +01001206 dev_dbg(card->dev, "probe %s dai link %d late %d\n",
1207 card->name, num, order);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001208
1209 /* config components */
1210 codec_dai->codec = codec;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001211 cpu_dai->platform = platform;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001212 codec_dai->card = card;
1213 cpu_dai->card = card;
1214
1215 /* set default power off timeout */
1216 rtd->pmdown_time = pmdown_time;
1217
1218 /* probe the cpu_dai */
Liam Girdwood0168bf02011-06-07 16:08:05 +01001219 if (!cpu_dai->probed &&
1220 cpu_dai->driver->probe_order == order) {
Liam Girdwood61b61e32011-05-24 13:57:43 +01001221 if (!try_module_get(cpu_dai->dev->driver->owner))
1222 return -ENODEV;
1223
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001224 if (cpu_dai->driver->probe) {
1225 ret = cpu_dai->driver->probe(cpu_dai);
1226 if (ret < 0) {
Fabio Estevam0837fc62012-02-17 19:40:38 -02001227 pr_err("asoc: failed to probe CPU DAI %s: %d\n",
1228 cpu_dai->name, ret);
Liam Girdwood61b61e32011-05-24 13:57:43 +01001229 module_put(cpu_dai->dev->driver->owner);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001230 return ret;
1231 }
1232 }
1233 cpu_dai->probed = 1;
Wolfram Sang1c8371d2011-07-17 18:00:26 +02001234 /* mark cpu_dai as probed and add to card dai list */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001235 list_add(&cpu_dai->card_list, &card->dai_dev_list);
1236 }
1237
1238 /* probe the CODEC */
Liam Girdwood0168bf02011-06-07 16:08:05 +01001239 if (!codec->probed &&
1240 codec->driver->probe_order == order) {
Jarkko Nikula589c3562010-12-06 16:27:07 +02001241 ret = soc_probe_codec(card, codec);
1242 if (ret < 0)
1243 return ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001244 }
1245
1246 /* probe the platform */
Liam Girdwood0168bf02011-06-07 16:08:05 +01001247 if (!platform->probed &&
1248 platform->driver->probe_order == order) {
Liam Girdwood956245e2011-07-01 16:54:08 +01001249 ret = soc_probe_platform(card, platform);
1250 if (ret < 0)
1251 return ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001252 }
1253
1254 /* probe the CODEC DAI */
Liam Girdwood0168bf02011-06-07 16:08:05 +01001255 if (!codec_dai->probed && codec_dai->driver->probe_order == order) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001256 if (codec_dai->driver->probe) {
1257 ret = codec_dai->driver->probe(codec_dai);
1258 if (ret < 0) {
Fabio Estevam0837fc62012-02-17 19:40:38 -02001259 pr_err("asoc: failed to probe CODEC DAI %s: %d\n",
1260 codec_dai->name, ret);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001261 return ret;
Mark Brown6b05eda2008-12-08 19:26:48 +00001262 }
1263 }
1264
Wolfram Sang1c8371d2011-07-17 18:00:26 +02001265 /* mark codec_dai as probed and add to card dai list */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001266 codec_dai->probed = 1;
1267 list_add(&codec_dai->card_list, &card->dai_dev_list);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001268 }
1269
Liam Girdwood0168bf02011-06-07 16:08:05 +01001270 /* complete DAI probe during last probe */
1271 if (order != SND_SOC_COMP_ORDER_LAST)
1272 return 0;
1273
Jarkko Nikula589c3562010-12-06 16:27:07 +02001274 ret = soc_post_component_init(card, codec, num, 0);
1275 if (ret)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001276 return ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001277
Mark Brown36ae1a92012-01-06 17:12:45 -08001278 ret = device_create_file(rtd->dev, &dev_attr_pmdown_time);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001279 if (ret < 0)
Fabio Estevam0837fc62012-02-17 19:40:38 -02001280 pr_warn("asoc: failed to add pmdown_time sysfs:%d\n", ret);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001281
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001282 /* create the pcm */
1283 ret = soc_new_pcm(rtd, num);
1284 if (ret < 0) {
Fabio Estevam0837fc62012-02-17 19:40:38 -02001285 pr_err("asoc: can't create pcm %s :%d\n",
1286 dai_link->stream_name, ret);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001287 return ret;
1288 }
1289
1290 /* add platform data for AC97 devices */
1291 if (rtd->codec_dai->driver->ac97_control)
1292 snd_ac97_dev_add_pdata(codec->ac97, rtd->cpu_dai->ac97_pdata);
1293
1294 return 0;
1295}
1296
1297#ifdef CONFIG_SND_SOC_AC97_BUS
1298static int soc_register_ac97_dai_link(struct snd_soc_pcm_runtime *rtd)
1299{
1300 int ret;
1301
1302 /* Only instantiate AC97 if not already done by the adaptor
1303 * for the generic AC97 subsystem.
1304 */
1305 if (rtd->codec_dai->driver->ac97_control && !rtd->codec->ac97_registered) {
Mika Westerberg0562f782010-10-13 11:30:32 +03001306 /*
1307 * It is possible that the AC97 device is already registered to
1308 * the device subsystem. This happens when the device is created
1309 * via snd_ac97_mixer(). Currently only SoC codec that does so
1310 * is the generic AC97 glue but others migh emerge.
1311 *
1312 * In those cases we don't try to register the device again.
1313 */
1314 if (!rtd->codec->ac97_created)
1315 return 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001316
1317 ret = soc_ac97_dev_register(rtd->codec);
1318 if (ret < 0) {
Fabio Estevam0837fc62012-02-17 19:40:38 -02001319 pr_err("asoc: AC97 device register failed:%d\n", ret);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001320 return ret;
1321 }
1322
1323 rtd->codec->ac97_registered = 1;
1324 }
1325 return 0;
1326}
1327
1328static void soc_unregister_ac97_dai_link(struct snd_soc_codec *codec)
1329{
1330 if (codec->ac97_registered) {
1331 soc_ac97_dev_unregister(codec);
1332 codec->ac97_registered = 0;
1333 }
1334}
1335#endif
1336
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001337static int soc_probe_aux_dev(struct snd_soc_card *card, int num)
1338{
1339 struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001340 struct snd_soc_codec *codec;
Jarkko Nikula676ad982010-12-03 09:18:22 +02001341 int ret = -ENODEV;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001342
1343 /* find CODEC from registered CODECs*/
1344 list_for_each_entry(codec, &codec_list, list) {
1345 if (!strcmp(codec->name, aux_dev->codec_name)) {
1346 if (codec->probed) {
1347 dev_err(codec->dev,
1348 "asoc: codec already probed");
1349 ret = -EBUSY;
1350 goto out;
1351 }
Jarkko Nikula676ad982010-12-03 09:18:22 +02001352 goto found;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001353 }
1354 }
Jarkko Nikula676ad982010-12-03 09:18:22 +02001355 /* codec not found */
1356 dev_err(card->dev, "asoc: codec %s not found", aux_dev->codec_name);
1357 goto out;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001358
Jarkko Nikula676ad982010-12-03 09:18:22 +02001359found:
Jarkko Nikula589c3562010-12-06 16:27:07 +02001360 ret = soc_probe_codec(card, codec);
1361 if (ret < 0)
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001362 return ret;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001363
Jarkko Nikula589c3562010-12-06 16:27:07 +02001364 ret = soc_post_component_init(card, codec, num, 1);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001365
1366out:
1367 return ret;
1368}
1369
1370static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
1371{
1372 struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
1373 struct snd_soc_codec *codec = rtd->codec;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001374
1375 /* unregister the rtd device */
1376 if (rtd->dev_registered) {
Mark Brown36ae1a92012-01-06 17:12:45 -08001377 device_remove_file(rtd->dev, &dev_attr_codec_reg);
1378 device_del(rtd->dev);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001379 rtd->dev_registered = 0;
1380 }
1381
Jarkko Nikula589c3562010-12-06 16:27:07 +02001382 if (codec && codec->probed)
1383 soc_remove_codec(codec);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001384}
1385
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001386static int snd_soc_init_codec_cache(struct snd_soc_codec *codec,
1387 enum snd_soc_compress_type compress_type)
1388{
1389 int ret;
1390
1391 if (codec->cache_init)
1392 return 0;
1393
1394 /* override the compress_type if necessary */
1395 if (compress_type && codec->compress_type != compress_type)
1396 codec->compress_type = compress_type;
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001397 ret = snd_soc_cache_init(codec);
1398 if (ret < 0) {
1399 dev_err(codec->dev, "Failed to set cache compression type: %d\n",
1400 ret);
1401 return ret;
1402 }
1403 codec->cache_init = 1;
1404 return 0;
1405}
1406
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001407static void snd_soc_instantiate_card(struct snd_soc_card *card)
1408{
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001409 struct snd_soc_codec *codec;
1410 struct snd_soc_codec_conf *codec_conf;
1411 enum snd_soc_compress_type compress_type;
Mark Brown75d9ac42011-09-27 16:41:01 +01001412 struct snd_soc_dai_link *dai_link;
Liam Girdwood0168bf02011-06-07 16:08:05 +01001413 int ret, i, order;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001414
1415 mutex_lock(&card->mutex);
1416
1417 if (card->instantiated) {
1418 mutex_unlock(&card->mutex);
1419 return;
1420 }
1421
1422 /* bind DAIs */
1423 for (i = 0; i < card->num_links; i++)
1424 soc_bind_dai_link(card, i);
1425
1426 /* bind completed ? */
1427 if (card->num_rtd != card->num_links) {
1428 mutex_unlock(&card->mutex);
1429 return;
1430 }
1431
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001432 /* initialize the register cache for each available codec */
1433 list_for_each_entry(codec, &codec_list, list) {
1434 if (codec->cache_init)
1435 continue;
Dimitris Papastamos861f2fa2011-01-11 11:43:51 +00001436 /* by default we don't override the compress_type */
1437 compress_type = 0;
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001438 /* check to see if we need to override the compress_type */
1439 for (i = 0; i < card->num_configs; ++i) {
1440 codec_conf = &card->codec_conf[i];
1441 if (!strcmp(codec->name, codec_conf->dev_name)) {
1442 compress_type = codec_conf->compress_type;
1443 if (compress_type && compress_type
1444 != codec->compress_type)
1445 break;
1446 }
1447 }
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001448 ret = snd_soc_init_codec_cache(codec, compress_type);
1449 if (ret < 0) {
1450 mutex_unlock(&card->mutex);
1451 return;
1452 }
1453 }
1454
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001455 /* card bind complete so register a sound card */
1456 ret = snd_card_create(SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
1457 card->owner, 0, &card->snd_card);
1458 if (ret < 0) {
Fabio Estevam0837fc62012-02-17 19:40:38 -02001459 pr_err("asoc: can't create sound card for card %s: %d\n",
1460 card->name, ret);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001461 mutex_unlock(&card->mutex);
1462 return;
1463 }
1464 card->snd_card->dev = card->dev;
1465
Mark Browne37a4972011-03-02 18:21:57 +00001466 card->dapm.bias_level = SND_SOC_BIAS_OFF;
1467 card->dapm.dev = card->dev;
1468 card->dapm.card = card;
1469 list_add(&card->dapm.list, &card->dapm_list);
1470
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001471#ifdef CONFIG_DEBUG_FS
1472 snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
1473#endif
1474
Mark Brown88ee1c62011-02-02 10:43:26 +00001475#ifdef CONFIG_PM_SLEEP
Andy Green6ed25972008-06-13 16:24:05 +01001476 /* deferred resume work */
Mark Brown63084192008-12-02 15:08:03 +00001477 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
Randy Dunlap1301a962008-06-17 19:19:34 +01001478#endif
Andy Green6ed25972008-06-13 16:24:05 +01001479
Mark Brown9a841eb2011-04-12 17:51:37 -07001480 if (card->dapm_widgets)
1481 snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
1482 card->num_dapm_widgets);
1483
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001484 /* initialise the sound card only once */
1485 if (card->probe) {
Mark Browne7361ec2011-01-26 14:17:20 +00001486 ret = card->probe(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001487 if (ret < 0)
1488 goto card_probe_error;
1489 }
1490
Liam Girdwood0168bf02011-06-07 16:08:05 +01001491 /* early DAI link probe */
1492 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1493 order++) {
1494 for (i = 0; i < card->num_links; i++) {
1495 ret = soc_probe_dai_link(card, i, order);
1496 if (ret < 0) {
1497 pr_err("asoc: failed to instantiate card %s: %d\n",
Mark Brown321de0d2010-09-21 15:09:37 +01001498 card->name, ret);
Liam Girdwood0168bf02011-06-07 16:08:05 +01001499 goto probe_dai_err;
1500 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001501 }
1502 }
1503
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001504 for (i = 0; i < card->num_aux_devs; i++) {
1505 ret = soc_probe_aux_dev(card, i);
1506 if (ret < 0) {
1507 pr_err("asoc: failed to add auxiliary devices %s: %d\n",
1508 card->name, ret);
1509 goto probe_aux_dev_err;
1510 }
1511 }
1512
Mark Brown888df392012-02-16 19:37:51 -08001513 snd_soc_dapm_link_dai_widgets(card);
1514
Mark Brownb7af1da2011-04-07 19:18:44 +09001515 if (card->controls)
Liam Girdwood022658b2012-02-03 17:43:09 +00001516 snd_soc_add_card_controls(card, card->controls, card->num_controls);
Mark Brownb7af1da2011-04-07 19:18:44 +09001517
Mark Brownb8ad29d2011-03-02 18:35:51 +00001518 if (card->dapm_routes)
1519 snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
1520 card->num_dapm_routes);
1521
Mark Brownb90d2f92011-10-10 13:38:06 +01001522 snd_soc_dapm_new_widgets(&card->dapm);
1523
Mark Brown75d9ac42011-09-27 16:41:01 +01001524 for (i = 0; i < card->num_links; i++) {
1525 dai_link = &card->dai_link[i];
1526
1527 if (dai_link->dai_fmt) {
1528 ret = snd_soc_dai_set_fmt(card->rtd[i].codec_dai,
1529 dai_link->dai_fmt);
Shawn Guo5e4ba562012-03-09 00:59:40 +08001530 if (ret != 0 && ret != -ENOTSUPP)
Mark Brown75d9ac42011-09-27 16:41:01 +01001531 dev_warn(card->rtd[i].codec_dai->dev,
1532 "Failed to set DAI format: %d\n",
1533 ret);
1534
1535 ret = snd_soc_dai_set_fmt(card->rtd[i].cpu_dai,
1536 dai_link->dai_fmt);
Shawn Guo5e4ba562012-03-09 00:59:40 +08001537 if (ret != 0 && ret != -ENOTSUPP)
Mark Brown75d9ac42011-09-27 16:41:01 +01001538 dev_warn(card->rtd[i].cpu_dai->dev,
1539 "Failed to set DAI format: %d\n",
1540 ret);
1541 }
1542 }
1543
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001544 snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001545 "%s", card->name);
Liam Girdwood22de71b2011-05-12 16:14:04 +01001546 snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
1547 "%s", card->long_name ? card->long_name : card->name);
Mark Brownf0e8ed82011-09-20 11:41:54 +01001548 snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
1549 "%s", card->driver_name ? card->driver_name : card->name);
1550 for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
1551 switch (card->snd_card->driver[i]) {
1552 case '_':
1553 case '-':
1554 case '\0':
1555 break;
1556 default:
1557 if (!isalnum(card->snd_card->driver[i]))
1558 card->snd_card->driver[i] = '_';
1559 break;
1560 }
1561 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001562
Mark Brown28e9ad92011-03-02 18:36:34 +00001563 if (card->late_probe) {
1564 ret = card->late_probe(card);
1565 if (ret < 0) {
1566 dev_err(card->dev, "%s late_probe() failed: %d\n",
1567 card->name, ret);
1568 goto probe_aux_dev_err;
1569 }
1570 }
1571
Mark Brown2dc00212011-10-08 13:59:44 +01001572 snd_soc_dapm_new_widgets(&card->dapm);
1573
Stephen Warren16332812011-11-23 12:42:04 -07001574 if (card->fully_routed)
Mark Brownb05d8dc2011-11-27 19:38:34 +00001575 list_for_each_entry(codec, &card->codec_dev_list, card_list)
Stephen Warren16332812011-11-23 12:42:04 -07001576 snd_soc_dapm_auto_nc_codec_pins(codec);
1577
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001578 ret = snd_card_register(card->snd_card);
1579 if (ret < 0) {
Fabio Estevam0837fc62012-02-17 19:40:38 -02001580 pr_err("asoc: failed to register soundcard for %s: %d\n",
1581 card->name, ret);
Axel Lin6b3ed782010-12-07 16:12:29 +08001582 goto probe_aux_dev_err;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001583 }
1584
1585#ifdef CONFIG_SND_SOC_AC97_BUS
1586 /* register any AC97 codecs */
1587 for (i = 0; i < card->num_rtd; i++) {
Axel Lin6b3ed782010-12-07 16:12:29 +08001588 ret = soc_register_ac97_dai_link(&card->rtd[i]);
1589 if (ret < 0) {
Fabio Estevam0837fc62012-02-17 19:40:38 -02001590 pr_err("asoc: failed to register AC97 %s: %d\n",
1591 card->name, ret);
Axel Lin6b3ed782010-12-07 16:12:29 +08001592 while (--i >= 0)
Mark Brown7d8316d2010-12-13 17:03:27 +00001593 soc_unregister_ac97_dai_link(card->rtd[i].codec);
Axel Lin6b3ed782010-12-07 16:12:29 +08001594 goto probe_aux_dev_err;
Mark Brownfe3e78e2009-11-03 22:13:13 +00001595 }
Axel Lin6b3ed782010-12-07 16:12:29 +08001596 }
Mark Brownfe3e78e2009-11-03 22:13:13 +00001597#endif
1598
Mark Brown435c5e22008-12-04 15:32:53 +00001599 card->instantiated = 1;
Mark Brown4f4c0072011-10-07 14:29:19 +01001600 snd_soc_dapm_sync(&card->dapm);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001601 mutex_unlock(&card->mutex);
Mark Brown435c5e22008-12-04 15:32:53 +00001602 return;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001603
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001604probe_aux_dev_err:
1605 for (i = 0; i < card->num_aux_devs; i++)
1606 soc_remove_aux_dev(card, i);
1607
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001608probe_dai_err:
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001609 soc_remove_dai_links(card);
Mark Brownfe3e78e2009-11-03 22:13:13 +00001610
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001611card_probe_error:
Mark Brown87506542008-11-18 20:50:34 +00001612 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00001613 card->remove(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001614
1615 snd_card_free(card->snd_card);
1616
1617 mutex_unlock(&card->mutex);
Mark Brown435c5e22008-12-04 15:32:53 +00001618}
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001619
Mark Brown435c5e22008-12-04 15:32:53 +00001620/*
Uwe Kleine-König421f91d2010-06-11 12:17:00 +02001621 * Attempt to initialise any uninitialised cards. Must be called with
Mark Brown435c5e22008-12-04 15:32:53 +00001622 * client_mutex.
1623 */
1624static void snd_soc_instantiate_cards(void)
1625{
1626 struct snd_soc_card *card;
1627 list_for_each_entry(card, &card_list, list)
1628 snd_soc_instantiate_card(card);
1629}
1630
1631/* probes a new socdev */
1632static int soc_probe(struct platform_device *pdev)
1633{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001634 struct snd_soc_card *card = platform_get_drvdata(pdev);
Mark Brown435c5e22008-12-04 15:32:53 +00001635 int ret = 0;
Mark Brown435c5e22008-12-04 15:32:53 +00001636
Vinod Koul70a7ca32011-01-14 19:22:48 +05301637 /*
1638 * no card, so machine driver should be registering card
1639 * we should not be here in that case so ret error
1640 */
1641 if (!card)
1642 return -EINVAL;
1643
Mark Brownfe4085e2012-03-02 13:07:41 +00001644 dev_warn(&pdev->dev,
1645 "ASoC machine %s should use snd_soc_register_card()\n",
1646 card->name);
1647
Mark Brown435c5e22008-12-04 15:32:53 +00001648 /* Bodge while we unpick instantiation */
1649 card->dev = &pdev->dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001650
Mark Brown435c5e22008-12-04 15:32:53 +00001651 ret = snd_soc_register_card(card);
1652 if (ret != 0) {
1653 dev_err(&pdev->dev, "Failed to register card\n");
1654 return ret;
1655 }
1656
1657 return 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001658}
1659
Vinod Koulb0e26482011-01-13 22:48:02 +05301660static int soc_cleanup_card_resources(struct snd_soc_card *card)
1661{
Vinod Koulb0e26482011-01-13 22:48:02 +05301662 int i;
1663
1664 /* make sure any delayed work runs */
1665 for (i = 0; i < card->num_rtd; i++) {
1666 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1667 flush_delayed_work_sync(&rtd->delayed_work);
1668 }
1669
1670 /* remove auxiliary devices */
1671 for (i = 0; i < card->num_aux_devs; i++)
1672 soc_remove_aux_dev(card, i);
1673
1674 /* remove and free each DAI */
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001675 soc_remove_dai_links(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05301676
1677 soc_cleanup_card_debugfs(card);
1678
1679 /* remove the card */
1680 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00001681 card->remove(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05301682
Lars-Peter Clausen0aaae522011-04-30 19:45:47 +02001683 snd_soc_dapm_free(&card->dapm);
1684
Vinod Koulb0e26482011-01-13 22:48:02 +05301685 snd_card_free(card->snd_card);
1686 return 0;
1687
1688}
1689
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001690/* removes a socdev */
1691static int soc_remove(struct platform_device *pdev)
1692{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001693 struct snd_soc_card *card = platform_get_drvdata(pdev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001694
Mark Brownc5af3a22008-11-28 13:29:45 +00001695 snd_soc_unregister_card(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001696 return 0;
1697}
1698
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001699int snd_soc_poweroff(struct device *dev)
Mark Brown51737472009-06-22 13:16:51 +01001700{
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001701 struct snd_soc_card *card = dev_get_drvdata(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001702 int i;
Mark Brown51737472009-06-22 13:16:51 +01001703
1704 if (!card->instantiated)
Mark Brown416356f2009-06-30 19:05:15 +01001705 return 0;
Mark Brown51737472009-06-22 13:16:51 +01001706
1707 /* Flush out pmdown_time work - we actually do want to run it
1708 * now, we're shutting down so no imminent restart. */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001709 for (i = 0; i < card->num_rtd; i++) {
1710 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
Tejun Heo5b84ba22010-12-11 17:51:26 +01001711 flush_delayed_work_sync(&rtd->delayed_work);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001712 }
Mark Brown51737472009-06-22 13:16:51 +01001713
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001714 snd_soc_dapm_shutdown(card);
Mark Brown416356f2009-06-30 19:05:15 +01001715
1716 return 0;
Mark Brown51737472009-06-22 13:16:51 +01001717}
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001718EXPORT_SYMBOL_GPL(snd_soc_poweroff);
Mark Brown51737472009-06-22 13:16:51 +01001719
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001720const struct dev_pm_ops snd_soc_pm_ops = {
Viresh Kumarb1dd5892012-02-24 16:25:49 +05301721 .suspend = snd_soc_suspend,
1722 .resume = snd_soc_resume,
1723 .freeze = snd_soc_suspend,
1724 .thaw = snd_soc_resume,
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001725 .poweroff = snd_soc_poweroff,
Viresh Kumarb1dd5892012-02-24 16:25:49 +05301726 .restore = snd_soc_resume,
Mark Brown416356f2009-06-30 19:05:15 +01001727};
Stephen Warrendeb26072011-04-05 19:35:30 -06001728EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
Mark Brown416356f2009-06-30 19:05:15 +01001729
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001730/* ASoC platform driver */
1731static struct platform_driver soc_driver = {
1732 .driver = {
1733 .name = "soc-audio",
Kay Sievers8b45a202008-04-14 13:33:36 +02001734 .owner = THIS_MODULE,
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001735 .pm = &snd_soc_pm_ops,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001736 },
1737 .probe = soc_probe,
1738 .remove = soc_remove,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001739};
1740
Mark Brown096e49d2009-07-05 15:12:22 +01001741/**
1742 * snd_soc_codec_volatile_register: Report if a register is volatile.
1743 *
1744 * @codec: CODEC to query.
1745 * @reg: Register to query.
1746 *
1747 * Boolean function indiciating if a CODEC register is volatile.
1748 */
Mark Brown181e0552011-01-24 14:05:25 +00001749int snd_soc_codec_volatile_register(struct snd_soc_codec *codec,
1750 unsigned int reg)
Mark Brown096e49d2009-07-05 15:12:22 +01001751{
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00001752 if (codec->volatile_register)
1753 return codec->volatile_register(codec, reg);
Mark Brown096e49d2009-07-05 15:12:22 +01001754 else
1755 return 0;
1756}
1757EXPORT_SYMBOL_GPL(snd_soc_codec_volatile_register);
1758
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001759/**
Dimitris Papastamos239c9702011-03-24 13:45:18 +00001760 * snd_soc_codec_readable_register: Report if a register is readable.
1761 *
1762 * @codec: CODEC to query.
1763 * @reg: Register to query.
1764 *
1765 * Boolean function indicating if a CODEC register is readable.
1766 */
1767int snd_soc_codec_readable_register(struct snd_soc_codec *codec,
1768 unsigned int reg)
1769{
1770 if (codec->readable_register)
1771 return codec->readable_register(codec, reg);
1772 else
Lars-Peter Clausen63fa0a22011-08-27 18:24:12 +02001773 return 1;
Dimitris Papastamos239c9702011-03-24 13:45:18 +00001774}
1775EXPORT_SYMBOL_GPL(snd_soc_codec_readable_register);
1776
1777/**
1778 * snd_soc_codec_writable_register: Report if a register is writable.
1779 *
1780 * @codec: CODEC to query.
1781 * @reg: Register to query.
1782 *
1783 * Boolean function indicating if a CODEC register is writable.
1784 */
1785int snd_soc_codec_writable_register(struct snd_soc_codec *codec,
1786 unsigned int reg)
1787{
1788 if (codec->writable_register)
1789 return codec->writable_register(codec, reg);
1790 else
Lars-Peter Clausen63fa0a22011-08-27 18:24:12 +02001791 return 1;
Dimitris Papastamos239c9702011-03-24 13:45:18 +00001792}
1793EXPORT_SYMBOL_GPL(snd_soc_codec_writable_register);
1794
Liam Girdwoodf1442bc2011-07-04 11:10:15 +01001795int snd_soc_platform_read(struct snd_soc_platform *platform,
1796 unsigned int reg)
1797{
1798 unsigned int ret;
1799
1800 if (!platform->driver->read) {
1801 dev_err(platform->dev, "platform has no read back\n");
1802 return -1;
1803 }
1804
1805 ret = platform->driver->read(platform, reg);
1806 dev_dbg(platform->dev, "read %x => %x\n", reg, ret);
Liam Girdwooda82ce2a2011-07-04 22:10:50 +01001807 trace_snd_soc_preg_read(platform, reg, ret);
Liam Girdwoodf1442bc2011-07-04 11:10:15 +01001808
1809 return ret;
1810}
1811EXPORT_SYMBOL_GPL(snd_soc_platform_read);
1812
1813int snd_soc_platform_write(struct snd_soc_platform *platform,
1814 unsigned int reg, unsigned int val)
1815{
1816 if (!platform->driver->write) {
1817 dev_err(platform->dev, "platform has no write back\n");
1818 return -1;
1819 }
1820
1821 dev_dbg(platform->dev, "write %x = %x\n", reg, val);
Liam Girdwooda82ce2a2011-07-04 22:10:50 +01001822 trace_snd_soc_preg_write(platform, reg, val);
Liam Girdwoodf1442bc2011-07-04 11:10:15 +01001823 return platform->driver->write(platform, reg, val);
1824}
1825EXPORT_SYMBOL_GPL(snd_soc_platform_write);
1826
Dimitris Papastamos239c9702011-03-24 13:45:18 +00001827/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001828 * snd_soc_new_ac97_codec - initailise AC97 device
1829 * @codec: audio codec
1830 * @ops: AC97 bus operations
1831 * @num: AC97 codec number
1832 *
1833 * Initialises AC97 codec resources for use by ad-hoc devices only.
1834 */
1835int snd_soc_new_ac97_codec(struct snd_soc_codec *codec,
1836 struct snd_ac97_bus_ops *ops, int num)
1837{
1838 mutex_lock(&codec->mutex);
1839
1840 codec->ac97 = kzalloc(sizeof(struct snd_ac97), GFP_KERNEL);
1841 if (codec->ac97 == NULL) {
1842 mutex_unlock(&codec->mutex);
1843 return -ENOMEM;
1844 }
1845
1846 codec->ac97->bus = kzalloc(sizeof(struct snd_ac97_bus), GFP_KERNEL);
1847 if (codec->ac97->bus == NULL) {
1848 kfree(codec->ac97);
1849 codec->ac97 = NULL;
1850 mutex_unlock(&codec->mutex);
1851 return -ENOMEM;
1852 }
1853
1854 codec->ac97->bus->ops = ops;
1855 codec->ac97->num = num;
Mika Westerberg0562f782010-10-13 11:30:32 +03001856
1857 /*
1858 * Mark the AC97 device to be created by us. This way we ensure that the
1859 * device will be registered with the device subsystem later on.
1860 */
1861 codec->ac97_created = 1;
1862
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001863 mutex_unlock(&codec->mutex);
1864 return 0;
1865}
1866EXPORT_SYMBOL_GPL(snd_soc_new_ac97_codec);
1867
1868/**
1869 * snd_soc_free_ac97_codec - free AC97 codec device
1870 * @codec: audio codec
1871 *
1872 * Frees AC97 codec device resources.
1873 */
1874void snd_soc_free_ac97_codec(struct snd_soc_codec *codec)
1875{
1876 mutex_lock(&codec->mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001877#ifdef CONFIG_SND_SOC_AC97_BUS
1878 soc_unregister_ac97_dai_link(codec);
1879#endif
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001880 kfree(codec->ac97->bus);
1881 kfree(codec->ac97);
1882 codec->ac97 = NULL;
Mika Westerberg0562f782010-10-13 11:30:32 +03001883 codec->ac97_created = 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001884 mutex_unlock(&codec->mutex);
1885}
1886EXPORT_SYMBOL_GPL(snd_soc_free_ac97_codec);
1887
Mark Brownc3753702010-11-01 15:41:57 -04001888unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg)
1889{
1890 unsigned int ret;
1891
Mark Brownc3acec22010-12-02 16:15:29 +00001892 ret = codec->read(codec, reg);
Mark Brownc3753702010-11-01 15:41:57 -04001893 dev_dbg(codec->dev, "read %x => %x\n", reg, ret);
Mark Browna8b1d342010-11-03 18:05:58 -04001894 trace_snd_soc_reg_read(codec, reg, ret);
Mark Brownc3753702010-11-01 15:41:57 -04001895
1896 return ret;
1897}
1898EXPORT_SYMBOL_GPL(snd_soc_read);
1899
1900unsigned int snd_soc_write(struct snd_soc_codec *codec,
1901 unsigned int reg, unsigned int val)
1902{
1903 dev_dbg(codec->dev, "write %x = %x\n", reg, val);
Mark Browna8b1d342010-11-03 18:05:58 -04001904 trace_snd_soc_reg_write(codec, reg, val);
Mark Brownc3acec22010-12-02 16:15:29 +00001905 return codec->write(codec, reg, val);
Mark Brownc3753702010-11-01 15:41:57 -04001906}
1907EXPORT_SYMBOL_GPL(snd_soc_write);
1908
Dimitris Papastamos5fb609d2011-03-22 10:37:03 +00001909unsigned int snd_soc_bulk_write_raw(struct snd_soc_codec *codec,
1910 unsigned int reg, const void *data, size_t len)
1911{
1912 return codec->bulk_write_raw(codec, reg, data, len);
1913}
1914EXPORT_SYMBOL_GPL(snd_soc_bulk_write_raw);
1915
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001916/**
1917 * snd_soc_update_bits - update codec register bits
1918 * @codec: audio codec
1919 * @reg: codec register
1920 * @mask: register mask
1921 * @value: new value
1922 *
1923 * Writes new register value.
1924 *
Timur Tabi180c3292011-01-10 15:58:13 -06001925 * Returns 1 for change, 0 for no change, or negative error code.
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001926 */
1927int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned short reg,
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001928 unsigned int mask, unsigned int value)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001929{
Mark Brown8a713da2011-12-03 12:33:55 +00001930 bool change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001931 unsigned int old, new;
Timur Tabi180c3292011-01-10 15:58:13 -06001932 int ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001933
Mark Brown8a713da2011-12-03 12:33:55 +00001934 if (codec->using_regmap) {
1935 ret = regmap_update_bits_check(codec->control_data, reg,
1936 mask, value, &change);
1937 } else {
1938 ret = snd_soc_read(codec, reg);
Timur Tabi180c3292011-01-10 15:58:13 -06001939 if (ret < 0)
1940 return ret;
Mark Brown8a713da2011-12-03 12:33:55 +00001941
1942 old = ret;
1943 new = (old & ~mask) | (value & mask);
1944 change = old != new;
1945 if (change)
1946 ret = snd_soc_write(codec, reg, new);
Timur Tabi180c3292011-01-10 15:58:13 -06001947 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001948
Mark Brown8a713da2011-12-03 12:33:55 +00001949 if (ret < 0)
1950 return ret;
1951
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001952 return change;
1953}
1954EXPORT_SYMBOL_GPL(snd_soc_update_bits);
1955
1956/**
Eero Nurkkala6c508c62009-10-30 13:34:03 +02001957 * snd_soc_update_bits_locked - update codec register bits
1958 * @codec: audio codec
1959 * @reg: codec register
1960 * @mask: register mask
1961 * @value: new value
1962 *
1963 * Writes new register value, and takes the codec mutex.
1964 *
1965 * Returns 1 for change else 0.
1966 */
Mark Browndd1b3d52009-12-04 14:22:03 +00001967int snd_soc_update_bits_locked(struct snd_soc_codec *codec,
1968 unsigned short reg, unsigned int mask,
1969 unsigned int value)
Eero Nurkkala6c508c62009-10-30 13:34:03 +02001970{
1971 int change;
1972
1973 mutex_lock(&codec->mutex);
1974 change = snd_soc_update_bits(codec, reg, mask, value);
1975 mutex_unlock(&codec->mutex);
1976
1977 return change;
1978}
Mark Browndd1b3d52009-12-04 14:22:03 +00001979EXPORT_SYMBOL_GPL(snd_soc_update_bits_locked);
Eero Nurkkala6c508c62009-10-30 13:34:03 +02001980
1981/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001982 * snd_soc_test_bits - test register for change
1983 * @codec: audio codec
1984 * @reg: codec register
1985 * @mask: register mask
1986 * @value: new value
1987 *
1988 * Tests a register with a new value and checks if the new value is
1989 * different from the old value.
1990 *
1991 * Returns 1 for change else 0.
1992 */
1993int snd_soc_test_bits(struct snd_soc_codec *codec, unsigned short reg,
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001994 unsigned int mask, unsigned int value)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001995{
1996 int change;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03001997 unsigned int old, new;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001998
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001999 old = snd_soc_read(codec, reg);
2000 new = (old & ~mask) | value;
2001 change = old != new;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002002
2003 return change;
2004}
2005EXPORT_SYMBOL_GPL(snd_soc_test_bits);
2006
2007/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002008 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
2009 * @substream: the pcm substream
2010 * @hw: the hardware parameters
2011 *
2012 * Sets the substream runtime hardware parameters.
2013 */
2014int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
2015 const struct snd_pcm_hardware *hw)
2016{
2017 struct snd_pcm_runtime *runtime = substream->runtime;
2018 runtime->hw.info = hw->info;
2019 runtime->hw.formats = hw->formats;
2020 runtime->hw.period_bytes_min = hw->period_bytes_min;
2021 runtime->hw.period_bytes_max = hw->period_bytes_max;
2022 runtime->hw.periods_min = hw->periods_min;
2023 runtime->hw.periods_max = hw->periods_max;
2024 runtime->hw.buffer_bytes_max = hw->buffer_bytes_max;
2025 runtime->hw.fifo_size = hw->fifo_size;
2026 return 0;
2027}
2028EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
2029
2030/**
2031 * snd_soc_cnew - create new control
2032 * @_template: control template
2033 * @data: control private data
Mark Brownac11a2b2009-01-01 12:18:17 +00002034 * @long_name: control long name
Mark Brownefb7ac32011-03-08 17:23:24 +00002035 * @prefix: control name prefix
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002036 *
2037 * Create a new mixer control from a template control.
2038 *
2039 * Returns 0 for success, else error.
2040 */
2041struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
Mark Brown30565572012-02-16 17:07:42 -08002042 void *data, const char *long_name,
Mark Brownefb7ac32011-03-08 17:23:24 +00002043 const char *prefix)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002044{
2045 struct snd_kcontrol_new template;
Mark Brownefb7ac32011-03-08 17:23:24 +00002046 struct snd_kcontrol *kcontrol;
2047 char *name = NULL;
2048 int name_len;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002049
2050 memcpy(&template, _template, sizeof(template));
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002051 template.index = 0;
2052
Mark Brownefb7ac32011-03-08 17:23:24 +00002053 if (!long_name)
2054 long_name = template.name;
2055
2056 if (prefix) {
2057 name_len = strlen(long_name) + strlen(prefix) + 2;
Axel Lin57cf9d42011-08-20 11:03:44 +08002058 name = kmalloc(name_len, GFP_KERNEL);
Mark Brownefb7ac32011-03-08 17:23:24 +00002059 if (!name)
2060 return NULL;
2061
2062 snprintf(name, name_len, "%s %s", prefix, long_name);
2063
2064 template.name = name;
2065 } else {
2066 template.name = long_name;
2067 }
2068
2069 kcontrol = snd_ctl_new1(&template, data);
2070
2071 kfree(name);
2072
2073 return kcontrol;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002074}
2075EXPORT_SYMBOL_GPL(snd_soc_cnew);
2076
Liam Girdwood022658b2012-02-03 17:43:09 +00002077static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
2078 const struct snd_kcontrol_new *controls, int num_controls,
2079 const char *prefix, void *data)
2080{
2081 int err, i;
2082
2083 for (i = 0; i < num_controls; i++) {
2084 const struct snd_kcontrol_new *control = &controls[i];
2085 err = snd_ctl_add(card, snd_soc_cnew(control, data,
2086 control->name, prefix));
2087 if (err < 0) {
2088 dev_err(dev, "Failed to add %s: %d\n", control->name, err);
2089 return err;
2090 }
2091 }
2092
2093 return 0;
2094}
2095
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002096/**
Liam Girdwood022658b2012-02-03 17:43:09 +00002097 * snd_soc_add_codec_controls - add an array of controls to a codec.
2098 * Convenience function to add a list of controls. Many codecs were
Ian Molton3e8e1952009-01-09 00:23:21 +00002099 * duplicating this code.
2100 *
2101 * @codec: codec to add controls to
2102 * @controls: array of controls to add
2103 * @num_controls: number of elements in the array
2104 *
2105 * Return 0 for success, else error.
2106 */
Liam Girdwood022658b2012-02-03 17:43:09 +00002107int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
Ian Molton3e8e1952009-01-09 00:23:21 +00002108 const struct snd_kcontrol_new *controls, int num_controls)
2109{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002110 struct snd_card *card = codec->card->snd_card;
Ian Molton3e8e1952009-01-09 00:23:21 +00002111
Liam Girdwood022658b2012-02-03 17:43:09 +00002112 return snd_soc_add_controls(card, codec->dev, controls, num_controls,
2113 codec->name_prefix, codec);
Ian Molton3e8e1952009-01-09 00:23:21 +00002114}
Liam Girdwood022658b2012-02-03 17:43:09 +00002115EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls);
Ian Molton3e8e1952009-01-09 00:23:21 +00002116
2117/**
Liam Girdwooda491a5c2011-07-04 22:10:51 +01002118 * snd_soc_add_platform_controls - add an array of controls to a platform.
Liam Girdwood022658b2012-02-03 17:43:09 +00002119 * Convenience function to add a list of controls.
Liam Girdwooda491a5c2011-07-04 22:10:51 +01002120 *
2121 * @platform: platform to add controls to
2122 * @controls: array of controls to add
2123 * @num_controls: number of elements in the array
2124 *
2125 * Return 0 for success, else error.
2126 */
2127int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
2128 const struct snd_kcontrol_new *controls, int num_controls)
2129{
2130 struct snd_card *card = platform->card->snd_card;
Liam Girdwooda491a5c2011-07-04 22:10:51 +01002131
Liam Girdwood022658b2012-02-03 17:43:09 +00002132 return snd_soc_add_controls(card, platform->dev, controls, num_controls,
2133 NULL, platform);
Liam Girdwooda491a5c2011-07-04 22:10:51 +01002134}
2135EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
2136
2137/**
Liam Girdwood022658b2012-02-03 17:43:09 +00002138 * snd_soc_add_card_controls - add an array of controls to a SoC card.
2139 * Convenience function to add a list of controls.
2140 *
2141 * @soc_card: SoC card to add controls to
2142 * @controls: array of controls to add
2143 * @num_controls: number of elements in the array
2144 *
2145 * Return 0 for success, else error.
2146 */
2147int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
2148 const struct snd_kcontrol_new *controls, int num_controls)
2149{
2150 struct snd_card *card = soc_card->snd_card;
2151
2152 return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,
2153 NULL, soc_card);
2154}
2155EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
2156
2157/**
2158 * snd_soc_add_dai_controls - add an array of controls to a DAI.
2159 * Convienience function to add a list of controls.
2160 *
2161 * @dai: DAI to add controls to
2162 * @controls: array of controls to add
2163 * @num_controls: number of elements in the array
2164 *
2165 * Return 0 for success, else error.
2166 */
2167int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
2168 const struct snd_kcontrol_new *controls, int num_controls)
2169{
2170 struct snd_card *card = dai->card->snd_card;
2171
2172 return snd_soc_add_controls(card, dai->dev, controls, num_controls,
2173 NULL, dai);
2174}
2175EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
2176
2177/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002178 * snd_soc_info_enum_double - enumerated double mixer info callback
2179 * @kcontrol: mixer control
2180 * @uinfo: control element information
2181 *
2182 * Callback to provide information about a double enumerated
2183 * mixer control.
2184 *
2185 * Returns 0 for success.
2186 */
2187int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
2188 struct snd_ctl_elem_info *uinfo)
2189{
2190 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2191
2192 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2193 uinfo->count = e->shift_l == e->shift_r ? 1 : 2;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002194 uinfo->value.enumerated.items = e->max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002195
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002196 if (uinfo->value.enumerated.item > e->max - 1)
2197 uinfo->value.enumerated.item = e->max - 1;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002198 strcpy(uinfo->value.enumerated.name,
2199 e->texts[uinfo->value.enumerated.item]);
2200 return 0;
2201}
2202EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
2203
2204/**
2205 * snd_soc_get_enum_double - enumerated double mixer get callback
2206 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002207 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002208 *
2209 * Callback to get the value of a double enumerated mixer.
2210 *
2211 * Returns 0 for success.
2212 */
2213int snd_soc_get_enum_double(struct snd_kcontrol *kcontrol,
2214 struct snd_ctl_elem_value *ucontrol)
2215{
2216 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2217 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002218 unsigned int val, bitmask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002219
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002220 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002221 ;
2222 val = snd_soc_read(codec, e->reg);
Mark Brown3ff3f642008-05-19 12:32:25 +02002223 ucontrol->value.enumerated.item[0]
2224 = (val >> e->shift_l) & (bitmask - 1);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002225 if (e->shift_l != e->shift_r)
2226 ucontrol->value.enumerated.item[1] =
2227 (val >> e->shift_r) & (bitmask - 1);
2228
2229 return 0;
2230}
2231EXPORT_SYMBOL_GPL(snd_soc_get_enum_double);
2232
2233/**
2234 * snd_soc_put_enum_double - enumerated double mixer put callback
2235 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002236 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002237 *
2238 * Callback to set the value of a double enumerated mixer.
2239 *
2240 * Returns 0 for success.
2241 */
2242int snd_soc_put_enum_double(struct snd_kcontrol *kcontrol,
2243 struct snd_ctl_elem_value *ucontrol)
2244{
2245 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2246 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002247 unsigned int val;
2248 unsigned int mask, bitmask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002249
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002250 for (bitmask = 1; bitmask < e->max; bitmask <<= 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002251 ;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002252 if (ucontrol->value.enumerated.item[0] > e->max - 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002253 return -EINVAL;
2254 val = ucontrol->value.enumerated.item[0] << e->shift_l;
2255 mask = (bitmask - 1) << e->shift_l;
2256 if (e->shift_l != e->shift_r) {
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002257 if (ucontrol->value.enumerated.item[1] > e->max - 1)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002258 return -EINVAL;
2259 val |= ucontrol->value.enumerated.item[1] << e->shift_r;
2260 mask |= (bitmask - 1) << e->shift_r;
2261 }
2262
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002263 return snd_soc_update_bits_locked(codec, e->reg, mask, val);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002264}
2265EXPORT_SYMBOL_GPL(snd_soc_put_enum_double);
2266
2267/**
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002268 * snd_soc_get_value_enum_double - semi enumerated double mixer get callback
2269 * @kcontrol: mixer control
2270 * @ucontrol: control element information
2271 *
2272 * Callback to get the value of a double semi enumerated mixer.
2273 *
2274 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2275 * used for handling bitfield coded enumeration for example.
2276 *
2277 * Returns 0 for success.
2278 */
2279int snd_soc_get_value_enum_double(struct snd_kcontrol *kcontrol,
2280 struct snd_ctl_elem_value *ucontrol)
2281{
2282 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Peter Ujfalusi74155552009-01-08 13:34:29 +02002283 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002284 unsigned int reg_val, val, mux;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002285
2286 reg_val = snd_soc_read(codec, e->reg);
2287 val = (reg_val >> e->shift_l) & e->mask;
2288 for (mux = 0; mux < e->max; mux++) {
2289 if (val == e->values[mux])
2290 break;
2291 }
2292 ucontrol->value.enumerated.item[0] = mux;
2293 if (e->shift_l != e->shift_r) {
2294 val = (reg_val >> e->shift_r) & e->mask;
2295 for (mux = 0; mux < e->max; mux++) {
2296 if (val == e->values[mux])
2297 break;
2298 }
2299 ucontrol->value.enumerated.item[1] = mux;
2300 }
2301
2302 return 0;
2303}
2304EXPORT_SYMBOL_GPL(snd_soc_get_value_enum_double);
2305
2306/**
2307 * snd_soc_put_value_enum_double - semi enumerated double mixer put callback
2308 * @kcontrol: mixer control
2309 * @ucontrol: control element information
2310 *
2311 * Callback to set the value of a double semi enumerated mixer.
2312 *
2313 * Semi enumerated mixer: the enumerated items are referred as values. Can be
2314 * used for handling bitfield coded enumeration for example.
2315 *
2316 * Returns 0 for success.
2317 */
2318int snd_soc_put_value_enum_double(struct snd_kcontrol *kcontrol,
2319 struct snd_ctl_elem_value *ucontrol)
2320{
2321 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Peter Ujfalusi74155552009-01-08 13:34:29 +02002322 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002323 unsigned int val;
2324 unsigned int mask;
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002325
2326 if (ucontrol->value.enumerated.item[0] > e->max - 1)
2327 return -EINVAL;
2328 val = e->values[ucontrol->value.enumerated.item[0]] << e->shift_l;
2329 mask = e->mask << e->shift_l;
2330 if (e->shift_l != e->shift_r) {
2331 if (ucontrol->value.enumerated.item[1] > e->max - 1)
2332 return -EINVAL;
2333 val |= e->values[ucontrol->value.enumerated.item[1]] << e->shift_r;
2334 mask |= e->mask << e->shift_r;
2335 }
2336
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002337 return snd_soc_update_bits_locked(codec, e->reg, mask, val);
Peter Ujfalusi2e72f8e2009-01-05 09:54:57 +02002338}
2339EXPORT_SYMBOL_GPL(snd_soc_put_value_enum_double);
2340
2341/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002342 * snd_soc_info_enum_ext - external enumerated single mixer info callback
2343 * @kcontrol: mixer control
2344 * @uinfo: control element information
2345 *
2346 * Callback to provide information about an external enumerated
2347 * single mixer.
2348 *
2349 * Returns 0 for success.
2350 */
2351int snd_soc_info_enum_ext(struct snd_kcontrol *kcontrol,
2352 struct snd_ctl_elem_info *uinfo)
2353{
2354 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
2355
2356 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2357 uinfo->count = 1;
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002358 uinfo->value.enumerated.items = e->max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002359
Jon Smirlf8ba0b72008-07-29 11:42:27 +01002360 if (uinfo->value.enumerated.item > e->max - 1)
2361 uinfo->value.enumerated.item = e->max - 1;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002362 strcpy(uinfo->value.enumerated.name,
2363 e->texts[uinfo->value.enumerated.item]);
2364 return 0;
2365}
2366EXPORT_SYMBOL_GPL(snd_soc_info_enum_ext);
2367
2368/**
2369 * snd_soc_info_volsw_ext - external single mixer info callback
2370 * @kcontrol: mixer control
2371 * @uinfo: control element information
2372 *
2373 * Callback to provide information about a single external mixer control.
2374 *
2375 * Returns 0 for success.
2376 */
2377int snd_soc_info_volsw_ext(struct snd_kcontrol *kcontrol,
2378 struct snd_ctl_elem_info *uinfo)
2379{
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002380 int max = kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002381
Mark Brownfd5dfad2009-04-15 21:37:46 +01002382 if (max == 1 && !strstr(kcontrol->id.name, " Volume"))
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002383 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2384 else
2385 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2386
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002387 uinfo->count = 1;
2388 uinfo->value.integer.min = 0;
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002389 uinfo->value.integer.max = max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002390 return 0;
2391}
2392EXPORT_SYMBOL_GPL(snd_soc_info_volsw_ext);
2393
2394/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002395 * snd_soc_info_volsw - single mixer info callback
2396 * @kcontrol: mixer control
2397 * @uinfo: control element information
2398 *
Peter Ujfalusie8f5a102011-10-05 10:29:23 +03002399 * Callback to provide information about a single mixer control, or a double
2400 * mixer control that spans 2 registers.
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002401 *
2402 * Returns 0 for success.
2403 */
2404int snd_soc_info_volsw(struct snd_kcontrol *kcontrol,
2405 struct snd_ctl_elem_info *uinfo)
2406{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002407 struct soc_mixer_control *mc =
2408 (struct soc_mixer_control *)kcontrol->private_value;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002409 int platform_max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002410
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002411 if (!mc->platform_max)
2412 mc->platform_max = mc->max;
2413 platform_max = mc->platform_max;
2414
2415 if (platform_max == 1 && !strstr(kcontrol->id.name, " Volume"))
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002416 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2417 else
2418 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2419
Peter Ujfalusie8f5a102011-10-05 10:29:23 +03002420 uinfo->count = snd_soc_volsw_is_stereo(mc) ? 2 : 1;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002421 uinfo->value.integer.min = 0;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002422 uinfo->value.integer.max = platform_max;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002423 return 0;
2424}
2425EXPORT_SYMBOL_GPL(snd_soc_info_volsw);
2426
2427/**
2428 * snd_soc_get_volsw - single mixer get callback
2429 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002430 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002431 *
Peter Ujfalusif7915d92011-10-05 10:29:24 +03002432 * Callback to get the value of a single mixer control, or a double mixer
2433 * control that spans 2 registers.
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002434 *
2435 * Returns 0 for success.
2436 */
2437int snd_soc_get_volsw(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;
Peter Ujfalusif7915d92011-10-05 10:29:24 +03002444 unsigned int reg2 = mc->rreg;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002445 unsigned int shift = mc->shift;
2446 unsigned int rshift = mc->rshift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002447 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002448 unsigned int mask = (1 << fls(max)) - 1;
2449 unsigned int invert = mc->invert;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002450
2451 ucontrol->value.integer.value[0] =
2452 (snd_soc_read(codec, reg) >> shift) & mask;
Peter Ujfalusif7915d92011-10-05 10:29:24 +03002453 if (invert)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002454 ucontrol->value.integer.value[0] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002455 max - ucontrol->value.integer.value[0];
Peter Ujfalusif7915d92011-10-05 10:29:24 +03002456
2457 if (snd_soc_volsw_is_stereo(mc)) {
2458 if (reg == reg2)
2459 ucontrol->value.integer.value[1] =
2460 (snd_soc_read(codec, reg) >> rshift) & mask;
2461 else
2462 ucontrol->value.integer.value[1] =
2463 (snd_soc_read(codec, reg2) >> shift) & mask;
2464 if (invert)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002465 ucontrol->value.integer.value[1] =
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002466 max - ucontrol->value.integer.value[1];
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002467 }
2468
2469 return 0;
2470}
2471EXPORT_SYMBOL_GPL(snd_soc_get_volsw);
2472
2473/**
2474 * snd_soc_put_volsw - single mixer put callback
2475 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002476 * @ucontrol: control element information
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002477 *
Peter Ujfalusi974815b2011-10-05 10:29:25 +03002478 * Callback to set the value of a single mixer control, or a double mixer
2479 * control that spans 2 registers.
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002480 *
2481 * Returns 0 for success.
2482 */
2483int snd_soc_put_volsw(struct snd_kcontrol *kcontrol,
2484 struct snd_ctl_elem_value *ucontrol)
2485{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002486 struct soc_mixer_control *mc =
2487 (struct soc_mixer_control *)kcontrol->private_value;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002488 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002489 unsigned int reg = mc->reg;
Peter Ujfalusi974815b2011-10-05 10:29:25 +03002490 unsigned int reg2 = mc->rreg;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002491 unsigned int shift = mc->shift;
2492 unsigned int rshift = mc->rshift;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002493 int max = mc->max;
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002494 unsigned int mask = (1 << fls(max)) - 1;
2495 unsigned int invert = mc->invert;
Peter Ujfalusi974815b2011-10-05 10:29:25 +03002496 int err;
2497 bool type_2r = 0;
2498 unsigned int val2 = 0;
2499 unsigned int val, val_mask;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002500
2501 val = (ucontrol->value.integer.value[0] & mask);
2502 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002503 val = max - val;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002504 val_mask = mask << shift;
2505 val = val << shift;
Peter Ujfalusi974815b2011-10-05 10:29:25 +03002506 if (snd_soc_volsw_is_stereo(mc)) {
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002507 val2 = (ucontrol->value.integer.value[1] & mask);
2508 if (invert)
Philipp Zabela7a4ac82008-01-10 14:37:42 +01002509 val2 = max - val2;
Peter Ujfalusi974815b2011-10-05 10:29:25 +03002510 if (reg == reg2) {
2511 val_mask |= mask << rshift;
2512 val |= val2 << rshift;
2513 } else {
2514 val2 = val2 << shift;
2515 type_2r = 1;
2516 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002517 }
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002518 err = snd_soc_update_bits_locked(codec, reg, val_mask, val);
Mark Brown3ff3f642008-05-19 12:32:25 +02002519 if (err < 0)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002520 return err;
2521
Peter Ujfalusi974815b2011-10-05 10:29:25 +03002522 if (type_2r)
2523 err = snd_soc_update_bits_locked(codec, reg2, val_mask, val2);
2524
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002525 return err;
2526}
Peter Ujfalusi974815b2011-10-05 10:29:25 +03002527EXPORT_SYMBOL_GPL(snd_soc_put_volsw);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002528
Mark Browne13ac2e2008-05-28 17:58:05 +01002529/**
2530 * snd_soc_info_volsw_s8 - signed mixer info callback
2531 * @kcontrol: mixer control
2532 * @uinfo: control element information
2533 *
2534 * Callback to provide information about a signed mixer control.
2535 *
2536 * Returns 0 for success.
2537 */
2538int snd_soc_info_volsw_s8(struct snd_kcontrol *kcontrol,
2539 struct snd_ctl_elem_info *uinfo)
2540{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002541 struct soc_mixer_control *mc =
2542 (struct soc_mixer_control *)kcontrol->private_value;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002543 int platform_max;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002544 int min = mc->min;
Mark Browne13ac2e2008-05-28 17:58:05 +01002545
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002546 if (!mc->platform_max)
2547 mc->platform_max = mc->max;
2548 platform_max = mc->platform_max;
2549
Mark Browne13ac2e2008-05-28 17:58:05 +01002550 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2551 uinfo->count = 2;
2552 uinfo->value.integer.min = 0;
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002553 uinfo->value.integer.max = platform_max - min;
Mark Browne13ac2e2008-05-28 17:58:05 +01002554 return 0;
2555}
2556EXPORT_SYMBOL_GPL(snd_soc_info_volsw_s8);
2557
2558/**
2559 * snd_soc_get_volsw_s8 - signed mixer get callback
2560 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002561 * @ucontrol: control element information
Mark Browne13ac2e2008-05-28 17:58:05 +01002562 *
2563 * Callback to get the value of a signed mixer control.
2564 *
2565 * Returns 0 for success.
2566 */
2567int snd_soc_get_volsw_s8(struct snd_kcontrol *kcontrol,
2568 struct snd_ctl_elem_value *ucontrol)
2569{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002570 struct soc_mixer_control *mc =
2571 (struct soc_mixer_control *)kcontrol->private_value;
Mark Browne13ac2e2008-05-28 17:58:05 +01002572 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002573 unsigned int reg = mc->reg;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002574 int min = mc->min;
Mark Browne13ac2e2008-05-28 17:58:05 +01002575 int val = snd_soc_read(codec, reg);
2576
2577 ucontrol->value.integer.value[0] =
2578 ((signed char)(val & 0xff))-min;
2579 ucontrol->value.integer.value[1] =
2580 ((signed char)((val >> 8) & 0xff))-min;
2581 return 0;
2582}
2583EXPORT_SYMBOL_GPL(snd_soc_get_volsw_s8);
2584
2585/**
2586 * snd_soc_put_volsw_sgn - signed mixer put callback
2587 * @kcontrol: mixer control
Mark Brownac11a2b2009-01-01 12:18:17 +00002588 * @ucontrol: control element information
Mark Browne13ac2e2008-05-28 17:58:05 +01002589 *
2590 * Callback to set the value of a signed mixer control.
2591 *
2592 * Returns 0 for success.
2593 */
2594int snd_soc_put_volsw_s8(struct snd_kcontrol *kcontrol,
2595 struct snd_ctl_elem_value *ucontrol)
2596{
Jon Smirl4eaa9812008-07-29 11:42:26 +01002597 struct soc_mixer_control *mc =
2598 (struct soc_mixer_control *)kcontrol->private_value;
Mark Browne13ac2e2008-05-28 17:58:05 +01002599 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Jon Smirl815ecf8d2008-07-29 10:22:24 -04002600 unsigned int reg = mc->reg;
Jon Smirl4eaa9812008-07-29 11:42:26 +01002601 int min = mc->min;
Daniel Ribeiro46f58222009-06-07 02:49:11 -03002602 unsigned int val;
Mark Browne13ac2e2008-05-28 17:58:05 +01002603
2604 val = (ucontrol->value.integer.value[0]+min) & 0xff;
2605 val |= ((ucontrol->value.integer.value[1]+min) & 0xff) << 8;
2606
Eero Nurkkala6c508c62009-10-30 13:34:03 +02002607 return snd_soc_update_bits_locked(codec, reg, 0xffff, val);
Mark Browne13ac2e2008-05-28 17:58:05 +01002608}
2609EXPORT_SYMBOL_GPL(snd_soc_put_volsw_s8);
2610
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002611/**
Peter Ujfalusi637d3842010-05-07 14:05:49 +03002612 * snd_soc_limit_volume - Set new limit to an existing volume control.
2613 *
2614 * @codec: where to look for the control
2615 * @name: Name of the control
2616 * @max: new maximum limit
2617 *
2618 * Return 0 for success, else error.
2619 */
2620int snd_soc_limit_volume(struct snd_soc_codec *codec,
2621 const char *name, int max)
2622{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002623 struct snd_card *card = codec->card->snd_card;
Peter Ujfalusi637d3842010-05-07 14:05:49 +03002624 struct snd_kcontrol *kctl;
2625 struct soc_mixer_control *mc;
2626 int found = 0;
2627 int ret = -EINVAL;
2628
2629 /* Sanity check for name and max */
2630 if (unlikely(!name || max <= 0))
2631 return -EINVAL;
2632
2633 list_for_each_entry(kctl, &card->controls, list) {
2634 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name))) {
2635 found = 1;
2636 break;
2637 }
2638 }
2639 if (found) {
2640 mc = (struct soc_mixer_control *)kctl->private_value;
2641 if (max <= mc->max) {
Peter Ujfalusid11bb4a2010-05-10 14:39:24 +03002642 mc->platform_max = max;
Peter Ujfalusi637d3842010-05-07 14:05:49 +03002643 ret = 0;
2644 }
2645 }
2646 return ret;
2647}
2648EXPORT_SYMBOL_GPL(snd_soc_limit_volume);
2649
2650/**
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02002651 * snd_soc_info_volsw_2r_sx - double with tlv and variable data size
2652 * mixer info callback
2653 * @kcontrol: mixer control
2654 * @uinfo: control element information
2655 *
2656 * Returns 0 for success.
2657 */
2658int snd_soc_info_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2659 struct snd_ctl_elem_info *uinfo)
2660{
2661 struct soc_mixer_control *mc =
2662 (struct soc_mixer_control *)kcontrol->private_value;
2663 int max = mc->max;
2664 int min = mc->min;
2665
2666 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2667 uinfo->count = 2;
2668 uinfo->value.integer.min = 0;
2669 uinfo->value.integer.max = max-min;
2670
2671 return 0;
2672}
2673EXPORT_SYMBOL_GPL(snd_soc_info_volsw_2r_sx);
2674
2675/**
2676 * snd_soc_get_volsw_2r_sx - double with tlv and variable data size
2677 * mixer get callback
2678 * @kcontrol: mixer control
2679 * @uinfo: control element information
2680 *
2681 * Returns 0 for success.
2682 */
2683int snd_soc_get_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2684 struct snd_ctl_elem_value *ucontrol)
2685{
2686 struct soc_mixer_control *mc =
2687 (struct soc_mixer_control *)kcontrol->private_value;
2688 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2689 unsigned int mask = (1<<mc->shift)-1;
2690 int min = mc->min;
2691 int val = snd_soc_read(codec, mc->reg) & mask;
2692 int valr = snd_soc_read(codec, mc->rreg) & mask;
2693
Stuart Longland20630c72010-06-18 12:56:10 +10002694 ucontrol->value.integer.value[0] = ((val & 0xff)-min) & mask;
2695 ucontrol->value.integer.value[1] = ((valr & 0xff)-min) & mask;
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02002696 return 0;
2697}
2698EXPORT_SYMBOL_GPL(snd_soc_get_volsw_2r_sx);
2699
2700/**
2701 * snd_soc_put_volsw_2r_sx - double with tlv and variable data size
2702 * mixer put callback
2703 * @kcontrol: mixer control
2704 * @uinfo: control element information
2705 *
2706 * Returns 0 for success.
2707 */
2708int snd_soc_put_volsw_2r_sx(struct snd_kcontrol *kcontrol,
2709 struct snd_ctl_elem_value *ucontrol)
2710{
2711 struct soc_mixer_control *mc =
2712 (struct soc_mixer_control *)kcontrol->private_value;
2713 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2714 unsigned int mask = (1<<mc->shift)-1;
2715 int min = mc->min;
2716 int ret;
2717 unsigned int val, valr, oval, ovalr;
2718
2719 val = ((ucontrol->value.integer.value[0]+min) & 0xff);
2720 val &= mask;
2721 valr = ((ucontrol->value.integer.value[1]+min) & 0xff);
2722 valr &= mask;
2723
2724 oval = snd_soc_read(codec, mc->reg) & mask;
2725 ovalr = snd_soc_read(codec, mc->rreg) & mask;
2726
2727 ret = 0;
2728 if (oval != val) {
2729 ret = snd_soc_write(codec, mc->reg, val);
2730 if (ret < 0)
Mark Brownf1df5ae2010-06-15 15:14:31 +01002731 return ret;
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02002732 }
2733 if (ovalr != valr) {
2734 ret = snd_soc_write(codec, mc->rreg, valr);
2735 if (ret < 0)
Mark Brownf1df5ae2010-06-15 15:14:31 +01002736 return ret;
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02002737 }
2738
2739 return 0;
2740}
2741EXPORT_SYMBOL_GPL(snd_soc_put_volsw_2r_sx);
2742
Mark Brown71d08512011-10-10 18:31:26 +01002743int snd_soc_bytes_info(struct snd_kcontrol *kcontrol,
2744 struct snd_ctl_elem_info *uinfo)
2745{
2746 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2747 struct soc_bytes *params = (void *)kcontrol->private_value;
2748
2749 uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
2750 uinfo->count = params->num_regs * codec->val_bytes;
2751
2752 return 0;
2753}
2754EXPORT_SYMBOL_GPL(snd_soc_bytes_info);
2755
2756int snd_soc_bytes_get(struct snd_kcontrol *kcontrol,
2757 struct snd_ctl_elem_value *ucontrol)
2758{
2759 struct soc_bytes *params = (void *)kcontrol->private_value;
2760 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
2761 int ret;
2762
2763 if (codec->using_regmap)
2764 ret = regmap_raw_read(codec->control_data, params->base,
2765 ucontrol->value.bytes.data,
2766 params->num_regs * codec->val_bytes);
2767 else
2768 ret = -EINVAL;
2769
Mark Brownf831b052012-02-17 16:20:33 -08002770 /* Hide any masked bytes to ensure consistent data reporting */
2771 if (ret == 0 && params->mask) {
2772 switch (codec->val_bytes) {
2773 case 1:
2774 ucontrol->value.bytes.data[0] &= ~params->mask;
2775 break;
2776 case 2:
2777 ((u16 *)(&ucontrol->value.bytes.data))[0]
2778 &= ~params->mask;
2779 break;
2780 case 4:
2781 ((u32 *)(&ucontrol->value.bytes.data))[0]
2782 &= ~params->mask;
2783 break;
2784 default:
2785 return -EINVAL;
2786 }
2787 }
2788
Mark Brown71d08512011-10-10 18:31:26 +01002789 return ret;
2790}
2791EXPORT_SYMBOL_GPL(snd_soc_bytes_get);
2792
2793int snd_soc_bytes_put(struct snd_kcontrol *kcontrol,
2794 struct snd_ctl_elem_value *ucontrol)
2795{
2796 struct soc_bytes *params = (void *)kcontrol->private_value;
2797 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
Mark Brownf831b052012-02-17 16:20:33 -08002798 int ret, len;
2799 unsigned int val;
2800 void *data;
Mark Brown71d08512011-10-10 18:31:26 +01002801
Mark Brownf831b052012-02-17 16:20:33 -08002802 if (!codec->using_regmap)
2803 return -EINVAL;
2804
2805 data = ucontrol->value.bytes.data;
2806 len = params->num_regs * codec->val_bytes;
2807
2808 /*
2809 * If we've got a mask then we need to preserve the register
2810 * bits. We shouldn't modify the incoming data so take a
2811 * copy.
2812 */
2813 if (params->mask) {
2814 ret = regmap_read(codec->control_data, params->base, &val);
2815 if (ret != 0)
2816 return ret;
2817
2818 val &= params->mask;
2819
2820 data = kmemdup(data, len, GFP_KERNEL);
2821 if (!data)
2822 return -ENOMEM;
2823
2824 switch (codec->val_bytes) {
2825 case 1:
2826 ((u8 *)data)[0] &= ~params->mask;
2827 ((u8 *)data)[0] |= val;
2828 break;
2829 case 2:
2830 ((u16 *)data)[0] &= cpu_to_be16(~params->mask);
2831 ((u16 *)data)[0] |= cpu_to_be16(val);
2832 break;
2833 case 4:
2834 ((u32 *)data)[0] &= cpu_to_be32(~params->mask);
2835 ((u32 *)data)[0] |= cpu_to_be32(val);
2836 break;
2837 default:
2838 return -EINVAL;
2839 }
2840 }
2841
2842 ret = regmap_raw_write(codec->control_data, params->base,
2843 data, len);
2844
2845 if (params->mask)
2846 kfree(data);
Mark Brown71d08512011-10-10 18:31:26 +01002847
2848 return ret;
2849}
2850EXPORT_SYMBOL_GPL(snd_soc_bytes_put);
2851
apatard@mandriva.comb6f4bb32010-05-15 17:30:01 +02002852/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002853 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2854 * @dai: DAI
2855 * @clk_id: DAI specific clock ID
2856 * @freq: new clock frequency in Hz
2857 * @dir: new clock direction - input/output.
2858 *
2859 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2860 */
2861int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2862 unsigned int freq, int dir)
2863{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002864 if (dai->driver && dai->driver->ops->set_sysclk)
2865 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
Mark Brownec4ee522011-03-07 20:58:11 +00002866 else if (dai->codec && dai->codec->driver->set_sysclk)
Mark Brownda1c6ea2011-08-24 20:09:01 +01002867 return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,
Mark Brownec4ee522011-03-07 20:58:11 +00002868 freq, dir);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002869 else
2870 return -EINVAL;
2871}
2872EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
2873
2874/**
Mark Brownec4ee522011-03-07 20:58:11 +00002875 * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
2876 * @codec: CODEC
2877 * @clk_id: DAI specific clock ID
Mark Brownda1c6ea2011-08-24 20:09:01 +01002878 * @source: Source for the clock
Mark Brownec4ee522011-03-07 20:58:11 +00002879 * @freq: new clock frequency in Hz
2880 * @dir: new clock direction - input/output.
2881 *
2882 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
2883 */
2884int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
Mark Brownda1c6ea2011-08-24 20:09:01 +01002885 int source, unsigned int freq, int dir)
Mark Brownec4ee522011-03-07 20:58:11 +00002886{
2887 if (codec->driver->set_sysclk)
Mark Brownda1c6ea2011-08-24 20:09:01 +01002888 return codec->driver->set_sysclk(codec, clk_id, source,
2889 freq, dir);
Mark Brownec4ee522011-03-07 20:58:11 +00002890 else
2891 return -EINVAL;
2892}
2893EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
2894
2895/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002896 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
2897 * @dai: DAI
Mark Brownac11a2b2009-01-01 12:18:17 +00002898 * @div_id: DAI specific clock divider ID
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002899 * @div: new clock divisor.
2900 *
2901 * Configures the clock dividers. This is used to derive the best DAI bit and
2902 * frame clocks from the system or master clock. It's best to set the DAI bit
2903 * and frame clocks as low as possible to save system power.
2904 */
2905int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2906 int div_id, int div)
2907{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002908 if (dai->driver && dai->driver->ops->set_clkdiv)
2909 return dai->driver->ops->set_clkdiv(dai, div_id, div);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002910 else
2911 return -EINVAL;
2912}
2913EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
2914
2915/**
2916 * snd_soc_dai_set_pll - configure DAI PLL.
2917 * @dai: DAI
2918 * @pll_id: DAI specific PLL ID
Mark Brown85488032009-09-05 18:52:16 +01002919 * @source: DAI specific source for the PLL
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002920 * @freq_in: PLL input clock frequency in Hz
2921 * @freq_out: requested PLL output clock frequency in Hz
2922 *
2923 * Configures and enables PLL to generate output clock based on input clock.
2924 */
Mark Brown85488032009-09-05 18:52:16 +01002925int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
2926 unsigned int freq_in, unsigned int freq_out)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002927{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002928 if (dai->driver && dai->driver->ops->set_pll)
2929 return dai->driver->ops->set_pll(dai, pll_id, source,
Mark Brown85488032009-09-05 18:52:16 +01002930 freq_in, freq_out);
Mark Brownec4ee522011-03-07 20:58:11 +00002931 else if (dai->codec && dai->codec->driver->set_pll)
2932 return dai->codec->driver->set_pll(dai->codec, pll_id, source,
2933 freq_in, freq_out);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002934 else
2935 return -EINVAL;
2936}
2937EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
2938
Mark Brownec4ee522011-03-07 20:58:11 +00002939/*
2940 * snd_soc_codec_set_pll - configure codec PLL.
2941 * @codec: CODEC
2942 * @pll_id: DAI specific PLL ID
2943 * @source: DAI specific source for the PLL
2944 * @freq_in: PLL input clock frequency in Hz
2945 * @freq_out: requested PLL output clock frequency in Hz
2946 *
2947 * Configures and enables PLL to generate output clock based on input clock.
2948 */
2949int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
2950 unsigned int freq_in, unsigned int freq_out)
2951{
2952 if (codec->driver->set_pll)
2953 return codec->driver->set_pll(codec, pll_id, source,
2954 freq_in, freq_out);
2955 else
2956 return -EINVAL;
2957}
2958EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);
2959
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002960/**
2961 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
2962 * @dai: DAI
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002963 * @fmt: SND_SOC_DAIFMT_ format value.
2964 *
2965 * Configures the DAI hardware format and clocking.
2966 */
2967int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2968{
Shawn Guo5e4ba562012-03-09 00:59:40 +08002969 if (dai->driver == NULL)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002970 return -EINVAL;
Shawn Guo5e4ba562012-03-09 00:59:40 +08002971 if (dai->driver->ops->set_fmt == NULL)
2972 return -ENOTSUPP;
2973 return dai->driver->ops->set_fmt(dai, fmt);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002974}
2975EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
2976
2977/**
2978 * snd_soc_dai_set_tdm_slot - configure DAI TDM.
2979 * @dai: DAI
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002980 * @tx_mask: bitmask representing active TX slots.
2981 * @rx_mask: bitmask representing active RX slots.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002982 * @slots: Number of slots in use.
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002983 * @slot_width: Width in bits for each slot.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002984 *
2985 * Configures a DAI for TDM operation. Both mask and slots are codec and DAI
2986 * specific.
2987 */
2988int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002989 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002990{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002991 if (dai->driver && dai->driver->ops->set_tdm_slot)
2992 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002993 slots, slot_width);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002994 else
2995 return -EINVAL;
2996}
2997EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
2998
2999/**
Barry Song472df3c2009-09-12 01:16:29 +08003000 * snd_soc_dai_set_channel_map - configure DAI audio channel map
3001 * @dai: DAI
3002 * @tx_num: how many TX channels
3003 * @tx_slot: pointer to an array which imply the TX slot number channel
3004 * 0~num-1 uses
3005 * @rx_num: how many RX channels
3006 * @rx_slot: pointer to an array which imply the RX slot number channel
3007 * 0~num-1 uses
3008 *
3009 * configure the relationship between channel number and TDM slot number.
3010 */
3011int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
3012 unsigned int tx_num, unsigned int *tx_slot,
3013 unsigned int rx_num, unsigned int *rx_slot)
3014{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003015 if (dai->driver && dai->driver->ops->set_channel_map)
3016 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
Barry Song472df3c2009-09-12 01:16:29 +08003017 rx_num, rx_slot);
3018 else
3019 return -EINVAL;
3020}
3021EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
3022
3023/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003024 * snd_soc_dai_set_tristate - configure DAI system or master clock.
3025 * @dai: DAI
3026 * @tristate: tristate enable
3027 *
3028 * Tristates the DAI so that others can use it.
3029 */
3030int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
3031{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003032 if (dai->driver && dai->driver->ops->set_tristate)
3033 return dai->driver->ops->set_tristate(dai, tristate);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003034 else
3035 return -EINVAL;
3036}
3037EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
3038
3039/**
3040 * snd_soc_dai_digital_mute - configure DAI system or master clock.
3041 * @dai: DAI
3042 * @mute: mute enable
3043 *
3044 * Mutes the DAI DAC.
3045 */
3046int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute)
3047{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003048 if (dai->driver && dai->driver->ops->digital_mute)
3049 return dai->driver->ops->digital_mute(dai, mute);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01003050 else
3051 return -EINVAL;
3052}
3053EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
3054
Mark Brownc5af3a22008-11-28 13:29:45 +00003055/**
3056 * snd_soc_register_card - Register a card with the ASoC core
3057 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003058 * @card: Card to register
Mark Brownc5af3a22008-11-28 13:29:45 +00003059 *
Mark Brownc5af3a22008-11-28 13:29:45 +00003060 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05303061int snd_soc_register_card(struct snd_soc_card *card)
Mark Brownc5af3a22008-11-28 13:29:45 +00003062{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003063 int i;
3064
Mark Brownc5af3a22008-11-28 13:29:45 +00003065 if (!card->name || !card->dev)
3066 return -EINVAL;
3067
Stephen Warren5a504962011-12-21 10:40:59 -07003068 for (i = 0; i < card->num_links; i++) {
3069 struct snd_soc_dai_link *link = &card->dai_link[i];
3070
3071 /*
3072 * Codec must be specified by 1 of name or OF node,
3073 * not both or neither.
3074 */
3075 if (!!link->codec_name == !!link->codec_of_node) {
3076 dev_err(card->dev,
Liam Girdwood3b09bb82012-01-09 12:09:29 +00003077 "Neither/both codec name/of_node are set for %s\n",
3078 link->name);
Stephen Warren5a504962011-12-21 10:40:59 -07003079 return -EINVAL;
3080 }
3081
3082 /*
3083 * Platform may be specified by either name or OF node, but
3084 * can be left unspecified, and a dummy platform will be used.
3085 */
3086 if (link->platform_name && link->platform_of_node) {
3087 dev_err(card->dev,
Liam Girdwood3b09bb82012-01-09 12:09:29 +00003088 "Both platform name/of_node are set for %s\n", link->name);
Stephen Warren5a504962011-12-21 10:40:59 -07003089 return -EINVAL;
3090 }
3091
3092 /*
3093 * CPU DAI must be specified by 1 of name or OF node,
3094 * not both or neither.
3095 */
3096 if (!!link->cpu_dai_name == !!link->cpu_dai_of_node) {
3097 dev_err(card->dev,
Liam Girdwood3b09bb82012-01-09 12:09:29 +00003098 "Neither/both cpu_dai name/of_node are set for %s\n",
3099 link->name);
Stephen Warren5a504962011-12-21 10:40:59 -07003100 return -EINVAL;
3101 }
3102 }
3103
Mark Browned77cc12011-05-03 18:25:34 +01003104 dev_set_drvdata(card->dev, card);
3105
Stephen Warren111c6412011-01-28 14:26:35 -07003106 snd_soc_initialize_card_lists(card);
3107
Vinod Koul150dd2f2011-01-13 22:48:32 +05303108 soc_init_card_debugfs(card);
3109
Mark Brown181a6892012-03-14 20:18:49 +00003110 card->rtd = devm_kzalloc(card->dev,
3111 sizeof(struct snd_soc_pcm_runtime) *
3112 (card->num_links + card->num_aux_devs),
3113 GFP_KERNEL);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003114 if (card->rtd == NULL)
3115 return -ENOMEM;
Liam Girdwooda7dbb602012-04-17 18:00:11 +01003116 card->num_rtd = 0;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02003117 card->rtd_aux = &card->rtd[card->num_links];
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003118
3119 for (i = 0; i < card->num_links; i++)
3120 card->rtd[i].dai_link = &card->dai_link[i];
3121
Mark Brownc5af3a22008-11-28 13:29:45 +00003122 INIT_LIST_HEAD(&card->list);
Mark Browndb432b42011-10-03 21:06:40 +01003123 INIT_LIST_HEAD(&card->dapm_dirty);
Mark Brownc5af3a22008-11-28 13:29:45 +00003124 card->instantiated = 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003125 mutex_init(&card->mutex);
Mark Brownc5af3a22008-11-28 13:29:45 +00003126
3127 mutex_lock(&client_mutex);
3128 list_add(&card->list, &card_list);
Mark Brown435c5e22008-12-04 15:32:53 +00003129 snd_soc_instantiate_cards();
Mark Brownc5af3a22008-11-28 13:29:45 +00003130 mutex_unlock(&client_mutex);
3131
3132 dev_dbg(card->dev, "Registered card '%s'\n", card->name);
3133
3134 return 0;
3135}
Vinod Koul70a7ca32011-01-14 19:22:48 +05303136EXPORT_SYMBOL_GPL(snd_soc_register_card);
Mark Brownc5af3a22008-11-28 13:29:45 +00003137
3138/**
3139 * snd_soc_unregister_card - Unregister a card with the ASoC core
3140 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003141 * @card: Card to unregister
Mark Brownc5af3a22008-11-28 13:29:45 +00003142 *
Mark Brownc5af3a22008-11-28 13:29:45 +00003143 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05303144int snd_soc_unregister_card(struct snd_soc_card *card)
Mark Brownc5af3a22008-11-28 13:29:45 +00003145{
Vinod Koulb0e26482011-01-13 22:48:02 +05303146 if (card->instantiated)
3147 soc_cleanup_card_resources(card);
Mark Brownc5af3a22008-11-28 13:29:45 +00003148 mutex_lock(&client_mutex);
3149 list_del(&card->list);
3150 mutex_unlock(&client_mutex);
Mark Brownc5af3a22008-11-28 13:29:45 +00003151 dev_dbg(card->dev, "Unregistered card '%s'\n", card->name);
3152
3153 return 0;
3154}
Vinod Koul70a7ca32011-01-14 19:22:48 +05303155EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
Mark Brownc5af3a22008-11-28 13:29:45 +00003156
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003157/*
3158 * Simplify DAI link configuration by removing ".-1" from device names
3159 * and sanitizing names.
3160 */
Dimitris Papastamos0b9a2142010-12-06 15:49:20 +00003161static char *fmt_single_name(struct device *dev, int *id)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003162{
3163 char *found, name[NAME_SIZE];
3164 int id1, id2;
3165
3166 if (dev_name(dev) == NULL)
3167 return NULL;
3168
Dimitris Papastamos58818a72010-12-06 15:42:17 +00003169 strlcpy(name, dev_name(dev), NAME_SIZE);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003170
3171 /* are we a "%s.%d" name (platform and SPI components) */
3172 found = strstr(name, dev->driver->name);
3173 if (found) {
3174 /* get ID */
3175 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
3176
3177 /* discard ID from name if ID == -1 */
3178 if (*id == -1)
3179 found[strlen(dev->driver->name)] = '\0';
3180 }
3181
3182 } else {
3183 /* I2C component devices are named "bus-addr" */
3184 if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
3185 char tmp[NAME_SIZE];
3186
3187 /* create unique ID number from I2C addr and bus */
Jarkko Nikula05899442010-10-19 11:10:45 +03003188 *id = ((id1 & 0xffff) << 16) + id2;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003189
3190 /* sanitize component name for DAI link creation */
3191 snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
Dimitris Papastamos58818a72010-12-06 15:42:17 +00003192 strlcpy(name, tmp, NAME_SIZE);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003193 } else
3194 *id = 0;
3195 }
3196
3197 return kstrdup(name, GFP_KERNEL);
3198}
3199
3200/*
3201 * Simplify DAI link naming for single devices with multiple DAIs by removing
3202 * any ".-1" and using the DAI name (instead of device name).
3203 */
3204static inline char *fmt_multiple_name(struct device *dev,
3205 struct snd_soc_dai_driver *dai_drv)
3206{
3207 if (dai_drv->name == NULL) {
Fabio Estevam0837fc62012-02-17 19:40:38 -02003208 pr_err("asoc: error - multiple DAI %s registered with no name\n",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003209 dev_name(dev));
3210 return NULL;
3211 }
3212
3213 return kstrdup(dai_drv->name, GFP_KERNEL);
3214}
3215
Mark Brown91151712008-11-30 23:31:24 +00003216/**
3217 * snd_soc_register_dai - Register a DAI with the ASoC core
3218 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003219 * @dai: DAI to register
Mark Brown91151712008-11-30 23:31:24 +00003220 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003221int snd_soc_register_dai(struct device *dev,
3222 struct snd_soc_dai_driver *dai_drv)
Mark Brown91151712008-11-30 23:31:24 +00003223{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003224 struct snd_soc_dai *dai;
Mark Brown91151712008-11-30 23:31:24 +00003225
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003226 dev_dbg(dev, "dai register %s\n", dev_name(dev));
Mark Brown91151712008-11-30 23:31:24 +00003227
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003228 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
3229 if (dai == NULL)
Lu Guanquna7393622011-04-20 16:00:51 +08003230 return -ENOMEM;
Eric Miao6335d052009-03-03 09:41:00 +08003231
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003232 /* create DAI component name */
3233 dai->name = fmt_single_name(dev, &dai->id);
3234 if (dai->name == NULL) {
3235 kfree(dai);
3236 return -ENOMEM;
3237 }
3238
3239 dai->dev = dev;
3240 dai->driver = dai_drv;
3241 if (!dai->driver->ops)
3242 dai->driver->ops = &null_dai_ops;
Mark Brown91151712008-11-30 23:31:24 +00003243
3244 mutex_lock(&client_mutex);
3245 list_add(&dai->list, &dai_list);
Mark Brown435c5e22008-12-04 15:32:53 +00003246 snd_soc_instantiate_cards();
Mark Brown91151712008-11-30 23:31:24 +00003247 mutex_unlock(&client_mutex);
3248
3249 pr_debug("Registered DAI '%s'\n", dai->name);
3250
3251 return 0;
3252}
3253EXPORT_SYMBOL_GPL(snd_soc_register_dai);
3254
3255/**
3256 * snd_soc_unregister_dai - Unregister a DAI from the ASoC core
3257 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003258 * @dai: DAI to unregister
Mark Brown91151712008-11-30 23:31:24 +00003259 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003260void snd_soc_unregister_dai(struct device *dev)
Mark Brown91151712008-11-30 23:31:24 +00003261{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003262 struct snd_soc_dai *dai;
3263
3264 list_for_each_entry(dai, &dai_list, list) {
3265 if (dev == dai->dev)
3266 goto found;
3267 }
3268 return;
3269
3270found:
Mark Brown91151712008-11-30 23:31:24 +00003271 mutex_lock(&client_mutex);
3272 list_del(&dai->list);
3273 mutex_unlock(&client_mutex);
3274
3275 pr_debug("Unregistered DAI '%s'\n", dai->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003276 kfree(dai->name);
3277 kfree(dai);
Mark Brown91151712008-11-30 23:31:24 +00003278}
3279EXPORT_SYMBOL_GPL(snd_soc_unregister_dai);
3280
3281/**
3282 * snd_soc_register_dais - Register multiple DAIs with the ASoC core
3283 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003284 * @dai: Array of DAIs to register
3285 * @count: Number of DAIs
Mark Brown91151712008-11-30 23:31:24 +00003286 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003287int snd_soc_register_dais(struct device *dev,
3288 struct snd_soc_dai_driver *dai_drv, size_t count)
Mark Brown91151712008-11-30 23:31:24 +00003289{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003290 struct snd_soc_dai *dai;
3291 int i, ret = 0;
3292
Liam Girdwood720ffa42010-08-18 00:30:30 +01003293 dev_dbg(dev, "dai register %s #%Zu\n", dev_name(dev), count);
Mark Brown91151712008-11-30 23:31:24 +00003294
3295 for (i = 0; i < count; i++) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003296
3297 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
Axel Linc46e0072010-11-03 15:04:45 +08003298 if (dai == NULL) {
3299 ret = -ENOMEM;
3300 goto err;
3301 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003302
3303 /* create DAI component name */
3304 dai->name = fmt_multiple_name(dev, &dai_drv[i]);
3305 if (dai->name == NULL) {
3306 kfree(dai);
3307 ret = -EINVAL;
Mark Brown91151712008-11-30 23:31:24 +00003308 goto err;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003309 }
3310
3311 dai->dev = dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003312 dai->driver = &dai_drv[i];
Mark Brown0f9141c2010-10-12 15:43:21 +01003313 if (dai->driver->id)
3314 dai->id = dai->driver->id;
3315 else
3316 dai->id = i;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003317 if (!dai->driver->ops)
3318 dai->driver->ops = &null_dai_ops;
3319
3320 mutex_lock(&client_mutex);
3321 list_add(&dai->list, &dai_list);
3322 mutex_unlock(&client_mutex);
3323
3324 pr_debug("Registered DAI '%s'\n", dai->name);
Mark Brown91151712008-11-30 23:31:24 +00003325 }
3326
Axel Lin1dcb4f32010-12-06 16:48:03 +08003327 mutex_lock(&client_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003328 snd_soc_instantiate_cards();
Axel Lin1dcb4f32010-12-06 16:48:03 +08003329 mutex_unlock(&client_mutex);
Mark Brown91151712008-11-30 23:31:24 +00003330 return 0;
3331
3332err:
3333 for (i--; i >= 0; i--)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003334 snd_soc_unregister_dai(dev);
Mark Brown91151712008-11-30 23:31:24 +00003335
3336 return ret;
3337}
3338EXPORT_SYMBOL_GPL(snd_soc_register_dais);
3339
3340/**
3341 * snd_soc_unregister_dais - Unregister multiple DAIs from the ASoC core
3342 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003343 * @dai: Array of DAIs to unregister
3344 * @count: Number of DAIs
Mark Brown91151712008-11-30 23:31:24 +00003345 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003346void snd_soc_unregister_dais(struct device *dev, size_t count)
Mark Brown91151712008-11-30 23:31:24 +00003347{
3348 int i;
3349
3350 for (i = 0; i < count; i++)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003351 snd_soc_unregister_dai(dev);
Mark Brown91151712008-11-30 23:31:24 +00003352}
3353EXPORT_SYMBOL_GPL(snd_soc_unregister_dais);
3354
Mark Brown12a48a8c2008-12-03 19:40:30 +00003355/**
3356 * snd_soc_register_platform - Register a platform with the ASoC core
3357 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003358 * @platform: platform to register
Mark Brown12a48a8c2008-12-03 19:40:30 +00003359 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003360int snd_soc_register_platform(struct device *dev,
3361 struct snd_soc_platform_driver *platform_drv)
Mark Brown12a48a8c2008-12-03 19:40:30 +00003362{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003363 struct snd_soc_platform *platform;
Mark Brown12a48a8c2008-12-03 19:40:30 +00003364
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003365 dev_dbg(dev, "platform register %s\n", dev_name(dev));
3366
3367 platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
3368 if (platform == NULL)
Lu Guanquna7393622011-04-20 16:00:51 +08003369 return -ENOMEM;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003370
3371 /* create platform component name */
3372 platform->name = fmt_single_name(dev, &platform->id);
3373 if (platform->name == NULL) {
3374 kfree(platform);
3375 return -ENOMEM;
3376 }
3377
3378 platform->dev = dev;
3379 platform->driver = platform_drv;
Liam Girdwoodb7950642011-07-04 22:10:52 +01003380 platform->dapm.dev = dev;
3381 platform->dapm.platform = platform;
Liam Girdwood64a648c2011-07-25 11:15:15 +01003382 platform->dapm.stream_event = platform_drv->stream_event;
Liam Girdwoodcc22d372012-03-06 18:16:18 +00003383 mutex_init(&platform->mutex);
Mark Brown12a48a8c2008-12-03 19:40:30 +00003384
3385 mutex_lock(&client_mutex);
3386 list_add(&platform->list, &platform_list);
Mark Brown435c5e22008-12-04 15:32:53 +00003387 snd_soc_instantiate_cards();
Mark Brown12a48a8c2008-12-03 19:40:30 +00003388 mutex_unlock(&client_mutex);
3389
3390 pr_debug("Registered platform '%s'\n", platform->name);
3391
3392 return 0;
3393}
3394EXPORT_SYMBOL_GPL(snd_soc_register_platform);
3395
3396/**
3397 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
3398 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003399 * @platform: platform to unregister
Mark Brown12a48a8c2008-12-03 19:40:30 +00003400 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003401void snd_soc_unregister_platform(struct device *dev)
Mark Brown12a48a8c2008-12-03 19:40:30 +00003402{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003403 struct snd_soc_platform *platform;
3404
3405 list_for_each_entry(platform, &platform_list, list) {
3406 if (dev == platform->dev)
3407 goto found;
3408 }
3409 return;
3410
3411found:
Mark Brown12a48a8c2008-12-03 19:40:30 +00003412 mutex_lock(&client_mutex);
3413 list_del(&platform->list);
3414 mutex_unlock(&client_mutex);
3415
3416 pr_debug("Unregistered platform '%s'\n", platform->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003417 kfree(platform->name);
3418 kfree(platform);
Mark Brown12a48a8c2008-12-03 19:40:30 +00003419}
3420EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
3421
Mark Brown151ab222009-05-09 16:22:58 +01003422static u64 codec_format_map[] = {
3423 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
3424 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
3425 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
3426 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
3427 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
3428 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
3429 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3430 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3431 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
3432 SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
3433 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
3434 SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
3435 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
3436 SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
3437 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
3438 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
3439};
3440
3441/* Fix up the DAI formats for endianness: codecs don't actually see
3442 * the endianness of the data but we're using the CPU format
3443 * definitions which do need to include endianness so we ensure that
3444 * codec DAIs always have both big and little endian variants set.
3445 */
3446static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
3447{
3448 int i;
3449
3450 for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
3451 if (stream->formats & codec_format_map[i])
3452 stream->formats |= codec_format_map[i];
3453}
3454
Mark Brown0d0cf002008-12-10 14:32:45 +00003455/**
3456 * snd_soc_register_codec - Register a codec with the ASoC core
3457 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003458 * @codec: codec to register
Mark Brown0d0cf002008-12-10 14:32:45 +00003459 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003460int snd_soc_register_codec(struct device *dev,
Mark Brown001ae4c2010-12-02 16:21:08 +00003461 const struct snd_soc_codec_driver *codec_drv,
3462 struct snd_soc_dai_driver *dai_drv,
3463 int num_dai)
Mark Brown0d0cf002008-12-10 14:32:45 +00003464{
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003465 size_t reg_size;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003466 struct snd_soc_codec *codec;
3467 int ret, i;
Mark Brown151ab222009-05-09 16:22:58 +01003468
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003469 dev_dbg(dev, "codec register %s\n", dev_name(dev));
Mark Brown0d0cf002008-12-10 14:32:45 +00003470
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003471 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
3472 if (codec == NULL)
3473 return -ENOMEM;
Mark Brown0d0cf002008-12-10 14:32:45 +00003474
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003475 /* create CODEC component name */
3476 codec->name = fmt_single_name(dev, &codec->id);
3477 if (codec->name == NULL) {
3478 kfree(codec);
3479 return -ENOMEM;
Mark Brown151ab222009-05-09 16:22:58 +01003480 }
3481
Dimitris Papastamos23bbce32010-12-02 14:53:01 +00003482 if (codec_drv->compress_type)
3483 codec->compress_type = codec_drv->compress_type;
3484 else
3485 codec->compress_type = SND_SOC_FLAT_COMPRESSION;
3486
Mark Brownc3acec22010-12-02 16:15:29 +00003487 codec->write = codec_drv->write;
3488 codec->read = codec_drv->read;
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00003489 codec->volatile_register = codec_drv->volatile_register;
3490 codec->readable_register = codec_drv->readable_register;
Dimitris Papastamos80204542011-03-24 13:45:17 +00003491 codec->writable_register = codec_drv->writable_register;
Mark Brown5124e692012-02-08 13:20:50 +00003492 codec->ignore_pmdown_time = codec_drv->ignore_pmdown_time;
Liam Girdwoodce6120c2010-11-05 15:53:46 +02003493 codec->dapm.bias_level = SND_SOC_BIAS_OFF;
3494 codec->dapm.dev = dev;
3495 codec->dapm.codec = codec;
Mark Brown474b62d2011-01-18 16:14:44 +00003496 codec->dapm.seq_notifier = codec_drv->seq_notifier;
Liam Girdwood64a648c2011-07-25 11:15:15 +01003497 codec->dapm.stream_event = codec_drv->stream_event;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003498 codec->dev = dev;
3499 codec->driver = codec_drv;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003500 codec->num_dai = num_dai;
3501 mutex_init(&codec->mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003502
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003503 /* allocate CODEC register cache */
3504 if (codec_drv->reg_cache_size && codec_drv->reg_word_size) {
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003505 reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
Dimitris Papastamosaea170a2011-01-12 10:38:58 +00003506 codec->reg_size = reg_size;
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003507 /* it is necessary to make a copy of the default register cache
3508 * because in the case of using a compression type that requires
3509 * the default register cache to be marked as __devinitconst the
3510 * kernel might have freed the array by the time we initialize
3511 * the cache.
3512 */
Dimitris Papastamos2aa86322011-01-10 10:10:56 +00003513 if (codec_drv->reg_cache_default) {
3514 codec->reg_def_copy = kmemdup(codec_drv->reg_cache_default,
3515 reg_size, GFP_KERNEL);
3516 if (!codec->reg_def_copy) {
3517 ret = -ENOMEM;
3518 goto fail;
3519 }
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003520 }
3521 }
3522
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00003523 if (codec_drv->reg_access_size && codec_drv->reg_access_default) {
3524 if (!codec->volatile_register)
3525 codec->volatile_register = snd_soc_default_volatile_register;
3526 if (!codec->readable_register)
3527 codec->readable_register = snd_soc_default_readable_register;
Dimitris Papastamos80204542011-03-24 13:45:17 +00003528 if (!codec->writable_register)
3529 codec->writable_register = snd_soc_default_writable_register;
Dimitris Papastamos1500b7b2011-01-13 12:20:38 +00003530 }
3531
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003532 for (i = 0; i < num_dai; i++) {
3533 fixup_codec_formats(&dai_drv[i].playback);
3534 fixup_codec_formats(&dai_drv[i].capture);
3535 }
3536
Mark Brown26b01cc2010-08-18 20:20:55 +01003537 /* register any DAIs */
3538 if (num_dai) {
3539 ret = snd_soc_register_dais(dev, dai_drv, num_dai);
3540 if (ret < 0)
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00003541 goto fail;
Mark Brown26b01cc2010-08-18 20:20:55 +01003542 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003543
Mark Brown0d0cf002008-12-10 14:32:45 +00003544 mutex_lock(&client_mutex);
3545 list_add(&codec->list, &codec_list);
3546 snd_soc_instantiate_cards();
3547 mutex_unlock(&client_mutex);
3548
3549 pr_debug("Registered codec '%s'\n", codec->name);
Mark Brown0d0cf002008-12-10 14:32:45 +00003550 return 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003551
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00003552fail:
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003553 kfree(codec->reg_def_copy);
3554 codec->reg_def_copy = NULL;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003555 kfree(codec->name);
3556 kfree(codec);
3557 return ret;
Mark Brown0d0cf002008-12-10 14:32:45 +00003558}
3559EXPORT_SYMBOL_GPL(snd_soc_register_codec);
3560
3561/**
3562 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
3563 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003564 * @codec: codec to unregister
Mark Brown0d0cf002008-12-10 14:32:45 +00003565 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003566void snd_soc_unregister_codec(struct device *dev)
Mark Brown0d0cf002008-12-10 14:32:45 +00003567{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003568 struct snd_soc_codec *codec;
3569 int i;
3570
3571 list_for_each_entry(codec, &codec_list, list) {
3572 if (dev == codec->dev)
3573 goto found;
3574 }
3575 return;
3576
3577found:
Mark Brown26b01cc2010-08-18 20:20:55 +01003578 if (codec->num_dai)
3579 for (i = 0; i < codec->num_dai; i++)
3580 snd_soc_unregister_dai(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003581
Mark Brown0d0cf002008-12-10 14:32:45 +00003582 mutex_lock(&client_mutex);
3583 list_del(&codec->list);
3584 mutex_unlock(&client_mutex);
3585
3586 pr_debug("Unregistered codec '%s'\n", codec->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003587
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003588 snd_soc_cache_exit(codec);
Dimitris Papastamos3335ddc2010-12-02 16:11:05 +00003589 kfree(codec->reg_def_copy);
Dimitris Papastamos1aafcd42010-10-21 13:19:45 +01003590 kfree(codec->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003591 kfree(codec);
Mark Brown0d0cf002008-12-10 14:32:45 +00003592}
3593EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
3594
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003595/* Retrieve a card's name from device tree */
3596int snd_soc_of_parse_card_name(struct snd_soc_card *card,
3597 const char *propname)
3598{
3599 struct device_node *np = card->dev->of_node;
3600 int ret;
3601
3602 ret = of_property_read_string_index(np, propname, 0, &card->name);
3603 /*
3604 * EINVAL means the property does not exist. This is fine providing
3605 * card->name was previously set, which is checked later in
3606 * snd_soc_register_card.
3607 */
3608 if (ret < 0 && ret != -EINVAL) {
3609 dev_err(card->dev,
3610 "Property '%s' could not be read: %d\n",
3611 propname, ret);
3612 return ret;
3613 }
3614
3615 return 0;
3616}
3617EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
3618
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003619int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
3620 const char *propname)
3621{
3622 struct device_node *np = card->dev->of_node;
3623 int num_routes;
3624 struct snd_soc_dapm_route *routes;
3625 int i, ret;
3626
3627 num_routes = of_property_count_strings(np, propname);
Richard Zhaoc34ce322012-04-24 15:24:43 +08003628 if (num_routes < 0 || num_routes & 1) {
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003629 dev_err(card->dev,
Richard Zhaoc34ce322012-04-24 15:24:43 +08003630 "Property '%s' does not exist or its length is not even\n",
3631 propname);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003632 return -EINVAL;
3633 }
3634 num_routes /= 2;
3635 if (!num_routes) {
3636 dev_err(card->dev,
3637 "Property '%s's length is zero\n",
3638 propname);
3639 return -EINVAL;
3640 }
3641
3642 routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),
3643 GFP_KERNEL);
3644 if (!routes) {
3645 dev_err(card->dev,
3646 "Could not allocate DAPM route table\n");
3647 return -EINVAL;
3648 }
3649
3650 for (i = 0; i < num_routes; i++) {
3651 ret = of_property_read_string_index(np, propname,
3652 2 * i, &routes[i].sink);
3653 if (ret) {
3654 dev_err(card->dev,
3655 "Property '%s' index %d could not be read: %d\n",
3656 propname, 2 * i, ret);
3657 return -EINVAL;
3658 }
3659 ret = of_property_read_string_index(np, propname,
3660 (2 * i) + 1, &routes[i].source);
3661 if (ret) {
3662 dev_err(card->dev,
3663 "Property '%s' index %d could not be read: %d\n",
3664 propname, (2 * i) + 1, ret);
3665 return -EINVAL;
3666 }
3667 }
3668
3669 card->num_dapm_routes = num_routes;
3670 card->dapm_routes = routes;
3671
3672 return 0;
3673}
3674EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
3675
Takashi Iwaic9b3a402008-12-10 07:47:22 +01003676static int __init snd_soc_init(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003677{
Mark Brown384c89e2008-12-03 17:34:03 +00003678#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +00003679 snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
3680 if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
Fabio Estevam0837fc62012-02-17 19:40:38 -02003681 pr_warn("ASoC: Failed to create debugfs directory\n");
Mark Brown8a9dab12011-01-10 22:25:21 +00003682 snd_soc_debugfs_root = NULL;
Mark Brown384c89e2008-12-03 17:34:03 +00003683 }
Mark Brownc3c5a192010-09-15 18:15:14 +01003684
Mark Brown8a9dab12011-01-10 22:25:21 +00003685 if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
Mark Brownc3c5a192010-09-15 18:15:14 +01003686 &codec_list_fops))
3687 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
3688
Mark Brown8a9dab12011-01-10 22:25:21 +00003689 if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
Mark Brownf3208782010-09-15 18:19:07 +01003690 &dai_list_fops))
3691 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
Mark Brown19c7ac22010-09-15 18:22:40 +01003692
Mark Brown8a9dab12011-01-10 22:25:21 +00003693 if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
Mark Brown19c7ac22010-09-15 18:22:40 +01003694 &platform_list_fops))
3695 pr_warn("ASoC: Failed to create platform list debugfs file\n");
Mark Brown384c89e2008-12-03 17:34:03 +00003696#endif
3697
Mark Brownfb257892011-04-28 10:57:54 +01003698 snd_soc_util_init();
3699
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003700 return platform_driver_register(&soc_driver);
3701}
Mark Brown4abe8e12010-10-12 17:41:03 +01003702module_init(snd_soc_init);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003703
Mark Brown7d8c16a2008-11-30 22:11:24 +00003704static void __exit snd_soc_exit(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003705{
Mark Brownfb257892011-04-28 10:57:54 +01003706 snd_soc_util_exit();
3707
Mark Brown384c89e2008-12-03 17:34:03 +00003708#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +00003709 debugfs_remove_recursive(snd_soc_debugfs_root);
Mark Brown384c89e2008-12-03 17:34:03 +00003710#endif
Mark Brown3ff3f642008-05-19 12:32:25 +02003711 platform_driver_unregister(&soc_driver);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003712}
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003713module_exit(snd_soc_exit);
3714
3715/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01003716MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003717MODULE_DESCRIPTION("ALSA SoC Core");
3718MODULE_LICENSE("GPL");
Kay Sievers8b45a202008-04-14 13:33:36 +02003719MODULE_ALIAS("platform:soc-audio");