projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ASoC: add Component level .read/.write
[linux-2.6-block.git] / sound / soc / soc-core.c
CommitLineData
db2a4165
FM		 1/*
2 * soc-core.c -- ALSA SoC Audio Layer
3 *
4 * Copyright 2005 Wolfson Microelectronics PLC.
0664d888 5 * Copyright 2005 Openedhand Ltd.
f0fba2ad
LG		 6 * Copyright (C) 2010 Slimlogic Ltd.
7 * Copyright (C) 2010 Texas Instruments Inc.
0664d888 8 *
d331124d 9 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
0664d888
LG		 10 * with code, comments and ideas from :-
11 * Richard Purdie <richard@openedhand.com>
db2a4165
FM		 12 *
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 *
db2a4165
FM		 18 * 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>
12ef193d 31#include <linux/debugfs.h>
db2a4165 32#include <linux/platform_device.h>
741a509f 33#include <linux/pinctrl/consumer.h>
f0e8ed85 34#include <linux/ctype.h>
5a0e3ad6 35#include <linux/slab.h>
bec4fa05 36#include <linux/of.h>
a180e8b9 37#include <linux/of_graph.h>
345233d7 38#include <linux/dmi.h>
db2a4165 39#include <sound/core.h>
3028eb8c 40#include <sound/jack.h>
db2a4165
FM		 41#include <sound/pcm.h>
42#include <sound/pcm_params.h>
43#include <sound/soc.h>
01d7584c 44#include <sound/soc-dpcm.h>
8a978234 45#include <sound/soc-topology.h>
db2a4165
FM		 46#include <sound/initval.h>
47
a8b1d34f
MB		 48#define CREATE_TRACE_POINTS
49#include <trace/events/asoc.h>
50
f0fba2ad
LG		 51#define NAME_SIZE 32
52
384c89e2 53#ifdef CONFIG_DEBUG_FS
8a9dab1a
MB		 54struct dentry *snd_soc_debugfs_root;
55EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
384c89e2
MB		 56#endif
57
c5af3a2e 58static DEFINE_MUTEX(client_mutex);
12a48a8c 59static LIST_HEAD(platform_list);
0d0cf00a 60static LIST_HEAD(codec_list);
030e79f6 61static LIST_HEAD(component_list);
c5af3a2e 62
db2a4165
FM		 63/*
64 * This is a timeout to do a DAPM powerdown after a stream is closed().
65 * It can be used to eliminate pops between different playback streams, e.g.
66 * between two audio tracks.
67 */
68static int pmdown_time = 5000;
69module_param(pmdown_time, int, 0);
70MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");
71
98faf436
ML		 72/* If a DMI filed contain strings in this blacklist (e.g.
73 * "Type2 - Board Manufacturer" or "Type1 - TBD by OEM"), it will be taken
74 * as invalid and dropped when setting the card long name from DMI info.
75 */
76static const char * const dmi_blacklist[] = {
77 "To be filled by OEM",
78 "TBD by OEM",
79 "Default String",
80 "Board Manufacturer",
81 "Board Vendor Name",
82 "Board Product Name",
83 NULL, /* terminator */
84};
85
2bc9a81e
DP		 86/* returns the minimum number of bytes needed to represent
87 * a particular given value */
88static int min_bytes_needed(unsigned long val)
89{
90 int c = 0;
91 int i;
92
93 for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)
94 if (val & (1UL << i))
95 break;
96 c = (sizeof val * 8) - c;
97 if (!c || (c % 8))
98 c = (c + 8) / 8;
99 else
100 c /= 8;
101 return c;
102}
103
13fd179f
DP		 104/* fill buf which is 'len' bytes with a formatted
105 * string of the form 'reg: value\n' */
106static int format_register_str(struct snd_soc_codec *codec,
107 unsigned int reg, char *buf, size_t len)
108{
00b317a4
SW		 109 int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
110 int regsize = codec->driver->reg_word_size * 2;
13fd179f 111 int ret;
13fd179f
DP		 112
113 /* +2 for ': ' and + 1 for '\n' */
114 if (wordsize + regsize + 2 + 1 != len)
115 return -EINVAL;
116
d6b6c2ca
TI		 117 sprintf(buf, "%.*x: ", wordsize, reg);
118 buf += wordsize + 2;
13fd179f 119
d6b6c2ca
TI		 120 ret = snd_soc_read(codec, reg);
121 if (ret < 0)
122 memset(buf, 'X', regsize);
123 else
124 sprintf(buf, "%.*x", regsize, ret);
125 buf[regsize] = '\n';
126 /* no NUL-termination needed */
13fd179f
DP		 127 return 0;
128}
129
2624d5fa 130/* codec register dump */
13fd179f
DP		 131static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
132 size_t count, loff_t pos)
2624d5fa 133{
13fd179f 134 int i, step = 1;
2bc9a81e 135 int wordsize, regsize;
13fd179f
DP		 136 int len;
137 size_t total = 0;
138 loff_t p = 0;
2bc9a81e 139
00b317a4
SW		 140 wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
141 regsize = codec->driver->reg_word_size * 2;
2624d5fa 142
13fd179f
DP		 143 len = wordsize + regsize + 2 + 1;
144
f0fba2ad 145 if (!codec->driver->reg_cache_size)
2624d5fa
MB		 146 return 0;
147
f0fba2ad
LG		 148 if (codec->driver->reg_cache_step)
149 step = codec->driver->reg_cache_step;
2624d5fa 150
f0fba2ad 151 for (i = 0; i < codec->driver->reg_cache_size; i += step) {
20a0ec27
LPC		 152 /* only support larger than PAGE_SIZE bytes debugfs
153 * entries for the default case */
154 if (p >= pos) {
155 if (total + len >= count - 1)
156 break;
157 format_register_str(codec, i, buf + total, len);
158 total += len;
5164d74d 159 }
20a0ec27 160 p += len;
2624d5fa
MB		 161 }
162
13fd179f 163 total = min(total, count - 1);
2624d5fa 164
13fd179f 165 return total;
2624d5fa 166}
13fd179f 167
2624d5fa
MB		 168static ssize_t codec_reg_show(struct device *dev,
169 struct device_attribute *attr, char *buf)
170{
36ae1a96 171 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
f0fba2ad 172
13fd179f 173 return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);
2624d5fa
MB		 174}
175
176static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);
177
dbe21408
MB		 178static ssize_t pmdown_time_show(struct device *dev,
179 struct device_attribute *attr, char *buf)
180{
36ae1a96 181 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
dbe21408 182
f0fba2ad 183 return sprintf(buf, "%ld\n", rtd->pmdown_time);
dbe21408
MB		 184}
185
186static ssize_t pmdown_time_set(struct device *dev,
187 struct device_attribute *attr,
188 const char *buf, size_t count)
189{
36ae1a96 190 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
c593b520 191 int ret;
dbe21408 192
b785a492 193 ret = kstrtol(buf, 10, &rtd->pmdown_time);
c593b520
MB		 194 if (ret)
195 return ret;
dbe21408
MB		 196
197 return count;
198}
199
200static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);
201
d29697dc
TI		 202static struct attribute *soc_dev_attrs[] = {
203 &dev_attr_codec_reg.attr,
204 &dev_attr_pmdown_time.attr,
205 NULL
206};
207
208static umode_t soc_dev_attr_is_visible(struct kobject *kobj,
209 struct attribute *attr, int idx)
210{
211 struct device *dev = kobj_to_dev(kobj);
212 struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
213
214 if (attr == &dev_attr_pmdown_time.attr)
215 return attr->mode; /* always visible */
3b6eed8d 216 return rtd->num_codecs ? attr->mode : 0; /* enabled only with codec */
d29697dc
TI		 217}
218
219static const struct attribute_group soc_dapm_dev_group = {
220 .attrs = soc_dapm_dev_attrs,
221 .is_visible = soc_dev_attr_is_visible,
222};
223
224static const struct attribute_group soc_dev_roup = {
225 .attrs = soc_dev_attrs,
226 .is_visible = soc_dev_attr_is_visible,
227};
228
229static const struct attribute_group *soc_dev_attr_groups[] = {
230 &soc_dapm_dev_group,
231 &soc_dev_roup,
232 NULL
233};
234
2624d5fa 235#ifdef CONFIG_DEBUG_FS
2624d5fa 236static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
13fd179f 237 size_t count, loff_t *ppos)
2624d5fa
MB		 238{
239 ssize_t ret;
240 struct snd_soc_codec *codec = file->private_data;
13fd179f
DP		 241 char *buf;
242
243 if (*ppos < 0 || !count)
244 return -EINVAL;
245
246 buf = kmalloc(count, GFP_KERNEL);
2624d5fa
MB		 247 if (!buf)
248 return -ENOMEM;
13fd179f
DP		 249
250 ret = soc_codec_reg_show(codec, buf, count, *ppos);
251 if (ret >= 0) {
252 if (copy_to_user(user_buf, buf, ret)) {
253 kfree(buf);
254 return -EFAULT;
255 }
256 *ppos += ret;
257 }
258
2624d5fa
MB		 259 kfree(buf);
260 return ret;
261}
262
263static ssize_t codec_reg_write_file(struct file *file,
264 const char __user *user_buf, size_t count, loff_t *ppos)
265{
266 char buf[32];
34e268d8 267 size_t buf_size;
2624d5fa
MB		 268 char *start = buf;
269 unsigned long reg, value;
2624d5fa 270 struct snd_soc_codec *codec = file->private_data;
b785a492 271 int ret;
2624d5fa
MB		 272
273 buf_size = min(count, (sizeof(buf)-1));
274 if (copy_from_user(buf, user_buf, buf_size))
275 return -EFAULT;
276 buf[buf_size] = 0;
2624d5fa
MB		 277
278 while (*start == ' ')
279 start++;
280 reg = simple_strtoul(start, &start, 16);
2624d5fa
MB		 281 while (*start == ' ')
282 start++;
b785a492
JH		 283 ret = kstrtoul(start, 16, &value);
284 if (ret)
285 return ret;
0d51a9cb
MB		 286
287 /* Userspace has been fiddling around behind the kernel's back */
373d4d09 288 add_taint(TAINT_USER, LOCKDEP_NOW_UNRELIABLE);
0d51a9cb 289
e4f078d8 290 snd_soc_write(codec, reg, value);
2624d5fa
MB		 291 return buf_size;
292}
293
294static const struct file_operations codec_reg_fops = {
234e3405 295 .open = simple_open,
2624d5fa
MB		 296 .read = codec_reg_read_file,
297 .write = codec_reg_write_file,
6038f373 298 .llseek = default_llseek,
2624d5fa
MB		 299};
300
81c7cfd1 301static void soc_init_component_debugfs(struct snd_soc_component *component)
e73f3de5 302{
6553bf06
LPC		 303 if (!component->card->debugfs_card_root)
304 return;
305
81c7cfd1
LPC		 306 if (component->debugfs_prefix) {
307 char *name;
e73f3de5 308
81c7cfd1
LPC		 309 name = kasprintf(GFP_KERNEL, "%s:%s",
310 component->debugfs_prefix, component->name);
311 if (name) {
312 component->debugfs_root = debugfs_create_dir(name,
313 component->card->debugfs_card_root);
314 kfree(name);
315 }
316 } else {
317 component->debugfs_root = debugfs_create_dir(component->name,
318 component->card->debugfs_card_root);
319 }
e73f3de5 320
81c7cfd1
LPC		 321 if (!component->debugfs_root) {
322 dev_warn(component->dev,
323 "ASoC: Failed to create component debugfs directory\n");
324 return;
325 }
e73f3de5 326
81c7cfd1
LPC		 327 snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component),
328 component->debugfs_root);
e73f3de5 329
81c7cfd1
LPC		 330 if (component->init_debugfs)
331 component->init_debugfs(component);
e73f3de5
RK		 332}
333
81c7cfd1 334static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
2624d5fa 335{
81c7cfd1
LPC		 336 debugfs_remove_recursive(component->debugfs_root);
337}
d6ce4cf3 338
81c7cfd1
LPC		 339static void soc_init_codec_debugfs(struct snd_soc_component *component)
340{
341 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
353c64dd 342 struct dentry *debugfs_reg;
2624d5fa 343
353c64dd
FE		 344 debugfs_reg = debugfs_create_file("codec_reg", 0644,
345 codec->component.debugfs_root,
346 codec, &codec_reg_fops);
347 if (!debugfs_reg)
10e8aa9a
MM		 348 dev_warn(codec->dev,
349 "ASoC: Failed to create codec register debugfs file\n");
731f1ab2
SG		 350}
351
c3c5a19a
MB		 352static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
353 size_t count, loff_t *ppos)
354{
355 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
2b194f9d 356 ssize_t len, ret = 0;
c3c5a19a
MB		 357 struct snd_soc_codec *codec;
358
359 if (!buf)
360 return -ENOMEM;
361
34e81ab4
LPC		 362 mutex_lock(&client_mutex);
363
2b194f9d
MB		 364 list_for_each_entry(codec, &codec_list, list) {
365 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
f4333203 366 codec->component.name);
2b194f9d
MB		 367 if (len >= 0)
368 ret += len;
369 if (ret > PAGE_SIZE) {
370 ret = PAGE_SIZE;
371 break;
372 }
373 }
c3c5a19a 374
34e81ab4
LPC		 375 mutex_unlock(&client_mutex);
376
c3c5a19a
MB		 377 if (ret >= 0)
378 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
379
380 kfree(buf);
381
382 return ret;
383}
384
385static const struct file_operations codec_list_fops = {
386 .read = codec_list_read_file,
387 .llseek = default_llseek,/* read accesses f_pos */
388};
389
f3208780
MB		 390static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
391 size_t count, loff_t *ppos)
392{
393 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
2b194f9d 394 ssize_t len, ret = 0;
1438c2f6 395 struct snd_soc_component *component;
f3208780
MB		 396 struct snd_soc_dai *dai;
397
398 if (!buf)
399 return -ENOMEM;
400
34e81ab4
LPC		 401 mutex_lock(&client_mutex);
402
1438c2f6
LPC		 403 list_for_each_entry(component, &component_list, list) {
404 list_for_each_entry(dai, &component->dai_list, list) {
405 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
406 dai->name);
407 if (len >= 0)
408 ret += len;
409 if (ret > PAGE_SIZE) {
410 ret = PAGE_SIZE;
411 break;
412 }
2b194f9d
MB		 413 }
414 }
f3208780 415
34e81ab4
LPC		 416 mutex_unlock(&client_mutex);
417
2b194f9d 418 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
f3208780
MB		 419
420 kfree(buf);
421
422 return ret;
423}
424
425static const struct file_operations dai_list_fops = {
426 .read = dai_list_read_file,
427 .llseek = default_llseek,/* read accesses f_pos */
428};
429
19c7ac27
MB		 430static ssize_t platform_list_read_file(struct file *file,
431 char __user *user_buf,
432 size_t count, loff_t *ppos)
433{
434 char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
2b194f9d 435 ssize_t len, ret = 0;
19c7ac27
MB		 436 struct snd_soc_platform *platform;
437
438 if (!buf)
439 return -ENOMEM;
440
34e81ab4
LPC		 441 mutex_lock(&client_mutex);
442
2b194f9d
MB		 443 list_for_each_entry(platform, &platform_list, list) {
444 len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
f4333203 445 platform->component.name);
2b194f9d
MB		 446 if (len >= 0)
447 ret += len;
448 if (ret > PAGE_SIZE) {
449 ret = PAGE_SIZE;
450 break;
451 }
452 }
19c7ac27 453
34e81ab4
LPC		 454 mutex_unlock(&client_mutex);
455
2b194f9d 456 ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
19c7ac27
MB		 457
458 kfree(buf);
459
460 return ret;
461}
462
463static const struct file_operations platform_list_fops = {
464 .read = platform_list_read_file,
465 .llseek = default_llseek,/* read accesses f_pos */
466};
467
a6052154
JN		 468static void soc_init_card_debugfs(struct snd_soc_card *card)
469{
6553bf06
LPC		 470 if (!snd_soc_debugfs_root)
471 return;
472
a6052154 473 card->debugfs_card_root = debugfs_create_dir(card->name,
8a9dab1a 474 snd_soc_debugfs_root);
3a45b867 475 if (!card->debugfs_card_root) {
a6052154 476 dev_warn(card->dev,
7c08be84 477 "ASoC: Failed to create card debugfs directory\n");
3a45b867
JN		 478 return;
479 }
480
481 card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
482 card->debugfs_card_root,
483 &card->pop_time);
484 if (!card->debugfs_pop_time)
485 dev_warn(card->dev,
f110bfc7 486 "ASoC: Failed to create pop time debugfs file\n");
a6052154
JN		 487}
488
489static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
490{
491 debugfs_remove_recursive(card->debugfs_card_root);
492}
493
6553bf06
LPC		 494
495static void snd_soc_debugfs_init(void)
496{
497 snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
d9a02c55 498 if (IS_ERR_OR_NULL(snd_soc_debugfs_root)) {
6553bf06
LPC		 499 pr_warn("ASoC: Failed to create debugfs directory\n");
500 snd_soc_debugfs_root = NULL;
501 return;
502 }
503
504 if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
505 &codec_list_fops))
506 pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
507
508 if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
509 &dai_list_fops))
510 pr_warn("ASoC: Failed to create DAI list debugfs file\n");
511
512 if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
513 &platform_list_fops))
514 pr_warn("ASoC: Failed to create platform list debugfs file\n");
515}
516
517static void snd_soc_debugfs_exit(void)
518{
519 debugfs_remove_recursive(snd_soc_debugfs_root);
520}
521
2624d5fa
MB		 522#else
523
81c7cfd1 524#define soc_init_codec_debugfs NULL
b95fccbc 525
81c7cfd1
LPC		 526static inline void soc_init_component_debugfs(
527 struct snd_soc_component *component)
731f1ab2
SG		 528{
529}
530
81c7cfd1
LPC		 531static inline void soc_cleanup_component_debugfs(
532 struct snd_soc_component *component)
731f1ab2
SG		 533{
534}
535
b95fccbc
AL		 536static inline void soc_init_card_debugfs(struct snd_soc_card *card)
537{
538}
539
540static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
541{
542}
6553bf06
LPC		 543
544static inline void snd_soc_debugfs_init(void)
545{
546}
547
548static inline void snd_soc_debugfs_exit(void)
549{
550}
551
2624d5fa
MB		 552#endif
553
a0ac4411
KM		 554static int snd_soc_rtdcom_add(struct snd_soc_pcm_runtime *rtd,
555 struct snd_soc_component *component)
556{
557 struct snd_soc_rtdcom_list *rtdcom;
558 struct snd_soc_rtdcom_list *new_rtdcom;
559
560 for_each_rtdcom(rtd, rtdcom) {
561 /* already connected */
562 if (rtdcom->component == component)
563 return 0;
564 }
565
566 new_rtdcom = kmalloc(sizeof(*new_rtdcom), GFP_KERNEL);
567 if (!new_rtdcom)
568 return -ENOMEM;
569
570 new_rtdcom->component = component;
571 INIT_LIST_HEAD(&new_rtdcom->list);
572
573 list_add_tail(&new_rtdcom->list, &rtd->component_list);
574
575 return 0;
576}
577
578static void snd_soc_rtdcom_del_all(struct snd_soc_pcm_runtime *rtd)
579{
580 struct snd_soc_rtdcom_list *rtdcom1, *rtdcom2;
581
582 for_each_rtdcom_safe(rtd, rtdcom1, rtdcom2)
583 kfree(rtdcom1);
584
585 INIT_LIST_HEAD(&rtd->component_list);
586}
587
588struct snd_soc_component *snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
589 const char *driver_name)
590{
591 struct snd_soc_rtdcom_list *rtdcom;
592
593 for_each_rtdcom(rtd, rtdcom) {
594 if ((rtdcom->component->driver->name == driver_name) ||
595 strcmp(rtdcom->component->driver->name, driver_name) == 0)
596 return rtdcom->component;
597 }
598
599 return NULL;
600}
601
47c88fff
LG		 602struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
603 const char *dai_link, int stream)
604{
1a497983 605 struct snd_soc_pcm_runtime *rtd;
47c88fff 606
1a497983
ML		 607 list_for_each_entry(rtd, &card->rtd_list, list) {
608 if (rtd->dai_link->no_pcm &&
609 !strcmp(rtd->dai_link->name, dai_link))
610 return rtd->pcm->streams[stream].substream;
47c88fff 611 }
f110bfc7 612 dev_dbg(card->dev, "ASoC: failed to find dai link %s\n", dai_link);
47c88fff
LG		 613 return NULL;
614}
615EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);
616
75ab9eb6
KM		 617static const struct snd_soc_ops null_snd_soc_ops;
618
1a497983
ML		 619static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
620 struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)
621{
622 struct snd_soc_pcm_runtime *rtd;
623
624 rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
625 if (!rtd)
626 return NULL;
627
a0ac4411 628 INIT_LIST_HEAD(&rtd->component_list);
1a497983
ML		 629 rtd->card = card;
630 rtd->dai_link = dai_link;
75ab9eb6
KM		 631 if (!rtd->dai_link->ops)
632 rtd->dai_link->ops = &null_snd_soc_ops;
633
1a497983
ML		 634 rtd->codec_dais = kzalloc(sizeof(struct snd_soc_dai *) *
635 dai_link->num_codecs,
636 GFP_KERNEL);
637 if (!rtd->codec_dais) {
638 kfree(rtd);
639 return NULL;
640 }
641
642 return rtd;
643}
644
645static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
646{
db1721f5 647 kfree(rtd->codec_dais);
a0ac4411 648 snd_soc_rtdcom_del_all(rtd);
1a497983
ML		 649 kfree(rtd);
650}
651
652static void soc_add_pcm_runtime(struct snd_soc_card *card,
653 struct snd_soc_pcm_runtime *rtd)
654{
655 list_add_tail(&rtd->list, &card->rtd_list);
656 rtd->num = card->num_rtd;
657 card->num_rtd++;
658}
659
660static void soc_remove_pcm_runtimes(struct snd_soc_card *card)
661{
662 struct snd_soc_pcm_runtime *rtd, *_rtd;
663
664 list_for_each_entry_safe(rtd, _rtd, &card->rtd_list, list) {
665 list_del(&rtd->list);
666 soc_free_pcm_runtime(rtd);
667 }
668
669 card->num_rtd = 0;
670}
671
47c88fff
LG		 672struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
673 const char *dai_link)
674{
1a497983 675 struct snd_soc_pcm_runtime *rtd;
47c88fff 676
1a497983
ML		 677 list_for_each_entry(rtd, &card->rtd_list, list) {
678 if (!strcmp(rtd->dai_link->name, dai_link))
679 return rtd;
47c88fff 680 }
f110bfc7 681 dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link);
47c88fff
LG		 682 return NULL;
683}
684EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);
685
9d58a077
RF		 686static void codec2codec_close_delayed_work(struct work_struct *work)
687{
688 /* Currently nothing to do for c2c links
689 * Since c2c links are internal nodes in the DAPM graph and
690 * don't interface with the outside world or application layer
691 * we don't have to do any special handling on close.
692 */
693}
694
6f8ab4ac 695#ifdef CONFIG_PM_SLEEP
db2a4165 696/* powers down audio subsystem for suspend */
6f8ab4ac 697int snd_soc_suspend(struct device *dev)
db2a4165 698{
6f8ab4ac 699 struct snd_soc_card *card = dev_get_drvdata(dev);
d9fc4063 700 struct snd_soc_component *component;
1a497983
ML		 701 struct snd_soc_pcm_runtime *rtd;
702 int i;
db2a4165 703
c5599b87
LPC		 704 /* If the card is not initialized yet there is nothing to do */
705 if (!card->instantiated)
e3509ff0
DM		 706 return 0;
707
6ed25978
AG		 708 /* Due to the resume being scheduled into a workqueue we could
709 * suspend before that's finished - wait for it to complete.
710 */
f0fba2ad 711 snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
6ed25978
AG		 712
713 /* we're going to block userspace touching us until resume completes */
f0fba2ad 714 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
6ed25978 715
a00f90f9 716 /* mute any active DACs */
1a497983 717 list_for_each_entry(rtd, &card->rtd_list, list) {
3efab7dc 718
1a497983 719 if (rtd->dai_link->ignore_suspend)
3efab7dc
MB		 720 continue;
721
1a497983
ML		 722 for (i = 0; i < rtd->num_codecs; i++) {
723 struct snd_soc_dai *dai = rtd->codec_dais[i];
88bd870f
BC		 724 struct snd_soc_dai_driver *drv = dai->driver;
725
726 if (drv->ops->digital_mute && dai->playback_active)
727 drv->ops->digital_mute(dai, 1);
728 }
db2a4165
FM		 729 }
730
4ccab3e7 731 /* suspend all pcms */
1a497983
ML		 732 list_for_each_entry(rtd, &card->rtd_list, list) {
733 if (rtd->dai_link->ignore_suspend)
3efab7dc
MB		 734 continue;
735
1a497983 736 snd_pcm_suspend_all(rtd->pcm);
3efab7dc 737 }
4ccab3e7 738
87506549 739 if (card->suspend_pre)
70b2ac12 740 card->suspend_pre(card);
db2a4165 741
1a497983
ML		 742 list_for_each_entry(rtd, &card->rtd_list, list) {
743 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
3efab7dc 744
1a497983 745 if (rtd->dai_link->ignore_suspend)
3efab7dc
MB		 746 continue;
747
bc263214 748 if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)
f0fba2ad 749 cpu_dai->driver->suspend(cpu_dai);
db2a4165
FM		 750 }
751
37660b6d 752 /* close any waiting streams */
1a497983
ML		 753 list_for_each_entry(rtd, &card->rtd_list, list)
754 flush_delayed_work(&rtd->delayed_work);
db2a4165 755
1a497983 756 list_for_each_entry(rtd, &card->rtd_list, list) {
3efab7dc 757
1a497983 758 if (rtd->dai_link->ignore_suspend)
3efab7dc
MB		 759 continue;
760
1a497983 761 snd_soc_dapm_stream_event(rtd,
7bd3a6f3 762 SNDRV_PCM_STREAM_PLAYBACK,
7bd3a6f3 763 SND_SOC_DAPM_STREAM_SUSPEND);
f0fba2ad 764
1a497983 765 snd_soc_dapm_stream_event(rtd,
7bd3a6f3 766 SNDRV_PCM_STREAM_CAPTURE,
7bd3a6f3 767 SND_SOC_DAPM_STREAM_SUSPEND);
db2a4165
FM		 768 }
769
8be4da29
LPC		 770 /* Recheck all endpoints too, their state is affected by suspend */
771 dapm_mark_endpoints_dirty(card);
e2d32ff6
MB		 772 snd_soc_dapm_sync(&card->dapm);
773
9178feb4 774 /* suspend all COMPONENTs */
d9fc4063
KM		 775 list_for_each_entry(component, &card->component_dev_list, card_list) {
776 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
d9fc4063 777
9178feb4 778 /* If there are paths active then the COMPONENT will be held with
f0fba2ad 779 * bias _ON and should not be suspended. */
9178feb4 780 if (!component->suspended) {
4890140f 781 switch (snd_soc_dapm_get_bias_level(dapm)) {
f0fba2ad 782 case SND_SOC_BIAS_STANDBY:
125a25da 783 /*
9178feb4 784 * If the COMPONENT is capable of idle
125a25da
MB		 785 * bias off then being in STANDBY
786 * means it's doing something,
787 * otherwise fall through.
788 */
4890140f 789 if (dapm->idle_bias_off) {
9178feb4 790 dev_dbg(component->dev,
10e8aa9a 791 "ASoC: idle_bias_off CODEC on over suspend\n");
125a25da
MB		 792 break;
793 }
a8093297 794
f0fba2ad 795 case SND_SOC_BIAS_OFF:
9178feb4
KM		 796 if (component->suspend)
797 component->suspend(component);
798 component->suspended = 1;
799 if (component->regmap)
800 regcache_mark_dirty(component->regmap);
988e8cc4 801 /* deactivate pins to sleep state */
9178feb4 802 pinctrl_pm_select_sleep_state(component->dev);
f0fba2ad
LG		 803 break;
804 default:
9178feb4
KM		 805 dev_dbg(component->dev,
806 "ASoC: COMPONENT is on over suspend\n");
f0fba2ad
LG		 807 break;
808 }
1547aba9
MB		 809 }
810 }
db2a4165 811
1a497983
ML		 812 list_for_each_entry(rtd, &card->rtd_list, list) {
813 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
3efab7dc 814
1a497983 815 if (rtd->dai_link->ignore_suspend)
3efab7dc
MB		 816 continue;
817
bc263214 818 if (cpu_dai->driver->suspend && cpu_dai->driver->bus_control)
f0fba2ad 819 cpu_dai->driver->suspend(cpu_dai);
988e8cc4
NC		 820
821 /* deactivate pins to sleep state */
822 pinctrl_pm_select_sleep_state(cpu_dai->dev);
db2a4165
FM		 823 }
824
87506549 825 if (card->suspend_post)
70b2ac12 826 card->suspend_post(card);
db2a4165
FM		 827
828 return 0;
829}
6f8ab4ac 830EXPORT_SYMBOL_GPL(snd_soc_suspend);
db2a4165 831
6ed25978
AG		 832/* deferred resume work, so resume can complete before we finished
833 * setting our codec back up, which can be very slow on I2C
834 */
835static void soc_resume_deferred(struct work_struct *work)
db2a4165 836{
f0fba2ad
LG		 837 struct snd_soc_card *card =
838 container_of(work, struct snd_soc_card, deferred_resume_work);
1a497983 839 struct snd_soc_pcm_runtime *rtd;
d9fc4063 840 struct snd_soc_component *component;
1a497983 841 int i;
db2a4165 842
6ed25978
AG		 843 /* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
844 * so userspace apps are blocked from touching us
845 */
846
f110bfc7 847 dev_dbg(card->dev, "ASoC: starting resume work\n");
6ed25978 848
9949788b 849 /* Bring us up into D2 so that DAPM starts enabling things */
f0fba2ad 850 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
9949788b 851
87506549 852 if (card->resume_pre)
70b2ac12 853 card->resume_pre(card);
db2a4165 854
bc263214 855 /* resume control bus DAIs */
1a497983
ML		 856 list_for_each_entry(rtd, &card->rtd_list, list) {
857 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
3efab7dc 858
1a497983 859 if (rtd->dai_link->ignore_suspend)
3efab7dc
MB		 860 continue;
861
bc263214 862 if (cpu_dai->driver->resume && cpu_dai->driver->bus_control)
f0fba2ad
LG		 863 cpu_dai->driver->resume(cpu_dai);
864 }
865
d9fc4063 866 list_for_each_entry(component, &card->component_dev_list, card_list) {
9178feb4
KM		 867 if (component->suspended) {
868 if (component->resume)
869 component->resume(component);
870 component->suspended = 0;
1547aba9
MB		 871 }
872 }
db2a4165 873
1a497983 874 list_for_each_entry(rtd, &card->rtd_list, list) {
3efab7dc 875
1a497983 876 if (rtd->dai_link->ignore_suspend)
3efab7dc
MB		 877 continue;
878
1a497983 879 snd_soc_dapm_stream_event(rtd,
d9b0951b 880 SNDRV_PCM_STREAM_PLAYBACK,
7bd3a6f3 881 SND_SOC_DAPM_STREAM_RESUME);
f0fba2ad 882
1a497983 883 snd_soc_dapm_stream_event(rtd,
d9b0951b 884 SNDRV_PCM_STREAM_CAPTURE,
7bd3a6f3 885 SND_SOC_DAPM_STREAM_RESUME);
db2a4165
FM		 886 }
887
3ff3f64b 888 /* unmute any active DACs */
1a497983 889 list_for_each_entry(rtd, &card->rtd_list, list) {
3efab7dc 890
1a497983 891 if (rtd->dai_link->ignore_suspend)
3efab7dc
MB		 892 continue;
893
1a497983
ML		 894 for (i = 0; i < rtd->num_codecs; i++) {
895 struct snd_soc_dai *dai = rtd->codec_dais[i];
88bd870f
BC		 896 struct snd_soc_dai_driver *drv = dai->driver;
897
898 if (drv->ops->digital_mute && dai->playback_active)
899 drv->ops->digital_mute(dai, 0);
900 }
db2a4165
FM		 901 }
902
1a497983
ML		 903 list_for_each_entry(rtd, &card->rtd_list, list) {
904 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
3efab7dc 905
1a497983 906 if (rtd->dai_link->ignore_suspend)
3efab7dc
MB		 907 continue;
908
bc263214 909 if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)
f0fba2ad 910 cpu_dai->driver->resume(cpu_dai);
db2a4165
FM		 911 }
912
87506549 913 if (card->resume_post)
70b2ac12 914 card->resume_post(card);
db2a4165 915
f110bfc7 916 dev_dbg(card->dev, "ASoC: resume work completed\n");
6ed25978 917
8be4da29
LPC		 918 /* Recheck all endpoints too, their state is affected by suspend */
919 dapm_mark_endpoints_dirty(card);
e2d32ff6 920 snd_soc_dapm_sync(&card->dapm);
1a7aaa58
JK		 921
922 /* userspace can access us now we are back as we were before */
923 snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
6ed25978
AG		 924}
925
926/* powers up audio subsystem after a suspend */
6f8ab4ac 927int snd_soc_resume(struct device *dev)
6ed25978 928{
6f8ab4ac 929 struct snd_soc_card *card = dev_get_drvdata(dev);
bc263214 930 bool bus_control = false;
1a497983 931 struct snd_soc_pcm_runtime *rtd;
b9dd94a8 932
c5599b87
LPC		 933 /* If the card is not initialized yet there is nothing to do */
934 if (!card->instantiated)
5ff1ddf2
EM		 935 return 0;
936
988e8cc4 937 /* activate pins from sleep state */
1a497983 938 list_for_each_entry(rtd, &card->rtd_list, list) {
88bd870f
BC		 939 struct snd_soc_dai **codec_dais = rtd->codec_dais;
940 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
941 int j;
942
988e8cc4
NC		 943 if (cpu_dai->active)
944 pinctrl_pm_select_default_state(cpu_dai->dev);
88bd870f
BC		 945
946 for (j = 0; j < rtd->num_codecs; j++) {
947 struct snd_soc_dai *codec_dai = codec_dais[j];
948 if (codec_dai->active)
949 pinctrl_pm_select_default_state(codec_dai->dev);
950 }
988e8cc4
NC		 951 }
952
bc263214
LPC		 953 /*
954 * DAIs that also act as the control bus master might have other drivers
955 * hanging off them so need to resume immediately. Other drivers don't
956 * have that problem and may take a substantial amount of time to resume
64ab9baa
MB		 957 * due to I/O costs and anti-pop so handle them out of line.
958 */
1a497983
ML		 959 list_for_each_entry(rtd, &card->rtd_list, list) {
960 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
bc263214 961 bus_control |= cpu_dai->driver->bus_control;
82e14e8b 962 }
bc263214
LPC		 963 if (bus_control) {
964 dev_dbg(dev, "ASoC: Resuming control bus master immediately\n");
82e14e8b
SW		 965 soc_resume_deferred(&card->deferred_resume_work);
966 } else {
f110bfc7 967 dev_dbg(dev, "ASoC: Scheduling resume work\n");
82e14e8b 968 if (!schedule_work(&card->deferred_resume_work))
f110bfc7 969 dev_err(dev, "ASoC: resume work item may be lost\n");
64ab9baa 970 }
6ed25978 971
db2a4165
FM		 972 return 0;
973}
6f8ab4ac 974EXPORT_SYMBOL_GPL(snd_soc_resume);
db2a4165 975#else
6f8ab4ac
MB		 976#define snd_soc_suspend NULL
977#define snd_soc_resume NULL
db2a4165
FM		 978#endif
979
85e7652d 980static const struct snd_soc_dai_ops null_dai_ops = {
02a06d30
BS		 981};
982
65d9361f
LPC		 983static struct snd_soc_component *soc_find_component(
984 const struct device_node *of_node, const char *name)
12023a9a 985{
65d9361f 986 struct snd_soc_component *component;
12023a9a 987
34e81ab4
LPC		 988 lockdep_assert_held(&client_mutex);
989
65d9361f
LPC		 990 list_for_each_entry(component, &component_list, list) {
991 if (of_node) {
992 if (component->dev->of_node == of_node)
993 return component;
994 } else if (strcmp(component->name, name) == 0) {
995 return component;
12023a9a 996 }
12023a9a
MLC		 997 }
998
999 return NULL;
1000}
1001
fbb88b5c
ML		 1002/**
1003 * snd_soc_find_dai - Find a registered DAI
1004 *
4958471b 1005 * @dlc: name of the DAI or the DAI driver and optional component info to match
fbb88b5c 1006 *
ad61dd30 1007 * This function will search all registered components and their DAIs to
fbb88b5c
ML		 1008 * find the DAI of the same name. The component's of_node and name
1009 * should also match if being specified.
1010 *
1011 * Return: pointer of DAI, or NULL if not found.
1012 */
305e9020 1013struct snd_soc_dai *snd_soc_find_dai(
14621c7e 1014 const struct snd_soc_dai_link_component *dlc)
12023a9a 1015{
14621c7e
LPC		 1016 struct snd_soc_component *component;
1017 struct snd_soc_dai *dai;
3e0aa8d8 1018 struct device_node *component_of_node;
12023a9a 1019
34e81ab4
LPC		 1020 lockdep_assert_held(&client_mutex);
1021
14621c7e
LPC		 1022 /* Find CPU DAI from registered DAIs*/
1023 list_for_each_entry(component, &component_list, list) {
3e0aa8d8
JS		 1024 component_of_node = component->dev->of_node;
1025 if (!component_of_node && component->dev->parent)
1026 component_of_node = component->dev->parent->of_node;
1027
1028 if (dlc->of_node && component_of_node != dlc->of_node)
14621c7e 1029 continue;
1ffae361 1030 if (dlc->name && strcmp(component->name, dlc->name))
14621c7e
LPC		 1031 continue;
1032 list_for_each_entry(dai, &component->dai_list, list) {
4958471b 1033 if (dlc->dai_name && strcmp(dai->name, dlc->dai_name)
6a6dafda
JC		 1034 && (!dai->driver->name
1035 || strcmp(dai->driver->name, dlc->dai_name)))
12023a9a 1036 continue;
12023a9a 1037
14621c7e 1038 return dai;
12023a9a
MLC		 1039 }
1040 }
1041
1042 return NULL;
1043}
305e9020 1044EXPORT_SYMBOL_GPL(snd_soc_find_dai);
12023a9a 1045
17fb1755
ML		 1046
1047/**
1048 * snd_soc_find_dai_link - Find a DAI link
1049 *
1050 * @card: soc card
1051 * @id: DAI link ID to match
1052 * @name: DAI link name to match, optional
8abab35f 1053 * @stream_name: DAI link stream name to match, optional
17fb1755
ML		 1054 *
1055 * This function will search all existing DAI links of the soc card to
1056 * find the link of the same ID. Since DAI links may not have their
1057 * unique ID, so name and stream name should also match if being
1058 * specified.
1059 *
1060 * Return: pointer of DAI link, or NULL if not found.
1061 */
1062struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card,
1063 int id, const char *name,
1064 const char *stream_name)
1065{
1066 struct snd_soc_dai_link *link, *_link;
1067
1068 lockdep_assert_held(&client_mutex);
1069
1070 list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1071 if (link->id != id)
1072 continue;
1073
1074 if (name && (!link->name || strcmp(name, link->name)))
1075 continue;
1076
1077 if (stream_name && (!link->stream_name
1078 || strcmp(stream_name, link->stream_name)))
1079 continue;
1080
1081 return link;
1082 }
1083
1084 return NULL;
1085}
1086EXPORT_SYMBOL_GPL(snd_soc_find_dai_link);
1087
49a5ba1c
ML		 1088static bool soc_is_dai_link_bound(struct snd_soc_card *card,
1089 struct snd_soc_dai_link *dai_link)
1090{
1091 struct snd_soc_pcm_runtime *rtd;
1092
1093 list_for_each_entry(rtd, &card->rtd_list, list) {
1094 if (rtd->dai_link == dai_link)
1095 return true;
1096 }
1097
1098 return false;
1099}
1100
6f2f1ff0
ML		 1101static int soc_bind_dai_link(struct snd_soc_card *card,
1102 struct snd_soc_dai_link *dai_link)
db2a4165 1103{
1a497983 1104 struct snd_soc_pcm_runtime *rtd;
88bd870f 1105 struct snd_soc_dai_link_component *codecs = dai_link->codecs;
14621c7e 1106 struct snd_soc_dai_link_component cpu_dai_component;
90be711e 1107 struct snd_soc_component *component;
1a497983 1108 struct snd_soc_dai **codec_dais;
435c5e25 1109 struct snd_soc_platform *platform;
06859fca 1110 struct device_node *platform_of_node;
848dd8be 1111 const char *platform_name;
88bd870f 1112 int i;
435c5e25 1113
6f2f1ff0 1114 dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name);
435c5e25 1115
49a5ba1c
ML		 1116 if (soc_is_dai_link_bound(card, dai_link)) {
1117 dev_dbg(card->dev, "ASoC: dai link %s already bound\n",
1118 dai_link->name);
1119 return 0;
1120 }
435c5e25 1121
513cb311
SM		 1122 rtd = soc_new_pcm_runtime(card, dai_link);
1123 if (!rtd)
1124 return -ENOMEM;
1125
14621c7e
LPC		 1126 cpu_dai_component.name = dai_link->cpu_name;
1127 cpu_dai_component.of_node = dai_link->cpu_of_node;
1128 cpu_dai_component.dai_name = dai_link->cpu_dai_name;
1129 rtd->cpu_dai = snd_soc_find_dai(&cpu_dai_component);
b19e6e7b 1130 if (!rtd->cpu_dai) {
f110bfc7 1131 dev_err(card->dev, "ASoC: CPU DAI %s not registered\n",
b19e6e7b 1132 dai_link->cpu_dai_name);
1a497983 1133 goto _err_defer;
f0fba2ad 1134 }
90be711e 1135 snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
f0fba2ad 1136
88bd870f 1137 rtd->num_codecs = dai_link->num_codecs;
848dd8be 1138
88bd870f 1139 /* Find CODEC from registered CODECs */
1a497983 1140 codec_dais = rtd->codec_dais;
88bd870f 1141 for (i = 0; i < rtd->num_codecs; i++) {
14621c7e 1142 codec_dais[i] = snd_soc_find_dai(&codecs[i]);
88bd870f
BC		 1143 if (!codec_dais[i]) {
1144 dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
1145 codecs[i].dai_name);
1a497983 1146 goto _err_defer;
88bd870f 1147 }
90be711e 1148 snd_soc_rtdcom_add(rtd, codec_dais[i]->component);
12023a9a
MLC		 1149 }
1150
88bd870f
BC		 1151 /* Single codec links expect codec and codec_dai in runtime data */
1152 rtd->codec_dai = codec_dais[0];
1153 rtd->codec = rtd->codec_dai->codec;
1154
848dd8be
MB		 1155 /* if there's no platform we match on the empty platform */
1156 platform_name = dai_link->platform_name;
5a504963 1157 if (!platform_name && !dai_link->platform_of_node)
848dd8be
MB		 1158 platform_name = "snd-soc-dummy";
1159
90be711e
KM		 1160 /* find one from the set of registered platforms */
1161 list_for_each_entry(component, &component_list, list) {
1162 platform_of_node = component->dev->of_node;
1163 if (!platform_of_node && component->dev->parent->of_node)
1164 platform_of_node = component->dev->parent->of_node;
1165
1166 if (dai_link->platform_of_node) {
1167 if (platform_of_node != dai_link->platform_of_node)
1168 continue;
1169 } else {
1170 if (strcmp(component->name, platform_name))
1171 continue;
1172 }
1173
1174 snd_soc_rtdcom_add(rtd, component);
1175 }
1176
b19e6e7b 1177 /* find one from the set of registered platforms */
f0fba2ad 1178 list_for_each_entry(platform, &platform_list, list) {
06859fca
CK		 1179 platform_of_node = platform->dev->of_node;
1180 if (!platform_of_node && platform->dev->parent->of_node)
1181 platform_of_node = platform->dev->parent->of_node;
1182
5a504963 1183 if (dai_link->platform_of_node) {
06859fca 1184 if (platform_of_node != dai_link->platform_of_node)
5a504963
SW		 1185 continue;
1186 } else {
f4333203 1187 if (strcmp(platform->component.name, platform_name))
5a504963
SW		 1188 continue;
1189 }
2610ab77
SW		 1190
1191 rtd->platform = platform;
02a06d30 1192 }
b19e6e7b 1193 if (!rtd->platform) {
f110bfc7 1194 dev_err(card->dev, "ASoC: platform %s not registered\n",
f0fba2ad 1195 dai_link->platform_name);
70fcad49 1196 goto _err_defer;
f0fba2ad 1197 }
b19e6e7b 1198
1a497983 1199 soc_add_pcm_runtime(card, rtd);
b19e6e7b 1200 return 0;
1a497983
ML		 1201
1202_err_defer:
1203 soc_free_pcm_runtime(rtd);
1204 return -EPROBE_DEFER;
f0fba2ad
LG		 1205}
1206
f1d45cc3 1207static void soc_remove_component(struct snd_soc_component *component)
d12cd198 1208{
abd31b32 1209 if (!component->card)
70090bbb 1210 return;
d12cd198 1211
d9fc4063 1212 list_del(&component->card_list);
589c3563 1213
f1d45cc3
LPC		 1214 if (component->remove)
1215 component->remove(component);
589c3563 1216
f1d45cc3 1217 snd_soc_dapm_free(snd_soc_component_get_dapm(component));
589c3563 1218
f1d45cc3 1219 soc_cleanup_component_debugfs(component);
abd31b32 1220 component->card = NULL;
f1d45cc3 1221 module_put(component->dev->driver->owner);
589c3563
JN		 1222}
1223
e60cd14f 1224static void soc_remove_dai(struct snd_soc_dai *dai, int order)
f0fba2ad 1225{
f0fba2ad
LG		 1226 int err;
1227
e60cd14f
LPC		 1228 if (dai && dai->probed &&
1229 dai->driver->remove_order == order) {
1230 if (dai->driver->remove) {
1231 err = dai->driver->remove(dai);
f0fba2ad 1232 if (err < 0)
e60cd14f 1233 dev_err(dai->dev,
f110bfc7 1234 "ASoC: failed to remove %s: %d\n",
e60cd14f 1235 dai->name, err);
6b05eda6 1236 }
e60cd14f 1237 dai->probed = 0;
f0fba2ad 1238 }
b0aa88af
MLC		 1239}
1240
1a497983
ML		 1241static void soc_remove_link_dais(struct snd_soc_card *card,
1242 struct snd_soc_pcm_runtime *rtd, int order)
b0aa88af 1243{
e60cd14f 1244 int i;
b0aa88af
MLC		 1245
1246 /* unregister the rtd device */
1247 if (rtd->dev_registered) {
b0aa88af
MLC		 1248 device_unregister(rtd->dev);
1249 rtd->dev_registered = 0;
1250 }
1251
1252 /* remove the CODEC DAI */
88bd870f 1253 for (i = 0; i < rtd->num_codecs; i++)
e60cd14f 1254 soc_remove_dai(rtd->codec_dais[i], order);
6b05eda6 1255
e60cd14f 1256 soc_remove_dai(rtd->cpu_dai, order);
f0fba2ad 1257}
db2a4165 1258
1a497983
ML		 1259static void soc_remove_link_components(struct snd_soc_card *card,
1260 struct snd_soc_pcm_runtime *rtd, int order)
62ae68fa 1261{
61aca564 1262 struct snd_soc_component *component;
90be711e 1263 struct snd_soc_rtdcom_list *rtdcom;
62ae68fa 1264
90be711e
KM		 1265 for_each_rtdcom(rtd, rtdcom) {
1266 component = rtdcom->component;
62ae68fa 1267
70090bbb 1268 if (component->driver->remove_order == order)
61aca564 1269 soc_remove_component(component);
62ae68fa 1270 }
62ae68fa
SW		 1271}
1272
0671fd8e
KM		 1273static void soc_remove_dai_links(struct snd_soc_card *card)
1274{
1a497983
ML		 1275 int order;
1276 struct snd_soc_pcm_runtime *rtd;
f8f80361 1277 struct snd_soc_dai_link *link, *_link;
0671fd8e 1278
0168bf0d
LG		 1279 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1280 order++) {
1a497983
ML		 1281 list_for_each_entry(rtd, &card->rtd_list, list)
1282 soc_remove_link_dais(card, rtd, order);
62ae68fa
SW		 1283 }
1284
1285 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1286 order++) {
1a497983
ML		 1287 list_for_each_entry(rtd, &card->rtd_list, list)
1288 soc_remove_link_components(card, rtd, order);
0168bf0d 1289 }
62ae68fa 1290
f8f80361
ML		 1291 list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1292 if (link->dobj.type == SND_SOC_DOBJ_DAI_LINK)
1293 dev_warn(card->dev, "Topology forgot to remove link %s?\n",
1294 link->name);
1295
1296 list_del(&link->list);
1297 card->num_dai_links--;
1298 }
0671fd8e
KM		 1299}
1300
923c5e61
ML		 1301static int snd_soc_init_multicodec(struct snd_soc_card *card,
1302 struct snd_soc_dai_link *dai_link)
1303{
1304 /* Legacy codec/codec_dai link is a single entry in multicodec */
1305 if (dai_link->codec_name || dai_link->codec_of_node ||
1306 dai_link->codec_dai_name) {
1307 dai_link->num_codecs = 1;
1308
1309 dai_link->codecs = devm_kzalloc(card->dev,
1310 sizeof(struct snd_soc_dai_link_component),
1311 GFP_KERNEL);
1312 if (!dai_link->codecs)
1313 return -ENOMEM;
1314
1315 dai_link->codecs[0].name = dai_link->codec_name;
1316 dai_link->codecs[0].of_node = dai_link->codec_of_node;
1317 dai_link->codecs[0].dai_name = dai_link->codec_dai_name;
1318 }
1319
1320 if (!dai_link->codecs) {
1321 dev_err(card->dev, "ASoC: DAI link has no CODECs\n");
1322 return -EINVAL;
1323 }
1324
1325 return 0;
1326}
1327
1328static int soc_init_dai_link(struct snd_soc_card *card,
1329 struct snd_soc_dai_link *link)
1330{
1331 int i, ret;
1332
1333 ret = snd_soc_init_multicodec(card, link);
1334 if (ret) {
1335 dev_err(card->dev, "ASoC: failed to init multicodec\n");
1336 return ret;
1337 }
1338
1339 for (i = 0; i < link->num_codecs; i++) {
1340 /*
1341 * Codec must be specified by 1 of name or OF node,
1342 * not both or neither.
1343 */
1344 if (!!link->codecs[i].name ==
1345 !!link->codecs[i].of_node) {
1346 dev_err(card->dev, "ASoC: Neither/both codec name/of_node are set for %s\n",
1347 link->name);
1348 return -EINVAL;
1349 }
1350 /* Codec DAI name must be specified */
1351 if (!link->codecs[i].dai_name) {
1352 dev_err(card->dev, "ASoC: codec_dai_name not set for %s\n",
1353 link->name);
1354 return -EINVAL;
1355 }
1356 }
1357
1358 /*
1359 * Platform may be specified by either name or OF node, but
1360 * can be left unspecified, and a dummy platform will be used.
1361 */
1362 if (link->platform_name && link->platform_of_node) {
1363 dev_err(card->dev,
1364 "ASoC: Both platform name/of_node are set for %s\n",
1365 link->name);
1366 return -EINVAL;
1367 }
1368
1369 /*
1370 * CPU device may be specified by either name or OF node, but
1371 * can be left unspecified, and will be matched based on DAI
1372 * name alone..
1373 */
1374 if (link->cpu_name && link->cpu_of_node) {
1375 dev_err(card->dev,
1376 "ASoC: Neither/both cpu name/of_node are set for %s\n",
1377 link->name);
1378 return -EINVAL;
1379 }
1380 /*
1381 * At least one of CPU DAI name or CPU device name/node must be
1382 * specified
1383 */
1384 if (!link->cpu_dai_name &&
1385 !(link->cpu_name || link->cpu_of_node)) {
1386 dev_err(card->dev,
1387 "ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
1388 link->name);
1389 return -EINVAL;
1390 }
1391
1392 return 0;
0671fd8e
KM		 1393}
1394
f8f80361
ML		 1395/**
1396 * snd_soc_add_dai_link - Add a DAI link dynamically
1397 * @card: The ASoC card to which the DAI link is added
1398 * @dai_link: The new DAI link to add
1399 *
1400 * This function adds a DAI link to the ASoC card's link list.
1401 *
1402 * Note: Topology can use this API to add DAI links when probing the
1403 * topology component. And machine drivers can still define static
1404 * DAI links in dai_link array.
1405 */
1406int snd_soc_add_dai_link(struct snd_soc_card *card,
1407 struct snd_soc_dai_link *dai_link)
1408{
1409 if (dai_link->dobj.type
1410 && dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
1411 dev_err(card->dev, "Invalid dai link type %d\n",
1412 dai_link->dobj.type);
1413 return -EINVAL;
1414 }
1415
1416 lockdep_assert_held(&client_mutex);
d6f220ea
ML		 1417 /* Notify the machine driver for extra initialization
1418 * on the link created by topology.
1419 */
1420 if (dai_link->dobj.type && card->add_dai_link)
1421 card->add_dai_link(card, dai_link);
1422
f8f80361
ML		 1423 list_add_tail(&dai_link->list, &card->dai_link_list);
1424 card->num_dai_links++;
1425
1426 return 0;
1427}
1428EXPORT_SYMBOL_GPL(snd_soc_add_dai_link);
1429
1430/**
1431 * snd_soc_remove_dai_link - Remove a DAI link from the list
1432 * @card: The ASoC card that owns the link
1433 * @dai_link: The DAI link to remove
1434 *
1435 * This function removes a DAI link from the ASoC card's link list.
1436 *
1437 * For DAI links previously added by topology, topology should
1438 * remove them by using the dobj embedded in the link.
1439 */
1440void snd_soc_remove_dai_link(struct snd_soc_card *card,
1441 struct snd_soc_dai_link *dai_link)
1442{
1443 struct snd_soc_dai_link *link, *_link;
1444
1445 if (dai_link->dobj.type
1446 && dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
1447 dev_err(card->dev, "Invalid dai link type %d\n",
1448 dai_link->dobj.type);
1449 return;
1450 }
1451
1452 lockdep_assert_held(&client_mutex);
d6f220ea
ML		 1453 /* Notify the machine driver for extra destruction
1454 * on the link created by topology.
1455 */
1456 if (dai_link->dobj.type && card->remove_dai_link)
1457 card->remove_dai_link(card, dai_link);
1458
f8f80361
ML		 1459 list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
1460 if (link == dai_link) {
1461 list_del(&link->list);
1462 card->num_dai_links--;
1463 return;
1464 }
1465 }
1466}
1467EXPORT_SYMBOL_GPL(snd_soc_remove_dai_link);
1468
ead9b919 1469static void soc_set_name_prefix(struct snd_soc_card *card,
94f99c87 1470 struct snd_soc_component *component)
ead9b919
JN		 1471{
1472 int i;
1473
ff819b83 1474 if (card->codec_conf == NULL)
ead9b919
JN		 1475 return;
1476
ff819b83
DP		 1477 for (i = 0; i < card->num_configs; i++) {
1478 struct snd_soc_codec_conf *map = &card->codec_conf[i];
94f99c87 1479 if (map->of_node && component->dev->of_node != map->of_node)
3ca041ed 1480 continue;
94f99c87 1481 if (map->dev_name && strcmp(component->name, map->dev_name))
3ca041ed 1482 continue;
94f99c87 1483 component->name_prefix = map->name_prefix;
3ca041ed 1484 break;
ead9b919
JN		 1485 }
1486}
1487
f1d45cc3
LPC		 1488static int soc_probe_component(struct snd_soc_card *card,
1489 struct snd_soc_component *component)
589c3563 1490{
f1d45cc3 1491 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
888df395 1492 struct snd_soc_dai *dai;
f1d45cc3 1493 int ret;
589c3563 1494
1b7c1231 1495 if (!strcmp(component->name, "snd-soc-dummy"))
70090bbb 1496 return 0;
589c3563 1497
abd31b32 1498 if (component->card) {
1b7c1231
LPC		 1499 if (component->card != card) {
1500 dev_err(component->dev,
1501 "Trying to bind component to card \"%s\" but is already bound to card \"%s\"\n",
1502 card->name, component->card->name);
1503 return -ENODEV;
1504 }
1505 return 0;
1506 }
589c3563 1507
f1d45cc3 1508 if (!try_module_get(component->dev->driver->owner))
70d29331
JN		 1509 return -ENODEV;
1510
f1d45cc3
LPC		 1511 component->card = card;
1512 dapm->card = card;
1513 soc_set_name_prefix(card, component);
589c3563 1514
f1d45cc3 1515 soc_init_component_debugfs(component);
d5d1e0be 1516
688d0ebf
KM		 1517 if (component->driver->dapm_widgets) {
1518 ret = snd_soc_dapm_new_controls(dapm,
1519 component->driver->dapm_widgets,
1520 component->driver->num_dapm_widgets);
b318ad50
NP		 1521
1522 if (ret != 0) {
f1d45cc3 1523 dev_err(component->dev,
b318ad50
NP		 1524 "Failed to create new controls %d\n", ret);
1525 goto err_probe;
1526 }
1527 }
77530150 1528
0634814f
LPC		 1529 list_for_each_entry(dai, &component->dai_list, list) {
1530 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
261edc70 1531 if (ret != 0) {
0634814f 1532 dev_err(component->dev,
261edc70
NP		 1533 "Failed to create DAI widgets %d\n", ret);
1534 goto err_probe;
1535 }
1536 }
888df395 1537
f1d45cc3
LPC		 1538 if (component->probe) {
1539 ret = component->probe(component);
589c3563 1540 if (ret < 0) {
f1d45cc3
LPC		 1541 dev_err(component->dev,
1542 "ASoC: failed to probe component %d\n", ret);
70d29331 1543 goto err_probe;
589c3563 1544 }
cb2cf612 1545
f1d45cc3
LPC		 1546 WARN(dapm->idle_bias_off &&
1547 dapm->bias_level != SND_SOC_BIAS_OFF,
1548 "codec %s can not start from non-off bias with idle_bias_off==1\n",
1549 component->name);
be09ad90
LG		 1550 }
1551
f2ed6b07
ML		 1552 /* machine specific init */
1553 if (component->init) {
1554 ret = component->init(component);
1555 if (ret < 0) {
1556 dev_err(component->dev,
1557 "Failed to do machine specific init %d\n", ret);
1558 goto err_probe;
1559 }
1560 }
1561
b8972bf0
KM		 1562 if (component->driver->controls)
1563 snd_soc_add_component_controls(component,
1564 component->driver->controls,
1565 component->driver->num_controls);
6969b2ba
KM		 1566 if (component->driver->dapm_routes)
1567 snd_soc_dapm_add_routes(dapm,
1568 component->driver->dapm_routes,
1569 component->driver->num_dapm_routes);
3fec6b6d 1570
f1d45cc3 1571 list_add(&dapm->list, &card->dapm_list);
d9fc4063 1572 list_add(&component->card_list, &card->component_dev_list);
956245e9
LG		 1573
1574 return 0;
1575
1576err_probe:
f1d45cc3 1577 soc_cleanup_component_debugfs(component);
abd31b32 1578 component->card = NULL;
f1d45cc3 1579 module_put(component->dev->driver->owner);
956245e9
LG		 1580
1581 return ret;
1582}
1583
36ae1a96
MB		 1584static void rtd_release(struct device *dev)
1585{
1586 kfree(dev);
1587}
f0fba2ad 1588
5f3484ac
LPC		 1589static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
1590 const char *name)
503ae5e0 1591{
589c3563
JN		 1592 int ret = 0;
1593
589c3563 1594 /* register the rtd device */
36ae1a96
MB		 1595 rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
1596 if (!rtd->dev)
1597 return -ENOMEM;
1598 device_initialize(rtd->dev);
5f3484ac 1599 rtd->dev->parent = rtd->card->dev;
36ae1a96 1600 rtd->dev->release = rtd_release;
d29697dc 1601 rtd->dev->groups = soc_dev_attr_groups;
f294afed 1602 dev_set_name(rtd->dev, "%s", name);
36ae1a96 1603 dev_set_drvdata(rtd->dev, rtd);
b8c0dab9 1604 mutex_init(&rtd->pcm_mutex);
01d7584c
LG		 1605 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
1606 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
1607 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
1608 INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
36ae1a96 1609 ret = device_add(rtd->dev);
589c3563 1610 if (ret < 0) {
865df9cb
CL		 1611 /* calling put_device() here to free the rtd->dev */
1612 put_device(rtd->dev);
5f3484ac 1613 dev_err(rtd->card->dev,
f110bfc7 1614 "ASoC: failed to register runtime device: %d\n", ret);
589c3563
JN		 1615 return ret;
1616 }
1617 rtd->dev_registered = 1;
589c3563
JN		 1618 return 0;
1619}
1620
1a497983
ML		 1621static int soc_probe_link_components(struct snd_soc_card *card,
1622 struct snd_soc_pcm_runtime *rtd,
62ae68fa
SW		 1623 int order)
1624{
f1d45cc3 1625 struct snd_soc_component *component;
90be711e
KM		 1626 struct snd_soc_rtdcom_list *rtdcom;
1627 int ret;
62ae68fa 1628
90be711e
KM		 1629 for_each_rtdcom(rtd, rtdcom) {
1630 component = rtdcom->component;
62ae68fa 1631
70090bbb 1632 if (component->driver->probe_order == order) {
f1d45cc3 1633 ret = soc_probe_component(card, component);
88bd870f
BC		 1634 if (ret < 0)
1635 return ret;
1636 }
62ae68fa
SW		 1637 }
1638
62ae68fa
SW		 1639 return 0;
1640}
1641
8e2be562 1642static int soc_probe_dai(struct snd_soc_dai *dai, int order)
b0aa88af
MLC		 1643{
1644 int ret;
1645
8e2be562
LPC		 1646 if (!dai->probed && dai->driver->probe_order == order) {
1647 if (dai->driver->probe) {
1648 ret = dai->driver->probe(dai);
b0aa88af 1649 if (ret < 0) {
8e2be562
LPC		 1650 dev_err(dai->dev,
1651 "ASoC: failed to probe DAI %s: %d\n",
1652 dai->name, ret);
b0aa88af
MLC		 1653 return ret;
1654 }
1655 }
1656
8e2be562 1657 dai->probed = 1;
b0aa88af
MLC		 1658 }
1659
1660 return 0;
1661}
1662
25f7b701
AP		 1663static int soc_link_dai_pcm_new(struct snd_soc_dai **dais, int num_dais,
1664 struct snd_soc_pcm_runtime *rtd)
1665{
1666 int i, ret = 0;
1667
1668 for (i = 0; i < num_dais; ++i) {
1669 struct snd_soc_dai_driver *drv = dais[i]->driver;
1670
1671 if (!rtd->dai_link->no_pcm && drv->pcm_new)
1672 ret = drv->pcm_new(rtd, dais[i]);
1673 if (ret < 0) {
1674 dev_err(dais[i]->dev,
1675 "ASoC: Failed to bind %s with pcm device\n",
1676 dais[i]->name);
1677 return ret;
1678 }
1679 }
1680
1681 return 0;
1682}
1683
2436a723
MLC		 1684static int soc_link_dai_widgets(struct snd_soc_card *card,
1685 struct snd_soc_dai_link *dai_link,
3f901a02 1686 struct snd_soc_pcm_runtime *rtd)
2436a723 1687{
3f901a02
BC		 1688 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1689 struct snd_soc_dai *codec_dai = rtd->codec_dai;
3de7c420 1690 struct snd_soc_dapm_widget *sink, *source;
2436a723
MLC		 1691 int ret;
1692
88bd870f
BC		 1693 if (rtd->num_codecs > 1)
1694 dev_warn(card->dev, "ASoC: Multiple codecs not supported yet\n");
1695
2436a723 1696 /* link the DAI widgets */
3de7c420
VK		 1697 sink = codec_dai->playback_widget;
1698 source = cpu_dai->capture_widget;
1699 if (sink && source) {
2436a723 1700 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
3de7c420
VK		 1701 dai_link->num_params,
1702 source, sink);
2436a723
MLC		 1703 if (ret != 0) {
1704 dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
3de7c420 1705 sink->name, source->name, ret);
2436a723
MLC		 1706 return ret;
1707 }
1708 }
1709
3de7c420
VK		 1710 sink = cpu_dai->playback_widget;
1711 source = codec_dai->capture_widget;
1712 if (sink && source) {
2436a723 1713 ret = snd_soc_dapm_new_pcm(card, dai_link->params,
3de7c420
VK		 1714 dai_link->num_params,
1715 source, sink);
2436a723
MLC		 1716 if (ret != 0) {
1717 dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
3de7c420 1718 sink->name, source->name, ret);
2436a723
MLC		 1719 return ret;
1720 }
1721 }
1722
1723 return 0;
1724}
1725
1a497983
ML		 1726static int soc_probe_link_dais(struct snd_soc_card *card,
1727 struct snd_soc_pcm_runtime *rtd, int order)
f0fba2ad 1728{
1a497983 1729 struct snd_soc_dai_link *dai_link = rtd->dai_link;
c74184ed 1730 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
88bd870f 1731 int i, ret;
f0fba2ad 1732
f110bfc7 1733 dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
1a497983 1734 card->name, rtd->num, order);
f0fba2ad 1735
f0fba2ad
LG		 1736 /* set default power off timeout */
1737 rtd->pmdown_time = pmdown_time;
1738
8e2be562
LPC		 1739 ret = soc_probe_dai(cpu_dai, order);
1740 if (ret)
1741 return ret;
db2a4165 1742
f0fba2ad 1743 /* probe the CODEC DAI */
88bd870f 1744 for (i = 0; i < rtd->num_codecs; i++) {
8e2be562 1745 ret = soc_probe_dai(rtd->codec_dais[i], order);
88bd870f
BC		 1746 if (ret)
1747 return ret;
1748 }
fe3e78e0 1749
0168bf0d
LG		 1750 /* complete DAI probe during last probe */
1751 if (order != SND_SOC_COMP_ORDER_LAST)
1752 return 0;
1753
5f3484ac
LPC		 1754 /* do machine specific initialization */
1755 if (dai_link->init) {
1756 ret = dai_link->init(rtd);
1757 if (ret < 0) {
1758 dev_err(card->dev, "ASoC: failed to init %s: %d\n",
1759 dai_link->name, ret);
1760 return ret;
1761 }
1762 }
1763
a5053a8e
KM		 1764 if (dai_link->dai_fmt)
1765 snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
1766
5f3484ac 1767 ret = soc_post_component_init(rtd, dai_link->name);
589c3563 1768 if (ret)
f0fba2ad 1769 return ret;
fe3e78e0 1770
5f3484ac
LPC		 1771#ifdef CONFIG_DEBUG_FS
1772 /* add DPCM sysfs entries */
2e55b90a
LPC		 1773 if (dai_link->dynamic)
1774 soc_dpcm_debugfs_add(rtd);
5f3484ac
LPC		 1775#endif
1776
6f0c4226 1777 if (cpu_dai->driver->compress_new) {
1245b700 1778 /*create compress_device"*/
1a497983 1779 ret = cpu_dai->driver->compress_new(rtd, rtd->num);
c74184ed 1780 if (ret < 0) {
f110bfc7 1781 dev_err(card->dev, "ASoC: can't create compress %s\n",
1245b700 1782 dai_link->stream_name);
c74184ed
MB		 1783 return ret;
1784 }
1785 } else {
1245b700
NK		 1786
1787 if (!dai_link->params) {
1788 /* create the pcm */
1a497983 1789 ret = soc_new_pcm(rtd, rtd->num);
1245b700 1790 if (ret < 0) {
f110bfc7 1791 dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
1245b700 1792 dai_link->stream_name, ret);
c74184ed
MB		 1793 return ret;
1794 }
25f7b701
AP		 1795 ret = soc_link_dai_pcm_new(&cpu_dai, 1, rtd);
1796 if (ret < 0)
1797 return ret;
1798 ret = soc_link_dai_pcm_new(rtd->codec_dais,
1799 rtd->num_codecs, rtd);
1800 if (ret < 0)
1801 return ret;
1245b700 1802 } else {
9d58a077
RF		 1803 INIT_DELAYED_WORK(&rtd->delayed_work,
1804 codec2codec_close_delayed_work);
1805
1245b700 1806 /* link the DAI widgets */
3f901a02 1807 ret = soc_link_dai_widgets(card, dai_link, rtd);
2436a723
MLC		 1808 if (ret)
1809 return ret;
c74184ed 1810 }
f0fba2ad
LG		 1811 }
1812
f0fba2ad
LG		 1813 return 0;
1814}
1815
44c69bb1 1816static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
3ca041ed
SR		 1817{
1818 struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
f2ed6b07
ML		 1819 struct snd_soc_component *component;
1820 const char *name;
1821 struct device_node *codec_of_node;
1822
1823 if (aux_dev->codec_of_node || aux_dev->codec_name) {
1824 /* codecs, usually analog devices */
1825 name = aux_dev->codec_name;
1826 codec_of_node = aux_dev->codec_of_node;
1827 component = soc_find_component(codec_of_node, name);
1828 if (!component) {
1829 if (codec_of_node)
1830 name = of_node_full_name(codec_of_node);
1831 goto err_defer;
1832 }
1833 } else if (aux_dev->name) {
1834 /* generic components */
1835 name = aux_dev->name;
1836 component = soc_find_component(NULL, name);
1837 if (!component)
1838 goto err_defer;
1839 } else {
1840 dev_err(card->dev, "ASoC: Invalid auxiliary device\n");
1841 return -EINVAL;
3ca041ed 1842 }
fb099cb7 1843
f2ed6b07 1844 component->init = aux_dev->init;
d2e3a135 1845 list_add(&component->card_aux_list, &card->aux_comp_list);
1a653aa4 1846
44c69bb1 1847 return 0;
f2ed6b07
ML		 1848
1849err_defer:
1850 dev_err(card->dev, "ASoC: %s not registered\n", name);
1851 return -EPROBE_DEFER;
b19e6e7b
MB		 1852}
1853
f2ed6b07 1854static int soc_probe_aux_devices(struct snd_soc_card *card)
2eea392d 1855{
991454e1 1856 struct snd_soc_component *comp;
f2ed6b07 1857 int order;
44c69bb1 1858 int ret;
3ca041ed 1859
f2ed6b07
ML		 1860 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1861 order++) {
991454e1 1862 list_for_each_entry(comp, &card->aux_comp_list, card_aux_list) {
f2ed6b07
ML		 1863 if (comp->driver->probe_order == order) {
1864 ret = soc_probe_component(card, comp);
1865 if (ret < 0) {
1866 dev_err(card->dev,
1867 "ASoC: failed to probe aux component %s %d\n",
1868 comp->name, ret);
1869 return ret;
1870 }
1871 }
5f3484ac
LPC		 1872 }
1873 }
2eea392d 1874
f2ed6b07 1875 return 0;
2eea392d
JN		 1876}
1877
f2ed6b07 1878static void soc_remove_aux_devices(struct snd_soc_card *card)
2eea392d 1879{
f2ed6b07
ML		 1880 struct snd_soc_component *comp, *_comp;
1881 int order;
2eea392d 1882
f2ed6b07
ML		 1883 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
1884 order++) {
1885 list_for_each_entry_safe(comp, _comp,
991454e1 1886 &card->aux_comp_list, card_aux_list) {
1a653aa4 1887
f2ed6b07
ML		 1888 if (comp->driver->remove_order == order) {
1889 soc_remove_component(comp);
991454e1
KM		 1890 /* remove it from the card's aux_comp_list */
1891 list_del(&comp->card_aux_list);
f2ed6b07
ML		 1892 }
1893 }
2eea392d 1894 }
2eea392d
JN		 1895}
1896
f90fb3f7 1897static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)
fdf0f54d
DP		 1898{
1899 int ret;
1900
1901 if (codec->cache_init)
1902 return 0;
1903
fdf0f54d
DP		 1904 ret = snd_soc_cache_init(codec);
1905 if (ret < 0) {
10e8aa9a
MM		 1906 dev_err(codec->dev,
1907 "ASoC: Failed to set cache compression type: %d\n",
1908 ret);
fdf0f54d
DP		 1909 return ret;
1910 }
1911 codec->cache_init = 1;
1912 return 0;
1913}
1914
ce64c8b9
LPC		 1915/**
1916 * snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime
1917 * @rtd: The runtime for which the DAI link format should be changed
1918 * @dai_fmt: The new DAI link format
1919 *
1920 * This function updates the DAI link format for all DAIs connected to the DAI
1921 * link for the specified runtime.
1922 *
1923 * Note: For setups with a static format set the dai_fmt field in the
1924 * corresponding snd_dai_link struct instead of using this function.
1925 *
1926 * Returns 0 on success, otherwise a negative error code.
1927 */
1928int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
1929 unsigned int dai_fmt)
1930{
1931 struct snd_soc_dai **codec_dais = rtd->codec_dais;
1932 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1933 unsigned int i;
1934 int ret;
1935
1936 for (i = 0; i < rtd->num_codecs; i++) {
1937 struct snd_soc_dai *codec_dai = codec_dais[i];
1938
1939 ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
1940 if (ret != 0 && ret != -ENOTSUPP) {
1941 dev_warn(codec_dai->dev,
1942 "ASoC: Failed to set DAI format: %d\n", ret);
1943 return ret;
1944 }
1945 }
1946
1947 /* Flip the polarity for the "CPU" end of a CODEC<->CODEC link */
cb2cf0de
KM		 1948 /* the component which has non_legacy_dai_naming is Codec */
1949 if (cpu_dai->codec ||
1950 cpu_dai->component->driver->non_legacy_dai_naming) {
ce64c8b9
LPC		 1951 unsigned int inv_dai_fmt;
1952
1953 inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_MASTER_MASK;
1954 switch (dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1955 case SND_SOC_DAIFMT_CBM_CFM:
1956 inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
1957 break;
1958 case SND_SOC_DAIFMT_CBM_CFS:
1959 inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
1960 break;
1961 case SND_SOC_DAIFMT_CBS_CFM:
1962 inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
1963 break;
1964 case SND_SOC_DAIFMT_CBS_CFS:
1965 inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
1966 break;
1967 }
1968
1969 dai_fmt = inv_dai_fmt;
1970 }
1971
1972 ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt);
1973 if (ret != 0 && ret != -ENOTSUPP) {
1974 dev_warn(cpu_dai->dev,
1975 "ASoC: Failed to set DAI format: %d\n", ret);
1976 return ret;
1977 }
1978
1979 return 0;
1980}
ddaca25a 1981EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
ce64c8b9 1982
345233d7 1983
1f5a4535 1984#ifdef CONFIG_DMI
345233d7
LG		 1985/* Trim special characters, and replace '-' with '_' since '-' is used to
1986 * separate different DMI fields in the card long name. Only number and
1987 * alphabet characters and a few separator characters are kept.
1988 */
1989static void cleanup_dmi_name(char *name)
1990{
1991 int i, j = 0;
1992
1993 for (i = 0; name[i]; i++) {
1994 if (isalnum(name[i]) || (name[i] == '.')
1995 || (name[i] == '_'))
1996 name[j++] = name[i];
1997 else if (name[i] == '-')
1998 name[j++] = '_';
1999 }
2000
2001 name[j] = '\0';
2002}
2003
98faf436
ML		 2004/* Check if a DMI field is valid, i.e. not containing any string
2005 * in the black list.
2006 */
2007static int is_dmi_valid(const char *field)
2008{
2009 int i = 0;
2010
2011 while (dmi_blacklist[i]) {
2012 if (strstr(field, dmi_blacklist[i]))
2013 return 0;
2014 i++;
46b5a4d2 2015 }
98faf436
ML		 2016
2017 return 1;
2018}
2019
345233d7
LG		 2020/**
2021 * snd_soc_set_dmi_name() - Register DMI names to card
2022 * @card: The card to register DMI names
2023 * @flavour: The flavour "differentiator" for the card amongst its peers.
2024 *
2025 * An Intel machine driver may be used by many different devices but are
2026 * difficult for userspace to differentiate, since machine drivers ususally
2027 * use their own name as the card short name and leave the card long name
2028 * blank. To differentiate such devices and fix bugs due to lack of
2029 * device-specific configurations, this function allows DMI info to be used
2030 * as the sound card long name, in the format of
2031 * "vendor-product-version-board"
2032 * (Character '-' is used to separate different DMI fields here).
2033 * This will help the user space to load the device-specific Use Case Manager
2034 * (UCM) configurations for the card.
2035 *
2036 * Possible card long names may be:
2037 * DellInc.-XPS139343-01-0310JH
2038 * ASUSTeKCOMPUTERINC.-T100TA-1.0-T100TA
2039 * Circuitco-MinnowboardMaxD0PLATFORM-D0-MinnowBoardMAX
2040 *
2041 * This function also supports flavoring the card longname to provide
2042 * the extra differentiation, like "vendor-product-version-board-flavor".
2043 *
2044 * We only keep number and alphabet characters and a few separator characters
2045 * in the card long name since UCM in the user space uses the card long names
2046 * as card configuration directory names and AudoConf cannot support special
2047 * charactors like SPACE.
2048 *
2049 * Returns 0 on success, otherwise a negative error code.
2050 */
2051int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour)
2052{
2053 const char *vendor, *product, *product_version, *board;
2054 size_t longname_buf_size = sizeof(card->snd_card->longname);
2055 size_t len;
2056
2057 if (card->long_name)
2058 return 0; /* long name already set by driver or from DMI */
2059
2060 /* make up dmi long name as: vendor.product.version.board */
2061 vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
98faf436 2062 if (!vendor || !is_dmi_valid(vendor)) {
345233d7
LG		 2063 dev_warn(card->dev, "ASoC: no DMI vendor name!\n");
2064 return 0;
2065 }
2066
98faf436 2067
345233d7
LG		 2068 snprintf(card->dmi_longname, sizeof(card->snd_card->longname),
2069 "%s", vendor);
2070 cleanup_dmi_name(card->dmi_longname);
2071
2072 product = dmi_get_system_info(DMI_PRODUCT_NAME);
98faf436 2073 if (product && is_dmi_valid(product)) {
345233d7
LG		 2074 len = strlen(card->dmi_longname);
2075 snprintf(card->dmi_longname + len,
2076 longname_buf_size - len,
2077 "-%s", product);
2078
2079 len++; /* skip the separator "-" */
2080 if (len < longname_buf_size)
2081 cleanup_dmi_name(card->dmi_longname + len);
2082
2083 /* some vendors like Lenovo may only put a self-explanatory
2084 * name in the product version field
2085 */
2086 product_version = dmi_get_system_info(DMI_PRODUCT_VERSION);
98faf436 2087 if (product_version && is_dmi_valid(product_version)) {
345233d7
LG		 2088 len = strlen(card->dmi_longname);
2089 snprintf(card->dmi_longname + len,
2090 longname_buf_size - len,
2091 "-%s", product_version);
2092
2093 len++;
2094 if (len < longname_buf_size)
2095 cleanup_dmi_name(card->dmi_longname + len);
2096 }
2097 }
2098
2099 board = dmi_get_system_info(DMI_BOARD_NAME);
98faf436 2100 if (board && is_dmi_valid(board)) {
345233d7
LG		 2101 len = strlen(card->dmi_longname);
2102 snprintf(card->dmi_longname + len,
2103 longname_buf_size - len,
2104 "-%s", board);
2105
2106 len++;
2107 if (len < longname_buf_size)
2108 cleanup_dmi_name(card->dmi_longname + len);
2109 } else if (!product) {
2110 /* fall back to using legacy name */
2111 dev_warn(card->dev, "ASoC: no DMI board/product name!\n");
2112 return 0;
2113 }
2114
2115 /* Add flavour to dmi long name */
2116 if (flavour) {
2117 len = strlen(card->dmi_longname);
2118 snprintf(card->dmi_longname + len,
2119 longname_buf_size - len,
2120 "-%s", flavour);
2121
2122 len++;
2123 if (len < longname_buf_size)
2124 cleanup_dmi_name(card->dmi_longname + len);
2125 }
2126
2127 /* set the card long name */
2128 card->long_name = card->dmi_longname;
2129
2130 return 0;
2131}
2132EXPORT_SYMBOL_GPL(snd_soc_set_dmi_name);
1f5a4535 2133#endif /* CONFIG_DMI */
345233d7 2134
b19e6e7b 2135static int snd_soc_instantiate_card(struct snd_soc_card *card)
f0fba2ad 2136{
fdf0f54d 2137 struct snd_soc_codec *codec;
1a497983 2138 struct snd_soc_pcm_runtime *rtd;
61b0088b 2139 struct snd_soc_dai_link *dai_link;
ce64c8b9 2140 int ret, i, order;
fe3e78e0 2141
34e81ab4 2142 mutex_lock(&client_mutex);
01b9d99a 2143 mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
dbe21408 2144
f0fba2ad 2145 /* bind DAIs */
b19e6e7b 2146 for (i = 0; i < card->num_links; i++) {
6f2f1ff0 2147 ret = soc_bind_dai_link(card, &card->dai_link[i]);
b19e6e7b
MB		 2148 if (ret != 0)
2149 goto base_error;
2150 }
fe3e78e0 2151
44c69bb1 2152 /* bind aux_devs too */
b19e6e7b 2153 for (i = 0; i < card->num_aux_devs; i++) {
44c69bb1 2154 ret = soc_bind_aux_dev(card, i);
b19e6e7b
MB		 2155 if (ret != 0)
2156 goto base_error;
f0fba2ad 2157 }
435c5e25 2158
f8f80361
ML		 2159 /* add predefined DAI links to the list */
2160 for (i = 0; i < card->num_links; i++)
2161 snd_soc_add_dai_link(card, card->dai_link+i);
2162
fdf0f54d
DP		 2163 /* initialize the register cache for each available codec */
2164 list_for_each_entry(codec, &codec_list, list) {
2165 if (codec->cache_init)
2166 continue;
f90fb3f7 2167 ret = snd_soc_init_codec_cache(codec);
b19e6e7b
MB		 2168 if (ret < 0)
2169 goto base_error;
fdf0f54d
DP		 2170 }
2171
f0fba2ad 2172 /* card bind complete so register a sound card */
102b5a8d 2173 ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
f0fba2ad
LG		 2174 card->owner, 0, &card->snd_card);
2175 if (ret < 0) {
10e8aa9a
MM		 2176 dev_err(card->dev,
2177 "ASoC: can't create sound card for card %s: %d\n",
2178 card->name, ret);
b19e6e7b 2179 goto base_error;
f0fba2ad 2180 }
f0fba2ad 2181
0757d834
LPC		 2182 soc_init_card_debugfs(card);
2183
e37a4970
MB		 2184 card->dapm.bias_level = SND_SOC_BIAS_OFF;
2185 card->dapm.dev = card->dev;
2186 card->dapm.card = card;
2187 list_add(&card->dapm.list, &card->dapm_list);
2188
d5d1e0be
LPC		 2189#ifdef CONFIG_DEBUG_FS
2190 snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
2191#endif
2192
88ee1c61 2193#ifdef CONFIG_PM_SLEEP
f0fba2ad
LG		 2194 /* deferred resume work */
2195 INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
2196#endif
db2a4165 2197
9a841ebb
MB		 2198 if (card->dapm_widgets)
2199 snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
2200 card->num_dapm_widgets);
2201
f23e860e
NC		 2202 if (card->of_dapm_widgets)
2203 snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets,
2204 card->num_of_dapm_widgets);
2205
f0fba2ad
LG		 2206 /* initialise the sound card only once */
2207 if (card->probe) {
e7361ec4 2208 ret = card->probe(card);
f0fba2ad
LG		 2209 if (ret < 0)
2210 goto card_probe_error;
2211 }
fe3e78e0 2212
62ae68fa 2213 /* probe all components used by DAI links on this card */
0168bf0d
LG		 2214 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
2215 order++) {
1a497983
ML		 2216 list_for_each_entry(rtd, &card->rtd_list, list) {
2217 ret = soc_probe_link_components(card, rtd, order);
0168bf0d 2218 if (ret < 0) {
f110bfc7
LG		 2219 dev_err(card->dev,
2220 "ASoC: failed to instantiate card %d\n",
2221 ret);
62ae68fa
SW		 2222 goto probe_dai_err;
2223 }
2224 }
2225 }
2226
f2ed6b07
ML		 2227 /* probe auxiliary components */
2228 ret = soc_probe_aux_devices(card);
2229 if (ret < 0)
2230 goto probe_dai_err;
2231
61b0088b
ML		 2232 /* Find new DAI links added during probing components and bind them.
2233 * Components with topology may bring new DAIs and DAI links.
2234 */
2235 list_for_each_entry(dai_link, &card->dai_link_list, list) {
2236 if (soc_is_dai_link_bound(card, dai_link))
2237 continue;
2238
2239 ret = soc_init_dai_link(card, dai_link);
2240 if (ret)
2241 goto probe_dai_err;
2242 ret = soc_bind_dai_link(card, dai_link);
2243 if (ret)
2244 goto probe_dai_err;
2245 }
2246
62ae68fa
SW		 2247 /* probe all DAI links on this card */
2248 for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
2249 order++) {
1a497983
ML		 2250 list_for_each_entry(rtd, &card->rtd_list, list) {
2251 ret = soc_probe_link_dais(card, rtd, order);
62ae68fa 2252 if (ret < 0) {
f110bfc7
LG		 2253 dev_err(card->dev,
2254 "ASoC: failed to instantiate card %d\n",
2255 ret);
0168bf0d
LG		 2256 goto probe_dai_err;
2257 }
f0fba2ad
LG		 2258 }
2259 }
db2a4165 2260
888df395 2261 snd_soc_dapm_link_dai_widgets(card);
b893ea5f 2262 snd_soc_dapm_connect_dai_link_widgets(card);
888df395 2263
b7af1daf 2264 if (card->controls)
022658be 2265 snd_soc_add_card_controls(card, card->controls, card->num_controls);
b7af1daf 2266
b8ad29de
MB		 2267 if (card->dapm_routes)
2268 snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
2269 card->num_dapm_routes);
2270
f23e860e
NC		 2271 if (card->of_dapm_routes)
2272 snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,
2273 card->num_of_dapm_routes);
75d9ac46 2274
861886d3
TI		 2275 /* try to set some sane longname if DMI is available */
2276 snd_soc_set_dmi_name(card, NULL);
2277
f0fba2ad 2278 snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
f0fba2ad 2279 "%s", card->name);
22de71ba
LG		 2280 snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
2281 "%s", card->long_name ? card->long_name : card->name);
f0e8ed85
MB		 2282 snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
2283 "%s", card->driver_name ? card->driver_name : card->name);
2284 for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
2285 switch (card->snd_card->driver[i]) {
2286 case '_':
2287 case '-':
2288 case '\0':
2289 break;
2290 default:
2291 if (!isalnum(card->snd_card->driver[i]))
2292 card->snd_card->driver[i] = '_';
2293 break;
2294 }
2295 }
f0fba2ad 2296
28e9ad92
MB		 2297 if (card->late_probe) {
2298 ret = card->late_probe(card);
2299 if (ret < 0) {
f110bfc7 2300 dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
28e9ad92
MB		 2301 card->name, ret);
2302 goto probe_aux_dev_err;
2303 }
2304 }
2305
824ef826 2306 snd_soc_dapm_new_widgets(card);
8c193b8d 2307
f0fba2ad
LG		 2308 ret = snd_card_register(card->snd_card);
2309 if (ret < 0) {
f110bfc7
LG		 2310 dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
2311 ret);
6b3ed785 2312 goto probe_aux_dev_err;
db2a4165
FM		 2313 }
2314
f0fba2ad 2315 card->instantiated = 1;
4f4c0072 2316 snd_soc_dapm_sync(&card->dapm);
f0fba2ad 2317 mutex_unlock(&card->mutex);
34e81ab4 2318 mutex_unlock(&client_mutex);
b19e6e7b
MB		 2319
2320 return 0;
f0fba2ad 2321
2eea392d 2322probe_aux_dev_err:
f2ed6b07 2323 soc_remove_aux_devices(card);
2eea392d 2324
f0fba2ad 2325probe_dai_err:
0671fd8e 2326 soc_remove_dai_links(card);
f0fba2ad
LG		 2327
2328card_probe_error:
87506549 2329 if (card->remove)
e7361ec4 2330 card->remove(card);
f0fba2ad 2331
2210438b 2332 snd_soc_dapm_free(&card->dapm);
0757d834 2333 soc_cleanup_card_debugfs(card);
f0fba2ad
LG		 2334 snd_card_free(card->snd_card);
2335
b19e6e7b 2336base_error:
1a497983 2337 soc_remove_pcm_runtimes(card);
f0fba2ad 2338 mutex_unlock(&card->mutex);
34e81ab4 2339 mutex_unlock(&client_mutex);
db2a4165 2340
b19e6e7b 2341 return ret;
435c5e25
MB		 2342}
2343
2344/* probes a new socdev */
2345static int soc_probe(struct platform_device *pdev)
2346{
f0fba2ad 2347 struct snd_soc_card *card = platform_get_drvdata(pdev);
435c5e25 2348
70a7ca34
VK		 2349 /*
2350 * no card, so machine driver should be registering card
2351 * we should not be here in that case so ret error
2352 */
2353 if (!card)
2354 return -EINVAL;
2355
fe4085e8 2356 dev_warn(&pdev->dev,
f110bfc7 2357 "ASoC: machine %s should use snd_soc_register_card()\n",
fe4085e8
MB		 2358 card->name);
2359
435c5e25
MB		 2360 /* Bodge while we unpick instantiation */
2361 card->dev = &pdev->dev;
f0fba2ad 2362
28d528c8 2363 return snd_soc_register_card(card);
db2a4165
FM		 2364}
2365
b0e26485 2366static int soc_cleanup_card_resources(struct snd_soc_card *card)
db2a4165 2367{
1a497983 2368 struct snd_soc_pcm_runtime *rtd;
db2a4165 2369
b0e26485 2370 /* make sure any delayed work runs */
1a497983 2371 list_for_each_entry(rtd, &card->rtd_list, list)
43829731 2372 flush_delayed_work(&rtd->delayed_work);
914dc182 2373
4efda5f2
TI		 2374 /* free the ALSA card at first; this syncs with pending operations */
2375 snd_card_free(card->snd_card);
2376
b0e26485 2377 /* remove and free each DAI */
0671fd8e 2378 soc_remove_dai_links(card);
1a497983 2379 soc_remove_pcm_runtimes(card);
2eea392d 2380
f2ed6b07
ML		 2381 /* remove auxiliary devices */
2382 soc_remove_aux_devices(card);
2383
d1e81428 2384 snd_soc_dapm_free(&card->dapm);
b0e26485 2385 soc_cleanup_card_debugfs(card);
f0fba2ad 2386
b0e26485
VK		 2387 /* remove the card */
2388 if (card->remove)
e7361ec4 2389 card->remove(card);
a6052154 2390
b0e26485 2391 return 0;
b0e26485
VK		 2392}
2393
2394/* removes a socdev */
2395static int soc_remove(struct platform_device *pdev)
2396{
2397 struct snd_soc_card *card = platform_get_drvdata(pdev);
db2a4165 2398
c5af3a2e 2399 snd_soc_unregister_card(card);
db2a4165
FM		 2400 return 0;
2401}
2402
6f8ab4ac 2403int snd_soc_poweroff(struct device *dev)
51737470 2404{
6f8ab4ac 2405 struct snd_soc_card *card = dev_get_drvdata(dev);
1a497983 2406 struct snd_soc_pcm_runtime *rtd;
51737470
MB		 2407
2408 if (!card->instantiated)
416356fc 2409 return 0;
51737470
MB		 2410
2411 /* Flush out pmdown_time work - we actually do want to run it
2412 * now, we're shutting down so no imminent restart. */
1a497983 2413 list_for_each_entry(rtd, &card->rtd_list, list)
43829731 2414 flush_delayed_work(&rtd->delayed_work);
51737470 2415
f0fba2ad 2416 snd_soc_dapm_shutdown(card);
416356fc 2417
988e8cc4 2418 /* deactivate pins to sleep state */
1a497983 2419 list_for_each_entry(rtd, &card->rtd_list, list) {
88bd870f 2420 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1a497983 2421 int i;
88bd870f 2422
988e8cc4 2423 pinctrl_pm_select_sleep_state(cpu_dai->dev);
1a497983
ML		 2424 for (i = 0; i < rtd->num_codecs; i++) {
2425 struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
88bd870f
BC		 2426 pinctrl_pm_select_sleep_state(codec_dai->dev);
2427 }
988e8cc4
NC		 2428 }
2429
416356fc 2430 return 0;
51737470 2431}
6f8ab4ac 2432EXPORT_SYMBOL_GPL(snd_soc_poweroff);
51737470 2433
6f8ab4ac 2434const struct dev_pm_ops snd_soc_pm_ops = {
b1dd5897
VK		 2435 .suspend = snd_soc_suspend,
2436 .resume = snd_soc_resume,
2437 .freeze = snd_soc_suspend,
2438 .thaw = snd_soc_resume,
6f8ab4ac 2439 .poweroff = snd_soc_poweroff,
b1dd5897 2440 .restore = snd_soc_resume,
416356fc 2441};
deb2607e 2442EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
416356fc 2443
db2a4165
FM		 2444/* ASoC platform driver */
2445static struct platform_driver soc_driver = {
2446 .driver = {
2447 .name = "soc-audio",
6f8ab4ac 2448 .pm = &snd_soc_pm_ops,
db2a4165
FM		 2449 },
2450 .probe = soc_probe,
2451 .remove = soc_remove,
db2a4165
FM		 2452};
2453
db2a4165
FM		 2454/**
2455 * snd_soc_cnew - create new control
2456 * @_template: control template
2457 * @data: control private data
ac11a2b3 2458 * @long_name: control long name
efb7ac3f 2459 * @prefix: control name prefix
db2a4165
FM		 2460 *
2461 * Create a new mixer control from a template control.
2462 *
2463 * Returns 0 for success, else error.
2464 */
2465struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
3056557f 2466 void *data, const char *long_name,
efb7ac3f 2467 const char *prefix)
db2a4165
FM		 2468{
2469 struct snd_kcontrol_new template;
efb7ac3f
MB		 2470 struct snd_kcontrol *kcontrol;
2471 char *name = NULL;
db2a4165
FM		 2472
2473 memcpy(&template, _template, sizeof(template));
db2a4165
FM		 2474 template.index = 0;
2475
efb7ac3f
MB		 2476 if (!long_name)
2477 long_name = template.name;
2478
2479 if (prefix) {
2b581074 2480 name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
efb7ac3f
MB		 2481 if (!name)
2482 return NULL;
2483
efb7ac3f
MB		 2484 template.name = name;
2485 } else {
2486 template.name = long_name;
2487 }
2488
2489 kcontrol = snd_ctl_new1(&template, data);
2490
2491 kfree(name);
2492
2493 return kcontrol;
db2a4165
FM		 2494}
2495EXPORT_SYMBOL_GPL(snd_soc_cnew);
2496
022658be
LG		 2497static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
2498 const struct snd_kcontrol_new *controls, int num_controls,
2499 const char *prefix, void *data)
2500{
2501 int err, i;
2502
2503 for (i = 0; i < num_controls; i++) {
2504 const struct snd_kcontrol_new *control = &controls[i];
2505 err = snd_ctl_add(card, snd_soc_cnew(control, data,
2506 control->name, prefix));
2507 if (err < 0) {
f110bfc7
LG		 2508 dev_err(dev, "ASoC: Failed to add %s: %d\n",
2509 control->name, err);
022658be
LG		 2510 return err;
2511 }
2512 }
2513
2514 return 0;
2515}
2516
4fefd698
DP		 2517struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
2518 const char *name)
2519{
2520 struct snd_card *card = soc_card->snd_card;
2521 struct snd_kcontrol *kctl;
2522
2523 if (unlikely(!name))
2524 return NULL;
2525
2526 list_for_each_entry(kctl, &card->controls, list)
2527 if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name)))
2528 return kctl;
2529 return NULL;
2530}
2531EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol);
2532
0f2780ad
LPC		 2533/**
2534 * snd_soc_add_component_controls - Add an array of controls to a component.
2535 *
2536 * @component: Component to add controls to
2537 * @controls: Array of controls to add
2538 * @num_controls: Number of elements in the array
2539 *
2540 * Return: 0 for success, else error.
2541 */
2542int snd_soc_add_component_controls(struct snd_soc_component *component,
2543 const struct snd_kcontrol_new *controls, unsigned int num_controls)
2544{
2545 struct snd_card *card = component->card->snd_card;
2546
2547 return snd_soc_add_controls(card, component->dev, controls,
2548 num_controls, component->name_prefix, component);
2549}
2550EXPORT_SYMBOL_GPL(snd_soc_add_component_controls);
2551
3e8e1952 2552/**
022658be
LG		 2553 * snd_soc_add_codec_controls - add an array of controls to a codec.
2554 * Convenience function to add a list of controls. Many codecs were
3e8e1952
IM		 2555 * duplicating this code.
2556 *
2557 * @codec: codec to add controls to
2558 * @controls: array of controls to add
2559 * @num_controls: number of elements in the array
2560 *
2561 * Return 0 for success, else error.
2562 */
022658be 2563int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
0f2780ad 2564 const struct snd_kcontrol_new *controls, unsigned int num_controls)
3e8e1952 2565{
0f2780ad
LPC		 2566 return snd_soc_add_component_controls(&codec->component, controls,
2567 num_controls);
3e8e1952 2568}
022658be 2569EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls);
3e8e1952 2570
a491a5c8
LG		 2571/**
2572 * snd_soc_add_platform_controls - add an array of controls to a platform.
022658be 2573 * Convenience function to add a list of controls.
a491a5c8
LG		 2574 *
2575 * @platform: platform to add controls to
2576 * @controls: array of controls to add
2577 * @num_controls: number of elements in the array
2578 *
2579 * Return 0 for success, else error.
2580 */
2581int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
0f2780ad 2582 const struct snd_kcontrol_new *controls, unsigned int num_controls)
a491a5c8 2583{
0f2780ad
LPC		 2584 return snd_soc_add_component_controls(&platform->component, controls,
2585 num_controls);
a491a5c8
LG		 2586}
2587EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);
2588
022658be
LG		 2589/**
2590 * snd_soc_add_card_controls - add an array of controls to a SoC card.
2591 * Convenience function to add a list of controls.
2592 *
2593 * @soc_card: SoC card to add controls to
2594 * @controls: array of controls to add
2595 * @num_controls: number of elements in the array
2596 *
2597 * Return 0 for success, else error.
2598 */
2599int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
2600 const struct snd_kcontrol_new *controls, int num_controls)
2601{
2602 struct snd_card *card = soc_card->snd_card;
2603
2604 return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,
2605 NULL, soc_card);
2606}
2607EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);
2608
2609/**
2610 * snd_soc_add_dai_controls - add an array of controls to a DAI.
2611 * Convienience function to add a list of controls.
2612 *
2613 * @dai: DAI to add controls to
2614 * @controls: array of controls to add
2615 * @num_controls: number of elements in the array
2616 *
2617 * Return 0 for success, else error.
2618 */
2619int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
2620 const struct snd_kcontrol_new *controls, int num_controls)
2621{
313665b9 2622 struct snd_card *card = dai->component->card->snd_card;
022658be
LG		 2623
2624 return snd_soc_add_controls(card, dai->dev, controls, num_controls,
2625 NULL, dai);
2626}
2627EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);
2628
8c6529db
LG		 2629/**
2630 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
2631 * @dai: DAI
2632 * @clk_id: DAI specific clock ID
2633 * @freq: new clock frequency in Hz
2634 * @dir: new clock direction - input/output.
2635 *
2636 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
2637 */
2638int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
2639 unsigned int freq, int dir)
2640{
46471925 2641 if (dai->driver->ops->set_sysclk)
f0fba2ad 2642 return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
71ccef0d
KM		 2643
2644 return snd_soc_component_set_sysclk(dai->component, clk_id, 0,
2645 freq, dir);
8c6529db
LG		 2646}
2647EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
2648
ec4ee52a
MB		 2649/**
2650 * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
2651 * @codec: CODEC
2652 * @clk_id: DAI specific clock ID
da1c6ea6 2653 * @source: Source for the clock
ec4ee52a
MB		 2654 * @freq: new clock frequency in Hz
2655 * @dir: new clock direction - input/output.
2656 *
2657 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
2658 */
2659int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
da1c6ea6 2660 int source, unsigned int freq, int dir)
ec4ee52a
MB		 2661{
2662 if (codec->driver->set_sysclk)
da1c6ea6
MB		 2663 return codec->driver->set_sysclk(codec, clk_id, source,
2664 freq, dir);
ec4ee52a 2665 else
1104a9c8 2666 return -ENOTSUPP;
ec4ee52a
MB		 2667}
2668EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);
2669
71ccef0d
KM		 2670/**
2671 * snd_soc_component_set_sysclk - configure COMPONENT system or master clock.
2672 * @component: COMPONENT
2673 * @clk_id: DAI specific clock ID
2674 * @source: Source for the clock
2675 * @freq: new clock frequency in Hz
2676 * @dir: new clock direction - input/output.
2677 *
2678 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
2679 */
2680int snd_soc_component_set_sysclk(struct snd_soc_component *component, int clk_id,
2681 int source, unsigned int freq, int dir)
2682{
2683 /* will be removed */
2684 if (component->set_sysclk)
2685 return component->set_sysclk(component, clk_id, source,
2686 freq, dir);
2687
2688 if (component->driver->set_sysclk)
2689 return component->driver->set_sysclk(component, clk_id, source,
2690 freq, dir);
2691
2692 return -ENOTSUPP;
2693}
2694EXPORT_SYMBOL_GPL(snd_soc_component_set_sysclk);
2695
8c6529db
LG		 2696/**
2697 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
2698 * @dai: DAI
ac11a2b3 2699 * @div_id: DAI specific clock divider ID
8c6529db
LG		 2700 * @div: new clock divisor.
2701 *
2702 * Configures the clock dividers. This is used to derive the best DAI bit and
2703 * frame clocks from the system or master clock. It's best to set the DAI bit
2704 * and frame clocks as low as possible to save system power.
2705 */
2706int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
2707 int div_id, int div)
2708{
46471925 2709 if (dai->driver->ops->set_clkdiv)
f0fba2ad 2710 return dai->driver->ops->set_clkdiv(dai, div_id, div);
8c6529db
LG		 2711 else
2712 return -EINVAL;
2713}
2714EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
2715
2716/**
2717 * snd_soc_dai_set_pll - configure DAI PLL.
2718 * @dai: DAI
2719 * @pll_id: DAI specific PLL ID
85488037 2720 * @source: DAI specific source for the PLL
8c6529db
LG		 2721 * @freq_in: PLL input clock frequency in Hz
2722 * @freq_out: requested PLL output clock frequency in Hz
2723 *
2724 * Configures and enables PLL to generate output clock based on input clock.
2725 */
85488037
MB		 2726int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
2727 unsigned int freq_in, unsigned int freq_out)
8c6529db 2728{
46471925 2729 if (dai->driver->ops->set_pll)
f0fba2ad 2730 return dai->driver->ops->set_pll(dai, pll_id, source,
85488037 2731 freq_in, freq_out);
ef641e5d
KM		 2732
2733 return snd_soc_component_set_pll(dai->component, pll_id, source,
2734 freq_in, freq_out);
8c6529db
LG		 2735}
2736EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
2737
ec4ee52a
MB		 2738/*
2739 * snd_soc_codec_set_pll - configure codec PLL.
2740 * @codec: CODEC
2741 * @pll_id: DAI specific PLL ID
2742 * @source: DAI specific source for the PLL
2743 * @freq_in: PLL input clock frequency in Hz
2744 * @freq_out: requested PLL output clock frequency in Hz
2745 *
2746 * Configures and enables PLL to generate output clock based on input clock.
2747 */
2748int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
2749 unsigned int freq_in, unsigned int freq_out)
2750{
2751 if (codec->driver->set_pll)
2752 return codec->driver->set_pll(codec, pll_id, source,
2753 freq_in, freq_out);
2754 else
2755 return -EINVAL;
2756}
2757EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);
2758
ef641e5d
KM		 2759/*
2760 * snd_soc_component_set_pll - configure component PLL.
2761 * @component: COMPONENT
2762 * @pll_id: DAI specific PLL ID
2763 * @source: DAI specific source for the PLL
2764 * @freq_in: PLL input clock frequency in Hz
2765 * @freq_out: requested PLL output clock frequency in Hz
2766 *
2767 * Configures and enables PLL to generate output clock based on input clock.
2768 */
2769int snd_soc_component_set_pll(struct snd_soc_component *component, int pll_id,
2770 int source, unsigned int freq_in,
2771 unsigned int freq_out)
2772{
2773 /* will be removed */
2774 if (component->set_pll)
2775 return component->set_pll(component, pll_id, source,
2776 freq_in, freq_out);
2777
2778 if (component->driver->set_pll)
2779 return component->driver->set_pll(component, pll_id, source,
2780 freq_in, freq_out);
2781
2782 return -EINVAL;
2783}
2784EXPORT_SYMBOL_GPL(snd_soc_component_set_pll);
2785
e54cf76b
LG		 2786/**
2787 * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
2788 * @dai: DAI
231b86b1 2789 * @ratio: Ratio of BCLK to Sample rate.
e54cf76b
LG		 2790 *
2791 * Configures the DAI for a preset BCLK to sample rate ratio.
2792 */
2793int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
2794{
46471925 2795 if (dai->driver->ops->set_bclk_ratio)
e54cf76b
LG		 2796 return dai->driver->ops->set_bclk_ratio(dai, ratio);
2797 else
2798 return -EINVAL;
2799}
2800EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
2801
8c6529db
LG		 2802/**
2803 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
2804 * @dai: DAI
bb19ba2a 2805 * @fmt: SND_SOC_DAIFMT_* format value.
8c6529db
LG		 2806 *
2807 * Configures the DAI hardware format and clocking.
2808 */
2809int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2810{
5e4ba569 2811 if (dai->driver == NULL)
8c6529db 2812 return -EINVAL;
5e4ba569
SG		 2813 if (dai->driver->ops->set_fmt == NULL)
2814 return -ENOTSUPP;
2815 return dai->driver->ops->set_fmt(dai, fmt);
8c6529db
LG		 2816}
2817EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
2818
89c67857 2819/**
e5c21514 2820 * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
89c67857
XL		 2821 * @slots: Number of slots in use.
2822 * @tx_mask: bitmask representing active TX slots.
2823 * @rx_mask: bitmask representing active RX slots.
2824 *
2825 * Generates the TDM tx and rx slot default masks for DAI.
2826 */
e5c21514 2827static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
89c67857
XL		 2828 unsigned int *tx_mask,
2829 unsigned int *rx_mask)
2830{
2831 if (*tx_mask || *rx_mask)
2832 return 0;
2833
2834 if (!slots)
2835 return -EINVAL;
2836
2837 *tx_mask = (1 << slots) - 1;
2838 *rx_mask = (1 << slots) - 1;
2839
2840 return 0;
2841}
2842
8c6529db 2843/**
e46c9366
LPC		 2844 * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
2845 * @dai: The DAI to configure
a5479e38
DR		 2846 * @tx_mask: bitmask representing active TX slots.
2847 * @rx_mask: bitmask representing active RX slots.
8c6529db 2848 * @slots: Number of slots in use.
a5479e38 2849 * @slot_width: Width in bits for each slot.
8c6529db 2850 *
e46c9366
LPC		 2851 * This function configures the specified DAI for TDM operation. @slot contains
2852 * the total number of slots of the TDM stream and @slot_with the width of each
2853 * slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
2854 * active slots of the TDM stream for the specified DAI, i.e. which slots the
2855 * DAI should write to or read from. If a bit is set the corresponding slot is
2856 * active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
2857 * the first slot, bit 1 to the second slot and so on. The first active slot
2858 * maps to the first channel of the DAI, the second active slot to the second
2859 * channel and so on.
2860 *
2861 * TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
2862 * @rx_mask and @slot_width will be ignored.
2863 *
2864 * Returns 0 on success, a negative error code otherwise.
8c6529db
LG		 2865 */
2866int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
a5479e38 2867 unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
8c6529db 2868{
46471925 2869 if (dai->driver->ops->xlate_tdm_slot_mask)
e5c21514 2870 dai->driver->ops->xlate_tdm_slot_mask(slots,
89c67857
XL		 2871 &tx_mask, &rx_mask);
2872 else
e5c21514 2873 snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
89c67857 2874
88bd870f
BC		 2875 dai->tx_mask = tx_mask;
2876 dai->rx_mask = rx_mask;
2877
46471925 2878 if (dai->driver->ops->set_tdm_slot)
f0fba2ad 2879 return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
a5479e38 2880 slots, slot_width);
8c6529db 2881 else
b2cbb6e1 2882 return -ENOTSUPP;
8c6529db
LG		 2883}
2884EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
2885
472df3cb
BS		 2886/**
2887 * snd_soc_dai_set_channel_map - configure DAI audio channel map
2888 * @dai: DAI
2889 * @tx_num: how many TX channels
2890 * @tx_slot: pointer to an array which imply the TX slot number channel
2891 * 0~num-1 uses
2892 * @rx_num: how many RX channels
2893 * @rx_slot: pointer to an array which imply the RX slot number channel
2894 * 0~num-1 uses
2895 *
2896 * configure the relationship between channel number and TDM slot number.
2897 */
2898int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
2899 unsigned int tx_num, unsigned int *tx_slot,
2900 unsigned int rx_num, unsigned int *rx_slot)
2901{
46471925 2902 if (dai->driver->ops->set_channel_map)
f0fba2ad 2903 return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
472df3cb
BS		 2904 rx_num, rx_slot);
2905 else
2906 return -EINVAL;
2907}
2908EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
2909
8c6529db
LG		 2910/**
2911 * snd_soc_dai_set_tristate - configure DAI system or master clock.
2912 * @dai: DAI
2913 * @tristate: tristate enable
2914 *
2915 * Tristates the DAI so that others can use it.
2916 */
2917int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
2918{
46471925 2919 if (dai->driver->ops->set_tristate)
f0fba2ad 2920 return dai->driver->ops->set_tristate(dai, tristate);
8c6529db
LG		 2921 else
2922 return -EINVAL;
2923}
2924EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
2925
2926/**
2927 * snd_soc_dai_digital_mute - configure DAI system or master clock.
2928 * @dai: DAI
2929 * @mute: mute enable
da18396f 2930 * @direction: stream to mute
8c6529db
LG		 2931 *
2932 * Mutes the DAI DAC.
2933 */
da18396f
MB		 2934int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
2935 int direction)
8c6529db 2936{
da18396f
MB		 2937 if (!dai->driver)
2938 return -ENOTSUPP;
2939
2940 if (dai->driver->ops->mute_stream)
2941 return dai->driver->ops->mute_stream(dai, mute, direction);
2942 else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
2943 dai->driver->ops->digital_mute)
f0fba2ad 2944 return dai->driver->ops->digital_mute(dai, mute);
8c6529db 2945 else
04570c62 2946 return -ENOTSUPP;
8c6529db
LG		 2947}
2948EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);
2949
c5af3a2e
MB		 2950/**
2951 * snd_soc_register_card - Register a card with the ASoC core
2952 *
ac11a2b3 2953 * @card: Card to register
c5af3a2e 2954 *
c5af3a2e 2955 */
70a7ca34 2956int snd_soc_register_card(struct snd_soc_card *card)
c5af3a2e 2957{
923c5e61 2958 int i, ret;
1a497983 2959 struct snd_soc_pcm_runtime *rtd;
f0fba2ad 2960
c5af3a2e
MB		 2961 if (!card->name || !card->dev)
2962 return -EINVAL;
2963
5a504963
SW		 2964 for (i = 0; i < card->num_links; i++) {
2965 struct snd_soc_dai_link *link = &card->dai_link[i];
2966
923c5e61 2967 ret = soc_init_dai_link(card, link);
88bd870f 2968 if (ret) {
923c5e61 2969 dev_err(card->dev, "ASoC: failed to init link %s\n",
10e8aa9a 2970 link->name);
923c5e61 2971 return ret;
5a504963
SW		 2972 }
2973 }
2974
ed77cc12
MB		 2975 dev_set_drvdata(card->dev, card);
2976
111c6419
SW		 2977 snd_soc_initialize_card_lists(card);
2978
f8f80361
ML		 2979 INIT_LIST_HEAD(&card->dai_link_list);
2980 card->num_dai_links = 0;
2981
1a497983
ML		 2982 INIT_LIST_HEAD(&card->rtd_list);
2983 card->num_rtd = 0;
2984
db432b41 2985 INIT_LIST_HEAD(&card->dapm_dirty);
8a978234 2986 INIT_LIST_HEAD(&card->dobj_list);
c5af3a2e 2987 card->instantiated = 0;
f0fba2ad 2988 mutex_init(&card->mutex);
a73fb2df 2989 mutex_init(&card->dapm_mutex);
c5af3a2e 2990
b19e6e7b
MB		 2991 ret = snd_soc_instantiate_card(card);
2992 if (ret != 0)
4e2576bd 2993 return ret;
c5af3a2e 2994
988e8cc4 2995 /* deactivate pins to sleep state */
1a497983 2996 list_for_each_entry(rtd, &card->rtd_list, list) {
88bd870f
BC		 2997 struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2998 int j;
2999
3000 for (j = 0; j < rtd->num_codecs; j++) {
3001 struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
3002 if (!codec_dai->active)
3003 pinctrl_pm_select_sleep_state(codec_dai->dev);
3004 }
3005
988e8cc4
NC		 3006 if (!cpu_dai->active)
3007 pinctrl_pm_select_sleep_state(cpu_dai->dev);
3008 }
3009
b19e6e7b 3010 return ret;
c5af3a2e 3011}
70a7ca34 3012EXPORT_SYMBOL_GPL(snd_soc_register_card);
c5af3a2e
MB		 3013
3014/**
3015 * snd_soc_unregister_card - Unregister a card with the ASoC core
3016 *
ac11a2b3 3017 * @card: Card to unregister
c5af3a2e 3018 *
c5af3a2e 3019 */
70a7ca34 3020int snd_soc_unregister_card(struct snd_soc_card *card)
c5af3a2e 3021{
01e0df66
LPC		 3022 if (card->instantiated) {
3023 card->instantiated = false;
1c325f77 3024 snd_soc_dapm_shutdown(card);
b0e26485 3025 soc_cleanup_card_resources(card);
8f6f9b29 3026 dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
01e0df66 3027 }
c5af3a2e
MB		 3028
3029 return 0;
3030}
70a7ca34 3031EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
c5af3a2e 3032
f0fba2ad
LG		 3033/*
3034 * Simplify DAI link configuration by removing ".-1" from device names
3035 * and sanitizing names.
3036 */
0b9a214a 3037static char *fmt_single_name(struct device *dev, int *id)
f0fba2ad
LG		 3038{
3039 char *found, name[NAME_SIZE];
3040 int id1, id2;
3041
3042 if (dev_name(dev) == NULL)
3043 return NULL;
3044
58818a77 3045 strlcpy(name, dev_name(dev), NAME_SIZE);
f0fba2ad
LG		 3046
3047 /* are we a "%s.%d" name (platform and SPI components) */
3048 found = strstr(name, dev->driver->name);
3049 if (found) {
3050 /* get ID */
3051 if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {
3052
3053 /* discard ID from name if ID == -1 */
3054 if (*id == -1)
3055 found[strlen(dev->driver->name)] = '\0';
3056 }
3057
3058 } else {
3059 /* I2C component devices are named "bus-addr" */
3060 if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
3061 char tmp[NAME_SIZE];
3062
3063 /* create unique ID number from I2C addr and bus */
05899446 3064 *id = ((id1 & 0xffff) << 16) + id2;
f0fba2ad
LG		 3065
3066 /* sanitize component name for DAI link creation */
3067 snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
58818a77 3068 strlcpy(name, tmp, NAME_SIZE);
f0fba2ad
LG		 3069 } else
3070 *id = 0;
3071 }
3072
3073 return kstrdup(name, GFP_KERNEL);
3074}
3075
3076/*
3077 * Simplify DAI link naming for single devices with multiple DAIs by removing
3078 * any ".-1" and using the DAI name (instead of device name).
3079 */
3080static inline char *fmt_multiple_name(struct device *dev,
3081 struct snd_soc_dai_driver *dai_drv)
3082{
3083 if (dai_drv->name == NULL) {
10e8aa9a
MM		 3084 dev_err(dev,
3085 "ASoC: error - multiple DAI %s registered with no name\n",
3086 dev_name(dev));
f0fba2ad
LG		 3087 return NULL;
3088 }
3089
3090 return kstrdup(dai_drv->name, GFP_KERNEL);
3091}
3092
9115171a 3093/**
32c9ba54 3094 * snd_soc_unregister_dai - Unregister DAIs from the ASoC core
9115171a 3095 *
32c9ba54 3096 * @component: The component for which the DAIs should be unregistered
9115171a 3097 */
32c9ba54 3098static void snd_soc_unregister_dais(struct snd_soc_component *component)
9115171a 3099{
5c1d5f09 3100 struct snd_soc_dai *dai, *_dai;
9115171a 3101
5c1d5f09 3102 list_for_each_entry_safe(dai, _dai, &component->dai_list, list) {
32c9ba54
LPC		 3103 dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",
3104 dai->name);
5c1d5f09 3105 list_del(&dai->list);
32c9ba54 3106 kfree(dai->name);
f0fba2ad 3107 kfree(dai);
f0fba2ad 3108 }
9115171a 3109}
9115171a 3110
5e4fb372
ML		 3111/* Create a DAI and add it to the component's DAI list */
3112static struct snd_soc_dai *soc_add_dai(struct snd_soc_component *component,
3113 struct snd_soc_dai_driver *dai_drv,
3114 bool legacy_dai_naming)
3115{
3116 struct device *dev = component->dev;
3117 struct snd_soc_dai *dai;
3118
3119 dev_dbg(dev, "ASoC: dynamically register DAI %s\n", dev_name(dev));
3120
3121 dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
3122 if (dai == NULL)
3123 return NULL;
3124
3125 /*
3126 * Back in the old days when we still had component-less DAIs,
3127 * instead of having a static name, component-less DAIs would
3128 * inherit the name of the parent device so it is possible to
3129 * register multiple instances of the DAI. We still need to keep
3130 * the same naming style even though those DAIs are not
3131 * component-less anymore.
3132 */
3133 if (legacy_dai_naming &&
3134 (dai_drv->id == 0 || dai_drv->name == NULL)) {
3135 dai->name = fmt_single_name(dev, &dai->id);
3136 } else {
3137 dai->name = fmt_multiple_name(dev, dai_drv);
3138 if (dai_drv->id)
3139 dai->id = dai_drv->id;
3140 else
3141 dai->id = component->num_dai;
3142 }
3143 if (dai->name == NULL) {
3144 kfree(dai);
3145 return NULL;
3146 }
3147
3148 dai->component = component;
3149 dai->dev = dev;
3150 dai->driver = dai_drv;
3151 if (!dai->driver->ops)
3152 dai->driver->ops = &null_dai_ops;
3153
3154 list_add(&dai->list, &component->dai_list);
3155 component->num_dai++;
3156
3157 dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
3158 return dai;
3159}
3160
9115171a 3161/**
32c9ba54 3162 * snd_soc_register_dais - Register a DAI with the ASoC core
9115171a 3163 *
6106d129
LPC		 3164 * @component: The component the DAIs are registered for
3165 * @dai_drv: DAI driver to use for the DAIs
ac11a2b3 3166 * @count: Number of DAIs
32c9ba54
LPC		 3167 * @legacy_dai_naming: Use the legacy naming scheme and let the DAI inherit the
3168 * parent's name.
9115171a 3169 */
6106d129 3170static int snd_soc_register_dais(struct snd_soc_component *component,
bb13109d
LPC		 3171 struct snd_soc_dai_driver *dai_drv, size_t count,
3172 bool legacy_dai_naming)
9115171a 3173{
6106d129 3174 struct device *dev = component->dev;
f0fba2ad 3175 struct snd_soc_dai *dai;
32c9ba54
LPC		 3176 unsigned int i;
3177 int ret;
f0fba2ad 3178
5b5e0928 3179 dev_dbg(dev, "ASoC: dai register %s #%zu\n", dev_name(dev), count);
9115171a 3180
bb13109d 3181 component->dai_drv = dai_drv;
bb13109d 3182
9115171a 3183 for (i = 0; i < count; i++) {
f0fba2ad 3184
5e4fb372
ML		 3185 dai = soc_add_dai(component, dai_drv + i,
3186 count == 1 && legacy_dai_naming);
c46e0079
AL		 3187 if (dai == NULL) {
3188 ret = -ENOMEM;
3189 goto err;
3190 }
9115171a 3191 }
f0fba2ad 3192
9115171a 3193 return 0;
f0fba2ad 3194
9115171a 3195err:
32c9ba54 3196 snd_soc_unregister_dais(component);
f0fba2ad 3197
9115171a
MB		 3198 return ret;
3199}
9115171a 3200
68003e6c
ML		 3201/**
3202 * snd_soc_register_dai - Register a DAI dynamically & create its widgets
3203 *
3204 * @component: The component the DAIs are registered for
3205 * @dai_drv: DAI driver to use for the DAI
3206 *
3207 * Topology can use this API to register DAIs when probing a component.
3208 * These DAIs's widgets will be freed in the card cleanup and the DAIs
3209 * will be freed in the component cleanup.
3210 */
3211int snd_soc_register_dai(struct snd_soc_component *component,
3212 struct snd_soc_dai_driver *dai_drv)
3213{
3214 struct snd_soc_dapm_context *dapm =
3215 snd_soc_component_get_dapm(component);
3216 struct snd_soc_dai *dai;
3217 int ret;
054880fe 3218
68003e6c
ML		 3219 if (dai_drv->dobj.type != SND_SOC_DOBJ_PCM) {
3220 dev_err(component->dev, "Invalid dai type %d\n",
3221 dai_drv->dobj.type);
3222 return -EINVAL;
9115171a
MB		 3223 }
3224
68003e6c
ML		 3225 lockdep_assert_held(&client_mutex);
3226 dai = soc_add_dai(component, dai_drv, false);
3227 if (!dai)
3228 return -ENOMEM;
9115171a 3229
68003e6c
ML		 3230 /* Create the DAI widgets here. After adding DAIs, topology may
3231 * also add routes that need these widgets as source or sink.
3232 */
3233 ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
3234 if (ret != 0) {
3235 dev_err(component->dev,
3236 "Failed to create DAI widgets %d\n", ret);
3237 }
9115171a
MB		 3238
3239 return ret;
3240}
68003e6c 3241EXPORT_SYMBOL_GPL(snd_soc_register_dai);
9115171a 3242
14e8bdeb
LPC		 3243static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context *dapm,
3244 enum snd_soc_dapm_type type, int subseq)
d191bd8d 3245{
14e8bdeb 3246 struct snd_soc_component *component = dapm->component;
d191bd8d 3247
14e8bdeb
LPC		 3248 component->driver->seq_notifier(component, type, subseq);
3249}
d191bd8d 3250
14e8bdeb
LPC		 3251static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,
3252 int event)
3253{
3254 struct snd_soc_component *component = dapm->component;
d191bd8d 3255
14e8bdeb
LPC		 3256 return component->driver->stream_event(component, event);
3257}
e2c330b9 3258
f523aceb
KM		 3259static int snd_soc_component_drv_pcm_new(struct snd_soc_component *component,
3260 struct snd_soc_pcm_runtime *rtd)
3261{
3262 if (component->driver->pcm_new)
3263 return component->driver->pcm_new(rtd);
3264
3265 return 0;
3266}
3267
3268static void snd_soc_component_drv_pcm_free(struct snd_soc_component *component,
3269 struct snd_pcm *pcm)
3270{
3271 if (component->driver->pcm_free)
3272 component->driver->pcm_free(pcm);
3273}
3274
7ba236ce
KM		 3275static int snd_soc_component_set_bias_level(struct snd_soc_dapm_context *dapm,
3276 enum snd_soc_bias_level level)
3277{
3278 struct snd_soc_component *component = dapm->component;
3279
3280 return component->driver->set_bias_level(component, level);
3281}
3282
bb13109d
LPC		 3283static int snd_soc_component_initialize(struct snd_soc_component *component,
3284 const struct snd_soc_component_driver *driver, struct device *dev)
d191bd8d 3285{
ce0fc93a
LPC		 3286 struct snd_soc_dapm_context *dapm;
3287
bb13109d
LPC		 3288 component->name = fmt_single_name(dev, &component->id);
3289 if (!component->name) {
3290 dev_err(dev, "ASoC: Failed to allocate name\n");
d191bd8d
KM		 3291 return -ENOMEM;
3292 }
3293
bb13109d
LPC		 3294 component->dev = dev;
3295 component->driver = driver;
61aca564
LPC		 3296 component->probe = component->driver->probe;
3297 component->remove = component->driver->remove;
9178feb4
KM		 3298 component->suspend = component->driver->suspend;
3299 component->resume = component->driver->resume;
71ccef0d 3300 component->set_sysclk = component->driver->set_sysclk;
ef641e5d 3301 component->set_pll = component->driver->set_pll;
44c07365 3302 component->set_jack = component->driver->set_jack;
f523aceb
KM		 3303 component->pcm_new = snd_soc_component_drv_pcm_new;
3304 component->pcm_free = snd_soc_component_drv_pcm_free;
d191bd8d 3305
88c27465 3306 dapm = snd_soc_component_get_dapm(component);
ce0fc93a
LPC		 3307 dapm->dev = dev;
3308 dapm->component = component;
3309 dapm->bias_level = SND_SOC_BIAS_OFF;
7ba236ce
KM		 3310 dapm->idle_bias_off = !driver->idle_bias_on;
3311 dapm->suspend_bias_off = driver->suspend_bias_off;
14e8bdeb
LPC		 3312 if (driver->seq_notifier)
3313 dapm->seq_notifier = snd_soc_component_seq_notifier;
3314 if (driver->stream_event)
3315 dapm->stream_event = snd_soc_component_stream_event;
7ba236ce
KM		 3316 if (driver->set_bias_level)
3317 dapm->set_bias_level = snd_soc_component_set_bias_level;
d191bd8d 3318
bb13109d
LPC		 3319 INIT_LIST_HEAD(&component->dai_list);
3320 mutex_init(&component->io_mutex);
d191bd8d 3321
bb13109d
LPC		 3322 return 0;
3323}
d191bd8d 3324
20feb881 3325static void snd_soc_component_setup_regmap(struct snd_soc_component *component)
886f5692 3326{
20feb881
LPC		 3327 int val_bytes = regmap_get_val_bytes(component->regmap);
3328
3329 /* Errors are legitimate for non-integer byte multiples */
3330 if (val_bytes > 0)
3331 component->val_bytes = val_bytes;
3332}
3333
e874bf5f
LPC		 3334#ifdef CONFIG_REGMAP
3335
20feb881
LPC		 3336/**
3337 * snd_soc_component_init_regmap() - Initialize regmap instance for the component
3338 * @component: The component for which to initialize the regmap instance
3339 * @regmap: The regmap instance that should be used by the component
3340 *
3341 * This function allows deferred assignment of the regmap instance that is
3342 * associated with the component. Only use this if the regmap instance is not
3343 * yet ready when the component is registered. The function must also be called
3344 * before the first IO attempt of the component.
3345 */
3346void snd_soc_component_init_regmap(struct snd_soc_component *component,
3347 struct regmap *regmap)
3348{
3349 component->regmap = regmap;
3350 snd_soc_component_setup_regmap(component);
886f5692 3351}
20feb881
LPC		 3352EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap);
3353
3354/**
3355 * snd_soc_component_exit_regmap() - De-initialize regmap instance for the component
3356 * @component: The component for which to de-initialize the regmap instance
3357 *
3358 * Calls regmap_exit() on the regmap instance associated to the component and
3359 * removes the regmap instance from the component.
3360 *
3361 * This function should only be used if snd_soc_component_init_regmap() was used
3362 * to initialize the regmap instance.
3363 */
3364void snd_soc_component_exit_regmap(struct snd_soc_component *component)
3365{
3366 regmap_exit(component->regmap);
3367 component->regmap = NULL;
3368}
3369EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap);
886f5692 3370
e874bf5f 3371#endif
886f5692 3372
bb13109d
LPC		 3373static void snd_soc_component_add_unlocked(struct snd_soc_component *component)
3374{
20feb881
LPC		 3375 if (!component->write && !component->read) {
3376 if (!component->regmap)
3377 component->regmap = dev_get_regmap(component->dev, NULL);
3378 if (component->regmap)
3379 snd_soc_component_setup_regmap(component);
3380 }
886f5692 3381
bb13109d 3382 list_add(&component->list, &component_list);
8a978234 3383 INIT_LIST_HEAD(&component->dobj_list);
bb13109d 3384}
d191bd8d 3385
bb13109d
LPC		 3386static void snd_soc_component_add(struct snd_soc_component *component)
3387{
d191bd8d 3388 mutex_lock(&client_mutex);
bb13109d 3389 snd_soc_component_add_unlocked(component);
d191bd8d 3390 mutex_unlock(&client_mutex);
bb13109d 3391}
d191bd8d 3392
bb13109d
LPC		 3393static void snd_soc_component_cleanup(struct snd_soc_component *component)
3394{
3395 snd_soc_unregister_dais(component);
3396 kfree(component->name);
3397}
d191bd8d 3398
bb13109d
LPC		 3399static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
3400{
c12c1aad
KM		 3401 struct snd_soc_card *card = component->card;
3402
3403 if (card)
3404 snd_soc_unregister_card(card);
3405
bb13109d
LPC		 3406 list_del(&component->list);
3407}
d191bd8d 3408
273d778e
KM		 3409#define ENDIANNESS_MAP(name) \
3410 (SNDRV_PCM_FMTBIT_##name##LE | SNDRV_PCM_FMTBIT_##name##BE)
3411static u64 endianness_format_map[] = {
3412 ENDIANNESS_MAP(S16_),
3413 ENDIANNESS_MAP(U16_),
3414 ENDIANNESS_MAP(S24_),
3415 ENDIANNESS_MAP(U24_),
3416 ENDIANNESS_MAP(S32_),
3417 ENDIANNESS_MAP(U32_),
3418 ENDIANNESS_MAP(S24_3),
3419 ENDIANNESS_MAP(U24_3),
3420 ENDIANNESS_MAP(S20_3),
3421 ENDIANNESS_MAP(U20_3),
3422 ENDIANNESS_MAP(S18_3),
3423 ENDIANNESS_MAP(U18_3),
3424 ENDIANNESS_MAP(FLOAT_),
3425 ENDIANNESS_MAP(FLOAT64_),
3426 ENDIANNESS_MAP(IEC958_SUBFRAME_),
3427};
3428
3429/*
3430 * Fix up the DAI formats for endianness: codecs don't actually see
3431 * the endianness of the data but we're using the CPU format
3432 * definitions which do need to include endianness so we ensure that
3433 * codec DAIs always have both big and little endian variants set.
3434 */
3435static void convert_endianness_formats(struct snd_soc_pcm_stream *stream)
3436{
3437 int i;
3438
3439 for (i = 0; i < ARRAY_SIZE(endianness_format_map); i++)
3440 if (stream->formats & endianness_format_map[i])
3441 stream->formats |= endianness_format_map[i];
3442}
3443
e0dac41b
KM		 3444int snd_soc_add_component(struct device *dev,
3445 struct snd_soc_component *component,
3446 const struct snd_soc_component_driver *component_driver,
3447 struct snd_soc_dai_driver *dai_drv,
3448 int num_dai)
d191bd8d 3449{
bb13109d 3450 int ret;
273d778e 3451 int i;
d191bd8d 3452
cf9e829e 3453 ret = snd_soc_component_initialize(component, component_driver, dev);
bb13109d
LPC		 3454 if (ret)
3455 goto err_free;
3456
cf9e829e
KM		 3457 component->ignore_pmdown_time = true;
3458 component->registered_as_component = true;
3d59400f 3459
273d778e
KM		 3460 if (component_driver->endianness) {
3461 for (i = 0; i < num_dai; i++) {
3462 convert_endianness_formats(&dai_drv[i].playback);
3463 convert_endianness_formats(&dai_drv[i].capture);
3464 }
3465 }
3466
69941bab
KM		 3467 ret = snd_soc_register_dais(component, dai_drv, num_dai,
3468 !component_driver->non_legacy_dai_naming);
bb13109d 3469 if (ret < 0) {
f42cf8d6 3470 dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
bb13109d
LPC		 3471 goto err_cleanup;
3472 }
d191bd8d 3473
cf9e829e 3474 snd_soc_component_add(component);
4da53393 3475
bb13109d 3476 return 0;
4da53393 3477
bb13109d 3478err_cleanup:
cf9e829e 3479 snd_soc_component_cleanup(component);
bb13109d 3480err_free:
cf9e829e 3481 kfree(component);
bb13109d 3482 return ret;
4da53393 3483}
e0dac41b
KM		 3484EXPORT_SYMBOL_GPL(snd_soc_add_component);
3485
3486int snd_soc_register_component(struct device *dev,
3487 const struct snd_soc_component_driver *component_driver,
3488 struct snd_soc_dai_driver *dai_drv,
3489 int num_dai)
3490{
3491 struct snd_soc_component *component;
3492
3493 component = kzalloc(sizeof(*component), GFP_KERNEL);
08e61d03 3494 if (!component)
e0dac41b 3495 return -ENOMEM;
e0dac41b
KM		 3496
3497 return snd_soc_add_component(dev, component, component_driver,
3498 dai_drv, num_dai);
3499}
bb13109d 3500EXPORT_SYMBOL_GPL(snd_soc_register_component);
4da53393 3501
d191bd8d 3502/**
2eccea8c
KM		 3503 * snd_soc_unregister_component - Unregister all related component
3504 * from the ASoC core
d191bd8d 3505 *
628536ea 3506 * @dev: The device to unregister
d191bd8d 3507 */
2eccea8c 3508static int __snd_soc_unregister_component(struct device *dev)
d191bd8d 3509{
cf9e829e 3510 struct snd_soc_component *component;
21a03528 3511 int found = 0;
d191bd8d 3512
34e81ab4 3513 mutex_lock(&client_mutex);
cf9e829e 3514 list_for_each_entry(component, &component_list, list) {
21a03528
KM		 3515 if (dev != component->dev ||
3516 !component->registered_as_component)
3517 continue;
3518
3519 snd_soc_tplg_component_remove(component, SND_SOC_TPLG_INDEX_ALL);
3520 snd_soc_component_del_unlocked(component);
3521 found = 1;
3522 break;
d191bd8d 3523 }
34e81ab4 3524 mutex_unlock(&client_mutex);
d191bd8d 3525
21a03528
KM		 3526 if (found) {
3527 snd_soc_component_cleanup(component);
3528 kfree(component);
3529 }
2eccea8c
KM		 3530
3531 return found;
3532}
3533
3534void snd_soc_unregister_component(struct device *dev)
3535{
3536 while (__snd_soc_unregister_component(dev));
d191bd8d
KM		 3537}
3538EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
d191bd8d 3539
7dd5d0d9
KM		 3540struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
3541 const char *driver_name)
3542{
3543 struct snd_soc_component *component;
3544 struct snd_soc_component *ret;
3545
3546 ret = NULL;
3547 mutex_lock(&client_mutex);
3548 list_for_each_entry(component, &component_list, list) {
3549 if (dev != component->dev)
3550 continue;
3551
3552 if (driver_name &&
3553 (driver_name != component->driver->name) &&
3554 (strcmp(component->driver->name, driver_name) != 0))
3555 continue;
3556
3557 ret = component;
3558 break;
3559 }
3560 mutex_unlock(&client_mutex);
3561
3562 return ret;
3563}
3564EXPORT_SYMBOL_GPL(snd_soc_lookup_component);
3565
f1d45cc3 3566static int snd_soc_platform_drv_probe(struct snd_soc_component *component)
e2c330b9
LPC		 3567{
3568 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
d191bd8d 3569
f1d45cc3 3570 return platform->driver->probe(platform);
e2c330b9
LPC		 3571}
3572
f1d45cc3 3573static void snd_soc_platform_drv_remove(struct snd_soc_component *component)
e2c330b9
LPC		 3574{
3575 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
3576
f1d45cc3 3577 platform->driver->remove(platform);
d191bd8d 3578}
d191bd8d 3579
f523aceb
KM		 3580static int snd_soc_platform_drv_pcm_new(struct snd_soc_component *component,
3581 struct snd_soc_pcm_runtime *rtd)
3582{
3583 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
3584
3585 if (platform->driver->pcm_new)
3586 return platform->driver->pcm_new(rtd);
3587
3588 return 0;
3589}
3590
3591static void snd_soc_platform_drv_pcm_free(struct snd_soc_component *component,
3592 struct snd_pcm *pcm)
3593{
3594 struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
3595
3596 if (platform->driver->pcm_free)
3597 platform->driver->pcm_free(pcm);
3598}
3599
12a48a8c 3600/**
71a45cda
LPC		 3601 * snd_soc_add_platform - Add a platform to the ASoC core
3602 * @dev: The parent device for the platform
3603 * @platform: The platform to add
7d1442b4 3604 * @platform_drv: The driver for the platform
12a48a8c 3605 */
71a45cda 3606int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
d79e57db 3607 const struct snd_soc_platform_driver *platform_drv)
12a48a8c 3608{
b37f1d12
LPC		 3609 int ret;
3610
bb13109d
LPC		 3611 ret = snd_soc_component_initialize(&platform->component,
3612 &platform_drv->component_driver, dev);
3613 if (ret)
3614 return ret;
12a48a8c 3615
f0fba2ad
LG		 3616 platform->dev = dev;
3617 platform->driver = platform_drv;
f1d45cc3
LPC		 3618
3619 if (platform_drv->probe)
3620 platform->component.probe = snd_soc_platform_drv_probe;
3621 if (platform_drv->remove)
3622 platform->component.remove = snd_soc_platform_drv_remove;
f523aceb
KM		 3623 if (platform_drv->pcm_new)
3624 platform->component.pcm_new = snd_soc_platform_drv_pcm_new;
3625 if (platform_drv->pcm_free)
3626 platform->component.pcm_free = snd_soc_platform_drv_pcm_free;
12a48a8c 3627
81c7cfd1
LPC		 3628#ifdef CONFIG_DEBUG_FS
3629 platform->component.debugfs_prefix = "platform";
3630#endif
12a48a8c
MB		 3631
3632 mutex_lock(&client_mutex);
bb13109d 3633 snd_soc_component_add_unlocked(&platform->component);
12a48a8c
MB		 3634 list_add(&platform->list, &platform_list);
3635 mutex_unlock(&client_mutex);
3636
f4333203
LPC		 3637 dev_dbg(dev, "ASoC: Registered platform '%s'\n",
3638 platform->component.name);
12a48a8c
MB		 3639
3640 return 0;
3641}
71a45cda 3642EXPORT_SYMBOL_GPL(snd_soc_add_platform);
12a48a8c
MB		 3643
3644/**
71a45cda 3645 * snd_soc_register_platform - Register a platform with the ASoC core
12a48a8c 3646 *
628536ea
JC		 3647 * @dev: The device for the platform
3648 * @platform_drv: The driver for the platform
12a48a8c 3649 */
71a45cda
LPC		 3650int snd_soc_register_platform(struct device *dev,
3651 const struct snd_soc_platform_driver *platform_drv)
12a48a8c 3652{
f0fba2ad 3653 struct snd_soc_platform *platform;
71a45cda 3654 int ret;
f0fba2ad 3655
71a45cda 3656 dev_dbg(dev, "ASoC: platform register %s\n", dev_name(dev));
f0fba2ad 3657
71a45cda
LPC		 3658 platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
3659 if (platform == NULL)
3660 return -ENOMEM;
3661
3662 ret = snd_soc_add_platform(dev, platform, platform_drv);
3663 if (ret)
3664 kfree(platform);
3665
3666 return ret;
3667}
3668EXPORT_SYMBOL_GPL(snd_soc_register_platform);
3669
3670/**
3671 * snd_soc_remove_platform - Remove a platform from the ASoC core
3672 * @platform: the platform to remove
3673 */
3674void snd_soc_remove_platform(struct snd_soc_platform *platform)
3675{
b37f1d12 3676
12a48a8c
MB		 3677 mutex_lock(&client_mutex);
3678 list_del(&platform->list);
bb13109d 3679 snd_soc_component_del_unlocked(&platform->component);
12a48a8c
MB		 3680 mutex_unlock(&client_mutex);
3681
71a45cda 3682 dev_dbg(platform->dev, "ASoC: Unregistered platform '%s'\n",
f4333203 3683 platform->component.name);
decc27b0
DM		 3684
3685 snd_soc_component_cleanup(&platform->component);
71a45cda
LPC		 3686}
3687EXPORT_SYMBOL_GPL(snd_soc_remove_platform);
3688
3689struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev)
3690{
3691 struct snd_soc_platform *platform;
3692
34e81ab4 3693 mutex_lock(&client_mutex);
71a45cda 3694 list_for_each_entry(platform, &platform_list, list) {
34e81ab4
LPC		 3695 if (dev == platform->dev) {
3696 mutex_unlock(&client_mutex);
71a45cda 3697 return platform;
34e81ab4 3698 }
71a45cda 3699 }
34e81ab4 3700 mutex_unlock(&client_mutex);
71a45cda
LPC		 3701
3702 return NULL;
3703}
3704EXPORT_SYMBOL_GPL(snd_soc_lookup_platform);
3705
3706/**
3707 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
3708 *
628536ea 3709 * @dev: platform to unregister
71a45cda
LPC		 3710 */
3711void snd_soc_unregister_platform(struct device *dev)
3712{
3713 struct snd_soc_platform *platform;
3714
3715 platform = snd_soc_lookup_platform(dev);
3716 if (!platform)
3717 return;
3718
3719 snd_soc_remove_platform(platform);
f0fba2ad 3720 kfree(platform);
12a48a8c
MB		 3721}
3722EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);
3723
f1d45cc3
LPC		 3724static int snd_soc_codec_drv_probe(struct snd_soc_component *component)
3725{
3726 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3727
3728 return codec->driver->probe(codec);
3729}
3730
3731static void snd_soc_codec_drv_remove(struct snd_soc_component *component)
3732{
3733 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3734
3735 codec->driver->remove(codec);
3736}
3737
9178feb4
KM		 3738static int snd_soc_codec_drv_suspend(struct snd_soc_component *component)
3739{
3740 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3741
3742 return codec->driver->suspend(codec);
3743}
3744
3745static int snd_soc_codec_drv_resume(struct snd_soc_component *component)
3746{
3747 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3748
3749 return codec->driver->resume(codec);
3750}
3751
e2c330b9
LPC		 3752static int snd_soc_codec_drv_write(struct snd_soc_component *component,
3753 unsigned int reg, unsigned int val)
3754{
3755 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3756
3757 return codec->driver->write(codec, reg, val);
3758}
3759
3760static int snd_soc_codec_drv_read(struct snd_soc_component *component,
3761 unsigned int reg, unsigned int *val)
3762{
3763 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3764
3765 *val = codec->driver->read(codec, reg);
3766
3767 return 0;
3768}
3769
71ccef0d
KM		 3770static int snd_soc_codec_set_sysclk_(struct snd_soc_component *component,
3771 int clk_id, int source, unsigned int freq, int dir)
3772{
3773 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3774
3775 return snd_soc_codec_set_sysclk(codec, clk_id, source, freq, dir);
3776}
3777
ef641e5d
KM		 3778static int snd_soc_codec_set_pll_(struct snd_soc_component *component,
3779 int pll_id, int source, unsigned int freq_in,
3780 unsigned int freq_out)
3781{
3782 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3783
3784 return snd_soc_codec_set_pll(codec, pll_id, source, freq_in, freq_out);
3785}
3786
44c07365
KM		 3787static int snd_soc_codec_set_jack_(struct snd_soc_component *component,
3788 struct snd_soc_jack *jack, void *data)
3789{
3790 struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
3791
3792 return snd_soc_codec_set_jack(codec, jack, data);
3793}
3794
68f831c2
LPC		 3795static int snd_soc_codec_set_bias_level(struct snd_soc_dapm_context *dapm,
3796 enum snd_soc_bias_level level)
3797{
3798 struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
3799
3800 return codec->driver->set_bias_level(codec, level);
3801}
3802
0d0cf00a
MB		 3803/**
3804 * snd_soc_register_codec - Register a codec with the ASoC core
3805 *
628536ea
JC		 3806 * @dev: The parent device for this codec
3807 * @codec_drv: Codec driver
3808 * @dai_drv: The associated DAI driver
3809 * @num_dai: Number of DAIs
0d0cf00a 3810 */
f0fba2ad 3811int snd_soc_register_codec(struct device *dev,
001ae4c0
MB		 3812 const struct snd_soc_codec_driver *codec_drv,
3813 struct snd_soc_dai_driver *dai_drv,
3814 int num_dai)
0d0cf00a 3815{
4890140f 3816 struct snd_soc_dapm_context *dapm;
f0fba2ad 3817 struct snd_soc_codec *codec;
bb13109d 3818 struct snd_soc_dai *dai;
f0fba2ad 3819 int ret, i;
151ab22c 3820
f0fba2ad
LG		 3821 dev_dbg(dev, "codec register %s\n", dev_name(dev));
3822
3823 codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
3824 if (codec == NULL)
3825 return -ENOMEM;
0d0cf00a 3826
f1d45cc3 3827 codec->component.codec = codec;
ce0fc93a 3828
bb13109d
LPC		 3829 ret = snd_soc_component_initialize(&codec->component,
3830 &codec_drv->component_driver, dev);
3831 if (ret)
3832 goto err_free;
f0fba2ad 3833
f1d45cc3
LPC		 3834 if (codec_drv->probe)
3835 codec->component.probe = snd_soc_codec_drv_probe;
3836 if (codec_drv->remove)
3837 codec->component.remove = snd_soc_codec_drv_remove;
9178feb4
KM		 3838 if (codec_drv->suspend)
3839 codec->component.suspend = snd_soc_codec_drv_suspend;
3840 if (codec_drv->resume)
3841 codec->component.resume = snd_soc_codec_drv_resume;
e2c330b9
LPC		 3842 if (codec_drv->write)
3843 codec->component.write = snd_soc_codec_drv_write;
3844 if (codec_drv->read)
3845 codec->component.read = snd_soc_codec_drv_read;
71ccef0d
KM		 3846 if (codec_drv->set_sysclk)
3847 codec->component.set_sysclk = snd_soc_codec_set_sysclk_;
ef641e5d
KM		 3848 if (codec_drv->set_pll)
3849 codec->component.set_pll = snd_soc_codec_set_pll_;
44c07365
KM		 3850 if (codec_drv->set_jack)
3851 codec->component.set_jack = snd_soc_codec_set_jack_;
3d59400f 3852 codec->component.ignore_pmdown_time = codec_drv->ignore_pmdown_time;
4890140f
LPC		 3853
3854 dapm = snd_soc_codec_get_dapm(codec);
3855 dapm->idle_bias_off = codec_drv->idle_bias_off;
3856 dapm->suspend_bias_off = codec_drv->suspend_bias_off;
14e8bdeb 3857 if (codec_drv->seq_notifier)
4890140f 3858 dapm->seq_notifier = codec_drv->seq_notifier;
68f831c2 3859 if (codec_drv->set_bias_level)
4890140f 3860 dapm->set_bias_level = snd_soc_codec_set_bias_level;
7a30a3db
DP		 3861 codec->dev = dev;
3862 codec->driver = codec_drv;
e2c330b9 3863 codec->component.val_bytes = codec_drv->reg_word_size;
ce6120cc 3864
81c7cfd1
LPC		 3865#ifdef CONFIG_DEBUG_FS
3866 codec->component.init_debugfs = soc_init_codec_debugfs;
3867 codec->component.debugfs_prefix = "codec";
3868#endif
3869
886f5692
LPC		 3870 if (codec_drv->get_regmap)
3871 codec->component.regmap = codec_drv->get_regmap(dev);
a39f75f7 3872
f0fba2ad 3873 for (i = 0; i < num_dai; i++) {
273d778e
KM		 3874 convert_endianness_formats(&dai_drv[i].playback);
3875 convert_endianness_formats(&dai_drv[i].capture);
f0fba2ad
LG		 3876 }
3877
bb13109d 3878 ret = snd_soc_register_dais(&codec->component, dai_drv, num_dai, false);
5acd7dfb 3879 if (ret < 0) {
f42cf8d6 3880 dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
bb13109d 3881 goto err_cleanup;
26b01ccd 3882 }
f0fba2ad 3883
bb13109d
LPC		 3884 list_for_each_entry(dai, &codec->component.dai_list, list)
3885 dai->codec = codec;
f0fba2ad 3886
e1328a83 3887 mutex_lock(&client_mutex);
bb13109d 3888 snd_soc_component_add_unlocked(&codec->component);
054880fe 3889 list_add(&codec->list, &codec_list);
e1328a83
KM		 3890 mutex_unlock(&client_mutex);
3891
f4333203
LPC		 3892 dev_dbg(codec->dev, "ASoC: Registered codec '%s'\n",
3893 codec->component.name);
0d0cf00a 3894 return 0;
f0fba2ad 3895
bb13109d
LPC		 3896err_cleanup:
3897 snd_soc_component_cleanup(&codec->component);
3898err_free:
f0fba2ad
LG		 3899 kfree(codec);
3900 return ret;
0d0cf00a
MB		 3901}
3902EXPORT_SYMBOL_GPL(snd_soc_register_codec);
3903
3904/**
3905 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
3906 *
628536ea 3907 * @dev: codec to unregister
0d0cf00a 3908 */
f0fba2ad 3909void snd_soc_unregister_codec(struct device *dev)
0d0cf00a 3910{
f0fba2ad 3911 struct snd_soc_codec *codec;
f0fba2ad 3912
34e81ab4 3913 mutex_lock(&client_mutex);
f0fba2ad
LG		 3914 list_for_each_entry(codec, &codec_list, list) {
3915 if (dev == codec->dev)
3916 goto found;
3917 }
34e81ab4 3918 mutex_unlock(&client_mutex);
f0fba2ad
LG		 3919 return;
3920
3921found:
0d0cf00a 3922 list_del(&codec->list);
bb13109d 3923 snd_soc_component_del_unlocked(&codec->component);
0d0cf00a
MB		 3924 mutex_unlock(&client_mutex);
3925
f4333203
LPC		 3926 dev_dbg(codec->dev, "ASoC: Unregistered codec '%s'\n",
3927 codec->component.name);
f0fba2ad 3928
bb13109d 3929 snd_soc_component_cleanup(&codec->component);
7a30a3db 3930 snd_soc_cache_exit(codec);
f0fba2ad 3931 kfree(codec);
0d0cf00a
MB		 3932}
3933EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);
3934
bec4fa05 3935/* Retrieve a card's name from device tree */
b07609ce
KM		 3936int snd_soc_of_parse_card_name(struct snd_soc_card *card,
3937 const char *propname)
bec4fa05 3938{
b07609ce 3939 struct device_node *np;
bec4fa05
SW		 3940 int ret;
3941
7e07e7c0
TB		 3942 if (!card->dev) {
3943 pr_err("card->dev is not set before calling %s\n", __func__);
3944 return -EINVAL;
3945 }
3946
b07609ce 3947 np = card->dev->of_node;
7e07e7c0 3948
bec4fa05
SW		 3949 ret = of_property_read_string_index(np, propname, 0, &card->name);
3950 /*
3951 * EINVAL means the property does not exist. This is fine providing
3952 * card->name was previously set, which is checked later in
3953 * snd_soc_register_card.
3954 */
3955 if (ret < 0 && ret != -EINVAL) {
3956 dev_err(card->dev,
f110bfc7 3957 "ASoC: Property '%s' could not be read: %d\n",
bec4fa05
SW		 3958 propname, ret);
3959 return ret;
3960 }
3961
3962 return 0;
3963}
b07609ce 3964EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
bec4fa05 3965
9a6d4860
XL		 3966static const struct snd_soc_dapm_widget simple_widgets[] = {
3967 SND_SOC_DAPM_MIC("Microphone", NULL),
3968 SND_SOC_DAPM_LINE("Line", NULL),
3969 SND_SOC_DAPM_HP("Headphone", NULL),
3970 SND_SOC_DAPM_SPK("Speaker", NULL),
3971};
3972
21efde50 3973int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
9a6d4860
XL		 3974 const char *propname)
3975{
21efde50 3976 struct device_node *np = card->dev->of_node;
9a6d4860
XL		 3977 struct snd_soc_dapm_widget *widgets;
3978 const char *template, *wname;
3979 int i, j, num_widgets, ret;
3980
3981 num_widgets = of_property_count_strings(np, propname);
3982 if (num_widgets < 0) {
3983 dev_err(card->dev,
3984 "ASoC: Property '%s' does not exist\n", propname);
3985 return -EINVAL;
3986 }
3987 if (num_widgets & 1) {
3988 dev_err(card->dev,
3989 "ASoC: Property '%s' length is not even\n", propname);
3990 return -EINVAL;
3991 }
3992
3993 num_widgets /= 2;
3994 if (!num_widgets) {
3995 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
3996 propname);
3997 return -EINVAL;
3998 }
3999
4000 widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets),
4001 GFP_KERNEL);
4002 if (!widgets) {
4003 dev_err(card->dev,
4004 "ASoC: Could not allocate memory for widgets\n");
4005 return -ENOMEM;
4006 }
4007
4008 for (i = 0; i < num_widgets; i++) {
4009 ret = of_property_read_string_index(np, propname,
4010 2 * i, &template);
4011 if (ret) {
4012 dev_err(card->dev,
4013 "ASoC: Property '%s' index %d read error:%d\n",
4014 propname, 2 * i, ret);
4015 return -EINVAL;
4016 }
4017
4018 for (j = 0; j < ARRAY_SIZE(simple_widgets); j++) {
4019 if (!strncmp(template, simple_widgets[j].name,
4020 strlen(simple_widgets[j].name))) {
4021 widgets[i] = simple_widgets[j];
4022 break;
4023 }
4024 }
4025
4026 if (j >= ARRAY_SIZE(simple_widgets)) {
4027 dev_err(card->dev,
4028 "ASoC: DAPM widget '%s' is not supported\n",
4029 template);
4030 return -EINVAL;
4031 }
4032
4033 ret = of_property_read_string_index(np, propname,
4034 (2 * i) + 1,
4035 &wname);
4036 if (ret) {
4037 dev_err(card->dev,
4038 "ASoC: Property '%s' index %d read error:%d\n",
4039 propname, (2 * i) + 1, ret);
4040 return -EINVAL;
4041 }
4042
4043 widgets[i].name = wname;
4044 }
4045
f23e860e
NC		 4046 card->of_dapm_widgets = widgets;
4047 card->num_of_dapm_widgets = num_widgets;
9a6d4860
XL		 4048
4049 return 0;
4050}
21efde50 4051EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets);
9a6d4860 4052
6131084a
JS		 4053static int snd_soc_of_get_slot_mask(struct device_node *np,
4054 const char *prop_name,
4055 unsigned int *mask)
4056{
4057 u32 val;
6c84e591 4058 const __be32 *of_slot_mask = of_get_property(np, prop_name, &val);
6131084a
JS		 4059 int i;
4060
4061 if (!of_slot_mask)
4062 return 0;
4063 val /= sizeof(u32);
4064 for (i = 0; i < val; i++)
4065 if (be32_to_cpup(&of_slot_mask[i]))
4066 *mask |= (1 << i);
4067
4068 return val;
4069}
4070
89c67857 4071int snd_soc_of_parse_tdm_slot(struct device_node *np,
6131084a
JS		 4072 unsigned int *tx_mask,
4073 unsigned int *rx_mask,
89c67857
XL		 4074 unsigned int *slots,
4075 unsigned int *slot_width)
4076{
4077 u32 val;
4078 int ret;
4079
6131084a
JS		 4080 if (tx_mask)
4081 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask", tx_mask);
4082 if (rx_mask)
4083 snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask", rx_mask);
4084
89c67857
XL		 4085 if (of_property_read_bool(np, "dai-tdm-slot-num")) {
4086 ret = of_property_read_u32(np, "dai-tdm-slot-num", &val);
4087 if (ret)
4088 return ret;
4089
4090 if (slots)
4091 *slots = val;
4092 }
4093
4094 if (of_property_read_bool(np, "dai-tdm-slot-width")) {
4095 ret = of_property_read_u32(np, "dai-tdm-slot-width", &val);
4096 if (ret)
4097 return ret;
4098
4099 if (slot_width)
4100 *slot_width = val;
4101 }
4102
4103 return 0;
4104}
4105EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot);
4106
440a3006 4107void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
5e3cdaa2
KM		 4108 struct snd_soc_codec_conf *codec_conf,
4109 struct device_node *of_node,
4110 const char *propname)
4111{
440a3006 4112 struct device_node *np = card->dev->of_node;
5e3cdaa2
KM		 4113 const char *str;
4114 int ret;
4115
4116 ret = of_property_read_string(np, propname, &str);
4117 if (ret < 0) {
4118 /* no prefix is not error */
4119 return;
4120 }
4121
4122 codec_conf->of_node = of_node;
4123 codec_conf->name_prefix = str;
4124}
440a3006 4125EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_prefix);
5e3cdaa2 4126
2bc644af 4127int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
a4a54dd5
SW		 4128 const char *propname)
4129{
2bc644af 4130 struct device_node *np = card->dev->of_node;
e3b1e6a1 4131 int num_routes;
a4a54dd5
SW		 4132 struct snd_soc_dapm_route *routes;
4133 int i, ret;
4134
4135 num_routes = of_property_count_strings(np, propname);
c34ce320 4136 if (num_routes < 0 || num_routes & 1) {
10e8aa9a
MM		 4137 dev_err(card->dev,
4138 "ASoC: Property '%s' does not exist or its length is not even\n",
4139 propname);
a4a54dd5
SW		 4140 return -EINVAL;
4141 }
4142 num_routes /= 2;
4143 if (!num_routes) {
f110bfc7 4144 dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
a4a54dd5
SW		 4145 propname);
4146 return -EINVAL;
4147 }
4148
e3b1e6a1 4149 routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),
a4a54dd5
SW		 4150 GFP_KERNEL);
4151 if (!routes) {
4152 dev_err(card->dev,
f110bfc7 4153 "ASoC: Could not allocate DAPM route table\n");
a4a54dd5
SW		 4154 return -EINVAL;
4155 }
4156
4157 for (i = 0; i < num_routes; i++) {
4158 ret = of_property_read_string_index(np, propname,
e3b1e6a1 4159 2 * i, &routes[i].sink);
a4a54dd5 4160 if (ret) {
c871bd0b
MB		 4161 dev_err(card->dev,
4162 "ASoC: Property '%s' index %d could not be read: %d\n",
4163 propname, 2 * i, ret);
a4a54dd5
SW		 4164 return -EINVAL;
4165 }
4166 ret = of_property_read_string_index(np, propname,
e3b1e6a1 4167 (2 * i) + 1, &routes[i].source);
a4a54dd5
SW		 4168 if (ret) {
4169 dev_err(card->dev,
c871bd0b
MB		 4170 "ASoC: Property '%s' index %d could not be read: %d\n",
4171 propname, (2 * i) + 1, ret);
a4a54dd5
SW		 4172 return -EINVAL;
4173 }
4174 }
4175
f23e860e
NC		 4176 card->num_of_dapm_routes = num_routes;
4177 card->of_dapm_routes = routes;
a4a54dd5
SW		 4178
4179 return 0;
4180}
2bc644af 4181EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
a4a54dd5 4182
a7930ed4 4183unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
389cb834
JS		 4184 const char *prefix,
4185 struct device_node **bitclkmaster,
4186 struct device_node **framemaster)
a7930ed4
KM		 4187{
4188 int ret, i;
4189 char prop[128];
4190 unsigned int format = 0;
4191 int bit, frame;
4192 const char *str;
4193 struct {
4194 char *name;
4195 unsigned int val;
4196 } of_fmt_table[] = {
4197 { "i2s", SND_SOC_DAIFMT_I2S },
4198 { "right_j", SND_SOC_DAIFMT_RIGHT_J },
4199 { "left_j", SND_SOC_DAIFMT_LEFT_J },
4200 { "dsp_a", SND_SOC_DAIFMT_DSP_A },
4201 { "dsp_b", SND_SOC_DAIFMT_DSP_B },
4202 { "ac97", SND_SOC_DAIFMT_AC97 },
4203 { "pdm", SND_SOC_DAIFMT_PDM},
4204 { "msb", SND_SOC_DAIFMT_MSB },
4205 { "lsb", SND_SOC_DAIFMT_LSB },
a7930ed4
KM		 4206 };
4207
4208 if (!prefix)
4209 prefix = "";
4210
4211 /*
5711c979
KM		 4212 * check "dai-format = xxx"
4213 * or "[prefix]format = xxx"
a7930ed4
KM		 4214 * SND_SOC_DAIFMT_FORMAT_MASK area
4215 */
5711c979
KM		 4216 ret = of_property_read_string(np, "dai-format", &str);
4217 if (ret < 0) {
4218 snprintf(prop, sizeof(prop), "%sformat", prefix);
4219 ret = of_property_read_string(np, prop, &str);
4220 }
a7930ed4
KM		 4221 if (ret == 0) {
4222 for (i = 0; i < ARRAY_SIZE(of_fmt_table); i++) {
4223 if (strcmp(str, of_fmt_table[i].name) == 0) {
4224 format |= of_fmt_table[i].val;
4225 break;
4226 }
4227 }
4228 }
4229
4230 /*
8c2d6a9f 4231 * check "[prefix]continuous-clock"
a7930ed4
KM		 4232 * SND_SOC_DAIFMT_CLOCK_MASK area
4233 */
8c2d6a9f 4234 snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix);
51930295 4235 if (of_property_read_bool(np, prop))
8c2d6a9f
KM		 4236 format |= SND_SOC_DAIFMT_CONT;
4237 else
4238 format |= SND_SOC_DAIFMT_GATED;
a7930ed4
KM		 4239
4240 /*
4241 * check "[prefix]bitclock-inversion"
4242 * check "[prefix]frame-inversion"
4243 * SND_SOC_DAIFMT_INV_MASK area
4244 */
4245 snprintf(prop, sizeof(prop), "%sbitclock-inversion", prefix);
4246 bit = !!of_get_property(np, prop, NULL);
4247
4248 snprintf(prop, sizeof(prop), "%sframe-inversion", prefix);
4249 frame = !!of_get_property(np, prop, NULL);
4250
4251 switch ((bit << 4) + frame) {
4252 case 0x11:
4253 format |= SND_SOC_DAIFMT_IB_IF;
4254 break;
4255 case 0x10:
4256 format |= SND_SOC_DAIFMT_IB_NF;
4257 break;
4258 case 0x01:
4259 format |= SND_SOC_DAIFMT_NB_IF;
4260 break;
4261 default:
4262 /* SND_SOC_DAIFMT_NB_NF is default */
4263 break;
4264 }
4265
4266 /*
4267 * check "[prefix]bitclock-master"
4268 * check "[prefix]frame-master"
4269 * SND_SOC_DAIFMT_MASTER_MASK area
4270 */
4271 snprintf(prop, sizeof(prop), "%sbitclock-master", prefix);
4272 bit = !!of_get_property(np, prop, NULL);
389cb834
JS		 4273 if (bit && bitclkmaster)
4274 *bitclkmaster = of_parse_phandle(np, prop, 0);
a7930ed4
KM		 4275
4276 snprintf(prop, sizeof(prop), "%sframe-master", prefix);
4277 frame = !!of_get_property(np, prop, NULL);
389cb834
JS		 4278 if (frame && framemaster)
4279 *framemaster = of_parse_phandle(np, prop, 0);
a7930ed4
KM		 4280
4281 switch ((bit << 4) + frame) {
4282 case 0x11:
4283 format |= SND_SOC_DAIFMT_CBM_CFM;
4284 break;
4285 case 0x10:
4286 format |= SND_SOC_DAIFMT_CBM_CFS;
4287 break;
4288 case 0x01:
4289 format |= SND_SOC_DAIFMT_CBS_CFM;
4290 break;
4291 default:
4292 format |= SND_SOC_DAIFMT_CBS_CFS;
4293 break;
4294 }
4295
4296 return format;
4297}
4298EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt);
4299
a180e8b9
KM		 4300int snd_soc_get_dai_id(struct device_node *ep)
4301{
4302 struct snd_soc_component *pos;
4303 struct device_node *node;
4304 int ret;
4305
4306 node = of_graph_get_port_parent(ep);
4307
4308 /*
4309 * For example HDMI case, HDMI has video/sound port,
4310 * but ALSA SoC needs sound port number only.
4311 * Thus counting HDMI DT port/endpoint doesn't work.
4312 * Then, it should have .of_xlate_dai_id
4313 */
4314 ret = -ENOTSUPP;
4315 mutex_lock(&client_mutex);
4316 list_for_each_entry(pos, &component_list, list) {
4317 struct device_node *component_of_node = pos->dev->of_node;
4318
4319 if (!component_of_node && pos->dev->parent)
4320 component_of_node = pos->dev->parent->of_node;
4321
4322 if (component_of_node != node)
4323 continue;
4324
4325 if (pos->driver->of_xlate_dai_id)
4326 ret = pos->driver->of_xlate_dai_id(pos, ep);
4327
4328 break;
4329 }
4330 mutex_unlock(&client_mutex);
4331
c0a480d1
TL		 4332 of_node_put(node);
4333
a180e8b9
KM		 4334 return ret;
4335}
4336EXPORT_SYMBOL_GPL(snd_soc_get_dai_id);
4337
1ad8ec53 4338int snd_soc_get_dai_name(struct of_phandle_args *args,
93b0f3ee 4339 const char **dai_name)
cb470087
KM		 4340{
4341 struct snd_soc_component *pos;
3e0aa8d8 4342 struct device_node *component_of_node;
93b0f3ee 4343 int ret = -EPROBE_DEFER;
cb470087
KM		 4344
4345 mutex_lock(&client_mutex);
4346 list_for_each_entry(pos, &component_list, list) {
3e0aa8d8
JS		 4347 component_of_node = pos->dev->of_node;
4348 if (!component_of_node && pos->dev->parent)
4349 component_of_node = pos->dev->parent->of_node;
4350
4351 if (component_of_node != args->np)
cb470087
KM		 4352 continue;
4353
6833c452 4354 if (pos->driver->of_xlate_dai_name) {
93b0f3ee
JFM		 4355 ret = pos->driver->of_xlate_dai_name(pos,
4356 args,
4357 dai_name);
6833c452
KM		 4358 } else {
4359 int id = -1;
4360
93b0f3ee 4361 switch (args->args_count) {
6833c452
KM		 4362 case 0:
4363 id = 0; /* same as dai_drv[0] */
4364 break;
4365 case 1:
93b0f3ee 4366 id = args->args[0];
6833c452
KM		 4367 break;
4368 default:
4369 /* not supported */
4370 break;
4371 }
4372
4373 if (id < 0 || id >= pos->num_dai) {
4374 ret = -EINVAL;
3dcba280 4375 continue;
6833c452 4376 }
e41975ed
XL		 4377
4378 ret = 0;
4379
4380 *dai_name = pos->dai_drv[id].name;
4381 if (!*dai_name)
4382 *dai_name = pos->name;
cb470087
KM		 4383 }
4384
cb470087
KM		 4385 break;
4386 }
4387 mutex_unlock(&client_mutex);
93b0f3ee
JFM		 4388 return ret;
4389}
1ad8ec53 4390EXPORT_SYMBOL_GPL(snd_soc_get_dai_name);
93b0f3ee
JFM		 4391
4392int snd_soc_of_get_dai_name(struct device_node *of_node,
4393 const char **dai_name)
4394{
4395 struct of_phandle_args args;
4396 int ret;
4397
4398 ret = of_parse_phandle_with_args(of_node, "sound-dai",
4399 "#sound-dai-cells", 0, &args);
4400 if (ret)
4401 return ret;
4402
4403 ret = snd_soc_get_dai_name(&args, dai_name);
cb470087
KM		 4404
4405 of_node_put(args.np);
4406
4407 return ret;
4408}
4409EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name);
4410
93b0f3ee
JFM		 4411/*
4412 * snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree
4413 * @dev: Card device
4414 * @of_node: Device node
4415 * @dai_link: DAI link
4416 *
4417 * Builds an array of CODEC DAI components from the DAI link property
4418 * 'sound-dai'.
4419 * The array is set in the DAI link and the number of DAIs is set accordingly.
4420 * The device nodes in the array (of_node) must be dereferenced by the caller.
4421 *
4422 * Returns 0 for success
4423 */
4424int snd_soc_of_get_dai_link_codecs(struct device *dev,
4425 struct device_node *of_node,
4426 struct snd_soc_dai_link *dai_link)
4427{
4428 struct of_phandle_args args;
4429 struct snd_soc_dai_link_component *component;
4430 char *name;
4431 int index, num_codecs, ret;
4432
4433 /* Count the number of CODECs */
4434 name = "sound-dai";
4435 num_codecs = of_count_phandle_with_args(of_node, name,
4436 "#sound-dai-cells");
4437 if (num_codecs <= 0) {
4438 if (num_codecs == -ENOENT)
4439 dev_err(dev, "No 'sound-dai' property\n");
4440 else
4441 dev_err(dev, "Bad phandle in 'sound-dai'\n");
4442 return num_codecs;
4443 }
4444 component = devm_kzalloc(dev,
4445 sizeof *component * num_codecs,
4446 GFP_KERNEL);
4447 if (!component)
4448 return -ENOMEM;
4449 dai_link->codecs = component;
4450 dai_link->num_codecs = num_codecs;
4451
4452 /* Parse the list */
4453 for (index = 0, component = dai_link->codecs;
4454 index < dai_link->num_codecs;
4455 index++, component++) {
4456 ret = of_parse_phandle_with_args(of_node, name,
4457 "#sound-dai-cells",
4458 index, &args);
4459 if (ret)
4460 goto err;
4461 component->of_node = args.np;
4462 ret = snd_soc_get_dai_name(&args, &component->dai_name);
4463 if (ret < 0)
4464 goto err;
4465 }
4466 return 0;
4467err:
4468 for (index = 0, component = dai_link->codecs;
4469 index < dai_link->num_codecs;
4470 index++, component++) {
4471 if (!component->of_node)
4472 break;
4473 of_node_put(component->of_node);
4474 component->of_node = NULL;
4475 }
4476 dai_link->codecs = NULL;
4477 dai_link->num_codecs = 0;
4478 return ret;
4479}
4480EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);
4481
c9b3a40f 4482static int __init snd_soc_init(void)
db2a4165 4483{
6553bf06 4484 snd_soc_debugfs_init();
fb257897
MB		 4485 snd_soc_util_init();
4486
db2a4165
FM		 4487 return platform_driver_register(&soc_driver);
4488}
4abe8e16 4489module_init(snd_soc_init);
db2a4165 4490
7d8c16a6 4491static void __exit snd_soc_exit(void)
db2a4165 4492{
fb257897 4493 snd_soc_util_exit();
6553bf06 4494 snd_soc_debugfs_exit();
fb257897 4495
3ff3f64b 4496 platform_driver_unregister(&soc_driver);
db2a4165 4497}
db2a4165
FM		 4498module_exit(snd_soc_exit);
4499
4500/* Module information */
d331124d 4501MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
db2a4165
FM		 4502MODULE_DESCRIPTION("ALSA SoC Core");
4503MODULE_LICENSE("GPL");
8b45a209 4504MODULE_ALIAS("platform:soc-audio");
Linux 6.x block layer and io_uring tree(s)