soc-core.c 96.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
// SPDX-License-Identifier: GPL-2.0+
//
// soc-core.c  --  ALSA SoC Audio Layer
//
// Copyright 2005 Wolfson Microelectronics PLC.
// Copyright 2005 Openedhand Ltd.
// Copyright (C) 2010 Slimlogic Ltd.
// Copyright (C) 2010 Texas Instruments Inc.
//
// Author: Liam Girdwood <lrg@slimlogic.co.uk>
//         with code, comments and ideas from :-
//         Richard Purdie <richard@openedhand.com>
//
//  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
F
Frank Mandarino 已提交
19 20 21 22 23 24 25

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

43 44 45
#define CREATE_TRACE_POINTS
#include <trace/events/asoc.h>

46 47
#define NAME_SIZE	32

48
#ifdef CONFIG_DEBUG_FS
49 50
struct dentry *snd_soc_debugfs_root;
EXPORT_SYMBOL_GPL(snd_soc_debugfs_root);
51 52
#endif

M
Mark Brown 已提交
53
static DEFINE_MUTEX(client_mutex);
54
static LIST_HEAD(component_list);
M
Mark Brown 已提交
55

F
Frank Mandarino 已提交
56 57 58 59 60 61 62 63 64
/*
 * 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)");

65 66 67 68 69 70 71 72 73 74 75 76 77 78
/* If a DMI filed contain strings in this blacklist (e.g.
 * "Type2 - Board Manufacturer" or  "Type1 - TBD by OEM"), it will be taken
 * as invalid and dropped when setting the card long name from DMI info.
 */
static const char * const dmi_blacklist[] = {
	"To be filled by OEM",
	"TBD by OEM",
	"Default String",
	"Board Manufacturer",
	"Board Vendor Name",
	"Board Product Name",
	NULL,	/* terminator */
};

79 80 81
static ssize_t pmdown_time_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
82
	struct snd_soc_pcm_runtime *rtd = dev_get_drvdata(dev);
83

84
	return sprintf(buf, "%ld\n", rtd->pmdown_time);
85 86 87 88 89 90
}

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

94
	ret = kstrtol(buf, 10, &rtd->pmdown_time);
95 96
	if (ret)
		return ret;
97 98 99 100 101 102

	return count;
}

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

103 104 105 106 107 108 109 110 111 112 113 114 115
static struct attribute *soc_dev_attrs[] = {
	&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 */
116
	return rtd->num_codecs ? attr->mode : 0; /* enabled only with codec */
117 118 119 120 121 122 123
}

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

M
Mark Brown 已提交
124
static const struct attribute_group soc_dev_group = {
125 126 127 128 129 130
	.attrs = soc_dev_attrs,
	.is_visible = soc_dev_attr_is_visible,
};

static const struct attribute_group *soc_dev_attr_groups[] = {
	&soc_dapm_dev_group,
M
Mark Brown 已提交
131
	&soc_dev_group,
132 133 134
	NULL
};

135
#ifdef CONFIG_DEBUG_FS
136
static void soc_init_component_debugfs(struct snd_soc_component *component)
137
{
138 139 140
	if (!component->card->debugfs_card_root)
		return;

141 142
	if (component->debugfs_prefix) {
		char *name;
143

144 145 146 147 148 149 150 151 152 153 154
		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);
	}
155

156 157 158 159 160
	if (!component->debugfs_root) {
		dev_warn(component->dev,
			"ASoC: Failed to create component debugfs directory\n");
		return;
	}
161

162 163
	snd_soc_dapm_debugfs_init(snd_soc_component_get_dapm(component),
		component->debugfs_root);
164 165
}

166
static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
167
{
168 169
	debugfs_remove_recursive(component->debugfs_root);
}
170

171
static int dai_list_show(struct seq_file *m, void *v)
M
Mark Brown 已提交
172
{
173
	struct snd_soc_component *component;
M
Mark Brown 已提交
174 175
	struct snd_soc_dai *dai;

176 177
	mutex_lock(&client_mutex);

178 179 180
	list_for_each_entry(component, &component_list, list)
		list_for_each_entry(dai, &component->dai_list, list)
			seq_printf(m, "%s\n", dai->name);
M
Mark Brown 已提交
181

182 183
	mutex_unlock(&client_mutex);

184 185
	return 0;
}
186
DEFINE_SHOW_ATTRIBUTE(dai_list);
M
Mark Brown 已提交
187

188 189 190 191 192 193 194 195 196 197 198 199 200 201 202
static int component_list_show(struct seq_file *m, void *v)
{
	struct snd_soc_component *component;

	mutex_lock(&client_mutex);

	list_for_each_entry(component, &component_list, list)
		seq_printf(m, "%s\n", component->name);

	mutex_unlock(&client_mutex);

	return 0;
}
DEFINE_SHOW_ATTRIBUTE(component_list);

203 204
static void soc_init_card_debugfs(struct snd_soc_card *card)
{
205 206 207
	if (!snd_soc_debugfs_root)
		return;

208
	card->debugfs_card_root = debugfs_create_dir(card->name,
209
						     snd_soc_debugfs_root);
210
	if (!card->debugfs_card_root) {
211
		dev_warn(card->dev,
212
			 "ASoC: Failed to create card debugfs directory\n");
213 214 215 216 217 218 219 220
		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,
221
		       "ASoC: Failed to create pop time debugfs file\n");
222 223 224 225 226 227 228
}

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

229 230 231
static void snd_soc_debugfs_init(void)
{
	snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
232
	if (IS_ERR_OR_NULL(snd_soc_debugfs_root)) {
233 234 235 236 237 238 239 240
		pr_warn("ASoC: Failed to create debugfs directory\n");
		snd_soc_debugfs_root = NULL;
		return;
	}

	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");
241 242 243 244

	if (!debugfs_create_file("components", 0444, snd_soc_debugfs_root, NULL,
				 &component_list_fops))
		pr_warn("ASoC: Failed to create component list debugfs file\n");
245 246 247 248 249 250 251
}

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

252 253
#else

254 255
static inline void soc_init_component_debugfs(
	struct snd_soc_component *component)
256 257 258
{
}

259 260
static inline void soc_cleanup_component_debugfs(
	struct snd_soc_component *component)
261 262 263
{
}

264 265 266 267 268 269 270
static inline void soc_init_card_debugfs(struct snd_soc_card *card)
{
}

static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
{
}
271 272 273 274 275 276 277 278 279

static inline void snd_soc_debugfs_init(void)
{
}

static inline void snd_soc_debugfs_exit(void)
{
}

280 281
#endif

282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320
static int snd_soc_rtdcom_add(struct snd_soc_pcm_runtime *rtd,
			      struct snd_soc_component *component)
{
	struct snd_soc_rtdcom_list *rtdcom;
	struct snd_soc_rtdcom_list *new_rtdcom;

	for_each_rtdcom(rtd, rtdcom) {
		/* already connected */
		if (rtdcom->component == component)
			return 0;
	}

	new_rtdcom = kmalloc(sizeof(*new_rtdcom), GFP_KERNEL);
	if (!new_rtdcom)
		return -ENOMEM;

	new_rtdcom->component = component;
	INIT_LIST_HEAD(&new_rtdcom->list);

	list_add_tail(&new_rtdcom->list, &rtd->component_list);

	return 0;
}

static void snd_soc_rtdcom_del_all(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_soc_rtdcom_list *rtdcom1, *rtdcom2;

	for_each_rtdcom_safe(rtd, rtdcom1, rtdcom2)
		kfree(rtdcom1);

	INIT_LIST_HEAD(&rtd->component_list);
}

struct snd_soc_component *snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
						const char *driver_name)
{
	struct snd_soc_rtdcom_list *rtdcom;

321 322 323
	if (!driver_name)
		return NULL;

324
	for_each_rtdcom(rtd, rtdcom) {
325 326 327 328 329 330 331
		const char *component_name = rtdcom->component->driver->name;

		if (!component_name)
			continue;

		if ((component_name == driver_name) ||
		    strcmp(component_name, driver_name) == 0)
332 333 334 335 336
			return rtdcom->component;
	}

	return NULL;
}
337
EXPORT_SYMBOL_GPL(snd_soc_rtdcom_lookup);
338

339 340 341
struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
		const char *dai_link, int stream)
{
342
	struct snd_soc_pcm_runtime *rtd;
343

344 345 346 347
	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;
348
	}
349
	dev_dbg(card->dev, "ASoC: failed to find dai link %s\n", dai_link);
350 351 352 353
	return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_get_dai_substream);

354 355
static const struct snd_soc_ops null_snd_soc_ops;

356 357 358 359 360 361 362 363 364
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;

365
	INIT_LIST_HEAD(&rtd->component_list);
366 367
	rtd->card = card;
	rtd->dai_link = dai_link;
368 369 370
	if (!rtd->dai_link->ops)
		rtd->dai_link->ops = &null_snd_soc_ops;

K
Kees Cook 已提交
371 372
	rtd->codec_dais = kcalloc(dai_link->num_codecs,
					sizeof(struct snd_soc_dai *),
373 374 375 376 377 378 379 380 381 382 383
					GFP_KERNEL);
	if (!rtd->codec_dais) {
		kfree(rtd);
		return NULL;
	}

	return rtd;
}

static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
{
384
	kfree(rtd->codec_dais);
385
	snd_soc_rtdcom_del_all(rtd);
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
	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;
}

409 410 411
struct snd_soc_pcm_runtime *snd_soc_get_pcm_runtime(struct snd_soc_card *card,
		const char *dai_link)
{
412
	struct snd_soc_pcm_runtime *rtd;
413

414 415 416
	list_for_each_entry(rtd, &card->rtd_list, list) {
		if (!strcmp(rtd->dai_link->name, dai_link))
			return rtd;
417
	}
418
	dev_dbg(card->dev, "ASoC: failed to find rtd %s\n", dai_link);
419 420 421 422
	return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_get_pcm_runtime);

423 424 425 426 427 428 429 430 431
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.
	 */
}

432
#ifdef CONFIG_PM_SLEEP
F
Frank Mandarino 已提交
433
/* powers down audio subsystem for suspend */
434
int snd_soc_suspend(struct device *dev)
F
Frank Mandarino 已提交
435
{
436
	struct snd_soc_card *card = dev_get_drvdata(dev);
437
	struct snd_soc_component *component;
438 439
	struct snd_soc_pcm_runtime *rtd;
	int i;
F
Frank Mandarino 已提交
440

441 442
	/* If the card is not initialized yet there is nothing to do */
	if (!card->instantiated)
443 444
		return 0;

445 446 447
	/* Due to the resume being scheduled into a workqueue we could
	* suspend before that's finished - wait for it to complete.
	 */
448
	snd_power_wait(card->snd_card, SNDRV_CTL_POWER_D0);
449 450

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

M
Mark Brown 已提交
453
	/* mute any active DACs */
454
	list_for_each_entry(rtd, &card->rtd_list, list) {
455
		struct snd_soc_dai *dai;
456

457
		if (rtd->dai_link->ignore_suspend)
458 459
			continue;

460
		for_each_rtd_codec_dai(rtd, i, dai) {
461 462 463 464 465
			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 已提交
466 467
	}

468
	/* suspend all pcms */
469 470
	list_for_each_entry(rtd, &card->rtd_list, list) {
		if (rtd->dai_link->ignore_suspend)
471 472
			continue;

473
		snd_pcm_suspend_all(rtd->pcm);
474
	}
475

476
	if (card->suspend_pre)
477
		card->suspend_pre(card);
F
Frank Mandarino 已提交
478

479 480
	list_for_each_entry(rtd, &card->rtd_list, list) {
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
481

482
		if (rtd->dai_link->ignore_suspend)
483 484
			continue;

485
		if (cpu_dai->driver->suspend && !cpu_dai->driver->bus_control)
486
			cpu_dai->driver->suspend(cpu_dai);
F
Frank Mandarino 已提交
487 488
	}

489
	/* close any waiting streams */
490 491
	list_for_each_entry(rtd, &card->rtd_list, list)
		flush_delayed_work(&rtd->delayed_work);
F
Frank Mandarino 已提交
492

493
	list_for_each_entry(rtd, &card->rtd_list, list) {
494

495
		if (rtd->dai_link->ignore_suspend)
496 497
			continue;

498
		snd_soc_dapm_stream_event(rtd,
499 500
					  SNDRV_PCM_STREAM_PLAYBACK,
					  SND_SOC_DAPM_STREAM_SUSPEND);
501

502
		snd_soc_dapm_stream_event(rtd,
503 504
					  SNDRV_PCM_STREAM_CAPTURE,
					  SND_SOC_DAPM_STREAM_SUSPEND);
F
Frank Mandarino 已提交
505 506
	}

507 508
	/* Recheck all endpoints too, their state is affected by suspend */
	dapm_mark_endpoints_dirty(card);
509 510
	snd_soc_dapm_sync(&card->dapm);

511
	/* suspend all COMPONENTs */
512 513 514
	list_for_each_entry(component, &card->component_dev_list, card_list) {
		struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);

515
		/* If there are paths active then the COMPONENT will be held with
516
		 * bias _ON and should not be suspended. */
517
		if (!component->suspended) {
518
			switch (snd_soc_dapm_get_bias_level(dapm)) {
519
			case SND_SOC_BIAS_STANDBY:
520
				/*
521
				 * If the COMPONENT is capable of idle
522 523 524 525
				 * bias off then being in STANDBY
				 * means it's doing something,
				 * otherwise fall through.
				 */
526
				if (dapm->idle_bias_off) {
527
					dev_dbg(component->dev,
528
						"ASoC: idle_bias_off CODEC on over suspend\n");
529 530
					break;
				}
531
				/* fall through */
532

533
			case SND_SOC_BIAS_OFF:
534 535
				if (component->driver->suspend)
					component->driver->suspend(component);
536 537 538
				component->suspended = 1;
				if (component->regmap)
					regcache_mark_dirty(component->regmap);
539
				/* deactivate pins to sleep state */
540
				pinctrl_pm_select_sleep_state(component->dev);
541 542
				break;
			default:
543 544
				dev_dbg(component->dev,
					"ASoC: COMPONENT is on over suspend\n");
545 546
				break;
			}
547 548
		}
	}
F
Frank Mandarino 已提交
549

550 551
	list_for_each_entry(rtd, &card->rtd_list, list) {
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
552

553
		if (rtd->dai_link->ignore_suspend)
554 555
			continue;

556
		if (cpu_dai->driver->suspend && cpu_dai->driver->bus_control)
557
			cpu_dai->driver->suspend(cpu_dai);
558 559 560

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

563
	if (card->suspend_post)
564
		card->suspend_post(card);
F
Frank Mandarino 已提交
565 566 567

	return 0;
}
568
EXPORT_SYMBOL_GPL(snd_soc_suspend);
F
Frank Mandarino 已提交
569

570 571 572 573
/* 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 已提交
574
{
575 576
	struct snd_soc_card *card =
			container_of(work, struct snd_soc_card, deferred_resume_work);
577
	struct snd_soc_pcm_runtime *rtd;
578
	struct snd_soc_component *component;
579
	int i;
F
Frank Mandarino 已提交
580

581 582 583 584
	/* our power state is still SNDRV_CTL_POWER_D3hot from suspend time,
	 * so userspace apps are blocked from touching us
	 */

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

587
	/* Bring us up into D2 so that DAPM starts enabling things */
588
	snd_power_change_state(card->snd_card, SNDRV_CTL_POWER_D2);
589

590
	if (card->resume_pre)
591
		card->resume_pre(card);
F
Frank Mandarino 已提交
592

593
	/* resume control bus DAIs */
594 595
	list_for_each_entry(rtd, &card->rtd_list, list) {
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
596

597
		if (rtd->dai_link->ignore_suspend)
598 599
			continue;

600
		if (cpu_dai->driver->resume && cpu_dai->driver->bus_control)
601 602 603
			cpu_dai->driver->resume(cpu_dai);
	}

604
	list_for_each_entry(component, &card->component_dev_list, card_list) {
605
		if (component->suspended) {
606 607
			if (component->driver->resume)
				component->driver->resume(component);
608
			component->suspended = 0;
609 610
		}
	}
F
Frank Mandarino 已提交
611

612
	list_for_each_entry(rtd, &card->rtd_list, list) {
613

614
		if (rtd->dai_link->ignore_suspend)
615 616
			continue;

617
		snd_soc_dapm_stream_event(rtd,
618
					  SNDRV_PCM_STREAM_PLAYBACK,
619
					  SND_SOC_DAPM_STREAM_RESUME);
620

621
		snd_soc_dapm_stream_event(rtd,
622
					  SNDRV_PCM_STREAM_CAPTURE,
623
					  SND_SOC_DAPM_STREAM_RESUME);
F
Frank Mandarino 已提交
624 625
	}

626
	/* unmute any active DACs */
627
	list_for_each_entry(rtd, &card->rtd_list, list) {
628
		struct snd_soc_dai *dai;
629

630
		if (rtd->dai_link->ignore_suspend)
631 632
			continue;

633
		for_each_rtd_codec_dai(rtd, i, dai) {
634 635 636 637 638
			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 已提交
639 640
	}

641 642
	list_for_each_entry(rtd, &card->rtd_list, list) {
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
643

644
		if (rtd->dai_link->ignore_suspend)
645 646
			continue;

647
		if (cpu_dai->driver->resume && !cpu_dai->driver->bus_control)
648
			cpu_dai->driver->resume(cpu_dai);
F
Frank Mandarino 已提交
649 650
	}

651
	if (card->resume_post)
652
		card->resume_post(card);
F
Frank Mandarino 已提交
653

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

656 657
	/* Recheck all endpoints too, their state is affected by suspend */
	dapm_mark_endpoints_dirty(card);
658
	snd_soc_dapm_sync(&card->dapm);
659 660 661

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

/* powers up audio subsystem after a suspend */
665
int snd_soc_resume(struct device *dev)
666
{
667
	struct snd_soc_card *card = dev_get_drvdata(dev);
668
	bool bus_control = false;
669
	struct snd_soc_pcm_runtime *rtd;
670

671 672
	/* If the card is not initialized yet there is nothing to do */
	if (!card->instantiated)
673 674
		return 0;

675
	/* activate pins from sleep state */
676
	list_for_each_entry(rtd, &card->rtd_list, list) {
677
		struct snd_soc_dai *codec_dai;
678 679 680
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
		int j;

681 682
		if (cpu_dai->active)
			pinctrl_pm_select_default_state(cpu_dai->dev);
683

684
		for_each_rtd_codec_dai(rtd, j, codec_dai) {
685 686 687
			if (codec_dai->active)
				pinctrl_pm_select_default_state(codec_dai->dev);
		}
688 689
	}

690 691 692 693
	/*
	 * 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
694 695
	 * due to I/O costs and anti-pop so handle them out of line.
	 */
696 697
	list_for_each_entry(rtd, &card->rtd_list, list) {
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
698
		bus_control |= cpu_dai->driver->bus_control;
699
	}
700 701
	if (bus_control) {
		dev_dbg(dev, "ASoC: Resuming control bus master immediately\n");
702 703
		soc_resume_deferred(&card->deferred_resume_work);
	} else {
704
		dev_dbg(dev, "ASoC: Scheduling resume work\n");
705
		if (!schedule_work(&card->deferred_resume_work))
706
			dev_err(dev, "ASoC: resume work item may be lost\n");
707
	}
708

F
Frank Mandarino 已提交
709 710
	return 0;
}
711
EXPORT_SYMBOL_GPL(snd_soc_resume);
F
Frank Mandarino 已提交
712
#else
713 714
#define snd_soc_suspend NULL
#define snd_soc_resume NULL
F
Frank Mandarino 已提交
715 716
#endif

717
static const struct snd_soc_dai_ops null_dai_ops = {
718 719
};

720 721
static struct snd_soc_component *soc_find_component(
	const struct device_node *of_node, const char *name)
722
{
723
	struct snd_soc_component *component;
724

725 726
	lockdep_assert_held(&client_mutex);

727 728 729 730 731 732
	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;
733 734 735 736 737 738
		}
	}

	return NULL;
}

739 740 741
/**
 * snd_soc_find_dai - Find a registered DAI
 *
742
 * @dlc: name of the DAI or the DAI driver and optional component info to match
743
 *
744
 * This function will search all registered components and their DAIs to
745 746 747 748 749
 * 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 已提交
750
struct snd_soc_dai *snd_soc_find_dai(
751
	const struct snd_soc_dai_link_component *dlc)
752
{
753 754
	struct snd_soc_component *component;
	struct snd_soc_dai *dai;
755
	struct device_node *component_of_node;
756

757 758
	lockdep_assert_held(&client_mutex);

759 760
	/* Find CPU DAI from registered DAIs*/
	list_for_each_entry(component, &component_list, list) {
761 762 763 764 765
		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)
766
			continue;
767
		if (dlc->name && strcmp(component->name, dlc->name))
768 769
			continue;
		list_for_each_entry(dai, &component->dai_list, list) {
770
			if (dlc->dai_name && strcmp(dai->name, dlc->dai_name)
771 772
			    && (!dai->driver->name
				|| strcmp(dai->driver->name, dlc->dai_name)))
773 774
				continue;

775
			return dai;
776 777 778 779 780
		}
	}

	return NULL;
}
M
Mengdong Lin 已提交
781
EXPORT_SYMBOL_GPL(snd_soc_find_dai);
782

M
Mengdong Lin 已提交
783 784 785 786 787 788 789

/**
 * snd_soc_find_dai_link - Find a DAI link
 *
 * @card: soc card
 * @id: DAI link ID to match
 * @name: DAI link name to match, optional
790
 * @stream_name: DAI link stream name to match, optional
M
Mengdong Lin 已提交
791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824
 *
 * This function will search all existing DAI links of the soc card to
 * find the link of the same ID. Since DAI links may not have their
 * unique ID, so name and stream name should also match if being
 * specified.
 *
 * Return: pointer of DAI link, or NULL if not found.
 */
struct snd_soc_dai_link *snd_soc_find_dai_link(struct snd_soc_card *card,
					       int id, const char *name,
					       const char *stream_name)
{
	struct snd_soc_dai_link *link, *_link;

	lockdep_assert_held(&client_mutex);

	list_for_each_entry_safe(link, _link, &card->dai_link_list, list) {
		if (link->id != id)
			continue;

		if (name && (!link->name || strcmp(name, link->name)))
			continue;

		if (stream_name && (!link->stream_name
			|| strcmp(stream_name, link->stream_name)))
			continue;

		return link;
	}

	return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_find_dai_link);

825 826 827 828 829 830 831 832 833 834 835 836 837
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;
}

838 839
static int soc_bind_dai_link(struct snd_soc_card *card,
	struct snd_soc_dai_link *dai_link)
F
Frank Mandarino 已提交
840
{
841
	struct snd_soc_pcm_runtime *rtd;
842
	struct snd_soc_dai_link_component *codecs = dai_link->codecs;
843
	struct snd_soc_dai_link_component cpu_dai_component;
844
	struct snd_soc_component *component;
845
	struct snd_soc_dai **codec_dais;
846
	struct device_node *platform_of_node;
847
	const char *platform_name;
848
	int i;
849

850 851 852
	if (dai_link->ignore)
		return 0;

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

855 856 857 858 859
	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;
	}
860

S
Sudip Mukherjee 已提交
861 862 863 864
	rtd = soc_new_pcm_runtime(card, dai_link);
	if (!rtd)
		return -ENOMEM;

865 866 867 868
	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);
869
	if (!rtd->cpu_dai) {
870 871
		dev_info(card->dev, "ASoC: CPU DAI %s not registered\n",
			 dai_link->cpu_dai_name);
872
		goto _err_defer;
873
	}
874
	snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
875

876
	rtd->num_codecs = dai_link->num_codecs;
877

878
	/* Find CODEC from registered CODECs */
879
	/* we can use for_each_rtd_codec_dai() after this */
880
	codec_dais = rtd->codec_dais;
881
	for (i = 0; i < rtd->num_codecs; i++) {
882
		codec_dais[i] = snd_soc_find_dai(&codecs[i]);
883 884 885
		if (!codec_dais[i]) {
			dev_err(card->dev, "ASoC: CODEC DAI %s not registered\n",
				codecs[i].dai_name);
886
			goto _err_defer;
887
		}
888
		snd_soc_rtdcom_add(rtd, codec_dais[i]->component);
889 890
	}

891 892 893
	/* Single codec links expect codec and codec_dai in runtime data */
	rtd->codec_dai = codec_dais[0];

894
	/* if there's no platform we match on the empty platform */
895 896
	platform_name = dai_link->platform->name;
	if (!platform_name && !dai_link->platform->of_node)
897 898
		platform_name = "snd-soc-dummy";

899 900 901 902 903 904
	/* find one from the set of registered platforms */
	list_for_each_entry(component, &component_list, list) {
		platform_of_node = component->dev->of_node;
		if (!platform_of_node && component->dev->parent->of_node)
			platform_of_node = component->dev->parent->of_node;

905 906
		if (dai_link->platform->of_node) {
			if (platform_of_node != dai_link->platform->of_node)
907 908 909 910 911 912 913 914 915
				continue;
		} else {
			if (strcmp(component->name, platform_name))
				continue;
		}

		snd_soc_rtdcom_add(rtd, component);
	}

916
	soc_add_pcm_runtime(card, rtd);
917
	return 0;
918 919 920 921

_err_defer:
	soc_free_pcm_runtime(rtd);
	return  -EPROBE_DEFER;
922 923
}

924
static void soc_remove_component(struct snd_soc_component *component)
925
{
926
	if (!component->card)
927
		return;
928

929
	list_del(&component->card_list);
930

931 932
	if (component->driver->remove)
		component->driver->remove(component);
933

934
	snd_soc_dapm_free(snd_soc_component_get_dapm(component));
935

936
	soc_cleanup_component_debugfs(component);
937
	component->card = NULL;
938
	module_put(component->dev->driver->owner);
939 940
}

941
static void soc_remove_dai(struct snd_soc_dai *dai, int order)
942 943 944
{
	int err;

945 946 947 948
	if (dai && dai->probed &&
			dai->driver->remove_order == order) {
		if (dai->driver->remove) {
			err = dai->driver->remove(dai);
949
			if (err < 0)
950
				dev_err(dai->dev,
951
					"ASoC: failed to remove %s: %d\n",
952
					dai->name, err);
953
		}
954
		dai->probed = 0;
955
	}
956 957
}

958 959
static void soc_remove_link_dais(struct snd_soc_card *card,
		struct snd_soc_pcm_runtime *rtd, int order)
960
{
961
	int i;
962
	struct snd_soc_dai *codec_dai;
963 964 965 966 967 968 969 970

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

	/* remove the CODEC DAI */
971 972
	for_each_rtd_codec_dai(rtd, i, codec_dai)
		soc_remove_dai(codec_dai, order);
973

974
	soc_remove_dai(rtd->cpu_dai, order);
975
}
F
Frank Mandarino 已提交
976

977 978
static void soc_remove_link_components(struct snd_soc_card *card,
	struct snd_soc_pcm_runtime *rtd, int order)
979
{
980
	struct snd_soc_component *component;
981
	struct snd_soc_rtdcom_list *rtdcom;
982

983 984
	for_each_rtdcom(rtd, rtdcom) {
		component = rtdcom->component;
985

986
		if (component->driver->remove_order == order)
987
			soc_remove_component(component);
988 989 990
	}
}

991 992
static void soc_remove_dai_links(struct snd_soc_card *card)
{
993 994
	int order;
	struct snd_soc_pcm_runtime *rtd;
995
	struct snd_soc_dai_link *link, *_link;
996

997 998
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
			order++) {
999 1000
		list_for_each_entry(rtd, &card->rtd_list, list)
			soc_remove_link_dais(card, rtd, order);
1001 1002 1003 1004
	}

	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
			order++) {
1005 1006
		list_for_each_entry(rtd, &card->rtd_list, list)
			soc_remove_link_components(card, rtd, order);
1007
	}
1008

1009 1010 1011 1012 1013 1014 1015 1016
	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--;
	}
1017 1018
}

1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
static int snd_soc_init_platform(struct snd_soc_card *card,
				 struct snd_soc_dai_link *dai_link)
{
	/*
	 * FIXME
	 *
	 * this function should be removed in the future
	 */
	/* convert Legacy platform link */
	if (dai_link->platform)
		return 0;

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

	dai_link->platform->name	= dai_link->platform_name;
	dai_link->platform->of_node	= dai_link->platform_of_node;
	dai_link->platform->dai_name	= NULL;

	return 0;
}

1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
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;
1075
	struct snd_soc_dai_link_component *codec;
1076

1077 1078 1079 1080 1081 1082
	ret = snd_soc_init_platform(card, link);
	if (ret) {
		dev_err(card->dev, "ASoC: failed to init multiplatform\n");
		return ret;
	}

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

1089
	for_each_link_codecs(link, i, codec) {
1090 1091 1092 1093
		/*
		 * Codec must be specified by 1 of name or OF node,
		 * not both or neither.
		 */
1094 1095
		if (!!codec->name ==
		    !!codec->of_node) {
1096 1097 1098 1099 1100
			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 */
1101
		if (!codec->dai_name) {
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111
			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.
	 */
1112
	if (link->platform->name && link->platform->of_node) {
1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
		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;
1142 1143
}

1144 1145 1146 1147 1148 1149 1150 1151 1152
void snd_soc_disconnect_sync(struct device *dev)
{
	struct snd_soc_component *component = snd_soc_lookup_component(dev, NULL);

	if (!component || !component->card)
		return;

	snd_card_disconnect_sync(component->card->snd_card);
}
1153
EXPORT_SYMBOL_GPL(snd_soc_disconnect_sync);
1154

1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176
/**
 * 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);
1177 1178 1179 1180 1181 1182
	/* 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);

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
	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);
1213 1214 1215 1216 1217 1218
	/* 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);

1219 1220 1221 1222 1223 1224 1225 1226 1227 1228
	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);

1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
static void soc_set_of_name_prefix(struct snd_soc_component *component)
{
	struct device_node *component_of_node = component->dev->of_node;
	const char *str;
	int ret;

	if (!component_of_node && component->dev->parent)
		component_of_node = component->dev->parent->of_node;

	ret = of_property_read_string(component_of_node, "sound-name-prefix",
				      &str);
	if (!ret)
		component->name_prefix = str;
}

1244
static void soc_set_name_prefix(struct snd_soc_card *card,
1245
				struct snd_soc_component *component)
1246 1247 1248
{
	int i;

1249
	for (i = 0; i < card->num_configs && card->codec_conf; i++) {
1250
		struct snd_soc_codec_conf *map = &card->codec_conf[i];
1251 1252 1253 1254 1255 1256
		struct device_node *component_of_node = component->dev->of_node;

		if (!component_of_node && component->dev->parent)
			component_of_node = component->dev->parent->of_node;

		if (map->of_node && component_of_node != map->of_node)
1257
			continue;
1258
		if (map->dev_name && strcmp(component->name, map->dev_name))
1259
			continue;
1260
		component->name_prefix = map->name_prefix;
1261
		return;
1262
	}
1263 1264 1265 1266 1267 1268

	/*
	 * If there is no configuration table or no match in the table,
	 * check if a prefix is provided in the node
	 */
	soc_set_of_name_prefix(component);
1269 1270
}

1271 1272
static int soc_probe_component(struct snd_soc_card *card,
	struct snd_soc_component *component)
1273
{
1274
	struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
1275
	struct snd_soc_dai *dai;
1276
	int ret;
1277

1278
	if (!strcmp(component->name, "snd-soc-dummy"))
1279
		return 0;
1280

1281
	if (component->card) {
1282 1283 1284 1285 1286 1287 1288 1289
		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;
	}
1290

1291
	if (!try_module_get(component->dev->driver->owner))
1292 1293
		return -ENODEV;

1294 1295 1296
	component->card = card;
	dapm->card = card;
	soc_set_name_prefix(card, component);
1297

1298
	soc_init_component_debugfs(component);
1299

1300 1301 1302 1303
	if (component->driver->dapm_widgets) {
		ret = snd_soc_dapm_new_controls(dapm,
					component->driver->dapm_widgets,
					component->driver->num_dapm_widgets);
1304 1305

		if (ret != 0) {
1306
			dev_err(component->dev,
1307 1308 1309 1310
				"Failed to create new controls %d\n", ret);
			goto err_probe;
		}
	}
1311

1312 1313
	list_for_each_entry(dai, &component->dai_list, list) {
		ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
1314
		if (ret != 0) {
1315
			dev_err(component->dev,
1316 1317 1318 1319
				"Failed to create DAI widgets %d\n", ret);
			goto err_probe;
		}
	}
1320

1321 1322
	if (component->driver->probe) {
		ret = component->driver->probe(component);
1323
		if (ret < 0) {
1324 1325
			dev_err(component->dev,
				"ASoC: failed to probe component %d\n", ret);
1326
			goto err_probe;
1327
		}
1328

1329 1330 1331 1332
		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);
1333 1334
	}

1335 1336 1337 1338 1339 1340 1341 1342 1343 1344
	/* 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;
		}
	}

1345 1346 1347 1348
	if (component->driver->controls)
		snd_soc_add_component_controls(component,
					       component->driver->controls,
					       component->driver->num_controls);
1349 1350 1351 1352
	if (component->driver->dapm_routes)
		snd_soc_dapm_add_routes(dapm,
					component->driver->dapm_routes,
					component->driver->num_dapm_routes);
1353

1354
	list_add(&dapm->list, &card->dapm_list);
1355
	list_add(&component->card_list, &card->component_dev_list);
1356 1357 1358 1359

	return 0;

err_probe:
1360
	soc_cleanup_component_debugfs(component);
1361
	component->card = NULL;
1362
	module_put(component->dev->driver->owner);
1363 1364 1365 1366

	return ret;
}

1367 1368 1369 1370
static void rtd_release(struct device *dev)
{
	kfree(dev);
}
1371

1372 1373
static int soc_post_component_init(struct snd_soc_pcm_runtime *rtd,
	const char *name)
1374
{
1375 1376 1377
	int ret = 0;

	/* register the rtd device */
1378 1379 1380 1381
	rtd->dev = kzalloc(sizeof(struct device), GFP_KERNEL);
	if (!rtd->dev)
		return -ENOMEM;
	device_initialize(rtd->dev);
1382
	rtd->dev->parent = rtd->card->dev;
1383
	rtd->dev->release = rtd_release;
1384
	rtd->dev->groups = soc_dev_attr_groups;
1385
	dev_set_name(rtd->dev, "%s", name);
1386
	dev_set_drvdata(rtd->dev, rtd);
L
Liam Girdwood 已提交
1387
	mutex_init(&rtd->pcm_mutex);
1388 1389 1390 1391
	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);
1392
	ret = device_add(rtd->dev);
1393
	if (ret < 0) {
1394 1395
		/* calling put_device() here to free the rtd->dev */
		put_device(rtd->dev);
1396
		dev_err(rtd->card->dev,
1397
			"ASoC: failed to register runtime device: %d\n", ret);
1398 1399 1400 1401 1402 1403
		return ret;
	}
	rtd->dev_registered = 1;
	return 0;
}

1404 1405
static int soc_probe_link_components(struct snd_soc_card *card,
			struct snd_soc_pcm_runtime *rtd,
1406 1407
				     int order)
{
1408
	struct snd_soc_component *component;
1409 1410
	struct snd_soc_rtdcom_list *rtdcom;
	int ret;
1411

1412 1413
	for_each_rtdcom(rtd, rtdcom) {
		component = rtdcom->component;
1414

1415
		if (component->driver->probe_order == order) {
1416
			ret = soc_probe_component(card, component);
1417 1418 1419
			if (ret < 0)
				return ret;
		}
1420 1421 1422 1423 1424
	}

	return 0;
}

1425
static int soc_probe_dai(struct snd_soc_dai *dai, int order)
1426
{
1427 1428 1429
	if (dai->probed ||
	    dai->driver->probe_order != order)
		return 0;
1430

1431 1432 1433 1434 1435 1436
	if (dai->driver->probe) {
		int ret = dai->driver->probe(dai);
		if (ret < 0) {
			dev_err(dai->dev, "ASoC: failed to probe DAI %s: %d\n",
				dai->name, ret);
			return ret;
1437 1438 1439
		}
	}

1440 1441
	dai->probed = 1;

1442 1443 1444
	return 0;
}

1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465
static int soc_link_dai_pcm_new(struct snd_soc_dai **dais, int num_dais,
				struct snd_soc_pcm_runtime *rtd)
{
	int i, ret = 0;

	for (i = 0; i < num_dais; ++i) {
		struct snd_soc_dai_driver *drv = dais[i]->driver;

		if (!rtd->dai_link->no_pcm && drv->pcm_new)
			ret = drv->pcm_new(rtd, dais[i]);
		if (ret < 0) {
			dev_err(dais[i]->dev,
				"ASoC: Failed to bind %s with pcm device\n",
				dais[i]->name);
			return ret;
		}
	}

	return 0;
}

1466 1467
static int soc_probe_link_dais(struct snd_soc_card *card,
		struct snd_soc_pcm_runtime *rtd, int order)
1468
{
1469
	struct snd_soc_dai_link *dai_link = rtd->dai_link;
1470
	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
1471 1472
	struct snd_soc_rtdcom_list *rtdcom;
	struct snd_soc_component *component;
1473
	struct snd_soc_dai *codec_dai;
1474
	int i, ret, num;
1475

1476
	dev_dbg(card->dev, "ASoC: probe %s dai link %d late %d\n",
1477
			card->name, rtd->num, order);
1478 1479 1480 1481

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

1482 1483 1484
	ret = soc_probe_dai(cpu_dai, order);
	if (ret)
		return ret;
F
Frank Mandarino 已提交
1485

1486
	/* probe the CODEC DAI */
1487 1488
	for_each_rtd_codec_dai(rtd, i, codec_dai) {
		ret = soc_probe_dai(codec_dai, order);
1489 1490 1491
		if (ret)
			return ret;
	}
M
Mark Brown 已提交
1492

1493 1494 1495 1496
	/* complete DAI probe during last probe */
	if (order != SND_SOC_COMP_ORDER_LAST)
		return 0;

1497 1498 1499 1500 1501 1502 1503 1504 1505 1506
	/* 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;
		}
	}

1507 1508 1509
	if (dai_link->dai_fmt)
		snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);

1510
	ret = soc_post_component_init(rtd, dai_link->name);
1511
	if (ret)
1512
		return ret;
M
Mark Brown 已提交
1513

1514 1515
#ifdef CONFIG_DEBUG_FS
	/* add DPCM sysfs entries */
1516 1517
	if (dai_link->dynamic)
		soc_dpcm_debugfs_add(rtd);
1518 1519
#endif

1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538
	num = rtd->num;

	/*
	 * most drivers will register their PCMs using DAI link ordering but
	 * topology based drivers can use the DAI link id field to set PCM
	 * device number and then use rtd + a base offset of the BEs.
	 */
	for_each_rtdcom(rtd, rtdcom) {
		component = rtdcom->component;

		if (!component->driver->use_dai_pcm_id)
			continue;

		if (rtd->dai_link->no_pcm)
			num += component->driver->be_pcm_base;
		else
			num = rtd->dai_link->id;
	}

1539
	if (cpu_dai->driver->compress_new) {
1540
		/*create compress_device"*/
1541
		ret = cpu_dai->driver->compress_new(rtd, num);
1542
		if (ret < 0) {
1543
			dev_err(card->dev, "ASoC: can't create compress %s\n",
1544
					 dai_link->stream_name);
1545 1546 1547
			return ret;
		}
	} else {
1548 1549 1550

		if (!dai_link->params) {
			/* create the pcm */
1551
			ret = soc_new_pcm(rtd, num);
1552
			if (ret < 0) {
1553
				dev_err(card->dev, "ASoC: can't create pcm %s :%d\n",
1554
				       dai_link->stream_name, ret);
1555 1556
				return ret;
			}
1557 1558 1559 1560 1561 1562 1563
			ret = soc_link_dai_pcm_new(&cpu_dai, 1, rtd);
			if (ret < 0)
				return ret;
			ret = soc_link_dai_pcm_new(rtd->codec_dais,
						   rtd->num_codecs, rtd);
			if (ret < 0)
				return ret;
1564
		} else {
1565 1566
			INIT_DELAYED_WORK(&rtd->delayed_work,
						codec2codec_close_delayed_work);
1567
		}
1568 1569 1570 1571 1572
	}

	return 0;
}

1573
static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
1574 1575
{
	struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598
	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;
1599
	}
1600

1601
	component->init = aux_dev->init;
1602
	list_add(&component->card_aux_list, &card->aux_comp_list);
1603

1604
	return 0;
1605 1606 1607 1608

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

1611
static int soc_probe_aux_devices(struct snd_soc_card *card)
1612
{
1613
	struct snd_soc_component *comp;
1614
	int order;
1615
	int ret;
1616

1617 1618
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
		order++) {
1619
		list_for_each_entry(comp, &card->aux_comp_list, card_aux_list) {
1620 1621 1622 1623 1624 1625 1626 1627 1628
			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;
				}
			}
1629 1630
		}
	}
1631

1632
	return 0;
1633 1634
}

1635
static void soc_remove_aux_devices(struct snd_soc_card *card)
1636
{
1637 1638
	struct snd_soc_component *comp, *_comp;
	int order;
1639

1640 1641 1642
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
		order++) {
		list_for_each_entry_safe(comp, _comp,
1643
			&card->aux_comp_list, card_aux_list) {
1644

1645 1646
			if (comp->driver->remove_order == order) {
				soc_remove_component(comp);
1647 1648
				/* remove it from the card's aux_comp_list */
				list_del(&comp->card_aux_list);
1649 1650
			}
		}
1651 1652 1653
	}
}

1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670
/**
 * 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 *cpu_dai = rtd->cpu_dai;
1671
	struct snd_soc_dai *codec_dai;
1672 1673 1674
	unsigned int i;
	int ret;

1675
	for_each_rtd_codec_dai(rtd, i, codec_dai) {
1676 1677 1678 1679 1680 1681 1682 1683 1684
		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 */
1685
	/* the component which has non_legacy_dai_naming is Codec */
1686
	if (cpu_dai->component->driver->non_legacy_dai_naming) {
1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
		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;
}
1717
EXPORT_SYMBOL_GPL(snd_soc_runtime_set_dai_fmt);
1718

1719

1720
#ifdef CONFIG_DMI
1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739
/* Trim special characters, and replace '-' with '_' since '-' is used to
 * separate different DMI fields in the card long name. Only number and
 * alphabet characters and a few separator characters are kept.
 */
static void cleanup_dmi_name(char *name)
{
	int i, j = 0;

	for (i = 0; name[i]; i++) {
		if (isalnum(name[i]) || (name[i] == '.')
		    || (name[i] == '_'))
			name[j++] = name[i];
		else if (name[i] == '-')
			name[j++] = '_';
	}

	name[j] = '\0';
}

1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750
/* Check if a DMI field is valid, i.e. not containing any string
 * in the black list.
 */
static int is_dmi_valid(const char *field)
{
	int i = 0;

	while (dmi_blacklist[i]) {
		if (strstr(field, dmi_blacklist[i]))
			return 0;
		i++;
1751
	}
1752 1753 1754 1755

	return 1;
}

1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797
/**
 * snd_soc_set_dmi_name() - Register DMI names to card
 * @card: The card to register DMI names
 * @flavour: The flavour "differentiator" for the card amongst its peers.
 *
 * An Intel machine driver may be used by many different devices but are
 * difficult for userspace to differentiate, since machine drivers ususally
 * use their own name as the card short name and leave the card long name
 * blank. To differentiate such devices and fix bugs due to lack of
 * device-specific configurations, this function allows DMI info to be used
 * as the sound card long name, in the format of
 * "vendor-product-version-board"
 * (Character '-' is used to separate different DMI fields here).
 * This will help the user space to load the device-specific Use Case Manager
 * (UCM) configurations for the card.
 *
 * Possible card long names may be:
 * DellInc.-XPS139343-01-0310JH
 * ASUSTeKCOMPUTERINC.-T100TA-1.0-T100TA
 * Circuitco-MinnowboardMaxD0PLATFORM-D0-MinnowBoardMAX
 *
 * This function also supports flavoring the card longname to provide
 * the extra differentiation, like "vendor-product-version-board-flavor".
 *
 * We only keep number and alphabet characters and a few separator characters
 * in the card long name since UCM in the user space uses the card long names
 * as card configuration directory names and AudoConf cannot support special
 * charactors like SPACE.
 *
 * Returns 0 on success, otherwise a negative error code.
 */
int snd_soc_set_dmi_name(struct snd_soc_card *card, const char *flavour)
{
	const char *vendor, *product, *product_version, *board;
	size_t longname_buf_size = sizeof(card->snd_card->longname);
	size_t len;

	if (card->long_name)
		return 0; /* long name already set by driver or from DMI */

	/* make up dmi long name as: vendor.product.version.board */
	vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
1798
	if (!vendor || !is_dmi_valid(vendor)) {
1799 1800 1801 1802
		dev_warn(card->dev, "ASoC: no DMI vendor name!\n");
		return 0;
	}

1803

1804 1805 1806 1807 1808
	snprintf(card->dmi_longname, sizeof(card->snd_card->longname),
			 "%s", vendor);
	cleanup_dmi_name(card->dmi_longname);

	product = dmi_get_system_info(DMI_PRODUCT_NAME);
1809
	if (product && is_dmi_valid(product)) {
1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822
		len = strlen(card->dmi_longname);
		snprintf(card->dmi_longname + len,
			 longname_buf_size - len,
			 "-%s", product);

		len++;	/* skip the separator "-" */
		if (len < longname_buf_size)
			cleanup_dmi_name(card->dmi_longname + len);

		/* some vendors like Lenovo may only put a self-explanatory
		 * name in the product version field
		 */
		product_version = dmi_get_system_info(DMI_PRODUCT_VERSION);
1823
		if (product_version && is_dmi_valid(product_version)) {
1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
			len = strlen(card->dmi_longname);
			snprintf(card->dmi_longname + len,
				 longname_buf_size - len,
				 "-%s", product_version);

			len++;
			if (len < longname_buf_size)
				cleanup_dmi_name(card->dmi_longname + len);
		}
	}

	board = dmi_get_system_info(DMI_BOARD_NAME);
1836
	if (board && is_dmi_valid(board)) {
1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868
		len = strlen(card->dmi_longname);
		snprintf(card->dmi_longname + len,
			 longname_buf_size - len,
			 "-%s", board);

		len++;
		if (len < longname_buf_size)
			cleanup_dmi_name(card->dmi_longname + len);
	} else if (!product) {
		/* fall back to using legacy name */
		dev_warn(card->dev, "ASoC: no DMI board/product name!\n");
		return 0;
	}

	/* Add flavour to dmi long name */
	if (flavour) {
		len = strlen(card->dmi_longname);
		snprintf(card->dmi_longname + len,
			 longname_buf_size - len,
			 "-%s", flavour);

		len++;
		if (len < longname_buf_size)
			cleanup_dmi_name(card->dmi_longname + len);
	}

	/* set the card long name */
	card->long_name = card->dmi_longname;

	return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_set_dmi_name);
1869
#endif /* CONFIG_DMI */
1870

1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903
static void soc_check_tplg_fes(struct snd_soc_card *card)
{
	struct snd_soc_component *component;
	const struct snd_soc_component_driver *comp_drv;
	struct snd_soc_dai_link *dai_link;
	int i;

	list_for_each_entry(component, &component_list, list) {

		/* does this component override FEs ? */
		if (!component->driver->ignore_machine)
			continue;

		/* for this machine ? */
		if (strcmp(component->driver->ignore_machine,
			   card->dev->driver->name))
			continue;

		/* machine matches, so override the rtd data */
		for (i = 0; i < card->num_links; i++) {

			dai_link = &card->dai_link[i];

			/* ignore this FE */
			if (dai_link->dynamic) {
				dai_link->ignore = true;
				continue;
			}

			dev_info(card->dev, "info: override FE DAI link %s\n",
				 card->dai_link[i].name);

			/* override platform component */
1904 1905 1906 1907 1908
			if (snd_soc_init_platform(card, dai_link) < 0) {
				dev_err(card->dev, "init platform error");
				continue;
			}
			dai_link->platform->name = component->name;
1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942

			/* convert non BE into BE */
			dai_link->no_pcm = 1;

			/* override any BE fixups */
			dai_link->be_hw_params_fixup =
				component->driver->be_hw_params_fixup;

			/* most BE links don't set stream name, so set it to
			 * dai link name if it's NULL to help bind widgets.
			 */
			if (!dai_link->stream_name)
				dai_link->stream_name = dai_link->name;
		}

		/* Inform userspace we are using alternate topology */
		if (component->driver->topology_name_prefix) {

			/* topology shortname created ? */
			if (!card->topology_shortname_created) {
				comp_drv = component->driver;

				snprintf(card->topology_shortname, 32, "%s-%s",
					 comp_drv->topology_name_prefix,
					 card->name);
				card->topology_shortname_created = true;
			}

			/* use topology shortname */
			card->name = card->topology_shortname;
		}
	}
}

1943
static int snd_soc_instantiate_card(struct snd_soc_card *card)
1944
{
1945
	struct snd_soc_pcm_runtime *rtd;
1946
	struct snd_soc_dai_link *dai_link;
1947
	int ret, i, order;
M
Mark Brown 已提交
1948

1949
	mutex_lock(&client_mutex);
1950
	mutex_lock_nested(&card->mutex, SND_SOC_CARD_CLASS_INIT);
1951

1952 1953 1954
	/* check whether any platform is ignore machine FE and using topology */
	soc_check_tplg_fes(card);

1955
	/* bind DAIs */
1956
	for (i = 0; i < card->num_links; i++) {
1957
		ret = soc_bind_dai_link(card, &card->dai_link[i]);
1958 1959 1960
		if (ret != 0)
			goto base_error;
	}
M
Mark Brown 已提交
1961

1962
	/* bind aux_devs too */
1963
	for (i = 0; i < card->num_aux_devs; i++) {
1964
		ret = soc_bind_aux_dev(card, i);
1965 1966
		if (ret != 0)
			goto base_error;
1967
	}
1968

1969 1970 1971 1972
	/* 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);

1973
	/* card bind complete so register a sound card */
1974
	ret = snd_card_new(card->dev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1,
1975 1976
			card->owner, 0, &card->snd_card);
	if (ret < 0) {
1977 1978 1979
		dev_err(card->dev,
			"ASoC: can't create sound card for card %s: %d\n",
			card->name, ret);
1980
		goto base_error;
1981 1982
	}

1983 1984
	soc_init_card_debugfs(card);

M
Mark Brown 已提交
1985 1986 1987 1988 1989
	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);

1990 1991 1992 1993
#ifdef CONFIG_DEBUG_FS
	snd_soc_dapm_debugfs_init(&card->dapm, card->debugfs_card_root);
#endif

1994
#ifdef CONFIG_PM_SLEEP
1995 1996 1997
	/* deferred resume work */
	INIT_WORK(&card->deferred_resume_work, soc_resume_deferred);
#endif
F
Frank Mandarino 已提交
1998

1999 2000 2001 2002
	if (card->dapm_widgets)
		snd_soc_dapm_new_controls(&card->dapm, card->dapm_widgets,
					  card->num_dapm_widgets);

2003 2004 2005 2006
	if (card->of_dapm_widgets)
		snd_soc_dapm_new_controls(&card->dapm, card->of_dapm_widgets,
					  card->num_of_dapm_widgets);

2007 2008
	/* initialise the sound card only once */
	if (card->probe) {
2009
		ret = card->probe(card);
2010 2011 2012
		if (ret < 0)
			goto card_probe_error;
	}
M
Mark Brown 已提交
2013

2014
	/* probe all components used by DAI links on this card */
2015 2016
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
			order++) {
2017 2018
		list_for_each_entry(rtd, &card->rtd_list, list) {
			ret = soc_probe_link_components(card, rtd, order);
2019
			if (ret < 0) {
2020 2021 2022
				dev_err(card->dev,
					"ASoC: failed to instantiate card %d\n",
					ret);
2023 2024 2025 2026 2027
				goto probe_dai_err;
			}
		}
	}

2028 2029 2030 2031 2032
	/* probe auxiliary components */
	ret = soc_probe_aux_devices(card);
	if (ret < 0)
		goto probe_dai_err;

2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047
	/* 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;
	}

2048 2049 2050
	/* probe all DAI links on this card */
	for (order = SND_SOC_COMP_ORDER_FIRST; order <= SND_SOC_COMP_ORDER_LAST;
			order++) {
2051 2052
		list_for_each_entry(rtd, &card->rtd_list, list) {
			ret = soc_probe_link_dais(card, rtd, order);
2053
			if (ret < 0) {
2054 2055 2056
				dev_err(card->dev,
					"ASoC: failed to instantiate card %d\n",
					ret);
2057 2058
				goto probe_dai_err;
			}
2059 2060
		}
	}
F
Frank Mandarino 已提交
2061

2062
	snd_soc_dapm_link_dai_widgets(card);
2063
	snd_soc_dapm_connect_dai_link_widgets(card);
2064

2065
	if (card->controls)
2066
		snd_soc_add_card_controls(card, card->controls, card->num_controls);
2067

2068 2069 2070 2071
	if (card->dapm_routes)
		snd_soc_dapm_add_routes(&card->dapm, card->dapm_routes,
					card->num_dapm_routes);

2072 2073 2074
	if (card->of_dapm_routes)
		snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,
					card->num_of_dapm_routes);
2075

2076 2077 2078
	/* try to set some sane longname if DMI is available */
	snd_soc_set_dmi_name(card, NULL);

2079 2080
	snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
		 "%s", card->name);
2081 2082
	snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
		 "%s", card->long_name ? card->long_name : card->name);
2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096
	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;
		}
	}
2097

2098 2099 2100
	if (card->late_probe) {
		ret = card->late_probe(card);
		if (ret < 0) {
2101
			dev_err(card->dev, "ASoC: %s late_probe() failed: %d\n",
2102 2103 2104 2105 2106
				card->name, ret);
			goto probe_aux_dev_err;
		}
	}

2107
	snd_soc_dapm_new_widgets(card);
2108

2109 2110
	ret = snd_card_register(card->snd_card);
	if (ret < 0) {
2111 2112
		dev_err(card->dev, "ASoC: failed to register soundcard %d\n",
				ret);
2113
		goto probe_aux_dev_err;
F
Frank Mandarino 已提交
2114 2115
	}

2116
	card->instantiated = 1;
2117
	snd_soc_dapm_sync(&card->dapm);
2118
	mutex_unlock(&card->mutex);
2119
	mutex_unlock(&client_mutex);
2120 2121

	return 0;
2122

2123
probe_aux_dev_err:
2124
	soc_remove_aux_devices(card);
2125

2126
probe_dai_err:
2127
	soc_remove_dai_links(card);
2128 2129

card_probe_error:
2130
	if (card->remove)
2131
		card->remove(card);
2132

2133
	snd_soc_dapm_free(&card->dapm);
2134
	soc_cleanup_card_debugfs(card);
2135 2136
	snd_card_free(card->snd_card);

2137
base_error:
2138
	soc_remove_pcm_runtimes(card);
2139
	mutex_unlock(&card->mutex);
2140
	mutex_unlock(&client_mutex);
F
Frank Mandarino 已提交
2141

2142
	return ret;
2143 2144 2145 2146 2147
}

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

2150 2151 2152 2153 2154 2155 2156
	/*
	 * no card, so machine driver should be registering card
	 * we should not be here in that case so ret error
	 */
	if (!card)
		return -EINVAL;

2157
	dev_warn(&pdev->dev,
2158
		 "ASoC: machine %s should use snd_soc_register_card()\n",
2159 2160
		 card->name);

2161 2162
	/* Bodge while we unpick instantiation */
	card->dev = &pdev->dev;
2163

2164
	return snd_soc_register_card(card);
F
Frank Mandarino 已提交
2165 2166
}

2167
static int soc_cleanup_card_resources(struct snd_soc_card *card)
F
Frank Mandarino 已提交
2168
{
2169
	struct snd_soc_pcm_runtime *rtd;
F
Frank Mandarino 已提交
2170

2171
	/* make sure any delayed work runs */
2172
	list_for_each_entry(rtd, &card->rtd_list, list)
2173
		flush_delayed_work(&rtd->delayed_work);
2174

2175 2176 2177
	/* free the ALSA card at first; this syncs with pending operations */
	snd_card_free(card->snd_card);

2178
	/* remove and free each DAI */
2179
	soc_remove_dai_links(card);
2180
	soc_remove_pcm_runtimes(card);
2181

2182 2183 2184
	/* remove auxiliary devices */
	soc_remove_aux_devices(card);

2185
	snd_soc_dapm_free(&card->dapm);
2186
	soc_cleanup_card_debugfs(card);
2187

2188 2189
	/* remove the card */
	if (card->remove)
2190
		card->remove(card);
2191

2192 2193 2194 2195 2196 2197 2198
	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 已提交
2199

M
Mark Brown 已提交
2200
	snd_soc_unregister_card(card);
F
Frank Mandarino 已提交
2201 2202 2203
	return 0;
}

2204
int snd_soc_poweroff(struct device *dev)
M
Mark Brown 已提交
2205
{
2206
	struct snd_soc_card *card = dev_get_drvdata(dev);
2207
	struct snd_soc_pcm_runtime *rtd;
M
Mark Brown 已提交
2208 2209

	if (!card->instantiated)
M
Mark Brown 已提交
2210
		return 0;
M
Mark Brown 已提交
2211 2212 2213

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

2217
	snd_soc_dapm_shutdown(card);
M
Mark Brown 已提交
2218

2219
	/* deactivate pins to sleep state */
2220
	list_for_each_entry(rtd, &card->rtd_list, list) {
2221
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2222
		struct snd_soc_dai *codec_dai;
2223
		int i;
2224

2225
		pinctrl_pm_select_sleep_state(cpu_dai->dev);
2226
		for_each_rtd_codec_dai(rtd, i, codec_dai) {
2227 2228
			pinctrl_pm_select_sleep_state(codec_dai->dev);
		}
2229 2230
	}

M
Mark Brown 已提交
2231
	return 0;
M
Mark Brown 已提交
2232
}
2233
EXPORT_SYMBOL_GPL(snd_soc_poweroff);
M
Mark Brown 已提交
2234

2235
const struct dev_pm_ops snd_soc_pm_ops = {
2236 2237 2238 2239
	.suspend = snd_soc_suspend,
	.resume = snd_soc_resume,
	.freeze = snd_soc_suspend,
	.thaw = snd_soc_resume,
2240
	.poweroff = snd_soc_poweroff,
2241
	.restore = snd_soc_resume,
M
Mark Brown 已提交
2242
};
2243
EXPORT_SYMBOL_GPL(snd_soc_pm_ops);
M
Mark Brown 已提交
2244

F
Frank Mandarino 已提交
2245 2246 2247 2248
/* ASoC platform driver */
static struct platform_driver soc_driver = {
	.driver		= {
		.name		= "soc-audio",
2249
		.pm		= &snd_soc_pm_ops,
F
Frank Mandarino 已提交
2250 2251 2252 2253 2254 2255 2256 2257 2258
	},
	.probe		= soc_probe,
	.remove		= soc_remove,
};

/**
 * snd_soc_cnew - create new control
 * @_template: control template
 * @data: control private data
M
Mark Brown 已提交
2259
 * @long_name: control long name
2260
 * @prefix: control name prefix
F
Frank Mandarino 已提交
2261 2262 2263 2264 2265 2266
 *
 * 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,
2267
				  void *data, const char *long_name,
2268
				  const char *prefix)
F
Frank Mandarino 已提交
2269 2270
{
	struct snd_kcontrol_new template;
2271 2272
	struct snd_kcontrol *kcontrol;
	char *name = NULL;
F
Frank Mandarino 已提交
2273 2274 2275 2276

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

2277 2278 2279 2280
	if (!long_name)
		long_name = template.name;

	if (prefix) {
2281
		name = kasprintf(GFP_KERNEL, "%s %s", prefix, long_name);
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294
		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 已提交
2295 2296 2297
}
EXPORT_SYMBOL_GPL(snd_soc_cnew);

2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308
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) {
2309 2310
			dev_err(dev, "ASoC: Failed to add %s: %d\n",
				control->name, err);
2311 2312 2313 2314 2315 2316 2317
			return err;
		}
	}

	return 0;
}

2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333
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);

2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352
/**
 * 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);

2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385
/**
 * 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)
{
2386
	struct snd_card *card = dai->component->card->snd_card;
2387 2388 2389 2390 2391 2392

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

2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404
/**
 * 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)
{
2405
	if (dai->driver->ops->set_sysclk)
2406
		return dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
2407 2408 2409

	return snd_soc_component_set_sysclk(dai->component, clk_id, 0,
					    freq, dir);
2410 2411 2412
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);

2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433
/**
 * snd_soc_component_set_sysclk - configure COMPONENT system or master clock.
 * @component: COMPONENT
 * @clk_id: DAI specific clock ID
 * @source: Source for the clock
 * @freq: new clock frequency in Hz
 * @dir: new clock direction - input/output.
 *
 * Configures the CODEC master (MCLK) or system (SYSCLK) clocking.
 */
int snd_soc_component_set_sysclk(struct snd_soc_component *component, int clk_id,
			     int source, unsigned int freq, int dir)
{
	if (component->driver->set_sysclk)
		return component->driver->set_sysclk(component, clk_id, source,
						 freq, dir);

	return -ENOTSUPP;
}
EXPORT_SYMBOL_GPL(snd_soc_component_set_sysclk);

2434 2435 2436
/**
 * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
 * @dai: DAI
M
Mark Brown 已提交
2437
 * @div_id: DAI specific clock divider ID
2438 2439 2440 2441 2442 2443 2444 2445 2446
 * @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)
{
2447
	if (dai->driver->ops->set_clkdiv)
2448
		return dai->driver->ops->set_clkdiv(dai, div_id, div);
2449 2450 2451 2452 2453 2454 2455 2456 2457
	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
2458
 * @source: DAI specific source for the PLL
2459 2460 2461 2462 2463
 * @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.
 */
2464 2465
int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
	unsigned int freq_in, unsigned int freq_out)
2466
{
2467
	if (dai->driver->ops->set_pll)
2468
		return dai->driver->ops->set_pll(dai, pll_id, source,
2469
					 freq_in, freq_out);
2470 2471 2472

	return snd_soc_component_set_pll(dai->component, pll_id, source,
					 freq_in, freq_out);
2473 2474 2475
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);

2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497
/*
 * snd_soc_component_set_pll - configure component PLL.
 * @component: COMPONENT
 * @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_component_set_pll(struct snd_soc_component *component, int pll_id,
			      int source, unsigned int freq_in,
			      unsigned int freq_out)
{
	if (component->driver->set_pll)
		return component->driver->set_pll(component, pll_id, source,
					      freq_in, freq_out);

	return -EINVAL;
}
EXPORT_SYMBOL_GPL(snd_soc_component_set_pll);

2498 2499 2500
/**
 * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
 * @dai: DAI
2501
 * @ratio: Ratio of BCLK to Sample rate.
2502 2503 2504 2505 2506
 *
 * 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)
{
2507
	if (dai->driver->ops->set_bclk_ratio)
2508 2509 2510 2511 2512 2513
		return dai->driver->ops->set_bclk_ratio(dai, ratio);
	else
		return -EINVAL;
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);

2514 2515 2516
/**
 * snd_soc_dai_set_fmt - configure DAI hardware audio format.
 * @dai: DAI
2517
 * @fmt: SND_SOC_DAIFMT_* format value.
2518 2519 2520 2521 2522
 *
 * Configures the DAI hardware format and clocking.
 */
int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
{
2523
	if (dai->driver == NULL)
2524
		return -EINVAL;
2525 2526 2527
	if (dai->driver->ops->set_fmt == NULL)
		return -ENOTSUPP;
	return dai->driver->ops->set_fmt(dai, fmt);
2528 2529 2530
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);

2531
/**
2532
 * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
2533 2534 2535 2536 2537 2538
 * @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.
 */
2539
static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554
					  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;
}

2555
/**
2556 2557
 * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
 * @dai: The DAI to configure
2558 2559
 * @tx_mask: bitmask representing active TX slots.
 * @rx_mask: bitmask representing active RX slots.
2560
 * @slots: Number of slots in use.
2561
 * @slot_width: Width in bits for each slot.
2562
 *
2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576
 * 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.
2577 2578
 */
int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
2579
	unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
2580
{
2581
	if (dai->driver->ops->xlate_tdm_slot_mask)
2582
		dai->driver->ops->xlate_tdm_slot_mask(slots,
2583 2584
						&tx_mask, &rx_mask);
	else
2585
		snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
2586

2587 2588 2589
	dai->tx_mask = tx_mask;
	dai->rx_mask = rx_mask;

2590
	if (dai->driver->ops->set_tdm_slot)
2591
		return dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,
2592
				slots, slot_width);
2593
	else
2594
		return -ENOTSUPP;
2595 2596 2597
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);

2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613
/**
 * 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)
{
2614
	if (dai->driver->ops->set_channel_map)
2615
		return dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
2616 2617 2618 2619 2620 2621
			rx_num, rx_slot);
	else
		return -EINVAL;
}
EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);

2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643
/**
 * snd_soc_dai_get_channel_map - Get 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
 */
int snd_soc_dai_get_channel_map(struct snd_soc_dai *dai,
	unsigned int *tx_num, unsigned int *tx_slot,
	unsigned int *rx_num, unsigned int *rx_slot)
{
	if (dai->driver->ops->get_channel_map)
		return dai->driver->ops->get_channel_map(dai, tx_num, tx_slot,
			rx_num, rx_slot);
	else
		return -ENOTSUPP;
}
EXPORT_SYMBOL_GPL(snd_soc_dai_get_channel_map);

2644 2645 2646 2647 2648 2649 2650 2651 2652
/**
 * 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)
{
2653
	if (dai->driver->ops->set_tristate)
2654
		return dai->driver->ops->set_tristate(dai, tristate);
2655 2656 2657 2658 2659 2660 2661 2662 2663
	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
2664
 * @direction: stream to mute
2665 2666 2667
 *
 * Mutes the DAI DAC.
 */
2668 2669
int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
			     int direction)
2670
{
2671 2672 2673 2674 2675 2676 2677
	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)
2678
		return dai->driver->ops->digital_mute(dai, mute);
2679
	else
2680
		return -ENOTSUPP;
2681 2682 2683
}
EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);

M
Mark Brown 已提交
2684 2685 2686
/**
 * snd_soc_register_card - Register a card with the ASoC core
 *
M
Mark Brown 已提交
2687
 * @card: Card to register
M
Mark Brown 已提交
2688 2689
 *
 */
2690
int snd_soc_register_card(struct snd_soc_card *card)
M
Mark Brown 已提交
2691
{
2692
	int i, ret;
2693
	struct snd_soc_pcm_runtime *rtd;
2694

M
Mark Brown 已提交
2695 2696 2697
	if (!card->name || !card->dev)
		return -EINVAL;

2698 2699 2700
	for (i = 0; i < card->num_links; i++) {
		struct snd_soc_dai_link *link = &card->dai_link[i];

2701
		ret = soc_init_dai_link(card, link);
2702
		if (ret) {
2703
			dev_err(card->dev, "ASoC: failed to init link %s\n",
2704
				link->name);
2705
			return ret;
2706 2707 2708
		}
	}

M
Mark Brown 已提交
2709 2710
	dev_set_drvdata(card->dev, card);

2711 2712
	snd_soc_initialize_card_lists(card);

2713 2714 2715
	INIT_LIST_HEAD(&card->dai_link_list);
	card->num_dai_links = 0;

2716 2717 2718
	INIT_LIST_HEAD(&card->rtd_list);
	card->num_rtd = 0;

2719
	INIT_LIST_HEAD(&card->dapm_dirty);
2720
	INIT_LIST_HEAD(&card->dobj_list);
M
Mark Brown 已提交
2721
	card->instantiated = 0;
2722
	mutex_init(&card->mutex);
2723
	mutex_init(&card->dapm_mutex);
M
Mark Brown 已提交
2724

2725 2726
	ret = snd_soc_instantiate_card(card);
	if (ret != 0)
2727
		return ret;
M
Mark Brown 已提交
2728

2729
	/* deactivate pins to sleep state */
2730
	list_for_each_entry(rtd, &card->rtd_list, list)  {
2731
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
2732
		struct snd_soc_dai *codec_dai;
2733 2734
		int j;

2735
		for_each_rtd_codec_dai(rtd, j, codec_dai) {
2736 2737 2738 2739
			if (!codec_dai->active)
				pinctrl_pm_select_sleep_state(codec_dai->dev);
		}

2740 2741 2742 2743
		if (!cpu_dai->active)
			pinctrl_pm_select_sleep_state(cpu_dai->dev);
	}

2744
	return ret;
M
Mark Brown 已提交
2745
}
2746
EXPORT_SYMBOL_GPL(snd_soc_register_card);
M
Mark Brown 已提交
2747 2748 2749 2750

/**
 * snd_soc_unregister_card - Unregister a card with the ASoC core
 *
M
Mark Brown 已提交
2751
 * @card: Card to unregister
M
Mark Brown 已提交
2752 2753
 *
 */
2754
int snd_soc_unregister_card(struct snd_soc_card *card)
M
Mark Brown 已提交
2755
{
2756 2757
	if (card->instantiated) {
		card->instantiated = false;
2758
		snd_soc_dapm_shutdown(card);
2759
		soc_cleanup_card_resources(card);
2760
		dev_dbg(card->dev, "ASoC: Unregistered card '%s'\n", card->name);
2761
	}
M
Mark Brown 已提交
2762 2763 2764

	return 0;
}
2765
EXPORT_SYMBOL_GPL(snd_soc_unregister_card);
M
Mark Brown 已提交
2766

2767 2768 2769 2770
/*
 * Simplify DAI link configuration by removing ".-1" from device names
 * and sanitizing names.
 */
2771
static char *fmt_single_name(struct device *dev, int *id)
2772 2773 2774 2775 2776 2777 2778
{
	char *found, name[NAME_SIZE];
	int id1, id2;

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

2779
	strlcpy(name, dev_name(dev), NAME_SIZE);
2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797

	/* 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 */
2798
			*id = ((id1 & 0xffff) << 16) + id2;
2799 2800 2801

			/* sanitize component name for DAI link creation */
			snprintf(tmp, NAME_SIZE, "%s.%s", dev->driver->name, name);
2802
			strlcpy(name, tmp, NAME_SIZE);
2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817
		} 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) {
2818 2819 2820
		dev_err(dev,
			"ASoC: error - multiple DAI %s registered with no name\n",
			dev_name(dev));
2821 2822 2823 2824 2825 2826
		return NULL;
	}

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

M
Mark Brown 已提交
2827
/**
2828
 * snd_soc_unregister_dai - Unregister DAIs from the ASoC core
M
Mark Brown 已提交
2829
 *
2830
 * @component: The component for which the DAIs should be unregistered
M
Mark Brown 已提交
2831
 */
2832
static void snd_soc_unregister_dais(struct snd_soc_component *component)
M
Mark Brown 已提交
2833
{
L
Lars-Peter Clausen 已提交
2834
	struct snd_soc_dai *dai, *_dai;
M
Mark Brown 已提交
2835

L
Lars-Peter Clausen 已提交
2836
	list_for_each_entry_safe(dai, _dai, &component->dai_list, list) {
2837 2838
		dev_dbg(component->dev, "ASoC: Unregistered DAI '%s'\n",
			dai->name);
L
Lars-Peter Clausen 已提交
2839
		list_del(&dai->list);
2840
		kfree(dai->name);
2841 2842
		kfree(dai);
	}
M
Mark Brown 已提交
2843 2844
}

2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887
/* 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;

2888
	list_add_tail(&dai->list, &component->dai_list);
2889 2890 2891 2892 2893 2894
	component->num_dai++;

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

M
Mark Brown 已提交
2895
/**
2896
 * snd_soc_register_dais - Register a DAI with the ASoC core
M
Mark Brown 已提交
2897
 *
2898 2899
 * @component: The component the DAIs are registered for
 * @dai_drv: DAI driver to use for the DAIs
M
Mark Brown 已提交
2900
 * @count: Number of DAIs
M
Mark Brown 已提交
2901
 */
2902
static int snd_soc_register_dais(struct snd_soc_component *component,
2903
				 struct snd_soc_dai_driver *dai_drv, size_t count)
M
Mark Brown 已提交
2904
{
2905
	struct device *dev = component->dev;
2906
	struct snd_soc_dai *dai;
2907 2908
	unsigned int i;
	int ret;
2909

2910
	dev_dbg(dev, "ASoC: dai register %s #%zu\n", dev_name(dev), count);
M
Mark Brown 已提交
2911 2912

	for (i = 0; i < count; i++) {
2913

2914
		dai = soc_add_dai(component, dai_drv + i,
2915
				  count == 1 && !component->driver->non_legacy_dai_naming);
2916 2917 2918 2919
		if (dai == NULL) {
			ret = -ENOMEM;
			goto err;
		}
M
Mark Brown 已提交
2920
	}
2921

M
Mark Brown 已提交
2922
	return 0;
2923

M
Mark Brown 已提交
2924
err:
2925
	snd_soc_unregister_dais(component);
2926

M
Mark Brown 已提交
2927 2928 2929
	return ret;
}

2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
/**
 * 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;
2947

2948 2949 2950 2951
	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 已提交
2952 2953
	}

2954 2955 2956 2957
	lockdep_assert_held(&client_mutex);
	dai = soc_add_dai(component, dai_drv, false);
	if (!dai)
		return -ENOMEM;
M
Mark Brown 已提交
2958

2959 2960 2961 2962 2963 2964 2965 2966
	/* 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 已提交
2967 2968 2969

	return ret;
}
2970
EXPORT_SYMBOL_GPL(snd_soc_register_dai);
M
Mark Brown 已提交
2971

2972 2973
static void snd_soc_component_seq_notifier(struct snd_soc_dapm_context *dapm,
	enum snd_soc_dapm_type type, int subseq)
2974
{
2975
	struct snd_soc_component *component = dapm->component;
2976

2977 2978
	component->driver->seq_notifier(component, type, subseq);
}
2979

2980 2981 2982 2983
static int snd_soc_component_stream_event(struct snd_soc_dapm_context *dapm,
	int event)
{
	struct snd_soc_component *component = dapm->component;
2984

2985 2986
	return component->driver->stream_event(component, event);
}
2987

2988 2989 2990 2991 2992 2993 2994 2995
static int snd_soc_component_set_bias_level(struct snd_soc_dapm_context *dapm,
					enum snd_soc_bias_level level)
{
	struct snd_soc_component *component = dapm->component;

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

2996 2997
static int snd_soc_component_initialize(struct snd_soc_component *component,
	const struct snd_soc_component_driver *driver, struct device *dev)
2998
{
2999 3000
	struct snd_soc_dapm_context *dapm;

3001 3002 3003
	component->name = fmt_single_name(dev, &component->id);
	if (!component->name) {
		dev_err(dev, "ASoC: Failed to allocate name\n");
3004 3005 3006
		return -ENOMEM;
	}

3007 3008
	component->dev = dev;
	component->driver = driver;
3009

3010
	dapm = snd_soc_component_get_dapm(component);
3011 3012 3013
	dapm->dev = dev;
	dapm->component = component;
	dapm->bias_level = SND_SOC_BIAS_OFF;
3014 3015
	dapm->idle_bias_off = !driver->idle_bias_on;
	dapm->suspend_bias_off = driver->suspend_bias_off;
3016 3017 3018 3019
	if (driver->seq_notifier)
		dapm->seq_notifier = snd_soc_component_seq_notifier;
	if (driver->stream_event)
		dapm->stream_event = snd_soc_component_stream_event;
3020 3021
	if (driver->set_bias_level)
		dapm->set_bias_level = snd_soc_component_set_bias_level;
3022

3023 3024
	INIT_LIST_HEAD(&component->dai_list);
	mutex_init(&component->io_mutex);
3025

3026 3027
	return 0;
}
3028

3029
static void snd_soc_component_setup_regmap(struct snd_soc_component *component)
3030
{
3031 3032 3033 3034 3035 3036 3037
	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;
}

3038 3039
#ifdef CONFIG_REGMAP

3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054
/**
 * 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);
3055
}
3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073
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);
3074

3075
#endif
3076

3077
static void snd_soc_component_add(struct snd_soc_component *component)
3078
{
3079 3080
	mutex_lock(&client_mutex);

3081
	if (!component->driver->write && !component->driver->read) {
3082 3083 3084 3085 3086
		if (!component->regmap)
			component->regmap = dev_get_regmap(component->dev, NULL);
		if (component->regmap)
			snd_soc_component_setup_regmap(component);
	}
3087

3088
	list_add(&component->list, &component_list);
3089
	INIT_LIST_HEAD(&component->dobj_list);
3090 3091

	mutex_unlock(&client_mutex);
3092
}
3093

3094 3095 3096 3097 3098
static void snd_soc_component_cleanup(struct snd_soc_component *component)
{
	snd_soc_unregister_dais(component);
	kfree(component->name);
}
3099

3100 3101
static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
{
3102 3103 3104 3105 3106
	struct snd_soc_card *card = component->card;

	if (card)
		snd_soc_unregister_card(card);

3107 3108
	list_del(&component->list);
}
3109

3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144
#define ENDIANNESS_MAP(name) \
	(SNDRV_PCM_FMTBIT_##name##LE | SNDRV_PCM_FMTBIT_##name##BE)
static u64 endianness_format_map[] = {
	ENDIANNESS_MAP(S16_),
	ENDIANNESS_MAP(U16_),
	ENDIANNESS_MAP(S24_),
	ENDIANNESS_MAP(U24_),
	ENDIANNESS_MAP(S32_),
	ENDIANNESS_MAP(U32_),
	ENDIANNESS_MAP(S24_3),
	ENDIANNESS_MAP(U24_3),
	ENDIANNESS_MAP(S20_3),
	ENDIANNESS_MAP(U20_3),
	ENDIANNESS_MAP(S18_3),
	ENDIANNESS_MAP(U18_3),
	ENDIANNESS_MAP(FLOAT_),
	ENDIANNESS_MAP(FLOAT64_),
	ENDIANNESS_MAP(IEC958_SUBFRAME_),
};

/*
 * 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 convert_endianness_formats(struct snd_soc_pcm_stream *stream)
{
	int i;

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

3145 3146 3147 3148 3149
int snd_soc_add_component(struct device *dev,
			struct snd_soc_component *component,
			const struct snd_soc_component_driver *component_driver,
			struct snd_soc_dai_driver *dai_drv,
			int num_dai)
3150
{
3151
	int ret;
3152
	int i;
3153

3154
	ret = snd_soc_component_initialize(component, component_driver, dev);
3155 3156 3157
	if (ret)
		goto err_free;

3158 3159 3160 3161 3162 3163 3164
	if (component_driver->endianness) {
		for (i = 0; i < num_dai; i++) {
			convert_endianness_formats(&dai_drv[i].playback);
			convert_endianness_formats(&dai_drv[i].capture);
		}
	}

3165
	ret = snd_soc_register_dais(component, dai_drv, num_dai);
3166
	if (ret < 0) {
3167
		dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
3168 3169
		goto err_cleanup;
	}
3170

3171
	snd_soc_component_add(component);
3172

3173
	return 0;
3174

3175
err_cleanup:
3176
	snd_soc_component_cleanup(component);
3177 3178
err_free:
	return ret;
3179
}
3180 3181 3182 3183 3184 3185 3186 3187 3188
EXPORT_SYMBOL_GPL(snd_soc_add_component);

int snd_soc_register_component(struct device *dev,
			const struct snd_soc_component_driver *component_driver,
			struct snd_soc_dai_driver *dai_drv,
			int num_dai)
{
	struct snd_soc_component *component;

3189
	component = devm_kzalloc(dev, sizeof(*component), GFP_KERNEL);
3190
	if (!component)
3191 3192 3193 3194 3195
		return -ENOMEM;

	return snd_soc_add_component(dev, component, component_driver,
				     dai_drv, num_dai);
}
3196
EXPORT_SYMBOL_GPL(snd_soc_register_component);
3197

3198
/**
3199 3200
 * snd_soc_unregister_component - Unregister all related component
 * from the ASoC core
3201
 *
3202
 * @dev: The device to unregister
3203
 */
3204
static int __snd_soc_unregister_component(struct device *dev)
3205
{
3206
	struct snd_soc_component *component;
3207
	int found = 0;
3208

3209
	mutex_lock(&client_mutex);
3210
	list_for_each_entry(component, &component_list, list) {
3211
		if (dev != component->dev)
3212 3213 3214 3215 3216 3217
			continue;

		snd_soc_tplg_component_remove(component, SND_SOC_TPLG_INDEX_ALL);
		snd_soc_component_del_unlocked(component);
		found = 1;
		break;
3218
	}
3219
	mutex_unlock(&client_mutex);
3220

3221 3222 3223
	if (found) {
		snd_soc_component_cleanup(component);
	}
3224 3225 3226 3227 3228 3229 3230

	return found;
}

void snd_soc_unregister_component(struct device *dev)
{
	while (__snd_soc_unregister_component(dev));
3231 3232 3233
}
EXPORT_SYMBOL_GPL(snd_soc_unregister_component);

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
struct snd_soc_component *snd_soc_lookup_component(struct device *dev,
						   const char *driver_name)
{
	struct snd_soc_component *component;
	struct snd_soc_component *ret;

	ret = NULL;
	mutex_lock(&client_mutex);
	list_for_each_entry(component, &component_list, list) {
		if (dev != component->dev)
			continue;

		if (driver_name &&
		    (driver_name != component->driver->name) &&
		    (strcmp(component->driver->name, driver_name) != 0))
			continue;

		ret = component;
		break;
	}
	mutex_unlock(&client_mutex);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_lookup_component);

3260
/* Retrieve a card's name from device tree */
3261 3262
int snd_soc_of_parse_card_name(struct snd_soc_card *card,
			       const char *propname)
3263
{
3264
	struct device_node *np;
3265 3266
	int ret;

3267 3268 3269 3270 3271
	if (!card->dev) {
		pr_err("card->dev is not set before calling %s\n", __func__);
		return -EINVAL;
	}

3272
	np = card->dev->of_node;
3273

3274 3275 3276 3277 3278 3279 3280 3281
	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,
3282
			"ASoC: Property '%s' could not be read: %d\n",
3283 3284 3285 3286 3287 3288
			propname, ret);
		return ret;
	}

	return 0;
}
3289
EXPORT_SYMBOL_GPL(snd_soc_of_parse_card_name);
3290

3291 3292 3293 3294 3295 3296 3297
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),
};

3298
int snd_soc_of_parse_audio_simple_widgets(struct snd_soc_card *card,
3299 3300
					  const char *propname)
{
3301
	struct device_node *np = card->dev->of_node;
3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370
	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;
	}

3371 3372
	card->of_dapm_widgets = widgets;
	card->num_of_dapm_widgets = num_widgets;
3373 3374 3375

	return 0;
}
3376
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_simple_widgets);
3377

3378 3379 3380
int snd_soc_of_get_slot_mask(struct device_node *np,
			     const char *prop_name,
			     unsigned int *mask)
3381 3382
{
	u32 val;
3383
	const __be32 *of_slot_mask = of_get_property(np, prop_name, &val);
3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394
	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;
}
3395
EXPORT_SYMBOL_GPL(snd_soc_of_get_slot_mask);
3396

3397
int snd_soc_of_parse_tdm_slot(struct device_node *np,
3398 3399
			      unsigned int *tx_mask,
			      unsigned int *rx_mask,
3400 3401 3402 3403 3404 3405
			      unsigned int *slots,
			      unsigned int *slot_width)
{
	u32 val;
	int ret;

3406 3407 3408 3409 3410
	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);

3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432
	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);

3433
void snd_soc_of_parse_audio_prefix(struct snd_soc_card *card,
3434 3435 3436 3437
				   struct snd_soc_codec_conf *codec_conf,
				   struct device_node *of_node,
				   const char *propname)
{
3438
	struct device_node *np = card->dev->of_node;
3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450
	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;
}
3451
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_prefix);
3452

3453
int snd_soc_of_parse_audio_routing(struct snd_soc_card *card,
3454 3455
				   const char *propname)
{
3456
	struct device_node *np = card->dev->of_node;
3457
	int num_routes;
3458 3459 3460 3461
	struct snd_soc_dapm_route *routes;
	int i, ret;

	num_routes = of_property_count_strings(np, propname);
3462
	if (num_routes < 0 || num_routes & 1) {
3463 3464 3465
		dev_err(card->dev,
			"ASoC: Property '%s' does not exist or its length is not even\n",
			propname);
3466 3467 3468 3469
		return -EINVAL;
	}
	num_routes /= 2;
	if (!num_routes) {
3470
		dev_err(card->dev, "ASoC: Property '%s's length is zero\n",
3471 3472 3473 3474
			propname);
		return -EINVAL;
	}

3475
	routes = devm_kcalloc(card->dev, num_routes, sizeof(*routes),
3476 3477 3478
			      GFP_KERNEL);
	if (!routes) {
		dev_err(card->dev,
3479
			"ASoC: Could not allocate DAPM route table\n");
3480 3481 3482 3483 3484
		return -EINVAL;
	}

	for (i = 0; i < num_routes; i++) {
		ret = of_property_read_string_index(np, propname,
3485
			2 * i, &routes[i].sink);
3486
		if (ret) {
3487 3488 3489
			dev_err(card->dev,
				"ASoC: Property '%s' index %d could not be read: %d\n",
				propname, 2 * i, ret);
3490 3491 3492
			return -EINVAL;
		}
		ret = of_property_read_string_index(np, propname,
3493
			(2 * i) + 1, &routes[i].source);
3494 3495
		if (ret) {
			dev_err(card->dev,
3496 3497
				"ASoC: Property '%s' index %d could not be read: %d\n",
				propname, (2 * i) + 1, ret);
3498 3499 3500 3501
			return -EINVAL;
		}
	}

3502 3503
	card->num_of_dapm_routes = num_routes;
	card->of_dapm_routes = routes;
3504 3505 3506

	return 0;
}
3507
EXPORT_SYMBOL_GPL(snd_soc_of_parse_audio_routing);
3508

3509
unsigned int snd_soc_of_parse_daifmt(struct device_node *np,
3510 3511 3512
				     const char *prefix,
				     struct device_node **bitclkmaster,
				     struct device_node **framemaster)
3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537
{
	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 = "";

	/*
3538 3539
	 * check "dai-format = xxx"
	 * or    "[prefix]format = xxx"
3540 3541
	 * SND_SOC_DAIFMT_FORMAT_MASK area
	 */
3542 3543 3544 3545 3546
	ret = of_property_read_string(np, "dai-format", &str);
	if (ret < 0) {
		snprintf(prop, sizeof(prop), "%sformat", prefix);
		ret = of_property_read_string(np, prop, &str);
	}
3547 3548 3549 3550 3551 3552 3553 3554 3555 3556
	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;
			}
		}
	}

	/*
3557
	 * check "[prefix]continuous-clock"
3558 3559
	 * SND_SOC_DAIFMT_CLOCK_MASK area
	 */
3560
	snprintf(prop, sizeof(prop), "%scontinuous-clock", prefix);
J
Julia Lawall 已提交
3561
	if (of_property_read_bool(np, prop))
3562 3563 3564
		format |= SND_SOC_DAIFMT_CONT;
	else
		format |= SND_SOC_DAIFMT_GATED;
3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598

	/*
	 * 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);
3599 3600
	if (bit && bitclkmaster)
		*bitclkmaster = of_parse_phandle(np, prop, 0);
3601 3602 3603

	snprintf(prop, sizeof(prop), "%sframe-master", prefix);
	frame = !!of_get_property(np, prop, NULL);
3604 3605
	if (frame && framemaster)
		*framemaster = of_parse_phandle(np, prop, 0);
3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625

	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);

3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657
int snd_soc_get_dai_id(struct device_node *ep)
{
	struct snd_soc_component *pos;
	struct device_node *node;
	int ret;

	node = of_graph_get_port_parent(ep);

	/*
	 * For example HDMI case, HDMI has video/sound port,
	 * but ALSA SoC needs sound port number only.
	 * Thus counting HDMI DT port/endpoint doesn't work.
	 * Then, it should have .of_xlate_dai_id
	 */
	ret = -ENOTSUPP;
	mutex_lock(&client_mutex);
	list_for_each_entry(pos, &component_list, list) {
		struct device_node *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 != node)
			continue;

		if (pos->driver->of_xlate_dai_id)
			ret = pos->driver->of_xlate_dai_id(pos, ep);

		break;
	}
	mutex_unlock(&client_mutex);

3658 3659
	of_node_put(node);

3660 3661 3662 3663
	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_get_dai_id);

3664
int snd_soc_get_dai_name(struct of_phandle_args *args,
3665
				const char **dai_name)
3666 3667
{
	struct snd_soc_component *pos;
3668
	struct device_node *component_of_node;
3669
	int ret = -EPROBE_DEFER;
3670 3671 3672

	mutex_lock(&client_mutex);
	list_for_each_entry(pos, &component_list, list) {
3673 3674 3675 3676 3677
		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)
3678 3679
			continue;

3680
		if (pos->driver->of_xlate_dai_name) {
3681 3682 3683
			ret = pos->driver->of_xlate_dai_name(pos,
							     args,
							     dai_name);
3684
		} else {
3685
			struct snd_soc_dai *dai;
3686 3687
			int id = -1;

3688
			switch (args->args_count) {
3689 3690 3691 3692
			case 0:
				id = 0; /* same as dai_drv[0] */
				break;
			case 1:
3693
				id = args->args[0];
3694 3695 3696 3697 3698 3699 3700 3701
				break;
			default:
				/* not supported */
				break;
			}

			if (id < 0 || id >= pos->num_dai) {
				ret = -EINVAL;
3702
				continue;
3703
			}
X
Xiubo Li 已提交
3704 3705 3706

			ret = 0;

3707 3708 3709 3710 3711 3712 3713 3714
			/* find target DAI */
			list_for_each_entry(dai, &pos->dai_list, list) {
				if (id == 0)
					break;
				id--;
			}

			*dai_name = dai->driver->name;
X
Xiubo Li 已提交
3715 3716
			if (!*dai_name)
				*dai_name = pos->name;
3717 3718 3719 3720 3721
		}

		break;
	}
	mutex_unlock(&client_mutex);
3722 3723
	return ret;
}
3724
EXPORT_SYMBOL_GPL(snd_soc_get_dai_name);
3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737

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);
3738 3739 3740 3741 3742 3743 3744

	of_node_put(args.np);

	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_name);

3745 3746 3747 3748 3749 3750 3751 3752
/*
 * snd_soc_of_put_dai_link_codecs - Dereference device nodes in the codecs array
 * @dai_link: DAI link
 *
 * Dereference device nodes acquired by snd_soc_of_get_dai_link_codecs().
 */
void snd_soc_of_put_dai_link_codecs(struct snd_soc_dai_link *dai_link)
{
3753
	struct snd_soc_dai_link_component *component;
3754 3755
	int index;

3756
	for_each_link_codecs(dai_link, index, component) {
3757 3758 3759 3760 3761 3762 3763 3764
		if (!component->of_node)
			break;
		of_node_put(component->of_node);
		component->of_node = NULL;
	}
}
EXPORT_SYMBOL_GPL(snd_soc_of_put_dai_link_codecs);

3765 3766 3767 3768 3769 3770 3771 3772 3773
/*
 * 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.
3774 3775
 * The device nodes in the array (of_node) must be dereferenced by calling
 * snd_soc_of_put_dai_link_codecs() on @dai_link.
3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798
 *
 * 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;
	}
3799 3800
	component = devm_kcalloc(dev,
				 num_codecs, sizeof(*component),
3801 3802 3803 3804 3805 3806 3807
				 GFP_KERNEL);
	if (!component)
		return -ENOMEM;
	dai_link->codecs = component;
	dai_link->num_codecs = num_codecs;

	/* Parse the list */
3808
	for_each_link_codecs(dai_link, index, component) {
3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820
		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:
3821
	snd_soc_of_put_dai_link_codecs(dai_link);
3822 3823 3824 3825 3826 3827
	dai_link->codecs = NULL;
	dai_link->num_codecs = 0;
	return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);

3828
static int __init snd_soc_init(void)
F
Frank Mandarino 已提交
3829
{
3830
	snd_soc_debugfs_init();
3831 3832
	snd_soc_util_init();

F
Frank Mandarino 已提交
3833 3834
	return platform_driver_register(&soc_driver);
}
3835
module_init(snd_soc_init);
F
Frank Mandarino 已提交
3836

M
Mark Brown 已提交
3837
static void __exit snd_soc_exit(void)
F
Frank Mandarino 已提交
3838
{
3839
	snd_soc_util_exit();
3840
	snd_soc_debugfs_exit();
3841

3842
	platform_driver_unregister(&soc_driver);
F
Frank Mandarino 已提交
3843 3844 3845 3846
}
module_exit(snd_soc_exit);

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