soc-core.c 99.1 KB
Newer Older
F
Frank Mandarino 已提交
1 2 3 4
/*
 * soc-core.c  --  ALSA SoC Audio Layer
 *
 * Copyright 2005 Wolfson Microelectronics PLC.
5
 * Copyright 2005 Openedhand Ltd.
6 7
 * Copyright (C) 2010 Slimlogic Ltd.
 * Copyright (C) 2010 Texas Instruments Inc.
8
 *
9
 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
10 11
 *         with code, comments and ideas from :-
 *         Richard Purdie <richard@openedhand.com>
F
Frank Mandarino 已提交
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 *
 *  TODO:
 *   o Add hw rules to enforce rates, etc.
 *   o More testing with other codecs/machines.
 *   o Add more codecs and platforms to ensure good API coverage.
 *   o Support TDM on PCM and I2S
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/pm.h>
#include <linux/bitops.h>
31
#include <linux/debugfs.h>
F
Frank Mandarino 已提交
32
#include <linux/platform_device.h>
33
#include <linux/pinctrl/consumer.h>
34
#include <linux/ctype.h>
35
#include <linux/slab.h>
36
#include <linux/of.h>
F
Frank Mandarino 已提交
37
#include <sound/core.h>
38
#include <sound/jack.h>
F
Frank Mandarino 已提交
39 40 41
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
42
#include <sound/soc-dpcm.h>
43
#include <sound/soc-topology.h>
F
Frank Mandarino 已提交
44 45
#include <sound/initval.h>

46 47 48
#define CREATE_TRACE_POINTS
#include <trace/events/asoc.h>

49 50
#define NAME_SIZE	32

51
#ifdef CONFIG_DEBUG_FS
52 53
struct dentry *snd_soc_debugfs_root;
EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
54 55
#endif

M
Mark Brown 已提交
56
static DEFINE_MUTEX(client_mutex);
M
Mark Brown 已提交
57
static LIST_HEAD(platform_list);
M
Mark Brown 已提交
58
static LIST_HEAD(codec_list);
59
static LIST_HEAD(component_list);
M
Mark Brown 已提交
60

F
Frank Mandarino 已提交
61 62 63 64 65 66 67 68 69
/*
 * This is a timeout to do a DAPM powerdown after a stream is closed().
 * It can be used to eliminate pops between different playback streams, e.g.
 * between two audio tracks.
 */
static int pmdown_time = 5000;
module_param(pmdown_time, int, 0);
MODULE_PARM_DESC(pmdown_time, "DAPM stream powerdown time (msecs)");

70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87
/* returns the minimum number of bytes needed to represent
 * a particular given value */
static int min_bytes_needed(unsigned long val)
{
	int c = 0;
	int i;

	for (i = (sizeof val * 8) - 1; i >= 0; --i, ++c)
		if (val & (1UL << i))
			break;
	c = (sizeof val * 8) - c;
	if (!c || (c % 8))
		c = (c + 8) / 8;
	else
		c /= 8;
	return c;
}

88 89 90 91 92
/* fill buf which is 'len' bytes with a formatted
 * string of the form 'reg: value\n' */
static int format_register_str(struct snd_soc_codec *codec,
			       unsigned int reg, char *buf, size_t len)
{
93 94
	int wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
	int regsize = codec->driver->reg_word_size * 2;
95 96 97 98 99 100
	int ret;

	/* +2 for ': ' and + 1 for '\n' */
	if (wordsize + regsize + 2 + 1 != len)
		return -EINVAL;

101 102
	sprintf(buf, "%.*x: ", wordsize, reg);
	buf += wordsize + 2;
103

104 105 106 107 108 109 110
	ret = snd_soc_read(codec, reg);
	if (ret < 0)
		memset(buf, 'X', regsize);
	else
		sprintf(buf, "%.*x", regsize, ret);
	buf[regsize] = '\n';
	/* no NUL-termination needed */
111 112 113
	return 0;
}

114
/* codec register dump */
115 116
static ssize_t soc_codec_reg_show(struct snd_soc_codec *codec, char *buf,
				  size_t count, loff_t pos)
117
{
118
	int i, step = 1;
119
	int wordsize, regsize;
120 121 122
	int len;
	size_t total = 0;
	loff_t p = 0;
123

124 125
	wordsize = min_bytes_needed(codec->driver->reg_cache_size) * 2;
	regsize = codec->driver->reg_word_size * 2;
126

127 128
	len = wordsize + regsize + 2 + 1;

129
	if (!codec->driver->reg_cache_size)
130 131
		return 0;

132 133
	if (codec->driver->reg_cache_step)
		step = codec->driver->reg_cache_step;
134

135
	for (i = 0; i < codec->driver->reg_cache_size; i += step) {
136 137 138 139 140 141 142
		/* only support larger than PAGE_SIZE bytes debugfs
		 * entries for the default case */
		if (p >= pos) {
			if (total + len >= count - 1)
				break;
			format_register_str(codec, i, buf + total, len);
			total += len;
143
		}
144
		p += len;
145 146
	}

147
	total = min(total, count - 1);
148

149
	return total;
150
}
151

152 153 154
static ssize_t codec_reg_show(struct device *dev,
	struct device_attribute *attr, char *buf)
{
155
	struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
156

157
	return soc_codec_reg_show(rtd->codec, buf, PAGE_SIZE, 0);
158 159 160 161
}

static DEVICE_ATTR(codec_reg, 0444, codec_reg_show, NULL);

162 163 164
static ssize_t pmdown_time_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
165
	struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
166

167
	return sprintf(buf, "%ld\n", rtd->pmdown_time);
168 169 170 171 172 173
}

static ssize_t pmdown_time_set(struct device *dev,
			       struct device_attribute *attr,
			       const char *buf, size_t count)
{
174
	struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
175
	int ret;
176

177
	ret = kstrtol(buf, 10, &rtd->pmdown_time);
178 179
	if (ret)
		return ret;
180 181 182 183 184 185

	return count;
}

static DEVICE_ATTR(pmdown_time, 0644, pmdown_time_show, pmdown_time_set);

186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
static struct attribute *soc_dev_attrs[] = {
	&dev_attr_codec_reg.attr,
	&dev_attr_pmdown_time.attr,
	NULL
};

static umode_t soc_dev_attr_is_visible(struct kobject *kobj,
				       struct attribute *attr, int idx)
{
	struct device *dev = kobj_to_dev(kobj);
	struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);

	if (attr == &dev_attr_pmdown_time.attr)
		return attr->mode; /* always visible */
	return rtd->codec ? attr->mode : 0; /* enabled only with codec */
}

static const struct attribute_group soc_dapm_dev_group = {
	.attrs = soc_dapm_dev_attrs,
	.is_visible = soc_dev_attr_is_visible,
};

static const struct attribute_group soc_dev_roup = {
	.attrs = soc_dev_attrs,
	.is_visible = soc_dev_attr_is_visible,
};

static const struct attribute_group *soc_dev_attr_groups[] = {
	&soc_dapm_dev_group,
	&soc_dev_roup,
	NULL
};

219 220
#ifdef CONFIG_DEBUG_FS
static ssize_t codec_reg_read_file(struct file *file, char __user *user_buf,
221
				   size_t count, loff_t *ppos)
222 223 224
{
	ssize_t ret;
	struct snd_soc_codec *codec = file->private_data;
225 226 227 228 229 230
	char *buf;

	if (*ppos < 0 || !count)
		return -EINVAL;

	buf = kmalloc(count, GFP_KERNEL);
231 232
	if (!buf)
		return -ENOMEM;
233 234 235 236 237 238 239 240 241 242

	ret = soc_codec_reg_show(codec, buf, count, *ppos);
	if (ret >= 0) {
		if (copy_to_user(user_buf, buf, ret)) {
			kfree(buf);
			return -EFAULT;
		}
		*ppos += ret;
	}

243 244 245 246 247 248 249 250
	kfree(buf);
	return ret;
}

static ssize_t codec_reg_write_file(struct file *file,
		const char __user *user_buf, size_t count, loff_t *ppos)
{
	char buf[32];
251
	size_t buf_size;
252 253 254
	char *start = buf;
	unsigned long reg, value;
	struct snd_soc_codec *codec = file->private_data;
255
	int ret;
256 257 258 259 260 261 262 263 264 265 266

	buf_size = min(count, (sizeof(buf)-1));
	if (copy_from_user(buf, user_buf, buf_size))
		return -EFAULT;
	buf[buf_size] = 0;

	while (*start == ' ')
		start++;
	reg = simple_strtoul(start, &start, 16);
	while (*start == ' ')
		start++;
267 268 269
	ret = kstrtoul(start, 16, &value);
	if (ret)
		return ret;
270 271

	/* Userspace has been fiddling around behind the kernel's back */
272
	add_taint(TAINT_USER, LOCKDEP_NOW_UNRELIABLE);
273

274
	snd_soc_write(codec, reg, value);
275 276 277 278
	return buf_size;
}

static const struct file_operations codec_reg_fops = {
279
	.open = simple_open,
280 281
	.read = codec_reg_read_file,
	.write = codec_reg_write_file,
282
	.llseek = default_llseek,
283 284
};

285
static void soc_init_component_debugfs(struct snd_soc_component *component)
286
{
287 288 289
	if (!component->card->debugfs_card_root)
		return;

290 291
	if (component->debugfs_prefix) {
		char *name;
292

293 294 295 296 297 298 299 300 301 302 303
		name = kasprintf(GFP_KERNEL, "%s:%s",
			component->debugfs_prefix, component->name);
		if (name) {
			component->debugfs_root = debugfs_create_dir(name,
				component->card->debugfs_card_root);
			kfree(name);
		}
	} else {
		component->debugfs_root = debugfs_create_dir(component->name,
				component->card->debugfs_card_root);
	}
304

305 306 307 308 309
	if (!component->debugfs_root) {
		dev_warn(component->dev,
			"ASoC: Failed to create component debugfs directory\n");
		return;
	}
310

311 312
	snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component),
		component->debugfs_root);
313

314 315
	if (component->init_debugfs)
		component->init_debugfs(component);
316 317
}

318
static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
319
{
320 321
	debugfs_remove_recursive(component->debugfs_root);
}
322

323 324 325
static void soc_init_codec_debugfs(struct snd_soc_component *component)
{
	struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
326 327

	codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
328
						 codec->component.debugfs_root,
329 330
						 codec, &codec_reg_fops);
	if (!codec->debugfs_reg)
331 332
		dev_warn(codec->dev,
			"ASoC: Failed to create codec register debugfs file\n");
333 334
}

335 336 337 338
static ssize_t codec_list_read_file(struct file *file, char __user *user_buf,
				    size_t count, loff_t *ppos)
{
	char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
339
	ssize_t len, ret = 0;
340 341 342 343 344
	struct snd_soc_codec *codec;

	if (!buf)
		return -ENOMEM;

345 346
	mutex_lock(&client_mutex);

347 348
	list_for_each_entry(codec, &codec_list, list) {
		len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
349
			       codec->component.name);
350 351 352 353 354 355 356
		if (len >= 0)
			ret += len;
		if (ret > PAGE_SIZE) {
			ret = PAGE_SIZE;
			break;
		}
	}
357

358 359
	mutex_unlock(&client_mutex);

360 361 362 363 364 365 366 367 368 369 370 371 372
	if (ret >= 0)
		ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);

	kfree(buf);

	return ret;
}

static const struct file_operations codec_list_fops = {
	.read = codec_list_read_file,
	.llseek = default_llseek,/* read accesses f_pos */
};

M
Mark Brown 已提交
373 374 375 376
static ssize_t dai_list_read_file(struct file *file, char __user *user_buf,
				  size_t count, loff_t *ppos)
{
	char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
377
	ssize_t len, ret = 0;
378
	struct snd_soc_component *component;
M
Mark Brown 已提交
379 380 381 382 383
	struct snd_soc_dai *dai;

	if (!buf)
		return -ENOMEM;

384 385
	mutex_lock(&client_mutex);

386 387 388 389 390 391 392 393 394 395
	list_for_each_entry(component, &component_list, list) {
		list_for_each_entry(dai, &component->dai_list, list) {
			len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
				dai->name);
			if (len >= 0)
				ret += len;
			if (ret > PAGE_SIZE) {
				ret = PAGE_SIZE;
				break;
			}
396 397
		}
	}
M
Mark Brown 已提交
398

399 400
	mutex_unlock(&client_mutex);

401
	ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
M
Mark Brown 已提交
402 403 404 405 406 407 408 409 410 411 412

	kfree(buf);

	return ret;
}

static const struct file_operations dai_list_fops = {
	.read = dai_list_read_file,
	.llseek = default_llseek,/* read accesses f_pos */
};

413 414 415 416 417
static ssize_t platform_list_read_file(struct file *file,
				       char __user *user_buf,
				       size_t count, loff_t *ppos)
{
	char *buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
418
	ssize_t len, ret = 0;
419 420 421 422 423
	struct snd_soc_platform *platform;

	if (!buf)
		return -ENOMEM;

424 425
	mutex_lock(&client_mutex);

426 427
	list_for_each_entry(platform, &platform_list, list) {
		len = snprintf(buf + ret, PAGE_SIZE - ret, "%s\n",
428
			       platform->component.name);
429 430 431 432 433 434 435
		if (len >= 0)
			ret += len;
		if (ret > PAGE_SIZE) {
			ret = PAGE_SIZE;
			break;
		}
	}
436

437 438
	mutex_unlock(&client_mutex);

439
	ret = simple_read_from_buffer(user_buf, count, ppos, buf, ret);
440 441 442 443 444 445 446 447 448 449 450

	kfree(buf);

	return ret;
}

static const struct file_operations platform_list_fops = {
	.read = platform_list_read_file,
	.llseek = default_llseek,/* read accesses f_pos */
};

451 452
static void soc_init_card_debugfs(struct snd_soc_card *card)
{
453 454 455
	if (!snd_soc_debugfs_root)
		return;

456
	card->debugfs_card_root = debugfs_create_dir(card->name,
457
						     snd_soc_debugfs_root);
458
	if (!card->debugfs_card_root) {
459
		dev_warn(card->dev,
460
			 "ASoC: Failed to create card debugfs directory\n");
461 462 463 464 465 466 467 468
		return;
	}

	card->debugfs_pop_time = debugfs_create_u32("dapm_pop_time", 0644,
						    card->debugfs_card_root,
						    &card->pop_time);
	if (!card->debugfs_pop_time)
		dev_warn(card->dev,
469
		       "ASoC: Failed to create pop time debugfs file\n");
470 471 472 473 474 475 476
}

static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
{
	debugfs_remove_recursive(card->debugfs_card_root);
}

477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504

static void snd_soc_debugfs_init(void)
{
	snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
	if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
		pr_warn("ASoC: Failed to create debugfs directory\n");
		snd_soc_debugfs_root = NULL;
		return;
	}

	if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
				 &codec_list_fops))
		pr_warn("ASoC: Failed to create CODEC list debugfs file\n");

	if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
				 &dai_list_fops))
		pr_warn("ASoC: Failed to create DAI list debugfs file\n");

	if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
				 &platform_list_fops))
		pr_warn("ASoC: Failed to create platform list debugfs file\n");
}

static void snd_soc_debugfs_exit(void)
{
	debugfs_remove_recursive(snd_soc_debugfs_root);
}

505 506
#else

507
#define soc_init_codec_debugfs NULL
508

509 510
static inline void soc_init_component_debugfs(
	struct snd_soc_component *component)
511 512 513
{
}

514 515
static inline void soc_cleanup_component_debugfs(
	struct snd_soc_component *component)
516 517 518
{
}

519 520 521 522 523 524 525
static inline void soc_init_card_debugfs(struct snd_soc_card *card)
{
}

static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
{
}
526 527 528 529 530 531 532 533 534

static inline void snd_soc_debugfs_init(void)
{
}

static inline void snd_soc_debugfs_exit(void)
{
}

535 536
#endif

537 538 539
struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
		const char *dai_link, int stream)
{
540
	struct snd_soc_pcm_runtime *rtd;
541

542 543 544 545
	list_for_each_entry(rtd, &card->rtd_list, list) {
		if (rtd->dai_link->no_pcm &&
			!strcmp(rtd->dai_link->name, dai_link))
			return rtd->pcm->streams[stream].substream;
546
	}
547
	dev_dbg(card->dev, "ASoC: failed to find dai link %s\n", dai_link);
548 549 550 551
	return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);

552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
	struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)
{
	struct snd_soc_pcm_runtime *rtd;

	rtd = kzalloc(sizeof(struct snd_soc_pcm_runtime), GFP_KERNEL);
	if (!rtd)
		return NULL;

	rtd->card = card;
	rtd->dai_link = dai_link;
	rtd->codec_dais = kzalloc(sizeof(struct snd_soc_dai *) *
					dai_link->num_codecs,
					GFP_KERNEL);
	if (!rtd->codec_dais) {
		kfree(rtd);
		return NULL;
	}

	return rtd;
}

static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
{
	if (rtd && rtd->codec_dais)
		kfree(rtd->codec_dais);
	kfree(rtd);
}

static void soc_add_pcm_runtime(struct snd_soc_card *card,
		struct snd_soc_pcm_runtime *rtd)
{
	list_add_tail(&rtd->list, &card->rtd_list);
	rtd->num = card->num_rtd;
	card->num_rtd++;
}

static void soc_remove_pcm_runtimes(struct snd_soc_card *card)
{
	struct snd_soc_pcm_runtime *rtd, *_rtd;

	list_for_each_entry_safe(rtd, _rtd, &card->rtd_list, list) {
		list_del(&rtd->list);
		soc_free_pcm_runtime(rtd);
	}

	card->num_rtd = 0;
}

601 602 603
struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
		const char *dai_link)
{
604
	struct snd_soc_pcm_runtime *rtd;
605

606 607 608
	list_for_each_entry(rtd, &card->rtd_list, list) {
		if (!strcmp(rtd->dai_link->name, dai_link))
			return rtd;
609
	}
610
	dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link);
611 612 613 614
	return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);

615 616 617 618 619 620 621 622 623
static void codec2codec_close_delayed_work(struct work_struct *work)
{
	/* Currently nothing to do for c2c links
	 * Since c2c links are internal nodes in the DAPM graph and
	 * don't interface with the outside world or application layer
	 * we don't have to do any special handling on close.
	 */
}

624
#ifdef CONFIG_PM_SLEEP
F
Frank Mandarino 已提交
625
/* powers down audio subsystem for suspend */
626
int snd_soc_suspend(struct device *dev)
F
Frank Mandarino 已提交
627
{
628
	struct snd_soc_card *card = dev_get_drvdata(dev);
629
	struct snd_soc_codec *codec;
630 631
	struct snd_soc_pcm_runtime *rtd;
	int i;
F
Frank Mandarino 已提交
632

633 634
	/* If the card is not initialized yet there is nothing to do */
	if (!card->instantiated)
635 636
		return 0;

637 638 639
	/* Due to the resume being scheduled into a workqueue we could
	* suspend before that's finished - wait for it to complete.
	 */
640 641 642
	snd_power_lock(card->snd_card);
	snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
	snd_power_unlock(card->snd_card);
643 644

	/* we're going to block userspace touching us until resume completes */
645
	snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D3hot);
646

M
Mark Brown 已提交
647
	/* mute any active DACs */
648
	list_for_each_entry(rtd, &card->rtd_list, list) {
649

650
		if (rtd->dai_link->ignore_suspend)
651 652
			continue;

653 654
		for (i = 0; i < rtd->num_codecs; i++) {
			struct snd_soc_dai *dai = rtd->codec_dais[i];
655 656 657 658 659
			struct snd_soc_dai_driver *drv = dai->driver;

			if (drv->ops->digital_mute && dai->playback_active)
				drv->ops->digital_mute(dai, 1);
		}
F
Frank Mandarino 已提交
660 661
	}

662
	/* suspend all pcms */
663 664
	list_for_each_entry(rtd, &card->rtd_list, list) {
		if (rtd->dai_link->ignore_suspend)
665 666
			continue;

667
		snd_pcm_suspend_all(rtd->pcm);
668
	}
669

670
	if (card->suspend_pre)
671
		card->suspend_pre(card);
F
Frank Mandarino 已提交
672

673 674
	list_for_each_entry(rtd, &card->rtd_list, list) {
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
675

676
		if (rtd->dai_link->ignore_suspend)
677 678
			continue;

679
		if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)
680
			cpu_dai->driver->suspend(cpu_dai);
F
Frank Mandarino 已提交
681 682
	}

683
	/* close any waiting streams */
684 685
	list_for_each_entry(rtd, &card->rtd_list, list)
		flush_delayed_work(&rtd->delayed_work);
F
Frank Mandarino 已提交
686

687
	list_for_each_entry(rtd, &card->rtd_list, list) {
688

689
		if (rtd->dai_link->ignore_suspend)
690 691
			continue;

692
		snd_soc_dapm_stream_event(rtd,
693 694
					  SNDRV_PCM_STREAM_PLAYBACK,
					  SND_SOC_DAPM_STREAM_SUSPEND);
695

696
		snd_soc_dapm_stream_event(rtd,
697 698
					  SNDRV_PCM_STREAM_CAPTURE,
					  SND_SOC_DAPM_STREAM_SUSPEND);
F
Frank Mandarino 已提交
699 700
	}

701 702
	/* Recheck all endpoints too, their state is affected by suspend */
	dapm_mark_endpoints_dirty(card);
703 704
	snd_soc_dapm_sync(&card->dapm);

705
	/* suspend all CODECs */
706
	list_for_each_entry(codec, &card->codec_dev_list, card_list) {
707 708
		struct snd_soc_dapm_context *dapm = snd_soc_codec_get_dapm(codec);

709 710
		/* If there are paths active then the CODEC will be held with
		 * bias _ON and should not be suspended. */
711
		if (!codec->suspended) {
712
			switch (snd_soc_dapm_get_bias_level(dapm)) {
713
			case SND_SOC_BIAS_STANDBY:
714 715 716 717 718 719
				/*
				 * If the CODEC is capable of idle
				 * bias off then being in STANDBY
				 * means it's doing something,
				 * otherwise fall through.
				 */
720
				if (dapm->idle_bias_off) {
721
					dev_dbg(codec->dev,
722
						"ASoC: idle_bias_off CODEC on over suspend\n");
723 724
					break;
				}
725

726
			case SND_SOC_BIAS_OFF:
727 728
				if (codec->driver->suspend)
					codec->driver->suspend(codec);
729
				codec->suspended = 1;
730 731
				if (codec->component.regmap)
					regcache_mark_dirty(codec->component.regmap);
732 733
				/* deactivate pins to sleep state */
				pinctrl_pm_select_sleep_state(codec->dev);
734 735
				break;
			default:
736 737
				dev_dbg(codec->dev,
					"ASoC: CODEC is on over suspend\n");
738 739
				break;
			}
740 741
		}
	}
F
Frank Mandarino 已提交
742

743 744
	list_for_each_entry(rtd, &card->rtd_list, list) {
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
745

746
		if (rtd->dai_link->ignore_suspend)
747 748
			continue;

749
		if (cpu_dai->driver->suspend && cpu_dai->driver->bus_control)
750
			cpu_dai->driver->suspend(cpu_dai);
751 752 753

		/* deactivate pins to sleep state */
		pinctrl_pm_select_sleep_state(cpu_dai->dev);
F
Frank Mandarino 已提交
754 755
	}

756
	if (card->suspend_post)
757
		card->suspend_post(card);
F
Frank Mandarino 已提交
758 759 760

	return 0;
}
761
EXPORT_SYMBOL_GPL(snd_soc_suspend);
F
Frank Mandarino 已提交
762

763 764 765 766
/* deferred resume work, so resume can complete before we finished
 * setting our codec back up, which can be very slow on I2C
 */
static void soc_resume_deferred(struct work_struct *work)
F
Frank Mandarino 已提交
767
{
768 769
	struct snd_soc_card *card =
			container_of(work, struct snd_soc_card, deferred_resume_work);
770
	struct snd_soc_pcm_runtime *rtd;
771
	struct snd_soc_codec *codec;
772
	int i;
F
Frank Mandarino 已提交
773

774 775 776 777
	/* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
	 * so userspace apps are blocked from touching us
	 */

778
	dev_dbg(card->dev, "ASoC: starting resume work\n");
779

780
	/* Bring us up into D2 so that DAPM starts enabling things */
781
	snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
782

783
	if (card->resume_pre)
784
		card->resume_pre(card);
F
Frank Mandarino 已提交
785

786
	/* resume control bus DAIs */
787 788
	list_for_each_entry(rtd, &card->rtd_list, list) {
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
789

790
		if (rtd->dai_link->ignore_suspend)
791 792
			continue;

793
		if (cpu_dai->driver->resume && cpu_dai->driver->bus_control)
794 795 796
			cpu_dai->driver->resume(cpu_dai);
	}

797
	list_for_each_entry(codec, &card->codec_dev_list, card_list) {
798
		if (codec->suspended) {
799 800 801
			if (codec->driver->resume)
				codec->driver->resume(codec);
			codec->suspended = 0;
802 803
		}
	}
F
Frank Mandarino 已提交
804

805
	list_for_each_entry(rtd, &card->rtd_list, list) {
806

807
		if (rtd->dai_link->ignore_suspend)
808 809
			continue;

810
		snd_soc_dapm_stream_event(rtd,
811
					  SNDRV_PCM_STREAM_PLAYBACK,
812
					  SND_SOC_DAPM_STREAM_RESUME);
813

814
		snd_soc_dapm_stream_event(rtd,
815
					  SNDRV_PCM_STREAM_CAPTURE,
816
					  SND_SOC_DAPM_STREAM_RESUME);
F
Frank Mandarino 已提交
817 818
	}

819
	/* unmute any active DACs */
820
	list_for_each_entry(rtd, &card->rtd_list, list) {
821

822
		if (rtd->dai_link->ignore_suspend)
823 824
			continue;

825 826
		for (i = 0; i < rtd->num_codecs; i++) {
			struct snd_soc_dai *dai = rtd->codec_dais[i];
827 828 829 830 831
			struct snd_soc_dai_driver *drv = dai->driver;

			if (drv->ops->digital_mute && dai->playback_active)
				drv->ops->digital_mute(dai, 0);
		}
F
Frank Mandarino 已提交
832 833
	}

834 835
	list_for_each_entry(rtd, &card->rtd_list, list) {
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
836

837
		if (rtd->dai_link->ignore_suspend)
838 839
			continue;

840
		if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)
841
			cpu_dai->driver->resume(cpu_dai);
F
Frank Mandarino 已提交
842 843
	}

844
	if (card->resume_post)
845
		card->resume_post(card);
F
Frank Mandarino 已提交
846

847
	dev_dbg(card->dev, "ASoC: resume work completed\n");
848

849 850
	/* Recheck all endpoints too, their state is affected by suspend */
	dapm_mark_endpoints_dirty(card);
851
	snd_soc_dapm_sync(&card->dapm);
852 853 854

	/* userspace can access us now we are back as we were before */
	snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D0);
855 856 857
}

/* powers up audio subsystem after a suspend */
858
int snd_soc_resume(struct device *dev)
859
{
860
	struct snd_soc_card *card = dev_get_drvdata(dev);
861
	bool bus_control = false;
862
	struct snd_soc_pcm_runtime *rtd;
863

864 865
	/* If the card is not initialized yet there is nothing to do */
	if (!card->instantiated)
866 867
		return 0;

868
	/* activate pins from sleep state */
869
	list_for_each_entry(rtd, &card->rtd_list, list) {
870 871 872 873
		struct snd_soc_dai **codec_dais = rtd->codec_dais;
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
		int j;

874 875
		if (cpu_dai->active)
			pinctrl_pm_select_default_state(cpu_dai->dev);
876 877 878 879 880 881

		for (j = 0; j < rtd->num_codecs; j++) {
			struct snd_soc_dai *codec_dai = codec_dais[j];
			if (codec_dai->active)
				pinctrl_pm_select_default_state(codec_dai->dev);
		}
882 883
	}

884 885 886 887
	/*
	 * DAIs that also act as the control bus master might have other drivers
	 * hanging off them so need to resume immediately. Other drivers don't
	 * have that problem and may take a substantial amount of time to resume
888 889
	 * due to I/O costs and anti-pop so handle them out of line.
	 */
890 891
	list_for_each_entry(rtd, &card->rtd_list, list) {
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
892
		bus_control |= cpu_dai->driver->bus_control;
893
	}
894 895
	if (bus_control) {
		dev_dbg(dev, "ASoC: Resuming control bus master immediately\n");
896 897
		soc_resume_deferred(&card->deferred_resume_work);
	} else {
898
		dev_dbg(dev, "ASoC: Scheduling resume work\n");
899
		if (!schedule_work(&card->deferred_resume_work))
900
			dev_err(dev, "ASoC: resume work item may be lost\n");
901
	}
902

F
Frank Mandarino 已提交
903 904
	return 0;
}
905
EXPORT_SYMBOL_GPL(snd_soc_resume);
F
Frank Mandarino 已提交
906
#else
907 908
#define snd_soc_suspend NULL
#define snd_soc_resume NULL
F
Frank Mandarino 已提交
909 910
#endif

911
static const struct snd_soc_dai_ops null_dai_ops = {
912 913
};

914 915
static struct snd_soc_component *soc_find_component(
	const struct device_node *of_node, const char *name)
916
{
917
	struct snd_soc_component *component;
918

919 920
	lockdep_assert_held(&client_mutex);

921 922 923 924 925 926
	list_for_each_entry(component, &component_list, list) {
		if (of_node) {
			if (component->dev->of_node == of_node)
				return component;
		} else if (strcmp(component->name, name) == 0) {
			return component;
927 928 929 930 931 932
		}
	}

	return NULL;
}

933 934 935 936 937 938 939 940 941 942 943
/**
 * snd_soc_find_dai - Find a registered DAI
 *
 * @dlc: name of the DAI and optional component info to match
 *
 * This function will search all regsitered components and their DAIs to
 * find the DAI of the same name. The component's of_node and name
 * should also match if being specified.
 *
 * Return: pointer of DAI, or NULL if not found.
 */
M
Mengdong Lin 已提交
944
struct snd_soc_dai *snd_soc_find_dai(
945
	const struct snd_soc_dai_link_component *dlc)
946
{
947 948
	struct snd_soc_component *component;
	struct snd_soc_dai *dai;
949
	struct device_node *component_of_node;
950

951 952
	lockdep_assert_held(&client_mutex);

953 954
	/* Find CPU DAI from registered DAIs*/
	list_for_each_entry(component, &component_list, list) {
955 956 957 958 959
		component_of_node = component->dev->of_node;
		if (!component_of_node && component->dev->parent)
			component_of_node = component->dev->parent->of_node;

		if (dlc->of_node && component_of_node != dlc->of_node)
960
			continue;
961
		if (dlc->name && strcmp(component->name, dlc->name))
962 963 964
			continue;
		list_for_each_entry(dai, &component->dai_list, list) {
			if (dlc->dai_name && strcmp(dai->name, dlc->dai_name))
965 966
				continue;

967
			return dai;
968 969 970 971 972
		}
	}

	return NULL;
}
M
Mengdong Lin 已提交
973
EXPORT_SYMBOL_GPL(snd_soc_find_dai);
974

975 976 977 978 979 980 981 982 983 984 985 986 987
static bool soc_is_dai_link_bound(struct snd_soc_card *card,
		struct snd_soc_dai_link *dai_link)
{
	struct snd_soc_pcm_runtime *rtd;

	list_for_each_entry(rtd, &card->rtd_list, list) {
		if (rtd->dai_link == dai_link)
			return true;
	}

	return false;
}

988 989
static int soc_bind_dai_link(struct snd_soc_card *card,
	struct snd_soc_dai_link *dai_link)
F
Frank Mandarino 已提交
990
{
991
	struct snd_soc_pcm_runtime *rtd;
992
	struct snd_soc_dai_link_component *codecs = dai_link->codecs;
993
	struct snd_soc_dai_link_component cpu_dai_component;
994
	struct snd_soc_dai **codec_dais;
995
	struct snd_soc_platform *platform;
996
	const char *platform_name;
997
	int i;
998

999
	dev_dbg(card->dev, "ASoC: binding %s\n", dai_link->name);
1000

1001 1002 1003 1004 1005
	if (soc_is_dai_link_bound(card, dai_link)) {
		dev_dbg(card->dev, "ASoC: dai link %s already bound\n",
			dai_link->name);
		return 0;
	}
1006

S
Sudip Mukherjee 已提交
1007 1008 1009 1010
	rtd = soc_new_pcm_runtime(card, dai_link);
	if (!rtd)
		return -ENOMEM;

1011 1012 1013 1014
	cpu_dai_component.name = dai_link->cpu_name;
	cpu_dai_component.of_node = dai_link->cpu_of_node;
	cpu_dai_component.dai_name = dai_link->cpu_dai_name;
	rtd->cpu_dai = snd_soc_find_dai(&cpu_dai_component);
1015
	if (!rtd->cpu_dai) {
1016
		dev_err(card->dev, "ASoC: CPU DAI %s not registered\n",
1017
			dai_link->cpu_dai_name);
1018
		goto _err_defer;
1019 1020
	}

1021
	rtd->num_codecs = dai_link->num_codecs;
1022

1023
	/* Find CODEC from registered CODECs */
1024
	codec_dais = rtd->codec_dais;
1025
	for (i = 0; i < rtd->num_codecs; i++) {
1026
		codec_dais[i] = snd_soc_find_dai(&codecs[i]);
1027 1028 1029
		if (!codec_dais[i]) {
			dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
				codecs[i].dai_name);
1030
			goto _err_defer;
1031
		}
1032 1033
	}

1034 1035 1036 1037
	/* Single codec links expect codec and codec_dai in runtime data */
	rtd->codec_dai = codec_dais[0];
	rtd->codec = rtd->codec_dai->codec;

1038 1039
	/* if there's no platform we match on the empty platform */
	platform_name = dai_link->platform_name;
1040
	if (!platform_name && !dai_link->platform_of_node)
1041 1042
		platform_name = "snd-soc-dummy";

1043
	/* find one from the set of registered platforms */
1044
	list_for_each_entry(platform, &platform_list, list) {
1045 1046 1047 1048 1049
		if (dai_link->platform_of_node) {
			if (platform->dev->of_node !=
			    dai_link->platform_of_node)
				continue;
		} else {
1050
			if (strcmp(platform->component.name, platform_name))
1051 1052
				continue;
		}
1053 1054

		rtd->platform = platform;
1055
	}
1056
	if (!rtd->platform) {
1057
		dev_err(card->dev, "ASoC: platform %s not registered\n",
1058
			dai_link->platform_name);
1059
		goto _err_defer;
1060
	}
1061

1062
	soc_add_pcm_runtime(card, rtd);
1063
	return 0;
1064 1065 1066 1067

_err_defer:
	soc_free_pcm_runtime(rtd);
	return  -EPROBE_DEFER;
1068 1069
}

1070
static void soc_remove_component(struct snd_soc_component *component)
1071
{
1072
	if (!component->card)
1073
		return;
1074

1075 1076 1077
	/* This is a HACK and will be removed soon */
	if (component->codec)
		list_del(&component->codec->card_list);
1078

1079 1080
	if (component->remove)
		component->remove(component);
1081

1082
	snd_soc_dapm_free(snd_soc_component_get_dapm(component));
1083

1084
	soc_cleanup_component_debugfs(component);
1085
	component->card = NULL;
1086
	module_put(component->dev->driver->owner);
1087 1088
}

1089
static void soc_remove_dai(struct snd_soc_dai *dai, int order)
1090 1091 1092
{
	int err;

1093 1094 1095 1096
	if (dai && dai->probed &&
			dai->driver->remove_order == order) {
		if (dai->driver->remove) {
			err = dai->driver->remove(dai);
1097
			if (err < 0)
1098
				dev_err(dai->dev,
1099
					"ASoC: failed to remove %s: %d\n",
1100
					dai->name, err);
1101
		}
1102
		dai->probed = 0;
1103
	}
1104 1105
}

1106 1107
static void soc_remove_link_dais(struct snd_soc_card *card,
		struct snd_soc_pcm_runtime *rtd, int order)
1108
{
1109
	int i;
1110 1111 1112 1113 1114 1115 1116 1117

	/* unregister the rtd device */
	if (rtd->dev_registered) {
		device_unregister(rtd->dev);
		rtd->dev_registered = 0;
	}

	/* remove the CODEC DAI */
1118
	for (i = 0; i < rtd->num_codecs; i++)
1119
		soc_remove_dai(rtd->codec_dais[i], order);
1120

1121
	soc_remove_dai(rtd->cpu_dai, order);
1122
}
F
Frank Mandarino 已提交
1123

1124 1125
static void soc_remove_link_components(struct snd_soc_card *card,
	struct snd_soc_pcm_runtime *rtd, int order)
1126 1127 1128
{
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	struct snd_soc_platform *platform = rtd->platform;
1129
	struct snd_soc_component *component;
1130
	int i;
1131 1132

	/* remove the platform */
1133
	if (platform && platform->component.driver->remove_order == order)
1134
		soc_remove_component(&platform->component);
1135 1136

	/* remove the CODEC-side CODEC */
1137
	for (i = 0; i < rtd->num_codecs; i++) {
1138
		component = rtd->codec_dais[i]->component;
1139
		if (component->driver->remove_order == order)
1140
			soc_remove_component(component);
1141 1142 1143 1144
	}

	/* remove any CPU-side CODEC */
	if (cpu_dai) {
1145
		if (cpu_dai->component->driver->remove_order == order)
1146
			soc_remove_component(cpu_dai->component);
1147 1148 1149
	}
}

1150 1151
static void soc_remove_dai_links(struct snd_soc_card *card)
{
1152 1153
	int order;
	struct snd_soc_pcm_runtime *rtd;
1154
	struct snd_soc_dai_link *link, *_link;
1155

1156 1157
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
			order++) {
1158 1159
		list_for_each_entry(rtd, &card->rtd_list, list)
			soc_remove_link_dais(card, rtd, order);
1160 1161 1162 1163
	}

	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
			order++) {
1164 1165
		list_for_each_entry(rtd, &card->rtd_list, list)
			soc_remove_link_components(card, rtd, order);
1166
	}
1167

1168 1169 1170 1171 1172 1173 1174 1175
	list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
		if (link->dobj.type == SND_SOC_DOBJ_DAI_LINK)
			dev_warn(card->dev, "Topology forgot to remove link %s?\n",
				link->name);

		list_del(&link->list);
		card->num_dai_links--;
	}
1176 1177
}

1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
static int snd_soc_init_multicodec(struct snd_soc_card *card,
				   struct snd_soc_dai_link *dai_link)
{
	/* Legacy codec/codec_dai link is a single entry in multicodec */
	if (dai_link->codec_name || dai_link->codec_of_node ||
	    dai_link->codec_dai_name) {
		dai_link->num_codecs = 1;

		dai_link->codecs = devm_kzalloc(card->dev,
				sizeof(struct snd_soc_dai_link_component),
				GFP_KERNEL);
		if (!dai_link->codecs)
			return -ENOMEM;

		dai_link->codecs[0].name = dai_link->codec_name;
		dai_link->codecs[0].of_node = dai_link->codec_of_node;
		dai_link->codecs[0].dai_name = dai_link->codec_dai_name;
	}

	if (!dai_link->codecs) {
		dev_err(card->dev, "ASoC: DAI link has no CODECs\n");
		return -EINVAL;
	}

	return 0;
}

static int soc_init_dai_link(struct snd_soc_card *card,
				   struct snd_soc_dai_link *link)
{
	int i, ret;

	ret = snd_soc_init_multicodec(card, link);
	if (ret) {
		dev_err(card->dev, "ASoC: failed to init multicodec\n");
		return ret;
	}

	for (i = 0; i < link->num_codecs; i++) {
		/*
		 * Codec must be specified by 1 of name or OF node,
		 * not both or neither.
		 */
		if (!!link->codecs[i].name ==
		    !!link->codecs[i].of_node) {
			dev_err(card->dev, "ASoC: Neither/both codec name/of_node are set for %s\n",
				link->name);
			return -EINVAL;
		}
		/* Codec DAI name must be specified */
		if (!link->codecs[i].dai_name) {
			dev_err(card->dev, "ASoC: codec_dai_name not set for %s\n",
				link->name);
			return -EINVAL;
		}
	}

	/*
	 * Platform may be specified by either name or OF node, but
	 * can be left unspecified, and a dummy platform will be used.
	 */
	if (link->platform_name && link->platform_of_node) {
		dev_err(card->dev,
			"ASoC: Both platform name/of_node are set for %s\n",
			link->name);
		return -EINVAL;
	}

	/*
	 * CPU device may be specified by either name or OF node, but
	 * can be left unspecified, and will be matched based on DAI
	 * name alone..
	 */
	if (link->cpu_name && link->cpu_of_node) {
		dev_err(card->dev,
			"ASoC: Neither/both cpu name/of_node are set for %s\n",
			link->name);
		return -EINVAL;
	}
	/*
	 * At least one of CPU DAI name or CPU device name/node must be
	 * specified
	 */
	if (!link->cpu_dai_name &&
	    !(link->cpu_name || link->cpu_of_node)) {
		dev_err(card->dev,
			"ASoC: Neither cpu_dai_name nor cpu_name/of_node are set for %s\n",
			link->name);
		return -EINVAL;
	}

	return 0;
1270 1271
}

1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
/**
 * snd_soc_add_dai_link - Add a DAI link dynamically
 * @card: The ASoC card to which the DAI link is added
 * @dai_link: The new DAI link to add
 *
 * This function adds a DAI link to the ASoC card's link list.
 *
 * Note: Topology can use this API to add DAI links when probing the
 * topology component. And machine drivers can still define static
 * DAI links in dai_link array.
 */
int snd_soc_add_dai_link(struct snd_soc_card *card,
		struct snd_soc_dai_link *dai_link)
{
	if (dai_link->dobj.type
	    && dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
		dev_err(card->dev, "Invalid dai link type %d\n",
			dai_link->dobj.type);
		return -EINVAL;
	}

	lockdep_assert_held(&client_mutex);
1294 1295 1296 1297 1298 1299
	/* Notify the machine driver for extra initialization
	 * on the link created by topology.
	 */
	if (dai_link->dobj.type && card->add_dai_link)
		card->add_dai_link(card, dai_link);

1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
	list_add_tail(&dai_link->list, &card->dai_link_list);
	card->num_dai_links++;

	return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_add_dai_link);

/**
 * snd_soc_remove_dai_link - Remove a DAI link from the list
 * @card: The ASoC card that owns the link
 * @dai_link: The DAI link to remove
 *
 * This function removes a DAI link from the ASoC card's link list.
 *
 * For DAI links previously added by topology, topology should
 * remove them by using the dobj embedded in the link.
 */
void snd_soc_remove_dai_link(struct snd_soc_card *card,
			     struct snd_soc_dai_link *dai_link)
{
	struct snd_soc_dai_link *link, *_link;

	if (dai_link->dobj.type
	    && dai_link->dobj.type != SND_SOC_DOBJ_DAI_LINK) {
		dev_err(card->dev, "Invalid dai link type %d\n",
			dai_link->dobj.type);
		return;
	}

	lockdep_assert_held(&client_mutex);
1330 1331 1332 1333 1334 1335
	/* Notify the machine driver for extra destruction
	 * on the link created by topology.
	 */
	if (dai_link->dobj.type && card->remove_dai_link)
		card->remove_dai_link(card, dai_link);

1336 1337 1338 1339 1340 1341 1342 1343 1344 1345
	list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
		if (link == dai_link) {
			list_del(&link->list);
			card->num_dai_links--;
			return;
		}
	}
}
EXPORT_SYMBOL_GPL(snd_soc_remove_dai_link);

1346
static void soc_set_name_prefix(struct snd_soc_card *card,
1347
				struct snd_soc_component *component)
1348 1349 1350
{
	int i;

1351
	if (card->codec_conf == NULL)
1352 1353
		return;

1354 1355
	for (i = 0; i < card->num_configs; i++) {
		struct snd_soc_codec_conf *map = &card->codec_conf[i];
1356
		if (map->of_node && component->dev->of_node != map->of_node)
1357
			continue;
1358
		if (map->dev_name && strcmp(component->name, map->dev_name))
1359
			continue;
1360
		component->name_prefix = map->name_prefix;
1361
		break;
1362 1363 1364
	}
}

1365 1366
static int soc_probe_component(struct snd_soc_card *card,
	struct snd_soc_component *component)
1367
{
1368
	struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
1369
	struct snd_soc_dai *dai;
1370
	int ret;
1371

1372
	if (!strcmp(component->name, "snd-soc-dummy"))
1373
		return 0;
1374

1375
	if (component->card) {
1376 1377 1378 1379 1380 1381 1382 1383
		if (component->card != card) {
			dev_err(component->dev,
				"Trying to bind component to card \"%s\" but is already bound to card \"%s\"\n",
				card->name, component->card->name);
			return -ENODEV;
		}
		return 0;
	}
1384

1385
	if (!try_module_get(component->dev->driver->owner))
1386 1387
		return -ENODEV;

1388 1389 1390
	component->card = card;
	dapm->card = card;
	soc_set_name_prefix(card, component);
1391

1392
	soc_init_component_debugfs(component);
1393

1394 1395 1396
	if (component->dapm_widgets) {
		ret = snd_soc_dapm_new_controls(dapm, component->dapm_widgets,
			component->num_dapm_widgets);
1397 1398

		if (ret != 0) {
1399
			dev_err(component->dev,
1400 1401 1402 1403
				"Failed to create new controls %d\n", ret);
			goto err_probe;
		}
	}
1404

1405 1406
	list_for_each_entry(dai, &component->dai_list, list) {
		ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
1407
		if (ret != 0) {
1408
			dev_err(component->dev,
1409 1410 1411 1412
				"Failed to create DAI widgets %d\n", ret);
			goto err_probe;
		}
	}
1413

1414 1415
	if (component->probe) {
		ret = component->probe(component);
1416
		if (ret < 0) {
1417 1418
			dev_err(component->dev,
				"ASoC: failed to probe component %d\n", ret);
1419
			goto err_probe;
1420
		}
1421

1422 1423 1424 1425
		WARN(dapm->idle_bias_off &&
			dapm->bias_level != SND_SOC_BIAS_OFF,
			"codec %s can not start from non-off bias with idle_bias_off==1\n",
			component->name);
1426 1427
	}

1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
	/* machine specific init */
	if (component->init) {
		ret = component->init(component);
		if (ret < 0) {
			dev_err(component->dev,
				"Failed to do machine specific init %d\n", ret);
			goto err_probe;
		}
	}

1438 1439 1440 1441 1442 1443
	if (component->controls)
		snd_soc_add_component_controls(component, component->controls,
				     component->num_controls);
	if (component->dapm_routes)
		snd_soc_dapm_add_routes(dapm, component->dapm_routes,
					component->num_dapm_routes);
1444

1445
	list_add(&dapm->list, &card->dapm_list);
1446

1447 1448 1449
	/* This is a HACK and will be removed soon */
	if (component->codec)
		list_add(&component->codec->card_list, &card->codec_dev_list);
1450 1451 1452 1453

	return 0;

err_probe:
1454
	soc_cleanup_component_debugfs(component);
1455
	component->card = NULL;
1456
	module_put(component->dev->driver->owner);
1457 1458 1459 1460

	return ret;
}

1461 1462 1463 1464
static void rtd_release(struct device *dev)
{
	kfree(dev);
}
1465

1466 1467
static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
	const char *name)
1468
{
1469 1470 1471
	int ret = 0;

	/* register the rtd device */
1472 1473 1474 1475
	rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
	if (!rtd->dev)
		return -ENOMEM;
	device_initialize(rtd->dev);
1476
	rtd->dev->parent = rtd->card->dev;
1477
	rtd->dev->release = rtd_release;
1478
	rtd->dev->groups = soc_dev_attr_groups;
1479
	dev_set_name(rtd->dev, "%s", name);
1480
	dev_set_drvdata(rtd->dev, rtd);
L
Liam Girdwood 已提交
1481
	mutex_init(&rtd->pcm_mutex);
1482 1483 1484 1485
	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].be_clients);
	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].be_clients);
	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_PLAYBACK].fe_clients);
	INIT_LIST_HEAD(&rtd->dpcm[SNDRV_PCM_STREAM_CAPTURE].fe_clients);
1486
	ret = device_add(rtd->dev);
1487
	if (ret < 0) {
1488 1489
		/* calling put_device() here to free the rtd->dev */
		put_device(rtd->dev);
1490
		dev_err(rtd->card->dev,
1491
			"ASoC: failed to register runtime device: %d\n", ret);
1492 1493 1494 1495 1496 1497
		return ret;
	}
	rtd->dev_registered = 1;
	return 0;
}

1498 1499
static int soc_probe_link_components(struct snd_soc_card *card,
			struct snd_soc_pcm_runtime *rtd,
1500 1501 1502
				     int order)
{
	struct snd_soc_platform *platform = rtd->platform;
1503
	struct snd_soc_component *component;
1504
	int i, ret;
1505 1506

	/* probe the CPU-side component, if it is a CODEC */
1507
	component = rtd->cpu_dai->component;
1508
	if (component->driver->probe_order == order) {
1509
		ret = soc_probe_component(card, component);
1510 1511 1512 1513
		if (ret < 0)
			return ret;
	}

1514 1515
	/* probe the CODEC-side components */
	for (i = 0; i < rtd->num_codecs; i++) {
1516
		component = rtd->codec_dais[i]->component;
1517
		if (component->driver->probe_order == order) {
1518
			ret = soc_probe_component(card, component);
1519 1520 1521
			if (ret < 0)
				return ret;
		}
1522 1523 1524
	}

	/* probe the platform */
1525
	if (platform->component.driver->probe_order == order) {
1526
		ret = soc_probe_component(card, &platform->component);
1527 1528 1529 1530 1531 1532 1533
		if (ret < 0)
			return ret;
	}

	return 0;
}

1534
static int soc_probe_dai(struct snd_soc_dai *dai, int order)
1535 1536 1537
{
	int ret;

1538 1539 1540
	if (!dai->probed && dai->driver->probe_order == order) {
		if (dai->driver->probe) {
			ret = dai->driver->probe(dai);
1541
			if (ret < 0) {
1542 1543 1544
				dev_err(dai->dev,
					"ASoC: failed to probe DAI %s: %d\n",
					dai->name, ret);
1545 1546 1547 1548
				return ret;
			}
		}

1549
		dai->probed = 1;
1550 1551 1552 1553 1554
	}

	return 0;
}

1555 1556
static int soc_link_dai_widgets(struct snd_soc_card *card,
				struct snd_soc_dai_link *dai_link,
1557
				struct snd_soc_pcm_runtime *rtd)
1558
{
1559 1560
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	struct snd_soc_dai *codec_dai = rtd->codec_dai;
1561
	struct snd_soc_dapm_widget *sink, *source;
1562 1563
	int ret;

1564 1565 1566
	if (rtd->num_codecs > 1)
		dev_warn(card->dev, "ASoC: Multiple codecs not supported yet\n");

1567
	/* link the DAI widgets */
1568 1569 1570
	sink = codec_dai->playback_widget;
	source = cpu_dai->capture_widget;
	if (sink && source) {
1571
		ret = snd_soc_dapm_new_pcm(card, dai_link->params,
1572 1573
					   dai_link->num_params,
					   source, sink);
1574 1575
		if (ret != 0) {
			dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1576
				sink->name, source->name, ret);
1577 1578 1579 1580
			return ret;
		}
	}

1581 1582 1583
	sink = cpu_dai->playback_widget;
	source = codec_dai->capture_widget;
	if (sink && source) {
1584
		ret = snd_soc_dapm_new_pcm(card, dai_link->params,
1585 1586
					   dai_link->num_params,
					   source, sink);
1587 1588
		if (ret != 0) {
			dev_err(card->dev, "ASoC: Can't link %s to %s: %d\n",
1589
				sink->name, source->name, ret);
1590 1591 1592 1593 1594 1595 1596
			return ret;
		}
	}

	return 0;
}

1597 1598
static int soc_probe_link_dais(struct snd_soc_card *card,
		struct snd_soc_pcm_runtime *rtd, int order)
1599
{
1600
	struct snd_soc_dai_link *dai_link = rtd->dai_link;
1601
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1602
	int i, ret;
1603

1604
	dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
1605
			card->name, rtd->num, order);
1606 1607 1608 1609

	/* set default power off timeout */
	rtd->pmdown_time = pmdown_time;

1610 1611 1612
	ret = soc_probe_dai(cpu_dai, order);
	if (ret)
		return ret;
F
Frank Mandarino 已提交
1613

1614
	/* probe the CODEC DAI */
1615
	for (i = 0; i < rtd->num_codecs; i++) {
1616
		ret = soc_probe_dai(rtd->codec_dais[i], order);
1617 1618 1619
		if (ret)
			return ret;
	}
M
Mark Brown 已提交
1620

1621 1622 1623 1624
	/* complete DAI probe during last probe */
	if (order != SND_SOC_COMP_ORDER_LAST)
		return 0;

1625 1626 1627 1628 1629 1630 1631 1632 1633 1634
	/* do machine specific initialization */
	if (dai_link->init) {
		ret = dai_link->init(rtd);
		if (ret < 0) {
			dev_err(card->dev, "ASoC: failed to init %s: %d\n",
				dai_link->name, ret);
			return ret;
		}
	}

1635 1636 1637
	if (dai_link->dai_fmt)
		snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);

1638
	ret = soc_post_component_init(rtd, dai_link->name);
1639
	if (ret)
1640
		return ret;
M
Mark Brown 已提交
1641

1642 1643
#ifdef CONFIG_DEBUG_FS
	/* add DPCM sysfs entries */
1644 1645
	if (dai_link->dynamic)
		soc_dpcm_debugfs_add(rtd);
1646 1647
#endif

1648
	if (cpu_dai->driver->compress_new) {
1649
		/*create compress_device"*/
1650
		ret = cpu_dai->driver->compress_new(rtd, rtd->num);
1651
		if (ret < 0) {
1652
			dev_err(card->dev, "ASoC: can't create compress %s\n",
1653
					 dai_link->stream_name);
1654 1655 1656
			return ret;
		}
	} else {
1657 1658 1659

		if (!dai_link->params) {
			/* create the pcm */
1660
			ret = soc_new_pcm(rtd, rtd->num);
1661
			if (ret < 0) {
1662
				dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
1663
				       dai_link->stream_name, ret);
1664 1665
				return ret;
			}
1666
		} else {
1667 1668 1669
			INIT_DELAYED_WORK(&rtd->delayed_work,
						codec2codec_close_delayed_work);

1670
			/* link the DAI widgets */
1671
			ret = soc_link_dai_widgets(card, dai_link, rtd);
1672 1673
			if (ret)
				return ret;
1674
		}
1675 1676 1677 1678 1679
	}

	return 0;
}

1680
static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
1681 1682
{
	struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705
	struct snd_soc_component *component;
	const char *name;
	struct device_node *codec_of_node;

	if (aux_dev->codec_of_node || aux_dev->codec_name) {
		/* codecs, usually analog devices */
		name = aux_dev->codec_name;
		codec_of_node = aux_dev->codec_of_node;
		component = soc_find_component(codec_of_node, name);
		if (!component) {
			if (codec_of_node)
				name = of_node_full_name(codec_of_node);
			goto err_defer;
		}
	} else if (aux_dev->name) {
		/* generic components */
		name = aux_dev->name;
		component = soc_find_component(NULL, name);
		if (!component)
			goto err_defer;
	} else {
		dev_err(card->dev, "ASoC: Invalid auxiliary device\n");
		return -EINVAL;
1706
	}
1707

1708 1709
	component->init = aux_dev->init;
	list_add(&component->list_aux, &card->aux_comp_list);
1710
	return 0;
1711 1712 1713 1714

err_defer:
	dev_err(card->dev, "ASoC: %s not registered\n", name);
	return -EPROBE_DEFER;
1715 1716
}

1717
static int soc_probe_aux_devices(struct snd_soc_card *card)
1718
{
1719 1720
	struct snd_soc_component *comp;
	int order;
1721
	int ret;
1722

1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
		order++) {
		list_for_each_entry(comp, &card->aux_comp_list, list_aux) {
			if (comp->driver->probe_order == order) {
				ret = soc_probe_component(card,	comp);
				if (ret < 0) {
					dev_err(card->dev,
						"ASoC: failed to probe aux component %s %d\n",
						comp->name, ret);
					return ret;
				}
			}
1735 1736
		}
	}
1737

1738
	return 0;
1739 1740
}

1741
static void soc_remove_aux_devices(struct snd_soc_card *card)
1742
{
1743 1744
	struct snd_soc_component *comp, *_comp;
	int order;
1745

1746 1747 1748 1749 1750 1751 1752 1753 1754 1755
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
		order++) {
		list_for_each_entry_safe(comp, _comp,
			&card->aux_comp_list, list_aux) {
			if (comp->driver->remove_order == order) {
				soc_remove_component(comp);
				/* remove it from the card's aux_comp_list */
				list_del(&comp->list_aux);
			}
		}
1756 1757 1758
	}
}

1759
static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)
1760 1761 1762 1763 1764 1765 1766 1767
{
	int ret;

	if (codec->cache_init)
		return 0;

	ret = snd_soc_cache_init(codec);
	if (ret < 0) {
1768 1769 1770
		dev_err(codec->dev,
			"ASoC: Failed to set cache compression type: %d\n",
			ret);
1771 1772 1773 1774 1775 1776
		return ret;
	}
	codec->cache_init = 1;
	return 0;
}

1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840
/**
 * snd_soc_runtime_set_dai_fmt() - Change DAI link format for a ASoC runtime
 * @rtd: The runtime for which the DAI link format should be changed
 * @dai_fmt: The new DAI link format
 *
 * This function updates the DAI link format for all DAIs connected to the DAI
 * link for the specified runtime.
 *
 * Note: For setups with a static format set the dai_fmt field in the
 * corresponding snd_dai_link struct instead of using this function.
 *
 * Returns 0 on success, otherwise a negative error code.
 */
int snd_soc_runtime_set_dai_fmt(struct snd_soc_pcm_runtime *rtd,
	unsigned int dai_fmt)
{
	struct snd_soc_dai **codec_dais = rtd->codec_dais;
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
	unsigned int i;
	int ret;

	for (i = 0; i < rtd->num_codecs; i++) {
		struct snd_soc_dai *codec_dai = codec_dais[i];

		ret = snd_soc_dai_set_fmt(codec_dai, dai_fmt);
		if (ret != 0 && ret != -ENOTSUPP) {
			dev_warn(codec_dai->dev,
				 "ASoC: Failed to set DAI format: %d\n", ret);
			return ret;
		}
	}

	/* Flip the polarity for the "CPU" end of a CODEC<->CODEC link */
	if (cpu_dai->codec) {
		unsigned int inv_dai_fmt;

		inv_dai_fmt = dai_fmt & ~SND_SOC_DAIFMT_MASTER_MASK;
		switch (dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) {
		case SND_SOC_DAIFMT_CBM_CFM:
			inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFS;
			break;
		case SND_SOC_DAIFMT_CBM_CFS:
			inv_dai_fmt |= SND_SOC_DAIFMT_CBS_CFM;
			break;
		case SND_SOC_DAIFMT_CBS_CFM:
			inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFS;
			break;
		case SND_SOC_DAIFMT_CBS_CFS:
			inv_dai_fmt |= SND_SOC_DAIFMT_CBM_CFM;
			break;
		}

		dai_fmt = inv_dai_fmt;
	}

	ret = snd_soc_dai_set_fmt(cpu_dai, dai_fmt);
	if (ret != 0 && ret != -ENOTSUPP) {
		dev_warn(cpu_dai->dev,
			 "ASoC: Failed to set DAI format: %d\n", ret);
		return ret;
	}

	return 0;
}
1841
EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
1842

1843
static int snd_soc_instantiate_card(struct snd_soc_card *card)
1844
{
1845
	struct snd_soc_codec *codec;
1846
	struct snd_soc_pcm_runtime *rtd;
1847
	struct snd_soc_dai_link *dai_link;
1848
	int ret, i, order;
M
Mark Brown 已提交
1849

1850
	mutex_lock(&client_mutex);
1851
	mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
1852

1853
	/* bind DAIs */
1854
	for (i = 0; i < card->num_links; i++) {
1855
		ret = soc_bind_dai_link(card, &card->dai_link[i]);
1856 1857 1858
		if (ret != 0)
			goto base_error;
	}
M
Mark Brown 已提交
1859

1860
	/* bind aux_devs too */
1861
	for (i = 0; i < card->num_aux_devs; i++) {
1862
		ret = soc_bind_aux_dev(card, i);
1863 1864
		if (ret != 0)
			goto base_error;
1865
	}
1866

1867 1868 1869 1870
	/* add predefined DAI links to the list */
	for (i = 0; i < card->num_links; i++)
		snd_soc_add_dai_link(card, card->dai_link+i);

1871 1872 1873 1874
	/* initialize the register cache for each available codec */
	list_for_each_entry(codec, &codec_list, list) {
		if (codec->cache_init)
			continue;
1875
		ret = snd_soc_init_codec_cache(codec);
1876 1877
		if (ret < 0)
			goto base_error;
1878 1879
	}

1880
	/* card bind complete so register a sound card */
1881
	ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
1882 1883
			card->owner, 0, &card->snd_card);
	if (ret < 0) {
1884 1885 1886
		dev_err(card->dev,
			"ASoC: can't create sound card for card %s: %d\n",
			card->name, ret);
1887
		goto base_error;
1888 1889
	}

1890 1891
	soc_init_card_debugfs(card);

M
Mark Brown 已提交
1892 1893 1894 1895 1896
	card->dapm.bias_level = SND_SOC_BIAS_OFF;
	card->dapm.dev = card->dev;
	card->dapm.card = card;
	list_add(&card->dapm.list, &card->dapm_list);

1897 1898 1899 1900
#ifdef CONFIG_DEBUG_FS
	snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
#endif

1901
#ifdef CONFIG_PM_SLEEP
1902 1903 1904
	/* deferred resume work */
	INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
#endif
F
Frank Mandarino 已提交
1905

1906 1907 1908 1909
	if (card->dapm_widgets)
		snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
					  card->num_dapm_widgets);

1910 1911 1912 1913
	if (card->of_dapm_widgets)
		snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets,
					  card->num_of_dapm_widgets);

1914 1915
	/* initialise the sound card only once */
	if (card->probe) {
1916
		ret = card->probe(card);
1917 1918 1919
		if (ret < 0)
			goto card_probe_error;
	}
M
Mark Brown 已提交
1920

1921
	/* probe all components used by DAI links on this card */
1922 1923
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
			order++) {
1924 1925
		list_for_each_entry(rtd, &card->rtd_list, list) {
			ret = soc_probe_link_components(card, rtd, order);
1926
			if (ret < 0) {
1927 1928 1929
				dev_err(card->dev,
					"ASoC: failed to instantiate card %d\n",
					ret);
1930 1931 1932 1933 1934
				goto probe_dai_err;
			}
		}
	}

1935 1936 1937 1938 1939
	/* probe auxiliary components */
	ret = soc_probe_aux_devices(card);
	if (ret < 0)
		goto probe_dai_err;

1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954
	/* Find new DAI links added during probing components and bind them.
	 * Components with topology may bring new DAIs and DAI links.
	 */
	list_for_each_entry(dai_link, &card->dai_link_list, list) {
		if (soc_is_dai_link_bound(card, dai_link))
			continue;

		ret = soc_init_dai_link(card, dai_link);
		if (ret)
			goto probe_dai_err;
		ret = soc_bind_dai_link(card, dai_link);
		if (ret)
			goto probe_dai_err;
	}

1955 1956 1957
	/* probe all DAI links on this card */
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
			order++) {
1958 1959
		list_for_each_entry(rtd, &card->rtd_list, list) {
			ret = soc_probe_link_dais(card, rtd, order);
1960
			if (ret < 0) {
1961 1962 1963
				dev_err(card->dev,
					"ASoC: failed to instantiate card %d\n",
					ret);
1964 1965
				goto probe_dai_err;
			}
1966 1967
		}
	}
F
Frank Mandarino 已提交
1968

1969
	snd_soc_dapm_link_dai_widgets(card);
1970
	snd_soc_dapm_connect_dai_link_widgets(card);
1971

1972
	if (card->controls)
1973
		snd_soc_add_card_controls(card, card->controls, card->num_controls);
1974

1975 1976 1977 1978
	if (card->dapm_routes)
		snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
					card->num_dapm_routes);

1979 1980 1981
	if (card->of_dapm_routes)
		snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,
					card->num_of_dapm_routes);
1982

1983 1984
	snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
		 "%s", card->name);
1985 1986
	snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
		 "%s", card->long_name ? card->long_name : card->name);
1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000
	snprintf(card->snd_card->driver, sizeof(card->snd_card->driver),
		 "%s", card->driver_name ? card->driver_name : card->name);
	for (i = 0; i < ARRAY_SIZE(card->snd_card->driver); i++) {
		switch (card->snd_card->driver[i]) {
		case '_':
		case '-':
		case '\0':
			break;
		default:
			if (!isalnum(card->snd_card->driver[i]))
				card->snd_card->driver[i] = '_';
			break;
		}
	}
2001

2002 2003 2004
	if (card->late_probe) {
		ret = card->late_probe(card);
		if (ret < 0) {
2005
			dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
2006 2007 2008 2009 2010
				card->name, ret);
			goto probe_aux_dev_err;
		}
	}

2011
	snd_soc_dapm_new_widgets(card);
2012

2013 2014
	ret = snd_card_register(card->snd_card);
	if (ret < 0) {
2015 2016
		dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
				ret);
2017
		goto probe_aux_dev_err;
F
Frank Mandarino 已提交
2018 2019
	}

2020
	card->instantiated = 1;
2021
	snd_soc_dapm_sync(&card->dapm);
2022
	mutex_unlock(&card->mutex);
2023
	mutex_unlock(&client_mutex);
2024 2025

	return 0;
2026

2027
probe_aux_dev_err:
2028
	soc_remove_aux_devices(card);
2029

2030
probe_dai_err:
2031
	soc_remove_dai_links(card);
2032 2033

card_probe_error:
2034
	if (card->remove)
2035
		card->remove(card);
2036

2037
	snd_soc_dapm_free(&card->dapm);
2038
	soc_cleanup_card_debugfs(card);
2039 2040
	snd_card_free(card->snd_card);

2041
base_error:
2042
	soc_remove_pcm_runtimes(card);
2043
	mutex_unlock(&card->mutex);
2044
	mutex_unlock(&client_mutex);
F
Frank Mandarino 已提交
2045

2046
	return ret;
2047 2048 2049 2050 2051
}

/* probes a new socdev */
static int soc_probe(struct platform_device *pdev)
{
2052
	struct snd_soc_card *card = platform_get_drvdata(pdev);
2053

2054 2055 2056 2057 2058 2059 2060
	/*
	 * no card, so machine driver should be registering card
	 * we should not be here in that case so ret error
	 */
	if (!card)
		return -EINVAL;

2061
	dev_warn(&pdev->dev,
2062
		 "ASoC: machine %s should use snd_soc_register_card()\n",
2063 2064
		 card->name);

2065 2066
	/* Bodge while we unpick instantiation */
	card->dev = &pdev->dev;
2067

2068
	return snd_soc_register_card(card);
F
Frank Mandarino 已提交
2069 2070
}

2071
static int soc_cleanup_card_resources(struct snd_soc_card *card)
F
Frank Mandarino 已提交
2072
{
2073
	struct snd_soc_pcm_runtime *rtd;
F
Frank Mandarino 已提交
2074

2075
	/* make sure any delayed work runs */
2076
	list_for_each_entry(rtd, &card->rtd_list, list)
2077
		flush_delayed_work(&rtd->delayed_work);
2078

2079
	/* remove and free each DAI */
2080
	soc_remove_dai_links(card);
2081
	soc_remove_pcm_runtimes(card);
2082

2083 2084 2085
	/* remove auxiliary devices */
	soc_remove_aux_devices(card);

2086
	snd_soc_dapm_free(&card->dapm);
2087
	soc_cleanup_card_debugfs(card);
2088

2089 2090
	/* remove the card */
	if (card->remove)
2091
		card->remove(card);
2092

2093 2094 2095 2096 2097 2098 2099 2100 2101
	snd_card_free(card->snd_card);
	return 0;

}

/* removes a socdev */
static int soc_remove(struct platform_device *pdev)
{
	struct snd_soc_card *card = platform_get_drvdata(pdev);
F
Frank Mandarino 已提交
2102

M
Mark Brown 已提交
2103
	snd_soc_unregister_card(card);
F
Frank Mandarino 已提交
2104 2105 2106
	return 0;
}

2107
int snd_soc_poweroff(struct device *dev)
M
Mark Brown 已提交
2108
{
2109
	struct snd_soc_card *card = dev_get_drvdata(dev);
2110
	struct snd_soc_pcm_runtime *rtd;
M
Mark Brown 已提交
2111 2112

	if (!card->instantiated)
M
Mark Brown 已提交
2113
		return 0;
M
Mark Brown 已提交
2114 2115 2116

	/* Flush out pmdown_time work - we actually do want to run it
	 * now, we're shutting down so no imminent restart. */
2117
	list_for_each_entry(rtd, &card->rtd_list, list)
2118
		flush_delayed_work(&rtd->delayed_work);
M
Mark Brown 已提交
2119

2120
	snd_soc_dapm_shutdown(card);
M
Mark Brown 已提交
2121

2122
	/* deactivate pins to sleep state */
2123
	list_for_each_entry(rtd, &card->rtd_list, list) {
2124
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2125
		int i;
2126

2127
		pinctrl_pm_select_sleep_state(cpu_dai->dev);
2128 2129
		for (i = 0; i < rtd->num_codecs; i++) {
			struct snd_soc_dai *codec_dai = rtd->codec_dais[i];
2130 2131
			pinctrl_pm_select_sleep_state(codec_dai->dev);
		}
2132 2133
	}

M
Mark Brown 已提交
2134
	return 0;
M
Mark Brown 已提交
2135
}
2136
EXPORT_SYMBOL_GPL(snd_soc_poweroff);
M
Mark Brown 已提交
2137

2138
const struct dev_pm_ops snd_soc_pm_ops = {
2139 2140 2141 2142
	.suspend = snd_soc_suspend,
	.resume = snd_soc_resume,
	.freeze = snd_soc_suspend,
	.thaw = snd_soc_resume,
2143
	.poweroff = snd_soc_poweroff,
2144
	.restore = snd_soc_resume,
M
Mark Brown 已提交
2145
};
2146
EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
M
Mark Brown 已提交
2147

F
Frank Mandarino 已提交
2148 2149 2150 2151
/* ASoC platform driver */
static struct platform_driver soc_driver = {
	.driver		= {
		.name		= "soc-audio",
2152
		.pm		= &snd_soc_pm_ops,
F
Frank Mandarino 已提交
2153 2154 2155 2156 2157 2158 2159 2160 2161
	},
	.probe		= soc_probe,
	.remove		= soc_remove,
};

/**
 * snd_soc_cnew - create new control
 * @_template: control template
 * @data: control private data
M
Mark Brown 已提交
2162
 * @long_name: control long name
2163
 * @prefix: control name prefix
F
Frank Mandarino 已提交
2164 2165 2166 2167 2168 2169
 *
 * Create a new mixer control from a template control.
 *
 * Returns 0 for success, else error.
 */
struct snd_kcontrol *snd_soc_cnew(const struct snd_kcontrol_new *_template,
2170
				  void *data, const char *long_name,
2171
				  const char *prefix)
F
Frank Mandarino 已提交
2172 2173
{
	struct snd_kcontrol_new template;
2174 2175
	struct snd_kcontrol *kcontrol;
	char *name = NULL;
F
Frank Mandarino 已提交
2176 2177 2178 2179

	memcpy(&template, _template, sizeof(template));
	template.index = 0;

2180 2181 2182 2183
	if (!long_name)
		long_name = template.name;

	if (prefix) {
2184
		name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197
		if (!name)
			return NULL;

		template.name = name;
	} else {
		template.name = long_name;
	}

	kcontrol = snd_ctl_new1(&template, data);

	kfree(name);

	return kcontrol;
F
Frank Mandarino 已提交
2198 2199 2200
}
EXPORT_SYMBOL_GPL(snd_soc_cnew);

2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211
static int snd_soc_add_controls(struct snd_card *card, struct device *dev,
	const struct snd_kcontrol_new *controls, int num_controls,
	const char *prefix, void *data)
{
	int err, i;

	for (i = 0; i < num_controls; i++) {
		const struct snd_kcontrol_new *control = &controls[i];
		err = snd_ctl_add(card, snd_soc_cnew(control, data,
						     control->name, prefix));
		if (err < 0) {
2212 2213
			dev_err(dev, "ASoC: Failed to add %s: %d\n",
				control->name, err);
2214 2215 2216 2217 2218 2219 2220
			return err;
		}
	}

	return 0;
}

2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236
struct snd_kcontrol *snd_soc_card_get_kcontrol(struct snd_soc_card *soc_card,
					       const char *name)
{
	struct snd_card *card = soc_card->snd_card;
	struct snd_kcontrol *kctl;

	if (unlikely(!name))
		return NULL;

	list_for_each_entry(kctl, &card->controls, list)
		if (!strncmp(kctl->id.name, name, sizeof(kctl->id.name)))
			return kctl;
	return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_card_get_kcontrol);

2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255
/**
 * snd_soc_add_component_controls - Add an array of controls to a component.
 *
 * @component: Component to add controls to
 * @controls: Array of controls to add
 * @num_controls: Number of elements in the array
 *
 * Return: 0 for success, else error.
 */
int snd_soc_add_component_controls(struct snd_soc_component *component,
	const struct snd_kcontrol_new *controls, unsigned int num_controls)
{
	struct snd_card *card = component->card->snd_card;

	return snd_soc_add_controls(card, component->dev, controls,
			num_controls, component->name_prefix, component);
}
EXPORT_SYMBOL_GPL(snd_soc_add_component_controls);

I
Ian Molton 已提交
2256
/**
2257 2258
 * snd_soc_add_codec_controls - add an array of controls to a codec.
 * Convenience function to add a list of controls. Many codecs were
I
Ian Molton 已提交
2259 2260 2261 2262 2263 2264 2265 2266
 * duplicating this code.
 *
 * @codec: codec to add controls to
 * @controls: array of controls to add
 * @num_controls: number of elements in the array
 *
 * Return 0 for success, else error.
 */
2267
int snd_soc_add_codec_controls(struct snd_soc_codec *codec,
2268
	const struct snd_kcontrol_new *controls, unsigned int num_controls)
I
Ian Molton 已提交
2269
{
2270 2271
	return snd_soc_add_component_controls(&codec->component, controls,
		num_controls);
I
Ian Molton 已提交
2272
}
2273
EXPORT_SYMBOL_GPL(snd_soc_add_codec_controls);
I
Ian Molton 已提交
2274

2275 2276
/**
 * snd_soc_add_platform_controls - add an array of controls to a platform.
2277
 * Convenience function to add a list of controls.
2278 2279 2280 2281 2282 2283 2284 2285
 *
 * @platform: platform to add controls to
 * @controls: array of controls to add
 * @num_controls: number of elements in the array
 *
 * Return 0 for success, else error.
 */
int snd_soc_add_platform_controls(struct snd_soc_platform *platform,
2286
	const struct snd_kcontrol_new *controls, unsigned int num_controls)
2287
{
2288 2289
	return snd_soc_add_component_controls(&platform->component, controls,
		num_controls);
2290 2291 2292
}
EXPORT_SYMBOL_GPL(snd_soc_add_platform_controls);

2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325
/**
 * snd_soc_add_card_controls - add an array of controls to a SoC card.
 * Convenience function to add a list of controls.
 *
 * @soc_card: SoC card to add controls to
 * @controls: array of controls to add
 * @num_controls: number of elements in the array
 *
 * Return 0 for success, else error.
 */
int snd_soc_add_card_controls(struct snd_soc_card *soc_card,
	const struct snd_kcontrol_new *controls, int num_controls)
{
	struct snd_card *card = soc_card->snd_card;

	return snd_soc_add_controls(card, soc_card->dev, controls, num_controls,
			NULL, soc_card);
}
EXPORT_SYMBOL_GPL(snd_soc_add_card_controls);

/**
 * snd_soc_add_dai_controls - add an array of controls to a DAI.
 * Convienience function to add a list of controls.
 *
 * @dai: DAI to add controls to
 * @controls: array of controls to add
 * @num_controls: number of elements in the array
 *
 * Return 0 for success, else error.
 */
int snd_soc_add_dai_controls(struct snd_soc_dai *dai,
	const struct snd_kcontrol_new *controls, int num_controls)
{
2326
	struct snd_card *card = dai->component->card->snd_card;
2327 2328 2329 2330 2331 2332

	return snd_soc_add_controls(card, dai->dev, controls, num_controls,
			NULL, dai);
}
EXPORT_SYMBOL_GPL(snd_soc_add_dai_controls);

2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344
/**
 * snd_soc_dai_set_sysclk - configure DAI system or master clock.
 * @dai: DAI
 * @clk_id: DAI specific clock ID
 * @freq: new clock frequency in Hz
 * @dir: new clock direction - input/output.
 *
 * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
 */
int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
	unsigned int freq, int dir)
{
2345 2346
	if (dai->driver && dai->driver->ops->set_sysclk)
		return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
2347
	else if (dai->codec && dai->codec->driver->set_sysclk)
2348
		return dai->codec->driver->set_sysclk(dai->codec, clk_id, 0,
2349
						      freq, dir);
2350
	else
2351
		return -ENOTSUPP;
2352 2353 2354
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);

2355 2356 2357 2358
/**
 * snd_soc_codec_set_sysclk - configure CODEC system or master clock.
 * @codec: CODEC
 * @clk_id: DAI specific clock ID
2359
 * @source: Source for the clock
2360 2361 2362 2363 2364 2365
 * @freq: new clock frequency in Hz
 * @dir: new clock direction - input/output.
 *
 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
 */
int snd_soc_codec_set_sysclk(struct snd_soc_codec *codec, int clk_id,
2366
			     int source, unsigned int freq, int dir)
2367 2368
{
	if (codec->driver->set_sysclk)
2369 2370
		return codec->driver->set_sysclk(codec, clk_id, source,
						 freq, dir);
2371
	else
2372
		return -ENOTSUPP;
2373 2374 2375
}
EXPORT_SYMBOL_GPL(snd_soc_codec_set_sysclk);

2376 2377 2378
/**
 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
 * @dai: DAI
M
Mark Brown 已提交
2379
 * @div_id: DAI specific clock divider ID
2380 2381 2382 2383 2384 2385 2386 2387 2388
 * @div: new clock divisor.
 *
 * Configures the clock dividers. This is used to derive the best DAI bit and
 * frame clocks from the system or master clock. It's best to set the DAI bit
 * and frame clocks as low as possible to save system power.
 */
int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
	int div_id, int div)
{
2389 2390
	if (dai->driver && dai->driver->ops->set_clkdiv)
		return dai->driver->ops->set_clkdiv(dai, div_id, div);
2391 2392 2393 2394 2395 2396 2397 2398 2399
	else
		return -EINVAL;
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);

/**
 * snd_soc_dai_set_pll - configure DAI PLL.
 * @dai: DAI
 * @pll_id: DAI specific PLL ID
2400
 * @source: DAI specific source for the PLL
2401 2402 2403 2404 2405
 * @freq_in: PLL input clock frequency in Hz
 * @freq_out: requested PLL output clock frequency in Hz
 *
 * Configures and enables PLL to generate output clock based on input clock.
 */
2406 2407
int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
	unsigned int freq_in, unsigned int freq_out)
2408
{
2409 2410
	if (dai->driver && dai->driver->ops->set_pll)
		return dai->driver->ops->set_pll(dai, pll_id, source,
2411
					 freq_in, freq_out);
2412 2413 2414
	else if (dai->codec && dai->codec->driver->set_pll)
		return dai->codec->driver->set_pll(dai->codec, pll_id, source,
						   freq_in, freq_out);
2415 2416 2417 2418 2419
	else
		return -EINVAL;
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);

2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440
/*
 * snd_soc_codec_set_pll - configure codec PLL.
 * @codec: CODEC
 * @pll_id: DAI specific PLL ID
 * @source: DAI specific source for the PLL
 * @freq_in: PLL input clock frequency in Hz
 * @freq_out: requested PLL output clock frequency in Hz
 *
 * Configures and enables PLL to generate output clock based on input clock.
 */
int snd_soc_codec_set_pll(struct snd_soc_codec *codec, int pll_id, int source,
			  unsigned int freq_in, unsigned int freq_out)
{
	if (codec->driver->set_pll)
		return codec->driver->set_pll(codec, pll_id, source,
					      freq_in, freq_out);
	else
		return -EINVAL;
}
EXPORT_SYMBOL_GPL(snd_soc_codec_set_pll);

2441 2442 2443
/**
 * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
 * @dai: DAI
2444
 * @ratio: Ratio of BCLK to Sample rate.
2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456
 *
 * Configures the DAI for a preset BCLK to sample rate ratio.
 */
int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
{
	if (dai->driver && dai->driver->ops->set_bclk_ratio)
		return dai->driver->ops->set_bclk_ratio(dai, ratio);
	else
		return -EINVAL;
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);

2457 2458 2459 2460 2461 2462 2463 2464 2465
/**
 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
 * @dai: DAI
 * @fmt: SND_SOC_DAIFMT_ format value.
 *
 * Configures the DAI hardware format and clocking.
 */
int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
{
2466
	if (dai->driver == NULL)
2467
		return -EINVAL;
2468 2469 2470
	if (dai->driver->ops->set_fmt == NULL)
		return -ENOTSUPP;
	return dai->driver->ops->set_fmt(dai, fmt);
2471 2472 2473
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);

2474
/**
2475
 * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
2476 2477 2478 2479 2480 2481
 * @slots: Number of slots in use.
 * @tx_mask: bitmask representing active TX slots.
 * @rx_mask: bitmask representing active RX slots.
 *
 * Generates the TDM tx and rx slot default masks for DAI.
 */
2482
static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497
					  unsigned int *tx_mask,
					  unsigned int *rx_mask)
{
	if (*tx_mask || *rx_mask)
		return 0;

	if (!slots)
		return -EINVAL;

	*tx_mask = (1 << slots) - 1;
	*rx_mask = (1 << slots) - 1;

	return 0;
}

2498
/**
2499 2500
 * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
 * @dai: The DAI to configure
2501 2502
 * @tx_mask: bitmask representing active TX slots.
 * @rx_mask: bitmask representing active RX slots.
2503
 * @slots: Number of slots in use.
2504
 * @slot_width: Width in bits for each slot.
2505
 *
2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519
 * This function configures the specified DAI for TDM operation. @slot contains
 * the total number of slots of the TDM stream and @slot_with the width of each
 * slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
 * active slots of the TDM stream for the specified DAI, i.e. which slots the
 * DAI should write to or read from. If a bit is set the corresponding slot is
 * active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
 * the first slot, bit 1 to the second slot and so on. The first active slot
 * maps to the first channel of the DAI, the second active slot to the second
 * channel and so on.
 *
 * TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
 * @rx_mask and @slot_width will be ignored.
 *
 * Returns 0 on success, a negative error code otherwise.
2520 2521
 */
int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
2522
	unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
2523
{
2524 2525
	if (dai->driver && dai->driver->ops->xlate_tdm_slot_mask)
		dai->driver->ops->xlate_tdm_slot_mask(slots,
2526 2527
						&tx_mask, &rx_mask);
	else
2528
		snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
2529

2530 2531 2532
	dai->tx_mask = tx_mask;
	dai->rx_mask = rx_mask;

2533 2534
	if (dai->driver && dai->driver->ops->set_tdm_slot)
		return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
2535
				slots, slot_width);
2536
	else
2537
		return -ENOTSUPP;
2538 2539 2540
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);

2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556
/**
 * snd_soc_dai_set_channel_map - configure DAI audio channel map
 * @dai: DAI
 * @tx_num: how many TX channels
 * @tx_slot: pointer to an array which imply the TX slot number channel
 *           0~num-1 uses
 * @rx_num: how many RX channels
 * @rx_slot: pointer to an array which imply the RX slot number channel
 *           0~num-1 uses
 *
 * configure the relationship between channel number and TDM slot number.
 */
int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
	unsigned int tx_num, unsigned int *tx_slot,
	unsigned int rx_num, unsigned int *rx_slot)
{
2557 2558
	if (dai->driver && dai->driver->ops->set_channel_map)
		return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
2559 2560 2561 2562 2563 2564
			rx_num, rx_slot);
	else
		return -EINVAL;
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);

2565 2566 2567 2568 2569 2570 2571 2572 2573
/**
 * snd_soc_dai_set_tristate - configure DAI system or master clock.
 * @dai: DAI
 * @tristate: tristate enable
 *
 * Tristates the DAI so that others can use it.
 */
int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
{
2574 2575
	if (dai->driver && dai->driver->ops->set_tristate)
		return dai->driver->ops->set_tristate(dai, tristate);
2576 2577 2578 2579 2580 2581 2582 2583 2584
	else
		return -EINVAL;
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);

/**
 * snd_soc_dai_digital_mute - configure DAI system or master clock.
 * @dai: DAI
 * @mute: mute enable
2585
 * @direction: stream to mute
2586 2587 2588
 *
 * Mutes the DAI DAC.
 */
2589 2590
int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
			     int direction)
2591
{
2592 2593 2594 2595 2596 2597 2598
	if (!dai->driver)
		return -ENOTSUPP;

	if (dai->driver->ops->mute_stream)
		return dai->driver->ops->mute_stream(dai, mute, direction);
	else if (direction == SNDRV_PCM_STREAM_PLAYBACK &&
		 dai->driver->ops->digital_mute)
2599
		return dai->driver->ops->digital_mute(dai, mute);
2600
	else
2601
		return -ENOTSUPP;
2602 2603 2604
}
EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);

M
Mark Brown 已提交
2605 2606 2607
/**
 * snd_soc_register_card - Register a card with the ASoC core
 *
M
Mark Brown 已提交
2608
 * @card: Card to register
M
Mark Brown 已提交
2609 2610
 *
 */
2611
int snd_soc_register_card(struct snd_soc_card *card)
M
Mark Brown 已提交
2612
{
2613
	int i, ret;
2614
	struct snd_soc_pcm_runtime *rtd;
2615

M
Mark Brown 已提交
2616 2617 2618
	if (!card->name || !card->dev)
		return -EINVAL;

2619 2620 2621
	for (i = 0; i < card->num_links; i++) {
		struct snd_soc_dai_link *link = &card->dai_link[i];

2622
		ret = soc_init_dai_link(card, link);
2623
		if (ret) {
2624
			dev_err(card->dev, "ASoC: failed to init link %s\n",
2625
				link->name);
2626
			return ret;
2627 2628 2629
		}
	}

M
Mark Brown 已提交
2630 2631
	dev_set_drvdata(card->dev, card);

2632 2633
	snd_soc_initialize_card_lists(card);

2634 2635 2636
	INIT_LIST_HEAD(&card->dai_link_list);
	card->num_dai_links = 0;

2637 2638 2639
	INIT_LIST_HEAD(&card->rtd_list);
	card->num_rtd = 0;

2640
	INIT_LIST_HEAD(&card->dapm_dirty);
2641
	INIT_LIST_HEAD(&card->dobj_list);
M
Mark Brown 已提交
2642
	card->instantiated = 0;
2643
	mutex_init(&card->mutex);
2644
	mutex_init(&card->dapm_mutex);
M
Mark Brown 已提交
2645

2646 2647
	ret = snd_soc_instantiate_card(card);
	if (ret != 0)
2648
		return ret;
M
Mark Brown 已提交
2649

2650
	/* deactivate pins to sleep state */
2651
	list_for_each_entry(rtd, &card->rtd_list, list)  {
2652 2653 2654 2655 2656 2657 2658 2659 2660
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
		int j;

		for (j = 0; j < rtd->num_codecs; j++) {
			struct snd_soc_dai *codec_dai = rtd->codec_dais[j];
			if (!codec_dai->active)
				pinctrl_pm_select_sleep_state(codec_dai->dev);
		}

2661 2662 2663 2664
		if (!cpu_dai->active)
			pinctrl_pm_select_sleep_state(cpu_dai->dev);
	}

2665
	return ret;
M
Mark Brown 已提交
2666
}
2667
EXPORT_SYMBOL_GPL(snd_soc_register_card);
M
Mark Brown 已提交
2668 2669 2670 2671

/**
 * snd_soc_unregister_card - Unregister a card with the ASoC core
 *
M
Mark Brown 已提交
2672
 * @card: Card to unregister
M
Mark Brown 已提交
2673 2674
 *
 */
2675
int snd_soc_unregister_card(struct snd_soc_card *card)
M
Mark Brown 已提交
2676
{
2677 2678
	if (card->instantiated) {
		card->instantiated = false;
2679
		snd_soc_dapm_shutdown(card);
2680
		soc_cleanup_card_resources(card);
2681
		dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
2682
	}
M
Mark Brown 已提交
2683 2684 2685

	return 0;
}
2686
EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
M
Mark Brown 已提交
2687

2688 2689 2690 2691
/*
 * Simplify DAI link configuration by removing ".-1" from device names
 * and sanitizing names.
 */
2692
static char *fmt_single_name(struct device *dev, int *id)
2693 2694 2695 2696 2697 2698 2699
{
	char *found, name[NAME_SIZE];
	int id1, id2;

	if (dev_name(dev) == NULL)
		return NULL;

2700
	strlcpy(name, dev_name(dev), NAME_SIZE);
2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718

	/* are we a "%s.%d" name (platform and SPI components) */
	found = strstr(name, dev->driver->name);
	if (found) {
		/* get ID */
		if (sscanf(&found[strlen(dev->driver->name)], ".%d", id) == 1) {

			/* discard ID from name if ID == -1 */
			if (*id == -1)
				found[strlen(dev->driver->name)] = '\0';
		}

	} else {
		/* I2C component devices are named "bus-addr"  */
		if (sscanf(name, "%x-%x", &id1, &id2) == 2) {
			char tmp[NAME_SIZE];

			/* create unique ID number from I2C addr and bus */
2719
			*id = ((id1 & 0xffff) << 16) + id2;
2720 2721 2722

			/* sanitize component name for DAI link creation */
			snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
2723
			strlcpy(name, tmp, NAME_SIZE);
2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738
		} else
			*id = 0;
	}

	return kstrdup(name, GFP_KERNEL);
}

/*
 * Simplify DAI link naming for single devices with multiple DAIs by removing
 * any ".-1" and using the DAI name (instead of device name).
 */
static inline char *fmt_multiple_name(struct device *dev,
		struct snd_soc_dai_driver *dai_drv)
{
	if (dai_drv->name == NULL) {
2739 2740 2741
		dev_err(dev,
			"ASoC: error - multiple DAI %s registered with no name\n",
			dev_name(dev));
2742 2743 2744 2745 2746 2747
		return NULL;
	}

	return kstrdup(dai_drv->name, GFP_KERNEL);
}

M
Mark Brown 已提交
2748
/**
2749
 * snd_soc_unregister_dai - Unregister DAIs from the ASoC core
M
Mark Brown 已提交
2750
 *
2751
 * @component: The component for which the DAIs should be unregistered
M
Mark Brown 已提交
2752
 */
2753
static void snd_soc_unregister_dais(struct snd_soc_component *component)
M
Mark Brown 已提交
2754
{
L
Lars-Peter Clausen 已提交
2755
	struct snd_soc_dai *dai, *_dai;
M
Mark Brown 已提交
2756

L
Lars-Peter Clausen 已提交
2757
	list_for_each_entry_safe(dai, _dai, &component->dai_list, list) {
2758 2759
		dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",
			dai->name);
L
Lars-Peter Clausen 已提交
2760
		list_del(&dai->list);
2761
		kfree(dai->name);
2762 2763
		kfree(dai);
	}
M
Mark Brown 已提交
2764 2765
}

2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815
/* Create a DAI and add it to the component's DAI list */
static struct snd_soc_dai *soc_add_dai(struct snd_soc_component *component,
	struct snd_soc_dai_driver *dai_drv,
	bool legacy_dai_naming)
{
	struct device *dev = component->dev;
	struct snd_soc_dai *dai;

	dev_dbg(dev, "ASoC: dynamically register DAI %s\n", dev_name(dev));

	dai = kzalloc(sizeof(struct snd_soc_dai), GFP_KERNEL);
	if (dai == NULL)
		return NULL;

	/*
	 * Back in the old days when we still had component-less DAIs,
	 * instead of having a static name, component-less DAIs would
	 * inherit the name of the parent device so it is possible to
	 * register multiple instances of the DAI. We still need to keep
	 * the same naming style even though those DAIs are not
	 * component-less anymore.
	 */
	if (legacy_dai_naming &&
	   (dai_drv->id == 0 || dai_drv->name == NULL)) {
		dai->name = fmt_single_name(dev, &dai->id);
	} else {
		dai->name = fmt_multiple_name(dev, dai_drv);
		if (dai_drv->id)
			dai->id = dai_drv->id;
		else
			dai->id = component->num_dai;
	}
	if (dai->name == NULL) {
		kfree(dai);
		return NULL;
	}

	dai->component = component;
	dai->dev = dev;
	dai->driver = dai_drv;
	if (!dai->driver->ops)
		dai->driver->ops = &null_dai_ops;

	list_add(&dai->list, &component->dai_list);
	component->num_dai++;

	dev_dbg(dev, "ASoC: Registered DAI '%s'\n", dai->name);
	return dai;
}

M
Mark Brown 已提交
2816
/**
2817
 * snd_soc_register_dais - Register a DAI with the ASoC core
M
Mark Brown 已提交
2818
 *
2819 2820
 * @component: The component the DAIs are registered for
 * @dai_drv: DAI driver to use for the DAIs
M
Mark Brown 已提交
2821
 * @count: Number of DAIs
2822 2823
 * @legacy_dai_naming: Use the legacy naming scheme and let the DAI inherit the
 *                     parent's name.
M
Mark Brown 已提交
2824
 */
2825
static int snd_soc_register_dais(struct snd_soc_component *component,
2826 2827
	struct snd_soc_dai_driver *dai_drv, size_t count,
	bool legacy_dai_naming)
M
Mark Brown 已提交
2828
{
2829
	struct device *dev = component->dev;
2830
	struct snd_soc_dai *dai;
2831 2832
	unsigned int i;
	int ret;
2833

2834
	dev_dbg(dev, "ASoC: dai register %s #%Zu\n", dev_name(dev), count);
M
Mark Brown 已提交
2835

2836 2837
	component->dai_drv = dai_drv;

M
Mark Brown 已提交
2838
	for (i = 0; i < count; i++) {
2839

2840 2841
		dai = soc_add_dai(component, dai_drv + i,
				count == 1 && legacy_dai_naming);
2842 2843 2844 2845
		if (dai == NULL) {
			ret = -ENOMEM;
			goto err;
		}
M
Mark Brown 已提交
2846
	}
2847

M
Mark Brown 已提交
2848
	return 0;
2849

M
Mark Brown 已提交
2850
err:
2851
	snd_soc_unregister_dais(component);
2852

M
Mark Brown 已提交
2853 2854 2855
	return ret;
}

2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872
/**
 * snd_soc_register_dai - Register a DAI dynamically & create its widgets
 *
 * @component: The component the DAIs are registered for
 * @dai_drv: DAI driver to use for the DAI
 *
 * Topology can use this API to register DAIs when probing a component.
 * These DAIs's widgets will be freed in the card cleanup and the DAIs
 * will be freed in the component cleanup.
 */
int snd_soc_register_dai(struct snd_soc_component *component,
	struct snd_soc_dai_driver *dai_drv)
{
	struct snd_soc_dapm_context *dapm =
		snd_soc_component_get_dapm(component);
	struct snd_soc_dai *dai;
	int ret;
2873

2874 2875 2876 2877
	if (dai_drv->dobj.type != SND_SOC_DOBJ_PCM) {
		dev_err(component->dev, "Invalid dai type %d\n",
			dai_drv->dobj.type);
		return -EINVAL;
M
Mark Brown 已提交
2878 2879
	}

2880 2881 2882 2883
	lockdep_assert_held(&client_mutex);
	dai = soc_add_dai(component, dai_drv, false);
	if (!dai)
		return -ENOMEM;
M
Mark Brown 已提交
2884

2885 2886 2887 2888 2889 2890 2891 2892
	/* Create the DAI widgets here. After adding DAIs, topology may
	 * also add routes that need these widgets as source or sink.
	 */
	ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
	if (ret != 0) {
		dev_err(component->dev,
			"Failed to create DAI widgets %d\n", ret);
	}
M
Mark Brown 已提交
2893 2894 2895

	return ret;
}
2896
EXPORT_SYMBOL_GPL(snd_soc_register_dai);
M
Mark Brown 已提交
2897

2898 2899
static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context *dapm,
	enum snd_soc_dapm_type type, int subseq)
2900
{
2901
	struct snd_soc_component *component = dapm->component;
2902

2903 2904
	component->driver->seq_notifier(component, type, subseq);
}
2905

2906 2907 2908 2909
static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,
	int event)
{
	struct snd_soc_component *component = dapm->component;
2910

2911 2912
	return component->driver->stream_event(component, event);
}
2913

2914 2915
static int snd_soc_component_initialize(struct snd_soc_component *component,
	const struct snd_soc_component_driver *driver, struct device *dev)
2916
{
2917 2918
	struct snd_soc_dapm_context *dapm;

2919 2920 2921
	component->name = fmt_single_name(dev, &component->id);
	if (!component->name) {
		dev_err(dev, "ASoC: Failed to allocate name\n");
2922 2923 2924
		return -ENOMEM;
	}

2925 2926
	component->dev = dev;
	component->driver = driver;
2927 2928
	component->probe = component->driver->probe;
	component->remove = component->driver->remove;
2929

2930
	dapm = &component->dapm;
2931 2932 2933
	dapm->dev = dev;
	dapm->component = component;
	dapm->bias_level = SND_SOC_BIAS_OFF;
2934
	dapm->idle_bias_off = true;
2935 2936 2937 2938
	if (driver->seq_notifier)
		dapm->seq_notifier = snd_soc_component_seq_notifier;
	if (driver->stream_event)
		dapm->stream_event = snd_soc_component_stream_event;
2939

2940 2941 2942 2943 2944 2945 2946
	component->controls = driver->controls;
	component->num_controls = driver->num_controls;
	component->dapm_widgets = driver->dapm_widgets;
	component->num_dapm_widgets = driver->num_dapm_widgets;
	component->dapm_routes = driver->dapm_routes;
	component->num_dapm_routes = driver->num_dapm_routes;

2947 2948
	INIT_LIST_HEAD(&component->dai_list);
	mutex_init(&component->io_mutex);
2949

2950 2951
	return 0;
}
2952

2953
static void snd_soc_component_setup_regmap(struct snd_soc_component *component)
2954
{
2955 2956 2957 2958 2959 2960 2961
	int val_bytes = regmap_get_val_bytes(component->regmap);

	/* Errors are legitimate for non-integer byte multiples */
	if (val_bytes > 0)
		component->val_bytes = val_bytes;
}

2962 2963
#ifdef CONFIG_REGMAP

2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978
/**
 * snd_soc_component_init_regmap() - Initialize regmap instance for the component
 * @component: The component for which to initialize the regmap instance
 * @regmap: The regmap instance that should be used by the component
 *
 * This function allows deferred assignment of the regmap instance that is
 * associated with the component. Only use this if the regmap instance is not
 * yet ready when the component is registered. The function must also be called
 * before the first IO attempt of the component.
 */
void snd_soc_component_init_regmap(struct snd_soc_component *component,
	struct regmap *regmap)
{
	component->regmap = regmap;
	snd_soc_component_setup_regmap(component);
2979
}
2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997
EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap);

/**
 * snd_soc_component_exit_regmap() - De-initialize regmap instance for the component
 * @component: The component for which to de-initialize the regmap instance
 *
 * Calls regmap_exit() on the regmap instance associated to the component and
 * removes the regmap instance from the component.
 *
 * This function should only be used if snd_soc_component_init_regmap() was used
 * to initialize the regmap instance.
 */
void snd_soc_component_exit_regmap(struct snd_soc_component *component)
{
	regmap_exit(component->regmap);
	component->regmap = NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap);
2998

2999
#endif
3000

3001 3002
static void snd_soc_component_add_unlocked(struct snd_soc_component *component)
{
3003 3004 3005 3006 3007 3008
	if (!component->write && !component->read) {
		if (!component->regmap)
			component->regmap = dev_get_regmap(component->dev, NULL);
		if (component->regmap)
			snd_soc_component_setup_regmap(component);
	}
3009

3010
	list_add(&component->list, &component_list);
3011
	INIT_LIST_HEAD(&component->dobj_list);
3012
}
3013

3014 3015
static void snd_soc_component_add(struct snd_soc_component *component)
{
3016
	mutex_lock(&client_mutex);
3017
	snd_soc_component_add_unlocked(component);
3018
	mutex_unlock(&client_mutex);
3019
}
3020

3021 3022 3023 3024 3025
static void snd_soc_component_cleanup(struct snd_soc_component *component)
{
	snd_soc_unregister_dais(component);
	kfree(component->name);
}
3026

3027 3028 3029 3030
static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
{
	list_del(&component->list);
}
3031 3032 3033 3034 3035 3036 3037

int snd_soc_register_component(struct device *dev,
			       const struct snd_soc_component_driver *cmpnt_drv,
			       struct snd_soc_dai_driver *dai_drv,
			       int num_dai)
{
	struct snd_soc_component *cmpnt;
3038
	int ret;
3039

3040
	cmpnt = kzalloc(sizeof(*cmpnt), GFP_KERNEL);
3041 3042 3043 3044 3045
	if (!cmpnt) {
		dev_err(dev, "ASoC: Failed to allocate memory\n");
		return -ENOMEM;
	}

3046 3047 3048 3049
	ret = snd_soc_component_initialize(cmpnt, cmpnt_drv, dev);
	if (ret)
		goto err_free;

3050
	cmpnt->ignore_pmdown_time = true;
3051
	cmpnt->registered_as_component = true;
3052

3053 3054
	ret = snd_soc_register_dais(cmpnt, dai_drv, num_dai, true);
	if (ret < 0) {
3055
		dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
3056 3057
		goto err_cleanup;
	}
3058

3059
	snd_soc_component_add(cmpnt);
3060

3061
	return 0;
3062

3063 3064 3065 3066 3067
err_cleanup:
	snd_soc_component_cleanup(cmpnt);
err_free:
	kfree(cmpnt);
	return ret;
3068
}
3069
EXPORT_SYMBOL_GPL(snd_soc_register_component);
3070

3071 3072 3073
/**
 * snd_soc_unregister_component - Unregister a component from the ASoC core
 *
3074
 * @dev: The device to unregister
3075 3076 3077 3078 3079
 */
void snd_soc_unregister_component(struct device *dev)
{
	struct snd_soc_component *cmpnt;

3080
	mutex_lock(&client_mutex);
3081
	list_for_each_entry(cmpnt, &component_list, list) {
3082
		if (dev == cmpnt->dev && cmpnt->registered_as_component)
3083 3084
			goto found;
	}
3085
	mutex_unlock(&client_mutex);
3086 3087 3088
	return;

found:
3089
	snd_soc_tplg_component_remove(cmpnt, SND_SOC_TPLG_INDEX_ALL);
3090 3091
	snd_soc_component_del_unlocked(cmpnt);
	mutex_unlock(&client_mutex);
3092 3093
	snd_soc_component_cleanup(cmpnt);
	kfree(cmpnt);
3094 3095 3096
}
EXPORT_SYMBOL_GPL(snd_soc_unregister_component);

3097
static int snd_soc_platform_drv_probe(struct snd_soc_component *component)
3098 3099
{
	struct snd_soc_platform *platform = snd_soc_component_to_platform(component);
3100

3101
	return platform->driver->probe(platform);
3102 3103
}

3104
static void snd_soc_platform_drv_remove(struct snd_soc_component *component)
3105 3106 3107
{
	struct snd_soc_platform *platform = snd_soc_component_to_platform(component);

3108
	platform->driver->remove(platform);
3109 3110
}

M
Mark Brown 已提交
3111
/**
3112 3113 3114
 * snd_soc_add_platform - Add a platform to the ASoC core
 * @dev: The parent device for the platform
 * @platform: The platform to add
3115
 * @platform_drv: The driver for the platform
M
Mark Brown 已提交
3116
 */
3117
int snd_soc_add_platform(struct device *dev, struct snd_soc_platform *platform,
3118
		const struct snd_soc_platform_driver *platform_drv)
M
Mark Brown 已提交
3119
{
3120 3121
	int ret;

3122 3123 3124 3125
	ret = snd_soc_component_initialize(&platform->component,
			&platform_drv->component_driver, dev);
	if (ret)
		return ret;
M
Mark Brown 已提交
3126

3127 3128
	platform->dev = dev;
	platform->driver = platform_drv;
3129 3130 3131 3132 3133

	if (platform_drv->probe)
		platform->component.probe = snd_soc_platform_drv_probe;
	if (platform_drv->remove)
		platform->component.remove = snd_soc_platform_drv_remove;
M
Mark Brown 已提交
3134

3135 3136 3137
#ifdef CONFIG_DEBUG_FS
	platform->component.debugfs_prefix = "platform";
#endif
M
Mark Brown 已提交
3138 3139

	mutex_lock(&client_mutex);
3140
	snd_soc_component_add_unlocked(&platform->component);
M
Mark Brown 已提交
3141 3142 3143
	list_add(&platform->list, &platform_list);
	mutex_unlock(&client_mutex);

3144 3145
	dev_dbg(dev, "ASoC: Registered platform '%s'\n",
		platform->component.name);
M
Mark Brown 已提交
3146 3147 3148

	return 0;
}
3149
EXPORT_SYMBOL_GPL(snd_soc_add_platform);
M
Mark Brown 已提交
3150 3151

/**
3152
 * snd_soc_register_platform - Register a platform with the ASoC core
M
Mark Brown 已提交
3153
 *
3154 3155
 * @dev: The device for the platform
 * @platform_drv: The driver for the platform
M
Mark Brown 已提交
3156
 */
3157 3158
int snd_soc_register_platform(struct device *dev,
		const struct snd_soc_platform_driver *platform_drv)
M
Mark Brown 已提交
3159
{
3160
	struct snd_soc_platform *platform;
3161
	int ret;
3162

3163
	dev_dbg(dev, "ASoC: platform register %s\n", dev_name(dev));
3164

3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182
	platform = kzalloc(sizeof(struct snd_soc_platform), GFP_KERNEL);
	if (platform == NULL)
		return -ENOMEM;

	ret = snd_soc_add_platform(dev, platform, platform_drv);
	if (ret)
		kfree(platform);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_register_platform);

/**
 * snd_soc_remove_platform - Remove a platform from the ASoC core
 * @platform: the platform to remove
 */
void snd_soc_remove_platform(struct snd_soc_platform *platform)
{
3183

M
Mark Brown 已提交
3184 3185
	mutex_lock(&client_mutex);
	list_del(&platform->list);
3186
	snd_soc_component_del_unlocked(&platform->component);
M
Mark Brown 已提交
3187 3188
	mutex_unlock(&client_mutex);

3189
	dev_dbg(platform->dev, "ASoC: Unregistered platform '%s'\n",
3190
		platform->component.name);
3191 3192

	snd_soc_component_cleanup(&platform->component);
3193 3194 3195 3196 3197 3198 3199
}
EXPORT_SYMBOL_GPL(snd_soc_remove_platform);

struct snd_soc_platform *snd_soc_lookup_platform(struct device *dev)
{
	struct snd_soc_platform *platform;

3200
	mutex_lock(&client_mutex);
3201
	list_for_each_entry(platform, &platform_list, list) {
3202 3203
		if (dev == platform->dev) {
			mutex_unlock(&client_mutex);
3204
			return platform;
3205
		}
3206
	}
3207
	mutex_unlock(&client_mutex);
3208 3209 3210 3211 3212 3213 3214 3215

	return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_lookup_platform);

/**
 * snd_soc_unregister_platform - Unregister a platform from the ASoC core
 *
3216
 * @dev: platform to unregister
3217 3218 3219 3220 3221 3222 3223 3224 3225 3226
 */
void snd_soc_unregister_platform(struct device *dev)
{
	struct snd_soc_platform *platform;

	platform = snd_soc_lookup_platform(dev);
	if (!platform)
		return;

	snd_soc_remove_platform(platform);
3227
	kfree(platform);
M
Mark Brown 已提交
3228 3229 3230
}
EXPORT_SYMBOL_GPL(snd_soc_unregister_platform);

3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263
static u64 codec_format_map[] = {
	SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE,
	SNDRV_PCM_FMTBIT_U16_LE | SNDRV_PCM_FMTBIT_U16_BE,
	SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S24_BE,
	SNDRV_PCM_FMTBIT_U24_LE | SNDRV_PCM_FMTBIT_U24_BE,
	SNDRV_PCM_FMTBIT_S32_LE | SNDRV_PCM_FMTBIT_S32_BE,
	SNDRV_PCM_FMTBIT_U32_LE | SNDRV_PCM_FMTBIT_U32_BE,
	SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
	SNDRV_PCM_FMTBIT_U24_3LE | SNDRV_PCM_FMTBIT_U24_3BE,
	SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S20_3BE,
	SNDRV_PCM_FMTBIT_U20_3LE | SNDRV_PCM_FMTBIT_U20_3BE,
	SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S18_3BE,
	SNDRV_PCM_FMTBIT_U18_3LE | SNDRV_PCM_FMTBIT_U18_3BE,
	SNDRV_PCM_FMTBIT_FLOAT_LE | SNDRV_PCM_FMTBIT_FLOAT_BE,
	SNDRV_PCM_FMTBIT_FLOAT64_LE | SNDRV_PCM_FMTBIT_FLOAT64_BE,
	SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE
	| SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_BE,
};

/* Fix up the DAI formats for endianness: codecs don't actually see
 * the endianness of the data but we're using the CPU format
 * definitions which do need to include endianness so we ensure that
 * codec DAIs always have both big and little endian variants set.
 */
static void fixup_codec_formats(struct snd_soc_pcm_stream *stream)
{
	int i;

	for (i = 0; i < ARRAY_SIZE(codec_format_map); i++)
		if (stream->formats & codec_format_map[i])
			stream->formats |= codec_format_map[i];
}

3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277
static int snd_soc_codec_drv_probe(struct snd_soc_component *component)
{
	struct snd_soc_codec *codec = snd_soc_component_to_codec(component);

	return codec->driver->probe(codec);
}

static void snd_soc_codec_drv_remove(struct snd_soc_component *component)
{
	struct snd_soc_codec *codec = snd_soc_component_to_codec(component);

	codec->driver->remove(codec);
}

3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295
static int snd_soc_codec_drv_write(struct snd_soc_component *component,
	unsigned int reg, unsigned int val)
{
	struct snd_soc_codec *codec = snd_soc_component_to_codec(component);

	return codec->driver->write(codec, reg, val);
}

static int snd_soc_codec_drv_read(struct snd_soc_component *component,
	unsigned int reg, unsigned int *val)
{
	struct snd_soc_codec *codec = snd_soc_component_to_codec(component);

	*val = codec->driver->read(codec, reg);

	return 0;
}

3296 3297 3298 3299 3300 3301 3302 3303
static int snd_soc_codec_set_bias_level(struct snd_soc_dapm_context *dapm,
	enum snd_soc_bias_level level)
{
	struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);

	return codec->driver->set_bias_level(codec, level);
}

M
Mark Brown 已提交
3304 3305 3306
/**
 * snd_soc_register_codec - Register a codec with the ASoC core
 *
3307 3308 3309 3310
 * @dev: The parent device for this codec
 * @codec_drv: Codec driver
 * @dai_drv: The associated DAI driver
 * @num_dai: Number of DAIs
M
Mark Brown 已提交
3311
 */
3312
int snd_soc_register_codec(struct device *dev,
3313 3314 3315
			   const struct snd_soc_codec_driver *codec_drv,
			   struct snd_soc_dai_driver *dai_drv,
			   int num_dai)
M
Mark Brown 已提交
3316
{
3317
	struct snd_soc_dapm_context *dapm;
3318
	struct snd_soc_codec *codec;
3319
	struct snd_soc_dai *dai;
3320
	int ret, i;
3321

3322 3323 3324 3325 3326
	dev_dbg(dev, "codec register %s\n", dev_name(dev));

	codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
	if (codec == NULL)
		return -ENOMEM;
M
Mark Brown 已提交
3327

3328
	codec->component.codec = codec;
3329

3330 3331 3332 3333
	ret = snd_soc_component_initialize(&codec->component,
			&codec_drv->component_driver, dev);
	if (ret)
		goto err_free;
3334

3335 3336 3337 3338
	if (codec_drv->probe)
		codec->component.probe = snd_soc_codec_drv_probe;
	if (codec_drv->remove)
		codec->component.remove = snd_soc_codec_drv_remove;
3339 3340 3341 3342
	if (codec_drv->write)
		codec->component.write = snd_soc_codec_drv_write;
	if (codec_drv->read)
		codec->component.read = snd_soc_codec_drv_read;
3343
	codec->component.ignore_pmdown_time = codec_drv->ignore_pmdown_time;
3344 3345 3346 3347

	dapm = snd_soc_codec_get_dapm(codec);
	dapm->idle_bias_off = codec_drv->idle_bias_off;
	dapm->suspend_bias_off = codec_drv->suspend_bias_off;
3348
	if (codec_drv->seq_notifier)
3349
		dapm->seq_notifier = codec_drv->seq_notifier;
3350
	if (codec_drv->set_bias_level)
3351
		dapm->set_bias_level = snd_soc_codec_set_bias_level;
3352 3353
	codec->dev = dev;
	codec->driver = codec_drv;
3354
	codec->component.val_bytes = codec_drv->reg_word_size;
L
Liam Girdwood 已提交
3355

3356 3357 3358 3359 3360
#ifdef CONFIG_DEBUG_FS
	codec->component.init_debugfs = soc_init_codec_debugfs;
	codec->component.debugfs_prefix = "codec";
#endif

3361 3362
	if (codec_drv->get_regmap)
		codec->component.regmap = codec_drv->get_regmap(dev);
3363

3364 3365 3366 3367 3368
	for (i = 0; i < num_dai; i++) {
		fixup_codec_formats(&dai_drv[i].playback);
		fixup_codec_formats(&dai_drv[i].capture);
	}

3369
	ret = snd_soc_register_dais(&codec->component, dai_drv, num_dai, false);
3370
	if (ret < 0) {
3371
		dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
3372
		goto err_cleanup;
3373
	}
3374

3375 3376
	list_for_each_entry(dai, &codec->component.dai_list, list)
		dai->codec = codec;
3377

3378
	mutex_lock(&client_mutex);
3379
	snd_soc_component_add_unlocked(&codec->component);
3380
	list_add(&codec->list, &codec_list);
3381 3382
	mutex_unlock(&client_mutex);

3383 3384
	dev_dbg(codec->dev, "ASoC: Registered codec '%s'\n",
		codec->component.name);
M
Mark Brown 已提交
3385
	return 0;
3386

3387 3388 3389
err_cleanup:
	snd_soc_component_cleanup(&codec->component);
err_free:
3390 3391
	kfree(codec);
	return ret;
M
Mark Brown 已提交
3392 3393 3394 3395 3396 3397
}
EXPORT_SYMBOL_GPL(snd_soc_register_codec);

/**
 * snd_soc_unregister_codec - Unregister a codec from the ASoC core
 *
3398
 * @dev: codec to unregister
M
Mark Brown 已提交
3399
 */
3400
void snd_soc_unregister_codec(struct device *dev)
M
Mark Brown 已提交
3401
{
3402 3403
	struct snd_soc_codec *codec;

3404
	mutex_lock(&client_mutex);
3405 3406 3407 3408
	list_for_each_entry(codec, &codec_list, list) {
		if (dev == codec->dev)
			goto found;
	}
3409
	mutex_unlock(&client_mutex);
3410 3411 3412
	return;

found:
M
Mark Brown 已提交
3413
	list_del(&codec->list);
3414
	snd_soc_component_del_unlocked(&codec->component);
M
Mark Brown 已提交
3415 3416
	mutex_unlock(&client_mutex);

3417 3418
	dev_dbg(codec->dev, "ASoC: Unregistered codec '%s'\n",
			codec->component.name);
3419

3420
	snd_soc_component_cleanup(&codec->component);
3421
	snd_soc_cache_exit(codec);
3422
	kfree(codec);
M
Mark Brown 已提交
3423 3424 3425
}
EXPORT_SYMBOL_GPL(snd_soc_unregister_codec);

3426 3427 3428 3429
/* Retrieve a card's name from device tree */
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
			       const char *propname)
{
3430
	struct device_node *np;
3431 3432
	int ret;

3433 3434 3435 3436 3437 3438 3439
	if (!card->dev) {
		pr_err("card->dev is not set before calling %s\n", __func__);
		return -EINVAL;
	}

	np = card->dev->of_node;

3440 3441 3442 3443 3444 3445 3446 3447
	ret = of_property_read_string_index(np, propname, 0, &card->name);
	/*
	 * EINVAL means the property does not exist. This is fine providing
	 * card->name was previously set, which is checked later in
	 * snd_soc_register_card.
	 */
	if (ret < 0 && ret != -EINVAL) {
		dev_err(card->dev,
3448
			"ASoC: Property '%s' could not be read: %d\n",
3449 3450 3451 3452 3453 3454 3455 3456
			propname, ret);
		return ret;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);

3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536
static const struct snd_soc_dapm_widget simple_widgets[] = {
	SND_SOC_DAPM_MIC("Microphone", NULL),
	SND_SOC_DAPM_LINE("Line", NULL),
	SND_SOC_DAPM_HP("Headphone", NULL),
	SND_SOC_DAPM_SPK("Speaker", NULL),
};

int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
					  const char *propname)
{
	struct device_node *np = card->dev->of_node;
	struct snd_soc_dapm_widget *widgets;
	const char *template, *wname;
	int i, j, num_widgets, ret;

	num_widgets = of_property_count_strings(np, propname);
	if (num_widgets < 0) {
		dev_err(card->dev,
			"ASoC: Property '%s' does not exist\n",	propname);
		return -EINVAL;
	}
	if (num_widgets & 1) {
		dev_err(card->dev,
			"ASoC: Property '%s' length is not even\n", propname);
		return -EINVAL;
	}

	num_widgets /= 2;
	if (!num_widgets) {
		dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
			propname);
		return -EINVAL;
	}

	widgets = devm_kcalloc(card->dev, num_widgets, sizeof(*widgets),
			       GFP_KERNEL);
	if (!widgets) {
		dev_err(card->dev,
			"ASoC: Could not allocate memory for widgets\n");
		return -ENOMEM;
	}

	for (i = 0; i < num_widgets; i++) {
		ret = of_property_read_string_index(np, propname,
			2 * i, &template);
		if (ret) {
			dev_err(card->dev,
				"ASoC: Property '%s' index %d read error:%d\n",
				propname, 2 * i, ret);
			return -EINVAL;
		}

		for (j = 0; j < ARRAY_SIZE(simple_widgets); j++) {
			if (!strncmp(template, simple_widgets[j].name,
				     strlen(simple_widgets[j].name))) {
				widgets[i] = simple_widgets[j];
				break;
			}
		}

		if (j >= ARRAY_SIZE(simple_widgets)) {
			dev_err(card->dev,
				"ASoC: DAPM widget '%s' is not supported\n",
				template);
			return -EINVAL;
		}

		ret = of_property_read_string_index(np, propname,
						    (2 * i) + 1,
						    &wname);
		if (ret) {
			dev_err(card->dev,
				"ASoC: Property '%s' index %d read error:%d\n",
				propname, (2 * i) + 1, ret);
			return -EINVAL;
		}

		widgets[i].name = wname;
	}

3537 3538
	card->of_dapm_widgets = widgets;
	card->num_of_dapm_widgets = num_widgets;
3539 3540 3541 3542 3543

	return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets);

3544 3545 3546 3547 3548
static int snd_soc_of_get_slot_mask(struct device_node *np,
				    const char *prop_name,
				    unsigned int *mask)
{
	u32 val;
3549
	const __be32 *of_slot_mask = of_get_property(np, prop_name, &val);
3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561
	int i;

	if (!of_slot_mask)
		return 0;
	val /= sizeof(u32);
	for (i = 0; i < val; i++)
		if (be32_to_cpup(&of_slot_mask[i]))
			*mask |= (1 << i);

	return val;
}

3562
int snd_soc_of_parse_tdm_slot(struct device_node *np,
3563 3564
			      unsigned int *tx_mask,
			      unsigned int *rx_mask,
3565 3566 3567 3568 3569 3570
			      unsigned int *slots,
			      unsigned int *slot_width)
{
	u32 val;
	int ret;

3571 3572 3573 3574 3575
	if (tx_mask)
		snd_soc_of_get_slot_mask(np, "dai-tdm-slot-tx-mask", tx_mask);
	if (rx_mask)
		snd_soc_of_get_slot_mask(np, "dai-tdm-slot-rx-mask", rx_mask);

3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597
	if (of_property_read_bool(np, "dai-tdm-slot-num")) {
		ret = of_property_read_u32(np, "dai-tdm-slot-num", &val);
		if (ret)
			return ret;

		if (slots)
			*slots = val;
	}

	if (of_property_read_bool(np, "dai-tdm-slot-width")) {
		ret = of_property_read_u32(np, "dai-tdm-slot-width", &val);
		if (ret)
			return ret;

		if (slot_width)
			*slot_width = val;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_of_parse_tdm_slot);

3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617
void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
				   struct snd_soc_codec_conf *codec_conf,
				   struct device_node *of_node,
				   const char *propname)
{
	struct device_node *np = card->dev->of_node;
	const char *str;
	int ret;

	ret = of_property_read_string(np, propname, &str);
	if (ret < 0) {
		/* no prefix is not error */
		return;
	}

	codec_conf->of_node	= of_node;
	codec_conf->name_prefix	= str;
}
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_prefix);

3618 3619
int snd_soc_of_parse_audio_routing_from_node(struct snd_soc_card *card,
				   struct device_node *np,
3620 3621
				   const char *propname)
{
3622
	int num_routes;
3623 3624 3625
	struct snd_soc_dapm_route *routes;
	int i, ret;

3626 3627 3628
	if (!np)
		np = card->dev->of_node;

3629
	num_routes = of_property_count_strings(np, propname);
3630
	if (num_routes < 0 || num_routes & 1) {
3631 3632 3633
		dev_err(card->dev,
			"ASoC: Property '%s' does not exist or its length is not even\n",
			propname);
3634 3635 3636 3637
		return -EINVAL;
	}
	num_routes /= 2;
	if (!num_routes) {
3638
		dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
3639 3640 3641 3642
			propname);
		return -EINVAL;
	}

3643
	routes = devm_kzalloc(card->dev, num_routes * sizeof(*routes),
3644 3645 3646
			      GFP_KERNEL);
	if (!routes) {
		dev_err(card->dev,
3647
			"ASoC: Could not allocate DAPM route table\n");
3648 3649 3650 3651 3652
		return -EINVAL;
	}

	for (i = 0; i < num_routes; i++) {
		ret = of_property_read_string_index(np, propname,
3653
			2 * i, &routes[i].sink);
3654
		if (ret) {
3655 3656 3657
			dev_err(card->dev,
				"ASoC: Property '%s' index %d could not be read: %d\n",
				propname, 2 * i, ret);
3658 3659 3660
			return -EINVAL;
		}
		ret = of_property_read_string_index(np, propname,
3661
			(2 * i) + 1, &routes[i].source);
3662 3663
		if (ret) {
			dev_err(card->dev,
3664 3665
				"ASoC: Property '%s' index %d could not be read: %d\n",
				propname, (2 * i) + 1, ret);
3666 3667 3668 3669
			return -EINVAL;
		}
	}

3670 3671
	card->num_of_dapm_routes = num_routes;
	card->of_dapm_routes = routes;
3672 3673 3674

	return 0;
}
3675
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing_from_node);
3676

3677
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
3678 3679 3680
				     const char *prefix,
				     struct device_node **bitclkmaster,
				     struct device_node **framemaster)
3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720
{
	int ret, i;
	char prop[128];
	unsigned int format = 0;
	int bit, frame;
	const char *str;
	struct {
		char *name;
		unsigned int val;
	} of_fmt_table[] = {
		{ "i2s",	SND_SOC_DAIFMT_I2S },
		{ "right_j",	SND_SOC_DAIFMT_RIGHT_J },
		{ "left_j",	SND_SOC_DAIFMT_LEFT_J },
		{ "dsp_a",	SND_SOC_DAIFMT_DSP_A },
		{ "dsp_b",	SND_SOC_DAIFMT_DSP_B },
		{ "ac97",	SND_SOC_DAIFMT_AC97 },
		{ "pdm",	SND_SOC_DAIFMT_PDM},
		{ "msb",	SND_SOC_DAIFMT_MSB },
		{ "lsb",	SND_SOC_DAIFMT_LSB },
	};

	if (!prefix)
		prefix = "";

	/*
	 * check "[prefix]format = xxx"
	 * SND_SOC_DAIFMT_FORMAT_MASK area
	 */
	snprintf(prop, sizeof(prop), "%sformat", prefix);
	ret = of_property_read_string(np, prop, &str);
	if (ret == 0) {
		for (i = 0; i < ARRAY_SIZE(of_fmt_table); i++) {
			if (strcmp(str, of_fmt_table[i].name) == 0) {
				format |= of_fmt_table[i].val;
				break;
			}
		}
	}

	/*
3721
	 * check "[prefix]continuous-clock"
3722 3723
	 * SND_SOC_DAIFMT_CLOCK_MASK area
	 */
3724
	snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix);
J
Julia Lawall 已提交
3725
	if (of_property_read_bool(np, prop))
3726 3727 3728
		format |= SND_SOC_DAIFMT_CONT;
	else
		format |= SND_SOC_DAIFMT_GATED;
3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762

	/*
	 * check "[prefix]bitclock-inversion"
	 * check "[prefix]frame-inversion"
	 * SND_SOC_DAIFMT_INV_MASK area
	 */
	snprintf(prop, sizeof(prop), "%sbitclock-inversion", prefix);
	bit = !!of_get_property(np, prop, NULL);

	snprintf(prop, sizeof(prop), "%sframe-inversion", prefix);
	frame = !!of_get_property(np, prop, NULL);

	switch ((bit << 4) + frame) {
	case 0x11:
		format |= SND_SOC_DAIFMT_IB_IF;
		break;
	case 0x10:
		format |= SND_SOC_DAIFMT_IB_NF;
		break;
	case 0x01:
		format |= SND_SOC_DAIFMT_NB_IF;
		break;
	default:
		/* SND_SOC_DAIFMT_NB_NF is default */
		break;
	}

	/*
	 * check "[prefix]bitclock-master"
	 * check "[prefix]frame-master"
	 * SND_SOC_DAIFMT_MASTER_MASK area
	 */
	snprintf(prop, sizeof(prop), "%sbitclock-master", prefix);
	bit = !!of_get_property(np, prop, NULL);
3763 3764
	if (bit && bitclkmaster)
		*bitclkmaster = of_parse_phandle(np, prop, 0);
3765 3766 3767

	snprintf(prop, sizeof(prop), "%sframe-master", prefix);
	frame = !!of_get_property(np, prop, NULL);
3768 3769
	if (frame && framemaster)
		*framemaster = of_parse_phandle(np, prop, 0);
3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789

	switch ((bit << 4) + frame) {
	case 0x11:
		format |= SND_SOC_DAIFMT_CBM_CFM;
		break;
	case 0x10:
		format |= SND_SOC_DAIFMT_CBM_CFS;
		break;
	case 0x01:
		format |= SND_SOC_DAIFMT_CBS_CFM;
		break;
	default:
		format |= SND_SOC_DAIFMT_CBS_CFS;
		break;
	}

	return format;
}
EXPORT_SYMBOL_GPL(snd_soc_of_parse_daifmt);

3790 3791
static int snd_soc_get_dai_name(struct of_phandle_args *args,
				const char **dai_name)
3792 3793
{
	struct snd_soc_component *pos;
3794
	struct device_node *component_of_node;
3795
	int ret = -EPROBE_DEFER;
3796 3797 3798

	mutex_lock(&client_mutex);
	list_for_each_entry(pos, &component_list, list) {
3799 3800 3801 3802 3803
		component_of_node = pos->dev->of_node;
		if (!component_of_node && pos->dev->parent)
			component_of_node = pos->dev->parent->of_node;

		if (component_of_node != args->np)
3804 3805
			continue;

3806
		if (pos->driver->of_xlate_dai_name) {
3807 3808 3809
			ret = pos->driver->of_xlate_dai_name(pos,
							     args,
							     dai_name);
3810 3811 3812
		} else {
			int id = -1;

3813
			switch (args->args_count) {
3814 3815 3816 3817
			case 0:
				id = 0; /* same as dai_drv[0] */
				break;
			case 1:
3818
				id = args->args[0];
3819 3820 3821 3822 3823 3824 3825 3826
				break;
			default:
				/* not supported */
				break;
			}

			if (id < 0 || id >= pos->num_dai) {
				ret = -EINVAL;
3827
				continue;
3828
			}
X
Xiubo Li 已提交
3829 3830 3831 3832 3833 3834

			ret = 0;

			*dai_name = pos->dai_drv[id].name;
			if (!*dai_name)
				*dai_name = pos->name;
3835 3836 3837 3838 3839
		}

		break;
	}
	mutex_unlock(&client_mutex);
3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854
	return ret;
}

int snd_soc_of_get_dai_name(struct device_node *of_node,
			    const char **dai_name)
{
	struct of_phandle_args args;
	int ret;

	ret = of_parse_phandle_with_args(of_node, "sound-dai",
					 "#sound-dai-cells", 0, &args);
	if (ret)
		return ret;

	ret = snd_soc_get_dai_name(&args, dai_name);
3855 3856 3857 3858 3859 3860 3861

	of_node_put(args.np);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name);

3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932
/*
 * snd_soc_of_get_dai_link_codecs - Parse a list of CODECs in the devicetree
 * @dev: Card device
 * @of_node: Device node
 * @dai_link: DAI link
 *
 * Builds an array of CODEC DAI components from the DAI link property
 * 'sound-dai'.
 * The array is set in the DAI link and the number of DAIs is set accordingly.
 * The device nodes in the array (of_node) must be dereferenced by the caller.
 *
 * Returns 0 for success
 */
int snd_soc_of_get_dai_link_codecs(struct device *dev,
				   struct device_node *of_node,
				   struct snd_soc_dai_link *dai_link)
{
	struct of_phandle_args args;
	struct snd_soc_dai_link_component *component;
	char *name;
	int index, num_codecs, ret;

	/* Count the number of CODECs */
	name = "sound-dai";
	num_codecs = of_count_phandle_with_args(of_node, name,
						"#sound-dai-cells");
	if (num_codecs <= 0) {
		if (num_codecs == -ENOENT)
			dev_err(dev, "No 'sound-dai' property\n");
		else
			dev_err(dev, "Bad phandle in 'sound-dai'\n");
		return num_codecs;
	}
	component = devm_kzalloc(dev,
				 sizeof *component * num_codecs,
				 GFP_KERNEL);
	if (!component)
		return -ENOMEM;
	dai_link->codecs = component;
	dai_link->num_codecs = num_codecs;

	/* Parse the list */
	for (index = 0, component = dai_link->codecs;
	     index < dai_link->num_codecs;
	     index++, component++) {
		ret = of_parse_phandle_with_args(of_node, name,
						 "#sound-dai-cells",
						  index, &args);
		if (ret)
			goto err;
		component->of_node = args.np;
		ret = snd_soc_get_dai_name(&args, &component->dai_name);
		if (ret < 0)
			goto err;
	}
	return 0;
err:
	for (index = 0, component = dai_link->codecs;
	     index < dai_link->num_codecs;
	     index++, component++) {
		if (!component->of_node)
			break;
		of_node_put(component->of_node);
		component->of_node = NULL;
	}
	dai_link->codecs = NULL;
	dai_link->num_codecs = 0;
	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);

3933
static int __init snd_soc_init(void)
F
Frank Mandarino 已提交
3934
{
3935
	snd_soc_debugfs_init();
3936 3937
	snd_soc_util_init();

F
Frank Mandarino 已提交
3938 3939
	return platform_driver_register(&soc_driver);
}
3940
module_init(snd_soc_init);
F
Frank Mandarino 已提交
3941

M
Mark Brown 已提交
3942
static void __exit snd_soc_exit(void)
F
Frank Mandarino 已提交
3943
{
3944
	snd_soc_util_exit();
3945
	snd_soc_debugfs_exit();
3946

3947 3948
#ifdef CONFIG_DEBUG_FS
#endif
3949
	platform_driver_unregister(&soc_driver);
F
Frank Mandarino 已提交
3950 3951 3952 3953
}
module_exit(snd_soc_exit);

/* Module information */
3954
MODULE_AUTHOR("Liam Girdwood, lrg@slimlogic.co.uk");
F
Frank Mandarino 已提交
3955 3956
MODULE_DESCRIPTION("ALSA SoC Core");
MODULE_LICENSE("GPL");
3957
MODULE_ALIAS("platform:soc-audio");