1// SPDX-License-Identifier: GPL-2.0+
   2//
   3// soc-pcm.c  --  ALSA SoC PCM
   4//
   5// Copyright 2005 Wolfson Microelectronics PLC.
   6// Copyright 2005 Openedhand Ltd.
   7// Copyright (C) 2010 Slimlogic Ltd.
   8// Copyright (C) 2010 Texas Instruments Inc.
   9//
  10// Authors: Liam Girdwood <lrg@ti.com>
  11//          Mark Brown <broonie@opensource.wolfsonmicro.com>
 
 
 
 
 
 
  12
  13#include <linux/kernel.h>
  14#include <linux/init.h>
  15#include <linux/delay.h>
  16#include <linux/pinctrl/consumer.h>
  17#include <linux/pm_runtime.h>
  18#include <linux/slab.h>
  19#include <linux/workqueue.h>
  20#include <linux/export.h>
  21#include <linux/debugfs.h>
  22#include <sound/core.h>
  23#include <sound/pcm.h>
  24#include <sound/pcm_params.h>
  25#include <sound/soc.h>
  26#include <sound/soc-dpcm.h>
  27#include <sound/soc-link.h>
  28#include <sound/initval.h>
  29
  30#define soc_pcm_ret(rtd, ret) _soc_pcm_ret(rtd, __func__, ret)
  31static inline int _soc_pcm_ret(struct snd_soc_pcm_runtime *rtd,
  32			       const char *func, int ret)
  33{
  34	/* Positive, Zero values are not errors */
  35	if (ret >= 0)
  36		return ret;
  37
  38	/* Negative values might be errors */
  39	switch (ret) {
  40	case -EPROBE_DEFER:
  41	case -ENOTSUPP:
  42		break;
  43	default:
  44		dev_err(rtd->dev,
  45			"ASoC: error at %s on %s: %d\n",
  46			func, rtd->dai_link->name, ret);
  47	}
  48
  49	return ret;
  50}
  51
  52static inline void snd_soc_dpcm_mutex_lock(struct snd_soc_pcm_runtime *rtd)
  53{
  54	mutex_lock_nested(&rtd->card->pcm_mutex, rtd->card->pcm_subclass);
  55}
  56
  57static inline void snd_soc_dpcm_mutex_unlock(struct snd_soc_pcm_runtime *rtd)
  58{
  59	mutex_unlock(&rtd->card->pcm_mutex);
  60}
  61
  62#define snd_soc_dpcm_mutex_assert_held(rtd) \
  63	lockdep_assert_held(&(rtd)->card->pcm_mutex)
  64
  65static inline void snd_soc_dpcm_stream_lock_irq(struct snd_soc_pcm_runtime *rtd,
  66						int stream)
  67{
  68	snd_pcm_stream_lock_irq(snd_soc_dpcm_get_substream(rtd, stream));
  69}
  70
  71#define snd_soc_dpcm_stream_lock_irqsave_nested(rtd, stream, flags) \
  72	snd_pcm_stream_lock_irqsave_nested(snd_soc_dpcm_get_substream(rtd, stream), flags)
  73
  74static inline void snd_soc_dpcm_stream_unlock_irq(struct snd_soc_pcm_runtime *rtd,
  75						  int stream)
  76{
  77	snd_pcm_stream_unlock_irq(snd_soc_dpcm_get_substream(rtd, stream));
  78}
  79
  80#define snd_soc_dpcm_stream_unlock_irqrestore(rtd, stream, flags) \
  81	snd_pcm_stream_unlock_irqrestore(snd_soc_dpcm_get_substream(rtd, stream), flags)
  82
  83#define DPCM_MAX_BE_USERS	8
  84
  85static inline const char *soc_cpu_dai_name(struct snd_soc_pcm_runtime *rtd)
  86{
  87	return (rtd)->dai_link->num_cpus == 1 ? asoc_rtd_to_cpu(rtd, 0)->name : "multicpu";
  88}
  89static inline const char *soc_codec_dai_name(struct snd_soc_pcm_runtime *rtd)
  90{
  91	return (rtd)->dai_link->num_codecs == 1 ? asoc_rtd_to_codec(rtd, 0)->name : "multicodec";
  92}
  93
  94#ifdef CONFIG_DEBUG_FS
  95static const char *dpcm_state_string(enum snd_soc_dpcm_state state)
  96{
  97	switch (state) {
  98	case SND_SOC_DPCM_STATE_NEW:
  99		return "new";
 100	case SND_SOC_DPCM_STATE_OPEN:
 101		return "open";
 102	case SND_SOC_DPCM_STATE_HW_PARAMS:
 103		return "hw_params";
 104	case SND_SOC_DPCM_STATE_PREPARE:
 105		return "prepare";
 106	case SND_SOC_DPCM_STATE_START:
 107		return "start";
 108	case SND_SOC_DPCM_STATE_STOP:
 109		return "stop";
 110	case SND_SOC_DPCM_STATE_SUSPEND:
 111		return "suspend";
 112	case SND_SOC_DPCM_STATE_PAUSED:
 113		return "paused";
 114	case SND_SOC_DPCM_STATE_HW_FREE:
 115		return "hw_free";
 116	case SND_SOC_DPCM_STATE_CLOSE:
 117		return "close";
 118	}
 119
 120	return "unknown";
 121}
 122
 123static ssize_t dpcm_show_state(struct snd_soc_pcm_runtime *fe,
 124			       int stream, char *buf, size_t size)
 125{
 126	struct snd_pcm_hw_params *params = &fe->dpcm[stream].hw_params;
 127	struct snd_soc_dpcm *dpcm;
 128	ssize_t offset = 0;
 129
 130	/* FE state */
 131	offset += scnprintf(buf + offset, size - offset,
 132			   "[%s - %s]\n", fe->dai_link->name,
 133			   stream ? "Capture" : "Playback");
 134
 135	offset += scnprintf(buf + offset, size - offset, "State: %s\n",
 136			   dpcm_state_string(fe->dpcm[stream].state));
 137
 138	if ((fe->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
 139	    (fe->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
 140		offset += scnprintf(buf + offset, size - offset,
 141				   "Hardware Params: "
 142				   "Format = %s, Channels = %d, Rate = %d\n",
 143				   snd_pcm_format_name(params_format(params)),
 144				   params_channels(params),
 145				   params_rate(params));
 146
 147	/* BEs state */
 148	offset += scnprintf(buf + offset, size - offset, "Backends:\n");
 149
 150	if (list_empty(&fe->dpcm[stream].be_clients)) {
 151		offset += scnprintf(buf + offset, size - offset,
 152				   " No active DSP links\n");
 153		goto out;
 154	}
 155
 156	for_each_dpcm_be(fe, stream, dpcm) {
 157		struct snd_soc_pcm_runtime *be = dpcm->be;
 158		params = &be->dpcm[stream].hw_params;
 159
 160		offset += scnprintf(buf + offset, size - offset,
 161				   "- %s\n", be->dai_link->name);
 162
 163		offset += scnprintf(buf + offset, size - offset,
 164				   "   State: %s\n",
 165				   dpcm_state_string(be->dpcm[stream].state));
 166
 167		if ((be->dpcm[stream].state >= SND_SOC_DPCM_STATE_HW_PARAMS) &&
 168		    (be->dpcm[stream].state <= SND_SOC_DPCM_STATE_STOP))
 169			offset += scnprintf(buf + offset, size - offset,
 170					   "   Hardware Params: "
 171					   "Format = %s, Channels = %d, Rate = %d\n",
 172					   snd_pcm_format_name(params_format(params)),
 173					   params_channels(params),
 174					   params_rate(params));
 175	}
 176out:
 177	return offset;
 178}
 179
 180static ssize_t dpcm_state_read_file(struct file *file, char __user *user_buf,
 181				    size_t count, loff_t *ppos)
 182{
 183	struct snd_soc_pcm_runtime *fe = file->private_data;
 184	ssize_t out_count = PAGE_SIZE, offset = 0, ret = 0;
 185	int stream;
 186	char *buf;
 187
 188	if (fe->dai_link->num_cpus > 1) {
 189		dev_err(fe->dev,
 190			"%s doesn't support Multi CPU yet\n", __func__);
 191		return -EINVAL;
 192	}
 193
 194	buf = kmalloc(out_count, GFP_KERNEL);
 195	if (!buf)
 196		return -ENOMEM;
 197
 198	snd_soc_dpcm_mutex_lock(fe);
 199	for_each_pcm_streams(stream)
 200		if (snd_soc_dai_stream_valid(asoc_rtd_to_cpu(fe, 0), stream))
 201			offset += dpcm_show_state(fe, stream,
 202						  buf + offset,
 203						  out_count - offset);
 204	snd_soc_dpcm_mutex_unlock(fe);
 205
 206	ret = simple_read_from_buffer(user_buf, count, ppos, buf, offset);
 207
 208	kfree(buf);
 209	return ret;
 210}
 211
 212static const struct file_operations dpcm_state_fops = {
 213	.open = simple_open,
 214	.read = dpcm_state_read_file,
 215	.llseek = default_llseek,
 216};
 217
 218void soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
 219{
 220	if (!rtd->dai_link->dynamic)
 221		return;
 222
 223	if (!rtd->card->debugfs_card_root)
 224		return;
 225
 226	rtd->debugfs_dpcm_root = debugfs_create_dir(rtd->dai_link->name,
 227						    rtd->card->debugfs_card_root);
 228
 229	debugfs_create_file("state", 0444, rtd->debugfs_dpcm_root,
 230			    rtd, &dpcm_state_fops);
 231}
 232
 233static void dpcm_create_debugfs_state(struct snd_soc_dpcm *dpcm, int stream)
 234{
 235	char *name;
 236
 237	name = kasprintf(GFP_KERNEL, "%s:%s", dpcm->be->dai_link->name,
 238			 stream ? "capture" : "playback");
 239	if (name) {
 240		dpcm->debugfs_state = debugfs_create_dir(
 241			name, dpcm->fe->debugfs_dpcm_root);
 242		debugfs_create_u32("state", 0644, dpcm->debugfs_state,
 243				   &dpcm->state);
 244		kfree(name);
 245	}
 246}
 247
 248static void dpcm_remove_debugfs_state(struct snd_soc_dpcm *dpcm)
 249{
 250	debugfs_remove_recursive(dpcm->debugfs_state);
 251}
 252
 253#else
 254static inline void dpcm_create_debugfs_state(struct snd_soc_dpcm *dpcm,
 255					     int stream)
 256{
 257}
 258
 259static inline void dpcm_remove_debugfs_state(struct snd_soc_dpcm *dpcm)
 260{
 261}
 262#endif
 263
 264/* Set FE's runtime_update state; the state is protected via PCM stream lock
 265 * for avoiding the race with trigger callback.
 266 * If the state is unset and a trigger is pending while the previous operation,
 267 * process the pending trigger action here.
 268 */
 269static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd);
 270static void dpcm_set_fe_update_state(struct snd_soc_pcm_runtime *fe,
 271				     int stream, enum snd_soc_dpcm_update state)
 272{
 273	struct snd_pcm_substream *substream =
 274		snd_soc_dpcm_get_substream(fe, stream);
 275
 276	snd_soc_dpcm_stream_lock_irq(fe, stream);
 277	if (state == SND_SOC_DPCM_UPDATE_NO && fe->dpcm[stream].trigger_pending) {
 278		dpcm_fe_dai_do_trigger(substream,
 279				       fe->dpcm[stream].trigger_pending - 1);
 280		fe->dpcm[stream].trigger_pending = 0;
 
 
 
 281	}
 282	fe->dpcm[stream].runtime_update = state;
 283	snd_soc_dpcm_stream_unlock_irq(fe, stream);
 284}
 285
 286static void dpcm_set_be_update_state(struct snd_soc_pcm_runtime *be,
 287				     int stream, enum snd_soc_dpcm_update state)
 288{
 289	be->dpcm[stream].runtime_update = state;
 290}
 291
 292/**
 293 * snd_soc_runtime_action() - Increment/Decrement active count for
 294 * PCM runtime components
 295 * @rtd: ASoC PCM runtime that is activated
 296 * @stream: Direction of the PCM stream
 297 * @action: Activate stream if 1. Deactivate if -1.
 298 *
 299 * Increments/Decrements the active count for all the DAIs and components
 300 * attached to a PCM runtime.
 301 * Should typically be called when a stream is opened.
 302 *
 303 * Must be called with the rtd->card->pcm_mutex being held
 304 */
 305void snd_soc_runtime_action(struct snd_soc_pcm_runtime *rtd,
 306			    int stream, int action)
 307{
 308	struct snd_soc_dai *dai;
 309	int i;
 310
 311	snd_soc_dpcm_mutex_assert_held(rtd);
 312
 313	for_each_rtd_dais(rtd, i, dai)
 314		snd_soc_dai_action(dai, stream, action);
 
 
 
 
 
 
 
 
 
 
 315}
 316EXPORT_SYMBOL_GPL(snd_soc_runtime_action);
 317
 318/**
 319 * snd_soc_runtime_ignore_pmdown_time() - Check whether to ignore the power down delay
 320 * @rtd: The ASoC PCM runtime that should be checked.
 321 *
 322 * This function checks whether the power down delay should be ignored for a
 323 * specific PCM runtime. Returns true if the delay is 0, if it the DAI link has
 324 * been configured to ignore the delay, or if none of the components benefits
 325 * from having the delay.
 326 */
 327bool snd_soc_runtime_ignore_pmdown_time(struct snd_soc_pcm_runtime *rtd)
 328{
 329	struct snd_soc_component *component;
 330	bool ignore = true;
 331	int i;
 332
 333	if (!rtd->pmdown_time || rtd->dai_link->ignore_pmdown_time)
 334		return true;
 335
 336	for_each_rtd_components(rtd, i, component)
 337		ignore &= !component->driver->use_pmdown_time;
 338
 339	return ignore;
 340}
 341
 342/**
 343 * snd_soc_set_runtime_hwparams - set the runtime hardware parameters
 344 * @substream: the pcm substream
 345 * @hw: the hardware parameters
 346 *
 347 * Sets the substream runtime hardware parameters.
 348 */
 349int snd_soc_set_runtime_hwparams(struct snd_pcm_substream *substream,
 350	const struct snd_pcm_hardware *hw)
 351{
 352	substream->runtime->hw = *hw;
 353
 
 
 
 
 
 
 
 354	return 0;
 355}
 356EXPORT_SYMBOL_GPL(snd_soc_set_runtime_hwparams);
 357
 358/* DPCM stream event, send event to FE and all active BEs. */
 359int dpcm_dapm_stream_event(struct snd_soc_pcm_runtime *fe, int dir,
 360	int event)
 361{
 362	struct snd_soc_dpcm *dpcm;
 363
 364	snd_soc_dpcm_mutex_assert_held(fe);
 365
 366	for_each_dpcm_be(fe, dir, dpcm) {
 367
 368		struct snd_soc_pcm_runtime *be = dpcm->be;
 369
 370		dev_dbg(be->dev, "ASoC: BE %s event %d dir %d\n",
 371				be->dai_link->name, event, dir);
 372
 373		if ((event == SND_SOC_DAPM_STREAM_STOP) &&
 374		    (be->dpcm[dir].users >= 1))
 375			continue;
 376
 377		snd_soc_dapm_stream_event(be, dir, event);
 378	}
 379
 380	snd_soc_dapm_stream_event(fe, dir, event);
 381
 382	return 0;
 383}
 384
 385static void soc_pcm_set_dai_params(struct snd_soc_dai *dai,
 386				   struct snd_pcm_hw_params *params)
 387{
 388	if (params) {
 389		dai->rate	 = params_rate(params);
 390		dai->channels	 = params_channels(params);
 391		dai->sample_bits = snd_pcm_format_physical_width(params_format(params));
 392	} else {
 393		dai->rate	 = 0;
 394		dai->channels	 = 0;
 395		dai->sample_bits = 0;
 396	}
 397}
 398
 399static int soc_pcm_apply_symmetry(struct snd_pcm_substream *substream,
 400					struct snd_soc_dai *soc_dai)
 401{
 402	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 403	int ret;
 404
 405	if (!snd_soc_dai_active(soc_dai))
 406		return 0;
 
 
 
 
 
 
 
 
 
 
 
 
 
 407
 408#define __soc_pcm_apply_symmetry(name, NAME)				\
 409	if (soc_dai->name && (soc_dai->driver->symmetric_##name ||	\
 410			      rtd->dai_link->symmetric_##name)) {	\
 411		dev_dbg(soc_dai->dev, "ASoC: Symmetry forces %s to %d\n",\
 412			#name, soc_dai->name);				\
 413									\
 414		ret = snd_pcm_hw_constraint_single(substream->runtime,	\
 415						   SNDRV_PCM_HW_PARAM_##NAME,\
 416						   soc_dai->name);	\
 417		if (ret < 0) {						\
 418			dev_err(soc_dai->dev,				\
 419				"ASoC: Unable to apply %s constraint: %d\n",\
 420				#name, ret);				\
 421			return ret;					\
 422		}							\
 423	}
 424
 425	__soc_pcm_apply_symmetry(rate,		RATE);
 426	__soc_pcm_apply_symmetry(channels,	CHANNELS);
 427	__soc_pcm_apply_symmetry(sample_bits,	SAMPLE_BITS);
 
 
 
 
 
 
 
 
 
 
 
 
 
 428
 429	return 0;
 430}
 431
 432static int soc_pcm_params_symmetry(struct snd_pcm_substream *substream,
 433				struct snd_pcm_hw_params *params)
 434{
 435	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 436	struct snd_soc_dai d;
 437	struct snd_soc_dai *dai;
 438	struct snd_soc_dai *cpu_dai;
 439	unsigned int symmetry, i;
 440
 441	d.name = __func__;
 442	soc_pcm_set_dai_params(&d, params);
 443
 444#define __soc_pcm_params_symmetry(xxx)					\
 445	symmetry = rtd->dai_link->symmetric_##xxx;			\
 446	for_each_rtd_dais(rtd, i, dai)					\
 447		symmetry |= dai->driver->symmetric_##xxx;		\
 448									\
 449	if (symmetry)							\
 450		for_each_rtd_cpu_dais(rtd, i, cpu_dai)			\
 451			if (!snd_soc_dai_is_dummy(cpu_dai) &&		\
 452			    cpu_dai->xxx && cpu_dai->xxx != d.xxx) {	\
 453				dev_err(rtd->dev, "ASoC: unmatched %s symmetry: %s:%d - %s:%d\n", \
 454					#xxx, cpu_dai->name, cpu_dai->xxx, d.name, d.xxx); \
 455				return -EINVAL;				\
 456			}
 457
 458	/* reject unmatched parameters when applying symmetry */
 459	__soc_pcm_params_symmetry(rate);
 460	__soc_pcm_params_symmetry(channels);
 461	__soc_pcm_params_symmetry(sample_bits);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 462
 463	return 0;
 464}
 465
 466static void soc_pcm_update_symmetry(struct snd_pcm_substream *substream)
 467{
 468	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 
 
 469	struct snd_soc_dai_link *link = rtd->dai_link;
 470	struct snd_soc_dai *dai;
 471	unsigned int symmetry, i;
 472
 473	symmetry = link->symmetric_rate ||
 474		link->symmetric_channels ||
 475		link->symmetric_sample_bits;
 476
 477	for_each_rtd_dais(rtd, i, dai)
 478		symmetry = symmetry ||
 479			dai->driver->symmetric_rate ||
 480			dai->driver->symmetric_channels ||
 481			dai->driver->symmetric_sample_bits;
 482
 483	if (symmetry)
 484		substream->runtime->hw.info |= SNDRV_PCM_INFO_JOINT_DUPLEX;
 
 
 
 
 485}
 486
 487static void soc_pcm_set_msb(struct snd_pcm_substream *substream, int bits)
 488{
 489	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 490	int ret;
 491
 492	if (!bits)
 493		return;
 494
 495	ret = snd_pcm_hw_constraint_msbits(substream->runtime, 0, 0, bits);
 496	if (ret != 0)
 497		dev_warn(rtd->dev, "ASoC: Failed to set MSB %d: %d\n",
 498				 bits, ret);
 499}
 500
 501static void soc_pcm_apply_msb(struct snd_pcm_substream *substream)
 
 502{
 503	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 504	struct snd_soc_dai *cpu_dai;
 505	struct snd_soc_dai *codec_dai;
 506	int stream = substream->stream;
 507	int i;
 508	unsigned int bits = 0, cpu_bits = 0;
 509
 510	for_each_rtd_codec_dais(rtd, i, codec_dai) {
 511		struct snd_soc_pcm_stream *pcm_codec = snd_soc_dai_get_pcm_stream(codec_dai, stream);
 
 
 512
 513		if (pcm_codec->sig_bits == 0) {
 514			bits = 0;
 515			break;
 516		}
 517		bits = max(pcm_codec->sig_bits, bits);
 518	}
 519
 520	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
 521		struct snd_soc_pcm_stream *pcm_cpu = snd_soc_dai_get_pcm_stream(cpu_dai, stream);
 
 522
 523		if (pcm_cpu->sig_bits == 0) {
 524			cpu_bits = 0;
 525			break;
 526		}
 527		cpu_bits = max(pcm_cpu->sig_bits, cpu_bits);
 
 528	}
 529
 530	soc_pcm_set_msb(substream, bits);
 531	soc_pcm_set_msb(substream, cpu_bits);
 532}
 533
 534static void soc_pcm_hw_init(struct snd_pcm_hardware *hw)
 
 
 535{
 536	hw->rates		= UINT_MAX;
 537	hw->rate_min		= 0;
 538	hw->rate_max		= UINT_MAX;
 539	hw->channels_min	= 0;
 540	hw->channels_max	= UINT_MAX;
 541	hw->formats		= ULLONG_MAX;
 542}
 543
 544static void soc_pcm_hw_update_rate(struct snd_pcm_hardware *hw,
 545				   struct snd_soc_pcm_stream *p)
 546{
 547	hw->rates = snd_pcm_rate_mask_intersect(hw->rates, p->rates);
 548
 549	/* setup hw->rate_min/max via hw->rates first */
 550	snd_pcm_hw_limit_rates(hw);
 551
 552	/* update hw->rate_min/max by snd_soc_pcm_stream */
 553	hw->rate_min = max(hw->rate_min, p->rate_min);
 554	hw->rate_max = min_not_zero(hw->rate_max, p->rate_max);
 555}
 556
 557static void soc_pcm_hw_update_chan(struct snd_pcm_hardware *hw,
 558				   struct snd_soc_pcm_stream *p)
 559{
 560	hw->channels_min = max(hw->channels_min, p->channels_min);
 561	hw->channels_max = min(hw->channels_max, p->channels_max);
 562}
 563
 564static void soc_pcm_hw_update_format(struct snd_pcm_hardware *hw,
 565				     struct snd_soc_pcm_stream *p)
 566{
 567	hw->formats &= p->formats;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 568}
 569
 570/**
 571 * snd_soc_runtime_calc_hw() - Calculate hw limits for a PCM stream
 572 * @rtd: ASoC PCM runtime
 573 * @hw: PCM hardware parameters (output)
 574 * @stream: Direction of the PCM stream
 575 *
 576 * Calculates the subset of stream parameters supported by all DAIs
 577 * associated with the PCM stream.
 578 */
 579int snd_soc_runtime_calc_hw(struct snd_soc_pcm_runtime *rtd,
 580			    struct snd_pcm_hardware *hw, int stream)
 581{
 582	struct snd_soc_dai *codec_dai;
 583	struct snd_soc_dai *cpu_dai;
 584	struct snd_soc_pcm_stream *codec_stream;
 585	struct snd_soc_pcm_stream *cpu_stream;
 586	unsigned int cpu_chan_min = 0, cpu_chan_max = UINT_MAX;
 587	int i;
 
 
 588
 589	soc_pcm_hw_init(hw);
 
 
 
 
 590
 591	/* first calculate min/max only for CPUs in the DAI link */
 592	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
 593
 594		/*
 595		 * Skip CPUs which don't support the current stream type.
 596		 * Otherwise, since the rate, channel, and format values will
 597		 * zero in that case, we would have no usable settings left,
 598		 * causing the resulting setup to fail.
 599		 */
 600		if (!snd_soc_dai_stream_valid(cpu_dai, stream))
 601			continue;
 602
 603		cpu_stream = snd_soc_dai_get_pcm_stream(cpu_dai, stream);
 604
 605		soc_pcm_hw_update_chan(hw, cpu_stream);
 606		soc_pcm_hw_update_rate(hw, cpu_stream);
 607		soc_pcm_hw_update_format(hw, cpu_stream);
 
 
 
 
 608	}
 609	cpu_chan_min = hw->channels_min;
 610	cpu_chan_max = hw->channels_max;
 611
 612	/* second calculate min/max only for CODECs in the DAI link */
 613	for_each_rtd_codec_dais(rtd, i, codec_dai) {
 
 
 
 
 
 
 614
 615		/*
 616		 * Skip CODECs which don't support the current stream type.
 617		 * Otherwise, since the rate, channel, and format values will
 618		 * zero in that case, we would have no usable settings left,
 619		 * causing the resulting setup to fail.
 620		 */
 621		if (!snd_soc_dai_stream_valid(codec_dai, stream))
 622			continue;
 623
 624		codec_stream = snd_soc_dai_get_pcm_stream(codec_dai, stream);
 
 
 625
 626		soc_pcm_hw_update_chan(hw, codec_stream);
 627		soc_pcm_hw_update_rate(hw, codec_stream);
 628		soc_pcm_hw_update_format(hw, codec_stream);
 
 
 
 
 629	}
 630
 631	/* Verify both a valid CPU DAI and a valid CODEC DAI were found */
 632	if (!hw->channels_min)
 633		return -EINVAL;
 634
 635	/*
 636	 * chan min/max cannot be enforced if there are multiple CODEC DAIs
 637	 * connected to CPU DAI(s), use CPU DAI's directly and let
 638	 * channel allocation be fixed up later
 639	 */
 640	if (rtd->dai_link->num_codecs > 1) {
 641		hw->channels_min = cpu_chan_min;
 642		hw->channels_max = cpu_chan_max;
 
 
 
 
 
 
 
 
 643	}
 644
 645	return 0;
 646}
 647EXPORT_SYMBOL_GPL(snd_soc_runtime_calc_hw);
 648
 649static void soc_pcm_init_runtime_hw(struct snd_pcm_substream *substream)
 650{
 651	struct snd_pcm_hardware *hw = &substream->runtime->hw;
 652	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 653	u64 formats = hw->formats;
 
 654
 655	/*
 656	 * At least one CPU and one CODEC should match. Otherwise, we should
 657	 * have bailed out on a higher level, since there would be no CPU or
 658	 * CODEC to support the transfer direction in that case.
 659	 */
 660	snd_soc_runtime_calc_hw(rtd, hw, substream->stream);
 661
 662	if (formats)
 663		hw->formats &= formats;
 664}
 
 
 
 
 665
 666static int soc_pcm_components_open(struct snd_pcm_substream *substream)
 667{
 668	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 669	struct snd_soc_component *component;
 670	int i, ret = 0;
 671
 672	for_each_rtd_components(rtd, i, component) {
 673		ret = snd_soc_component_module_get_when_open(component, substream);
 674		if (ret < 0)
 675			break;
 676
 677		ret = snd_soc_component_open(component, substream);
 678		if (ret < 0)
 679			break;
 680	}
 681
 682	return ret;
 683}
 
 684
 685static int soc_pcm_components_close(struct snd_pcm_substream *substream,
 686				    int rollback)
 687{
 688	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 689	struct snd_soc_component *component;
 690	int i, ret = 0;
 691
 692	for_each_rtd_components(rtd, i, component) {
 693		int r = snd_soc_component_close(component, substream, rollback);
 694		if (r < 0)
 695			ret = r; /* use last ret */
 
 
 696
 697		snd_soc_component_module_put_when_close(component, substream, rollback);
 698	}
 
 
 
 
 
 699
 700	return ret;
 701}
 702
 703static int soc_pcm_clean(struct snd_soc_pcm_runtime *rtd,
 704			 struct snd_pcm_substream *substream, int rollback)
 
 
 
 
 705{
 706	struct snd_soc_component *component;
 707	struct snd_soc_dai *dai;
 708	int i;
 709
 710	snd_soc_dpcm_mutex_assert_held(rtd);
 711
 712	if (!rollback) {
 713		snd_soc_runtime_deactivate(rtd, substream->stream);
 714		/* clear the corresponding DAIs parameters when going to be inactive */
 715		for_each_rtd_dais(rtd, i, dai) {
 716			if (snd_soc_dai_active(dai) == 0)
 717				soc_pcm_set_dai_params(dai, NULL);
 718
 719			if (snd_soc_dai_stream_active(dai, substream->stream) == 0)
 720				snd_soc_dai_digital_mute(dai, 1, substream->stream);
 721		}
 
 
 722	}
 723
 724	for_each_rtd_dais(rtd, i, dai)
 725		snd_soc_dai_shutdown(dai, substream, rollback);
 726
 727	snd_soc_link_shutdown(substream, rollback);
 728
 729	soc_pcm_components_close(substream, rollback);
 730
 731	snd_soc_pcm_component_pm_runtime_put(rtd, substream, rollback);
 732
 733	for_each_rtd_components(rtd, i, component)
 734		if (!snd_soc_component_active(component))
 735			pinctrl_pm_select_sleep_state(component->dev);
 736
 737	return 0;
 738}
 739
 740/*
 741 * Called by ALSA when a PCM substream is closed. Private data can be
 742 * freed here. The cpu DAI, codec DAI, machine and components are also
 743 * shutdown.
 744 */
 745static int __soc_pcm_close(struct snd_soc_pcm_runtime *rtd,
 746			   struct snd_pcm_substream *substream)
 747{
 748	return soc_pcm_clean(rtd, substream, 0);
 749}
 750
 751/* PCM close ops for non-DPCM streams */
 752static int soc_pcm_close(struct snd_pcm_substream *substream)
 753{
 754	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 
 
 
 755
 756	snd_soc_dpcm_mutex_lock(rtd);
 757	__soc_pcm_close(rtd, substream);
 758	snd_soc_dpcm_mutex_unlock(rtd);
 759	return 0;
 760}
 761
 762static int soc_hw_sanity_check(struct snd_pcm_substream *substream)
 763{
 764	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 765	struct snd_pcm_hardware *hw = &substream->runtime->hw;
 766	const char *name_cpu = soc_cpu_dai_name(rtd);
 767	const char *name_codec = soc_codec_dai_name(rtd);
 768	const char *err_msg;
 769	struct device *dev = rtd->dev;
 770
 771	err_msg = "rates";
 772	if (!hw->rates)
 773		goto config_err;
 774
 775	err_msg = "formats";
 776	if (!hw->formats)
 777		goto config_err;
 778
 779	err_msg = "channels";
 780	if (!hw->channels_min || !hw->channels_max ||
 781	     hw->channels_min  >  hw->channels_max)
 782		goto config_err;
 783
 784	dev_dbg(dev, "ASoC: %s <-> %s info:\n",		name_codec,
 785							name_cpu);
 786	dev_dbg(dev, "ASoC: rate mask 0x%x\n",		hw->rates);
 787	dev_dbg(dev, "ASoC: ch   min %d max %d\n",	hw->channels_min,
 788							hw->channels_max);
 789	dev_dbg(dev, "ASoC: rate min %d max %d\n",	hw->rate_min,
 790							hw->rate_max);
 791
 792	return 0;
 793
 794config_err:
 795	dev_err(dev, "ASoC: %s <-> %s No matching %s\n",
 796		name_codec, name_cpu, err_msg);
 797	return -EINVAL;
 798}
 799
 800/*
 801 * Called by ALSA when a PCM substream is opened, the runtime->hw record is
 802 * then initialized and any private data can be allocated. This also calls
 803 * startup for the cpu DAI, component, machine and codec DAI.
 804 */
 805static int __soc_pcm_open(struct snd_soc_pcm_runtime *rtd,
 806			  struct snd_pcm_substream *substream)
 807{
 808	struct snd_soc_component *component;
 809	struct snd_soc_dai *dai;
 810	int i, ret = 0;
 811
 812	snd_soc_dpcm_mutex_assert_held(rtd);
 813
 814	for_each_rtd_components(rtd, i, component)
 815		pinctrl_pm_select_default_state(component->dev);
 816
 817	ret = snd_soc_pcm_component_pm_runtime_get(rtd, substream);
 818	if (ret < 0)
 819		goto err;
 820
 821	ret = soc_pcm_components_open(substream);
 822	if (ret < 0)
 823		goto err;
 824
 825	ret = snd_soc_link_startup(substream);
 826	if (ret < 0)
 827		goto err;
 828
 829	/* startup the audio subsystem */
 830	for_each_rtd_dais(rtd, i, dai) {
 831		ret = snd_soc_dai_startup(dai, substream);
 832		if (ret < 0)
 833			goto err;
 834	}
 835
 836	/* Dynamic PCM DAI links compat checks use dynamic capabilities */
 837	if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm)
 838		goto dynamic;
 839
 840	/* Check that the codec and cpu DAIs are compatible */
 841	soc_pcm_init_runtime_hw(substream);
 842
 843	soc_pcm_update_symmetry(substream);
 
 844
 845	ret = soc_hw_sanity_check(substream);
 846	if (ret < 0)
 847		goto err;
 848
 849	soc_pcm_apply_msb(substream);
 
 
 850
 851	/* Symmetry only applies if we've already got an active stream. */
 852	for_each_rtd_dais(rtd, i, dai) {
 853		ret = soc_pcm_apply_symmetry(substream, dai);
 854		if (ret != 0)
 855			goto err;
 
 
 
 
 
 
 
 
 
 
 
 
 856	}
 857dynamic:
 858	snd_soc_runtime_activate(rtd, substream->stream);
 859	ret = 0;
 860err:
 861	if (ret < 0)
 862		soc_pcm_clean(rtd, substream, 1);
 863
 864	return soc_pcm_ret(rtd, ret);
 865}
 866
 867/* PCM open ops for non-DPCM streams */
 868static int soc_pcm_open(struct snd_pcm_substream *substream)
 869{
 870	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 871	int ret;
 
 872
 873	snd_soc_dpcm_mutex_lock(rtd);
 874	ret = __soc_pcm_open(rtd, substream);
 875	snd_soc_dpcm_mutex_unlock(rtd);
 876	return ret;
 877}
 878
 879/*
 880 * Called by ALSA when the PCM substream is prepared, can set format, sample
 881 * rate, etc.  This function is non atomic and can be called multiple times,
 882 * it can refer to the runtime info.
 883 */
 884static int __soc_pcm_prepare(struct snd_soc_pcm_runtime *rtd,
 885			     struct snd_pcm_substream *substream)
 886{
 887	struct snd_soc_dai *dai;
 888	int i, ret = 0;
 
 
 
 889
 890	snd_soc_dpcm_mutex_assert_held(rtd);
 891
 892	ret = snd_soc_link_prepare(substream);
 893	if (ret < 0)
 894		goto out;
 
 
 
 
 
 895
 896	ret = snd_soc_pcm_component_prepare(substream);
 897	if (ret < 0)
 898		goto out;
 
 
 
 
 
 899
 900	ret = snd_soc_pcm_dai_prepare(substream);
 901	if (ret < 0)
 902		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 903
 904	/* cancel any delayed stream shutdown that is pending */
 905	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
 906	    rtd->pop_wait) {
 907		rtd->pop_wait = 0;
 908		cancel_delayed_work(&rtd->delayed_work);
 909	}
 910
 911	snd_soc_dapm_stream_event(rtd, substream->stream,
 912			SND_SOC_DAPM_STREAM_START);
 913
 914	for_each_rtd_dais(rtd, i, dai)
 915		snd_soc_dai_digital_mute(dai, 0, substream->stream);
 916
 917out:
 918	return soc_pcm_ret(rtd, ret);
 919}
 920
 921/* PCM prepare ops for non-DPCM streams */
 922static int soc_pcm_prepare(struct snd_pcm_substream *substream)
 923{
 924	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 925	int ret;
 926
 927	snd_soc_dpcm_mutex_lock(rtd);
 928	ret = __soc_pcm_prepare(rtd, substream);
 929	snd_soc_dpcm_mutex_unlock(rtd);
 930	return ret;
 931}
 932
 933static void soc_pcm_codec_params_fixup(struct snd_pcm_hw_params *params,
 934				       unsigned int mask)
 935{
 936	struct snd_interval *interval;
 937	int channels = hweight_long(mask);
 938
 939	interval = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS);
 940	interval->min = channels;
 941	interval->max = channels;
 942}
 943
 944static int soc_pcm_hw_clean(struct snd_soc_pcm_runtime *rtd,
 945			    struct snd_pcm_substream *substream, int rollback)
 946{
 947	struct snd_soc_dai *dai;
 948	int i;
 949
 950	snd_soc_dpcm_mutex_assert_held(rtd);
 951
 952	/* run the stream event */
 953	snd_soc_dapm_stream_stop(rtd, substream->stream);
 954
 955	/* free any machine hw params */
 956	snd_soc_link_hw_free(substream, rollback);
 957
 958	/* free any component resources */
 959	snd_soc_pcm_component_hw_free(substream, rollback);
 960
 961	/* now free hw params for the DAIs  */
 962	for_each_rtd_dais(rtd, i, dai)
 963		if (snd_soc_dai_stream_valid(dai, substream->stream))
 964			snd_soc_dai_hw_free(dai, substream, rollback);
 965
 966	return 0;
 967}
 968
 969/*
 970 * Frees resources allocated by hw_params, can be called multiple times
 971 */
 972static int __soc_pcm_hw_free(struct snd_soc_pcm_runtime *rtd,
 973			     struct snd_pcm_substream *substream)
 974{
 975	return soc_pcm_hw_clean(rtd, substream, 0);
 976}
 977
 978/* hw_free PCM ops for non-DPCM streams */
 979static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
 980{
 981	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
 982	int ret;
 983
 984	snd_soc_dpcm_mutex_lock(rtd);
 985	ret = __soc_pcm_hw_free(rtd, substream);
 986	snd_soc_dpcm_mutex_unlock(rtd);
 987	return ret;
 988}
 989
 990/*
 991 * Called by ALSA when the hardware params are set by application. This
 992 * function can also be called multiple times and can allocate buffers
 993 * (using snd_pcm_lib_* ). It's non-atomic.
 994 */
 995static int __soc_pcm_hw_params(struct snd_soc_pcm_runtime *rtd,
 996			       struct snd_pcm_substream *substream,
 997			       struct snd_pcm_hw_params *params)
 998{
 999	struct snd_soc_dai *cpu_dai;
1000	struct snd_soc_dai *codec_dai;
1001	int i, ret = 0;
 
1002
1003	snd_soc_dpcm_mutex_assert_held(rtd);
1004
1005	ret = soc_pcm_params_symmetry(substream, params);
1006	if (ret)
1007		goto out;
1008
1009	ret = snd_soc_link_hw_params(substream, params);
1010	if (ret < 0)
1011		goto out;
1012
1013	for_each_rtd_codec_dais(rtd, i, codec_dai) {
1014		struct snd_pcm_hw_params codec_params;
1015
1016		/*
1017		 * Skip CODECs which don't support the current stream type,
1018		 * the idea being that if a CODEC is not used for the currently
1019		 * set up transfer direction, it should not need to be
1020		 * configured, especially since the configuration used might
1021		 * not even be supported by that CODEC. There may be cases
1022		 * however where a CODEC needs to be set up although it is
1023		 * actually not being used for the transfer, e.g. if a
1024		 * capture-only CODEC is acting as an LRCLK and/or BCLK master
1025		 * for the DAI link including a playback-only CODEC.
1026		 * If this becomes necessary, we will have to augment the
1027		 * machine driver setup with information on how to act, so
1028		 * we can do the right thing here.
1029		 */
1030		if (!snd_soc_dai_stream_valid(codec_dai, substream->stream))
1031			continue;
1032
1033		/* copy params for each codec */
1034		codec_params = *params;
1035
1036		/* fixup params based on TDM slot masks */
1037		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK &&
1038		    codec_dai->tx_mask)
1039			soc_pcm_codec_params_fixup(&codec_params,
1040						   codec_dai->tx_mask);
1041
1042		if (substream->stream == SNDRV_PCM_STREAM_CAPTURE &&
1043		    codec_dai->rx_mask)
1044			soc_pcm_codec_params_fixup(&codec_params,
1045						   codec_dai->rx_mask);
1046
1047		ret = snd_soc_dai_hw_params(codec_dai, substream,
1048					    &codec_params);
1049		if(ret < 0)
1050			goto out;
1051
1052		soc_pcm_set_dai_params(codec_dai, &codec_params);
1053		snd_soc_dapm_update_dai(substream, &codec_params, codec_dai);
1054	}
1055
1056	for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
1057		/*
1058		 * Skip CPUs which don't support the current stream
1059		 * type. See soc_pcm_init_runtime_hw() for more details
1060		 */
1061		if (!snd_soc_dai_stream_valid(cpu_dai, substream->stream))
1062			continue;
 
1063
1064		ret = snd_soc_dai_hw_params(cpu_dai, substream, params);
1065		if (ret < 0)
1066			goto out;
 
 
 
 
 
1067
1068		/* store the parameters for each DAI */
1069		soc_pcm_set_dai_params(cpu_dai, params);
1070		snd_soc_dapm_update_dai(substream, params, cpu_dai);
 
 
 
 
1071	}
1072
1073	ret = snd_soc_pcm_component_hw_params(substream, params);
 
 
 
 
 
 
 
 
 
 
1074out:
1075	if (ret < 0)
1076		soc_pcm_hw_clean(rtd, substream, 1);
 
 
 
 
 
 
 
 
 
 
 
 
1077
1078	return soc_pcm_ret(rtd, ret);
 
1079}
1080
1081/* hw_params PCM ops for non-DPCM streams */
1082static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
1083			     struct snd_pcm_hw_params *params)
 
1084{
1085	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1086	int ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1087
1088	snd_soc_dpcm_mutex_lock(rtd);
1089	ret = __soc_pcm_hw_params(rtd, substream, params);
1090	snd_soc_dpcm_mutex_unlock(rtd);
1091	return ret;
 
 
 
 
 
 
 
 
 
 
 
 
 
1092}
1093
1094static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
1095{
1096	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);
1097	int ret = -EINVAL, _ret = 0;
1098	int rollback = 0;
 
 
1099
1100	switch (cmd) {
1101	case SNDRV_PCM_TRIGGER_START:
1102	case SNDRV_PCM_TRIGGER_RESUME:
1103	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1104		ret = snd_soc_link_trigger(substream, cmd, 0);
1105		if (ret < 0)
1106			goto start_err;
 
1107
1108		ret = snd_soc_pcm_component_trigger(substream, cmd, 0);
 
1109		if (ret < 0)
1110			goto start_err;
 
1111
1112		ret = snd_soc_pcm_dai_trigger(substream, cmd, 0);
1113start_err:
1114		if (ret < 0)
1115			rollback = 1;
1116	}
 
 
1117
1118	if (rollback) {
1119		_ret = ret;
1120		switch (cmd) {
1121		case SNDRV_PCM_TRIGGER_START:
1122			cmd = SNDRV_PCM_TRIGGER_STOP;
1123			break;
1124		case SNDRV_PCM_TRIGGER_RESUME:
1125			cmd = SNDRV_PCM_TRIGGER_SUSPEND;
1126			break;
1127		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1128			cmd = SNDRV_PCM_TRIGGER_PAUSE_PUSH;
1129			break;
1130		}
1131	}
1132
1133	switch (cmd) {
1134	case SNDRV_PCM_TRIGGER_STOP:
1135	case SNDRV_PCM_TRIGGER_SUSPEND:
1136	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1137		if (rtd->dai_link->stop_dma_first) {
1138			ret = snd_soc_pcm_component_trigger(substream, cmd, rollback);
1139			if (ret < 0)
1140				break;
1141
1142			ret = snd_soc_pcm_dai_trigger(substream, cmd, rollback);
1143			if (ret < 0)
1144				break;
1145		} else {
1146			ret = snd_soc_pcm_dai_trigger(substream, cmd, rollback);
1147			if (ret < 0)
1148				break;
1149
1150			ret = snd_soc_pcm_component_trigger(substream, cmd, rollback);
1151			if (ret < 0)
1152				break;
1153		}
1154		ret = snd_soc_link_trigger(substream, cmd, rollback);
1155		break;
1156	}
1157
1158	if (_ret)
1159		ret = _ret;
 
 
 
1160
1161	return ret;
 
 
 
 
 
1162}
1163
1164/*
1165 * soc level wrapper for pointer callback
1166 * If cpu_dai, codec_dai, component driver has the delay callback, then
1167 * the runtime->delay will be updated via snd_soc_pcm_component/dai_delay().
1168 */
1169static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
1170{
 
 
 
 
1171	struct snd_pcm_runtime *runtime = substream->runtime;
1172	snd_pcm_uframes_t offset = 0;
1173	snd_pcm_sframes_t codec_delay = 0;
1174	snd_pcm_sframes_t cpu_delay = 0;
 
 
 
 
 
1175
1176	offset = snd_soc_pcm_component_pointer(substream);
 
1177
1178	/* should be called *after* snd_soc_pcm_component_pointer() */
1179	snd_soc_pcm_dai_delay(substream, &cpu_delay, &codec_delay);
1180	snd_soc_pcm_component_delay(substream, &cpu_delay, &codec_delay);
1181
1182	runtime->delay = cpu_delay + codec_delay;
1183
1184	return offset;
1185}
1186
1187/* connect a FE and BE */
1188static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe,
1189		struct snd_soc_pcm_runtime *be, int stream)
1190{
1191	struct snd_pcm_substream *fe_substream;
1192	struct snd_pcm_substream *be_substream;
1193	struct snd_soc_dpcm *dpcm;
1194
1195	snd_soc_dpcm_mutex_assert_held(fe);
1196
1197	/* only add new dpcms */
1198	for_each_dpcm_be(fe, stream, dpcm) {
1199		if (dpcm->be == be && dpcm->fe == fe)
1200			return 0;
1201	}
1202
1203	fe_substream = snd_soc_dpcm_get_substream(fe, stream);
1204	be_substream = snd_soc_dpcm_get_substream(be, stream);
1205
1206	if (!fe_substream->pcm->nonatomic && be_substream->pcm->nonatomic) {
1207		dev_err(be->dev, "%s: FE is atomic but BE is nonatomic, invalid configuration\n",
1208			__func__);
1209		return -EINVAL;
1210	}
1211	if (fe_substream->pcm->nonatomic && !be_substream->pcm->nonatomic) {
1212		dev_dbg(be->dev, "FE is nonatomic but BE is not, forcing BE as nonatomic\n");
1213		be_substream->pcm->nonatomic = 1;
1214	}
1215
1216	dpcm = kzalloc(sizeof(struct snd_soc_dpcm), GFP_KERNEL);
1217	if (!dpcm)
1218		return -ENOMEM;
1219
1220	dpcm->be = be;
1221	dpcm->fe = fe;
1222	be->dpcm[stream].runtime = fe->dpcm[stream].runtime;
1223	dpcm->state = SND_SOC_DPCM_LINK_STATE_NEW;
1224	snd_soc_dpcm_stream_lock_irq(fe, stream);
1225	list_add(&dpcm->list_be, &fe->dpcm[stream].be_clients);
1226	list_add(&dpcm->list_fe, &be->dpcm[stream].fe_clients);
1227	snd_soc_dpcm_stream_unlock_irq(fe, stream);
1228
1229	dev_dbg(fe->dev, "connected new DPCM %s path %s %s %s\n",
1230			stream ? "capture" : "playback",  fe->dai_link->name,
1231			stream ? "<-" : "->", be->dai_link->name);
1232
1233	dpcm_create_debugfs_state(dpcm, stream);
1234
 
 
1235	return 1;
1236}
1237
1238/* reparent a BE onto another FE */
1239static void dpcm_be_reparent(struct snd_soc_pcm_runtime *fe,
1240			struct snd_soc_pcm_runtime *be, int stream)
1241{
1242	struct snd_soc_dpcm *dpcm;
1243	struct snd_pcm_substream *fe_substream, *be_substream;
1244
1245	/* reparent if BE is connected to other FEs */
1246	if (!be->dpcm[stream].users)
1247		return;
1248
1249	be_substream = snd_soc_dpcm_get_substream(be, stream);
1250	if (!be_substream)
1251		return;
1252
1253	for_each_dpcm_fe(be, stream, dpcm) {
1254		if (dpcm->fe == fe)
1255			continue;
1256
1257		dev_dbg(fe->dev, "reparent %s path %s %s %s\n",
1258			stream ? "capture" : "playback",
1259			dpcm->fe->dai_link->name,
1260			stream ? "<-" : "->", dpcm->be->dai_link->name);
1261
1262		fe_substream = snd_soc_dpcm_get_substream(dpcm->fe, stream);
1263		be_substream->runtime = fe_substream->runtime;
1264		break;
1265	}
1266}
1267
1268/* disconnect a BE and FE */
1269void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream)
1270{
1271	struct snd_soc_dpcm *dpcm, *d;
1272	LIST_HEAD(deleted_dpcms);
1273
1274	snd_soc_dpcm_mutex_assert_held(fe);
1275
1276	snd_soc_dpcm_stream_lock_irq(fe, stream);
1277	for_each_dpcm_be_safe(fe, stream, dpcm, d) {
1278		dev_dbg(fe->dev, "ASoC: BE %s disconnect check for %s\n",
1279				stream ? "capture" : "playback",
1280				dpcm->be->dai_link->name);
1281
1282		if (dpcm->state != SND_SOC_DPCM_LINK_STATE_FREE)
1283			continue;
1284
1285		dev_dbg(fe->dev, "freed DSP %s path %s %s %s\n",
1286			stream ? "capture" : "playback", fe->dai_link->name,
1287			stream ? "<-" : "->", dpcm->be->dai_link->name);
1288
1289		/* BEs still alive need new FE */
1290		dpcm_be_reparent(fe, dpcm->be, stream);
1291
 
 
 
1292		list_del(&dpcm->list_be);
1293		list_move(&dpcm->list_fe, &deleted_dpcms);
1294	}
1295	snd_soc_dpcm_stream_unlock_irq(fe, stream);
1296
1297	while (!list_empty(&deleted_dpcms)) {
1298		dpcm = list_first_entry(&deleted_dpcms, struct snd_soc_dpcm,
1299					list_fe);
1300		list_del(&dpcm->list_fe);
1301		dpcm_remove_debugfs_state(dpcm);
1302		kfree(dpcm);
1303	}
1304}
1305
1306/* get BE for DAI widget and stream */
1307static struct snd_soc_pcm_runtime *dpcm_get_be(struct snd_soc_card *card,
1308		struct snd_soc_dapm_widget *widget, int stream)
1309{
1310	struct snd_soc_pcm_runtime *be;
1311	struct snd_soc_dapm_widget *w;
1312	struct snd_soc_dai *dai;
1313	int i;
1314
1315	dev_dbg(card->dev, "ASoC: find BE for widget %s\n", widget->name);
1316
1317	for_each_card_rtds(card, be) {
1318
1319		if (!be->dai_link->no_pcm)
1320			continue;
1321
1322		if (!snd_soc_dpcm_get_substream(be, stream))
1323			continue;
 
 
 
1324
1325		for_each_rtd_dais(be, i, dai) {
1326			w = snd_soc_dai_get_widget(dai, stream);
1327
1328			dev_dbg(card->dev, "ASoC: try BE : %s\n",
1329				w ? w->name : "(not set)");
1330
1331			if (w == widget)
 
1332				return be;
1333		}
1334	}
1335
1336	/* Widget provided is not a BE */
 
1337	return NULL;
1338}
1339
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1340static int widget_in_list(struct snd_soc_dapm_widget_list *list,
1341		struct snd_soc_dapm_widget *widget)
1342{
1343	struct snd_soc_dapm_widget *w;
1344	int i;
1345
1346	for_each_dapm_widgets(list, i, w)
1347		if (widget == w)
1348			return 1;
 
1349
1350	return 0;
1351}
1352
1353bool dpcm_end_walk_at_be(struct snd_soc_dapm_widget *widget, enum snd_soc_dapm_direction dir)
1354{
1355	struct snd_soc_card *card = widget->dapm->card;
1356	struct snd_soc_pcm_runtime *rtd;
1357	int stream;
1358
1359	/* adjust dir to stream */
1360	if (dir == SND_SOC_DAPM_DIR_OUT)
1361		stream = SNDRV_PCM_STREAM_PLAYBACK;
1362	else
1363		stream = SNDRV_PCM_STREAM_CAPTURE;
1364
1365	rtd = dpcm_get_be(card, widget, stream);
1366	if (rtd)
1367		return true;
1368
1369	return false;
1370}
1371EXPORT_SYMBOL_GPL(dpcm_end_walk_at_be);
1372
1373int dpcm_path_get(struct snd_soc_pcm_runtime *fe,
1374	int stream, struct snd_soc_dapm_widget_list **list)
1375{
1376	struct snd_soc_dai *cpu_dai = asoc_rtd_to_cpu(fe, 0);
 
1377	int paths;
1378
1379	if (fe->dai_link->num_cpus > 1) {
1380		dev_err(fe->dev,
1381			"%s doesn't support Multi CPU yet\n", __func__);
1382		return -EINVAL;
1383	}
1384
1385	/* get number of valid DAI paths and their widgets */
1386	paths = snd_soc_dapm_dai_get_connected_widgets(cpu_dai, stream, list,
1387			fe->card->component_chaining ?
1388				NULL : dpcm_end_walk_at_be);
1389
1390	if (paths > 0)
1391		dev_dbg(fe->dev, "ASoC: found %d audio %s paths\n", paths,
1392			stream ? "capture" : "playback");
1393	else if (paths == 0)
1394		dev_dbg(fe->dev, "ASoC: %s no valid %s path\n", fe->dai_link->name,
1395			 stream ? "capture" : "playback");
1396
 
1397	return paths;
1398}
1399
1400void dpcm_path_put(struct snd_soc_dapm_widget_list **list)
 
1401{
1402	snd_soc_dapm_dai_free_widgets(list);
1403}
 
 
1404
1405static bool dpcm_be_is_active(struct snd_soc_dpcm *dpcm, int stream,
1406			      struct snd_soc_dapm_widget_list *list)
1407{
1408	struct snd_soc_dai *dai;
1409	unsigned int i;
1410
1411	/* is there a valid DAI widget for this BE */
1412	for_each_rtd_dais(dpcm->be, i, dai) {
1413		struct snd_soc_dapm_widget *widget = snd_soc_dai_get_widget(dai, stream);
1414
1415		/*
1416		 * The BE is pruned only if none of the dai
1417		 * widgets are in the active list.
1418		 */
1419		if (widget && widget_in_list(list, widget))
1420			return true;
1421	}
1422
1423	return false;
1424}
1425
1426static int dpcm_prune_paths(struct snd_soc_pcm_runtime *fe, int stream,
1427			    struct snd_soc_dapm_widget_list **list_)
1428{
1429	struct snd_soc_dpcm *dpcm;
1430	int prune = 0;
1431
1432	/* Destroy any old FE <--> BE connections */
1433	for_each_dpcm_be(fe, stream, dpcm) {
1434		if (dpcm_be_is_active(dpcm, stream, *list_))
1435			continue;
1436
1437		dev_dbg(fe->dev, "ASoC: pruning %s BE %s for %s\n",
1438			stream ? "capture" : "playback",
1439			dpcm->be->dai_link->name, fe->dai_link->name);
1440		dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
1441		dpcm_set_be_update_state(dpcm->be, stream, SND_SOC_DPCM_UPDATE_BE);
1442		prune++;
1443	}
1444
1445	dev_dbg(fe->dev, "ASoC: found %d old BE paths for pruning\n", prune);
1446	return prune;
1447}
1448
1449static int dpcm_add_paths(struct snd_soc_pcm_runtime *fe, int stream,
1450	struct snd_soc_dapm_widget_list **list_)
1451{
1452	struct snd_soc_card *card = fe->card;
1453	struct snd_soc_dapm_widget_list *list = *list_;
1454	struct snd_soc_pcm_runtime *be;
1455	struct snd_soc_dapm_widget *widget;
1456	int i, new = 0, err;
1457
1458	/* don't connect if FE is not running */
1459	if (!fe->dpcm[stream].runtime && !fe->fe_compr)
1460		return new;
1461
1462	/* Create any new FE <--> BE connections */
1463	for_each_dapm_widgets(list, i, widget) {
1464
1465		switch (widget->id) {
1466		case snd_soc_dapm_dai_in:
1467			if (stream != SNDRV_PCM_STREAM_PLAYBACK)
1468				continue;
1469			break;
1470		case snd_soc_dapm_dai_out:
1471			if (stream != SNDRV_PCM_STREAM_CAPTURE)
1472				continue;
1473			break;
1474		default:
1475			continue;
1476		}
1477
1478		/* is there a valid BE rtd for this widget */
1479		be = dpcm_get_be(card, widget, stream);
1480		if (!be) {
1481			dev_dbg(fe->dev, "ASoC: no BE found for %s\n",
1482				widget->name);
1483			continue;
1484		}
1485
1486		/*
1487		 * Filter for systems with 'component_chaining' enabled.
1488		 * This helps to avoid unnecessary re-configuration of an
1489		 * already active BE on such systems.
1490		 */
1491		if (fe->card->component_chaining &&
1492		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_NEW) &&
1493		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
1494			continue;
1495
1496		/* newly connected FE and BE */
1497		err = dpcm_be_connect(fe, be, stream);
1498		if (err < 0) {
1499			dev_err(fe->dev, "ASoC: can't connect %s\n",
1500				widget->name);
1501			break;
1502		} else if (err == 0) /* already connected */
1503			continue;
1504
1505		/* new */
1506		dpcm_set_be_update_state(be, stream, SND_SOC_DPCM_UPDATE_BE);
1507		new++;
1508	}
1509
1510	dev_dbg(fe->dev, "ASoC: found %d new BE paths\n", new);
1511	return new;
1512}
1513
1514/*
1515 * Find the corresponding BE DAIs that source or sink audio to this
1516 * FE substream.
1517 */
1518int dpcm_process_paths(struct snd_soc_pcm_runtime *fe,
1519	int stream, struct snd_soc_dapm_widget_list **list, int new)
1520{
1521	if (new)
1522		return dpcm_add_paths(fe, stream, list);
1523	else
1524		return dpcm_prune_paths(fe, stream, list);
1525}
1526
1527void dpcm_clear_pending_state(struct snd_soc_pcm_runtime *fe, int stream)
1528{
1529	struct snd_soc_dpcm *dpcm;
1530
1531	for_each_dpcm_be(fe, stream, dpcm)
1532		dpcm_set_be_update_state(dpcm->be, stream, SND_SOC_DPCM_UPDATE_NO);
 
1533}
1534
1535void dpcm_be_dai_stop(struct snd_soc_pcm_runtime *fe, int stream,
1536		      int do_hw_free, struct snd_soc_dpcm *last)
1537{
1538	struct snd_soc_dpcm *dpcm;
1539
1540	/* disable any enabled and non active backends */
1541	for_each_dpcm_be(fe, stream, dpcm) {
 
1542		struct snd_soc_pcm_runtime *be = dpcm->be;
1543		struct snd_pcm_substream *be_substream =
1544			snd_soc_dpcm_get_substream(be, stream);
1545
1546		if (dpcm == last)
1547			return;
1548
1549		/* is this op for this BE ? */
1550		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1551			continue;
1552
1553		if (be->dpcm[stream].users == 0) {
1554			dev_err(be->dev, "ASoC: no users %s at close - state %d\n",
1555				stream ? "capture" : "playback",
1556				be->dpcm[stream].state);
1557			continue;
1558		}
1559
1560		if (--be->dpcm[stream].users != 0)
1561			continue;
1562
1563		if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) {
1564			if (!do_hw_free)
1565				continue;
1566
1567			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) {
1568				__soc_pcm_hw_free(be, be_substream);
1569				be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
1570			}
1571		}
1572
1573		__soc_pcm_close(be, be_substream);
1574		be_substream->runtime = NULL;
1575		be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1576	}
1577}
1578
1579int dpcm_be_dai_startup(struct snd_soc_pcm_runtime *fe, int stream)
1580{
1581	struct snd_soc_pcm_runtime *be;
1582	struct snd_soc_dpcm *dpcm;
1583	int err, count = 0;
1584
1585	/* only startup BE DAIs that are either sinks or sources to this FE DAI */
1586	for_each_dpcm_be(fe, stream, dpcm) {
1587		struct snd_pcm_substream *be_substream;
1588
1589		be = dpcm->be;
1590		be_substream = snd_soc_dpcm_get_substream(be, stream);
 
1591
1592		if (!be_substream) {
1593			dev_err(be->dev, "ASoC: no backend %s stream\n",
1594				stream ? "capture" : "playback");
1595			continue;
1596		}
1597
1598		/* is this op for this BE ? */
1599		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1600			continue;
1601
1602		/* first time the dpcm is open ? */
1603		if (be->dpcm[stream].users == DPCM_MAX_BE_USERS) {
1604			dev_err(be->dev, "ASoC: too many users %s at open %d\n",
1605				stream ? "capture" : "playback",
1606				be->dpcm[stream].state);
1607			continue;
1608		}
1609
1610		if (be->dpcm[stream].users++ != 0)
1611			continue;
1612
1613		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_NEW) &&
1614		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
1615			continue;
1616
1617		dev_dbg(be->dev, "ASoC: open %s BE %s\n",
1618			stream ? "capture" : "playback", be->dai_link->name);
1619
1620		be_substream->runtime = be->dpcm[stream].runtime;
1621		err = __soc_pcm_open(be, be_substream);
1622		if (err < 0) {
 
1623			be->dpcm[stream].users--;
1624			if (be->dpcm[stream].users < 0)
1625				dev_err(be->dev, "ASoC: no users %s at unwind %d\n",
1626					stream ? "capture" : "playback",
1627					be->dpcm[stream].state);
1628
1629			be->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1630			goto unwind;
1631		}
1632		be->dpcm[stream].be_start = 0;
1633		be->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
1634		count++;
1635	}
1636
1637	return count;
1638
1639unwind:
1640	dpcm_be_dai_startup_rollback(fe, stream, dpcm);
1641
1642	return soc_pcm_ret(fe, err);
1643}
1644
1645static void dpcm_runtime_setup_fe(struct snd_pcm_substream *substream)
1646{
1647	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1648	struct snd_pcm_runtime *runtime = substream->runtime;
1649	struct snd_pcm_hardware *hw = &runtime->hw;
1650	struct snd_soc_dai *dai;
1651	int stream = substream->stream;
1652	int i;
1653
1654	soc_pcm_hw_init(hw);
 
1655
1656	for_each_rtd_cpu_dais(fe, i, dai) {
1657		struct snd_soc_pcm_stream *cpu_stream;
 
 
1658
1659		/*
1660		 * Skip CPUs which don't support the current stream
1661		 * type. See soc_pcm_init_runtime_hw() for more details
1662		 */
1663		if (!snd_soc_dai_stream_valid(dai, stream))
1664			continue;
1665
1666		cpu_stream = snd_soc_dai_get_pcm_stream(dai, stream);
 
1667
1668		soc_pcm_hw_update_rate(hw, cpu_stream);
1669		soc_pcm_hw_update_chan(hw, cpu_stream);
1670		soc_pcm_hw_update_format(hw, cpu_stream);
1671	}
1672
 
1673}
1674
1675static void dpcm_runtime_setup_be_format(struct snd_pcm_substream *substream)
 
1676{
1677	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1678	struct snd_pcm_runtime *runtime = substream->runtime;
1679	struct snd_pcm_hardware *hw = &runtime->hw;
1680	struct snd_soc_dpcm *dpcm;
1681	struct snd_soc_dai *dai;
1682	int stream = substream->stream;
1683
1684	if (!fe->dai_link->dpcm_merged_format)
1685		return;
1686
1687	/*
1688	 * It returns merged BE codec format
1689	 * if FE want to use it (= dpcm_merged_format)
1690	 */
1691
1692	for_each_dpcm_be(fe, stream, dpcm) {
1693		struct snd_soc_pcm_runtime *be = dpcm->be;
1694		struct snd_soc_pcm_stream *codec_stream;
1695		int i;
1696
1697		for_each_rtd_codec_dais(be, i, dai) {
1698			/*
1699			 * Skip CODECs which don't support the current stream
1700			 * type. See soc_pcm_init_runtime_hw() for more details
1701			 */
1702			if (!snd_soc_dai_stream_valid(dai, stream))
1703				continue;
1704
1705			codec_stream = snd_soc_dai_get_pcm_stream(dai, stream);
1706
1707			soc_pcm_hw_update_format(hw, codec_stream);
1708		}
1709	}
1710}
1711
1712static void dpcm_runtime_setup_be_chan(struct snd_pcm_substream *substream)
1713{
1714	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1715	struct snd_pcm_runtime *runtime = substream->runtime;
1716	struct snd_pcm_hardware *hw = &runtime->hw;
1717	struct snd_soc_dpcm *dpcm;
1718	int stream = substream->stream;
1719
1720	if (!fe->dai_link->dpcm_merged_chan)
1721		return;
1722
1723	/*
1724	 * It returns merged BE codec channel;
1725	 * if FE want to use it (= dpcm_merged_chan)
1726	 */
1727
1728	for_each_dpcm_be(fe, stream, dpcm) {
1729		struct snd_soc_pcm_runtime *be = dpcm->be;
1730		struct snd_soc_pcm_stream *cpu_stream;
1731		struct snd_soc_dai *dai;
1732		int i;
1733
1734		for_each_rtd_cpu_dais(be, i, dai) {
1735			/*
1736			 * Skip CPUs which don't support the current stream
1737			 * type. See soc_pcm_init_runtime_hw() for more details
1738			 */
1739			if (!snd_soc_dai_stream_valid(dai, stream))
1740				continue;
1741
1742			cpu_stream = snd_soc_dai_get_pcm_stream(dai, stream);
1743
1744			soc_pcm_hw_update_chan(hw, cpu_stream);
1745		}
 
 
 
1746
1747		/*
1748		 * chan min/max cannot be enforced if there are multiple CODEC
1749		 * DAIs connected to a single CPU DAI, use CPU DAI's directly
1750		 */
1751		if (be->dai_link->num_codecs == 1) {
1752			struct snd_soc_pcm_stream *codec_stream = snd_soc_dai_get_pcm_stream(
1753				asoc_rtd_to_codec(be, 0), stream);
1754
1755			soc_pcm_hw_update_chan(hw, codec_stream);
1756		}
 
 
1757	}
1758}
1759
1760static void dpcm_runtime_setup_be_rate(struct snd_pcm_substream *substream)
1761{
1762	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1763	struct snd_pcm_runtime *runtime = substream->runtime;
1764	struct snd_pcm_hardware *hw = &runtime->hw;
1765	struct snd_soc_dpcm *dpcm;
1766	int stream = substream->stream;
1767
1768	if (!fe->dai_link->dpcm_merged_rate)
1769		return;
 
 
 
 
1770
1771	/*
1772	 * It returns merged BE codec channel;
1773	 * if FE want to use it (= dpcm_merged_chan)
1774	 */
1775
1776	for_each_dpcm_be(fe, stream, dpcm) {
1777		struct snd_soc_pcm_runtime *be = dpcm->be;
1778		struct snd_soc_pcm_stream *pcm;
1779		struct snd_soc_dai *dai;
1780		int i;
1781
1782		for_each_rtd_dais(be, i, dai) {
1783			/*
1784			 * Skip DAIs which don't support the current stream
1785			 * type. See soc_pcm_init_runtime_hw() for more details
1786			 */
1787			if (!snd_soc_dai_stream_valid(dai, stream))
1788				continue;
1789
1790			pcm = snd_soc_dai_get_pcm_stream(dai, stream);
 
1791
1792			soc_pcm_hw_update_rate(hw, pcm);
1793		}
1794	}
 
 
1795}
1796
1797static int dpcm_apply_symmetry(struct snd_pcm_substream *fe_substream,
1798			       int stream)
1799{
1800	struct snd_soc_dpcm *dpcm;
1801	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
1802	struct snd_soc_dai *fe_cpu_dai;
1803	int err = 0;
1804	int i;
1805
1806	/* apply symmetry for FE */
1807	soc_pcm_update_symmetry(fe_substream);
1808
1809	for_each_rtd_cpu_dais (fe, i, fe_cpu_dai) {
1810		/* Symmetry only applies if we've got an active stream. */
1811		err = soc_pcm_apply_symmetry(fe_substream, fe_cpu_dai);
1812		if (err < 0)
1813			goto error;
1814	}
1815
1816	/* apply symmetry for BE */
1817	for_each_dpcm_be(fe, stream, dpcm) {
1818		struct snd_soc_pcm_runtime *be = dpcm->be;
1819		struct snd_pcm_substream *be_substream =
1820			snd_soc_dpcm_get_substream(be, stream);
1821		struct snd_soc_pcm_runtime *rtd;
1822		struct snd_soc_dai *dai;
1823
1824		/* A backend may not have the requested substream */
1825		if (!be_substream)
1826			continue;
1827
1828		rtd = asoc_substream_to_rtd(be_substream);
1829		if (rtd->dai_link->be_hw_params_fixup)
1830			continue;
1831
1832		soc_pcm_update_symmetry(be_substream);
1833
1834		/* Symmetry only applies if we've got an active stream. */
1835		for_each_rtd_dais(rtd, i, dai) {
1836			err = soc_pcm_apply_symmetry(fe_substream, dai);
1837			if (err < 0)
1838				goto error;
1839		}
1840	}
1841error:
1842	return soc_pcm_ret(fe, err);
1843}
1844
1845static int dpcm_fe_dai_startup(struct snd_pcm_substream *fe_substream)
1846{
1847	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
1848	int stream = fe_substream->stream, ret = 0;
1849
1850	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
1851
1852	ret = dpcm_be_dai_startup(fe, stream);
1853	if (ret < 0)
1854		goto be_err;
1855
1856	dev_dbg(fe->dev, "ASoC: open FE %s\n", fe->dai_link->name);
1857
1858	/* start the DAI frontend */
1859	ret = __soc_pcm_open(fe, fe_substream);
1860	if (ret < 0)
1861		goto unwind;
1862
1863	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_OPEN;
1864
1865	dpcm_runtime_setup_fe(fe_substream);
 
1866
1867	dpcm_runtime_setup_be_format(fe_substream);
1868	dpcm_runtime_setup_be_chan(fe_substream);
1869	dpcm_runtime_setup_be_rate(fe_substream);
1870
1871	ret = dpcm_apply_symmetry(fe_substream, stream);
 
1872
1873unwind:
1874	if (ret < 0)
1875		dpcm_be_dai_startup_unwind(fe, stream);
1876be_err:
1877	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
1878
1879	return soc_pcm_ret(fe, ret);
 
 
1880}
1881
1882static int dpcm_fe_dai_shutdown(struct snd_pcm_substream *substream)
1883{
1884	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1885	int stream = substream->stream;
1886
1887	snd_soc_dpcm_mutex_assert_held(fe);
1888
1889	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
1890
1891	/* shutdown the BEs */
1892	dpcm_be_dai_shutdown(fe, stream);
1893
1894	dev_dbg(fe->dev, "ASoC: close FE %s\n", fe->dai_link->name);
1895
1896	/* now shutdown the frontend */
1897	__soc_pcm_close(fe, substream);
1898
1899	/* run the stream stop event */
1900	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_STOP);
1901
1902	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_CLOSE;
1903	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
1904	return 0;
1905}
1906
1907void dpcm_be_dai_hw_free(struct snd_soc_pcm_runtime *fe, int stream)
1908{
1909	struct snd_soc_dpcm *dpcm;
1910
1911	/* only hw_params backends that are either sinks or sources
1912	 * to this frontend DAI */
1913	for_each_dpcm_be(fe, stream, dpcm) {
1914
1915		struct snd_soc_pcm_runtime *be = dpcm->be;
1916		struct snd_pcm_substream *be_substream =
1917			snd_soc_dpcm_get_substream(be, stream);
1918
1919		/* is this op for this BE ? */
1920		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1921			continue;
1922
1923		/* only free hw when no longer used - check all FEs */
1924		if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
1925				continue;
1926
1927		/* do not free hw if this BE is used by other FE */
1928		if (be->dpcm[stream].users > 1)
1929			continue;
1930
1931		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
1932		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
1933		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
1934		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED) &&
1935		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
1936		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
1937			continue;
1938
1939		dev_dbg(be->dev, "ASoC: hw_free BE %s\n",
1940			be->dai_link->name);
1941
1942		__soc_pcm_hw_free(be, be_substream);
1943
1944		be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
1945	}
 
 
1946}
1947
1948static int dpcm_fe_dai_hw_free(struct snd_pcm_substream *substream)
1949{
1950	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
1951	int stream = substream->stream;
1952
1953	snd_soc_dpcm_mutex_lock(fe);
1954	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
1955
1956	dev_dbg(fe->dev, "ASoC: hw_free FE %s\n", fe->dai_link->name);
1957
1958	/* call hw_free on the frontend */
1959	soc_pcm_hw_clean(fe, substream, 0);
 
 
 
1960
1961	/* only hw_params backends that are either sinks or sources
1962	 * to this frontend DAI */
1963	dpcm_be_dai_hw_free(fe, stream);
1964
1965	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_FREE;
1966	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
1967
1968	snd_soc_dpcm_mutex_unlock(fe);
1969	return 0;
1970}
1971
1972int dpcm_be_dai_hw_params(struct snd_soc_pcm_runtime *fe, int stream)
1973{
1974	struct snd_soc_pcm_runtime *be;
1975	struct snd_pcm_substream *be_substream;
1976	struct snd_soc_dpcm *dpcm;
1977	int ret;
1978
1979	for_each_dpcm_be(fe, stream, dpcm) {
1980		struct snd_pcm_hw_params hw_params;
1981
1982		be = dpcm->be;
1983		be_substream = snd_soc_dpcm_get_substream(be, stream);
 
1984
1985		/* is this op for this BE ? */
1986		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
1987			continue;
1988
1989		/* copy params for each dpcm */
1990		memcpy(&hw_params, &fe->dpcm[stream].hw_params,
1991				sizeof(struct snd_pcm_hw_params));
1992
1993		/* perform any hw_params fixups */
1994		ret = snd_soc_link_be_hw_params_fixup(be, &hw_params);
1995		if (ret < 0)
1996			goto unwind;
1997
1998		/* copy the fixed-up hw params for BE dai */
1999		memcpy(&be->dpcm[stream].hw_params, &hw_params,
2000		       sizeof(struct snd_pcm_hw_params));
2001
2002		/* only allow hw_params() if no connected FEs are running */
2003		if (!snd_soc_dpcm_can_be_params(fe, be, stream))
2004			continue;
2005
2006		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
2007		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
2008		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE))
2009			continue;
2010
2011		dev_dbg(be->dev, "ASoC: hw_params BE %s\n",
2012			be->dai_link->name);
2013
2014		ret = __soc_pcm_hw_params(be, be_substream, &hw_params);
2015		if (ret < 0)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2016			goto unwind;
 
2017
2018		be->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
2019	}
2020	return 0;
2021
2022unwind:
2023	dev_dbg(fe->dev, "ASoC: %s() failed at %s (%d)\n",
2024		__func__, be->dai_link->name, ret);
2025
2026	/* disable any enabled and non active backends */
2027	for_each_dpcm_be_rollback(fe, stream, dpcm) {
2028		be = dpcm->be;
2029		be_substream = snd_soc_dpcm_get_substream(be, stream);
 
2030
2031		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2032			continue;
2033
2034		/* only allow hw_free() if no connected FEs are running */
2035		if (!snd_soc_dpcm_can_be_free_stop(fe, be, stream))
2036			continue;
2037
2038		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_OPEN) &&
2039		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
2040		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_FREE) &&
2041		   (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP))
2042			continue;
2043
2044		__soc_pcm_hw_free(be, be_substream);
2045	}
2046
2047	return ret;
2048}
2049
2050static int dpcm_fe_dai_hw_params(struct snd_pcm_substream *substream,
2051				 struct snd_pcm_hw_params *params)
2052{
2053	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2054	int ret, stream = substream->stream;
2055
2056	snd_soc_dpcm_mutex_lock(fe);
2057	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
2058
2059	memcpy(&fe->dpcm[stream].hw_params, params,
2060			sizeof(struct snd_pcm_hw_params));
2061	ret = dpcm_be_dai_hw_params(fe, stream);
2062	if (ret < 0)
 
2063		goto out;
 
2064
2065	dev_dbg(fe->dev, "ASoC: hw_params FE %s rate %d chan %x fmt %d\n",
2066			fe->dai_link->name, params_rate(params),
2067			params_channels(params), params_format(params));
2068
2069	/* call hw_params on the frontend */
2070	ret = __soc_pcm_hw_params(fe, substream, params);
2071	if (ret < 0)
 
2072		dpcm_be_dai_hw_free(fe, stream);
2073	else
2074		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_HW_PARAMS;
2075
2076out:
2077	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
2078	snd_soc_dpcm_mutex_unlock(fe);
 
 
2079
2080	return soc_pcm_ret(fe, ret);
 
 
 
 
 
 
 
 
 
 
 
 
2081}
2082
2083int dpcm_be_dai_trigger(struct snd_soc_pcm_runtime *fe, int stream,
2084			       int cmd)
2085{
2086	struct snd_soc_pcm_runtime *be;
2087	bool pause_stop_transition;
2088	struct snd_soc_dpcm *dpcm;
2089	unsigned long flags;
2090	int ret = 0;
2091
2092	for_each_dpcm_be(fe, stream, dpcm) {
2093		struct snd_pcm_substream *be_substream;
2094
2095		be = dpcm->be;
2096		be_substream = snd_soc_dpcm_get_substream(be, stream);
2097
2098		snd_soc_dpcm_stream_lock_irqsave_nested(be, stream, flags);
2099
2100		/* is this op for this BE ? */
2101		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2102			goto next;
2103
2104		dev_dbg(be->dev, "ASoC: trigger BE %s cmd %d\n",
2105			be->dai_link->name, cmd);
2106
2107		switch (cmd) {
2108		case SNDRV_PCM_TRIGGER_START:
2109			if (!be->dpcm[stream].be_start &&
2110			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PREPARE) &&
2111			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
2112			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2113				goto next;
2114
2115			be->dpcm[stream].be_start++;
2116			if (be->dpcm[stream].be_start != 1)
2117				goto next;
2118
2119			if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_PAUSED)
2120				ret = soc_pcm_trigger(be_substream,
2121						      SNDRV_PCM_TRIGGER_PAUSE_RELEASE);
2122			else
2123				ret = soc_pcm_trigger(be_substream,
2124						      SNDRV_PCM_TRIGGER_START);
2125			if (ret) {
2126				be->dpcm[stream].be_start--;
2127				goto next;
2128			}
2129
2130			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2131			break;
2132		case SNDRV_PCM_TRIGGER_RESUME:
2133			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND))
2134				goto next;
2135
2136			be->dpcm[stream].be_start++;
2137			if (be->dpcm[stream].be_start != 1)
2138				goto next;
2139
2140			ret = soc_pcm_trigger(be_substream, cmd);
2141			if (ret) {
2142				be->dpcm[stream].be_start--;
2143				goto next;
2144			}
2145
2146			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2147			break;
2148		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2149			if (!be->dpcm[stream].be_start &&
2150			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) &&
2151			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2152				goto next;
2153
2154			fe->dpcm[stream].fe_pause = false;
2155			be->dpcm[stream].be_pause--;
2156
2157			be->dpcm[stream].be_start++;
2158			if (be->dpcm[stream].be_start != 1)
2159				goto next;
2160
2161			ret = soc_pcm_trigger(be_substream, cmd);
2162			if (ret) {
2163				be->dpcm[stream].be_start--;
2164				goto next;
2165			}
2166
2167			be->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2168			break;
2169		case SNDRV_PCM_TRIGGER_STOP:
2170			if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_START) &&
2171			    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2172				goto next;
2173
2174			if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_START)
2175				be->dpcm[stream].be_start--;
2176
2177			if (be->dpcm[stream].be_start != 0)
2178				goto next;
2179
2180			pause_stop_transition = false;
2181			if (fe->dpcm[stream].fe_pause) {
2182				pause_stop_transition = true;
2183				fe->dpcm[stream].fe_pause = false;
2184				be->dpcm[stream].be_pause--;
2185			}
2186
2187			if (be->dpcm[stream].be_pause != 0)
2188				ret = soc_pcm_trigger(be_substream, SNDRV_PCM_TRIGGER_PAUSE_PUSH);
2189			else
2190				ret = soc_pcm_trigger(be_substream, SNDRV_PCM_TRIGGER_STOP);
2191
2192			if (ret) {
2193				if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_START)
2194					be->dpcm[stream].be_start++;
2195				if (pause_stop_transition) {
2196					fe->dpcm[stream].fe_pause = true;
2197					be->dpcm[stream].be_pause++;
2198				}
2199				goto next;
2200			}
2201
2202			if (be->dpcm[stream].be_pause != 0)
2203				be->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
2204			else
2205				be->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
2206
 
2207			break;
2208		case SNDRV_PCM_TRIGGER_SUSPEND:
2209			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
2210				goto next;
2211
2212			be->dpcm[stream].be_start--;
2213			if (be->dpcm[stream].be_start != 0)
2214				goto next;
2215
2216			ret = soc_pcm_trigger(be_substream, cmd);
2217			if (ret) {
2218				be->dpcm[stream].be_start++;
2219				goto next;
2220			}
2221
2222			be->dpcm[stream].state = SND_SOC_DPCM_STATE_SUSPEND;
2223			break;
2224		case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2225			if (be->dpcm[stream].state != SND_SOC_DPCM_STATE_START)
2226				goto next;
2227
2228			fe->dpcm[stream].fe_pause = true;
2229			be->dpcm[stream].be_pause++;
2230
2231			be->dpcm[stream].be_start--;
2232			if (be->dpcm[stream].be_start != 0)
2233				goto next;
2234
2235			ret = soc_pcm_trigger(be_substream, cmd);
2236			if (ret) {
2237				be->dpcm[stream].be_start++;
2238				goto next;
2239			}
2240
2241			be->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
2242			break;
2243		}
2244next:
2245		snd_soc_dpcm_stream_unlock_irqrestore(be, stream, flags);
2246		if (ret)
2247			break;
2248	}
2249	return soc_pcm_ret(fe, ret);
2250}
2251EXPORT_SYMBOL_GPL(dpcm_be_dai_trigger);
2252
2253static int dpcm_dai_trigger_fe_be(struct snd_pcm_substream *substream,
2254				  int cmd, bool fe_first)
2255{
2256	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2257	int ret;
2258
2259	/* call trigger on the frontend before the backend. */
2260	if (fe_first) {
2261		dev_dbg(fe->dev, "ASoC: pre trigger FE %s cmd %d\n",
2262			fe->dai_link->name, cmd);
2263
2264		ret = soc_pcm_trigger(substream, cmd);
2265		if (ret < 0)
2266			return ret;
2267
2268		ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
2269		return ret;
2270	}
2271
2272	/* call trigger on the frontend after the backend. */
2273	ret = dpcm_be_dai_trigger(fe, substream->stream, cmd);
2274	if (ret < 0)
2275		return ret;
2276
2277	dev_dbg(fe->dev, "ASoC: post trigger FE %s cmd %d\n",
2278		fe->dai_link->name, cmd);
2279
2280	ret = soc_pcm_trigger(substream, cmd);
2281
2282	return ret;
2283}
 
2284
2285static int dpcm_fe_dai_do_trigger(struct snd_pcm_substream *substream, int cmd)
2286{
2287	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2288	int stream = substream->stream;
2289	int ret = 0;
2290	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2291
2292	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_FE;
2293
2294	switch (trigger) {
2295	case SND_SOC_DPCM_TRIGGER_PRE:
2296		switch (cmd) {
2297		case SNDRV_PCM_TRIGGER_START:
2298		case SNDRV_PCM_TRIGGER_RESUME:
2299		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2300		case SNDRV_PCM_TRIGGER_DRAIN:
2301			ret = dpcm_dai_trigger_fe_be(substream, cmd, true);
2302			break;
2303		case SNDRV_PCM_TRIGGER_STOP:
2304		case SNDRV_PCM_TRIGGER_SUSPEND:
2305		case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2306			ret = dpcm_dai_trigger_fe_be(substream, cmd, false);
2307			break;
2308		default:
2309			ret = -EINVAL;
2310			break;
2311		}
 
 
2312		break;
2313	case SND_SOC_DPCM_TRIGGER_POST:
2314		switch (cmd) {
2315		case SNDRV_PCM_TRIGGER_START:
2316		case SNDRV_PCM_TRIGGER_RESUME:
2317		case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2318		case SNDRV_PCM_TRIGGER_DRAIN:
2319			ret = dpcm_dai_trigger_fe_be(substream, cmd, false);
2320			break;
2321		case SNDRV_PCM_TRIGGER_STOP:
2322		case SNDRV_PCM_TRIGGER_SUSPEND:
2323		case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2324			ret = dpcm_dai_trigger_fe_be(substream, cmd, true);
2325			break;
2326		default:
2327			ret = -EINVAL;
2328			break;
2329		}
 
 
 
 
 
2330		break;
2331	case SND_SOC_DPCM_TRIGGER_BESPOKE:
2332		/* bespoke trigger() - handles both FE and BEs */
2333
2334		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd %d\n",
2335				fe->dai_link->name, cmd);
2336
2337		ret = snd_soc_pcm_dai_bespoke_trigger(substream, cmd);
 
 
 
 
2338		break;
2339	default:
2340		dev_err(fe->dev, "ASoC: invalid trigger cmd %d for %s\n", cmd,
2341				fe->dai_link->name);
2342		ret = -EINVAL;
2343		goto out;
2344	}
2345
2346	if (ret < 0) {
2347		dev_err(fe->dev, "ASoC: trigger FE cmd: %d failed: %d\n",
2348			cmd, ret);
2349		goto out;
2350	}
2351
2352	switch (cmd) {
2353	case SNDRV_PCM_TRIGGER_START:
2354	case SNDRV_PCM_TRIGGER_RESUME:
2355	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
2356		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_START;
2357		break;
2358	case SNDRV_PCM_TRIGGER_STOP:
2359	case SNDRV_PCM_TRIGGER_SUSPEND:
2360		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_STOP;
2361		break;
2362	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
2363		fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PAUSED;
2364		break;
2365	}
2366
2367out:
2368	fe->dpcm[stream].runtime_update = SND_SOC_DPCM_UPDATE_NO;
2369	return ret;
2370}
2371
2372static int dpcm_fe_dai_trigger(struct snd_pcm_substream *substream, int cmd)
2373{
2374	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2375	int stream = substream->stream;
2376
2377	/* if FE's runtime_update is already set, we're in race;
2378	 * process this trigger later at exit
2379	 */
2380	if (fe->dpcm[stream].runtime_update != SND_SOC_DPCM_UPDATE_NO) {
2381		fe->dpcm[stream].trigger_pending = cmd + 1;
2382		return 0; /* delayed, assuming it's successful */
2383	}
2384
2385	/* we're alone, let's trigger */
2386	return dpcm_fe_dai_do_trigger(substream, cmd);
2387}
2388
2389int dpcm_be_dai_prepare(struct snd_soc_pcm_runtime *fe, int stream)
2390{
2391	struct snd_soc_dpcm *dpcm;
2392	int ret = 0;
2393
2394	for_each_dpcm_be(fe, stream, dpcm) {
2395
2396		struct snd_soc_pcm_runtime *be = dpcm->be;
2397		struct snd_pcm_substream *be_substream =
2398			snd_soc_dpcm_get_substream(be, stream);
2399
2400		/* is this op for this BE ? */
2401		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2402			continue;
2403
2404		if ((be->dpcm[stream].state != SND_SOC_DPCM_STATE_HW_PARAMS) &&
2405		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_STOP) &&
2406		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_SUSPEND) &&
2407		    (be->dpcm[stream].state != SND_SOC_DPCM_STATE_PAUSED))
2408			continue;
2409
2410		dev_dbg(be->dev, "ASoC: prepare BE %s\n",
2411			be->dai_link->name);
2412
2413		ret = __soc_pcm_prepare(be, be_substream);
2414		if (ret < 0)
 
 
2415			break;
 
2416
2417		be->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
2418	}
2419
2420	return soc_pcm_ret(fe, ret);
2421}
2422
2423static int dpcm_fe_dai_prepare(struct snd_pcm_substream *substream)
2424{
2425	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream);
2426	int stream = substream->stream, ret = 0;
2427
2428	snd_soc_dpcm_mutex_lock(fe);
2429
2430	dev_dbg(fe->dev, "ASoC: prepare FE %s\n", fe->dai_link->name);
2431
2432	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_FE);
2433
2434	/* there is no point preparing this FE if there are no BEs */
2435	if (list_empty(&fe->dpcm[stream].be_clients)) {
2436		dev_err(fe->dev, "ASoC: no backend DAIs enabled for %s\n",
2437				fe->dai_link->name);
2438		ret = -EINVAL;
2439		goto out;
2440	}
2441
2442	ret = dpcm_be_dai_prepare(fe, stream);
2443	if (ret < 0)
2444		goto out;
2445
2446	/* call prepare on the frontend */
2447	ret = __soc_pcm_prepare(fe, substream);
2448	if (ret < 0)
 
 
2449		goto out;
 
2450
 
 
2451	fe->dpcm[stream].state = SND_SOC_DPCM_STATE_PREPARE;
2452
2453out:
2454	dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
2455	snd_soc_dpcm_mutex_unlock(fe);
2456
2457	return soc_pcm_ret(fe, ret);
 
 
 
 
 
 
 
 
 
 
 
2458}
2459
2460static int dpcm_run_update_shutdown(struct snd_soc_pcm_runtime *fe, int stream)
2461{
2462	struct snd_pcm_substream *substream =
2463		snd_soc_dpcm_get_substream(fe, stream);
2464	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2465	int err;
2466
2467	dev_dbg(fe->dev, "ASoC: runtime %s close on FE %s\n",
2468			stream ? "capture" : "playback", fe->dai_link->name);
2469
2470	if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
2471		/* call bespoke trigger - FE takes care of all BE triggers */
2472		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd stop\n",
2473				fe->dai_link->name);
2474
2475		err = snd_soc_pcm_dai_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_STOP);
 
 
2476	} else {
2477		dev_dbg(fe->dev, "ASoC: trigger FE %s cmd stop\n",
2478			fe->dai_link->name);
2479
2480		err = dpcm_be_dai_trigger(fe, stream, SNDRV_PCM_TRIGGER_STOP);
 
 
2481	}
2482
2483	dpcm_be_dai_hw_free(fe, stream);
 
 
2484
2485	dpcm_be_dai_shutdown(fe, stream);
 
 
2486
2487	/* run the stream event for each BE */
2488	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP);
2489
2490	return soc_pcm_ret(fe, err);
2491}
2492
2493static int dpcm_run_update_startup(struct snd_soc_pcm_runtime *fe, int stream)
2494{
2495	struct snd_pcm_substream *substream =
2496		snd_soc_dpcm_get_substream(fe, stream);
2497	struct snd_soc_dpcm *dpcm;
2498	enum snd_soc_dpcm_trigger trigger = fe->dai_link->trigger[stream];
2499	int ret = 0;
2500
2501	dev_dbg(fe->dev, "ASoC: runtime %s open on FE %s\n",
2502			stream ? "capture" : "playback", fe->dai_link->name);
2503
2504	/* Only start the BE if the FE is ready */
2505	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_FREE ||
2506		fe->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE) {
2507		dev_err(fe->dev, "ASoC: FE %s is not ready %d\n",
2508			fe->dai_link->name, fe->dpcm[stream].state);
2509		ret = -EINVAL;
2510		goto disconnect;
2511	}
2512
2513	/* startup must always be called for new BEs */
2514	ret = dpcm_be_dai_startup(fe, stream);
2515	if (ret < 0)
2516		goto disconnect;
2517
2518	/* keep going if FE state is > open */
2519	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_OPEN)
2520		return 0;
2521
2522	ret = dpcm_be_dai_hw_params(fe, stream);
2523	if (ret < 0)
2524		goto close;
2525
2526	/* keep going if FE state is > hw_params */
2527	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_HW_PARAMS)
2528		return 0;
2529
 
2530	ret = dpcm_be_dai_prepare(fe, stream);
2531	if (ret < 0)
2532		goto hw_free;
2533
2534	/* run the stream event for each BE */
2535	dpcm_dapm_stream_event(fe, stream, SND_SOC_DAPM_STREAM_NOP);
2536
2537	/* keep going if FE state is > prepare */
2538	if (fe->dpcm[stream].state == SND_SOC_DPCM_STATE_PREPARE ||
2539		fe->dpcm[stream].state == SND_SOC_DPCM_STATE_STOP)
2540		return 0;
2541
2542	if (trigger == SND_SOC_DPCM_TRIGGER_BESPOKE) {
2543		/* call trigger on the frontend - FE takes care of all BE triggers */
2544		dev_dbg(fe->dev, "ASoC: bespoke trigger FE %s cmd start\n",
2545				fe->dai_link->name);
2546
2547		ret = snd_soc_pcm_dai_bespoke_trigger(substream, SNDRV_PCM_TRIGGER_START);
2548		if (ret < 0)
 
2549			goto hw_free;
 
2550	} else {
2551		dev_dbg(fe->dev, "ASoC: trigger FE %s cmd start\n",
2552			fe->dai_link->name);
2553
2554		ret = dpcm_be_dai_trigger(fe, stream,
2555					SNDRV_PCM_TRIGGER_START);
2556		if (ret < 0)
 
2557			goto hw_free;
 
2558	}
2559
2560	return 0;
2561
2562hw_free:
2563	dpcm_be_dai_hw_free(fe, stream);
2564close:
2565	dpcm_be_dai_shutdown(fe, stream);
2566disconnect:
2567	/* disconnect any pending BEs */
2568	for_each_dpcm_be(fe, stream, dpcm) {
2569		struct snd_soc_pcm_runtime *be = dpcm->be;
2570
2571		/* is this op for this BE ? */
2572		if (!snd_soc_dpcm_be_can_update(fe, be, stream))
2573			continue;
2574
2575		if (be->dpcm[stream].state == SND_SOC_DPCM_STATE_CLOSE ||
2576			be->dpcm[stream].state == SND_SOC_DPCM_STATE_NEW)
2577				dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
2578	}
2579
2580	return soc_pcm_ret(fe, ret);
2581}
2582
2583static int soc_dpcm_fe_runtime_update(struct snd_soc_pcm_runtime *fe, int new)
2584{
2585	struct snd_soc_dapm_widget_list *list;
2586	int stream;
2587	int count, paths;
2588
2589	if (!fe->dai_link->dynamic)
2590		return 0;
 
 
 
2591
2592	if (fe->dai_link->num_cpus > 1) {
2593		dev_err(fe->dev,
2594			"%s doesn't support Multi CPU yet\n", __func__);
2595		return -EINVAL;
2596	}
2597
2598	/* only check active links */
2599	if (!snd_soc_dai_active(asoc_rtd_to_cpu(fe, 0)))
2600		return 0;
2601
2602	/* DAPM sync will call this to update DSP paths */
2603	dev_dbg(fe->dev, "ASoC: DPCM %s runtime update for FE %s\n",
2604		new ? "new" : "old", fe->dai_link->name);
 
 
2605
2606	for_each_pcm_streams(stream) {
 
2607
2608		/* skip if FE doesn't have playback/capture capability */
2609		if (!snd_soc_dai_stream_valid(asoc_rtd_to_cpu(fe, 0),   stream) ||
2610		    !snd_soc_dai_stream_valid(asoc_rtd_to_codec(fe, 0), stream))
 
 
 
 
 
 
 
 
 
 
 
2611			continue;
2612
2613		/* skip if FE isn't currently playing/capturing */
2614		if (!snd_soc_dai_stream_active(asoc_rtd_to_cpu(fe, 0), stream) ||
2615		    !snd_soc_dai_stream_active(asoc_rtd_to_codec(fe, 0), stream))
2616			continue;
2617
2618		paths = dpcm_path_get(fe, stream, &list);
2619		if (paths < 0)
 
 
 
 
 
 
 
 
 
 
 
2620			return paths;
 
2621
2622		/* update any playback/capture paths */
2623		count = dpcm_process_paths(fe, stream, &list, new);
2624		if (count) {
2625			dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_BE);
2626			if (new)
2627				dpcm_run_update_startup(fe, stream);
2628			else
2629				dpcm_run_update_shutdown(fe, stream);
2630			dpcm_set_fe_update_state(fe, stream, SND_SOC_DPCM_UPDATE_NO);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2631
2632			dpcm_clear_pending_state(fe, stream);
2633			dpcm_be_disconnect(fe, stream);
 
 
 
 
2634		}
2635
2636		dpcm_path_put(&list);
2637	}
2638
 
2639	return 0;
2640}
2641
2642/* Called by DAPM mixer/mux changes to update audio routing between PCMs and
2643 * any DAI links.
2644 */
2645int snd_soc_dpcm_runtime_update(struct snd_soc_card *card)
2646{
2647	struct snd_soc_pcm_runtime *fe;
2648	int ret = 0;
2649
2650	mutex_lock_nested(&card->pcm_mutex, card->pcm_subclass);
2651	/* shutdown all old paths first */
2652	for_each_card_rtds(card, fe) {
2653		ret = soc_dpcm_fe_runtime_update(fe, 0);
2654		if (ret)
2655			goto out;
2656	}
2657
2658	/* bring new paths up */
2659	for_each_card_rtds(card, fe) {
2660		ret = soc_dpcm_fe_runtime_update(fe, 1);
2661		if (ret)
2662			goto out;
2663	}
2664
2665out:
2666	mutex_unlock(&card->pcm_mutex);
2667	return ret;
2668}
2669EXPORT_SYMBOL_GPL(snd_soc_dpcm_runtime_update);
2670
2671static void dpcm_fe_dai_cleanup(struct snd_pcm_substream *fe_substream)
2672{
2673	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
2674	struct snd_soc_dpcm *dpcm;
2675	int stream = fe_substream->stream;
 
2676
2677	snd_soc_dpcm_mutex_assert_held(fe);
2678
2679	/* mark FE's links ready to prune */
2680	for_each_dpcm_be(fe, stream, dpcm)
2681		dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;
2682
2683	dpcm_be_disconnect(fe, stream);
2684
2685	fe->dpcm[stream].runtime = NULL;
2686}
2687
2688static int dpcm_fe_dai_close(struct snd_pcm_substream *fe_substream)
2689{
2690	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
2691	int ret;
2692
2693	snd_soc_dpcm_mutex_lock(fe);
2694	ret = dpcm_fe_dai_shutdown(fe_substream);
2695
2696	dpcm_fe_dai_cleanup(fe_substream);
 
 
2697
2698	snd_soc_dpcm_mutex_unlock(fe);
2699	return ret;
2700}
2701
2702static int dpcm_fe_dai_open(struct snd_pcm_substream *fe_substream)
2703{
2704	struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(fe_substream);
 
2705	struct snd_soc_dapm_widget_list *list;
2706	int ret;
2707	int stream = fe_substream->stream;
2708
2709	snd_soc_dpcm_mutex_lock(fe);
2710	fe->dpcm[stream].runtime = fe_substream->runtime;
2711
2712	ret = dpcm_path_get(fe, stream, &list);
2713	if (ret < 0)
2714		goto open_end;
 
2715
2716	/* calculate valid and active FE <-> BE dpcms */
2717	dpcm_process_paths(fe, stream, &list, 1);
2718
2719	ret = dpcm_fe_dai_startup(fe_substream);
2720	if (ret < 0)
2721		dpcm_fe_dai_cleanup(fe_substream);
 
 
 
 
 
 
2722
2723	dpcm_clear_pending_state(fe, stream);
2724	dpcm_path_put(&list);
2725open_end:
2726	snd_soc_dpcm_mutex_unlock(fe);
2727	return ret;
2728}
2729
2730static int soc_get_playback_capture(struct snd_soc_pcm_runtime *rtd,
2731				    int *playback, int *capture)
2732{
2733	struct snd_soc_dai *cpu_dai;
2734	int i;
 
2735
2736	if (rtd->dai_link->dynamic && rtd->dai_link->num_cpus > 1) {
2737		dev_err(rtd->dev,
2738			"DPCM doesn't support Multi CPU for Front-Ends yet\n");
2739		return -EINVAL;
2740	}
2741
2742	if (rtd->dai_link->dynamic || rtd->dai_link->no_pcm) {
2743		int stream;
 
2744
2745		if (rtd->dai_link->dpcm_playback) {
2746			stream = SNDRV_PCM_STREAM_PLAYBACK;
2747
2748			for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
2749				if (snd_soc_dai_stream_valid(cpu_dai, stream)) {
2750					*playback = 1;
2751					break;
2752				}
2753			}
2754			if (!*playback) {
2755				dev_err(rtd->card->dev,
2756					"No CPU DAIs support playback for stream %s\n",
2757					rtd->dai_link->stream_name);
2758				return -EINVAL;
2759			}
2760		}
2761		if (rtd->dai_link->dpcm_capture) {
2762			stream = SNDRV_PCM_STREAM_CAPTURE;
2763
2764			for_each_rtd_cpu_dais(rtd, i, cpu_dai) {
2765				if (snd_soc_dai_stream_valid(cpu_dai, stream)) {
2766					*capture = 1;
2767					break;
2768				}
2769			}
 
 
 
2770
2771			if (!*capture) {
2772				dev_err(rtd->card->dev,
2773					"No CPU DAIs support capture for stream %s\n",
2774					rtd->dai_link->stream_name);
2775				return -EINVAL;
2776			}
2777		}
2778	} else {
2779		struct snd_soc_dai *codec_dai;
2780
2781		/* Adapt stream for codec2codec links */
2782		int cpu_capture = rtd->dai_link->params ?
2783			SNDRV_PCM_STREAM_PLAYBACK : SNDRV_PCM_STREAM_CAPTURE;
2784		int cpu_playback = rtd->dai_link->params ?
2785			SNDRV_PCM_STREAM_CAPTURE : SNDRV_PCM_STREAM_PLAYBACK;
2786
2787		for_each_rtd_codec_dais(rtd, i, codec_dai) {
2788			if (rtd->dai_link->num_cpus == 1) {
2789				cpu_dai = asoc_rtd_to_cpu(rtd, 0);
2790			} else if (rtd->dai_link->num_cpus == rtd->dai_link->num_codecs) {
2791				cpu_dai = asoc_rtd_to_cpu(rtd, i);
2792			} else {
2793				dev_err(rtd->card->dev,
2794					"N cpus to M codecs link is not supported yet\n");
2795				return -EINVAL;
2796			}
2797
2798			if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_PLAYBACK) &&
2799			    snd_soc_dai_stream_valid(cpu_dai,   cpu_playback))
2800				*playback = 1;
2801			if (snd_soc_dai_stream_valid(codec_dai, SNDRV_PCM_STREAM_CAPTURE) &&
2802			    snd_soc_dai_stream_valid(cpu_dai,   cpu_capture))
2803				*capture = 1;
2804		}
2805	}
2806
2807	if (rtd->dai_link->playback_only) {
2808		*playback = 1;
2809		*capture = 0;
2810	}
2811
2812	if (rtd->dai_link->capture_only) {
2813		*playback = 0;
2814		*capture = 1;
2815	}
2816
2817	return 0;
2818}
2819
2820static int soc_create_pcm(struct snd_pcm **pcm,
2821			  struct snd_soc_pcm_runtime *rtd,
2822			  int playback, int capture, int num)
2823{
2824	char new_name[64];
2825	int ret;
2826
2827	/* create the PCM */
2828	if (rtd->dai_link->params) {
2829		snprintf(new_name, sizeof(new_name), "codec2codec(%s)",
2830			 rtd->dai_link->stream_name);
2831
2832		ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
2833					   playback, capture, pcm);
2834	} else if (rtd->dai_link->no_pcm) {
2835		snprintf(new_name, sizeof(new_name), "(%s)",
2836			rtd->dai_link->stream_name);
2837
2838		ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,
2839				playback, capture, pcm);
2840	} else {
2841		if (rtd->dai_link->dynamic)
2842			snprintf(new_name, sizeof(new_name), "%s (*)",
2843				rtd->dai_link->stream_name);
2844		else
2845			snprintf(new_name, sizeof(new_name), "%s %s-%d",
2846				rtd->dai_link->stream_name,
2847				soc_codec_dai_name(rtd), num);
2848
2849		ret = snd_pcm_new(rtd->card->snd_card, new_name, num, playback,
2850			capture, pcm);
2851	}
2852	if (ret < 0) {
2853		dev_err(rtd->card->dev, "ASoC: can't create pcm %s for dailink %s: %d\n",
2854			new_name, rtd->dai_link->name, ret);
2855		return ret;
2856	}
2857	dev_dbg(rtd->card->dev, "ASoC: registered pcm #%d %s\n",num, new_name);
2858
2859	return 0;
2860}
2861
2862/* create a new pcm */
2863int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
2864{
2865	struct snd_soc_component *component;
2866	struct snd_pcm *pcm;
2867	int ret = 0, playback = 0, capture = 0;
2868	int i;
2869
2870	ret = soc_get_playback_capture(rtd, &playback, &capture);
2871	if (ret < 0)
2872		return ret;
2873
2874	ret = soc_create_pcm(&pcm, rtd, playback, capture, num);
2875	if (ret < 0)
2876		return ret;
2877
2878	/* DAPM dai link stream work */
2879	/*
2880	 * Currently nothing to do for c2c links
2881	 * Since c2c links are internal nodes in the DAPM graph and
2882	 * don't interface with the outside world or application layer
2883	 * we don't have to do any special handling on close.
2884	 */
2885	if (!rtd->dai_link->params)
2886		rtd->close_delayed_work_func = snd_soc_close_delayed_work;
2887
2888	rtd->pcm = pcm;
2889	pcm->nonatomic = rtd->dai_link->nonatomic;
2890	pcm->private_data = rtd;
2891	pcm->no_device_suspend = true;
2892
2893	if (rtd->dai_link->no_pcm || rtd->dai_link->params) {
2894		if (playback)
2895			pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->private_data = rtd;
2896		if (capture)
2897			pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->private_data = rtd;
2898		goto out;
2899	}
2900
2901	/* ASoC PCM operations */
2902	if (rtd->dai_link->dynamic) {
2903		rtd->ops.open		= dpcm_fe_dai_open;
2904		rtd->ops.hw_params	= dpcm_fe_dai_hw_params;
2905		rtd->ops.prepare	= dpcm_fe_dai_prepare;
2906		rtd->ops.trigger	= dpcm_fe_dai_trigger;
2907		rtd->ops.hw_free	= dpcm_fe_dai_hw_free;
2908		rtd->ops.close		= dpcm_fe_dai_close;
2909		rtd->ops.pointer	= soc_pcm_pointer;
 
2910	} else {
2911		rtd->ops.open		= soc_pcm_open;
2912		rtd->ops.hw_params	= soc_pcm_hw_params;
2913		rtd->ops.prepare	= soc_pcm_prepare;
2914		rtd->ops.trigger	= soc_pcm_trigger;
2915		rtd->ops.hw_free	= soc_pcm_hw_free;
2916		rtd->ops.close		= soc_pcm_close;
2917		rtd->ops.pointer	= soc_pcm_pointer;
 
2918	}
2919
2920	for_each_rtd_components(rtd, i, component) {
2921		const struct snd_soc_component_driver *drv = component->driver;
2922
2923		if (drv->ioctl)
2924			rtd->ops.ioctl		= snd_soc_pcm_component_ioctl;
2925		if (drv->sync_stop)
2926			rtd->ops.sync_stop	= snd_soc_pcm_component_sync_stop;
2927		if (drv->copy_user)
2928			rtd->ops.copy_user	= snd_soc_pcm_component_copy_user;
2929		if (drv->page)
2930			rtd->ops.page		= snd_soc_pcm_component_page;
2931		if (drv->mmap)
2932			rtd->ops.mmap		= snd_soc_pcm_component_mmap;
2933		if (drv->ack)
2934			rtd->ops.ack            = snd_soc_pcm_component_ack;
2935	}
2936
2937	if (playback)
2938		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &rtd->ops);
2939
2940	if (capture)
2941		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &rtd->ops);
2942
2943	ret = snd_soc_pcm_component_new(rtd);
2944	if (ret < 0)
2945		return ret;
 
 
 
 
 
 
 
 
2946out:
2947	dev_dbg(rtd->card->dev, "%s <-> %s mapping ok\n",
2948		soc_codec_dai_name(rtd), soc_cpu_dai_name(rtd));
2949	return ret;
2950}
2951
2952/* is the current PCM operation for this FE ? */
2953int snd_soc_dpcm_fe_can_update(struct snd_soc_pcm_runtime *fe, int stream)
2954{
2955	if (fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE)
2956		return 1;
2957	return 0;
2958}
2959EXPORT_SYMBOL_GPL(snd_soc_dpcm_fe_can_update);
2960
2961/* is the current PCM operation for this BE ? */
2962int snd_soc_dpcm_be_can_update(struct snd_soc_pcm_runtime *fe,
2963		struct snd_soc_pcm_runtime *be, int stream)
2964{
2965	if ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_FE) ||
2966	   ((fe->dpcm[stream].runtime_update == SND_SOC_DPCM_UPDATE_BE) &&
2967		  be->dpcm[stream].runtime_update))
2968		return 1;
2969	return 0;
2970}
2971EXPORT_SYMBOL_GPL(snd_soc_dpcm_be_can_update);
2972
2973/* get the substream for this BE */
2974struct snd_pcm_substream *
2975	snd_soc_dpcm_get_substream(struct snd_soc_pcm_runtime *be, int stream)
2976{
2977	return be->pcm->streams[stream].substream;
2978}
2979EXPORT_SYMBOL_GPL(snd_soc_dpcm_get_substream);
2980
2981static int snd_soc_dpcm_check_state(struct snd_soc_pcm_runtime *fe,
2982				    struct snd_soc_pcm_runtime *be,
2983				    int stream,
2984				    const enum snd_soc_dpcm_state *states,
2985				    int num_states)
2986{
2987	struct snd_soc_dpcm *dpcm;
2988	int state;
2989	int ret = 1;
2990	int i;
2991
2992	for_each_dpcm_fe(be, stream, dpcm) {
2993
2994		if (dpcm->fe == fe)
2995			continue;
2996
2997		state = dpcm->fe->dpcm[stream].state;
2998		for (i = 0; i < num_states; i++) {
2999			if (state == states[i]) {
3000				ret = 0;
3001				break;
3002			}
3003		}
3004	}
3005
3006	/* it's safe to do this BE DAI */
3007	return ret;
 
 
 
3008}
 
3009
3010/*
3011 * We can only hw_free, stop, pause or suspend a BE DAI if any of it's FE
3012 * are not running, paused or suspended for the specified stream direction.
3013 */
3014int snd_soc_dpcm_can_be_free_stop(struct snd_soc_pcm_runtime *fe,
3015		struct snd_soc_pcm_runtime *be, int stream)
3016{
3017	const enum snd_soc_dpcm_state state[] = {
3018		SND_SOC_DPCM_STATE_START,
3019		SND_SOC_DPCM_STATE_PAUSED,
3020		SND_SOC_DPCM_STATE_SUSPEND,
3021	};
 
 
 
 
 
 
 
 
 
3022
3023	return snd_soc_dpcm_check_state(fe, be, stream, state, ARRAY_SIZE(state));
 
3024}
3025EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_free_stop);
3026
3027/*
3028 * We can only change hw params a BE DAI if any of it's FE are not prepared,
3029 * running, paused or suspended for the specified stream direction.
3030 */
3031int snd_soc_dpcm_can_be_params(struct snd_soc_pcm_runtime *fe,
3032		struct snd_soc_pcm_runtime *be, int stream)
3033{
3034	const enum snd_soc_dpcm_state state[] = {
3035		SND_SOC_DPCM_STATE_START,
3036		SND_SOC_DPCM_STATE_PAUSED,
3037		SND_SOC_DPCM_STATE_SUSPEND,
3038		SND_SOC_DPCM_STATE_PREPARE,
3039	};
 
 
 
 
 
 
 
 
 
3040
3041	return snd_soc_dpcm_check_state(fe, be, stream, state, ARRAY_SIZE(state));
 
3042}
3043EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params);