blob: a7a1ca40bcf5ed9394398ab1cb3a8fff4a7b205e [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{
Mengdong Lin1a497982015-11-18 02:34:11 -0500540 struct snd_soc_pcm_runtime *rtd;
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100541
Mengdong Lin1a497982015-11-18 02:34:11 -0500542 list_for_each_entry(rtd, &card->rtd_list, list) {
543 if (rtd->dai_link->no_pcm &&
544 !strcmp(rtd->dai_link->name, dai_link))
545 return rtd->pcm->streams[stream].substream;
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100546 }
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
Mengdong Lin1a497982015-11-18 02:34:11 -0500552static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
553 struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)
554{
555 struct snd_soc_pcm_runtime *rtd;
556
557 rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
558 if (!rtd)
559 return NULL;
560
561 rtd->card = card;
562 rtd->dai_link = dai_link;
563 rtd->codec_dais = kzalloc(sizeof(struct snd_soc_dai *) *
564 dai_link->num_codecs,
565 GFP_KERNEL);
566 if (!rtd->codec_dais) {
567 kfree(rtd);
568 return NULL;
569 }
570
571 return rtd;
572}
573
574static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
575{
576 if (rtd && rtd->codec_dais)
577 kfree(rtd->codec_dais);
578 kfree(rtd);
579}
580
581static void soc_add_pcm_runtime(struct snd_soc_card *card,
582 struct snd_soc_pcm_runtime *rtd)
583{
584 list_add_tail(&rtd->list, &card->rtd_list);
585 rtd->num = card->num_rtd;
586 card->num_rtd++;
587}
588
589static void soc_remove_pcm_runtimes(struct snd_soc_card *card)
590{
591 struct snd_soc_pcm_runtime *rtd, *_rtd;
592
593 list_for_each_entry_safe(rtd, _rtd, &card->rtd_list, list) {
594 list_del(&rtd->list);
595 soc_free_pcm_runtime(rtd);
596 }
597
598 card->num_rtd = 0;
599}
600
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100601struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
602 const char *dai_link)
603{
Mengdong Lin1a497982015-11-18 02:34:11 -0500604 struct snd_soc_pcm_runtime *rtd;
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100605
Mengdong Lin1a497982015-11-18 02:34:11 -0500606 list_for_each_entry(rtd, &card->rtd_list, list) {
607 if (!strcmp(rtd->dai_link->name, dai_link))
608 return rtd;
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100609 }
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000610 dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link);
Liam Girdwood47c88ff2012-04-25 12:12:53 +0100611 return NULL;
612}
613EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);
614
Richard Fitzgerald9d58a072013-08-05 13:17:28 +0100615static void codec2codec_close_delayed_work(struct work_struct *work)
616{
617 /* Currently nothing to do for c2c links
618 * Since c2c links are internal nodes in the DAPM graph and
619 * don't interface with the outside world or application layer
620 * we don't have to do any special handling on close.
621 */
622}
623
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000624#ifdef CONFIG_PM_SLEEP
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200625/* powers down audio subsystem for suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000626int snd_soc_suspend(struct device *dev)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200627{
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000628 struct snd_soc_card *card = dev_get_drvdata(dev);
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200629 struct snd_soc_codec *codec;
Mengdong Lin1a497982015-11-18 02:34:11 -0500630 struct snd_soc_pcm_runtime *rtd;
631 int i;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200632
Lars-Peter Clausenc5599b82014-08-19 15:51:30 +0200633 /* If the card is not initialized yet there is nothing to do */
634 if (!card->instantiated)
Daniel Macke3509ff2009-06-03 17:44:49 +0200635 return 0;
636
Andy Green6ed25972008-06-13 16:24:05 +0100637 /* Due to the resume being scheduled into a workqueue we could
638 * suspend before that's finished - wait for it to complete.
639 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000640 snd_power_lock(card->snd_card);
641 snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
642 snd_power_unlock(card->snd_card);
Andy Green6ed25972008-06-13 16:24:05 +0100643
644 /* we're going to block userspace touching us until resume completes */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000645 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
Andy Green6ed25972008-06-13 16:24:05 +0100646
Mark Browna00f90f2010-12-02 16:24:24 +0000647 /* mute any active DACs */
Mengdong Lin1a497982015-11-18 02:34:11 -0500648 list_for_each_entry(rtd, &card->rtd_list, list) {
Mark Brown3efab7d2010-05-09 13:25:43 +0100649
Mengdong Lin1a497982015-11-18 02:34:11 -0500650 if (rtd->dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100651 continue;
652
Mengdong Lin1a497982015-11-18 02:34:11 -0500653 for (i = 0; i < rtd->num_codecs; i++) {
654 struct snd_soc_dai *dai = rtd->codec_dais[i];
Benoit Cousson88bd8702014-07-08 23:19:34 +0200655 struct snd_soc_dai_driver *drv = dai->driver;
656
657 if (drv->ops->digital_mute && dai->playback_active)
658 drv->ops->digital_mute(dai, 1);
659 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200660 }
661
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100662 /* suspend all pcms */
Mengdong Lin1a497982015-11-18 02:34:11 -0500663 list_for_each_entry(rtd, &card->rtd_list, list) {
664 if (rtd->dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100665 continue;
666
Mengdong Lin1a497982015-11-18 02:34:11 -0500667 snd_pcm_suspend_all(rtd->pcm);
Mark Brown3efab7d2010-05-09 13:25:43 +0100668 }
Liam Girdwood4ccab3e2008-01-10 14:39:01 +0100669
Mark Brown87506542008-11-18 20:50:34 +0000670 if (card->suspend_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +0000671 card->suspend_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200672
Mengdong Lin1a497982015-11-18 02:34:11 -0500673 list_for_each_entry(rtd, &card->rtd_list, list) {
674 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100675
Mengdong Lin1a497982015-11-18 02:34:11 -0500676 if (rtd->dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100677 continue;
678
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100679 if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000680 cpu_dai->driver->suspend(cpu_dai);
Mark Brown1547aba2010-05-07 21:11:40 +0100681 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200682
Lars-Peter Clausen37660b62015-03-30 21:04:50 +0200683 /* close any waiting streams */
Mengdong Lin1a497982015-11-18 02:34:11 -0500684 list_for_each_entry(rtd, &card->rtd_list, list)
685 flush_delayed_work(&rtd->delayed_work);
Mark Brown3efab7d2010-05-09 13:25:43 +0100686
Mengdong Lin1a497982015-11-18 02:34:11 -0500687 list_for_each_entry(rtd, &card->rtd_list, list) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000688
Mengdong Lin1a497982015-11-18 02:34:11 -0500689 if (rtd->dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100690 continue;
691
Mengdong Lin1a497982015-11-18 02:34:11 -0500692 snd_soc_dapm_stream_event(rtd,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800693 SNDRV_PCM_STREAM_PLAYBACK,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800694 SND_SOC_DAPM_STREAM_SUSPEND);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000695
Mengdong Lin1a497982015-11-18 02:34:11 -0500696 snd_soc_dapm_stream_event(rtd,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800697 SNDRV_PCM_STREAM_CAPTURE,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800698 SND_SOC_DAPM_STREAM_SUSPEND);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000699 }
700
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200701 /* Recheck all endpoints too, their state is affected by suspend */
702 dapm_mark_endpoints_dirty(card);
Mark Browne2d32ff2012-08-31 17:38:32 -0700703 snd_soc_dapm_sync(&card->dapm);
704
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000705 /* suspend all CODECs */
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200706 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Lars-Peter Clausen48901402015-07-06 15:38:11 +0200707 struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);
708
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000709 /* If there are paths active then the CODEC will be held with
710 * bias _ON and should not be suspended. */
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200711 if (!codec->suspended) {
Lars-Peter Clausen48901402015-07-06 15:38:11 +0200712 switch (snd_soc_dapm_get_bias_level(dapm)) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000713 case SND_SOC_BIAS_STANDBY:
Mark Brown125a25d2012-01-31 15:49:10 +0000714 /*
715 * If the CODEC is capable of idle
716 * bias off then being in STANDBY
717 * means it's doing something,
718 * otherwise fall through.
719 */
Lars-Peter Clausen48901402015-07-06 15:38:11 +0200720 if (dapm->idle_bias_off) {
Mark Brown125a25d2012-01-31 15:49:10 +0000721 dev_dbg(codec->dev,
Michał Mirosław10e8aa92013-05-04 22:21:38 +0200722 "ASoC: idle_bias_off CODEC on over suspend\n");
Mark Brown125a25d2012-01-31 15:49:10 +0000723 break;
724 }
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200725
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000726 case SND_SOC_BIAS_OFF:
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200727 if (codec->driver->suspend)
728 codec->driver->suspend(codec);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000729 codec->suspended = 1;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +0200730 if (codec->component.regmap)
731 regcache_mark_dirty(codec->component.regmap);
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800732 /* deactivate pins to sleep state */
733 pinctrl_pm_select_sleep_state(codec->dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000734 break;
735 default:
Michał Mirosław10e8aa92013-05-04 22:21:38 +0200736 dev_dbg(codec->dev,
737 "ASoC: CODEC is on over suspend\n");
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000738 break;
739 }
740 }
741 }
742
Mengdong Lin1a497982015-11-18 02:34:11 -0500743 list_for_each_entry(rtd, &card->rtd_list, list) {
744 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000745
Mengdong Lin1a497982015-11-18 02:34:11 -0500746 if (rtd->dai_link->ignore_suspend)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000747 continue;
748
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100749 if (cpu_dai->driver->suspend && cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000750 cpu_dai->driver->suspend(cpu_dai);
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800751
752 /* deactivate pins to sleep state */
753 pinctrl_pm_select_sleep_state(cpu_dai->dev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200754 }
755
Mark Brown87506542008-11-18 20:50:34 +0000756 if (card->suspend_post)
Mark Brown70b2ac12011-01-26 14:05:25 +0000757 card->suspend_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200758
759 return 0;
760}
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000761EXPORT_SYMBOL_GPL(snd_soc_suspend);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200762
Andy Green6ed25972008-06-13 16:24:05 +0100763/* deferred resume work, so resume can complete before we finished
764 * setting our codec back up, which can be very slow on I2C
765 */
766static void soc_resume_deferred(struct work_struct *work)
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200767{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000768 struct snd_soc_card *card =
769 container_of(work, struct snd_soc_card, deferred_resume_work);
Mengdong Lin1a497982015-11-18 02:34:11 -0500770 struct snd_soc_pcm_runtime *rtd;
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200771 struct snd_soc_codec *codec;
Mengdong Lin1a497982015-11-18 02:34:11 -0500772 int i;
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200773
Andy Green6ed25972008-06-13 16:24:05 +0100774 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
775 * so userspace apps are blocked from touching us
776 */
777
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000778 dev_dbg(card->dev, "ASoC: starting resume work\n");
Andy Green6ed25972008-06-13 16:24:05 +0100779
Mark Brown9949788b2010-05-07 20:24:05 +0100780 /* Bring us up into D2 so that DAPM starts enabling things */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000781 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
Mark Brown9949788b2010-05-07 20:24:05 +0100782
Mark Brown87506542008-11-18 20:50:34 +0000783 if (card->resume_pre)
Mark Brown70b2ac12011-01-26 14:05:25 +0000784 card->resume_pre(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200785
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100786 /* resume control bus DAIs */
Mengdong Lin1a497982015-11-18 02:34:11 -0500787 list_for_each_entry(rtd, &card->rtd_list, list) {
788 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100789
Mengdong Lin1a497982015-11-18 02:34:11 -0500790 if (rtd->dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100791 continue;
792
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100793 if (cpu_dai->driver->resume && cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000794 cpu_dai->driver->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200795 }
796
Jarkko Nikula2eea3922010-11-25 17:47:38 +0200797 list_for_each_entry(codec, &card->codec_dev_list, card_list) {
Lars-Peter Clausena8093292014-09-04 19:44:07 +0200798 if (codec->suspended) {
Lars-Peter Clausenb8faaba2015-05-15 12:41:30 +0200799 if (codec->driver->resume)
800 codec->driver->resume(codec);
801 codec->suspended = 0;
Mark Brown1547aba2010-05-07 21:11:40 +0100802 }
803 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200804
Mengdong Lin1a497982015-11-18 02:34:11 -0500805 list_for_each_entry(rtd, &card->rtd_list, list) {
Mark Brown3efab7d2010-05-09 13:25:43 +0100806
Mengdong Lin1a497982015-11-18 02:34:11 -0500807 if (rtd->dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100808 continue;
809
Mengdong Lin1a497982015-11-18 02:34:11 -0500810 snd_soc_dapm_stream_event(rtd,
Liam Girdwoodd9b09512012-03-07 16:32:59 +0000811 SNDRV_PCM_STREAM_PLAYBACK,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800812 SND_SOC_DAPM_STREAM_RESUME);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000813
Mengdong Lin1a497982015-11-18 02:34:11 -0500814 snd_soc_dapm_stream_event(rtd,
Liam Girdwoodd9b09512012-03-07 16:32:59 +0000815 SNDRV_PCM_STREAM_CAPTURE,
Mark Brown7bd3a6f2012-02-16 15:03:27 -0800816 SND_SOC_DAPM_STREAM_RESUME);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200817 }
818
Mark Brown3ff3f642008-05-19 12:32:25 +0200819 /* unmute any active DACs */
Mengdong Lin1a497982015-11-18 02:34:11 -0500820 list_for_each_entry(rtd, &card->rtd_list, list) {
Mark Brown3efab7d2010-05-09 13:25:43 +0100821
Mengdong Lin1a497982015-11-18 02:34:11 -0500822 if (rtd->dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100823 continue;
824
Mengdong Lin1a497982015-11-18 02:34:11 -0500825 for (i = 0; i < rtd->num_codecs; i++) {
826 struct snd_soc_dai *dai = rtd->codec_dais[i];
Benoit Cousson88bd8702014-07-08 23:19:34 +0200827 struct snd_soc_dai_driver *drv = dai->driver;
828
829 if (drv->ops->digital_mute && dai->playback_active)
830 drv->ops->digital_mute(dai, 0);
831 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200832 }
833
Mengdong Lin1a497982015-11-18 02:34:11 -0500834 list_for_each_entry(rtd, &card->rtd_list, list) {
835 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Mark Brown3efab7d2010-05-09 13:25:43 +0100836
Mengdong Lin1a497982015-11-18 02:34:11 -0500837 if (rtd->dai_link->ignore_suspend)
Mark Brown3efab7d2010-05-09 13:25:43 +0100838 continue;
839
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100840 if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +0000841 cpu_dai->driver->resume(cpu_dai);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200842 }
843
Mark Brown87506542008-11-18 20:50:34 +0000844 if (card->resume_post)
Mark Brown70b2ac12011-01-26 14:05:25 +0000845 card->resume_post(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200846
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000847 dev_dbg(card->dev, "ASoC: resume work completed\n");
Andy Green6ed25972008-06-13 16:24:05 +0100848
Lars-Peter Clausen8be4da22014-10-25 17:42:01 +0200849 /* Recheck all endpoints too, their state is affected by suspend */
850 dapm_mark_endpoints_dirty(card);
Mark Browne2d32ff2012-08-31 17:38:32 -0700851 snd_soc_dapm_sync(&card->dapm);
Jeeja KP1a7aaa52015-11-23 21:22:31 +0530852
853 /* userspace can access us now we are back as we were before */
854 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
Andy Green6ed25972008-06-13 16:24:05 +0100855}
856
857/* powers up audio subsystem after a suspend */
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000858int snd_soc_resume(struct device *dev)
Andy Green6ed25972008-06-13 16:24:05 +0100859{
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000860 struct snd_soc_card *card = dev_get_drvdata(dev);
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100861 bool bus_control = false;
Mengdong Lin1a497982015-11-18 02:34:11 -0500862 struct snd_soc_pcm_runtime *rtd;
Peter Ujfalusib9dd94a2010-02-22 13:27:13 +0200863
Lars-Peter Clausenc5599b82014-08-19 15:51:30 +0200864 /* If the card is not initialized yet there is nothing to do */
865 if (!card->instantiated)
Eric Miao5ff1ddf2011-11-23 22:37:00 +0800866 return 0;
867
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800868 /* activate pins from sleep state */
Mengdong Lin1a497982015-11-18 02:34:11 -0500869 list_for_each_entry(rtd, &card->rtd_list, list) {
Benoit Cousson88bd8702014-07-08 23:19:34 +0200870 struct snd_soc_dai **codec_dais = rtd->codec_dais;
871 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
872 int j;
873
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800874 if (cpu_dai->active)
875 pinctrl_pm_select_default_state(cpu_dai->dev);
Benoit Cousson88bd8702014-07-08 23:19:34 +0200876
877 for (j = 0; j < rtd->num_codecs; j++) {
878 struct snd_soc_dai *codec_dai = codec_dais[j];
879 if (codec_dai->active)
880 pinctrl_pm_select_default_state(codec_dai->dev);
881 }
Nicolin Chen988e8cc2013-11-04 14:57:31 +0800882 }
883
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100884 /*
885 * DAIs that also act as the control bus master might have other drivers
886 * hanging off them so need to resume immediately. Other drivers don't
887 * have that problem and may take a substantial amount of time to resume
Mark Brown64ab9ba2009-03-31 11:27:03 +0100888 * due to I/O costs and anti-pop so handle them out of line.
889 */
Mengdong Lin1a497982015-11-18 02:34:11 -0500890 list_for_each_entry(rtd, &card->rtd_list, list) {
891 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100892 bus_control |= cpu_dai->driver->bus_control;
Stephen Warren82e14e82011-05-25 14:06:41 -0600893 }
Lars-Peter Clausenbc263212014-11-10 22:41:52 +0100894 if (bus_control) {
895 dev_dbg(dev, "ASoC: Resuming control bus master immediately\n");
Stephen Warren82e14e82011-05-25 14:06:41 -0600896 soc_resume_deferred(&card->deferred_resume_work);
897 } else {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000898 dev_dbg(dev, "ASoC: Scheduling resume work\n");
Stephen Warren82e14e82011-05-25 14:06:41 -0600899 if (!schedule_work(&card->deferred_resume_work))
Liam Girdwoodf110bfc2012-11-19 14:47:09 +0000900 dev_err(dev, "ASoC: resume work item may be lost\n");
Mark Brown64ab9ba2009-03-31 11:27:03 +0100901 }
Andy Green6ed25972008-06-13 16:24:05 +0100902
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200903 return 0;
904}
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000905EXPORT_SYMBOL_GPL(snd_soc_resume);
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200906#else
Mark Brown6f8ab4a2011-01-26 14:59:27 +0000907#define snd_soc_suspend NULL
908#define snd_soc_resume NULL
Frank Mandarinodb2a4162006-10-06 18:31:09 +0200909#endif
910
Lars-Peter Clausen85e76522011-11-23 11:40:40 +0100911static const struct snd_soc_dai_ops null_dai_ops = {
Barry Song02a06d32009-10-16 18:13:38 +0800912};
913
Lars-Peter Clausen65d93612014-08-19 15:51:22 +0200914static struct snd_soc_component *soc_find_component(
915 const struct device_node *of_node, const char *name)
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100916{
Lars-Peter Clausen65d93612014-08-19 15:51:22 +0200917 struct snd_soc_component *component;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100918
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100919 lockdep_assert_held(&client_mutex);
920
Lars-Peter Clausen65d93612014-08-19 15:51:22 +0200921 list_for_each_entry(component, &component_list, list) {
922 if (of_node) {
923 if (component->dev->of_node == of_node)
924 return component;
925 } else if (strcmp(component->name, name) == 0) {
926 return component;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100927 }
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100928 }
929
930 return NULL;
931}
932
Mengdong Linfbb88b52016-04-22 12:25:33 +0800933/**
934 * snd_soc_find_dai - Find a registered DAI
935 *
936 * @dlc: name of the DAI and optional component info to match
937 *
938 * This function will search all regsitered components and their DAIs to
939 * find the DAI of the same name. The component's of_node and name
940 * should also match if being specified.
941 *
942 * Return: pointer of DAI, or NULL if not found.
943 */
Mengdong Lin305e9022016-04-19 13:12:25 +0800944struct snd_soc_dai *snd_soc_find_dai(
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200945 const struct snd_soc_dai_link_component *dlc)
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100946{
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200947 struct snd_soc_component *component;
948 struct snd_soc_dai *dai;
Jyri Sarha3e0aa8d2015-05-26 21:59:05 +0300949 struct device_node *component_of_node;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100950
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +0100951 lockdep_assert_held(&client_mutex);
952
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200953 /* Find CPU DAI from registered DAIs*/
954 list_for_each_entry(component, &component_list, list) {
Jyri Sarha3e0aa8d2015-05-26 21:59:05 +0300955 component_of_node = component->dev->of_node;
956 if (!component_of_node && component->dev->parent)
957 component_of_node = component->dev->parent->of_node;
958
959 if (dlc->of_node && component_of_node != dlc->of_node)
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200960 continue;
Lars-Peter Clausen1ffae362014-10-29 21:46:30 +0100961 if (dlc->name && strcmp(component->name, dlc->name))
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200962 continue;
963 list_for_each_entry(dai, &component->dai_list, list) {
964 if (dlc->dai_name && strcmp(dai->name, dlc->dai_name))
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100965 continue;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100966
Lars-Peter Clausen14621c72014-08-19 15:51:27 +0200967 return dai;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100968 }
969 }
970
971 return NULL;
972}
Mengdong Lin305e9022016-04-19 13:12:25 +0800973EXPORT_SYMBOL_GPL(snd_soc_find_dai);
Misael Lopez Cruz12023a92014-03-21 16:27:25 +0100974
Mengdong Lin17fb17552016-11-03 01:04:12 +0800975
976/**
977 * snd_soc_find_dai_link - Find a DAI link
978 *
979 * @card: soc card
980 * @id: DAI link ID to match
981 * @name: DAI link name to match, optional
982 * @stream name: DAI link stream name to match, optional
983 *
984 * This function will search all existing DAI links of the soc card to
985 * find the link of the same ID. Since DAI links may not have their
986 * unique ID, so name and stream name should also match if being
987 * specified.
988 *
989 * Return: pointer of DAI link, or NULL if not found.
990 */
991struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card,
992 int id, const char *name,
993 const char *stream_name)
994{
995 struct snd_soc_dai_link *link, *_link;
996
997 lockdep_assert_held(&client_mutex);
998
999 list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1000 if (link->id != id)
1001 continue;
1002
1003 if (name && (!link->name || strcmp(name, link->name)))
1004 continue;
1005
1006 if (stream_name && (!link->stream_name
1007 || strcmp(stream_name, link->stream_name)))
1008 continue;
1009
1010 return link;
1011 }
1012
1013 return NULL;
1014}
1015EXPORT_SYMBOL_GPL(snd_soc_find_dai_link);
1016
Mengdong Lin49a5ba12015-12-02 14:11:40 +08001017static bool soc_is_dai_link_bound(struct snd_soc_card *card,
1018 struct snd_soc_dai_link *dai_link)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001019{
Mengdong Lin49a5ba12015-12-02 14:11:40 +08001020 struct snd_soc_pcm_runtime *rtd;
1021
1022 list_for_each_entry(rtd, &card->rtd_list, list) {
1023 if (rtd->dai_link == dai_link)
1024 return true;
1025 }
1026
1027 return false;
1028}
1029
Mengdong Lin6f2f1ff2015-11-23 11:03:52 -05001030static int soc_bind_dai_link(struct snd_soc_card *card,
1031 struct snd_soc_dai_link *dai_link)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001032{
Mengdong Lin1a497982015-11-18 02:34:11 -05001033 struct snd_soc_pcm_runtime *rtd;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001034 struct snd_soc_dai_link_component *codecs = dai_link->codecs;
Lars-Peter Clausen14621c72014-08-19 15:51:27 +02001035 struct snd_soc_dai_link_component cpu_dai_component;
Mengdong Lin1a497982015-11-18 02:34:11 -05001036 struct snd_soc_dai **codec_dais;
Mark Brown435c5e22008-12-04 15:32:53 +00001037 struct snd_soc_platform *platform;
Mark Brown848dd8b2011-04-27 18:16:32 +01001038 const char *platform_name;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001039 int i;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001040
Mengdong Lin6f2f1ff2015-11-23 11:03:52 -05001041 dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name);
Mark Brown63084192008-12-02 15:08:03 +00001042
Mengdong Lin49a5ba12015-12-02 14:11:40 +08001043 if (soc_is_dai_link_bound(card, dai_link)) {
1044 dev_dbg(card->dev, "ASoC: dai link %s already bound\n",
1045 dai_link->name);
1046 return 0;
1047 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001048
Sudip Mukherjee513cb3112016-02-22 14:14:31 +05301049 rtd = soc_new_pcm_runtime(card, dai_link);
1050 if (!rtd)
1051 return -ENOMEM;
1052
Lars-Peter Clausen14621c72014-08-19 15:51:27 +02001053 cpu_dai_component.name = dai_link->cpu_name;
1054 cpu_dai_component.of_node = dai_link->cpu_of_node;
1055 cpu_dai_component.dai_name = dai_link->cpu_dai_name;
1056 rtd->cpu_dai = snd_soc_find_dai(&cpu_dai_component);
Mark Brownb19e6e72012-03-14 21:18:39 +00001057 if (!rtd->cpu_dai) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001058 dev_err(card->dev, "ASoC: CPU DAI %s not registered\n",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001059 dai_link->cpu_dai_name);
Mengdong Lin1a497982015-11-18 02:34:11 -05001060 goto _err_defer;
Mark Brownc5af3a22008-11-28 13:29:45 +00001061 }
1062
Benoit Cousson88bd8702014-07-08 23:19:34 +02001063 rtd->num_codecs = dai_link->num_codecs;
1064
1065 /* Find CODEC from registered CODECs */
Mengdong Lin1a497982015-11-18 02:34:11 -05001066 codec_dais = rtd->codec_dais;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001067 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen14621c72014-08-19 15:51:27 +02001068 codec_dais[i] = snd_soc_find_dai(&codecs[i]);
Benoit Cousson88bd8702014-07-08 23:19:34 +02001069 if (!codec_dais[i]) {
1070 dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
1071 codecs[i].dai_name);
Mengdong Lin1a497982015-11-18 02:34:11 -05001072 goto _err_defer;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001073 }
Mark Brownb19e6e72012-03-14 21:18:39 +00001074 }
Mark Brown848dd8b2011-04-27 18:16:32 +01001075
Benoit Cousson88bd8702014-07-08 23:19:34 +02001076 /* Single codec links expect codec and codec_dai in runtime data */
1077 rtd->codec_dai = codec_dais[0];
1078 rtd->codec = rtd->codec_dai->codec;
Misael Lopez Cruz12023a92014-03-21 16:27:25 +01001079
Mark Brown848dd8b2011-04-27 18:16:32 +01001080 /* if there's no platform we match on the empty platform */
1081 platform_name = dai_link->platform_name;
Stephen Warren5a504962011-12-21 10:40:59 -07001082 if (!platform_name && !dai_link->platform_of_node)
Mark Brown848dd8b2011-04-27 18:16:32 +01001083 platform_name = "snd-soc-dummy";
1084
Mark Brownb19e6e72012-03-14 21:18:39 +00001085 /* find one from the set of registered platforms */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001086 list_for_each_entry(platform, &platform_list, list) {
Stephen Warren5a504962011-12-21 10:40:59 -07001087 if (dai_link->platform_of_node) {
1088 if (platform->dev->of_node !=
1089 dai_link->platform_of_node)
1090 continue;
1091 } else {
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02001092 if (strcmp(platform->component.name, platform_name))
Stephen Warren5a504962011-12-21 10:40:59 -07001093 continue;
1094 }
Stephen Warren2610ab72011-12-07 13:58:27 -07001095
1096 rtd->platform = platform;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001097 }
Mark Brownb19e6e72012-03-14 21:18:39 +00001098 if (!rtd->platform) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001099 dev_err(card->dev, "ASoC: platform %s not registered\n",
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001100 dai_link->platform_name);
Charles Keepax70fcad42016-08-11 14:39:00 +01001101 goto _err_defer;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001102 }
Mark Brownb19e6e72012-03-14 21:18:39 +00001103
Mengdong Lin1a497982015-11-18 02:34:11 -05001104 soc_add_pcm_runtime(card, rtd);
Mark Brownb19e6e72012-03-14 21:18:39 +00001105 return 0;
Mengdong Lin1a497982015-11-18 02:34:11 -05001106
1107_err_defer:
1108 soc_free_pcm_runtime(rtd);
1109 return -EPROBE_DEFER;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001110}
1111
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001112static void soc_remove_component(struct snd_soc_component *component)
Stephen Warrend12cd192012-06-08 12:34:22 -06001113{
Lars-Peter Clausenabd31b32015-07-08 20:47:44 +02001114 if (!component->card)
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001115 return;
Stephen Warrend12cd192012-06-08 12:34:22 -06001116
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001117 /* This is a HACK and will be removed soon */
1118 if (component->codec)
1119 list_del(&component->codec->card_list);
Stephen Warrend12cd192012-06-08 12:34:22 -06001120
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001121 if (component->remove)
1122 component->remove(component);
Stephen Warrend12cd192012-06-08 12:34:22 -06001123
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001124 snd_soc_dapm_free(snd_soc_component_get_dapm(component));
Stephen Warrend12cd192012-06-08 12:34:22 -06001125
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001126 soc_cleanup_component_debugfs(component);
Lars-Peter Clausenabd31b32015-07-08 20:47:44 +02001127 component->card = NULL;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001128 module_put(component->dev->driver->owner);
Stephen Warrend12cd192012-06-08 12:34:22 -06001129}
1130
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001131static void soc_remove_dai(struct snd_soc_dai *dai, int order)
Jarkko Nikula589c3562010-12-06 16:27:07 +02001132{
1133 int err;
1134
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001135 if (dai && dai->probed &&
1136 dai->driver->remove_order == order) {
1137 if (dai->driver->remove) {
1138 err = dai->driver->remove(dai);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001139 if (err < 0)
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001140 dev_err(dai->dev,
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001141 "ASoC: failed to remove %s: %d\n",
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001142 dai->name, err);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001143 }
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001144 dai->probed = 0;
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001145 }
1146}
1147
Mengdong Lin1a497982015-11-18 02:34:11 -05001148static void soc_remove_link_dais(struct snd_soc_card *card,
1149 struct snd_soc_pcm_runtime *rtd, int order)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001150{
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001151 int i;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001152
1153 /* unregister the rtd device */
1154 if (rtd->dev_registered) {
Mark Brown36ae1a92012-01-06 17:12:45 -08001155 device_unregister(rtd->dev);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001156 rtd->dev_registered = 0;
1157 }
1158
1159 /* remove the CODEC DAI */
Benoit Cousson88bd8702014-07-08 23:19:34 +02001160 for (i = 0; i < rtd->num_codecs; i++)
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001161 soc_remove_dai(rtd->codec_dais[i], order);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001162
Lars-Peter Clausene60cd142014-08-19 15:51:26 +02001163 soc_remove_dai(rtd->cpu_dai, order);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001164}
1165
Mengdong Lin1a497982015-11-18 02:34:11 -05001166static void soc_remove_link_components(struct snd_soc_card *card,
1167 struct snd_soc_pcm_runtime *rtd, int order)
Stephen Warren62ae68f2012-06-08 12:34:23 -06001168{
Stephen Warren62ae68f2012-06-08 12:34:23 -06001169 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Stephen Warren62ae68f2012-06-08 12:34:23 -06001170 struct snd_soc_platform *platform = rtd->platform;
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001171 struct snd_soc_component *component;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001172 int i;
Stephen Warren62ae68f2012-06-08 12:34:23 -06001173
1174 /* remove the platform */
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001175 if (platform && platform->component.driver->remove_order == order)
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001176 soc_remove_component(&platform->component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001177
1178 /* remove the CODEC-side CODEC */
Benoit Cousson88bd8702014-07-08 23:19:34 +02001179 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001180 component = rtd->codec_dais[i]->component;
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001181 if (component->driver->remove_order == order)
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001182 soc_remove_component(component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001183 }
1184
1185 /* remove any CPU-side CODEC */
1186 if (cpu_dai) {
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001187 if (cpu_dai->component->driver->remove_order == order)
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001188 soc_remove_component(cpu_dai->component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001189 }
1190}
1191
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001192static void soc_remove_dai_links(struct snd_soc_card *card)
1193{
Mengdong Lin1a497982015-11-18 02:34:11 -05001194 int order;
1195 struct snd_soc_pcm_runtime *rtd;
Mengdong Linf8f80362015-12-02 14:11:22 +08001196 struct snd_soc_dai_link *link, *_link;
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001197
Liam Girdwood0168bf02011-06-07 16:08:05 +01001198 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1199 order++) {
Mengdong Lin1a497982015-11-18 02:34:11 -05001200 list_for_each_entry(rtd, &card->rtd_list, list)
1201 soc_remove_link_dais(card, rtd, order);
Liam Girdwood0168bf02011-06-07 16:08:05 +01001202 }
Stephen Warren62ae68f2012-06-08 12:34:23 -06001203
1204 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1205 order++) {
Mengdong Lin1a497982015-11-18 02:34:11 -05001206 list_for_each_entry(rtd, &card->rtd_list, list)
1207 soc_remove_link_components(card, rtd, order);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001208 }
1209
Mengdong Linf8f80362015-12-02 14:11:22 +08001210 list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1211 if (link->dobj.type == SND_SOC_DOBJ_DAI_LINK)
1212 dev_warn(card->dev, "Topology forgot to remove link %s?\n",
1213 link->name);
1214
1215 list_del(&link->list);
1216 card->num_dai_links--;
1217 }
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09001218}
1219
Mengdong Lin923c5e612015-11-23 11:01:49 -05001220static int snd_soc_init_multicodec(struct snd_soc_card *card,
1221 struct snd_soc_dai_link *dai_link)
1222{
1223 /* Legacy codec/codec_dai link is a single entry in multicodec */
1224 if (dai_link->codec_name || dai_link->codec_of_node ||
1225 dai_link->codec_dai_name) {
1226 dai_link->num_codecs = 1;
1227
1228 dai_link->codecs = devm_kzalloc(card->dev,
1229 sizeof(struct snd_soc_dai_link_component),
1230 GFP_KERNEL);
1231 if (!dai_link->codecs)
1232 return -ENOMEM;
1233
1234 dai_link->codecs[0].name = dai_link->codec_name;
1235 dai_link->codecs[0].of_node = dai_link->codec_of_node;
1236 dai_link->codecs[0].dai_name = dai_link->codec_dai_name;
1237 }
1238
1239 if (!dai_link->codecs) {
1240 dev_err(card->dev, "ASoC: DAI link has no CODECs\n");
1241 return -EINVAL;
1242 }
1243
1244 return 0;
1245}
1246
1247static int soc_init_dai_link(struct snd_soc_card *card,
1248 struct snd_soc_dai_link *link)
1249{
1250 int i, ret;
1251
1252 ret = snd_soc_init_multicodec(card, link);
1253 if (ret) {
1254 dev_err(card->dev, "ASoC: failed to init multicodec\n");
1255 return ret;
1256 }
1257
1258 for (i = 0; i < link->num_codecs; i++) {
1259 /*
1260 * Codec must be specified by 1 of name or OF node,
1261 * not both or neither.
1262 */
1263 if (!!link->codecs[i].name ==
1264 !!link->codecs[i].of_node) {
1265 dev_err(card->dev, "ASoC: Neither/both codec name/of_node are set for %s\n",
1266 link->name);
1267 return -EINVAL;
1268 }
1269 /* Codec DAI name must be specified */
1270 if (!link->codecs[i].dai_name) {
1271 dev_err(card->dev, "ASoC: codec_dai_name not set for %s\n",
1272 link->name);
1273 return -EINVAL;
1274 }
1275 }
1276
1277 /*
1278 * Platform may be specified by either name or OF node, but
1279 * can be left unspecified, and a dummy platform will be used.
1280 */
1281 if (link->platform_name && link->platform_of_node) {
1282 dev_err(card->dev,
1283 "ASoC: Both platform name/of_node are set for %s\n",
1284 link->name);
1285 return -EINVAL;
1286 }
1287
1288 /*
1289 * CPU device may be specified by either name or OF node, but
1290 * can be left unspecified, and will be matched based on DAI
1291 * name alone..
1292 */
1293 if (link->cpu_name && link->cpu_of_node) {
1294 dev_err(card->dev,
1295 "ASoC: Neither/both cpu name/of_node are set for %s\n",
1296 link->name);
1297 return -EINVAL;
1298 }
1299 /*
1300 * At least one of CPU DAI name or CPU device name/node must be
1301 * specified
1302 */
1303 if (!link->cpu_dai_name &&
1304 !(link->cpu_name || link->cpu_of_node)) {
1305 dev_err(card->dev,
1306 "ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
1307 link->name);
1308 return -EINVAL;
1309 }
1310
1311 return 0;
1312}
1313
Mengdong Linf8f80362015-12-02 14:11:22 +08001314/**
1315 * snd_soc_add_dai_link - Add a DAI link dynamically
1316 * @card: The ASoC card to which the DAI link is added
1317 * @dai_link: The new DAI link to add
1318 *
1319 * This function adds a DAI link to the ASoC card's link list.
1320 *
1321 * Note: Topology can use this API to add DAI links when probing the
1322 * topology component. And machine drivers can still define static
1323 * DAI links in dai_link array.
1324 */
1325int snd_soc_add_dai_link(struct snd_soc_card *card,
1326 struct snd_soc_dai_link *dai_link)
1327{
1328 if (dai_link->dobj.type
1329 && dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
1330 dev_err(card->dev, "Invalid dai link type %d\n",
1331 dai_link->dobj.type);
1332 return -EINVAL;
1333 }
1334
1335 lockdep_assert_held(&client_mutex);
Mengdong Lind6f220e2015-12-02 14:11:32 +08001336 /* Notify the machine driver for extra initialization
1337 * on the link created by topology.
1338 */
1339 if (dai_link->dobj.type && card->add_dai_link)
1340 card->add_dai_link(card, dai_link);
1341
Mengdong Linf8f80362015-12-02 14:11:22 +08001342 list_add_tail(&dai_link->list, &card->dai_link_list);
1343 card->num_dai_links++;
1344
1345 return 0;
1346}
1347EXPORT_SYMBOL_GPL(snd_soc_add_dai_link);
1348
1349/**
1350 * snd_soc_remove_dai_link - Remove a DAI link from the list
1351 * @card: The ASoC card that owns the link
1352 * @dai_link: The DAI link to remove
1353 *
1354 * This function removes a DAI link from the ASoC card's link list.
1355 *
1356 * For DAI links previously added by topology, topology should
1357 * remove them by using the dobj embedded in the link.
1358 */
1359void snd_soc_remove_dai_link(struct snd_soc_card *card,
1360 struct snd_soc_dai_link *dai_link)
1361{
1362 struct snd_soc_dai_link *link, *_link;
1363
1364 if (dai_link->dobj.type
1365 && dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
1366 dev_err(card->dev, "Invalid dai link type %d\n",
1367 dai_link->dobj.type);
1368 return;
1369 }
1370
1371 lockdep_assert_held(&client_mutex);
Mengdong Lind6f220e2015-12-02 14:11:32 +08001372 /* Notify the machine driver for extra destruction
1373 * on the link created by topology.
1374 */
1375 if (dai_link->dobj.type && card->remove_dai_link)
1376 card->remove_dai_link(card, dai_link);
1377
Mengdong Linf8f80362015-12-02 14:11:22 +08001378 list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1379 if (link == dai_link) {
1380 list_del(&link->list);
1381 card->num_dai_links--;
1382 return;
1383 }
1384 }
1385}
1386EXPORT_SYMBOL_GPL(snd_soc_remove_dai_link);
1387
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001388static void soc_set_name_prefix(struct snd_soc_card *card,
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001389 struct snd_soc_component *component)
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001390{
1391 int i;
1392
Dimitris Papastamosff819b82010-12-02 14:53:03 +00001393 if (card->codec_conf == NULL)
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001394 return;
1395
Dimitris Papastamosff819b82010-12-02 14:53:03 +00001396 for (i = 0; i < card->num_configs; i++) {
1397 struct snd_soc_codec_conf *map = &card->codec_conf[i];
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001398 if (map->of_node && component->dev->of_node != map->of_node)
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001399 continue;
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001400 if (map->dev_name && strcmp(component->name, map->dev_name))
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001401 continue;
Lars-Peter Clausen94f99c82014-06-16 18:13:01 +02001402 component->name_prefix = map->name_prefix;
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001403 break;
Jarkko Nikulaead9b912010-11-13 20:40:44 +02001404 }
1405}
1406
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001407static int soc_probe_component(struct snd_soc_card *card,
1408 struct snd_soc_component *component)
Jarkko Nikula589c3562010-12-06 16:27:07 +02001409{
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001410 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
Mark Brown888df392012-02-16 19:37:51 -08001411 struct snd_soc_dai *dai;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001412 int ret;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001413
Lars-Peter Clausen1b7c1232015-07-08 20:47:43 +02001414 if (!strcmp(component->name, "snd-soc-dummy"))
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001415 return 0;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001416
Lars-Peter Clausenabd31b32015-07-08 20:47:44 +02001417 if (component->card) {
Lars-Peter Clausen1b7c1232015-07-08 20:47:43 +02001418 if (component->card != card) {
1419 dev_err(component->dev,
1420 "Trying to bind component to card \"%s\" but is already bound to card \"%s\"\n",
1421 card->name, component->card->name);
1422 return -ENODEV;
1423 }
1424 return 0;
1425 }
1426
Lars-Peter Clausenabd31b32015-07-08 20:47:44 +02001427 if (!try_module_get(component->dev->driver->owner))
1428 return -ENODEV;
1429
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001430 component->card = card;
1431 dapm->card = card;
1432 soc_set_name_prefix(card, component);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001433
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001434 soc_init_component_debugfs(component);
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001435
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001436 if (component->dapm_widgets) {
1437 ret = snd_soc_dapm_new_controls(dapm, component->dapm_widgets,
1438 component->num_dapm_widgets);
Nariman Poushinb318ad52014-04-01 13:59:33 +01001439
1440 if (ret != 0) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001441 dev_err(component->dev,
Nariman Poushinb318ad52014-04-01 13:59:33 +01001442 "Failed to create new controls %d\n", ret);
1443 goto err_probe;
1444 }
1445 }
Lars-Peter Clausen77530152011-05-05 16:59:09 +02001446
Lars-Peter Clausen06348142014-08-20 13:08:49 +02001447 list_for_each_entry(dai, &component->dai_list, list) {
1448 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
Nariman Poushin261edc72014-03-31 15:47:12 +01001449 if (ret != 0) {
Lars-Peter Clausen06348142014-08-20 13:08:49 +02001450 dev_err(component->dev,
Nariman Poushin261edc72014-03-31 15:47:12 +01001451 "Failed to create DAI widgets %d\n", ret);
1452 goto err_probe;
1453 }
1454 }
Mark Brown888df392012-02-16 19:37:51 -08001455
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001456 if (component->probe) {
1457 ret = component->probe(component);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001458 if (ret < 0) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001459 dev_err(component->dev,
1460 "ASoC: failed to probe component %d\n", ret);
Jarkko Nikula70d293312011-01-27 16:24:22 +02001461 goto err_probe;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001462 }
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001463
1464 WARN(dapm->idle_bias_off &&
1465 dapm->bias_level != SND_SOC_BIAS_OFF,
Michał Mirosław10e8aa92013-05-04 22:21:38 +02001466 "codec %s can not start from non-off bias with idle_bias_off==1\n",
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001467 component->name);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001468 }
1469
Mengdong Linf2ed6b02016-01-06 13:29:31 +08001470 /* machine specific init */
1471 if (component->init) {
1472 ret = component->init(component);
1473 if (ret < 0) {
1474 dev_err(component->dev,
1475 "Failed to do machine specific init %d\n", ret);
1476 goto err_probe;
1477 }
1478 }
1479
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001480 if (component->controls)
1481 snd_soc_add_component_controls(component, component->controls,
1482 component->num_controls);
1483 if (component->dapm_routes)
1484 snd_soc_dapm_add_routes(dapm, component->dapm_routes,
1485 component->num_dapm_routes);
Mark Brown89b95ac02011-03-07 16:38:44 +00001486
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001487 list_add(&dapm->list, &card->dapm_list);
1488
1489 /* This is a HACK and will be removed soon */
1490 if (component->codec)
1491 list_add(&component->codec->card_list, &card->codec_dev_list);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001492
Jarkko Nikula70d293312011-01-27 16:24:22 +02001493 return 0;
1494
1495err_probe:
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001496 soc_cleanup_component_debugfs(component);
Lars-Peter Clausenabd31b32015-07-08 20:47:44 +02001497 component->card = NULL;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001498 module_put(component->dev->driver->owner);
Liam Girdwood956245e2011-07-01 16:54:08 +01001499
1500 return ret;
1501}
1502
Mark Brown36ae1a92012-01-06 17:12:45 -08001503static void rtd_release(struct device *dev)
1504{
1505 kfree(dev);
1506}
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001507
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001508static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
1509 const char *name)
Misael Lopez Cruz503ae5e2014-04-24 14:01:44 +02001510{
Jarkko Nikula589c3562010-12-06 16:27:07 +02001511 int ret = 0;
1512
Jarkko Nikula589c3562010-12-06 16:27:07 +02001513 /* register the rtd device */
Mark Brown36ae1a92012-01-06 17:12:45 -08001514 rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1515 if (!rtd->dev)
1516 return -ENOMEM;
1517 device_initialize(rtd->dev);
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001518 rtd->dev->parent = rtd->card->dev;
Mark Brown36ae1a92012-01-06 17:12:45 -08001519 rtd->dev->release = rtd_release;
Takashi Iwaid29697d2015-01-30 20:16:37 +01001520 rtd->dev->groups = soc_dev_attr_groups;
Lars-Peter Clausenf294afe2014-08-17 11:28:35 +02001521 dev_set_name(rtd->dev, "%s", name);
Mark Brown36ae1a92012-01-06 17:12:45 -08001522 dev_set_drvdata(rtd->dev, rtd);
Liam Girdwoodb8c0dab2011-06-09 17:04:39 +01001523 mutex_init(&rtd->pcm_mutex);
Liam Girdwood01d75842012-04-25 12:12:49 +01001524 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
1525 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
1526 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
1527 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
Mark Brown36ae1a92012-01-06 17:12:45 -08001528 ret = device_add(rtd->dev);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001529 if (ret < 0) {
Chuansheng Liu865df9c2012-12-26 00:56:05 +08001530 /* calling put_device() here to free the rtd->dev */
1531 put_device(rtd->dev);
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001532 dev_err(rtd->card->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001533 "ASoC: failed to register runtime device: %d\n", ret);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001534 return ret;
1535 }
1536 rtd->dev_registered = 1;
Jarkko Nikula589c3562010-12-06 16:27:07 +02001537 return 0;
1538}
1539
Mengdong Lin1a497982015-11-18 02:34:11 -05001540static int soc_probe_link_components(struct snd_soc_card *card,
1541 struct snd_soc_pcm_runtime *rtd,
Stephen Warren62ae68f2012-06-08 12:34:23 -06001542 int order)
1543{
Stephen Warren62ae68f2012-06-08 12:34:23 -06001544 struct snd_soc_platform *platform = rtd->platform;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001545 struct snd_soc_component *component;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001546 int i, ret;
Stephen Warren62ae68f2012-06-08 12:34:23 -06001547
1548 /* probe the CPU-side component, if it is a CODEC */
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001549 component = rtd->cpu_dai->component;
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001550 if (component->driver->probe_order == order) {
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001551 ret = soc_probe_component(card, component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001552 if (ret < 0)
1553 return ret;
1554 }
1555
Benoit Cousson88bd8702014-07-08 23:19:34 +02001556 /* probe the CODEC-side components */
1557 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02001558 component = rtd->codec_dais[i]->component;
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001559 if (component->driver->probe_order == order) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001560 ret = soc_probe_component(card, component);
Benoit Cousson88bd8702014-07-08 23:19:34 +02001561 if (ret < 0)
1562 return ret;
1563 }
Stephen Warren62ae68f2012-06-08 12:34:23 -06001564 }
1565
1566 /* probe the platform */
Lars-Peter Clausen70090bb2014-08-19 15:51:24 +02001567 if (platform->component.driver->probe_order == order) {
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02001568 ret = soc_probe_component(card, &platform->component);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001569 if (ret < 0)
1570 return ret;
1571 }
1572
1573 return 0;
1574}
1575
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001576static int soc_probe_dai(struct snd_soc_dai *dai, int order)
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001577{
1578 int ret;
1579
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001580 if (!dai->probed && dai->driver->probe_order == order) {
1581 if (dai->driver->probe) {
1582 ret = dai->driver->probe(dai);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001583 if (ret < 0) {
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001584 dev_err(dai->dev,
1585 "ASoC: failed to probe DAI %s: %d\n",
1586 dai->name, ret);
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001587 return ret;
1588 }
1589 }
1590
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001591 dai->probed = 1;
Misael Lopez Cruzb0aa88a2014-03-21 16:27:26 +01001592 }
1593
1594 return 0;
1595}
1596
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001597static int soc_link_dai_widgets(struct snd_soc_card *card,
1598 struct snd_soc_dai_link *dai_link,
Benoit Cousson3f901a02014-07-01 09:47:54 +02001599 struct snd_soc_pcm_runtime *rtd)
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001600{
Benoit Cousson3f901a02014-07-01 09:47:54 +02001601 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1602 struct snd_soc_dai *codec_dai = rtd->codec_dai;
Vinod Koul3de7c422015-11-09 23:19:58 +05301603 struct snd_soc_dapm_widget *sink, *source;
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001604 int ret;
1605
Benoit Cousson88bd8702014-07-08 23:19:34 +02001606 if (rtd->num_codecs > 1)
1607 dev_warn(card->dev, "ASoC: Multiple codecs not supported yet\n");
1608
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001609 /* link the DAI widgets */
Vinod Koul3de7c422015-11-09 23:19:58 +05301610 sink = codec_dai->playback_widget;
1611 source = cpu_dai->capture_widget;
1612 if (sink && source) {
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001613 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
Vinod Koul3de7c422015-11-09 23:19:58 +05301614 dai_link->num_params,
1615 source, sink);
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001616 if (ret != 0) {
1617 dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
Vinod Koul3de7c422015-11-09 23:19:58 +05301618 sink->name, source->name, ret);
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001619 return ret;
1620 }
1621 }
1622
Vinod Koul3de7c422015-11-09 23:19:58 +05301623 sink = cpu_dai->playback_widget;
1624 source = codec_dai->capture_widget;
1625 if (sink && source) {
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001626 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
Vinod Koul3de7c422015-11-09 23:19:58 +05301627 dai_link->num_params,
1628 source, sink);
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001629 if (ret != 0) {
1630 dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
Vinod Koul3de7c422015-11-09 23:19:58 +05301631 sink->name, source->name, ret);
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001632 return ret;
1633 }
1634 }
1635
1636 return 0;
1637}
1638
Mengdong Lin1a497982015-11-18 02:34:11 -05001639static int soc_probe_link_dais(struct snd_soc_card *card,
1640 struct snd_soc_pcm_runtime *rtd, int order)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001641{
Mengdong Lin1a497982015-11-18 02:34:11 -05001642 struct snd_soc_dai_link *dai_link = rtd->dai_link;
Mark Brownc74184e2012-04-04 22:12:09 +01001643 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Benoit Cousson88bd8702014-07-08 23:19:34 +02001644 int i, ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001645
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001646 dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
Mengdong Lin1a497982015-11-18 02:34:11 -05001647 card->name, rtd->num, order);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001648
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001649 /* set default power off timeout */
1650 rtd->pmdown_time = pmdown_time;
1651
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001652 ret = soc_probe_dai(cpu_dai, order);
1653 if (ret)
1654 return ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001655
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001656 /* probe the CODEC DAI */
Benoit Cousson88bd8702014-07-08 23:19:34 +02001657 for (i = 0; i < rtd->num_codecs; i++) {
Lars-Peter Clausen8e2be562014-11-04 11:30:59 +01001658 ret = soc_probe_dai(rtd->codec_dais[i], order);
Benoit Cousson88bd8702014-07-08 23:19:34 +02001659 if (ret)
1660 return ret;
1661 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001662
Liam Girdwood0168bf02011-06-07 16:08:05 +01001663 /* complete DAI probe during last probe */
1664 if (order != SND_SOC_COMP_ORDER_LAST)
1665 return 0;
1666
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001667 /* do machine specific initialization */
1668 if (dai_link->init) {
1669 ret = dai_link->init(rtd);
1670 if (ret < 0) {
1671 dev_err(card->dev, "ASoC: failed to init %s: %d\n",
1672 dai_link->name, ret);
1673 return ret;
1674 }
1675 }
1676
Kuninori Morimotoa5053a82015-04-10 09:47:00 +00001677 if (dai_link->dai_fmt)
1678 snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
1679
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001680 ret = soc_post_component_init(rtd, dai_link->name);
Jarkko Nikula589c3562010-12-06 16:27:07 +02001681 if (ret)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001682 return ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02001683
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001684#ifdef CONFIG_DEBUG_FS
1685 /* add DPCM sysfs entries */
Lars-Peter Clausen2e55b902015-04-09 10:52:37 +02001686 if (dai_link->dynamic)
1687 soc_dpcm_debugfs_add(rtd);
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001688#endif
1689
Jie Yang6f0c4222015-10-13 23:41:00 +08001690 if (cpu_dai->driver->compress_new) {
Namarta Kohli1245b702012-08-16 17:10:41 +05301691 /*create compress_device"*/
Mengdong Lin1a497982015-11-18 02:34:11 -05001692 ret = cpu_dai->driver->compress_new(rtd, rtd->num);
Mark Brownc74184e2012-04-04 22:12:09 +01001693 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001694 dev_err(card->dev, "ASoC: can't create compress %s\n",
Namarta Kohli1245b702012-08-16 17:10:41 +05301695 dai_link->stream_name);
Mark Brownc74184e2012-04-04 22:12:09 +01001696 return ret;
1697 }
1698 } else {
Namarta Kohli1245b702012-08-16 17:10:41 +05301699
1700 if (!dai_link->params) {
1701 /* create the pcm */
Mengdong Lin1a497982015-11-18 02:34:11 -05001702 ret = soc_new_pcm(rtd, rtd->num);
Namarta Kohli1245b702012-08-16 17:10:41 +05301703 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001704 dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
Namarta Kohli1245b702012-08-16 17:10:41 +05301705 dai_link->stream_name, ret);
Mark Brownc74184e2012-04-04 22:12:09 +01001706 return ret;
1707 }
Namarta Kohli1245b702012-08-16 17:10:41 +05301708 } else {
Richard Fitzgerald9d58a072013-08-05 13:17:28 +01001709 INIT_DELAYED_WORK(&rtd->delayed_work,
1710 codec2codec_close_delayed_work);
1711
Namarta Kohli1245b702012-08-16 17:10:41 +05301712 /* link the DAI widgets */
Benoit Cousson3f901a02014-07-01 09:47:54 +02001713 ret = soc_link_dai_widgets(card, dai_link, rtd);
Misael Lopez Cruz2436a722014-03-21 16:27:27 +01001714 if (ret)
1715 return ret;
Mark Brownc74184e2012-04-04 22:12:09 +01001716 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001717 }
1718
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001719 return 0;
1720}
1721
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001722static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
Mark Brownb19e6e72012-03-14 21:18:39 +00001723{
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001724 struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
Mengdong Linf2ed6b02016-01-06 13:29:31 +08001725 struct snd_soc_component *component;
1726 const char *name;
1727 struct device_node *codec_of_node;
Sebastian Reichel3ca041e2014-04-28 16:07:22 +02001728
Mengdong Linf2ed6b02016-01-06 13:29:31 +08001729 if (aux_dev->codec_of_node || aux_dev->codec_name) {
1730 /* codecs, usually analog devices */
1731 name = aux_dev->codec_name;
1732 codec_of_node = aux_dev->codec_of_node;
1733 component = soc_find_component(codec_of_node, name);
1734 if (!component) {
1735 if (codec_of_node)
1736 name = of_node_full_name(codec_of_node);
1737 goto err_defer;
1738 }
1739 } else if (aux_dev->name) {
1740 /* generic components */
1741 name = aux_dev->name;
1742 component = soc_find_component(NULL, name);
1743 if (!component)
1744 goto err_defer;
1745 } else {
1746 dev_err(card->dev, "ASoC: Invalid auxiliary device\n");
1747 return -EINVAL;
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001748 }
1749
Mengdong Linf2ed6b02016-01-06 13:29:31 +08001750 component->init = aux_dev->init;
1751 list_add(&component->list_aux, &card->aux_comp_list);
1752 return 0;
1753
1754err_defer:
1755 dev_err(card->dev, "ASoC: %s not registered\n", name);
1756 return -EPROBE_DEFER;
1757}
1758
1759static int soc_probe_aux_devices(struct snd_soc_card *card)
1760{
1761 struct snd_soc_component *comp;
1762 int order;
1763 int ret;
1764
1765 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1766 order++) {
1767 list_for_each_entry(comp, &card->aux_comp_list, list_aux) {
1768 if (comp->driver->probe_order == order) {
1769 ret = soc_probe_component(card, comp);
1770 if (ret < 0) {
1771 dev_err(card->dev,
1772 "ASoC: failed to probe aux component %s %d\n",
1773 comp->name, ret);
1774 return ret;
1775 }
1776 }
1777 }
1778 }
Lars-Peter Clausen65d93612014-08-19 15:51:22 +02001779
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001780 return 0;
Mark Brownb19e6e72012-03-14 21:18:39 +00001781}
1782
Mengdong Linf2ed6b02016-01-06 13:29:31 +08001783static void soc_remove_aux_devices(struct snd_soc_card *card)
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001784{
Mengdong Linf2ed6b02016-01-06 13:29:31 +08001785 struct snd_soc_component *comp, *_comp;
1786 int order;
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001787
Mengdong Linf2ed6b02016-01-06 13:29:31 +08001788 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1789 order++) {
1790 list_for_each_entry_safe(comp, _comp,
1791 &card->aux_comp_list, list_aux) {
1792 if (comp->driver->remove_order == order) {
1793 soc_remove_component(comp);
1794 /* remove it from the card's aux_comp_list */
1795 list_del(&comp->list_aux);
1796 }
Lars-Peter Clausen5f3484a2014-07-01 22:13:48 +02001797 }
1798 }
Jarkko Nikula2eea3922010-11-25 17:47:38 +02001799}
1800
Lars-Peter Clausenf90fb3f2013-08-31 20:31:15 +02001801static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001802{
1803 int ret;
1804
1805 if (codec->cache_init)
1806 return 0;
1807
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001808 ret = snd_soc_cache_init(codec);
1809 if (ret < 0) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02001810 dev_err(codec->dev,
1811 "ASoC: Failed to set cache compression type: %d\n",
1812 ret);
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001813 return ret;
1814 }
1815 codec->cache_init = 1;
1816 return 0;
1817}
1818
Lars-Peter Clausence64c8b2015-01-06 15:17:20 +01001819/**
1820 * snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime
1821 * @rtd: The runtime for which the DAI link format should be changed
1822 * @dai_fmt: The new DAI link format
1823 *
1824 * This function updates the DAI link format for all DAIs connected to the DAI
1825 * link for the specified runtime.
1826 *
1827 * Note: For setups with a static format set the dai_fmt field in the
1828 * corresponding snd_dai_link struct instead of using this function.
1829 *
1830 * Returns 0 on success, otherwise a negative error code.
1831 */
1832int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
1833 unsigned int dai_fmt)
1834{
1835 struct snd_soc_dai **codec_dais = rtd->codec_dais;
1836 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1837 unsigned int i;
1838 int ret;
1839
1840 for (i = 0; i < rtd->num_codecs; i++) {
1841 struct snd_soc_dai *codec_dai = codec_dais[i];
1842
1843 ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
1844 if (ret != 0 && ret != -ENOTSUPP) {
1845 dev_warn(codec_dai->dev,
1846 "ASoC: Failed to set DAI format: %d\n", ret);
1847 return ret;
1848 }
1849 }
1850
1851 /* Flip the polarity for the "CPU" end of a CODEC<->CODEC link */
1852 if (cpu_dai->codec) {
1853 unsigned int inv_dai_fmt;
1854
1855 inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_MASTER_MASK;
1856 switch (dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1857 case SND_SOC_DAIFMT_CBM_CFM:
1858 inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
1859 break;
1860 case SND_SOC_DAIFMT_CBM_CFS:
1861 inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
1862 break;
1863 case SND_SOC_DAIFMT_CBS_CFM:
1864 inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
1865 break;
1866 case SND_SOC_DAIFMT_CBS_CFS:
1867 inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
1868 break;
1869 }
1870
1871 dai_fmt = inv_dai_fmt;
1872 }
1873
1874 ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt);
1875 if (ret != 0 && ret != -ENOTSUPP) {
1876 dev_warn(cpu_dai->dev,
1877 "ASoC: Failed to set DAI format: %d\n", ret);
1878 return ret;
1879 }
1880
1881 return 0;
1882}
Lars-Peter Clausenddaca252015-01-08 12:23:05 +01001883EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
Lars-Peter Clausence64c8b2015-01-06 15:17:20 +01001884
Mark Brownb19e6e72012-03-14 21:18:39 +00001885static int snd_soc_instantiate_card(struct snd_soc_card *card)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001886{
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001887 struct snd_soc_codec *codec;
Mengdong Lin1a497982015-11-18 02:34:11 -05001888 struct snd_soc_pcm_runtime *rtd;
Mengdong Lin61b00882015-12-02 14:11:48 +08001889 struct snd_soc_dai_link *dai_link;
Lars-Peter Clausence64c8b2015-01-06 15:17:20 +01001890 int ret, i, order;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001891
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01001892 mutex_lock(&client_mutex);
Liam Girdwood01b9d992012-03-07 10:38:25 +00001893 mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001894
Mark Brownb19e6e72012-03-14 21:18:39 +00001895 /* bind DAIs */
1896 for (i = 0; i < card->num_links; i++) {
Mengdong Lin6f2f1ff2015-11-23 11:03:52 -05001897 ret = soc_bind_dai_link(card, &card->dai_link[i]);
Mark Brownb19e6e72012-03-14 21:18:39 +00001898 if (ret != 0)
1899 goto base_error;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001900 }
1901
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001902 /* bind aux_devs too */
Mark Brownb19e6e72012-03-14 21:18:39 +00001903 for (i = 0; i < card->num_aux_devs; i++) {
Lars-Peter Clausen44c69bb2014-07-01 22:13:47 +02001904 ret = soc_bind_aux_dev(card, i);
Mark Brownb19e6e72012-03-14 21:18:39 +00001905 if (ret != 0)
1906 goto base_error;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001907 }
1908
Mengdong Linf8f80362015-12-02 14:11:22 +08001909 /* add predefined DAI links to the list */
1910 for (i = 0; i < card->num_links; i++)
1911 snd_soc_add_dai_link(card, card->dai_link+i);
1912
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001913 /* initialize the register cache for each available codec */
1914 list_for_each_entry(codec, &codec_list, list) {
1915 if (codec->cache_init)
1916 continue;
Lars-Peter Clausenf90fb3f2013-08-31 20:31:15 +02001917 ret = snd_soc_init_codec_cache(codec);
Mark Brownb19e6e72012-03-14 21:18:39 +00001918 if (ret < 0)
1919 goto base_error;
Dimitris Papastamosfdf0f542010-12-02 16:11:06 +00001920 }
1921
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001922 /* card bind complete so register a sound card */
Takashi Iwai102b5a82014-01-29 14:42:55 +01001923 ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001924 card->owner, 0, &card->snd_card);
1925 if (ret < 0) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02001926 dev_err(card->dev,
1927 "ASoC: can't create sound card for card %s: %d\n",
1928 card->name, ret);
Mark Brownb19e6e72012-03-14 21:18:39 +00001929 goto base_error;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001930 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001931
Lars-Peter Clausen0757d832015-04-09 10:52:36 +02001932 soc_init_card_debugfs(card);
1933
Mark Browne37a4972011-03-02 18:21:57 +00001934 card->dapm.bias_level = SND_SOC_BIAS_OFF;
1935 card->dapm.dev = card->dev;
1936 card->dapm.card = card;
1937 list_add(&card->dapm.list, &card->dapm_list);
1938
Lars-Peter Clausend5d1e0b2011-04-30 19:45:49 +02001939#ifdef CONFIG_DEBUG_FS
1940 snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
1941#endif
1942
Mark Brown88ee1c62011-02-02 10:43:26 +00001943#ifdef CONFIG_PM_SLEEP
Andy Green6ed25972008-06-13 16:24:05 +01001944 /* deferred resume work */
Mark Brown63084192008-12-02 15:08:03 +00001945 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
Randy Dunlap1301a962008-06-17 19:19:34 +01001946#endif
Andy Green6ed25972008-06-13 16:24:05 +01001947
Mark Brown9a841eb2011-04-12 17:51:37 -07001948 if (card->dapm_widgets)
1949 snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
1950 card->num_dapm_widgets);
1951
Nicolin Chenf23e8602015-02-14 17:22:49 -08001952 if (card->of_dapm_widgets)
1953 snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets,
1954 card->num_of_dapm_widgets);
1955
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001956 /* initialise the sound card only once */
1957 if (card->probe) {
Mark Browne7361ec2011-01-26 14:17:20 +00001958 ret = card->probe(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00001959 if (ret < 0)
1960 goto card_probe_error;
1961 }
1962
Stephen Warren62ae68f2012-06-08 12:34:23 -06001963 /* probe all components used by DAI links on this card */
Liam Girdwood0168bf02011-06-07 16:08:05 +01001964 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1965 order++) {
Mengdong Lin1a497982015-11-18 02:34:11 -05001966 list_for_each_entry(rtd, &card->rtd_list, list) {
1967 ret = soc_probe_link_components(card, rtd, order);
Liam Girdwood0168bf02011-06-07 16:08:05 +01001968 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00001969 dev_err(card->dev,
1970 "ASoC: failed to instantiate card %d\n",
1971 ret);
Stephen Warren62ae68f2012-06-08 12:34:23 -06001972 goto probe_dai_err;
1973 }
1974 }
1975 }
1976
Mengdong Linf2ed6b02016-01-06 13:29:31 +08001977 /* probe auxiliary components */
1978 ret = soc_probe_aux_devices(card);
1979 if (ret < 0)
1980 goto probe_dai_err;
1981
Mengdong Lin61b00882015-12-02 14:11:48 +08001982 /* Find new DAI links added during probing components and bind them.
1983 * Components with topology may bring new DAIs and DAI links.
1984 */
1985 list_for_each_entry(dai_link, &card->dai_link_list, list) {
1986 if (soc_is_dai_link_bound(card, dai_link))
1987 continue;
1988
1989 ret = soc_init_dai_link(card, dai_link);
1990 if (ret)
1991 goto probe_dai_err;
1992 ret = soc_bind_dai_link(card, dai_link);
1993 if (ret)
1994 goto probe_dai_err;
1995 }
1996
Stephen Warren62ae68f2012-06-08 12:34:23 -06001997 /* probe all DAI links on this card */
1998 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1999 order++) {
Mengdong Lin1a497982015-11-18 02:34:11 -05002000 list_for_each_entry(rtd, &card->rtd_list, list) {
2001 ret = soc_probe_link_dais(card, rtd, order);
Stephen Warren62ae68f2012-06-08 12:34:23 -06002002 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00002003 dev_err(card->dev,
2004 "ASoC: failed to instantiate card %d\n",
2005 ret);
Liam Girdwood0168bf02011-06-07 16:08:05 +01002006 goto probe_dai_err;
2007 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002008 }
2009 }
2010
Mark Brown888df392012-02-16 19:37:51 -08002011 snd_soc_dapm_link_dai_widgets(card);
Liam Girdwoodb893ea52014-01-08 10:40:19 +00002012 snd_soc_dapm_connect_dai_link_widgets(card);
Mark Brown888df392012-02-16 19:37:51 -08002013
Mark Brownb7af1da2011-04-07 19:18:44 +09002014 if (card->controls)
Liam Girdwood022658b2012-02-03 17:43:09 +00002015 snd_soc_add_card_controls(card, card->controls, card->num_controls);
Mark Brownb7af1da2011-04-07 19:18:44 +09002016
Mark Brownb8ad29d2011-03-02 18:35:51 +00002017 if (card->dapm_routes)
2018 snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
2019 card->num_dapm_routes);
2020
Nicolin Chenf23e8602015-02-14 17:22:49 -08002021 if (card->of_dapm_routes)
2022 snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,
2023 card->num_of_dapm_routes);
Mark Brown75d9ac42011-09-27 16:41:01 +01002024
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002025 snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002026 "%s", card->name);
Liam Girdwood22de71b2011-05-12 16:14:04 +01002027 snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
2028 "%s", card->long_name ? card->long_name : card->name);
Mark Brownf0e8ed82011-09-20 11:41:54 +01002029 snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
2030 "%s", card->driver_name ? card->driver_name : card->name);
2031 for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
2032 switch (card->snd_card->driver[i]) {
2033 case '_':
2034 case '-':
2035 case '\0':
2036 break;
2037 default:
2038 if (!isalnum(card->snd_card->driver[i]))
2039 card->snd_card->driver[i] = '_';
2040 break;
2041 }
2042 }
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002043
Mark Brown28e9ad92011-03-02 18:36:34 +00002044 if (card->late_probe) {
2045 ret = card->late_probe(card);
2046 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00002047 dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
Mark Brown28e9ad92011-03-02 18:36:34 +00002048 card->name, ret);
2049 goto probe_aux_dev_err;
2050 }
2051 }
2052
Lars-Peter Clausen824ef822013-08-27 15:51:01 +02002053 snd_soc_dapm_new_widgets(card);
Lars-Peter Clausen8c193b82013-08-27 15:51:00 +02002054
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002055 ret = snd_card_register(card->snd_card);
2056 if (ret < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00002057 dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
2058 ret);
Axel Lin6b3ed782010-12-07 16:12:29 +08002059 goto probe_aux_dev_err;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002060 }
2061
Mark Brown435c5e22008-12-04 15:32:53 +00002062 card->instantiated = 1;
Mark Brown4f4c0072011-10-07 14:29:19 +01002063 snd_soc_dapm_sync(&card->dapm);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002064 mutex_unlock(&card->mutex);
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002065 mutex_unlock(&client_mutex);
Mark Brownb19e6e72012-03-14 21:18:39 +00002066
2067 return 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002068
Jarkko Nikula2eea3922010-11-25 17:47:38 +02002069probe_aux_dev_err:
Mengdong Linf2ed6b02016-01-06 13:29:31 +08002070 soc_remove_aux_devices(card);
Jarkko Nikula2eea3922010-11-25 17:47:38 +02002071
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002072probe_dai_err:
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09002073 soc_remove_dai_links(card);
Mark Brownfe3e78e2009-11-03 22:13:13 +00002074
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002075card_probe_error:
Mark Brown87506542008-11-18 20:50:34 +00002076 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00002077 card->remove(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002078
Lars-Peter Clausen22104382015-07-08 22:14:48 +02002079 snd_soc_dapm_free(&card->dapm);
Lars-Peter Clausen0757d832015-04-09 10:52:36 +02002080 soc_cleanup_card_debugfs(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002081 snd_card_free(card->snd_card);
2082
Mark Brownb19e6e72012-03-14 21:18:39 +00002083base_error:
Mengdong Lin1a497982015-11-18 02:34:11 -05002084 soc_remove_pcm_runtimes(card);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002085 mutex_unlock(&card->mutex);
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01002086 mutex_unlock(&client_mutex);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002087
Mark Brownb19e6e72012-03-14 21:18:39 +00002088 return ret;
Mark Brown435c5e22008-12-04 15:32:53 +00002089}
2090
2091/* probes a new socdev */
2092static int soc_probe(struct platform_device *pdev)
2093{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002094 struct snd_soc_card *card = platform_get_drvdata(pdev);
Mark Brown435c5e22008-12-04 15:32:53 +00002095
Vinod Koul70a7ca32011-01-14 19:22:48 +05302096 /*
2097 * no card, so machine driver should be registering card
2098 * we should not be here in that case so ret error
2099 */
2100 if (!card)
2101 return -EINVAL;
2102
Mark Brownfe4085e2012-03-02 13:07:41 +00002103 dev_warn(&pdev->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00002104 "ASoC: machine %s should use snd_soc_register_card()\n",
Mark Brownfe4085e2012-03-02 13:07:41 +00002105 card->name);
2106
Mark Brown435c5e22008-12-04 15:32:53 +00002107 /* Bodge while we unpick instantiation */
2108 card->dev = &pdev->dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002109
Mark Brown28d528c2012-08-09 18:45:23 +01002110 return snd_soc_register_card(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002111}
2112
Vinod Koulb0e26482011-01-13 22:48:02 +05302113static int soc_cleanup_card_resources(struct snd_soc_card *card)
2114{
Mengdong Lin1a497982015-11-18 02:34:11 -05002115 struct snd_soc_pcm_runtime *rtd;
Vinod Koulb0e26482011-01-13 22:48:02 +05302116
2117 /* make sure any delayed work runs */
Mengdong Lin1a497982015-11-18 02:34:11 -05002118 list_for_each_entry(rtd, &card->rtd_list, list)
Tejun Heo43829732012-08-20 14:51:24 -07002119 flush_delayed_work(&rtd->delayed_work);
Vinod Koulb0e26482011-01-13 22:48:02 +05302120
Vinod Koulb0e26482011-01-13 22:48:02 +05302121 /* remove and free each DAI */
Kuninori Morimoto0671fd82011-04-08 14:50:44 +09002122 soc_remove_dai_links(card);
Mengdong Lin1a497982015-11-18 02:34:11 -05002123 soc_remove_pcm_runtimes(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05302124
Mengdong Linf2ed6b02016-01-06 13:29:31 +08002125 /* remove auxiliary devices */
2126 soc_remove_aux_devices(card);
2127
Mark Brownd1e81422016-08-18 19:32:59 +01002128 snd_soc_dapm_free(&card->dapm);
Vinod Koulb0e26482011-01-13 22:48:02 +05302129 soc_cleanup_card_debugfs(card);
2130
2131 /* remove the card */
2132 if (card->remove)
Mark Browne7361ec2011-01-26 14:17:20 +00002133 card->remove(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05302134
Vinod Koulb0e26482011-01-13 22:48:02 +05302135 snd_card_free(card->snd_card);
2136 return 0;
2137
2138}
2139
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002140/* removes a socdev */
2141static int soc_remove(struct platform_device *pdev)
2142{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002143 struct snd_soc_card *card = platform_get_drvdata(pdev);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002144
Mark Brownc5af3a22008-11-28 13:29:45 +00002145 snd_soc_unregister_card(card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002146 return 0;
2147}
2148
Mark Brown6f8ab4a2011-01-26 14:59:27 +00002149int snd_soc_poweroff(struct device *dev)
Mark Brown51737472009-06-22 13:16:51 +01002150{
Mark Brown6f8ab4a2011-01-26 14:59:27 +00002151 struct snd_soc_card *card = dev_get_drvdata(dev);
Mengdong Lin1a497982015-11-18 02:34:11 -05002152 struct snd_soc_pcm_runtime *rtd;
Mark Brown51737472009-06-22 13:16:51 +01002153
2154 if (!card->instantiated)
Mark Brown416356f2009-06-30 19:05:15 +01002155 return 0;
Mark Brown51737472009-06-22 13:16:51 +01002156
2157 /* Flush out pmdown_time work - we actually do want to run it
2158 * now, we're shutting down so no imminent restart. */
Mengdong Lin1a497982015-11-18 02:34:11 -05002159 list_for_each_entry(rtd, &card->rtd_list, list)
Tejun Heo43829732012-08-20 14:51:24 -07002160 flush_delayed_work(&rtd->delayed_work);
Mark Brown51737472009-06-22 13:16:51 +01002161
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002162 snd_soc_dapm_shutdown(card);
Mark Brown416356f2009-06-30 19:05:15 +01002163
Nicolin Chen988e8cc2013-11-04 14:57:31 +08002164 /* deactivate pins to sleep state */
Mengdong Lin1a497982015-11-18 02:34:11 -05002165 list_for_each_entry(rtd, &card->rtd_list, list) {
Benoit Cousson88bd8702014-07-08 23:19:34 +02002166 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
Mengdong Lin1a497982015-11-18 02:34:11 -05002167 int i;
Benoit Cousson88bd8702014-07-08 23:19:34 +02002168
Nicolin Chen988e8cc2013-11-04 14:57:31 +08002169 pinctrl_pm_select_sleep_state(cpu_dai->dev);
Mengdong Lin1a497982015-11-18 02:34:11 -05002170 for (i = 0; i < rtd->num_codecs; i++) {
2171 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
Benoit Cousson88bd8702014-07-08 23:19:34 +02002172 pinctrl_pm_select_sleep_state(codec_dai->dev);
2173 }
Nicolin Chen988e8cc2013-11-04 14:57:31 +08002174 }
2175
Mark Brown416356f2009-06-30 19:05:15 +01002176 return 0;
Mark Brown51737472009-06-22 13:16:51 +01002177}
Mark Brown6f8ab4a2011-01-26 14:59:27 +00002178EXPORT_SYMBOL_GPL(snd_soc_poweroff);
Mark Brown51737472009-06-22 13:16:51 +01002179
Mark Brown6f8ab4a2011-01-26 14:59:27 +00002180const struct dev_pm_ops snd_soc_pm_ops = {
Viresh Kumarb1dd5892012-02-24 16:25:49 +05302181 .suspend = snd_soc_suspend,
2182 .resume = snd_soc_resume,
2183 .freeze = snd_soc_suspend,
2184 .thaw = snd_soc_resume,
Mark Brown6f8ab4a2011-01-26 14:59:27 +00002185 .poweroff = snd_soc_poweroff,
Viresh Kumarb1dd5892012-02-24 16:25:49 +05302186 .restore = snd_soc_resume,
Mark Brown416356f2009-06-30 19:05:15 +01002187};
Stephen Warrendeb26072011-04-05 19:35:30 -06002188EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
Mark Brown416356f2009-06-30 19:05:15 +01002189
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002190/* ASoC platform driver */
2191static struct platform_driver soc_driver = {
2192 .driver = {
2193 .name = "soc-audio",
Mark Brown6f8ab4a2011-01-26 14:59:27 +00002194 .pm = &snd_soc_pm_ops,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002195 },
2196 .probe = soc_probe,
2197 .remove = soc_remove,
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002198};
2199
Mark Brown096e49d2009-07-05 15:12:22 +01002200/**
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002201 * snd_soc_cnew - create new control
2202 * @_template: control template
2203 * @data: control private data
Mark Brownac11a2b2009-01-01 12:18:17 +00002204 * @long_name: control long name
Mark Brownefb7ac32011-03-08 17:23:24 +00002205 * @prefix: control name prefix
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002206 *
2207 * Create a new mixer control from a template control.
2208 *
2209 * Returns 0 for success, else error.
2210 */
2211struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
Mark Brown30565572012-02-16 17:07:42 -08002212 void *data, const char *long_name,
Mark Brownefb7ac32011-03-08 17:23:24 +00002213 const char *prefix)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002214{
2215 struct snd_kcontrol_new template;
Mark Brownefb7ac32011-03-08 17:23:24 +00002216 struct snd_kcontrol *kcontrol;
2217 char *name = NULL;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002218
2219 memcpy(&template, _template, sizeof(template));
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002220 template.index = 0;
2221
Mark Brownefb7ac32011-03-08 17:23:24 +00002222 if (!long_name)
2223 long_name = template.name;
2224
2225 if (prefix) {
Lars-Peter Clausen2b581072013-05-14 11:05:32 +02002226 name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
Mark Brownefb7ac32011-03-08 17:23:24 +00002227 if (!name)
2228 return NULL;
2229
Mark Brownefb7ac32011-03-08 17:23:24 +00002230 template.name = name;
2231 } else {
2232 template.name = long_name;
2233 }
2234
2235 kcontrol = snd_ctl_new1(&template, data);
2236
2237 kfree(name);
2238
2239 return kcontrol;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002240}
2241EXPORT_SYMBOL_GPL(snd_soc_cnew);
2242
Liam Girdwood022658b2012-02-03 17:43:09 +00002243static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
2244 const struct snd_kcontrol_new *controls, int num_controls,
2245 const char *prefix, void *data)
2246{
2247 int err, i;
2248
2249 for (i = 0; i < num_controls; i++) {
2250 const struct snd_kcontrol_new *control = &controls[i];
2251 err = snd_ctl_add(card, snd_soc_cnew(control, data,
2252 control->name, prefix));
2253 if (err < 0) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00002254 dev_err(dev, "ASoC: Failed to add %s: %d\n",
2255 control->name, err);
Liam Girdwood022658b2012-02-03 17:43:09 +00002256 return err;
2257 }
2258 }
2259
2260 return 0;
2261}
2262
Dimitris Papastamos4fefd692013-07-29 13:51:58 +01002263struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
2264 const char *name)
2265{
2266 struct snd_card *card = soc_card->snd_card;
2267 struct snd_kcontrol *kctl;
2268
2269 if (unlikely(!name))
2270 return NULL;
2271
2272 list_for_each_entry(kctl, &card->controls, list)
2273 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name)))
2274 return kctl;
2275 return NULL;
2276}
2277EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol);
2278
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002279/**
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02002280 * snd_soc_add_component_controls - Add an array of controls to a component.
2281 *
2282 * @component: Component to add controls to
2283 * @controls: Array of controls to add
2284 * @num_controls: Number of elements in the array
2285 *
2286 * Return: 0 for success, else error.
2287 */
2288int snd_soc_add_component_controls(struct snd_soc_component *component,
2289 const struct snd_kcontrol_new *controls, unsigned int num_controls)
2290{
2291 struct snd_card *card = component->card->snd_card;
2292
2293 return snd_soc_add_controls(card, component->dev, controls,
2294 num_controls, component->name_prefix, component);
2295}
2296EXPORT_SYMBOL_GPL(snd_soc_add_component_controls);
2297
2298/**
Liam Girdwood022658b2012-02-03 17:43:09 +00002299 * snd_soc_add_codec_controls - add an array of controls to a codec.
2300 * Convenience function to add a list of controls. Many codecs were
Ian Molton3e8e1952009-01-09 00:23:21 +00002301 * duplicating this code.
2302 *
2303 * @codec: codec to add controls to
2304 * @controls: array of controls to add
2305 * @num_controls: number of elements in the array
2306 *
2307 * Return 0 for success, else error.
2308 */
Liam Girdwood022658b2012-02-03 17:43:09 +00002309int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02002310 const struct snd_kcontrol_new *controls, unsigned int num_controls)
Ian Molton3e8e1952009-01-09 00:23:21 +00002311{
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02002312 return snd_soc_add_component_controls(&codec->component, controls,
2313 num_controls);
Ian Molton3e8e1952009-01-09 00:23:21 +00002314}
Liam Girdwood022658b2012-02-03 17:43:09 +00002315EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls);
Ian Molton3e8e1952009-01-09 00:23:21 +00002316
2317/**
Liam Girdwooda491a5c2011-07-04 22:10:51 +01002318 * snd_soc_add_platform_controls - add an array of controls to a platform.
Liam Girdwood022658b2012-02-03 17:43:09 +00002319 * Convenience function to add a list of controls.
Liam Girdwooda491a5c2011-07-04 22:10:51 +01002320 *
2321 * @platform: platform to add controls to
2322 * @controls: array of controls to add
2323 * @num_controls: number of elements in the array
2324 *
2325 * Return 0 for success, else error.
2326 */
2327int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02002328 const struct snd_kcontrol_new *controls, unsigned int num_controls)
Liam Girdwooda491a5c2011-07-04 22:10:51 +01002329{
Lars-Peter Clausen0f2780a2014-07-17 22:01:08 +02002330 return snd_soc_add_component_controls(&platform->component, controls,
2331 num_controls);
Liam Girdwooda491a5c2011-07-04 22:10:51 +01002332}
2333EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
2334
2335/**
Liam Girdwood022658b2012-02-03 17:43:09 +00002336 * snd_soc_add_card_controls - add an array of controls to a SoC card.
2337 * Convenience function to add a list of controls.
2338 *
2339 * @soc_card: SoC card to add controls to
2340 * @controls: array of controls to add
2341 * @num_controls: number of elements in the array
2342 *
2343 * Return 0 for success, else error.
2344 */
2345int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
2346 const struct snd_kcontrol_new *controls, int num_controls)
2347{
2348 struct snd_card *card = soc_card->snd_card;
2349
2350 return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,
2351 NULL, soc_card);
2352}
2353EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
2354
2355/**
2356 * snd_soc_add_dai_controls - add an array of controls to a DAI.
2357 * Convienience function to add a list of controls.
2358 *
2359 * @dai: DAI to add controls to
2360 * @controls: array of controls to add
2361 * @num_controls: number of elements in the array
2362 *
2363 * Return 0 for success, else error.
2364 */
2365int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
2366 const struct snd_kcontrol_new *controls, int num_controls)
2367{
Lars-Peter Clausen313665b2014-11-04 11:30:58 +01002368 struct snd_card *card = dai->component->card->snd_card;
Liam Girdwood022658b2012-02-03 17:43:09 +00002369
2370 return snd_soc_add_controls(card, dai->dev, controls, num_controls,
2371 NULL, dai);
2372}
2373EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
2374
2375/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002376 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2377 * @dai: DAI
2378 * @clk_id: DAI specific clock ID
2379 * @freq: new clock frequency in Hz
2380 * @dir: new clock direction - input/output.
2381 *
2382 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2383 */
2384int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2385 unsigned int freq, int dir)
2386{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002387 if (dai->driver && dai->driver->ops->set_sysclk)
2388 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
Mark Brownec4ee522011-03-07 20:58:11 +00002389 else if (dai->codec && dai->codec->driver->set_sysclk)
Mark Brownda1c6ea2011-08-24 20:09:01 +01002390 return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,
Mark Brownec4ee522011-03-07 20:58:11 +00002391 freq, dir);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002392 else
Mark Brown1104a9c2014-01-15 19:04:19 +00002393 return -ENOTSUPP;
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002394}
2395EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
2396
2397/**
Mark Brownec4ee522011-03-07 20:58:11 +00002398 * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
2399 * @codec: CODEC
2400 * @clk_id: DAI specific clock ID
Mark Brownda1c6ea2011-08-24 20:09:01 +01002401 * @source: Source for the clock
Mark Brownec4ee522011-03-07 20:58:11 +00002402 * @freq: new clock frequency in Hz
2403 * @dir: new clock direction - input/output.
2404 *
2405 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
2406 */
2407int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
Mark Brownda1c6ea2011-08-24 20:09:01 +01002408 int source, unsigned int freq, int dir)
Mark Brownec4ee522011-03-07 20:58:11 +00002409{
2410 if (codec->driver->set_sysclk)
Mark Brownda1c6ea2011-08-24 20:09:01 +01002411 return codec->driver->set_sysclk(codec, clk_id, source,
2412 freq, dir);
Mark Brownec4ee522011-03-07 20:58:11 +00002413 else
Mark Brown1104a9c2014-01-15 19:04:19 +00002414 return -ENOTSUPP;
Mark Brownec4ee522011-03-07 20:58:11 +00002415}
2416EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
2417
2418/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002419 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
2420 * @dai: DAI
Mark Brownac11a2b2009-01-01 12:18:17 +00002421 * @div_id: DAI specific clock divider ID
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002422 * @div: new clock divisor.
2423 *
2424 * Configures the clock dividers. This is used to derive the best DAI bit and
2425 * frame clocks from the system or master clock. It's best to set the DAI bit
2426 * and frame clocks as low as possible to save system power.
2427 */
2428int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2429 int div_id, int div)
2430{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002431 if (dai->driver && dai->driver->ops->set_clkdiv)
2432 return dai->driver->ops->set_clkdiv(dai, div_id, div);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002433 else
2434 return -EINVAL;
2435}
2436EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
2437
2438/**
2439 * snd_soc_dai_set_pll - configure DAI PLL.
2440 * @dai: DAI
2441 * @pll_id: DAI specific PLL ID
Mark Brown85488032009-09-05 18:52:16 +01002442 * @source: DAI specific source for the PLL
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002443 * @freq_in: PLL input clock frequency in Hz
2444 * @freq_out: requested PLL output clock frequency in Hz
2445 *
2446 * Configures and enables PLL to generate output clock based on input clock.
2447 */
Mark Brown85488032009-09-05 18:52:16 +01002448int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
2449 unsigned int freq_in, unsigned int freq_out)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002450{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002451 if (dai->driver && dai->driver->ops->set_pll)
2452 return dai->driver->ops->set_pll(dai, pll_id, source,
Mark Brown85488032009-09-05 18:52:16 +01002453 freq_in, freq_out);
Mark Brownec4ee522011-03-07 20:58:11 +00002454 else if (dai->codec && dai->codec->driver->set_pll)
2455 return dai->codec->driver->set_pll(dai->codec, pll_id, source,
2456 freq_in, freq_out);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002457 else
2458 return -EINVAL;
2459}
2460EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
2461
Mark Brownec4ee522011-03-07 20:58:11 +00002462/*
2463 * snd_soc_codec_set_pll - configure codec PLL.
2464 * @codec: CODEC
2465 * @pll_id: DAI specific PLL ID
2466 * @source: DAI specific source for the PLL
2467 * @freq_in: PLL input clock frequency in Hz
2468 * @freq_out: requested PLL output clock frequency in Hz
2469 *
2470 * Configures and enables PLL to generate output clock based on input clock.
2471 */
2472int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
2473 unsigned int freq_in, unsigned int freq_out)
2474{
2475 if (codec->driver->set_pll)
2476 return codec->driver->set_pll(codec, pll_id, source,
2477 freq_in, freq_out);
2478 else
2479 return -EINVAL;
2480}
2481EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);
2482
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002483/**
Liam Girdwoode54cf762013-09-16 13:01:46 +01002484 * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
2485 * @dai: DAI
Masanari Iida231b86b2015-07-15 23:02:38 +09002486 * @ratio: Ratio of BCLK to Sample rate.
Liam Girdwoode54cf762013-09-16 13:01:46 +01002487 *
2488 * Configures the DAI for a preset BCLK to sample rate ratio.
2489 */
2490int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
2491{
2492 if (dai->driver && dai->driver->ops->set_bclk_ratio)
2493 return dai->driver->ops->set_bclk_ratio(dai, ratio);
2494 else
2495 return -EINVAL;
2496}
2497EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
2498
2499/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002500 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
2501 * @dai: DAI
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002502 * @fmt: SND_SOC_DAIFMT_ format value.
2503 *
2504 * Configures the DAI hardware format and clocking.
2505 */
2506int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2507{
Shawn Guo5e4ba562012-03-09 00:59:40 +08002508 if (dai->driver == NULL)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002509 return -EINVAL;
Shawn Guo5e4ba562012-03-09 00:59:40 +08002510 if (dai->driver->ops->set_fmt == NULL)
2511 return -ENOTSUPP;
2512 return dai->driver->ops->set_fmt(dai, fmt);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002513}
2514EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
2515
2516/**
Xiubo Lie5c21512014-03-21 14:17:12 +08002517 * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
Xiubo Li89c67852014-02-14 09:34:35 +08002518 * @slots: Number of slots in use.
2519 * @tx_mask: bitmask representing active TX slots.
2520 * @rx_mask: bitmask representing active RX slots.
2521 *
2522 * Generates the TDM tx and rx slot default masks for DAI.
2523 */
Xiubo Lie5c21512014-03-21 14:17:12 +08002524static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
Xiubo Li89c67852014-02-14 09:34:35 +08002525 unsigned int *tx_mask,
2526 unsigned int *rx_mask)
2527{
2528 if (*tx_mask || *rx_mask)
2529 return 0;
2530
2531 if (!slots)
2532 return -EINVAL;
2533
2534 *tx_mask = (1 << slots) - 1;
2535 *rx_mask = (1 << slots) - 1;
2536
2537 return 0;
2538}
2539
2540/**
Lars-Peter Clausene46c9362015-01-12 10:27:20 +01002541 * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
2542 * @dai: The DAI to configure
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002543 * @tx_mask: bitmask representing active TX slots.
2544 * @rx_mask: bitmask representing active RX slots.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002545 * @slots: Number of slots in use.
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002546 * @slot_width: Width in bits for each slot.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002547 *
Lars-Peter Clausene46c9362015-01-12 10:27:20 +01002548 * This function configures the specified DAI for TDM operation. @slot contains
2549 * the total number of slots of the TDM stream and @slot_with the width of each
2550 * slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
2551 * active slots of the TDM stream for the specified DAI, i.e. which slots the
2552 * DAI should write to or read from. If a bit is set the corresponding slot is
2553 * active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
2554 * the first slot, bit 1 to the second slot and so on. The first active slot
2555 * maps to the first channel of the DAI, the second active slot to the second
2556 * channel and so on.
2557 *
2558 * TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
2559 * @rx_mask and @slot_width will be ignored.
2560 *
2561 * Returns 0 on success, a negative error code otherwise.
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002562 */
2563int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002564 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002565{
Xiubo Lie5c21512014-03-21 14:17:12 +08002566 if (dai->driver && dai->driver->ops->xlate_tdm_slot_mask)
2567 dai->driver->ops->xlate_tdm_slot_mask(slots,
Xiubo Li89c67852014-02-14 09:34:35 +08002568 &tx_mask, &rx_mask);
2569 else
Xiubo Lie5c21512014-03-21 14:17:12 +08002570 snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
Xiubo Li89c67852014-02-14 09:34:35 +08002571
Benoit Cousson88bd8702014-07-08 23:19:34 +02002572 dai->tx_mask = tx_mask;
2573 dai->rx_mask = rx_mask;
2574
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002575 if (dai->driver && dai->driver->ops->set_tdm_slot)
2576 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
Daniel Ribeiroa5479e32009-06-15 21:44:31 -03002577 slots, slot_width);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002578 else
Xiubo Lib2cbb6e2014-01-23 13:02:47 +08002579 return -ENOTSUPP;
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002580}
2581EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
2582
2583/**
Barry Song472df3c2009-09-12 01:16:29 +08002584 * snd_soc_dai_set_channel_map - configure DAI audio channel map
2585 * @dai: DAI
2586 * @tx_num: how many TX channels
2587 * @tx_slot: pointer to an array which imply the TX slot number channel
2588 * 0~num-1 uses
2589 * @rx_num: how many RX channels
2590 * @rx_slot: pointer to an array which imply the RX slot number channel
2591 * 0~num-1 uses
2592 *
2593 * configure the relationship between channel number and TDM slot number.
2594 */
2595int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
2596 unsigned int tx_num, unsigned int *tx_slot,
2597 unsigned int rx_num, unsigned int *rx_slot)
2598{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002599 if (dai->driver && dai->driver->ops->set_channel_map)
2600 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
Barry Song472df3c2009-09-12 01:16:29 +08002601 rx_num, rx_slot);
2602 else
2603 return -EINVAL;
2604}
2605EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
2606
2607/**
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002608 * snd_soc_dai_set_tristate - configure DAI system or master clock.
2609 * @dai: DAI
2610 * @tristate: tristate enable
2611 *
2612 * Tristates the DAI so that others can use it.
2613 */
2614int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
2615{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002616 if (dai->driver && dai->driver->ops->set_tristate)
2617 return dai->driver->ops->set_tristate(dai, tristate);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002618 else
2619 return -EINVAL;
2620}
2621EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
2622
2623/**
2624 * snd_soc_dai_digital_mute - configure DAI system or master clock.
2625 * @dai: DAI
2626 * @mute: mute enable
Mark Brownda183962013-02-06 15:44:07 +00002627 * @direction: stream to mute
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002628 *
2629 * Mutes the DAI DAC.
2630 */
Mark Brownda183962013-02-06 15:44:07 +00002631int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
2632 int direction)
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002633{
Mark Brownda183962013-02-06 15:44:07 +00002634 if (!dai->driver)
2635 return -ENOTSUPP;
2636
2637 if (dai->driver->ops->mute_stream)
2638 return dai->driver->ops->mute_stream(dai, mute, direction);
2639 else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
2640 dai->driver->ops->digital_mute)
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002641 return dai->driver->ops->digital_mute(dai, mute);
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002642 else
Mark Brown04570c62012-04-13 19:16:03 +01002643 return -ENOTSUPP;
Liam Girdwood8c6529d2008-07-08 13:19:13 +01002644}
2645EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
2646
Mark Brownc5af3a22008-11-28 13:29:45 +00002647/**
2648 * snd_soc_register_card - Register a card with the ASoC core
2649 *
Mark Brownac11a2b2009-01-01 12:18:17 +00002650 * @card: Card to register
Mark Brownc5af3a22008-11-28 13:29:45 +00002651 *
Mark Brownc5af3a22008-11-28 13:29:45 +00002652 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05302653int snd_soc_register_card(struct snd_soc_card *card)
Mark Brownc5af3a22008-11-28 13:29:45 +00002654{
Mengdong Lin923c5e612015-11-23 11:01:49 -05002655 int i, ret;
Mengdong Lin1a497982015-11-18 02:34:11 -05002656 struct snd_soc_pcm_runtime *rtd;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002657
Mark Brownc5af3a22008-11-28 13:29:45 +00002658 if (!card->name || !card->dev)
2659 return -EINVAL;
2660
Stephen Warren5a504962011-12-21 10:40:59 -07002661 for (i = 0; i < card->num_links; i++) {
2662 struct snd_soc_dai_link *link = &card->dai_link[i];
2663
Mengdong Lin923c5e612015-11-23 11:01:49 -05002664 ret = soc_init_dai_link(card, link);
Benoit Cousson88bd8702014-07-08 23:19:34 +02002665 if (ret) {
Mengdong Lin923c5e612015-11-23 11:01:49 -05002666 dev_err(card->dev, "ASoC: failed to init link %s\n",
2667 link->name);
Benoit Cousson88bd8702014-07-08 23:19:34 +02002668 return ret;
Stephen Warren5a504962011-12-21 10:40:59 -07002669 }
Stephen Warren5a504962011-12-21 10:40:59 -07002670 }
2671
Mark Browned77cc12011-05-03 18:25:34 +01002672 dev_set_drvdata(card->dev, card);
2673
Stephen Warren111c6412011-01-28 14:26:35 -07002674 snd_soc_initialize_card_lists(card);
2675
Mengdong Linf8f80362015-12-02 14:11:22 +08002676 INIT_LIST_HEAD(&card->dai_link_list);
2677 card->num_dai_links = 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002678
Mengdong Lin1a497982015-11-18 02:34:11 -05002679 INIT_LIST_HEAD(&card->rtd_list);
Mark Brown91151712008-11-30 23:31:24 +00002680 card->num_rtd = 0;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002681
Mark Browndb432b42011-10-03 21:06:40 +01002682 INIT_LIST_HEAD(&card->dapm_dirty);
Liam Girdwood8a978232015-05-29 19:06:14 +01002683 INIT_LIST_HEAD(&card->dobj_list);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002684 card->instantiated = 0;
2685 mutex_init(&card->mutex);
Liam Girdwooda73fb2d2012-03-07 10:38:26 +00002686 mutex_init(&card->dapm_mutex);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002687
Mark Brownb19e6e72012-03-14 21:18:39 +00002688 ret = snd_soc_instantiate_card(card);
2689 if (ret != 0)
Kuninori Morimoto4e2576b2015-03-24 09:01:00 +00002690 return ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002691
Nicolin Chen988e8cc2013-11-04 14:57:31 +08002692 /* deactivate pins to sleep state */
Mengdong Lin1a497982015-11-18 02:34:11 -05002693 list_for_each_entry(rtd, &card->rtd_list, list) {
Benoit Cousson88bd8702014-07-08 23:19:34 +02002694 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2695 int j;
2696
2697 for (j = 0; j < rtd->num_codecs; j++) {
2698 struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
2699 if (!codec_dai->active)
2700 pinctrl_pm_select_sleep_state(codec_dai->dev);
2701 }
2702
Nicolin Chen988e8cc2013-11-04 14:57:31 +08002703 if (!cpu_dai->active)
2704 pinctrl_pm_select_sleep_state(cpu_dai->dev);
2705 }
2706
Mark Brownb19e6e72012-03-14 21:18:39 +00002707 return ret;
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002708}
Vinod Koul70a7ca32011-01-14 19:22:48 +05302709EXPORT_SYMBOL_GPL(snd_soc_register_card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002710
2711/**
2712 * snd_soc_unregister_card - Unregister a card with the ASoC core
2713 *
2714 * @card: Card to unregister
2715 *
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002716 */
Vinod Koul70a7ca32011-01-14 19:22:48 +05302717int snd_soc_unregister_card(struct snd_soc_card *card)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002718{
Lars-Peter Clausen01e0df62014-09-04 19:44:04 +02002719 if (card->instantiated) {
2720 card->instantiated = false;
Lars-Peter Clausen1c325f72014-09-04 19:44:05 +02002721 snd_soc_dapm_shutdown(card);
Vinod Koulb0e26482011-01-13 22:48:02 +05302722 soc_cleanup_card_resources(card);
Kuninori Morimoto8f6f9b22015-02-05 05:34:10 +00002723 dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
Lars-Peter Clausen01e0df62014-09-04 19:44:04 +02002724 }
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002725
2726 return 0;
2727}
Vinod Koul70a7ca32011-01-14 19:22:48 +05302728EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002729
2730/*
2731 * Simplify DAI link configuration by removing ".-1" from device names
2732 * and sanitizing names.
2733 */
Dimitris Papastamos0b9a2142010-12-06 15:49:20 +00002734static char *fmt_single_name(struct device *dev, int *id)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002735{
2736 char *found, name[NAME_SIZE];
2737 int id1, id2;
2738
2739 if (dev_name(dev) == NULL)
2740 return NULL;
2741
Dimitris Papastamos58818a72010-12-06 15:42:17 +00002742 strlcpy(name, dev_name(dev), NAME_SIZE);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02002743
2744 /* are we a "%s.%d" name (platform and SPI components) */
Mark Brownc5af3a22008-11-28 13:29:45 +00002745 found = strstr(name, dev->driver->name);
2746 if (found) {
2747 /* get ID */
2748 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
2749
2750 /* discard ID from name if ID == -1 */
2751 if (*id == -1)
2752 found[strlen(dev->driver->name)] = '\0';
2753 }
2754
2755 } else {
2756 /* I2C component devices are named "bus-addr" */
2757 if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
2758 char tmp[NAME_SIZE];
2759
2760 /* create unique ID number from I2C addr and bus */
2761 *id = ((id1 & 0xffff) << 16) + id2;
2762
2763 /* sanitize component name for DAI link creation */
2764 snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
Dimitris Papastamos58818a72010-12-06 15:42:17 +00002765 strlcpy(name, tmp, NAME_SIZE);
Mark Brownc5af3a22008-11-28 13:29:45 +00002766 } else
2767 *id = 0;
2768 }
2769
2770 return kstrdup(name, GFP_KERNEL);
2771}
2772
2773/*
2774 * Simplify DAI link naming for single devices with multiple DAIs by removing
2775 * any ".-1" and using the DAI name (instead of device name).
2776 */
2777static inline char *fmt_multiple_name(struct device *dev,
2778 struct snd_soc_dai_driver *dai_drv)
2779{
2780 if (dai_drv->name == NULL) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02002781 dev_err(dev,
2782 "ASoC: error - multiple DAI %s registered with no name\n",
2783 dev_name(dev));
Mark Brownc5af3a22008-11-28 13:29:45 +00002784 return NULL;
2785 }
2786
2787 return kstrdup(dai_drv->name, GFP_KERNEL);
2788}
2789
2790/**
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002791 * snd_soc_unregister_dai - Unregister DAIs from the ASoC core
Mark Brown91151712008-11-30 23:31:24 +00002792 *
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002793 * @component: The component for which the DAIs should be unregistered
Mark Brown91151712008-11-30 23:31:24 +00002794 */
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002795static void snd_soc_unregister_dais(struct snd_soc_component *component)
Mark Brown91151712008-11-30 23:31:24 +00002796{
Lars-Peter Clausen5c1d5f02014-03-12 08:34:39 +01002797 struct snd_soc_dai *dai, *_dai;
Mark Brown91151712008-11-30 23:31:24 +00002798
Lars-Peter Clausen5c1d5f02014-03-12 08:34:39 +01002799 list_for_each_entry_safe(dai, _dai, &component->dai_list, list) {
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002800 dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",
2801 dai->name);
Lars-Peter Clausen5c1d5f02014-03-12 08:34:39 +01002802 list_del(&dai->list);
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002803 kfree(dai->name);
Mark Brown91151712008-11-30 23:31:24 +00002804 kfree(dai);
Mark Brown91151712008-11-30 23:31:24 +00002805 }
Mark Brown91151712008-11-30 23:31:24 +00002806}
Mark Brown91151712008-11-30 23:31:24 +00002807
Mengdong Lin5e4fb372015-12-31 16:40:20 +08002808/* Create a DAI and add it to the component's DAI list */
2809static struct snd_soc_dai *soc_add_dai(struct snd_soc_component *component,
2810 struct snd_soc_dai_driver *dai_drv,
2811 bool legacy_dai_naming)
2812{
2813 struct device *dev = component->dev;
2814 struct snd_soc_dai *dai;
2815
2816 dev_dbg(dev, "ASoC: dynamically register DAI %s\n", dev_name(dev));
2817
2818 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
2819 if (dai == NULL)
2820 return NULL;
2821
2822 /*
2823 * Back in the old days when we still had component-less DAIs,
2824 * instead of having a static name, component-less DAIs would
2825 * inherit the name of the parent device so it is possible to
2826 * register multiple instances of the DAI. We still need to keep
2827 * the same naming style even though those DAIs are not
2828 * component-less anymore.
2829 */
2830 if (legacy_dai_naming &&
2831 (dai_drv->id == 0 || dai_drv->name == NULL)) {
2832 dai->name = fmt_single_name(dev, &dai->id);
2833 } else {
2834 dai->name = fmt_multiple_name(dev, dai_drv);
2835 if (dai_drv->id)
2836 dai->id = dai_drv->id;
2837 else
2838 dai->id = component->num_dai;
2839 }
2840 if (dai->name == NULL) {
2841 kfree(dai);
2842 return NULL;
2843 }
2844
2845 dai->component = component;
2846 dai->dev = dev;
2847 dai->driver = dai_drv;
2848 if (!dai->driver->ops)
2849 dai->driver->ops = &null_dai_ops;
2850
2851 list_add(&dai->list, &component->dai_list);
2852 component->num_dai++;
2853
2854 dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
2855 return dai;
2856}
2857
Mark Brown91151712008-11-30 23:31:24 +00002858/**
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002859 * snd_soc_register_dais - Register a DAI with the ASoC core
Mark Brown91151712008-11-30 23:31:24 +00002860 *
Lars-Peter Clausen6106d122014-03-05 13:17:46 +01002861 * @component: The component the DAIs are registered for
2862 * @dai_drv: DAI driver to use for the DAIs
Mark Brownac11a2b2009-01-01 12:18:17 +00002863 * @count: Number of DAIs
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002864 * @legacy_dai_naming: Use the legacy naming scheme and let the DAI inherit the
2865 * parent's name.
Mark Brown91151712008-11-30 23:31:24 +00002866 */
Lars-Peter Clausen6106d122014-03-05 13:17:46 +01002867static int snd_soc_register_dais(struct snd_soc_component *component,
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002868 struct snd_soc_dai_driver *dai_drv, size_t count,
2869 bool legacy_dai_naming)
Mark Brown91151712008-11-30 23:31:24 +00002870{
Lars-Peter Clausen6106d122014-03-05 13:17:46 +01002871 struct device *dev = component->dev;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002872 struct snd_soc_dai *dai;
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002873 unsigned int i;
2874 int ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002875
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00002876 dev_dbg(dev, "ASoC: dai register %s #%Zu\n", dev_name(dev), count);
Mark Brown91151712008-11-30 23:31:24 +00002877
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002878 component->dai_drv = dai_drv;
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002879
Mark Brown91151712008-11-30 23:31:24 +00002880 for (i = 0; i < count; i++) {
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00002881
Mengdong Lin5e4fb372015-12-31 16:40:20 +08002882 dai = soc_add_dai(component, dai_drv + i,
2883 count == 1 && legacy_dai_naming);
Axel Linc46e0072010-11-03 15:04:45 +08002884 if (dai == NULL) {
2885 ret = -ENOMEM;
2886 goto err;
2887 }
Mark Brown91151712008-11-30 23:31:24 +00002888 }
2889
2890 return 0;
2891
2892err:
Lars-Peter Clausen32c9ba52014-03-09 17:41:45 +01002893 snd_soc_unregister_dais(component);
Mark Brown91151712008-11-30 23:31:24 +00002894
2895 return ret;
2896}
Mark Brown91151712008-11-30 23:31:24 +00002897
Mengdong Lin68003e62015-12-31 16:40:43 +08002898/**
2899 * snd_soc_register_dai - Register a DAI dynamically & create its widgets
2900 *
2901 * @component: The component the DAIs are registered for
2902 * @dai_drv: DAI driver to use for the DAI
2903 *
2904 * Topology can use this API to register DAIs when probing a component.
2905 * These DAIs's widgets will be freed in the card cleanup and the DAIs
2906 * will be freed in the component cleanup.
2907 */
2908int snd_soc_register_dai(struct snd_soc_component *component,
2909 struct snd_soc_dai_driver *dai_drv)
2910{
2911 struct snd_soc_dapm_context *dapm =
2912 snd_soc_component_get_dapm(component);
2913 struct snd_soc_dai *dai;
2914 int ret;
2915
2916 if (dai_drv->dobj.type != SND_SOC_DOBJ_PCM) {
2917 dev_err(component->dev, "Invalid dai type %d\n",
2918 dai_drv->dobj.type);
2919 return -EINVAL;
2920 }
2921
2922 lockdep_assert_held(&client_mutex);
2923 dai = soc_add_dai(component, dai_drv, false);
2924 if (!dai)
2925 return -ENOMEM;
2926
2927 /* Create the DAI widgets here. After adding DAIs, topology may
2928 * also add routes that need these widgets as source or sink.
2929 */
2930 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
2931 if (ret != 0) {
2932 dev_err(component->dev,
2933 "Failed to create DAI widgets %d\n", ret);
2934 }
2935
2936 return ret;
2937}
2938EXPORT_SYMBOL_GPL(snd_soc_register_dai);
2939
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002940static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context *dapm,
2941 enum snd_soc_dapm_type type, int subseq)
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002942{
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002943 struct snd_soc_component *component = dapm->component;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002944
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002945 component->driver->seq_notifier(component, type, subseq);
2946}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002947
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002948static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,
2949 int event)
2950{
2951 struct snd_soc_component *component = dapm->component;
2952
2953 return component->driver->stream_event(component, event);
2954}
2955
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002956static int snd_soc_component_initialize(struct snd_soc_component *component,
2957 const struct snd_soc_component_driver *driver, struct device *dev)
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002958{
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02002959 struct snd_soc_dapm_context *dapm;
2960
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002961 component->name = fmt_single_name(dev, &component->id);
2962 if (!component->name) {
2963 dev_err(dev, "ASoC: Failed to allocate name\n");
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002964 return -ENOMEM;
2965 }
2966
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002967 component->dev = dev;
2968 component->driver = driver;
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02002969 component->probe = component->driver->probe;
2970 component->remove = component->driver->remove;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02002971
Lars-Peter Clausen48901402015-07-06 15:38:11 +02002972 dapm = &component->dapm;
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02002973 dapm->dev = dev;
2974 dapm->component = component;
2975 dapm->bias_level = SND_SOC_BIAS_OFF;
Lars-Peter Clausen5819c2f2014-08-24 15:36:55 +02002976 dapm->idle_bias_off = true;
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02002977 if (driver->seq_notifier)
2978 dapm->seq_notifier = snd_soc_component_seq_notifier;
2979 if (driver->stream_event)
2980 dapm->stream_event = snd_soc_component_stream_event;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002981
Lars-Peter Clausen61aca562014-08-19 15:51:21 +02002982 component->controls = driver->controls;
2983 component->num_controls = driver->num_controls;
2984 component->dapm_widgets = driver->dapm_widgets;
2985 component->num_dapm_widgets = driver->num_dapm_widgets;
2986 component->dapm_routes = driver->dapm_routes;
2987 component->num_dapm_routes = driver->num_dapm_routes;
2988
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002989 INIT_LIST_HEAD(&component->dai_list);
2990 mutex_init(&component->io_mutex);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002991
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02002992 return 0;
2993}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07002994
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01002995static void snd_soc_component_setup_regmap(struct snd_soc_component *component)
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02002996{
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01002997 int val_bytes = regmap_get_val_bytes(component->regmap);
2998
2999 /* Errors are legitimate for non-integer byte multiples */
3000 if (val_bytes > 0)
3001 component->val_bytes = val_bytes;
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02003002}
3003
Lars-Peter Clausene874bf52014-11-25 21:41:03 +01003004#ifdef CONFIG_REGMAP
3005
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01003006/**
3007 * snd_soc_component_init_regmap() - Initialize regmap instance for the component
3008 * @component: The component for which to initialize the regmap instance
3009 * @regmap: The regmap instance that should be used by the component
3010 *
3011 * This function allows deferred assignment of the regmap instance that is
3012 * associated with the component. Only use this if the regmap instance is not
3013 * yet ready when the component is registered. The function must also be called
3014 * before the first IO attempt of the component.
3015 */
3016void snd_soc_component_init_regmap(struct snd_soc_component *component,
3017 struct regmap *regmap)
3018{
3019 component->regmap = regmap;
3020 snd_soc_component_setup_regmap(component);
3021}
3022EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap);
3023
3024/**
3025 * snd_soc_component_exit_regmap() - De-initialize regmap instance for the component
3026 * @component: The component for which to de-initialize the regmap instance
3027 *
3028 * Calls regmap_exit() on the regmap instance associated to the component and
3029 * removes the regmap instance from the component.
3030 *
3031 * This function should only be used if snd_soc_component_init_regmap() was used
3032 * to initialize the regmap instance.
3033 */
3034void snd_soc_component_exit_regmap(struct snd_soc_component *component)
3035{
3036 regmap_exit(component->regmap);
3037 component->regmap = NULL;
3038}
3039EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap);
3040
Lars-Peter Clausene874bf52014-11-25 21:41:03 +01003041#endif
3042
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003043static void snd_soc_component_add_unlocked(struct snd_soc_component *component)
3044{
Lars-Peter Clausen20feb882014-11-18 19:45:52 +01003045 if (!component->write && !component->read) {
3046 if (!component->regmap)
3047 component->regmap = dev_get_regmap(component->dev, NULL);
3048 if (component->regmap)
3049 snd_soc_component_setup_regmap(component);
3050 }
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02003051
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003052 list_add(&component->list, &component_list);
Liam Girdwood8a978232015-05-29 19:06:14 +01003053 INIT_LIST_HEAD(&component->dobj_list);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003054}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003055
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003056static void snd_soc_component_add(struct snd_soc_component *component)
3057{
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003058 mutex_lock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003059 snd_soc_component_add_unlocked(component);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003060 mutex_unlock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003061}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003062
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003063static void snd_soc_component_cleanup(struct snd_soc_component *component)
3064{
3065 snd_soc_unregister_dais(component);
3066 kfree(component->name);
3067}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003068
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003069static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
3070{
3071 list_del(&component->list);
3072}
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003073
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003074int snd_soc_register_component(struct device *dev,
3075 const struct snd_soc_component_driver *cmpnt_drv,
3076 struct snd_soc_dai_driver *dai_drv,
3077 int num_dai)
3078{
3079 struct snd_soc_component *cmpnt;
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003080 int ret;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003081
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003082 cmpnt = kzalloc(sizeof(*cmpnt), GFP_KERNEL);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003083 if (!cmpnt) {
3084 dev_err(dev, "ASoC: Failed to allocate memory\n");
3085 return -ENOMEM;
3086 }
3087
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003088 ret = snd_soc_component_initialize(cmpnt, cmpnt_drv, dev);
3089 if (ret)
3090 goto err_free;
3091
Lars-Peter Clausen3d594002014-03-05 13:17:48 +01003092 cmpnt->ignore_pmdown_time = true;
Lars-Peter Clausen98e639f2014-03-18 09:02:11 +01003093 cmpnt->registered_as_component = true;
Lars-Peter Clausen3d594002014-03-05 13:17:48 +01003094
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003095 ret = snd_soc_register_dais(cmpnt, dai_drv, num_dai, true);
3096 if (ret < 0) {
Masanari Iidaf42cf8d2015-02-24 23:11:26 +09003097 dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003098 goto err_cleanup;
3099 }
3100
3101 snd_soc_component_add(cmpnt);
3102
3103 return 0;
3104
3105err_cleanup:
3106 snd_soc_component_cleanup(cmpnt);
3107err_free:
3108 kfree(cmpnt);
3109 return ret;
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003110}
3111EXPORT_SYMBOL_GPL(snd_soc_register_component);
3112
3113/**
3114 * snd_soc_unregister_component - Unregister a component from the ASoC core
3115 *
Jonathan Corbet628536e2015-08-25 01:14:48 -06003116 * @dev: The device to unregister
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003117 */
3118void snd_soc_unregister_component(struct device *dev)
3119{
3120 struct snd_soc_component *cmpnt;
3121
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003122 mutex_lock(&client_mutex);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003123 list_for_each_entry(cmpnt, &component_list, list) {
Lars-Peter Clausen98e639f2014-03-18 09:02:11 +01003124 if (dev == cmpnt->dev && cmpnt->registered_as_component)
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003125 goto found;
3126 }
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003127 mutex_unlock(&client_mutex);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003128 return;
3129
3130found:
Liam Girdwood8a978232015-05-29 19:06:14 +01003131 snd_soc_tplg_component_remove(cmpnt, SND_SOC_TPLG_INDEX_ALL);
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003132 snd_soc_component_del_unlocked(cmpnt);
3133 mutex_unlock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003134 snd_soc_component_cleanup(cmpnt);
3135 kfree(cmpnt);
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003136}
3137EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
3138
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003139static int snd_soc_platform_drv_probe(struct snd_soc_component *component)
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003140{
3141 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
3142
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003143 return platform->driver->probe(platform);
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003144}
3145
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003146static void snd_soc_platform_drv_remove(struct snd_soc_component *component)
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003147{
3148 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
3149
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003150 platform->driver->remove(platform);
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003151}
3152
Kuninori Morimotod191bd82013-09-04 19:39:03 -07003153/**
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003154 * snd_soc_add_platform - Add a platform to the ASoC core
3155 * @dev: The parent device for the platform
3156 * @platform: The platform to add
Masanari Iida7d1442b2015-07-15 23:02:39 +09003157 * @platform_drv: The driver for the platform
Mark Brown12a48a8c2008-12-03 19:40:30 +00003158 */
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003159int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
Lars-Peter Clausend79e57d2013-03-27 12:02:22 +01003160 const struct snd_soc_platform_driver *platform_drv)
Mark Brown12a48a8c2008-12-03 19:40:30 +00003161{
Lars-Peter Clausenb37f1d12014-03-18 09:02:12 +01003162 int ret;
3163
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003164 ret = snd_soc_component_initialize(&platform->component,
3165 &platform_drv->component_driver, dev);
3166 if (ret)
3167 return ret;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003168
3169 platform->dev = dev;
3170 platform->driver = platform_drv;
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003171
3172 if (platform_drv->probe)
3173 platform->component.probe = snd_soc_platform_drv_probe;
3174 if (platform_drv->remove)
3175 platform->component.remove = snd_soc_platform_drv_remove;
Mark Brown12a48a8c2008-12-03 19:40:30 +00003176
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +02003177#ifdef CONFIG_DEBUG_FS
3178 platform->component.debugfs_prefix = "platform";
3179#endif
Mark Brown12a48a8c2008-12-03 19:40:30 +00003180
3181 mutex_lock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003182 snd_soc_component_add_unlocked(&platform->component);
Mark Brown12a48a8c2008-12-03 19:40:30 +00003183 list_add(&platform->list, &platform_list);
3184 mutex_unlock(&client_mutex);
3185
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003186 dev_dbg(dev, "ASoC: Registered platform '%s'\n",
3187 platform->component.name);
Mark Brown12a48a8c2008-12-03 19:40:30 +00003188
3189 return 0;
3190}
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003191EXPORT_SYMBOL_GPL(snd_soc_add_platform);
3192
3193/**
3194 * snd_soc_register_platform - Register a platform with the ASoC core
3195 *
Jonathan Corbet628536e2015-08-25 01:14:48 -06003196 * @dev: The device for the platform
3197 * @platform_drv: The driver for the platform
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003198 */
3199int snd_soc_register_platform(struct device *dev,
3200 const struct snd_soc_platform_driver *platform_drv)
3201{
3202 struct snd_soc_platform *platform;
3203 int ret;
3204
3205 dev_dbg(dev, "ASoC: platform register %s\n", dev_name(dev));
3206
3207 platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
3208 if (platform == NULL)
3209 return -ENOMEM;
3210
3211 ret = snd_soc_add_platform(dev, platform, platform_drv);
3212 if (ret)
3213 kfree(platform);
3214
3215 return ret;
3216}
Mark Brown12a48a8c2008-12-03 19:40:30 +00003217EXPORT_SYMBOL_GPL(snd_soc_register_platform);
3218
3219/**
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003220 * snd_soc_remove_platform - Remove a platform from the ASoC core
3221 * @platform: the platform to remove
3222 */
3223void snd_soc_remove_platform(struct snd_soc_platform *platform)
3224{
Lars-Peter Clausenb37f1d12014-03-18 09:02:12 +01003225
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003226 mutex_lock(&client_mutex);
3227 list_del(&platform->list);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003228 snd_soc_component_del_unlocked(&platform->component);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003229 mutex_unlock(&client_mutex);
3230
3231 dev_dbg(platform->dev, "ASoC: Unregistered platform '%s'\n",
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003232 platform->component.name);
Daniel Mackdecc27b2014-10-07 13:41:23 +02003233
3234 snd_soc_component_cleanup(&platform->component);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003235}
3236EXPORT_SYMBOL_GPL(snd_soc_remove_platform);
3237
3238struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev)
3239{
3240 struct snd_soc_platform *platform;
3241
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003242 mutex_lock(&client_mutex);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003243 list_for_each_entry(platform, &platform_list, list) {
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003244 if (dev == platform->dev) {
3245 mutex_unlock(&client_mutex);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003246 return platform;
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003247 }
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003248 }
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003249 mutex_unlock(&client_mutex);
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003250
3251 return NULL;
3252}
3253EXPORT_SYMBOL_GPL(snd_soc_lookup_platform);
3254
3255/**
Mark Brown12a48a8c2008-12-03 19:40:30 +00003256 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
3257 *
Jonathan Corbet628536e2015-08-25 01:14:48 -06003258 * @dev: platform to unregister
Mark Brown12a48a8c2008-12-03 19:40:30 +00003259 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003260void snd_soc_unregister_platform(struct device *dev)
Mark Brown12a48a8c2008-12-03 19:40:30 +00003261{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003262 struct snd_soc_platform *platform;
3263
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003264 platform = snd_soc_lookup_platform(dev);
3265 if (!platform)
3266 return;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003267
Lars-Peter Clausen71a45cd2013-04-15 19:19:49 +02003268 snd_soc_remove_platform(platform);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003269 kfree(platform);
Mark Brown12a48a8c2008-12-03 19:40:30 +00003270}
3271EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
3272
Mark Brown151ab222009-05-09 16:22:58 +01003273static u64 codec_format_map[] = {
3274 SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
3275 SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
3276 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
3277 SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
3278 SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
3279 SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
3280 SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3281 SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
3282 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
3283 SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
3284 SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
3285 SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
3286 SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
3287 SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
3288 SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
3289 | SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
3290};
3291
3292/* Fix up the DAI formats for endianness: codecs don't actually see
3293 * the endianness of the data but we're using the CPU format
3294 * definitions which do need to include endianness so we ensure that
3295 * codec DAIs always have both big and little endian variants set.
3296 */
3297static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
3298{
3299 int i;
3300
3301 for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
3302 if (stream->formats & codec_format_map[i])
3303 stream->formats |= codec_format_map[i];
3304}
3305
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003306static int snd_soc_codec_drv_probe(struct snd_soc_component *component)
3307{
3308 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3309
3310 return codec->driver->probe(codec);
3311}
3312
3313static void snd_soc_codec_drv_remove(struct snd_soc_component *component)
3314{
3315 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3316
3317 codec->driver->remove(codec);
3318}
3319
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003320static int snd_soc_codec_drv_write(struct snd_soc_component *component,
3321 unsigned int reg, unsigned int val)
3322{
3323 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3324
3325 return codec->driver->write(codec, reg, val);
3326}
3327
3328static int snd_soc_codec_drv_read(struct snd_soc_component *component,
3329 unsigned int reg, unsigned int *val)
3330{
3331 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3332
3333 *val = codec->driver->read(codec, reg);
3334
3335 return 0;
3336}
3337
Lars-Peter Clausen68f831c2014-06-16 18:13:05 +02003338static int snd_soc_codec_set_bias_level(struct snd_soc_dapm_context *dapm,
3339 enum snd_soc_bias_level level)
3340{
3341 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
3342
3343 return codec->driver->set_bias_level(codec, level);
3344}
3345
Mark Brown0d0cf002008-12-10 14:32:45 +00003346/**
3347 * snd_soc_register_codec - Register a codec with the ASoC core
3348 *
Jonathan Corbet628536e2015-08-25 01:14:48 -06003349 * @dev: The parent device for this codec
3350 * @codec_drv: Codec driver
3351 * @dai_drv: The associated DAI driver
3352 * @num_dai: Number of DAIs
Mark Brown0d0cf002008-12-10 14:32:45 +00003353 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003354int snd_soc_register_codec(struct device *dev,
Mark Brown001ae4c2010-12-02 16:21:08 +00003355 const struct snd_soc_codec_driver *codec_drv,
3356 struct snd_soc_dai_driver *dai_drv,
3357 int num_dai)
Mark Brown0d0cf002008-12-10 14:32:45 +00003358{
Lars-Peter Clausen48901402015-07-06 15:38:11 +02003359 struct snd_soc_dapm_context *dapm;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003360 struct snd_soc_codec *codec;
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003361 struct snd_soc_dai *dai;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003362 int ret, i;
Mark Brown151ab222009-05-09 16:22:58 +01003363
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003364 dev_dbg(dev, "codec register %s\n", dev_name(dev));
Mark Brown0d0cf002008-12-10 14:32:45 +00003365
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003366 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
3367 if (codec == NULL)
3368 return -ENOMEM;
Mark Brown0d0cf002008-12-10 14:32:45 +00003369
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003370 codec->component.codec = codec;
Lars-Peter Clausence0fc932014-06-16 18:13:06 +02003371
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003372 ret = snd_soc_component_initialize(&codec->component,
3373 &codec_drv->component_driver, dev);
3374 if (ret)
3375 goto err_free;
Mark Brown151ab222009-05-09 16:22:58 +01003376
Lars-Peter Clausenf1d45cc32014-08-19 15:51:19 +02003377 if (codec_drv->probe)
3378 codec->component.probe = snd_soc_codec_drv_probe;
3379 if (codec_drv->remove)
3380 codec->component.remove = snd_soc_codec_drv_remove;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003381 if (codec_drv->write)
3382 codec->component.write = snd_soc_codec_drv_write;
3383 if (codec_drv->read)
3384 codec->component.read = snd_soc_codec_drv_read;
Lars-Peter Clausen3d594002014-03-05 13:17:48 +01003385 codec->component.ignore_pmdown_time = codec_drv->ignore_pmdown_time;
Lars-Peter Clausen48901402015-07-06 15:38:11 +02003386
3387 dapm = snd_soc_codec_get_dapm(codec);
3388 dapm->idle_bias_off = codec_drv->idle_bias_off;
3389 dapm->suspend_bias_off = codec_drv->suspend_bias_off;
Lars-Peter Clausen14e8bde2014-06-16 18:13:08 +02003390 if (codec_drv->seq_notifier)
Lars-Peter Clausen48901402015-07-06 15:38:11 +02003391 dapm->seq_notifier = codec_drv->seq_notifier;
Lars-Peter Clausen68f831c2014-06-16 18:13:05 +02003392 if (codec_drv->set_bias_level)
Lars-Peter Clausen48901402015-07-06 15:38:11 +02003393 dapm->set_bias_level = snd_soc_codec_set_bias_level;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003394 codec->dev = dev;
3395 codec->driver = codec_drv;
Lars-Peter Clausene2c330b2014-04-22 13:23:13 +02003396 codec->component.val_bytes = codec_drv->reg_word_size;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003397
Lars-Peter Clausen81c7cfd2014-08-19 15:51:18 +02003398#ifdef CONFIG_DEBUG_FS
3399 codec->component.init_debugfs = soc_init_codec_debugfs;
3400 codec->component.debugfs_prefix = "codec";
3401#endif
Xiubo Lia39f75f2014-03-26 13:40:23 +08003402
Lars-Peter Clausen886f5692014-08-19 15:51:28 +02003403 if (codec_drv->get_regmap)
3404 codec->component.regmap = codec_drv->get_regmap(dev);
Xiubo Lia39f75f2014-03-26 13:40:23 +08003405
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003406 for (i = 0; i < num_dai; i++) {
3407 fixup_codec_formats(&dai_drv[i].playback);
3408 fixup_codec_formats(&dai_drv[i].capture);
3409 }
3410
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003411 ret = snd_soc_register_dais(&codec->component, dai_drv, num_dai, false);
3412 if (ret < 0) {
Masanari Iidaf42cf8d2015-02-24 23:11:26 +09003413 dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003414 goto err_cleanup;
3415 }
3416
3417 list_for_each_entry(dai, &codec->component.dai_list, list)
3418 dai->codec = codec;
3419
Mark Brown054880f2012-04-09 17:29:19 +01003420 mutex_lock(&client_mutex);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003421 snd_soc_component_add_unlocked(&codec->component);
Mark Brown054880f2012-04-09 17:29:19 +01003422 list_add(&codec->list, &codec_list);
3423 mutex_unlock(&client_mutex);
3424
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003425 dev_dbg(codec->dev, "ASoC: Registered codec '%s'\n",
3426 codec->component.name);
Mark Brown0d0cf002008-12-10 14:32:45 +00003427 return 0;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003428
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003429err_cleanup:
3430 snd_soc_component_cleanup(&codec->component);
3431err_free:
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003432 kfree(codec);
3433 return ret;
Mark Brown0d0cf002008-12-10 14:32:45 +00003434}
3435EXPORT_SYMBOL_GPL(snd_soc_register_codec);
3436
3437/**
3438 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
3439 *
Jonathan Corbet628536e2015-08-25 01:14:48 -06003440 * @dev: codec to unregister
Mark Brown0d0cf002008-12-10 14:32:45 +00003441 */
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003442void snd_soc_unregister_codec(struct device *dev)
Mark Brown0d0cf002008-12-10 14:32:45 +00003443{
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003444 struct snd_soc_codec *codec;
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003445
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003446 mutex_lock(&client_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003447 list_for_each_entry(codec, &codec_list, list) {
3448 if (dev == codec->dev)
3449 goto found;
3450 }
Lars-Peter Clausen34e81ab2015-03-07 19:34:03 +01003451 mutex_unlock(&client_mutex);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003452 return;
3453
3454found:
Mark Brown0d0cf002008-12-10 14:32:45 +00003455 list_del(&codec->list);
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003456 snd_soc_component_del_unlocked(&codec->component);
Mark Brown0d0cf002008-12-10 14:32:45 +00003457 mutex_unlock(&client_mutex);
3458
Lars-Peter Clausenf4333202014-06-16 18:13:02 +02003459 dev_dbg(codec->dev, "ASoC: Unregistered codec '%s'\n",
3460 codec->component.name);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003461
Lars-Peter Clausenbb131092014-06-16 18:13:03 +02003462 snd_soc_component_cleanup(&codec->component);
Dimitris Papastamos7a30a3d2010-11-11 10:04:57 +00003463 snd_soc_cache_exit(codec);
Liam Girdwoodf0fba2a2010-03-17 20:15:21 +00003464 kfree(codec);
Mark Brown0d0cf002008-12-10 14:32:45 +00003465}
3466EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
3467
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003468/* Retrieve a card's name from device tree */
3469int snd_soc_of_parse_card_name(struct snd_soc_card *card,
3470 const char *propname)
3471{
Tushar Behera7e07e7c2014-07-04 14:23:00 +05303472 struct device_node *np;
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003473 int ret;
3474
Tushar Behera7e07e7c2014-07-04 14:23:00 +05303475 if (!card->dev) {
3476 pr_err("card->dev is not set before calling %s\n", __func__);
3477 return -EINVAL;
3478 }
3479
3480 np = card->dev->of_node;
3481
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003482 ret = of_property_read_string_index(np, propname, 0, &card->name);
3483 /*
3484 * EINVAL means the property does not exist. This is fine providing
3485 * card->name was previously set, which is checked later in
3486 * snd_soc_register_card.
3487 */
3488 if (ret < 0 && ret != -EINVAL) {
3489 dev_err(card->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00003490 "ASoC: Property '%s' could not be read: %d\n",
Stephen Warrenbec4fa02011-12-12 15:55:34 -07003491 propname, ret);
3492 return ret;
3493 }
3494
3495 return 0;
3496}
3497EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
3498
Xiubo Li9a6d4862014-02-08 15:59:52 +08003499static const struct snd_soc_dapm_widget simple_widgets[] = {
3500 SND_SOC_DAPM_MIC("Microphone", NULL),
3501 SND_SOC_DAPM_LINE("Line", NULL),
3502 SND_SOC_DAPM_HP("Headphone", NULL),
3503 SND_SOC_DAPM_SPK("Speaker", NULL),
3504};
3505
3506int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
3507 const char *propname)
3508{
3509 struct device_node *np = card->dev->of_node;
3510 struct snd_soc_dapm_widget *widgets;
3511 const char *template, *wname;
3512 int i, j, num_widgets, ret;
3513
3514 num_widgets = of_property_count_strings(np, propname);
3515 if (num_widgets < 0) {
3516 dev_err(card->dev,
3517 "ASoC: Property '%s' does not exist\n", propname);
3518 return -EINVAL;
3519 }
3520 if (num_widgets & 1) {
3521 dev_err(card->dev,
3522 "ASoC: Property '%s' length is not even\n", propname);
3523 return -EINVAL;
3524 }
3525
3526 num_widgets /= 2;
3527 if (!num_widgets) {
3528 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
3529 propname);
3530 return -EINVAL;
3531 }
3532
3533 widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets),
3534 GFP_KERNEL);
3535 if (!widgets) {
3536 dev_err(card->dev,
3537 "ASoC: Could not allocate memory for widgets\n");
3538 return -ENOMEM;
3539 }
3540
3541 for (i = 0; i < num_widgets; i++) {
3542 ret = of_property_read_string_index(np, propname,
3543 2 * i, &template);
3544 if (ret) {
3545 dev_err(card->dev,
3546 "ASoC: Property '%s' index %d read error:%d\n",
3547 propname, 2 * i, ret);
3548 return -EINVAL;
3549 }
3550
3551 for (j = 0; j < ARRAY_SIZE(simple_widgets); j++) {
3552 if (!strncmp(template, simple_widgets[j].name,
3553 strlen(simple_widgets[j].name))) {
3554 widgets[i] = simple_widgets[j];
3555 break;
3556 }
3557 }
3558
3559 if (j >= ARRAY_SIZE(simple_widgets)) {
3560 dev_err(card->dev,
3561 "ASoC: DAPM widget '%s' is not supported\n",
3562 template);
3563 return -EINVAL;
3564 }
3565
3566 ret = of_property_read_string_index(np, propname,
3567 (2 * i) + 1,
3568 &wname);
3569 if (ret) {
3570 dev_err(card->dev,
3571 "ASoC: Property '%s' index %d read error:%d\n",
3572 propname, (2 * i) + 1, ret);
3573 return -EINVAL;
3574 }
3575
3576 widgets[i].name = wname;
3577 }
3578
Nicolin Chenf23e8602015-02-14 17:22:49 -08003579 card->of_dapm_widgets = widgets;
3580 card->num_of_dapm_widgets = num_widgets;
Xiubo Li9a6d4862014-02-08 15:59:52 +08003581
3582 return 0;
3583}
3584EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets);
3585
Jyri Sarha61310842015-09-09 21:27:43 +03003586static int snd_soc_of_get_slot_mask(struct device_node *np,
3587 const char *prop_name,
3588 unsigned int *mask)
3589{
3590 u32 val;
Jyri Sarha6c84e5912015-09-17 13:13:38 +03003591 const __be32 *of_slot_mask = of_get_property(np, prop_name, &val);
Jyri Sarha61310842015-09-09 21:27:43 +03003592 int i;
3593
3594 if (!of_slot_mask)
3595 return 0;
3596 val /= sizeof(u32);
3597 for (i = 0; i < val; i++)
3598 if (be32_to_cpup(&of_slot_mask[i]))
3599 *mask |= (1 << i);
3600
3601 return val;
3602}
3603
Xiubo Li89c67852014-02-14 09:34:35 +08003604int snd_soc_of_parse_tdm_slot(struct device_node *np,
Jyri Sarha61310842015-09-09 21:27:43 +03003605 unsigned int *tx_mask,
3606 unsigned int *rx_mask,
Xiubo Li89c67852014-02-14 09:34:35 +08003607 unsigned int *slots,
3608 unsigned int *slot_width)
3609{
3610 u32 val;
3611 int ret;
3612
Jyri Sarha61310842015-09-09 21:27:43 +03003613 if (tx_mask)
3614 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask", tx_mask);
3615 if (rx_mask)
3616 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask", rx_mask);
3617
Xiubo Li89c67852014-02-14 09:34:35 +08003618 if (of_property_read_bool(np, "dai-tdm-slot-num")) {
3619 ret = of_property_read_u32(np, "dai-tdm-slot-num", &val);
3620 if (ret)
3621 return ret;
3622
3623 if (slots)
3624 *slots = val;
3625 }
3626
3627 if (of_property_read_bool(np, "dai-tdm-slot-width")) {
3628 ret = of_property_read_u32(np, "dai-tdm-slot-width", &val);
3629 if (ret)
3630 return ret;
3631
3632 if (slot_width)
3633 *slot_width = val;
3634 }
3635
3636 return 0;
3637}
3638EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot);
3639
Kuninori Morimoto5e3cdaa2015-07-15 07:07:42 +00003640void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
3641 struct snd_soc_codec_conf *codec_conf,
3642 struct device_node *of_node,
3643 const char *propname)
3644{
3645 struct device_node *np = card->dev->of_node;
3646 const char *str;
3647 int ret;
3648
3649 ret = of_property_read_string(np, propname, &str);
3650 if (ret < 0) {
3651 /* no prefix is not error */
3652 return;
3653 }
3654
3655 codec_conf->of_node = of_node;
3656 codec_conf->name_prefix = str;
3657}
3658EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_prefix);
3659
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003660int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
3661 const char *propname)
3662{
3663 struct device_node *np = card->dev->of_node;
Mark Browne3b1e6a2014-12-18 11:46:38 +00003664 int num_routes;
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003665 struct snd_soc_dapm_route *routes;
3666 int i, ret;
3667
3668 num_routes = of_property_count_strings(np, propname);
Richard Zhaoc34ce322012-04-24 15:24:43 +08003669 if (num_routes < 0 || num_routes & 1) {
Michał Mirosław10e8aa92013-05-04 22:21:38 +02003670 dev_err(card->dev,
3671 "ASoC: Property '%s' does not exist or its length is not even\n",
3672 propname);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003673 return -EINVAL;
3674 }
3675 num_routes /= 2;
3676 if (!num_routes) {
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00003677 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003678 propname);
3679 return -EINVAL;
3680 }
3681
Mark Browne3b1e6a2014-12-18 11:46:38 +00003682 routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003683 GFP_KERNEL);
3684 if (!routes) {
3685 dev_err(card->dev,
Liam Girdwoodf110bfc2012-11-19 14:47:09 +00003686 "ASoC: Could not allocate DAPM route table\n");
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003687 return -EINVAL;
3688 }
3689
3690 for (i = 0; i < num_routes; i++) {
3691 ret = of_property_read_string_index(np, propname,
Mark Browne3b1e6a2014-12-18 11:46:38 +00003692 2 * i, &routes[i].sink);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003693 if (ret) {
Mark Brownc871bd02012-12-10 16:19:52 +09003694 dev_err(card->dev,
3695 "ASoC: Property '%s' index %d could not be read: %d\n",
3696 propname, 2 * i, ret);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003697 return -EINVAL;
3698 }
3699 ret = of_property_read_string_index(np, propname,
Mark Browne3b1e6a2014-12-18 11:46:38 +00003700 (2 * i) + 1, &routes[i].source);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003701 if (ret) {
3702 dev_err(card->dev,
Mark Brownc871bd02012-12-10 16:19:52 +09003703 "ASoC: Property '%s' index %d could not be read: %d\n",
3704 propname, (2 * i) + 1, ret);
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003705 return -EINVAL;
3706 }
3707 }
3708
Nicolin Chenf23e8602015-02-14 17:22:49 -08003709 card->num_of_dapm_routes = num_routes;
3710 card->of_dapm_routes = routes;
Stephen Warrena4a54dd2011-12-12 15:55:35 -07003711
3712 return 0;
3713}
3714EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
3715
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003716unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
Jyri Sarha389cb832014-03-24 12:15:24 +02003717 const char *prefix,
3718 struct device_node **bitclkmaster,
3719 struct device_node **framemaster)
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003720{
3721 int ret, i;
3722 char prop[128];
3723 unsigned int format = 0;
3724 int bit, frame;
3725 const char *str;
3726 struct {
3727 char *name;
3728 unsigned int val;
3729 } of_fmt_table[] = {
3730 { "i2s", SND_SOC_DAIFMT_I2S },
3731 { "right_j", SND_SOC_DAIFMT_RIGHT_J },
3732 { "left_j", SND_SOC_DAIFMT_LEFT_J },
3733 { "dsp_a", SND_SOC_DAIFMT_DSP_A },
3734 { "dsp_b", SND_SOC_DAIFMT_DSP_B },
3735 { "ac97", SND_SOC_DAIFMT_AC97 },
3736 { "pdm", SND_SOC_DAIFMT_PDM},
3737 { "msb", SND_SOC_DAIFMT_MSB },
3738 { "lsb", SND_SOC_DAIFMT_LSB },
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003739 };
3740
3741 if (!prefix)
3742 prefix = "";
3743
3744 /*
3745 * check "[prefix]format = xxx"
3746 * SND_SOC_DAIFMT_FORMAT_MASK area
3747 */
3748 snprintf(prop, sizeof(prop), "%sformat", prefix);
3749 ret = of_property_read_string(np, prop, &str);
3750 if (ret == 0) {
3751 for (i = 0; i < ARRAY_SIZE(of_fmt_table); i++) {
3752 if (strcmp(str, of_fmt_table[i].name) == 0) {
3753 format |= of_fmt_table[i].val;
3754 break;
3755 }
3756 }
3757 }
3758
3759 /*
Kuninori Morimoto8c2d6a92013-01-29 21:03:36 -08003760 * check "[prefix]continuous-clock"
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003761 * SND_SOC_DAIFMT_CLOCK_MASK area
3762 */
Kuninori Morimoto8c2d6a92013-01-29 21:03:36 -08003763 snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix);
Julia Lawall51930292016-08-05 10:56:51 +02003764 if (of_property_read_bool(np, prop))
Kuninori Morimoto8c2d6a92013-01-29 21:03:36 -08003765 format |= SND_SOC_DAIFMT_CONT;
3766 else
3767 format |= SND_SOC_DAIFMT_GATED;
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003768
3769 /*
3770 * check "[prefix]bitclock-inversion"
3771 * check "[prefix]frame-inversion"
3772 * SND_SOC_DAIFMT_INV_MASK area
3773 */
3774 snprintf(prop, sizeof(prop), "%sbitclock-inversion", prefix);
3775 bit = !!of_get_property(np, prop, NULL);
3776
3777 snprintf(prop, sizeof(prop), "%sframe-inversion", prefix);
3778 frame = !!of_get_property(np, prop, NULL);
3779
3780 switch ((bit << 4) + frame) {
3781 case 0x11:
3782 format |= SND_SOC_DAIFMT_IB_IF;
3783 break;
3784 case 0x10:
3785 format |= SND_SOC_DAIFMT_IB_NF;
3786 break;
3787 case 0x01:
3788 format |= SND_SOC_DAIFMT_NB_IF;
3789 break;
3790 default:
3791 /* SND_SOC_DAIFMT_NB_NF is default */
3792 break;
3793 }
3794
3795 /*
3796 * check "[prefix]bitclock-master"
3797 * check "[prefix]frame-master"
3798 * SND_SOC_DAIFMT_MASTER_MASK area
3799 */
3800 snprintf(prop, sizeof(prop), "%sbitclock-master", prefix);
3801 bit = !!of_get_property(np, prop, NULL);
Jyri Sarha389cb832014-03-24 12:15:24 +02003802 if (bit && bitclkmaster)
3803 *bitclkmaster = of_parse_phandle(np, prop, 0);
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003804
3805 snprintf(prop, sizeof(prop), "%sframe-master", prefix);
3806 frame = !!of_get_property(np, prop, NULL);
Jyri Sarha389cb832014-03-24 12:15:24 +02003807 if (frame && framemaster)
3808 *framemaster = of_parse_phandle(np, prop, 0);
Kuninori Morimotoa7930ed2013-01-14 18:36:04 -08003809
3810 switch ((bit << 4) + frame) {
3811 case 0x11:
3812 format |= SND_SOC_DAIFMT_CBM_CFM;
3813 break;
3814 case 0x10:
3815 format |= SND_SOC_DAIFMT_CBM_CFS;
3816 break;
3817 case 0x01:
3818 format |= SND_SOC_DAIFMT_CBS_CFM;
3819 break;
3820 default:
3821 format |= SND_SOC_DAIFMT_CBS_CFS;
3822 break;
3823 }
3824
3825 return format;
3826}
3827EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt);
3828
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003829static int snd_soc_get_dai_name(struct of_phandle_args *args,
3830 const char **dai_name)
Kuninori Morimotocb470082013-09-10 17:39:56 -07003831{
3832 struct snd_soc_component *pos;
Jyri Sarha3e0aa8d2015-05-26 21:59:05 +03003833 struct device_node *component_of_node;
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003834 int ret = -EPROBE_DEFER;
Kuninori Morimotocb470082013-09-10 17:39:56 -07003835
3836 mutex_lock(&client_mutex);
3837 list_for_each_entry(pos, &component_list, list) {
Jyri Sarha3e0aa8d2015-05-26 21:59:05 +03003838 component_of_node = pos->dev->of_node;
3839 if (!component_of_node && pos->dev->parent)
3840 component_of_node = pos->dev->parent->of_node;
3841
3842 if (component_of_node != args->np)
Kuninori Morimotocb470082013-09-10 17:39:56 -07003843 continue;
3844
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003845 if (pos->driver->of_xlate_dai_name) {
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003846 ret = pos->driver->of_xlate_dai_name(pos,
3847 args,
3848 dai_name);
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003849 } else {
3850 int id = -1;
3851
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003852 switch (args->args_count) {
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003853 case 0:
3854 id = 0; /* same as dai_drv[0] */
3855 break;
3856 case 1:
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003857 id = args->args[0];
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003858 break;
3859 default:
3860 /* not supported */
3861 break;
3862 }
3863
3864 if (id < 0 || id >= pos->num_dai) {
3865 ret = -EINVAL;
Nicolin Chen3dcba282014-04-21 19:14:46 +08003866 continue;
Kuninori Morimoto6833c452013-10-16 22:05:26 -07003867 }
Xiubo Lie41975e2013-12-20 14:39:51 +08003868
3869 ret = 0;
3870
3871 *dai_name = pos->dai_drv[id].name;
3872 if (!*dai_name)
3873 *dai_name = pos->name;
Kuninori Morimotocb470082013-09-10 17:39:56 -07003874 }
3875
Kuninori Morimotocb470082013-09-10 17:39:56 -07003876 break;
3877 }
3878 mutex_unlock(&client_mutex);
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003879 return ret;
3880}
3881
3882int snd_soc_of_get_dai_name(struct device_node *of_node,
3883 const char **dai_name)
3884{
3885 struct of_phandle_args args;
3886 int ret;
3887
3888 ret = of_parse_phandle_with_args(of_node, "sound-dai",
3889 "#sound-dai-cells", 0, &args);
3890 if (ret)
3891 return ret;
3892
3893 ret = snd_soc_get_dai_name(&args, dai_name);
Kuninori Morimotocb470082013-09-10 17:39:56 -07003894
3895 of_node_put(args.np);
3896
3897 return ret;
3898}
3899EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name);
3900
Jean-Francois Moine93b0f3e2014-11-25 13:16:12 +01003901/*
3902 * snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree
3903 * @dev: Card device
3904 * @of_node: Device node
3905 * @dai_link: DAI link
3906 *
3907 * Builds an array of CODEC DAI components from the DAI link property
3908 * 'sound-dai'.
3909 * The array is set in the DAI link and the number of DAIs is set accordingly.
3910 * The device nodes in the array (of_node) must be dereferenced by the caller.
3911 *
3912 * Returns 0 for success
3913 */
3914int snd_soc_of_get_dai_link_codecs(struct device *dev,
3915 struct device_node *of_node,
3916 struct snd_soc_dai_link *dai_link)
3917{
3918 struct of_phandle_args args;
3919 struct snd_soc_dai_link_component *component;
3920 char *name;
3921 int index, num_codecs, ret;
3922
3923 /* Count the number of CODECs */
3924 name = "sound-dai";
3925 num_codecs = of_count_phandle_with_args(of_node, name,
3926 "#sound-dai-cells");
3927 if (num_codecs <= 0) {
3928 if (num_codecs == -ENOENT)
3929 dev_err(dev, "No 'sound-dai' property\n");
3930 else
3931 dev_err(dev, "Bad phandle in 'sound-dai'\n");
3932 return num_codecs;
3933 }
3934 component = devm_kzalloc(dev,
3935 sizeof *component * num_codecs,
3936 GFP_KERNEL);
3937 if (!component)
3938 return -ENOMEM;
3939 dai_link->codecs = component;
3940 dai_link->num_codecs = num_codecs;
3941
3942 /* Parse the list */
3943 for (index = 0, component = dai_link->codecs;
3944 index < dai_link->num_codecs;
3945 index++, component++) {
3946 ret = of_parse_phandle_with_args(of_node, name,
3947 "#sound-dai-cells",
3948 index, &args);
3949 if (ret)
3950 goto err;
3951 component->of_node = args.np;
3952 ret = snd_soc_get_dai_name(&args, &component->dai_name);
3953 if (ret < 0)
3954 goto err;
3955 }
3956 return 0;
3957err:
3958 for (index = 0, component = dai_link->codecs;
3959 index < dai_link->num_codecs;
3960 index++, component++) {
3961 if (!component->of_node)
3962 break;
3963 of_node_put(component->of_node);
3964 component->of_node = NULL;
3965 }
3966 dai_link->codecs = NULL;
3967 dai_link->num_codecs = 0;
3968 return ret;
3969}
3970EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);
3971
Takashi Iwaic9b3a402008-12-10 07:47:22 +01003972static int __init snd_soc_init(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003973{
Lars-Peter Clausen6553bf062015-04-09 10:52:38 +02003974 snd_soc_debugfs_init();
Mark Brownfb257892011-04-28 10:57:54 +01003975 snd_soc_util_init();
3976
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003977 return platform_driver_register(&soc_driver);
3978}
Mark Brown4abe8e12010-10-12 17:41:03 +01003979module_init(snd_soc_init);
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003980
Mark Brown7d8c16a2008-11-30 22:11:24 +00003981static void __exit snd_soc_exit(void)
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003982{
Mark Brownfb257892011-04-28 10:57:54 +01003983 snd_soc_util_exit();
Lars-Peter Clausen6553bf062015-04-09 10:52:38 +02003984 snd_soc_debugfs_exit();
Mark Brownfb257892011-04-28 10:57:54 +01003985
Mark Brown384c89e2008-12-03 17:34:03 +00003986#ifdef CONFIG_DEBUG_FS
Mark Brown384c89e2008-12-03 17:34:03 +00003987#endif
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003988 platform_driver_unregister(&soc_driver);
3989}
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003990module_exit(snd_soc_exit);
3991
3992/* Module information */
Liam Girdwoodd3311242008-10-12 13:17:36 +01003993MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
Frank Mandarinodb2a4162006-10-06 18:31:09 +02003994MODULE_DESCRIPTION("ALSA SoC Core");
3995MODULE_LICENSE("GPL");
3996MODULE_ALIAS("platform:soc-audio");