blob: 24b096066a07205c88e377e28f94eacff1261f3e [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>
Liam Girdwood8a978232015-05-29 19:06:14 +010043#include <sound/soc-topology.h>
Frank Mandarinodb2a4162006-10-06 18:31:09 +020044#include <sound/initval.h>
45
Mark Browna8b1d342010-11-03 18:05:58 -040046#define CREATE_TRACE_POINTS
47#include <trace/events/asoc.h>
48
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +000049#define NAME_SIZE 32
50
Mark Brown384c89e2008-12-03 17:34:03 +000051#ifdef CONFIG_DEBUG_FS
Mark Brown8a9dab12011-01-10 22:25:21 +000052struct dentry *snd_soc_debugfs_root;
53EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
Mark Brown384c89e2008-12-03 17:34:03 +000054#endif
55
Mark Brownc5af3a22008-11-28 13:29:45 +000056static DEFINE_MUTEX(client_mutex);
Mark Brown12a48a8c2008-12-03 19:40:30 +000057static LIST_HEAD(platform_list);
Mark Brown0d0cf002008-12-10 14:32:45 +000058static LIST_HEAD(codec_list);
Kuninori Morimoto030e79f2013-03-11 18:27:21 -070059static LIST_HEAD(component_list);
Mark Brownc5af3a22008-11-28 13:29:45 +000060
Frank Mandarinodb2a4162006-10-06 18:31:09 +020061/*
62 * This is a timeout to do a DAPM powerdown after a stream is closed().
63 * It can be used to eliminate pops between different playback streams, e.g.
64 * between two audio tracks.
65 */
66static int pmdown_time = 5000;
67module_param(pmdown_time, int, 0);
68MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
69
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +000070/* returns the minimum number of bytes needed to represent
71 * a particular given value */
72static int min_bytes_needed(unsigned long val)
73{
74 int c = 0;
75 int i;
76
77 for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)
78 if (val & (1UL << i))
79 break;
80 c = (sizeof val * 8) - c;
81 if (!c || (c % 8))
82 c = (c + 8) / 8;
83 else
84 c /= 8;
85 return c;
86}
87
Dimitris Papastamos13fd1792011-02-02 13:58:58 +000088/* fill buf which is 'len' bytes with a formatted
89 * string of the form 'reg: value\n' */
90static int format_register_str(struct snd_soc_codec *codec,
91 unsigned int reg, char *buf, size_t len)
Mark Brown2624d5f2009-11-03 21:56:13 +000092{
Stephen Warren00b317a2011-04-01 14:50:44 -060093 int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
94 int regsize = codec->driver->reg_word_size * 2;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +000095 int ret;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +000096
97 /* +2 for ': ' and + 1 for '\n' */
98 if (wordsize + regsize + 2 + 1 != len)
99 return -EINVAL;
100
Takashi Iwaid6b6c2c2015-05-26 14:40:14 +0200101 sprintf(buf, "%.*x: ", wordsize, reg);
102 buf += wordsize + 2;
103
Mark Brown25032c12011-08-01 13:52:48 +0900104 ret = snd_soc_read(codec, reg);
Takashi Iwaid6b6c2c2015-05-26 14:40:14 +0200105 if (ret < 0)
106 memset(buf, 'X', regsize);
107 else
108 sprintf(buf, "%.*x", regsize, ret);
109 buf[regsize] = '\n';
110 /* no NUL-termination needed */
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000111 return 0;
112}
113
114/* codec register dump */
115static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
116 size_t count, loff_t pos)
117{
118 int i, step = 1;
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +0000119 int wordsize, regsize;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000120 int len;
121 size_t total = 0;
122 loff_t p = 0;
Dimitris Papastamos2bc9a812011-02-01 12:24:08 +0000123
Stephen Warren00b317a2011-04-01 14:50:44 -0600124 wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
125 regsize = codec->driver->reg_word_size * 2;
Mark Brown2624d5f2009-11-03 21:56:13 +0000126
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000127 len = wordsize + regsize + 2 + 1;
128
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000129 if (!codec->driver->reg_cache_size)
Mark Brown2624d5f2009-11-03 21:56:13 +0000130 return 0;
131
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000132 if (codec->driver->reg_cache_step)
133 step = codec->driver->reg_cache_step;
Mark Brown2624d5f2009-11-03 21:56:13 +0000134
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000135 for (i = 0; i < codec->driver->reg_cache_size; i += step) {
Lars-Peter Clausen20a0ec22014-03-18 09:02:09 +0100136 /* only support larger than PAGE_SIZE bytes debugfs
137 * entries for the default case */
138 if (p >= pos) {
139 if (total + len >= count - 1)
140 break;
141 format_register_str(codec, i, buf + total, len);
142 total += len;
Mark Brown5164d742010-07-14 16:14:33 +0100143 }
Lars-Peter Clausen20a0ec22014-03-18 09:02:09 +0100144 p += len;
Mark Brown2624d5f2009-11-03 21:56:13 +0000145 }
146
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000147 total = min(total, count - 1);
Mark Brown2624d5f2009-11-03 21:56:13 +0000148
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000149 return total;
Mark Brown2624d5f2009-11-03 21:56:13 +0000150}
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000151
Mark Brown2624d5f2009-11-03 21:56:13 +0000152static ssize_t codec_reg_show(struct device *dev,
153 struct device_attribute *attr, char *buf)
154{
Mark Brown36ae1a92012-01-06 17:12:45 -0800155 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000156
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000157 return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);
Mark Brown2624d5f2009-11-03 21:56:13 +0000158}
159
160static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
161
Mark Browndbe21402010-02-12 11:37:24 +0000162static ssize_t pmdown_time_show(struct device *dev,
163 struct device_attribute *attr, char *buf)
164{
Mark Brown36ae1a92012-01-06 17:12:45 -0800165 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
Mark Browndbe21402010-02-12 11:37:24 +0000166
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000167 return sprintf(buf, "%ld\n", rtd->pmdown_time);
Mark Browndbe21402010-02-12 11:37:24 +0000168}
169
170static ssize_t pmdown_time_set(struct device *dev,
171 struct device_attribute *attr,
172 const char *buf, size_t count)
173{
Mark Brown36ae1a92012-01-06 17:12:45 -0800174 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
Mark Brownc593b522010-10-27 20:11:17 -0700175 int ret;
Mark Browndbe21402010-02-12 11:37:24 +0000176
Jingoo Hanb785a492013-07-19 16:24:59 +0900177 ret = kstrtol(buf, 10, &rtd->pmdown_time);
Mark Brownc593b522010-10-27 20:11:17 -0700178 if (ret)
179 return ret;
Mark Browndbe21402010-02-12 11:37:24 +0000180
181 return count;
182}
183
184static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
185
Takashi Iwaid29697d2015-01-30 20:16:37 +0100186static struct attribute *soc_dev_attrs[] = {
187 &dev_attr_codec_reg.attr,
188 &dev_attr_pmdown_time.attr,
189 NULL
190};
191
192static umode_t soc_dev_attr_is_visible(struct kobject *kobj,
193 struct attribute *attr, int idx)
194{
195 struct device *dev = kobj_to_dev(kobj);
196 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
197
198 if (attr == &dev_attr_pmdown_time.attr)
199 return attr->mode; /* always visible */
200 return rtd->codec ? attr->mode : 0; /* enabled only with codec */
201}
202
203static const struct attribute_group soc_dapm_dev_group = {
204 .attrs = soc_dapm_dev_attrs,
205 .is_visible = soc_dev_attr_is_visible,
206};
207
208static const struct attribute_group soc_dev_roup = {
209 .attrs = soc_dev_attrs,
210 .is_visible = soc_dev_attr_is_visible,
211};
212
213static const struct attribute_group *soc_dev_attr_groups[] = {
214 &soc_dapm_dev_group,
215 &soc_dev_roup,
216 NULL
217};
218
Mark Brown2624d5f2009-11-03 21:56:13 +0000219#ifdef CONFIG_DEBUG_FS
Mark Brown2624d5f2009-11-03 21:56:13 +0000220static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000221 size_t count, loff_t *ppos)
Mark Brown2624d5f2009-11-03 21:56:13 +0000222{
223 ssize_t ret;
224 struct snd_soc_codec *codec = file->private_data;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000225 char *buf;
226
227 if (*ppos < 0 || !count)
228 return -EINVAL;
229
230 buf = kmalloc(count, GFP_KERNEL);
Mark Brown2624d5f2009-11-03 21:56:13 +0000231 if (!buf)
232 return -ENOMEM;
Dimitris Papastamos13fd1792011-02-02 13:58:58 +0000233
234 ret = soc_codec_reg_show(codec, buf, count, *ppos);
235 if (ret >= 0) {
236 if (copy_to_user(user_buf, buf, ret)) {
237 kfree(buf);
238 return -EFAULT;
239 }
240 *ppos += ret;
241 }
242
Mark Brown2624d5f2009-11-03 21:56:13 +0000243 kfree(buf);
244 return ret;
245}
246
247static ssize_t codec_reg_write_file(struct file *file,
248 const char __user *user_buf, size_t count, loff_t *ppos)
249{
250 char buf[32];
Stephen Boyd34e268d2011-05-12 16:50:10 -0700251 size_t buf_size;
Mark Brown2624d5f2009-11-03 21:56:13 +0000252 char *start = buf;
253 unsigned long reg, value;
Mark Brown2624d5f2009-11-03 21:56:13 +0000254 struct snd_soc_codec *codec = file->private_data;
Jingoo Hanb785a492013-07-19 16:24:59 +0900255 int ret;
Mark Brown2624d5f2009-11-03 21:56:13 +0000256
257 buf_size = min(count, (sizeof(buf)-1));
258 if (copy_from_user(buf, user_buf, buf_size))
259 return -EFAULT;
260 buf[buf_size] = 0;
261
Mark Brown2624d5f2009-11-03 21:56:13 +0000262 while (*start == ' ')
263 start++;
264 reg = simple_strtoul(start, &start, 16);
Mark Brown2624d5f2009-11-03 21:56:13 +0000265 while (*start == ' ')
266 start++;
Jingoo Hanb785a492013-07-19 16:24:59 +0900267 ret = kstrtoul(start, 16, &value);
268 if (ret)
269 return ret;
Mark Brown0d51a9c2011-01-06 16:04:57 +0000270
271 /* Userspace has been fiddling around behind the kernel's back */
Rusty Russell373d4d02013-01-21 17:17:39 +1030272 add_taint(TAINT_USER, LOCKDEP_NOW_UNRELIABLE);
Mark Brown0d51a9c2011-01-06 16:04:57 +0000273
Dimitris Papastamose4f078d2010-12-07 16:30:38 +0000274 snd_soc_write(codec, reg, value);
Mark Brown2624d5f2009-11-03 21:56:13 +0000275 return buf_size;
276}
277
278static const struct file_operations codec_reg_fops = {
Stephen Boyd234e3402012-04-05 14:25:11 -0700279 .open = simple_open,
Mark Brown2624d5f2009-11-03 21:56:13 +0000280 .read = codec_reg_read_file,
281 .write = codec_reg_write_file,
Arnd Bergmann6038f372010-08-15 18:52:59 +0200282 .llseek = default_llseek,
Mark Brown2624d5f2009-11-03 21:56:13 +0000283};
284
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200285static void soc_init_component_debugfs(struct snd_soc_component *component)
Russell Kinge73f3de2014-06-26 15:22:50 +0100286{
Lars-Peter Clausen6553bf062015-04-09 10:52:38 +0200287 if (!component->card->debugfs_card_root)
288 return;
289
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200290 if (component->debugfs_prefix) {
291 char *name;
Russell Kinge73f3de2014-06-26 15:22:50 +0100292
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200293 name = kasprintf(GFP_KERNEL, "%s:%s",
294 component->debugfs_prefix, component->name);
295 if (name) {
296 component->debugfs_root = debugfs_create_dir(name,
297 component->card->debugfs_card_root);
298 kfree(name);
299 }
300 } else {
301 component->debugfs_root = debugfs_create_dir(component->name,
302 component->card->debugfs_card_root);
303 }
Russell Kinge73f3de2014-06-26 15:22:50 +0100304
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200305 if (!component->debugfs_root) {
306 dev_warn(component->dev,
307 "ASoC: Failed to create component debugfs directory\n");
Mark Brown2624d5f2009-11-03 21:56:13 +0000308 return;
309 }
310
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200311 snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component),
312 component->debugfs_root);
313
314 if (component->init_debugfs)
315 component->init_debugfs(component);
316}
317
318static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
319{
320 debugfs_remove_recursive(component->debugfs_root);
321}
322
323static void soc_init_codec_debugfs(struct snd_soc_component *component)
324{
325 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
326
Mark Brown2624d5f2009-11-03 21:56:13 +0000327 codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200328 codec->component.debugfs_root,
Mark Brown2624d5f2009-11-03 21:56:13 +0000329 codec, &codec_reg_fops);
330 if (!codec->debugfs_reg)
Michał Mirosław10e8aa92013-05-04 22:21:38 +0200331 dev_warn(codec->dev,
332 "ASoC: Failed to create codec register debugfs file\n");
Sebastien Guiriec731f1ab2012-02-15 15:25:31 +0000333}
334
Mark Brownc3c5a192010-09-15 18:15:14 +0100335static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
336 size_t count, loff_t *ppos)
337{
338 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100339 ssize_t len, ret = 0;
Mark Brownc3c5a192010-09-15 18:15:14 +0100340 struct snd_soc_codec *codec;
341
342 if (!buf)
343 return -ENOMEM;
344
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100345 mutex_lock(&client_mutex);
346
Mark Brown2b194f9d2010-10-13 10:52:16 +0100347 list_for_each_entry(codec, &codec_list, list) {
348 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +0200349 codec->component.name);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100350 if (len >= 0)
351 ret += len;
352 if (ret > PAGE_SIZE) {
353 ret = PAGE_SIZE;
354 break;
355 }
356 }
Mark Brownc3c5a192010-09-15 18:15:14 +0100357
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100358 mutex_unlock(&client_mutex);
359
Mark Brownc3c5a192010-09-15 18:15:14 +0100360 if (ret >= 0)
361 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
362
363 kfree(buf);
364
365 return ret;
366}
367
368static const struct file_operations codec_list_fops = {
369 .read = codec_list_read_file,
370 .llseek = default_llseek,/* read accesses f_pos */
371};
372
Mark Brownf3208782010-09-15 18:19:07 +0100373static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
374 size_t count, loff_t *ppos)
375{
376 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100377 ssize_t len, ret = 0;
Lars-Peter Clausen1438c2f2014-03-09 17:41:47 +0100378 struct snd_soc_component *component;
Mark Brownf3208782010-09-15 18:19:07 +0100379 struct snd_soc_dai *dai;
380
381 if (!buf)
382 return -ENOMEM;
383
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100384 mutex_lock(&client_mutex);
385
Lars-Peter Clausen1438c2f2014-03-09 17:41:47 +0100386 list_for_each_entry(component, &component_list, list) {
387 list_for_each_entry(dai, &component->dai_list, list) {
388 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
389 dai->name);
390 if (len >= 0)
391 ret += len;
392 if (ret > PAGE_SIZE) {
393 ret = PAGE_SIZE;
394 break;
395 }
Mark Brown2b194f9d2010-10-13 10:52:16 +0100396 }
397 }
Mark Brownf3208782010-09-15 18:19:07 +0100398
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100399 mutex_unlock(&client_mutex);
400
Mark Brown2b194f9d2010-10-13 10:52:16 +0100401 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
Mark Brownf3208782010-09-15 18:19:07 +0100402
403 kfree(buf);
404
405 return ret;
406}
407
408static const struct file_operations dai_list_fops = {
409 .read = dai_list_read_file,
410 .llseek = default_llseek,/* read accesses f_pos */
411};
412
Mark Brown19c7ac22010-09-15 18:22:40 +0100413static ssize_t platform_list_read_file(struct file *file,
414 char __user *user_buf,
415 size_t count, loff_t *ppos)
416{
417 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100418 ssize_t len, ret = 0;
Mark Brown19c7ac22010-09-15 18:22:40 +0100419 struct snd_soc_platform *platform;
420
421 if (!buf)
422 return -ENOMEM;
423
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100424 mutex_lock(&client_mutex);
425
Mark Brown2b194f9d2010-10-13 10:52:16 +0100426 list_for_each_entry(platform, &platform_list, list) {
427 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +0200428 platform->component.name);
Mark Brown2b194f9d2010-10-13 10:52:16 +0100429 if (len >= 0)
430 ret += len;
431 if (ret > PAGE_SIZE) {
432 ret = PAGE_SIZE;
433 break;
434 }
435 }
Mark Brown19c7ac22010-09-15 18:22:40 +0100436
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100437 mutex_unlock(&client_mutex);
438
Mark Brown2b194f9d2010-10-13 10:52:16 +0100439 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
Mark Brown19c7ac22010-09-15 18:22:40 +0100440
441 kfree(buf);
442
443 return ret;
444}
445
446static const struct file_operations platform_list_fops = {
447 .read = platform_list_read_file,
448 .llseek = default_llseek,/* read accesses f_pos */
449};
450
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200451static void soc_init_card_debugfs(struct snd_soc_card *card)
452{
Lars-Peter Clausen6553bf062015-04-09 10:52:38 +0200453 if (!snd_soc_debugfs_root)
454 return;
455
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200456 card->debugfs_card_root = debugfs_create_dir(card->name,
Mark Brown8a9dab12011-01-10 22:25:21 +0000457 snd_soc_debugfs_root);
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200458 if (!card->debugfs_card_root) {
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200459 dev_warn(card->dev,
Lothar Waßmann7c08be82011-12-09 14:16:29 +0100460 "ASoC: Failed to create card debugfs directory\n");
Jarkko Nikula3a45b862010-11-05 20:35:21 +0200461 return;
462 }
463
464 card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
465 card->debugfs_card_root,
466 &card->pop_time);
467 if (!card->debugfs_pop_time)
468 dev_warn(card->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000469 "ASoC: Failed to create pop time debugfs file\n");
Jarkko Nikulaa6052152010-11-05 20:35:19 +0200470}
471
472static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
473{
474 debugfs_remove_recursive(card->debugfs_card_root);
475}
476
Lars-Peter Clausen6553bf062015-04-09 10:52:38 +0200477
478static void snd_soc_debugfs_init(void)
479{
480 snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
481 if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
482 pr_warn("ASoC: Failed to create debugfs directory\n");
483 snd_soc_debugfs_root = NULL;
484 return;
485 }
486
487 if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
488 &codec_list_fops))
489 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
490
491 if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
492 &dai_list_fops))
493 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
494
495 if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
496 &platform_list_fops))
497 pr_warn("ASoC: Failed to create platform list debugfs file\n");
498}
499
500static void snd_soc_debugfs_exit(void)
501{
502 debugfs_remove_recursive(snd_soc_debugfs_root);
503}
504
Mark Brown2624d5f2009-11-03 21:56:13 +0000505#else
506
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200507#define soc_init_codec_debugfs NULL
508
509static inline void soc_init_component_debugfs(
510 struct snd_soc_component *component)
Mark Brown2624d5f2009-11-03 21:56:13 +0000511{
512}
513
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +0200514static inline void soc_cleanup_component_debugfs(
515 struct snd_soc_component *component)
Sebastien Guiriec731f1ab2012-02-15 15:25:31 +0000516{
517}
518
Axel Linb95fccb2010-11-09 17:06:44 +0800519static inline void soc_init_card_debugfs(struct snd_soc_card *card)
520{
521}
522
523static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
524{
525}
Lars-Peter Clausen6553bf062015-04-09 10:52:38 +0200526
527static inline void snd_soc_debugfs_init(void)
528{
529}
530
531static inline void snd_soc_debugfs_exit(void)
532{
533}
534
Mark Brown2624d5f2009-11-03 21:56:13 +0000535#endif
536
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100537struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
538 const char *dai_link, int stream)
539{
540 int i;
541
542 for (i = 0; i < card->num_links; i++) {
543 if (card->rtd[i].dai_link->no_pcm &&
544 !strcmp(card->rtd[i].dai_link->name, dai_link))
545 return card->rtd[i].pcm->streams[stream].substream;
546 }
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000547 dev_dbg(card->dev, "ASoC: failed to find dai link %s\n", dai_link);
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100548 return NULL;
549}
550EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);
551
552struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
553 const char *dai_link)
554{
555 int i;
556
557 for (i = 0; i < card->num_links; i++) {
558 if (!strcmp(card->rtd[i].dai_link->name, dai_link))
559 return &card->rtd[i];
560 }
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000561 dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link);
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100562 return NULL;
563}
564EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);
565
Richard Fitzgerald9d58a072013-08-05 13:17:28 +0100566static void codec2codec_close_delayed_work(struct work_struct *work)
567{
568 /* Currently nothing to do for c2c links
569 * Since c2c links are internal nodes in the DAPM graph and
570 * don't interface with the outside world or application layer
571 * we don't have to do any special handling on close.
572 */
573}
574
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000575#ifdef CONFIG_PM_SLEEP
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200576/* powers down audio subsystem for suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000577int snd_soc_suspend(struct device *dev)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200578{
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000579 struct snd_soc_card *card = dev_get_drvdata(dev);
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200580 struct snd_soc_codec *codec;
Benoit Cousson88bd8702014-07-08 23:19:34 +0200581 int i, j;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200582
Lars-Peter Clausenc5599b82014-08-19 15:51:30 +0200583 /* If the card is not initialized yet there is nothing to do */
584 if (!card->instantiated)
Daniel Macke3509ff2009-06-03 17:44:49 +0200585 return 0;
586
Andy Green6ed25972008-06-13 16:24:05 +0100587 /* Due to the resume being scheduled into a workqueue we could
588 * suspend before that's finished - wait for it to complete.
589 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000590 snd_power_lock(card->snd_card);
591 snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
592 snd_power_unlock(card->snd_card);
Andy Green6ed25972008-06-13 16:24:05 +0100593
594 /* we're going to block userspace touching us until resume completes */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000595 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
Andy Green6ed25972008-06-13 16:24:05 +0100596
Mark Browna00f90f2010-12-02 16:24:24 +0000597 /* mute any active DACs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000598 for (i = 0; i < card->num_rtd; i++) {
Mark Brown3efab7d2010-05-09 13:25:43 +0100599
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000600 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100601 continue;
602
Benoit Cousson88bd8702014-07-08 23:19:34 +0200603 for (j = 0; j < card->rtd[i].num_codecs; j++) {
604 struct snd_soc_dai *dai = card->rtd[i].codec_dais[j];
605 struct snd_soc_dai_driver *drv = dai->driver;
606
607 if (drv->ops->digital_mute && dai->playback_active)
608 drv->ops->digital_mute(dai, 1);
609 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200610 }
611
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100612 /* suspend all pcms */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000613 for (i = 0; i < card->num_rtd; i++) {
614 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100615 continue;
616
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000617 snd_pcm_suspend_all(card->rtd[i].pcm);
Mark Brown3efab7d2010-05-09 13:25:43 +0100618 }
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100619
Mark Brown87506542008-11-18 20:50:34 +0000620 if (card->suspend_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +0000621 card->suspend_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200622
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000623 for (i = 0; i < card->num_rtd; i++) {
624 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100625
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000626 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100627 continue;
628
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100629 if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000630 cpu_dai->driver->suspend(cpu_dai);
Mark Brown1547aba2010-05-07 21:11:40 +0100631 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200632
Lars-Peter Clausen37660b62015-03-30 21:04:50 +0200633 /* close any waiting streams */
634 for (i = 0; i < card->num_rtd; i++)
Tejun Heo43829732012-08-20 14:51:24 -0700635 flush_delayed_work(&card->rtd[i].delayed_work);
Mark Brown3efab7d2010-05-09 13:25:43 +0100636
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000637 for (i = 0; i < card->num_rtd; i++) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000638
639 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100640 continue;
641
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800642 snd_soc_dapm_stream_event(&card->rtd[i],
643 SNDRV_PCM_STREAM_PLAYBACK,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800644 SND_SOC_DAPM_STREAM_SUSPEND);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000645
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800646 snd_soc_dapm_stream_event(&card->rtd[i],
647 SNDRV_PCM_STREAM_CAPTURE,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800648 SND_SOC_DAPM_STREAM_SUSPEND);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000649 }
650
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200651 /* Recheck all endpoints too, their state is affected by suspend */
652 dapm_mark_endpoints_dirty(card);
Mark Browne2d32ff2012-08-31 17:38:32 -0700653 snd_soc_dapm_sync(&card->dapm);
654
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000655 /* suspend all CODECs */
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200656 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Lars-Peter Clausen48901402015-07-06 15:38:11 +0200657 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
658
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000659 /* If there are paths active then the CODEC will be held with
660 * bias _ON and should not be suspended. */
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200661 if (!codec->suspended) {
Lars-Peter Clausen48901402015-07-06 15:38:11 +0200662 switch (snd_soc_dapm_get_bias_level(dapm)) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000663 case SND_SOC_BIAS_STANDBY:
Mark Brown125a25d2012-01-31 15:49:10 +0000664 /*
665 * If the CODEC is capable of idle
666 * bias off then being in STANDBY
667 * means it's doing something,
668 * otherwise fall through.
669 */
Lars-Peter Clausen48901402015-07-06 15:38:11 +0200670 if (dapm->idle_bias_off) {
Mark Brown125a25d2012-01-31 15:49:10 +0000671 dev_dbg(codec->dev,
Michał Mirosław10e8aa92013-05-04 22:21:38 +0200672 "ASoC: idle_bias_off CODEC on over suspend\n");
Mark Brown125a25d2012-01-31 15:49:10 +0000673 break;
674 }
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200675
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000676 case SND_SOC_BIAS_OFF:
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200677 if (codec->driver->suspend)
678 codec->driver->suspend(codec);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000679 codec->suspended = 1;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +0200680 if (codec->component.regmap)
681 regcache_mark_dirty(codec->component.regmap);
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800682 /* deactivate pins to sleep state */
683 pinctrl_pm_select_sleep_state(codec->dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000684 break;
685 default:
Michał Mirosław10e8aa92013-05-04 22:21:38 +0200686 dev_dbg(codec->dev,
687 "ASoC: CODEC is on over suspend\n");
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000688 break;
689 }
690 }
691 }
692
693 for (i = 0; i < card->num_rtd; i++) {
694 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
695
696 if (card->rtd[i].dai_link->ignore_suspend)
697 continue;
698
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100699 if (cpu_dai->driver->suspend && cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000700 cpu_dai->driver->suspend(cpu_dai);
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800701
702 /* deactivate pins to sleep state */
703 pinctrl_pm_select_sleep_state(cpu_dai->dev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200704 }
705
Mark Brown87506542008-11-18 20:50:34 +0000706 if (card->suspend_post)
Mark Brown70b2ac12011-01-26 14:05:25 +0000707 card->suspend_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200708
709 return 0;
710}
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000711EXPORT_SYMBOL_GPL(snd_soc_suspend);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200712
Andy Green6ed25972008-06-13 16:24:05 +0100713/* deferred resume work, so resume can complete before we finished
714 * setting our codec back up, which can be very slow on I2C
715 */
716static void soc_resume_deferred(struct work_struct *work)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200717{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000718 struct snd_soc_card *card =
719 container_of(work, struct snd_soc_card, deferred_resume_work);
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200720 struct snd_soc_codec *codec;
Benoit Cousson88bd8702014-07-08 23:19:34 +0200721 int i, j;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200722
Andy Green6ed25972008-06-13 16:24:05 +0100723 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
724 * so userspace apps are blocked from touching us
725 */
726
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000727 dev_dbg(card->dev, "ASoC: starting resume work\n");
Andy Green6ed25972008-06-13 16:24:05 +0100728
Mark Brown99497882010-05-07 20:24:05 +0100729 /* Bring us up into D2 so that DAPM starts enabling things */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000730 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
Mark Brown99497882010-05-07 20:24:05 +0100731
Mark Brown87506542008-11-18 20:50:34 +0000732 if (card->resume_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +0000733 card->resume_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200734
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100735 /* resume control bus DAIs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000736 for (i = 0; i < card->num_rtd; i++) {
737 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100738
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000739 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100740 continue;
741
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100742 if (cpu_dai->driver->resume && cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000743 cpu_dai->driver->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200744 }
745
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200746 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200747 if (codec->suspended) {
Lars-Peter Clausenb8faaba2015-05-15 12:41:30 +0200748 if (codec->driver->resume)
749 codec->driver->resume(codec);
750 codec->suspended = 0;
Mark Brown1547aba2010-05-07 21:11:40 +0100751 }
752 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200753
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000754 for (i = 0; i < card->num_rtd; i++) {
Mark Brown3efab7d2010-05-09 13:25:43 +0100755
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000756 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100757 continue;
758
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800759 snd_soc_dapm_stream_event(&card->rtd[i],
Liam Girdwoodd9b09512012-03-07 16:32:59 +0000760 SNDRV_PCM_STREAM_PLAYBACK,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800761 SND_SOC_DAPM_STREAM_RESUME);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000762
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800763 snd_soc_dapm_stream_event(&card->rtd[i],
Liam Girdwoodd9b09512012-03-07 16:32:59 +0000764 SNDRV_PCM_STREAM_CAPTURE,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800765 SND_SOC_DAPM_STREAM_RESUME);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200766 }
767
Mark Brown3ff3f642008-05-19 12:32:25 +0200768 /* unmute any active DACs */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000769 for (i = 0; i < card->num_rtd; i++) {
Mark Brown3efab7d2010-05-09 13:25:43 +0100770
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000771 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100772 continue;
773
Benoit Cousson88bd8702014-07-08 23:19:34 +0200774 for (j = 0; j < card->rtd[i].num_codecs; j++) {
775 struct snd_soc_dai *dai = card->rtd[i].codec_dais[j];
776 struct snd_soc_dai_driver *drv = dai->driver;
777
778 if (drv->ops->digital_mute && dai->playback_active)
779 drv->ops->digital_mute(dai, 0);
780 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200781 }
782
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000783 for (i = 0; i < card->num_rtd; i++) {
784 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100785
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000786 if (card->rtd[i].dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100787 continue;
788
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100789 if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000790 cpu_dai->driver->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200791 }
792
Mark Brown87506542008-11-18 20:50:34 +0000793 if (card->resume_post)
Mark Brown70b2ac12011-01-26 14:05:25 +0000794 card->resume_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200795
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000796 dev_dbg(card->dev, "ASoC: resume work completed\n");
Andy Green6ed25972008-06-13 16:24:05 +0100797
798 /* userspace can access us now we are back as we were before */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000799 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
Mark Browne2d32ff2012-08-31 17:38:32 -0700800
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200801 /* Recheck all endpoints too, their state is affected by suspend */
802 dapm_mark_endpoints_dirty(card);
Mark Browne2d32ff2012-08-31 17:38:32 -0700803 snd_soc_dapm_sync(&card->dapm);
Andy Green6ed25972008-06-13 16:24:05 +0100804}
805
806/* powers up audio subsystem after a suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000807int snd_soc_resume(struct device *dev)
Andy Green6ed25972008-06-13 16:24:05 +0100808{
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000809 struct snd_soc_card *card = dev_get_drvdata(dev);
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100810 bool bus_control = false;
811 int i;
Peter Ujfalusib9dd94a2010-02-22 13:27:13 +0200812
Lars-Peter Clausenc5599b82014-08-19 15:51:30 +0200813 /* If the card is not initialized yet there is nothing to do */
814 if (!card->instantiated)
Eric Miao5ff1ddf2011-11-23 22:37:00 +0800815 return 0;
816
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800817 /* activate pins from sleep state */
818 for (i = 0; i < card->num_rtd; i++) {
Benoit Cousson88bd8702014-07-08 23:19:34 +0200819 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
820 struct snd_soc_dai **codec_dais = rtd->codec_dais;
821 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
822 int j;
823
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800824 if (cpu_dai->active)
825 pinctrl_pm_select_default_state(cpu_dai->dev);
Benoit Cousson88bd8702014-07-08 23:19:34 +0200826
827 for (j = 0; j < rtd->num_codecs; j++) {
828 struct snd_soc_dai *codec_dai = codec_dais[j];
829 if (codec_dai->active)
830 pinctrl_pm_select_default_state(codec_dai->dev);
831 }
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800832 }
833
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100834 /*
835 * DAIs that also act as the control bus master might have other drivers
836 * hanging off them so need to resume immediately. Other drivers don't
837 * have that problem and may take a substantial amount of time to resume
Mark Brown64ab9ba2009-03-31 11:27:03 +0100838 * due to I/O costs and anti-pop so handle them out of line.
839 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000840 for (i = 0; i < card->num_rtd; i++) {
841 struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100842 bus_control |= cpu_dai->driver->bus_control;
Stephen Warren82e14e82011-05-25 14:06:41 -0600843 }
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100844 if (bus_control) {
845 dev_dbg(dev, "ASoC: Resuming control bus master immediately\n");
Stephen Warren82e14e82011-05-25 14:06:41 -0600846 soc_resume_deferred(&card->deferred_resume_work);
847 } else {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000848 dev_dbg(dev, "ASoC: Scheduling resume work\n");
Stephen Warren82e14e82011-05-25 14:06:41 -0600849 if (!schedule_work(&card->deferred_resume_work))
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000850 dev_err(dev, "ASoC: resume work item may be lost\n");
Mark Brown64ab9ba2009-03-31 11:27:03 +0100851 }
Andy Green6ed25972008-06-13 16:24:05 +0100852
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200853 return 0;
854}
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000855EXPORT_SYMBOL_GPL(snd_soc_resume);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200856#else
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000857#define snd_soc_suspend NULL
858#define snd_soc_resume NULL
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200859#endif
860
Lars-Peter Clausen85e76522011-11-23 11:40:40 +0100861static const struct snd_soc_dai_ops null_dai_ops = {
Barry Song02a06d32009-10-16 18:13:38 +0800862};
863
Lars-Peter Clausen65d93612014-08-19 15:51:22 +0200864static struct snd_soc_component *soc_find_component(
865 const struct device_node *of_node, const char *name)
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100866{
Lars-Peter Clausen65d93612014-08-19 15:51:22 +0200867 struct snd_soc_component *component;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100868
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100869 lockdep_assert_held(&client_mutex);
870
Lars-Peter Clausen65d93612014-08-19 15:51:22 +0200871 list_for_each_entry(component, &component_list, list) {
872 if (of_node) {
873 if (component->dev->of_node == of_node)
874 return component;
875 } else if (strcmp(component->name, name) == 0) {
876 return component;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100877 }
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100878 }
879
880 return NULL;
881}
882
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200883static struct snd_soc_dai *snd_soc_find_dai(
884 const struct snd_soc_dai_link_component *dlc)
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100885{
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200886 struct snd_soc_component *component;
887 struct snd_soc_dai *dai;
Jyri Sarha3e0aa8d2015-05-26 21:59:05 +0300888 struct device_node *component_of_node;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100889
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100890 lockdep_assert_held(&client_mutex);
891
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200892 /* Find CPU DAI from registered DAIs*/
893 list_for_each_entry(component, &component_list, list) {
Jyri Sarha3e0aa8d2015-05-26 21:59:05 +0300894 component_of_node = component->dev->of_node;
895 if (!component_of_node && component->dev->parent)
896 component_of_node = component->dev->parent->of_node;
897
898 if (dlc->of_node && component_of_node != dlc->of_node)
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200899 continue;
Lars-Peter Clausen1ffae362014-10-29 21:46:30 +0100900 if (dlc->name && strcmp(component->name, dlc->name))
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200901 continue;
902 list_for_each_entry(dai, &component->dai_list, list) {
903 if (dlc->dai_name && strcmp(dai->name, dlc->dai_name))
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100904 continue;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100905
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200906 return dai;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100907 }
908 }
909
910 return NULL;
911}
912
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000913static int soc_bind_dai_link(struct snd_soc_card *card, int num)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200914{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000915 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
916 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
Benoit Cousson88bd8702014-07-08 23:19:34 +0200917 struct snd_soc_dai_link_component *codecs = dai_link->codecs;
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200918 struct snd_soc_dai_link_component cpu_dai_component;
Benoit Cousson88bd8702014-07-08 23:19:34 +0200919 struct snd_soc_dai **codec_dais = rtd->codec_dais;
Mark Brown435c5e22008-12-04 15:32:53 +0000920 struct snd_soc_platform *platform;
Mark Brown848dd8b2011-04-27 18:16:32 +0100921 const char *platform_name;
Benoit Cousson88bd8702014-07-08 23:19:34 +0200922 int i;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200923
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000924 dev_dbg(card->dev, "ASoC: binding %s at idx %d\n", dai_link->name, num);
Mark Brown63084192008-12-02 15:08:03 +0000925
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200926 cpu_dai_component.name = dai_link->cpu_name;
927 cpu_dai_component.of_node = dai_link->cpu_of_node;
928 cpu_dai_component.dai_name = dai_link->cpu_dai_name;
929 rtd->cpu_dai = snd_soc_find_dai(&cpu_dai_component);
Mark Brownb19e6e72012-03-14 21:18:39 +0000930 if (!rtd->cpu_dai) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000931 dev_err(card->dev, "ASoC: CPU DAI %s not registered\n",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000932 dai_link->cpu_dai_name);
Mark Brownb19e6e72012-03-14 21:18:39 +0000933 return -EPROBE_DEFER;
Mark Brownc5af3a22008-11-28 13:29:45 +0000934 }
935
Benoit Cousson88bd8702014-07-08 23:19:34 +0200936 rtd->num_codecs = dai_link->num_codecs;
937
938 /* Find CODEC from registered CODECs */
939 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200940 codec_dais[i] = snd_soc_find_dai(&codecs[i]);
Benoit Cousson88bd8702014-07-08 23:19:34 +0200941 if (!codec_dais[i]) {
942 dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
943 codecs[i].dai_name);
944 return -EPROBE_DEFER;
945 }
Mark Brownb19e6e72012-03-14 21:18:39 +0000946 }
Mark Brown848dd8b2011-04-27 18:16:32 +0100947
Benoit Cousson88bd8702014-07-08 23:19:34 +0200948 /* Single codec links expect codec and codec_dai in runtime data */
949 rtd->codec_dai = codec_dais[0];
950 rtd->codec = rtd->codec_dai->codec;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100951
Mark Brown848dd8b2011-04-27 18:16:32 +0100952 /* if there's no platform we match on the empty platform */
953 platform_name = dai_link->platform_name;
Stephen Warren5a504962011-12-21 10:40:59 -0700954 if (!platform_name && !dai_link->platform_of_node)
Mark Brown848dd8b2011-04-27 18:16:32 +0100955 platform_name = "snd-soc-dummy";
956
Mark Brownb19e6e72012-03-14 21:18:39 +0000957 /* find one from the set of registered platforms */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000958 list_for_each_entry(platform, &platform_list, list) {
Stephen Warren5a504962011-12-21 10:40:59 -0700959 if (dai_link->platform_of_node) {
960 if (platform->dev->of_node !=
961 dai_link->platform_of_node)
962 continue;
963 } else {
Lars-Peter Clausenf4333202014-06-16 18:13:02 +0200964 if (strcmp(platform->component.name, platform_name))
Stephen Warren5a504962011-12-21 10:40:59 -0700965 continue;
966 }
Stephen Warren2610ab72011-12-07 13:58:27 -0700967
968 rtd->platform = platform;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000969 }
Mark Brownb19e6e72012-03-14 21:18:39 +0000970 if (!rtd->platform) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000971 dev_err(card->dev, "ASoC: platform %s not registered\n",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000972 dai_link->platform_name);
Mark Brownb19e6e72012-03-14 21:18:39 +0000973 return -EPROBE_DEFER;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000974 }
Mark Brownb19e6e72012-03-14 21:18:39 +0000975
976 card->num_rtd++;
977
978 return 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000979}
980
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +0200981static void soc_remove_component(struct snd_soc_component *component)
Stephen Warrend12cd192012-06-08 12:34:22 -0600982{
Lars-Peter Clausenabd31b32015-07-08 20:47:44 +0200983 if (!component->card)
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +0200984 return;
Stephen Warrend12cd192012-06-08 12:34:22 -0600985
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +0200986 /* This is a HACK and will be removed soon */
987 if (component->codec)
988 list_del(&component->codec->card_list);
Stephen Warrend12cd192012-06-08 12:34:22 -0600989
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +0200990 if (component->remove)
991 component->remove(component);
Stephen Warrend12cd192012-06-08 12:34:22 -0600992
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +0200993 snd_soc_dapm_free(snd_soc_component_get_dapm(component));
Stephen Warrend12cd192012-06-08 12:34:22 -0600994
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +0200995 soc_cleanup_component_debugfs(component);
Lars-Peter Clausenabd31b32015-07-08 20:47:44 +0200996 component->card = NULL;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +0200997 module_put(component->dev->driver->owner);
Stephen Warrend12cd192012-06-08 12:34:22 -0600998}
999
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001000static void soc_remove_dai(struct snd_soc_dai *dai, int order)
Jarkko Nikula589c3562010-12-06 16:27:07 +02001001{
1002 int err;
1003
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001004 if (dai && dai->probed &&
1005 dai->driver->remove_order == order) {
1006 if (dai->driver->remove) {
1007 err = dai->driver->remove(dai);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001008 if (err < 0)
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001009 dev_err(dai->dev,
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001010 "ASoC: failed to remove %s: %d\n",
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001011 dai->name, err);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001012 }
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001013 dai->probed = 0;
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001014 }
1015}
1016
Stephen Warren62ae68f2012-06-08 12:34:23 -06001017static void soc_remove_link_dais(struct snd_soc_card *card, int num, int order)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001018{
1019 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001020 int i;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001021
1022 /* unregister the rtd device */
1023 if (rtd->dev_registered) {
Mark Brown36ae1a92012-01-06 17:12:45 -08001024 device_unregister(rtd->dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001025 rtd->dev_registered = 0;
1026 }
1027
1028 /* remove the CODEC DAI */
Benoit Cousson88bd8702014-07-08 23:19:34 +02001029 for (i = 0; i < rtd->num_codecs; i++)
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001030 soc_remove_dai(rtd->codec_dais[i], order);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001031
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001032 soc_remove_dai(rtd->cpu_dai, order);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001033}
1034
Stephen Warren62ae68f2012-06-08 12:34:23 -06001035static void soc_remove_link_components(struct snd_soc_card *card, int num,
1036 int order)
1037{
1038 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
1039 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Stephen Warren62ae68f2012-06-08 12:34:23 -06001040 struct snd_soc_platform *platform = rtd->platform;
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001041 struct snd_soc_component *component;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001042 int i;
Stephen Warren62ae68f2012-06-08 12:34:23 -06001043
1044 /* remove the platform */
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001045 if (platform && platform->component.driver->remove_order == order)
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001046 soc_remove_component(&platform->component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001047
1048 /* remove the CODEC-side CODEC */
Benoit Cousson88bd8702014-07-08 23:19:34 +02001049 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001050 component = rtd->codec_dais[i]->component;
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001051 if (component->driver->remove_order == order)
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001052 soc_remove_component(component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001053 }
1054
1055 /* remove any CPU-side CODEC */
1056 if (cpu_dai) {
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001057 if (cpu_dai->component->driver->remove_order == order)
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001058 soc_remove_component(cpu_dai->component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001059 }
1060}
1061
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001062static void soc_remove_dai_links(struct snd_soc_card *card)
1063{
Liam Girdwood0168bf02011-06-07 16:08:05 +01001064 int dai, order;
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001065
Liam Girdwood0168bf02011-06-07 16:08:05 +01001066 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1067 order++) {
1068 for (dai = 0; dai < card->num_rtd; dai++)
Stephen Warren62ae68f2012-06-08 12:34:23 -06001069 soc_remove_link_dais(card, dai, order);
Liam Girdwood0168bf02011-06-07 16:08:05 +01001070 }
Stephen Warren62ae68f2012-06-08 12:34:23 -06001071
1072 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1073 order++) {
1074 for (dai = 0; dai < card->num_rtd; dai++)
1075 soc_remove_link_components(card, dai, order);
1076 }
1077
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001078 card->num_rtd = 0;
1079}
1080
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001081static void soc_set_name_prefix(struct snd_soc_card *card,
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001082 struct snd_soc_component *component)
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001083{
1084 int i;
1085
Dimitris Papastamosff819b82010-12-02 14:53:03 +00001086 if (card->codec_conf == NULL)
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001087 return;
1088
Dimitris Papastamosff819b82010-12-02 14:53:03 +00001089 for (i = 0; i < card->num_configs; i++) {
1090 struct snd_soc_codec_conf *map = &card->codec_conf[i];
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001091 if (map->of_node && component->dev->of_node != map->of_node)
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001092 continue;
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001093 if (map->dev_name && strcmp(component->name, map->dev_name))
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001094 continue;
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001095 component->name_prefix = map->name_prefix;
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001096 break;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001097 }
1098}
1099
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001100static int soc_probe_component(struct snd_soc_card *card,
1101 struct snd_soc_component *component)
Jarkko Nikula589c3562010-12-06 16:27:07 +02001102{
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001103 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
Mark Brown888df392012-02-16 19:37:51 -08001104 struct snd_soc_dai *dai;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001105 int ret;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001106
Lars-Peter Clausen1b7c1232015-07-08 20:47:43 +02001107 if (!strcmp(component->name, "snd-soc-dummy"))
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001108 return 0;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001109
Lars-Peter Clausenabd31b32015-07-08 20:47:44 +02001110 if (component->card) {
Lars-Peter Clausen1b7c1232015-07-08 20:47:43 +02001111 if (component->card != card) {
1112 dev_err(component->dev,
1113 "Trying to bind component to card \"%s\" but is already bound to card \"%s\"\n",
1114 card->name, component->card->name);
1115 return -ENODEV;
1116 }
1117 return 0;
1118 }
1119
Lars-Peter Clausenabd31b32015-07-08 20:47:44 +02001120 if (!try_module_get(component->dev->driver->owner))
1121 return -ENODEV;
1122
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001123 component->card = card;
1124 dapm->card = card;
1125 soc_set_name_prefix(card, component);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001126
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001127 soc_init_component_debugfs(component);
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001128
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001129 if (component->dapm_widgets) {
1130 ret = snd_soc_dapm_new_controls(dapm, component->dapm_widgets,
1131 component->num_dapm_widgets);
Nariman Poushinb318ad52014-04-01 13:59:33 +01001132
1133 if (ret != 0) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001134 dev_err(component->dev,
Nariman Poushinb318ad52014-04-01 13:59:33 +01001135 "Failed to create new controls %d\n", ret);
1136 goto err_probe;
1137 }
1138 }
Lars-Peter Clausen77530152011-05-05 16:59:09 +02001139
Lars-Peter Clausen06348142014-08-20 13:08:49 +02001140 list_for_each_entry(dai, &component->dai_list, list) {
1141 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
Nariman Poushin261edc72014-03-31 15:47:12 +01001142 if (ret != 0) {
Lars-Peter Clausen06348142014-08-20 13:08:49 +02001143 dev_err(component->dev,
Nariman Poushin261edc72014-03-31 15:47:12 +01001144 "Failed to create DAI widgets %d\n", ret);
1145 goto err_probe;
1146 }
1147 }
Mark Brown888df392012-02-16 19:37:51 -08001148
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001149 if (component->probe) {
1150 ret = component->probe(component);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001151 if (ret < 0) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001152 dev_err(component->dev,
1153 "ASoC: failed to probe component %d\n", ret);
Jarkko Nikula70d29332011-01-27 16:24:22 +02001154 goto err_probe;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001155 }
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001156
1157 WARN(dapm->idle_bias_off &&
1158 dapm->bias_level != SND_SOC_BIAS_OFF,
Michał Mirosław10e8aa92013-05-04 22:21:38 +02001159 "codec %s can not start from non-off bias with idle_bias_off==1\n",
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001160 component->name);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001161 }
1162
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001163 if (component->controls)
1164 snd_soc_add_component_controls(component, component->controls,
1165 component->num_controls);
1166 if (component->dapm_routes)
1167 snd_soc_dapm_add_routes(dapm, component->dapm_routes,
1168 component->num_dapm_routes);
Mark Brown89b95ac02011-03-07 16:38:44 +00001169
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001170 list_add(&dapm->list, &card->dapm_list);
1171
1172 /* This is a HACK and will be removed soon */
1173 if (component->codec)
1174 list_add(&component->codec->card_list, &card->codec_dev_list);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001175
Jarkko Nikula70d29332011-01-27 16:24:22 +02001176 return 0;
1177
1178err_probe:
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001179 soc_cleanup_component_debugfs(component);
Lars-Peter Clausenabd31b32015-07-08 20:47:44 +02001180 component->card = NULL;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001181 module_put(component->dev->driver->owner);
Liam Girdwood956245e2011-07-01 16:54:08 +01001182
1183 return ret;
1184}
1185
Mark Brown36ae1a92012-01-06 17:12:45 -08001186static void rtd_release(struct device *dev)
1187{
1188 kfree(dev);
1189}
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001190
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001191static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
1192 const char *name)
Misael Lopez Cruz503ae5e2014-04-24 14:01:44 +02001193{
Jarkko Nikula589c3562010-12-06 16:27:07 +02001194 int ret = 0;
1195
Jarkko Nikula589c3562010-12-06 16:27:07 +02001196 /* register the rtd device */
Mark Brown36ae1a92012-01-06 17:12:45 -08001197 rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1198 if (!rtd->dev)
1199 return -ENOMEM;
1200 device_initialize(rtd->dev);
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001201 rtd->dev->parent = rtd->card->dev;
Mark Brown36ae1a92012-01-06 17:12:45 -08001202 rtd->dev->release = rtd_release;
Takashi Iwaid29697d2015-01-30 20:16:37 +01001203 rtd->dev->groups = soc_dev_attr_groups;
Lars-Peter Clausenf294afe2014-08-17 11:28:35 +02001204 dev_set_name(rtd->dev, "%s", name);
Mark Brown36ae1a92012-01-06 17:12:45 -08001205 dev_set_drvdata(rtd->dev, rtd);
Liam Girdwoodb8c0dab2011-06-09 17:04:39 +01001206 mutex_init(&rtd->pcm_mutex);
Liam Girdwood01d75842012-04-25 12:12:49 +01001207 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
1208 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
1209 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
1210 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
Mark Brown36ae1a92012-01-06 17:12:45 -08001211 ret = device_add(rtd->dev);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001212 if (ret < 0) {
Chuansheng Liu865df9c2012-12-26 00:56:05 +08001213 /* calling put_device() here to free the rtd->dev */
1214 put_device(rtd->dev);
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001215 dev_err(rtd->card->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001216 "ASoC: failed to register runtime device: %d\n", ret);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001217 return ret;
1218 }
1219 rtd->dev_registered = 1;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001220 return 0;
1221}
1222
Stephen Warren62ae68f2012-06-08 12:34:23 -06001223static int soc_probe_link_components(struct snd_soc_card *card, int num,
1224 int order)
1225{
1226 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
Stephen Warren62ae68f2012-06-08 12:34:23 -06001227 struct snd_soc_platform *platform = rtd->platform;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001228 struct snd_soc_component *component;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001229 int i, ret;
Stephen Warren62ae68f2012-06-08 12:34:23 -06001230
1231 /* probe the CPU-side component, if it is a CODEC */
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001232 component = rtd->cpu_dai->component;
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001233 if (component->driver->probe_order == order) {
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001234 ret = soc_probe_component(card, component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001235 if (ret < 0)
1236 return ret;
1237 }
1238
Benoit Cousson88bd8702014-07-08 23:19:34 +02001239 /* probe the CODEC-side components */
1240 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001241 component = rtd->codec_dais[i]->component;
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001242 if (component->driver->probe_order == order) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001243 ret = soc_probe_component(card, component);
Benoit Cousson88bd8702014-07-08 23:19:34 +02001244 if (ret < 0)
1245 return ret;
1246 }
Stephen Warren62ae68f2012-06-08 12:34:23 -06001247 }
1248
1249 /* probe the platform */
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001250 if (platform->component.driver->probe_order == order) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001251 ret = soc_probe_component(card, &platform->component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001252 if (ret < 0)
1253 return ret;
1254 }
1255
1256 return 0;
1257}
1258
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001259static int soc_probe_dai(struct snd_soc_dai *dai, int order)
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001260{
1261 int ret;
1262
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001263 if (!dai->probed && dai->driver->probe_order == order) {
1264 if (dai->driver->probe) {
1265 ret = dai->driver->probe(dai);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001266 if (ret < 0) {
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001267 dev_err(dai->dev,
1268 "ASoC: failed to probe DAI %s: %d\n",
1269 dai->name, ret);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001270 return ret;
1271 }
1272 }
1273
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001274 dai->probed = 1;
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001275 }
1276
1277 return 0;
1278}
1279
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001280static int soc_link_dai_widgets(struct snd_soc_card *card,
1281 struct snd_soc_dai_link *dai_link,
Benoit Cousson3f901a02014-07-01 09:47:54 +02001282 struct snd_soc_pcm_runtime *rtd)
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001283{
Benoit Cousson3f901a02014-07-01 09:47:54 +02001284 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1285 struct snd_soc_dai *codec_dai = rtd->codec_dai;
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001286 struct snd_soc_dapm_widget *play_w, *capture_w;
1287 int ret;
1288
Benoit Cousson88bd8702014-07-08 23:19:34 +02001289 if (rtd->num_codecs > 1)
1290 dev_warn(card->dev, "ASoC: Multiple codecs not supported yet\n");
1291
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001292 /* link the DAI widgets */
1293 play_w = codec_dai->playback_widget;
1294 capture_w = cpu_dai->capture_widget;
1295 if (play_w && capture_w) {
1296 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
Nikesh Oswalc6615082015-02-02 17:06:44 +00001297 dai_link->num_params, capture_w,
1298 play_w);
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001299 if (ret != 0) {
1300 dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1301 play_w->name, capture_w->name, ret);
1302 return ret;
1303 }
1304 }
1305
1306 play_w = cpu_dai->playback_widget;
1307 capture_w = codec_dai->capture_widget;
1308 if (play_w && capture_w) {
1309 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
Nikesh Oswalc6615082015-02-02 17:06:44 +00001310 dai_link->num_params, capture_w,
1311 play_w);
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001312 if (ret != 0) {
1313 dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1314 play_w->name, capture_w->name, ret);
1315 return ret;
1316 }
1317 }
1318
1319 return 0;
1320}
1321
Stephen Warren62ae68f2012-06-08 12:34:23 -06001322static int soc_probe_link_dais(struct snd_soc_card *card, int num, int order)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001323{
1324 struct snd_soc_dai_link *dai_link = &card->dai_link[num];
1325 struct snd_soc_pcm_runtime *rtd = &card->rtd[num];
Mark Brownc74184e2012-04-04 22:12:09 +01001326 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001327 int i, ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001328
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001329 dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
Liam Girdwood0168bf02011-06-07 16:08:05 +01001330 card->name, num, order);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001331
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001332 /* set default power off timeout */
1333 rtd->pmdown_time = pmdown_time;
1334
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001335 ret = soc_probe_dai(cpu_dai, order);
1336 if (ret)
1337 return ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001338
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001339 /* probe the CODEC DAI */
Benoit Cousson88bd8702014-07-08 23:19:34 +02001340 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001341 ret = soc_probe_dai(rtd->codec_dais[i], order);
Benoit Cousson88bd8702014-07-08 23:19:34 +02001342 if (ret)
1343 return ret;
1344 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001345
Liam Girdwood0168bf02011-06-07 16:08:05 +01001346 /* complete DAI probe during last probe */
1347 if (order != SND_SOC_COMP_ORDER_LAST)
1348 return 0;
1349
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001350 /* do machine specific initialization */
1351 if (dai_link->init) {
1352 ret = dai_link->init(rtd);
1353 if (ret < 0) {
1354 dev_err(card->dev, "ASoC: failed to init %s: %d\n",
1355 dai_link->name, ret);
1356 return ret;
1357 }
1358 }
1359
Kuninori Morimotoa5053a82015-04-10 09:47:00 +00001360 if (dai_link->dai_fmt)
1361 snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
1362
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001363 ret = soc_post_component_init(rtd, dai_link->name);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001364 if (ret)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001365 return ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001366
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001367#ifdef CONFIG_DEBUG_FS
1368 /* add DPCM sysfs entries */
Lars-Peter Clausen2e55b902015-04-09 10:52:37 +02001369 if (dai_link->dynamic)
1370 soc_dpcm_debugfs_add(rtd);
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001371#endif
1372
Jie Yang6f0c4222015-10-13 23:41:00 +08001373 if (cpu_dai->driver->compress_new) {
Namarta Kohli1245b702012-08-16 17:10:41 +05301374 /*create compress_device"*/
Jie Yang6f0c4222015-10-13 23:41:00 +08001375 ret = cpu_dai->driver->compress_new(rtd, num);
Mark Brownc74184e2012-04-04 22:12:09 +01001376 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001377 dev_err(card->dev, "ASoC: can't create compress %s\n",
Namarta Kohli1245b702012-08-16 17:10:41 +05301378 dai_link->stream_name);
Mark Brownc74184e2012-04-04 22:12:09 +01001379 return ret;
1380 }
1381 } else {
Namarta Kohli1245b702012-08-16 17:10:41 +05301382
1383 if (!dai_link->params) {
1384 /* create the pcm */
1385 ret = soc_new_pcm(rtd, num);
1386 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001387 dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
Namarta Kohli1245b702012-08-16 17:10:41 +05301388 dai_link->stream_name, ret);
Mark Brownc74184e2012-04-04 22:12:09 +01001389 return ret;
1390 }
Namarta Kohli1245b702012-08-16 17:10:41 +05301391 } else {
Richard Fitzgerald9d58a072013-08-05 13:17:28 +01001392 INIT_DELAYED_WORK(&rtd->delayed_work,
1393 codec2codec_close_delayed_work);
1394
Namarta Kohli1245b702012-08-16 17:10:41 +05301395 /* link the DAI widgets */
Benoit Cousson3f901a02014-07-01 09:47:54 +02001396 ret = soc_link_dai_widgets(card, dai_link, rtd);
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001397 if (ret)
1398 return ret;
Mark Brownc74184e2012-04-04 22:12:09 +01001399 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001400 }
1401
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001402 return 0;
1403}
1404
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001405static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
Mark Brownb19e6e72012-03-14 21:18:39 +00001406{
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001407 struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001408 struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001409 const char *name = aux_dev->codec_name;
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001410
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001411 rtd->component = soc_find_component(aux_dev->codec_of_node, name);
1412 if (!rtd->component) {
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001413 if (aux_dev->codec_of_node)
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001414 name = of_node_full_name(aux_dev->codec_of_node);
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001415
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001416 dev_err(card->dev, "ASoC: %s not registered\n", name);
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001417 return -EPROBE_DEFER;
1418 }
1419
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001420 /*
1421 * Some places still reference rtd->codec, so we have to keep that
1422 * initialized if the component is a CODEC. Once all those references
1423 * have been removed, this code can be removed as well.
1424 */
1425 rtd->codec = rtd->component->codec;
1426
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001427 return 0;
Mark Brownb19e6e72012-03-14 21:18:39 +00001428}
1429
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001430static int soc_probe_aux_dev(struct snd_soc_card *card, int num)
1431{
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001432 struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001433 struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001434 int ret;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001435
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001436 ret = soc_probe_component(card, rtd->component);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001437 if (ret < 0)
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001438 return ret;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001439
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001440 /* do machine specific initialization */
1441 if (aux_dev->init) {
Lars-Peter Clausen57bf7722014-08-19 15:51:23 +02001442 ret = aux_dev->init(rtd->component);
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001443 if (ret < 0) {
1444 dev_err(card->dev, "ASoC: failed to init %s: %d\n",
1445 aux_dev->name, ret);
1446 return ret;
1447 }
1448 }
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001449
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001450 return soc_post_component_init(rtd, aux_dev->name);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001451}
1452
1453static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
1454{
1455 struct snd_soc_pcm_runtime *rtd = &card->rtd_aux[num];
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001456 struct snd_soc_component *component = rtd->component;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001457
1458 /* unregister the rtd device */
1459 if (rtd->dev_registered) {
Chuansheng Liud3bf1562012-12-26 00:57:32 +08001460 device_unregister(rtd->dev);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001461 rtd->dev_registered = 0;
1462 }
1463
Lars-Peter Clausenabd31b32015-07-08 20:47:44 +02001464 if (component)
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001465 soc_remove_component(component);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001466}
1467
Lars-Peter Clausenf90fb3f2013-08-31 20:31:15 +02001468static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001469{
1470 int ret;
1471
1472 if (codec->cache_init)
1473 return 0;
1474
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001475 ret = snd_soc_cache_init(codec);
1476 if (ret < 0) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02001477 dev_err(codec->dev,
1478 "ASoC: Failed to set cache compression type: %d\n",
1479 ret);
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001480 return ret;
1481 }
1482 codec->cache_init = 1;
1483 return 0;
1484}
1485
Lars-Peter Clausence64c8b2015-01-06 15:17:20 +01001486/**
1487 * snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime
1488 * @rtd: The runtime for which the DAI link format should be changed
1489 * @dai_fmt: The new DAI link format
1490 *
1491 * This function updates the DAI link format for all DAIs connected to the DAI
1492 * link for the specified runtime.
1493 *
1494 * Note: For setups with a static format set the dai_fmt field in the
1495 * corresponding snd_dai_link struct instead of using this function.
1496 *
1497 * Returns 0 on success, otherwise a negative error code.
1498 */
1499int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
1500 unsigned int dai_fmt)
1501{
1502 struct snd_soc_dai **codec_dais = rtd->codec_dais;
1503 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1504 unsigned int i;
1505 int ret;
1506
1507 for (i = 0; i < rtd->num_codecs; i++) {
1508 struct snd_soc_dai *codec_dai = codec_dais[i];
1509
1510 ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
1511 if (ret != 0 && ret != -ENOTSUPP) {
1512 dev_warn(codec_dai->dev,
1513 "ASoC: Failed to set DAI format: %d\n", ret);
1514 return ret;
1515 }
1516 }
1517
1518 /* Flip the polarity for the "CPU" end of a CODEC<->CODEC link */
1519 if (cpu_dai->codec) {
1520 unsigned int inv_dai_fmt;
1521
1522 inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_MASTER_MASK;
1523 switch (dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1524 case SND_SOC_DAIFMT_CBM_CFM:
1525 inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
1526 break;
1527 case SND_SOC_DAIFMT_CBM_CFS:
1528 inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
1529 break;
1530 case SND_SOC_DAIFMT_CBS_CFM:
1531 inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
1532 break;
1533 case SND_SOC_DAIFMT_CBS_CFS:
1534 inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
1535 break;
1536 }
1537
1538 dai_fmt = inv_dai_fmt;
1539 }
1540
1541 ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt);
1542 if (ret != 0 && ret != -ENOTSUPP) {
1543 dev_warn(cpu_dai->dev,
1544 "ASoC: Failed to set DAI format: %d\n", ret);
1545 return ret;
1546 }
1547
1548 return 0;
1549}
Lars-Peter Clausenddaca252015-01-08 12:23:05 +01001550EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
Lars-Peter Clausence64c8b2015-01-06 15:17:20 +01001551
Mark Brownb19e6e72012-03-14 21:18:39 +00001552static int snd_soc_instantiate_card(struct snd_soc_card *card)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001553{
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001554 struct snd_soc_codec *codec;
Lars-Peter Clausence64c8b2015-01-06 15:17:20 +01001555 int ret, i, order;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001556
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01001557 mutex_lock(&client_mutex);
Liam Girdwood01b9d992012-03-07 10:38:25 +00001558 mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001559
Mark Brownb19e6e72012-03-14 21:18:39 +00001560 /* bind DAIs */
1561 for (i = 0; i < card->num_links; i++) {
1562 ret = soc_bind_dai_link(card, i);
1563 if (ret != 0)
1564 goto base_error;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001565 }
1566
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001567 /* bind aux_devs too */
Mark Brownb19e6e72012-03-14 21:18:39 +00001568 for (i = 0; i < card->num_aux_devs; i++) {
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001569 ret = soc_bind_aux_dev(card, i);
Mark Brownb19e6e72012-03-14 21:18:39 +00001570 if (ret != 0)
1571 goto base_error;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001572 }
1573
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001574 /* initialize the register cache for each available codec */
1575 list_for_each_entry(codec, &codec_list, list) {
1576 if (codec->cache_init)
1577 continue;
Lars-Peter Clausenf90fb3f2013-08-31 20:31:15 +02001578 ret = snd_soc_init_codec_cache(codec);
Mark Brownb19e6e72012-03-14 21:18:39 +00001579 if (ret < 0)
1580 goto base_error;
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001581 }
1582
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001583 /* card bind complete so register a sound card */
Takashi Iwai102b5a82014-01-29 14:42:55 +01001584 ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001585 card->owner, 0, &card->snd_card);
1586 if (ret < 0) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02001587 dev_err(card->dev,
1588 "ASoC: can't create sound card for card %s: %d\n",
1589 card->name, ret);
Mark Brownb19e6e72012-03-14 21:18:39 +00001590 goto base_error;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001591 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001592
Lars-Peter Clausen0757d832015-04-09 10:52:36 +02001593 soc_init_card_debugfs(card);
1594
Mark Browne37a4972011-03-02 18:21:57 +00001595 card->dapm.bias_level = SND_SOC_BIAS_OFF;
1596 card->dapm.dev = card->dev;
1597 card->dapm.card = card;
1598 list_add(&card->dapm.list, &card->dapm_list);
1599
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001600#ifdef CONFIG_DEBUG_FS
1601 snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
1602#endif
1603
Mark Brown88ee1c62011-02-02 10:43:26 +00001604#ifdef CONFIG_PM_SLEEP
Andy Green6ed25972008-06-13 16:24:05 +01001605 /* deferred resume work */
Mark Brown63084192008-12-02 15:08:03 +00001606 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
Randy Dunlap1301a962008-06-17 19:19:34 +01001607#endif
Andy Green6ed25972008-06-13 16:24:05 +01001608
Mark Brown9a841eb2011-04-12 17:51:37 -07001609 if (card->dapm_widgets)
1610 snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
1611 card->num_dapm_widgets);
1612
Nicolin Chenf23e8602015-02-14 17:22:49 -08001613 if (card->of_dapm_widgets)
1614 snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets,
1615 card->num_of_dapm_widgets);
1616
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001617 /* initialise the sound card only once */
1618 if (card->probe) {
Mark Browne7361ec2011-01-26 14:17:20 +00001619 ret = card->probe(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001620 if (ret < 0)
1621 goto card_probe_error;
1622 }
1623
Stephen Warren62ae68f2012-06-08 12:34:23 -06001624 /* probe all components used by DAI links on this card */
Liam Girdwood0168bf02011-06-07 16:08:05 +01001625 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1626 order++) {
1627 for (i = 0; i < card->num_links; i++) {
Stephen Warren62ae68f2012-06-08 12:34:23 -06001628 ret = soc_probe_link_components(card, i, order);
Liam Girdwood0168bf02011-06-07 16:08:05 +01001629 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001630 dev_err(card->dev,
1631 "ASoC: failed to instantiate card %d\n",
1632 ret);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001633 goto probe_dai_err;
1634 }
1635 }
1636 }
1637
1638 /* probe all DAI links on this card */
1639 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1640 order++) {
1641 for (i = 0; i < card->num_links; i++) {
1642 ret = soc_probe_link_dais(card, i, order);
1643 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001644 dev_err(card->dev,
1645 "ASoC: failed to instantiate card %d\n",
1646 ret);
Liam Girdwood0168bf02011-06-07 16:08:05 +01001647 goto probe_dai_err;
1648 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001649 }
1650 }
1651
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001652 for (i = 0; i < card->num_aux_devs; i++) {
1653 ret = soc_probe_aux_dev(card, i);
1654 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001655 dev_err(card->dev,
1656 "ASoC: failed to add auxiliary devices %d\n",
1657 ret);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001658 goto probe_aux_dev_err;
1659 }
1660 }
1661
Mark Brown888df392012-02-16 19:37:51 -08001662 snd_soc_dapm_link_dai_widgets(card);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00001663 snd_soc_dapm_connect_dai_link_widgets(card);
Mark Brown888df392012-02-16 19:37:51 -08001664
Mark Brownb7af1da2011-04-07 19:18:44 +09001665 if (card->controls)
Liam Girdwood022658b2012-02-03 17:43:09 +00001666 snd_soc_add_card_controls(card, card->controls, card->num_controls);
Mark Brownb7af1da2011-04-07 19:18:44 +09001667
Mark Brownb8ad29d2011-03-02 18:35:51 +00001668 if (card->dapm_routes)
1669 snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
1670 card->num_dapm_routes);
1671
Nicolin Chenf23e8602015-02-14 17:22:49 -08001672 if (card->of_dapm_routes)
1673 snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,
1674 card->num_of_dapm_routes);
Mark Brown75d9ac42011-09-27 16:41:01 +01001675
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001676 snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001677 "%s", card->name);
Liam Girdwood22de71b2011-05-12 16:14:04 +01001678 snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
1679 "%s", card->long_name ? card->long_name : card->name);
Mark Brownf0e8ed82011-09-20 11:41:54 +01001680 snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
1681 "%s", card->driver_name ? card->driver_name : card->name);
1682 for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
1683 switch (card->snd_card->driver[i]) {
1684 case '_':
1685 case '-':
1686 case '\0':
1687 break;
1688 default:
1689 if (!isalnum(card->snd_card->driver[i]))
1690 card->snd_card->driver[i] = '_';
1691 break;
1692 }
1693 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001694
Mark Brown28e9ad92011-03-02 18:36:34 +00001695 if (card->late_probe) {
1696 ret = card->late_probe(card);
1697 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001698 dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
Mark Brown28e9ad92011-03-02 18:36:34 +00001699 card->name, ret);
1700 goto probe_aux_dev_err;
1701 }
1702 }
1703
Lars-Peter Clausen824ef822013-08-27 15:51:01 +02001704 snd_soc_dapm_new_widgets(card);
Lars-Peter Clausen8c193b82013-08-27 15:51:00 +02001705
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001706 ret = snd_card_register(card->snd_card);
1707 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001708 dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
1709 ret);
Axel Lin6b3ed782010-12-07 16:12:29 +08001710 goto probe_aux_dev_err;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001711 }
1712
Mark Brown435c5e22008-12-04 15:32:53 +00001713 card->instantiated = 1;
Mark Brown4f4c0072011-10-07 14:29:19 +01001714 snd_soc_dapm_sync(&card->dapm);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001715 mutex_unlock(&card->mutex);
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01001716 mutex_unlock(&client_mutex);
Mark Brownb19e6e72012-03-14 21:18:39 +00001717
1718 return 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001719
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001720probe_aux_dev_err:
1721 for (i = 0; i < card->num_aux_devs; i++)
1722 soc_remove_aux_dev(card, i);
1723
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001724probe_dai_err:
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001725 soc_remove_dai_links(card);
Mark Brownfe3e78e2009-11-03 22:13:13 +00001726
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001727card_probe_error:
Mark Brown87506542008-11-18 20:50:34 +00001728 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00001729 card->remove(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001730
Lars-Peter Clausen22104382015-07-08 22:14:48 +02001731 snd_soc_dapm_free(&card->dapm);
Lars-Peter Clausen0757d832015-04-09 10:52:36 +02001732 soc_cleanup_card_debugfs(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001733 snd_card_free(card->snd_card);
1734
Mark Brownb19e6e72012-03-14 21:18:39 +00001735base_error:
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001736 mutex_unlock(&card->mutex);
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01001737 mutex_unlock(&client_mutex);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001738
Mark Brownb19e6e72012-03-14 21:18:39 +00001739 return ret;
Mark Brown435c5e22008-12-04 15:32:53 +00001740}
1741
1742/* probes a new socdev */
1743static int soc_probe(struct platform_device *pdev)
1744{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001745 struct snd_soc_card *card = platform_get_drvdata(pdev);
Mark Brown435c5e22008-12-04 15:32:53 +00001746
Vinod Koul70a7ca32011-01-14 19:22:48 +05301747 /*
1748 * no card, so machine driver should be registering card
1749 * we should not be here in that case so ret error
1750 */
1751 if (!card)
1752 return -EINVAL;
1753
Mark Brownfe4085e2012-03-02 13:07:41 +00001754 dev_warn(&pdev->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001755 "ASoC: machine %s should use snd_soc_register_card()\n",
Mark Brownfe4085e2012-03-02 13:07:41 +00001756 card->name);
1757
Mark Brown435c5e22008-12-04 15:32:53 +00001758 /* Bodge while we unpick instantiation */
1759 card->dev = &pdev->dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001760
Mark Brown28d528c2012-08-09 18:45:23 +01001761 return snd_soc_register_card(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001762}
1763
Vinod Koulb0e26482011-01-13 22:48:02 +05301764static int soc_cleanup_card_resources(struct snd_soc_card *card)
1765{
Vinod Koulb0e26482011-01-13 22:48:02 +05301766 int i;
1767
1768 /* make sure any delayed work runs */
1769 for (i = 0; i < card->num_rtd; i++) {
1770 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
Tejun Heo43829732012-08-20 14:51:24 -07001771 flush_delayed_work(&rtd->delayed_work);
Vinod Koulb0e26482011-01-13 22:48:02 +05301772 }
1773
1774 /* remove auxiliary devices */
1775 for (i = 0; i < card->num_aux_devs; i++)
1776 soc_remove_aux_dev(card, i);
1777
1778 /* remove and free each DAI */
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001779 soc_remove_dai_links(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05301780
1781 soc_cleanup_card_debugfs(card);
1782
1783 /* remove the card */
1784 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00001785 card->remove(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05301786
Lars-Peter Clausen0aaae522011-04-30 19:45:47 +02001787 snd_soc_dapm_free(&card->dapm);
1788
Vinod Koulb0e26482011-01-13 22:48:02 +05301789 snd_card_free(card->snd_card);
1790 return 0;
1791
1792}
1793
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001794/* removes a socdev */
1795static int soc_remove(struct platform_device *pdev)
1796{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001797 struct snd_soc_card *card = platform_get_drvdata(pdev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001798
Mark Brownc5af3a22008-11-28 13:29:45 +00001799 snd_soc_unregister_card(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001800 return 0;
1801}
1802
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001803int snd_soc_poweroff(struct device *dev)
Mark Brown51737472009-06-22 13:16:51 +01001804{
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001805 struct snd_soc_card *card = dev_get_drvdata(dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001806 int i;
Mark Brown51737472009-06-22 13:16:51 +01001807
1808 if (!card->instantiated)
Mark Brown416356f2009-06-30 19:05:15 +01001809 return 0;
Mark Brown51737472009-06-22 13:16:51 +01001810
1811 /* Flush out pmdown_time work - we actually do want to run it
1812 * now, we're shutting down so no imminent restart. */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001813 for (i = 0; i < card->num_rtd; i++) {
1814 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
Tejun Heo43829732012-08-20 14:51:24 -07001815 flush_delayed_work(&rtd->delayed_work);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001816 }
Mark Brown51737472009-06-22 13:16:51 +01001817
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001818 snd_soc_dapm_shutdown(card);
Mark Brown416356f2009-06-30 19:05:15 +01001819
Nicolin Chen988e8cc2013-11-04 14:57:31 +08001820 /* deactivate pins to sleep state */
1821 for (i = 0; i < card->num_rtd; i++) {
Benoit Cousson88bd8702014-07-08 23:19:34 +02001822 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
1823 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1824 int j;
1825
Nicolin Chen988e8cc2013-11-04 14:57:31 +08001826 pinctrl_pm_select_sleep_state(cpu_dai->dev);
Benoit Cousson88bd8702014-07-08 23:19:34 +02001827 for (j = 0; j < rtd->num_codecs; j++) {
1828 struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
1829 pinctrl_pm_select_sleep_state(codec_dai->dev);
1830 }
Nicolin Chen988e8cc2013-11-04 14:57:31 +08001831 }
1832
Mark Brown416356f2009-06-30 19:05:15 +01001833 return 0;
Mark Brown51737472009-06-22 13:16:51 +01001834}
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001835EXPORT_SYMBOL_GPL(snd_soc_poweroff);
Mark Brown51737472009-06-22 13:16:51 +01001836
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001837const struct dev_pm_ops snd_soc_pm_ops = {
Viresh Kumarb1dd5892012-02-24 16:25:49 +05301838 .suspend = snd_soc_suspend,
1839 .resume = snd_soc_resume,
1840 .freeze = snd_soc_suspend,
1841 .thaw = snd_soc_resume,
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001842 .poweroff = snd_soc_poweroff,
Viresh Kumarb1dd5892012-02-24 16:25:49 +05301843 .restore = snd_soc_resume,
Mark Brown416356f2009-06-30 19:05:15 +01001844};
Stephen Warrendeb26072011-04-05 19:35:30 -06001845EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
Mark Brown416356f2009-06-30 19:05:15 +01001846
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001847/* ASoC platform driver */
1848static struct platform_driver soc_driver = {
1849 .driver = {
1850 .name = "soc-audio",
Mark Brown6f8ab4a2011-01-26 14:59:27 +00001851 .pm = &snd_soc_pm_ops,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001852 },
1853 .probe = soc_probe,
1854 .remove = soc_remove,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001855};
1856
Mark Brown096e49d2009-07-05 15:12:22 +01001857/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001858 * snd_soc_cnew - create new control
1859 * @_template: control template
1860 * @data: control private data
Mark Brownac11a2b2009-01-01 12:18:17 +00001861 * @long_name: control long name
Mark Brownefb7ac32011-03-08 17:23:24 +00001862 * @prefix: control name prefix
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001863 *
1864 * Create a new mixer control from a template control.
1865 *
1866 * Returns 0 for success, else error.
1867 */
1868struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
Mark Brown30565572012-02-16 17:07:42 -08001869 void *data, const char *long_name,
Mark Brownefb7ac32011-03-08 17:23:24 +00001870 const char *prefix)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001871{
1872 struct snd_kcontrol_new template;
Mark Brownefb7ac32011-03-08 17:23:24 +00001873 struct snd_kcontrol *kcontrol;
1874 char *name = NULL;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001875
1876 memcpy(&template, _template, sizeof(template));
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001877 template.index = 0;
1878
Mark Brownefb7ac32011-03-08 17:23:24 +00001879 if (!long_name)
1880 long_name = template.name;
1881
1882 if (prefix) {
Lars-Peter Clausen2b581072013-05-14 11:05:32 +02001883 name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
Mark Brownefb7ac32011-03-08 17:23:24 +00001884 if (!name)
1885 return NULL;
1886
Mark Brownefb7ac32011-03-08 17:23:24 +00001887 template.name = name;
1888 } else {
1889 template.name = long_name;
1890 }
1891
1892 kcontrol = snd_ctl_new1(&template, data);
1893
1894 kfree(name);
1895
1896 return kcontrol;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001897}
1898EXPORT_SYMBOL_GPL(snd_soc_cnew);
1899
Liam Girdwood022658b2012-02-03 17:43:09 +00001900static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
1901 const struct snd_kcontrol_new *controls, int num_controls,
1902 const char *prefix, void *data)
1903{
1904 int err, i;
1905
1906 for (i = 0; i < num_controls; i++) {
1907 const struct snd_kcontrol_new *control = &controls[i];
1908 err = snd_ctl_add(card, snd_soc_cnew(control, data,
1909 control->name, prefix));
1910 if (err < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001911 dev_err(dev, "ASoC: Failed to add %s: %d\n",
1912 control->name, err);
Liam Girdwood022658b2012-02-03 17:43:09 +00001913 return err;
1914 }
1915 }
1916
1917 return 0;
1918}
1919
Dimitris Papastamos4fefd692013-07-29 13:51:58 +01001920struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
1921 const char *name)
1922{
1923 struct snd_card *card = soc_card->snd_card;
1924 struct snd_kcontrol *kctl;
1925
1926 if (unlikely(!name))
1927 return NULL;
1928
1929 list_for_each_entry(kctl, &card->controls, list)
1930 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name)))
1931 return kctl;
1932 return NULL;
1933}
1934EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol);
1935
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001936/**
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02001937 * snd_soc_add_component_controls - Add an array of controls to a component.
1938 *
1939 * @component: Component to add controls to
1940 * @controls: Array of controls to add
1941 * @num_controls: Number of elements in the array
1942 *
1943 * Return: 0 for success, else error.
1944 */
1945int snd_soc_add_component_controls(struct snd_soc_component *component,
1946 const struct snd_kcontrol_new *controls, unsigned int num_controls)
1947{
1948 struct snd_card *card = component->card->snd_card;
1949
1950 return snd_soc_add_controls(card, component->dev, controls,
1951 num_controls, component->name_prefix, component);
1952}
1953EXPORT_SYMBOL_GPL(snd_soc_add_component_controls);
1954
1955/**
Liam Girdwood022658b2012-02-03 17:43:09 +00001956 * snd_soc_add_codec_controls - add an array of controls to a codec.
1957 * Convenience function to add a list of controls. Many codecs were
Ian Molton3e8e1952009-01-09 00:23:21 +00001958 * duplicating this code.
1959 *
1960 * @codec: codec 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 */
Liam Girdwood022658b2012-02-03 17:43:09 +00001966int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02001967 const struct snd_kcontrol_new *controls, unsigned int num_controls)
Ian Molton3e8e1952009-01-09 00:23:21 +00001968{
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02001969 return snd_soc_add_component_controls(&codec->component, controls,
1970 num_controls);
Ian Molton3e8e1952009-01-09 00:23:21 +00001971}
Liam Girdwood022658b2012-02-03 17:43:09 +00001972EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls);
Ian Molton3e8e1952009-01-09 00:23:21 +00001973
1974/**
Liam Girdwooda491a5c2011-07-04 22:10:51 +01001975 * snd_soc_add_platform_controls - add an array of controls to a platform.
Liam Girdwood022658b2012-02-03 17:43:09 +00001976 * Convenience function to add a list of controls.
Liam Girdwooda491a5c2011-07-04 22:10:51 +01001977 *
1978 * @platform: platform to add controls to
1979 * @controls: array of controls to add
1980 * @num_controls: number of elements in the array
1981 *
1982 * Return 0 for success, else error.
1983 */
1984int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02001985 const struct snd_kcontrol_new *controls, unsigned int num_controls)
Liam Girdwooda491a5c2011-07-04 22:10:51 +01001986{
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02001987 return snd_soc_add_component_controls(&platform->component, controls,
1988 num_controls);
Liam Girdwooda491a5c2011-07-04 22:10:51 +01001989}
1990EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
1991
1992/**
Liam Girdwood022658b2012-02-03 17:43:09 +00001993 * snd_soc_add_card_controls - add an array of controls to a SoC card.
1994 * Convenience function to add a list of controls.
1995 *
1996 * @soc_card: SoC card to add controls to
1997 * @controls: array of controls to add
1998 * @num_controls: number of elements in the array
1999 *
2000 * Return 0 for success, else error.
2001 */
2002int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
2003 const struct snd_kcontrol_new *controls, int num_controls)
2004{
2005 struct snd_card *card = soc_card->snd_card;
2006
2007 return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,
2008 NULL, soc_card);
2009}
2010EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
2011
2012/**
2013 * snd_soc_add_dai_controls - add an array of controls to a DAI.
2014 * Convienience function to add a list of controls.
2015 *
2016 * @dai: DAI to add controls to
2017 * @controls: array of controls to add
2018 * @num_controls: number of elements in the array
2019 *
2020 * Return 0 for success, else error.
2021 */
2022int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
2023 const struct snd_kcontrol_new *controls, int num_controls)
2024{
Lars-Peter Clausen313665b2014-11-04 11:30:58 +01002025 struct snd_card *card = dai->component->card->snd_card;
Liam Girdwood022658b2012-02-03 17:43:09 +00002026
2027 return snd_soc_add_controls(card, dai->dev, controls, num_controls,
2028 NULL, dai);
2029}
2030EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
2031
2032/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002033 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2034 * @dai: DAI
2035 * @clk_id: DAI specific clock ID
2036 * @freq: new clock frequency in Hz
2037 * @dir: new clock direction - input/output.
2038 *
2039 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2040 */
2041int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2042 unsigned int freq, int dir)
2043{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002044 if (dai->driver && dai->driver->ops->set_sysclk)
2045 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
Mark Brownec4ee522011-03-07 20:58:11 +00002046 else if (dai->codec && dai->codec->driver->set_sysclk)
Mark Brownda1c6ea2011-08-24 20:09:01 +01002047 return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,
Mark Brownec4ee522011-03-07 20:58:11 +00002048 freq, dir);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002049 else
Mark Brown1104a9c2014-01-15 19:04:19 +00002050 return -ENOTSUPP;
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002051}
2052EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
2053
2054/**
Mark Brownec4ee522011-03-07 20:58:11 +00002055 * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
2056 * @codec: CODEC
2057 * @clk_id: DAI specific clock ID
Mark Brownda1c6ea2011-08-24 20:09:01 +01002058 * @source: Source for the clock
Mark Brownec4ee522011-03-07 20:58:11 +00002059 * @freq: new clock frequency in Hz
2060 * @dir: new clock direction - input/output.
2061 *
2062 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
2063 */
2064int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
Mark Brownda1c6ea2011-08-24 20:09:01 +01002065 int source, unsigned int freq, int dir)
Mark Brownec4ee522011-03-07 20:58:11 +00002066{
2067 if (codec->driver->set_sysclk)
Mark Brownda1c6ea2011-08-24 20:09:01 +01002068 return codec->driver->set_sysclk(codec, clk_id, source,
2069 freq, dir);
Mark Brownec4ee522011-03-07 20:58:11 +00002070 else
Mark Brown1104a9c2014-01-15 19:04:19 +00002071 return -ENOTSUPP;
Mark Brownec4ee522011-03-07 20:58:11 +00002072}
2073EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
2074
2075/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002076 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
2077 * @dai: DAI
Mark Brownac11a2b2009-01-01 12:18:17 +00002078 * @div_id: DAI specific clock divider ID
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002079 * @div: new clock divisor.
2080 *
2081 * Configures the clock dividers. This is used to derive the best DAI bit and
2082 * frame clocks from the system or master clock. It's best to set the DAI bit
2083 * and frame clocks as low as possible to save system power.
2084 */
2085int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2086 int div_id, int div)
2087{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002088 if (dai->driver && dai->driver->ops->set_clkdiv)
2089 return dai->driver->ops->set_clkdiv(dai, div_id, div);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002090 else
2091 return -EINVAL;
2092}
2093EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
2094
2095/**
2096 * snd_soc_dai_set_pll - configure DAI PLL.
2097 * @dai: DAI
2098 * @pll_id: DAI specific PLL ID
Mark Brown85488032009-09-05 18:52:16 +01002099 * @source: DAI specific source for the PLL
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002100 * @freq_in: PLL input clock frequency in Hz
2101 * @freq_out: requested PLL output clock frequency in Hz
2102 *
2103 * Configures and enables PLL to generate output clock based on input clock.
2104 */
Mark Brown85488032009-09-05 18:52:16 +01002105int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
2106 unsigned int freq_in, unsigned int freq_out)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002107{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002108 if (dai->driver && dai->driver->ops->set_pll)
2109 return dai->driver->ops->set_pll(dai, pll_id, source,
Mark Brown85488032009-09-05 18:52:16 +01002110 freq_in, freq_out);
Mark Brownec4ee522011-03-07 20:58:11 +00002111 else if (dai->codec && dai->codec->driver->set_pll)
2112 return dai->codec->driver->set_pll(dai->codec, pll_id, source,
2113 freq_in, freq_out);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002114 else
2115 return -EINVAL;
2116}
2117EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
2118
Mark Brownec4ee522011-03-07 20:58:11 +00002119/*
2120 * snd_soc_codec_set_pll - configure codec PLL.
2121 * @codec: CODEC
2122 * @pll_id: DAI specific PLL ID
2123 * @source: DAI specific source for the PLL
2124 * @freq_in: PLL input clock frequency in Hz
2125 * @freq_out: requested PLL output clock frequency in Hz
2126 *
2127 * Configures and enables PLL to generate output clock based on input clock.
2128 */
2129int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
2130 unsigned int freq_in, unsigned int freq_out)
2131{
2132 if (codec->driver->set_pll)
2133 return codec->driver->set_pll(codec, pll_id, source,
2134 freq_in, freq_out);
2135 else
2136 return -EINVAL;
2137}
2138EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);
2139
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002140/**
Liam Girdwoode54cf762013-09-16 13:01:46 +01002141 * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
2142 * @dai: DAI
Masanari Iida231b86b2015-07-15 23:02:38 +09002143 * @ratio: Ratio of BCLK to Sample rate.
Liam Girdwoode54cf762013-09-16 13:01:46 +01002144 *
2145 * Configures the DAI for a preset BCLK to sample rate ratio.
2146 */
2147int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
2148{
2149 if (dai->driver && dai->driver->ops->set_bclk_ratio)
2150 return dai->driver->ops->set_bclk_ratio(dai, ratio);
2151 else
2152 return -EINVAL;
2153}
2154EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
2155
2156/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002157 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
2158 * @dai: DAI
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002159 * @fmt: SND_SOC_DAIFMT_ format value.
2160 *
2161 * Configures the DAI hardware format and clocking.
2162 */
2163int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2164{
Shawn Guo5e4ba562012-03-09 00:59:40 +08002165 if (dai->driver == NULL)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002166 return -EINVAL;
Shawn Guo5e4ba562012-03-09 00:59:40 +08002167 if (dai->driver->ops->set_fmt == NULL)
2168 return -ENOTSUPP;
2169 return dai->driver->ops->set_fmt(dai, fmt);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002170}
2171EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
2172
2173/**
Xiubo Lie5c21512014-03-21 14:17:12 +08002174 * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
Xiubo Li89c67852014-02-14 09:34:35 +08002175 * @slots: Number of slots in use.
2176 * @tx_mask: bitmask representing active TX slots.
2177 * @rx_mask: bitmask representing active RX slots.
2178 *
2179 * Generates the TDM tx and rx slot default masks for DAI.
2180 */
Xiubo Lie5c21512014-03-21 14:17:12 +08002181static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
Xiubo Li89c67852014-02-14 09:34:35 +08002182 unsigned int *tx_mask,
2183 unsigned int *rx_mask)
2184{
2185 if (*tx_mask || *rx_mask)
2186 return 0;
2187
2188 if (!slots)
2189 return -EINVAL;
2190
2191 *tx_mask = (1 << slots) - 1;
2192 *rx_mask = (1 << slots) - 1;
2193
2194 return 0;
2195}
2196
2197/**
Lars-Peter Clausene46c9362015-01-12 10:27:20 +01002198 * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
2199 * @dai: The DAI to configure
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002200 * @tx_mask: bitmask representing active TX slots.
2201 * @rx_mask: bitmask representing active RX slots.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002202 * @slots: Number of slots in use.
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002203 * @slot_width: Width in bits for each slot.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002204 *
Lars-Peter Clausene46c9362015-01-12 10:27:20 +01002205 * This function configures the specified DAI for TDM operation. @slot contains
2206 * the total number of slots of the TDM stream and @slot_with the width of each
2207 * slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
2208 * active slots of the TDM stream for the specified DAI, i.e. which slots the
2209 * DAI should write to or read from. If a bit is set the corresponding slot is
2210 * active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
2211 * the first slot, bit 1 to the second slot and so on. The first active slot
2212 * maps to the first channel of the DAI, the second active slot to the second
2213 * channel and so on.
2214 *
2215 * TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
2216 * @rx_mask and @slot_width will be ignored.
2217 *
2218 * Returns 0 on success, a negative error code otherwise.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002219 */
2220int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002221 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002222{
Xiubo Lie5c21512014-03-21 14:17:12 +08002223 if (dai->driver && dai->driver->ops->xlate_tdm_slot_mask)
2224 dai->driver->ops->xlate_tdm_slot_mask(slots,
Xiubo Li89c67852014-02-14 09:34:35 +08002225 &tx_mask, &rx_mask);
2226 else
Xiubo Lie5c21512014-03-21 14:17:12 +08002227 snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
Xiubo Li89c67852014-02-14 09:34:35 +08002228
Benoit Cousson88bd8702014-07-08 23:19:34 +02002229 dai->tx_mask = tx_mask;
2230 dai->rx_mask = rx_mask;
2231
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002232 if (dai->driver && dai->driver->ops->set_tdm_slot)
2233 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002234 slots, slot_width);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002235 else
Xiubo Lib2cbb6e2014-01-23 13:02:47 +08002236 return -ENOTSUPP;
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002237}
2238EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
2239
2240/**
Barry Song472df3c2009-09-12 01:16:29 +08002241 * snd_soc_dai_set_channel_map - configure DAI audio channel map
2242 * @dai: DAI
2243 * @tx_num: how many TX channels
2244 * @tx_slot: pointer to an array which imply the TX slot number channel
2245 * 0~num-1 uses
2246 * @rx_num: how many RX channels
2247 * @rx_slot: pointer to an array which imply the RX slot number channel
2248 * 0~num-1 uses
2249 *
2250 * configure the relationship between channel number and TDM slot number.
2251 */
2252int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
2253 unsigned int tx_num, unsigned int *tx_slot,
2254 unsigned int rx_num, unsigned int *rx_slot)
2255{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002256 if (dai->driver && dai->driver->ops->set_channel_map)
2257 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
Barry Song472df3c2009-09-12 01:16:29 +08002258 rx_num, rx_slot);
2259 else
2260 return -EINVAL;
2261}
2262EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
2263
2264/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002265 * snd_soc_dai_set_tristate - configure DAI system or master clock.
2266 * @dai: DAI
2267 * @tristate: tristate enable
2268 *
2269 * Tristates the DAI so that others can use it.
2270 */
2271int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
2272{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002273 if (dai->driver && dai->driver->ops->set_tristate)
2274 return dai->driver->ops->set_tristate(dai, tristate);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002275 else
2276 return -EINVAL;
2277}
2278EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
2279
2280/**
2281 * snd_soc_dai_digital_mute - configure DAI system or master clock.
2282 * @dai: DAI
2283 * @mute: mute enable
Mark Brownda183962013-02-06 15:44:07 +00002284 * @direction: stream to mute
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002285 *
2286 * Mutes the DAI DAC.
2287 */
Mark Brownda183962013-02-06 15:44:07 +00002288int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
2289 int direction)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002290{
Mark Brownda183962013-02-06 15:44:07 +00002291 if (!dai->driver)
2292 return -ENOTSUPP;
2293
2294 if (dai->driver->ops->mute_stream)
2295 return dai->driver->ops->mute_stream(dai, mute, direction);
2296 else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
2297 dai->driver->ops->digital_mute)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002298 return dai->driver->ops->digital_mute(dai, mute);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002299 else
Mark Brown04570c62012-04-13 19:16:03 +01002300 return -ENOTSUPP;
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002301}
2302EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
2303
Benoit Cousson88bd8702014-07-08 23:19:34 +02002304static int snd_soc_init_multicodec(struct snd_soc_card *card,
2305 struct snd_soc_dai_link *dai_link)
2306{
2307 /* Legacy codec/codec_dai link is a single entry in multicodec */
2308 if (dai_link->codec_name || dai_link->codec_of_node ||
2309 dai_link->codec_dai_name) {
2310 dai_link->num_codecs = 1;
2311
2312 dai_link->codecs = devm_kzalloc(card->dev,
2313 sizeof(struct snd_soc_dai_link_component),
2314 GFP_KERNEL);
2315 if (!dai_link->codecs)
2316 return -ENOMEM;
2317
2318 dai_link->codecs[0].name = dai_link->codec_name;
2319 dai_link->codecs[0].of_node = dai_link->codec_of_node;
2320 dai_link->codecs[0].dai_name = dai_link->codec_dai_name;
2321 }
2322
2323 if (!dai_link->codecs) {
2324 dev_err(card->dev, "ASoC: DAI link has no CODECs\n");
2325 return -EINVAL;
2326 }
2327
2328 return 0;
2329}
2330
Mark Brownc5af3a22008-11-28 13:29:45 +00002331/**
2332 * snd_soc_register_card - Register a card with the ASoC core
2333 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002334 * @card: Card to register
Mark Brownc5af3a22008-11-28 13:29:45 +00002335 *
Mark Brownc5af3a22008-11-28 13:29:45 +00002336 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05302337int snd_soc_register_card(struct snd_soc_card *card)
Mark Brownc5af3a22008-11-28 13:29:45 +00002338{
Benoit Cousson88bd8702014-07-08 23:19:34 +02002339 int i, j, ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002340
Mark Brownc5af3a22008-11-28 13:29:45 +00002341 if (!card->name || !card->dev)
2342 return -EINVAL;
2343
Stephen Warren5a504962011-12-21 10:40:59 -07002344 for (i = 0; i < card->num_links; i++) {
2345 struct snd_soc_dai_link *link = &card->dai_link[i];
2346
Benoit Cousson88bd8702014-07-08 23:19:34 +02002347 ret = snd_soc_init_multicodec(card, link);
2348 if (ret) {
2349 dev_err(card->dev, "ASoC: failed to init multicodec\n");
2350 return ret;
Stephen Warren5a504962011-12-21 10:40:59 -07002351 }
Benoit Cousson88bd8702014-07-08 23:19:34 +02002352
2353 for (j = 0; j < link->num_codecs; j++) {
2354 /*
2355 * Codec must be specified by 1 of name or OF node,
2356 * not both or neither.
2357 */
2358 if (!!link->codecs[j].name ==
2359 !!link->codecs[j].of_node) {
2360 dev_err(card->dev, "ASoC: Neither/both codec name/of_node are set for %s\n",
2361 link->name);
2362 return -EINVAL;
2363 }
2364 /* Codec DAI name must be specified */
2365 if (!link->codecs[j].dai_name) {
2366 dev_err(card->dev, "ASoC: codec_dai_name not set for %s\n",
2367 link->name);
2368 return -EINVAL;
2369 }
Stephen Warrenbc926572012-05-25 18:22:11 -06002370 }
Stephen Warren5a504962011-12-21 10:40:59 -07002371
2372 /*
2373 * Platform may be specified by either name or OF node, but
2374 * can be left unspecified, and a dummy platform will be used.
2375 */
2376 if (link->platform_name && link->platform_of_node) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02002377 dev_err(card->dev,
2378 "ASoC: Both platform name/of_node are set for %s\n",
2379 link->name);
Stephen Warren5a504962011-12-21 10:40:59 -07002380 return -EINVAL;
2381 }
2382
2383 /*
Stephen Warrenbc926572012-05-25 18:22:11 -06002384 * CPU device may be specified by either name or OF node, but
2385 * can be left unspecified, and will be matched based on DAI
2386 * name alone..
Stephen Warren5a504962011-12-21 10:40:59 -07002387 */
Stephen Warrenbc926572012-05-25 18:22:11 -06002388 if (link->cpu_name && link->cpu_of_node) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02002389 dev_err(card->dev,
2390 "ASoC: Neither/both cpu name/of_node are set for %s\n",
2391 link->name);
Stephen Warrenbc926572012-05-25 18:22:11 -06002392 return -EINVAL;
2393 }
2394 /*
2395 * At least one of CPU DAI name or CPU device name/node must be
2396 * specified
2397 */
2398 if (!link->cpu_dai_name &&
2399 !(link->cpu_name || link->cpu_of_node)) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02002400 dev_err(card->dev,
2401 "ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
2402 link->name);
Stephen Warren5a504962011-12-21 10:40:59 -07002403 return -EINVAL;
2404 }
2405 }
2406
Mark Browned77cc12011-05-03 18:25:34 +01002407 dev_set_drvdata(card->dev, card);
2408
Stephen Warren111c6412011-01-28 14:26:35 -07002409 snd_soc_initialize_card_lists(card);
2410
Mark Brown181a6892012-03-14 20:18:49 +00002411 card->rtd = devm_kzalloc(card->dev,
2412 sizeof(struct snd_soc_pcm_runtime) *
2413 (card->num_links + card->num_aux_devs),
2414 GFP_KERNEL);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002415 if (card->rtd == NULL)
2416 return -ENOMEM;
Liam Girdwooda7dbb602012-04-17 18:00:11 +01002417 card->num_rtd = 0;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02002418 card->rtd_aux = &card->rtd[card->num_links];
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002419
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02002420 for (i = 0; i < card->num_links; i++) {
2421 card->rtd[i].card = card;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002422 card->rtd[i].dai_link = &card->dai_link[i];
Benoit Cousson88bd8702014-07-08 23:19:34 +02002423 card->rtd[i].codec_dais = devm_kzalloc(card->dev,
2424 sizeof(struct snd_soc_dai *) *
2425 (card->rtd[i].dai_link->num_codecs),
2426 GFP_KERNEL);
2427 if (card->rtd[i].codec_dais == NULL)
2428 return -ENOMEM;
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02002429 }
2430
2431 for (i = 0; i < card->num_aux_devs; i++)
2432 card->rtd_aux[i].card = card;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002433
Mark Browndb432b42011-10-03 21:06:40 +01002434 INIT_LIST_HEAD(&card->dapm_dirty);
Liam Girdwood8a978232015-05-29 19:06:14 +01002435 INIT_LIST_HEAD(&card->dobj_list);
Mark Brownc5af3a22008-11-28 13:29:45 +00002436 card->instantiated = 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002437 mutex_init(&card->mutex);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002438 mutex_init(&card->dapm_mutex);
Mark Brownc5af3a22008-11-28 13:29:45 +00002439
Mark Brownb19e6e72012-03-14 21:18:39 +00002440 ret = snd_soc_instantiate_card(card);
2441 if (ret != 0)
Kuninori Morimoto4e2576b2015-03-24 09:01:00 +00002442 return ret;
Mark Brownc5af3a22008-11-28 13:29:45 +00002443
Nicolin Chen988e8cc2013-11-04 14:57:31 +08002444 /* deactivate pins to sleep state */
2445 for (i = 0; i < card->num_rtd; i++) {
Benoit Cousson88bd8702014-07-08 23:19:34 +02002446 struct snd_soc_pcm_runtime *rtd = &card->rtd[i];
2447 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2448 int j;
2449
2450 for (j = 0; j < rtd->num_codecs; j++) {
2451 struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
2452 if (!codec_dai->active)
2453 pinctrl_pm_select_sleep_state(codec_dai->dev);
2454 }
2455
Nicolin Chen988e8cc2013-11-04 14:57:31 +08002456 if (!cpu_dai->active)
2457 pinctrl_pm_select_sleep_state(cpu_dai->dev);
2458 }
2459
Mark Brownb19e6e72012-03-14 21:18:39 +00002460 return ret;
Mark Brownc5af3a22008-11-28 13:29:45 +00002461}
Vinod Koul70a7ca32011-01-14 19:22:48 +05302462EXPORT_SYMBOL_GPL(snd_soc_register_card);
Mark Brownc5af3a22008-11-28 13:29:45 +00002463
2464/**
2465 * snd_soc_unregister_card - Unregister a card with the ASoC core
2466 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002467 * @card: Card to unregister
Mark Brownc5af3a22008-11-28 13:29:45 +00002468 *
Mark Brownc5af3a22008-11-28 13:29:45 +00002469 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05302470int snd_soc_unregister_card(struct snd_soc_card *card)
Mark Brownc5af3a22008-11-28 13:29:45 +00002471{
Lars-Peter Clausen01e0df62014-09-04 19:44:04 +02002472 if (card->instantiated) {
2473 card->instantiated = false;
Lars-Peter Clausen1c325f72014-09-04 19:44:05 +02002474 snd_soc_dapm_shutdown(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05302475 soc_cleanup_card_resources(card);
Kuninori Morimoto8f6f9b22015-02-05 05:34:10 +00002476 dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
Lars-Peter Clausen01e0df62014-09-04 19:44:04 +02002477 }
Mark Brownc5af3a22008-11-28 13:29:45 +00002478
2479 return 0;
2480}
Vinod Koul70a7ca32011-01-14 19:22:48 +05302481EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
Mark Brownc5af3a22008-11-28 13:29:45 +00002482
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002483/*
2484 * Simplify DAI link configuration by removing ".-1" from device names
2485 * and sanitizing names.
2486 */
Dimitris Papastamos0b9a2142010-12-06 15:49:20 +00002487static char *fmt_single_name(struct device *dev, int *id)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002488{
2489 char *found, name[NAME_SIZE];
2490 int id1, id2;
2491
2492 if (dev_name(dev) == NULL)
2493 return NULL;
2494
Dimitris Papastamos58818a72010-12-06 15:42:17 +00002495 strlcpy(name, dev_name(dev), NAME_SIZE);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002496
2497 /* are we a "%s.%d" name (platform and SPI components) */
2498 found = strstr(name, dev->driver->name);
2499 if (found) {
2500 /* get ID */
2501 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
2502
2503 /* discard ID from name if ID == -1 */
2504 if (*id == -1)
2505 found[strlen(dev->driver->name)] = '\0';
2506 }
2507
2508 } else {
2509 /* I2C component devices are named "bus-addr" */
2510 if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
2511 char tmp[NAME_SIZE];
2512
2513 /* create unique ID number from I2C addr and bus */
Jarkko Nikula05899442010-10-19 11:10:45 +03002514 *id = ((id1 & 0xffff) << 16) + id2;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002515
2516 /* sanitize component name for DAI link creation */
2517 snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
Dimitris Papastamos58818a72010-12-06 15:42:17 +00002518 strlcpy(name, tmp, NAME_SIZE);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002519 } else
2520 *id = 0;
2521 }
2522
2523 return kstrdup(name, GFP_KERNEL);
2524}
2525
2526/*
2527 * Simplify DAI link naming for single devices with multiple DAIs by removing
2528 * any ".-1" and using the DAI name (instead of device name).
2529 */
2530static inline char *fmt_multiple_name(struct device *dev,
2531 struct snd_soc_dai_driver *dai_drv)
2532{
2533 if (dai_drv->name == NULL) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02002534 dev_err(dev,
2535 "ASoC: error - multiple DAI %s registered with no name\n",
2536 dev_name(dev));
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002537 return NULL;
2538 }
2539
2540 return kstrdup(dai_drv->name, GFP_KERNEL);
2541}
2542
Mark Brown91151712008-11-30 23:31:24 +00002543/**
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002544 * snd_soc_unregister_dai - Unregister DAIs from the ASoC core
Mark Brown91151712008-11-30 23:31:24 +00002545 *
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002546 * @component: The component for which the DAIs should be unregistered
Mark Brown91151712008-11-30 23:31:24 +00002547 */
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002548static void snd_soc_unregister_dais(struct snd_soc_component *component)
Mark Brown91151712008-11-30 23:31:24 +00002549{
Lars-Peter Clausen5c1d5f02014-03-12 08:34:39 +01002550 struct snd_soc_dai *dai, *_dai;
Mark Brown91151712008-11-30 23:31:24 +00002551
Lars-Peter Clausen5c1d5f02014-03-12 08:34:39 +01002552 list_for_each_entry_safe(dai, _dai, &component->dai_list, list) {
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002553 dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",
2554 dai->name);
Lars-Peter Clausen5c1d5f02014-03-12 08:34:39 +01002555 list_del(&dai->list);
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002556 kfree(dai->name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002557 kfree(dai);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002558 }
Mark Brown91151712008-11-30 23:31:24 +00002559}
Mark Brown91151712008-11-30 23:31:24 +00002560
2561/**
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002562 * snd_soc_register_dais - Register a DAI with the ASoC core
Mark Brown91151712008-11-30 23:31:24 +00002563 *
Lars-Peter Clausen6106d122014-03-05 13:17:46 +01002564 * @component: The component the DAIs are registered for
2565 * @dai_drv: DAI driver to use for the DAIs
Mark Brownac11a2b2009-01-01 12:18:17 +00002566 * @count: Number of DAIs
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002567 * @legacy_dai_naming: Use the legacy naming scheme and let the DAI inherit the
2568 * parent's name.
Mark Brown91151712008-11-30 23:31:24 +00002569 */
Lars-Peter Clausen6106d122014-03-05 13:17:46 +01002570static int snd_soc_register_dais(struct snd_soc_component *component,
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002571 struct snd_soc_dai_driver *dai_drv, size_t count,
2572 bool legacy_dai_naming)
Mark Brown91151712008-11-30 23:31:24 +00002573{
Lars-Peter Clausen6106d122014-03-05 13:17:46 +01002574 struct device *dev = component->dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002575 struct snd_soc_dai *dai;
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002576 unsigned int i;
2577 int ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002578
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00002579 dev_dbg(dev, "ASoC: dai register %s #%Zu\n", dev_name(dev), count);
Mark Brown91151712008-11-30 23:31:24 +00002580
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002581 component->dai_drv = dai_drv;
2582 component->num_dai = count;
2583
Mark Brown91151712008-11-30 23:31:24 +00002584 for (i = 0; i < count; i++) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002585
2586 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
Axel Linc46e0072010-11-03 15:04:45 +08002587 if (dai == NULL) {
2588 ret = -ENOMEM;
2589 goto err;
2590 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002591
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002592 /*
2593 * Back in the old days when we still had component-less DAIs,
2594 * instead of having a static name, component-less DAIs would
2595 * inherit the name of the parent device so it is possible to
2596 * register multiple instances of the DAI. We still need to keep
2597 * the same naming style even though those DAIs are not
2598 * component-less anymore.
2599 */
Srinivas Kandagatla9e498082015-05-15 10:38:27 +01002600 if (count == 1 && legacy_dai_naming &&
2601 (dai_drv[i].id == 0 || dai_drv[i].name == NULL)) {
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002602 dai->name = fmt_single_name(dev, &dai->id);
2603 } else {
2604 dai->name = fmt_multiple_name(dev, &dai_drv[i]);
2605 if (dai_drv[i].id)
2606 dai->id = dai_drv[i].id;
2607 else
2608 dai->id = i;
2609 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002610 if (dai->name == NULL) {
2611 kfree(dai);
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002612 ret = -ENOMEM;
Mark Brown91151712008-11-30 23:31:24 +00002613 goto err;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002614 }
2615
Lars-Peter Clausen6106d122014-03-05 13:17:46 +01002616 dai->component = component;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002617 dai->dev = dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002618 dai->driver = &dai_drv[i];
2619 if (!dai->driver->ops)
2620 dai->driver->ops = &null_dai_ops;
2621
Lars-Peter Clausen1438c2f2014-03-09 17:41:47 +01002622 list_add(&dai->list, &component->dai_list);
Mark Brown054880f2012-04-09 17:29:19 +01002623
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002624 dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
Mark Brown91151712008-11-30 23:31:24 +00002625 }
2626
2627 return 0;
2628
2629err:
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002630 snd_soc_unregister_dais(component);
Mark Brown91151712008-11-30 23:31:24 +00002631
2632 return ret;
2633}
Mark Brown91151712008-11-30 23:31:24 +00002634
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002635static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context *dapm,
2636 enum snd_soc_dapm_type type, int subseq)
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002637{
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002638 struct snd_soc_component *component = dapm->component;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002639
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002640 component->driver->seq_notifier(component, type, subseq);
2641}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002642
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002643static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,
2644 int event)
2645{
2646 struct snd_soc_component *component = dapm->component;
2647
2648 return component->driver->stream_event(component, event);
2649}
2650
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002651static int snd_soc_component_initialize(struct snd_soc_component *component,
2652 const struct snd_soc_component_driver *driver, struct device *dev)
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002653{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02002654 struct snd_soc_dapm_context *dapm;
2655
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002656 component->name = fmt_single_name(dev, &component->id);
2657 if (!component->name) {
2658 dev_err(dev, "ASoC: Failed to allocate name\n");
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002659 return -ENOMEM;
2660 }
2661
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002662 component->dev = dev;
2663 component->driver = driver;
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02002664 component->probe = component->driver->probe;
2665 component->remove = component->driver->remove;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002666
Lars-Peter Clausen48901402015-07-06 15:38:11 +02002667 dapm = &component->dapm;
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02002668 dapm->dev = dev;
2669 dapm->component = component;
2670 dapm->bias_level = SND_SOC_BIAS_OFF;
Lars-Peter Clausen5819c2f2014-08-24 15:36:55 +02002671 dapm->idle_bias_off = true;
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002672 if (driver->seq_notifier)
2673 dapm->seq_notifier = snd_soc_component_seq_notifier;
2674 if (driver->stream_event)
2675 dapm->stream_event = snd_soc_component_stream_event;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002676
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02002677 component->controls = driver->controls;
2678 component->num_controls = driver->num_controls;
2679 component->dapm_widgets = driver->dapm_widgets;
2680 component->num_dapm_widgets = driver->num_dapm_widgets;
2681 component->dapm_routes = driver->dapm_routes;
2682 component->num_dapm_routes = driver->num_dapm_routes;
2683
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002684 INIT_LIST_HEAD(&component->dai_list);
2685 mutex_init(&component->io_mutex);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002686
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002687 return 0;
2688}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002689
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01002690static void snd_soc_component_setup_regmap(struct snd_soc_component *component)
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02002691{
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01002692 int val_bytes = regmap_get_val_bytes(component->regmap);
2693
2694 /* Errors are legitimate for non-integer byte multiples */
2695 if (val_bytes > 0)
2696 component->val_bytes = val_bytes;
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02002697}
2698
Lars-Peter Clausene874bf52014-11-25 21:41:03 +01002699#ifdef CONFIG_REGMAP
2700
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01002701/**
2702 * snd_soc_component_init_regmap() - Initialize regmap instance for the component
2703 * @component: The component for which to initialize the regmap instance
2704 * @regmap: The regmap instance that should be used by the component
2705 *
2706 * This function allows deferred assignment of the regmap instance that is
2707 * associated with the component. Only use this if the regmap instance is not
2708 * yet ready when the component is registered. The function must also be called
2709 * before the first IO attempt of the component.
2710 */
2711void snd_soc_component_init_regmap(struct snd_soc_component *component,
2712 struct regmap *regmap)
2713{
2714 component->regmap = regmap;
2715 snd_soc_component_setup_regmap(component);
2716}
2717EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap);
2718
2719/**
2720 * snd_soc_component_exit_regmap() - De-initialize regmap instance for the component
2721 * @component: The component for which to de-initialize the regmap instance
2722 *
2723 * Calls regmap_exit() on the regmap instance associated to the component and
2724 * removes the regmap instance from the component.
2725 *
2726 * This function should only be used if snd_soc_component_init_regmap() was used
2727 * to initialize the regmap instance.
2728 */
2729void snd_soc_component_exit_regmap(struct snd_soc_component *component)
2730{
2731 regmap_exit(component->regmap);
2732 component->regmap = NULL;
2733}
2734EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap);
2735
Lars-Peter Clausene874bf52014-11-25 21:41:03 +01002736#endif
2737
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002738static void snd_soc_component_add_unlocked(struct snd_soc_component *component)
2739{
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01002740 if (!component->write && !component->read) {
2741 if (!component->regmap)
2742 component->regmap = dev_get_regmap(component->dev, NULL);
2743 if (component->regmap)
2744 snd_soc_component_setup_regmap(component);
2745 }
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02002746
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002747 list_add(&component->list, &component_list);
Liam Girdwood8a978232015-05-29 19:06:14 +01002748 INIT_LIST_HEAD(&component->dobj_list);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002749}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002750
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002751static void snd_soc_component_add(struct snd_soc_component *component)
2752{
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002753 mutex_lock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002754 snd_soc_component_add_unlocked(component);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002755 mutex_unlock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002756}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002757
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002758static void snd_soc_component_cleanup(struct snd_soc_component *component)
2759{
2760 snd_soc_unregister_dais(component);
2761 kfree(component->name);
2762}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002763
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002764static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
2765{
2766 list_del(&component->list);
2767}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002768
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002769int snd_soc_register_component(struct device *dev,
2770 const struct snd_soc_component_driver *cmpnt_drv,
2771 struct snd_soc_dai_driver *dai_drv,
2772 int num_dai)
2773{
2774 struct snd_soc_component *cmpnt;
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002775 int ret;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002776
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002777 cmpnt = kzalloc(sizeof(*cmpnt), GFP_KERNEL);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002778 if (!cmpnt) {
2779 dev_err(dev, "ASoC: Failed to allocate memory\n");
2780 return -ENOMEM;
2781 }
2782
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002783 ret = snd_soc_component_initialize(cmpnt, cmpnt_drv, dev);
2784 if (ret)
2785 goto err_free;
2786
Lars-Peter Clausen3d594002014-03-05 13:17:48 +01002787 cmpnt->ignore_pmdown_time = true;
Lars-Peter Clausen98e639f2014-03-18 09:02:11 +01002788 cmpnt->registered_as_component = true;
Lars-Peter Clausen3d594002014-03-05 13:17:48 +01002789
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002790 ret = snd_soc_register_dais(cmpnt, dai_drv, num_dai, true);
2791 if (ret < 0) {
Masanari Iidaf42cf8d2015-02-24 23:11:26 +09002792 dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002793 goto err_cleanup;
2794 }
2795
2796 snd_soc_component_add(cmpnt);
2797
2798 return 0;
2799
2800err_cleanup:
2801 snd_soc_component_cleanup(cmpnt);
2802err_free:
2803 kfree(cmpnt);
2804 return ret;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002805}
2806EXPORT_SYMBOL_GPL(snd_soc_register_component);
2807
2808/**
2809 * snd_soc_unregister_component - Unregister a component from the ASoC core
2810 *
Jonathan Corbet628536e2015-08-25 01:14:48 -06002811 * @dev: The device to unregister
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002812 */
2813void snd_soc_unregister_component(struct device *dev)
2814{
2815 struct snd_soc_component *cmpnt;
2816
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002817 mutex_lock(&client_mutex);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002818 list_for_each_entry(cmpnt, &component_list, list) {
Lars-Peter Clausen98e639f2014-03-18 09:02:11 +01002819 if (dev == cmpnt->dev && cmpnt->registered_as_component)
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002820 goto found;
2821 }
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002822 mutex_unlock(&client_mutex);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002823 return;
2824
2825found:
Liam Girdwood8a978232015-05-29 19:06:14 +01002826 snd_soc_tplg_component_remove(cmpnt, SND_SOC_TPLG_INDEX_ALL);
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002827 snd_soc_component_del_unlocked(cmpnt);
2828 mutex_unlock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002829 snd_soc_component_cleanup(cmpnt);
2830 kfree(cmpnt);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002831}
2832EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
2833
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02002834static int snd_soc_platform_drv_probe(struct snd_soc_component *component)
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002835{
2836 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
2837
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02002838 return platform->driver->probe(platform);
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002839}
2840
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02002841static void snd_soc_platform_drv_remove(struct snd_soc_component *component)
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002842{
2843 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
2844
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02002845 platform->driver->remove(platform);
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002846}
2847
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002848/**
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002849 * snd_soc_add_platform - Add a platform to the ASoC core
2850 * @dev: The parent device for the platform
2851 * @platform: The platform to add
Masanari Iida7d1442b2015-07-15 23:02:39 +09002852 * @platform_drv: The driver for the platform
Mark Brown12a48a8c2008-12-03 19:40:30 +00002853 */
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002854int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
Lars-Peter Clausend79e57d2013-03-27 12:02:22 +01002855 const struct snd_soc_platform_driver *platform_drv)
Mark Brown12a48a8c2008-12-03 19:40:30 +00002856{
Lars-Peter Clausenb37f1d12014-03-18 09:02:12 +01002857 int ret;
2858
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002859 ret = snd_soc_component_initialize(&platform->component,
2860 &platform_drv->component_driver, dev);
2861 if (ret)
2862 return ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002863
2864 platform->dev = dev;
2865 platform->driver = platform_drv;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02002866
2867 if (platform_drv->probe)
2868 platform->component.probe = snd_soc_platform_drv_probe;
2869 if (platform_drv->remove)
2870 platform->component.remove = snd_soc_platform_drv_remove;
Mark Brown12a48a8c2008-12-03 19:40:30 +00002871
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +02002872#ifdef CONFIG_DEBUG_FS
2873 platform->component.debugfs_prefix = "platform";
2874#endif
Mark Brown12a48a8c2008-12-03 19:40:30 +00002875
2876 mutex_lock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002877 snd_soc_component_add_unlocked(&platform->component);
Mark Brown12a48a8c2008-12-03 19:40:30 +00002878 list_add(&platform->list, &platform_list);
2879 mutex_unlock(&client_mutex);
2880
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02002881 dev_dbg(dev, "ASoC: Registered platform '%s'\n",
2882 platform->component.name);
Mark Brown12a48a8c2008-12-03 19:40:30 +00002883
2884 return 0;
2885}
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002886EXPORT_SYMBOL_GPL(snd_soc_add_platform);
2887
2888/**
2889 * snd_soc_register_platform - Register a platform with the ASoC core
2890 *
Jonathan Corbet628536e2015-08-25 01:14:48 -06002891 * @dev: The device for the platform
2892 * @platform_drv: The driver for the platform
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002893 */
2894int snd_soc_register_platform(struct device *dev,
2895 const struct snd_soc_platform_driver *platform_drv)
2896{
2897 struct snd_soc_platform *platform;
2898 int ret;
2899
2900 dev_dbg(dev, "ASoC: platform register %s\n", dev_name(dev));
2901
2902 platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
2903 if (platform == NULL)
2904 return -ENOMEM;
2905
2906 ret = snd_soc_add_platform(dev, platform, platform_drv);
2907 if (ret)
2908 kfree(platform);
2909
2910 return ret;
2911}
Mark Brown12a48a8c2008-12-03 19:40:30 +00002912EXPORT_SYMBOL_GPL(snd_soc_register_platform);
2913
2914/**
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002915 * snd_soc_remove_platform - Remove a platform from the ASoC core
2916 * @platform: the platform to remove
2917 */
2918void snd_soc_remove_platform(struct snd_soc_platform *platform)
2919{
Lars-Peter Clausenb37f1d12014-03-18 09:02:12 +01002920
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002921 mutex_lock(&client_mutex);
2922 list_del(&platform->list);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002923 snd_soc_component_del_unlocked(&platform->component);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002924 mutex_unlock(&client_mutex);
2925
2926 dev_dbg(platform->dev, "ASoC: Unregistered platform '%s'\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02002927 platform->component.name);
Daniel Mackdecc27b2014-10-07 13:41:23 +02002928
2929 snd_soc_component_cleanup(&platform->component);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002930}
2931EXPORT_SYMBOL_GPL(snd_soc_remove_platform);
2932
2933struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev)
2934{
2935 struct snd_soc_platform *platform;
2936
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002937 mutex_lock(&client_mutex);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002938 list_for_each_entry(platform, &platform_list, list) {
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002939 if (dev == platform->dev) {
2940 mutex_unlock(&client_mutex);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002941 return platform;
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002942 }
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002943 }
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002944 mutex_unlock(&client_mutex);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002945
2946 return NULL;
2947}
2948EXPORT_SYMBOL_GPL(snd_soc_lookup_platform);
2949
2950/**
Mark Brown12a48a8c2008-12-03 19:40:30 +00002951 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
2952 *
Jonathan Corbet628536e2015-08-25 01:14:48 -06002953 * @dev: platform to unregister
Mark Brown12a48a8c2008-12-03 19:40:30 +00002954 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002955void snd_soc_unregister_platform(struct device *dev)
Mark Brown12a48a8c2008-12-03 19:40:30 +00002956{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002957 struct snd_soc_platform *platform;
2958
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002959 platform = snd_soc_lookup_platform(dev);
2960 if (!platform)
2961 return;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002962
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02002963 snd_soc_remove_platform(platform);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002964 kfree(platform);
Mark Brown12a48a8c2008-12-03 19:40:30 +00002965}
2966EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
2967
Mark Brown151ab222009-05-09 16:22:58 +01002968static u64 codec_format_map[] = {
2969 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
2970 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
2971 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
2972 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
2973 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
2974 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
2975 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
2976 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
2977 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
2978 SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
2979 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
2980 SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
2981 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
2982 SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
2983 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
2984 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
2985};
2986
2987/* Fix up the DAI formats for endianness: codecs don't actually see
2988 * the endianness of the data but we're using the CPU format
2989 * definitions which do need to include endianness so we ensure that
2990 * codec DAIs always have both big and little endian variants set.
2991 */
2992static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
2993{
2994 int i;
2995
2996 for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
2997 if (stream->formats & codec_format_map[i])
2998 stream->formats |= codec_format_map[i];
2999}
3000
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003001static int snd_soc_codec_drv_probe(struct snd_soc_component *component)
3002{
3003 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3004
3005 return codec->driver->probe(codec);
3006}
3007
3008static void snd_soc_codec_drv_remove(struct snd_soc_component *component)
3009{
3010 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3011
3012 codec->driver->remove(codec);
3013}
3014
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003015static int snd_soc_codec_drv_write(struct snd_soc_component *component,
3016 unsigned int reg, unsigned int val)
3017{
3018 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3019
3020 return codec->driver->write(codec, reg, val);
3021}
3022
3023static int snd_soc_codec_drv_read(struct snd_soc_component *component,
3024 unsigned int reg, unsigned int *val)
3025{
3026 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3027
3028 *val = codec->driver->read(codec, reg);
3029
3030 return 0;
3031}
3032
Lars-Peter Clausen68f831c2014-06-16 18:13:05 +02003033static int snd_soc_codec_set_bias_level(struct snd_soc_dapm_context *dapm,
3034 enum snd_soc_bias_level level)
3035{
3036 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
3037
3038 return codec->driver->set_bias_level(codec, level);
3039}
3040
Mark Brown0d0cf002008-12-10 14:32:45 +00003041/**
3042 * snd_soc_register_codec - Register a codec with the ASoC core
3043 *
Jonathan Corbet628536e2015-08-25 01:14:48 -06003044 * @dev: The parent device for this codec
3045 * @codec_drv: Codec driver
3046 * @dai_drv: The associated DAI driver
3047 * @num_dai: Number of DAIs
Mark Brown0d0cf002008-12-10 14:32:45 +00003048 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003049int snd_soc_register_codec(struct device *dev,
Mark Brown001ae4c2010-12-02 16:21:08 +00003050 const struct snd_soc_codec_driver *codec_drv,
3051 struct snd_soc_dai_driver *dai_drv,
3052 int num_dai)
Mark Brown0d0cf002008-12-10 14:32:45 +00003053{
Lars-Peter Clausen48901402015-07-06 15:38:11 +02003054 struct snd_soc_dapm_context *dapm;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003055 struct snd_soc_codec *codec;
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003056 struct snd_soc_dai *dai;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003057 int ret, i;
Mark Brown151ab222009-05-09 16:22:58 +01003058
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003059 dev_dbg(dev, "codec register %s\n", dev_name(dev));
Mark Brown0d0cf002008-12-10 14:32:45 +00003060
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003061 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
3062 if (codec == NULL)
3063 return -ENOMEM;
Mark Brown0d0cf002008-12-10 14:32:45 +00003064
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003065 codec->component.codec = codec;
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003066
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003067 ret = snd_soc_component_initialize(&codec->component,
3068 &codec_drv->component_driver, dev);
3069 if (ret)
3070 goto err_free;
Mark Brown151ab222009-05-09 16:22:58 +01003071
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003072 if (codec_drv->controls) {
3073 codec->component.controls = codec_drv->controls;
3074 codec->component.num_controls = codec_drv->num_controls;
3075 }
3076 if (codec_drv->dapm_widgets) {
3077 codec->component.dapm_widgets = codec_drv->dapm_widgets;
3078 codec->component.num_dapm_widgets = codec_drv->num_dapm_widgets;
3079 }
3080 if (codec_drv->dapm_routes) {
3081 codec->component.dapm_routes = codec_drv->dapm_routes;
3082 codec->component.num_dapm_routes = codec_drv->num_dapm_routes;
3083 }
3084
3085 if (codec_drv->probe)
3086 codec->component.probe = snd_soc_codec_drv_probe;
3087 if (codec_drv->remove)
3088 codec->component.remove = snd_soc_codec_drv_remove;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003089 if (codec_drv->write)
3090 codec->component.write = snd_soc_codec_drv_write;
3091 if (codec_drv->read)
3092 codec->component.read = snd_soc_codec_drv_read;
Lars-Peter Clausen3d594002014-03-05 13:17:48 +01003093 codec->component.ignore_pmdown_time = codec_drv->ignore_pmdown_time;
Lars-Peter Clausen48901402015-07-06 15:38:11 +02003094
3095 dapm = snd_soc_codec_get_dapm(codec);
3096 dapm->idle_bias_off = codec_drv->idle_bias_off;
3097 dapm->suspend_bias_off = codec_drv->suspend_bias_off;
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02003098 if (codec_drv->seq_notifier)
Lars-Peter Clausen48901402015-07-06 15:38:11 +02003099 dapm->seq_notifier = codec_drv->seq_notifier;
Lars-Peter Clausen68f831c2014-06-16 18:13:05 +02003100 if (codec_drv->set_bias_level)
Lars-Peter Clausen48901402015-07-06 15:38:11 +02003101 dapm->set_bias_level = snd_soc_codec_set_bias_level;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003102 codec->dev = dev;
3103 codec->driver = codec_drv;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003104 codec->component.val_bytes = codec_drv->reg_word_size;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003105
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +02003106#ifdef CONFIG_DEBUG_FS
3107 codec->component.init_debugfs = soc_init_codec_debugfs;
3108 codec->component.debugfs_prefix = "codec";
3109#endif
Xiubo Lia39f75f2014-03-26 13:40:23 +08003110
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02003111 if (codec_drv->get_regmap)
3112 codec->component.regmap = codec_drv->get_regmap(dev);
Xiubo Lia39f75f2014-03-26 13:40:23 +08003113
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003114 for (i = 0; i < num_dai; i++) {
3115 fixup_codec_formats(&dai_drv[i].playback);
3116 fixup_codec_formats(&dai_drv[i].capture);
3117 }
3118
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003119 ret = snd_soc_register_dais(&codec->component, dai_drv, num_dai, false);
3120 if (ret < 0) {
Masanari Iidaf42cf8d2015-02-24 23:11:26 +09003121 dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003122 goto err_cleanup;
3123 }
3124
3125 list_for_each_entry(dai, &codec->component.dai_list, list)
3126 dai->codec = codec;
3127
Mark Brown054880f2012-04-09 17:29:19 +01003128 mutex_lock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003129 snd_soc_component_add_unlocked(&codec->component);
Mark Brown054880f2012-04-09 17:29:19 +01003130 list_add(&codec->list, &codec_list);
3131 mutex_unlock(&client_mutex);
3132
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003133 dev_dbg(codec->dev, "ASoC: Registered codec '%s'\n",
3134 codec->component.name);
Mark Brown0d0cf002008-12-10 14:32:45 +00003135 return 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003136
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003137err_cleanup:
3138 snd_soc_component_cleanup(&codec->component);
3139err_free:
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003140 kfree(codec);
3141 return ret;
Mark Brown0d0cf002008-12-10 14:32:45 +00003142}
3143EXPORT_SYMBOL_GPL(snd_soc_register_codec);
3144
3145/**
3146 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
3147 *
Jonathan Corbet628536e2015-08-25 01:14:48 -06003148 * @dev: codec to unregister
Mark Brown0d0cf002008-12-10 14:32:45 +00003149 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003150void snd_soc_unregister_codec(struct device *dev)
Mark Brown0d0cf002008-12-10 14:32:45 +00003151{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003152 struct snd_soc_codec *codec;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003153
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003154 mutex_lock(&client_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003155 list_for_each_entry(codec, &codec_list, list) {
3156 if (dev == codec->dev)
3157 goto found;
3158 }
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003159 mutex_unlock(&client_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003160 return;
3161
3162found:
Mark Brown0d0cf002008-12-10 14:32:45 +00003163 list_del(&codec->list);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003164 snd_soc_component_del_unlocked(&codec->component);
Mark Brown0d0cf002008-12-10 14:32:45 +00003165 mutex_unlock(&client_mutex);
3166
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003167 dev_dbg(codec->dev, "ASoC: Unregistered codec '%s'\n",
3168 codec->component.name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003169
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003170 snd_soc_component_cleanup(&codec->component);
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003171 snd_soc_cache_exit(codec);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003172 kfree(codec);
Mark Brown0d0cf002008-12-10 14:32:45 +00003173}
3174EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
3175
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003176/* Retrieve a card's name from device tree */
3177int snd_soc_of_parse_card_name(struct snd_soc_card *card,
3178 const char *propname)
3179{
Tushar Behera7e07e7c2014-07-04 14:23:00 +05303180 struct device_node *np;
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003181 int ret;
3182
Tushar Behera7e07e7c2014-07-04 14:23:00 +05303183 if (!card->dev) {
3184 pr_err("card->dev is not set before calling %s\n", __func__);
3185 return -EINVAL;
3186 }
3187
3188 np = card->dev->of_node;
3189
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003190 ret = of_property_read_string_index(np, propname, 0, &card->name);
3191 /*
3192 * EINVAL means the property does not exist. This is fine providing
3193 * card->name was previously set, which is checked later in
3194 * snd_soc_register_card.
3195 */
3196 if (ret < 0 && ret != -EINVAL) {
3197 dev_err(card->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00003198 "ASoC: Property '%s' could not be read: %d\n",
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003199 propname, ret);
3200 return ret;
3201 }
3202
3203 return 0;
3204}
3205EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
3206
Xiubo Li9a6d4862014-02-08 15:59:52 +08003207static const struct snd_soc_dapm_widget simple_widgets[] = {
3208 SND_SOC_DAPM_MIC("Microphone", NULL),
3209 SND_SOC_DAPM_LINE("Line", NULL),
3210 SND_SOC_DAPM_HP("Headphone", NULL),
3211 SND_SOC_DAPM_SPK("Speaker", NULL),
3212};
3213
3214int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
3215 const char *propname)
3216{
3217 struct device_node *np = card->dev->of_node;
3218 struct snd_soc_dapm_widget *widgets;
3219 const char *template, *wname;
3220 int i, j, num_widgets, ret;
3221
3222 num_widgets = of_property_count_strings(np, propname);
3223 if (num_widgets < 0) {
3224 dev_err(card->dev,
3225 "ASoC: Property '%s' does not exist\n", propname);
3226 return -EINVAL;
3227 }
3228 if (num_widgets & 1) {
3229 dev_err(card->dev,
3230 "ASoC: Property '%s' length is not even\n", propname);
3231 return -EINVAL;
3232 }
3233
3234 num_widgets /= 2;
3235 if (!num_widgets) {
3236 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
3237 propname);
3238 return -EINVAL;
3239 }
3240
3241 widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets),
3242 GFP_KERNEL);
3243 if (!widgets) {
3244 dev_err(card->dev,
3245 "ASoC: Could not allocate memory for widgets\n");
3246 return -ENOMEM;
3247 }
3248
3249 for (i = 0; i < num_widgets; i++) {
3250 ret = of_property_read_string_index(np, propname,
3251 2 * i, &template);
3252 if (ret) {
3253 dev_err(card->dev,
3254 "ASoC: Property '%s' index %d read error:%d\n",
3255 propname, 2 * i, ret);
3256 return -EINVAL;
3257 }
3258
3259 for (j = 0; j < ARRAY_SIZE(simple_widgets); j++) {
3260 if (!strncmp(template, simple_widgets[j].name,
3261 strlen(simple_widgets[j].name))) {
3262 widgets[i] = simple_widgets[j];
3263 break;
3264 }
3265 }
3266
3267 if (j >= ARRAY_SIZE(simple_widgets)) {
3268 dev_err(card->dev,
3269 "ASoC: DAPM widget '%s' is not supported\n",
3270 template);
3271 return -EINVAL;
3272 }
3273
3274 ret = of_property_read_string_index(np, propname,
3275 (2 * i) + 1,
3276 &wname);
3277 if (ret) {
3278 dev_err(card->dev,
3279 "ASoC: Property '%s' index %d read error:%d\n",
3280 propname, (2 * i) + 1, ret);
3281 return -EINVAL;
3282 }
3283
3284 widgets[i].name = wname;
3285 }
3286
Nicolin Chenf23e8602015-02-14 17:22:49 -08003287 card->of_dapm_widgets = widgets;
3288 card->num_of_dapm_widgets = num_widgets;
Xiubo Li9a6d4862014-02-08 15:59:52 +08003289
3290 return 0;
3291}
3292EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets);
3293
Jyri Sarha61310842015-09-09 21:27:43 +03003294static int snd_soc_of_get_slot_mask(struct device_node *np,
3295 const char *prop_name,
3296 unsigned int *mask)
3297{
3298 u32 val;
Jyri Sarha6c84e5912015-09-17 13:13:38 +03003299 const __be32 *of_slot_mask = of_get_property(np, prop_name, &val);
Jyri Sarha61310842015-09-09 21:27:43 +03003300 int i;
3301
3302 if (!of_slot_mask)
3303 return 0;
3304 val /= sizeof(u32);
3305 for (i = 0; i < val; i++)
3306 if (be32_to_cpup(&of_slot_mask[i]))
3307 *mask |= (1 << i);
3308
3309 return val;
3310}
3311
Xiubo Li89c67852014-02-14 09:34:35 +08003312int snd_soc_of_parse_tdm_slot(struct device_node *np,
Jyri Sarha61310842015-09-09 21:27:43 +03003313 unsigned int *tx_mask,
3314 unsigned int *rx_mask,
Xiubo Li89c67852014-02-14 09:34:35 +08003315 unsigned int *slots,
3316 unsigned int *slot_width)
3317{
3318 u32 val;
3319 int ret;
3320
Jyri Sarha61310842015-09-09 21:27:43 +03003321 if (tx_mask)
3322 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask", tx_mask);
3323 if (rx_mask)
3324 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask", rx_mask);
3325
Xiubo Li89c67852014-02-14 09:34:35 +08003326 if (of_property_read_bool(np, "dai-tdm-slot-num")) {
3327 ret = of_property_read_u32(np, "dai-tdm-slot-num", &val);
3328 if (ret)
3329 return ret;
3330
3331 if (slots)
3332 *slots = val;
3333 }
3334
3335 if (of_property_read_bool(np, "dai-tdm-slot-width")) {
3336 ret = of_property_read_u32(np, "dai-tdm-slot-width", &val);
3337 if (ret)
3338 return ret;
3339
3340 if (slot_width)
3341 *slot_width = val;
3342 }
3343
3344 return 0;
3345}
3346EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot);
3347
Kuninori Morimoto5e3cdaa2015-07-15 07:07:42 +00003348void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
3349 struct snd_soc_codec_conf *codec_conf,
3350 struct device_node *of_node,
3351 const char *propname)
3352{
3353 struct device_node *np = card->dev->of_node;
3354 const char *str;
3355 int ret;
3356
3357 ret = of_property_read_string(np, propname, &str);
3358 if (ret < 0) {
3359 /* no prefix is not error */
3360 return;
3361 }
3362
3363 codec_conf->of_node = of_node;
3364 codec_conf->name_prefix = str;
3365}
3366EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_prefix);
3367
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003368int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
3369 const char *propname)
3370{
3371 struct device_node *np = card->dev->of_node;
Mark Browne3b1e6a2014-12-18 11:46:38 +00003372 int num_routes;
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003373 struct snd_soc_dapm_route *routes;
3374 int i, ret;
3375
3376 num_routes = of_property_count_strings(np, propname);
Richard Zhaoc34ce322012-04-24 15:24:43 +08003377 if (num_routes < 0 || num_routes & 1) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02003378 dev_err(card->dev,
3379 "ASoC: Property '%s' does not exist or its length is not even\n",
3380 propname);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003381 return -EINVAL;
3382 }
3383 num_routes /= 2;
3384 if (!num_routes) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00003385 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003386 propname);
3387 return -EINVAL;
3388 }
3389
Mark Browne3b1e6a2014-12-18 11:46:38 +00003390 routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003391 GFP_KERNEL);
3392 if (!routes) {
3393 dev_err(card->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00003394 "ASoC: Could not allocate DAPM route table\n");
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003395 return -EINVAL;
3396 }
3397
3398 for (i = 0; i < num_routes; i++) {
3399 ret = of_property_read_string_index(np, propname,
Mark Browne3b1e6a2014-12-18 11:46:38 +00003400 2 * i, &routes[i].sink);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003401 if (ret) {
Mark Brownc871bd02012-12-10 16:19:52 +09003402 dev_err(card->dev,
3403 "ASoC: Property '%s' index %d could not be read: %d\n",
3404 propname, 2 * i, ret);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003405 return -EINVAL;
3406 }
3407 ret = of_property_read_string_index(np, propname,
Mark Browne3b1e6a2014-12-18 11:46:38 +00003408 (2 * i) + 1, &routes[i].source);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003409 if (ret) {
3410 dev_err(card->dev,
Mark Brownc871bd02012-12-10 16:19:52 +09003411 "ASoC: Property '%s' index %d could not be read: %d\n",
3412 propname, (2 * i) + 1, ret);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003413 return -EINVAL;
3414 }
3415 }
3416
Nicolin Chenf23e8602015-02-14 17:22:49 -08003417 card->num_of_dapm_routes = num_routes;
3418 card->of_dapm_routes = routes;
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003419
3420 return 0;
3421}
3422EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
3423
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003424unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
Jyri Sarha389cb832014-03-24 12:15:24 +02003425 const char *prefix,
3426 struct device_node **bitclkmaster,
3427 struct device_node **framemaster)
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003428{
3429 int ret, i;
3430 char prop[128];
3431 unsigned int format = 0;
3432 int bit, frame;
3433 const char *str;
3434 struct {
3435 char *name;
3436 unsigned int val;
3437 } of_fmt_table[] = {
3438 { "i2s", SND_SOC_DAIFMT_I2S },
3439 { "right_j", SND_SOC_DAIFMT_RIGHT_J },
3440 { "left_j", SND_SOC_DAIFMT_LEFT_J },
3441 { "dsp_a", SND_SOC_DAIFMT_DSP_A },
3442 { "dsp_b", SND_SOC_DAIFMT_DSP_B },
3443 { "ac97", SND_SOC_DAIFMT_AC97 },
3444 { "pdm", SND_SOC_DAIFMT_PDM},
3445 { "msb", SND_SOC_DAIFMT_MSB },
3446 { "lsb", SND_SOC_DAIFMT_LSB },
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003447 };
3448
3449 if (!prefix)
3450 prefix = "";
3451
3452 /*
3453 * check "[prefix]format = xxx"
3454 * SND_SOC_DAIFMT_FORMAT_MASK area
3455 */
3456 snprintf(prop, sizeof(prop), "%sformat", prefix);
3457 ret = of_property_read_string(np, prop, &str);
3458 if (ret == 0) {
3459 for (i = 0; i < ARRAY_SIZE(of_fmt_table); i++) {
3460 if (strcmp(str, of_fmt_table[i].name) == 0) {
3461 format |= of_fmt_table[i].val;
3462 break;
3463 }
3464 }
3465 }
3466
3467 /*
Kuninori Morimoto8c2d6a92013-01-29 21:03:36 -08003468 * check "[prefix]continuous-clock"
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003469 * SND_SOC_DAIFMT_CLOCK_MASK area
3470 */
Kuninori Morimoto8c2d6a92013-01-29 21:03:36 -08003471 snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix);
3472 if (of_get_property(np, prop, NULL))
3473 format |= SND_SOC_DAIFMT_CONT;
3474 else
3475 format |= SND_SOC_DAIFMT_GATED;
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003476
3477 /*
3478 * check "[prefix]bitclock-inversion"
3479 * check "[prefix]frame-inversion"
3480 * SND_SOC_DAIFMT_INV_MASK area
3481 */
3482 snprintf(prop, sizeof(prop), "%sbitclock-inversion", prefix);
3483 bit = !!of_get_property(np, prop, NULL);
3484
3485 snprintf(prop, sizeof(prop), "%sframe-inversion", prefix);
3486 frame = !!of_get_property(np, prop, NULL);
3487
3488 switch ((bit << 4) + frame) {
3489 case 0x11:
3490 format |= SND_SOC_DAIFMT_IB_IF;
3491 break;
3492 case 0x10:
3493 format |= SND_SOC_DAIFMT_IB_NF;
3494 break;
3495 case 0x01:
3496 format |= SND_SOC_DAIFMT_NB_IF;
3497 break;
3498 default:
3499 /* SND_SOC_DAIFMT_NB_NF is default */
3500 break;
3501 }
3502
3503 /*
3504 * check "[prefix]bitclock-master"
3505 * check "[prefix]frame-master"
3506 * SND_SOC_DAIFMT_MASTER_MASK area
3507 */
3508 snprintf(prop, sizeof(prop), "%sbitclock-master", prefix);
3509 bit = !!of_get_property(np, prop, NULL);
Jyri Sarha389cb832014-03-24 12:15:24 +02003510 if (bit && bitclkmaster)
3511 *bitclkmaster = of_parse_phandle(np, prop, 0);
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003512
3513 snprintf(prop, sizeof(prop), "%sframe-master", prefix);
3514 frame = !!of_get_property(np, prop, NULL);
Jyri Sarha389cb832014-03-24 12:15:24 +02003515 if (frame && framemaster)
3516 *framemaster = of_parse_phandle(np, prop, 0);
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003517
3518 switch ((bit << 4) + frame) {
3519 case 0x11:
3520 format |= SND_SOC_DAIFMT_CBM_CFM;
3521 break;
3522 case 0x10:
3523 format |= SND_SOC_DAIFMT_CBM_CFS;
3524 break;
3525 case 0x01:
3526 format |= SND_SOC_DAIFMT_CBS_CFM;
3527 break;
3528 default:
3529 format |= SND_SOC_DAIFMT_CBS_CFS;
3530 break;
3531 }
3532
3533 return format;
3534}
3535EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt);
3536
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003537static int snd_soc_get_dai_name(struct of_phandle_args *args,
3538 const char **dai_name)
Kuninori Morimotocb470082013-09-10 17:39:56 -07003539{
3540 struct snd_soc_component *pos;
Jyri Sarha3e0aa8d2015-05-26 21:59:05 +03003541 struct device_node *component_of_node;
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003542 int ret = -EPROBE_DEFER;
Kuninori Morimotocb470082013-09-10 17:39:56 -07003543
3544 mutex_lock(&client_mutex);
3545 list_for_each_entry(pos, &component_list, list) {
Jyri Sarha3e0aa8d2015-05-26 21:59:05 +03003546 component_of_node = pos->dev->of_node;
3547 if (!component_of_node && pos->dev->parent)
3548 component_of_node = pos->dev->parent->of_node;
3549
3550 if (component_of_node != args->np)
Kuninori Morimotocb470082013-09-10 17:39:56 -07003551 continue;
3552
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003553 if (pos->driver->of_xlate_dai_name) {
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003554 ret = pos->driver->of_xlate_dai_name(pos,
3555 args,
3556 dai_name);
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003557 } else {
3558 int id = -1;
3559
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003560 switch (args->args_count) {
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003561 case 0:
3562 id = 0; /* same as dai_drv[0] */
3563 break;
3564 case 1:
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003565 id = args->args[0];
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003566 break;
3567 default:
3568 /* not supported */
3569 break;
3570 }
3571
3572 if (id < 0 || id >= pos->num_dai) {
3573 ret = -EINVAL;
Nicolin Chen3dcba282014-04-21 19:14:46 +08003574 continue;
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003575 }
Xiubo Lie41975e2013-12-20 14:39:51 +08003576
3577 ret = 0;
3578
3579 *dai_name = pos->dai_drv[id].name;
3580 if (!*dai_name)
3581 *dai_name = pos->name;
Kuninori Morimotocb470082013-09-10 17:39:56 -07003582 }
3583
Kuninori Morimotocb470082013-09-10 17:39:56 -07003584 break;
3585 }
3586 mutex_unlock(&client_mutex);
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003587 return ret;
3588}
3589
3590int snd_soc_of_get_dai_name(struct device_node *of_node,
3591 const char **dai_name)
3592{
3593 struct of_phandle_args args;
3594 int ret;
3595
3596 ret = of_parse_phandle_with_args(of_node, "sound-dai",
3597 "#sound-dai-cells", 0, &args);
3598 if (ret)
3599 return ret;
3600
3601 ret = snd_soc_get_dai_name(&args, dai_name);
Kuninori Morimotocb470082013-09-10 17:39:56 -07003602
3603 of_node_put(args.np);
3604
3605 return ret;
3606}
3607EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name);
3608
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003609/*
3610 * snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree
3611 * @dev: Card device
3612 * @of_node: Device node
3613 * @dai_link: DAI link
3614 *
3615 * Builds an array of CODEC DAI components from the DAI link property
3616 * 'sound-dai'.
3617 * The array is set in the DAI link and the number of DAIs is set accordingly.
3618 * The device nodes in the array (of_node) must be dereferenced by the caller.
3619 *
3620 * Returns 0 for success
3621 */
3622int snd_soc_of_get_dai_link_codecs(struct device *dev,
3623 struct device_node *of_node,
3624 struct snd_soc_dai_link *dai_link)
3625{
3626 struct of_phandle_args args;
3627 struct snd_soc_dai_link_component *component;
3628 char *name;
3629 int index, num_codecs, ret;
3630
3631 /* Count the number of CODECs */
3632 name = "sound-dai";
3633 num_codecs = of_count_phandle_with_args(of_node, name,
3634 "#sound-dai-cells");
3635 if (num_codecs <= 0) {
3636 if (num_codecs == -ENOENT)
3637 dev_err(dev, "No 'sound-dai' property\n");
3638 else
3639 dev_err(dev, "Bad phandle in 'sound-dai'\n");
3640 return num_codecs;
3641 }
3642 component = devm_kzalloc(dev,
3643 sizeof *component * num_codecs,
3644 GFP_KERNEL);
3645 if (!component)
3646 return -ENOMEM;
3647 dai_link->codecs = component;
3648 dai_link->num_codecs = num_codecs;
3649
3650 /* Parse the list */
3651 for (index = 0, component = dai_link->codecs;
3652 index < dai_link->num_codecs;
3653 index++, component++) {
3654 ret = of_parse_phandle_with_args(of_node, name,
3655 "#sound-dai-cells",
3656 index, &args);
3657 if (ret)
3658 goto err;
3659 component->of_node = args.np;
3660 ret = snd_soc_get_dai_name(&args, &component->dai_name);
3661 if (ret < 0)
3662 goto err;
3663 }
3664 return 0;
3665err:
3666 for (index = 0, component = dai_link->codecs;
3667 index < dai_link->num_codecs;
3668 index++, component++) {
3669 if (!component->of_node)
3670 break;
3671 of_node_put(component->of_node);
3672 component->of_node = NULL;
3673 }
3674 dai_link->codecs = NULL;
3675 dai_link->num_codecs = 0;
3676 return ret;
3677}
3678EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);
3679
Takashi Iwaic9b3a402008-12-10 07:47:22 +01003680static int __init snd_soc_init(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003681{
Lars-Peter Clausen6553bf062015-04-09 10:52:38 +02003682 snd_soc_debugfs_init();
Mark Brownfb257892011-04-28 10:57:54 +01003683 snd_soc_util_init();
3684
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003685 return platform_driver_register(&soc_driver);
3686}
Mark Brown4abe8e12010-10-12 17:41:03 +01003687module_init(snd_soc_init);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003688
Mark Brown7d8c16a2008-11-30 22:11:24 +00003689static void __exit snd_soc_exit(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003690{
Mark Brownfb257892011-04-28 10:57:54 +01003691 snd_soc_util_exit();
Lars-Peter Clausen6553bf062015-04-09 10:52:38 +02003692 snd_soc_debugfs_exit();
Mark Brownfb257892011-04-28 10:57:54 +01003693
Mark Brown384c89e2008-12-03 17:34:03 +00003694#ifdef CONFIG_DEBUG_FS
Mark Brown384c89e2008-12-03 17:34:03 +00003695#endif
Mark Brown3ff3f642008-05-19 12:32:25 +02003696 platform_driver_unregister(&soc_driver);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003697}
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003698module_exit(snd_soc_exit);
3699
3700/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01003701MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003702MODULE_DESCRIPTION("ALSA SoC Core");
3703MODULE_LICENSE("GPL");
Kay Sievers8b45a202008-04-14 13:33:36 +02003704MODULE_ALIAS("platform:soc-audio");