blob: e5c990889dcc5e6d9a1ecca2682acf4384ab5ae5 [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>
Markus Pargmann741a5092013-08-19 17:05:55 +020033#include <linux/pinctrl/consumer.h>
Mark Brownf0e8ed82011-09-20 11:41:54 +010034#include <linux/ctype.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090035#include <linux/slab.h>
Stephen Warrenbec4fa02011-12-12 15:55:34 -070036#include <linux/of.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>
Liam Girdwood01d75842012-04-25 12:12:49 +010042#include <sound/soc-dpcm.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020043#include <sound/initval.h>
44
Mark Browna8b1d342010-11-03 18:05:58 -040045#define CREATE_TRACE_POINTS
46#include <trace/events/asoc.h>
47
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +000048#define NAME_SIZE 32
49
Mark Brown384c89e2008-12-03 17:34:03 +000050#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +000051struct dentry *snd_soc_debugfs_root;
52EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
Mark Brown384c89e2008-12-03 17:34:03 +000053#endif
54
Mark Brownc5af3a22008-11-28 13:29:45 +000055static DEFINE_MUTEX(client_mutex);
Mark Brown12a48a8c2008-12-03 19:40:30 +000056static LIST_HEAD(platform_list);
Mark Brown0d0cf002008-12-10 14:32:45 +000057static LIST_HEAD(codec_list);
Kuninori Morimoto030e79f2013-03-11 18:27:21 -070058static LIST_HEAD(component_list);
Mark Brownc5af3a22008-11-28 13:29:45 +000059
Frank Mandarinodb2a4162006-10-06 18:31:09 +020060/*
61 * This is a timeout to do a DAPM powerdown after a stream is closed().
62 * It can be used to eliminate pops between different playback streams, e.g.
63 * between two audio tracks.
64 */
65static int pmdown_time = 5000;
66module_param(pmdown_time, int, 0);
67MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
68
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +000069/* returns the minimum number of bytes needed to represent
70 * a particular given value */
71static int min_bytes_needed(unsigned long val)
72{
73 int c = 0;
74 int i;
75
76 for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)
77 if (val & (1UL << i))
78 break;
79 c = (sizeof val * 8) - c;
80 if (!c || (c % 8))
81 c = (c + 8) / 8;
82 else
83 c /= 8;
84 return c;
85}
86
Dimitris Papastamos13fd1792011-02-02 13:58:58 +000087/* fill buf which is 'len' bytes with a formatted
88 * string of the form 'reg: value\n' */
89static int format_register_str(struct snd_soc_codec *codec,
90 unsigned int reg, char *buf, size_t len)
Mark Brown2624d5f2009-11-03 21:56:13 +000091{
Stephen Warren00b317a2011-04-01 14:50:44 -060092 int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
93 int regsize = codec->driver->reg_word_size * 2;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +000094 int ret;
95 char tmpbuf[len + 1];
96 char regbuf[regsize + 1];
97
98 /* since tmpbuf is allocated on the stack, warn the callers if they
99 * try to abuse this function */
100 WARN_ON(len > 63);
101
102 /* +2 for ': ' and + 1 for '\n' */
103 if (wordsize + regsize + 2 + 1 != len)
104 return -EINVAL;
105
Mark Brown25032c12011-08-01 13:52:48 +0900106 ret = snd_soc_read(codec, reg);
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000107 if (ret < 0) {
108 memset(regbuf, 'X', regsize);
109 regbuf[regsize] = '\0';
110 } else {
111 snprintf(regbuf, regsize + 1, "%.*x", regsize, ret);
112 }
113
114 /* prepare the buffer */
115 snprintf(tmpbuf, len + 1, "%.*x: %s\n", wordsize, reg, regbuf);
116 /* copy it back to the caller without the '\0' */
117 memcpy(buf, tmpbuf, len);
118
119 return 0;
120}
121
122/* codec register dump */
123static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
124 size_t count, loff_t pos)
125{
126 int i, step = 1;
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +0000127 int wordsize, regsize;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000128 int len;
129 size_t total = 0;
130 loff_t p = 0;
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +0000131
Stephen Warren00b317a2011-04-01 14:50:44 -0600132 wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
133 regsize = codec->driver->reg_word_size * 2;
Mark Brown2624d5f2009-11-03 21:56:13 +0000134
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000135 len = wordsize + regsize + 2 + 1;
136
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000137 if (!codec->driver->reg_cache_size)
Mark Brown2624d5f2009-11-03 21:56:13 +0000138 return 0;
139
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000140 if (codec->driver->reg_cache_step)
141 step = codec->driver->reg_cache_step;
Mark Brown2624d5f2009-11-03 21:56:13 +0000142
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000143 for (i = 0; i < codec->driver->reg_cache_size; i += step) {
Lars-Peter Clausen20a0ec22014-03-18 09:02:09 +0100144 /* only support larger than PAGE_SIZE bytes debugfs
145 * entries for the default case */
146 if (p >= pos) {
147 if (total + len >= count - 1)
148 break;
149 format_register_str(codec, i, buf + total, len);
150 total += len;
Mark Brown5164d742010-07-14 16:14:33 +0100151 }
Lars-Peter Clausen20a0ec22014-03-18 09:02:09 +0100152 p += len;
Mark Brown2624d5f2009-11-03 21:56:13 +0000153 }
154
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000155 total = min(total, count - 1);
Mark Brown2624d5f2009-11-03 21:56:13 +0000156
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000157 return total;
Mark Brown2624d5f2009-11-03 21:56:13 +0000158}
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000159
Mark Brown2624d5f2009-11-03 21:56:13 +0000160static ssize_t codec_reg_show(struct device *dev,
161 struct device_attribute *attr, char *buf)
162{
Mark Brown36ae1a92012-01-06 17:12:45 -0800163 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000164
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000165 return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);
Mark Brown2624d5f2009-11-03 21:56:13 +0000166}
167
168static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
169
Mark Browndbe21402010-02-12 11:37:24 +0000170static ssize_t pmdown_time_show(struct device *dev,
171 struct device_attribute *attr, char *buf)
172{
Mark Brown36ae1a92012-01-06 17:12:45 -0800173 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
Mark Browndbe21402010-02-12 11:37:24 +0000174
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000175 return sprintf(buf, "%ld\n", rtd->pmdown_time);
Mark Browndbe21402010-02-12 11:37:24 +0000176}
177
178static ssize_t pmdown_time_set(struct device *dev,
179 struct device_attribute *attr,
180 const char *buf, size_t count)
181{
Mark Brown36ae1a92012-01-06 17:12:45 -0800182 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
Mark Brownc593b522010-10-27 20:11:17 -0700183 int ret;
Mark Browndbe21402010-02-12 11:37:24 +0000184
Jingoo Hanb785a492013-07-19 16:24:59 +0900185 ret = kstrtol(buf, 10, &rtd->pmdown_time);
Mark Brownc593b522010-10-27 20:11:17 -0700186 if (ret)
187 return ret;
Mark Browndbe21402010-02-12 11:37:24 +0000188
189 return count;
190}
191
192static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
193
Takashi Iwaid29697d2015-01-30 20:16:37 +0100194static struct attribute *soc_dev_attrs[] = {
195 &dev_attr_codec_reg.attr,
196 &dev_attr_pmdown_time.attr,
197 NULL
198};
199
200static umode_t soc_dev_attr_is_visible(struct kobject *kobj,
201 struct attribute *attr, int idx)
202{
203 struct device *dev = kobj_to_dev(kobj);
204 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
205
206 if (attr == &dev_attr_pmdown_time.attr)
207 return attr->mode; /* always visible */
208 return rtd->codec ? attr->mode : 0; /* enabled only with codec */
209}
210
211static const struct attribute_group soc_dapm_dev_group = {
212 .attrs = soc_dapm_dev_attrs,
213 .is_visible = soc_dev_attr_is_visible,
214};
215
216static const struct attribute_group soc_dev_roup = {
217 .attrs = soc_dev_attrs,
218 .is_visible = soc_dev_attr_is_visible,
219};
220
221static const struct attribute_group *soc_dev_attr_groups[] = {
222 &soc_dapm_dev_group,
223 &soc_dev_roup,
224 NULL
225};
226
Mark Brown2624d5f2009-11-03 21:56:13 +0000227#ifdef CONFIG_DEBUG_FS
Mark Brown2624d5f2009-11-03 21:56:13 +0000228static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000229 size_t count, loff_t *ppos)
Mark Brown2624d5f2009-11-03 21:56:13 +0000230{
231 ssize_t ret;
232 struct snd_soc_codec *codec = file->private_data;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000233 char *buf;
234
235 if (*ppos < 0 || !count)
236 return -EINVAL;
237
238 buf = kmalloc(count, GFP_KERNEL);
Mark Brown2624d5f2009-11-03 21:56:13 +0000239 if (!buf)
240 return -ENOMEM;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000241
242 ret = soc_codec_reg_show(codec, buf, count, *ppos);
243 if (ret >= 0) {
244 if (copy_to_user(user_buf, buf, ret)) {
245 kfree(buf);
246 return -EFAULT;
247 }
248 *ppos += ret;
249 }
250
Mark Brown2624d5f2009-11-03 21:56:13 +0000251 kfree(buf);
252 return ret;
253}
254
255static ssize_t codec_reg_write_file(struct file *file,
256 const char __user *user_buf, size_t count, loff_t *ppos)
257{
258 char buf[32];
Stephen Boyd34e268d2011-05-12 16:50:10 -0700259 size_t buf_size;
Mark Brown2624d5f2009-11-03 21:56:13 +0000260 char *start = buf;
261 unsigned long reg, value;
Mark Brown2624d5f2009-11-03 21:56:13 +0000262 struct snd_soc_codec *codec = file->private_data;
Jingoo Hanb785a492013-07-19 16:24:59 +0900263 int ret;
Mark Brown2624d5f2009-11-03 21:56:13 +0000264
265 buf_size = min(count, (sizeof(buf)-1));
266 if (copy_from_user(buf, user_buf, buf_size))
267 return -EFAULT;
268 buf[buf_size] = 0;
269
Mark Brown2624d5f2009-11-03 21:56:13 +0000270 while (*start == ' ')
271 start++;
272 reg = simple_strtoul(start, &start, 16);
Mark Brown2624d5f2009-11-03 21:56:13 +0000273 while (*start == ' ')
274 start++;
Jingoo Hanb785a492013-07-19 16:24:59 +0900275 ret = kstrtoul(start, 16, &value);
276 if (ret)
277 return ret;
Mark Brown0d51a9c2011-01-06 16:04:57 +0000278
279 /* Userspace has been fiddling around behind the kernel's back */
Rusty Russell373d4d02013-01-21 17:17:39 +1030280 add_taint(TAINT_USER, LOCKDEP_NOW_UNRELIABLE);
Mark Brown0d51a9c2011-01-06 16:04:57 +0000281
Dimitris Papastamose4f078d2010-12-07 16:30:38 +0000282 snd_soc_write(codec, reg, value);
Mark Brown2624d5f2009-11-03 21:56:13 +0000283 return buf_size;
284}
285
286static const struct file_operations codec_reg_fops = {
Stephen Boyd234e3402012-04-05 14:25:11 -0700287 .open = simple_open,
Mark Brown2624d5f2009-11-03 21:56:13 +0000288 .read = codec_reg_read_file,
289 .write = codec_reg_write_file,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200290 .llseek = default_llseek,
Mark Brown2624d5f2009-11-03 21:56:13 +0000291};
292
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200293static void soc_init_component_debugfs(struct snd_soc_component *component)
Russell Kinge73f3de2014-06-26 15:22:50 +0100294{
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200295 if (component->debugfs_prefix) {
296 char *name;
Russell Kinge73f3de2014-06-26 15:22:50 +0100297
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200298 name = kasprintf(GFP_KERNEL, "%s:%s",
299 component->debugfs_prefix, component->name);
300 if (name) {
301 component->debugfs_root = debugfs_create_dir(name,
302 component->card->debugfs_card_root);
303 kfree(name);
304 }
305 } else {
306 component->debugfs_root = debugfs_create_dir(component->name,
307 component->card->debugfs_card_root);
308 }
Russell Kinge73f3de2014-06-26 15:22:50 +0100309
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200310 if (!component->debugfs_root) {
311 dev_warn(component->dev,
312 "ASoC: Failed to create component debugfs directory\n");
Mark Brown2624d5f2009-11-03 21:56:13 +0000313 return;
314 }
315
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200316 snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component),
317 component->debugfs_root);
318
319 if (component->init_debugfs)
320 component->init_debugfs(component);
321}
322
323static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
324{
325 debugfs_remove_recursive(component->debugfs_root);
326}
327
328static void soc_init_codec_debugfs(struct snd_soc_component *component)
329{
330 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
331
Mark Brown2624d5f2009-11-03 21:56:13 +0000332 codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200333 codec->component.debugfs_root,
Mark Brown2624d5f2009-11-03 21:56:13 +0000334 codec, &codec_reg_fops);
335 if (!codec->debugfs_reg)
Michał Mirosław10e8aa92013-05-04 22:21:38 +0200336 dev_warn(codec->dev,
337 "ASoC: Failed to create codec register debugfs file\n");
Sebastien Guiriec731f1ab2012-02-15 15:25:31 +0000338}
339
Mark Brownc3c5a192010-09-15 18:15:14 +0100340static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
341 size_t count, loff_t *ppos)
342{
343 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100344 ssize_t len, ret = 0;
Mark Brownc3c5a192010-09-15 18:15:14 +0100345 struct snd_soc_codec *codec;
346
347 if (!buf)
348 return -ENOMEM;
349
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100350 mutex_lock(&client_mutex);
351
Mark Brown2b194f9d2010-10-13 10:52:16 +0100352 list_for_each_entry(codec, &codec_list, list) {
353 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +0200354 codec->component.name);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100355 if (len >= 0)
356 ret += len;
357 if (ret > PAGE_SIZE) {
358 ret = PAGE_SIZE;
359 break;
360 }
361 }
Mark Brownc3c5a192010-09-15 18:15:14 +0100362
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100363 mutex_unlock(&client_mutex);
364
Mark Brownc3c5a192010-09-15 18:15:14 +0100365 if (ret >= 0)
366 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
367
368 kfree(buf);
369
370 return ret;
371}
372
373static const struct file_operations codec_list_fops = {
374 .read = codec_list_read_file,
375 .llseek = default_llseek,/* read accesses f_pos */
376};
377
Mark Brownf3208782010-09-15 18:19:07 +0100378static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
379 size_t count, loff_t *ppos)
380{
381 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100382 ssize_t len, ret = 0;
Lars-Peter Clausen1438c2f2014-03-09 17:41:47 +0100383 struct snd_soc_component *component;
Mark Brownf3208782010-09-15 18:19:07 +0100384 struct snd_soc_dai *dai;
385
386 if (!buf)
387 return -ENOMEM;
388
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100389 mutex_lock(&client_mutex);
390
Lars-Peter Clausen1438c2f2014-03-09 17:41:47 +0100391 list_for_each_entry(component, &component_list, list) {
392 list_for_each_entry(dai, &component->dai_list, list) {
393 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
394 dai->name);
395 if (len >= 0)
396 ret += len;
397 if (ret > PAGE_SIZE) {
398 ret = PAGE_SIZE;
399 break;
400 }
Mark Brown2b194f9d2010-10-13 10:52:16 +0100401 }
402 }
Mark Brownf3208782010-09-15 18:19:07 +0100403
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100404 mutex_unlock(&client_mutex);
405
Mark Brown2b194f9d2010-10-13 10:52:16 +0100406 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
Mark Brownf3208782010-09-15 18:19:07 +0100407
408 kfree(buf);
409
410 return ret;
411}
412
413static const struct file_operations dai_list_fops = {
414 .read = dai_list_read_file,
415 .llseek = default_llseek,/* read accesses f_pos */
416};
417
Mark Brown19c7ac22010-09-15 18:22:40 +0100418static ssize_t platform_list_read_file(struct file *file,
419 char __user *user_buf,
420 size_t count, loff_t *ppos)
421{
422 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100423 ssize_t len, ret = 0;
Mark Brown19c7ac22010-09-15 18:22:40 +0100424 struct snd_soc_platform *platform;
425
426 if (!buf)
427 return -ENOMEM;
428
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100429 mutex_lock(&client_mutex);
430
Mark Brown2b194f9d2010-10-13 10:52:16 +0100431 list_for_each_entry(platform, &platform_list, list) {
432 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +0200433 platform->component.name);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100434 if (len >= 0)
435 ret += len;
436 if (ret > PAGE_SIZE) {
437 ret = PAGE_SIZE;
438 break;
439 }
440 }
Mark Brown19c7ac22010-09-15 18:22:40 +0100441
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100442 mutex_unlock(&client_mutex);
443
Mark Brown2b194f9d2010-10-13 10:52:16 +0100444 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
Mark Brown19c7ac22010-09-15 18:22:40 +0100445
446 kfree(buf);
447
448 return ret;
449}
450
451static const struct file_operations platform_list_fops = {
452 .read = platform_list_read_file,
453 .llseek = default_llseek,/* read accesses f_pos */
454};
455
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200456static void soc_init_card_debugfs(struct snd_soc_card *card)
457{
458 card->debugfs_card_root = debugfs_create_dir(card->name,
Mark Brown8a9dab12011-01-10 22:25:21 +0000459 snd_soc_debugfs_root);
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200460 if (!card->debugfs_card_root) {
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200461 dev_warn(card->dev,
Lothar Waßmann7c08be82011-12-09 14:16:29 +0100462 "ASoC: Failed to create card debugfs directory\n");
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200463 return;
464 }
465
466 card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
467 card->debugfs_card_root,
468 &card->pop_time);
469 if (!card->debugfs_pop_time)
470 dev_warn(card->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000471 "ASoC: Failed to create pop time debugfs file\n");
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200472}
473
474static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
475{
476 debugfs_remove_recursive(card->debugfs_card_root);
477}
478
Mark Brown2624d5f2009-11-03 21:56:13 +0000479#else
480
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200481#define soc_init_codec_debugfs NULL
482
483static inline void soc_init_component_debugfs(
484 struct snd_soc_component *component)
Mark Brown2624d5f2009-11-03 21:56:13 +0000485{
486}
487
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200488static inline void soc_cleanup_component_debugfs(
489 struct snd_soc_component *component)
Sebastien Guiriec731f1ab2012-02-15 15:25:31 +0000490{
491}
492
Axel Linb95fccb2010-11-09 17:06:44 +0800493static inline void soc_init_card_debugfs(struct snd_soc_card *card)
494{
495}
496
497static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
498{
499}
Mark Brown2624d5f2009-11-03 21:56:13 +0000500#endif
501
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100502struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
503 const char *dai_link, int stream)
504{
505 int i;
506
507 for (i = 0; i < card->num_links; i++) {
508 if (card->rtd[i].dai_link->no_pcm &&
509 !strcmp(card->rtd[i].dai_link->name, dai_link))
510 return card->rtd[i].pcm->streams[stream].substream;
511 }
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000512 dev_dbg(card->dev, "ASoC: failed to find dai link %s\n", dai_link);
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100513 return NULL;
514}
515EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);
516
517struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
518 const char *dai_link)
519{
520 int i;
521
522 for (i = 0; i < card->num_links; i++) {
523 if (!strcmp(card->rtd[i].dai_link->name, dai_link))
524 return &card->rtd[i];
525 }
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000526 dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link);
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100527 return NULL;
528}
529EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);
530
Richard Fitzgerald9d58a072013-08-05 13:17:28 +0100531static void codec2codec_close_delayed_work(struct work_struct *work)
532{
533 /* Currently nothing to do for c2c links
534 * Since c2c links are internal nodes in the DAPM graph and
535 * don't interface with the outside world or application layer
536 * we don't have to do any special handling on close.
537 */
538}
539
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000540#ifdef CONFIG_PM_SLEEP
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200541/* powers down audio subsystem for suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000542int snd_soc_suspend(struct device *dev)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200543{
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000544 struct snd_soc_card *card = dev_get_drvdata(dev);
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200545 struct snd_soc_codec *codec;
Benoit Cousson88bd8702014-07-08 23:19:34 +0200546 int i, j;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200547
Lars-Peter Clausenc5599b82014-08-19 15:51:30 +0200548 /* If the card is not initialized yet there is nothing to do */
549 if (!card->instantiated)
Daniel Macke3509ff2009-06-03 17:44:49 +0200550 return 0;
551
Andy Green6ed25972008-06-13 16:24:05 +0100552 /* Due to the resume being scheduled into a workqueue we could
553 * suspend before that's finished - wait for it to complete.
554 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000555 snd_power_lock(card->snd_card);
556 snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
557 snd_power_unlock(card->snd_card);
Andy Green6ed25972008-06-13 16:24:05 +0100558
559 /* we're going to block userspace touching us until resume completes */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000560 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
Andy Green6ed25972008-06-13 16:24:05 +0100561
Mark Browna00f90f2010-12-02 16:24:24 +0000562 /* mute any active DACs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000563 for (i = 0; i < card->num_rtd; i++) {
Mark Brown3efab7d2010-05-09 13:25:43 +0100564
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000565 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100566 continue;
567
Benoit Cousson88bd8702014-07-08 23:19:34 +0200568 for (j = 0; j < card->rtd[i].num_codecs; j++) {
569 struct snd_soc_dai *dai = card->rtd[i].codec_dais[j];
570 struct snd_soc_dai_driver *drv = dai->driver;
571
572 if (drv->ops->digital_mute && dai->playback_active)
573 drv->ops->digital_mute(dai, 1);
574 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200575 }
576
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100577 /* suspend all pcms */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000578 for (i = 0; i < card->num_rtd; i++) {
579 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100580 continue;
581
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000582 snd_pcm_suspend_all(card->rtd[i].pcm);
Mark Brown3efab7d2010-05-09 13:25:43 +0100583 }
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100584
Mark Brown87506542008-11-18 20:50:34 +0000585 if (card->suspend_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +0000586 card->suspend_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200587
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000588 for (i = 0; i < card->num_rtd; i++) {
589 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100590
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000591 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100592 continue;
593
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100594 if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000595 cpu_dai->driver->suspend(cpu_dai);
Mark Brown1547aba2010-05-07 21:11:40 +0100596 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200597
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000598 /* close any waiting streams and save state */
599 for (i = 0; i < card->num_rtd; i++) {
Benoit Cousson88bd8702014-07-08 23:19:34 +0200600 struct snd_soc_dai **codec_dais = card->rtd[i].codec_dais;
Tejun Heo43829732012-08-20 14:51:24 -0700601 flush_delayed_work(&card->rtd[i].delayed_work);
Benoit Cousson88bd8702014-07-08 23:19:34 +0200602 for (j = 0; j < card->rtd[i].num_codecs; j++) {
603 codec_dais[j]->codec->dapm.suspend_bias_level =
604 codec_dais[j]->codec->dapm.bias_level;
605 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000606 }
Mark Brown3efab7d2010-05-09 13:25:43 +0100607
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000608 for (i = 0; i < card->num_rtd; i++) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000609
610 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100611 continue;
612
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800613 snd_soc_dapm_stream_event(&card->rtd[i],
614 SNDRV_PCM_STREAM_PLAYBACK,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800615 SND_SOC_DAPM_STREAM_SUSPEND);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000616
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800617 snd_soc_dapm_stream_event(&card->rtd[i],
618 SNDRV_PCM_STREAM_CAPTURE,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800619 SND_SOC_DAPM_STREAM_SUSPEND);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000620 }
621
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200622 /* Recheck all endpoints too, their state is affected by suspend */
623 dapm_mark_endpoints_dirty(card);
Mark Browne2d32ff2012-08-31 17:38:32 -0700624 snd_soc_dapm_sync(&card->dapm);
625
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000626 /* suspend all CODECs */
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200627 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000628 /* If there are paths active then the CODEC will be held with
629 * bias _ON and should not be suspended. */
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200630 if (!codec->suspended) {
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200631 switch (codec->dapm.bias_level) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000632 case SND_SOC_BIAS_STANDBY:
Mark Brown125a25d2012-01-31 15:49:10 +0000633 /*
634 * If the CODEC is capable of idle
635 * bias off then being in STANDBY
636 * means it's doing something,
637 * otherwise fall through.
638 */
639 if (codec->dapm.idle_bias_off) {
640 dev_dbg(codec->dev,
Michał Mirosław10e8aa92013-05-04 22:21:38 +0200641 "ASoC: idle_bias_off CODEC on over suspend\n");
Mark Brown125a25d2012-01-31 15:49:10 +0000642 break;
643 }
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200644
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000645 case SND_SOC_BIAS_OFF:
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200646 if (codec->driver->suspend)
647 codec->driver->suspend(codec);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000648 codec->suspended = 1;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +0200649 if (codec->component.regmap)
650 regcache_mark_dirty(codec->component.regmap);
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800651 /* deactivate pins to sleep state */
652 pinctrl_pm_select_sleep_state(codec->dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000653 break;
654 default:
Michał Mirosław10e8aa92013-05-04 22:21:38 +0200655 dev_dbg(codec->dev,
656 "ASoC: CODEC is on over suspend\n");
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000657 break;
658 }
659 }
660 }
661
662 for (i = 0; i < card->num_rtd; i++) {
663 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
664
665 if (card->rtd[i].dai_link->ignore_suspend)
666 continue;
667
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100668 if (cpu_dai->driver->suspend && cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000669 cpu_dai->driver->suspend(cpu_dai);
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800670
671 /* deactivate pins to sleep state */
672 pinctrl_pm_select_sleep_state(cpu_dai->dev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200673 }
674
Mark Brown87506542008-11-18 20:50:34 +0000675 if (card->suspend_post)
Mark Brown70b2ac12011-01-26 14:05:25 +0000676 card->suspend_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200677
678 return 0;
679}
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000680EXPORT_SYMBOL_GPL(snd_soc_suspend);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200681
Andy Green6ed25972008-06-13 16:24:05 +0100682/* deferred resume work, so resume can complete before we finished
683 * setting our codec back up, which can be very slow on I2C
684 */
685static void soc_resume_deferred(struct work_struct *work)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200686{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000687 struct snd_soc_card *card =
688 container_of(work, struct snd_soc_card, deferred_resume_work);
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200689 struct snd_soc_codec *codec;
Benoit Cousson88bd8702014-07-08 23:19:34 +0200690 int i, j;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200691
Andy Green6ed25972008-06-13 16:24:05 +0100692 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
693 * so userspace apps are blocked from touching us
694 */
695
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000696 dev_dbg(card->dev, "ASoC: starting resume work\n");
Andy Green6ed25972008-06-13 16:24:05 +0100697
Mark Brown99497882010-05-07 20:24:05 +0100698 /* Bring us up into D2 so that DAPM starts enabling things */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000699 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
Mark Brown99497882010-05-07 20:24:05 +0100700
Mark Brown87506542008-11-18 20:50:34 +0000701 if (card->resume_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +0000702 card->resume_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200703
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100704 /* resume control bus DAIs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000705 for (i = 0; i < card->num_rtd; i++) {
706 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100707
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000708 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100709 continue;
710
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100711 if (cpu_dai->driver->resume && cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000712 cpu_dai->driver->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200713 }
714
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200715 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000716 /* If the CODEC was idle over suspend then it will have been
717 * left with bias OFF or STANDBY and suspended so we must now
718 * resume. Otherwise the suspend was suppressed.
719 */
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200720 if (codec->suspended) {
Liam Girdwoodce6120c2010-11-05 15:53:46 +0200721 switch (codec->dapm.bias_level) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000722 case SND_SOC_BIAS_STANDBY:
723 case SND_SOC_BIAS_OFF:
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200724 if (codec->driver->resume)
725 codec->driver->resume(codec);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000726 codec->suspended = 0;
727 break;
728 default:
Michał Mirosław10e8aa92013-05-04 22:21:38 +0200729 dev_dbg(codec->dev,
730 "ASoC: CODEC was on over suspend\n");
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000731 break;
732 }
Mark Brown1547aba2010-05-07 21:11:40 +0100733 }
734 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200735
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000736 for (i = 0; i < card->num_rtd; i++) {
Mark Brown3efab7d2010-05-09 13:25:43 +0100737
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000738 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100739 continue;
740
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800741 snd_soc_dapm_stream_event(&card->rtd[i],
Liam Girdwoodd9b09512012-03-07 16:32:59 +0000742 SNDRV_PCM_STREAM_PLAYBACK,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800743 SND_SOC_DAPM_STREAM_RESUME);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000744
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800745 snd_soc_dapm_stream_event(&card->rtd[i],
Liam Girdwoodd9b09512012-03-07 16:32:59 +0000746 SNDRV_PCM_STREAM_CAPTURE,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800747 SND_SOC_DAPM_STREAM_RESUME);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200748 }
749
Mark Brown3ff3f642008-05-19 12:32:25 +0200750 /* unmute any active DACs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000751 for (i = 0; i < card->num_rtd; i++) {
Mark Brown3efab7d2010-05-09 13:25:43 +0100752
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000753 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100754 continue;
755
Benoit Cousson88bd8702014-07-08 23:19:34 +0200756 for (j = 0; j < card->rtd[i].num_codecs; j++) {
757 struct snd_soc_dai *dai = card->rtd[i].codec_dais[j];
758 struct snd_soc_dai_driver *drv = dai->driver;
759
760 if (drv->ops->digital_mute && dai->playback_active)
761 drv->ops->digital_mute(dai, 0);
762 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200763 }
764
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000765 for (i = 0; i < card->num_rtd; i++) {
766 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100767
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000768 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100769 continue;
770
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100771 if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000772 cpu_dai->driver->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200773 }
774
Mark Brown87506542008-11-18 20:50:34 +0000775 if (card->resume_post)
Mark Brown70b2ac12011-01-26 14:05:25 +0000776 card->resume_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200777
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000778 dev_dbg(card->dev, "ASoC: resume work completed\n");
Andy Green6ed25972008-06-13 16:24:05 +0100779
780 /* userspace can access us now we are back as we were before */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000781 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
Mark Browne2d32ff2012-08-31 17:38:32 -0700782
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200783 /* Recheck all endpoints too, their state is affected by suspend */
784 dapm_mark_endpoints_dirty(card);
Mark Browne2d32ff2012-08-31 17:38:32 -0700785 snd_soc_dapm_sync(&card->dapm);
Andy Green6ed25972008-06-13 16:24:05 +0100786}
787
788/* powers up audio subsystem after a suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000789int snd_soc_resume(struct device *dev)
Andy Green6ed25972008-06-13 16:24:05 +0100790{
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000791 struct snd_soc_card *card = dev_get_drvdata(dev);
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100792 bool bus_control = false;
793 int i;
Peter Ujfalusib9dd94a2010-02-22 13:27:13 +0200794
Lars-Peter Clausenc5599b82014-08-19 15:51:30 +0200795 /* If the card is not initialized yet there is nothing to do */
796 if (!card->instantiated)
Eric Miao5ff1ddf2011-11-23 22:37:00 +0800797 return 0;
798
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800799 /* activate pins from sleep state */
800 for (i = 0; i < card->num_rtd; i++) {
Benoit Cousson88bd8702014-07-08 23:19:34 +0200801 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
802 struct snd_soc_dai **codec_dais = rtd->codec_dais;
803 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
804 int j;
805
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800806 if (cpu_dai->active)
807 pinctrl_pm_select_default_state(cpu_dai->dev);
Benoit Cousson88bd8702014-07-08 23:19:34 +0200808
809 for (j = 0; j < rtd->num_codecs; j++) {
810 struct snd_soc_dai *codec_dai = codec_dais[j];
811 if (codec_dai->active)
812 pinctrl_pm_select_default_state(codec_dai->dev);
813 }
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800814 }
815
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100816 /*
817 * DAIs that also act as the control bus master might have other drivers
818 * hanging off them so need to resume immediately. Other drivers don't
819 * have that problem and may take a substantial amount of time to resume
Mark Brown64ab9ba2009-03-31 11:27:03 +0100820 * due to I/O costs and anti-pop so handle them out of line.
821 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000822 for (i = 0; i < card->num_rtd; i++) {
823 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100824 bus_control |= cpu_dai->driver->bus_control;
Stephen Warren82e14e82011-05-25 14:06:41 -0600825 }
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100826 if (bus_control) {
827 dev_dbg(dev, "ASoC: Resuming control bus master immediately\n");
Stephen Warren82e14e82011-05-25 14:06:41 -0600828 soc_resume_deferred(&card->deferred_resume_work);
829 } else {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000830 dev_dbg(dev, "ASoC: Scheduling resume work\n");
Stephen Warren82e14e82011-05-25 14:06:41 -0600831 if (!schedule_work(&card->deferred_resume_work))
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000832 dev_err(dev, "ASoC: resume work item may be lost\n");
Mark Brown64ab9ba2009-03-31 11:27:03 +0100833 }
Andy Green6ed25972008-06-13 16:24:05 +0100834
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200835 return 0;
836}
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000837EXPORT_SYMBOL_GPL(snd_soc_resume);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200838#else
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000839#define snd_soc_suspend NULL
840#define snd_soc_resume NULL
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200841#endif
842
Lars-Peter Clausen85e76522011-11-23 11:40:40 +0100843static const struct snd_soc_dai_ops null_dai_ops = {
Barry Song02a06d32009-10-16 18:13:38 +0800844};
845
Lars-Peter Clausen65d93612014-08-19 15:51:22 +0200846static struct snd_soc_component *soc_find_component(
847 const struct device_node *of_node, const char *name)
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100848{
Lars-Peter Clausen65d93612014-08-19 15:51:22 +0200849 struct snd_soc_component *component;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100850
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100851 lockdep_assert_held(&client_mutex);
852
Lars-Peter Clausen65d93612014-08-19 15:51:22 +0200853 list_for_each_entry(component, &component_list, list) {
854 if (of_node) {
855 if (component->dev->of_node == of_node)
856 return component;
857 } else if (strcmp(component->name, name) == 0) {
858 return component;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100859 }
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100860 }
861
862 return NULL;
863}
864
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200865static struct snd_soc_dai *snd_soc_find_dai(
866 const struct snd_soc_dai_link_component *dlc)
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100867{
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200868 struct snd_soc_component *component;
869 struct snd_soc_dai *dai;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100870
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100871 lockdep_assert_held(&client_mutex);
872
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200873 /* Find CPU DAI from registered DAIs*/
874 list_for_each_entry(component, &component_list, list) {
875 if (dlc->of_node && component->dev->of_node != dlc->of_node)
876 continue;
Lars-Peter Clausen1ffae362014-10-29 21:46:30 +0100877 if (dlc->name && strcmp(component->name, dlc->name))
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200878 continue;
879 list_for_each_entry(dai, &component->dai_list, list) {
880 if (dlc->dai_name && strcmp(dai->name, dlc->dai_name))
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100881 continue;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100882
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200883 return dai;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100884 }
885 }
886
887 return NULL;
888}
889
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000890static int soc_bind_dai_link(struct snd_soc_card *card, int num)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200891{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000892 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
893 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
Benoit Cousson88bd8702014-07-08 23:19:34 +0200894 struct snd_soc_dai_link_component *codecs = dai_link->codecs;
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200895 struct snd_soc_dai_link_component cpu_dai_component;
Benoit Cousson88bd8702014-07-08 23:19:34 +0200896 struct snd_soc_dai **codec_dais = rtd->codec_dais;
Mark Brown435c5e22008-12-04 15:32:53 +0000897 struct snd_soc_platform *platform;
Mark Brown848dd8b2011-04-27 18:16:32 +0100898 const char *platform_name;
Benoit Cousson88bd8702014-07-08 23:19:34 +0200899 int i;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200900
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000901 dev_dbg(card->dev, "ASoC: binding %s at idx %d\n", dai_link->name, num);
Mark Brown63084192008-12-02 15:08:03 +0000902
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200903 cpu_dai_component.name = dai_link->cpu_name;
904 cpu_dai_component.of_node = dai_link->cpu_of_node;
905 cpu_dai_component.dai_name = dai_link->cpu_dai_name;
906 rtd->cpu_dai = snd_soc_find_dai(&cpu_dai_component);
Mark Brownb19e6e72012-03-14 21:18:39 +0000907 if (!rtd->cpu_dai) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000908 dev_err(card->dev, "ASoC: CPU DAI %s not registered\n",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000909 dai_link->cpu_dai_name);
Mark Brownb19e6e72012-03-14 21:18:39 +0000910 return -EPROBE_DEFER;
Mark Brownc5af3a22008-11-28 13:29:45 +0000911 }
912
Benoit Cousson88bd8702014-07-08 23:19:34 +0200913 rtd->num_codecs = dai_link->num_codecs;
914
915 /* Find CODEC from registered CODECs */
916 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200917 codec_dais[i] = snd_soc_find_dai(&codecs[i]);
Benoit Cousson88bd8702014-07-08 23:19:34 +0200918 if (!codec_dais[i]) {
919 dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
920 codecs[i].dai_name);
921 return -EPROBE_DEFER;
922 }
Mark Brownb19e6e72012-03-14 21:18:39 +0000923 }
Mark Brown848dd8b2011-04-27 18:16:32 +0100924
Benoit Cousson88bd8702014-07-08 23:19:34 +0200925 /* Single codec links expect codec and codec_dai in runtime data */
926 rtd->codec_dai = codec_dais[0];
927 rtd->codec = rtd->codec_dai->codec;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100928
Mark Brown848dd8b2011-04-27 18:16:32 +0100929 /* if there's no platform we match on the empty platform */
930 platform_name = dai_link->platform_name;
Stephen Warren5a504962011-12-21 10:40:59 -0700931 if (!platform_name && !dai_link->platform_of_node)
Mark Brown848dd8b2011-04-27 18:16:32 +0100932 platform_name = "snd-soc-dummy";
933
Mark Brownb19e6e72012-03-14 21:18:39 +0000934 /* find one from the set of registered platforms */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000935 list_for_each_entry(platform, &platform_list, list) {
Stephen Warren5a504962011-12-21 10:40:59 -0700936 if (dai_link->platform_of_node) {
937 if (platform->dev->of_node !=
938 dai_link->platform_of_node)
939 continue;
940 } else {
Lars-Peter Clausenf4333202014-06-16 18:13:02 +0200941 if (strcmp(platform->component.name, platform_name))
Stephen Warren5a504962011-12-21 10:40:59 -0700942 continue;
943 }
Stephen Warren2610ab72011-12-07 13:58:27 -0700944
945 rtd->platform = platform;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000946 }
Mark Brownb19e6e72012-03-14 21:18:39 +0000947 if (!rtd->platform) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000948 dev_err(card->dev, "ASoC: platform %s not registered\n",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000949 dai_link->platform_name);
Mark Brownb19e6e72012-03-14 21:18:39 +0000950 return -EPROBE_DEFER;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000951 }
Mark Brownb19e6e72012-03-14 21:18:39 +0000952
953 card->num_rtd++;
954
955 return 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000956}
957
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +0200958static void soc_remove_component(struct snd_soc_component *component)
Stephen Warrend12cd192012-06-08 12:34:22 -0600959{
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +0200960 if (!component->probed)
961 return;
Stephen Warrend12cd192012-06-08 12:34:22 -0600962
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +0200963 /* This is a HACK and will be removed soon */
964 if (component->codec)
965 list_del(&component->codec->card_list);
Stephen Warrend12cd192012-06-08 12:34:22 -0600966
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +0200967 if (component->remove)
968 component->remove(component);
Stephen Warrend12cd192012-06-08 12:34:22 -0600969
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +0200970 snd_soc_dapm_free(snd_soc_component_get_dapm(component));
Stephen Warrend12cd192012-06-08 12:34:22 -0600971
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +0200972 soc_cleanup_component_debugfs(component);
973 component->probed = 0;
974 module_put(component->dev->driver->owner);
Stephen Warrend12cd192012-06-08 12:34:22 -0600975}
976
Lars-Peter Clausene60cd142014-08-19 15:51:26 +0200977static void soc_remove_dai(struct snd_soc_dai *dai, int order)
Jarkko Nikula589c3562010-12-06 16:27:07 +0200978{
979 int err;
980
Lars-Peter Clausene60cd142014-08-19 15:51:26 +0200981 if (dai && dai->probed &&
982 dai->driver->remove_order == order) {
983 if (dai->driver->remove) {
984 err = dai->driver->remove(dai);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +0100985 if (err < 0)
Lars-Peter Clausene60cd142014-08-19 15:51:26 +0200986 dev_err(dai->dev,
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +0100987 "ASoC: failed to remove %s: %d\n",
Lars-Peter Clausene60cd142014-08-19 15:51:26 +0200988 dai->name, err);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +0100989 }
Lars-Peter Clausene60cd142014-08-19 15:51:26 +0200990 dai->probed = 0;
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +0100991 }
992}
993
Stephen Warren62ae68f2012-06-08 12:34:23 -0600994static void soc_remove_link_dais(struct snd_soc_card *card, int num, int order)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000995{
996 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
Lars-Peter Clausene60cd142014-08-19 15:51:26 +0200997 int i;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000998
999 /* unregister the rtd device */
1000 if (rtd->dev_registered) {
Mark Brown36ae1a92012-01-06 17:12:45 -08001001 device_unregister(rtd->dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001002 rtd->dev_registered = 0;
1003 }
1004
1005 /* remove the CODEC DAI */
Benoit Cousson88bd8702014-07-08 23:19:34 +02001006 for (i = 0; i < rtd->num_codecs; i++)
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001007 soc_remove_dai(rtd->codec_dais[i], order);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001008
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001009 soc_remove_dai(rtd->cpu_dai, order);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001010}
1011
Stephen Warren62ae68f2012-06-08 12:34:23 -06001012static void soc_remove_link_components(struct snd_soc_card *card, int num,
1013 int order)
1014{
1015 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1016 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Stephen Warren62ae68f2012-06-08 12:34:23 -06001017 struct snd_soc_platform *platform = rtd->platform;
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001018 struct snd_soc_component *component;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001019 int i;
Stephen Warren62ae68f2012-06-08 12:34:23 -06001020
1021 /* remove the platform */
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001022 if (platform && platform->component.driver->remove_order == order)
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001023 soc_remove_component(&platform->component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001024
1025 /* remove the CODEC-side CODEC */
Benoit Cousson88bd8702014-07-08 23:19:34 +02001026 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001027 component = rtd->codec_dais[i]->component;
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001028 if (component->driver->remove_order == order)
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001029 soc_remove_component(component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001030 }
1031
1032 /* remove any CPU-side CODEC */
1033 if (cpu_dai) {
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001034 if (cpu_dai->component->driver->remove_order == order)
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001035 soc_remove_component(cpu_dai->component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001036 }
1037}
1038
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001039static void soc_remove_dai_links(struct snd_soc_card *card)
1040{
Liam Girdwood0168bf02011-06-07 16:08:05 +01001041 int dai, order;
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001042
Liam Girdwood0168bf02011-06-07 16:08:05 +01001043 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1044 order++) {
1045 for (dai = 0; dai < card->num_rtd; dai++)
Stephen Warren62ae68f2012-06-08 12:34:23 -06001046 soc_remove_link_dais(card, dai, order);
Liam Girdwood0168bf02011-06-07 16:08:05 +01001047 }
Stephen Warren62ae68f2012-06-08 12:34:23 -06001048
1049 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1050 order++) {
1051 for (dai = 0; dai < card->num_rtd; dai++)
1052 soc_remove_link_components(card, dai, order);
1053 }
1054
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001055 card->num_rtd = 0;
1056}
1057
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001058static void soc_set_name_prefix(struct snd_soc_card *card,
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001059 struct snd_soc_component *component)
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001060{
1061 int i;
1062
Dimitris Papastamosff819b82010-12-02 14:53:03 +00001063 if (card->codec_conf == NULL)
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001064 return;
1065
Dimitris Papastamosff819b82010-12-02 14:53:03 +00001066 for (i = 0; i < card->num_configs; i++) {
1067 struct snd_soc_codec_conf *map = &card->codec_conf[i];
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001068 if (map->of_node && component->dev->of_node != map->of_node)
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001069 continue;
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001070 if (map->dev_name && strcmp(component->name, map->dev_name))
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001071 continue;
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001072 component->name_prefix = map->name_prefix;
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001073 break;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001074 }
1075}
1076
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001077static int soc_probe_component(struct snd_soc_card *card,
1078 struct snd_soc_component *component)
Jarkko Nikula589c3562010-12-06 16:27:07 +02001079{
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001080 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
Mark Brown888df392012-02-16 19:37:51 -08001081 struct snd_soc_dai *dai;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001082 int ret;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001083
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001084 if (component->probed)
1085 return 0;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001086
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001087 component->card = card;
1088 dapm->card = card;
1089 soc_set_name_prefix(card, component);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001090
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001091 if (!try_module_get(component->dev->driver->owner))
Jarkko Nikula70d29332011-01-27 16:24:22 +02001092 return -ENODEV;
1093
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001094 soc_init_component_debugfs(component);
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001095
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001096 if (component->dapm_widgets) {
1097 ret = snd_soc_dapm_new_controls(dapm, component->dapm_widgets,
1098 component->num_dapm_widgets);
Nariman Poushinb318ad52014-04-01 13:59:33 +01001099
1100 if (ret != 0) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001101 dev_err(component->dev,
Nariman Poushinb318ad52014-04-01 13:59:33 +01001102 "Failed to create new controls %d\n", ret);
1103 goto err_probe;
1104 }
1105 }
Lars-Peter Clausen77530152011-05-05 16:59:09 +02001106
Lars-Peter Clausen06348142014-08-20 13:08:49 +02001107 list_for_each_entry(dai, &component->dai_list, list) {
1108 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
Nariman Poushin261edc72014-03-31 15:47:12 +01001109 if (ret != 0) {
Lars-Peter Clausen06348142014-08-20 13:08:49 +02001110 dev_err(component->dev,
Nariman Poushin261edc72014-03-31 15:47:12 +01001111 "Failed to create DAI widgets %d\n", ret);
1112 goto err_probe;
1113 }
1114 }
Mark Brown888df392012-02-16 19:37:51 -08001115
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001116 if (component->probe) {
1117 ret = component->probe(component);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001118 if (ret < 0) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001119 dev_err(component->dev,
1120 "ASoC: failed to probe component %d\n", ret);
Jarkko Nikula70d29332011-01-27 16:24:22 +02001121 goto err_probe;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001122 }
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001123
1124 WARN(dapm->idle_bias_off &&
1125 dapm->bias_level != SND_SOC_BIAS_OFF,
Michał Mirosław10e8aa92013-05-04 22:21:38 +02001126 "codec %s can not start from non-off bias with idle_bias_off==1\n",
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001127 component->name);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001128 }
1129
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001130 if (component->controls)
1131 snd_soc_add_component_controls(component, component->controls,
1132 component->num_controls);
1133 if (component->dapm_routes)
1134 snd_soc_dapm_add_routes(dapm, component->dapm_routes,
1135 component->num_dapm_routes);
Mark Brown89b95ac02011-03-07 16:38:44 +00001136
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001137 component->probed = 1;
1138 list_add(&dapm->list, &card->dapm_list);
1139
1140 /* This is a HACK and will be removed soon */
1141 if (component->codec)
1142 list_add(&component->codec->card_list, &card->codec_dev_list);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001143
Jarkko Nikula70d29332011-01-27 16:24:22 +02001144 return 0;
1145
1146err_probe:
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001147 soc_cleanup_component_debugfs(component);
1148 module_put(component->dev->driver->owner);
Liam Girdwood956245e2011-07-01 16:54:08 +01001149
1150 return ret;
1151}
1152
Mark Brown36ae1a92012-01-06 17:12:45 -08001153static void rtd_release(struct device *dev)
1154{
1155 kfree(dev);
1156}
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001157
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001158static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
1159 const char *name)
Misael Lopez Cruz503ae5e2014-04-24 14:01:44 +02001160{
Jarkko Nikula589c3562010-12-06 16:27:07 +02001161 int ret = 0;
1162
Jarkko Nikula589c3562010-12-06 16:27:07 +02001163 /* register the rtd device */
Mark Brown36ae1a92012-01-06 17:12:45 -08001164 rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1165 if (!rtd->dev)
1166 return -ENOMEM;
1167 device_initialize(rtd->dev);
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001168 rtd->dev->parent = rtd->card->dev;
Mark Brown36ae1a92012-01-06 17:12:45 -08001169 rtd->dev->release = rtd_release;
Takashi Iwaid29697d2015-01-30 20:16:37 +01001170 rtd->dev->groups = soc_dev_attr_groups;
Lars-Peter Clausenf294afe2014-08-17 11:28:35 +02001171 dev_set_name(rtd->dev, "%s", name);
Mark Brown36ae1a92012-01-06 17:12:45 -08001172 dev_set_drvdata(rtd->dev, rtd);
Liam Girdwoodb8c0dab2011-06-09 17:04:39 +01001173 mutex_init(&rtd->pcm_mutex);
Liam Girdwood01d75842012-04-25 12:12:49 +01001174 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
1175 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
1176 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
1177 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
Mark Brown36ae1a92012-01-06 17:12:45 -08001178 ret = device_add(rtd->dev);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001179 if (ret < 0) {
Chuansheng Liu865df9c2012-12-26 00:56:05 +08001180 /* calling put_device() here to free the rtd->dev */
1181 put_device(rtd->dev);
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001182 dev_err(rtd->card->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001183 "ASoC: failed to register runtime device: %d\n", ret);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001184 return ret;
1185 }
1186 rtd->dev_registered = 1;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001187 return 0;
1188}
1189
Stephen Warren62ae68f2012-06-08 12:34:23 -06001190static int soc_probe_link_components(struct snd_soc_card *card, int num,
1191 int order)
1192{
1193 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
Stephen Warren62ae68f2012-06-08 12:34:23 -06001194 struct snd_soc_platform *platform = rtd->platform;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001195 struct snd_soc_component *component;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001196 int i, ret;
Stephen Warren62ae68f2012-06-08 12:34:23 -06001197
1198 /* probe the CPU-side component, if it is a CODEC */
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001199 component = rtd->cpu_dai->component;
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001200 if (component->driver->probe_order == order) {
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001201 ret = soc_probe_component(card, component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001202 if (ret < 0)
1203 return ret;
1204 }
1205
Benoit Cousson88bd8702014-07-08 23:19:34 +02001206 /* probe the CODEC-side components */
1207 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001208 component = rtd->codec_dais[i]->component;
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001209 if (component->driver->probe_order == order) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001210 ret = soc_probe_component(card, component);
Benoit Cousson88bd8702014-07-08 23:19:34 +02001211 if (ret < 0)
1212 return ret;
1213 }
Stephen Warren62ae68f2012-06-08 12:34:23 -06001214 }
1215
1216 /* probe the platform */
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001217 if (platform->component.driver->probe_order == order) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001218 ret = soc_probe_component(card, &platform->component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001219 if (ret < 0)
1220 return ret;
1221 }
1222
1223 return 0;
1224}
1225
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001226static int soc_probe_dai(struct snd_soc_dai *dai, int order)
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001227{
1228 int ret;
1229
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001230 if (!dai->probed && dai->driver->probe_order == order) {
1231 if (dai->driver->probe) {
1232 ret = dai->driver->probe(dai);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001233 if (ret < 0) {
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001234 dev_err(dai->dev,
1235 "ASoC: failed to probe DAI %s: %d\n",
1236 dai->name, ret);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001237 return ret;
1238 }
1239 }
1240
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001241 dai->probed = 1;
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001242 }
1243
1244 return 0;
1245}
1246
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001247static int soc_link_dai_widgets(struct snd_soc_card *card,
1248 struct snd_soc_dai_link *dai_link,
Benoit Cousson3f901a02014-07-01 09:47:54 +02001249 struct snd_soc_pcm_runtime *rtd)
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001250{
Benoit Cousson3f901a02014-07-01 09:47:54 +02001251 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1252 struct snd_soc_dai *codec_dai = rtd->codec_dai;
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001253 struct snd_soc_dapm_widget *play_w, *capture_w;
1254 int ret;
1255
Benoit Cousson88bd8702014-07-08 23:19:34 +02001256 if (rtd->num_codecs > 1)
1257 dev_warn(card->dev, "ASoC: Multiple codecs not supported yet\n");
1258
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001259 /* link the DAI widgets */
1260 play_w = codec_dai->playback_widget;
1261 capture_w = cpu_dai->capture_widget;
1262 if (play_w && capture_w) {
1263 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
1264 capture_w, play_w);
1265 if (ret != 0) {
1266 dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1267 play_w->name, capture_w->name, ret);
1268 return ret;
1269 }
1270 }
1271
1272 play_w = cpu_dai->playback_widget;
1273 capture_w = codec_dai->capture_widget;
1274 if (play_w && capture_w) {
1275 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
1276 capture_w, play_w);
1277 if (ret != 0) {
1278 dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1279 play_w->name, capture_w->name, ret);
1280 return ret;
1281 }
1282 }
1283
1284 return 0;
1285}
1286
Stephen Warren62ae68f2012-06-08 12:34:23 -06001287static int soc_probe_link_dais(struct snd_soc_card *card, int num, int order)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001288{
1289 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
1290 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
Mark Brownc74184e2012-04-04 22:12:09 +01001291 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001292 int i, ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001293
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001294 dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
Liam Girdwood0168bf02011-06-07 16:08:05 +01001295 card->name, num, order);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001296
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001297 /* set default power off timeout */
1298 rtd->pmdown_time = pmdown_time;
1299
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001300 ret = soc_probe_dai(cpu_dai, order);
1301 if (ret)
1302 return ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001303
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001304 /* probe the CODEC DAI */
Benoit Cousson88bd8702014-07-08 23:19:34 +02001305 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001306 ret = soc_probe_dai(rtd->codec_dais[i], order);
Benoit Cousson88bd8702014-07-08 23:19:34 +02001307 if (ret)
1308 return ret;
1309 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001310
Liam Girdwood0168bf02011-06-07 16:08:05 +01001311 /* complete DAI probe during last probe */
1312 if (order != SND_SOC_COMP_ORDER_LAST)
1313 return 0;
1314
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001315 /* do machine specific initialization */
1316 if (dai_link->init) {
1317 ret = dai_link->init(rtd);
1318 if (ret < 0) {
1319 dev_err(card->dev, "ASoC: failed to init %s: %d\n",
1320 dai_link->name, ret);
1321 return ret;
1322 }
1323 }
1324
1325 ret = soc_post_component_init(rtd, dai_link->name);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001326 if (ret)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001327 return ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001328
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001329#ifdef CONFIG_DEBUG_FS
1330 /* add DPCM sysfs entries */
1331 if (dai_link->dynamic) {
1332 ret = soc_dpcm_debugfs_add(rtd);
1333 if (ret < 0) {
1334 dev_err(rtd->dev,
1335 "ASoC: failed to add dpcm sysfs entries: %d\n",
1336 ret);
1337 return ret;
1338 }
1339 }
1340#endif
1341
Namarta Kohli1245b702012-08-16 17:10:41 +05301342 if (cpu_dai->driver->compress_dai) {
1343 /*create compress_device"*/
1344 ret = soc_new_compress(rtd, num);
Mark Brownc74184e2012-04-04 22:12:09 +01001345 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001346 dev_err(card->dev, "ASoC: can't create compress %s\n",
Namarta Kohli1245b702012-08-16 17:10:41 +05301347 dai_link->stream_name);
Mark Brownc74184e2012-04-04 22:12:09 +01001348 return ret;
1349 }
1350 } else {
Namarta Kohli1245b702012-08-16 17:10:41 +05301351
1352 if (!dai_link->params) {
1353 /* create the pcm */
1354 ret = soc_new_pcm(rtd, num);
1355 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001356 dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
Namarta Kohli1245b702012-08-16 17:10:41 +05301357 dai_link->stream_name, ret);
Mark Brownc74184e2012-04-04 22:12:09 +01001358 return ret;
1359 }
Namarta Kohli1245b702012-08-16 17:10:41 +05301360 } else {
Richard Fitzgerald9d58a072013-08-05 13:17:28 +01001361 INIT_DELAYED_WORK(&rtd->delayed_work,
1362 codec2codec_close_delayed_work);
1363
Namarta Kohli1245b702012-08-16 17:10:41 +05301364 /* link the DAI widgets */
Benoit Cousson3f901a02014-07-01 09:47:54 +02001365 ret = soc_link_dai_widgets(card, dai_link, rtd);
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001366 if (ret)
1367 return ret;
Mark Brownc74184e2012-04-04 22:12:09 +01001368 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001369 }
1370
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001371 return 0;
1372}
1373
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001374static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
Mark Brownb19e6e72012-03-14 21:18:39 +00001375{
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001376 struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001377 struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001378 const char *name = aux_dev->codec_name;
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001379
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001380 rtd->component = soc_find_component(aux_dev->codec_of_node, name);
1381 if (!rtd->component) {
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001382 if (aux_dev->codec_of_node)
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001383 name = of_node_full_name(aux_dev->codec_of_node);
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001384
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001385 dev_err(card->dev, "ASoC: %s not registered\n", name);
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001386 return -EPROBE_DEFER;
1387 }
1388
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001389 /*
1390 * Some places still reference rtd->codec, so we have to keep that
1391 * initialized if the component is a CODEC. Once all those references
1392 * have been removed, this code can be removed as well.
1393 */
1394 rtd->codec = rtd->component->codec;
1395
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001396 return 0;
Mark Brownb19e6e72012-03-14 21:18:39 +00001397}
1398
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001399static int soc_probe_aux_dev(struct snd_soc_card *card, int num)
1400{
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001401 struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001402 struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001403 int ret;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001404
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001405 ret = soc_probe_component(card, rtd->component);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001406 if (ret < 0)
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001407 return ret;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001408
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001409 /* do machine specific initialization */
1410 if (aux_dev->init) {
Lars-Peter Clausen57bf7722014-08-19 15:51:23 +02001411 ret = aux_dev->init(rtd->component);
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001412 if (ret < 0) {
1413 dev_err(card->dev, "ASoC: failed to init %s: %d\n",
1414 aux_dev->name, ret);
1415 return ret;
1416 }
1417 }
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001418
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001419 return soc_post_component_init(rtd, aux_dev->name);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001420}
1421
1422static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
1423{
1424 struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001425 struct snd_soc_component *component = rtd->component;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001426
1427 /* unregister the rtd device */
1428 if (rtd->dev_registered) {
Mark Brown36ae1a92012-01-06 17:12:45 -08001429 device_remove_file(rtd->dev, &dev_attr_codec_reg);
Chuansheng Liud3bf1562012-12-26 00:57:32 +08001430 device_unregister(rtd->dev);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001431 rtd->dev_registered = 0;
1432 }
1433
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001434 if (component && component->probed)
1435 soc_remove_component(component);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001436}
1437
Lars-Peter Clausenf90fb3f2013-08-31 20:31:15 +02001438static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001439{
1440 int ret;
1441
1442 if (codec->cache_init)
1443 return 0;
1444
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001445 ret = snd_soc_cache_init(codec);
1446 if (ret < 0) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02001447 dev_err(codec->dev,
1448 "ASoC: Failed to set cache compression type: %d\n",
1449 ret);
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001450 return ret;
1451 }
1452 codec->cache_init = 1;
1453 return 0;
1454}
1455
Lars-Peter Clausence64c8b2015-01-06 15:17:20 +01001456/**
1457 * snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime
1458 * @rtd: The runtime for which the DAI link format should be changed
1459 * @dai_fmt: The new DAI link format
1460 *
1461 * This function updates the DAI link format for all DAIs connected to the DAI
1462 * link for the specified runtime.
1463 *
1464 * Note: For setups with a static format set the dai_fmt field in the
1465 * corresponding snd_dai_link struct instead of using this function.
1466 *
1467 * Returns 0 on success, otherwise a negative error code.
1468 */
1469int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
1470 unsigned int dai_fmt)
1471{
1472 struct snd_soc_dai **codec_dais = rtd->codec_dais;
1473 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1474 unsigned int i;
1475 int ret;
1476
1477 for (i = 0; i < rtd->num_codecs; i++) {
1478 struct snd_soc_dai *codec_dai = codec_dais[i];
1479
1480 ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
1481 if (ret != 0 && ret != -ENOTSUPP) {
1482 dev_warn(codec_dai->dev,
1483 "ASoC: Failed to set DAI format: %d\n", ret);
1484 return ret;
1485 }
1486 }
1487
1488 /* Flip the polarity for the "CPU" end of a CODEC<->CODEC link */
1489 if (cpu_dai->codec) {
1490 unsigned int inv_dai_fmt;
1491
1492 inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_MASTER_MASK;
1493 switch (dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1494 case SND_SOC_DAIFMT_CBM_CFM:
1495 inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
1496 break;
1497 case SND_SOC_DAIFMT_CBM_CFS:
1498 inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
1499 break;
1500 case SND_SOC_DAIFMT_CBS_CFM:
1501 inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
1502 break;
1503 case SND_SOC_DAIFMT_CBS_CFS:
1504 inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
1505 break;
1506 }
1507
1508 dai_fmt = inv_dai_fmt;
1509 }
1510
1511 ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt);
1512 if (ret != 0 && ret != -ENOTSUPP) {
1513 dev_warn(cpu_dai->dev,
1514 "ASoC: Failed to set DAI format: %d\n", ret);
1515 return ret;
1516 }
1517
1518 return 0;
1519}
Lars-Peter Clausenddaca252015-01-08 12:23:05 +01001520EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
Lars-Peter Clausence64c8b2015-01-06 15:17:20 +01001521
Mark Brownb19e6e72012-03-14 21:18:39 +00001522static int snd_soc_instantiate_card(struct snd_soc_card *card)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001523{
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001524 struct snd_soc_codec *codec;
Lars-Peter Clausence64c8b2015-01-06 15:17:20 +01001525 int ret, i, order;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001526
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01001527 mutex_lock(&client_mutex);
Liam Girdwood01b9d992012-03-07 10:38:25 +00001528 mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001529
Mark Brownb19e6e72012-03-14 21:18:39 +00001530 /* bind DAIs */
1531 for (i = 0; i < card->num_links; i++) {
1532 ret = soc_bind_dai_link(card, i);
1533 if (ret != 0)
1534 goto base_error;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001535 }
1536
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001537 /* bind aux_devs too */
Mark Brownb19e6e72012-03-14 21:18:39 +00001538 for (i = 0; i < card->num_aux_devs; i++) {
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001539 ret = soc_bind_aux_dev(card, i);
Mark Brownb19e6e72012-03-14 21:18:39 +00001540 if (ret != 0)
1541 goto base_error;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001542 }
1543
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001544 /* initialize the register cache for each available codec */
1545 list_for_each_entry(codec, &codec_list, list) {
1546 if (codec->cache_init)
1547 continue;
Lars-Peter Clausenf90fb3f2013-08-31 20:31:15 +02001548 ret = snd_soc_init_codec_cache(codec);
Mark Brownb19e6e72012-03-14 21:18:39 +00001549 if (ret < 0)
1550 goto base_error;
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001551 }
1552
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001553 /* card bind complete so register a sound card */
Takashi Iwai102b5a82014-01-29 14:42:55 +01001554 ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001555 card->owner, 0, &card->snd_card);
1556 if (ret < 0) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02001557 dev_err(card->dev,
1558 "ASoC: can't create sound card for card %s: %d\n",
1559 card->name, ret);
Mark Brownb19e6e72012-03-14 21:18:39 +00001560 goto base_error;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001561 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001562
Mark Browne37a4972011-03-02 18:21:57 +00001563 card->dapm.bias_level = SND_SOC_BIAS_OFF;
1564 card->dapm.dev = card->dev;
1565 card->dapm.card = card;
1566 list_add(&card->dapm.list, &card->dapm_list);
1567
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001568#ifdef CONFIG_DEBUG_FS
1569 snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
1570#endif
1571
Mark Brown88ee1c62011-02-02 10:43:26 +00001572#ifdef CONFIG_PM_SLEEP
Andy Green6ed25972008-06-13 16:24:05 +01001573 /* deferred resume work */
Mark Brown63084192008-12-02 15:08:03 +00001574 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
Randy Dunlap1301a962008-06-17 19:19:34 +01001575#endif
Andy Green6ed25972008-06-13 16:24:05 +01001576
Mark Brown9a841eb2011-04-12 17:51:37 -07001577 if (card->dapm_widgets)
1578 snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
1579 card->num_dapm_widgets);
1580
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001581 /* initialise the sound card only once */
1582 if (card->probe) {
Mark Browne7361ec2011-01-26 14:17:20 +00001583 ret = card->probe(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001584 if (ret < 0)
1585 goto card_probe_error;
1586 }
1587
Stephen Warren62ae68f2012-06-08 12:34:23 -06001588 /* probe all components used by DAI links on this card */
Liam Girdwood0168bf02011-06-07 16:08:05 +01001589 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1590 order++) {
1591 for (i = 0; i < card->num_links; i++) {
Stephen Warren62ae68f2012-06-08 12:34:23 -06001592 ret = soc_probe_link_components(card, i, order);
Liam Girdwood0168bf02011-06-07 16:08:05 +01001593 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001594 dev_err(card->dev,
1595 "ASoC: failed to instantiate card %d\n",
1596 ret);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001597 goto probe_dai_err;
1598 }
1599 }
1600 }
1601
1602 /* probe all DAI links on this card */
1603 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1604 order++) {
1605 for (i = 0; i < card->num_links; i++) {
1606 ret = soc_probe_link_dais(card, i, order);
1607 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001608 dev_err(card->dev,
1609 "ASoC: failed to instantiate card %d\n",
1610 ret);
Liam Girdwood0168bf02011-06-07 16:08:05 +01001611 goto probe_dai_err;
1612 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001613 }
1614 }
1615
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001616 for (i = 0; i < card->num_aux_devs; i++) {
1617 ret = soc_probe_aux_dev(card, i);
1618 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001619 dev_err(card->dev,
1620 "ASoC: failed to add auxiliary devices %d\n",
1621 ret);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001622 goto probe_aux_dev_err;
1623 }
1624 }
1625
Mark Brown888df392012-02-16 19:37:51 -08001626 snd_soc_dapm_link_dai_widgets(card);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00001627 snd_soc_dapm_connect_dai_link_widgets(card);
Mark Brown888df392012-02-16 19:37:51 -08001628
Mark Brownb7af1da2011-04-07 19:18:44 +09001629 if (card->controls)
Liam Girdwood022658b2012-02-03 17:43:09 +00001630 snd_soc_add_card_controls(card, card->controls, card->num_controls);
Mark Brownb7af1da2011-04-07 19:18:44 +09001631
Mark Brownb8ad29d2011-03-02 18:35:51 +00001632 if (card->dapm_routes)
1633 snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
1634 card->num_dapm_routes);
1635
Mark Brown75d9ac42011-09-27 16:41:01 +01001636 for (i = 0; i < card->num_links; i++) {
Lars-Peter Clausence64c8b2015-01-06 15:17:20 +01001637 if (card->dai_link[i].dai_fmt)
1638 snd_soc_runtime_set_dai_fmt(&card->rtd[i],
1639 card->dai_link[i].dai_fmt);
Mark Brown75d9ac42011-09-27 16:41:01 +01001640 }
1641
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001642 snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001643 "%s", card->name);
Liam Girdwood22de71b2011-05-12 16:14:04 +01001644 snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
1645 "%s", card->long_name ? card->long_name : card->name);
Mark Brownf0e8ed82011-09-20 11:41:54 +01001646 snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
1647 "%s", card->driver_name ? card->driver_name : card->name);
1648 for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
1649 switch (card->snd_card->driver[i]) {
1650 case '_':
1651 case '-':
1652 case '\0':
1653 break;
1654 default:
1655 if (!isalnum(card->snd_card->driver[i]))
1656 card->snd_card->driver[i] = '_';
1657 break;
1658 }
1659 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001660
Mark Brown28e9ad92011-03-02 18:36:34 +00001661 if (card->late_probe) {
1662 ret = card->late_probe(card);
1663 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001664 dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
Mark Brown28e9ad92011-03-02 18:36:34 +00001665 card->name, ret);
1666 goto probe_aux_dev_err;
1667 }
1668 }
1669
Lars-Peter Clausen824ef822013-08-27 15:51:01 +02001670 snd_soc_dapm_new_widgets(card);
Lars-Peter Clausen8c193b82013-08-27 15:51:00 +02001671
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001672 ret = snd_card_register(card->snd_card);
1673 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001674 dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
1675 ret);
Axel Lin6b3ed782010-12-07 16:12:29 +08001676 goto probe_aux_dev_err;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001677 }
1678
Mark Brown435c5e22008-12-04 15:32:53 +00001679 card->instantiated = 1;
Mark Brown4f4c0072011-10-07 14:29:19 +01001680 snd_soc_dapm_sync(&card->dapm);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001681 mutex_unlock(&card->mutex);
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01001682 mutex_unlock(&client_mutex);
Mark Brownb19e6e72012-03-14 21:18:39 +00001683
1684 return 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001685
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001686probe_aux_dev_err:
1687 for (i = 0; i < card->num_aux_devs; i++)
1688 soc_remove_aux_dev(card, i);
1689
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001690probe_dai_err:
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001691 soc_remove_dai_links(card);
Mark Brownfe3e78e2009-11-03 22:13:13 +00001692
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001693card_probe_error:
Mark Brown87506542008-11-18 20:50:34 +00001694 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00001695 card->remove(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001696
1697 snd_card_free(card->snd_card);
1698
Mark Brownb19e6e72012-03-14 21:18:39 +00001699base_error:
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001700 mutex_unlock(&card->mutex);
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01001701 mutex_unlock(&client_mutex);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001702
Mark Brownb19e6e72012-03-14 21:18:39 +00001703 return ret;
Mark Brown435c5e22008-12-04 15:32:53 +00001704}
1705
1706/* probes a new socdev */
1707static int soc_probe(struct platform_device *pdev)
1708{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001709 struct snd_soc_card *card = platform_get_drvdata(pdev);
Mark Brown435c5e22008-12-04 15:32:53 +00001710
Vinod Koul70a7ca32011-01-14 19:22:48 +05301711 /*
1712 * no card, so machine driver should be registering card
1713 * we should not be here in that case so ret error
1714 */
1715 if (!card)
1716 return -EINVAL;
1717
Mark Brownfe4085e2012-03-02 13:07:41 +00001718 dev_warn(&pdev->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001719 "ASoC: machine %s should use snd_soc_register_card()\n",
Mark Brownfe4085e2012-03-02 13:07:41 +00001720 card->name);
1721
Mark Brown435c5e22008-12-04 15:32:53 +00001722 /* Bodge while we unpick instantiation */
1723 card->dev = &pdev->dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001724
Mark Brown28d528c2012-08-09 18:45:23 +01001725 return snd_soc_register_card(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001726}
1727
Vinod Koulb0e26482011-01-13 22:48:02 +05301728static int soc_cleanup_card_resources(struct snd_soc_card *card)
1729{
Vinod Koulb0e26482011-01-13 22:48:02 +05301730 int i;
1731
1732 /* make sure any delayed work runs */
1733 for (i = 0; i < card->num_rtd; i++) {
1734 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
Tejun Heo43829732012-08-20 14:51:24 -07001735 flush_delayed_work(&rtd->delayed_work);
Vinod Koulb0e26482011-01-13 22:48:02 +05301736 }
1737
1738 /* remove auxiliary devices */
1739 for (i = 0; i < card->num_aux_devs; i++)
1740 soc_remove_aux_dev(card, i);
1741
1742 /* remove and free each DAI */
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001743 soc_remove_dai_links(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05301744
1745 soc_cleanup_card_debugfs(card);
1746
1747 /* remove the card */
1748 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00001749 card->remove(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05301750
Lars-Peter Clausen0aaae522011-04-30 19:45:47 +02001751 snd_soc_dapm_free(&card->dapm);
1752
Vinod Koulb0e26482011-01-13 22:48:02 +05301753 snd_card_free(card->snd_card);
1754 return 0;
1755
1756}
1757
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001758/* removes a socdev */
1759static int soc_remove(struct platform_device *pdev)
1760{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001761 struct snd_soc_card *card = platform_get_drvdata(pdev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001762
Mark Brownc5af3a22008-11-28 13:29:45 +00001763 snd_soc_unregister_card(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001764 return 0;
1765}
1766
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001767int snd_soc_poweroff(struct device *dev)
Mark Brown51737472009-06-22 13:16:51 +01001768{
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001769 struct snd_soc_card *card = dev_get_drvdata(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001770 int i;
Mark Brown51737472009-06-22 13:16:51 +01001771
1772 if (!card->instantiated)
Mark Brown416356f2009-06-30 19:05:15 +01001773 return 0;
Mark Brown51737472009-06-22 13:16:51 +01001774
1775 /* Flush out pmdown_time work - we actually do want to run it
1776 * now, we're shutting down so no imminent restart. */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001777 for (i = 0; i < card->num_rtd; i++) {
1778 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
Tejun Heo43829732012-08-20 14:51:24 -07001779 flush_delayed_work(&rtd->delayed_work);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001780 }
Mark Brown51737472009-06-22 13:16:51 +01001781
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001782 snd_soc_dapm_shutdown(card);
Mark Brown416356f2009-06-30 19:05:15 +01001783
Nicolin Chen988e8cc2013-11-04 14:57:31 +08001784 /* deactivate pins to sleep state */
1785 for (i = 0; i < card->num_rtd; i++) {
Benoit Cousson88bd8702014-07-08 23:19:34 +02001786 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1787 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1788 int j;
1789
Nicolin Chen988e8cc2013-11-04 14:57:31 +08001790 pinctrl_pm_select_sleep_state(cpu_dai->dev);
Benoit Cousson88bd8702014-07-08 23:19:34 +02001791 for (j = 0; j < rtd->num_codecs; j++) {
1792 struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
1793 pinctrl_pm_select_sleep_state(codec_dai->dev);
1794 }
Nicolin Chen988e8cc2013-11-04 14:57:31 +08001795 }
1796
Mark Brown416356f2009-06-30 19:05:15 +01001797 return 0;
Mark Brown51737472009-06-22 13:16:51 +01001798}
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001799EXPORT_SYMBOL_GPL(snd_soc_poweroff);
Mark Brown51737472009-06-22 13:16:51 +01001800
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001801const struct dev_pm_ops snd_soc_pm_ops = {
Viresh Kumarb1dd5892012-02-24 16:25:49 +05301802 .suspend = snd_soc_suspend,
1803 .resume = snd_soc_resume,
1804 .freeze = snd_soc_suspend,
1805 .thaw = snd_soc_resume,
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001806 .poweroff = snd_soc_poweroff,
Viresh Kumarb1dd5892012-02-24 16:25:49 +05301807 .restore = snd_soc_resume,
Mark Brown416356f2009-06-30 19:05:15 +01001808};
Stephen Warrendeb26072011-04-05 19:35:30 -06001809EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
Mark Brown416356f2009-06-30 19:05:15 +01001810
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001811/* ASoC platform driver */
1812static struct platform_driver soc_driver = {
1813 .driver = {
1814 .name = "soc-audio",
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001815 .pm = &snd_soc_pm_ops,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001816 },
1817 .probe = soc_probe,
1818 .remove = soc_remove,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001819};
1820
Mark Brown096e49d2009-07-05 15:12:22 +01001821/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001822 * snd_soc_cnew - create new control
1823 * @_template: control template
1824 * @data: control private data
Mark Brownac11a2b2009-01-01 12:18:17 +00001825 * @long_name: control long name
Mark Brownefb7ac32011-03-08 17:23:24 +00001826 * @prefix: control name prefix
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001827 *
1828 * Create a new mixer control from a template control.
1829 *
1830 * Returns 0 for success, else error.
1831 */
1832struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
Mark Brown30565572012-02-16 17:07:42 -08001833 void *data, const char *long_name,
Mark Brownefb7ac32011-03-08 17:23:24 +00001834 const char *prefix)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001835{
1836 struct snd_kcontrol_new template;
Mark Brownefb7ac32011-03-08 17:23:24 +00001837 struct snd_kcontrol *kcontrol;
1838 char *name = NULL;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001839
1840 memcpy(&template, _template, sizeof(template));
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001841 template.index = 0;
1842
Mark Brownefb7ac32011-03-08 17:23:24 +00001843 if (!long_name)
1844 long_name = template.name;
1845
1846 if (prefix) {
Lars-Peter Clausen2b581072013-05-14 11:05:32 +02001847 name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
Mark Brownefb7ac32011-03-08 17:23:24 +00001848 if (!name)
1849 return NULL;
1850
Mark Brownefb7ac32011-03-08 17:23:24 +00001851 template.name = name;
1852 } else {
1853 template.name = long_name;
1854 }
1855
1856 kcontrol = snd_ctl_new1(&template, data);
1857
1858 kfree(name);
1859
1860 return kcontrol;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001861}
1862EXPORT_SYMBOL_GPL(snd_soc_cnew);
1863
Liam Girdwood022658b2012-02-03 17:43:09 +00001864static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
1865 const struct snd_kcontrol_new *controls, int num_controls,
1866 const char *prefix, void *data)
1867{
1868 int err, i;
1869
1870 for (i = 0; i < num_controls; i++) {
1871 const struct snd_kcontrol_new *control = &controls[i];
1872 err = snd_ctl_add(card, snd_soc_cnew(control, data,
1873 control->name, prefix));
1874 if (err < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001875 dev_err(dev, "ASoC: Failed to add %s: %d\n",
1876 control->name, err);
Liam Girdwood022658b2012-02-03 17:43:09 +00001877 return err;
1878 }
1879 }
1880
1881 return 0;
1882}
1883
Dimitris Papastamos4fefd692013-07-29 13:51:58 +01001884struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
1885 const char *name)
1886{
1887 struct snd_card *card = soc_card->snd_card;
1888 struct snd_kcontrol *kctl;
1889
1890 if (unlikely(!name))
1891 return NULL;
1892
1893 list_for_each_entry(kctl, &card->controls, list)
1894 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name)))
1895 return kctl;
1896 return NULL;
1897}
1898EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol);
1899
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001900/**
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02001901 * snd_soc_add_component_controls - Add an array of controls to a component.
1902 *
1903 * @component: Component to add controls to
1904 * @controls: Array of controls to add
1905 * @num_controls: Number of elements in the array
1906 *
1907 * Return: 0 for success, else error.
1908 */
1909int snd_soc_add_component_controls(struct snd_soc_component *component,
1910 const struct snd_kcontrol_new *controls, unsigned int num_controls)
1911{
1912 struct snd_card *card = component->card->snd_card;
1913
1914 return snd_soc_add_controls(card, component->dev, controls,
1915 num_controls, component->name_prefix, component);
1916}
1917EXPORT_SYMBOL_GPL(snd_soc_add_component_controls);
1918
1919/**
Liam Girdwood022658b2012-02-03 17:43:09 +00001920 * snd_soc_add_codec_controls - add an array of controls to a codec.
1921 * Convenience function to add a list of controls. Many codecs were
Ian Molton3e8e1952009-01-09 00:23:21 +00001922 * duplicating this code.
1923 *
1924 * @codec: codec to add controls to
1925 * @controls: array of controls to add
1926 * @num_controls: number of elements in the array
1927 *
1928 * Return 0 for success, else error.
1929 */
Liam Girdwood022658b2012-02-03 17:43:09 +00001930int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02001931 const struct snd_kcontrol_new *controls, unsigned int num_controls)
Ian Molton3e8e1952009-01-09 00:23:21 +00001932{
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02001933 return snd_soc_add_component_controls(&codec->component, controls,
1934 num_controls);
Ian Molton3e8e1952009-01-09 00:23:21 +00001935}
Liam Girdwood022658b2012-02-03 17:43:09 +00001936EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls);
Ian Molton3e8e1952009-01-09 00:23:21 +00001937
1938/**
Liam Girdwooda491a5c2011-07-04 22:10:51 +01001939 * snd_soc_add_platform_controls - add an array of controls to a platform.
Liam Girdwood022658b2012-02-03 17:43:09 +00001940 * Convenience function to add a list of controls.
Liam Girdwooda491a5c2011-07-04 22:10:51 +01001941 *
1942 * @platform: platform to add controls to
1943 * @controls: array of controls to add
1944 * @num_controls: number of elements in the array
1945 *
1946 * Return 0 for success, else error.
1947 */
1948int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02001949 const struct snd_kcontrol_new *controls, unsigned int num_controls)
Liam Girdwooda491a5c2011-07-04 22:10:51 +01001950{
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02001951 return snd_soc_add_component_controls(&platform->component, controls,
1952 num_controls);
Liam Girdwooda491a5c2011-07-04 22:10:51 +01001953}
1954EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
1955
1956/**
Liam Girdwood022658b2012-02-03 17:43:09 +00001957 * snd_soc_add_card_controls - add an array of controls to a SoC card.
1958 * Convenience function to add a list of controls.
1959 *
1960 * @soc_card: SoC card to add controls to
1961 * @controls: array of controls to add
1962 * @num_controls: number of elements in the array
1963 *
1964 * Return 0 for success, else error.
1965 */
1966int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
1967 const struct snd_kcontrol_new *controls, int num_controls)
1968{
1969 struct snd_card *card = soc_card->snd_card;
1970
1971 return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,
1972 NULL, soc_card);
1973}
1974EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
1975
1976/**
1977 * snd_soc_add_dai_controls - add an array of controls to a DAI.
1978 * Convienience function to add a list of controls.
1979 *
1980 * @dai: DAI to add controls to
1981 * @controls: array of controls to add
1982 * @num_controls: number of elements in the array
1983 *
1984 * Return 0 for success, else error.
1985 */
1986int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
1987 const struct snd_kcontrol_new *controls, int num_controls)
1988{
Lars-Peter Clausen313665b2014-11-04 11:30:58 +01001989 struct snd_card *card = dai->component->card->snd_card;
Liam Girdwood022658b2012-02-03 17:43:09 +00001990
1991 return snd_soc_add_controls(card, dai->dev, controls, num_controls,
1992 NULL, dai);
1993}
1994EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
1995
1996/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01001997 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
1998 * @dai: DAI
1999 * @clk_id: DAI specific clock ID
2000 * @freq: new clock frequency in Hz
2001 * @dir: new clock direction - input/output.
2002 *
2003 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2004 */
2005int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2006 unsigned int freq, int dir)
2007{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002008 if (dai->driver && dai->driver->ops->set_sysclk)
2009 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
Mark Brownec4ee522011-03-07 20:58:11 +00002010 else if (dai->codec && dai->codec->driver->set_sysclk)
Mark Brownda1c6ea2011-08-24 20:09:01 +01002011 return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,
Mark Brownec4ee522011-03-07 20:58:11 +00002012 freq, dir);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002013 else
Mark Brown1104a9c2014-01-15 19:04:19 +00002014 return -ENOTSUPP;
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002015}
2016EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
2017
2018/**
Mark Brownec4ee522011-03-07 20:58:11 +00002019 * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
2020 * @codec: CODEC
2021 * @clk_id: DAI specific clock ID
Mark Brownda1c6ea2011-08-24 20:09:01 +01002022 * @source: Source for the clock
Mark Brownec4ee522011-03-07 20:58:11 +00002023 * @freq: new clock frequency in Hz
2024 * @dir: new clock direction - input/output.
2025 *
2026 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
2027 */
2028int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
Mark Brownda1c6ea2011-08-24 20:09:01 +01002029 int source, unsigned int freq, int dir)
Mark Brownec4ee522011-03-07 20:58:11 +00002030{
2031 if (codec->driver->set_sysclk)
Mark Brownda1c6ea2011-08-24 20:09:01 +01002032 return codec->driver->set_sysclk(codec, clk_id, source,
2033 freq, dir);
Mark Brownec4ee522011-03-07 20:58:11 +00002034 else
Mark Brown1104a9c2014-01-15 19:04:19 +00002035 return -ENOTSUPP;
Mark Brownec4ee522011-03-07 20:58:11 +00002036}
2037EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
2038
2039/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002040 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
2041 * @dai: DAI
Mark Brownac11a2b2009-01-01 12:18:17 +00002042 * @div_id: DAI specific clock divider ID
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002043 * @div: new clock divisor.
2044 *
2045 * Configures the clock dividers. This is used to derive the best DAI bit and
2046 * frame clocks from the system or master clock. It's best to set the DAI bit
2047 * and frame clocks as low as possible to save system power.
2048 */
2049int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2050 int div_id, int div)
2051{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002052 if (dai->driver && dai->driver->ops->set_clkdiv)
2053 return dai->driver->ops->set_clkdiv(dai, div_id, div);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002054 else
2055 return -EINVAL;
2056}
2057EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
2058
2059/**
2060 * snd_soc_dai_set_pll - configure DAI PLL.
2061 * @dai: DAI
2062 * @pll_id: DAI specific PLL ID
Mark Brown85488032009-09-05 18:52:16 +01002063 * @source: DAI specific source for the PLL
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002064 * @freq_in: PLL input clock frequency in Hz
2065 * @freq_out: requested PLL output clock frequency in Hz
2066 *
2067 * Configures and enables PLL to generate output clock based on input clock.
2068 */
Mark Brown85488032009-09-05 18:52:16 +01002069int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
2070 unsigned int freq_in, unsigned int freq_out)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002071{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002072 if (dai->driver && dai->driver->ops->set_pll)
2073 return dai->driver->ops->set_pll(dai, pll_id, source,
Mark Brown85488032009-09-05 18:52:16 +01002074 freq_in, freq_out);
Mark Brownec4ee522011-03-07 20:58:11 +00002075 else if (dai->codec && dai->codec->driver->set_pll)
2076 return dai->codec->driver->set_pll(dai->codec, pll_id, source,
2077 freq_in, freq_out);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002078 else
2079 return -EINVAL;
2080}
2081EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
2082
Mark Brownec4ee522011-03-07 20:58:11 +00002083/*
2084 * snd_soc_codec_set_pll - configure codec PLL.
2085 * @codec: CODEC
2086 * @pll_id: DAI specific PLL ID
2087 * @source: DAI specific source for the PLL
2088 * @freq_in: PLL input clock frequency in Hz
2089 * @freq_out: requested PLL output clock frequency in Hz
2090 *
2091 * Configures and enables PLL to generate output clock based on input clock.
2092 */
2093int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
2094 unsigned int freq_in, unsigned int freq_out)
2095{
2096 if (codec->driver->set_pll)
2097 return codec->driver->set_pll(codec, pll_id, source,
2098 freq_in, freq_out);
2099 else
2100 return -EINVAL;
2101}
2102EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);
2103
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002104/**
Liam Girdwoode54cf762013-09-16 13:01:46 +01002105 * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
2106 * @dai: DAI
2107 * @ratio Ratio of BCLK to Sample rate.
2108 *
2109 * Configures the DAI for a preset BCLK to sample rate ratio.
2110 */
2111int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
2112{
2113 if (dai->driver && dai->driver->ops->set_bclk_ratio)
2114 return dai->driver->ops->set_bclk_ratio(dai, ratio);
2115 else
2116 return -EINVAL;
2117}
2118EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
2119
2120/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002121 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
2122 * @dai: DAI
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002123 * @fmt: SND_SOC_DAIFMT_ format value.
2124 *
2125 * Configures the DAI hardware format and clocking.
2126 */
2127int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2128{
Shawn Guo5e4ba562012-03-09 00:59:40 +08002129 if (dai->driver == NULL)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002130 return -EINVAL;
Shawn Guo5e4ba562012-03-09 00:59:40 +08002131 if (dai->driver->ops->set_fmt == NULL)
2132 return -ENOTSUPP;
2133 return dai->driver->ops->set_fmt(dai, fmt);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002134}
2135EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
2136
2137/**
Xiubo Lie5c21512014-03-21 14:17:12 +08002138 * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
Xiubo Li89c67852014-02-14 09:34:35 +08002139 * @slots: Number of slots in use.
2140 * @tx_mask: bitmask representing active TX slots.
2141 * @rx_mask: bitmask representing active RX slots.
2142 *
2143 * Generates the TDM tx and rx slot default masks for DAI.
2144 */
Xiubo Lie5c21512014-03-21 14:17:12 +08002145static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
Xiubo Li89c67852014-02-14 09:34:35 +08002146 unsigned int *tx_mask,
2147 unsigned int *rx_mask)
2148{
2149 if (*tx_mask || *rx_mask)
2150 return 0;
2151
2152 if (!slots)
2153 return -EINVAL;
2154
2155 *tx_mask = (1 << slots) - 1;
2156 *rx_mask = (1 << slots) - 1;
2157
2158 return 0;
2159}
2160
2161/**
Lars-Peter Clausene46c9362015-01-12 10:27:20 +01002162 * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
2163 * @dai: The DAI to configure
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002164 * @tx_mask: bitmask representing active TX slots.
2165 * @rx_mask: bitmask representing active RX slots.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002166 * @slots: Number of slots in use.
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002167 * @slot_width: Width in bits for each slot.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002168 *
Lars-Peter Clausene46c9362015-01-12 10:27:20 +01002169 * This function configures the specified DAI for TDM operation. @slot contains
2170 * the total number of slots of the TDM stream and @slot_with the width of each
2171 * slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
2172 * active slots of the TDM stream for the specified DAI, i.e. which slots the
2173 * DAI should write to or read from. If a bit is set the corresponding slot is
2174 * active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
2175 * the first slot, bit 1 to the second slot and so on. The first active slot
2176 * maps to the first channel of the DAI, the second active slot to the second
2177 * channel and so on.
2178 *
2179 * TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
2180 * @rx_mask and @slot_width will be ignored.
2181 *
2182 * Returns 0 on success, a negative error code otherwise.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002183 */
2184int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002185 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002186{
Xiubo Lie5c21512014-03-21 14:17:12 +08002187 if (dai->driver && dai->driver->ops->xlate_tdm_slot_mask)
2188 dai->driver->ops->xlate_tdm_slot_mask(slots,
Xiubo Li89c67852014-02-14 09:34:35 +08002189 &tx_mask, &rx_mask);
2190 else
Xiubo Lie5c21512014-03-21 14:17:12 +08002191 snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
Xiubo Li89c67852014-02-14 09:34:35 +08002192
Benoit Cousson88bd8702014-07-08 23:19:34 +02002193 dai->tx_mask = tx_mask;
2194 dai->rx_mask = rx_mask;
2195
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002196 if (dai->driver && dai->driver->ops->set_tdm_slot)
2197 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002198 slots, slot_width);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002199 else
Xiubo Lib2cbb6e2014-01-23 13:02:47 +08002200 return -ENOTSUPP;
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002201}
2202EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
2203
2204/**
Barry Song472df3c2009-09-12 01:16:29 +08002205 * snd_soc_dai_set_channel_map - configure DAI audio channel map
2206 * @dai: DAI
2207 * @tx_num: how many TX channels
2208 * @tx_slot: pointer to an array which imply the TX slot number channel
2209 * 0~num-1 uses
2210 * @rx_num: how many RX channels
2211 * @rx_slot: pointer to an array which imply the RX slot number channel
2212 * 0~num-1 uses
2213 *
2214 * configure the relationship between channel number and TDM slot number.
2215 */
2216int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
2217 unsigned int tx_num, unsigned int *tx_slot,
2218 unsigned int rx_num, unsigned int *rx_slot)
2219{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002220 if (dai->driver && dai->driver->ops->set_channel_map)
2221 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
Barry Song472df3c2009-09-12 01:16:29 +08002222 rx_num, rx_slot);
2223 else
2224 return -EINVAL;
2225}
2226EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
2227
2228/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002229 * snd_soc_dai_set_tristate - configure DAI system or master clock.
2230 * @dai: DAI
2231 * @tristate: tristate enable
2232 *
2233 * Tristates the DAI so that others can use it.
2234 */
2235int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
2236{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002237 if (dai->driver && dai->driver->ops->set_tristate)
2238 return dai->driver->ops->set_tristate(dai, tristate);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002239 else
2240 return -EINVAL;
2241}
2242EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
2243
2244/**
2245 * snd_soc_dai_digital_mute - configure DAI system or master clock.
2246 * @dai: DAI
2247 * @mute: mute enable
Mark Brownda183962013-02-06 15:44:07 +00002248 * @direction: stream to mute
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002249 *
2250 * Mutes the DAI DAC.
2251 */
Mark Brownda183962013-02-06 15:44:07 +00002252int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
2253 int direction)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002254{
Mark Brownda183962013-02-06 15:44:07 +00002255 if (!dai->driver)
2256 return -ENOTSUPP;
2257
2258 if (dai->driver->ops->mute_stream)
2259 return dai->driver->ops->mute_stream(dai, mute, direction);
2260 else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
2261 dai->driver->ops->digital_mute)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002262 return dai->driver->ops->digital_mute(dai, mute);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002263 else
Mark Brown04570c62012-04-13 19:16:03 +01002264 return -ENOTSUPP;
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002265}
2266EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
2267
Benoit Cousson88bd8702014-07-08 23:19:34 +02002268static int snd_soc_init_multicodec(struct snd_soc_card *card,
2269 struct snd_soc_dai_link *dai_link)
2270{
2271 /* Legacy codec/codec_dai link is a single entry in multicodec */
2272 if (dai_link->codec_name || dai_link->codec_of_node ||
2273 dai_link->codec_dai_name) {
2274 dai_link->num_codecs = 1;
2275
2276 dai_link->codecs = devm_kzalloc(card->dev,
2277 sizeof(struct snd_soc_dai_link_component),
2278 GFP_KERNEL);
2279 if (!dai_link->codecs)
2280 return -ENOMEM;
2281
2282 dai_link->codecs[0].name = dai_link->codec_name;
2283 dai_link->codecs[0].of_node = dai_link->codec_of_node;
2284 dai_link->codecs[0].dai_name = dai_link->codec_dai_name;
2285 }
2286
2287 if (!dai_link->codecs) {
2288 dev_err(card->dev, "ASoC: DAI link has no CODECs\n");
2289 return -EINVAL;
2290 }
2291
2292 return 0;
2293}
2294
Mark Brownc5af3a22008-11-28 13:29:45 +00002295/**
2296 * snd_soc_register_card - Register a card with the ASoC core
2297 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002298 * @card: Card to register
Mark Brownc5af3a22008-11-28 13:29:45 +00002299 *
Mark Brownc5af3a22008-11-28 13:29:45 +00002300 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05302301int snd_soc_register_card(struct snd_soc_card *card)
Mark Brownc5af3a22008-11-28 13:29:45 +00002302{
Benoit Cousson88bd8702014-07-08 23:19:34 +02002303 int i, j, ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002304
Mark Brownc5af3a22008-11-28 13:29:45 +00002305 if (!card->name || !card->dev)
2306 return -EINVAL;
2307
Stephen Warren5a504962011-12-21 10:40:59 -07002308 for (i = 0; i < card->num_links; i++) {
2309 struct snd_soc_dai_link *link = &card->dai_link[i];
2310
Benoit Cousson88bd8702014-07-08 23:19:34 +02002311 ret = snd_soc_init_multicodec(card, link);
2312 if (ret) {
2313 dev_err(card->dev, "ASoC: failed to init multicodec\n");
2314 return ret;
Stephen Warren5a504962011-12-21 10:40:59 -07002315 }
Benoit Cousson88bd8702014-07-08 23:19:34 +02002316
2317 for (j = 0; j < link->num_codecs; j++) {
2318 /*
2319 * Codec must be specified by 1 of name or OF node,
2320 * not both or neither.
2321 */
2322 if (!!link->codecs[j].name ==
2323 !!link->codecs[j].of_node) {
2324 dev_err(card->dev, "ASoC: Neither/both codec name/of_node are set for %s\n",
2325 link->name);
2326 return -EINVAL;
2327 }
2328 /* Codec DAI name must be specified */
2329 if (!link->codecs[j].dai_name) {
2330 dev_err(card->dev, "ASoC: codec_dai_name not set for %s\n",
2331 link->name);
2332 return -EINVAL;
2333 }
Stephen Warrenbc926572012-05-25 18:22:11 -06002334 }
Stephen Warren5a504962011-12-21 10:40:59 -07002335
2336 /*
2337 * Platform may be specified by either name or OF node, but
2338 * can be left unspecified, and a dummy platform will be used.
2339 */
2340 if (link->platform_name && link->platform_of_node) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02002341 dev_err(card->dev,
2342 "ASoC: Both platform name/of_node are set for %s\n",
2343 link->name);
Stephen Warren5a504962011-12-21 10:40:59 -07002344 return -EINVAL;
2345 }
2346
2347 /*
Stephen Warrenbc926572012-05-25 18:22:11 -06002348 * CPU device may be specified by either name or OF node, but
2349 * can be left unspecified, and will be matched based on DAI
2350 * name alone..
Stephen Warren5a504962011-12-21 10:40:59 -07002351 */
Stephen Warrenbc926572012-05-25 18:22:11 -06002352 if (link->cpu_name && link->cpu_of_node) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02002353 dev_err(card->dev,
2354 "ASoC: Neither/both cpu name/of_node are set for %s\n",
2355 link->name);
Stephen Warrenbc926572012-05-25 18:22:11 -06002356 return -EINVAL;
2357 }
2358 /*
2359 * At least one of CPU DAI name or CPU device name/node must be
2360 * specified
2361 */
2362 if (!link->cpu_dai_name &&
2363 !(link->cpu_name || link->cpu_of_node)) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02002364 dev_err(card->dev,
2365 "ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
2366 link->name);
Stephen Warren5a504962011-12-21 10:40:59 -07002367 return -EINVAL;
2368 }
2369 }
2370
Mark Browned77cc12011-05-03 18:25:34 +01002371 dev_set_drvdata(card->dev, card);
2372
Stephen Warren111c6412011-01-28 14:26:35 -07002373 snd_soc_initialize_card_lists(card);
2374
Vinod Koul150dd2f2011-01-13 22:48:32 +05302375 soc_init_card_debugfs(card);
2376
Mark Brown181a6892012-03-14 20:18:49 +00002377 card->rtd = devm_kzalloc(card->dev,
2378 sizeof(struct snd_soc_pcm_runtime) *
2379 (card->num_links + card->num_aux_devs),
2380 GFP_KERNEL);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002381 if (card->rtd == NULL)
2382 return -ENOMEM;
Liam Girdwooda7dbb602012-04-17 18:00:11 +01002383 card->num_rtd = 0;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02002384 card->rtd_aux = &card->rtd[card->num_links];
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002385
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02002386 for (i = 0; i < card->num_links; i++) {
2387 card->rtd[i].card = card;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002388 card->rtd[i].dai_link = &card->dai_link[i];
Benoit Cousson88bd8702014-07-08 23:19:34 +02002389 card->rtd[i].codec_dais = devm_kzalloc(card->dev,
2390 sizeof(struct snd_soc_dai *) *
2391 (card->rtd[i].dai_link->num_codecs),
2392 GFP_KERNEL);
2393 if (card->rtd[i].codec_dais == NULL)
2394 return -ENOMEM;
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02002395 }
2396
2397 for (i = 0; i < card->num_aux_devs; i++)
2398 card->rtd_aux[i].card = card;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002399
Mark Browndb432b42011-10-03 21:06:40 +01002400 INIT_LIST_HEAD(&card->dapm_dirty);
Mark Brownc5af3a22008-11-28 13:29:45 +00002401 card->instantiated = 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002402 mutex_init(&card->mutex);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002403 mutex_init(&card->dapm_mutex);
Mark Brownc5af3a22008-11-28 13:29:45 +00002404
Mark Brownb19e6e72012-03-14 21:18:39 +00002405 ret = snd_soc_instantiate_card(card);
2406 if (ret != 0)
2407 soc_cleanup_card_debugfs(card);
Mark Brownc5af3a22008-11-28 13:29:45 +00002408
Nicolin Chen988e8cc2013-11-04 14:57:31 +08002409 /* deactivate pins to sleep state */
2410 for (i = 0; i < card->num_rtd; i++) {
Benoit Cousson88bd8702014-07-08 23:19:34 +02002411 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
2412 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2413 int j;
2414
2415 for (j = 0; j < rtd->num_codecs; j++) {
2416 struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
2417 if (!codec_dai->active)
2418 pinctrl_pm_select_sleep_state(codec_dai->dev);
2419 }
2420
Nicolin Chen988e8cc2013-11-04 14:57:31 +08002421 if (!cpu_dai->active)
2422 pinctrl_pm_select_sleep_state(cpu_dai->dev);
2423 }
2424
Mark Brownb19e6e72012-03-14 21:18:39 +00002425 return ret;
Mark Brownc5af3a22008-11-28 13:29:45 +00002426}
Vinod Koul70a7ca32011-01-14 19:22:48 +05302427EXPORT_SYMBOL_GPL(snd_soc_register_card);
Mark Brownc5af3a22008-11-28 13:29:45 +00002428
2429/**
2430 * snd_soc_unregister_card - Unregister a card with the ASoC core
2431 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002432 * @card: Card to unregister
Mark Brownc5af3a22008-11-28 13:29:45 +00002433 *
Mark Brownc5af3a22008-11-28 13:29:45 +00002434 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05302435int snd_soc_unregister_card(struct snd_soc_card *card)
Mark Brownc5af3a22008-11-28 13:29:45 +00002436{
Lars-Peter Clausen01e0df62014-09-04 19:44:04 +02002437 if (card->instantiated) {
2438 card->instantiated = false;
Lars-Peter Clausen1c325f72014-09-04 19:44:05 +02002439 snd_soc_dapm_shutdown(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05302440 soc_cleanup_card_resources(card);
Kuninori Morimoto8f6f9b22015-02-05 05:34:10 +00002441 dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
Lars-Peter Clausen01e0df62014-09-04 19:44:04 +02002442 }
Mark Brownc5af3a22008-11-28 13:29:45 +00002443
2444 return 0;
2445}
Vinod Koul70a7ca32011-01-14 19:22:48 +05302446EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
Mark Brownc5af3a22008-11-28 13:29:45 +00002447
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002448/*
2449 * Simplify DAI link configuration by removing ".-1" from device names
2450 * and sanitizing names.
2451 */
Dimitris Papastamos0b9a2142010-12-06 15:49:20 +00002452static char *fmt_single_name(struct device *dev, int *id)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002453{
2454 char *found, name[NAME_SIZE];
2455 int id1, id2;
2456
2457 if (dev_name(dev) == NULL)
2458 return NULL;
2459
Dimitris Papastamos58818a72010-12-06 15:42:17 +00002460 strlcpy(name, dev_name(dev), NAME_SIZE);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002461
2462 /* are we a "%s.%d" name (platform and SPI components) */
2463 found = strstr(name, dev->driver->name);
2464 if (found) {
2465 /* get ID */
2466 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
2467
2468 /* discard ID from name if ID == -1 */
2469 if (*id == -1)
2470 found[strlen(dev->driver->name)] = '\0';
2471 }
2472
2473 } else {
2474 /* I2C component devices are named "bus-addr" */
2475 if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
2476 char tmp[NAME_SIZE];
2477
2478 /* create unique ID number from I2C addr and bus */
Jarkko Nikula05899442010-10-19 11:10:45 +03002479 *id = ((id1 & 0xffff) << 16) + id2;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002480
2481 /* sanitize component name for DAI link creation */
2482 snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
Dimitris Papastamos58818a72010-12-06 15:42:17 +00002483 strlcpy(name, tmp, NAME_SIZE);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002484 } else
2485 *id = 0;
2486 }
2487
2488 return kstrdup(name, GFP_KERNEL);
2489}
2490
2491/*
2492 * Simplify DAI link naming for single devices with multiple DAIs by removing
2493 * any ".-1" and using the DAI name (instead of device name).
2494 */
2495static inline char *fmt_multiple_name(struct device *dev,
2496 struct snd_soc_dai_driver *dai_drv)
2497{
2498 if (dai_drv->name == NULL) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02002499 dev_err(dev,
2500 "ASoC: error - multiple DAI %s registered with no name\n",
2501 dev_name(dev));
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002502 return NULL;
2503 }
2504
2505 return kstrdup(dai_drv->name, GFP_KERNEL);
2506}
2507
Mark Brown91151712008-11-30 23:31:24 +00002508/**
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002509 * snd_soc_unregister_dai - Unregister DAIs from the ASoC core
Mark Brown91151712008-11-30 23:31:24 +00002510 *
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002511 * @component: The component for which the DAIs should be unregistered
Mark Brown91151712008-11-30 23:31:24 +00002512 */
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002513static void snd_soc_unregister_dais(struct snd_soc_component *component)
Mark Brown91151712008-11-30 23:31:24 +00002514{
Lars-Peter Clausen5c1d5f02014-03-12 08:34:39 +01002515 struct snd_soc_dai *dai, *_dai;
Mark Brown91151712008-11-30 23:31:24 +00002516
Lars-Peter Clausen5c1d5f02014-03-12 08:34:39 +01002517 list_for_each_entry_safe(dai, _dai, &component->dai_list, list) {
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002518 dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",
2519 dai->name);
Lars-Peter Clausen5c1d5f02014-03-12 08:34:39 +01002520 list_del(&dai->list);
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002521 kfree(dai->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002522 kfree(dai);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002523 }
Mark Brown91151712008-11-30 23:31:24 +00002524}
Mark Brown91151712008-11-30 23:31:24 +00002525
2526/**
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002527 * snd_soc_register_dais - Register a DAI with the ASoC core
Mark Brown91151712008-11-30 23:31:24 +00002528 *
Lars-Peter Clausen6106d122014-03-05 13:17:46 +01002529 * @component: The component the DAIs are registered for
2530 * @dai_drv: DAI driver to use for the DAIs
Mark Brownac11a2b2009-01-01 12:18:17 +00002531 * @count: Number of DAIs
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002532 * @legacy_dai_naming: Use the legacy naming scheme and let the DAI inherit the
2533 * parent's name.
Mark Brown91151712008-11-30 23:31:24 +00002534 */
Lars-Peter Clausen6106d122014-03-05 13:17:46 +01002535static int snd_soc_register_dais(struct snd_soc_component *component,
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002536 struct snd_soc_dai_driver *dai_drv, size_t count,
2537 bool legacy_dai_naming)
Mark Brown91151712008-11-30 23:31:24 +00002538{
Lars-Peter Clausen6106d122014-03-05 13:17:46 +01002539 struct device *dev = component->dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002540 struct snd_soc_dai *dai;
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002541 unsigned int i;
2542 int ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002543
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00002544 dev_dbg(dev, "ASoC: dai register %s #%Zu\n", dev_name(dev), count);
Mark Brown91151712008-11-30 23:31:24 +00002545
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002546 component->dai_drv = dai_drv;
2547 component->num_dai = count;
2548
Mark Brown91151712008-11-30 23:31:24 +00002549 for (i = 0; i < count; i++) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002550
2551 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
Axel Linc46e0072010-11-03 15:04:45 +08002552 if (dai == NULL) {
2553 ret = -ENOMEM;
2554 goto err;
2555 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002556
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002557 /*
2558 * Back in the old days when we still had component-less DAIs,
2559 * instead of having a static name, component-less DAIs would
2560 * inherit the name of the parent device so it is possible to
2561 * register multiple instances of the DAI. We still need to keep
2562 * the same naming style even though those DAIs are not
2563 * component-less anymore.
2564 */
2565 if (count == 1 && legacy_dai_naming) {
2566 dai->name = fmt_single_name(dev, &dai->id);
2567 } else {
2568 dai->name = fmt_multiple_name(dev, &dai_drv[i]);
2569 if (dai_drv[i].id)
2570 dai->id = dai_drv[i].id;
2571 else
2572 dai->id = i;
2573 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002574 if (dai->name == NULL) {
2575 kfree(dai);
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002576 ret = -ENOMEM;
Mark Brown91151712008-11-30 23:31:24 +00002577 goto err;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002578 }
2579
Lars-Peter Clausen6106d122014-03-05 13:17:46 +01002580 dai->component = component;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002581 dai->dev = dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002582 dai->driver = &dai_drv[i];
2583 if (!dai->driver->ops)
2584 dai->driver->ops = &null_dai_ops;
2585
Lars-Peter Clausen1438c2f2014-03-09 17:41:47 +01002586 list_add(&dai->list, &component->dai_list);
Mark Brown054880f2012-04-09 17:29:19 +01002587
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002588 dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
Mark Brown91151712008-11-30 23:31:24 +00002589 }
2590
2591 return 0;
2592
2593err:
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002594 snd_soc_unregister_dais(component);
Mark Brown91151712008-11-30 23:31:24 +00002595
2596 return ret;
2597}
Mark Brown91151712008-11-30 23:31:24 +00002598
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002599static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context *dapm,
2600 enum snd_soc_dapm_type type, int subseq)
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002601{
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002602 struct snd_soc_component *component = dapm->component;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002603
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002604 component->driver->seq_notifier(component, type, subseq);
2605}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002606
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002607static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,
2608 int event)
2609{
2610 struct snd_soc_component *component = dapm->component;
2611
2612 return component->driver->stream_event(component, event);
2613}
2614
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002615static int snd_soc_component_initialize(struct snd_soc_component *component,
2616 const struct snd_soc_component_driver *driver, struct device *dev)
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002617{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02002618 struct snd_soc_dapm_context *dapm;
2619
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002620 component->name = fmt_single_name(dev, &component->id);
2621 if (!component->name) {
2622 dev_err(dev, "ASoC: Failed to allocate name\n");
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002623 return -ENOMEM;
2624 }
2625
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002626 component->dev = dev;
2627 component->driver = driver;
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02002628 component->probe = component->driver->probe;
2629 component->remove = component->driver->remove;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002630
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02002631 if (!component->dapm_ptr)
2632 component->dapm_ptr = &component->dapm;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002633
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02002634 dapm = component->dapm_ptr;
2635 dapm->dev = dev;
2636 dapm->component = component;
2637 dapm->bias_level = SND_SOC_BIAS_OFF;
Lars-Peter Clausen5819c2f2014-08-24 15:36:55 +02002638 dapm->idle_bias_off = true;
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002639 if (driver->seq_notifier)
2640 dapm->seq_notifier = snd_soc_component_seq_notifier;
2641 if (driver->stream_event)
2642 dapm->stream_event = snd_soc_component_stream_event;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002643
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02002644 component->controls = driver->controls;
2645 component->num_controls = driver->num_controls;
2646 component->dapm_widgets = driver->dapm_widgets;
2647 component->num_dapm_widgets = driver->num_dapm_widgets;
2648 component->dapm_routes = driver->dapm_routes;
2649 component->num_dapm_routes = driver->num_dapm_routes;
2650
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002651 INIT_LIST_HEAD(&component->dai_list);
2652 mutex_init(&component->io_mutex);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002653
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002654 return 0;
2655}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002656
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01002657static void snd_soc_component_setup_regmap(struct snd_soc_component *component)
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02002658{
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01002659 int val_bytes = regmap_get_val_bytes(component->regmap);
2660
2661 /* Errors are legitimate for non-integer byte multiples */
2662 if (val_bytes > 0)
2663 component->val_bytes = val_bytes;
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02002664}
2665
Lars-Peter Clausene874bf52014-11-25 21:41:03 +01002666#ifdef CONFIG_REGMAP
2667
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01002668/**
2669 * snd_soc_component_init_regmap() - Initialize regmap instance for the component
2670 * @component: The component for which to initialize the regmap instance
2671 * @regmap: The regmap instance that should be used by the component
2672 *
2673 * This function allows deferred assignment of the regmap instance that is
2674 * associated with the component. Only use this if the regmap instance is not
2675 * yet ready when the component is registered. The function must also be called
2676 * before the first IO attempt of the component.
2677 */
2678void snd_soc_component_init_regmap(struct snd_soc_component *component,
2679 struct regmap *regmap)
2680{
2681 component->regmap = regmap;
2682 snd_soc_component_setup_regmap(component);
2683}
2684EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap);
2685
2686/**
2687 * snd_soc_component_exit_regmap() - De-initialize regmap instance for the component
2688 * @component: The component for which to de-initialize the regmap instance
2689 *
2690 * Calls regmap_exit() on the regmap instance associated to the component and
2691 * removes the regmap instance from the component.
2692 *
2693 * This function should only be used if snd_soc_component_init_regmap() was used
2694 * to initialize the regmap instance.
2695 */
2696void snd_soc_component_exit_regmap(struct snd_soc_component *component)
2697{
2698 regmap_exit(component->regmap);
2699 component->regmap = NULL;
2700}
2701EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap);
2702
Lars-Peter Clausene874bf52014-11-25 21:41:03 +01002703#endif
2704
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002705static void snd_soc_component_add_unlocked(struct snd_soc_component *component)
2706{
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01002707 if (!component->write && !component->read) {
2708 if (!component->regmap)
2709 component->regmap = dev_get_regmap(component->dev, NULL);
2710 if (component->regmap)
2711 snd_soc_component_setup_regmap(component);
2712 }
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02002713
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002714 list_add(&component->list, &component_list);
2715}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002716
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002717static void snd_soc_component_add(struct snd_soc_component *component)
2718{
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002719 mutex_lock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002720 snd_soc_component_add_unlocked(component);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002721 mutex_unlock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002722}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002723
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002724static void snd_soc_component_cleanup(struct snd_soc_component *component)
2725{
2726 snd_soc_unregister_dais(component);
2727 kfree(component->name);
2728}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002729
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002730static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
2731{
2732 list_del(&component->list);
2733}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002734
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002735int snd_soc_register_component(struct device *dev,
2736 const struct snd_soc_component_driver *cmpnt_drv,
2737 struct snd_soc_dai_driver *dai_drv,
2738 int num_dai)
2739{
2740 struct snd_soc_component *cmpnt;
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002741 int ret;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002742
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002743 cmpnt = kzalloc(sizeof(*cmpnt), GFP_KERNEL);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002744 if (!cmpnt) {
2745 dev_err(dev, "ASoC: Failed to allocate memory\n");
2746 return -ENOMEM;
2747 }
2748
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002749 ret = snd_soc_component_initialize(cmpnt, cmpnt_drv, dev);
2750 if (ret)
2751 goto err_free;
2752
Lars-Peter Clausen3d594002014-03-05 13:17:48 +01002753 cmpnt->ignore_pmdown_time = true;
Lars-Peter Clausen98e639f2014-03-18 09:02:11 +01002754 cmpnt->registered_as_component = true;
Lars-Peter Clausen3d594002014-03-05 13:17:48 +01002755
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002756 ret = snd_soc_register_dais(cmpnt, dai_drv, num_dai, true);
2757 if (ret < 0) {
2758 dev_err(dev, "ASoC: Failed to regster DAIs: %d\n", ret);
2759 goto err_cleanup;
2760 }
2761
2762 snd_soc_component_add(cmpnt);
2763
2764 return 0;
2765
2766err_cleanup:
2767 snd_soc_component_cleanup(cmpnt);
2768err_free:
2769 kfree(cmpnt);
2770 return ret;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002771}
2772EXPORT_SYMBOL_GPL(snd_soc_register_component);
2773
2774/**
2775 * snd_soc_unregister_component - Unregister a component from the ASoC core
2776 *
2777 */
2778void snd_soc_unregister_component(struct device *dev)
2779{
2780 struct snd_soc_component *cmpnt;
2781
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002782 mutex_lock(&client_mutex);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002783 list_for_each_entry(cmpnt, &component_list, list) {
Lars-Peter Clausen98e639f2014-03-18 09:02:11 +01002784 if (dev == cmpnt->dev && cmpnt->registered_as_component)
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002785 goto found;
2786 }
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002787 mutex_unlock(&client_mutex);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002788 return;
2789
2790found:
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002791 snd_soc_component_del_unlocked(cmpnt);
2792 mutex_unlock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002793 snd_soc_component_cleanup(cmpnt);
2794 kfree(cmpnt);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002795}
2796EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
2797
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02002798static int snd_soc_platform_drv_probe(struct snd_soc_component *component)
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002799{
2800 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
2801
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02002802 return platform->driver->probe(platform);
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002803}
2804
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02002805static void snd_soc_platform_drv_remove(struct snd_soc_component *component)
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002806{
2807 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
2808
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02002809 platform->driver->remove(platform);
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002810}
2811
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002812/**
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002813 * snd_soc_add_platform - Add a platform to the ASoC core
2814 * @dev: The parent device for the platform
2815 * @platform: The platform to add
2816 * @platform_driver: The driver for the platform
Mark Brown12a48a8c2008-12-03 19:40:30 +00002817 */
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002818int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
Lars-Peter Clausend79e57d2013-03-27 12:02:22 +01002819 const struct snd_soc_platform_driver *platform_drv)
Mark Brown12a48a8c2008-12-03 19:40:30 +00002820{
Lars-Peter Clausenb37f1d12014-03-18 09:02:12 +01002821 int ret;
2822
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002823 ret = snd_soc_component_initialize(&platform->component,
2824 &platform_drv->component_driver, dev);
2825 if (ret)
2826 return ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002827
2828 platform->dev = dev;
2829 platform->driver = platform_drv;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02002830
2831 if (platform_drv->probe)
2832 platform->component.probe = snd_soc_platform_drv_probe;
2833 if (platform_drv->remove)
2834 platform->component.remove = snd_soc_platform_drv_remove;
Mark Brown12a48a8c2008-12-03 19:40:30 +00002835
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +02002836#ifdef CONFIG_DEBUG_FS
2837 platform->component.debugfs_prefix = "platform";
2838#endif
Mark Brown12a48a8c2008-12-03 19:40:30 +00002839
2840 mutex_lock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002841 snd_soc_component_add_unlocked(&platform->component);
Mark Brown12a48a8c2008-12-03 19:40:30 +00002842 list_add(&platform->list, &platform_list);
2843 mutex_unlock(&client_mutex);
2844
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02002845 dev_dbg(dev, "ASoC: Registered platform '%s'\n",
2846 platform->component.name);
Mark Brown12a48a8c2008-12-03 19:40:30 +00002847
2848 return 0;
2849}
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002850EXPORT_SYMBOL_GPL(snd_soc_add_platform);
2851
2852/**
2853 * snd_soc_register_platform - Register a platform with the ASoC core
2854 *
2855 * @platform: platform to register
2856 */
2857int snd_soc_register_platform(struct device *dev,
2858 const struct snd_soc_platform_driver *platform_drv)
2859{
2860 struct snd_soc_platform *platform;
2861 int ret;
2862
2863 dev_dbg(dev, "ASoC: platform register %s\n", dev_name(dev));
2864
2865 platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
2866 if (platform == NULL)
2867 return -ENOMEM;
2868
2869 ret = snd_soc_add_platform(dev, platform, platform_drv);
2870 if (ret)
2871 kfree(platform);
2872
2873 return ret;
2874}
Mark Brown12a48a8c2008-12-03 19:40:30 +00002875EXPORT_SYMBOL_GPL(snd_soc_register_platform);
2876
2877/**
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002878 * snd_soc_remove_platform - Remove a platform from the ASoC core
2879 * @platform: the platform to remove
2880 */
2881void snd_soc_remove_platform(struct snd_soc_platform *platform)
2882{
Lars-Peter Clausenb37f1d12014-03-18 09:02:12 +01002883
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002884 mutex_lock(&client_mutex);
2885 list_del(&platform->list);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002886 snd_soc_component_del_unlocked(&platform->component);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002887 mutex_unlock(&client_mutex);
2888
2889 dev_dbg(platform->dev, "ASoC: Unregistered platform '%s'\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02002890 platform->component.name);
Daniel Mackdecc27b2014-10-07 13:41:23 +02002891
2892 snd_soc_component_cleanup(&platform->component);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002893}
2894EXPORT_SYMBOL_GPL(snd_soc_remove_platform);
2895
2896struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev)
2897{
2898 struct snd_soc_platform *platform;
2899
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002900 mutex_lock(&client_mutex);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002901 list_for_each_entry(platform, &platform_list, list) {
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002902 if (dev == platform->dev) {
2903 mutex_unlock(&client_mutex);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002904 return platform;
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002905 }
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002906 }
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002907 mutex_unlock(&client_mutex);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002908
2909 return NULL;
2910}
2911EXPORT_SYMBOL_GPL(snd_soc_lookup_platform);
2912
2913/**
Mark Brown12a48a8c2008-12-03 19:40:30 +00002914 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
2915 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002916 * @platform: platform to unregister
Mark Brown12a48a8c2008-12-03 19:40:30 +00002917 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002918void snd_soc_unregister_platform(struct device *dev)
Mark Brown12a48a8c2008-12-03 19:40:30 +00002919{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002920 struct snd_soc_platform *platform;
2921
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002922 platform = snd_soc_lookup_platform(dev);
2923 if (!platform)
2924 return;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002925
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002926 snd_soc_remove_platform(platform);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002927 kfree(platform);
Mark Brown12a48a8c2008-12-03 19:40:30 +00002928}
2929EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
2930
Mark Brown151ab222009-05-09 16:22:58 +01002931static u64 codec_format_map[] = {
2932 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
2933 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
2934 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
2935 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
2936 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
2937 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
2938 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
2939 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
2940 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
2941 SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
2942 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
2943 SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
2944 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
2945 SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
2946 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
2947 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
2948};
2949
2950/* Fix up the DAI formats for endianness: codecs don't actually see
2951 * the endianness of the data but we're using the CPU format
2952 * definitions which do need to include endianness so we ensure that
2953 * codec DAIs always have both big and little endian variants set.
2954 */
2955static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
2956{
2957 int i;
2958
2959 for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
2960 if (stream->formats & codec_format_map[i])
2961 stream->formats |= codec_format_map[i];
2962}
2963
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02002964static int snd_soc_codec_drv_probe(struct snd_soc_component *component)
2965{
2966 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
2967
2968 return codec->driver->probe(codec);
2969}
2970
2971static void snd_soc_codec_drv_remove(struct snd_soc_component *component)
2972{
2973 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
2974
2975 codec->driver->remove(codec);
2976}
2977
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002978static int snd_soc_codec_drv_write(struct snd_soc_component *component,
2979 unsigned int reg, unsigned int val)
2980{
2981 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
2982
2983 return codec->driver->write(codec, reg, val);
2984}
2985
2986static int snd_soc_codec_drv_read(struct snd_soc_component *component,
2987 unsigned int reg, unsigned int *val)
2988{
2989 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
2990
2991 *val = codec->driver->read(codec, reg);
2992
2993 return 0;
2994}
2995
Lars-Peter Clausen68f831c2014-06-16 18:13:05 +02002996static int snd_soc_codec_set_bias_level(struct snd_soc_dapm_context *dapm,
2997 enum snd_soc_bias_level level)
2998{
2999 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
3000
3001 return codec->driver->set_bias_level(codec, level);
3002}
3003
Mark Brown0d0cf002008-12-10 14:32:45 +00003004/**
3005 * snd_soc_register_codec - Register a codec with the ASoC core
3006 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003007 * @codec: codec to register
Mark Brown0d0cf002008-12-10 14:32:45 +00003008 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003009int snd_soc_register_codec(struct device *dev,
Mark Brown001ae4c2010-12-02 16:21:08 +00003010 const struct snd_soc_codec_driver *codec_drv,
3011 struct snd_soc_dai_driver *dai_drv,
3012 int num_dai)
Mark Brown0d0cf002008-12-10 14:32:45 +00003013{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003014 struct snd_soc_codec *codec;
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003015 struct snd_soc_dai *dai;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003016 int ret, i;
Mark Brown151ab222009-05-09 16:22:58 +01003017
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003018 dev_dbg(dev, "codec register %s\n", dev_name(dev));
Mark Brown0d0cf002008-12-10 14:32:45 +00003019
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003020 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
3021 if (codec == NULL)
3022 return -ENOMEM;
Mark Brown0d0cf002008-12-10 14:32:45 +00003023
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003024 codec->component.dapm_ptr = &codec->dapm;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003025 codec->component.codec = codec;
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003026
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003027 ret = snd_soc_component_initialize(&codec->component,
3028 &codec_drv->component_driver, dev);
3029 if (ret)
3030 goto err_free;
Mark Brown151ab222009-05-09 16:22:58 +01003031
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003032 if (codec_drv->controls) {
3033 codec->component.controls = codec_drv->controls;
3034 codec->component.num_controls = codec_drv->num_controls;
3035 }
3036 if (codec_drv->dapm_widgets) {
3037 codec->component.dapm_widgets = codec_drv->dapm_widgets;
3038 codec->component.num_dapm_widgets = codec_drv->num_dapm_widgets;
3039 }
3040 if (codec_drv->dapm_routes) {
3041 codec->component.dapm_routes = codec_drv->dapm_routes;
3042 codec->component.num_dapm_routes = codec_drv->num_dapm_routes;
3043 }
3044
3045 if (codec_drv->probe)
3046 codec->component.probe = snd_soc_codec_drv_probe;
3047 if (codec_drv->remove)
3048 codec->component.remove = snd_soc_codec_drv_remove;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003049 if (codec_drv->write)
3050 codec->component.write = snd_soc_codec_drv_write;
3051 if (codec_drv->read)
3052 codec->component.read = snd_soc_codec_drv_read;
Lars-Peter Clausen3d594002014-03-05 13:17:48 +01003053 codec->component.ignore_pmdown_time = codec_drv->ignore_pmdown_time;
Lars-Peter Clausen5819c2f2014-08-24 15:36:55 +02003054 codec->dapm.idle_bias_off = codec_drv->idle_bias_off;
Lars-Peter Clausen86dbf2a2014-09-04 19:44:06 +02003055 codec->dapm.suspend_bias_off = codec_drv->suspend_bias_off;
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02003056 if (codec_drv->seq_notifier)
3057 codec->dapm.seq_notifier = codec_drv->seq_notifier;
Lars-Peter Clausen68f831c2014-06-16 18:13:05 +02003058 if (codec_drv->set_bias_level)
3059 codec->dapm.set_bias_level = snd_soc_codec_set_bias_level;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003060 codec->dev = dev;
3061 codec->driver = codec_drv;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003062 codec->component.val_bytes = codec_drv->reg_word_size;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003063
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +02003064#ifdef CONFIG_DEBUG_FS
3065 codec->component.init_debugfs = soc_init_codec_debugfs;
3066 codec->component.debugfs_prefix = "codec";
3067#endif
Xiubo Lia39f75f2014-03-26 13:40:23 +08003068
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02003069 if (codec_drv->get_regmap)
3070 codec->component.regmap = codec_drv->get_regmap(dev);
Xiubo Lia39f75f2014-03-26 13:40:23 +08003071
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003072 for (i = 0; i < num_dai; i++) {
3073 fixup_codec_formats(&dai_drv[i].playback);
3074 fixup_codec_formats(&dai_drv[i].capture);
3075 }
3076
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003077 ret = snd_soc_register_dais(&codec->component, dai_drv, num_dai, false);
3078 if (ret < 0) {
3079 dev_err(dev, "ASoC: Failed to regster DAIs: %d\n", ret);
3080 goto err_cleanup;
3081 }
3082
3083 list_for_each_entry(dai, &codec->component.dai_list, list)
3084 dai->codec = codec;
3085
Mark Brown054880f2012-04-09 17:29:19 +01003086 mutex_lock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003087 snd_soc_component_add_unlocked(&codec->component);
Mark Brown054880f2012-04-09 17:29:19 +01003088 list_add(&codec->list, &codec_list);
3089 mutex_unlock(&client_mutex);
3090
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003091 dev_dbg(codec->dev, "ASoC: Registered codec '%s'\n",
3092 codec->component.name);
Mark Brown0d0cf002008-12-10 14:32:45 +00003093 return 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003094
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003095err_cleanup:
3096 snd_soc_component_cleanup(&codec->component);
3097err_free:
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003098 kfree(codec);
3099 return ret;
Mark Brown0d0cf002008-12-10 14:32:45 +00003100}
3101EXPORT_SYMBOL_GPL(snd_soc_register_codec);
3102
3103/**
3104 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
3105 *
Mark Brownac11a2b2009-01-01 12:18:17 +00003106 * @codec: codec to unregister
Mark Brown0d0cf002008-12-10 14:32:45 +00003107 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003108void snd_soc_unregister_codec(struct device *dev)
Mark Brown0d0cf002008-12-10 14:32:45 +00003109{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003110 struct snd_soc_codec *codec;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003111
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003112 mutex_lock(&client_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003113 list_for_each_entry(codec, &codec_list, list) {
3114 if (dev == codec->dev)
3115 goto found;
3116 }
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003117 mutex_unlock(&client_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003118 return;
3119
3120found:
Mark Brown0d0cf002008-12-10 14:32:45 +00003121 list_del(&codec->list);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003122 snd_soc_component_del_unlocked(&codec->component);
Mark Brown0d0cf002008-12-10 14:32:45 +00003123 mutex_unlock(&client_mutex);
3124
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003125 dev_dbg(codec->dev, "ASoC: Unregistered codec '%s'\n",
3126 codec->component.name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003127
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003128 snd_soc_component_cleanup(&codec->component);
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003129 snd_soc_cache_exit(codec);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003130 kfree(codec);
Mark Brown0d0cf002008-12-10 14:32:45 +00003131}
3132EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
3133
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003134/* Retrieve a card's name from device tree */
3135int snd_soc_of_parse_card_name(struct snd_soc_card *card,
3136 const char *propname)
3137{
Tushar Behera7e07e7c2014-07-04 14:23:00 +05303138 struct device_node *np;
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003139 int ret;
3140
Tushar Behera7e07e7c2014-07-04 14:23:00 +05303141 if (!card->dev) {
3142 pr_err("card->dev is not set before calling %s\n", __func__);
3143 return -EINVAL;
3144 }
3145
3146 np = card->dev->of_node;
3147
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003148 ret = of_property_read_string_index(np, propname, 0, &card->name);
3149 /*
3150 * EINVAL means the property does not exist. This is fine providing
3151 * card->name was previously set, which is checked later in
3152 * snd_soc_register_card.
3153 */
3154 if (ret < 0 && ret != -EINVAL) {
3155 dev_err(card->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00003156 "ASoC: Property '%s' could not be read: %d\n",
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003157 propname, ret);
3158 return ret;
3159 }
3160
3161 return 0;
3162}
3163EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
3164
Xiubo Li9a6d4862014-02-08 15:59:52 +08003165static const struct snd_soc_dapm_widget simple_widgets[] = {
3166 SND_SOC_DAPM_MIC("Microphone", NULL),
3167 SND_SOC_DAPM_LINE("Line", NULL),
3168 SND_SOC_DAPM_HP("Headphone", NULL),
3169 SND_SOC_DAPM_SPK("Speaker", NULL),
3170};
3171
3172int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
3173 const char *propname)
3174{
3175 struct device_node *np = card->dev->of_node;
3176 struct snd_soc_dapm_widget *widgets;
3177 const char *template, *wname;
3178 int i, j, num_widgets, ret;
3179
3180 num_widgets = of_property_count_strings(np, propname);
3181 if (num_widgets < 0) {
3182 dev_err(card->dev,
3183 "ASoC: Property '%s' does not exist\n", propname);
3184 return -EINVAL;
3185 }
3186 if (num_widgets & 1) {
3187 dev_err(card->dev,
3188 "ASoC: Property '%s' length is not even\n", propname);
3189 return -EINVAL;
3190 }
3191
3192 num_widgets /= 2;
3193 if (!num_widgets) {
3194 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
3195 propname);
3196 return -EINVAL;
3197 }
3198
3199 widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets),
3200 GFP_KERNEL);
3201 if (!widgets) {
3202 dev_err(card->dev,
3203 "ASoC: Could not allocate memory for widgets\n");
3204 return -ENOMEM;
3205 }
3206
3207 for (i = 0; i < num_widgets; i++) {
3208 ret = of_property_read_string_index(np, propname,
3209 2 * i, &template);
3210 if (ret) {
3211 dev_err(card->dev,
3212 "ASoC: Property '%s' index %d read error:%d\n",
3213 propname, 2 * i, ret);
3214 return -EINVAL;
3215 }
3216
3217 for (j = 0; j < ARRAY_SIZE(simple_widgets); j++) {
3218 if (!strncmp(template, simple_widgets[j].name,
3219 strlen(simple_widgets[j].name))) {
3220 widgets[i] = simple_widgets[j];
3221 break;
3222 }
3223 }
3224
3225 if (j >= ARRAY_SIZE(simple_widgets)) {
3226 dev_err(card->dev,
3227 "ASoC: DAPM widget '%s' is not supported\n",
3228 template);
3229 return -EINVAL;
3230 }
3231
3232 ret = of_property_read_string_index(np, propname,
3233 (2 * i) + 1,
3234 &wname);
3235 if (ret) {
3236 dev_err(card->dev,
3237 "ASoC: Property '%s' index %d read error:%d\n",
3238 propname, (2 * i) + 1, ret);
3239 return -EINVAL;
3240 }
3241
3242 widgets[i].name = wname;
3243 }
3244
3245 card->dapm_widgets = widgets;
3246 card->num_dapm_widgets = num_widgets;
3247
3248 return 0;
3249}
3250EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets);
3251
Xiubo Li89c67852014-02-14 09:34:35 +08003252int snd_soc_of_parse_tdm_slot(struct device_node *np,
3253 unsigned int *slots,
3254 unsigned int *slot_width)
3255{
3256 u32 val;
3257 int ret;
3258
3259 if (of_property_read_bool(np, "dai-tdm-slot-num")) {
3260 ret = of_property_read_u32(np, "dai-tdm-slot-num", &val);
3261 if (ret)
3262 return ret;
3263
3264 if (slots)
3265 *slots = val;
3266 }
3267
3268 if (of_property_read_bool(np, "dai-tdm-slot-width")) {
3269 ret = of_property_read_u32(np, "dai-tdm-slot-width", &val);
3270 if (ret)
3271 return ret;
3272
3273 if (slot_width)
3274 *slot_width = val;
3275 }
3276
3277 return 0;
3278}
3279EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot);
3280
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003281int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
3282 const char *propname)
3283{
3284 struct device_node *np = card->dev->of_node;
Mark Browne3b1e6a2014-12-18 11:46:38 +00003285 int num_routes;
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003286 struct snd_soc_dapm_route *routes;
3287 int i, ret;
3288
3289 num_routes = of_property_count_strings(np, propname);
Richard Zhaoc34ce322012-04-24 15:24:43 +08003290 if (num_routes < 0 || num_routes & 1) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02003291 dev_err(card->dev,
3292 "ASoC: Property '%s' does not exist or its length is not even\n",
3293 propname);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003294 return -EINVAL;
3295 }
3296 num_routes /= 2;
3297 if (!num_routes) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00003298 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003299 propname);
3300 return -EINVAL;
3301 }
3302
Mark Browne3b1e6a2014-12-18 11:46:38 +00003303 routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003304 GFP_KERNEL);
3305 if (!routes) {
3306 dev_err(card->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00003307 "ASoC: Could not allocate DAPM route table\n");
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003308 return -EINVAL;
3309 }
3310
3311 for (i = 0; i < num_routes; i++) {
3312 ret = of_property_read_string_index(np, propname,
Mark Browne3b1e6a2014-12-18 11:46:38 +00003313 2 * i, &routes[i].sink);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003314 if (ret) {
Mark Brownc871bd02012-12-10 16:19:52 +09003315 dev_err(card->dev,
3316 "ASoC: Property '%s' index %d could not be read: %d\n",
3317 propname, 2 * i, ret);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003318 return -EINVAL;
3319 }
3320 ret = of_property_read_string_index(np, propname,
Mark Browne3b1e6a2014-12-18 11:46:38 +00003321 (2 * i) + 1, &routes[i].source);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003322 if (ret) {
3323 dev_err(card->dev,
Mark Brownc871bd02012-12-10 16:19:52 +09003324 "ASoC: Property '%s' index %d could not be read: %d\n",
3325 propname, (2 * i) + 1, ret);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003326 return -EINVAL;
3327 }
3328 }
3329
Mark Browne3b1e6a2014-12-18 11:46:38 +00003330 card->num_dapm_routes = num_routes;
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003331 card->dapm_routes = routes;
3332
3333 return 0;
3334}
3335EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
3336
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003337unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
Jyri Sarha389cb832014-03-24 12:15:24 +02003338 const char *prefix,
3339 struct device_node **bitclkmaster,
3340 struct device_node **framemaster)
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003341{
3342 int ret, i;
3343 char prop[128];
3344 unsigned int format = 0;
3345 int bit, frame;
3346 const char *str;
3347 struct {
3348 char *name;
3349 unsigned int val;
3350 } of_fmt_table[] = {
3351 { "i2s", SND_SOC_DAIFMT_I2S },
3352 { "right_j", SND_SOC_DAIFMT_RIGHT_J },
3353 { "left_j", SND_SOC_DAIFMT_LEFT_J },
3354 { "dsp_a", SND_SOC_DAIFMT_DSP_A },
3355 { "dsp_b", SND_SOC_DAIFMT_DSP_B },
3356 { "ac97", SND_SOC_DAIFMT_AC97 },
3357 { "pdm", SND_SOC_DAIFMT_PDM},
3358 { "msb", SND_SOC_DAIFMT_MSB },
3359 { "lsb", SND_SOC_DAIFMT_LSB },
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003360 };
3361
3362 if (!prefix)
3363 prefix = "";
3364
3365 /*
3366 * check "[prefix]format = xxx"
3367 * SND_SOC_DAIFMT_FORMAT_MASK area
3368 */
3369 snprintf(prop, sizeof(prop), "%sformat", prefix);
3370 ret = of_property_read_string(np, prop, &str);
3371 if (ret == 0) {
3372 for (i = 0; i < ARRAY_SIZE(of_fmt_table); i++) {
3373 if (strcmp(str, of_fmt_table[i].name) == 0) {
3374 format |= of_fmt_table[i].val;
3375 break;
3376 }
3377 }
3378 }
3379
3380 /*
Kuninori Morimoto8c2d6a92013-01-29 21:03:36 -08003381 * check "[prefix]continuous-clock"
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003382 * SND_SOC_DAIFMT_CLOCK_MASK area
3383 */
Kuninori Morimoto8c2d6a92013-01-29 21:03:36 -08003384 snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix);
3385 if (of_get_property(np, prop, NULL))
3386 format |= SND_SOC_DAIFMT_CONT;
3387 else
3388 format |= SND_SOC_DAIFMT_GATED;
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003389
3390 /*
3391 * check "[prefix]bitclock-inversion"
3392 * check "[prefix]frame-inversion"
3393 * SND_SOC_DAIFMT_INV_MASK area
3394 */
3395 snprintf(prop, sizeof(prop), "%sbitclock-inversion", prefix);
3396 bit = !!of_get_property(np, prop, NULL);
3397
3398 snprintf(prop, sizeof(prop), "%sframe-inversion", prefix);
3399 frame = !!of_get_property(np, prop, NULL);
3400
3401 switch ((bit << 4) + frame) {
3402 case 0x11:
3403 format |= SND_SOC_DAIFMT_IB_IF;
3404 break;
3405 case 0x10:
3406 format |= SND_SOC_DAIFMT_IB_NF;
3407 break;
3408 case 0x01:
3409 format |= SND_SOC_DAIFMT_NB_IF;
3410 break;
3411 default:
3412 /* SND_SOC_DAIFMT_NB_NF is default */
3413 break;
3414 }
3415
3416 /*
3417 * check "[prefix]bitclock-master"
3418 * check "[prefix]frame-master"
3419 * SND_SOC_DAIFMT_MASTER_MASK area
3420 */
3421 snprintf(prop, sizeof(prop), "%sbitclock-master", prefix);
3422 bit = !!of_get_property(np, prop, NULL);
Jyri Sarha389cb832014-03-24 12:15:24 +02003423 if (bit && bitclkmaster)
3424 *bitclkmaster = of_parse_phandle(np, prop, 0);
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003425
3426 snprintf(prop, sizeof(prop), "%sframe-master", prefix);
3427 frame = !!of_get_property(np, prop, NULL);
Jyri Sarha389cb832014-03-24 12:15:24 +02003428 if (frame && framemaster)
3429 *framemaster = of_parse_phandle(np, prop, 0);
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003430
3431 switch ((bit << 4) + frame) {
3432 case 0x11:
3433 format |= SND_SOC_DAIFMT_CBM_CFM;
3434 break;
3435 case 0x10:
3436 format |= SND_SOC_DAIFMT_CBM_CFS;
3437 break;
3438 case 0x01:
3439 format |= SND_SOC_DAIFMT_CBS_CFM;
3440 break;
3441 default:
3442 format |= SND_SOC_DAIFMT_CBS_CFS;
3443 break;
3444 }
3445
3446 return format;
3447}
3448EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt);
3449
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003450static int snd_soc_get_dai_name(struct of_phandle_args *args,
3451 const char **dai_name)
Kuninori Morimotocb470082013-09-10 17:39:56 -07003452{
3453 struct snd_soc_component *pos;
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003454 int ret = -EPROBE_DEFER;
Kuninori Morimotocb470082013-09-10 17:39:56 -07003455
3456 mutex_lock(&client_mutex);
3457 list_for_each_entry(pos, &component_list, list) {
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003458 if (pos->dev->of_node != args->np)
Kuninori Morimotocb470082013-09-10 17:39:56 -07003459 continue;
3460
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003461 if (pos->driver->of_xlate_dai_name) {
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003462 ret = pos->driver->of_xlate_dai_name(pos,
3463 args,
3464 dai_name);
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003465 } else {
3466 int id = -1;
3467
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003468 switch (args->args_count) {
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003469 case 0:
3470 id = 0; /* same as dai_drv[0] */
3471 break;
3472 case 1:
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003473 id = args->args[0];
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003474 break;
3475 default:
3476 /* not supported */
3477 break;
3478 }
3479
3480 if (id < 0 || id >= pos->num_dai) {
3481 ret = -EINVAL;
Nicolin Chen3dcba282014-04-21 19:14:46 +08003482 continue;
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003483 }
Xiubo Lie41975e2013-12-20 14:39:51 +08003484
3485 ret = 0;
3486
3487 *dai_name = pos->dai_drv[id].name;
3488 if (!*dai_name)
3489 *dai_name = pos->name;
Kuninori Morimotocb470082013-09-10 17:39:56 -07003490 }
3491
Kuninori Morimotocb470082013-09-10 17:39:56 -07003492 break;
3493 }
3494 mutex_unlock(&client_mutex);
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003495 return ret;
3496}
3497
3498int snd_soc_of_get_dai_name(struct device_node *of_node,
3499 const char **dai_name)
3500{
3501 struct of_phandle_args args;
3502 int ret;
3503
3504 ret = of_parse_phandle_with_args(of_node, "sound-dai",
3505 "#sound-dai-cells", 0, &args);
3506 if (ret)
3507 return ret;
3508
3509 ret = snd_soc_get_dai_name(&args, dai_name);
Kuninori Morimotocb470082013-09-10 17:39:56 -07003510
3511 of_node_put(args.np);
3512
3513 return ret;
3514}
3515EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name);
3516
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003517/*
3518 * snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree
3519 * @dev: Card device
3520 * @of_node: Device node
3521 * @dai_link: DAI link
3522 *
3523 * Builds an array of CODEC DAI components from the DAI link property
3524 * 'sound-dai'.
3525 * The array is set in the DAI link and the number of DAIs is set accordingly.
3526 * The device nodes in the array (of_node) must be dereferenced by the caller.
3527 *
3528 * Returns 0 for success
3529 */
3530int snd_soc_of_get_dai_link_codecs(struct device *dev,
3531 struct device_node *of_node,
3532 struct snd_soc_dai_link *dai_link)
3533{
3534 struct of_phandle_args args;
3535 struct snd_soc_dai_link_component *component;
3536 char *name;
3537 int index, num_codecs, ret;
3538
3539 /* Count the number of CODECs */
3540 name = "sound-dai";
3541 num_codecs = of_count_phandle_with_args(of_node, name,
3542 "#sound-dai-cells");
3543 if (num_codecs <= 0) {
3544 if (num_codecs == -ENOENT)
3545 dev_err(dev, "No 'sound-dai' property\n");
3546 else
3547 dev_err(dev, "Bad phandle in 'sound-dai'\n");
3548 return num_codecs;
3549 }
3550 component = devm_kzalloc(dev,
3551 sizeof *component * num_codecs,
3552 GFP_KERNEL);
3553 if (!component)
3554 return -ENOMEM;
3555 dai_link->codecs = component;
3556 dai_link->num_codecs = num_codecs;
3557
3558 /* Parse the list */
3559 for (index = 0, component = dai_link->codecs;
3560 index < dai_link->num_codecs;
3561 index++, component++) {
3562 ret = of_parse_phandle_with_args(of_node, name,
3563 "#sound-dai-cells",
3564 index, &args);
3565 if (ret)
3566 goto err;
3567 component->of_node = args.np;
3568 ret = snd_soc_get_dai_name(&args, &component->dai_name);
3569 if (ret < 0)
3570 goto err;
3571 }
3572 return 0;
3573err:
3574 for (index = 0, component = dai_link->codecs;
3575 index < dai_link->num_codecs;
3576 index++, component++) {
3577 if (!component->of_node)
3578 break;
3579 of_node_put(component->of_node);
3580 component->of_node = NULL;
3581 }
3582 dai_link->codecs = NULL;
3583 dai_link->num_codecs = 0;
3584 return ret;
3585}
3586EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);
3587
Takashi Iwaic9b3a402008-12-10 07:47:22 +01003588static int __init snd_soc_init(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003589{
Mark Brown384c89e2008-12-03 17:34:03 +00003590#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +00003591 snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
3592 if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
Fabio Estevam0837fc62012-02-17 19:40:38 -02003593 pr_warn("ASoC: Failed to create debugfs directory\n");
Mark Brown8a9dab12011-01-10 22:25:21 +00003594 snd_soc_debugfs_root = NULL;
Mark Brown384c89e2008-12-03 17:34:03 +00003595 }
Mark Brownc3c5a192010-09-15 18:15:14 +01003596
Mark Brown8a9dab12011-01-10 22:25:21 +00003597 if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
Mark Brownc3c5a192010-09-15 18:15:14 +01003598 &codec_list_fops))
3599 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
3600
Mark Brown8a9dab12011-01-10 22:25:21 +00003601 if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
Mark Brownf3208782010-09-15 18:19:07 +01003602 &dai_list_fops))
3603 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
Mark Brown19c7ac22010-09-15 18:22:40 +01003604
Mark Brown8a9dab12011-01-10 22:25:21 +00003605 if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
Mark Brown19c7ac22010-09-15 18:22:40 +01003606 &platform_list_fops))
3607 pr_warn("ASoC: Failed to create platform list debugfs file\n");
Mark Brown384c89e2008-12-03 17:34:03 +00003608#endif
3609
Mark Brownfb257892011-04-28 10:57:54 +01003610 snd_soc_util_init();
3611
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003612 return platform_driver_register(&soc_driver);
3613}
Mark Brown4abe8e12010-10-12 17:41:03 +01003614module_init(snd_soc_init);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003615
Mark Brown7d8c16a2008-11-30 22:11:24 +00003616static void __exit snd_soc_exit(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003617{
Mark Brownfb257892011-04-28 10:57:54 +01003618 snd_soc_util_exit();
3619
Mark Brown384c89e2008-12-03 17:34:03 +00003620#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +00003621 debugfs_remove_recursive(snd_soc_debugfs_root);
Mark Brown384c89e2008-12-03 17:34:03 +00003622#endif
Mark Brown3ff3f642008-05-19 12:32:25 +02003623 platform_driver_unregister(&soc_driver);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003624}
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003625module_exit(snd_soc_exit);
3626
3627/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01003628MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003629MODULE_DESCRIPTION("ALSA SoC Core");
3630MODULE_LICENSE("GPL");
Kay Sievers8b45a202008-04-14 13:33:36 +02003631MODULE_ALIAS("platform:soc-audio");