Merge tag 'regmap-3.8' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regmap (99b8f42e) · Commits · e / devices / android_kernel_xiaomi_markw

drivers/base/regmap/internal.h

+21 −3

Original line number	Original line	Diff line number	Diff line
	@@ -15,10 +15,18 @@

	#include <linux/regmap.h>		#include <linux/regmap.h>
	#include <linux/fs.h>		#include <linux/fs.h>
			#include <linux/list.h>

	struct regmap;		struct regmap;
	struct regcache_ops;		struct regcache_ops;

			struct regmap_debugfs_off_cache {
			struct list_head list;
			off_t min;
			off_t max;
			unsigned int base_reg;
			};

	struct regmap_format {		struct regmap_format {
	size_t buf_size;		size_t buf_size;
	size_t reg_bytes;		size_t reg_bytes;
	@@ -31,14 +39,12 @@ struct regmap_format {
	unsigned int (parse_val)(void buf);		unsigned int (parse_val)(void buf);
	};		};

	typedef void (regmap_lock)(struct regmap map);
	typedef void (regmap_unlock)(struct regmap map);

	struct regmap {		struct regmap {
	struct mutex mutex;		struct mutex mutex;
	spinlock_t spinlock;		spinlock_t spinlock;
	regmap_lock lock;		regmap_lock lock;
	regmap_unlock unlock;		regmap_unlock unlock;
			void lock_arg; / This is passed to lock/unlock functions */

	struct device dev; / Device we do I/O on */		struct device dev; / Device we do I/O on */
	void work_buf; / Scratch buffer used to format I/O */		void work_buf; / Scratch buffer used to format I/O */
	@@ -50,6 +56,12 @@ struct regmap {
	#ifdef CONFIG_DEBUG_FS		#ifdef CONFIG_DEBUG_FS
	struct dentry *debugfs;		struct dentry *debugfs;
	const char *debugfs_name;		const char *debugfs_name;

			unsigned int debugfs_reg_len;
			unsigned int debugfs_val_len;
			unsigned int debugfs_tot_len;

			struct list_head debugfs_off_cache;
	#endif		#endif

	unsigned int max_register;		unsigned int max_register;
	@@ -57,6 +69,10 @@ struct regmap {
	bool (readable_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 (volatile_reg)(struct device dev, unsigned int reg);
	bool (precious_reg)(struct device dev, unsigned int reg);		bool (precious_reg)(struct device dev, unsigned int reg);
			const struct regmap_access_table *wr_table;
			const struct regmap_access_table *rd_table;
			const struct regmap_access_table *volatile_table;
			const struct regmap_access_table *precious_table;

	u8 read_flag_mask;		u8 read_flag_mask;
	u8 write_flag_mask;		u8 write_flag_mask;
	@@ -120,6 +136,8 @@ int _regmap_write(struct regmap *map, unsigned int reg,

	struct regmap_range_node {		struct regmap_range_node {
	struct rb_node node;		struct rb_node node;
			const char *name;
			struct regmap *map;

	unsigned int range_min;		unsigned int range_min;
	unsigned int range_max;		unsigned int range_max;

drivers/base/regmap/regmap-debugfs.c

+132 −16

Original line number	Original line	Diff line number	Diff line
	@@ -56,17 +56,74 @@ static const struct file_operations regmap_name_fops = {
	.llseek = default_llseek,		.llseek = default_llseek,
	};		};

	static ssize_t regmap_map_read_file(struct file file, char __user user_buf,		/*
			* Work out where the start offset maps into register numbers, bearing
			* in mind that we suppress hidden registers.
			*/
			static unsigned int regmap_debugfs_get_dump_start(struct regmap *map,
			unsigned int base,
			loff_t from,
			loff_t *pos)
			{
			struct regmap_debugfs_off_cache *c = NULL;
			loff_t p = 0;
			unsigned int i, ret;

			/*
			* If we don't have a cache build one so we don't have to do a
			* linear scan each time.
			*/
			if (list_empty(&map->debugfs_off_cache)) {
			for (i = base; i <= map->max_register; i += map->reg_stride) {
			/* Skip unprinted registers, closing off cache entry */
			if (!regmap_readable(map, i) \|\|
			regmap_precious(map, i)) {
			if (c) {
			c->max = p - 1;
			list_add_tail(&c->list,
			&map->debugfs_off_cache);
			c = NULL;
			}

			continue;
			}

			/* No cache entry? Start a new one */
			if (!c) {
			c = kzalloc(sizeof(*c), GFP_KERNEL);
			if (!c)
			break;
			c->min = p;
			c->base_reg = i;
			}

			p += map->debugfs_tot_len;
			}
			}

			/* Find the relevant block */
			list_for_each_entry(c, &map->debugfs_off_cache, list) {
			if (pos >= c->min && pos <= c->max) {
			*pos = c->min;
			return c->base_reg;
			}

			ret = c->max;
			}

			return ret;
			}

			static ssize_t regmap_read_debugfs(struct regmap *map, unsigned int from,
			unsigned int to, char __user *user_buf,
	size_t count, loff_t *ppos)		size_t count, loff_t *ppos)
	{		{
	int reg_len, val_len, tot_len;
	size_t buf_pos = 0;		size_t buf_pos = 0;
	loff_t p = 0;		loff_t p = *ppos;
	ssize_t ret;		ssize_t ret;
	int i;		int i;
	struct regmap *map = file->private_data;
	char *buf;		char *buf;
	unsigned int val;		unsigned int val, start_reg;

	if (*ppos < 0 \|\| !count)		if (*ppos < 0 \|\| !count)
	return -EINVAL;		return -EINVAL;
	@@ -76,11 +133,18 @@ static ssize_t regmap_map_read_file(struct file file, char __user user_buf,
	return -ENOMEM;		return -ENOMEM;

	/* Calculate the length of a fixed format */		/* Calculate the length of a fixed format */
	reg_len = regmap_calc_reg_len(map->max_register, buf, count);		if (!map->debugfs_tot_len) {
	val_len = 2 * map->format.val_bytes;		map->debugfs_reg_len = regmap_calc_reg_len(map->max_register,
	tot_len = reg_len + val_len + 3; /* : \n */		buf, count);
			map->debugfs_val_len = 2 * map->format.val_bytes;
			map->debugfs_tot_len = map->debugfs_reg_len +
			map->debugfs_val_len + 3; /* : \n */
			}

	for (i = 0; i <= map->max_register; i += map->reg_stride) {		/* Work out which register we're starting at */
			start_reg = regmap_debugfs_get_dump_start(map, from, *ppos, &p);

			for (i = start_reg; i <= to; i += map->reg_stride) {
	if (!regmap_readable(map, i))		if (!regmap_readable(map, i))
	continue;		continue;

	@@ -90,26 +154,27 @@ static ssize_t regmap_map_read_file(struct file file, char __user user_buf,
	/* If we're in the region the user is trying to read */		/* If we're in the region the user is trying to read */
	if (p >= *ppos) {		if (p >= *ppos) {
	/* ...but not beyond it */		/* ...but not beyond it */
	if (buf_pos >= count - 1 - tot_len)		if (buf_pos + 1 + map->debugfs_tot_len >= count)
	break;		break;

	/* Format the register */		/* Format the register */
	snprintf(buf + buf_pos, count - buf_pos, "%.*x: ",		snprintf(buf + buf_pos, count - buf_pos, "%.*x: ",
	reg_len, i);		map->debugfs_reg_len, i - from);
	buf_pos += reg_len + 2;		buf_pos += map->debugfs_reg_len + 2;

	/* Format the value, write all X if we can't read */		/* Format the value, write all X if we can't read */
	ret = regmap_read(map, i, &val);		ret = regmap_read(map, i, &val);
	if (ret == 0)		if (ret == 0)
	snprintf(buf + buf_pos, count - buf_pos,		snprintf(buf + buf_pos, count - buf_pos,
	"%.*x", val_len, val);		"%.*x", map->debugfs_val_len, val);
	else		else
	memset(buf + buf_pos, 'X', val_len);		memset(buf + buf_pos, 'X',
			map->debugfs_val_len);
	buf_pos += 2 * map->format.val_bytes;		buf_pos += 2 * map->format.val_bytes;

	buf[buf_pos++] = '\n';		buf[buf_pos++] = '\n';
	}		}
	p += tot_len;		p += map->debugfs_tot_len;
	}		}

	ret = buf_pos;		ret = buf_pos;
	@@ -126,6 +191,15 @@ out:
	return ret;		return ret;
	}		}

			static ssize_t regmap_map_read_file(struct file file, char __user user_buf,
			size_t count, loff_t *ppos)
			{
			struct regmap *map = file->private_data;

			return regmap_read_debugfs(map, 0, map->max_register, user_buf,
			count, ppos);
			}

	#undef REGMAP_ALLOW_WRITE_DEBUGFS		#undef REGMAP_ALLOW_WRITE_DEBUGFS
	#ifdef REGMAP_ALLOW_WRITE_DEBUGFS		#ifdef REGMAP_ALLOW_WRITE_DEBUGFS
	/*		/*
	@@ -174,6 +248,22 @@ static const struct file_operations regmap_map_fops = {
	.llseek = default_llseek,		.llseek = default_llseek,
	};		};

			static ssize_t regmap_range_read_file(struct file file, char __user user_buf,
			size_t count, loff_t *ppos)
			{
			struct regmap_range_node *range = file->private_data;
			struct regmap *map = range->map;

			return regmap_read_debugfs(map, range->range_min, range->range_max,
			user_buf, count, ppos);
			}

			static const struct file_operations regmap_range_fops = {
			.open = simple_open,
			.read = regmap_range_read_file,
			.llseek = default_llseek,
			};

	static ssize_t regmap_access_read_file(struct file *file,		static ssize_t regmap_access_read_file(struct file *file,
	char __user *user_buf, size_t count,		char __user *user_buf, size_t count,
	loff_t *ppos)		loff_t *ppos)
	@@ -244,6 +334,11 @@ static const struct file_operations regmap_access_fops = {

	void regmap_debugfs_init(struct regmap map, const char name)		void regmap_debugfs_init(struct regmap map, const char name)
	{		{
			struct rb_node *next;
			struct regmap_range_node *range_node;

			INIT_LIST_HEAD(&map->debugfs_off_cache);

	if (name) {		if (name) {
	map->debugfs_name = kasprintf(GFP_KERNEL, "%s-%s",		map->debugfs_name = kasprintf(GFP_KERNEL, "%s-%s",
	dev_name(map->dev), name);		dev_name(map->dev), name);
	@@ -276,11 +371,32 @@ void regmap_debugfs_init(struct regmap map, const char name)
	debugfs_create_bool("cache_bypass", 0400, map->debugfs,		debugfs_create_bool("cache_bypass", 0400, map->debugfs,
	&map->cache_bypass);		&map->cache_bypass);
	}		}

			next = rb_first(&map->range_tree);
			while (next) {
			range_node = rb_entry(next, struct regmap_range_node, node);

			if (range_node->name)
			debugfs_create_file(range_node->name, 0400,
			map->debugfs, range_node,
			&regmap_range_fops);

			next = rb_next(&range_node->node);
			}
	}		}

	void regmap_debugfs_exit(struct regmap *map)		void regmap_debugfs_exit(struct regmap *map)
	{		{
			struct regmap_debugfs_off_cache *c;

	debugfs_remove_recursive(map->debugfs);		debugfs_remove_recursive(map->debugfs);
			while (!list_empty(&map->debugfs_off_cache)) {
			c = list_first_entry(&map->debugfs_off_cache,
			struct regmap_debugfs_off_cache,
			list);
			list_del(&c->list);
			kfree(c);
			}
	kfree(map->debugfs_name);		kfree(map->debugfs_name);
	}		}

drivers/base/regmap/regmap-irq.c

+19 −0

Original line number	Original line	Diff line number	Diff line
	@@ -458,3 +458,22 @@ int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq)
	return irq_create_mapping(data->domain, irq);		return irq_create_mapping(data->domain, irq);
	}		}
	EXPORT_SYMBOL_GPL(regmap_irq_get_virq);		EXPORT_SYMBOL_GPL(regmap_irq_get_virq);

			/**
			* regmap_irq_get_domain(): Retrieve the irq_domain for the chip
			*
			* Useful for drivers to request their own IRQs and for integration
			* with subsystems. For ease of integration NULL is accepted as a
			* domain, allowing devices to just call this even if no domain is
			* allocated.
			*
			* @data: regmap_irq controller to operate on.
			*/
			struct irq_domain regmap_irq_get_domain(struct regmap_irq_chip_data data)
			{
			if (data)
			return data->domain;
			else
			return NULL;
			}
			EXPORT_SYMBOL_GPL(regmap_irq_get_domain);

drivers/base/regmap/regmap.c

+193 −76

Original line number	Original line	Diff line number	Diff line
	@@ -34,6 +34,36 @@ static int _regmap_update_bits(struct regmap *map, unsigned int reg,
	unsigned int mask, unsigned int val,		unsigned int mask, unsigned int val,
	bool *change);		bool *change);

			bool regmap_reg_in_ranges(unsigned int reg,
			const struct regmap_range *ranges,
			unsigned int nranges)
			{
			const struct regmap_range *r;
			int i;

			for (i = 0, r = ranges; i < nranges; i++, r++)
			if (regmap_reg_in_range(reg, r))
			return true;
			return false;
			}
			EXPORT_SYMBOL_GPL(regmap_reg_in_ranges);

			static bool _regmap_check_range_table(struct regmap *map,
			unsigned int reg,
			const struct regmap_access_table *table)
			{
			/* Check "no ranges" first */
			if (regmap_reg_in_ranges(reg, table->no_ranges, table->n_no_ranges))
			return false;

			/* In case zero "yes ranges" are supplied, any reg is OK */
			if (!table->n_yes_ranges)
			return true;

			return regmap_reg_in_ranges(reg, table->yes_ranges,
			table->n_yes_ranges);
			}

	bool regmap_writeable(struct regmap *map, unsigned int reg)		bool regmap_writeable(struct regmap *map, unsigned int reg)
	{		{
	if (map->max_register && reg > map->max_register)		if (map->max_register && reg > map->max_register)
	@@ -42,6 +72,9 @@ bool regmap_writeable(struct regmap *map, unsigned int reg)
	if (map->writeable_reg)		if (map->writeable_reg)
	return map->writeable_reg(map->dev, reg);		return map->writeable_reg(map->dev, reg);

			if (map->wr_table)
			return _regmap_check_range_table(map, reg, map->wr_table);

	return true;		return true;
	}		}

	@@ -56,6 +89,9 @@ bool regmap_readable(struct regmap *map, unsigned int reg)
	if (map->readable_reg)		if (map->readable_reg)
	return map->readable_reg(map->dev, reg);		return map->readable_reg(map->dev, reg);

			if (map->rd_table)
			return _regmap_check_range_table(map, reg, map->rd_table);

	return true;		return true;
	}		}

	@@ -67,6 +103,9 @@ bool regmap_volatile(struct regmap *map, unsigned int reg)
	if (map->volatile_reg)		if (map->volatile_reg)
	return map->volatile_reg(map->dev, reg);		return map->volatile_reg(map->dev, reg);

			if (map->volatile_table)
			return _regmap_check_range_table(map, reg, map->volatile_table);

	return true;		return true;
	}		}

	@@ -78,11 +117,14 @@ bool regmap_precious(struct regmap *map, unsigned int reg)
	if (map->precious_reg)		if (map->precious_reg)
	return map->precious_reg(map->dev, reg);		return map->precious_reg(map->dev, reg);

			if (map->precious_table)
			return _regmap_check_range_table(map, reg, map->precious_table);

	return false;		return false;
	}		}

	static bool regmap_volatile_range(struct regmap *map, unsigned int reg,		static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
	unsigned int num)		size_t num)
	{		{
	unsigned int i;		unsigned int i;

	@@ -214,23 +256,27 @@ static unsigned int regmap_parse_32_native(void *buf)
	return (u32 )buf;		return (u32 )buf;
	}		}

	static void regmap_lock_mutex(struct regmap *map)		static void regmap_lock_mutex(void *__map)
	{		{
			struct regmap *map = __map;
	mutex_lock(&map->mutex);		mutex_lock(&map->mutex);
	}		}

	static void regmap_unlock_mutex(struct regmap *map)		static void regmap_unlock_mutex(void *__map)
	{		{
			struct regmap *map = __map;
	mutex_unlock(&map->mutex);		mutex_unlock(&map->mutex);
	}		}

	static void regmap_lock_spinlock(struct regmap *map)		static void regmap_lock_spinlock(void *__map)
	{		{
			struct regmap *map = __map;
	spin_lock(&map->spinlock);		spin_lock(&map->spinlock);
	}		}

	static void regmap_unlock_spinlock(struct regmap *map)		static void regmap_unlock_spinlock(void *__map)
	{		{
			struct regmap *map = __map;
	spin_unlock(&map->spinlock);		spin_unlock(&map->spinlock);
	}		}

	@@ -335,6 +381,11 @@ struct regmap regmap_init(struct device dev,
	goto err;		goto err;
	}		}

			if (config->lock && config->unlock) {
			map->lock = config->lock;
			map->unlock = config->unlock;
			map->lock_arg = config->lock_arg;
			} else {
	if (bus->fast_io) {		if (bus->fast_io) {
	spin_lock_init(&map->spinlock);		spin_lock_init(&map->spinlock);
	map->lock = regmap_lock_spinlock;		map->lock = regmap_lock_spinlock;
	@@ -344,6 +395,8 @@ struct regmap regmap_init(struct device dev,
	map->lock = regmap_lock_mutex;		map->lock = regmap_lock_mutex;
	map->unlock = regmap_unlock_mutex;		map->unlock = regmap_unlock_mutex;
	}		}
			map->lock_arg = map;
			}
	map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);		map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
	map->format.pad_bytes = config->pad_bits / 8;		map->format.pad_bytes = config->pad_bits / 8;
	map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);		map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
	@@ -359,6 +412,10 @@ struct regmap regmap_init(struct device dev,
	map->bus = bus;		map->bus = bus;
	map->bus_context = bus_context;		map->bus_context = bus_context;
	map->max_register = config->max_register;		map->max_register = config->max_register;
			map->wr_table = config->wr_table;
			map->rd_table = config->rd_table;
			map->volatile_table = config->volatile_table;
			map->precious_table = config->precious_table;
	map->writeable_reg = config->writeable_reg;		map->writeable_reg = config->writeable_reg;
	map->readable_reg = config->readable_reg;		map->readable_reg = config->readable_reg;
	map->volatile_reg = config->volatile_reg;		map->volatile_reg = config->volatile_reg;
	@@ -519,20 +576,38 @@ struct regmap regmap_init(struct device dev,
	}		}

	map->range_tree = RB_ROOT;		map->range_tree = RB_ROOT;
	for (i = 0; i < config->n_ranges; i++) {		for (i = 0; i < config->num_ranges; i++) {
	const struct regmap_range_cfg *range_cfg = &config->ranges[i];		const struct regmap_range_cfg *range_cfg = &config->ranges[i];
	struct regmap_range_node *new;		struct regmap_range_node *new;

	/* Sanity check */		/* Sanity check */
	if (range_cfg->range_max < range_cfg->range_min \|\|		if (range_cfg->range_max < range_cfg->range_min) {
	range_cfg->range_max > map->max_register \|\|		dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
	range_cfg->selector_reg > map->max_register \|\|		range_cfg->range_max, range_cfg->range_min);
	range_cfg->window_len == 0)		goto err_range;
			}

			if (range_cfg->range_max > map->max_register) {
			dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
			range_cfg->range_max, map->max_register);
			goto err_range;
			}

			if (range_cfg->selector_reg > map->max_register) {
			dev_err(map->dev,
			"Invalid range %d: selector out of map\n", i);
			goto err_range;
			}

			if (range_cfg->window_len == 0) {
			dev_err(map->dev, "Invalid range %d: window_len 0\n",
			i);
	goto err_range;		goto err_range;
			}

	/* Make sure, that this register range has no selector		/* Make sure, that this register range has no selector
	or data window within its boundary */		or data window within its boundary */
	for (j = 0; j < config->n_ranges; j++) {		for (j = 0; j < config->num_ranges; j++) {
	unsigned sel_reg = config->ranges[j].selector_reg;		unsigned sel_reg = config->ranges[j].selector_reg;
	unsigned win_min = config->ranges[j].window_start;		unsigned win_min = config->ranges[j].window_start;
	unsigned win_max = win_min +		unsigned win_max = win_min +
	@@ -540,11 +615,17 @@ struct regmap regmap_init(struct device dev,

	if (range_cfg->range_min <= sel_reg &&		if (range_cfg->range_min <= sel_reg &&
	sel_reg <= range_cfg->range_max) {		sel_reg <= range_cfg->range_max) {
			dev_err(map->dev,
			"Range %d: selector for %d in window\n",
			i, j);
	goto err_range;		goto err_range;
	}		}

	if (!(win_max < range_cfg->range_min \|\|		if (!(win_max < range_cfg->range_min \|\|
	win_min > range_cfg->range_max)) {		win_min > range_cfg->range_max)) {
			dev_err(map->dev,
			"Range %d: window for %d in window\n",
			i, j);
	goto err_range;		goto err_range;
	}		}
	}		}
	@@ -555,6 +636,8 @@ struct regmap regmap_init(struct device dev,
	goto err_range;		goto err_range;
	}		}

			new->map = map;
			new->name = range_cfg->name;
	new->range_min = range_cfg->range_min;		new->range_min = range_cfg->range_min;
	new->range_max = range_cfg->range_max;		new->range_max = range_cfg->range_max;
	new->selector_reg = range_cfg->selector_reg;		new->selector_reg = range_cfg->selector_reg;
	@@ -564,6 +647,7 @@ struct regmap regmap_init(struct device dev,
	new->window_len = range_cfg->window_len;		new->window_len = range_cfg->window_len;

	if (_regmap_range_add(map, new) == false) {		if (_regmap_range_add(map, new) == false) {
			dev_err(map->dev, "Failed to add range %d\n", i);
	kfree(new);		kfree(new);
	goto err_range;		goto err_range;
	}		}
	@@ -579,7 +663,7 @@ struct regmap regmap_init(struct device dev,
	}		}

	ret = regcache_init(map, config);		ret = regcache_init(map, config);
	if (ret < 0)		if (ret != 0)
	goto err_range;		goto err_range;

	regmap_debugfs_init(map, config->name);		regmap_debugfs_init(map, config->name);
	@@ -738,17 +822,15 @@ struct regmap dev_get_regmap(struct device dev, const char *name)
	EXPORT_SYMBOL_GPL(dev_get_regmap);		EXPORT_SYMBOL_GPL(dev_get_regmap);

	static int _regmap_select_page(struct regmap map, unsigned int reg,		static int _regmap_select_page(struct regmap map, unsigned int reg,
			struct regmap_range_node *range,
	unsigned int val_num)		unsigned int val_num)
	{		{
	struct regmap_range_node *range;
	void *orig_work_buf;		void *orig_work_buf;
	unsigned int win_offset;		unsigned int win_offset;
	unsigned int win_page;		unsigned int win_page;
	bool page_chg;		bool page_chg;
	int ret;		int ret;

	range = _regmap_range_lookup(map, *reg);
	if (range) {
	win_offset = (*reg - range->range_min) % range->window_len;		win_offset = (*reg - range->range_min) % range->window_len;
	win_page = (*reg - range->range_min) / range->window_len;		win_page = (*reg - range->range_min) / range->window_len;

	@@ -778,12 +860,11 @@ static int _regmap_select_page(struct regmap map, unsigned int reg,

	map->work_buf = orig_work_buf;		map->work_buf = orig_work_buf;

	if (ret < 0)		if (ret != 0)
	return ret;		return ret;
	}		}

	*reg = range->window_start + win_offset;		*reg = range->window_start + win_offset;
	}

	return 0;		return 0;
	}		}
	@@ -791,6 +872,7 @@ static int _regmap_select_page(struct regmap map, unsigned int reg,
	static int _regmap_raw_write(struct regmap *map, unsigned int reg,		static int _regmap_raw_write(struct regmap *map, unsigned int reg,
	const void *val, size_t val_len)		const void *val, size_t val_len)
	{		{
			struct regmap_range_node *range;
	u8 *u8 = map->work_buf;		u8 *u8 = map->work_buf;
	void *buf;		void *buf;
	int ret = -ENOTSUPP;		int ret = -ENOTSUPP;
	@@ -814,7 +896,7 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
	ival);		ival);
	if (ret) {		if (ret) {
	dev_err(map->dev,		dev_err(map->dev,
	"Error in caching of register: %u ret: %d\n",		"Error in caching of register: %x ret: %d\n",
	reg + i, ret);		reg + i, ret);
	return ret;		return ret;
	}		}
	@@ -825,10 +907,36 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
	}		}
	}		}

	ret = _regmap_select_page(map, &reg, val_len / map->format.val_bytes);		range = _regmap_range_lookup(map, reg);
	if (ret < 0)		if (range) {
			int val_num = val_len / map->format.val_bytes;
			int win_offset = (reg - range->range_min) % range->window_len;
			int win_residue = range->window_len - win_offset;

			/* If the write goes beyond the end of the window split it */
			while (val_num > win_residue) {
			dev_dbg(map->dev, "Writing window %d/%zu\n",
			win_residue, val_len / map->format.val_bytes);
			ret = _regmap_raw_write(map, reg, val, win_residue *
			map->format.val_bytes);
			if (ret != 0)
	return ret;		return ret;

			reg += win_residue;
			val_num -= win_residue;
			val += win_residue * map->format.val_bytes;
			val_len -= win_residue * map->format.val_bytes;

			win_offset = (reg - range->range_min) %
			range->window_len;
			win_residue = range->window_len - win_offset;
			}

			ret = _regmap_select_page(map, &reg, range, val_num);
			if (ret != 0)
			return ret;
			}

	map->format.format_reg(map->work_buf, reg, map->reg_shift);		map->format.format_reg(map->work_buf, reg, map->reg_shift);

	u8[0] \|= map->write_flag_mask;		u8[0] \|= map->write_flag_mask;
	@@ -876,6 +984,7 @@ static int _regmap_raw_write(struct regmap *map, unsigned int reg,
	int _regmap_write(struct regmap *map, unsigned int reg,		int _regmap_write(struct regmap *map, unsigned int reg,
	unsigned int val)		unsigned int val)
	{		{
			struct regmap_range_node *range;
	int ret;		int ret;
	BUG_ON(!map->format.format_write && !map->format.format_val);		BUG_ON(!map->format.format_write && !map->format.format_val);

	@@ -897,9 +1006,12 @@ int _regmap_write(struct regmap *map, unsigned int reg,
	trace_regmap_reg_write(map->dev, reg, val);		trace_regmap_reg_write(map->dev, reg, val);

	if (map->format.format_write) {		if (map->format.format_write) {
	ret = _regmap_select_page(map, &reg, 1);		range = _regmap_range_lookup(map, reg);
	if (ret < 0)		if (range) {
			ret = _regmap_select_page(map, &reg, range, 1);
			if (ret != 0)
	return ret;		return ret;
			}

	map->format.format_write(map, reg, val);		map->format.format_write(map, reg, val);

	@@ -939,11 +1051,11 @@ int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
	if (reg % map->reg_stride)		if (reg % map->reg_stride)
	return -EINVAL;		return -EINVAL;

	map->lock(map);		map->lock(map->lock_arg);

	ret = _regmap_write(map, reg, val);		ret = _regmap_write(map, reg, val);

	map->unlock(map);		map->unlock(map->lock_arg);

	return ret;		return ret;
	}		}
	@@ -975,11 +1087,11 @@ int regmap_raw_write(struct regmap *map, unsigned int reg,
	if (reg % map->reg_stride)		if (reg % map->reg_stride)
	return -EINVAL;		return -EINVAL;

	map->lock(map);		map->lock(map->lock_arg);

	ret = _regmap_raw_write(map, reg, val, val_len);		ret = _regmap_raw_write(map, reg, val, val_len);

	map->unlock(map);		map->unlock(map->lock_arg);

	return ret;		return ret;
	}		}
	@@ -1011,7 +1123,7 @@ int regmap_bulk_write(struct regmap map, unsigned int reg, const void val,
	if (reg % map->reg_stride)		if (reg % map->reg_stride)
	return -EINVAL;		return -EINVAL;

	map->lock(map);		map->lock(map->lock_arg);

	/* No formatting is require if val_byte is 1 */		/* No formatting is require if val_byte is 1 */
	if (val_bytes == 1) {		if (val_bytes == 1) {
	@@ -1047,7 +1159,7 @@ int regmap_bulk_write(struct regmap map, unsigned int reg, const void val,
	kfree(wval);		kfree(wval);

	out:		out:
	map->unlock(map);		map->unlock(map->lock_arg);
	return ret;		return ret;
	}		}
	EXPORT_SYMBOL_GPL(regmap_bulk_write);		EXPORT_SYMBOL_GPL(regmap_bulk_write);
	@@ -1055,12 +1167,17 @@ EXPORT_SYMBOL_GPL(regmap_bulk_write);
	static int _regmap_raw_read(struct regmap map, unsigned int reg, void val,		static int _regmap_raw_read(struct regmap map, unsigned int reg, void val,
	unsigned int val_len)		unsigned int val_len)
	{		{
			struct regmap_range_node *range;
	u8 *u8 = map->work_buf;		u8 *u8 = map->work_buf;
	int ret;		int ret;

	ret = _regmap_select_page(map, &reg, val_len / map->format.val_bytes);		range = _regmap_range_lookup(map, reg);
	if (ret < 0)		if (range) {
			ret = _regmap_select_page(map, &reg, range,
			val_len / map->format.val_bytes);
			if (ret != 0)
	return ret;		return ret;
			}

	map->format.format_reg(map->work_buf, reg, map->reg_shift);		map->format.format_reg(map->work_buf, reg, map->reg_shift);

	@@ -1137,11 +1254,11 @@ int regmap_read(struct regmap map, unsigned int reg, unsigned int val)
	if (reg % map->reg_stride)		if (reg % map->reg_stride)
	return -EINVAL;		return -EINVAL;

	map->lock(map);		map->lock(map->lock_arg);

	ret = _regmap_read(map, reg, val);		ret = _regmap_read(map, reg, val);

	map->unlock(map);		map->unlock(map->lock_arg);

	return ret;		return ret;
	}		}
	@@ -1171,7 +1288,7 @@ int regmap_raw_read(struct regmap map, unsigned int reg, void val,
	if (reg % map->reg_stride)		if (reg % map->reg_stride)
	return -EINVAL;		return -EINVAL;

	map->lock(map);		map->lock(map->lock_arg);

	if (regmap_volatile_range(map, reg, val_count) \|\| map->cache_bypass \|\|		if (regmap_volatile_range(map, reg, val_count) \|\| map->cache_bypass \|\|
	map->cache_type == REGCACHE_NONE) {		map->cache_type == REGCACHE_NONE) {
	@@ -1193,7 +1310,7 @@ int regmap_raw_read(struct regmap map, unsigned int reg, void val,
	}		}

	out:		out:
	map->unlock(map);		map->unlock(map->lock_arg);

	return ret;		return ret;
	}		}
	@@ -1300,9 +1417,9 @@ int regmap_update_bits(struct regmap *map, unsigned int reg,
	bool change;		bool change;
	int ret;		int ret;

	map->lock(map);		map->lock(map->lock_arg);
	ret = _regmap_update_bits(map, reg, mask, val, &change);		ret = _regmap_update_bits(map, reg, mask, val, &change);
	map->unlock(map);		map->unlock(map->lock_arg);

	return ret;		return ret;
	}		}
	@@ -1326,9 +1443,9 @@ int regmap_update_bits_check(struct regmap *map, unsigned int reg,
	{		{
	int ret;		int ret;

	map->lock(map);		map->lock(map->lock_arg);
	ret = _regmap_update_bits(map, reg, mask, val, change);		ret = _regmap_update_bits(map, reg, mask, val, change);
	map->unlock(map);		map->unlock(map->lock_arg);
	return ret;		return ret;
	}		}
	EXPORT_SYMBOL_GPL(regmap_update_bits_check);		EXPORT_SYMBOL_GPL(regmap_update_bits_check);
	@@ -1357,7 +1474,7 @@ int regmap_register_patch(struct regmap map, const struct reg_default regs,
	if (map->patch)		if (map->patch)
	return -EBUSY;		return -EBUSY;

	map->lock(map);		map->lock(map->lock_arg);

	bypass = map->cache_bypass;		bypass = map->cache_bypass;

	@@ -1385,7 +1502,7 @@ int regmap_register_patch(struct regmap map, const struct reg_default regs,
	out:		out:
	map->cache_bypass = bypass;		map->cache_bypass = bypass;

	map->unlock(map);		map->unlock(map->lock_arg);

	return ret;		return ret;
	}		}

include/linux/regmap.h

+88 −7

Original line number	Original line	Diff line number	Diff line
	@@ -19,6 +19,7 @@
	struct module;		struct module;
	struct device;		struct device;
	struct i2c_client;		struct i2c_client;
			struct irq_domain;
	struct spi_device;		struct spi_device;
	struct regmap;		struct regmap;
	struct regmap_range_cfg;		struct regmap_range_cfg;
	@@ -53,6 +54,39 @@ enum regmap_endian {
	REGMAP_ENDIAN_NATIVE,		REGMAP_ENDIAN_NATIVE,
	};		};

			/**
			* A register range, used for access related checks
			* (readable/writeable/volatile/precious checks)
			*
			* @range_min: address of first register
			* @range_max: address of last register
			*/
			struct regmap_range {
			unsigned int range_min;
			unsigned int range_max;
			};

			/*
			* A table of ranges including some yes ranges and some no ranges.
			* If a register belongs to a no_range, the corresponding check function
			* will return false. If a register belongs to a yes range, the corresponding
			* check function will return true. "no_ranges" are searched first.
			*
			* @yes_ranges : pointer to an array of regmap ranges used as "yes ranges"
			* @n_yes_ranges: size of the above array
			* @no_ranges: pointer to an array of regmap ranges used as "no ranges"
			* @n_no_ranges: size of the above array
			*/
			struct regmap_access_table {
			const struct regmap_range *yes_ranges;
			unsigned int n_yes_ranges;
			const struct regmap_range *no_ranges;
			unsigned int n_no_ranges;
			};

			typedef void (regmap_lock)(void );
			typedef void (regmap_unlock)(void );

	/**		/**
	* Configuration for the register map of a device.		* Configuration for the register map of a device.
	*		*
	@@ -67,16 +101,39 @@ enum regmap_endian {
	* @val_bits: Number of bits in a register value, mandatory.		* @val_bits: Number of bits in a register value, mandatory.
	*		*
	* @writeable_reg: Optional callback returning true if the register		* @writeable_reg: Optional callback returning true if the register
	* can be written to.		* can be written to. If this field is NULL but wr_table
			* (see below) is not, the check is performed on such table
			* (a register is writeable if it belongs to one of the ranges
			* specified by wr_table).
	* @readable_reg: Optional callback returning true if the register		* @readable_reg: Optional callback returning true if the register
	* can be read from.		* can be read from. If this field is NULL but rd_table
			* (see below) is not, the check is performed on such table
			* (a register is readable if it belongs to one of the ranges
			* specified by rd_table).
	* @volatile_reg: Optional callback returning true if the register		* @volatile_reg: Optional callback returning true if the register
	* value can't be cached.		* value can't be cached. If this field is NULL but
			* volatile_table (see below) is not, the check is performed on
			* such table (a register is volatile if it belongs to one of
			* the ranges specified by volatile_table).
	* @precious_reg: Optional callback returning true if the rgister		* @precious_reg: Optional callback returning true if the rgister
	* should not be read outside of a call from the driver		* should not be read outside of a call from the driver
	* (eg, a clear on read interrupt status register).		* (eg, a clear on read interrupt status register). If this
			* field is NULL but precious_table (see below) is not, the
			* check is performed on such table (a register is precious if
			* it belongs to one of the ranges specified by precious_table).
			* @lock: Optional lock callback (overrides regmap's default lock
			* function, based on spinlock or mutex).
			* @unlock: As above for unlocking.
			* @lock_arg: this field is passed as the only argument of lock/unlock
			* functions (ignored in case regular lock/unlock functions
			* are not overridden).
	*		*
	* @max_register: Optional, specifies the maximum valid register index.		* @max_register: Optional, specifies the maximum valid register index.
			* @wr_table: Optional, points to a struct regmap_access_table specifying
			* valid ranges for write access.
			* @rd_table: As above, for read access.
			* @volatile_table: As above, for volatile registers.
			* @precious_table: As above, for precious registers.
	* @reg_defaults: Power on reset values for registers (for use with		* @reg_defaults: Power on reset values for registers (for use with
	* register cache support).		* register cache support).
	* @num_reg_defaults: Number of elements in reg_defaults.		* @num_reg_defaults: Number of elements in reg_defaults.
	@@ -116,8 +173,15 @@ struct regmap_config {
	bool (readable_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 (volatile_reg)(struct device dev, unsigned int reg);
	bool (precious_reg)(struct device dev, unsigned int reg);		bool (precious_reg)(struct device dev, unsigned int reg);
			regmap_lock lock;
			regmap_unlock unlock;
			void *lock_arg;

	unsigned int max_register;		unsigned int max_register;
			const struct regmap_access_table *wr_table;
			const struct regmap_access_table *rd_table;
			const struct regmap_access_table *volatile_table;
			const struct regmap_access_table *precious_table;
	const struct reg_default *reg_defaults;		const struct reg_default *reg_defaults;
	unsigned int num_reg_defaults;		unsigned int num_reg_defaults;
	enum regcache_type cache_type;		enum regcache_type cache_type;
	@@ -133,7 +197,7 @@ struct regmap_config {
	enum regmap_endian val_format_endian;		enum regmap_endian val_format_endian;

	const struct regmap_range_cfg *ranges;		const struct regmap_range_cfg *ranges;
	unsigned int n_ranges;		unsigned int num_ranges;
	};		};

	/**		/**
	@@ -142,6 +206,8 @@ struct regmap_config {
	* 1. page selector register update;		* 1. page selector register update;
	* 2. access through data window registers.		* 2. access through data window registers.
	*		*
			* @name: Descriptive name for diagnostics
			*
	* @range_min: Address of the lowest register address in virtual range.		* @range_min: Address of the lowest register address in virtual range.
	* @range_max: Address of the highest register in virtual range.		* @range_max: Address of the highest register in virtual range.
	*		*
	@@ -153,6 +219,8 @@ struct regmap_config {
	* @window_len: Number of registers in data window.		* @window_len: Number of registers in data window.
	*/		*/
	struct regmap_range_cfg {		struct regmap_range_cfg {
			const char *name;

	/* Registers of virtual address range */		/* Registers of virtual address range */
	unsigned int range_min;		unsigned int range_min;
	unsigned int range_max;		unsigned int range_max;
	@@ -181,7 +249,9 @@ typedef void (regmap_hw_free_context)(void context);
	* Description of a hardware bus for the register map infrastructure.		* Description of a hardware bus for the register map infrastructure.
	*		*
	* @fast_io: Register IO is fast. Use a spinlock instead of a mutex		* @fast_io: Register IO is fast. Use a spinlock instead of a mutex
	* to perform locking.		* to perform locking. This field is ignored if custom lock/unlock
			* functions are used (see fields lock/unlock of
			* struct regmap_config).
	* @write: Write operation.		* @write: Write operation.
	* @gather_write: Write operation with split register/value, return -ENOTSUPP		* @gather_write: Write operation with split register/value, return -ENOTSUPP
	* if not implemented on a given device.		* if not implemented on a given device.
	@@ -262,6 +332,16 @@ void regcache_mark_dirty(struct regmap *map);
	int regmap_register_patch(struct regmap map, const struct reg_default regs,		int regmap_register_patch(struct regmap map, const struct reg_default regs,
	int num_regs);		int num_regs);

			static inline bool regmap_reg_in_range(unsigned int reg,
			const struct regmap_range *range)
			{
			return reg >= range->range_min && reg <= range->range_max;
			}

			bool regmap_reg_in_ranges(unsigned int reg,
			const struct regmap_range *ranges,
			unsigned int nranges);

	/**		/**
	* Description of an IRQ for the generic regmap irq_chip.		* Description of an IRQ for the generic regmap irq_chip.
	*		*
	@@ -317,6 +397,7 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
	void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);		void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
	int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);		int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
	int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);		int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
			struct irq_domain regmap_irq_get_domain(struct regmap_irq_chip_data data);

	#else		#else