[mirror_ubuntu-bionic-kernel.git] / sound / soc / soc-cache.c

/*
 * soc-cache.c  --  ASoC register cache helpers
 *
 * Copyright 2009 Wolfson Microelectronics PLC.
 *
 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  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 <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:
		BUG();
	}
	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:
		BUG();
	}
	/* unreachable */
	return -1;
}

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;

		WARN_ON(!snd_soc_codec_writable_register(codec, i));

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

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)
{
	const struct snd_soc_codec_driver *codec_drv = codec->driver;

	if (codec_drv->reg_cache_default)
		codec->reg_cache = kmemdup(codec_drv->reg_cache_default,
					   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.
 *
 * @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)
{
	int ret;
	const char *name;

	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);
	trace_snd_soc_cache_sync(codec, name, "start");
	ret = codec->cache_ops->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);
Commit	Line	Data
	1	/*
	2	* soc-cache.c -- ASoC register cache helpers
	3	*
	4	* Copyright 2009 Wolfson Microelectronics PLC.
	5	*
	6	* Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2 of the License, or (at your
	11	* option) any later version.
	12	*/
	13
	14	#include <linux/i2c.h>
	15	#include <linux/spi/spi.h>
	16	#include <sound/soc.h>
	17	#include <linux/bitmap.h>
	18	#include <linux/rbtree.h>
	19	#include <linux/export.h>
	20
	21	#include <trace/events/asoc.h>
	22
	23	static bool snd_soc_set_cache_val(void *base, unsigned int idx,
	24	unsigned int val, unsigned int word_size)
	25	{
	26	switch (word_size) {
	27	case 1: {
	28	u8 *cache = base;
	29	if (cache[idx] == val)
	30	return true;
	31	cache[idx] = val;
	32	break;
	33	}
	34	case 2: {
	35	u16 *cache = base;
	36	if (cache[idx] == val)
	37	return true;
	38	cache[idx] = val;
	39	break;
	40	}
	41	default:
	42	BUG();
	43	}
	44	return false;
	45	}
	46
	47	static unsigned int snd_soc_get_cache_val(const void *base, unsigned int idx,
	48	unsigned int word_size)
	49	{
	50	if (!base)
	51	return -1;
	52
	53	switch (word_size) {
	54	case 1: {
	55	const u8 *cache = base;
	56	return cache[idx];
	57	}
	58	case 2: {
	59	const u16 *cache = base;
	60	return cache[idx];
	61	}
	62	default:
	63	BUG();
	64	}
	65	/* unreachable */
	66	return -1;
	67	}
	68
	69	static int snd_soc_flat_cache_sync(struct snd_soc_codec *codec)
	70	{
	71	int i;
	72	int ret;
	73	const struct snd_soc_codec_driver *codec_drv;
	74	unsigned int val;
	75
	76	codec_drv = codec->driver;
	77	for (i = 0; i < codec_drv->reg_cache_size; ++i) {
	78	ret = snd_soc_cache_read(codec, i, &val);
	79	if (ret)
	80	return ret;
	81	if (codec_drv->reg_cache_default)
	82	if (snd_soc_get_cache_val(codec_drv->reg_cache_default,
	83	i, codec_drv->reg_word_size) == val)
	84	continue;
	85
	86	WARN_ON(!snd_soc_codec_writable_register(codec, i));
	87
	88	ret = snd_soc_write(codec, i, val);
	89	if (ret)
	90	return ret;
	91	dev_dbg(codec->dev, "ASoC: Synced register %#x, value = %#x\n",
	92	i, val);
	93	}
	94	return 0;
	95	}
	96
	97	static int snd_soc_flat_cache_write(struct snd_soc_codec *codec,
	98	unsigned int reg, unsigned int value)
	99	{
	100	snd_soc_set_cache_val(codec->reg_cache, reg, value,
	101	codec->driver->reg_word_size);
	102	return 0;
	103	}
	104
	105	static int snd_soc_flat_cache_read(struct snd_soc_codec *codec,
	106	unsigned int reg, unsigned int *value)
	107	{
	108	*value = snd_soc_get_cache_val(codec->reg_cache, reg,
	109	codec->driver->reg_word_size);
	110	return 0;
	111	}
	112
	113	static int snd_soc_flat_cache_exit(struct snd_soc_codec *codec)
	114	{
	115	if (!codec->reg_cache)
	116	return 0;
	117	kfree(codec->reg_cache);
	118	codec->reg_cache = NULL;
	119	return 0;
	120	}
	121
	122	static int snd_soc_flat_cache_init(struct snd_soc_codec *codec)
	123	{
	124	const struct snd_soc_codec_driver *codec_drv = codec->driver;
	125
	126	if (codec_drv->reg_cache_default)
	127	codec->reg_cache = kmemdup(codec_drv->reg_cache_default,
	128	codec->reg_size, GFP_KERNEL);
	129	else
	130	codec->reg_cache = kzalloc(codec->reg_size, GFP_KERNEL);
	131	if (!codec->reg_cache)
	132	return -ENOMEM;
	133
	134	return 0;
	135	}
	136
	137	/* an array of all supported compression types */
	138	static const struct snd_soc_cache_ops cache_types[] = {
	139	/* Flat must be the first entry for fallback */
	140	{
	141	.id = SND_SOC_FLAT_COMPRESSION,
	142	.name = "flat",
	143	.init = snd_soc_flat_cache_init,
	144	.exit = snd_soc_flat_cache_exit,
	145	.read = snd_soc_flat_cache_read,
	146	.write = snd_soc_flat_cache_write,
	147	.sync = snd_soc_flat_cache_sync
	148	},
	149	};
	150
	151	int snd_soc_cache_init(struct snd_soc_codec *codec)
	152	{
	153	int i;
	154
	155	for (i = 0; i < ARRAY_SIZE(cache_types); ++i)
	156	if (cache_types[i].id == codec->compress_type)
	157	break;
	158
	159	/* Fall back to flat compression */
	160	if (i == ARRAY_SIZE(cache_types)) {
	161	dev_warn(codec->dev, "ASoC: Could not match compress type: %d\n",
	162	codec->compress_type);
	163	i = 0;
	164	}
	165
	166	mutex_init(&codec->cache_rw_mutex);
	167	codec->cache_ops = &cache_types[i];
	168
	169	if (codec->cache_ops->init) {
	170	if (codec->cache_ops->name)
	171	dev_dbg(codec->dev, "ASoC: Initializing %s cache for %s codec\n",
	172	codec->cache_ops->name, codec->name);
	173	return codec->cache_ops->init(codec);
	174	}
	175	return -ENOSYS;
	176	}
	177
	178	/*
	179	* NOTE: keep in mind that this function might be called
	180	* multiple times.
	181	*/
	182	int snd_soc_cache_exit(struct snd_soc_codec *codec)
	183	{
	184	if (codec->cache_ops && codec->cache_ops->exit) {
	185	if (codec->cache_ops->name)
	186	dev_dbg(codec->dev, "ASoC: Destroying %s cache for %s codec\n",
	187	codec->cache_ops->name, codec->name);
	188	return codec->cache_ops->exit(codec);
	189	}
	190	return -ENOSYS;
	191	}
	192
	193	/**
	194	* snd_soc_cache_read: Fetch the value of a given register from the cache.
	195	*
	196	* @codec: CODEC to configure.
	197	* @reg: The register index.
	198	* @value: The value to be returned.
	199	*/
	200	int snd_soc_cache_read(struct snd_soc_codec *codec,
	201	unsigned int reg, unsigned int *value)
	202	{
	203	int ret;
	204
	205	mutex_lock(&codec->cache_rw_mutex);
	206
	207	if (value && codec->cache_ops && codec->cache_ops->read) {
	208	ret = codec->cache_ops->read(codec, reg, value);
	209	mutex_unlock(&codec->cache_rw_mutex);
	210	return ret;
	211	}
	212
	213	mutex_unlock(&codec->cache_rw_mutex);
	214	return -ENOSYS;
	215	}
	216	EXPORT_SYMBOL_GPL(snd_soc_cache_read);
	217
	218	/**
	219	* snd_soc_cache_write: Set the value of a given register in the cache.
	220	*
	221	* @codec: CODEC to configure.
	222	* @reg: The register index.
	223	* @value: The new register value.
	224	*/
	225	int snd_soc_cache_write(struct snd_soc_codec *codec,
	226	unsigned int reg, unsigned int value)
	227	{
	228	int ret;
	229
	230	mutex_lock(&codec->cache_rw_mutex);
	231
	232	if (codec->cache_ops && codec->cache_ops->write) {
	233	ret = codec->cache_ops->write(codec, reg, value);
	234	mutex_unlock(&codec->cache_rw_mutex);
	235	return ret;
	236	}
	237
	238	mutex_unlock(&codec->cache_rw_mutex);
	239	return -ENOSYS;
	240	}
	241	EXPORT_SYMBOL_GPL(snd_soc_cache_write);
	242
	243	/**
	244	* snd_soc_cache_sync: Sync the register cache with the hardware.
	245	*
	246	* @codec: CODEC to configure.
	247	*
	248	* Any registers that should not be synced should be marked as
	249	* volatile. In general drivers can choose not to use the provided
	250	* syncing functionality if they so require.
	251	*/
	252	int snd_soc_cache_sync(struct snd_soc_codec *codec)
	253	{
	254	int ret;
	255	const char *name;
	256
	257	if (!codec->cache_sync) {
	258	return 0;
	259	}
	260
	261	if (!codec->cache_ops \|\| !codec->cache_ops->sync)
	262	return -ENOSYS;
	263
	264	if (codec->cache_ops->name)
	265	name = codec->cache_ops->name;
	266	else
	267	name = "unknown";
	268
	269	if (codec->cache_ops->name)
	270	dev_dbg(codec->dev, "ASoC: Syncing %s cache for %s codec\n",
	271	codec->cache_ops->name, codec->name);
	272	trace_snd_soc_cache_sync(codec, name, "start");
	273	ret = codec->cache_ops->sync(codec);
	274	if (!ret)
	275	codec->cache_sync = 0;
	276	trace_snd_soc_cache_sync(codec, name, "end");
	277	return ret;
	278	}
	279	EXPORT_SYMBOL_GPL(snd_soc_cache_sync);