// SPDX-License-Identifier: GPL-2.0
  //
  // soc-dai.c
  //
  // Copyright (C) 2019 Renesas Electronics Corp.
  // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
  //
  
  #include <sound/soc.h>
  #include <sound/soc-dai.h>

  #include <sound/soc-link.h>

  #define soc_dai_ret(dai, ret) _soc_dai_ret(dai, __func__, ret)
  static inline int _soc_dai_ret(struct snd_soc_dai *dai,
  			       const char *func, int ret)
  {

  	/* Positive, Zero values are not errors */
  	if (ret >= 0)
  		return ret;
  
  	/* Negative values might be errors */

  	switch (ret) {
  	case -EPROBE_DEFER:
  	case -ENOTSUPP:

  		break;
  	default:
  		dev_err(dai->dev,
  			"ASoC: error at %s on %s: %d
  ",
  			func, dai->name, ret);
  	}
  
  	return ret;
  }

  /*
   * We might want to check substream by using list.
   * In such case, we can update these macros.
   */
  #define soc_dai_mark_push(dai, substream, tgt)	((dai)->mark_##tgt = substream)
  #define soc_dai_mark_pop(dai, substream, tgt)	((dai)->mark_##tgt = NULL)
  #define soc_dai_mark_match(dai, substream, tgt)	((dai)->mark_##tgt == substream)

  /**
   * snd_soc_dai_set_sysclk - configure DAI system or master clock.
   * @dai: DAI
   * @clk_id: DAI specific clock ID
   * @freq: new clock frequency in Hz
   * @dir: new clock direction - input/output.
   *
   * Configures the DAI master (MCLK) or system (SYSCLK) clocking.
   */
  int snd_soc_dai_set_sysclk(struct snd_soc_dai *dai, int clk_id,
  			   unsigned int freq, int dir)
  {

  	int ret;

  	if (dai->driver->ops &&
  	    dai->driver->ops->set_sysclk)

  		ret = dai->driver->ops->set_sysclk(dai, clk_id, freq, dir);
  	else
  		ret = snd_soc_component_set_sysclk(dai->component, clk_id, 0,
  						   freq, dir);

  	return soc_dai_ret(dai, ret);

  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_set_sysclk);
  
  /**
   * snd_soc_dai_set_clkdiv - configure DAI clock dividers.
   * @dai: DAI
   * @div_id: DAI specific clock divider ID
   * @div: new clock divisor.
   *
   * Configures the clock dividers. This is used to derive the best DAI bit and
   * frame clocks from the system or master clock. It's best to set the DAI bit
   * and frame clocks as low as possible to save system power.
   */
  int snd_soc_dai_set_clkdiv(struct snd_soc_dai *dai,
  			   int div_id, int div)
  {

  	int ret = -EINVAL;

  	if (dai->driver->ops &&
  	    dai->driver->ops->set_clkdiv)

  		ret = dai->driver->ops->set_clkdiv(dai, div_id, div);
  
  	return soc_dai_ret(dai, ret);

  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_set_clkdiv);
  
  /**
   * snd_soc_dai_set_pll - configure DAI PLL.
   * @dai: DAI
   * @pll_id: DAI specific PLL ID
   * @source: DAI specific source for the PLL
   * @freq_in: PLL input clock frequency in Hz
   * @freq_out: requested PLL output clock frequency in Hz
   *
   * Configures and enables PLL to generate output clock based on input clock.
   */
  int snd_soc_dai_set_pll(struct snd_soc_dai *dai, int pll_id, int source,
  			unsigned int freq_in, unsigned int freq_out)
  {

  	int ret;

  	if (dai->driver->ops &&
  	    dai->driver->ops->set_pll)

  		ret = dai->driver->ops->set_pll(dai, pll_id, source,
  						freq_in, freq_out);
  	else
  		ret = snd_soc_component_set_pll(dai->component, pll_id, source,
  						freq_in, freq_out);

  	return soc_dai_ret(dai, ret);

  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_set_pll);
  
  /**
   * snd_soc_dai_set_bclk_ratio - configure BCLK to sample rate ratio.
   * @dai: DAI
   * @ratio: Ratio of BCLK to Sample rate.
   *
   * Configures the DAI for a preset BCLK to sample rate ratio.
   */
  int snd_soc_dai_set_bclk_ratio(struct snd_soc_dai *dai, unsigned int ratio)
  {

  	int ret = -EINVAL;

  	if (dai->driver->ops &&
  	    dai->driver->ops->set_bclk_ratio)

  		ret = dai->driver->ops->set_bclk_ratio(dai, ratio);
  
  	return soc_dai_ret(dai, ret);

  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_set_bclk_ratio);
  
  /**
   * snd_soc_dai_set_fmt - configure DAI hardware audio format.
   * @dai: DAI
   * @fmt: SND_SOC_DAIFMT_* format value.
   *
   * Configures the DAI hardware format and clocking.
   */
  int snd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
  {

  	int ret = -ENOTSUPP;

  	if (dai->driver->ops &&
  	    dai->driver->ops->set_fmt)

  		ret = dai->driver->ops->set_fmt(dai, fmt);
  
  	return soc_dai_ret(dai, ret);

  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_set_fmt);
  
  /**
   * snd_soc_xlate_tdm_slot - generate tx/rx slot mask.
   * @slots: Number of slots in use.
   * @tx_mask: bitmask representing active TX slots.
   * @rx_mask: bitmask representing active RX slots.
   *
   * Generates the TDM tx and rx slot default masks for DAI.
   */
  static int snd_soc_xlate_tdm_slot_mask(unsigned int slots,
  				       unsigned int *tx_mask,
  				       unsigned int *rx_mask)
  {
  	if (*tx_mask || *rx_mask)
  		return 0;
  
  	if (!slots)
  		return -EINVAL;
  
  	*tx_mask = (1 << slots) - 1;
  	*rx_mask = (1 << slots) - 1;
  
  	return 0;
  }
  
  /**
   * snd_soc_dai_set_tdm_slot() - Configures a DAI for TDM operation
   * @dai: The DAI to configure
   * @tx_mask: bitmask representing active TX slots.
   * @rx_mask: bitmask representing active RX slots.
   * @slots: Number of slots in use.
   * @slot_width: Width in bits for each slot.
   *
   * This function configures the specified DAI for TDM operation. @slot contains
   * the total number of slots of the TDM stream and @slot_with the width of each
   * slot in bit clock cycles. @tx_mask and @rx_mask are bitmasks specifying the
   * active slots of the TDM stream for the specified DAI, i.e. which slots the
   * DAI should write to or read from. If a bit is set the corresponding slot is
   * active, if a bit is cleared the corresponding slot is inactive. Bit 0 maps to
   * the first slot, bit 1 to the second slot and so on. The first active slot
   * maps to the first channel of the DAI, the second active slot to the second
   * channel and so on.
   *
   * TDM mode can be disabled by passing 0 for @slots. In this case @tx_mask,
   * @rx_mask and @slot_width will be ignored.
   *
   * Returns 0 on success, a negative error code otherwise.
   */
  int snd_soc_dai_set_tdm_slot(struct snd_soc_dai *dai,
  			     unsigned int tx_mask, unsigned int rx_mask,
  			     int slots, int slot_width)
  {

  	int ret = -ENOTSUPP;

  	if (dai->driver->ops &&
  	    dai->driver->ops->xlate_tdm_slot_mask)

  		dai->driver->ops->xlate_tdm_slot_mask(slots,
  						      &tx_mask, &rx_mask);
  	else
  		snd_soc_xlate_tdm_slot_mask(slots, &tx_mask, &rx_mask);
  
  	dai->tx_mask = tx_mask;
  	dai->rx_mask = rx_mask;

  	if (dai->driver->ops &&
  	    dai->driver->ops->set_tdm_slot)

  		ret = dai->driver->ops->set_tdm_slot(dai, tx_mask, rx_mask,

  						      slots, slot_width);

  	return soc_dai_ret(dai, ret);

  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_set_tdm_slot);
  
  /**
   * snd_soc_dai_set_channel_map - configure DAI audio channel map
   * @dai: DAI
   * @tx_num: how many TX channels
   * @tx_slot: pointer to an array which imply the TX slot number channel
   *           0~num-1 uses
   * @rx_num: how many RX channels
   * @rx_slot: pointer to an array which imply the RX slot number channel
   *           0~num-1 uses
   *
   * configure the relationship between channel number and TDM slot number.
   */
  int snd_soc_dai_set_channel_map(struct snd_soc_dai *dai,
  				unsigned int tx_num, unsigned int *tx_slot,
  				unsigned int rx_num, unsigned int *rx_slot)
  {

  	int ret = -ENOTSUPP;

  	if (dai->driver->ops &&
  	    dai->driver->ops->set_channel_map)

  		ret = dai->driver->ops->set_channel_map(dai, tx_num, tx_slot,
  							rx_num, rx_slot);
  	return soc_dai_ret(dai, ret);

  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_set_channel_map);
  
  /**
   * snd_soc_dai_get_channel_map - Get DAI audio channel map
   * @dai: DAI
   * @tx_num: how many TX channels
   * @tx_slot: pointer to an array which imply the TX slot number channel
   *           0~num-1 uses
   * @rx_num: how many RX channels
   * @rx_slot: pointer to an array which imply the RX slot number channel
   *           0~num-1 uses
   */
  int snd_soc_dai_get_channel_map(struct snd_soc_dai *dai,
  				unsigned int *tx_num, unsigned int *tx_slot,
  				unsigned int *rx_num, unsigned int *rx_slot)
  {

  	int ret = -ENOTSUPP;

  	if (dai->driver->ops &&
  	    dai->driver->ops->get_channel_map)

  		ret = dai->driver->ops->get_channel_map(dai, tx_num, tx_slot,
  							rx_num, rx_slot);
  	return soc_dai_ret(dai, ret);

  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_get_channel_map);
  
  /**
   * snd_soc_dai_set_tristate - configure DAI system or master clock.
   * @dai: DAI
   * @tristate: tristate enable
   *
   * Tristates the DAI so that others can use it.
   */
  int snd_soc_dai_set_tristate(struct snd_soc_dai *dai, int tristate)
  {

  	int ret = -EINVAL;

  	if (dai->driver->ops &&
  	    dai->driver->ops->set_tristate)

  		ret = dai->driver->ops->set_tristate(dai, tristate);
  
  	return soc_dai_ret(dai, ret);

  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_set_tristate);
  
  /**
   * snd_soc_dai_digital_mute - configure DAI system or master clock.
   * @dai: DAI
   * @mute: mute enable
   * @direction: stream to mute
   *
   * Mutes the DAI DAC.
   */
  int snd_soc_dai_digital_mute(struct snd_soc_dai *dai, int mute,
  			     int direction)
  {

  	int ret = -ENOTSUPP;

  	/*
  	 * ignore if direction was CAPTURE
  	 * and it had .no_capture_mute flag
  	 */

  	if (dai->driver->ops &&

  	    dai->driver->ops->mute_stream &&
  	    (direction == SNDRV_PCM_STREAM_PLAYBACK ||
  	     !dai->driver->ops->no_capture_mute))

  		ret = dai->driver->ops->mute_stream(dai, mute, direction);

  
  	return soc_dai_ret(dai, ret);

  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_digital_mute);

  
  int snd_soc_dai_hw_params(struct snd_soc_dai *dai,
  			  struct snd_pcm_substream *substream,
  			  struct snd_pcm_hw_params *params)
  {

  	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);

  	int ret = 0;

  
  	/* perform any topology hw_params fixups before DAI  */

  	ret = snd_soc_link_be_hw_params_fixup(rtd, params);
  	if (ret < 0)
  		goto end;

  	if (dai->driver->ops &&
  	    dai->driver->ops->hw_params)

  		ret = dai->driver->ops->hw_params(substream, params, dai);

  end:
  	return soc_dai_ret(dai, ret);

  }

  
  void snd_soc_dai_hw_free(struct snd_soc_dai *dai,
  			 struct snd_pcm_substream *substream)
  {

  	if (dai->driver->ops &&
  	    dai->driver->ops->hw_free)

  		dai->driver->ops->hw_free(substream, dai);
  }

  
  int snd_soc_dai_startup(struct snd_soc_dai *dai,
  			struct snd_pcm_substream *substream)
  {
  	int ret = 0;

  	if (dai->driver->ops &&
  	    dai->driver->ops->startup)

  		ret = dai->driver->ops->startup(substream, dai);

  	/* mark substream if succeeded */
  	if (ret == 0)
  		soc_dai_mark_push(dai, substream, startup);

  	return soc_dai_ret(dai, ret);

  }

  
  void snd_soc_dai_shutdown(struct snd_soc_dai *dai,

  			  struct snd_pcm_substream *substream,
  			  int rollback)

  {

  	if (rollback && !soc_dai_mark_match(dai, substream, startup))
  		return;

  	if (dai->driver->ops &&
  	    dai->driver->ops->shutdown)

  		dai->driver->ops->shutdown(substream, dai);

  
  	/* remove marked substream */
  	soc_dai_mark_pop(dai, substream, startup);

  }

  snd_pcm_sframes_t snd_soc_dai_delay(struct snd_soc_dai *dai,
  				    struct snd_pcm_substream *substream)
  {
  	int delay = 0;

  	if (dai->driver->ops &&
  	    dai->driver->ops->delay)

  		delay = dai->driver->ops->delay(substream, dai);
  
  	return delay;
  }

  int snd_soc_dai_compress_new(struct snd_soc_dai *dai,
  			     struct snd_soc_pcm_runtime *rtd, int num)
  {

  	int ret = -ENOTSUPP;

  	if (dai->driver->compress_new)

  		ret = dai->driver->compress_new(rtd, num);
  	return soc_dai_ret(dai, ret);

  }

  
  /*
   * snd_soc_dai_stream_valid() - check if a DAI supports the given stream
   *
   * Returns true if the DAI supports the indicated stream type.
   */
  bool snd_soc_dai_stream_valid(struct snd_soc_dai *dai, int dir)
  {

  	struct snd_soc_pcm_stream *stream = snd_soc_dai_get_pcm_stream(dai, dir);

  
  	/* If the codec specifies any channels at all, it supports the stream */
  	return stream->channels_min;
  }

  /*
   * snd_soc_dai_link_set_capabilities() - set dai_link properties based on its DAIs
   */
  void snd_soc_dai_link_set_capabilities(struct snd_soc_dai_link *dai_link)
  {
  	struct snd_soc_dai_link_component *cpu;
  	struct snd_soc_dai_link_component *codec;
  	struct snd_soc_dai *dai;
  	bool supported[SNDRV_PCM_STREAM_LAST + 1];

  	bool supported_cpu;
  	bool supported_codec;

  	int direction;
  	int i;
  
  	for_each_pcm_streams(direction) {

  		supported_cpu = false;
  		supported_codec = false;

  
  		for_each_link_cpus(dai_link, i, cpu) {

  			dai = snd_soc_find_dai_with_mutex(cpu);

  			if (dai && snd_soc_dai_stream_valid(dai, direction)) {
  				supported_cpu = true;

  				break;
  			}
  		}

  		for_each_link_codecs(dai_link, i, codec) {

  			dai = snd_soc_find_dai_with_mutex(codec);

  			if (dai && snd_soc_dai_stream_valid(dai, direction)) {
  				supported_codec = true;

  				break;
  			}
  		}

  		supported[direction] = supported_cpu && supported_codec;

  	}
  
  	dai_link->dpcm_playback = supported[SNDRV_PCM_STREAM_PLAYBACK];
  	dai_link->dpcm_capture  = supported[SNDRV_PCM_STREAM_CAPTURE];
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_link_set_capabilities);

  void snd_soc_dai_action(struct snd_soc_dai *dai,
  			int stream, int action)
  {

  	/* see snd_soc_dai_stream_active() */

  	dai->stream_active[stream]	+= action;

  	/* see snd_soc_component_active() */

  	dai->component->active		+= action;
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_action);

  int snd_soc_dai_active(struct snd_soc_dai *dai)
  {
  	int stream, active;
  
  	active = 0;
  	for_each_pcm_streams(stream)
  		active += dai->stream_active[stream];
  
  	return active;
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_active);

  int snd_soc_pcm_dai_probe(struct snd_soc_pcm_runtime *rtd, int order)
  {
  	struct snd_soc_dai *dai;
  	int i;
  
  	for_each_rtd_dais(rtd, i, dai) {
  		if (dai->driver->probe_order != order)
  			continue;
  
  		if (dai->driver->probe) {
  			int ret = dai->driver->probe(dai);
  
  			if (ret < 0)
  				return soc_dai_ret(dai, ret);
  		}
  
  		dai->probed = 1;
  	}
  
  	return 0;
  }

  int snd_soc_pcm_dai_remove(struct snd_soc_pcm_runtime *rtd, int order)
  {
  	struct snd_soc_dai *dai;
  	int i, r, ret = 0;
  
  	for_each_rtd_dais(rtd, i, dai) {
  		if (dai->driver->remove_order != order)
  			continue;
  
  		if (dai->probed &&
  		    dai->driver->remove) {
  			r = dai->driver->remove(dai);
  			if (r < 0)
  				ret = r; /* use last error */
  		}
  
  		dai->probed = 0;
  	}
  
  	return ret;
  }

  int snd_soc_pcm_dai_new(struct snd_soc_pcm_runtime *rtd)
  {
  	struct snd_soc_dai *dai;
  	int i, ret = 0;
  
  	for_each_rtd_dais(rtd, i, dai) {
  		if (dai->driver->pcm_new) {
  			ret = dai->driver->pcm_new(rtd, dai);
  			if (ret < 0)
  				return soc_dai_ret(dai, ret);
  		}
  	}
  
  	return 0;
  }

  
  int snd_soc_pcm_dai_prepare(struct snd_pcm_substream *substream)
  {

  	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);

  	struct snd_soc_dai *dai;
  	int i, ret;
  
  	for_each_rtd_dais(rtd, i, dai) {
  		if (dai->driver->ops &&
  		    dai->driver->ops->prepare) {
  			ret = dai->driver->ops->prepare(substream, dai);
  			if (ret < 0)
  				return soc_dai_ret(dai, ret);
  		}
  	}
  
  	return 0;
  }

  
  int snd_soc_pcm_dai_trigger(struct snd_pcm_substream *substream,
  			    int cmd)
  {

  	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);

  	struct snd_soc_dai *dai;
  	int i, ret;
  
  	for_each_rtd_dais(rtd, i, dai) {
  		if (dai->driver->ops &&
  		    dai->driver->ops->trigger) {
  			ret = dai->driver->ops->trigger(substream, cmd, dai);
  			if (ret < 0)
  				return soc_dai_ret(dai, ret);
  		}
  	}
  
  	return 0;
  }

  
  int snd_soc_pcm_dai_bespoke_trigger(struct snd_pcm_substream *substream,
  				    int cmd)
  {

  	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);

  	struct snd_soc_dai *dai;
  	int i, ret;
  
  	for_each_rtd_dais(rtd, i, dai) {
  		if (dai->driver->ops &&
  		    dai->driver->ops->bespoke_trigger) {
  			ret = dai->driver->ops->bespoke_trigger(substream,
  								cmd, dai);
  			if (ret < 0)
  				return soc_dai_ret(dai, ret);
  		}
  	}
  
  	return 0;
  }

  
  int snd_soc_dai_compr_startup(struct snd_soc_dai *dai,
  			      struct snd_compr_stream *cstream)
  {
  	int ret = 0;
  
  	if (dai->driver->cops &&
  	    dai->driver->cops->startup)
  		ret = dai->driver->cops->startup(cstream, dai);
  
  	return soc_dai_ret(dai, ret);
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_compr_startup);

  
  void snd_soc_dai_compr_shutdown(struct snd_soc_dai *dai,
  				struct snd_compr_stream *cstream)
  {
  	if (dai->driver->cops &&
  	    dai->driver->cops->shutdown)
  		dai->driver->cops->shutdown(cstream, dai);
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_compr_shutdown);

  
  int snd_soc_dai_compr_trigger(struct snd_soc_dai *dai,
  			      struct snd_compr_stream *cstream, int cmd)
  {
  	int ret = 0;
  
  	if (dai->driver->cops &&
  	    dai->driver->cops->trigger)
  		ret = dai->driver->cops->trigger(cstream, cmd, dai);
  
  	return soc_dai_ret(dai, ret);
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_compr_trigger);

  
  int snd_soc_dai_compr_set_params(struct snd_soc_dai *dai,
  				 struct snd_compr_stream *cstream,
  				 struct snd_compr_params *params)
  {
  	int ret = 0;
  
  	if (dai->driver->cops &&
  	    dai->driver->cops->set_params)
  		ret = dai->driver->cops->set_params(cstream, params, dai);
  
  	return soc_dai_ret(dai, ret);
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_compr_set_params);

  
  int snd_soc_dai_compr_get_params(struct snd_soc_dai *dai,
  				 struct snd_compr_stream *cstream,
  				 struct snd_codec *params)
  {
  	int ret = 0;
  
  	if (dai->driver->cops &&
  	    dai->driver->cops->get_params)
  		ret = dai->driver->cops->get_params(cstream, params, dai);
  
  	return soc_dai_ret(dai, ret);
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_compr_get_params);

  
  int snd_soc_dai_compr_ack(struct snd_soc_dai *dai,
  			  struct snd_compr_stream *cstream,
  			  size_t bytes)
  {
  	int ret = 0;
  
  	if (dai->driver->cops &&
  	    dai->driver->cops->ack)
  		ret = dai->driver->cops->ack(cstream, bytes, dai);
  
  	return soc_dai_ret(dai, ret);
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_compr_ack);

  
  int snd_soc_dai_compr_pointer(struct snd_soc_dai *dai,
  			      struct snd_compr_stream *cstream,
  			      struct snd_compr_tstamp *tstamp)
  {
  	int ret = 0;
  
  	if (dai->driver->cops &&
  	    dai->driver->cops->pointer)
  		ret = dai->driver->cops->pointer(cstream, tstamp, dai);
  
  	return soc_dai_ret(dai, ret);
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_compr_pointer);

  
  int snd_soc_dai_compr_set_metadata(struct snd_soc_dai *dai,
  				   struct snd_compr_stream *cstream,
  				   struct snd_compr_metadata *metadata)
  {
  	int ret = 0;
  
  	if (dai->driver->cops &&
  	    dai->driver->cops->set_metadata)
  		ret = dai->driver->cops->set_metadata(cstream, metadata, dai);
  
  	return soc_dai_ret(dai, ret);
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_compr_set_metadata);

  
  int snd_soc_dai_compr_get_metadata(struct snd_soc_dai *dai,
  				   struct snd_compr_stream *cstream,
  				   struct snd_compr_metadata *metadata)
  {
  	int ret = 0;
  
  	if (dai->driver->cops &&
  	    dai->driver->cops->get_metadata)
  		ret = dai->driver->cops->get_metadata(cstream, metadata, dai);
  
  	return soc_dai_ret(dai, ret);
  }
  EXPORT_SYMBOL_GPL(snd_soc_dai_compr_get_metadata);