regmap.c 71.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12
/*
 * Register map access API
 *
 * 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.
 */

13
#include <linux/device.h>
14
#include <linux/slab.h>
15
#include <linux/export.h>
16 17
#include <linux/mutex.h>
#include <linux/err.h>
18
#include <linux/of.h>
19
#include <linux/rbtree.h>
20
#include <linux/sched.h>
21
#include <linux/delay.h>
22
#include <linux/log2.h>
23
#include <linux/hwspinlock.h>
24

M
Mark Brown 已提交
25
#define CREATE_TRACE_POINTS
26
#include "trace.h"
M
Mark Brown 已提交
27

28
#include "internal.h"
29

30 31 32 33 34 35 36 37 38 39
/*
 * Sometimes for failures during very early init the trace
 * infrastructure isn't available early enough to be used.  For this
 * sort of problem defining LOG_DEVICE will add printks for basic
 * register I/O on a specific device.
 */
#undef LOG_DEVICE

static int _regmap_update_bits(struct regmap *map, unsigned int reg,
			       unsigned int mask, unsigned int val,
40
			       bool *change, bool force_write);
41

42 43
static int _regmap_bus_reg_read(void *context, unsigned int reg,
				unsigned int *val);
44 45
static int _regmap_bus_read(void *context, unsigned int reg,
			    unsigned int *val);
46 47
static int _regmap_bus_formatted_write(void *context, unsigned int reg,
				       unsigned int val);
48 49
static int _regmap_bus_reg_write(void *context, unsigned int reg,
				 unsigned int val);
50 51
static int _regmap_bus_raw_write(void *context, unsigned int reg,
				 unsigned int val);
52

53 54 55 56 57 58 59 60 61 62 63 64 65 66
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);

67 68
bool regmap_check_range_table(struct regmap *map, unsigned int reg,
			      const struct regmap_access_table *table)
69 70 71 72 73 74 75 76 77 78 79 80
{
	/* 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);
}
81
EXPORT_SYMBOL_GPL(regmap_check_range_table);
82

83 84 85 86 87 88 89 90
bool regmap_writeable(struct regmap *map, unsigned int reg)
{
	if (map->max_register && reg > map->max_register)
		return false;

	if (map->writeable_reg)
		return map->writeable_reg(map->dev, reg);

91
	if (map->wr_table)
92
		return regmap_check_range_table(map, reg, map->wr_table);
93

94 95 96
	return true;
}

97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
bool regmap_cached(struct regmap *map, unsigned int reg)
{
	int ret;
	unsigned int val;

	if (map->cache == REGCACHE_NONE)
		return false;

	if (!map->cache_ops)
		return false;

	if (map->max_register && reg > map->max_register)
		return false;

	map->lock(map->lock_arg);
	ret = regcache_read(map, reg, &val);
	map->unlock(map->lock_arg);
	if (ret)
		return false;

	return true;
}

120 121
bool regmap_readable(struct regmap *map, unsigned int reg)
{
122 123 124
	if (!map->reg_read)
		return false;

125 126 127
	if (map->max_register && reg > map->max_register)
		return false;

128 129 130
	if (map->format.format_write)
		return false;

131 132 133
	if (map->readable_reg)
		return map->readable_reg(map->dev, reg);

134
	if (map->rd_table)
135
		return regmap_check_range_table(map, reg, map->rd_table);
136

137 138 139 140 141
	return true;
}

bool regmap_volatile(struct regmap *map, unsigned int reg)
{
142
	if (!map->format.format_write && !regmap_readable(map, reg))
143 144 145 146 147
		return false;

	if (map->volatile_reg)
		return map->volatile_reg(map->dev, reg);

148
	if (map->volatile_table)
149
		return regmap_check_range_table(map, reg, map->volatile_table);
150

151 152 153 154
	if (map->cache_ops)
		return false;
	else
		return true;
155 156 157 158
}

bool regmap_precious(struct regmap *map, unsigned int reg)
{
159
	if (!regmap_readable(map, reg))
160 161 162 163 164
		return false;

	if (map->precious_reg)
		return map->precious_reg(map->dev, reg);

165
	if (map->precious_table)
166
		return regmap_check_range_table(map, reg, map->precious_table);
167

168 169 170
	return false;
}

171
static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
P
Paul Bolle 已提交
172
	size_t num)
173 174 175 176 177 178 179 180 181 182
{
	unsigned int i;

	for (i = 0; i < num; i++)
		if (!regmap_volatile(map, reg + i))
			return false;

	return true;
}

183 184 185 186 187 188 189 190
static void regmap_format_2_6_write(struct regmap *map,
				     unsigned int reg, unsigned int val)
{
	u8 *out = map->work_buf;

	*out = (reg << 6) | val;
}

191 192 193 194 195 196 197 198 199 200 201 202 203 204
static void regmap_format_4_12_write(struct regmap *map,
				     unsigned int reg, unsigned int val)
{
	__be16 *out = map->work_buf;
	*out = cpu_to_be16((reg << 12) | val);
}

static void regmap_format_7_9_write(struct regmap *map,
				    unsigned int reg, unsigned int val)
{
	__be16 *out = map->work_buf;
	*out = cpu_to_be16((reg << 9) | val);
}

205 206 207 208 209 210 211 212 213 214
static void regmap_format_10_14_write(struct regmap *map,
				    unsigned int reg, unsigned int val)
{
	u8 *out = map->work_buf;

	out[2] = val;
	out[1] = (val >> 8) | (reg << 6);
	out[0] = reg >> 2;
}

215
static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
216 217 218
{
	u8 *b = buf;

219
	b[0] = val << shift;
220 221
}

222
static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
223 224 225
{
	__be16 *b = buf;

226
	b[0] = cpu_to_be16(val << shift);
227 228
}

229 230 231 232 233 234 235
static void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)
{
	__le16 *b = buf;

	b[0] = cpu_to_le16(val << shift);
}

236 237 238 239 240 241
static void regmap_format_16_native(void *buf, unsigned int val,
				    unsigned int shift)
{
	*(u16 *)buf = val << shift;
}

242
static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
243 244 245
{
	u8 *b = buf;

246 247
	val <<= shift;

248 249 250 251 252
	b[0] = val >> 16;
	b[1] = val >> 8;
	b[2] = val;
}

253
static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
254 255 256
{
	__be32 *b = buf;

257
	b[0] = cpu_to_be32(val << shift);
258 259
}

260 261 262 263 264 265 266
static void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)
{
	__le32 *b = buf;

	b[0] = cpu_to_le32(val << shift);
}

267 268 269 270 271 272
static void regmap_format_32_native(void *buf, unsigned int val,
				    unsigned int shift)
{
	*(u32 *)buf = val << shift;
}

X
Xiubo Li 已提交
273 274 275 276 277
#ifdef CONFIG_64BIT
static void regmap_format_64_be(void *buf, unsigned int val, unsigned int shift)
{
	__be64 *b = buf;

278
	b[0] = cpu_to_be64((u64)val << shift);
X
Xiubo Li 已提交
279 280 281 282 283 284
}

static void regmap_format_64_le(void *buf, unsigned int val, unsigned int shift)
{
	__le64 *b = buf;

285
	b[0] = cpu_to_le64((u64)val << shift);
X
Xiubo Li 已提交
286 287 288 289 290
}

static void regmap_format_64_native(void *buf, unsigned int val,
				    unsigned int shift)
{
291
	*(u64 *)buf = (u64)val << shift;
X
Xiubo Li 已提交
292 293 294
}
#endif

295
static void regmap_parse_inplace_noop(void *buf)
296
{
297 298 299 300 301
}

static unsigned int regmap_parse_8(const void *buf)
{
	const u8 *b = buf;
302 303 304 305

	return b[0];
}

306 307 308 309 310 311 312
static unsigned int regmap_parse_16_be(const void *buf)
{
	const __be16 *b = buf;

	return be16_to_cpu(b[0]);
}

313 314 315 316 317 318 319
static unsigned int regmap_parse_16_le(const void *buf)
{
	const __le16 *b = buf;

	return le16_to_cpu(b[0]);
}

320
static void regmap_parse_16_be_inplace(void *buf)
321 322 323 324 325 326
{
	__be16 *b = buf;

	b[0] = be16_to_cpu(b[0]);
}

327 328 329 330 331 332 333
static void regmap_parse_16_le_inplace(void *buf)
{
	__le16 *b = buf;

	b[0] = le16_to_cpu(b[0]);
}

334
static unsigned int regmap_parse_16_native(const void *buf)
335 336 337 338
{
	return *(u16 *)buf;
}

339
static unsigned int regmap_parse_24(const void *buf)
340
{
341
	const u8 *b = buf;
342 343 344 345 346 347 348
	unsigned int ret = b[2];
	ret |= ((unsigned int)b[1]) << 8;
	ret |= ((unsigned int)b[0]) << 16;

	return ret;
}

349 350 351 352 353 354 355
static unsigned int regmap_parse_32_be(const void *buf)
{
	const __be32 *b = buf;

	return be32_to_cpu(b[0]);
}

356 357 358 359 360 361 362
static unsigned int regmap_parse_32_le(const void *buf)
{
	const __le32 *b = buf;

	return le32_to_cpu(b[0]);
}

363
static void regmap_parse_32_be_inplace(void *buf)
364 365 366 367 368 369
{
	__be32 *b = buf;

	b[0] = be32_to_cpu(b[0]);
}

370 371 372 373 374 375 376
static void regmap_parse_32_le_inplace(void *buf)
{
	__le32 *b = buf;

	b[0] = le32_to_cpu(b[0]);
}

377
static unsigned int regmap_parse_32_native(const void *buf)
378 379 380 381
{
	return *(u32 *)buf;
}

X
Xiubo Li 已提交
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416
#ifdef CONFIG_64BIT
static unsigned int regmap_parse_64_be(const void *buf)
{
	const __be64 *b = buf;

	return be64_to_cpu(b[0]);
}

static unsigned int regmap_parse_64_le(const void *buf)
{
	const __le64 *b = buf;

	return le64_to_cpu(b[0]);
}

static void regmap_parse_64_be_inplace(void *buf)
{
	__be64 *b = buf;

	b[0] = be64_to_cpu(b[0]);
}

static void regmap_parse_64_le_inplace(void *buf)
{
	__le64 *b = buf;

	b[0] = le64_to_cpu(b[0]);
}

static unsigned int regmap_parse_64_native(const void *buf)
{
	return *(u64 *)buf;
}
#endif

417
#ifdef REGMAP_HWSPINLOCK
418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
static void regmap_lock_hwlock(void *__map)
{
	struct regmap *map = __map;

	hwspin_lock_timeout(map->hwlock, UINT_MAX);
}

static void regmap_lock_hwlock_irq(void *__map)
{
	struct regmap *map = __map;

	hwspin_lock_timeout_irq(map->hwlock, UINT_MAX);
}

static void regmap_lock_hwlock_irqsave(void *__map)
{
	struct regmap *map = __map;

	hwspin_lock_timeout_irqsave(map->hwlock, UINT_MAX,
				    &map->spinlock_flags);
}

static void regmap_unlock_hwlock(void *__map)
{
	struct regmap *map = __map;

	hwspin_unlock(map->hwlock);
}

static void regmap_unlock_hwlock_irq(void *__map)
{
	struct regmap *map = __map;

	hwspin_unlock_irq(map->hwlock);
}

static void regmap_unlock_hwlock_irqrestore(void *__map)
{
	struct regmap *map = __map;

	hwspin_unlock_irqrestore(map->hwlock, &map->spinlock_flags);
}
460
#endif
461

462
static void regmap_lock_mutex(void *__map)
463
{
464
	struct regmap *map = __map;
465 466 467
	mutex_lock(&map->mutex);
}

468
static void regmap_unlock_mutex(void *__map)
469
{
470
	struct regmap *map = __map;
471 472 473
	mutex_unlock(&map->mutex);
}

474
static void regmap_lock_spinlock(void *__map)
475
__acquires(&map->spinlock)
476
{
477
	struct regmap *map = __map;
478 479 480 481
	unsigned long flags;

	spin_lock_irqsave(&map->spinlock, flags);
	map->spinlock_flags = flags;
482 483
}

484
static void regmap_unlock_spinlock(void *__map)
485
__releases(&map->spinlock)
486
{
487
	struct regmap *map = __map;
488
	spin_unlock_irqrestore(&map->spinlock, map->spinlock_flags);
489 490
}

M
Mark Brown 已提交
491 492 493 494 495 496 497 498 499
static void dev_get_regmap_release(struct device *dev, void *res)
{
	/*
	 * We don't actually have anything to do here; the goal here
	 * is not to manage the regmap but to provide a simple way to
	 * get the regmap back given a struct device.
	 */
}

500 501 502 503 504 505 506 507
static bool _regmap_range_add(struct regmap *map,
			      struct regmap_range_node *data)
{
	struct rb_root *root = &map->range_tree;
	struct rb_node **new = &(root->rb_node), *parent = NULL;

	while (*new) {
		struct regmap_range_node *this =
G
Geliang Tang 已提交
508
			rb_entry(*new, struct regmap_range_node, node);
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531

		parent = *new;
		if (data->range_max < this->range_min)
			new = &((*new)->rb_left);
		else if (data->range_min > this->range_max)
			new = &((*new)->rb_right);
		else
			return false;
	}

	rb_link_node(&data->node, parent, new);
	rb_insert_color(&data->node, root);

	return true;
}

static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
						      unsigned int reg)
{
	struct rb_node *node = map->range_tree.rb_node;

	while (node) {
		struct regmap_range_node *this =
G
Geliang Tang 已提交
532
			rb_entry(node, struct regmap_range_node, node);
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560

		if (reg < this->range_min)
			node = node->rb_left;
		else if (reg > this->range_max)
			node = node->rb_right;
		else
			return this;
	}

	return NULL;
}

static void regmap_range_exit(struct regmap *map)
{
	struct rb_node *next;
	struct regmap_range_node *range_node;

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

	kfree(map->selector_work_buf);
}

561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582
int regmap_attach_dev(struct device *dev, struct regmap *map,
		      const struct regmap_config *config)
{
	struct regmap **m;

	map->dev = dev;

	regmap_debugfs_init(map, config->name);

	/* Add a devres resource for dev_get_regmap() */
	m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
	if (!m) {
		regmap_debugfs_exit(map);
		return -ENOMEM;
	}
	*m = map;
	devres_add(dev, m);

	return 0;
}
EXPORT_SYMBOL_GPL(regmap_attach_dev);

583 584 585 586 587 588 589 590 591 592 593 594 595 596 597
static enum regmap_endian regmap_get_reg_endian(const struct regmap_bus *bus,
					const struct regmap_config *config)
{
	enum regmap_endian endian;

	/* Retrieve the endianness specification from the regmap config */
	endian = config->reg_format_endian;

	/* If the regmap config specified a non-default value, use that */
	if (endian != REGMAP_ENDIAN_DEFAULT)
		return endian;

	/* Retrieve the endianness specification from the bus config */
	if (bus && bus->reg_format_endian_default)
		endian = bus->reg_format_endian_default;
598

599 600 601 602 603 604 605 606
	/* If the bus specified a non-default value, use that */
	if (endian != REGMAP_ENDIAN_DEFAULT)
		return endian;

	/* Use this if no other value was found */
	return REGMAP_ENDIAN_BIG;
}

607 608 609
enum regmap_endian regmap_get_val_endian(struct device *dev,
					 const struct regmap_bus *bus,
					 const struct regmap_config *config)
610
{
611
	struct device_node *np;
612
	enum regmap_endian endian;
613

614
	/* Retrieve the endianness specification from the regmap config */
615
	endian = config->val_format_endian;
616

617
	/* If the regmap config specified a non-default value, use that */
618 619
	if (endian != REGMAP_ENDIAN_DEFAULT)
		return endian;
620

621 622 623
	/* If the dev and dev->of_node exist try to get endianness from DT */
	if (dev && dev->of_node) {
		np = dev->of_node;
624

625 626 627 628 629
		/* Parse the device's DT node for an endianness specification */
		if (of_property_read_bool(np, "big-endian"))
			endian = REGMAP_ENDIAN_BIG;
		else if (of_property_read_bool(np, "little-endian"))
			endian = REGMAP_ENDIAN_LITTLE;
630 631
		else if (of_property_read_bool(np, "native-endian"))
			endian = REGMAP_ENDIAN_NATIVE;
632 633 634 635 636

		/* If the endianness was specified in DT, use that */
		if (endian != REGMAP_ENDIAN_DEFAULT)
			return endian;
	}
637 638

	/* Retrieve the endianness specification from the bus config */
639 640
	if (bus && bus->val_format_endian_default)
		endian = bus->val_format_endian_default;
641

642
	/* If the bus specified a non-default value, use that */
643 644
	if (endian != REGMAP_ENDIAN_DEFAULT)
		return endian;
645 646

	/* Use this if no other value was found */
647
	return REGMAP_ENDIAN_BIG;
648
}
649
EXPORT_SYMBOL_GPL(regmap_get_val_endian);
650

651 652 653 654 655 656
struct regmap *__regmap_init(struct device *dev,
			     const struct regmap_bus *bus,
			     void *bus_context,
			     const struct regmap_config *config,
			     struct lock_class_key *lock_key,
			     const char *lock_name)
657
{
658
	struct regmap *map;
659
	int ret = -EINVAL;
660
	enum regmap_endian reg_endian, val_endian;
661
	int i, j;
662

663
	if (!config)
664
		goto err;
665 666 667 668 669 670 671

	map = kzalloc(sizeof(*map), GFP_KERNEL);
	if (map == NULL) {
		ret = -ENOMEM;
		goto err;
	}

672 673 674 675
	if (config->lock && config->unlock) {
		map->lock = config->lock;
		map->unlock = config->unlock;
		map->lock_arg = config->lock_arg;
676
	} else if (config->hwlock_id) {
677
#ifdef REGMAP_HWSPINLOCK
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699
		map->hwlock = hwspin_lock_request_specific(config->hwlock_id);
		if (!map->hwlock) {
			ret = -ENXIO;
			goto err_map;
		}

		switch (config->hwlock_mode) {
		case HWLOCK_IRQSTATE:
			map->lock = regmap_lock_hwlock_irqsave;
			map->unlock = regmap_unlock_hwlock_irqrestore;
			break;
		case HWLOCK_IRQ:
			map->lock = regmap_lock_hwlock_irq;
			map->unlock = regmap_unlock_hwlock_irq;
			break;
		default:
			map->lock = regmap_lock_hwlock;
			map->unlock = regmap_unlock_hwlock;
			break;
		}

		map->lock_arg = map;
700 701 702 703
#else
		ret = -EINVAL;
		goto err;
#endif
704
	} else {
705 706
		if ((bus && bus->fast_io) ||
		    config->fast_io) {
707 708 709
			spin_lock_init(&map->spinlock);
			map->lock = regmap_lock_spinlock;
			map->unlock = regmap_unlock_spinlock;
710 711
			lockdep_set_class_and_name(&map->spinlock,
						   lock_key, lock_name);
712 713 714 715
		} else {
			mutex_init(&map->mutex);
			map->lock = regmap_lock_mutex;
			map->unlock = regmap_unlock_mutex;
716 717
			lockdep_set_class_and_name(&map->mutex,
						   lock_key, lock_name);
718 719
		}
		map->lock_arg = map;
720
	}
721 722 723 724 725 726 727 728 729 730

	/*
	 * When we write in fast-paths with regmap_bulk_write() don't allocate
	 * scratch buffers with sleeping allocations.
	 */
	if ((bus && bus->fast_io) || config->fast_io)
		map->alloc_flags = GFP_ATOMIC;
	else
		map->alloc_flags = GFP_KERNEL;

731
	map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
732
	map->format.pad_bytes = config->pad_bits / 8;
733
	map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
734 735
	map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
			config->val_bits + config->pad_bits, 8);
736
	map->reg_shift = config->pad_bits % 8;
737 738 739 740
	if (config->reg_stride)
		map->reg_stride = config->reg_stride;
	else
		map->reg_stride = 1;
741 742 743 744
	if (is_power_of_2(map->reg_stride))
		map->reg_stride_order = ilog2(map->reg_stride);
	else
		map->reg_stride_order = -1;
745 746
	map->use_single_read = config->use_single_rw || !bus || !bus->read;
	map->use_single_write = config->use_single_rw || !bus || !bus->write;
747
	map->can_multi_write = config->can_multi_write && bus && bus->write;
748 749 750 751
	if (bus) {
		map->max_raw_read = bus->max_raw_read;
		map->max_raw_write = bus->max_raw_write;
	}
752 753
	map->dev = dev;
	map->bus = bus;
754
	map->bus_context = bus_context;
755
	map->max_register = config->max_register;
756 757 758 759
	map->wr_table = config->wr_table;
	map->rd_table = config->rd_table;
	map->volatile_table = config->volatile_table;
	map->precious_table = config->precious_table;
760 761 762
	map->writeable_reg = config->writeable_reg;
	map->readable_reg = config->readable_reg;
	map->volatile_reg = config->volatile_reg;
763
	map->precious_reg = config->precious_reg;
764
	map->cache_type = config->cache_type;
M
Mark Brown 已提交
765
	map->name = config->name;
766

767 768
	spin_lock_init(&map->async_lock);
	INIT_LIST_HEAD(&map->async_list);
M
Mark Brown 已提交
769
	INIT_LIST_HEAD(&map->async_free);
770 771
	init_waitqueue_head(&map->async_waitq);

772 773 774
	if (config->read_flag_mask || config->write_flag_mask) {
		map->read_flag_mask = config->read_flag_mask;
		map->write_flag_mask = config->write_flag_mask;
775
	} else if (bus) {
776 777 778
		map->read_flag_mask = bus->read_flag_mask;
	}

779 780 781 782
	if (!bus) {
		map->reg_read  = config->reg_read;
		map->reg_write = config->reg_write;

783 784 785 786 787 788
		map->defer_caching = false;
		goto skip_format_initialization;
	} else if (!bus->read || !bus->write) {
		map->reg_read = _regmap_bus_reg_read;
		map->reg_write = _regmap_bus_reg_write;

789 790 791 792
		map->defer_caching = false;
		goto skip_format_initialization;
	} else {
		map->reg_read  = _regmap_bus_read;
793
		map->reg_update_bits = bus->reg_update_bits;
794
	}
795

796 797
	reg_endian = regmap_get_reg_endian(bus, config);
	val_endian = regmap_get_val_endian(dev, bus, config);
798

799
	switch (config->reg_bits + map->reg_shift) {
800 801 802 803 804 805
	case 2:
		switch (config->val_bits) {
		case 6:
			map->format.format_write = regmap_format_2_6_write;
			break;
		default:
806
			goto err_hwlock;
807 808 809
		}
		break;

810 811 812 813 814 815
	case 4:
		switch (config->val_bits) {
		case 12:
			map->format.format_write = regmap_format_4_12_write;
			break;
		default:
816
			goto err_hwlock;
817 818 819 820 821 822 823 824 825
		}
		break;

	case 7:
		switch (config->val_bits) {
		case 9:
			map->format.format_write = regmap_format_7_9_write;
			break;
		default:
826
			goto err_hwlock;
827 828 829
		}
		break;

830 831 832 833 834 835
	case 10:
		switch (config->val_bits) {
		case 14:
			map->format.format_write = regmap_format_10_14_write;
			break;
		default:
836
			goto err_hwlock;
837 838 839
		}
		break;

840 841 842 843 844
	case 8:
		map->format.format_reg = regmap_format_8;
		break;

	case 16:
845 846 847 848
		switch (reg_endian) {
		case REGMAP_ENDIAN_BIG:
			map->format.format_reg = regmap_format_16_be;
			break;
849 850 851
		case REGMAP_ENDIAN_LITTLE:
			map->format.format_reg = regmap_format_16_le;
			break;
852 853 854 855
		case REGMAP_ENDIAN_NATIVE:
			map->format.format_reg = regmap_format_16_native;
			break;
		default:
856
			goto err_hwlock;
857
		}
858 859
		break;

860 861
	case 24:
		if (reg_endian != REGMAP_ENDIAN_BIG)
862
			goto err_hwlock;
863 864 865
		map->format.format_reg = regmap_format_24;
		break;

866
	case 32:
867 868 869 870
		switch (reg_endian) {
		case REGMAP_ENDIAN_BIG:
			map->format.format_reg = regmap_format_32_be;
			break;
871 872 873
		case REGMAP_ENDIAN_LITTLE:
			map->format.format_reg = regmap_format_32_le;
			break;
874 875 876 877
		case REGMAP_ENDIAN_NATIVE:
			map->format.format_reg = regmap_format_32_native;
			break;
		default:
878
			goto err_hwlock;
879
		}
880 881
		break;

X
Xiubo Li 已提交
882 883 884 885 886 887
#ifdef CONFIG_64BIT
	case 64:
		switch (reg_endian) {
		case REGMAP_ENDIAN_BIG:
			map->format.format_reg = regmap_format_64_be;
			break;
888 889 890
		case REGMAP_ENDIAN_LITTLE:
			map->format.format_reg = regmap_format_64_le;
			break;
X
Xiubo Li 已提交
891 892 893 894
		case REGMAP_ENDIAN_NATIVE:
			map->format.format_reg = regmap_format_64_native;
			break;
		default:
895
			goto err_hwlock;
X
Xiubo Li 已提交
896 897 898 899
		}
		break;
#endif

900
	default:
901
		goto err_hwlock;
902 903
	}

904 905 906
	if (val_endian == REGMAP_ENDIAN_NATIVE)
		map->format.parse_inplace = regmap_parse_inplace_noop;

907 908 909 910
	switch (config->val_bits) {
	case 8:
		map->format.format_val = regmap_format_8;
		map->format.parse_val = regmap_parse_8;
911
		map->format.parse_inplace = regmap_parse_inplace_noop;
912 913
		break;
	case 16:
914 915 916 917
		switch (val_endian) {
		case REGMAP_ENDIAN_BIG:
			map->format.format_val = regmap_format_16_be;
			map->format.parse_val = regmap_parse_16_be;
918
			map->format.parse_inplace = regmap_parse_16_be_inplace;
919
			break;
920 921 922 923 924
		case REGMAP_ENDIAN_LITTLE:
			map->format.format_val = regmap_format_16_le;
			map->format.parse_val = regmap_parse_16_le;
			map->format.parse_inplace = regmap_parse_16_le_inplace;
			break;
925 926 927 928 929
		case REGMAP_ENDIAN_NATIVE:
			map->format.format_val = regmap_format_16_native;
			map->format.parse_val = regmap_parse_16_native;
			break;
		default:
930
			goto err_hwlock;
931
		}
932
		break;
933
	case 24:
934
		if (val_endian != REGMAP_ENDIAN_BIG)
935
			goto err_hwlock;
936 937 938
		map->format.format_val = regmap_format_24;
		map->format.parse_val = regmap_parse_24;
		break;
939
	case 32:
940 941 942 943
		switch (val_endian) {
		case REGMAP_ENDIAN_BIG:
			map->format.format_val = regmap_format_32_be;
			map->format.parse_val = regmap_parse_32_be;
944
			map->format.parse_inplace = regmap_parse_32_be_inplace;
945
			break;
946 947 948 949 950
		case REGMAP_ENDIAN_LITTLE:
			map->format.format_val = regmap_format_32_le;
			map->format.parse_val = regmap_parse_32_le;
			map->format.parse_inplace = regmap_parse_32_le_inplace;
			break;
951 952 953 954 955
		case REGMAP_ENDIAN_NATIVE:
			map->format.format_val = regmap_format_32_native;
			map->format.parse_val = regmap_parse_32_native;
			break;
		default:
956
			goto err_hwlock;
957
		}
958
		break;
X
Xiubo Li 已提交
959
#ifdef CONFIG_64BIT
D
Dan Carpenter 已提交
960
	case 64:
X
Xiubo Li 已提交
961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976
		switch (val_endian) {
		case REGMAP_ENDIAN_BIG:
			map->format.format_val = regmap_format_64_be;
			map->format.parse_val = regmap_parse_64_be;
			map->format.parse_inplace = regmap_parse_64_be_inplace;
			break;
		case REGMAP_ENDIAN_LITTLE:
			map->format.format_val = regmap_format_64_le;
			map->format.parse_val = regmap_parse_64_le;
			map->format.parse_inplace = regmap_parse_64_le_inplace;
			break;
		case REGMAP_ENDIAN_NATIVE:
			map->format.format_val = regmap_format_64_native;
			map->format.parse_val = regmap_parse_64_native;
			break;
		default:
977
			goto err_hwlock;
X
Xiubo Li 已提交
978 979 980
		}
		break;
#endif
981 982
	}

983 984 985
	if (map->format.format_write) {
		if ((reg_endian != REGMAP_ENDIAN_BIG) ||
		    (val_endian != REGMAP_ENDIAN_BIG))
986
			goto err_hwlock;
987
		map->use_single_write = true;
988
	}
989

990 991
	if (!map->format.format_write &&
	    !(map->format.format_reg && map->format.format_val))
992
		goto err_hwlock;
993

994
	map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
995 996
	if (map->work_buf == NULL) {
		ret = -ENOMEM;
997
		goto err_hwlock;
998 999
	}

1000 1001
	if (map->format.format_write) {
		map->defer_caching = false;
1002
		map->reg_write = _regmap_bus_formatted_write;
1003 1004
	} else if (map->format.format_val) {
		map->defer_caching = true;
1005
		map->reg_write = _regmap_bus_raw_write;
1006 1007 1008
	}

skip_format_initialization:
1009

1010
	map->range_tree = RB_ROOT;
M
Mark Brown 已提交
1011
	for (i = 0; i < config->num_ranges; i++) {
1012 1013 1014 1015
		const struct regmap_range_cfg *range_cfg = &config->ranges[i];
		struct regmap_range_node *new;

		/* Sanity check */
1016 1017 1018
		if (range_cfg->range_max < range_cfg->range_min) {
			dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
				range_cfg->range_max, range_cfg->range_min);
1019
			goto err_range;
1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
		}

		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;
		}
1039 1040 1041

		/* Make sure, that this register range has no selector
		   or data window within its boundary */
M
Mark Brown 已提交
1042
		for (j = 0; j < config->num_ranges; j++) {
1043 1044 1045 1046 1047
			unsigned sel_reg = config->ranges[j].selector_reg;
			unsigned win_min = config->ranges[j].window_start;
			unsigned win_max = win_min +
					   config->ranges[j].window_len - 1;

1048 1049 1050 1051
			/* Allow data window inside its own virtual range */
			if (j == i)
				continue;

1052 1053
			if (range_cfg->range_min <= sel_reg &&
			    sel_reg <= range_cfg->range_max) {
1054 1055 1056
				dev_err(map->dev,
					"Range %d: selector for %d in window\n",
					i, j);
1057 1058 1059 1060 1061
				goto err_range;
			}

			if (!(win_max < range_cfg->range_min ||
			      win_min > range_cfg->range_max)) {
1062 1063 1064
				dev_err(map->dev,
					"Range %d: window for %d in window\n",
					i, j);
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
				goto err_range;
			}
		}

		new = kzalloc(sizeof(*new), GFP_KERNEL);
		if (new == NULL) {
			ret = -ENOMEM;
			goto err_range;
		}

1075
		new->map = map;
M
Mark Brown 已提交
1076
		new->name = range_cfg->name;
1077 1078 1079 1080 1081 1082 1083 1084
		new->range_min = range_cfg->range_min;
		new->range_max = range_cfg->range_max;
		new->selector_reg = range_cfg->selector_reg;
		new->selector_mask = range_cfg->selector_mask;
		new->selector_shift = range_cfg->selector_shift;
		new->window_start = range_cfg->window_start;
		new->window_len = range_cfg->window_len;

N
Nenghua Cao 已提交
1085
		if (!_regmap_range_add(map, new)) {
1086
			dev_err(map->dev, "Failed to add range %d\n", i);
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099
			kfree(new);
			goto err_range;
		}

		if (map->selector_work_buf == NULL) {
			map->selector_work_buf =
				kzalloc(map->format.buf_size, GFP_KERNEL);
			if (map->selector_work_buf == NULL) {
				ret = -ENOMEM;
				goto err_range;
			}
		}
	}
1100

1101
	ret = regcache_init(map, config);
1102
	if (ret != 0)
1103 1104
		goto err_range;

1105
	if (dev) {
1106 1107 1108
		ret = regmap_attach_dev(dev, map, config);
		if (ret != 0)
			goto err_regcache;
1109
	}
M
Mark Brown 已提交
1110

1111 1112
	return map;

1113
err_regcache:
M
Mark Brown 已提交
1114
	regcache_exit(map);
1115 1116
err_range:
	regmap_range_exit(map);
1117
	kfree(map->work_buf);
1118
err_hwlock:
1119 1120
	if (IS_ENABLED(REGMAP_HWSPINLOCK) && map->hwlock)
		hwspin_lock_free(map->hwlock);
1121 1122 1123 1124 1125
err_map:
	kfree(map);
err:
	return ERR_PTR(ret);
}
1126
EXPORT_SYMBOL_GPL(__regmap_init);
1127

1128 1129 1130 1131 1132
static void devm_regmap_release(struct device *dev, void *res)
{
	regmap_exit(*(struct regmap **)res);
}

1133 1134 1135 1136 1137 1138
struct regmap *__devm_regmap_init(struct device *dev,
				  const struct regmap_bus *bus,
				  void *bus_context,
				  const struct regmap_config *config,
				  struct lock_class_key *lock_key,
				  const char *lock_name)
1139 1140 1141 1142 1143 1144 1145
{
	struct regmap **ptr, *regmap;

	ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
	if (!ptr)
		return ERR_PTR(-ENOMEM);

1146 1147
	regmap = __regmap_init(dev, bus, bus_context, config,
			       lock_key, lock_name);
1148 1149 1150 1151 1152 1153 1154 1155 1156
	if (!IS_ERR(regmap)) {
		*ptr = regmap;
		devres_add(dev, ptr);
	} else {
		devres_free(ptr);
	}

	return regmap;
}
1157
EXPORT_SYMBOL_GPL(__devm_regmap_init);
1158

1159 1160 1161 1162 1163 1164
static void regmap_field_init(struct regmap_field *rm_field,
	struct regmap *regmap, struct reg_field reg_field)
{
	rm_field->regmap = regmap;
	rm_field->reg = reg_field.reg;
	rm_field->shift = reg_field.lsb;
1165
	rm_field->mask = GENMASK(reg_field.msb, reg_field.lsb);
1166 1167
	rm_field->id_size = reg_field.id_size;
	rm_field->id_offset = reg_field.id_offset;
1168 1169 1170
}

/**
1171
 * devm_regmap_field_alloc() - Allocate and initialise a register field.
1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
 *
 * @dev: Device that will be interacted with
 * @regmap: regmap bank in which this register field is located.
 * @reg_field: Register field with in the bank.
 *
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap_field. The regmap_field will be automatically freed
 * by the device management code.
 */
struct regmap_field *devm_regmap_field_alloc(struct device *dev,
		struct regmap *regmap, struct reg_field reg_field)
{
	struct regmap_field *rm_field = devm_kzalloc(dev,
					sizeof(*rm_field), GFP_KERNEL);
	if (!rm_field)
		return ERR_PTR(-ENOMEM);

	regmap_field_init(rm_field, regmap, reg_field);

	return rm_field;

}
EXPORT_SYMBOL_GPL(devm_regmap_field_alloc);

/**
1197 1198
 * devm_regmap_field_free() - Free a register field allocated using
 *                            devm_regmap_field_alloc.
1199 1200 1201
 *
 * @dev: Device that will be interacted with
 * @field: regmap field which should be freed.
1202 1203 1204 1205
 *
 * Free register field allocated using devm_regmap_field_alloc(). Usually
 * drivers need not call this function, as the memory allocated via devm
 * will be freed as per device-driver life-cyle.
1206 1207 1208 1209 1210 1211 1212 1213 1214
 */
void devm_regmap_field_free(struct device *dev,
	struct regmap_field *field)
{
	devm_kfree(dev, field);
}
EXPORT_SYMBOL_GPL(devm_regmap_field_free);

/**
1215
 * regmap_field_alloc() - Allocate and initialise a register field.
1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
 *
 * @regmap: regmap bank in which this register field is located.
 * @reg_field: Register field with in the bank.
 *
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap_field. The regmap_field should be freed by the
 * user once its finished working with it using regmap_field_free().
 */
struct regmap_field *regmap_field_alloc(struct regmap *regmap,
		struct reg_field reg_field)
{
	struct regmap_field *rm_field = kzalloc(sizeof(*rm_field), GFP_KERNEL);

	if (!rm_field)
		return ERR_PTR(-ENOMEM);

	regmap_field_init(rm_field, regmap, reg_field);

	return rm_field;
}
EXPORT_SYMBOL_GPL(regmap_field_alloc);

/**
1239 1240
 * regmap_field_free() - Free register field allocated using
 *                       regmap_field_alloc.
1241 1242 1243 1244 1245 1246 1247 1248 1249
 *
 * @field: regmap field which should be freed.
 */
void regmap_field_free(struct regmap_field *field)
{
	kfree(field);
}
EXPORT_SYMBOL_GPL(regmap_field_free);

1250
/**
1251
 * regmap_reinit_cache() - Reinitialise the current register cache
1252 1253 1254 1255 1256 1257 1258 1259
 *
 * @map: Register map to operate on.
 * @config: New configuration.  Only the cache data will be used.
 *
 * Discard any existing register cache for the map and initialize a
 * new cache.  This can be used to restore the cache to defaults or to
 * update the cache configuration to reflect runtime discovery of the
 * hardware.
1260 1261 1262
 *
 * No explicit locking is done here, the user needs to ensure that
 * this function will not race with other calls to regmap.
1263 1264 1265 1266
 */
int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
{
	regcache_exit(map);
1267
	regmap_debugfs_exit(map);
1268 1269 1270 1271 1272 1273 1274 1275

	map->max_register = config->max_register;
	map->writeable_reg = config->writeable_reg;
	map->readable_reg = config->readable_reg;
	map->volatile_reg = config->volatile_reg;
	map->precious_reg = config->precious_reg;
	map->cache_type = config->cache_type;

1276
	regmap_debugfs_init(map, config->name);
1277

1278 1279 1280
	map->cache_bypass = false;
	map->cache_only = false;

1281
	return regcache_init(map, config);
1282
}
1283
EXPORT_SYMBOL_GPL(regmap_reinit_cache);
1284

1285
/**
1286 1287 1288
 * regmap_exit() - Free a previously allocated register map
 *
 * @map: Register map to operate on.
1289 1290 1291
 */
void regmap_exit(struct regmap *map)
{
M
Mark Brown 已提交
1292 1293
	struct regmap_async *async;

1294
	regcache_exit(map);
1295
	regmap_debugfs_exit(map);
1296
	regmap_range_exit(map);
1297
	if (map->bus && map->bus->free_context)
1298
		map->bus->free_context(map->bus_context);
1299
	kfree(map->work_buf);
M
Mark Brown 已提交
1300 1301 1302 1303 1304 1305 1306 1307
	while (!list_empty(&map->async_free)) {
		async = list_first_entry_or_null(&map->async_free,
						 struct regmap_async,
						 list);
		list_del(&async->list);
		kfree(async->work_buf);
		kfree(async);
	}
1308 1309
	if (IS_ENABLED(REGMAP_HWSPINLOCK) && map->hwlock)
		hwspin_lock_free(map->hwlock);
1310 1311 1312 1313
	kfree(map);
}
EXPORT_SYMBOL_GPL(regmap_exit);

M
Mark Brown 已提交
1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
static int dev_get_regmap_match(struct device *dev, void *res, void *data)
{
	struct regmap **r = res;
	if (!r || !*r) {
		WARN_ON(!r || !*r);
		return 0;
	}

	/* If the user didn't specify a name match any */
	if (data)
		return (*r)->name == data;
	else
		return 1;
}

/**
1330
 * dev_get_regmap() - Obtain the regmap (if any) for a device
M
Mark Brown 已提交
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
 *
 * @dev: Device to retrieve the map for
 * @name: Optional name for the register map, usually NULL.
 *
 * Returns the regmap for the device if one is present, or NULL.  If
 * name is specified then it must match the name specified when
 * registering the device, if it is NULL then the first regmap found
 * will be used.  Devices with multiple register maps are very rare,
 * generic code should normally not need to specify a name.
 */
struct regmap *dev_get_regmap(struct device *dev, const char *name)
{
	struct regmap **r = devres_find(dev, dev_get_regmap_release,
					dev_get_regmap_match, (void *)name);

	if (!r)
		return NULL;
	return *r;
}
EXPORT_SYMBOL_GPL(dev_get_regmap);

T
Tuomas Tynkkynen 已提交
1352
/**
1353
 * regmap_get_device() - Obtain the device from a regmap
T
Tuomas Tynkkynen 已提交
1354 1355 1356 1357 1358 1359 1360 1361 1362
 *
 * @map: Register map to operate on.
 *
 * Returns the underlying device that the regmap has been created for.
 */
struct device *regmap_get_device(struct regmap *map)
{
	return map->dev;
}
1363
EXPORT_SYMBOL_GPL(regmap_get_device);
T
Tuomas Tynkkynen 已提交
1364

1365
static int _regmap_select_page(struct regmap *map, unsigned int *reg,
1366
			       struct regmap_range_node *range,
1367 1368 1369 1370 1371 1372 1373 1374
			       unsigned int val_num)
{
	void *orig_work_buf;
	unsigned int win_offset;
	unsigned int win_page;
	bool page_chg;
	int ret;

1375 1376
	win_offset = (*reg - range->range_min) % range->window_len;
	win_page = (*reg - range->range_min) / range->window_len;
1377

1378 1379 1380 1381
	if (val_num > 1) {
		/* Bulk write shouldn't cross range boundary */
		if (*reg + val_num - 1 > range->range_max)
			return -EINVAL;
1382

1383 1384 1385 1386
		/* ... or single page boundary */
		if (val_num > range->window_len - win_offset)
			return -EINVAL;
	}
1387

1388 1389 1390 1391 1392 1393 1394 1395
	/* It is possible to have selector register inside data window.
	   In that case, selector register is located on every page and
	   it needs no page switching, when accessed alone. */
	if (val_num > 1 ||
	    range->window_start + win_offset != range->selector_reg) {
		/* Use separate work_buf during page switching */
		orig_work_buf = map->work_buf;
		map->work_buf = map->selector_work_buf;
1396

1397 1398 1399
		ret = _regmap_update_bits(map, range->selector_reg,
					  range->selector_mask,
					  win_page << range->selector_shift,
1400
					  &page_chg, false);
1401

1402
		map->work_buf = orig_work_buf;
1403

1404
		if (ret != 0)
1405
			return ret;
1406 1407
	}

1408 1409
	*reg = range->window_start + win_offset;

1410 1411 1412
	return 0;
}

1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
static void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
					  unsigned long mask)
{
	u8 *buf;
	int i;

	if (!mask || !map->work_buf)
		return;

	buf = map->work_buf;

	for (i = 0; i < max_bytes; i++)
		buf[i] |= (mask >> (8 * i)) & 0xff;
}

1428
int _regmap_raw_write(struct regmap *map, unsigned int reg,
1429
		      const void *val, size_t val_len)
1430
{
1431
	struct regmap_range_node *range;
1432 1433 1434
	unsigned long flags;
	void *work_val = map->work_buf + map->format.reg_bytes +
		map->format.pad_bytes;
1435 1436 1437
	void *buf;
	int ret = -ENOTSUPP;
	size_t len;
1438 1439
	int i;

1440
	WARN_ON(!map->bus);
1441

1442 1443 1444
	/* Check for unwritable registers before we start */
	if (map->writeable_reg)
		for (i = 0; i < val_len / map->format.val_bytes; i++)
1445
			if (!map->writeable_reg(map->dev,
1446
					       reg + regmap_get_offset(map, i)))
1447
				return -EINVAL;
1448

1449 1450 1451 1452
	if (!map->cache_bypass && map->format.parse_val) {
		unsigned int ival;
		int val_bytes = map->format.val_bytes;
		for (i = 0; i < val_len / val_bytes; i++) {
1453
			ival = map->format.parse_val(val + (i * val_bytes));
1454 1455
			ret = regcache_write(map,
					     reg + regmap_get_offset(map, i),
1456
					     ival);
1457 1458
			if (ret) {
				dev_err(map->dev,
1459
					"Error in caching of register: %x ret: %d\n",
1460 1461 1462 1463 1464 1465 1466 1467 1468 1469
					reg + i, ret);
				return ret;
			}
		}
		if (map->cache_only) {
			map->cache_dirty = true;
			return 0;
		}
	}

1470 1471
	range = _regmap_range_lookup(map, reg);
	if (range) {
1472 1473 1474 1475 1476 1477
		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) {
1478
			dev_dbg(map->dev, "Writing window %d/%zu\n",
1479 1480
				win_residue, val_len / map->format.val_bytes);
			ret = _regmap_raw_write(map, reg, val, win_residue *
1481
						map->format.val_bytes);
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
			if (ret != 0)
				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);
1496
		if (ret != 0)
1497 1498
			return ret;
	}
1499

1500
	map->format.format_reg(map->work_buf, reg, map->reg_shift);
1501 1502
	regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
				      map->write_flag_mask);
1503

1504 1505 1506 1507 1508 1509 1510 1511 1512 1513
	/*
	 * Essentially all I/O mechanisms will be faster with a single
	 * buffer to write.  Since register syncs often generate raw
	 * writes of single registers optimise that case.
	 */
	if (val != work_val && val_len == map->format.val_bytes) {
		memcpy(work_val, val, map->format.val_bytes);
		val = work_val;
	}

1514
	if (map->async && map->bus->async_write) {
M
Mark Brown 已提交
1515
		struct regmap_async *async;
1516

1517
		trace_regmap_async_write_start(map, reg, val_len);
1518

M
Mark Brown 已提交
1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537
		spin_lock_irqsave(&map->async_lock, flags);
		async = list_first_entry_or_null(&map->async_free,
						 struct regmap_async,
						 list);
		if (async)
			list_del(&async->list);
		spin_unlock_irqrestore(&map->async_lock, flags);

		if (!async) {
			async = map->bus->async_alloc();
			if (!async)
				return -ENOMEM;

			async->work_buf = kzalloc(map->format.buf_size,
						  GFP_KERNEL | GFP_DMA);
			if (!async->work_buf) {
				kfree(async);
				return -ENOMEM;
			}
1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549
		}

		async->map = map;

		/* If the caller supplied the value we can use it safely. */
		memcpy(async->work_buf, map->work_buf, map->format.pad_bytes +
		       map->format.reg_bytes + map->format.val_bytes);

		spin_lock_irqsave(&map->async_lock, flags);
		list_add_tail(&async->list, &map->async_list);
		spin_unlock_irqrestore(&map->async_lock, flags);

1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561
		if (val != work_val)
			ret = map->bus->async_write(map->bus_context,
						    async->work_buf,
						    map->format.reg_bytes +
						    map->format.pad_bytes,
						    val, val_len, async);
		else
			ret = map->bus->async_write(map->bus_context,
						    async->work_buf,
						    map->format.reg_bytes +
						    map->format.pad_bytes +
						    val_len, NULL, 0, async);
1562 1563 1564 1565 1566 1567

		if (ret != 0) {
			dev_err(map->dev, "Failed to schedule write: %d\n",
				ret);

			spin_lock_irqsave(&map->async_lock, flags);
M
Mark Brown 已提交
1568
			list_move(&async->list, &map->async_free);
1569 1570
			spin_unlock_irqrestore(&map->async_lock, flags);
		}
M
Mark Brown 已提交
1571 1572

		return ret;
1573 1574
	}

1575
	trace_regmap_hw_write_start(map, reg, val_len / map->format.val_bytes);
M
Mark Brown 已提交
1576

1577 1578 1579 1580
	/* If we're doing a single register write we can probably just
	 * send the work_buf directly, otherwise try to do a gather
	 * write.
	 */
1581
	if (val == work_val)
1582
		ret = map->bus->write(map->bus_context, map->work_buf,
1583 1584 1585
				      map->format.reg_bytes +
				      map->format.pad_bytes +
				      val_len);
1586
	else if (map->bus->gather_write)
1587
		ret = map->bus->gather_write(map->bus_context, map->work_buf,
1588 1589
					     map->format.reg_bytes +
					     map->format.pad_bytes,
1590 1591
					     val, val_len);

1592
	/* If that didn't work fall back on linearising by hand. */
1593
	if (ret == -ENOTSUPP) {
1594 1595
		len = map->format.reg_bytes + map->format.pad_bytes + val_len;
		buf = kzalloc(len, GFP_KERNEL);
1596 1597 1598 1599
		if (!buf)
			return -ENOMEM;

		memcpy(buf, map->work_buf, map->format.reg_bytes);
1600 1601
		memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
		       val, val_len);
1602
		ret = map->bus->write(map->bus_context, buf, len);
1603 1604

		kfree(buf);
1605
	} else if (ret != 0 && !map->cache_bypass && map->format.parse_val) {
1606 1607 1608 1609 1610
		/* regcache_drop_region() takes lock that we already have,
		 * thus call map->cache_ops->drop() directly
		 */
		if (map->cache_ops && map->cache_ops->drop)
			map->cache_ops->drop(map, reg, reg + 1);
1611 1612
	}

1613
	trace_regmap_hw_write_done(map, reg, val_len / map->format.val_bytes);
M
Mark Brown 已提交
1614

1615 1616 1617
	return ret;
}

1618 1619 1620 1621 1622 1623 1624
/**
 * regmap_can_raw_write - Test if regmap_raw_write() is supported
 *
 * @map: Map to check.
 */
bool regmap_can_raw_write(struct regmap *map)
{
1625 1626
	return map->bus && map->bus->write && map->format.format_val &&
		map->format.format_reg;
1627 1628 1629
}
EXPORT_SYMBOL_GPL(regmap_can_raw_write);

1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651
/**
 * regmap_get_raw_read_max - Get the maximum size we can read
 *
 * @map: Map to check.
 */
size_t regmap_get_raw_read_max(struct regmap *map)
{
	return map->max_raw_read;
}
EXPORT_SYMBOL_GPL(regmap_get_raw_read_max);

/**
 * regmap_get_raw_write_max - Get the maximum size we can read
 *
 * @map: Map to check.
 */
size_t regmap_get_raw_write_max(struct regmap *map)
{
	return map->max_raw_write;
}
EXPORT_SYMBOL_GPL(regmap_get_raw_write_max);

1652 1653 1654 1655 1656 1657 1658
static int _regmap_bus_formatted_write(void *context, unsigned int reg,
				       unsigned int val)
{
	int ret;
	struct regmap_range_node *range;
	struct regmap *map = context;

1659
	WARN_ON(!map->bus || !map->format.format_write);
1660 1661 1662 1663 1664 1665 1666 1667 1668 1669

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

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

1670
	trace_regmap_hw_write_start(map, reg, 1);
1671 1672 1673 1674

	ret = map->bus->write(map->bus_context, map->work_buf,
			      map->format.buf_size);

1675
	trace_regmap_hw_write_done(map, reg, 1);
1676 1677 1678 1679

	return ret;
}

1680 1681 1682 1683 1684 1685 1686 1687
static int _regmap_bus_reg_write(void *context, unsigned int reg,
				 unsigned int val)
{
	struct regmap *map = context;

	return map->bus->reg_write(map->bus_context, reg, val);
}

1688 1689 1690 1691 1692
static int _regmap_bus_raw_write(void *context, unsigned int reg,
				 unsigned int val)
{
	struct regmap *map = context;

1693
	WARN_ON(!map->bus || !map->format.format_val);
1694 1695 1696 1697 1698 1699 1700

	map->format.format_val(map->work_buf + map->format.reg_bytes
			       + map->format.pad_bytes, val, 0);
	return _regmap_raw_write(map, reg,
				 map->work_buf +
				 map->format.reg_bytes +
				 map->format.pad_bytes,
1701
				 map->format.val_bytes);
1702 1703
}

1704 1705 1706 1707 1708
static inline void *_regmap_map_get_context(struct regmap *map)
{
	return (map->bus) ? map : map->bus_context;
}

1709 1710
int _regmap_write(struct regmap *map, unsigned int reg,
		  unsigned int val)
1711
{
M
Mark Brown 已提交
1712
	int ret;
1713
	void *context = _regmap_map_get_context(map);
1714

1715 1716 1717
	if (!regmap_writeable(map, reg))
		return -EIO;

1718
	if (!map->cache_bypass && !map->defer_caching) {
1719 1720 1721
		ret = regcache_write(map, reg, val);
		if (ret != 0)
			return ret;
1722 1723
		if (map->cache_only) {
			map->cache_dirty = true;
1724
			return 0;
1725
		}
1726 1727
	}

1728
#ifdef LOG_DEVICE
1729
	if (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
1730 1731 1732
		dev_info(map->dev, "%x <= %x\n", reg, val);
#endif

1733
	trace_regmap_reg_write(map, reg, val);
M
Mark Brown 已提交
1734

1735
	return map->reg_write(context, reg, val);
1736 1737 1738
}

/**
1739
 * regmap_write() - Write a value to a single register
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751
 *
 * @map: Register map to write to
 * @reg: Register to write to
 * @val: Value to be written
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
{
	int ret;

1752
	if (!IS_ALIGNED(reg, map->reg_stride))
1753 1754
		return -EINVAL;

1755
	map->lock(map->lock_arg);
1756 1757 1758

	ret = _regmap_write(map, reg, val);

1759
	map->unlock(map->lock_arg);
1760 1761 1762 1763 1764

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_write);

1765
/**
1766
 * regmap_write_async() - Write a value to a single register asynchronously
1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
 *
 * @map: Register map to write to
 * @reg: Register to write to
 * @val: Value to be written
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val)
{
	int ret;

1779
	if (!IS_ALIGNED(reg, map->reg_stride))
1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795
		return -EINVAL;

	map->lock(map->lock_arg);

	map->async = true;

	ret = _regmap_write(map, reg, val);

	map->async = false;

	map->unlock(map->lock_arg);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_write_async);

1796
/**
1797
 * regmap_raw_write() - Write raw values to one or more registers
1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
 *
 * @map: Register map to write to
 * @reg: Initial register to write to
 * @val: Block of data to be written, laid out for direct transmission to the
 *       device
 * @val_len: Length of data pointed to by val.
 *
 * This function is intended to be used for things like firmware
 * download where a large block of data needs to be transferred to the
 * device.  No formatting will be done on the data provided.
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_raw_write(struct regmap *map, unsigned int reg,
		     const void *val, size_t val_len)
{
	int ret;

1817
	if (!regmap_can_raw_write(map))
1818
		return -EINVAL;
1819 1820
	if (val_len % map->format.val_bytes)
		return -EINVAL;
1821 1822
	if (map->max_raw_write && map->max_raw_write > val_len)
		return -E2BIG;
1823

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

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

1828
	map->unlock(map->lock_arg);
1829 1830 1831 1832 1833

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_raw_write);

1834
/**
1835 1836
 * regmap_field_update_bits_base() - Perform a read/modify/write cycle a
 *                                   register field.
1837 1838 1839 1840
 *
 * @field: Register field to write to
 * @mask: Bitmask to change
 * @val: Value to be written
1841 1842 1843
 * @change: Boolean indicating if a write was done
 * @async: Boolean indicating asynchronously
 * @force: Boolean indicating use force update
1844
 *
1845 1846 1847
 * Perform a read/modify/write cycle on the register field with change,
 * async, force option.
 *
1848 1849 1850
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
1851 1852 1853
int regmap_field_update_bits_base(struct regmap_field *field,
				  unsigned int mask, unsigned int val,
				  bool *change, bool async, bool force)
1854 1855 1856
{
	mask = (mask << field->shift) & field->mask;

1857 1858 1859
	return regmap_update_bits_base(field->regmap, field->reg,
				       mask, val << field->shift,
				       change, async, force);
1860
}
1861
EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);
1862

1863
/**
1864 1865
 * regmap_fields_update_bits_base() - Perform a read/modify/write cycle a
 *                                    register field with port ID
1866 1867 1868 1869 1870
 *
 * @field: Register field to write to
 * @id: port ID
 * @mask: Bitmask to change
 * @val: Value to be written
1871 1872 1873
 * @change: Boolean indicating if a write was done
 * @async: Boolean indicating asynchronously
 * @force: Boolean indicating use force update
1874 1875 1876 1877
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
1878 1879 1880
int regmap_fields_update_bits_base(struct regmap_field *field,  unsigned int id,
				   unsigned int mask, unsigned int val,
				   bool *change, bool async, bool force)
1881 1882 1883 1884 1885 1886
{
	if (id >= field->id_size)
		return -EINVAL;

	mask = (mask << field->shift) & field->mask;

1887 1888 1889 1890
	return regmap_update_bits_base(field->regmap,
				       field->reg + (field->id_offset * id),
				       mask, val << field->shift,
				       change, async, force);
1891
}
1892
EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);
1893

1894 1895
/**
 * regmap_bulk_write() - Write multiple registers to the device
1896 1897 1898 1899 1900 1901 1902
 *
 * @map: Register map to write to
 * @reg: First register to be write from
 * @val: Block of data to be written, in native register size for device
 * @val_count: Number of registers to write
 *
 * This function is intended to be used for writing a large block of
1903
 * data to the device either in single transfer or multiple transfer.
1904 1905 1906 1907 1908 1909 1910 1911 1912
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
		     size_t val_count)
{
	int ret = 0, i;
	size_t val_bytes = map->format.val_bytes;
1913
	size_t total_size = val_bytes * val_count;
1914

1915
	if (!IS_ALIGNED(reg, map->reg_stride))
1916
		return -EINVAL;
1917

1918 1919
	/*
	 * Some devices don't support bulk write, for
1920 1921 1922 1923 1924
	 * them we have a series of single write operations in the first two if
	 * blocks.
	 *
	 * The first if block is used for memory mapped io. It does not allow
	 * val_bytes of 3 for example.
1925 1926
	 * The second one is for busses that do not provide raw I/O.
	 * The third one is used for busses which do not have these limitations
1927
	 * and can write arbitrary value lengths.
1928
	 */
1929
	if (!map->bus) {
1930
		map->lock(map->lock_arg);
1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952
		for (i = 0; i < val_count; i++) {
			unsigned int ival;

			switch (val_bytes) {
			case 1:
				ival = *(u8 *)(val + (i * val_bytes));
				break;
			case 2:
				ival = *(u16 *)(val + (i * val_bytes));
				break;
			case 4:
				ival = *(u32 *)(val + (i * val_bytes));
				break;
#ifdef CONFIG_64BIT
			case 8:
				ival = *(u64 *)(val + (i * val_bytes));
				break;
#endif
			default:
				ret = -EINVAL;
				goto out;
			}
1953

1954 1955 1956
			ret = _regmap_write(map,
					    reg + regmap_get_offset(map, i),
					    ival);
1957 1958 1959
			if (ret != 0)
				goto out;
		}
1960 1961
out:
		map->unlock(map->lock_arg);
1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
	} else if (map->bus && !map->format.parse_inplace) {
		const u8 *u8 = val;
		const u16 *u16 = val;
		const u32 *u32 = val;
		unsigned int ival;

		for (i = 0; i < val_count; i++) {
			switch (map->format.val_bytes) {
			case 4:
				ival = u32[i];
				break;
			case 2:
				ival = u16[i];
				break;
			case 1:
				ival = u8[i];
				break;
			default:
				return -EINVAL;
			}

			ret = regmap_write(map, reg + (i * map->reg_stride),
					   ival);
			if (ret)
				return ret;
		}
1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001
	} else if (map->use_single_write ||
		   (map->max_raw_write && map->max_raw_write < total_size)) {
		int chunk_stride = map->reg_stride;
		size_t chunk_size = val_bytes;
		size_t chunk_count = val_count;

		if (!map->use_single_write) {
			chunk_size = map->max_raw_write;
			if (chunk_size % val_bytes)
				chunk_size -= chunk_size % val_bytes;
			chunk_count = total_size / chunk_size;
			chunk_stride *= chunk_size / val_bytes;
		}

2002
		map->lock(map->lock_arg);
2003 2004
		/* Write as many bytes as possible with chunk_size */
		for (i = 0; i < chunk_count; i++) {
2005
			ret = _regmap_raw_write(map,
2006 2007 2008
						reg + (i * chunk_stride),
						val + (i * chunk_size),
						chunk_size);
2009 2010 2011
			if (ret)
				break;
		}
2012 2013 2014 2015 2016 2017 2018

		/* Write remaining bytes */
		if (!ret && chunk_size * i < total_size) {
			ret = _regmap_raw_write(map, reg + (i * chunk_stride),
						val + (i * chunk_size),
						total_size - i * chunk_size);
		}
2019
		map->unlock(map->lock_arg);
2020
	} else {
2021 2022
		void *wval;

2023 2024 2025
		if (!val_count)
			return -EINVAL;

2026
		wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
2027 2028
		if (!wval) {
			dev_err(map->dev, "Error in memory allocation\n");
2029
			return -ENOMEM;
2030 2031
		}
		for (i = 0; i < val_count * val_bytes; i += val_bytes)
2032
			map->format.parse_inplace(wval + i);
2033

2034
		map->lock(map->lock_arg);
2035
		ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count);
2036
		map->unlock(map->lock_arg);
2037 2038

		kfree(wval);
2039
	}
2040 2041 2042 2043
	return ret;
}
EXPORT_SYMBOL_GPL(regmap_bulk_write);

2044 2045 2046 2047 2048
/*
 * _regmap_raw_multi_reg_write()
 *
 * the (register,newvalue) pairs in regs have not been formatted, but
 * they are all in the same page and have been changed to being page
X
Xiubo Li 已提交
2049
 * relative. The page register has been written if that was necessary.
2050 2051
 */
static int _regmap_raw_multi_reg_write(struct regmap *map,
2052
				       const struct reg_sequence *regs,
2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064
				       size_t num_regs)
{
	int ret;
	void *buf;
	int i;
	u8 *u8;
	size_t val_bytes = map->format.val_bytes;
	size_t reg_bytes = map->format.reg_bytes;
	size_t pad_bytes = map->format.pad_bytes;
	size_t pair_size = reg_bytes + pad_bytes + val_bytes;
	size_t len = pair_size * num_regs;

2065 2066 2067
	if (!len)
		return -EINVAL;

2068 2069 2070 2071 2072 2073 2074 2075 2076
	buf = kzalloc(len, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	/* We have to linearise by hand. */

	u8 = buf;

	for (i = 0; i < num_regs; i++) {
2077 2078
		unsigned int reg = regs[i].reg;
		unsigned int val = regs[i].def;
2079
		trace_regmap_hw_write_start(map, reg, 1);
2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093
		map->format.format_reg(u8, reg, map->reg_shift);
		u8 += reg_bytes + pad_bytes;
		map->format.format_val(u8, val, 0);
		u8 += val_bytes;
	}
	u8 = buf;
	*u8 |= map->write_flag_mask;

	ret = map->bus->write(map->bus_context, buf, len);

	kfree(buf);

	for (i = 0; i < num_regs; i++) {
		int reg = regs[i].reg;
2094
		trace_regmap_hw_write_done(map, reg, 1);
2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108
	}
	return ret;
}

static unsigned int _regmap_register_page(struct regmap *map,
					  unsigned int reg,
					  struct regmap_range_node *range)
{
	unsigned int win_page = (reg - range->range_min) / range->window_len;

	return win_page;
}

static int _regmap_range_multi_paged_reg_write(struct regmap *map,
2109
					       struct reg_sequence *regs,
2110 2111 2112 2113
					       size_t num_regs)
{
	int ret;
	int i, n;
2114
	struct reg_sequence *base;
2115
	unsigned int this_page = 0;
2116
	unsigned int page_change = 0;
2117 2118 2119
	/*
	 * the set of registers are not neccessarily in order, but
	 * since the order of write must be preserved this algorithm
2120 2121
	 * chops the set each time the page changes. This also applies
	 * if there is a delay required at any point in the sequence.
2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136
	 */
	base = regs;
	for (i = 0, n = 0; i < num_regs; i++, n++) {
		unsigned int reg = regs[i].reg;
		struct regmap_range_node *range;

		range = _regmap_range_lookup(map, reg);
		if (range) {
			unsigned int win_page = _regmap_register_page(map, reg,
								      range);

			if (i == 0)
				this_page = win_page;
			if (win_page != this_page) {
				this_page = win_page;
2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156
				page_change = 1;
			}
		}

		/* If we have both a page change and a delay make sure to
		 * write the regs and apply the delay before we change the
		 * page.
		 */

		if (page_change || regs[i].delay_us) {

				/* For situations where the first write requires
				 * a delay we need to make sure we don't call
				 * raw_multi_reg_write with n=0
				 * This can't occur with page breaks as we
				 * never write on the first iteration
				 */
				if (regs[i].delay_us && i == 0)
					n = 1;

2157 2158 2159
				ret = _regmap_raw_multi_reg_write(map, base, n);
				if (ret != 0)
					return ret;
2160 2161 2162 2163

				if (regs[i].delay_us)
					udelay(regs[i].delay_us);

2164 2165
				base += n;
				n = 0;
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176

				if (page_change) {
					ret = _regmap_select_page(map,
								  &base[n].reg,
								  range, 1);
					if (ret != 0)
						return ret;

					page_change = 0;
				}

2177
		}
2178

2179 2180 2181 2182 2183 2184
	}
	if (n > 0)
		return _regmap_raw_multi_reg_write(map, base, n);
	return 0;
}

2185
static int _regmap_multi_reg_write(struct regmap *map,
2186
				   const struct reg_sequence *regs,
2187
				   size_t num_regs)
2188
{
2189 2190 2191 2192 2193 2194 2195 2196
	int i;
	int ret;

	if (!map->can_multi_write) {
		for (i = 0; i < num_regs; i++) {
			ret = _regmap_write(map, regs[i].reg, regs[i].def);
			if (ret != 0)
				return ret;
2197 2198 2199

			if (regs[i].delay_us)
				udelay(regs[i].delay_us);
2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211
		}
		return 0;
	}

	if (!map->format.parse_inplace)
		return -EINVAL;

	if (map->writeable_reg)
		for (i = 0; i < num_regs; i++) {
			int reg = regs[i].reg;
			if (!map->writeable_reg(map->dev, reg))
				return -EINVAL;
2212
			if (!IS_ALIGNED(reg, map->reg_stride))
2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234
				return -EINVAL;
		}

	if (!map->cache_bypass) {
		for (i = 0; i < num_regs; i++) {
			unsigned int val = regs[i].def;
			unsigned int reg = regs[i].reg;
			ret = regcache_write(map, reg, val);
			if (ret) {
				dev_err(map->dev,
				"Error in caching of register: %x ret: %d\n",
								reg, ret);
				return ret;
			}
		}
		if (map->cache_only) {
			map->cache_dirty = true;
			return 0;
		}
	}

	WARN_ON(!map->bus);
2235 2236

	for (i = 0; i < num_regs; i++) {
2237 2238
		unsigned int reg = regs[i].reg;
		struct regmap_range_node *range;
2239 2240 2241 2242

		/* Coalesce all the writes between a page break or a delay
		 * in a sequence
		 */
2243
		range = _regmap_range_lookup(map, reg);
2244
		if (range || regs[i].delay_us) {
2245 2246
			size_t len = sizeof(struct reg_sequence)*num_regs;
			struct reg_sequence *base = kmemdup(regs, len,
2247 2248 2249 2250 2251 2252 2253
							   GFP_KERNEL);
			if (!base)
				return -ENOMEM;
			ret = _regmap_range_multi_paged_reg_write(map, base,
								  num_regs);
			kfree(base);

2254 2255 2256
			return ret;
		}
	}
2257
	return _regmap_raw_multi_reg_write(map, regs, num_regs);
2258 2259
}

2260 2261
/**
 * regmap_multi_reg_write() - Write multiple registers to the device
2262 2263 2264 2265 2266
 *
 * @map: Register map to write to
 * @regs: Array of structures containing register,value to be written
 * @num_regs: Number of registers to write
 *
2267 2268 2269
 * Write multiple registers to the device where the set of register, value
 * pairs are supplied in any order, possibly not all in a single range.
 *
2270
 * The 'normal' block write mode will send ultimately send data on the
2271
 * target bus as R,V1,V2,V3,..,Vn where successively higher registers are
2272 2273 2274
 * addressed. However, this alternative block multi write mode will send
 * the data as R1,V1,R2,V2,..,Rn,Vn on the target bus. The target device
 * must of course support the mode.
2275
 *
2276 2277
 * A value of zero will be returned on success, a negative errno will be
 * returned in error cases.
2278
 */
2279
int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
2280
			   int num_regs)
2281
{
2282
	int ret;
2283 2284 2285

	map->lock(map->lock_arg);

2286 2287
	ret = _regmap_multi_reg_write(map, regs, num_regs);

2288 2289 2290 2291 2292 2293
	map->unlock(map->lock_arg);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_multi_reg_write);

2294 2295 2296
/**
 * regmap_multi_reg_write_bypassed() - Write multiple registers to the
 *                                     device but not the cache
2297 2298 2299 2300 2301
 *
 * @map: Register map to write to
 * @regs: Array of structures containing register,value to be written
 * @num_regs: Number of registers to write
 *
2302 2303 2304
 * Write multiple registers to the device but not the cache where the set
 * of register are supplied in any order.
 *
2305 2306 2307 2308 2309 2310 2311
 * This function is intended to be used for writing a large block of data
 * atomically to the device in single transfer for those I2C client devices
 * that implement this alternative block write mode.
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
2312
int regmap_multi_reg_write_bypassed(struct regmap *map,
2313
				    const struct reg_sequence *regs,
2314
				    int num_regs)
2315
{
2316 2317
	int ret;
	bool bypass;
2318 2319 2320

	map->lock(map->lock_arg);

2321 2322 2323 2324 2325 2326 2327
	bypass = map->cache_bypass;
	map->cache_bypass = true;

	ret = _regmap_multi_reg_write(map, regs, num_regs);

	map->cache_bypass = bypass;

2328 2329 2330 2331
	map->unlock(map->lock_arg);

	return ret;
}
2332
EXPORT_SYMBOL_GPL(regmap_multi_reg_write_bypassed);
2333

2334
/**
2335 2336
 * regmap_raw_write_async() - Write raw values to one or more registers
 *                            asynchronously
2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362
 *
 * @map: Register map to write to
 * @reg: Initial register to write to
 * @val: Block of data to be written, laid out for direct transmission to the
 *       device.  Must be valid until regmap_async_complete() is called.
 * @val_len: Length of data pointed to by val.
 *
 * This function is intended to be used for things like firmware
 * download where a large block of data needs to be transferred to the
 * device.  No formatting will be done on the data provided.
 *
 * If supported by the underlying bus the write will be scheduled
 * asynchronously, helping maximise I/O speed on higher speed buses
 * like SPI.  regmap_async_complete() can be called to ensure that all
 * asynchrnous writes have been completed.
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_raw_write_async(struct regmap *map, unsigned int reg,
			   const void *val, size_t val_len)
{
	int ret;

	if (val_len % map->format.val_bytes)
		return -EINVAL;
2363
	if (!IS_ALIGNED(reg, map->reg_stride))
2364 2365 2366 2367
		return -EINVAL;

	map->lock(map->lock_arg);

2368 2369 2370 2371 2372
	map->async = true;

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

	map->async = false;
2373 2374 2375 2376 2377 2378 2379

	map->unlock(map->lock_arg);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_raw_write_async);

2380 2381 2382
static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
			    unsigned int val_len)
{
2383
	struct regmap_range_node *range;
2384 2385
	int ret;

2386
	WARN_ON(!map->bus);
2387

2388 2389 2390
	if (!map->bus || !map->bus->read)
		return -EINVAL;

2391 2392 2393 2394
	range = _regmap_range_lookup(map, reg);
	if (range) {
		ret = _regmap_select_page(map, &reg, range,
					  val_len / map->format.val_bytes);
2395
		if (ret != 0)
2396 2397
			return ret;
	}
2398

2399
	map->format.format_reg(map->work_buf, reg, map->reg_shift);
2400 2401
	regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
				      map->read_flag_mask);
2402
	trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
M
Mark Brown 已提交
2403

2404
	ret = map->bus->read(map->bus_context, map->work_buf,
2405
			     map->format.reg_bytes + map->format.pad_bytes,
M
Mark Brown 已提交
2406
			     val, val_len);
2407

2408
	trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
M
Mark Brown 已提交
2409 2410

	return ret;
2411 2412
}

2413 2414 2415 2416 2417 2418 2419 2420
static int _regmap_bus_reg_read(void *context, unsigned int reg,
				unsigned int *val)
{
	struct regmap *map = context;

	return map->bus->reg_read(map->bus_context, reg, val);
}

2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
static int _regmap_bus_read(void *context, unsigned int reg,
			    unsigned int *val)
{
	int ret;
	struct regmap *map = context;

	if (!map->format.parse_val)
		return -EINVAL;

	ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
	if (ret == 0)
		*val = map->format.parse_val(map->work_buf);

	return ret;
}

2437 2438 2439 2440
static int _regmap_read(struct regmap *map, unsigned int reg,
			unsigned int *val)
{
	int ret;
2441 2442
	void *context = _regmap_map_get_context(map);

2443 2444 2445 2446 2447 2448 2449 2450 2451
	if (!map->cache_bypass) {
		ret = regcache_read(map, reg, val);
		if (ret == 0)
			return 0;
	}

	if (map->cache_only)
		return -EBUSY;

2452 2453 2454
	if (!regmap_readable(map, reg))
		return -EIO;

2455
	ret = map->reg_read(context, reg, val);
M
Mark Brown 已提交
2456
	if (ret == 0) {
2457
#ifdef LOG_DEVICE
2458
		if (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
2459 2460 2461
			dev_info(map->dev, "%x => %x\n", reg, *val);
#endif

2462
		trace_regmap_reg_read(map, reg, *val);
2463

2464 2465 2466
		if (!map->cache_bypass)
			regcache_write(map, reg, *val);
	}
2467

2468 2469 2470 2471
	return ret;
}

/**
2472
 * regmap_read() - Read a value from a single register
2473
 *
2474
 * @map: Register map to read from
2475 2476 2477 2478 2479 2480 2481 2482 2483 2484
 * @reg: Register to be read from
 * @val: Pointer to store read value
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
{
	int ret;

2485
	if (!IS_ALIGNED(reg, map->reg_stride))
2486 2487
		return -EINVAL;

2488
	map->lock(map->lock_arg);
2489 2490 2491

	ret = _regmap_read(map, reg, val);

2492
	map->unlock(map->lock_arg);
2493 2494 2495 2496 2497 2498

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_read);

/**
2499
 * regmap_raw_read() - Read raw data from the device
2500
 *
2501
 * @map: Register map to read from
2502 2503 2504 2505 2506 2507 2508 2509 2510 2511
 * @reg: First register to be read from
 * @val: Pointer to store read value
 * @val_len: Size of data to read
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
		    size_t val_len)
{
2512 2513 2514 2515
	size_t val_bytes = map->format.val_bytes;
	size_t val_count = val_len / val_bytes;
	unsigned int v;
	int ret, i;
2516

2517 2518
	if (!map->bus)
		return -EINVAL;
2519 2520
	if (val_len % map->format.val_bytes)
		return -EINVAL;
2521
	if (!IS_ALIGNED(reg, map->reg_stride))
2522
		return -EINVAL;
2523 2524
	if (val_count == 0)
		return -EINVAL;
2525

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

2528 2529
	if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
	    map->cache_type == REGCACHE_NONE) {
2530 2531 2532 2533
		if (!map->bus->read) {
			ret = -ENOTSUPP;
			goto out;
		}
2534 2535 2536 2537
		if (map->max_raw_read && map->max_raw_read < val_len) {
			ret = -E2BIG;
			goto out;
		}
2538

2539 2540 2541 2542 2543 2544 2545 2546
		/* Physical block read if there's no cache involved */
		ret = _regmap_raw_read(map, reg, val, val_len);

	} else {
		/* Otherwise go word by word for the cache; should be low
		 * cost as we expect to hit the cache.
		 */
		for (i = 0; i < val_count; i++) {
2547
			ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2548
					   &v);
2549 2550 2551
			if (ret != 0)
				goto out;

2552
			map->format.format_val(val + (i * val_bytes), v, 0);
2553 2554
		}
	}
2555

2556
 out:
2557
	map->unlock(map->lock_arg);
2558 2559 2560 2561 2562

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_raw_read);

2563
/**
2564
 * regmap_field_read() - Read a value to a single register field
2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587
 *
 * @field: Register field to read from
 * @val: Pointer to store read value
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_field_read(struct regmap_field *field, unsigned int *val)
{
	int ret;
	unsigned int reg_val;
	ret = regmap_read(field->regmap, field->reg, &reg_val);
	if (ret != 0)
		return ret;

	reg_val &= field->mask;
	reg_val >>= field->shift;
	*val = reg_val;

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_field_read);

2588
/**
2589
 * regmap_fields_read() - Read a value to a single register field with port ID
2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620
 *
 * @field: Register field to read from
 * @id: port ID
 * @val: Pointer to store read value
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_fields_read(struct regmap_field *field, unsigned int id,
		       unsigned int *val)
{
	int ret;
	unsigned int reg_val;

	if (id >= field->id_size)
		return -EINVAL;

	ret = regmap_read(field->regmap,
			  field->reg + (field->id_offset * id),
			  &reg_val);
	if (ret != 0)
		return ret;

	reg_val &= field->mask;
	reg_val >>= field->shift;
	*val = reg_val;

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_fields_read);

2621
/**
2622
 * regmap_bulk_read() - Read multiple registers from the device
2623
 *
2624
 * @map: Register map to read from
2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636
 * @reg: First register to be read from
 * @val: Pointer to store read value, in native register size for device
 * @val_count: Number of registers to read
 *
 * A value of zero will be returned on success, a negative errno will
 * be returned in error cases.
 */
int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
		     size_t val_count)
{
	int ret, i;
	size_t val_bytes = map->format.val_bytes;
2637
	bool vol = regmap_volatile_range(map, reg, val_count);
2638

2639
	if (!IS_ALIGNED(reg, map->reg_stride))
2640
		return -EINVAL;
2641

2642
	if (map->bus && map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
2643 2644 2645 2646
		/*
		 * Some devices does not support bulk read, for
		 * them we have a series of single read operations.
		 */
2647 2648 2649 2650
		size_t total_size = val_bytes * val_count;

		if (!map->use_single_read &&
		    (!map->max_raw_read || map->max_raw_read > total_size)) {
2651 2652 2653 2654
			ret = regmap_raw_read(map, reg, val,
					      val_bytes * val_count);
			if (ret != 0)
				return ret;
2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691
		} else {
			/*
			 * Some devices do not support bulk read or do not
			 * support large bulk reads, for them we have a series
			 * of read operations.
			 */
			int chunk_stride = map->reg_stride;
			size_t chunk_size = val_bytes;
			size_t chunk_count = val_count;

			if (!map->use_single_read) {
				chunk_size = map->max_raw_read;
				if (chunk_size % val_bytes)
					chunk_size -= chunk_size % val_bytes;
				chunk_count = total_size / chunk_size;
				chunk_stride *= chunk_size / val_bytes;
			}

			/* Read bytes that fit into a multiple of chunk_size */
			for (i = 0; i < chunk_count; i++) {
				ret = regmap_raw_read(map,
						      reg + (i * chunk_stride),
						      val + (i * chunk_size),
						      chunk_size);
				if (ret != 0)
					return ret;
			}

			/* Read remaining bytes */
			if (chunk_size * i < total_size) {
				ret = regmap_raw_read(map,
						      reg + (i * chunk_stride),
						      val + (i * chunk_size),
						      total_size - i * chunk_size);
				if (ret != 0)
					return ret;
			}
2692
		}
2693 2694

		for (i = 0; i < val_count * val_bytes; i += val_bytes)
2695
			map->format.parse_inplace(val + i);
2696 2697
	} else {
		for (i = 0; i < val_count; i++) {
2698
			unsigned int ival;
2699
			ret = regmap_read(map, reg + regmap_get_offset(map, i),
2700
					  &ival);
2701 2702
			if (ret != 0)
				return ret;
2703 2704 2705 2706 2707 2708 2709 2710 2711 2712

			if (map->format.format_val) {
				map->format.format_val(val + (i * val_bytes), ival, 0);
			} else {
				/* Devices providing read and write
				 * operations can use the bulk I/O
				 * functions if they define a val_bytes,
				 * we assume that the values are native
				 * endian.
				 */
2713
#ifdef CONFIG_64BIT
X
Xiubo Li 已提交
2714
				u64 *u64 = val;
2715
#endif
2716 2717 2718 2719 2720
				u32 *u32 = val;
				u16 *u16 = val;
				u8 *u8 = val;

				switch (map->format.val_bytes) {
X
Xiubo Li 已提交
2721 2722 2723 2724 2725
#ifdef CONFIG_64BIT
				case 8:
					u64[i] = ival;
					break;
#endif
2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738
				case 4:
					u32[i] = ival;
					break;
				case 2:
					u16[i] = ival;
					break;
				case 1:
					u8[i] = ival;
					break;
				default:
					return -EINVAL;
				}
			}
2739 2740
		}
	}
2741 2742 2743 2744 2745

	return 0;
}
EXPORT_SYMBOL_GPL(regmap_bulk_read);

2746 2747
static int _regmap_update_bits(struct regmap *map, unsigned int reg,
			       unsigned int mask, unsigned int val,
2748
			       bool *change, bool force_write)
2749 2750
{
	int ret;
2751
	unsigned int tmp, orig;
2752

2753 2754
	if (change)
		*change = false;
2755

2756 2757 2758
	if (regmap_volatile(map, reg) && map->reg_update_bits) {
		ret = map->reg_update_bits(map->bus_context, reg, mask, val);
		if (ret == 0 && change)
2759
			*change = true;
2760
	} else {
2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772
		ret = _regmap_read(map, reg, &orig);
		if (ret != 0)
			return ret;

		tmp = orig & ~mask;
		tmp |= val & mask;

		if (force_write || (tmp != orig)) {
			ret = _regmap_write(map, reg, tmp);
			if (ret == 0 && change)
				*change = true;
		}
2773
	}
2774 2775 2776

	return ret;
}
2777 2778

/**
2779
 * regmap_update_bits_base() - Perform a read/modify/write cycle on a register
2780 2781 2782 2783 2784 2785
 *
 * @map: Register map to update
 * @reg: Register to update
 * @mask: Bitmask to change
 * @val: New value for bitmask
 * @change: Boolean indicating if a write was done
2786 2787
 * @async: Boolean indicating asynchronously
 * @force: Boolean indicating use force update
2788
 *
2789 2790 2791 2792 2793 2794 2795 2796
 * Perform a read/modify/write cycle on a register map with change, async, force
 * options.
 *
 * If async is true:
 *
 * With most buses the read must be done synchronously so this is most useful
 * for devices with a cache which do not need to interact with the hardware to
 * determine the current register value.
2797 2798 2799
 *
 * Returns zero for success, a negative number on error.
 */
2800 2801 2802
int regmap_update_bits_base(struct regmap *map, unsigned int reg,
			    unsigned int mask, unsigned int val,
			    bool *change, bool async, bool force)
2803 2804 2805 2806 2807
{
	int ret;

	map->lock(map->lock_arg);

2808
	map->async = async;
2809

2810
	ret = _regmap_update_bits(map, reg, mask, val, change, force);
2811 2812 2813 2814 2815 2816 2817

	map->async = false;

	map->unlock(map->lock_arg);

	return ret;
}
2818
EXPORT_SYMBOL_GPL(regmap_update_bits_base);
2819

2820 2821 2822 2823 2824
void regmap_async_complete_cb(struct regmap_async *async, int ret)
{
	struct regmap *map = async->map;
	bool wake;

2825
	trace_regmap_async_io_complete(map);
2826

2827
	spin_lock(&map->async_lock);
M
Mark Brown 已提交
2828
	list_move(&async->list, &map->async_free);
2829 2830 2831 2832 2833 2834 2835 2836 2837 2838
	wake = list_empty(&map->async_list);

	if (ret != 0)
		map->async_ret = ret;

	spin_unlock(&map->async_lock);

	if (wake)
		wake_up(&map->async_waitq);
}
2839
EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853

static int regmap_async_is_done(struct regmap *map)
{
	unsigned long flags;
	int ret;

	spin_lock_irqsave(&map->async_lock, flags);
	ret = list_empty(&map->async_list);
	spin_unlock_irqrestore(&map->async_lock, flags);

	return ret;
}

/**
2854
 * regmap_async_complete - Ensure all asynchronous I/O has completed.
2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866
 *
 * @map: Map to operate on.
 *
 * Blocks until any pending asynchronous I/O has completed.  Returns
 * an error code for any failed I/O operations.
 */
int regmap_async_complete(struct regmap *map)
{
	unsigned long flags;
	int ret;

	/* Nothing to do with no async support */
2867
	if (!map->bus || !map->bus->async_write)
2868 2869
		return 0;

2870
	trace_regmap_async_complete_start(map);
2871

2872 2873 2874 2875 2876 2877 2878
	wait_event(map->async_waitq, regmap_async_is_done(map));

	spin_lock_irqsave(&map->async_lock, flags);
	ret = map->async_ret;
	map->async_ret = 0;
	spin_unlock_irqrestore(&map->async_lock, flags);

2879
	trace_regmap_async_complete_done(map);
2880

2881 2882
	return ret;
}
2883
EXPORT_SYMBOL_GPL(regmap_async_complete);
2884

M
Mark Brown 已提交
2885
/**
2886 2887
 * regmap_register_patch - Register and apply register updates to be applied
 *                         on device initialistion
M
Mark Brown 已提交
2888 2889 2890 2891 2892 2893 2894 2895 2896 2897
 *
 * @map: Register map to apply updates to.
 * @regs: Values to update.
 * @num_regs: Number of entries in regs.
 *
 * Register a set of register updates to be applied to the device
 * whenever the device registers are synchronised with the cache and
 * apply them immediately.  Typically this is used to apply
 * corrections to be applied to the device defaults on startup, such
 * as the updates some vendors provide to undocumented registers.
2898 2899 2900
 *
 * The caller must ensure that this function cannot be called
 * concurrently with either itself or regcache_sync().
M
Mark Brown 已提交
2901
 */
2902
int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
M
Mark Brown 已提交
2903 2904
			  int num_regs)
{
2905
	struct reg_sequence *p;
2906
	int ret;
M
Mark Brown 已提交
2907 2908
	bool bypass;

2909 2910 2911 2912
	if (WARN_ONCE(num_regs <= 0, "invalid registers number (%d)\n",
	    num_regs))
		return 0;

2913
	p = krealloc(map->patch,
2914
		     sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
2915 2916 2917 2918 2919
		     GFP_KERNEL);
	if (p) {
		memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
		map->patch = p;
		map->patch_regs += num_regs;
M
Mark Brown 已提交
2920
	} else {
2921
		return -ENOMEM;
M
Mark Brown 已提交
2922 2923
	}

2924
	map->lock(map->lock_arg);
M
Mark Brown 已提交
2925 2926 2927 2928

	bypass = map->cache_bypass;

	map->cache_bypass = true;
2929
	map->async = true;
M
Mark Brown 已提交
2930

2931
	ret = _regmap_multi_reg_write(map, regs, num_regs);
M
Mark Brown 已提交
2932

2933
	map->async = false;
M
Mark Brown 已提交
2934 2935
	map->cache_bypass = bypass;

2936
	map->unlock(map->lock_arg);
M
Mark Brown 已提交
2937

2938 2939
	regmap_async_complete(map);

M
Mark Brown 已提交
2940 2941 2942 2943
	return ret;
}
EXPORT_SYMBOL_GPL(regmap_register_patch);

2944 2945 2946 2947
/**
 * regmap_get_val_bytes() - Report the size of a register value
 *
 * @map: Register map to operate on.
2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960
 *
 * Report the size of a register value, mainly intended to for use by
 * generic infrastructure built on top of regmap.
 */
int regmap_get_val_bytes(struct regmap *map)
{
	if (map->format.format_write)
		return -EINVAL;

	return map->format.val_bytes;
}
EXPORT_SYMBOL_GPL(regmap_get_val_bytes);

2961
/**
2962 2963 2964
 * regmap_get_max_register() - Report the max register value
 *
 * @map: Register map to operate on.
2965 2966 2967 2968 2969 2970 2971 2972 2973 2974
 *
 * Report the max register value, mainly intended to for use by
 * generic infrastructure built on top of regmap.
 */
int regmap_get_max_register(struct regmap *map)
{
	return map->max_register ? map->max_register : -EINVAL;
}
EXPORT_SYMBOL_GPL(regmap_get_max_register);

2975
/**
2976 2977 2978
 * regmap_get_reg_stride() - Report the register address stride
 *
 * @map: Register map to operate on.
2979 2980 2981 2982 2983 2984 2985 2986 2987 2988
 *
 * Report the register address stride, mainly intended to for use by
 * generic infrastructure built on top of regmap.
 */
int regmap_get_reg_stride(struct regmap *map)
{
	return map->reg_stride;
}
EXPORT_SYMBOL_GPL(regmap_get_reg_stride);

N
Nenghua Cao 已提交
2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000
int regmap_parse_val(struct regmap *map, const void *buf,
			unsigned int *val)
{
	if (!map->format.parse_val)
		return -EINVAL;

	*val = map->format.parse_val(buf);

	return 0;
}
EXPORT_SYMBOL_GPL(regmap_parse_val);

3001 3002 3003 3004 3005 3006 3007
static int __init regmap_initcall(void)
{
	regmap_debugfs_initcall();

	return 0;
}
postcore_initcall(regmap_initcall);