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

Commit 4e7e2a20 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://opensource.wolfsonmicro.com/regmap 

* 'for-linus' of git://opensource.wolfsonmicro.com/regmap: (62 commits)
  mfd: Enable rbtree cache for wm831x devices
  regmap: Support some block operations on cached devices
  regmap: Allow caches for devices with no defaults
  regmap: Ensure rbtree syncs registers set to zero properly
  regmap: Allow rbtree to cache zero default values
  regmap: Warn on raw I/O as well as bulk reads that bypass cache
  regmap: Return a sensible error code if we fail to read the cache
  regmap: Use bsearch() to search the register defaults
  regmap: Fix doc comment
  regmap: Optimize the lookup path to use binary search
  regmap: Ensure we scream if we enable cache bypass/only at the same time
  regmap: Implement regcache_cache_bypass helper function
  regmap: Save/restore the bypass state upon syncing
  regmap: Lock the sync path, ensure we use the lockless _regmap_write()
  regmap: Fix apostrophe usage
  regmap: Make _regmap_write() global
  regmap: Fix lock used for regcache_cache_only()
  regmap: Grab the lock in regcache_cache_only()
  regmap: Modify map->cache_bypass directly
  regmap: Fix regcache_sync generic implementation
  ...
parents 8a9ea323 7cccbdc8

drivers/base/regmap/Kconfig

+2 −0
Original line number Original line Diff line number Diff line
@@ -4,6 +4,8 @@ 




config REGMAP

config REGMAP

	default y if (REGMAP_I2C || REGMAP_SPI)

	default y if (REGMAP_I2C || REGMAP_SPI)

	select LZO_COMPRESS

	select LZO_DECOMPRESS

	bool

	bool





config REGMAP_I2C

config REGMAP_I2C

drivers/base/regmap/Makefile

+2 −1
Original line number Original line Diff line number Diff line 
obj-$(CONFIG_REGMAP) += regmap.o

obj-$(CONFIG_REGMAP) += regmap.o regcache.o regcache-indexed.o regcache-rbtree.o regcache-lzo.o

obj-$(CONFIG_DEBUG_FS) += regmap-debugfs.o

obj-$(CONFIG_REGMAP_I2C) += regmap-i2c.o

obj-$(CONFIG_REGMAP_I2C) += regmap-i2c.o

obj-$(CONFIG_REGMAP_SPI) += regmap-spi.o
 
obj-$(CONFIG_REGMAP_SPI) += regmap-spi.o

drivers/base/regmap/internal.h

0 → 100644
+128 −0
Original line number Original line Diff line number Diff line 
/*

 * Register map access API internal header

 *

 * Copyright 2011 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 version 2 as

 * published by the Free Software Foundation.

 */



#ifndef _REGMAP_INTERNAL_H

#define _REGMAP_INTERNAL_H



#include <linux/regmap.h>

#include <linux/fs.h>



struct regmap;

struct regcache_ops;



struct regmap_format {

	size_t buf_size;

	size_t reg_bytes;

	size_t val_bytes;

	void (*format_write)(struct regmap *map,

			     unsigned int reg, unsigned int val);

	void (*format_reg)(void *buf, unsigned int reg);

	void (*format_val)(void *buf, unsigned int val);

	unsigned int (*parse_val)(void *buf);

};



struct regmap {

	struct mutex lock;



	struct device *dev; /* Device we do I/O on */

	void *work_buf;     /* Scratch buffer used to format I/O */

	struct regmap_format format;  /* Buffer format */

	const struct regmap_bus *bus;



#ifdef CONFIG_DEBUG_FS

	struct dentry *debugfs;

#endif



	unsigned int max_register;

	bool (*writeable_reg)(struct device *dev, unsigned int reg);

	bool (*readable_reg)(struct device *dev, unsigned int reg);

	bool (*volatile_reg)(struct device *dev, unsigned int reg);

	bool (*precious_reg)(struct device *dev, unsigned int reg);



	u8 read_flag_mask;

	u8 write_flag_mask;



	/* regcache specific members */

	const struct regcache_ops *cache_ops;

	enum regcache_type cache_type;



	/* number of bytes in reg_defaults_raw */

	unsigned int cache_size_raw;

	/* number of bytes per word in reg_defaults_raw */

	unsigned int cache_word_size;

	/* number of entries in reg_defaults */

	unsigned int num_reg_defaults;

	/* number of entries in reg_defaults_raw */

	unsigned int num_reg_defaults_raw;



	/* if set, only the cache is modified not the HW */

	unsigned int cache_only:1;

	/* if set, only the HW is modified not the cache */

	unsigned int cache_bypass:1;

	/* if set, remember to free reg_defaults_raw */

	unsigned int cache_free:1;



	struct reg_default *reg_defaults;

	const void *reg_defaults_raw;

	void *cache;

};



struct regcache_ops {

	const char *name;

	enum regcache_type type;

	int (*init)(struct regmap *map);

	int (*exit)(struct regmap *map);

	int (*read)(struct regmap *map, unsigned int reg, unsigned int *value);

	int (*write)(struct regmap *map, unsigned int reg, unsigned int value);

	int (*sync)(struct regmap *map);

};



bool regmap_writeable(struct regmap *map, unsigned int reg);

bool regmap_readable(struct regmap *map, unsigned int reg);

bool regmap_volatile(struct regmap *map, unsigned int reg);

bool regmap_precious(struct regmap *map, unsigned int reg);



int _regmap_write(struct regmap *map, unsigned int reg,

		  unsigned int val);



#ifdef CONFIG_DEBUG_FS

extern void regmap_debugfs_initcall(void);

extern void regmap_debugfs_init(struct regmap *map);

extern void regmap_debugfs_exit(struct regmap *map);

#else

static inline void regmap_debugfs_initcall(void) { }

static inline void regmap_debugfs_init(struct regmap *map) { }

static inline void regmap_debugfs_exit(struct regmap *map) { }

#endif



/* regcache core declarations */

int regcache_init(struct regmap *map);

void regcache_exit(struct regmap *map);

int regcache_read(struct regmap *map,

		       unsigned int reg, unsigned int *value);

int regcache_write(struct regmap *map,

			unsigned int reg, unsigned int value);

int regcache_sync(struct regmap *map);



unsigned int regcache_get_val(const void *base, unsigned int idx,

			      unsigned int word_size);

bool regcache_set_val(void *base, unsigned int idx,

		      unsigned int val, unsigned int word_size);

int regcache_lookup_reg(struct regmap *map, unsigned int reg);

int regcache_insert_reg(struct regmap *map, unsigned int reg,

			unsigned int val);



extern struct regcache_ops regcache_indexed_ops;

extern struct regcache_ops regcache_rbtree_ops;

extern struct regcache_ops regcache_lzo_ops;



#endif

drivers/base/regmap/regcache-indexed.c

0 → 100644
+64 −0
Original line number Original line Diff line number Diff line 
/*

 * Register cache access API - indexed caching support

 *

 * Copyright 2011 Wolfson Microelectronics plc

 *

 * Author: Dimitris Papastamos <dp@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 version 2 as

 * published by the Free Software Foundation.

 */



#include <linux/slab.h>



#include "internal.h"



static int regcache_indexed_read(struct regmap *map, unsigned int reg,

				 unsigned int *value)

{

	int ret;



	ret = regcache_lookup_reg(map, reg);

	if (ret >= 0)

		*value = map->reg_defaults[ret].def;



	return ret;

}



static int regcache_indexed_write(struct regmap *map, unsigned int reg,

				  unsigned int value)

{

	int ret;



	ret = regcache_lookup_reg(map, reg);

	if (ret < 0)

		return regcache_insert_reg(map, reg, value);

	map->reg_defaults[ret].def = value;

	return 0;

}



static int regcache_indexed_sync(struct regmap *map)

{

	unsigned int i;

	int ret;



	for (i = 0; i < map->num_reg_defaults; i++) {

		ret = _regmap_write(map, map->reg_defaults[i].reg,

				    map->reg_defaults[i].def);

		if (ret < 0)

			return ret;

		dev_dbg(map->dev, "Synced register %#x, value %#x\n",

			map->reg_defaults[i].reg,

			map->reg_defaults[i].def);

	}

	return 0;

}



struct regcache_ops regcache_indexed_ops = {

	.type = REGCACHE_INDEXED,

	.name = "indexed",

	.read = regcache_indexed_read,

	.write = regcache_indexed_write,

	.sync = regcache_indexed_sync

};

drivers/base/regmap/regcache-lzo.c

0 → 100644
+361 −0
Original line number Original line Diff line number Diff line 
/*

 * Register cache access API - LZO caching support

 *

 * Copyright 2011 Wolfson Microelectronics plc

 *

 * Author: Dimitris Papastamos <dp@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 version 2 as

 * published by the Free Software Foundation.

 */



#include <linux/slab.h>

#include <linux/lzo.h>



#include "internal.h"



struct regcache_lzo_ctx {

	void *wmem;

	void *dst;

	const void *src;

	size_t src_len;

	size_t dst_len;

	size_t decompressed_size;

	unsigned long *sync_bmp;

	int sync_bmp_nbits;

};



#define LZO_BLOCK_NUM 8

static int regcache_lzo_block_count(void)

{

	return LZO_BLOCK_NUM;

}



static int regcache_lzo_prepare(struct regcache_lzo_ctx *lzo_ctx)

{

	lzo_ctx->wmem = kmalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);

	if (!lzo_ctx->wmem)

		return -ENOMEM;

	return 0;

}



static int regcache_lzo_compress(struct regcache_lzo_ctx *lzo_ctx)

{

	size_t compress_size;

	int ret;



	ret = lzo1x_1_compress(lzo_ctx->src, lzo_ctx->src_len,

			       lzo_ctx->dst, &compress_size, lzo_ctx->wmem);

	if (ret != LZO_E_OK || compress_size > lzo_ctx->dst_len)

		return -EINVAL;

	lzo_ctx->dst_len = compress_size;

	return 0;

}



static int regcache_lzo_decompress(struct regcache_lzo_ctx *lzo_ctx)

{

	size_t dst_len;

	int ret;



	dst_len = lzo_ctx->dst_len;

	ret = lzo1x_decompress_safe(lzo_ctx->src, lzo_ctx->src_len,

				    lzo_ctx->dst, &dst_len);

	if (ret != LZO_E_OK || dst_len != lzo_ctx->dst_len)

		return -EINVAL;

	return 0;

}



static int regcache_lzo_compress_cache_block(struct regmap *map,

		struct regcache_lzo_ctx *lzo_ctx)

{

	int ret;



	lzo_ctx->dst_len = lzo1x_worst_compress(PAGE_SIZE);

	lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL);

	if (!lzo_ctx->dst) {

		lzo_ctx->dst_len = 0;

		return -ENOMEM;

	}



	ret = regcache_lzo_compress(lzo_ctx);

	if (ret < 0)

		return ret;

	return 0;

}



static int regcache_lzo_decompress_cache_block(struct regmap *map,

		struct regcache_lzo_ctx *lzo_ctx)

{

	int ret;



	lzo_ctx->dst_len = lzo_ctx->decompressed_size;

	lzo_ctx->dst = kmalloc(lzo_ctx->dst_len, GFP_KERNEL);

	if (!lzo_ctx->dst) {

		lzo_ctx->dst_len = 0;

		return -ENOMEM;

	}



	ret = regcache_lzo_decompress(lzo_ctx);

	if (ret < 0)

		return ret;

	return 0;

}



static inline int regcache_lzo_get_blkindex(struct regmap *map,

					    unsigned int reg)

{

	return (reg * map->cache_word_size) /

		DIV_ROUND_UP(map->cache_size_raw, regcache_lzo_block_count());

}



static inline int regcache_lzo_get_blkpos(struct regmap *map,

					  unsigned int reg)

{

	return reg % (DIV_ROUND_UP(map->cache_size_raw, regcache_lzo_block_count()) /

		      map->cache_word_size);

}



static inline int regcache_lzo_get_blksize(struct regmap *map)

{

	return DIV_ROUND_UP(map->cache_size_raw, regcache_lzo_block_count());

}



static int regcache_lzo_init(struct regmap *map)

{

	struct regcache_lzo_ctx **lzo_blocks;

	size_t bmp_size;

	int ret, i, blksize, blkcount;

	const char *p, *end;

	unsigned long *sync_bmp;



	ret = 0;



	blkcount = regcache_lzo_block_count();

	map->cache = kzalloc(blkcount * sizeof *lzo_blocks,

			     GFP_KERNEL);

	if (!map->cache)

		return -ENOMEM;

	lzo_blocks = map->cache;



	/*

	 * allocate a bitmap to be used when syncing the cache with

	 * the hardware.  Each time a register is modified, the corresponding

	 * bit is set in the bitmap, so we know that we have to sync

	 * that register.

	 */

	bmp_size = map->num_reg_defaults_raw;

	sync_bmp = kmalloc(BITS_TO_LONGS(bmp_size) * sizeof(long),

			   GFP_KERNEL);

	if (!sync_bmp) {

		ret = -ENOMEM;

		goto err;

	}

	bitmap_zero(sync_bmp, bmp_size);



	/* allocate the lzo blocks and initialize them */

	for (i = 0; i < blkcount; i++) {

		lzo_blocks[i] = kzalloc(sizeof **lzo_blocks,

					GFP_KERNEL);

		if (!lzo_blocks[i]) {

			kfree(sync_bmp);

			ret = -ENOMEM;

			goto err;

		}

		lzo_blocks[i]->sync_bmp = sync_bmp;

		lzo_blocks[i]->sync_bmp_nbits = bmp_size;

		/* alloc the working space for the compressed block */

		ret = regcache_lzo_prepare(lzo_blocks[i]);

		if (ret < 0)

			goto err;

	}



	blksize = regcache_lzo_get_blksize(map);

	p = map->reg_defaults_raw;

	end = map->reg_defaults_raw + map->cache_size_raw;

	/* compress the register map and fill the lzo blocks */

	for (i = 0; i < blkcount; i++, p += blksize) {

		lzo_blocks[i]->src = p;

		if (p + blksize > end)

			lzo_blocks[i]->src_len = end - p;

		else

			lzo_blocks[i]->src_len = blksize;

		ret = regcache_lzo_compress_cache_block(map,

						       lzo_blocks[i]);

		if (ret < 0)

			goto err;

		lzo_blocks[i]->decompressed_size =

			lzo_blocks[i]->src_len;

	}



	return 0;

err:

	regcache_exit(map);

	return ret;

}



static int regcache_lzo_exit(struct regmap *map)

{

	struct regcache_lzo_ctx **lzo_blocks;

	int i, blkcount;



	lzo_blocks = map->cache;

	if (!lzo_blocks)

		return 0;



	blkcount = regcache_lzo_block_count();

	/*

	 * the pointer to the bitmap used for syncing the cache

	 * is shared amongst all lzo_blocks.  Ensure it is freed

	 * only once.

	 */

	if (lzo_blocks[0])

		kfree(lzo_blocks[0]->sync_bmp);

	for (i = 0; i < blkcount; i++) {

		if (lzo_blocks[i]) {

			kfree(lzo_blocks[i]->wmem);

			kfree(lzo_blocks[i]->dst);

		}

		/* each lzo_block is a pointer returned by kmalloc or NULL */

		kfree(lzo_blocks[i]);

	}

	kfree(lzo_blocks);

	map->cache = NULL;

	return 0;

}



static int regcache_lzo_read(struct regmap *map,

			     unsigned int reg, unsigned int *value)

{

	struct regcache_lzo_ctx *lzo_block, **lzo_blocks;

	int ret, blkindex, blkpos;

	size_t blksize, tmp_dst_len;

	void *tmp_dst;



	/* index of the compressed lzo block */

	blkindex = regcache_lzo_get_blkindex(map, reg);

	/* register index within the decompressed block */

	blkpos = regcache_lzo_get_blkpos(map, reg);

	/* size of the compressed block */

	blksize = regcache_lzo_get_blksize(map);

	lzo_blocks = map->cache;

	lzo_block = lzo_blocks[blkindex];



	/* save the pointer and length of the compressed block */

	tmp_dst = lzo_block->dst;

	tmp_dst_len = lzo_block->dst_len;



	/* prepare the source to be the compressed block */

	lzo_block->src = lzo_block->dst;

	lzo_block->src_len = lzo_block->dst_len;



	/* decompress the block */

	ret = regcache_lzo_decompress_cache_block(map, lzo_block);

	if (ret >= 0)

		/* fetch the value from the cache */

		*value = regcache_get_val(lzo_block->dst, blkpos,

					  map->cache_word_size);



	kfree(lzo_block->dst);

	/* restore the pointer and length of the compressed block */

	lzo_block->dst = tmp_dst;

	lzo_block->dst_len = tmp_dst_len;



	return ret;

}



static int regcache_lzo_write(struct regmap *map,

			      unsigned int reg, unsigned int value)

{

	struct regcache_lzo_ctx *lzo_block, **lzo_blocks;

	int ret, blkindex, blkpos;

	size_t blksize, tmp_dst_len;

	void *tmp_dst;



	/* index of the compressed lzo block */

	blkindex = regcache_lzo_get_blkindex(map, reg);

	/* register index within the decompressed block */

	blkpos = regcache_lzo_get_blkpos(map, reg);

	/* size of the compressed block */

	blksize = regcache_lzo_get_blksize(map);

	lzo_blocks = map->cache;

	lzo_block = lzo_blocks[blkindex];



	/* save the pointer and length of the compressed block */

	tmp_dst = lzo_block->dst;

	tmp_dst_len = lzo_block->dst_len;



	/* prepare the source to be the compressed block */

	lzo_block->src = lzo_block->dst;

	lzo_block->src_len = lzo_block->dst_len;



	/* decompress the block */

	ret = regcache_lzo_decompress_cache_block(map, lzo_block);

	if (ret < 0) {

		kfree(lzo_block->dst);

		goto out;

	}



	/* write the new value to the cache */

	if (regcache_set_val(lzo_block->dst, blkpos, value,

			     map->cache_word_size)) {

		kfree(lzo_block->dst);

		goto out;

	}



	/* prepare the source to be the decompressed block */

	lzo_block->src = lzo_block->dst;

	lzo_block->src_len = lzo_block->dst_len;



	/* compress the block */

	ret = regcache_lzo_compress_cache_block(map, lzo_block);

	if (ret < 0) {

		kfree(lzo_block->dst);

		kfree(lzo_block->src);

		goto out;

	}



	/* set the bit so we know we have to sync this register */

	set_bit(reg, lzo_block->sync_bmp);

	kfree(tmp_dst);

	kfree(lzo_block->src);

	return 0;

out:

	lzo_block->dst = tmp_dst;

	lzo_block->dst_len = tmp_dst_len;

	return ret;

}



static int regcache_lzo_sync(struct regmap *map)

{

	struct regcache_lzo_ctx **lzo_blocks;

	unsigned int val;

	int i;

	int ret;



	lzo_blocks = map->cache;

	for_each_set_bit(i, lzo_blocks[0]->sync_bmp, lzo_blocks[0]->sync_bmp_nbits) {

		ret = regcache_read(map, i, &val);

		if (ret)

			return ret;

		map->cache_bypass = 1;

		ret = _regmap_write(map, i, val);

		map->cache_bypass = 0;

		if (ret)

			return ret;

		dev_dbg(map->dev, "Synced register %#x, value %#x\n",

			i, val);

	}



	return 0;

}



struct regcache_ops regcache_lzo_ops = {

	.type = REGCACHE_LZO,

	.name = "lzo",

	.init = regcache_lzo_init,

	.exit = regcache_lzo_exit,

	.read = regcache_lzo_read,

	.write = regcache_lzo_write,

	.sync = regcache_lzo_sync

};