regmap.c 19.2 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 18
#include <linux/mutex.h>
#include <linux/err.h>

M
Mark Brown 已提交
19 20 21
#define CREATE_TRACE_POINTS
#include <trace/events/regmap.h>

22
#include "internal.h"
23

24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
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);

	return true;
}

bool regmap_readable(struct regmap *map, unsigned int reg)
{
	if (map->max_register && reg > map->max_register)
		return false;

40 41 42
	if (map->format.format_write)
		return false;

43 44 45 46 47 48 49 50
	if (map->readable_reg)
		return map->readable_reg(map->dev, reg);

	return true;
}

bool regmap_volatile(struct regmap *map, unsigned int reg)
{
51
	if (!regmap_readable(map, reg))
52 53 54 55 56 57 58 59 60 61
		return false;

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

	return true;
}

bool regmap_precious(struct regmap *map, unsigned int reg)
{
62
	if (!regmap_readable(map, reg))
63 64 65 66 67 68 69 70
		return false;

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

	return false;
}

71 72 73 74 75 76 77 78 79 80 81 82
static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
	unsigned int num)
{
	unsigned int i;

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

	return true;
}

83 84 85 86 87 88 89 90
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;
}

91 92 93 94 95 96 97 98 99 100 101 102 103 104
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);
}

105 106 107 108 109 110 111 112 113 114
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;
}

115 116 117 118 119 120 121 122 123 124 125 126 127 128
static void regmap_format_8(void *buf, unsigned int val)
{
	u8 *b = buf;

	b[0] = val;
}

static void regmap_format_16(void *buf, unsigned int val)
{
	__be16 *b = buf;

	b[0] = cpu_to_be16(val);
}

129 130 131 132 133 134 135
static void regmap_format_32(void *buf, unsigned int val)
{
	__be32 *b = buf;

	b[0] = cpu_to_be32(val);
}

136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151
static unsigned int regmap_parse_8(void *buf)
{
	u8 *b = buf;

	return b[0];
}

static unsigned int regmap_parse_16(void *buf)
{
	__be16 *b = buf;

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

	return b[0];
}

152 153 154 155 156 157 158 159 160
static unsigned int regmap_parse_32(void *buf)
{
	__be32 *b = buf;

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

	return b[0];
}

161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
/**
 * regmap_init(): Initialise register map
 *
 * @dev: Device that will be interacted with
 * @bus: Bus-specific callbacks to use with device
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer to
 * a struct regmap.  This function should generally not be called
 * directly, it should be called by bus-specific init functions.
 */
struct regmap *regmap_init(struct device *dev,
			   const struct regmap_bus *bus,
			   const struct regmap_config *config)
{
	struct regmap *map;
	int ret = -EINVAL;

	if (!bus || !config)
180
		goto err;
181 182 183 184 185 186 187 188 189

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

	mutex_init(&map->lock);
	map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
190
	map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
191
	map->format.pad_bytes = config->pad_bits / 8;
192
	map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
193
	map->format.buf_size += map->format.pad_bytes;
194 195
	map->dev = dev;
	map->bus = bus;
196 197 198 199
	map->max_register = config->max_register;
	map->writeable_reg = config->writeable_reg;
	map->readable_reg = config->readable_reg;
	map->volatile_reg = config->volatile_reg;
200
	map->precious_reg = config->precious_reg;
201
	map->cache_type = config->cache_type;
202

203 204 205 206 207 208 209
	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;
	} else {
		map->read_flag_mask = bus->read_flag_mask;
	}

210
	switch (config->reg_bits) {
211 212 213 214 215 216 217 218 219 220
	case 2:
		switch (config->val_bits) {
		case 6:
			map->format.format_write = regmap_format_2_6_write;
			break;
		default:
			goto err_map;
		}
		break;

221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240
	case 4:
		switch (config->val_bits) {
		case 12:
			map->format.format_write = regmap_format_4_12_write;
			break;
		default:
			goto err_map;
		}
		break;

	case 7:
		switch (config->val_bits) {
		case 9:
			map->format.format_write = regmap_format_7_9_write;
			break;
		default:
			goto err_map;
		}
		break;

241 242 243 244 245 246 247 248 249 250
	case 10:
		switch (config->val_bits) {
		case 14:
			map->format.format_write = regmap_format_10_14_write;
			break;
		default:
			goto err_map;
		}
		break;

251 252 253 254 255 256 257 258
	case 8:
		map->format.format_reg = regmap_format_8;
		break;

	case 16:
		map->format.format_reg = regmap_format_16;
		break;

259 260 261 262
	case 32:
		map->format.format_reg = regmap_format_32;
		break;

263 264 265 266 267 268 269 270 271 272 273 274 275
	default:
		goto err_map;
	}

	switch (config->val_bits) {
	case 8:
		map->format.format_val = regmap_format_8;
		map->format.parse_val = regmap_parse_8;
		break;
	case 16:
		map->format.format_val = regmap_format_16;
		map->format.parse_val = regmap_parse_16;
		break;
276 277 278 279
	case 32:
		map->format.format_val = regmap_format_32;
		map->format.parse_val = regmap_parse_32;
		break;
280 281 282 283 284 285
	}

	if (!map->format.format_write &&
	    !(map->format.format_reg && map->format.format_val))
		goto err_map;

286
	map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
287 288
	if (map->work_buf == NULL) {
		ret = -ENOMEM;
289
		goto err_map;
290 291
	}

292 293
	regmap_debugfs_init(map);

294
	ret = regcache_init(map, config);
295
	if (ret < 0)
296
		goto err_free_workbuf;
297

298 299
	return map;

300 301
err_free_workbuf:
	kfree(map->work_buf);
302 303 304 305 306 307 308
err_map:
	kfree(map);
err:
	return ERR_PTR(ret);
}
EXPORT_SYMBOL_GPL(regmap_init);

309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
static void devm_regmap_release(struct device *dev, void *res)
{
	regmap_exit(*(struct regmap **)res);
}

/**
 * devm_regmap_init(): Initialise managed register map
 *
 * @dev: Device that will be interacted with
 * @bus: Bus-specific callbacks to use with device
 * @config: Configuration for register map
 *
 * The return value will be an ERR_PTR() on error or a valid pointer
 * to a struct regmap.  This function should generally not be called
 * directly, it should be called by bus-specific init functions.  The
 * map will be automatically freed by the device management code.
 */
struct regmap *devm_regmap_init(struct device *dev,
				const struct regmap_bus *bus,
				const struct regmap_config *config)
{
	struct regmap **ptr, *regmap;

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

	regmap = regmap_init(dev, bus, config);
	if (!IS_ERR(regmap)) {
		*ptr = regmap;
		devres_add(dev, ptr);
	} else {
		devres_free(ptr);
	}

	return regmap;
}
EXPORT_SYMBOL_GPL(devm_regmap_init);

348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
/**
 * regmap_reinit_cache(): Reinitialise the current register cache
 *
 * @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.
 */
int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
{
	int ret;

	mutex_lock(&map->lock);

	regcache_exit(map);
366
	regmap_debugfs_exit(map);
367 368 369 370 371 372 373 374

	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;

375 376
	regmap_debugfs_init(map);

377 378 379
	map->cache_bypass = false;
	map->cache_only = false;

380 381 382 383 384 385 386
	ret = regcache_init(map, config);

	mutex_unlock(&map->lock);

	return ret;
}

387 388 389 390 391
/**
 * regmap_exit(): Free a previously allocated register map
 */
void regmap_exit(struct regmap *map)
{
392
	regcache_exit(map);
393
	regmap_debugfs_exit(map);
394 395 396 397 398 399 400 401
	kfree(map->work_buf);
	kfree(map);
}
EXPORT_SYMBOL_GPL(regmap_exit);

static int _regmap_raw_write(struct regmap *map, unsigned int reg,
			     const void *val, size_t val_len)
{
402
	u8 *u8 = map->work_buf;
403 404 405
	void *buf;
	int ret = -ENOTSUPP;
	size_t len;
406 407 408 409 410 411 412
	int i;

	/* Check for unwritable registers before we start */
	if (map->writeable_reg)
		for (i = 0; i < val_len / map->format.val_bytes; i++)
			if (!map->writeable_reg(map->dev, reg + i))
				return -EINVAL;
413 414 415

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

416 417
	u8[0] |= map->write_flag_mask;

M
Mark Brown 已提交
418 419 420
	trace_regmap_hw_write_start(map->dev, reg,
				    val_len / map->format.val_bytes);

421 422 423 424
	/* If we're doing a single register write we can probably just
	 * send the work_buf directly, otherwise try to do a gather
	 * write.
	 */
425 426
	if (val == (map->work_buf + map->format.pad_bytes +
		    map->format.reg_bytes))
427
		ret = map->bus->write(map->dev, map->work_buf,
428 429 430
				      map->format.reg_bytes +
				      map->format.pad_bytes +
				      val_len);
431
	else if (map->bus->gather_write)
432
		ret = map->bus->gather_write(map->dev, map->work_buf,
433 434
					     map->format.reg_bytes +
					     map->format.pad_bytes,
435 436
					     val, val_len);

437
	/* If that didn't work fall back on linearising by hand. */
438
	if (ret == -ENOTSUPP) {
439 440
		len = map->format.reg_bytes + map->format.pad_bytes + val_len;
		buf = kzalloc(len, GFP_KERNEL);
441 442 443 444
		if (!buf)
			return -ENOMEM;

		memcpy(buf, map->work_buf, map->format.reg_bytes);
445 446
		memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
		       val, val_len);
447 448 449 450 451
		ret = map->bus->write(map->dev, buf, len);

		kfree(buf);
	}

M
Mark Brown 已提交
452 453 454
	trace_regmap_hw_write_done(map->dev, reg,
				   val_len / map->format.val_bytes);

455 456 457
	return ret;
}

458 459
int _regmap_write(struct regmap *map, unsigned int reg,
		  unsigned int val)
460
{
M
Mark Brown 已提交
461
	int ret;
462 463
	BUG_ON(!map->format.format_write && !map->format.format_val);

464 465 466 467
	if (!map->cache_bypass) {
		ret = regcache_write(map, reg, val);
		if (ret != 0)
			return ret;
468 469
		if (map->cache_only) {
			map->cache_dirty = true;
470
			return 0;
471
		}
472 473
	}

M
Mark Brown 已提交
474 475
	trace_regmap_reg_write(map->dev, reg, val);

476 477 478
	if (map->format.format_write) {
		map->format.format_write(map, reg, val);

M
Mark Brown 已提交
479 480 481 482 483 484 485 486
		trace_regmap_hw_write_start(map->dev, reg, 1);

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

		trace_regmap_hw_write_done(map->dev, reg, 1);

		return ret;
487
	} else {
488 489
		map->format.format_val(map->work_buf + map->format.reg_bytes
				       + map->format.pad_bytes, val);
490
		return _regmap_raw_write(map, reg,
491 492 493
					 map->work_buf +
					 map->format.reg_bytes +
					 map->format.pad_bytes,
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
					 map->format.val_bytes);
	}
}

/**
 * regmap_write(): Write a value to a single register
 *
 * @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;

	mutex_lock(&map->lock);

	ret = _regmap_write(map, reg, val);

	mutex_unlock(&map->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_write);

/**
 * regmap_raw_write(): Write raw values to one or more registers
 *
 * @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)
{
541
	size_t val_count = val_len / map->format.val_bytes;
542 543
	int ret;

544 545
	WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
		map->cache_type != REGCACHE_NONE);
546

547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565
	mutex_lock(&map->lock);

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

	mutex_unlock(&map->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_raw_write);

static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
			    unsigned int val_len)
{
	u8 *u8 = map->work_buf;
	int ret;

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

	/*
566
	 * Some buses or devices flag reads by setting the high bits in the
567 568 569 570
	 * register addresss; since it's always the high bits for all
	 * current formats we can do this here rather than in
	 * formatting.  This may break if we get interesting formats.
	 */
571
	u8[0] |= map->read_flag_mask;
572

M
Mark Brown 已提交
573 574 575
	trace_regmap_hw_read_start(map->dev, reg,
				   val_len / map->format.val_bytes);

576 577
	ret = map->bus->read(map->dev, map->work_buf,
			     map->format.reg_bytes + map->format.pad_bytes,
M
Mark Brown 已提交
578
			     val, val_len);
579

M
Mark Brown 已提交
580 581 582 583
	trace_regmap_hw_read_done(map->dev, reg,
				  val_len / map->format.val_bytes);

	return ret;
584 585 586 587 588 589 590
}

static int _regmap_read(struct regmap *map, unsigned int reg,
			unsigned int *val)
{
	int ret;

591 592 593 594 595 596
	if (!map->cache_bypass) {
		ret = regcache_read(map, reg, val);
		if (ret == 0)
			return 0;
	}

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

600 601 602
	if (map->cache_only)
		return -EBUSY;

603
	ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
M
Mark Brown 已提交
604
	if (ret == 0) {
605
		*val = map->format.parse_val(map->work_buf);
M
Mark Brown 已提交
606 607
		trace_regmap_reg_read(map->dev, reg, *val);
	}
608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649

	return ret;
}

/**
 * regmap_read(): Read a value from a single register
 *
 * @map: Register map to write to
 * @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;

	mutex_lock(&map->lock);

	ret = _regmap_read(map, reg, val);

	mutex_unlock(&map->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_read);

/**
 * regmap_raw_read(): Read raw data from the device
 *
 * @map: Register map to write to
 * @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)
{
650 651 652 653
	size_t val_bytes = map->format.val_bytes;
	size_t val_count = val_len / val_bytes;
	unsigned int v;
	int ret, i;
654

655 656
	mutex_lock(&map->lock);

657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673
	if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
	    map->cache_type == REGCACHE_NONE) {
		/* 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++) {
			ret = _regmap_read(map, reg + i, &v);
			if (ret != 0)
				goto out;

			map->format.format_val(val + (i * val_bytes), v);
		}
	}
674

675
 out:
676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
	mutex_unlock(&map->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_raw_read);

/**
 * regmap_bulk_read(): Read multiple registers from the device
 *
 * @map: Register map to write to
 * @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;
698
	bool vol = regmap_volatile_range(map, reg, val_count);
699

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

703 704 705 706 707 708 709 710 711 712 713 714 715 716
	if (vol || map->cache_type == REGCACHE_NONE) {
		ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
		if (ret != 0)
			return ret;

		for (i = 0; i < val_count * val_bytes; i += val_bytes)
			map->format.parse_val(val + i);
	} else {
		for (i = 0; i < val_count; i++) {
			ret = regmap_read(map, reg + i, val + (i * val_bytes));
			if (ret != 0)
				return ret;
		}
	}
717 718 719 720 721

	return 0;
}
EXPORT_SYMBOL_GPL(regmap_bulk_read);

722 723 724
static int _regmap_update_bits(struct regmap *map, unsigned int reg,
			       unsigned int mask, unsigned int val,
			       bool *change)
725 726
{
	int ret;
727
	unsigned int tmp, orig;
728 729 730

	mutex_lock(&map->lock);

731
	ret = _regmap_read(map, reg, &orig);
732 733 734
	if (ret != 0)
		goto out;

735
	tmp = orig & ~mask;
736 737
	tmp |= val & mask;

738
	if (tmp != orig) {
739
		ret = _regmap_write(map, reg, tmp);
740 741 742 743
		*change = true;
	} else {
		*change = false;
	}
744 745 746 747 748 749

out:
	mutex_unlock(&map->lock);

	return ret;
}
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766

/**
 * regmap_update_bits: Perform a read/modify/write cycle on the register map
 *
 * @map: Register map to update
 * @reg: Register to update
 * @mask: Bitmask to change
 * @val: New value for bitmask
 *
 * Returns zero for success, a negative number on error.
 */
int regmap_update_bits(struct regmap *map, unsigned int reg,
		       unsigned int mask, unsigned int val)
{
	bool change;
	return _regmap_update_bits(map, reg, mask, val, &change);
}
767
EXPORT_SYMBOL_GPL(regmap_update_bits);
768

769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
/**
 * regmap_update_bits_check: Perform a read/modify/write cycle on the
 *                           register map and report if updated
 *
 * @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
 *
 * Returns zero for success, a negative number on error.
 */
int regmap_update_bits_check(struct regmap *map, unsigned int reg,
			     unsigned int mask, unsigned int val,
			     bool *change)
{
	return _regmap_update_bits(map, reg, mask, val, change);
}
EXPORT_SYMBOL_GPL(regmap_update_bits_check);

M
Mark Brown 已提交
789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
/**
 * regmap_register_patch: Register and apply register updates to be applied
 *                        on device initialistion
 *
 * @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.
 */
int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
			  int num_regs)
{
	int i, ret;
	bool bypass;

	/* If needed the implementation can be extended to support this */
	if (map->patch)
		return -EBUSY;

	mutex_lock(&map->lock);

	bypass = map->cache_bypass;

	map->cache_bypass = true;

	/* Write out first; it's useful to apply even if we fail later. */
	for (i = 0; i < num_regs; i++) {
		ret = _regmap_write(map, regs[i].reg, regs[i].def);
		if (ret != 0) {
			dev_err(map->dev, "Failed to write %x = %x: %d\n",
				regs[i].reg, regs[i].def, ret);
			goto out;
		}
	}

829
	map->patch = kcalloc(num_regs, sizeof(struct reg_default), GFP_KERNEL);
M
Mark Brown 已提交
830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
	if (map->patch != NULL) {
		memcpy(map->patch, regs,
		       num_regs * sizeof(struct reg_default));
		map->patch_regs = num_regs;
	} else {
		ret = -ENOMEM;
	}

out:
	map->cache_bypass = bypass;

	mutex_unlock(&map->lock);

	return ret;
}
EXPORT_SYMBOL_GPL(regmap_register_patch);

847 848 849 850 851 852 853
static int __init regmap_initcall(void)
{
	regmap_debugfs_initcall();

	return 0;
}
postcore_initcall(regmap_initcall);