#include <linux/debugfs.h>
#include <linux/module.h>
#include <linux/pm_runtime.h>
#include <sound/soc.h>
#include <linux/bitops.h>
#include "soc-internal.h"
#define soc_component_ret(dai, ret) _soc_component_ret(dai, __func__, ret)
static inline int _soc_component_ret(struct snd_soc_component *component, const char *func, int ret)
{
return snd_soc_ret(component->dev, ret,
"at %s() on %s\n", func, component->name);
}
#define soc_component_ret_reg_rw(dai, ret, reg) _soc_component_ret_reg_rw(dai, __func__, ret, reg)
static inline int _soc_component_ret_reg_rw(struct snd_soc_component *component,
const char *func, int ret, int reg)
{
return snd_soc_ret(component->dev, ret,
"at %s() on %s for register: [0x%08x]\n",
func, component->name, reg);
}
static LIST_HEAD(component_list);
struct list_head *snd_soc_component_get_list_head(void)
{
return &component_list;
}
const char *snd_soc_component_name(struct snd_soc_component *component)
{
return component->name;
}
EXPORT_SYMBOL_GPL(snd_soc_component_name);
void snd_soc_component_set_priv(struct snd_soc_component *component, void *priv)
{
component->priv = priv;
}
EXPORT_SYMBOL_GPL(snd_soc_component_set_priv);
void *snd_soc_component_to_priv(struct snd_soc_component *component)
{
return component->priv;
}
EXPORT_SYMBOL_GPL(snd_soc_component_to_priv);
struct snd_soc_dapm_context *snd_soc_component_to_dapm(struct snd_soc_component *component)
{
return component->dapm;
}
EXPORT_SYMBOL_GPL(snd_soc_component_to_dapm);
unsigned int snd_soc_component_active(struct snd_soc_component *component)
{
return component->active;
}
EXPORT_SYMBOL_GPL(snd_soc_component_active);
#define soc_component_mark_push(component, substream, tgt) ((component)->mark_##tgt = substream)
#define soc_component_mark_pop(component, tgt) ((component)->mark_##tgt = NULL)
#define soc_component_mark_match(component, substream, tgt) ((component)->mark_##tgt == substream)
void snd_soc_component_set_aux(struct snd_soc_component *component,
struct snd_soc_aux_dev *aux)
{
component->init = (aux) ? aux->init : NULL;
}
int snd_soc_component_init(struct snd_soc_component *component)
{
int ret = 0;
if (component->init)
ret = component->init(component);
return soc_component_ret(component, ret);
}
int snd_soc_component_set_sysclk(struct snd_soc_component *component,
int clk_id, int source, unsigned int freq,
int dir)
{
int ret = -ENOTSUPP;
if (component->driver->set_sysclk)
ret = component->driver->set_sysclk(component, clk_id, source,
freq, dir);
return soc_component_ret(component, ret);
}
EXPORT_SYMBOL_GPL(snd_soc_component_set_sysclk);
int snd_soc_component_set_pll(struct snd_soc_component *component, int pll_id,
int source, unsigned int freq_in,
unsigned int freq_out)
{
int ret = -EINVAL;
if (component->driver->set_pll)
ret = component->driver->set_pll(component, pll_id, source,
freq_in, freq_out);
return soc_component_ret(component, ret);
}
EXPORT_SYMBOL_GPL(snd_soc_component_set_pll);
void snd_soc_component_seq_notifier(struct snd_soc_component *component,
enum snd_soc_dapm_type type, int subseq)
{
if (component->driver->seq_notifier)
component->driver->seq_notifier(component, type, subseq);
}
int snd_soc_component_stream_event(struct snd_soc_component *component,
int event)
{
int ret = 0;
if (component->driver->stream_event)
ret = component->driver->stream_event(component, event);
return soc_component_ret(component, ret);
}
int snd_soc_component_set_bias_level(struct snd_soc_component *component,
enum snd_soc_bias_level level)
{
int ret = 0;
if (component->driver->set_bias_level)
ret = component->driver->set_bias_level(component, level);
return soc_component_ret(component, ret);
}
static void soc_get_kcontrol_name(struct snd_soc_component *component,
char *buf, int size, const char * const ctl)
{
if (component->name_prefix)
snprintf(buf, size, "%s %s", component->name_prefix, ctl);
else
snprintf(buf, size, "%s", ctl);
}
struct snd_kcontrol *snd_soc_component_get_kcontrol(struct snd_soc_component *component,
const char * const ctl)
{
char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
soc_get_kcontrol_name(component, name, ARRAY_SIZE(name), ctl);
return snd_soc_card_get_kcontrol(component->card, name);
}
EXPORT_SYMBOL_GPL(snd_soc_component_get_kcontrol);
int snd_soc_component_notify_control(struct snd_soc_component *component,
const char * const ctl)
{
struct snd_kcontrol *kctl;
kctl = snd_soc_component_get_kcontrol(component, ctl);
if (!kctl)
return soc_component_ret(component, -EINVAL);
snd_ctl_notify(component->card->snd_card,
SNDRV_CTL_EVENT_MASK_VALUE, &kctl->id);
return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_component_notify_control);
int snd_soc_component_set_jack(struct snd_soc_component *component,
struct snd_soc_jack *jack, void *data)
{
int ret = -ENOTSUPP;
if (component->driver->set_jack)
ret = component->driver->set_jack(component, jack, data);
return soc_component_ret(component, ret);
}
EXPORT_SYMBOL_GPL(snd_soc_component_set_jack);
int snd_soc_component_get_jack_type(
struct snd_soc_component *component)
{
int ret = -ENOTSUPP;
if (component->driver->get_jack_type)
ret = component->driver->get_jack_type(component);
return soc_component_ret(component, ret);
}
EXPORT_SYMBOL_GPL(snd_soc_component_get_jack_type);
int snd_soc_component_module_get(struct snd_soc_component *component,
void *mark, int upon_open)
{
int ret = 0;
if (component->driver->module_get_upon_open == !!upon_open &&
!try_module_get(component->dev->driver->owner))
ret = -ENODEV;
if (ret == 0)
soc_component_mark_push(component, mark, module);
return soc_component_ret(component, ret);
}
void snd_soc_component_module_put(struct snd_soc_component *component,
void *mark, int upon_open, int rollback)
{
if (rollback && !soc_component_mark_match(component, mark, module))
return;
if (component->driver->module_get_upon_open == !!upon_open)
module_put(component->dev->driver->owner);
soc_component_mark_pop(component, module);
}
int snd_soc_component_open(struct snd_soc_component *component,
struct snd_pcm_substream *substream)
{
int ret = 0;
if (component->driver->open)
ret = component->driver->open(component, substream);
if (ret == 0)
soc_component_mark_push(component, substream, open);
return soc_component_ret(component, ret);
}
int snd_soc_component_close(struct snd_soc_component *component,
struct snd_pcm_substream *substream,
int rollback)
{
int ret = 0;
if (rollback && !soc_component_mark_match(component, substream, open))
return 0;
if (component->driver->close)
ret = component->driver->close(component, substream);
soc_component_mark_pop(component, open);
return soc_component_ret(component, ret);
}
void snd_soc_component_suspend(struct snd_soc_component *component)
{
if (component->driver->suspend)
component->driver->suspend(component);
component->suspended = 1;
}
void snd_soc_component_resume(struct snd_soc_component *component)
{
int ret;
if (component->driver->resume) {
ret = component->driver->resume(component);
soc_component_ret(component, ret);
}
component->suspended = 0;
}
int snd_soc_component_is_suspended(struct snd_soc_component *component)
{
return component->suspended;
}
int snd_soc_component_add_controls(struct snd_soc_component *component,
const struct snd_kcontrol_new *controls,
unsigned int num_controls)
{
struct snd_card *card = component->card->snd_card;
return snd_soc_add_controls(card, component->dev, controls,
num_controls, component->name_prefix, component);
}
EXPORT_SYMBOL_GPL(snd_soc_component_add_controls);
int snd_soc_component_fixup_controls(struct snd_soc_component *component)
{
int ret = 0;
if (component->driver->fixup_controls)
ret = component->driver->fixup_controls(component);
return soc_component_ret(component, ret);
}
int snd_soc_component_of_xlate_dai_id(struct snd_soc_component *component,
struct device_node *ep)
{
int ret = -ENOTSUPP;
if (component->driver->of_xlate_dai_id)
ret = component->driver->of_xlate_dai_id(component, ep);
return soc_component_ret(component, ret);
}
int snd_soc_component_of_xlate_dai_name(struct snd_soc_component *component,
const struct of_phandle_args *args,
const char **dai_name)
{
if (component->driver->of_xlate_dai_name)
return component->driver->of_xlate_dai_name(component,
args, dai_name);
return -ENOTSUPP;
}
int snd_soc_component_regmap_val_bytes(struct snd_soc_component *component)
{
int val_bytes;
if (!component->regmap)
return 0;
val_bytes = regmap_get_val_bytes(component->regmap);
if (val_bytes < 0)
return 0;
return val_bytes;
}
EXPORT_SYMBOL_GPL(snd_soc_component_regmap_val_bytes);
int snd_soc_component_regmap_cache_sync(struct snd_soc_component *component)
{
if (!component->regmap)
return 0;
return regcache_sync(component->regmap);
}
EXPORT_SYMBOL_GPL(snd_soc_component_regmap_cache_sync);
void snd_soc_component_regmap_async_complete(struct snd_soc_component *component)
{
if (component->regmap)
regmap_async_complete(component->regmap);
}
EXPORT_SYMBOL_GPL(snd_soc_component_regmap_async_complete);
#ifdef CONFIG_REGMAP
void snd_soc_component_init_regmap(struct snd_soc_component *component,
struct regmap *regmap)
{
component->regmap = regmap;
}
EXPORT_SYMBOL_GPL(snd_soc_component_init_regmap);
void snd_soc_component_exit_regmap(struct snd_soc_component *component)
{
regmap_exit(component->regmap);
component->regmap = NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_component_exit_regmap);
#endif
int snd_soc_component_compr_open(struct snd_soc_component *component,
struct snd_compr_stream *cstream)
{
int ret = 0;
if (component->driver->compress_ops &&
component->driver->compress_ops->open)
ret = component->driver->compress_ops->open(component, cstream);
if (ret == 0)
soc_component_mark_push(component, cstream, compr_open);
return soc_component_ret(component, ret);
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_open);
void snd_soc_component_compr_free(struct snd_soc_component *component,
struct snd_compr_stream *cstream,
int rollback)
{
if (rollback && !soc_component_mark_match(component, cstream, compr_open))
return;
if (component->driver->compress_ops &&
component->driver->compress_ops->free)
component->driver->compress_ops->free(component, cstream);
soc_component_mark_pop(component, compr_open);
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_free);
int snd_soc_component_compr_trigger(struct snd_compr_stream *cstream, int cmd)
{
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct snd_soc_component *component;
int i, ret;
for_each_rtd_components(rtd, i, component) {
if (component->driver->compress_ops &&
component->driver->compress_ops->trigger) {
ret = component->driver->compress_ops->trigger(
component, cstream, cmd);
if (ret < 0)
return soc_component_ret(component, ret);
}
}
return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_trigger);
int snd_soc_component_compr_set_params(struct snd_compr_stream *cstream,
struct snd_compr_params *params)
{
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct snd_soc_component *component;
int i, ret;
for_each_rtd_components(rtd, i, component) {
if (component->driver->compress_ops &&
component->driver->compress_ops->set_params) {
ret = component->driver->compress_ops->set_params(
component, cstream, params);
if (ret < 0)
return soc_component_ret(component, ret);
}
}
return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_set_params);
int snd_soc_component_compr_get_params(struct snd_compr_stream *cstream,
struct snd_codec *params)
{
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct snd_soc_component *component;
int i, ret;
for_each_rtd_components(rtd, i, component) {
if (component->driver->compress_ops &&
component->driver->compress_ops->get_params) {
ret = component->driver->compress_ops->get_params(
component, cstream, params);
return soc_component_ret(component, ret);
}
}
return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_params);
int snd_soc_component_compr_get_caps(struct snd_compr_stream *cstream,
struct snd_compr_caps *caps)
{
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct snd_soc_component *component;
int i, ret = 0;
snd_soc_dpcm_mutex_lock(rtd);
for_each_rtd_components(rtd, i, component) {
if (component->driver->compress_ops &&
component->driver->compress_ops->get_caps) {
ret = component->driver->compress_ops->get_caps(
component, cstream, caps);
break;
}
}
snd_soc_dpcm_mutex_unlock(rtd);
return soc_component_ret(component, ret);
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_caps);
int snd_soc_component_compr_get_codec_caps(struct snd_compr_stream *cstream,
struct snd_compr_codec_caps *codec)
{
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct snd_soc_component *component;
int i, ret = 0;
snd_soc_dpcm_mutex_lock(rtd);
for_each_rtd_components(rtd, i, component) {
if (component->driver->compress_ops &&
component->driver->compress_ops->get_codec_caps) {
ret = component->driver->compress_ops->get_codec_caps(
component, cstream, codec);
break;
}
}
snd_soc_dpcm_mutex_unlock(rtd);
return soc_component_ret(component, ret);
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_codec_caps);
int snd_soc_component_compr_ack(struct snd_compr_stream *cstream, size_t bytes)
{
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct snd_soc_component *component;
int i, ret;
for_each_rtd_components(rtd, i, component) {
if (component->driver->compress_ops &&
component->driver->compress_ops->ack) {
ret = component->driver->compress_ops->ack(
component, cstream, bytes);
if (ret < 0)
return soc_component_ret(component, ret);
}
}
return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_ack);
int snd_soc_component_compr_pointer(struct snd_compr_stream *cstream,
struct snd_compr_tstamp64 *tstamp)
{
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct snd_soc_component *component;
int i, ret;
for_each_rtd_components(rtd, i, component) {
if (component->driver->compress_ops &&
component->driver->compress_ops->pointer) {
ret = component->driver->compress_ops->pointer(
component, cstream, tstamp);
return soc_component_ret(component, ret);
}
}
return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_pointer);
int snd_soc_component_compr_copy(struct snd_compr_stream *cstream,
char __user *buf, size_t count)
{
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct snd_soc_component *component;
int i, ret = 0;
snd_soc_dpcm_mutex_lock(rtd);
for_each_rtd_components(rtd, i, component) {
if (component->driver->compress_ops &&
component->driver->compress_ops->copy) {
ret = component->driver->compress_ops->copy(
component, cstream, buf, count);
break;
}
}
snd_soc_dpcm_mutex_unlock(rtd);
return soc_component_ret(component, ret);
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_copy);
int snd_soc_component_compr_set_metadata(struct snd_compr_stream *cstream,
struct snd_compr_metadata *metadata)
{
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct snd_soc_component *component;
int i, ret;
for_each_rtd_components(rtd, i, component) {
if (component->driver->compress_ops &&
component->driver->compress_ops->set_metadata) {
ret = component->driver->compress_ops->set_metadata(
component, cstream, metadata);
if (ret < 0)
return soc_component_ret(component, ret);
}
}
return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_set_metadata);
int snd_soc_component_compr_get_metadata(struct snd_compr_stream *cstream,
struct snd_compr_metadata *metadata)
{
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct snd_soc_component *component;
int i, ret;
for_each_rtd_components(rtd, i, component) {
if (component->driver->compress_ops &&
component->driver->compress_ops->get_metadata) {
ret = component->driver->compress_ops->get_metadata(
component, cstream, metadata);
return soc_component_ret(component, ret);
}
}
return 0;
}
EXPORT_SYMBOL_GPL(snd_soc_component_compr_get_metadata);
static unsigned int soc_component_read_no_lock(
struct snd_soc_component *component,
unsigned int reg)
{
int ret;
unsigned int val = 0;
if (component->regmap)
ret = regmap_read(component->regmap, reg, &val);
else if (component->driver->read) {
ret = 0;
val = component->driver->read(component, reg);
}
else
ret = -EIO;
if (ret < 0)
return soc_component_ret_reg_rw(component, ret, reg);
return val;
}
unsigned int snd_soc_component_read(struct snd_soc_component *component,
unsigned int reg)
{
unsigned int val;
mutex_lock(&component->io_mutex);
val = soc_component_read_no_lock(component, reg);
mutex_unlock(&component->io_mutex);
return val;
}
EXPORT_SYMBOL_GPL(snd_soc_component_read);
static int soc_component_write_no_lock(
struct snd_soc_component *component,
unsigned int reg, unsigned int val)
{
int ret = -EIO;
if (component->regmap)
ret = regmap_write(component->regmap, reg, val);
else if (component->driver->write)
ret = component->driver->write(component, reg, val);
return soc_component_ret_reg_rw(component, ret, reg);
}
int snd_soc_component_write(struct snd_soc_component *component,
unsigned int reg, unsigned int val)
{
int ret;
mutex_lock(&component->io_mutex);
ret = soc_component_write_no_lock(component, reg, val);
mutex_unlock(&component->io_mutex);
return ret;
}
EXPORT_SYMBOL_GPL(snd_soc_component_write);
static int snd_soc_component_update_bits_legacy(
struct snd_soc_component *component, unsigned int reg,
unsigned int mask, unsigned int val, bool *change)
{
unsigned int old, new;
int ret = 0;
mutex_lock(&component->io_mutex);
old = soc_component_read_no_lock(component, reg);
new = (old & ~mask) | (val & mask);
*change = old != new;
if (*change)
ret = soc_component_write_no_lock(component, reg, new);
mutex_unlock(&component->io_mutex);
return soc_component_ret_reg_rw(component, ret, reg);
}
int snd_soc_component_update_bits(struct snd_soc_component *component,
unsigned int reg, unsigned int mask, unsigned int val)
{
bool change;
int ret;
if (component->regmap)
ret = regmap_update_bits_check(component->regmap, reg, mask,
val, &change);
else
ret = snd_soc_component_update_bits_legacy(component, reg,
mask, val, &change);
if (ret < 0)
return soc_component_ret_reg_rw(component, ret, reg);
return change;
}
EXPORT_SYMBOL_GPL(snd_soc_component_update_bits);
int snd_soc_component_update_bits_async(struct snd_soc_component *component,
unsigned int reg, unsigned int mask, unsigned int val)
{
bool change;
int ret;
if (component->regmap)
ret = regmap_update_bits_check_async(component->regmap, reg,
mask, val, &change);
else
ret = snd_soc_component_update_bits_legacy(component, reg,
mask, val, &change);
if (ret < 0)
return soc_component_ret_reg_rw(component, ret, reg);
return change;
}
EXPORT_SYMBOL_GPL(snd_soc_component_update_bits_async);
static inline int soc_component_field_shift(struct snd_soc_component *component,
unsigned int mask)
{
if (!mask) {
dev_err(component->dev, "ASoC: error field mask is zero for %s\n",
component->name);
return 0;
}
return (ffs(mask) - 1);
}
unsigned int snd_soc_component_read_field(struct snd_soc_component *component,
unsigned int reg, unsigned int mask)
{
unsigned int val;
val = snd_soc_component_read(component, reg);
val = (val & mask) >> soc_component_field_shift(component, mask);
return val;
}
EXPORT_SYMBOL_GPL(snd_soc_component_read_field);
int snd_soc_component_write_field(struct snd_soc_component *component,
unsigned int reg, unsigned int mask,
unsigned int val)
{
val = (val << soc_component_field_shift(component, mask)) & mask;
return snd_soc_component_update_bits(component, reg, mask, val);
}
EXPORT_SYMBOL_GPL(snd_soc_component_write_field);
int snd_soc_component_test_bits(struct snd_soc_component *component,
unsigned int reg, unsigned int mask, unsigned int value)
{
unsigned int old, new;
old = snd_soc_component_read(component, reg);
new = (old & ~mask) | value;
return old != new;
}
EXPORT_SYMBOL_GPL(snd_soc_component_test_bits);
snd_pcm_uframes_t snd_soc_pcm_component_pointer(struct snd_pcm_substream *substream)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
int i;
for_each_rtd_components(rtd, i, component)
if (component->driver->pointer)
return component->driver->pointer(component, substream);
return 0;
}
static bool snd_soc_component_is_codec_on_rtd(struct snd_soc_pcm_runtime *rtd,
struct snd_soc_component *component)
{
struct snd_soc_dai *dai;
int i;
for_each_rtd_codec_dais(rtd, i, dai) {
if (dai->component == component)
return true;
}
return false;
}
void snd_soc_pcm_component_delay(struct snd_pcm_substream *substream,
snd_pcm_sframes_t *cpu_delay,
snd_pcm_sframes_t *codec_delay)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
snd_pcm_sframes_t delay;
int i;
for_each_rtd_components(rtd, i, component) {
if (!component->driver->delay)
continue;
delay = component->driver->delay(component, substream);
if (snd_soc_component_is_codec_on_rtd(rtd, component))
*codec_delay = max(*codec_delay, delay);
else
*cpu_delay = max(*cpu_delay, delay);
}
}
int snd_soc_pcm_component_ioctl(struct snd_pcm_substream *substream,
unsigned int cmd, void *arg)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
int i;
for_each_rtd_components(rtd, i, component)
if (component->driver->ioctl)
return soc_component_ret(
component,
component->driver->ioctl(component,
substream, cmd, arg));
return snd_pcm_lib_ioctl(substream, cmd, arg);
}
int snd_soc_pcm_component_sync_stop(struct snd_pcm_substream *substream)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
int i, ret;
for_each_rtd_components(rtd, i, component) {
if (component->driver->sync_stop) {
ret = component->driver->sync_stop(component,
substream);
if (ret < 0)
return soc_component_ret(component, ret);
}
}
return 0;
}
int snd_soc_pcm_component_copy(struct snd_pcm_substream *substream,
int channel, unsigned long pos,
struct iov_iter *iter, unsigned long bytes)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
int i;
for_each_rtd_components(rtd, i, component)
if (component->driver->copy)
return soc_component_ret(component,
component->driver->copy(component, substream,
channel, pos, iter, bytes));
return -EINVAL;
}
struct page *snd_soc_pcm_component_page(struct snd_pcm_substream *substream,
unsigned long offset)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
struct page *page;
int i;
for_each_rtd_components(rtd, i, component) {
if (component->driver->page) {
page = component->driver->page(component,
substream, offset);
if (page)
return page;
}
}
return NULL;
}
int snd_soc_pcm_component_mmap(struct snd_pcm_substream *substream,
struct vm_area_struct *vma)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
int i;
for_each_rtd_components(rtd, i, component)
if (component->driver->mmap)
return soc_component_ret(
component,
component->driver->mmap(component,
substream, vma));
return -EINVAL;
}
int snd_soc_pcm_component_new(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_component *component;
int ret;
int i;
for_each_rtd_components(rtd, i, component) {
if (component->driver->pcm_new) {
ret = component->driver->pcm_new(component, rtd);
if (ret < 0)
return soc_component_ret(component, ret);
}
}
return 0;
}
void snd_soc_pcm_component_free(struct snd_soc_pcm_runtime *rtd)
{
struct snd_soc_component *component;
int i;
if (!rtd->pcm)
return;
for_each_rtd_components(rtd, i, component)
if (component->driver->pcm_free)
component->driver->pcm_free(component, rtd->pcm);
}
int snd_soc_pcm_component_prepare(struct snd_pcm_substream *substream)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
int i, ret;
for_each_rtd_components(rtd, i, component) {
if (component->driver->prepare) {
ret = component->driver->prepare(component, substream);
if (ret < 0)
return soc_component_ret(component, ret);
}
}
return 0;
}
int snd_soc_pcm_component_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
int i, ret;
for_each_rtd_components(rtd, i, component) {
if (component->driver->hw_params) {
ret = component->driver->hw_params(component,
substream, params);
if (ret < 0)
return soc_component_ret(component, ret);
}
soc_component_mark_push(component, substream, hw_params);
}
return 0;
}
void snd_soc_pcm_component_hw_free(struct snd_pcm_substream *substream,
int rollback)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
int i, ret;
for_each_rtd_components(rtd, i, component) {
if (rollback && !soc_component_mark_match(component, substream, hw_params))
continue;
if (component->driver->hw_free) {
ret = component->driver->hw_free(component, substream);
if (ret < 0)
soc_component_ret(component, ret);
}
soc_component_mark_pop(component, hw_params);
}
}
static int soc_component_trigger(struct snd_soc_component *component,
struct snd_pcm_substream *substream,
int cmd)
{
int ret = 0;
if (component->driver->trigger)
ret = component->driver->trigger(component, substream, cmd);
return soc_component_ret(component, ret);
}
int snd_soc_pcm_component_trigger(struct snd_pcm_substream *substream,
int cmd, int rollback)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
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_components(rtd, i, component) {
ret = soc_component_trigger(component, substream, cmd);
if (ret < 0)
break;
soc_component_mark_push(component, substream, trigger);
}
break;
case SNDRV_PCM_TRIGGER_STOP:
case SNDRV_PCM_TRIGGER_SUSPEND:
case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
for_each_rtd_components(rtd, i, component) {
if (rollback && !soc_component_mark_match(component, substream, trigger))
continue;
r = soc_component_trigger(component, substream, cmd);
if (r < 0)
ret = r;
soc_component_mark_pop(component, trigger);
}
}
return ret;
}
int snd_soc_pcm_component_pm_runtime_get(struct snd_soc_pcm_runtime *rtd,
void *stream)
{
struct snd_soc_component *component;
int i;
for_each_rtd_components(rtd, i, component) {
int ret = pm_runtime_get_sync(component->dev);
if (ret < 0 && ret != -EACCES) {
pm_runtime_put_noidle(component->dev);
return soc_component_ret(component, ret);
}
soc_component_mark_push(component, stream, pm);
}
return 0;
}
void snd_soc_pcm_component_pm_runtime_put(struct snd_soc_pcm_runtime *rtd,
void *stream, int rollback)
{
struct snd_soc_component *component;
int i;
for_each_rtd_components(rtd, i, component) {
if (rollback && !soc_component_mark_match(component, stream, pm))
continue;
pm_runtime_put_autosuspend(component->dev);
soc_component_mark_pop(component, pm);
}
}
int snd_soc_pcm_component_ack(struct snd_pcm_substream *substream)
{
struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
struct snd_soc_component *component;
int i;
for_each_rtd_components(rtd, i, component)
if (component->driver->ack)
return component->driver->ack(component, substream);
return 0;
}
struct device_node *snd_soc_component_to_node(struct snd_soc_component *component)
{
struct device_node *of_node;
of_node = component->dev->of_node;
if (!of_node && component->dev->parent)
of_node = component->dev->parent->of_node;
return of_node;
}
bool snd_soc_component_matches_dlc(struct snd_soc_component *component,
const struct snd_soc_dai_link_component *dlc)
{
struct device_node *component_of_node;
if (!dlc)
return false;
if (dlc->dai_args) {
struct snd_soc_dai *dai;
for_each_component_dais(component, dai)
if (snd_soc_dai_matches_dlc(dai, dlc))
return true;
return false;
}
component_of_node = snd_soc_component_to_node(component);
if (dlc->of_node && component_of_node != dlc->of_node)
return false;
if (dlc->name && strcmp(component->name, dlc->name))
return false;
return true;
}
#ifdef CONFIG_DEBUG_FS
static void snd_soc_component_debugfs_init(struct snd_soc_component *component)
{
if (!component->card->debugfs_card_root)
return;
if (component->driver->debugfs_prefix) {
char *name;
name = kasprintf(GFP_KERNEL, "%s:%s",
component->driver->debugfs_prefix, component->name);
if (name) {
component->debugfs_root = debugfs_create_dir(name,
component->card->debugfs_card_root);
kfree(name);
}
} else {
component->debugfs_root = debugfs_create_dir(component->name,
component->card->debugfs_card_root);
}
snd_soc_dapm_debugfs_init(snd_soc_component_to_dapm(component),
component->debugfs_root);
}
static void snd_soc_component_debugfs_cleanup(struct snd_soc_component *component)
{
if (!component->debugfs_root)
return;
debugfs_remove_recursive(component->debugfs_root);
component->debugfs_root = NULL;
}
#else
static inline void snd_soc_component_debugfs_init(struct snd_soc_component *component) { }
static inline void snd_soc_component_debugfs_cleanup(struct snd_soc_component *component) { }
#endif /* CONFIG_DEBUG_FS */
static void snd_soc_component_set_name_prefix(struct snd_soc_component *component)
{
struct snd_soc_card *card = component->card;
struct device_node *of_node = snd_soc_component_to_node(component);
const char *str;
int ret, i;
for (i = 0; i < card->num_configs; i++) {
struct snd_soc_codec_conf *map = &card->codec_conf[i];
if (snd_soc_component_matches_dlc(component, &map->dlc) &&
map->name_prefix) {
component->name_prefix = map->name_prefix;
return;
}
}
ret = of_property_read_string(of_node, "sound-name-prefix", &str);
if (ret < 0)
return;
component->name_prefix = str;
}
void snd_soc_component_remove(struct snd_soc_component *component, int probed)
{
if (!component->card)
return;
if (probed && component->driver->remove)
component->driver->remove(component);
list_del_init(&component->card_list);
snd_soc_dapm_free(snd_soc_component_to_dapm(component));
snd_soc_component_debugfs_cleanup(component);
component->card = NULL;
snd_soc_component_module_put_when_remove(component);
}
int snd_soc_component_probe(struct snd_soc_component *component, struct snd_soc_card *card)
{
struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component);
struct snd_soc_dai *dai;
int probed = 0;
int ret;
if (snd_soc_component_is_dummy(component))
return 0;
if (component->card) {
if (component->card != card) {
dev_err(component->dev,
"Trying to bind component \"%s\" to card \"%s\" but is already bound to card \"%s\"\n",
component->name, card->name, component->card->name);
return -ENODEV;
}
return 0;
}
ret = snd_soc_component_module_get_when_probe(component);
if (ret < 0)
return ret;
component->card = card;
snd_soc_component_set_name_prefix(component);
snd_soc_component_debugfs_init(component);
snd_soc_dapm_init(dapm, card, component);
ret = snd_soc_dapm_new_controls(dapm,
component->driver->dapm_widgets,
component->driver->num_dapm_widgets);
if (ret != 0) {
dev_err(component->dev,
"Failed to create new controls %d\n", ret);
goto err_probe;
}
for_each_component_dais(component, dai) {
ret = snd_soc_dapm_new_dai_widgets(dapm, dai);
if (ret != 0) {
dev_err(component->dev,
"Failed to create DAI widgets %d\n", ret);
goto err_probe;
}
}
if (component->driver->probe) {
ret = component->driver->probe(component);
if (ret < 0)
goto err_probe;
}
WARN(!snd_soc_dapm_get_idle_bias(dapm) &&
snd_soc_dapm_get_bias_level(dapm) != SND_SOC_BIAS_OFF,
"codec %s can not start from non-off bias with idle_bias_off==1\n",
component->name);
probed = 1;
ret = snd_soc_component_init(component);
if (ret < 0)
goto err_probe;
ret = snd_soc_component_add_controls(component,
component->driver->controls,
component->driver->num_controls);
if (ret < 0)
goto err_probe;
ret = snd_soc_dapm_add_routes(dapm,
component->driver->dapm_routes,
component->driver->num_dapm_routes);
if (ret < 0)
goto err_probe;
list_add(&component->card_list, &card->component_dev_list);
err_probe:
if (ret < 0)
snd_soc_component_remove(component, probed);
return ret;
}
struct snd_soc_component
*snd_soc_component_lookup_nolock(struct device *dev, const char *driver_name)
{
struct snd_soc_component *component;
for_each_component(component) {
if (dev != component->dev)
continue;
if (!driver_name)
return component;
if (!component->driver->name)
continue;
if (component->driver->name == driver_name)
return component;
if (strcmp(component->driver->name, driver_name) == 0)
return component;
}
return NULL;
}
EXPORT_SYMBOL_GPL(snd_soc_component_lookup_nolock);
struct snd_soc_component *snd_soc_component_lookup(struct device *dev,
const char *driver_name)
{
guard(mutex)(&client_mutex);
return snd_soc_component_lookup_nolock(dev, driver_name);
}
EXPORT_SYMBOL_GPL(snd_soc_component_lookup);
struct snd_soc_component *snd_soc_component_lookup_by_name(const char *component_name)
{
struct snd_soc_component *component;
guard(mutex)(&client_mutex);
for_each_component(component)
if (strstr(component->name, component_name))
return component;
return NULL;
}
EXPORT_SYMBOL_GPL