mirror of
https://github.com/FEX-Emu/linux.git
synced 2024-12-23 01:40:30 +00:00
Merge remote-tracking branch 'asoc/topic/core' into asoc-next
This commit is contained in:
commit
c6016bdeab
@ -331,7 +331,6 @@ struct soc_enum;
|
||||
struct snd_soc_jack;
|
||||
struct snd_soc_jack_zone;
|
||||
struct snd_soc_jack_pin;
|
||||
struct snd_soc_cache_ops;
|
||||
#include <sound/soc-dapm.h>
|
||||
#include <sound/soc-dpcm.h>
|
||||
|
||||
@ -349,10 +348,6 @@ enum snd_soc_control_type {
|
||||
SND_SOC_REGMAP,
|
||||
};
|
||||
|
||||
enum snd_soc_compress_type {
|
||||
SND_SOC_FLAT_COMPRESSION = 1,
|
||||
};
|
||||
|
||||
enum snd_soc_pcm_subclass {
|
||||
SND_SOC_PCM_CLASS_PCM = 0,
|
||||
SND_SOC_PCM_CLASS_BE = 1,
|
||||
@ -404,12 +399,6 @@ int snd_soc_cache_write(struct snd_soc_codec *codec,
|
||||
unsigned int reg, unsigned int value);
|
||||
int snd_soc_cache_read(struct snd_soc_codec *codec,
|
||||
unsigned int reg, unsigned int *value);
|
||||
int snd_soc_default_volatile_register(struct snd_soc_codec *codec,
|
||||
unsigned int reg);
|
||||
int snd_soc_default_readable_register(struct snd_soc_codec *codec,
|
||||
unsigned int reg);
|
||||
int snd_soc_default_writable_register(struct snd_soc_codec *codec,
|
||||
unsigned int reg);
|
||||
int snd_soc_platform_read(struct snd_soc_platform *platform,
|
||||
unsigned int reg);
|
||||
int snd_soc_platform_write(struct snd_soc_platform *platform,
|
||||
@ -542,22 +531,6 @@ int snd_soc_get_strobe(struct snd_kcontrol *kcontrol,
|
||||
int snd_soc_put_strobe(struct snd_kcontrol *kcontrol,
|
||||
struct snd_ctl_elem_value *ucontrol);
|
||||
|
||||
/**
|
||||
* struct snd_soc_reg_access - Describes whether a given register is
|
||||
* readable, writable or volatile.
|
||||
*
|
||||
* @reg: the register number
|
||||
* @read: whether this register is readable
|
||||
* @write: whether this register is writable
|
||||
* @vol: whether this register is volatile
|
||||
*/
|
||||
struct snd_soc_reg_access {
|
||||
u16 reg;
|
||||
u16 read;
|
||||
u16 write;
|
||||
u16 vol;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct snd_soc_jack_pin - Describes a pin to update based on jack detection
|
||||
*
|
||||
@ -658,19 +631,6 @@ struct snd_soc_compr_ops {
|
||||
int (*trigger)(struct snd_compr_stream *);
|
||||
};
|
||||
|
||||
/* SoC cache ops */
|
||||
struct snd_soc_cache_ops {
|
||||
const char *name;
|
||||
enum snd_soc_compress_type id;
|
||||
int (*init)(struct snd_soc_codec *codec);
|
||||
int (*exit)(struct snd_soc_codec *codec);
|
||||
int (*read)(struct snd_soc_codec *codec, unsigned int reg,
|
||||
unsigned int *value);
|
||||
int (*write)(struct snd_soc_codec *codec, unsigned int reg,
|
||||
unsigned int value);
|
||||
int (*sync)(struct snd_soc_codec *codec);
|
||||
};
|
||||
|
||||
/* component interface */
|
||||
struct snd_soc_component_driver {
|
||||
const char *name;
|
||||
@ -684,10 +644,12 @@ struct snd_soc_component_driver {
|
||||
struct snd_soc_component {
|
||||
const char *name;
|
||||
int id;
|
||||
int num_dai;
|
||||
struct device *dev;
|
||||
struct list_head list;
|
||||
|
||||
struct snd_soc_dai_driver *dai_drv;
|
||||
int num_dai;
|
||||
|
||||
const struct snd_soc_component_driver *driver;
|
||||
};
|
||||
|
||||
@ -704,8 +666,6 @@ struct snd_soc_codec {
|
||||
struct list_head list;
|
||||
struct list_head card_list;
|
||||
int num_dai;
|
||||
enum snd_soc_compress_type compress_type;
|
||||
size_t reg_size; /* reg_cache_size * reg_word_size */
|
||||
int (*volatile_register)(struct snd_soc_codec *, unsigned int);
|
||||
int (*readable_register)(struct snd_soc_codec *, unsigned int);
|
||||
int (*writable_register)(struct snd_soc_codec *, unsigned int);
|
||||
@ -729,10 +689,7 @@ struct snd_soc_codec {
|
||||
unsigned int (*hw_read)(struct snd_soc_codec *, unsigned int);
|
||||
unsigned int (*read)(struct snd_soc_codec *, unsigned int);
|
||||
int (*write)(struct snd_soc_codec *, unsigned int, unsigned int);
|
||||
int (*bulk_write_raw)(struct snd_soc_codec *, unsigned int, const void *, size_t);
|
||||
void *reg_cache;
|
||||
const void *reg_def_copy;
|
||||
const struct snd_soc_cache_ops *cache_ops;
|
||||
struct mutex cache_rw_mutex;
|
||||
int val_bytes;
|
||||
|
||||
@ -785,9 +742,6 @@ struct snd_soc_codec_driver {
|
||||
short reg_cache_step;
|
||||
short reg_word_size;
|
||||
const void *reg_cache_default;
|
||||
short reg_access_size;
|
||||
const struct snd_soc_reg_access *reg_access_default;
|
||||
enum snd_soc_compress_type compress_type;
|
||||
|
||||
/* codec bias level */
|
||||
int (*set_bias_level)(struct snd_soc_codec *,
|
||||
@ -955,12 +909,6 @@ struct snd_soc_codec_conf {
|
||||
* associated per device
|
||||
*/
|
||||
const char *name_prefix;
|
||||
|
||||
/*
|
||||
* set this to the desired compression type if you want to
|
||||
* override the one supplied in codec->driver->compress_type
|
||||
*/
|
||||
enum snd_soc_compress_type compress_type;
|
||||
};
|
||||
|
||||
struct snd_soc_aux_dev {
|
||||
@ -1132,8 +1080,6 @@ struct soc_enum {
|
||||
unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg);
|
||||
unsigned int snd_soc_write(struct snd_soc_codec *codec,
|
||||
unsigned int reg, unsigned int val);
|
||||
unsigned int snd_soc_bulk_write_raw(struct snd_soc_codec *codec,
|
||||
unsigned int reg, const void *data, size_t len);
|
||||
|
||||
/* device driver data */
|
||||
|
||||
|
@ -14,6 +14,7 @@ struct snd_soc_codec;
|
||||
struct snd_soc_platform;
|
||||
struct snd_soc_card;
|
||||
struct snd_soc_dapm_widget;
|
||||
struct snd_soc_dapm_path;
|
||||
|
||||
/*
|
||||
* Log register events
|
||||
|
@ -11,12 +11,9 @@
|
||||
* option) any later version.
|
||||
*/
|
||||
|
||||
#include <linux/i2c.h>
|
||||
#include <linux/spi/spi.h>
|
||||
#include <sound/soc.h>
|
||||
#include <linux/bitmap.h>
|
||||
#include <linux/rbtree.h>
|
||||
#include <linux/export.h>
|
||||
#include <linux/slab.h>
|
||||
|
||||
#include <trace/events/asoc.h>
|
||||
|
||||
@ -66,6 +63,85 @@ static unsigned int snd_soc_get_cache_val(const void *base, unsigned int idx,
|
||||
return -1;
|
||||
}
|
||||
|
||||
int snd_soc_cache_init(struct snd_soc_codec *codec)
|
||||
{
|
||||
const struct snd_soc_codec_driver *codec_drv = codec->driver;
|
||||
size_t reg_size;
|
||||
|
||||
reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
|
||||
|
||||
mutex_init(&codec->cache_rw_mutex);
|
||||
|
||||
dev_dbg(codec->dev, "ASoC: Initializing cache for %s codec\n",
|
||||
codec->name);
|
||||
|
||||
if (codec_drv->reg_cache_default)
|
||||
codec->reg_cache = kmemdup(codec_drv->reg_cache_default,
|
||||
reg_size, GFP_KERNEL);
|
||||
else
|
||||
codec->reg_cache = kzalloc(reg_size, GFP_KERNEL);
|
||||
if (!codec->reg_cache)
|
||||
return -ENOMEM;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* NOTE: keep in mind that this function might be called
|
||||
* multiple times.
|
||||
*/
|
||||
int snd_soc_cache_exit(struct snd_soc_codec *codec)
|
||||
{
|
||||
dev_dbg(codec->dev, "ASoC: Destroying cache for %s codec\n",
|
||||
codec->name);
|
||||
if (!codec->reg_cache)
|
||||
return 0;
|
||||
kfree(codec->reg_cache);
|
||||
codec->reg_cache = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* snd_soc_cache_read: Fetch the value of a given register from the cache.
|
||||
*
|
||||
* @codec: CODEC to configure.
|
||||
* @reg: The register index.
|
||||
* @value: The value to be returned.
|
||||
*/
|
||||
int snd_soc_cache_read(struct snd_soc_codec *codec,
|
||||
unsigned int reg, unsigned int *value)
|
||||
{
|
||||
if (!value)
|
||||
return -EINVAL;
|
||||
|
||||
mutex_lock(&codec->cache_rw_mutex);
|
||||
*value = snd_soc_get_cache_val(codec->reg_cache, reg,
|
||||
codec->driver->reg_word_size);
|
||||
mutex_unlock(&codec->cache_rw_mutex);
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_cache_read);
|
||||
|
||||
/**
|
||||
* snd_soc_cache_write: Set the value of a given register in the cache.
|
||||
*
|
||||
* @codec: CODEC to configure.
|
||||
* @reg: The register index.
|
||||
* @value: The new register value.
|
||||
*/
|
||||
int snd_soc_cache_write(struct snd_soc_codec *codec,
|
||||
unsigned int reg, unsigned int value)
|
||||
{
|
||||
mutex_lock(&codec->cache_rw_mutex);
|
||||
snd_soc_set_cache_val(codec->reg_cache, reg, value,
|
||||
codec->driver->reg_word_size);
|
||||
mutex_unlock(&codec->cache_rw_mutex);
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_cache_write);
|
||||
|
||||
static int snd_soc_flat_cache_sync(struct snd_soc_codec *codec)
|
||||
{
|
||||
int i;
|
||||
@ -78,8 +154,8 @@ static int snd_soc_flat_cache_sync(struct snd_soc_codec *codec)
|
||||
ret = snd_soc_cache_read(codec, i, &val);
|
||||
if (ret)
|
||||
return ret;
|
||||
if (codec->reg_def_copy)
|
||||
if (snd_soc_get_cache_val(codec->reg_def_copy,
|
||||
if (codec_drv->reg_cache_default)
|
||||
if (snd_soc_get_cache_val(codec_drv->reg_cache_default,
|
||||
i, codec_drv->reg_word_size) == val)
|
||||
continue;
|
||||
|
||||
@ -94,150 +170,6 @@ static int snd_soc_flat_cache_sync(struct snd_soc_codec *codec)
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int snd_soc_flat_cache_write(struct snd_soc_codec *codec,
|
||||
unsigned int reg, unsigned int value)
|
||||
{
|
||||
snd_soc_set_cache_val(codec->reg_cache, reg, value,
|
||||
codec->driver->reg_word_size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int snd_soc_flat_cache_read(struct snd_soc_codec *codec,
|
||||
unsigned int reg, unsigned int *value)
|
||||
{
|
||||
*value = snd_soc_get_cache_val(codec->reg_cache, reg,
|
||||
codec->driver->reg_word_size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int snd_soc_flat_cache_exit(struct snd_soc_codec *codec)
|
||||
{
|
||||
if (!codec->reg_cache)
|
||||
return 0;
|
||||
kfree(codec->reg_cache);
|
||||
codec->reg_cache = NULL;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int snd_soc_flat_cache_init(struct snd_soc_codec *codec)
|
||||
{
|
||||
if (codec->reg_def_copy)
|
||||
codec->reg_cache = kmemdup(codec->reg_def_copy,
|
||||
codec->reg_size, GFP_KERNEL);
|
||||
else
|
||||
codec->reg_cache = kzalloc(codec->reg_size, GFP_KERNEL);
|
||||
if (!codec->reg_cache)
|
||||
return -ENOMEM;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* an array of all supported compression types */
|
||||
static const struct snd_soc_cache_ops cache_types[] = {
|
||||
/* Flat *must* be the first entry for fallback */
|
||||
{
|
||||
.id = SND_SOC_FLAT_COMPRESSION,
|
||||
.name = "flat",
|
||||
.init = snd_soc_flat_cache_init,
|
||||
.exit = snd_soc_flat_cache_exit,
|
||||
.read = snd_soc_flat_cache_read,
|
||||
.write = snd_soc_flat_cache_write,
|
||||
.sync = snd_soc_flat_cache_sync
|
||||
},
|
||||
};
|
||||
|
||||
int snd_soc_cache_init(struct snd_soc_codec *codec)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(cache_types); ++i)
|
||||
if (cache_types[i].id == codec->compress_type)
|
||||
break;
|
||||
|
||||
/* Fall back to flat compression */
|
||||
if (i == ARRAY_SIZE(cache_types)) {
|
||||
dev_warn(codec->dev, "ASoC: Could not match compress type: %d\n",
|
||||
codec->compress_type);
|
||||
i = 0;
|
||||
}
|
||||
|
||||
mutex_init(&codec->cache_rw_mutex);
|
||||
codec->cache_ops = &cache_types[i];
|
||||
|
||||
if (codec->cache_ops->init) {
|
||||
if (codec->cache_ops->name)
|
||||
dev_dbg(codec->dev, "ASoC: Initializing %s cache for %s codec\n",
|
||||
codec->cache_ops->name, codec->name);
|
||||
return codec->cache_ops->init(codec);
|
||||
}
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
/*
|
||||
* NOTE: keep in mind that this function might be called
|
||||
* multiple times.
|
||||
*/
|
||||
int snd_soc_cache_exit(struct snd_soc_codec *codec)
|
||||
{
|
||||
if (codec->cache_ops && codec->cache_ops->exit) {
|
||||
if (codec->cache_ops->name)
|
||||
dev_dbg(codec->dev, "ASoC: Destroying %s cache for %s codec\n",
|
||||
codec->cache_ops->name, codec->name);
|
||||
return codec->cache_ops->exit(codec);
|
||||
}
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
/**
|
||||
* snd_soc_cache_read: Fetch the value of a given register from the cache.
|
||||
*
|
||||
* @codec: CODEC to configure.
|
||||
* @reg: The register index.
|
||||
* @value: The value to be returned.
|
||||
*/
|
||||
int snd_soc_cache_read(struct snd_soc_codec *codec,
|
||||
unsigned int reg, unsigned int *value)
|
||||
{
|
||||
int ret;
|
||||
|
||||
mutex_lock(&codec->cache_rw_mutex);
|
||||
|
||||
if (value && codec->cache_ops && codec->cache_ops->read) {
|
||||
ret = codec->cache_ops->read(codec, reg, value);
|
||||
mutex_unlock(&codec->cache_rw_mutex);
|
||||
return ret;
|
||||
}
|
||||
|
||||
mutex_unlock(&codec->cache_rw_mutex);
|
||||
return -ENOSYS;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_cache_read);
|
||||
|
||||
/**
|
||||
* snd_soc_cache_write: Set the value of a given register in the cache.
|
||||
*
|
||||
* @codec: CODEC to configure.
|
||||
* @reg: The register index.
|
||||
* @value: The new register value.
|
||||
*/
|
||||
int snd_soc_cache_write(struct snd_soc_codec *codec,
|
||||
unsigned int reg, unsigned int value)
|
||||
{
|
||||
int ret;
|
||||
|
||||
mutex_lock(&codec->cache_rw_mutex);
|
||||
|
||||
if (codec->cache_ops && codec->cache_ops->write) {
|
||||
ret = codec->cache_ops->write(codec, reg, value);
|
||||
mutex_unlock(&codec->cache_rw_mutex);
|
||||
return ret;
|
||||
}
|
||||
|
||||
mutex_unlock(&codec->cache_rw_mutex);
|
||||
return -ENOSYS;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_cache_write);
|
||||
|
||||
/**
|
||||
* snd_soc_cache_sync: Sync the register cache with the hardware.
|
||||
*
|
||||
@ -249,92 +181,19 @@ EXPORT_SYMBOL_GPL(snd_soc_cache_write);
|
||||
*/
|
||||
int snd_soc_cache_sync(struct snd_soc_codec *codec)
|
||||
{
|
||||
const char *name = "flat";
|
||||
int ret;
|
||||
const char *name;
|
||||
|
||||
if (!codec->cache_sync) {
|
||||
if (!codec->cache_sync)
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (!codec->cache_ops || !codec->cache_ops->sync)
|
||||
return -ENOSYS;
|
||||
|
||||
if (codec->cache_ops->name)
|
||||
name = codec->cache_ops->name;
|
||||
else
|
||||
name = "unknown";
|
||||
|
||||
if (codec->cache_ops->name)
|
||||
dev_dbg(codec->dev, "ASoC: Syncing %s cache for %s codec\n",
|
||||
codec->cache_ops->name, codec->name);
|
||||
dev_dbg(codec->dev, "ASoC: Syncing cache for %s codec\n",
|
||||
codec->name);
|
||||
trace_snd_soc_cache_sync(codec, name, "start");
|
||||
ret = codec->cache_ops->sync(codec);
|
||||
ret = snd_soc_flat_cache_sync(codec);
|
||||
if (!ret)
|
||||
codec->cache_sync = 0;
|
||||
trace_snd_soc_cache_sync(codec, name, "end");
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_cache_sync);
|
||||
|
||||
static int snd_soc_get_reg_access_index(struct snd_soc_codec *codec,
|
||||
unsigned int reg)
|
||||
{
|
||||
const struct snd_soc_codec_driver *codec_drv;
|
||||
unsigned int min, max, index;
|
||||
|
||||
codec_drv = codec->driver;
|
||||
min = 0;
|
||||
max = codec_drv->reg_access_size - 1;
|
||||
do {
|
||||
index = (min + max) / 2;
|
||||
if (codec_drv->reg_access_default[index].reg == reg)
|
||||
return index;
|
||||
if (codec_drv->reg_access_default[index].reg < reg)
|
||||
min = index + 1;
|
||||
else
|
||||
max = index;
|
||||
} while (min <= max);
|
||||
return -1;
|
||||
}
|
||||
|
||||
int snd_soc_default_volatile_register(struct snd_soc_codec *codec,
|
||||
unsigned int reg)
|
||||
{
|
||||
int index;
|
||||
|
||||
if (reg >= codec->driver->reg_cache_size)
|
||||
return 1;
|
||||
index = snd_soc_get_reg_access_index(codec, reg);
|
||||
if (index < 0)
|
||||
return 0;
|
||||
return codec->driver->reg_access_default[index].vol;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_default_volatile_register);
|
||||
|
||||
int snd_soc_default_readable_register(struct snd_soc_codec *codec,
|
||||
unsigned int reg)
|
||||
{
|
||||
int index;
|
||||
|
||||
if (reg >= codec->driver->reg_cache_size)
|
||||
return 1;
|
||||
index = snd_soc_get_reg_access_index(codec, reg);
|
||||
if (index < 0)
|
||||
return 0;
|
||||
return codec->driver->reg_access_default[index].read;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_default_readable_register);
|
||||
|
||||
int snd_soc_default_writable_register(struct snd_soc_codec *codec,
|
||||
unsigned int reg)
|
||||
{
|
||||
int index;
|
||||
|
||||
if (reg >= codec->driver->reg_cache_size)
|
||||
return 1;
|
||||
index = snd_soc_get_reg_access_index(codec, reg);
|
||||
if (index < 0)
|
||||
return 0;
|
||||
return codec->driver->reg_access_default[index].write;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_default_writable_register);
|
||||
|
@ -662,6 +662,8 @@ int snd_soc_suspend(struct device *dev)
|
||||
codec->cache_sync = 1;
|
||||
if (codec->using_regmap)
|
||||
regcache_mark_dirty(codec->control_data);
|
||||
/* deactivate pins to sleep state */
|
||||
pinctrl_pm_select_sleep_state(codec->dev);
|
||||
break;
|
||||
default:
|
||||
dev_dbg(codec->dev,
|
||||
@ -679,6 +681,9 @@ int snd_soc_suspend(struct device *dev)
|
||||
|
||||
if (cpu_dai->driver->suspend && cpu_dai->driver->ac97_control)
|
||||
cpu_dai->driver->suspend(cpu_dai);
|
||||
|
||||
/* deactivate pins to sleep state */
|
||||
pinctrl_pm_select_sleep_state(cpu_dai->dev);
|
||||
}
|
||||
|
||||
if (card->suspend_post)
|
||||
@ -807,6 +812,16 @@ int snd_soc_resume(struct device *dev)
|
||||
if (list_empty(&card->codec_dev_list))
|
||||
return 0;
|
||||
|
||||
/* activate pins from sleep state */
|
||||
for (i = 0; i < card->num_rtd; i++) {
|
||||
struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
|
||||
struct snd_soc_dai *codec_dai = card->rtd[i].codec_dai;
|
||||
if (cpu_dai->active)
|
||||
pinctrl_pm_select_default_state(cpu_dai->dev);
|
||||
if (codec_dai->active)
|
||||
pinctrl_pm_select_default_state(codec_dai->dev);
|
||||
}
|
||||
|
||||
/* AC97 devices might have other drivers hanging off them so
|
||||
* need to resume immediately. Other drivers don't have that
|
||||
* problem and may take a substantial amount of time to resume
|
||||
@ -1589,17 +1604,13 @@ static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
|
||||
soc_remove_codec(codec);
|
||||
}
|
||||
|
||||
static int snd_soc_init_codec_cache(struct snd_soc_codec *codec,
|
||||
enum snd_soc_compress_type compress_type)
|
||||
static int snd_soc_init_codec_cache(struct snd_soc_codec *codec)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (codec->cache_init)
|
||||
return 0;
|
||||
|
||||
/* override the compress_type if necessary */
|
||||
if (compress_type && codec->compress_type != compress_type)
|
||||
codec->compress_type = compress_type;
|
||||
ret = snd_soc_cache_init(codec);
|
||||
if (ret < 0) {
|
||||
dev_err(codec->dev,
|
||||
@ -1614,8 +1625,6 @@ static int snd_soc_init_codec_cache(struct snd_soc_codec *codec,
|
||||
static int snd_soc_instantiate_card(struct snd_soc_card *card)
|
||||
{
|
||||
struct snd_soc_codec *codec;
|
||||
struct snd_soc_codec_conf *codec_conf;
|
||||
enum snd_soc_compress_type compress_type;
|
||||
struct snd_soc_dai_link *dai_link;
|
||||
int ret, i, order, dai_fmt;
|
||||
|
||||
@ -1639,19 +1648,7 @@ static int snd_soc_instantiate_card(struct snd_soc_card *card)
|
||||
list_for_each_entry(codec, &codec_list, list) {
|
||||
if (codec->cache_init)
|
||||
continue;
|
||||
/* by default we don't override the compress_type */
|
||||
compress_type = 0;
|
||||
/* check to see if we need to override the compress_type */
|
||||
for (i = 0; i < card->num_configs; ++i) {
|
||||
codec_conf = &card->codec_conf[i];
|
||||
if (!strcmp(codec->name, codec_conf->dev_name)) {
|
||||
compress_type = codec_conf->compress_type;
|
||||
if (compress_type && compress_type
|
||||
!= codec->compress_type)
|
||||
break;
|
||||
}
|
||||
}
|
||||
ret = snd_soc_init_codec_cache(codec, compress_type);
|
||||
ret = snd_soc_init_codec_cache(codec);
|
||||
if (ret < 0)
|
||||
goto base_error;
|
||||
}
|
||||
@ -1947,6 +1944,14 @@ int snd_soc_poweroff(struct device *dev)
|
||||
|
||||
snd_soc_dapm_shutdown(card);
|
||||
|
||||
/* deactivate pins to sleep state */
|
||||
for (i = 0; i < card->num_rtd; i++) {
|
||||
struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
|
||||
struct snd_soc_dai *codec_dai = card->rtd[i].codec_dai;
|
||||
pinctrl_pm_select_sleep_state(codec_dai->dev);
|
||||
pinctrl_pm_select_sleep_state(cpu_dai->dev);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_poweroff);
|
||||
@ -2297,13 +2302,6 @@ unsigned int snd_soc_write(struct snd_soc_codec *codec,
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_write);
|
||||
|
||||
unsigned int snd_soc_bulk_write_raw(struct snd_soc_codec *codec,
|
||||
unsigned int reg, const void *data, size_t len)
|
||||
{
|
||||
return codec->bulk_write_raw(codec, reg, data, len);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_bulk_write_raw);
|
||||
|
||||
/**
|
||||
* snd_soc_update_bits - update codec register bits
|
||||
* @codec: audio codec
|
||||
@ -2576,8 +2574,9 @@ int snd_soc_info_enum_double(struct snd_kcontrol *kcontrol,
|
||||
|
||||
if (uinfo->value.enumerated.item > e->max - 1)
|
||||
uinfo->value.enumerated.item = e->max - 1;
|
||||
strcpy(uinfo->value.enumerated.name,
|
||||
e->texts[uinfo->value.enumerated.item]);
|
||||
strlcpy(uinfo->value.enumerated.name,
|
||||
e->texts[uinfo->value.enumerated.item],
|
||||
sizeof(uinfo->value.enumerated.name));
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_info_enum_double);
|
||||
@ -3791,6 +3790,16 @@ int snd_soc_register_card(struct snd_soc_card *card)
|
||||
if (ret != 0)
|
||||
soc_cleanup_card_debugfs(card);
|
||||
|
||||
/* deactivate pins to sleep state */
|
||||
for (i = 0; i < card->num_rtd; i++) {
|
||||
struct snd_soc_dai *cpu_dai = card->rtd[i].cpu_dai;
|
||||
struct snd_soc_dai *codec_dai = card->rtd[i].codec_dai;
|
||||
if (!codec_dai->active)
|
||||
pinctrl_pm_select_sleep_state(codec_dai->dev);
|
||||
if (!cpu_dai->active)
|
||||
pinctrl_pm_select_sleep_state(cpu_dai->dev);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(snd_soc_register_card);
|
||||
@ -4063,6 +4072,7 @@ __snd_soc_register_component(struct device *dev,
|
||||
|
||||
cmpnt->dev = dev;
|
||||
cmpnt->driver = cmpnt_drv;
|
||||
cmpnt->dai_drv = dai_drv;
|
||||
cmpnt->num_dai = num_dai;
|
||||
|
||||
/*
|
||||
@ -4287,7 +4297,6 @@ int snd_soc_register_codec(struct device *dev,
|
||||
struct snd_soc_dai_driver *dai_drv,
|
||||
int num_dai)
|
||||
{
|
||||
size_t reg_size;
|
||||
struct snd_soc_codec *codec;
|
||||
int ret, i;
|
||||
|
||||
@ -4304,11 +4313,6 @@ int snd_soc_register_codec(struct device *dev,
|
||||
goto fail_codec;
|
||||
}
|
||||
|
||||
if (codec_drv->compress_type)
|
||||
codec->compress_type = codec_drv->compress_type;
|
||||
else
|
||||
codec->compress_type = SND_SOC_FLAT_COMPRESSION;
|
||||
|
||||
codec->write = codec_drv->write;
|
||||
codec->read = codec_drv->read;
|
||||
codec->volatile_register = codec_drv->volatile_register;
|
||||
@ -4325,35 +4329,6 @@ int snd_soc_register_codec(struct device *dev,
|
||||
codec->num_dai = num_dai;
|
||||
mutex_init(&codec->mutex);
|
||||
|
||||
/* allocate CODEC register cache */
|
||||
if (codec_drv->reg_cache_size && codec_drv->reg_word_size) {
|
||||
reg_size = codec_drv->reg_cache_size * codec_drv->reg_word_size;
|
||||
codec->reg_size = reg_size;
|
||||
/* it is necessary to make a copy of the default register cache
|
||||
* because in the case of using a compression type that requires
|
||||
* the default register cache to be marked as the
|
||||
* kernel might have freed the array by the time we initialize
|
||||
* the cache.
|
||||
*/
|
||||
if (codec_drv->reg_cache_default) {
|
||||
codec->reg_def_copy = kmemdup(codec_drv->reg_cache_default,
|
||||
reg_size, GFP_KERNEL);
|
||||
if (!codec->reg_def_copy) {
|
||||
ret = -ENOMEM;
|
||||
goto fail_codec_name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (codec_drv->reg_access_size && codec_drv->reg_access_default) {
|
||||
if (!codec->volatile_register)
|
||||
codec->volatile_register = snd_soc_default_volatile_register;
|
||||
if (!codec->readable_register)
|
||||
codec->readable_register = snd_soc_default_readable_register;
|
||||
if (!codec->writable_register)
|
||||
codec->writable_register = snd_soc_default_writable_register;
|
||||
}
|
||||
|
||||
for (i = 0; i < num_dai; i++) {
|
||||
fixup_codec_formats(&dai_drv[i].playback);
|
||||
fixup_codec_formats(&dai_drv[i].capture);
|
||||
@ -4412,7 +4387,6 @@ found:
|
||||
dev_dbg(codec->dev, "ASoC: Unregistered codec '%s'\n", codec->name);
|
||||
|
||||
snd_soc_cache_exit(codec);
|
||||
kfree(codec->reg_def_copy);
|
||||
kfree(codec->name);
|
||||
kfree(codec);
|
||||
}
|
||||
@ -4624,12 +4598,31 @@ int snd_soc_of_get_dai_name(struct device_node *of_node,
|
||||
if (pos->dev->of_node != args.np)
|
||||
continue;
|
||||
|
||||
if (!pos->driver->of_xlate_dai_name) {
|
||||
ret = -ENOSYS;
|
||||
break;
|
||||
if (pos->driver->of_xlate_dai_name) {
|
||||
ret = pos->driver->of_xlate_dai_name(pos, &args, dai_name);
|
||||
} else {
|
||||
int id = -1;
|
||||
|
||||
switch (args.args_count) {
|
||||
case 0:
|
||||
id = 0; /* same as dai_drv[0] */
|
||||
break;
|
||||
case 1:
|
||||
id = args.args[0];
|
||||
break;
|
||||
default:
|
||||
/* not supported */
|
||||
break;
|
||||
}
|
||||
|
||||
if (id < 0 || id >= pos->num_dai) {
|
||||
ret = -EINVAL;
|
||||
} else {
|
||||
*dai_name = pos->dai_drv[id].name;
|
||||
ret = 0;
|
||||
}
|
||||
}
|
||||
|
||||
ret = pos->driver->of_xlate_dai_name(pos, &args, dai_name);
|
||||
break;
|
||||
}
|
||||
mutex_unlock(&client_mutex);
|
||||
|
@ -65,31 +65,6 @@ static unsigned int hw_read(struct snd_soc_codec *codec, unsigned int reg)
|
||||
return val;
|
||||
}
|
||||
|
||||
/* Primitive bulk write support for soc-cache. The data pointed to by
|
||||
* `data' needs to already be in the form the hardware expects. Any
|
||||
* data written through this function will not go through the cache as
|
||||
* it only handles writing to volatile or out of bounds registers.
|
||||
*
|
||||
* This is currently only supported for devices using the regmap API
|
||||
* wrappers.
|
||||
*/
|
||||
static int snd_soc_hw_bulk_write_raw(struct snd_soc_codec *codec,
|
||||
unsigned int reg,
|
||||
const void *data, size_t len)
|
||||
{
|
||||
/* To ensure that we don't get out of sync with the cache, check
|
||||
* whether the base register is volatile or if we've directly asked
|
||||
* to bypass the cache. Out of bounds registers are considered
|
||||
* volatile.
|
||||
*/
|
||||
if (!codec->cache_bypass
|
||||
&& !snd_soc_codec_volatile_register(codec, reg)
|
||||
&& reg < codec->driver->reg_cache_size)
|
||||
return -EINVAL;
|
||||
|
||||
return regmap_raw_write(codec->control_data, reg, data, len);
|
||||
}
|
||||
|
||||
/**
|
||||
* snd_soc_codec_set_cache_io: Set up standard I/O functions.
|
||||
*
|
||||
@ -119,7 +94,6 @@ int snd_soc_codec_set_cache_io(struct snd_soc_codec *codec,
|
||||
memset(&config, 0, sizeof(config));
|
||||
codec->write = hw_write;
|
||||
codec->read = hw_read;
|
||||
codec->bulk_write_raw = snd_soc_hw_bulk_write_raw;
|
||||
|
||||
config.reg_bits = addr_bits;
|
||||
config.val_bits = data_bits;
|
||||
|
@ -19,6 +19,7 @@
|
||||
#include <linux/kernel.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/pinctrl/consumer.h>
|
||||
#include <linux/pm_runtime.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/workqueue.h>
|
||||
@ -183,6 +184,8 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
|
||||
struct snd_soc_dai_driver *codec_dai_drv = codec_dai->driver;
|
||||
int ret = 0;
|
||||
|
||||
pinctrl_pm_select_default_state(cpu_dai->dev);
|
||||
pinctrl_pm_select_default_state(codec_dai->dev);
|
||||
pm_runtime_get_sync(cpu_dai->dev);
|
||||
pm_runtime_get_sync(codec_dai->dev);
|
||||
pm_runtime_get_sync(platform->dev);
|
||||
@ -190,7 +193,7 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
|
||||
mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
|
||||
|
||||
/* startup the audio subsystem */
|
||||
if (cpu_dai->driver->ops->startup) {
|
||||
if (cpu_dai->driver->ops && cpu_dai->driver->ops->startup) {
|
||||
ret = cpu_dai->driver->ops->startup(substream, cpu_dai);
|
||||
if (ret < 0) {
|
||||
dev_err(cpu_dai->dev, "ASoC: can't open interface"
|
||||
@ -208,7 +211,7 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
|
||||
}
|
||||
}
|
||||
|
||||
if (codec_dai->driver->ops->startup) {
|
||||
if (codec_dai->driver->ops && codec_dai->driver->ops->startup) {
|
||||
ret = codec_dai->driver->ops->startup(substream, codec_dai);
|
||||
if (ret < 0) {
|
||||
dev_err(codec_dai->dev, "ASoC: can't open codec"
|
||||
@ -317,6 +320,10 @@ out:
|
||||
pm_runtime_put(platform->dev);
|
||||
pm_runtime_put(codec_dai->dev);
|
||||
pm_runtime_put(cpu_dai->dev);
|
||||
if (!codec_dai->active)
|
||||
pinctrl_pm_select_sleep_state(codec_dai->dev);
|
||||
if (!cpu_dai->active)
|
||||
pinctrl_pm_select_sleep_state(cpu_dai->dev);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@ -426,6 +433,10 @@ static int soc_pcm_close(struct snd_pcm_substream *substream)
|
||||
pm_runtime_put(platform->dev);
|
||||
pm_runtime_put(codec_dai->dev);
|
||||
pm_runtime_put(cpu_dai->dev);
|
||||
if (!codec_dai->active)
|
||||
pinctrl_pm_select_sleep_state(codec_dai->dev);
|
||||
if (!cpu_dai->active)
|
||||
pinctrl_pm_select_sleep_state(cpu_dai->dev);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -463,7 +474,7 @@ static int soc_pcm_prepare(struct snd_pcm_substream *substream)
|
||||
}
|
||||
}
|
||||
|
||||
if (codec_dai->driver->ops->prepare) {
|
||||
if (codec_dai->driver->ops && codec_dai->driver->ops->prepare) {
|
||||
ret = codec_dai->driver->ops->prepare(substream, codec_dai);
|
||||
if (ret < 0) {
|
||||
dev_err(codec_dai->dev, "ASoC: DAI prepare error: %d\n",
|
||||
@ -472,7 +483,7 @@ static int soc_pcm_prepare(struct snd_pcm_substream *substream)
|
||||
}
|
||||
}
|
||||
|
||||
if (cpu_dai->driver->ops->prepare) {
|
||||
if (cpu_dai->driver->ops && cpu_dai->driver->ops->prepare) {
|
||||
ret = cpu_dai->driver->ops->prepare(substream, cpu_dai);
|
||||
if (ret < 0) {
|
||||
dev_err(cpu_dai->dev, "ASoC: DAI prepare error: %d\n",
|
||||
@ -523,7 +534,7 @@ static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
|
||||
}
|
||||
}
|
||||
|
||||
if (codec_dai->driver->ops->hw_params) {
|
||||
if (codec_dai->driver->ops && codec_dai->driver->ops->hw_params) {
|
||||
ret = codec_dai->driver->ops->hw_params(substream, params, codec_dai);
|
||||
if (ret < 0) {
|
||||
dev_err(codec_dai->dev, "ASoC: can't set %s hw params:"
|
||||
@ -532,7 +543,7 @@ static int soc_pcm_hw_params(struct snd_pcm_substream *substream,
|
||||
}
|
||||
}
|
||||
|
||||
if (cpu_dai->driver->ops->hw_params) {
|
||||
if (cpu_dai->driver->ops && cpu_dai->driver->ops->hw_params) {
|
||||
ret = cpu_dai->driver->ops->hw_params(substream, params, cpu_dai);
|
||||
if (ret < 0) {
|
||||
dev_err(cpu_dai->dev, "ASoC: %s hw params failed: %d\n",
|
||||
@ -559,11 +570,11 @@ out:
|
||||
return ret;
|
||||
|
||||
platform_err:
|
||||
if (cpu_dai->driver->ops->hw_free)
|
||||
if (cpu_dai->driver->ops && cpu_dai->driver->ops->hw_free)
|
||||
cpu_dai->driver->ops->hw_free(substream, cpu_dai);
|
||||
|
||||
interface_err:
|
||||
if (codec_dai->driver->ops->hw_free)
|
||||
if (codec_dai->driver->ops && codec_dai->driver->ops->hw_free)
|
||||
codec_dai->driver->ops->hw_free(substream, codec_dai);
|
||||
|
||||
codec_err:
|
||||
@ -600,10 +611,10 @@ static int soc_pcm_hw_free(struct snd_pcm_substream *substream)
|
||||
platform->driver->ops->hw_free(substream);
|
||||
|
||||
/* now free hw params for the DAIs */
|
||||
if (codec_dai->driver->ops->hw_free)
|
||||
if (codec_dai->driver->ops && codec_dai->driver->ops->hw_free)
|
||||
codec_dai->driver->ops->hw_free(substream, codec_dai);
|
||||
|
||||
if (cpu_dai->driver->ops->hw_free)
|
||||
if (cpu_dai->driver->ops && cpu_dai->driver->ops->hw_free)
|
||||
cpu_dai->driver->ops->hw_free(substream, cpu_dai);
|
||||
|
||||
mutex_unlock(&rtd->pcm_mutex);
|
||||
@ -618,7 +629,7 @@ static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
|
||||
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
||||
int ret;
|
||||
|
||||
if (codec_dai->driver->ops->trigger) {
|
||||
if (codec_dai->driver->ops && codec_dai->driver->ops->trigger) {
|
||||
ret = codec_dai->driver->ops->trigger(substream, cmd, codec_dai);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
@ -630,7 +641,7 @@ static int soc_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (cpu_dai->driver->ops->trigger) {
|
||||
if (cpu_dai->driver->ops && cpu_dai->driver->ops->trigger) {
|
||||
ret = cpu_dai->driver->ops->trigger(substream, cmd, cpu_dai);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
@ -647,19 +658,20 @@ static int soc_pcm_bespoke_trigger(struct snd_pcm_substream *substream,
|
||||
struct snd_soc_dai *codec_dai = rtd->codec_dai;
|
||||
int ret;
|
||||
|
||||
if (codec_dai->driver->ops->bespoke_trigger) {
|
||||
if (codec_dai->driver->ops &&
|
||||
codec_dai->driver->ops->bespoke_trigger) {
|
||||
ret = codec_dai->driver->ops->bespoke_trigger(substream, cmd, codec_dai);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (platform->driver->bespoke_trigger) {
|
||||
if (platform->driver->ops && platform->driver->bespoke_trigger) {
|
||||
ret = platform->driver->bespoke_trigger(substream, cmd);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
}
|
||||
|
||||
if (cpu_dai->driver->ops->bespoke_trigger) {
|
||||
if (cpu_dai->driver->ops && cpu_dai->driver->ops->bespoke_trigger) {
|
||||
ret = cpu_dai->driver->ops->bespoke_trigger(substream, cmd, cpu_dai);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
@ -684,10 +696,10 @@ static snd_pcm_uframes_t soc_pcm_pointer(struct snd_pcm_substream *substream)
|
||||
if (platform->driver->ops && platform->driver->ops->pointer)
|
||||
offset = platform->driver->ops->pointer(substream);
|
||||
|
||||
if (cpu_dai->driver->ops->delay)
|
||||
if (cpu_dai->driver->ops && cpu_dai->driver->ops->delay)
|
||||
delay += cpu_dai->driver->ops->delay(substream, cpu_dai);
|
||||
|
||||
if (codec_dai->driver->ops->delay)
|
||||
if (codec_dai->driver->ops && codec_dai->driver->ops->delay)
|
||||
delay += codec_dai->driver->ops->delay(substream, codec_dai);
|
||||
|
||||
if (platform->driver->delay)
|
||||
@ -721,7 +733,7 @@ static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe,
|
||||
list_add(&dpcm->list_be, &fe->dpcm[stream].be_clients);
|
||||
list_add(&dpcm->list_fe, &be->dpcm[stream].fe_clients);
|
||||
|
||||
dev_dbg(fe->dev, " connected new DPCM %s path %s %s %s\n",
|
||||
dev_dbg(fe->dev, "connected new DPCM %s path %s %s %s\n",
|
||||
stream ? "capture" : "playback", fe->dai_link->name,
|
||||
stream ? "<-" : "->", be->dai_link->name);
|
||||
|
||||
@ -749,7 +761,7 @@ static void dpcm_be_reparent(struct snd_soc_pcm_runtime *fe,
|
||||
if (dpcm->fe == fe)
|
||||
continue;
|
||||
|
||||
dev_dbg(fe->dev, " reparent %s path %s %s %s\n",
|
||||
dev_dbg(fe->dev, "reparent %s path %s %s %s\n",
|
||||
stream ? "capture" : "playback",
|
||||
dpcm->fe->dai_link->name,
|
||||
stream ? "<-" : "->", dpcm->be->dai_link->name);
|
||||
@ -773,7 +785,7 @@ static void dpcm_be_disconnect(struct snd_soc_pcm_runtime *fe, int stream)
|
||||
if (dpcm->state != SND_SOC_DPCM_LINK_STATE_FREE)
|
||||
continue;
|
||||
|
||||
dev_dbg(fe->dev, " freed DSP %s path %s %s %s\n",
|
||||
dev_dbg(fe->dev, "freed DSP %s path %s %s %s\n",
|
||||
stream ? "capture" : "playback", fe->dai_link->name,
|
||||
stream ? "<-" : "->", dpcm->be->dai_link->name);
|
||||
|
||||
@ -1037,6 +1049,12 @@ static int dpcm_be_dai_startup(struct snd_soc_pcm_runtime *fe, int stream)
|
||||
struct snd_pcm_substream *be_substream =
|
||||
snd_soc_dpcm_get_substream(be, stream);
|
||||
|
||||
if (!be_substream) {
|
||||
dev_err(be->dev, "ASoC: no backend %s stream\n",
|
||||
stream ? "capture" : "playback");
|
||||
continue;
|
||||
}
|
||||
|
||||
/* is this op for this BE ? */
|
||||
if (!snd_soc_dpcm_be_can_update(fe, be, stream))
|
||||
continue;
|
||||
@ -1054,7 +1072,8 @@ static int dpcm_be_dai_startup(struct snd_soc_pcm_runtime *fe, int stream)
|
||||
(be->dpcm[stream].state != SND_SOC_DPCM_STATE_CLOSE))
|
||||
continue;
|
||||
|
||||
dev_dbg(be->dev, "ASoC: open BE %s\n", be->dai_link->name);
|
||||
dev_dbg(be->dev, "ASoC: open %s BE %s\n",
|
||||
stream ? "capture" : "playback", be->dai_link->name);
|
||||
|
||||
be_substream->runtime = be->dpcm[stream].runtime;
|
||||
err = soc_pcm_open(be_substream);
|
||||
@ -1673,7 +1692,7 @@ static int soc_pcm_ioctl(struct snd_pcm_substream *substream,
|
||||
struct snd_soc_pcm_runtime *rtd = substream->private_data;
|
||||
struct snd_soc_platform *platform = rtd->platform;
|
||||
|
||||
if (platform->driver->ops->ioctl)
|
||||
if (platform->driver->ops && platform->driver->ops->ioctl)
|
||||
return platform->driver->ops->ioctl(substream, cmd, arg);
|
||||
return snd_pcm_lib_ioctl(substream, cmd, arg);
|
||||
}
|
||||
@ -1934,8 +1953,8 @@ int soc_dpcm_be_digital_mute(struct snd_soc_pcm_runtime *fe, int mute)
|
||||
|
||||
dev_dbg(be->dev, "ASoC: BE digital mute %s\n", be->dai_link->name);
|
||||
|
||||
if (drv->ops->digital_mute && dai->playback_active)
|
||||
drv->ops->digital_mute(dai, mute);
|
||||
if (drv->ops && drv->ops->digital_mute && dai->playback_active)
|
||||
drv->ops->digital_mute(dai, mute);
|
||||
}
|
||||
|
||||
return 0;
|
||||
@ -2116,7 +2135,7 @@ int soc_new_pcm(struct snd_soc_pcm_runtime *rtd, int num)
|
||||
|
||||
pcm->private_free = platform->driver->pcm_free;
|
||||
out:
|
||||
dev_info(rtd->card->dev, " %s <-> %s mapping ok\n", codec_dai->name,
|
||||
dev_info(rtd->card->dev, "%s <-> %s mapping ok\n", codec_dai->name,
|
||||
cpu_dai->name);
|
||||
return ret;
|
||||
}
|
||||
@ -2224,7 +2243,7 @@ EXPORT_SYMBOL_GPL(snd_soc_dpcm_can_be_params);
|
||||
int snd_soc_platform_trigger(struct snd_pcm_substream *substream,
|
||||
int cmd, struct snd_soc_platform *platform)
|
||||
{
|
||||
if (platform->driver->ops->trigger)
|
||||
if (platform->driver->ops && platform->driver->ops->trigger)
|
||||
return platform->driver->ops->trigger(substream, cmd);
|
||||
return 0;
|
||||
}
|
||||
|
@ -75,7 +75,11 @@ static const struct snd_pcm_hardware dummy_dma_hardware = {
|
||||
|
||||
static int dummy_dma_open(struct snd_pcm_substream *substream)
|
||||
{
|
||||
snd_soc_set_runtime_hwparams(substream, &dummy_dma_hardware);
|
||||
struct snd_soc_pcm_runtime *rtd = substream->private_data;
|
||||
|
||||
/* BE's dont need dummy params */
|
||||
if (!rtd->dai_link->no_pcm)
|
||||
snd_soc_set_runtime_hwparams(substream, &dummy_dma_hardware);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
Loading…
Reference in New Issue
Block a user