Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 427d204c authored by Lars-Peter Clausen's avatar Lars-Peter Clausen Committed by Mark Brown
Browse files

ASoC: Remove snd_soc_cache_sync() implementation 



This function has no more non regmap user, which means we can remove the
implementation of the function and associated functions and structure
fields.

For convenience we keep a static inline version of the function that
forwards calls to regcache_sync() unconditionally.

Signed-off-by: default avatarLars-Peter Clausen <lars@metafoo.de>
Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 6cc79294

include/sound/soc.h

+12 −7
Original line number Diff line number Diff line
@@ -409,13 +409,9 @@ int devm_snd_soc_register_component(struct device *dev, 
			 const struct snd_soc_component_driver *cmpnt_drv,

			 struct snd_soc_dai_driver *dai_drv, int num_dai);

void snd_soc_unregister_component(struct device *dev);

int snd_soc_cache_sync(struct snd_soc_codec *codec);

int snd_soc_cache_init(struct snd_soc_codec *codec);

int snd_soc_cache_exit(struct snd_soc_codec *codec);

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_platform_read(struct snd_soc_platform *platform,

					unsigned int reg);

int snd_soc_platform_write(struct snd_soc_platform *platform,
@@ -791,13 +787,11 @@ struct snd_soc_codec { 
	unsigned int ac97_registered:1; /* Codec has been AC97 registered */

	unsigned int ac97_created:1; /* Codec has been created by SoC */

	unsigned int cache_init:1; /* codec cache has been initialized */

	u32 cache_sync; /* Cache needs to be synced to hardware */



	/* codec IO */

	void *control_data; /* codec control (i2c/3wire) data */

	hw_write_t hw_write;

	void *reg_cache;

	struct mutex cache_rw_mutex;



	/* component */

	struct snd_soc_component component;
@@ -1264,6 +1258,17 @@ unsigned int snd_soc_read(struct snd_soc_codec *codec, unsigned int reg); 
int snd_soc_write(struct snd_soc_codec *codec, unsigned int reg,

	unsigned int val);



/**

 * snd_soc_cache_sync() - Sync the register cache with the hardware

 * @codec: CODEC to sync

 *

 * Note: This function will call regcache_sync()

 */

static inline int snd_soc_cache_sync(struct snd_soc_codec *codec)

{

	return regcache_sync(codec->component.regmap);

}



/* component IO */

int snd_soc_component_read(struct snd_soc_component *component,

	unsigned int reg, unsigned int *val);

include/trace/events/asoc.h

+0 −25
Original line number Diff line number Diff line
@@ -288,31 +288,6 @@ TRACE_EVENT(snd_soc_jack_notify, 
	TP_printk("jack=%s %x", __get_str(name), (int)__entry->val)

);



TRACE_EVENT(snd_soc_cache_sync,



	TP_PROTO(struct snd_soc_codec *codec, const char *type,

		 const char *status),



	TP_ARGS(codec, type, status),



	TP_STRUCT__entry(

		__string(	name,		codec->component.name)

		__string(	status,		status		)

		__string(	type,		type		)

		__field(	int,		id		)

	),



	TP_fast_assign(

		__assign_str(name, codec->component.name);

		__assign_str(status, status);

		__assign_str(type, type);

		__entry->id = codec->component.id;

	),



	TP_printk("codec=%s.%d type=%s status=%s", __get_str(name),

		  (int)__entry->id, __get_str(type), __get_str(status))

);



#endif /* _TRACE_ASOC_H */



/* This part must be outside protection */

sound/soc/soc-cache.c

+0 −152
Original line number Diff line number Diff line
@@ -15,56 +15,6 @@ 
#include <linux/export.h>

#include <linux/slab.h>



#include <trace/events/asoc.h>



static bool snd_soc_set_cache_val(void *base, unsigned int idx,

				  unsigned int val, unsigned int word_size)

{

	switch (word_size) {

	case 1: {

		u8 *cache = base;

		if (cache[idx] == val)

			return true;

		cache[idx] = val;

		break;

	}

	case 2: {

		u16 *cache = base;

		if (cache[idx] == val)

			return true;

		cache[idx] = val;

		break;

	}

	default:

		WARN(1, "Invalid word_size %d\n", word_size);

		break;

	}

	return false;

}



static unsigned int snd_soc_get_cache_val(const void *base, unsigned int idx,

		unsigned int word_size)

{

	if (!base)

		return -1;



	switch (word_size) {

	case 1: {

		const u8 *cache = base;

		return cache[idx];

	}

	case 2: {

		const u16 *cache = base;

		return cache[idx];

	}

	default:

		WARN(1, "Invalid word_size %d\n", word_size);

		break;

	}

	/* unreachable */

	return -1;

}



int snd_soc_cache_init(struct snd_soc_codec *codec)

{

	const struct snd_soc_codec_driver *codec_drv = codec->driver;
@@ -75,8 +25,6 @@ int snd_soc_cache_init(struct snd_soc_codec *codec) 
	if (!reg_size)

		return 0;



	mutex_init(&codec->cache_rw_mutex);



	dev_dbg(codec->dev, "ASoC: Initializing cache for %s codec\n",

				codec->component.name);
@@ -103,103 +51,3 @@ int snd_soc_cache_exit(struct snd_soc_codec *codec) 
	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);

	if (!ZERO_OR_NULL_PTR(codec->reg_cache))

		*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);

	if (!ZERO_OR_NULL_PTR(codec->reg_cache))

		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;

	int ret;

	const struct snd_soc_codec_driver *codec_drv;

	unsigned int val;



	codec_drv = codec->driver;

	for (i = 0; i < codec_drv->reg_cache_size; ++i) {

		ret = snd_soc_cache_read(codec, i, &val);

		if (ret)

			return ret;

		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;



		ret = snd_soc_write(codec, i, val);

		if (ret)

			return ret;

		dev_dbg(codec->dev, "ASoC: Synced register %#x, value = %#x\n",

			i, val);

	}

	return 0;

}



/**

 * snd_soc_cache_sync: Sync the register cache with the hardware.

 *

 * @codec: CODEC to configure.

 *

 * Any registers that should not be synced should be marked as

 * volatile.  In general drivers can choose not to use the provided

 * syncing functionality if they so require.

 */

int snd_soc_cache_sync(struct snd_soc_codec *codec)

{

	const char *name = "flat";

	int ret;



	if (codec->component.regmap)

		return regcache_sync(codec->component.regmap);



	if (!codec->cache_sync)

		return 0;



	dev_dbg(codec->dev, "ASoC: Syncing cache for %s codec\n",

		codec->component.name);

	trace_snd_soc_cache_sync(codec, name, "start");

	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);

sound/soc/soc-core.c

+0 −4
Original line number Diff line number Diff line
@@ -309,9 +309,6 @@ static void soc_init_codec_debugfs(struct snd_soc_component *component) 
{

	struct snd_soc_codec *codec = snd_soc_component_to_codec(component);



	debugfs_create_bool("cache_sync", 0444, codec->component.debugfs_root,

			    &codec->cache_sync);



	codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,

						 codec->component.debugfs_root,

						 codec, &codec_reg_fops);
@@ -656,7 +653,6 @@ int snd_soc_suspend(struct device *dev) 
				if (codec->driver->suspend)

					codec->driver->suspend(codec);

				codec->suspended = 1;

				codec->cache_sync = 1;

				if (codec->component.regmap)

					regcache_mark_dirty(codec->component.regmap);

				/* deactivate pins to sleep state */