forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
762 lines
19 KiB
762 lines
19 KiB
// SPDX-License-Identifier: GPL-2.0 |
|
// |
|
// soc-dai.c |
|
// |
|
// Copyright (C) 2019 Renesas Electronics Corp. |
|
// Kuninori Morimoto <[email protected]> |
|
// |
|
|
|
#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\n", |
|
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); |
|
|
|
/* mark substream if succeeded */ |
|
if (ret == 0) |
|
soc_dai_mark_push(dai, substream, hw_params); |
|
end: |
|
return soc_dai_ret(dai, ret); |
|
} |
|
|
|
void snd_soc_dai_hw_free(struct snd_soc_dai *dai, |
|
struct snd_pcm_substream *substream, |
|
int rollback) |
|
{ |
|
if (rollback && !soc_dai_mark_match(dai, substream, hw_params)) |
|
return; |
|
|
|
if (dai->driver->ops && |
|
dai->driver->ops->hw_free) |
|
dai->driver->ops->hw_free(substream, dai); |
|
|
|
/* remove marked substream */ |
|
soc_dai_mark_pop(dai, substream, hw_params); |
|
} |
|
|
|
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; |
|
} |
|
|
|
static int soc_dai_trigger(struct snd_soc_dai *dai, |
|
struct snd_pcm_substream *substream, int cmd) |
|
{ |
|
int ret = 0; |
|
|
|
if (dai->driver->ops && |
|
dai->driver->ops->trigger) |
|
ret = dai->driver->ops->trigger(substream, cmd, dai); |
|
|
|
return soc_dai_ret(dai, ret); |
|
} |
|
|
|
int snd_soc_pcm_dai_trigger(struct snd_pcm_substream *substream, |
|
int cmd, int rollback) |
|
{ |
|
struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); |
|
struct snd_soc_dai *dai; |
|
int i, r, ret = 0; |
|
|
|
switch (cmd) { |
|
case SNDRV_PCM_TRIGGER_START: |
|
case SNDRV_PCM_TRIGGER_RESUME: |
|
case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: |
|
for_each_rtd_dais(rtd, i, dai) { |
|
ret = soc_dai_trigger(dai, substream, cmd); |
|
if (ret < 0) |
|
break; |
|
soc_dai_mark_push(dai, substream, trigger); |
|
} |
|
break; |
|
case SNDRV_PCM_TRIGGER_STOP: |
|
case SNDRV_PCM_TRIGGER_SUSPEND: |
|
case SNDRV_PCM_TRIGGER_PAUSE_PUSH: |
|
for_each_rtd_dais(rtd, i, dai) { |
|
if (rollback && !soc_dai_mark_match(dai, substream, trigger)) |
|
continue; |
|
|
|
r = soc_dai_trigger(dai, substream, cmd); |
|
if (r < 0) |
|
ret = r; /* use last ret */ |
|
soc_dai_mark_pop(dai, substream, trigger); |
|
} |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
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); |
|
|
|
/* mark cstream if succeeded */ |
|
if (ret == 0) |
|
soc_dai_mark_push(dai, cstream, compr_startup); |
|
|
|
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, |
|
int rollback) |
|
{ |
|
if (rollback && !soc_dai_mark_match(dai, cstream, compr_startup)) |
|
return; |
|
|
|
if (dai->driver->cops && |
|
dai->driver->cops->shutdown) |
|
dai->driver->cops->shutdown(cstream, dai); |
|
|
|
/* remove marked cstream */ |
|
soc_dai_mark_pop(dai, cstream, compr_startup); |
|
} |
|
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);
|
|
|