soc-pcm.c 81.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
// SPDX-License-Identifier: GPL-2.0+
//
// soc-pcm.c  --  ALSA SoC PCM
//
// Copyright 2005 Wolfson Microelectronics PLC.
// Copyright 2005 Openedhand Ltd.
// Copyright (C) 2010 Slimlogic Ltd.
// Copyright (C) 2010 Texas Instruments Inc.
//
// Authors: Liam Girdwood <lrg@ti.com>
//          Mark Brown <broonie@opensource.wolfsonmicro.com>
12 13 14 15

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/delay.h>
16
#include <linux/pinctrl/consumer.h>
17 18
#include <linux/slab.h>
#include <linux/workqueue.h>
19
#include <linux/export.h>
20
#include <linux/debugfs.h>
21 22 23 24
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
25
#include <sound/soc-dpcm.h>
26
#include <sound/soc-link.h>
27 28
#include <sound/initval.h>

29 30 31 32 33 34 35 36 37 38 39 40
#define soc_pcm_ret(rtd, ret) _soc_pcm_ret(rtd, __func__, ret)
static inline int _soc_pcm_ret(struct snd_soc_pcm_runtime *rtd,
			       const char *func, int ret)
{
	/* Positive, Zero values are not errors */
	if (ret >= 0)
		return ret;

	/* Negative values might be errors */
	switch (ret) {
	case -EPROBE_DEFER:
	case -ENOTSUPP:
41
	case -EINVAL:
42 43 44 45 46 47 48 49 50 51
		break;
	default:
		dev_err(rtd->dev,
			"ASoC: error at %s on %s: %d\n",
			func, rtd->dai_link->name, ret);
	}

	return ret;
}

52 53 54 55 56 57
static inline void snd_soc_dpcm_stream_lock_irq(struct snd_soc_pcm_runtime *rtd,
						int stream)
{
	snd_pcm_stream_lock_irq(snd_soc_dpcm_get_substream(rtd, stream));
}

58 59
#define snd_soc_dpcm_stream_lock_irqsave_nested(rtd, stream, flags) \
	snd_pcm_stream_lock_irqsave_nested(snd_soc_dpcm_get_substream(rtd, stream), flags)
60

61 62 63 64 65 66
static inline void snd_soc_dpcm_stream_unlock_irq(struct snd_soc_pcm_runtime *rtd,
						  int stream)
{
	snd_pcm_stream_unlock_irq(snd_soc_dpcm_get_substream(rtd, stream));
}

67 68 69
#define snd_soc_dpcm_stream_unlock_irqrestore(rtd, stream, flags) \
	snd_pcm_stream_unlock_irqrestore(snd_soc_dpcm_get_substream(rtd, stream), flags)

70 71
#define DPCM_MAX_BE_USERS	8

72 73
static inline const char *soc_cpu_dai_name(struct snd_soc_pcm_runtime *rtd)
{
74
	return (rtd)->dai_link->num_cpus == 1 ? snd_soc_rtd_to_cpu(rtd, 0)->name : "multicpu";
75 76 77
}
static inline const char *soc_codec_dai_name(struct snd_soc_pcm_runtime *rtd)
{
78
	return (rtd)->dai_link->num_codecs == 1 ? snd_soc_rtd_to_codec(rtd, 0)->name : "multicodec";
79 80
}

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
#ifdef CONFIG_DEBUG_FS
static const char *dpcm_state_string(enum snd_soc_dpcm_state state)
{
	switch (state) {
	case SND_SOC_DPCM_STATE_NEW:
		return "new";
	case SND_SOC_DPCM_STATE_OPEN:
		return "open";
	case SND_SOC_DPCM_STATE_HW_PARAMS:
		return "hw_params";
	case SND_SOC_DPCM_STATE_PREPARE:
		return "prepare";
	case SND_SOC_DPCM_STATE_START:
		return "start";
	case SND_SOC_DPCM_STATE_STOP:
		return "stop";
	case SND_SOC_DPCM_STATE_SUSPEND:
		return "suspend";
	case SND_SOC_DPCM_STATE_PAUSED:
		return "paused";
	case SND_SOC_DPCM_STATE_HW_FREE:
		return "hw_free";
	case SND_SOC_DPCM_STATE_CLOSE:
		return "close";
	}

	return "unknown";
}

static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe,
			       int stream, char *buf, size_t size)
{
	struct snd_pcm_hw_params *params = &fe->dpcm[stream].hw_params;
	struct snd_soc_dpcm *dpcm;
	ssize_t offset = 0;

	/* FE state */
118
	offset += scnprintf(buf + offset, size - offset,
119 120 121
			   "[%s - %s]\n", fe->dai_link->name,
			   stream ? "Capture" : "Playback");

122
	offset += scnprintf(buf + offset, size - offset, "State: %s\n",
123 124 125 126
			   dpcm_state_string(fe->dpcm[stream].state));

	if ((fe->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
	    (fe->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
127
		offset += scnprintf(buf + offset, size - offset,
128 129 130 131 132 133 134
				   "Hardware Params: "
				   "Format = %s, Channels = %d, Rate = %d\n",
				   snd_pcm_format_name(params_format(params)),
				   params_channels(params),
				   params_rate(params));

	/* BEs state */
135
	offset += scnprintf(buf + offset, size - offset, "Backends:\n");
136 137

	if (list_empty(&fe->dpcm[stream].be_clients)) {
138
		offset += scnprintf(buf + offset, size - offset,
139 140 141 142 143 144
				   " No active DSP links\n");
		goto out;
	}

	for_each_dpcm_be(fe, stream, dpcm) {
		struct snd_soc_pcm_runtime *be = dpcm->be;
145
		params = &be->dpcm[stream].hw_params;
146

147
		offset += scnprintf(buf + offset, size - offset,
148 149
				   "- %s\n", be->dai_link->name);

150
		offset += scnprintf(buf + offset, size - offset,
151 152 153 154 155
				   "   State: %s\n",
				   dpcm_state_string(be->dpcm[stream].state));

		if ((be->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
		    (be->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
156
			offset += scnprintf(buf + offset, size - offset,
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
					   "   Hardware Params: "
					   "Format = %s, Channels = %d, Rate = %d\n",
					   snd_pcm_format_name(params_format(params)),
					   params_channels(params),
					   params_rate(params));
	}
out:
	return offset;
}

static ssize_t dpcm_state_read_file(struct file *file, char __user *user_buf,
				    size_t count, loff_t *ppos)
{
	struct snd_soc_pcm_runtime *fe = file->private_data;
	ssize_t out_count = PAGE_SIZE, offset = 0, ret = 0;
	int stream;
	char *buf;

175
	if (fe->dai_link->num_cpus > 1) {
176 177 178 179 180
		dev_err(fe->dev,
			"%s doesn't support Multi CPU yet\n", __func__);
		return -EINVAL;
	}

181 182 183 184
	buf = kmalloc(out_count, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

185
	snd_soc_dpcm_mutex_lock(fe);
186
	for_each_pcm_streams(stream)
187
		if (snd_soc_dai_stream_valid(snd_soc_rtd_to_cpu(fe, 0), stream))
188 189 190
			offset += dpcm_show_state(fe, stream,
						  buf + offset,
						  out_count - offset);
191
	snd_soc_dpcm_mutex_unlock(fe);
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218

	ret = simple_read_from_buffer(user_buf, count, ppos, buf, offset);

	kfree(buf);
	return ret;
}

static const struct file_operations dpcm_state_fops = {
	.open = simple_open,
	.read = dpcm_state_read_file,
	.llseek = default_llseek,
};

void soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
{
	if (!rtd->dai_link->dynamic)
		return;

	if (!rtd->card->debugfs_card_root)
		return;

	rtd->debugfs_dpcm_root = debugfs_create_dir(rtd->dai_link->name,
						    rtd->card->debugfs_card_root);

	debugfs_create_file("state", 0444, rtd->debugfs_dpcm_root,
			    rtd, &dpcm_state_fops);
}
219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248

static void dpcm_create_debugfs_state(struct snd_soc_dpcm *dpcm, int stream)
{
	char *name;

	name = kasprintf(GFP_KERNEL, "%s:%s", dpcm->be->dai_link->name,
			 stream ? "capture" : "playback");
	if (name) {
		dpcm->debugfs_state = debugfs_create_dir(
			name, dpcm->fe->debugfs_dpcm_root);
		debugfs_create_u32("state", 0644, dpcm->debugfs_state,
				   &dpcm->state);
		kfree(name);
	}
}

static void dpcm_remove_debugfs_state(struct snd_soc_dpcm *dpcm)
{
	debugfs_remove_recursive(dpcm->debugfs_state);
}

#else
static inline void dpcm_create_debugfs_state(struct snd_soc_dpcm *dpcm,
					     int stream)
{
}

static inline void dpcm_remove_debugfs_state(struct snd_soc_dpcm *dpcm)
{
}
249 250
#endif

251 252 253 254 255 256 257 258 259 260 261 262
/* Set FE's runtime_update state; the state is protected via PCM stream lock
 * for avoiding the race with trigger callback.
 * If the state is unset and a trigger is pending while the previous operation,
 * process the pending trigger action here.
 */
static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd);
static void dpcm_set_fe_update_state(struct snd_soc_pcm_runtime *fe,
				     int stream, enum snd_soc_dpcm_update state)
{
	struct snd_pcm_substream *substream =
		snd_soc_dpcm_get_substream(fe, stream);

263
	snd_soc_dpcm_stream_lock_irq(fe, stream);
264 265 266 267 268 269
	if (state == SND_SOC_DPCM_UPDATE_NO && fe->dpcm[stream].trigger_pending) {
		dpcm_fe_dai_do_trigger(substream,
				       fe->dpcm[stream].trigger_pending - 1);
		fe->dpcm[stream].trigger_pending = 0;
	}
	fe->dpcm[stream].runtime_update = state;
270
	snd_soc_dpcm_stream_unlock_irq(fe, stream);
271 272
}

273 274 275 276 277 278
static void dpcm_set_be_update_state(struct snd_soc_pcm_runtime *be,
				     int stream, enum snd_soc_dpcm_update state)
{
	be->dpcm[stream].runtime_update = state;
}

279 280 281 282 283
/**
 * snd_soc_runtime_action() - Increment/Decrement active count for
 * PCM runtime components
 * @rtd: ASoC PCM runtime that is activated
 * @stream: Direction of the PCM stream
284
 * @action: Activate stream if 1. Deactivate if -1.
285 286 287 288 289 290 291 292 293
 *
 * Increments/Decrements the active count for all the DAIs and components
 * attached to a PCM runtime.
 * Should typically be called when a stream is opened.
 *
 * Must be called with the rtd->card->pcm_mutex being held
 */
void snd_soc_runtime_action(struct snd_soc_pcm_runtime *rtd,
			    int stream, int action)
294
{
295
	struct snd_soc_component *component;
296
	struct snd_soc_dai *dai;
297
	int i;
298

299
	snd_soc_dpcm_mutex_assert_held(rtd);
300

301 302
	for_each_rtd_dais(rtd, i, dai)
		snd_soc_dai_action(dai, stream, action);
303 304 305 306 307 308 309

	/* Increments/Decrements the active count for components without DAIs */
	for_each_rtd_components(rtd, i, component) {
		if (component->num_dai)
			continue;
		component->active += action;
	}
310
}
311
EXPORT_SYMBOL_GPL(snd_soc_runtime_action);
312

313 314 315 316 317 318 319 320 321 322 323
/**
 * snd_soc_runtime_ignore_pmdown_time() - Check whether to ignore the power down delay
 * @rtd: The ASoC PCM runtime that should be checked.
 *
 * This function checks whether the power down delay should be ignored for a
 * specific PCM runtime. Returns true if the delay is 0, if it the DAI link has
 * been configured to ignore the delay, or if none of the components benefits
 * from having the delay.
 */
bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd)
{
324
	struct snd_soc_component *component;
325
	bool ignore = true;
326
	int i;
327

328 329 330
	if (!rtd->pmdown_time || rtd->dai_link->ignore_pmdown_time)
		return true;

331
	for_each_rtd_components(rtd, i, component)
332
		ignore &= !component->driver->use_pmdown_time;
333 334

	return ignore;
335 336
}

337 338 339 340 341 342 343 344 345 346
/**
 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
 * @substream: the pcm substream
 * @hw: the hardware parameters
 *
 * Sets the substream runtime hardware parameters.
 */
int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
	const struct snd_pcm_hardware *hw)
{
347 348
	substream->runtime->hw = *hw;

349 350 351 352
	return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);

353
/* DPCM stream event, send event to FE and all active BEs. */
354
int dpcm_dapm_stream_event(struct snd_soc_pcm_runtime *fe, int dir,
355 356 357 358
	int event)
{
	struct snd_soc_dpcm *dpcm;

359 360
	snd_soc_dpcm_mutex_assert_held(fe);

361
	for_each_dpcm_be(fe, dir, dpcm) {
362 363 364

		struct snd_soc_pcm_runtime *be = dpcm->be;

365
		dev_dbg(be->dev, "ASoC: BE %s event %d dir %d\n",
366 367
				be->dai_link->name, event, dir);

368 369 370 371
		if ((event == SND_SOC_DAPM_STREAM_STOP) &&
		    (be->dpcm[dir].users >= 1))
			continue;

372 373 374 375 376 377 378 379
		snd_soc_dapm_stream_event(be, dir, event);
	}

	snd_soc_dapm_stream_event(fe, dir, event);

	return 0;
}

380 381 382 383 384 385 386 387 388 389 390 391 392 393
static void soc_pcm_set_dai_params(struct snd_soc_dai *dai,
				   struct snd_pcm_hw_params *params)
{
	if (params) {
		dai->rate	 = params_rate(params);
		dai->channels	 = params_channels(params);
		dai->sample_bits = snd_pcm_format_physical_width(params_format(params));
	} else {
		dai->rate	 = 0;
		dai->channels	 = 0;
		dai->sample_bits = 0;
	}
}

394 395
static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream,
					struct snd_soc_dai *soc_dai)
396
{
397
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
398 399
	int ret;

400 401 402
	if (!snd_soc_dai_active(soc_dai))
		return 0;

403 404 405 406 407 408 409 410 411 412 413 414 415 416 417
#define __soc_pcm_apply_symmetry(name, NAME)				\
	if (soc_dai->name && (soc_dai->driver->symmetric_##name ||	\
			      rtd->dai_link->symmetric_##name)) {	\
		dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %s to %d\n",\
			#name, soc_dai->name);				\
									\
		ret = snd_pcm_hw_constraint_single(substream->runtime,	\
						   SNDRV_PCM_HW_PARAM_##NAME,\
						   soc_dai->name);	\
		if (ret < 0) {						\
			dev_err(soc_dai->dev,				\
				"ASoC: Unable to apply %s constraint: %d\n",\
				#name, ret);				\
			return ret;					\
		}							\
418
	}
419

420 421 422
	__soc_pcm_apply_symmetry(rate,		RATE);
	__soc_pcm_apply_symmetry(channels,	CHANNELS);
	__soc_pcm_apply_symmetry(sample_bits,	SAMPLE_BITS);
423 424 425 426

	return 0;
}

427 428 429
static int soc_pcm_params_symmetry(struct snd_pcm_substream *substream,
				struct snd_pcm_hw_params *params)
{
430
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
431
	struct snd_soc_dai d;
432
	struct snd_soc_dai *dai;
433
	struct snd_soc_dai *cpu_dai;
434
	unsigned int symmetry, i;
435

436
	d.name = __func__;
437
	soc_pcm_set_dai_params(&d, params);
438

439 440
#define __soc_pcm_params_symmetry(xxx)					\
	symmetry = rtd->dai_link->symmetric_##xxx;			\
441
	for_each_rtd_dais(rtd, i, dai)					\
442
		symmetry |= dai->driver->symmetric_##xxx;		\
443 444 445
									\
	if (symmetry)							\
		for_each_rtd_cpu_dais(rtd, i, cpu_dai)			\
446 447
			if (!snd_soc_dai_is_dummy(cpu_dai) &&		\
			    cpu_dai->xxx && cpu_dai->xxx != d.xxx) {	\
448 449
				dev_err(rtd->dev, "ASoC: unmatched %s symmetry: %s:%d - %s:%d\n", \
					#xxx, cpu_dai->name, cpu_dai->xxx, d.name, d.xxx); \
450
				return -EINVAL;				\
451
			}
452

453 454 455 456
	/* reject unmatched parameters when applying symmetry */
	__soc_pcm_params_symmetry(rate);
	__soc_pcm_params_symmetry(channels);
	__soc_pcm_params_symmetry(sample_bits);
457 458 459 460

	return 0;
}

461
static void soc_pcm_update_symmetry(struct snd_pcm_substream *substream)
462
{
463
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
464
	struct snd_soc_dai_link *link = rtd->dai_link;
465
	struct snd_soc_dai *dai;
466
	unsigned int symmetry, i;
467

468
	symmetry = link->symmetric_rate ||
469
		link->symmetric_channels ||
470
		link->symmetric_sample_bits;
471

472
	for_each_rtd_dais(rtd, i, dai)
473
		symmetry = symmetry ||
474
			dai->driver->symmetric_rate ||
475
			dai->driver->symmetric_channels ||
476
			dai->driver->symmetric_sample_bits;
477

478 479
	if (symmetry)
		substream->runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
480 481
}

482
static void soc_pcm_set_msb(struct snd_pcm_substream *substream, int bits)
483
{
484
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
485
	int ret;
486 487 488 489

	if (!bits)
		return;

490 491 492 493
	ret = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 0, bits);
	if (ret != 0)
		dev_warn(rtd->dev, "ASoC: Failed to set MSB %d: %d\n",
				 bits, ret);
494 495
}

496 497
static void soc_pcm_apply_msb(struct snd_pcm_substream *substream)
{
498
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
499
	struct snd_soc_dai *cpu_dai;
500
	struct snd_soc_dai *codec_dai;
501
	int stream = substream->stream;
502
	int i;
503
	unsigned int bits = 0, cpu_bits = 0;
504

505
	for_each_rtd_codec_dais(rtd, i, codec_dai) {
506
		struct snd_soc_pcm_stream *pcm_codec = snd_soc_dai_get_pcm_stream(codec_dai, stream);
507 508 509 510

		if (pcm_codec->sig_bits == 0) {
			bits = 0;
			break;
511
		}
512
		bits = max(pcm_codec->sig_bits, bits);
513 514
	}

515
	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
516
		struct snd_soc_pcm_stream *pcm_cpu = snd_soc_dai_get_pcm_stream(cpu_dai, stream);
517 518 519 520 521 522 523

		if (pcm_cpu->sig_bits == 0) {
			cpu_bits = 0;
			break;
		}
		cpu_bits = max(pcm_cpu->sig_bits, cpu_bits);
	}
524

525 526
	soc_pcm_set_msb(substream, bits);
	soc_pcm_set_msb(substream, cpu_bits);
527 528
}

529 530 531 532 533
static void soc_pcm_hw_init(struct snd_pcm_hardware *hw)
{
	hw->rates		= UINT_MAX;
	hw->rate_min		= 0;
	hw->rate_max		= UINT_MAX;
534 535
	hw->channels_min	= 0;
	hw->channels_max	= UINT_MAX;
536
	hw->formats		= ULLONG_MAX;
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
}

static void soc_pcm_hw_update_rate(struct snd_pcm_hardware *hw,
				   struct snd_soc_pcm_stream *p)
{
	hw->rates = snd_pcm_rate_mask_intersect(hw->rates, p->rates);

	/* setup hw->rate_min/max via hw->rates first */
	snd_pcm_hw_limit_rates(hw);

	/* update hw->rate_min/max by snd_soc_pcm_stream */
	hw->rate_min = max(hw->rate_min, p->rate_min);
	hw->rate_max = min_not_zero(hw->rate_max, p->rate_max);
}

552 553 554 555 556 557 558
static void soc_pcm_hw_update_chan(struct snd_pcm_hardware *hw,
				   struct snd_soc_pcm_stream *p)
{
	hw->channels_min = max(hw->channels_min, p->channels_min);
	hw->channels_max = min(hw->channels_max, p->channels_max);
}

559 560 561 562 563 564
static void soc_pcm_hw_update_format(struct snd_pcm_hardware *hw,
				     struct snd_soc_pcm_stream *p)
{
	hw->formats &= p->formats;
}

565 566 567 568 569 570 571 572 573 574 575
/**
 * snd_soc_runtime_calc_hw() - Calculate hw limits for a PCM stream
 * @rtd: ASoC PCM runtime
 * @hw: PCM hardware parameters (output)
 * @stream: Direction of the PCM stream
 *
 * Calculates the subset of stream parameters supported by all DAIs
 * associated with the PCM stream.
 */
int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd,
			    struct snd_pcm_hardware *hw, int stream)
576
{
577
	struct snd_soc_dai *codec_dai;
578
	struct snd_soc_dai *cpu_dai;
579 580
	struct snd_soc_pcm_stream *codec_stream;
	struct snd_soc_pcm_stream *cpu_stream;
581
	unsigned int cpu_chan_min = 0, cpu_chan_max = UINT_MAX;
582
	int i;
583

584 585
	soc_pcm_hw_init(hw);

586
	/* first calculate min/max only for CPUs in the DAI link */
587
	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
588 589 590 591 592 593 594

		/*
		 * Skip CPUs which don't support the current stream type.
		 * Otherwise, since the rate, channel, and format values will
		 * zero in that case, we would have no usable settings left,
		 * causing the resulting setup to fail.
		 */
595
		if (!snd_soc_dai_stream_valid(cpu_dai, stream))
596 597
			continue;

598 599
		cpu_stream = snd_soc_dai_get_pcm_stream(cpu_dai, stream);

600
		soc_pcm_hw_update_chan(hw, cpu_stream);
601
		soc_pcm_hw_update_rate(hw, cpu_stream);
602
		soc_pcm_hw_update_format(hw, cpu_stream);
603
	}
604 605
	cpu_chan_min = hw->channels_min;
	cpu_chan_max = hw->channels_max;
606

607
	/* second calculate min/max only for CODECs in the DAI link */
608
	for_each_rtd_codec_dais(rtd, i, codec_dai) {
609 610 611 612 613 614 615

		/*
		 * Skip CODECs which don't support the current stream type.
		 * Otherwise, since the rate, channel, and format values will
		 * zero in that case, we would have no usable settings left,
		 * causing the resulting setup to fail.
		 */
616
		if (!snd_soc_dai_stream_valid(codec_dai, stream))
617 618
			continue;

619 620
		codec_stream = snd_soc_dai_get_pcm_stream(codec_dai, stream);

621
		soc_pcm_hw_update_chan(hw, codec_stream);
622
		soc_pcm_hw_update_rate(hw, codec_stream);
623
		soc_pcm_hw_update_format(hw, codec_stream);
624 625
	}

626
	/* Verify both a valid CPU DAI and a valid CODEC DAI were found */
627
	if (!hw->channels_min)
628 629
		return -EINVAL;

630 631
	/*
	 * chan min/max cannot be enforced if there are multiple CODEC DAIs
632
	 * connected to CPU DAI(s), use CPU DAI's directly and let
633 634
	 * channel allocation be fixed up later
	 */
635
	if (rtd->dai_link->num_codecs > 1) {
636 637
		hw->channels_min = cpu_chan_min;
		hw->channels_max = cpu_chan_max;
638 639
	}

640 641 642 643 644 645 646
	return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_runtime_calc_hw);

static void soc_pcm_init_runtime_hw(struct snd_pcm_substream *substream)
{
	struct snd_pcm_hardware *hw = &substream->runtime->hw;
647
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
648 649 650 651 652 653 654 655 656 657 658
	u64 formats = hw->formats;

	/*
	 * At least one CPU and one CODEC should match. Otherwise, we should
	 * have bailed out on a higher level, since there would be no CPU or
	 * CODEC to support the transfer direction in that case.
	 */
	snd_soc_runtime_calc_hw(rtd, hw, substream->stream);

	if (formats)
		hw->formats &= formats;
659 660
}

661
static int soc_pcm_components_open(struct snd_pcm_substream *substream)
662
{
663
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
664
	struct snd_soc_component *component;
665
	int i, ret = 0;
666

667
	for_each_rtd_components(rtd, i, component) {
668
		ret = snd_soc_component_module_get_when_open(component, substream);
669
		if (ret < 0)
670
			break;
671

672
		ret = snd_soc_component_open(component, substream);
673
		if (ret < 0)
674
			break;
675
	}
676

677
	return ret;
678 679
}

680 681
static int soc_pcm_components_close(struct snd_pcm_substream *substream,
				    int rollback)
682
{
683
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
684
	struct snd_soc_component *component;
685
	int i, ret = 0;
686

687
	for_each_rtd_components(rtd, i, component) {
688
		int r = snd_soc_component_close(component, substream, rollback);
689 690 691
		if (r < 0)
			ret = r; /* use last ret */

692
		snd_soc_component_module_put_when_close(component, substream, rollback);
693 694
	}

695
	return ret;
696 697
}

698 699
static int soc_pcm_clean(struct snd_soc_pcm_runtime *rtd,
			 struct snd_pcm_substream *substream, int rollback)
700 701
{
	struct snd_soc_component *component;
702
	struct snd_soc_dai *dai;
703 704
	int i;

705
	snd_soc_dpcm_mutex_assert_held(rtd);
706

707
	if (!rollback) {
708
		snd_soc_runtime_deactivate(rtd, substream->stream);
709

710
		/* Make sure DAI parameters cleared if the DAI becomes inactive */
711
		for_each_rtd_dais(rtd, i, dai) {
712 713 714
			if (snd_soc_dai_active(dai) == 0 &&
			    (dai->rate || dai->channels || dai->sample_bits))
				soc_pcm_set_dai_params(dai, NULL);
715

716 717 718 719
			if (snd_soc_dai_stream_active(dai, substream->stream) ==  0) {
				if (dai->driver->ops && !dai->driver->ops->mute_unmute_on_trigger)
					snd_soc_dai_digital_mute(dai, 1, substream->stream);
			}
720 721
		}
	}
722

723
	for_each_rtd_dais(rtd, i, dai)
724
		snd_soc_dai_shutdown(dai, substream, rollback);
725

726
	snd_soc_link_shutdown(substream, rollback);
727

728
	soc_pcm_components_close(substream, rollback);
729

730
	snd_soc_pcm_component_pm_runtime_put(rtd, substream, rollback);
731 732

	for_each_rtd_components(rtd, i, component)
733
		if (!snd_soc_component_active(component))
734 735 736 737 738
			pinctrl_pm_select_sleep_state(component->dev);

	return 0;
}

739 740 741 742 743
/*
 * Called by ALSA when a PCM substream is closed. Private data can be
 * freed here. The cpu DAI, codec DAI, machine and components are also
 * shutdown.
 */
744 745 746 747 748 749 750
static int __soc_pcm_close(struct snd_soc_pcm_runtime *rtd,
			   struct snd_pcm_substream *substream)
{
	return soc_pcm_clean(rtd, substream, 0);
}

/* PCM close ops for non-DPCM streams */
751 752
static int soc_pcm_close(struct snd_pcm_substream *substream)
{
753
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
754 755

	snd_soc_dpcm_mutex_lock(rtd);
756
	__soc_pcm_close(rtd, substream);
757 758
	snd_soc_dpcm_mutex_unlock(rtd);
	return 0;
759 760
}

761 762
static int soc_hw_sanity_check(struct snd_pcm_substream *substream)
{
763
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798
	struct snd_pcm_hardware *hw = &substream->runtime->hw;
	const char *name_cpu = soc_cpu_dai_name(rtd);
	const char *name_codec = soc_codec_dai_name(rtd);
	const char *err_msg;
	struct device *dev = rtd->dev;

	err_msg = "rates";
	if (!hw->rates)
		goto config_err;

	err_msg = "formats";
	if (!hw->formats)
		goto config_err;

	err_msg = "channels";
	if (!hw->channels_min || !hw->channels_max ||
	     hw->channels_min  >  hw->channels_max)
		goto config_err;

	dev_dbg(dev, "ASoC: %s <-> %s info:\n",		name_codec,
							name_cpu);
	dev_dbg(dev, "ASoC: rate mask 0x%x\n",		hw->rates);
	dev_dbg(dev, "ASoC: ch   min %d max %d\n",	hw->channels_min,
							hw->channels_max);
	dev_dbg(dev, "ASoC: rate min %d max %d\n",	hw->rate_min,
							hw->rate_max);

	return 0;

config_err:
	dev_err(dev, "ASoC: %s <-> %s No matching %s\n",
		name_codec, name_cpu, err_msg);
	return -EINVAL;
}

799 800 801
/*
 * Called by ALSA when a PCM substream is opened, the runtime->hw record is
 * then initialized and any private data can be allocated. This also calls
802
 * startup for the cpu DAI, component, machine and codec DAI.
803
 */
804 805
static int __soc_pcm_open(struct snd_soc_pcm_runtime *rtd,
			  struct snd_pcm_substream *substream)
806
{
807
	struct snd_soc_component *component;
808
	struct snd_soc_dai *dai;
809
	int i, ret = 0;
810

811 812
	snd_soc_dpcm_mutex_assert_held(rtd);

813 814
	for_each_rtd_components(rtd, i, component)
		pinctrl_pm_select_default_state(component->dev);
815

816 817
	ret = snd_soc_pcm_component_pm_runtime_get(rtd, substream);
	if (ret < 0)
818
		goto err;
819

820 821
	ret = soc_pcm_components_open(substream);
	if (ret < 0)
822
		goto err;
823

824
	ret = snd_soc_link_startup(substream);
825
	if (ret < 0)
826
		goto err;
827

828
	/* startup the audio subsystem */
829 830
	for_each_rtd_dais(rtd, i, dai) {
		ret = snd_soc_dai_startup(dai, substream);
831
		if (ret < 0)
832
			goto err;
833 834
	}

835 836 837 838
	/* Dynamic PCM DAI links compat checks use dynamic capabilities */
	if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm)
		goto dynamic;

839
	/* Check that the codec and cpu DAIs are compatible */
840 841
	soc_pcm_init_runtime_hw(substream);

842
	soc_pcm_update_symmetry(substream);
843

844 845
	ret = soc_hw_sanity_check(substream);
	if (ret < 0)
846
		goto err;
847

848
	soc_pcm_apply_msb(substream);
849

850
	/* Symmetry only applies if we've already got an active stream. */
851
	for_each_rtd_dais(rtd, i, dai) {
852 853 854
		ret = soc_pcm_apply_symmetry(substream, dai);
		if (ret != 0)
			goto err;
855
	}
856
dynamic:
857
	snd_soc_runtime_activate(rtd, substream->stream);
858
	ret = 0;
859
err:
860
	if (ret < 0)
861
		soc_pcm_clean(rtd, substream, 1);
862

863
	return soc_pcm_ret(rtd, ret);
864 865
}

866 867 868
/* PCM open ops for non-DPCM streams */
static int soc_pcm_open(struct snd_pcm_substream *substream)
{
869
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
870 871 872 873 874 875 876 877
	int ret;

	snd_soc_dpcm_mutex_lock(rtd);
	ret = __soc_pcm_open(rtd, substream);
	snd_soc_dpcm_mutex_unlock(rtd);
	return ret;
}

878 879 880 881 882
/*
 * Called by ALSA when the PCM substream is prepared, can set format, sample
 * rate, etc.  This function is non atomic and can be called multiple times,
 * it can refer to the runtime info.
 */
883 884
static int __soc_pcm_prepare(struct snd_soc_pcm_runtime *rtd,
			     struct snd_pcm_substream *substream)
885
{
886
	struct snd_soc_dai *dai;
887
	int i, ret = 0;
888

889
	snd_soc_dpcm_mutex_assert_held(rtd);
890

891
	ret = snd_soc_link_prepare(substream);
892
	if (ret < 0)
893
		goto out;
894

895 896 897
	ret = snd_soc_pcm_component_prepare(substream);
	if (ret < 0)
		goto out;
898

899
	ret = snd_soc_pcm_dai_prepare(substream);
900
	if (ret < 0)
901
		goto out;
902

903 904
	/* cancel any delayed stream shutdown that is pending */
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
905 906
	    rtd->pop_wait) {
		rtd->pop_wait = 0;
907 908 909
		cancel_delayed_work(&rtd->delayed_work);
	}

910 911
	snd_soc_dapm_stream_event(rtd, substream->stream,
			SND_SOC_DAPM_STREAM_START);
912

913 914 915 916
	for_each_rtd_dais(rtd, i, dai) {
		if (dai->driver->ops && !dai->driver->ops->mute_unmute_on_trigger)
			snd_soc_dai_digital_mute(dai, 0, substream->stream);
	}
917 918

out:
919
	return soc_pcm_ret(rtd, ret);
920 921
}

922 923 924
/* PCM prepare ops for non-DPCM streams */
static int soc_pcm_prepare(struct snd_pcm_substream *substream)
{
925
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
926 927 928 929 930 931 932 933
	int ret;

	snd_soc_dpcm_mutex_lock(rtd);
	ret = __soc_pcm_prepare(rtd, substream);
	snd_soc_dpcm_mutex_unlock(rtd);
	return ret;
}

934 935 936 937 938 939 940 941 942 943 944
static void soc_pcm_codec_params_fixup(struct snd_pcm_hw_params *params,
				       unsigned int mask)
{
	struct snd_interval *interval;
	int channels = hweight_long(mask);

	interval = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
	interval->min = channels;
	interval->max = channels;
}

945 946
static int soc_pcm_hw_clean(struct snd_soc_pcm_runtime *rtd,
			    struct snd_pcm_substream *substream, int rollback)
947 948 949 950
{
	struct snd_soc_dai *dai;
	int i;

951
	snd_soc_dpcm_mutex_assert_held(rtd);
952

953 954 955 956 957 958 959 960 961
	/* clear the corresponding DAIs parameters when going to be inactive */
	for_each_rtd_dais(rtd, i, dai) {
		if (snd_soc_dai_active(dai) == 1)
			soc_pcm_set_dai_params(dai, NULL);

		if (snd_soc_dai_stream_active(dai, substream->stream) == 1)
			snd_soc_dai_digital_mute(dai, 1, substream->stream);
	}

962 963 964
	/* run the stream event */
	snd_soc_dapm_stream_stop(rtd, substream->stream);

965
	/* free any machine hw params */
966
	snd_soc_link_hw_free(substream, rollback);
967 968

	/* free any component resources */
969
	snd_soc_pcm_component_hw_free(substream, rollback);
970 971

	/* now free hw params for the DAIs  */
972 973 974
	for_each_rtd_dais(rtd, i, dai)
		if (snd_soc_dai_stream_valid(dai, substream->stream))
			snd_soc_dai_hw_free(dai, substream, rollback);
975 976 977 978

	return 0;
}

979 980 981
/*
 * Frees resources allocated by hw_params, can be called multiple times
 */
982 983 984 985 986 987 988
static int __soc_pcm_hw_free(struct snd_soc_pcm_runtime *rtd,
			     struct snd_pcm_substream *substream)
{
	return soc_pcm_hw_clean(rtd, substream, 0);
}

/* hw_free PCM ops for non-DPCM streams */
989 990
static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
{
991
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
992 993 994 995 996 997
	int ret;

	snd_soc_dpcm_mutex_lock(rtd);
	ret = __soc_pcm_hw_free(rtd, substream);
	snd_soc_dpcm_mutex_unlock(rtd);
	return ret;
998 999
}

1000 1001 1002 1003 1004
/*
 * Called by ALSA when the hardware params are set by application. This
 * function can also be called multiple times and can allocate buffers
 * (using snd_pcm_lib_* ). It's non-atomic.
 */
1005 1006 1007
static int __soc_pcm_hw_params(struct snd_soc_pcm_runtime *rtd,
			       struct snd_pcm_substream *substream,
			       struct snd_pcm_hw_params *params)
1008
{
1009
	struct snd_soc_dai *cpu_dai;
1010
	struct snd_soc_dai *codec_dai;
1011
	struct snd_pcm_hw_params tmp_params;
1012
	int i, ret = 0;
1013

1014
	snd_soc_dpcm_mutex_assert_held(rtd);
1015 1016 1017 1018 1019

	ret = soc_pcm_params_symmetry(substream, params);
	if (ret)
		goto out;

1020
	ret = snd_soc_link_hw_params(substream, params);
1021
	if (ret < 0)
1022
		goto out;
1023

1024
	for_each_rtd_codec_dais(rtd, i, codec_dai) {
1025
		unsigned int tdm_mask = snd_soc_dai_tdm_mask_get(codec_dai, substream->stream);
1026

1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
		/*
		 * Skip CODECs which don't support the current stream type,
		 * the idea being that if a CODEC is not used for the currently
		 * set up transfer direction, it should not need to be
		 * configured, especially since the configuration used might
		 * not even be supported by that CODEC. There may be cases
		 * however where a CODEC needs to be set up although it is
		 * actually not being used for the transfer, e.g. if a
		 * capture-only CODEC is acting as an LRCLK and/or BCLK master
		 * for the DAI link including a playback-only CODEC.
		 * If this becomes necessary, we will have to augment the
		 * machine driver setup with information on how to act, so
		 * we can do the right thing here.
		 */
		if (!snd_soc_dai_stream_valid(codec_dai, substream->stream))
			continue;

1044
		/* copy params for each codec */
1045
		tmp_params = *params;
1046 1047

		/* fixup params based on TDM slot masks */
1048
		if (tdm_mask)
1049
			soc_pcm_codec_params_fixup(&tmp_params, tdm_mask);
1050

1051
		ret = snd_soc_dai_hw_params(codec_dai, substream,
1052
					    &tmp_params);
1053
		if(ret < 0)
1054
			goto out;
1055

1056 1057
		soc_pcm_set_dai_params(codec_dai, &tmp_params);
		snd_soc_dapm_update_dai(substream, &tmp_params, codec_dai);
1058 1059
	}

1060
	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
1061
		struct snd_soc_dai_link_ch_map *ch_maps;
1062 1063 1064
		unsigned int ch_mask = 0;
		int j;

1065 1066 1067 1068 1069 1070 1071
		/*
		 * Skip CPUs which don't support the current stream
		 * type. See soc_pcm_init_runtime_hw() for more details
		 */
		if (!snd_soc_dai_stream_valid(cpu_dai, substream->stream))
			continue;

1072
		/* copy params for each cpu */
1073
		tmp_params = *params;
1074 1075 1076 1077

		/*
		 * construct cpu channel mask by combining ch_mask of each
		 * codec which maps to the cpu.
1078 1079
		 * see
		 *	soc.h :: [dai_link->ch_maps Image sample]
1080
		 */
1081 1082 1083
		for_each_rtd_ch_maps(rtd, j, ch_maps)
			if (ch_maps->cpu == i)
				ch_mask |= ch_maps->ch_mask;
1084 1085 1086

		/* fixup cpu channel number */
		if (ch_mask)
1087
			soc_pcm_codec_params_fixup(&tmp_params, ch_mask);
1088

1089
		ret = snd_soc_dai_hw_params(cpu_dai, substream, &tmp_params);
1090
		if (ret < 0)
1091
			goto out;
1092

1093
		/* store the parameters for each DAI */
1094 1095
		soc_pcm_set_dai_params(cpu_dai, &tmp_params);
		snd_soc_dapm_update_dai(substream, &tmp_params, cpu_dai);
1096
	}
1097

1098
	ret = snd_soc_pcm_component_hw_params(substream, params);
1099
out:
1100
	if (ret < 0)
1101
		soc_pcm_hw_clean(rtd, substream, 1);
1102

1103
	return soc_pcm_ret(rtd, ret);
1104 1105
}

1106 1107 1108 1109
/* hw_params PCM ops for non-DPCM streams */
static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
			     struct snd_pcm_hw_params *params)
{
1110
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
1111 1112 1113 1114 1115 1116 1117 1118
	int ret;

	snd_soc_dpcm_mutex_lock(rtd);
	ret = __soc_pcm_hw_params(rtd, substream, params);
	snd_soc_dpcm_mutex_unlock(rtd);
	return ret;
}

1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
#define TRIGGER_MAX 3
static int (* const trigger[][TRIGGER_MAX])(struct snd_pcm_substream *substream, int cmd, int rollback) = {
	[SND_SOC_TRIGGER_ORDER_DEFAULT] = {
		snd_soc_link_trigger,
		snd_soc_pcm_component_trigger,
		snd_soc_pcm_dai_trigger,
	},
	[SND_SOC_TRIGGER_ORDER_LDC] = {
		snd_soc_link_trigger,
		snd_soc_pcm_dai_trigger,
		snd_soc_pcm_component_trigger,
	},
};

1133 1134
static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
1135
	struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
1136
	struct snd_soc_component *component;
1137
	int ret = 0, r = 0, i;
1138
	int rollback = 0;
1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
	int start = 0, stop = 0;

	/*
	 * select START/STOP sequence
	 */
	for_each_rtd_components(rtd, i, component) {
		if (component->driver->trigger_start)
			start = component->driver->trigger_start;
		if (component->driver->trigger_stop)
			stop = component->driver->trigger_stop;
	}
	if (rtd->dai_link->trigger_start)
		start = rtd->dai_link->trigger_start;
	if (rtd->dai_link->trigger_stop)
		stop  = rtd->dai_link->trigger_stop;

	if (start < 0 || start >= SND_SOC_TRIGGER_ORDER_MAX ||
	    stop  < 0 || stop  >= SND_SOC_TRIGGER_ORDER_MAX)
		return -EINVAL;
1158

1159 1160 1161
	/*
	 * START
	 */
1162 1163 1164 1165
	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
	case SNDRV_PCM_TRIGGER_RESUME:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1166 1167 1168
		for (i = 0; i < TRIGGER_MAX; i++) {
			r = trigger[start][i](substream, cmd, 0);
			if (r < 0)
1169 1170
				break;
		}
1171 1172
	}

1173 1174 1175 1176 1177 1178 1179
	/*
	 * Rollback if START failed
	 * find correspond STOP command
	 */
	if (r < 0) {
		rollback = 1;
		ret = r;
1180 1181 1182 1183 1184 1185
		switch (cmd) {
		case SNDRV_PCM_TRIGGER_START:
			cmd = SNDRV_PCM_TRIGGER_STOP;
			break;
		case SNDRV_PCM_TRIGGER_RESUME:
			cmd = SNDRV_PCM_TRIGGER_SUSPEND;
1186
			break;
1187 1188 1189 1190 1191
		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
			cmd = SNDRV_PCM_TRIGGER_PAUSE_PUSH;
			break;
		}
	}
1192

1193 1194 1195
	/*
	 * STOP
	 */
1196
	switch (cmd) {
1197 1198 1199
	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1200 1201 1202 1203
		for (i = TRIGGER_MAX; i > 0; i--) {
			r = trigger[stop][i - 1](substream, cmd, rollback);
			if (r < 0)
				ret = r;
1204
		}
1205 1206 1207 1208 1209
	}

	return ret;
}

1210 1211
/*
 * soc level wrapper for pointer callback
1212
 * If cpu_dai, codec_dai, component driver has the delay callback, then
1213
 * the runtime->delay will be updated via snd_soc_pcm_component/dai_delay().
1214 1215 1216 1217 1218
 */
static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	snd_pcm_uframes_t offset = 0;
1219
	snd_pcm_sframes_t codec_delay = 0;
1220
	snd_pcm_sframes_t cpu_delay = 0;
1221

1222
	offset = snd_soc_pcm_component_pointer(substream);
1223

1224
	/* should be called *after* snd_soc_pcm_component_pointer() */
1225
	snd_soc_pcm_dai_delay(substream, &cpu_delay, &codec_delay);
1226
	snd_soc_pcm_component_delay(substream, &cpu_delay, &codec_delay);
1227

1228
	runtime->delay = cpu_delay + codec_delay;
1229 1230 1231 1232

	return offset;
}

1233 1234 1235 1236
/* connect a FE and BE */
static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe,
		struct snd_soc_pcm_runtime *be, int stream)
{
1237 1238
	struct snd_pcm_substream *fe_substream;
	struct snd_pcm_substream *be_substream;
1239
	struct snd_soc_dpcm *dpcm;
1240 1241

	snd_soc_dpcm_mutex_assert_held(fe);
1242 1243

	/* only add new dpcms */
1244
	for_each_dpcm_be(fe, stream, dpcm) {
1245 1246 1247 1248
		if (dpcm->be == be && dpcm->fe == fe)
			return 0;
	}

1249 1250 1251 1252 1253 1254 1255 1256 1257
	fe_substream = snd_soc_dpcm_get_substream(fe, stream);
	be_substream = snd_soc_dpcm_get_substream(be, stream);

	if (!fe_substream->pcm->nonatomic && be_substream->pcm->nonatomic) {
		dev_err(be->dev, "%s: FE is atomic but BE is nonatomic, invalid configuration\n",
			__func__);
		return -EINVAL;
	}
	if (fe_substream->pcm->nonatomic && !be_substream->pcm->nonatomic) {
1258
		dev_dbg(be->dev, "FE is nonatomic but BE is not, forcing BE as nonatomic\n");
1259 1260 1261
		be_substream->pcm->nonatomic = 1;
	}

1262
	dpcm = kzalloc(sizeof(struct snd_soc_dpcm), GFP_KERNEL);
1263 1264 1265 1266 1267 1268
	if (!dpcm)
		return -ENOMEM;

	dpcm->be = be;
	dpcm->fe = fe;
	dpcm->state = SND_SOC_DPCM_LINK_STATE_NEW;
1269
	snd_soc_dpcm_stream_lock_irq(fe, stream);
1270 1271
	list_add(&dpcm->list_be, &fe->dpcm[stream].be_clients);
	list_add(&dpcm->list_fe, &be->dpcm[stream].fe_clients);
1272
	snd_soc_dpcm_stream_unlock_irq(fe, stream);
1273

1274
	dev_dbg(fe->dev, "connected new DPCM %s path %s %s %s\n",
1275 1276 1277
			stream ? "capture" : "playback",  fe->dai_link->name,
			stream ? "<-" : "->", be->dai_link->name);

1278 1279
	dpcm_create_debugfs_state(dpcm, stream);

1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
	return 1;
}

/* reparent a BE onto another FE */
static void dpcm_be_reparent(struct snd_soc_pcm_runtime *fe,
			struct snd_soc_pcm_runtime *be, int stream)
{
	struct snd_soc_dpcm *dpcm;
	struct snd_pcm_substream *fe_substream, *be_substream;

	/* reparent if BE is connected to other FEs */
	if (!be->dpcm[stream].users)
		return;

	be_substream = snd_soc_dpcm_get_substream(be, stream);
1295 1296
	if (!be_substream)
		return;
1297

1298
	for_each_dpcm_fe(be, stream, dpcm) {
1299 1300 1301
		if (dpcm->fe == fe)
			continue;

1302
		dev_dbg(fe->dev, "reparent %s path %s %s %s\n",
1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
			stream ? "capture" : "playback",
			dpcm->fe->dai_link->name,
			stream ? "<-" : "->", dpcm->be->dai_link->name);

		fe_substream = snd_soc_dpcm_get_substream(dpcm->fe, stream);
		be_substream->runtime = fe_substream->runtime;
		break;
	}
}

/* disconnect a BE and FE */
1314
void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream)
1315 1316
{
	struct snd_soc_dpcm *dpcm, *d;
1317
	LIST_HEAD(deleted_dpcms);
1318

1319 1320 1321
	snd_soc_dpcm_mutex_assert_held(fe);

	snd_soc_dpcm_stream_lock_irq(fe, stream);
1322
	for_each_dpcm_be_safe(fe, stream, dpcm, d) {
1323
		dev_dbg(fe->dev, "ASoC: BE %s disconnect check for %s\n",
1324 1325 1326 1327 1328 1329
				stream ? "capture" : "playback",
				dpcm->be->dai_link->name);

		if (dpcm->state != SND_SOC_DPCM_LINK_STATE_FREE)
			continue;

1330
		dev_dbg(fe->dev, "freed DSP %s path %s %s %s\n",
1331 1332 1333 1334 1335 1336 1337
			stream ? "capture" : "playback", fe->dai_link->name,
			stream ? "<-" : "->", dpcm->be->dai_link->name);

		/* BEs still alive need new FE */
		dpcm_be_reparent(fe, dpcm->be, stream);

		list_del(&dpcm->list_be);
1338 1339 1340 1341 1342 1343 1344
		list_move(&dpcm->list_fe, &deleted_dpcms);
	}
	snd_soc_dpcm_stream_unlock_irq(fe, stream);

	while (!list_empty(&deleted_dpcms)) {
		dpcm = list_first_entry(&deleted_dpcms, struct snd_soc_dpcm,
					list_fe);
1345
		list_del(&dpcm->list_fe);
1346
		dpcm_remove_debugfs_state(dpcm);
1347 1348 1349 1350 1351 1352 1353 1354 1355
		kfree(dpcm);
	}
}

/* get BE for DAI widget and stream */
static struct snd_soc_pcm_runtime *dpcm_get_be(struct snd_soc_card *card,
		struct snd_soc_dapm_widget *widget, int stream)
{
	struct snd_soc_pcm_runtime *be;
1356
	struct snd_soc_dapm_widget *w;
1357
	struct snd_soc_dai *dai;
1358
	int i;
1359

1360 1361
	dev_dbg(card->dev, "ASoC: find BE for widget %s\n", widget->name);

1362
	for_each_card_rtds(card, be) {
1363

1364 1365
		if (!be->dai_link->no_pcm)
			continue;
1366

1367 1368 1369
		if (!snd_soc_dpcm_get_substream(be, stream))
			continue;

1370
		for_each_rtd_dais(be, i, dai) {
1371
			w = snd_soc_dai_get_widget(dai, stream);
1372

1373 1374
			dev_dbg(card->dev, "ASoC: try BE : %s\n",
				w ? w->name : "(not set)");
1375

1376 1377 1378
			if (w == widget)
				return be;
		}
1379 1380
	}

1381
	/* Widget provided is not a BE */
1382 1383 1384
	return NULL;
}

1385
int widget_in_list(struct snd_soc_dapm_widget_list *list,
1386 1387
		struct snd_soc_dapm_widget *widget)
{
1388
	struct snd_soc_dapm_widget *w;
1389 1390
	int i;

1391 1392
	for_each_dapm_widgets(list, i, w)
		if (widget == w)
1393 1394 1395 1396
			return 1;

	return 0;
}
1397
EXPORT_SYMBOL_GPL(widget_in_list);
1398

1399
bool dpcm_end_walk_at_be(struct snd_soc_dapm_widget *widget, enum snd_soc_dapm_direction dir)
1400 1401 1402
{
	struct snd_soc_card *card = widget->dapm->card;
	struct snd_soc_pcm_runtime *rtd;
1403
	int stream;
1404

1405 1406 1407 1408 1409
	/* adjust dir to stream */
	if (dir == SND_SOC_DAPM_DIR_OUT)
		stream = SNDRV_PCM_STREAM_PLAYBACK;
	else
		stream = SNDRV_PCM_STREAM_CAPTURE;
1410

1411 1412 1413
	rtd = dpcm_get_be(card, widget, stream);
	if (rtd)
		return true;
1414 1415 1416

	return false;
}
1417
EXPORT_SYMBOL_GPL(dpcm_end_walk_at_be);
1418

1419
int dpcm_path_get(struct snd_soc_pcm_runtime *fe,
1420
	int stream, struct snd_soc_dapm_widget_list **list)
1421
{
1422
	struct snd_soc_dai *cpu_dai = snd_soc_rtd_to_cpu(fe, 0);
1423 1424
	int paths;

1425
	if (fe->dai_link->num_cpus > 1) {
1426 1427 1428 1429 1430
		dev_err(fe->dev,
			"%s doesn't support Multi CPU yet\n", __func__);
		return -EINVAL;
	}

1431
	/* get number of valid DAI paths and their widgets */
1432
	paths = snd_soc_dapm_dai_get_connected_widgets(cpu_dai, stream, list,
1433 1434
			fe->card->component_chaining ?
				NULL : dpcm_end_walk_at_be);
1435

1436 1437
	if (paths > 0)
		dev_dbg(fe->dev, "ASoC: found %d audio %s paths\n", paths,
1438
			stream ? "capture" : "playback");
1439 1440 1441
	else if (paths == 0)
		dev_dbg(fe->dev, "ASoC: %s no valid %s path\n", fe->dai_link->name,
			 stream ? "capture" : "playback");
1442 1443 1444 1445

	return paths;
}

1446 1447 1448 1449 1450
void dpcm_path_put(struct snd_soc_dapm_widget_list **list)
{
	snd_soc_dapm_dai_free_widgets(list);
}

1451 1452
static bool dpcm_be_is_active(struct snd_soc_dpcm *dpcm, int stream,
			      struct snd_soc_dapm_widget_list *list)
1453
{
1454
	struct snd_soc_dai *dai;
1455 1456
	unsigned int i;

1457 1458
	/* is there a valid DAI widget for this BE */
	for_each_rtd_dais(dpcm->be, i, dai) {
1459
		struct snd_soc_dapm_widget *widget = snd_soc_dai_get_widget(dai, stream);
1460 1461

		/*
1462
		 * The BE is pruned only if none of the dai
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475
		 * widgets are in the active list.
		 */
		if (widget && widget_in_list(list, widget))
			return true;
	}

	return false;
}

static int dpcm_prune_paths(struct snd_soc_pcm_runtime *fe, int stream,
			    struct snd_soc_dapm_widget_list **list_)
{
	struct snd_soc_dpcm *dpcm;
1476 1477 1478
	int prune = 0;

	/* Destroy any old FE <--> BE connections */
1479
	for_each_dpcm_be(fe, stream, dpcm) {
1480
		if (dpcm_be_is_active(dpcm, stream, *list_))
1481
			continue;
1482

1483
		dev_dbg(fe->dev, "ASoC: pruning %s BE %s for %s\n",
1484 1485 1486
			stream ? "capture" : "playback",
			dpcm->be->dai_link->name, fe->dai_link->name);
		dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
1487
		dpcm_set_be_update_state(dpcm->be, stream, SND_SOC_DPCM_UPDATE_BE);
1488 1489 1490
		prune++;
	}

1491
	dev_dbg(fe->dev, "ASoC: found %d old BE paths for pruning\n", prune);
1492 1493 1494 1495 1496 1497 1498 1499 1500
	return prune;
}

static int dpcm_add_paths(struct snd_soc_pcm_runtime *fe, int stream,
	struct snd_soc_dapm_widget_list **list_)
{
	struct snd_soc_card *card = fe->card;
	struct snd_soc_dapm_widget_list *list = *list_;
	struct snd_soc_pcm_runtime *be;
1501
	struct snd_soc_dapm_widget *widget;
1502
	struct snd_pcm_substream *fe_substream = snd_soc_dpcm_get_substream(fe, stream);
1503 1504
	int i, new = 0, err;

1505
	/* don't connect if FE is not running */
1506
	if (!fe_substream->runtime && !fe->fe_compr)
1507 1508
		return new;

1509
	/* Create any new FE <--> BE connections */
1510
	for_each_dapm_widgets(list, i, widget) {
1511

1512
		switch (widget->id) {
1513
		case snd_soc_dapm_dai_in:
1514 1515 1516
			if (stream != SNDRV_PCM_STREAM_PLAYBACK)
				continue;
			break;
1517
		case snd_soc_dapm_dai_out:
1518 1519
			if (stream != SNDRV_PCM_STREAM_CAPTURE)
				continue;
1520 1521
			break;
		default:
1522
			continue;
1523
		}
1524 1525

		/* is there a valid BE rtd for this widget */
1526
		be = dpcm_get_be(card, widget, stream);
1527
		if (!be) {
1528 1529
			dev_dbg(fe->dev, "ASoC: no BE found for %s\n",
				widget->name);
1530 1531 1532
			continue;
		}

1533 1534 1535 1536 1537 1538 1539
		/*
		 * Filter for systems with 'component_chaining' enabled.
		 * This helps to avoid unnecessary re-configuration of an
		 * already active BE on such systems.
		 */
		if (fe->card->component_chaining &&
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_NEW) &&
1540 1541 1542
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
			continue;

1543 1544 1545
		/* newly connected FE and BE */
		err = dpcm_be_connect(fe, be, stream);
		if (err < 0) {
1546
			dev_err(fe->dev, "ASoC: can't connect %s\n",
1547
				widget->name);
1548 1549 1550 1551 1552
			break;
		} else if (err == 0) /* already connected */
			continue;

		/* new */
1553
		dpcm_set_be_update_state(be, stream, SND_SOC_DPCM_UPDATE_BE);
1554 1555 1556
		new++;
	}

1557
	dev_dbg(fe->dev, "ASoC: found %d new BE paths\n", new);
1558 1559 1560 1561 1562 1563 1564
	return new;
}

/*
 * Find the corresponding BE DAIs that source or sink audio to this
 * FE substream.
 */
1565
int dpcm_process_paths(struct snd_soc_pcm_runtime *fe,
1566 1567 1568 1569 1570 1571 1572 1573
	int stream, struct snd_soc_dapm_widget_list **list, int new)
{
	if (new)
		return dpcm_add_paths(fe, stream, list);
	else
		return dpcm_prune_paths(fe, stream, list);
}

1574
void dpcm_clear_pending_state(struct snd_soc_pcm_runtime *fe, int stream)
1575 1576 1577
{
	struct snd_soc_dpcm *dpcm;

1578
	for_each_dpcm_be(fe, stream, dpcm)
1579
		dpcm_set_be_update_state(dpcm->be, stream, SND_SOC_DPCM_UPDATE_NO);
1580 1581
}

1582 1583
void dpcm_be_dai_stop(struct snd_soc_pcm_runtime *fe, int stream,
		      int do_hw_free, struct snd_soc_dpcm *last)
1584 1585 1586 1587
{
	struct snd_soc_dpcm *dpcm;

	/* disable any enabled and non active backends */
1588
	for_each_dpcm_be(fe, stream, dpcm) {
1589 1590 1591 1592
		struct snd_soc_pcm_runtime *be = dpcm->be;
		struct snd_pcm_substream *be_substream =
			snd_soc_dpcm_get_substream(be, stream);

1593 1594 1595 1596 1597 1598 1599
		if (dpcm == last)
			return;

		/* is this op for this BE ? */
		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
			continue;

1600
		if (be->dpcm[stream].users == 0) {
1601
			dev_err(be->dev, "ASoC: no users %s at close - state %d\n",
1602 1603
				stream ? "capture" : "playback",
				be->dpcm[stream].state);
1604 1605
			continue;
		}
1606 1607 1608 1609

		if (--be->dpcm[stream].users != 0)
			continue;

1610 1611 1612 1613 1614
		if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) {
			if (!do_hw_free)
				continue;

			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) {
1615
				__soc_pcm_hw_free(be, be_substream);
1616 1617 1618
				be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
			}
		}
1619

1620
		__soc_pcm_close(be, be_substream);
1621 1622 1623 1624 1625
		be_substream->runtime = NULL;
		be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
	}
}

1626
int dpcm_be_dai_startup(struct snd_soc_pcm_runtime *fe, int stream)
1627
{
1628
	struct snd_pcm_substream *fe_substream = snd_soc_dpcm_get_substream(fe, stream);
1629
	struct snd_soc_pcm_runtime *be;
1630 1631 1632 1633
	struct snd_soc_dpcm *dpcm;
	int err, count = 0;

	/* only startup BE DAIs that are either sinks or sources to this FE DAI */
1634
	for_each_dpcm_be(fe, stream, dpcm) {
1635
		struct snd_pcm_substream *be_substream;
1636

1637 1638
		be = dpcm->be;
		be_substream = snd_soc_dpcm_get_substream(be, stream);
1639

1640 1641 1642 1643 1644 1645
		if (!be_substream) {
			dev_err(be->dev, "ASoC: no backend %s stream\n",
				stream ? "capture" : "playback");
			continue;
		}

1646 1647 1648 1649 1650
		/* is this op for this BE ? */
		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
			continue;

		/* first time the dpcm is open ? */
1651
		if (be->dpcm[stream].users == DPCM_MAX_BE_USERS) {
1652
			dev_err(be->dev, "ASoC: too many users %s at open %d\n",
1653 1654
				stream ? "capture" : "playback",
				be->dpcm[stream].state);
1655 1656
			continue;
		}
1657 1658 1659 1660 1661 1662 1663 1664

		if (be->dpcm[stream].users++ != 0)
			continue;

		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_NEW) &&
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
			continue;

1665 1666
		dev_dbg(be->dev, "ASoC: open %s BE %s\n",
			stream ? "capture" : "playback", be->dai_link->name);
1667

1668
		be_substream->runtime = fe_substream->runtime;
1669
		err = __soc_pcm_open(be, be_substream);
1670 1671 1672
		if (err < 0) {
			be->dpcm[stream].users--;
			if (be->dpcm[stream].users < 0)
1673
				dev_err(be->dev, "ASoC: no users %s at unwind %d\n",
1674 1675 1676 1677 1678 1679
					stream ? "capture" : "playback",
					be->dpcm[stream].state);

			be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
			goto unwind;
		}
1680
		be->dpcm[stream].be_start = 0;
1681 1682 1683 1684 1685 1686 1687
		be->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
		count++;
	}

	return count;

unwind:
1688
	dpcm_be_dai_startup_rollback(fe, stream, dpcm);
1689

1690
	return soc_pcm_ret(fe, err);
1691 1692
}

1693 1694
static void dpcm_runtime_setup_fe(struct snd_pcm_substream *substream)
{
1695
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
1696 1697 1698 1699
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct snd_pcm_hardware *hw = &runtime->hw;
	struct snd_soc_dai *dai;
	int stream = substream->stream;
1700
	u64 formats = hw->formats;
1701 1702 1703 1704
	int i;

	soc_pcm_hw_init(hw);

1705 1706 1707
	if (formats)
		hw->formats &= formats;

1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726
	for_each_rtd_cpu_dais(fe, i, dai) {
		struct snd_soc_pcm_stream *cpu_stream;

		/*
		 * Skip CPUs which don't support the current stream
		 * type. See soc_pcm_init_runtime_hw() for more details
		 */
		if (!snd_soc_dai_stream_valid(dai, stream))
			continue;

		cpu_stream = snd_soc_dai_get_pcm_stream(dai, stream);

		soc_pcm_hw_update_rate(hw, cpu_stream);
		soc_pcm_hw_update_chan(hw, cpu_stream);
		soc_pcm_hw_update_format(hw, cpu_stream);
	}

}

1727
static void dpcm_runtime_setup_be_format(struct snd_pcm_substream *substream)
1728
{
1729
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
1730
	struct snd_pcm_runtime *runtime = substream->runtime;
1731
	struct snd_pcm_hardware *hw = &runtime->hw;
1732
	struct snd_soc_dpcm *dpcm;
1733
	struct snd_soc_dai *dai;
1734 1735 1736
	int stream = substream->stream;

	if (!fe->dai_link->dpcm_merged_format)
1737
		return;
1738 1739 1740 1741 1742 1743

	/*
	 * It returns merged BE codec format
	 * if FE want to use it (= dpcm_merged_format)
	 */

1744
	for_each_dpcm_be(fe, stream, dpcm) {
1745 1746 1747 1748
		struct snd_soc_pcm_runtime *be = dpcm->be;
		struct snd_soc_pcm_stream *codec_stream;
		int i;

1749
		for_each_rtd_codec_dais(be, i, dai) {
1750 1751 1752 1753
			/*
			 * Skip CODECs which don't support the current stream
			 * type. See soc_pcm_init_runtime_hw() for more details
			 */
1754
			if (!snd_soc_dai_stream_valid(dai, stream))
1755 1756
				continue;

1757
			codec_stream = snd_soc_dai_get_pcm_stream(dai, stream);
1758

1759
			soc_pcm_hw_update_format(hw, codec_stream);
1760 1761 1762 1763
		}
	}
}

1764
static void dpcm_runtime_setup_be_chan(struct snd_pcm_substream *substream)
1765
{
1766
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
1767
	struct snd_pcm_runtime *runtime = substream->runtime;
1768
	struct snd_pcm_hardware *hw = &runtime->hw;
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
	struct snd_soc_dpcm *dpcm;
	int stream = substream->stream;

	if (!fe->dai_link->dpcm_merged_chan)
		return;

	/*
	 * It returns merged BE codec channel;
	 * if FE want to use it (= dpcm_merged_chan)
	 */

1780
	for_each_dpcm_be(fe, stream, dpcm) {
1781
		struct snd_soc_pcm_runtime *be = dpcm->be;
1782
		struct snd_soc_pcm_stream *cpu_stream;
1783 1784
		struct snd_soc_dai *dai;
		int i;
1785

1786
		for_each_rtd_cpu_dais(be, i, dai) {
1787 1788 1789 1790 1791 1792 1793
			/*
			 * Skip CPUs which don't support the current stream
			 * type. See soc_pcm_init_runtime_hw() for more details
			 */
			if (!snd_soc_dai_stream_valid(dai, stream))
				continue;

1794
			cpu_stream = snd_soc_dai_get_pcm_stream(dai, stream);
1795

1796
			soc_pcm_hw_update_chan(hw, cpu_stream);
1797
		}
1798 1799 1800 1801 1802

		/*
		 * chan min/max cannot be enforced if there are multiple CODEC
		 * DAIs connected to a single CPU DAI, use CPU DAI's directly
		 */
1803
		if (be->dai_link->num_codecs == 1) {
1804
			struct snd_soc_pcm_stream *codec_stream = snd_soc_dai_get_pcm_stream(
1805
				snd_soc_rtd_to_codec(be, 0), stream);
1806

1807
			soc_pcm_hw_update_chan(hw, codec_stream);
1808 1809 1810 1811
		}
	}
}

1812
static void dpcm_runtime_setup_be_rate(struct snd_pcm_substream *substream)
1813
{
1814
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
1815
	struct snd_pcm_runtime *runtime = substream->runtime;
1816
	struct snd_pcm_hardware *hw = &runtime->hw;
1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827
	struct snd_soc_dpcm *dpcm;
	int stream = substream->stream;

	if (!fe->dai_link->dpcm_merged_rate)
		return;

	/*
	 * It returns merged BE codec channel;
	 * if FE want to use it (= dpcm_merged_chan)
	 */

1828
	for_each_dpcm_be(fe, stream, dpcm) {
1829
		struct snd_soc_pcm_runtime *be = dpcm->be;
1830
		struct snd_soc_pcm_stream *pcm;
1831
		struct snd_soc_dai *dai;
1832 1833
		int i;

1834
		for_each_rtd_dais(be, i, dai) {
1835
			/*
1836
			 * Skip DAIs which don't support the current stream
1837 1838
			 * type. See soc_pcm_init_runtime_hw() for more details
			 */
1839
			if (!snd_soc_dai_stream_valid(dai, stream))
1840 1841
				continue;

1842
			pcm = snd_soc_dai_get_pcm_stream(dai, stream);
1843

1844
			soc_pcm_hw_update_rate(hw, pcm);
1845 1846 1847 1848
		}
	}
}

1849 1850 1851 1852
static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream,
			       int stream)
{
	struct snd_soc_dpcm *dpcm;
1853
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(fe_substream);
1854
	struct snd_soc_dai *fe_cpu_dai;
1855
	int err = 0;
1856
	int i;
1857 1858

	/* apply symmetry for FE */
1859
	soc_pcm_update_symmetry(fe_substream);
1860

1861
	for_each_rtd_cpu_dais (fe, i, fe_cpu_dai) {
1862
		/* Symmetry only applies if we've got an active stream. */
1863 1864
		err = soc_pcm_apply_symmetry(fe_substream, fe_cpu_dai);
		if (err < 0)
1865
			goto error;
1866 1867 1868
	}

	/* apply symmetry for BE */
1869
	for_each_dpcm_be(fe, stream, dpcm) {
1870 1871 1872
		struct snd_soc_pcm_runtime *be = dpcm->be;
		struct snd_pcm_substream *be_substream =
			snd_soc_dpcm_get_substream(be, stream);
1873
		struct snd_soc_pcm_runtime *rtd;
1874
		struct snd_soc_dai *dai;
1875

1876 1877 1878 1879
		/* A backend may not have the requested substream */
		if (!be_substream)
			continue;

1880
		rtd = snd_soc_substream_to_rtd(be_substream);
1881 1882 1883
		if (rtd->dai_link->be_hw_params_fixup)
			continue;

1884
		soc_pcm_update_symmetry(be_substream);
1885 1886

		/* Symmetry only applies if we've got an active stream. */
1887
		for_each_rtd_dais(rtd, i, dai) {
1888 1889
			err = soc_pcm_apply_symmetry(fe_substream, dai);
			if (err < 0)
1890
				goto error;
1891 1892
		}
	}
1893
error:
1894
	return soc_pcm_ret(fe, err);
1895 1896
}

1897 1898
static int dpcm_fe_dai_startup(struct snd_pcm_substream *fe_substream)
{
1899
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(fe_substream);
1900 1901
	int stream = fe_substream->stream, ret = 0;

1902
	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
1903

1904
	ret = dpcm_be_dai_startup(fe, stream);
1905
	if (ret < 0)
1906 1907
		goto be_err;

1908
	dev_dbg(fe->dev, "ASoC: open FE %s\n", fe->dai_link->name);
1909 1910

	/* start the DAI frontend */
1911
	ret = __soc_pcm_open(fe, fe_substream);
1912
	if (ret < 0)
1913 1914 1915 1916
		goto unwind;

	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;

1917 1918 1919 1920 1921
	dpcm_runtime_setup_fe(fe_substream);

	dpcm_runtime_setup_be_format(fe_substream);
	dpcm_runtime_setup_be_chan(fe_substream);
	dpcm_runtime_setup_be_rate(fe_substream);
1922

1923
	ret = dpcm_apply_symmetry(fe_substream, stream);
1924 1925

unwind:
1926 1927
	if (ret < 0)
		dpcm_be_dai_startup_unwind(fe, stream);
1928
be_err:
1929
	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
1930

1931
	return soc_pcm_ret(fe, ret);
1932 1933 1934 1935
}

static int dpcm_fe_dai_shutdown(struct snd_pcm_substream *substream)
{
1936
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
1937 1938
	int stream = substream->stream;

1939 1940
	snd_soc_dpcm_mutex_assert_held(fe);

1941
	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
1942 1943

	/* shutdown the BEs */
1944
	dpcm_be_dai_shutdown(fe, stream);
1945

1946
	dev_dbg(fe->dev, "ASoC: close FE %s\n", fe->dai_link->name);
1947 1948

	/* now shutdown the frontend */
1949
	__soc_pcm_close(fe, substream);
1950

1951 1952 1953
	/* run the stream stop event */
	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);

1954
	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1955
	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
1956 1957 1958
	return 0;
}

1959
void dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime *fe, int stream)
1960 1961 1962 1963 1964
{
	struct snd_soc_dpcm *dpcm;

	/* only hw_params backends that are either sinks or sources
	 * to this frontend DAI */
1965
	for_each_dpcm_be(fe, stream, dpcm) {
1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978

		struct snd_soc_pcm_runtime *be = dpcm->be;
		struct snd_pcm_substream *be_substream =
			snd_soc_dpcm_get_substream(be, stream);

		/* is this op for this BE ? */
		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
			continue;

		/* only free hw when no longer used - check all FEs */
		if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
				continue;

1979 1980 1981 1982
		/* do not free hw if this BE is used by other FE */
		if (be->dpcm[stream].users > 1)
			continue;

1983 1984 1985
		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
1986
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED) &&
1987 1988
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
1989 1990
			continue;

1991
		dev_dbg(be->dev, "ASoC: hw_free BE %s\n",
1992
			be->dai_link->name);
1993

1994
		__soc_pcm_hw_free(be, be_substream);
1995 1996 1997 1998 1999

		be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
	}
}

2000
static int dpcm_fe_dai_hw_free(struct snd_pcm_substream *substream)
2001
{
2002
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2003
	int stream = substream->stream;
2004

2005
	snd_soc_dpcm_mutex_lock(fe);
2006
	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
2007

2008
	dev_dbg(fe->dev, "ASoC: hw_free FE %s\n", fe->dai_link->name);
2009 2010

	/* call hw_free on the frontend */
2011
	soc_pcm_hw_clean(fe, substream, 0);
2012 2013 2014

	/* only hw_params backends that are either sinks or sources
	 * to this frontend DAI */
2015
	dpcm_be_dai_hw_free(fe, stream);
2016 2017

	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
2018
	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
2019

2020
	snd_soc_dpcm_mutex_unlock(fe);
2021 2022 2023
	return 0;
}

2024
int dpcm_be_dai_hw_params(struct snd_soc_pcm_runtime *fe, int stream)
2025
{
2026 2027
	struct snd_soc_pcm_runtime *be;
	struct snd_pcm_substream *be_substream;
2028 2029 2030
	struct snd_soc_dpcm *dpcm;
	int ret;

2031
	for_each_dpcm_be(fe, stream, dpcm) {
2032 2033
		struct snd_pcm_hw_params hw_params;

2034 2035
		be = dpcm->be;
		be_substream = snd_soc_dpcm_get_substream(be, stream);
2036 2037 2038 2039 2040 2041

		/* is this op for this BE ? */
		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
			continue;

		/* copy params for each dpcm */
2042
		memcpy(&hw_params, &fe->dpcm[stream].hw_params,
2043 2044 2045
				sizeof(struct snd_pcm_hw_params));

		/* perform any hw_params fixups */
2046
		ret = snd_soc_link_be_hw_params_fixup(be, &hw_params);
2047 2048
		if (ret < 0)
			goto unwind;
2049

2050
		/* copy the fixed-up hw params for BE dai */
2051
		memcpy(&be->dpcm[stream].hw_params, &hw_params,
2052 2053
		       sizeof(struct snd_pcm_hw_params));

2054 2055 2056 2057 2058 2059 2060 2061 2062 2063
		/* only allow hw_params() if no connected FEs are running */
		if (!snd_soc_dpcm_can_be_params(fe, be, stream))
			continue;

		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE))
			continue;

		dev_dbg(be->dev, "ASoC: hw_params BE %s\n",
2064
			be->dai_link->name);
2065

2066
		ret = __soc_pcm_hw_params(be, be_substream, &hw_params);
2067
		if (ret < 0)
2068 2069 2070 2071 2072 2073 2074
			goto unwind;

		be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
	}
	return 0;

unwind:
2075 2076 2077
	dev_dbg(fe->dev, "ASoC: %s() failed at %s (%d)\n",
		__func__, be->dai_link->name, ret);

2078
	/* disable any enabled and non active backends */
2079
	for_each_dpcm_be_rollback(fe, stream, dpcm) {
2080 2081
		be = dpcm->be;
		be_substream = snd_soc_dpcm_get_substream(be, stream);
2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095

		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
			continue;

		/* only allow hw_free() if no connected FEs are running */
		if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
			continue;

		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP))
			continue;

2096
		__soc_pcm_hw_free(be, be_substream);
2097 2098 2099 2100 2101
	}

	return ret;
}

2102 2103
static int dpcm_fe_dai_hw_params(struct snd_pcm_substream *substream,
				 struct snd_pcm_hw_params *params)
2104
{
2105
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2106 2107
	int ret, stream = substream->stream;

2108
	snd_soc_dpcm_mutex_lock(fe);
2109
	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
2110

2111
	memcpy(&fe->dpcm[stream].hw_params, params,
2112
			sizeof(struct snd_pcm_hw_params));
2113
	ret = dpcm_be_dai_hw_params(fe, stream);
2114
	if (ret < 0)
2115 2116
		goto out;

2117
	dev_dbg(fe->dev, "ASoC: hw_params FE %s rate %d chan %x fmt %d\n",
2118 2119 2120 2121
			fe->dai_link->name, params_rate(params),
			params_channels(params), params_format(params));

	/* call hw_params on the frontend */
2122
	ret = __soc_pcm_hw_params(fe, substream, params);
2123
	if (ret < 0)
2124
		dpcm_be_dai_hw_free(fe, stream);
2125
	else
2126 2127 2128
		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;

out:
2129
	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
2130
	snd_soc_dpcm_mutex_unlock(fe);
2131

2132
	return soc_pcm_ret(fe, ret);
2133 2134
}

2135
int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime *fe, int stream,
2136
			       int cmd)
2137
{
2138
	struct snd_soc_pcm_runtime *be;
2139
	bool pause_stop_transition;
2140
	struct snd_soc_dpcm *dpcm;
2141
	unsigned long flags;
2142 2143
	int ret = 0;

2144
	for_each_dpcm_be(fe, stream, dpcm) {
2145
		struct snd_pcm_substream *be_substream;
2146

2147 2148
		be = dpcm->be;
		be_substream = snd_soc_dpcm_get_substream(be, stream);
2149

2150
		snd_soc_dpcm_stream_lock_irqsave_nested(be, stream, flags);
2151

2152 2153
		/* is this op for this BE ? */
		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2154
			goto next;
2155

2156 2157 2158
		dev_dbg(be->dev, "ASoC: trigger BE %s cmd %d\n",
			be->dai_link->name, cmd);

2159 2160
		switch (cmd) {
		case SNDRV_PCM_TRIGGER_START:
2161 2162
			if (!be->dpcm[stream].be_start &&
			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
2163
			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
2164
			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2165
				goto next;
2166

2167 2168 2169 2170
			be->dpcm[stream].be_start++;
			if (be->dpcm[stream].be_start != 1)
				goto next;

2171 2172 2173 2174 2175 2176
			if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_PAUSED)
				ret = soc_pcm_trigger(be_substream,
						      SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
			else
				ret = soc_pcm_trigger(be_substream,
						      SNDRV_PCM_TRIGGER_START);
2177 2178
			if (ret) {
				be->dpcm[stream].be_start--;
2179
				goto next;
2180
			}
2181

2182
			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2183 2184
			break;
		case SNDRV_PCM_TRIGGER_RESUME:
2185
			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
2186
				goto next;
2187

2188 2189 2190 2191
			be->dpcm[stream].be_start++;
			if (be->dpcm[stream].be_start != 1)
				goto next;

2192
			ret = soc_pcm_trigger(be_substream, cmd);
2193 2194
			if (ret) {
				be->dpcm[stream].be_start--;
2195
				goto next;
2196
			}
2197

2198
			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2199 2200
			break;
		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2201 2202 2203
			if (!be->dpcm[stream].be_start &&
			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) &&
			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2204
				goto next;
2205

2206 2207 2208
			fe->dpcm[stream].fe_pause = false;
			be->dpcm[stream].be_pause--;

2209 2210 2211 2212
			be->dpcm[stream].be_start++;
			if (be->dpcm[stream].be_start != 1)
				goto next;

2213
			ret = soc_pcm_trigger(be_substream, cmd);
2214 2215
			if (ret) {
				be->dpcm[stream].be_start--;
2216
				goto next;
2217
			}
2218

2219
			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2220 2221
			break;
		case SNDRV_PCM_TRIGGER_STOP:
2222
			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) &&
2223
			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2224
				goto next;
2225

2226 2227 2228 2229
			if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_START)
				be->dpcm[stream].be_start--;

			if (be->dpcm[stream].be_start != 0)
2230
				goto next;
2231

2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243
			pause_stop_transition = false;
			if (fe->dpcm[stream].fe_pause) {
				pause_stop_transition = true;
				fe->dpcm[stream].fe_pause = false;
				be->dpcm[stream].be_pause--;
			}

			if (be->dpcm[stream].be_pause != 0)
				ret = soc_pcm_trigger(be_substream, SNDRV_PCM_TRIGGER_PAUSE_PUSH);
			else
				ret = soc_pcm_trigger(be_substream, SNDRV_PCM_TRIGGER_STOP);

2244 2245 2246
			if (ret) {
				if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_START)
					be->dpcm[stream].be_start++;
2247 2248 2249 2250
				if (pause_stop_transition) {
					fe->dpcm[stream].fe_pause = true;
					be->dpcm[stream].be_pause++;
				}
2251
				goto next;
2252
			}
2253

2254 2255 2256 2257 2258
			if (be->dpcm[stream].be_pause != 0)
				be->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
			else
				be->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;

2259 2260
			break;
		case SNDRV_PCM_TRIGGER_SUSPEND:
2261
			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
2262
				goto next;
2263

2264 2265
			be->dpcm[stream].be_start--;
			if (be->dpcm[stream].be_start != 0)
2266
				goto next;
2267

2268
			ret = soc_pcm_trigger(be_substream, cmd);
2269 2270
			if (ret) {
				be->dpcm[stream].be_start++;
2271
				goto next;
2272
			}
2273

2274
			be->dpcm[stream].state = SND_SOC_DPCM_STATE_SUSPEND;
2275 2276
			break;
		case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2277
			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
2278
				goto next;
2279

2280 2281 2282
			fe->dpcm[stream].fe_pause = true;
			be->dpcm[stream].be_pause++;

2283 2284
			be->dpcm[stream].be_start--;
			if (be->dpcm[stream].be_start != 0)
2285
				goto next;
2286

2287
			ret = soc_pcm_trigger(be_substream, cmd);
2288 2289
			if (ret) {
				be->dpcm[stream].be_start++;
2290
				goto next;
2291
			}
2292

2293
			be->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
2294 2295
			break;
		}
2296 2297 2298 2299
next:
		snd_soc_dpcm_stream_unlock_irqrestore(be, stream, flags);
		if (ret)
			break;
2300
	}
2301
	return soc_pcm_ret(fe, ret);
2302 2303 2304
}
EXPORT_SYMBOL_GPL(dpcm_be_dai_trigger);

2305 2306 2307
static int dpcm_dai_trigger_fe_be(struct snd_pcm_substream *substream,
				  int cmd, bool fe_first)
{
2308
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336
	int ret;

	/* call trigger on the frontend before the backend. */
	if (fe_first) {
		dev_dbg(fe->dev, "ASoC: pre trigger FE %s cmd %d\n",
			fe->dai_link->name, cmd);

		ret = soc_pcm_trigger(substream, cmd);
		if (ret < 0)
			return ret;

		ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
		return ret;
	}

	/* call trigger on the frontend after the backend. */
	ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
	if (ret < 0)
		return ret;

	dev_dbg(fe->dev, "ASoC: post trigger FE %s cmd %d\n",
		fe->dai_link->name, cmd);

	ret = soc_pcm_trigger(substream, cmd);

	return ret;
}

2337
static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd)
2338
{
2339
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2340 2341
	int stream = substream->stream;
	int ret = 0;
2342 2343 2344 2345 2346 2347
	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];

	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;

	switch (trigger) {
	case SND_SOC_DPCM_TRIGGER_PRE:
2348 2349 2350 2351
		switch (cmd) {
		case SNDRV_PCM_TRIGGER_START:
		case SNDRV_PCM_TRIGGER_RESUME:
		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2352
		case SNDRV_PCM_TRIGGER_DRAIN:
2353 2354 2355 2356 2357 2358 2359 2360 2361 2362
			ret = dpcm_dai_trigger_fe_be(substream, cmd, true);
			break;
		case SNDRV_PCM_TRIGGER_STOP:
		case SNDRV_PCM_TRIGGER_SUSPEND:
		case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
			ret = dpcm_dai_trigger_fe_be(substream, cmd, false);
			break;
		default:
			ret = -EINVAL;
			break;
2363 2364 2365
		}
		break;
	case SND_SOC_DPCM_TRIGGER_POST:
2366 2367 2368 2369
		switch (cmd) {
		case SNDRV_PCM_TRIGGER_START:
		case SNDRV_PCM_TRIGGER_RESUME:
		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2370
		case SNDRV_PCM_TRIGGER_DRAIN:
2371 2372 2373 2374 2375 2376 2377 2378 2379 2380
			ret = dpcm_dai_trigger_fe_be(substream, cmd, false);
			break;
		case SNDRV_PCM_TRIGGER_STOP:
		case SNDRV_PCM_TRIGGER_SUSPEND:
		case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
			ret = dpcm_dai_trigger_fe_be(substream, cmd, true);
			break;
		default:
			ret = -EINVAL;
			break;
2381 2382
		}
		break;
2383 2384 2385
	case SND_SOC_DPCM_TRIGGER_BESPOKE:
		/* bespoke trigger() - handles both FE and BEs */

2386
		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd %d\n",
2387 2388
				fe->dai_link->name, cmd);

2389
		ret = snd_soc_pcm_dai_bespoke_trigger(substream, cmd);
2390
		break;
2391
	default:
2392
		dev_err(fe->dev, "ASoC: invalid trigger cmd %d for %s\n", cmd,
2393 2394 2395 2396 2397
				fe->dai_link->name);
		ret = -EINVAL;
		goto out;
	}

2398 2399 2400 2401 2402 2403
	if (ret < 0) {
		dev_err(fe->dev, "ASoC: trigger FE cmd: %d failed: %d\n",
			cmd, ret);
		goto out;
	}

2404 2405 2406 2407 2408 2409 2410 2411 2412 2413
	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
	case SNDRV_PCM_TRIGGER_RESUME:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
		break;
	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:
		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
		break;
2414 2415 2416
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
		break;
2417 2418 2419 2420 2421 2422 2423
	}

out:
	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
	return ret;
}

2424 2425
static int dpcm_fe_dai_trigger(struct snd_pcm_substream *substream, int cmd)
{
2426
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440
	int stream = substream->stream;

	/* if FE's runtime_update is already set, we're in race;
	 * process this trigger later at exit
	 */
	if (fe->dpcm[stream].runtime_update != SND_SOC_DPCM_UPDATE_NO) {
		fe->dpcm[stream].trigger_pending = cmd + 1;
		return 0; /* delayed, assuming it's successful */
	}

	/* we're alone, let's trigger */
	return dpcm_fe_dai_do_trigger(substream, cmd);
}

2441
int dpcm_be_dai_prepare(struct snd_soc_pcm_runtime *fe, int stream)
2442 2443 2444 2445
{
	struct snd_soc_dpcm *dpcm;
	int ret = 0;

2446
	for_each_dpcm_be(fe, stream, dpcm) {
2447 2448 2449 2450 2451 2452 2453 2454 2455

		struct snd_soc_pcm_runtime *be = dpcm->be;
		struct snd_pcm_substream *be_substream =
			snd_soc_dpcm_get_substream(be, stream);

		/* is this op for this BE ? */
		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
			continue;

2456 2457 2458
		if (!snd_soc_dpcm_can_be_prepared(fe, be, stream))
			continue;

2459
		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
2460
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
2461 2462
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND) &&
		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2463 2464
			continue;

2465
		dev_dbg(be->dev, "ASoC: prepare BE %s\n",
2466
			be->dai_link->name);
2467

2468
		ret = __soc_pcm_prepare(be, be_substream);
2469
		if (ret < 0)
2470 2471 2472 2473
			break;

		be->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
	}
2474

2475
	return soc_pcm_ret(fe, ret);
2476 2477
}

2478
static int dpcm_fe_dai_prepare(struct snd_pcm_substream *substream)
2479
{
2480
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(substream);
2481 2482
	int stream = substream->stream, ret = 0;

2483
	snd_soc_dpcm_mutex_lock(fe);
2484

2485
	dev_dbg(fe->dev, "ASoC: prepare FE %s\n", fe->dai_link->name);
2486

2487
	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
2488 2489 2490

	/* there is no point preparing this FE if there are no BEs */
	if (list_empty(&fe->dpcm[stream].be_clients)) {
2491 2492 2493 2494 2495
		/* dev_err_once() for visibility, dev_dbg() for debugging UCM profiles */
		dev_err_once(fe->dev, "ASoC: no backend DAIs enabled for %s, possibly missing ALSA mixer-based routing or UCM profile\n",
			     fe->dai_link->name);
		dev_dbg(fe->dev, "ASoC: no backend DAIs enabled for %s\n",
			fe->dai_link->name);
2496 2497 2498 2499
		ret = -EINVAL;
		goto out;
	}

2500
	ret = dpcm_be_dai_prepare(fe, stream);
2501 2502 2503 2504
	if (ret < 0)
		goto out;

	/* call prepare on the frontend */
2505
	ret = __soc_pcm_prepare(fe, substream);
2506
	if (ret < 0)
2507 2508 2509 2510 2511
		goto out;

	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;

out:
2512
	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
2513
	snd_soc_dpcm_mutex_unlock(fe);
2514

2515
	return soc_pcm_ret(fe, ret);
2516 2517
}

2518 2519
static int dpcm_run_update_shutdown(struct snd_soc_pcm_runtime *fe, int stream)
{
2520 2521 2522
	struct snd_pcm_substream *substream =
		snd_soc_dpcm_get_substream(fe, stream);
	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2523 2524
	int err;

2525
	dev_dbg(fe->dev, "ASoC: runtime %s close on FE %s\n",
2526 2527
			stream ? "capture" : "playback", fe->dai_link->name);

2528 2529
	if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
		/* call bespoke trigger - FE takes care of all BE triggers */
2530
		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd stop\n",
2531 2532
				fe->dai_link->name);

2533
		err = snd_soc_pcm_dai_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_STOP);
2534
	} else {
2535
		dev_dbg(fe->dev, "ASoC: trigger FE %s cmd stop\n",
2536 2537 2538 2539
			fe->dai_link->name);

		err = dpcm_be_dai_trigger(fe, stream, SNDRV_PCM_TRIGGER_STOP);
	}
2540

2541
	dpcm_be_dai_hw_free(fe, stream);
2542

2543
	dpcm_be_dai_shutdown(fe, stream);
2544 2545 2546 2547

	/* run the stream event for each BE */
	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP);

2548
	return soc_pcm_ret(fe, err);
2549 2550 2551 2552
}

static int dpcm_run_update_startup(struct snd_soc_pcm_runtime *fe, int stream)
{
2553 2554
	struct snd_pcm_substream *substream =
		snd_soc_dpcm_get_substream(fe, stream);
2555
	struct snd_soc_dpcm *dpcm;
2556
	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2557
	int ret = 0;
2558

2559
	dev_dbg(fe->dev, "ASoC: runtime %s open on FE %s\n",
2560 2561 2562 2563
			stream ? "capture" : "playback", fe->dai_link->name);

	/* Only start the BE if the FE is ready */
	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_FREE ||
2564 2565 2566
		fe->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE) {
		dev_err(fe->dev, "ASoC: FE %s is not ready %d\n",
			fe->dai_link->name, fe->dpcm[stream].state);
2567
		ret = -EINVAL;
2568 2569
		goto disconnect;
	}
2570 2571 2572

	/* startup must always be called for new BEs */
	ret = dpcm_be_dai_startup(fe, stream);
2573
	if (ret < 0)
2574 2575 2576 2577 2578
		goto disconnect;

	/* keep going if FE state is > open */
	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_OPEN)
		return 0;
2579

2580
	ret = dpcm_be_dai_hw_params(fe, stream);
2581
	if (ret < 0)
2582 2583 2584 2585 2586 2587 2588
		goto close;

	/* keep going if FE state is > hw_params */
	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_PARAMS)
		return 0;

	ret = dpcm_be_dai_prepare(fe, stream);
2589
	if (ret < 0)
2590 2591 2592 2593 2594 2595 2596 2597 2598 2599
		goto hw_free;

	/* run the stream event for each BE */
	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP);

	/* keep going if FE state is > prepare */
	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_PREPARE ||
		fe->dpcm[stream].state == SND_SOC_DPCM_STATE_STOP)
		return 0;

2600 2601
	if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
		/* call trigger on the frontend - FE takes care of all BE triggers */
2602
		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd start\n",
2603
				fe->dai_link->name);
2604

2605
		ret = snd_soc_pcm_dai_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_START);
2606
		if (ret < 0)
2607 2608
			goto hw_free;
	} else {
2609
		dev_dbg(fe->dev, "ASoC: trigger FE %s cmd start\n",
2610 2611 2612 2613
			fe->dai_link->name);

		ret = dpcm_be_dai_trigger(fe, stream,
					SNDRV_PCM_TRIGGER_START);
2614
		if (ret < 0)
2615
			goto hw_free;
2616 2617 2618 2619 2620 2621 2622 2623 2624
	}

	return 0;

hw_free:
	dpcm_be_dai_hw_free(fe, stream);
close:
	dpcm_be_dai_shutdown(fe, stream);
disconnect:
2625
	/* disconnect any pending BEs */
2626
	for_each_dpcm_be(fe, stream, dpcm) {
2627
		struct snd_soc_pcm_runtime *be = dpcm->be;
2628 2629 2630 2631 2632 2633 2634 2635

		/* is this op for this BE ? */
		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
			continue;

		if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE ||
			be->dpcm[stream].state == SND_SOC_DPCM_STATE_NEW)
				dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
2636 2637
	}

2638
	return soc_pcm_ret(fe, ret);
2639 2640
}

2641
static int soc_dpcm_fe_runtime_update(struct snd_soc_pcm_runtime *fe, int new)
2642
{
2643
	struct snd_soc_dapm_widget_list *list;
2644
	int stream;
2645
	int count, paths;
2646

2647 2648 2649
	if (!fe->dai_link->dynamic)
		return 0;

2650
	if (fe->dai_link->num_cpus > 1) {
2651 2652 2653 2654 2655
		dev_err(fe->dev,
			"%s doesn't support Multi CPU yet\n", __func__);
		return -EINVAL;
	}

2656
	/* only check active links */
2657
	if (!snd_soc_dai_active(snd_soc_rtd_to_cpu(fe, 0)))
2658
		return 0;
2659

2660 2661 2662
	/* DAPM sync will call this to update DSP paths */
	dev_dbg(fe->dev, "ASoC: DPCM %s runtime update for FE %s\n",
		new ? "new" : "old", fe->dai_link->name);
2663

2664
	for_each_pcm_streams(stream) {
2665

2666
		/* skip if FE doesn't have playback/capture capability */
2667 2668
		if (!snd_soc_dai_stream_valid(snd_soc_rtd_to_cpu(fe, 0),   stream) ||
		    !snd_soc_dai_stream_valid(snd_soc_rtd_to_codec(fe, 0), stream))
2669
			continue;
2670

2671
		/* skip if FE isn't currently playing/capturing */
2672 2673
		if (!snd_soc_dai_stream_active(snd_soc_rtd_to_cpu(fe, 0), stream) ||
		    !snd_soc_dai_stream_active(snd_soc_rtd_to_codec(fe, 0), stream))
2674
			continue;
2675

2676
		paths = dpcm_path_get(fe, stream, &list);
2677
		if (paths < 0)
2678
			return paths;
2679

2680 2681 2682
		/* update any playback/capture paths */
		count = dpcm_process_paths(fe, stream, &list, new);
		if (count) {
2683
			dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_BE);
2684
			if (new)
2685
				dpcm_run_update_startup(fe, stream);
2686
			else
2687
				dpcm_run_update_shutdown(fe, stream);
2688
			dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
2689

2690 2691 2692
			dpcm_clear_pending_state(fe, stream);
			dpcm_be_disconnect(fe, stream);
		}
2693

2694
		dpcm_path_put(&list);
2695 2696 2697 2698
	}

	return 0;
}
2699 2700 2701 2702

/* Called by DAPM mixer/mux changes to update audio routing between PCMs and
 * any DAI links.
 */
2703
int snd_soc_dpcm_runtime_update(struct snd_soc_card *card)
2704 2705 2706 2707
{
	struct snd_soc_pcm_runtime *fe;
	int ret = 0;

2708
	snd_soc_dpcm_mutex_lock(card);
2709
	/* shutdown all old paths first */
2710
	for_each_card_rtds(card, fe) {
2711 2712 2713 2714 2715 2716
		ret = soc_dpcm_fe_runtime_update(fe, 0);
		if (ret)
			goto out;
	}

	/* bring new paths up */
2717
	for_each_card_rtds(card, fe) {
2718 2719 2720 2721 2722 2723
		ret = soc_dpcm_fe_runtime_update(fe, 1);
		if (ret)
			goto out;
	}

out:
2724
	snd_soc_dpcm_mutex_unlock(card);
2725 2726
	return ret;
}
2727
EXPORT_SYMBOL_GPL(snd_soc_dpcm_runtime_update);
2728

2729
static void dpcm_fe_dai_cleanup(struct snd_pcm_substream *fe_substream)
2730
{
2731
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(fe_substream);
2732
	struct snd_soc_dpcm *dpcm;
2733
	int stream = fe_substream->stream;
2734

2735 2736
	snd_soc_dpcm_mutex_assert_held(fe);

2737 2738 2739 2740 2741
	/* mark FE's links ready to prune */
	for_each_dpcm_be(fe, stream, dpcm)
		dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;

	dpcm_be_disconnect(fe, stream);
2742 2743 2744 2745
}

static int dpcm_fe_dai_close(struct snd_pcm_substream *fe_substream)
{
2746
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(fe_substream);
2747 2748
	int ret;

2749
	snd_soc_dpcm_mutex_lock(fe);
2750 2751 2752 2753
	ret = dpcm_fe_dai_shutdown(fe_substream);

	dpcm_fe_dai_cleanup(fe_substream);

2754
	snd_soc_dpcm_mutex_unlock(fe);
2755 2756 2757
	return ret;
}

2758
static int dpcm_fe_dai_open(struct snd_pcm_substream *fe_substream)
2759
{
2760
	struct snd_soc_pcm_runtime *fe = snd_soc_substream_to_rtd(fe_substream);
2761 2762 2763 2764
	struct snd_soc_dapm_widget_list *list;
	int ret;
	int stream = fe_substream->stream;

2765
	snd_soc_dpcm_mutex_lock(fe);
2766

2767
	ret = dpcm_path_get(fe, stream, &list);
2768
	if (ret < 0)
2769
		goto open_end;
2770 2771 2772 2773 2774

	/* calculate valid and active FE <-> BE dpcms */
	dpcm_process_paths(fe, stream, &list, 1);

	ret = dpcm_fe_dai_startup(fe_substream);
2775 2776
	if (ret < 0)
		dpcm_fe_dai_cleanup(fe_substream);
2777 2778 2779

	dpcm_clear_pending_state(fe, stream);
	dpcm_path_put(&list);
2780
open_end:
2781
	snd_soc_dpcm_mutex_unlock(fe);
2782 2783 2784
	return ret;
}

2785 2786
static int soc_get_playback_capture(struct snd_soc_pcm_runtime *rtd,
				    int *playback, int *capture)
2787
{
2788
	struct snd_soc_dai_link *dai_link = rtd->dai_link;
2789
	struct snd_soc_dai *cpu_dai;
2790 2791
	int has_playback = 0;
	int has_capture  = 0;
2792
	int i;
2793

2794
	if (dai_link->dynamic && dai_link->num_cpus > 1) {
2795
		dev_err(rtd->dev, "DPCM doesn't support Multi CPU for Front-Ends yet\n");
2796 2797 2798
		return -EINVAL;
	}

2799
	if (dai_link->dynamic || dai_link->no_pcm) {
2800 2801
		int stream;

2802
		if (dai_link->dpcm_playback) {
2803 2804
			stream = SNDRV_PCM_STREAM_PLAYBACK;

2805 2806
			for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
				if (snd_soc_dai_stream_valid(cpu_dai, stream)) {
2807
					has_playback = 1;
2808
					break;
2809
				}
2810
			}
2811
			if (!has_playback) {
2812 2813
				dev_err(rtd->card->dev,
					"No CPU DAIs support playback for stream %s\n",
2814
					dai_link->stream_name);
2815 2816
				return -EINVAL;
			}
2817
		}
2818
		if (dai_link->dpcm_capture) {
2819 2820
			stream = SNDRV_PCM_STREAM_CAPTURE;

2821 2822
			for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
				if (snd_soc_dai_stream_valid(cpu_dai, stream)) {
2823
					has_capture = 1;
2824
					break;
2825
				}
2826 2827
			}

2828
			if (!has_capture) {
2829 2830
				dev_err(rtd->card->dev,
					"No CPU DAIs support capture for stream %s\n",
2831
					dai_link->stream_name);
2832 2833
				return -EINVAL;
			}
2834
		}
2835
	} else {
2836
		struct snd_soc_dai_link_ch_map *ch_maps;
2837 2838
		struct snd_soc_dai *codec_dai;

2839
		/* Adapt stream for codec2codec links */
2840 2841
		int cpu_capture  = snd_soc_get_stream_cpu(dai_link, SNDRV_PCM_STREAM_CAPTURE);
		int cpu_playback = snd_soc_get_stream_cpu(dai_link, SNDRV_PCM_STREAM_PLAYBACK);
2842

2843 2844 2845 2846 2847 2848 2849
		/*
		 * see
		 *	soc.h :: [dai_link->ch_maps Image sample]
		 */
		for_each_rtd_ch_maps(rtd, i, ch_maps) {
			cpu_dai	  = snd_soc_rtd_to_cpu(rtd,   ch_maps->cpu);
			codec_dai = snd_soc_rtd_to_codec(rtd, ch_maps->codec);
2850

2851
			if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_PLAYBACK) &&
2852
			    snd_soc_dai_stream_valid(cpu_dai,   cpu_playback))
2853
				has_playback = 1;
2854
			if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_CAPTURE) &&
2855
			    snd_soc_dai_stream_valid(cpu_dai,   cpu_capture))
2856
				has_capture = 1;
2857
		}
2858 2859
	}

2860
	if (dai_link->playback_only)
2861
		has_capture = 0;
2862

2863
	if (dai_link->capture_only)
2864
		has_playback = 0;
2865

2866
	if (!has_playback && !has_capture) {
2867
		dev_err(rtd->dev, "substream %s has no playback, no capture\n",
2868
			dai_link->stream_name);
2869 2870 2871 2872

		return -EINVAL;
	}

2873 2874 2875
	*playback = has_playback;
	*capture  = has_capture;

2876 2877 2878
	return 0;
}

2879 2880 2881
static int soc_create_pcm(struct snd_pcm **pcm,
			  struct snd_soc_pcm_runtime *rtd,
			  int playback, int capture, int num)
2882 2883
{
	char new_name[64];
2884
	int ret;
2885

2886
	/* create the PCM */
2887
	if (rtd->dai_link->c2c_params) {
2888 2889 2890 2891
		snprintf(new_name, sizeof(new_name), "codec2codec(%s)",
			 rtd->dai_link->stream_name);

		ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
2892
					   playback, capture, pcm);
2893
	} else if (rtd->dai_link->no_pcm) {
2894 2895 2896 2897
		snprintf(new_name, sizeof(new_name), "(%s)",
			rtd->dai_link->stream_name);

		ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
2898
				playback, capture, pcm);
2899 2900 2901 2902 2903 2904
	} else {
		if (rtd->dai_link->dynamic)
			snprintf(new_name, sizeof(new_name), "%s (*)",
				rtd->dai_link->stream_name);
		else
			snprintf(new_name, sizeof(new_name), "%s %s-%d",
2905
				rtd->dai_link->stream_name,
2906
				soc_codec_dai_name(rtd), num);
2907 2908

		ret = snd_pcm_new(rtd->card->snd_card, new_name, num, playback,
2909
			capture, pcm);
2910
	}
2911
	if (ret < 0) {
2912 2913
		dev_err(rtd->card->dev, "ASoC: can't create pcm %s for dailink %s: %d\n",
			new_name, rtd->dai_link->name, ret);
2914 2915
		return ret;
	}
2916
	dev_dbg(rtd->card->dev, "ASoC: registered pcm #%d %s\n",num, new_name);
2917

2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936
	return 0;
}

/* create a new pcm */
int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
{
	struct snd_soc_component *component;
	struct snd_pcm *pcm;
	int ret = 0, playback = 0, capture = 0;
	int i;

	ret = soc_get_playback_capture(rtd, &playback, &capture);
	if (ret < 0)
		return ret;

	ret = soc_create_pcm(&pcm, rtd, playback, capture, num);
	if (ret < 0)
		return ret;

2937
	/* DAPM dai link stream work */
2938 2939 2940 2941 2942 2943
	/*
	 * 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.
	 */
2944
	if (!rtd->dai_link->c2c_params)
2945
		rtd->close_delayed_work_func = snd_soc_close_delayed_work;
2946 2947

	rtd->pcm = pcm;
2948
	pcm->nonatomic = rtd->dai_link->nonatomic;
2949
	pcm->private_data = rtd;
2950
	pcm->no_device_suspend = true;
2951

2952
	if (rtd->dai_link->no_pcm || rtd->dai_link->c2c_params) {
2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978
		if (playback)
			pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
		if (capture)
			pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
		goto out;
	}

	/* ASoC PCM operations */
	if (rtd->dai_link->dynamic) {
		rtd->ops.open		= dpcm_fe_dai_open;
		rtd->ops.hw_params	= dpcm_fe_dai_hw_params;
		rtd->ops.prepare	= dpcm_fe_dai_prepare;
		rtd->ops.trigger	= dpcm_fe_dai_trigger;
		rtd->ops.hw_free	= dpcm_fe_dai_hw_free;
		rtd->ops.close		= dpcm_fe_dai_close;
		rtd->ops.pointer	= soc_pcm_pointer;
	} else {
		rtd->ops.open		= soc_pcm_open;
		rtd->ops.hw_params	= soc_pcm_hw_params;
		rtd->ops.prepare	= soc_pcm_prepare;
		rtd->ops.trigger	= soc_pcm_trigger;
		rtd->ops.hw_free	= soc_pcm_hw_free;
		rtd->ops.close		= soc_pcm_close;
		rtd->ops.pointer	= soc_pcm_pointer;
	}

2979
	for_each_rtd_components(rtd, i, component) {
2980
		const struct snd_soc_component_driver *drv = component->driver;
2981

2982 2983
		if (drv->ioctl)
			rtd->ops.ioctl		= snd_soc_pcm_component_ioctl;
2984 2985
		if (drv->sync_stop)
			rtd->ops.sync_stop	= snd_soc_pcm_component_sync_stop;
2986 2987
		if (drv->copy)
			rtd->ops.copy		= snd_soc_pcm_component_copy;
2988
		if (drv->page)
2989
			rtd->ops.page		= snd_soc_pcm_component_page;
2990
		if (drv->mmap)
2991
			rtd->ops.mmap		= snd_soc_pcm_component_mmap;
2992 2993
		if (drv->ack)
			rtd->ops.ack            = snd_soc_pcm_component_ack;
2994 2995 2996
	}

	if (playback)
2997
		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &rtd->ops);
2998 2999

	if (capture)
3000
		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &rtd->ops);
3001

3002
	ret = snd_soc_pcm_component_new(rtd);
3003
	if (ret < 0)
3004
		return ret;
3005
out:
3006
	dev_dbg(rtd->card->dev, "%s <-> %s mapping ok\n",
3007
		soc_codec_dai_name(rtd), soc_cpu_dai_name(rtd));
3008 3009
	return ret;
}
3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039

/* is the current PCM operation for this FE ? */
int snd_soc_dpcm_fe_can_update(struct snd_soc_pcm_runtime *fe, int stream)
{
	if (fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE)
		return 1;
	return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_dpcm_fe_can_update);

/* is the current PCM operation for this BE ? */
int snd_soc_dpcm_be_can_update(struct snd_soc_pcm_runtime *fe,
		struct snd_soc_pcm_runtime *be, int stream)
{
	if ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE) ||
	   ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_BE) &&
		  be->dpcm[stream].runtime_update))
		return 1;
	return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_can_update);

/* get the substream for this BE */
struct snd_pcm_substream *
	snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime *be, int stream)
{
	return be->pcm->streams[stream].substream;
}
EXPORT_SYMBOL_GPL(snd_soc_dpcm_get_substream);

3040 3041 3042 3043 3044
static int snd_soc_dpcm_check_state(struct snd_soc_pcm_runtime *fe,
				    struct snd_soc_pcm_runtime *be,
				    int stream,
				    const enum snd_soc_dpcm_state *states,
				    int num_states)
3045 3046 3047
{
	struct snd_soc_dpcm *dpcm;
	int state;
3048
	int ret = 1;
3049
	int i;
3050

3051
	for_each_dpcm_fe(be, stream, dpcm) {
3052 3053 3054 3055 3056

		if (dpcm->fe == fe)
			continue;

		state = dpcm->fe->dpcm[stream].state;
3057 3058 3059 3060 3061
		for (i = 0; i < num_states; i++) {
			if (state == states[i]) {
				ret = 0;
				break;
			}
3062
		}
3063 3064
	}

3065
	/* it's safe to do this BE DAI */
3066
	return ret;
3067
}
3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083

/*
 * We can only hw_free, stop, pause or suspend a BE DAI if any of it's FE
 * are not running, paused or suspended for the specified stream direction.
 */
int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime *fe,
		struct snd_soc_pcm_runtime *be, int stream)
{
	const enum snd_soc_dpcm_state state[] = {
		SND_SOC_DPCM_STATE_START,
		SND_SOC_DPCM_STATE_PAUSED,
		SND_SOC_DPCM_STATE_SUSPEND,
	};

	return snd_soc_dpcm_check_state(fe, be, stream, state, ARRAY_SIZE(state));
}
3084 3085 3086 3087 3088 3089 3090 3091 3092
EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop);

/*
 * We can only change hw params a BE DAI if any of it's FE are not prepared,
 * running, paused or suspended for the specified stream direction.
 */
int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime *fe,
		struct snd_soc_pcm_runtime *be, int stream)
{
3093 3094 3095 3096 3097 3098
	const enum snd_soc_dpcm_state state[] = {
		SND_SOC_DPCM_STATE_START,
		SND_SOC_DPCM_STATE_PAUSED,
		SND_SOC_DPCM_STATE_SUSPEND,
		SND_SOC_DPCM_STATE_PREPARE,
	};
3099

3100
	return snd_soc_dpcm_check_state(fe, be, stream, state, ARRAY_SIZE(state));
3101 3102
}
EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params);
3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119

/*
 * We can only prepare a BE DAI if any of it's FE are not prepared,
 * running or paused for the specified stream direction.
 */
int snd_soc_dpcm_can_be_prepared(struct snd_soc_pcm_runtime *fe,
				 struct snd_soc_pcm_runtime *be, int stream)
{
	const enum snd_soc_dpcm_state state[] = {
		SND_SOC_DPCM_STATE_START,
		SND_SOC_DPCM_STATE_PAUSED,
		SND_SOC_DPCM_STATE_PREPARE,
	};

	return snd_soc_dpcm_check_state(fe, be, stream, state, ARRAY_SIZE(state));
}
EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_prepared);