regmap.c revision 752a6a5f84bfed18d0709383913d9d9d21b61c77
1/* 2 * Register map access API 3 * 4 * Copyright 2011 Wolfson Microelectronics plc 5 * 6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 */ 12 13#include <linux/device.h> 14#include <linux/slab.h> 15#include <linux/export.h> 16#include <linux/mutex.h> 17#include <linux/err.h> 18 19#define CREATE_TRACE_POINTS 20#include <trace/events/regmap.h> 21 22#include "internal.h" 23 24bool regmap_writeable(struct regmap *map, unsigned int reg) 25{ 26 if (map->max_register && reg > map->max_register) 27 return false; 28 29 if (map->writeable_reg) 30 return map->writeable_reg(map->dev, reg); 31 32 return true; 33} 34 35bool regmap_readable(struct regmap *map, unsigned int reg) 36{ 37 if (map->max_register && reg > map->max_register) 38 return false; 39 40 if (map->format.format_write) 41 return false; 42 43 if (map->readable_reg) 44 return map->readable_reg(map->dev, reg); 45 46 return true; 47} 48 49bool regmap_volatile(struct regmap *map, unsigned int reg) 50{ 51 if (!regmap_readable(map, reg)) 52 return false; 53 54 if (map->volatile_reg) 55 return map->volatile_reg(map->dev, reg); 56 57 return true; 58} 59 60bool regmap_precious(struct regmap *map, unsigned int reg) 61{ 62 if (!regmap_readable(map, reg)) 63 return false; 64 65 if (map->precious_reg) 66 return map->precious_reg(map->dev, reg); 67 68 return false; 69} 70 71static bool regmap_volatile_range(struct regmap *map, unsigned int reg, 72 unsigned int num) 73{ 74 unsigned int i; 75 76 for (i = 0; i < num; i++) 77 if (!regmap_volatile(map, reg + i)) 78 return false; 79 80 return true; 81} 82 83static void regmap_format_2_6_write(struct regmap *map, 84 unsigned int reg, unsigned int val) 85{ 86 u8 *out = map->work_buf; 87 88 *out = (reg << 6) | val; 89} 90 91static void regmap_format_4_12_write(struct regmap *map, 92 unsigned int reg, unsigned int val) 93{ 94 __be16 *out = map->work_buf; 95 *out = cpu_to_be16((reg << 12) | val); 96} 97 98static void regmap_format_7_9_write(struct regmap *map, 99 unsigned int reg, unsigned int val) 100{ 101 __be16 *out = map->work_buf; 102 *out = cpu_to_be16((reg << 9) | val); 103} 104 105static void regmap_format_10_14_write(struct regmap *map, 106 unsigned int reg, unsigned int val) 107{ 108 u8 *out = map->work_buf; 109 110 out[2] = val; 111 out[1] = (val >> 8) | (reg << 6); 112 out[0] = reg >> 2; 113} 114 115static void regmap_format_8(void *buf, unsigned int val, unsigned int shift) 116{ 117 u8 *b = buf; 118 119 b[0] = val << shift; 120} 121 122static void regmap_format_16(void *buf, unsigned int val, unsigned int shift) 123{ 124 __be16 *b = buf; 125 126 b[0] = cpu_to_be16(val << shift); 127} 128 129static void regmap_format_24(void *buf, unsigned int val, unsigned int shift) 130{ 131 u8 *b = buf; 132 133 val <<= shift; 134 135 b[0] = val >> 16; 136 b[1] = val >> 8; 137 b[2] = val; 138} 139 140static void regmap_format_32(void *buf, unsigned int val, unsigned int shift) 141{ 142 __be32 *b = buf; 143 144 b[0] = cpu_to_be32(val << shift); 145} 146 147static unsigned int regmap_parse_8(void *buf) 148{ 149 u8 *b = buf; 150 151 return b[0]; 152} 153 154static unsigned int regmap_parse_16(void *buf) 155{ 156 __be16 *b = buf; 157 158 b[0] = be16_to_cpu(b[0]); 159 160 return b[0]; 161} 162 163static unsigned int regmap_parse_24(void *buf) 164{ 165 u8 *b = buf; 166 unsigned int ret = b[2]; 167 ret |= ((unsigned int)b[1]) << 8; 168 ret |= ((unsigned int)b[0]) << 16; 169 170 return ret; 171} 172 173static unsigned int regmap_parse_32(void *buf) 174{ 175 __be32 *b = buf; 176 177 b[0] = be32_to_cpu(b[0]); 178 179 return b[0]; 180} 181 182static void regmap_lock_mutex(struct regmap *map) 183{ 184 mutex_lock(&map->mutex); 185} 186 187static void regmap_unlock_mutex(struct regmap *map) 188{ 189 mutex_unlock(&map->mutex); 190} 191 192static void regmap_lock_spinlock(struct regmap *map) 193{ 194 spin_lock(&map->spinlock); 195} 196 197static void regmap_unlock_spinlock(struct regmap *map) 198{ 199 spin_unlock(&map->spinlock); 200} 201 202static void dev_get_regmap_release(struct device *dev, void *res) 203{ 204 /* 205 * We don't actually have anything to do here; the goal here 206 * is not to manage the regmap but to provide a simple way to 207 * get the regmap back given a struct device. 208 */ 209} 210 211/** 212 * regmap_init(): Initialise register map 213 * 214 * @dev: Device that will be interacted with 215 * @bus: Bus-specific callbacks to use with device 216 * @bus_context: Data passed to bus-specific callbacks 217 * @config: Configuration for register map 218 * 219 * The return value will be an ERR_PTR() on error or a valid pointer to 220 * a struct regmap. This function should generally not be called 221 * directly, it should be called by bus-specific init functions. 222 */ 223struct regmap *regmap_init(struct device *dev, 224 const struct regmap_bus *bus, 225 void *bus_context, 226 const struct regmap_config *config) 227{ 228 struct regmap *map, **m; 229 int ret = -EINVAL; 230 231 if (!bus || !config) 232 goto err; 233 234 map = kzalloc(sizeof(*map), GFP_KERNEL); 235 if (map == NULL) { 236 ret = -ENOMEM; 237 goto err; 238 } 239 240 if (bus->fast_io) { 241 spin_lock_init(&map->spinlock); 242 map->lock = regmap_lock_spinlock; 243 map->unlock = regmap_unlock_spinlock; 244 } else { 245 mutex_init(&map->mutex); 246 map->lock = regmap_lock_mutex; 247 map->unlock = regmap_unlock_mutex; 248 } 249 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8); 250 map->format.pad_bytes = config->pad_bits / 8; 251 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8); 252 map->format.buf_size = DIV_ROUND_UP(config->reg_bits + 253 config->val_bits + config->pad_bits, 8); 254 map->reg_shift = config->pad_bits % 8; 255 if (config->reg_stride) 256 map->reg_stride = config->reg_stride; 257 else 258 map->reg_stride = 1; 259 map->use_single_rw = config->use_single_rw; 260 map->dev = dev; 261 map->bus = bus; 262 map->bus_context = bus_context; 263 map->max_register = config->max_register; 264 map->writeable_reg = config->writeable_reg; 265 map->readable_reg = config->readable_reg; 266 map->volatile_reg = config->volatile_reg; 267 map->precious_reg = config->precious_reg; 268 map->cache_type = config->cache_type; 269 map->name = config->name; 270 271 if (config->read_flag_mask || config->write_flag_mask) { 272 map->read_flag_mask = config->read_flag_mask; 273 map->write_flag_mask = config->write_flag_mask; 274 } else { 275 map->read_flag_mask = bus->read_flag_mask; 276 } 277 278 switch (config->reg_bits + map->reg_shift) { 279 case 2: 280 switch (config->val_bits) { 281 case 6: 282 map->format.format_write = regmap_format_2_6_write; 283 break; 284 default: 285 goto err_map; 286 } 287 break; 288 289 case 4: 290 switch (config->val_bits) { 291 case 12: 292 map->format.format_write = regmap_format_4_12_write; 293 break; 294 default: 295 goto err_map; 296 } 297 break; 298 299 case 7: 300 switch (config->val_bits) { 301 case 9: 302 map->format.format_write = regmap_format_7_9_write; 303 break; 304 default: 305 goto err_map; 306 } 307 break; 308 309 case 10: 310 switch (config->val_bits) { 311 case 14: 312 map->format.format_write = regmap_format_10_14_write; 313 break; 314 default: 315 goto err_map; 316 } 317 break; 318 319 case 8: 320 map->format.format_reg = regmap_format_8; 321 break; 322 323 case 16: 324 map->format.format_reg = regmap_format_16; 325 break; 326 327 case 32: 328 map->format.format_reg = regmap_format_32; 329 break; 330 331 default: 332 goto err_map; 333 } 334 335 switch (config->val_bits) { 336 case 8: 337 map->format.format_val = regmap_format_8; 338 map->format.parse_val = regmap_parse_8; 339 break; 340 case 16: 341 map->format.format_val = regmap_format_16; 342 map->format.parse_val = regmap_parse_16; 343 break; 344 case 24: 345 map->format.format_val = regmap_format_24; 346 map->format.parse_val = regmap_parse_24; 347 break; 348 case 32: 349 map->format.format_val = regmap_format_32; 350 map->format.parse_val = regmap_parse_32; 351 break; 352 } 353 354 if (map->format.format_write) 355 map->use_single_rw = true; 356 357 if (!map->format.format_write && 358 !(map->format.format_reg && map->format.format_val)) 359 goto err_map; 360 361 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL); 362 if (map->work_buf == NULL) { 363 ret = -ENOMEM; 364 goto err_map; 365 } 366 367 regmap_debugfs_init(map, config->name); 368 369 ret = regcache_init(map, config); 370 if (ret < 0) 371 goto err_debugfs; 372 373 /* Add a devres resource for dev_get_regmap() */ 374 m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL); 375 if (!m) { 376 ret = -ENOMEM; 377 goto err_cache; 378 } 379 *m = map; 380 devres_add(dev, m); 381 382 return map; 383 384err_cache: 385 regcache_exit(map); 386err_debugfs: 387 regmap_debugfs_exit(map); 388 kfree(map->work_buf); 389err_map: 390 kfree(map); 391err: 392 return ERR_PTR(ret); 393} 394EXPORT_SYMBOL_GPL(regmap_init); 395 396static void devm_regmap_release(struct device *dev, void *res) 397{ 398 regmap_exit(*(struct regmap **)res); 399} 400 401/** 402 * devm_regmap_init(): Initialise managed register map 403 * 404 * @dev: Device that will be interacted with 405 * @bus: Bus-specific callbacks to use with device 406 * @bus_context: Data passed to bus-specific callbacks 407 * @config: Configuration for register map 408 * 409 * The return value will be an ERR_PTR() on error or a valid pointer 410 * to a struct regmap. This function should generally not be called 411 * directly, it should be called by bus-specific init functions. The 412 * map will be automatically freed by the device management code. 413 */ 414struct regmap *devm_regmap_init(struct device *dev, 415 const struct regmap_bus *bus, 416 void *bus_context, 417 const struct regmap_config *config) 418{ 419 struct regmap **ptr, *regmap; 420 421 ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL); 422 if (!ptr) 423 return ERR_PTR(-ENOMEM); 424 425 regmap = regmap_init(dev, bus, bus_context, config); 426 if (!IS_ERR(regmap)) { 427 *ptr = regmap; 428 devres_add(dev, ptr); 429 } else { 430 devres_free(ptr); 431 } 432 433 return regmap; 434} 435EXPORT_SYMBOL_GPL(devm_regmap_init); 436 437/** 438 * regmap_reinit_cache(): Reinitialise the current register cache 439 * 440 * @map: Register map to operate on. 441 * @config: New configuration. Only the cache data will be used. 442 * 443 * Discard any existing register cache for the map and initialize a 444 * new cache. This can be used to restore the cache to defaults or to 445 * update the cache configuration to reflect runtime discovery of the 446 * hardware. 447 */ 448int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config) 449{ 450 int ret; 451 452 map->lock(map); 453 454 regcache_exit(map); 455 regmap_debugfs_exit(map); 456 457 map->max_register = config->max_register; 458 map->writeable_reg = config->writeable_reg; 459 map->readable_reg = config->readable_reg; 460 map->volatile_reg = config->volatile_reg; 461 map->precious_reg = config->precious_reg; 462 map->cache_type = config->cache_type; 463 464 regmap_debugfs_init(map, config->name); 465 466 map->cache_bypass = false; 467 map->cache_only = false; 468 469 ret = regcache_init(map, config); 470 471 map->unlock(map); 472 473 return ret; 474} 475EXPORT_SYMBOL_GPL(regmap_reinit_cache); 476 477/** 478 * regmap_exit(): Free a previously allocated register map 479 */ 480void regmap_exit(struct regmap *map) 481{ 482 regcache_exit(map); 483 regmap_debugfs_exit(map); 484 if (map->bus->free_context) 485 map->bus->free_context(map->bus_context); 486 kfree(map->work_buf); 487 kfree(map); 488} 489EXPORT_SYMBOL_GPL(regmap_exit); 490 491static int dev_get_regmap_match(struct device *dev, void *res, void *data) 492{ 493 struct regmap **r = res; 494 if (!r || !*r) { 495 WARN_ON(!r || !*r); 496 return 0; 497 } 498 499 /* If the user didn't specify a name match any */ 500 if (data) 501 return (*r)->name == data; 502 else 503 return 1; 504} 505 506/** 507 * dev_get_regmap(): Obtain the regmap (if any) for a device 508 * 509 * @dev: Device to retrieve the map for 510 * @name: Optional name for the register map, usually NULL. 511 * 512 * Returns the regmap for the device if one is present, or NULL. If 513 * name is specified then it must match the name specified when 514 * registering the device, if it is NULL then the first regmap found 515 * will be used. Devices with multiple register maps are very rare, 516 * generic code should normally not need to specify a name. 517 */ 518struct regmap *dev_get_regmap(struct device *dev, const char *name) 519{ 520 struct regmap **r = devres_find(dev, dev_get_regmap_release, 521 dev_get_regmap_match, (void *)name); 522 523 if (!r) 524 return NULL; 525 return *r; 526} 527EXPORT_SYMBOL_GPL(dev_get_regmap); 528 529static int _regmap_raw_write(struct regmap *map, unsigned int reg, 530 const void *val, size_t val_len) 531{ 532 u8 *u8 = map->work_buf; 533 void *buf; 534 int ret = -ENOTSUPP; 535 size_t len; 536 int i; 537 538 /* Check for unwritable registers before we start */ 539 if (map->writeable_reg) 540 for (i = 0; i < val_len / map->format.val_bytes; i++) 541 if (!map->writeable_reg(map->dev, 542 reg + (i * map->reg_stride))) 543 return -EINVAL; 544 545 if (!map->cache_bypass && map->format.parse_val) { 546 unsigned int ival; 547 int val_bytes = map->format.val_bytes; 548 for (i = 0; i < val_len / val_bytes; i++) { 549 memcpy(map->work_buf, val + (i * val_bytes), val_bytes); 550 ival = map->format.parse_val(map->work_buf); 551 ret = regcache_write(map, reg + (i * map->reg_stride), 552 ival); 553 if (ret) { 554 dev_err(map->dev, 555 "Error in caching of register: %u ret: %d\n", 556 reg + i, ret); 557 return ret; 558 } 559 } 560 if (map->cache_only) { 561 map->cache_dirty = true; 562 return 0; 563 } 564 } 565 566 map->format.format_reg(map->work_buf, reg, map->reg_shift); 567 568 u8[0] |= map->write_flag_mask; 569 570 trace_regmap_hw_write_start(map->dev, reg, 571 val_len / map->format.val_bytes); 572 573 /* If we're doing a single register write we can probably just 574 * send the work_buf directly, otherwise try to do a gather 575 * write. 576 */ 577 if (val == (map->work_buf + map->format.pad_bytes + 578 map->format.reg_bytes)) 579 ret = map->bus->write(map->bus_context, map->work_buf, 580 map->format.reg_bytes + 581 map->format.pad_bytes + 582 val_len); 583 else if (map->bus->gather_write) 584 ret = map->bus->gather_write(map->bus_context, map->work_buf, 585 map->format.reg_bytes + 586 map->format.pad_bytes, 587 val, val_len); 588 589 /* If that didn't work fall back on linearising by hand. */ 590 if (ret == -ENOTSUPP) { 591 len = map->format.reg_bytes + map->format.pad_bytes + val_len; 592 buf = kzalloc(len, GFP_KERNEL); 593 if (!buf) 594 return -ENOMEM; 595 596 memcpy(buf, map->work_buf, map->format.reg_bytes); 597 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes, 598 val, val_len); 599 ret = map->bus->write(map->bus_context, buf, len); 600 601 kfree(buf); 602 } 603 604 trace_regmap_hw_write_done(map->dev, reg, 605 val_len / map->format.val_bytes); 606 607 return ret; 608} 609 610int _regmap_write(struct regmap *map, unsigned int reg, 611 unsigned int val) 612{ 613 int ret; 614 BUG_ON(!map->format.format_write && !map->format.format_val); 615 616 if (!map->cache_bypass && map->format.format_write) { 617 ret = regcache_write(map, reg, val); 618 if (ret != 0) 619 return ret; 620 if (map->cache_only) { 621 map->cache_dirty = true; 622 return 0; 623 } 624 } 625 626 trace_regmap_reg_write(map->dev, reg, val); 627 628 if (map->format.format_write) { 629 map->format.format_write(map, reg, val); 630 631 trace_regmap_hw_write_start(map->dev, reg, 1); 632 633 ret = map->bus->write(map->bus_context, map->work_buf, 634 map->format.buf_size); 635 636 trace_regmap_hw_write_done(map->dev, reg, 1); 637 638 return ret; 639 } else { 640 map->format.format_val(map->work_buf + map->format.reg_bytes 641 + map->format.pad_bytes, val, 0); 642 return _regmap_raw_write(map, reg, 643 map->work_buf + 644 map->format.reg_bytes + 645 map->format.pad_bytes, 646 map->format.val_bytes); 647 } 648} 649 650/** 651 * regmap_write(): Write a value to a single register 652 * 653 * @map: Register map to write to 654 * @reg: Register to write to 655 * @val: Value to be written 656 * 657 * A value of zero will be returned on success, a negative errno will 658 * be returned in error cases. 659 */ 660int regmap_write(struct regmap *map, unsigned int reg, unsigned int val) 661{ 662 int ret; 663 664 if (reg % map->reg_stride) 665 return -EINVAL; 666 667 map->lock(map); 668 669 ret = _regmap_write(map, reg, val); 670 671 map->unlock(map); 672 673 return ret; 674} 675EXPORT_SYMBOL_GPL(regmap_write); 676 677/** 678 * regmap_raw_write(): Write raw values to one or more registers 679 * 680 * @map: Register map to write to 681 * @reg: Initial register to write to 682 * @val: Block of data to be written, laid out for direct transmission to the 683 * device 684 * @val_len: Length of data pointed to by val. 685 * 686 * This function is intended to be used for things like firmware 687 * download where a large block of data needs to be transferred to the 688 * device. No formatting will be done on the data provided. 689 * 690 * A value of zero will be returned on success, a negative errno will 691 * be returned in error cases. 692 */ 693int regmap_raw_write(struct regmap *map, unsigned int reg, 694 const void *val, size_t val_len) 695{ 696 int ret; 697 698 if (val_len % map->format.val_bytes) 699 return -EINVAL; 700 if (reg % map->reg_stride) 701 return -EINVAL; 702 703 map->lock(map); 704 705 ret = _regmap_raw_write(map, reg, val, val_len); 706 707 map->unlock(map); 708 709 return ret; 710} 711EXPORT_SYMBOL_GPL(regmap_raw_write); 712 713/* 714 * regmap_bulk_write(): Write multiple registers to the device 715 * 716 * @map: Register map to write to 717 * @reg: First register to be write from 718 * @val: Block of data to be written, in native register size for device 719 * @val_count: Number of registers to write 720 * 721 * This function is intended to be used for writing a large block of 722 * data to be device either in single transfer or multiple transfer. 723 * 724 * A value of zero will be returned on success, a negative errno will 725 * be returned in error cases. 726 */ 727int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val, 728 size_t val_count) 729{ 730 int ret = 0, i; 731 size_t val_bytes = map->format.val_bytes; 732 void *wval; 733 734 if (!map->format.parse_val) 735 return -EINVAL; 736 if (reg % map->reg_stride) 737 return -EINVAL; 738 739 map->lock(map); 740 741 /* No formatting is require if val_byte is 1 */ 742 if (val_bytes == 1) { 743 wval = (void *)val; 744 } else { 745 wval = kmemdup(val, val_count * val_bytes, GFP_KERNEL); 746 if (!wval) { 747 ret = -ENOMEM; 748 dev_err(map->dev, "Error in memory allocation\n"); 749 goto out; 750 } 751 for (i = 0; i < val_count * val_bytes; i += val_bytes) 752 map->format.parse_val(wval + i); 753 } 754 /* 755 * Some devices does not support bulk write, for 756 * them we have a series of single write operations. 757 */ 758 if (map->use_single_rw) { 759 for (i = 0; i < val_count; i++) { 760 ret = regmap_raw_write(map, 761 reg + (i * map->reg_stride), 762 val + (i * val_bytes), 763 val_bytes); 764 if (ret != 0) 765 return ret; 766 } 767 } else { 768 ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count); 769 } 770 771 if (val_bytes != 1) 772 kfree(wval); 773 774out: 775 map->unlock(map); 776 return ret; 777} 778EXPORT_SYMBOL_GPL(regmap_bulk_write); 779 780static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val, 781 unsigned int val_len) 782{ 783 u8 *u8 = map->work_buf; 784 int ret; 785 786 map->format.format_reg(map->work_buf, reg, map->reg_shift); 787 788 /* 789 * Some buses or devices flag reads by setting the high bits in the 790 * register addresss; since it's always the high bits for all 791 * current formats we can do this here rather than in 792 * formatting. This may break if we get interesting formats. 793 */ 794 u8[0] |= map->read_flag_mask; 795 796 trace_regmap_hw_read_start(map->dev, reg, 797 val_len / map->format.val_bytes); 798 799 ret = map->bus->read(map->bus_context, map->work_buf, 800 map->format.reg_bytes + map->format.pad_bytes, 801 val, val_len); 802 803 trace_regmap_hw_read_done(map->dev, reg, 804 val_len / map->format.val_bytes); 805 806 return ret; 807} 808 809static int _regmap_read(struct regmap *map, unsigned int reg, 810 unsigned int *val) 811{ 812 int ret; 813 814 if (!map->cache_bypass) { 815 ret = regcache_read(map, reg, val); 816 if (ret == 0) 817 return 0; 818 } 819 820 if (!map->format.parse_val) 821 return -EINVAL; 822 823 if (map->cache_only) 824 return -EBUSY; 825 826 ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes); 827 if (ret == 0) { 828 *val = map->format.parse_val(map->work_buf); 829 trace_regmap_reg_read(map->dev, reg, *val); 830 } 831 832 if (ret == 0 && !map->cache_bypass) 833 regcache_write(map, reg, *val); 834 835 return ret; 836} 837 838/** 839 * regmap_read(): Read a value from a single register 840 * 841 * @map: Register map to write to 842 * @reg: Register to be read from 843 * @val: Pointer to store read value 844 * 845 * A value of zero will be returned on success, a negative errno will 846 * be returned in error cases. 847 */ 848int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val) 849{ 850 int ret; 851 852 if (reg % map->reg_stride) 853 return -EINVAL; 854 855 map->lock(map); 856 857 ret = _regmap_read(map, reg, val); 858 859 map->unlock(map); 860 861 return ret; 862} 863EXPORT_SYMBOL_GPL(regmap_read); 864 865/** 866 * regmap_raw_read(): Read raw data from the device 867 * 868 * @map: Register map to write to 869 * @reg: First register to be read from 870 * @val: Pointer to store read value 871 * @val_len: Size of data to read 872 * 873 * A value of zero will be returned on success, a negative errno will 874 * be returned in error cases. 875 */ 876int regmap_raw_read(struct regmap *map, unsigned int reg, void *val, 877 size_t val_len) 878{ 879 size_t val_bytes = map->format.val_bytes; 880 size_t val_count = val_len / val_bytes; 881 unsigned int v; 882 int ret, i; 883 884 if (val_len % map->format.val_bytes) 885 return -EINVAL; 886 if (reg % map->reg_stride) 887 return -EINVAL; 888 889 map->lock(map); 890 891 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass || 892 map->cache_type == REGCACHE_NONE) { 893 /* Physical block read if there's no cache involved */ 894 ret = _regmap_raw_read(map, reg, val, val_len); 895 896 } else { 897 /* Otherwise go word by word for the cache; should be low 898 * cost as we expect to hit the cache. 899 */ 900 for (i = 0; i < val_count; i++) { 901 ret = _regmap_read(map, reg + (i * map->reg_stride), 902 &v); 903 if (ret != 0) 904 goto out; 905 906 map->format.format_val(val + (i * val_bytes), v, 0); 907 } 908 } 909 910 out: 911 map->unlock(map); 912 913 return ret; 914} 915EXPORT_SYMBOL_GPL(regmap_raw_read); 916 917/** 918 * regmap_bulk_read(): Read multiple registers from the device 919 * 920 * @map: Register map to write to 921 * @reg: First register to be read from 922 * @val: Pointer to store read value, in native register size for device 923 * @val_count: Number of registers to read 924 * 925 * A value of zero will be returned on success, a negative errno will 926 * be returned in error cases. 927 */ 928int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val, 929 size_t val_count) 930{ 931 int ret, i; 932 size_t val_bytes = map->format.val_bytes; 933 bool vol = regmap_volatile_range(map, reg, val_count); 934 935 if (!map->format.parse_val) 936 return -EINVAL; 937 if (reg % map->reg_stride) 938 return -EINVAL; 939 940 if (vol || map->cache_type == REGCACHE_NONE) { 941 /* 942 * Some devices does not support bulk read, for 943 * them we have a series of single read operations. 944 */ 945 if (map->use_single_rw) { 946 for (i = 0; i < val_count; i++) { 947 ret = regmap_raw_read(map, 948 reg + (i * map->reg_stride), 949 val + (i * val_bytes), 950 val_bytes); 951 if (ret != 0) 952 return ret; 953 } 954 } else { 955 ret = regmap_raw_read(map, reg, val, 956 val_bytes * val_count); 957 if (ret != 0) 958 return ret; 959 } 960 961 for (i = 0; i < val_count * val_bytes; i += val_bytes) 962 map->format.parse_val(val + i); 963 } else { 964 for (i = 0; i < val_count; i++) { 965 unsigned int ival; 966 ret = regmap_read(map, reg + (i * map->reg_stride), 967 &ival); 968 if (ret != 0) 969 return ret; 970 memcpy(val + (i * val_bytes), &ival, val_bytes); 971 } 972 } 973 974 return 0; 975} 976EXPORT_SYMBOL_GPL(regmap_bulk_read); 977 978static int _regmap_update_bits(struct regmap *map, unsigned int reg, 979 unsigned int mask, unsigned int val, 980 bool *change) 981{ 982 int ret; 983 unsigned int tmp, orig; 984 985 map->lock(map); 986 987 ret = _regmap_read(map, reg, &orig); 988 if (ret != 0) 989 goto out; 990 991 tmp = orig & ~mask; 992 tmp |= val & mask; 993 994 if (tmp != orig) { 995 ret = _regmap_write(map, reg, tmp); 996 *change = true; 997 } else { 998 *change = false; 999 } 1000 1001out: 1002 map->unlock(map); 1003 1004 return ret; 1005} 1006 1007/** 1008 * regmap_update_bits: Perform a read/modify/write cycle on the register map 1009 * 1010 * @map: Register map to update 1011 * @reg: Register to update 1012 * @mask: Bitmask to change 1013 * @val: New value for bitmask 1014 * 1015 * Returns zero for success, a negative number on error. 1016 */ 1017int regmap_update_bits(struct regmap *map, unsigned int reg, 1018 unsigned int mask, unsigned int val) 1019{ 1020 bool change; 1021 return _regmap_update_bits(map, reg, mask, val, &change); 1022} 1023EXPORT_SYMBOL_GPL(regmap_update_bits); 1024 1025/** 1026 * regmap_update_bits_check: Perform a read/modify/write cycle on the 1027 * register map and report if updated 1028 * 1029 * @map: Register map to update 1030 * @reg: Register to update 1031 * @mask: Bitmask to change 1032 * @val: New value for bitmask 1033 * @change: Boolean indicating if a write was done 1034 * 1035 * Returns zero for success, a negative number on error. 1036 */ 1037int regmap_update_bits_check(struct regmap *map, unsigned int reg, 1038 unsigned int mask, unsigned int val, 1039 bool *change) 1040{ 1041 return _regmap_update_bits(map, reg, mask, val, change); 1042} 1043EXPORT_SYMBOL_GPL(regmap_update_bits_check); 1044 1045/** 1046 * regmap_register_patch: Register and apply register updates to be applied 1047 * on device initialistion 1048 * 1049 * @map: Register map to apply updates to. 1050 * @regs: Values to update. 1051 * @num_regs: Number of entries in regs. 1052 * 1053 * Register a set of register updates to be applied to the device 1054 * whenever the device registers are synchronised with the cache and 1055 * apply them immediately. Typically this is used to apply 1056 * corrections to be applied to the device defaults on startup, such 1057 * as the updates some vendors provide to undocumented registers. 1058 */ 1059int regmap_register_patch(struct regmap *map, const struct reg_default *regs, 1060 int num_regs) 1061{ 1062 int i, ret; 1063 bool bypass; 1064 1065 /* If needed the implementation can be extended to support this */ 1066 if (map->patch) 1067 return -EBUSY; 1068 1069 map->lock(map); 1070 1071 bypass = map->cache_bypass; 1072 1073 map->cache_bypass = true; 1074 1075 /* Write out first; it's useful to apply even if we fail later. */ 1076 for (i = 0; i < num_regs; i++) { 1077 ret = _regmap_write(map, regs[i].reg, regs[i].def); 1078 if (ret != 0) { 1079 dev_err(map->dev, "Failed to write %x = %x: %d\n", 1080 regs[i].reg, regs[i].def, ret); 1081 goto out; 1082 } 1083 } 1084 1085 map->patch = kcalloc(num_regs, sizeof(struct reg_default), GFP_KERNEL); 1086 if (map->patch != NULL) { 1087 memcpy(map->patch, regs, 1088 num_regs * sizeof(struct reg_default)); 1089 map->patch_regs = num_regs; 1090 } else { 1091 ret = -ENOMEM; 1092 } 1093 1094out: 1095 map->cache_bypass = bypass; 1096 1097 map->unlock(map); 1098 1099 return ret; 1100} 1101EXPORT_SYMBOL_GPL(regmap_register_patch); 1102 1103/* 1104 * regmap_get_val_bytes(): Report the size of a register value 1105 * 1106 * Report the size of a register value, mainly intended to for use by 1107 * generic infrastructure built on top of regmap. 1108 */ 1109int regmap_get_val_bytes(struct regmap *map) 1110{ 1111 if (map->format.format_write) 1112 return -EINVAL; 1113 1114 return map->format.val_bytes; 1115} 1116EXPORT_SYMBOL_GPL(regmap_get_val_bytes); 1117 1118static int __init regmap_initcall(void) 1119{ 1120 regmap_debugfs_initcall(); 1121 1122 return 0; 1123} 1124postcore_initcall(regmap_initcall); 1125