drivers/base/regmap/regmap.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // Register map access API
   4 //
   5 // Copyright 2011 Wolfson Microelectronics plc
   6 //
   7 // Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   8
   9 #include <linux/device.h>
  10 #include <linux/slab.h>
  11 #include <linux/export.h>
  12 #include <linux/mutex.h>
  13 #include <linux/err.h>
  14 #include <linux/property.h>
  15 #include <linux/rbtree.h>
  16 #include <linux/sched.h>
  17 #include <linux/delay.h>
  18 #include <linux/log2.h>
  19 #include <linux/hwspinlock.h>
  20 #include <asm/unaligned.h>
  21
  22 #define CREATE_TRACE_POINTS
  23 #include "trace.h"
  24
  25 #include "internal.h"
  26
  27 /*
  28  * Sometimes for failures during very early init the trace
  29  * infrastructure isn't available early enough to be used.  For this
  30  * sort of problem defining LOG_DEVICE will add printks for basic
  31  * register I/O on a specific device.
  32  */
  33 #undef LOG_DEVICE
  34
  35 #ifdef LOG_DEVICE
  36 static inline bool regmap_should_log(struct regmap *map)
  37 {
  38         return (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0);
  39 }
  40 #else
  41 static inline bool regmap_should_log(struct regmap *map) { return false; }
  42 #endif
  43
  44
  45 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
  46                                unsigned int mask, unsigned int val,
  47                                bool *change, bool force_write);
  48
  49 static int _regmap_bus_reg_read(void *context, unsigned int reg,
  50                                 unsigned int *val);
  51 static int _regmap_bus_read(void *context, unsigned int reg,
  52                             unsigned int *val);
  53 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
  54                                        unsigned int val);
  55 static int _regmap_bus_reg_write(void *context, unsigned int reg,
  56                                  unsigned int val);
  57 static int _regmap_bus_raw_write(void *context, unsigned int reg,
  58                                  unsigned int val);
  59
  60 bool regmap_reg_in_ranges(unsigned int reg,
  61                           const struct regmap_range *ranges,
  62                           unsigned int nranges)
  63 {
  64         const struct regmap_range *r;
  65         int i;
  66
  67         for (i = 0, r = ranges; i < nranges; i++, r++)
  68                 if (regmap_reg_in_range(reg, r))
  69                         return true;
  70         return false;
  71 }
  72 EXPORT_SYMBOL_GPL(regmap_reg_in_ranges);
  73
  74 bool regmap_check_range_table(struct regmap *map, unsigned int reg,
  75                               const struct regmap_access_table *table)
  76 {
  77         /* Check "no ranges" first */
  78         if (regmap_reg_in_ranges(reg, table->no_ranges, table->n_no_ranges))
  79                 return false;
  80
  81         /* In case zero "yes ranges" are supplied, any reg is OK */
  82         if (!table->n_yes_ranges)
  83                 return true;
  84
  85         return regmap_reg_in_ranges(reg, table->yes_ranges,
  86                                     table->n_yes_ranges);
  87 }
  88 EXPORT_SYMBOL_GPL(regmap_check_range_table);
  89
  90 bool regmap_writeable(struct regmap *map, unsigned int reg)
  91 {
  92         if (map->max_register && reg > map->max_register)
  93                 return false;
  94
  95         if (map->writeable_reg)
  96                 return map->writeable_reg(map->dev, reg);
  97
  98         if (map->wr_table)
  99                 return regmap_check_range_table(map, reg, map->wr_table);
 100
 101         return true;
 102 }
 103
 104 bool regmap_cached(struct regmap *map, unsigned int reg)
 105 {
 106         int ret;
 107         unsigned int val;
 108
 109         if (map->cache_type == REGCACHE_NONE)
 110                 return false;
 111
 112         if (!map->cache_ops)
 113                 return false;
 114
 115         if (map->max_register && reg > map->max_register)
 116                 return false;
 117
 118         map->lock(map->lock_arg);
 119         ret = regcache_read(map, reg, &val);
 120         map->unlock(map->lock_arg);
 121         if (ret)
 122                 return false;
 123
 124         return true;
 125 }
 126
 127 bool regmap_readable(struct regmap *map, unsigned int reg)
 128 {
 129         if (!map->reg_read)
 130                 return false;
 131
 132         if (map->max_register && reg > map->max_register)
 133                 return false;
 134
 135         if (map->format.format_write)
 136                 return false;
 137
 138         if (map->readable_reg)
 139                 return map->readable_reg(map->dev, reg);
 140
 141         if (map->rd_table)
 142                 return regmap_check_range_table(map, reg, map->rd_table);
 143
 144         return true;
 145 }
 146
 147 bool regmap_volatile(struct regmap *map, unsigned int reg)
 148 {
 149         if (!map->format.format_write && !regmap_readable(map, reg))
 150                 return false;
 151
 152         if (map->volatile_reg)
 153                 return map->volatile_reg(map->dev, reg);
 154
 155         if (map->volatile_table)
 156                 return regmap_check_range_table(map, reg, map->volatile_table);
 157
 158         if (map->cache_ops)
 159                 return false;
 160         else
 161                 return true;
 162 }
 163
 164 bool regmap_precious(struct regmap *map, unsigned int reg)
 165 {
 166         if (!regmap_readable(map, reg))
 167                 return false;
 168
 169         if (map->precious_reg)
 170                 return map->precious_reg(map->dev, reg);
 171
 172         if (map->precious_table)
 173                 return regmap_check_range_table(map, reg, map->precious_table);
 174
 175         return false;
 176 }
 177
 178 bool regmap_writeable_noinc(struct regmap *map, unsigned int reg)
 179 {
 180         if (map->writeable_noinc_reg)
 181                 return map->writeable_noinc_reg(map->dev, reg);
 182
 183         if (map->wr_noinc_table)
 184                 return regmap_check_range_table(map, reg, map->wr_noinc_table);
 185
 186         return true;
 187 }
 188
 189 bool regmap_readable_noinc(struct regmap *map, unsigned int reg)
 190 {
 191         if (map->readable_noinc_reg)
 192                 return map->readable_noinc_reg(map->dev, reg);
 193
 194         if (map->rd_noinc_table)
 195                 return regmap_check_range_table(map, reg, map->rd_noinc_table);
 196
 197         return true;
 198 }
 199
 200 static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
 201         size_t num)
 202 {
 203         unsigned int i;
 204
 205         for (i = 0; i < num; i++)
 206                 if (!regmap_volatile(map, reg + regmap_get_offset(map, i)))
 207                         return false;
 208
 209         return true;
 210 }
 211
 212 static void regmap_format_12_20_write(struct regmap *map,
 213                                      unsigned int reg, unsigned int val)
 214 {
 215         u8 *out = map->work_buf;
 216
 217         out[0] = reg >> 4;
 218         out[1] = (reg << 4) | (val >> 16);
 219         out[2] = val >> 8;
 220         out[3] = val;
 221 }
 222
 223
 224 static void regmap_format_2_6_write(struct regmap *map,
 225                                      unsigned int reg, unsigned int val)
 226 {
 227         u8 *out = map->work_buf;
 228
 229         *out = (reg << 6) | val;
 230 }
 231
 232 static void regmap_format_4_12_write(struct regmap *map,
 233                                      unsigned int reg, unsigned int val)
 234 {
 235         __be16 *out = map->work_buf;
 236         *out = cpu_to_be16((reg << 12) | val);
 237 }
 238
 239 static void regmap_format_7_9_write(struct regmap *map,
 240                                     unsigned int reg, unsigned int val)
 241 {
 242         __be16 *out = map->work_buf;
 243         *out = cpu_to_be16((reg << 9) | val);
 244 }
 245
 246 static void regmap_format_10_14_write(struct regmap *map,
 247                                     unsigned int reg, unsigned int val)
 248 {
 249         u8 *out = map->work_buf;
 250
 251         out[2] = val;
 252         out[1] = (val >> 8) | (reg << 6);
 253         out[0] = reg >> 2;
 254 }
 255
 256 static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
 257 {
 258         u8 *b = buf;
 259
 260         b[0] = val << shift;
 261 }
 262
 263 static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
 264 {
 265         put_unaligned_be16(val << shift, buf);
 266 }
 267
 268 static void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)
 269 {
 270         put_unaligned_le16(val << shift, buf);
 271 }
 272
 273 static void regmap_format_16_native(void *buf, unsigned int val,
 274                                     unsigned int shift)
 275 {
 276         u16 v = val << shift;
 277
 278         memcpy(buf, &v, sizeof(v));
 279 }
 280
 281 static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
 282 {
 283         u8 *b = buf;
 284
 285         val <<= shift;
 286
 287         b[0] = val >> 16;
 288         b[1] = val >> 8;
 289         b[2] = val;
 290 }
 291
 292 static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
 293 {
 294         put_unaligned_be32(val << shift, buf);
 295 }
 296
 297 static void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)
 298 {
 299         put_unaligned_le32(val << shift, buf);
 300 }
 301
 302 static void regmap_format_32_native(void *buf, unsigned int val,
 303                                     unsigned int shift)
 304 {
 305         u32 v = val << shift;
 306
 307         memcpy(buf, &v, sizeof(v));
 308 }
 309
 310 #ifdef CONFIG_64BIT
 311 static void regmap_format_64_be(void *buf, unsigned int val, unsigned int shift)
 312 {
 313         put_unaligned_be64((u64) val << shift, buf);
 314 }
 315
 316 static void regmap_format_64_le(void *buf, unsigned int val, unsigned int shift)
 317 {
 318         put_unaligned_le64((u64) val << shift, buf);
 319 }
 320
 321 static void regmap_format_64_native(void *buf, unsigned int val,
 322                                     unsigned int shift)
 323 {
 324         u64 v = (u64) val << shift;
 325
 326         memcpy(buf, &v, sizeof(v));
 327 }
 328 #endif
 329
 330 static void regmap_parse_inplace_noop(void *buf)
 331 {
 332 }
 333
 334 static unsigned int regmap_parse_8(const void *buf)
 335 {
 336         const u8 *b = buf;
 337
 338         return b[0];
 339 }
 340
 341 static unsigned int regmap_parse_16_be(const void *buf)
 342 {
 343         return get_unaligned_be16(buf);
 344 }
 345
 346 static unsigned int regmap_parse_16_le(const void *buf)
 347 {
 348         return get_unaligned_le16(buf);
 349 }
 350
 351 static void regmap_parse_16_be_inplace(void *buf)
 352 {
 353         u16 v = get_unaligned_be16(buf);
 354
 355         memcpy(buf, &v, sizeof(v));
 356 }
 357
 358 static void regmap_parse_16_le_inplace(void *buf)
 359 {
 360         u16 v = get_unaligned_le16(buf);
 361
 362         memcpy(buf, &v, sizeof(v));
 363 }
 364
 365 static unsigned int regmap_parse_16_native(const void *buf)
 366 {
 367         u16 v;
 368
 369         memcpy(&v, buf, sizeof(v));
 370         return v;
 371 }
 372
 373 static unsigned int regmap_parse_24(const void *buf)
 374 {
 375         const u8 *b = buf;
 376         unsigned int ret = b[2];
 377         ret |= ((unsigned int)b[1]) << 8;
 378         ret |= ((unsigned int)b[0]) << 16;
 379
 380         return ret;
 381 }
 382
 383 static unsigned int regmap_parse_32_be(const void *buf)
 384 {
 385         return get_unaligned_be32(buf);
 386 }
 387
 388 static unsigned int regmap_parse_32_le(const void *buf)
 389 {
 390         return get_unaligned_le32(buf);
 391 }
 392
 393 static void regmap_parse_32_be_inplace(void *buf)
 394 {
 395         u32 v = get_unaligned_be32(buf);
 396
 397         memcpy(buf, &v, sizeof(v));
 398 }
 399
 400 static void regmap_parse_32_le_inplace(void *buf)
 401 {
 402         u32 v = get_unaligned_le32(buf);
 403
 404         memcpy(buf, &v, sizeof(v));
 405 }
 406
 407 static unsigned int regmap_parse_32_native(const void *buf)
 408 {
 409         u32 v;
 410
 411         memcpy(&v, buf, sizeof(v));
 412         return v;
 413 }
 414
 415 #ifdef CONFIG_64BIT
 416 static unsigned int regmap_parse_64_be(const void *buf)
 417 {
 418         return get_unaligned_be64(buf);
 419 }
 420
 421 static unsigned int regmap_parse_64_le(const void *buf)
 422 {
 423         return get_unaligned_le64(buf);
 424 }
 425
 426 static void regmap_parse_64_be_inplace(void *buf)
 427 {
 428         u64 v =  get_unaligned_be64(buf);
 429
 430         memcpy(buf, &v, sizeof(v));
 431 }
 432
 433 static void regmap_parse_64_le_inplace(void *buf)
 434 {
 435         u64 v = get_unaligned_le64(buf);
 436
 437         memcpy(buf, &v, sizeof(v));
 438 }
 439
 440 static unsigned int regmap_parse_64_native(const void *buf)
 441 {
 442         u64 v;
 443
 444         memcpy(&v, buf, sizeof(v));
 445         return v;
 446 }
 447 #endif
 448
 449 static void regmap_lock_hwlock(void *__map)
 450 {
 451         struct regmap *map = __map;
 452
 453         hwspin_lock_timeout(map->hwlock, UINT_MAX);
 454 }
 455
 456 static void regmap_lock_hwlock_irq(void *__map)
 457 {
 458         struct regmap *map = __map;
 459
 460         hwspin_lock_timeout_irq(map->hwlock, UINT_MAX);
 461 }
 462
 463 static void regmap_lock_hwlock_irqsave(void *__map)
 464 {
 465         struct regmap *map = __map;
 466
 467         hwspin_lock_timeout_irqsave(map->hwlock, UINT_MAX,
 468                                     &map->spinlock_flags);
 469 }
 470
 471 static void regmap_unlock_hwlock(void *__map)
 472 {
 473         struct regmap *map = __map;
 474
 475         hwspin_unlock(map->hwlock);
 476 }
 477
 478 static void regmap_unlock_hwlock_irq(void *__map)
 479 {
 480         struct regmap *map = __map;
 481
 482         hwspin_unlock_irq(map->hwlock);
 483 }
 484
 485 static void regmap_unlock_hwlock_irqrestore(void *__map)
 486 {
 487         struct regmap *map = __map;
 488
 489         hwspin_unlock_irqrestore(map->hwlock, &map->spinlock_flags);
 490 }
 491
 492 static void regmap_lock_unlock_none(void *__map)
 493 {
 494
 495 }
 496
 497 static void regmap_lock_mutex(void *__map)
 498 {
 499         struct regmap *map = __map;
 500         mutex_lock(&map->mutex);
 501 }
 502
 503 static void regmap_unlock_mutex(void *__map)
 504 {
 505         struct regmap *map = __map;
 506         mutex_unlock(&map->mutex);
 507 }
 508
 509 static void regmap_lock_spinlock(void *__map)
 510 __acquires(&map->spinlock)
 511 {
 512         struct regmap *map = __map;
 513         unsigned long flags;
 514
 515         spin_lock_irqsave(&map->spinlock, flags);
 516         map->spinlock_flags = flags;
 517 }
 518
 519 static void regmap_unlock_spinlock(void *__map)
 520 __releases(&map->spinlock)
 521 {
 522         struct regmap *map = __map;
 523         spin_unlock_irqrestore(&map->spinlock, map->spinlock_flags);
 524 }
 525
 526 static void dev_get_regmap_release(struct device *dev, void *res)
 527 {
 528         /*
 529          * We don't actually have anything to do here; the goal here
 530          * is not to manage the regmap but to provide a simple way to
 531          * get the regmap back given a struct device.
 532          */
 533 }
 534
 535 static bool _regmap_range_add(struct regmap *map,
 536                               struct regmap_range_node *data)
 537 {
 538         struct rb_root *root = &map->range_tree;
 539         struct rb_node **new = &(root->rb_node), *parent = NULL;
 540
 541         while (*new) {
 542                 struct regmap_range_node *this =
 543                         rb_entry(*new, struct regmap_range_node, node);
 544
 545                 parent = *new;
 546                 if (data->range_max < this->range_min)
 547                         new = &((*new)->rb_left);
 548                 else if (data->range_min > this->range_max)
 549                         new = &((*new)->rb_right);
 550                 else
 551                         return false;
 552         }
 553
 554         rb_link_node(&data->node, parent, new);
 555         rb_insert_color(&data->node, root);
 556
 557         return true;
 558 }
 559
 560 static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
 561                                                       unsigned int reg)
 562 {
 563         struct rb_node *node = map->range_tree.rb_node;
 564
 565         while (node) {
 566                 struct regmap_range_node *this =
 567                         rb_entry(node, struct regmap_range_node, node);
 568
 569                 if (reg < this->range_min)
 570                         node = node->rb_left;
 571                 else if (reg > this->range_max)
 572                         node = node->rb_right;
 573                 else
 574                         return this;
 575         }
 576
 577         return NULL;
 578 }
 579
 580 static void regmap_range_exit(struct regmap *map)
 581 {
 582         struct rb_node *next;
 583         struct regmap_range_node *range_node;
 584
 585         next = rb_first(&map->range_tree);
 586         while (next) {
 587                 range_node = rb_entry(next, struct regmap_range_node, node);
 588                 next = rb_next(&range_node->node);
 589                 rb_erase(&range_node->node, &map->range_tree);
 590                 kfree(range_node);
 591         }
 592
 593         kfree(map->selector_work_buf);
 594 }
 595
 596 static int regmap_set_name(struct regmap *map, const struct regmap_config *config)
 597 {
 598         if (config->name) {
 599                 const char *name = kstrdup_const(config->name, GFP_KERNEL);
 600
 601                 if (!name)
 602                         return -ENOMEM;
 603
 604                 kfree_const(map->name);
 605                 map->name = name;
 606         }
 607
 608         return 0;
 609 }
 610
 611 int regmap_attach_dev(struct device *dev, struct regmap *map,
 612                       const struct regmap_config *config)
 613 {
 614         struct regmap **m;
 615         int ret;
 616
 617         map->dev = dev;
 618
 619         ret = regmap_set_name(map, config);
 620         if (ret)
 621                 return ret;
 622
 623         regmap_debugfs_exit(map);
 624         regmap_debugfs_init(map);
 625
 626         /* Add a devres resource for dev_get_regmap() */
 627         m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
 628         if (!m) {
 629                 regmap_debugfs_exit(map);
 630                 return -ENOMEM;
 631         }
 632         *m = map;
 633         devres_add(dev, m);
 634
 635         return 0;
 636 }
 637 EXPORT_SYMBOL_GPL(regmap_attach_dev);
 638
 639 static enum regmap_endian regmap_get_reg_endian(const struct regmap_bus *bus,
 640                                         const struct regmap_config *config)
 641 {
 642         enum regmap_endian endian;
 643
 644         /* Retrieve the endianness specification from the regmap config */
 645         endian = config->reg_format_endian;
 646
 647         /* If the regmap config specified a non-default value, use that */
 648         if (endian != REGMAP_ENDIAN_DEFAULT)
 649                 return endian;
 650
 651         /* Retrieve the endianness specification from the bus config */
 652         if (bus && bus->reg_format_endian_default)
 653                 endian = bus->reg_format_endian_default;
 654
 655         /* If the bus specified a non-default value, use that */
 656         if (endian != REGMAP_ENDIAN_DEFAULT)
 657                 return endian;
 658
 659         /* Use this if no other value was found */
 660         return REGMAP_ENDIAN_BIG;
 661 }
 662
 663 enum regmap_endian regmap_get_val_endian(struct device *dev,
 664                                          const struct regmap_bus *bus,
 665                                          const struct regmap_config *config)
 666 {
 667         struct fwnode_handle *fwnode = dev ? dev_fwnode(dev) : NULL;
 668         enum regmap_endian endian;
 669
 670         /* Retrieve the endianness specification from the regmap config */
 671         endian = config->val_format_endian;
 672
 673         /* If the regmap config specified a non-default value, use that */
 674         if (endian != REGMAP_ENDIAN_DEFAULT)
 675                 return endian;
 676
 677         /* If the firmware node exist try to get endianness from it */
 678         if (fwnode_property_read_bool(fwnode, "big-endian"))
 679                 endian = REGMAP_ENDIAN_BIG;
 680         else if (fwnode_property_read_bool(fwnode, "little-endian"))
 681                 endian = REGMAP_ENDIAN_LITTLE;
 682         else if (fwnode_property_read_bool(fwnode, "native-endian"))
 683                 endian = REGMAP_ENDIAN_NATIVE;
 684
 685         /* If the endianness was specified in fwnode, use that */
 686         if (endian != REGMAP_ENDIAN_DEFAULT)
 687                 return endian;
 688
 689         /* Retrieve the endianness specification from the bus config */
 690         if (bus && bus->val_format_endian_default)
 691                 endian = bus->val_format_endian_default;
 692
 693         /* If the bus specified a non-default value, use that */
 694         if (endian != REGMAP_ENDIAN_DEFAULT)
 695                 return endian;
 696
 697         /* Use this if no other value was found */
 698         return REGMAP_ENDIAN_BIG;
 699 }
 700 EXPORT_SYMBOL_GPL(regmap_get_val_endian);
 701
 702 struct regmap *__regmap_init(struct device *dev,
 703                              const struct regmap_bus *bus,
 704                              void *bus_context,
 705                              const struct regmap_config *config,
 706                              struct lock_class_key *lock_key,
 707                              const char *lock_name)
 708 {
 709         struct regmap *map;
 710         int ret = -EINVAL;
 711         enum regmap_endian reg_endian, val_endian;
 712         int i, j;
 713
 714         if (!config)
 715                 goto err;
 716
 717         map = kzalloc(sizeof(*map), GFP_KERNEL);
 718         if (map == NULL) {
 719                 ret = -ENOMEM;
 720                 goto err;
 721         }
 722
 723         ret = regmap_set_name(map, config);
 724         if (ret)
 725                 goto err_map;
 726
 727         ret = -EINVAL; /* Later error paths rely on this */
 728
 729         if (config->disable_locking) {
 730                 map->lock = map->unlock = regmap_lock_unlock_none;
 731                 map->can_sleep = config->can_sleep;
 732                 regmap_debugfs_disable(map);
 733         } else if (config->lock && config->unlock) {
 734                 map->lock = config->lock;
 735                 map->unlock = config->unlock;
 736                 map->lock_arg = config->lock_arg;
 737                 map->can_sleep = config->can_sleep;
 738         } else if (config->use_hwlock) {
 739                 map->hwlock = hwspin_lock_request_specific(config->hwlock_id);
 740                 if (!map->hwlock) {
 741                         ret = -ENXIO;
 742                         goto err_name;
 743                 }
 744
 745                 switch (config->hwlock_mode) {
 746                 case HWLOCK_IRQSTATE:
 747                         map->lock = regmap_lock_hwlock_irqsave;
 748                         map->unlock = regmap_unlock_hwlock_irqrestore;
 749                         break;
 750                 case HWLOCK_IRQ:
 751                         map->lock = regmap_lock_hwlock_irq;
 752                         map->unlock = regmap_unlock_hwlock_irq;
 753                         break;
 754                 default:
 755                         map->lock = regmap_lock_hwlock;
 756                         map->unlock = regmap_unlock_hwlock;
 757                         break;
 758                 }
 759
 760                 map->lock_arg = map;
 761         } else {
 762                 if ((bus && bus->fast_io) ||
 763                     config->fast_io) {
 764                         spin_lock_init(&map->spinlock);
 765                         map->lock = regmap_lock_spinlock;
 766                         map->unlock = regmap_unlock_spinlock;
 767                         lockdep_set_class_and_name(&map->spinlock,
 768                                                    lock_key, lock_name);
 769                 } else {
 770                         mutex_init(&map->mutex);
 771                         map->lock = regmap_lock_mutex;
 772                         map->unlock = regmap_unlock_mutex;
 773                         map->can_sleep = true;
 774                         lockdep_set_class_and_name(&map->mutex,
 775                                                    lock_key, lock_name);
 776                 }
 777                 map->lock_arg = map;
 778         }
 779
 780         /*
 781          * When we write in fast-paths with regmap_bulk_write() don't allocate
 782          * scratch buffers with sleeping allocations.
 783          */
 784         if ((bus && bus->fast_io) || config->fast_io)
 785                 map->alloc_flags = GFP_ATOMIC;
 786         else
 787                 map->alloc_flags = GFP_KERNEL;
 788
 789         map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
 790         map->format.pad_bytes = config->pad_bits / 8;
 791         map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
 792         map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
 793                         config->val_bits + config->pad_bits, 8);
 794         map->reg_shift = config->pad_bits % 8;
 795         if (config->reg_stride)
 796                 map->reg_stride = config->reg_stride;
 797         else
 798                 map->reg_stride = 1;
 799         if (is_power_of_2(map->reg_stride))
 800                 map->reg_stride_order = ilog2(map->reg_stride);
 801         else
 802                 map->reg_stride_order = -1;
 803         map->use_single_read = config->use_single_read || !(config->read || (bus && bus->read));
 804         map->use_single_write = config->use_single_write || !(config->write || (bus && bus->write));
 805         map->can_multi_write = config->can_multi_write && (config->write || (bus && bus->write));
 806         if (bus) {
 807                 map->max_raw_read = bus->max_raw_read;
 808                 map->max_raw_write = bus->max_raw_write;
 809         } else if (config->max_raw_read && config->max_raw_write) {
 810                 map->max_raw_read = config->max_raw_read;
 811                 map->max_raw_write = config->max_raw_write;
 812         }
 813         map->dev = dev;
 814         map->bus = bus;
 815         map->bus_context = bus_context;
 816         map->max_register = config->max_register;
 817         map->wr_table = config->wr_table;
 818         map->rd_table = config->rd_table;
 819         map->volatile_table = config->volatile_table;
 820         map->precious_table = config->precious_table;
 821         map->wr_noinc_table = config->wr_noinc_table;
 822         map->rd_noinc_table = config->rd_noinc_table;
 823         map->writeable_reg = config->writeable_reg;
 824         map->readable_reg = config->readable_reg;
 825         map->volatile_reg = config->volatile_reg;
 826         map->precious_reg = config->precious_reg;
 827         map->writeable_noinc_reg = config->writeable_noinc_reg;
 828         map->readable_noinc_reg = config->readable_noinc_reg;
 829         map->cache_type = config->cache_type;
 830
 831         spin_lock_init(&map->async_lock);
 832         INIT_LIST_HEAD(&map->async_list);
 833         INIT_LIST_HEAD(&map->async_free);
 834         init_waitqueue_head(&map->async_waitq);
 835
 836         if (config->read_flag_mask ||
 837             config->write_flag_mask ||
 838             config->zero_flag_mask) {
 839                 map->read_flag_mask = config->read_flag_mask;
 840                 map->write_flag_mask = config->write_flag_mask;
 841         } else if (bus) {
 842                 map->read_flag_mask = bus->read_flag_mask;
 843         }
 844
 845         if (config && config->read && config->write) {
 846                 map->reg_read  = _regmap_bus_read;
 847
 848                 /* Bulk read/write */
 849                 map->read = config->read;
 850                 map->write = config->write;
 851
 852                 reg_endian = REGMAP_ENDIAN_NATIVE;
 853                 val_endian = REGMAP_ENDIAN_NATIVE;
 854         } else if (!bus) {
 855                 map->reg_read  = config->reg_read;
 856                 map->reg_write = config->reg_write;
 857                 map->reg_update_bits = config->reg_update_bits;
 858
 859                 map->defer_caching = false;
 860                 goto skip_format_initialization;
 861         } else if (!bus->read || !bus->write) {
 862                 map->reg_read = _regmap_bus_reg_read;
 863                 map->reg_write = _regmap_bus_reg_write;
 864                 map->reg_update_bits = bus->reg_update_bits;
 865
 866                 map->defer_caching = false;
 867                 goto skip_format_initialization;
 868         } else {
 869                 map->reg_read  = _regmap_bus_read;
 870                 map->reg_update_bits = bus->reg_update_bits;
 871                 /* Bulk read/write */
 872                 map->read = bus->read;
 873                 map->write = bus->write;
 874
 875                 reg_endian = regmap_get_reg_endian(bus, config);
 876                 val_endian = regmap_get_val_endian(dev, bus, config);
 877         }
 878
 879         switch (config->reg_bits + map->reg_shift) {
 880         case 2:
 881                 switch (config->val_bits) {
 882                 case 6:
 883                         map->format.format_write = regmap_format_2_6_write;
 884                         break;
 885                 default:
 886                         goto err_hwlock;
 887                 }
 888                 break;
 889
 890         case 4:
 891                 switch (config->val_bits) {
 892                 case 12:
 893                         map->format.format_write = regmap_format_4_12_write;
 894                         break;
 895                 default:
 896                         goto err_hwlock;
 897                 }
 898                 break;
 899
 900         case 7:
 901                 switch (config->val_bits) {
 902                 case 9:
 903                         map->format.format_write = regmap_format_7_9_write;
 904                         break;
 905                 default:
 906                         goto err_hwlock;
 907                 }
 908                 break;
 909
 910         case 10:
 911                 switch (config->val_bits) {
 912                 case 14:
 913                         map->format.format_write = regmap_format_10_14_write;
 914                         break;
 915                 default:
 916                         goto err_hwlock;
 917                 }
 918                 break;
 919
 920         case 12:
 921                 switch (config->val_bits) {
 922                 case 20:
 923                         map->format.format_write = regmap_format_12_20_write;
 924                         break;
 925                 default:
 926                         goto err_hwlock;
 927                 }
 928                 break;
 929
 930         case 8:
 931                 map->format.format_reg = regmap_format_8;
 932                 break;
 933
 934         case 16:
 935                 switch (reg_endian) {
 936                 case REGMAP_ENDIAN_BIG:
 937                         map->format.format_reg = regmap_format_16_be;
 938                         break;
 939                 case REGMAP_ENDIAN_LITTLE:
 940                         map->format.format_reg = regmap_format_16_le;
 941                         break;
 942                 case REGMAP_ENDIAN_NATIVE:
 943                         map->format.format_reg = regmap_format_16_native;
 944                         break;
 945                 default:
 946                         goto err_hwlock;
 947                 }
 948                 break;
 949
 950         case 24:
 951                 if (reg_endian != REGMAP_ENDIAN_BIG)
 952                         goto err_hwlock;
 953                 map->format.format_reg = regmap_format_24;
 954                 break;
 955
 956         case 32:
 957                 switch (reg_endian) {
 958                 case REGMAP_ENDIAN_BIG:
 959                         map->format.format_reg = regmap_format_32_be;
 960                         break;
 961                 case REGMAP_ENDIAN_LITTLE:
 962                         map->format.format_reg = regmap_format_32_le;
 963                         break;
 964                 case REGMAP_ENDIAN_NATIVE:
 965                         map->format.format_reg = regmap_format_32_native;
 966                         break;
 967                 default:
 968                         goto err_hwlock;
 969                 }
 970                 break;
 971
 972 #ifdef CONFIG_64BIT
 973         case 64:
 974                 switch (reg_endian) {
 975                 case REGMAP_ENDIAN_BIG:
 976                         map->format.format_reg = regmap_format_64_be;
 977                         break;
 978                 case REGMAP_ENDIAN_LITTLE:
 979                         map->format.format_reg = regmap_format_64_le;
 980                         break;
 981                 case REGMAP_ENDIAN_NATIVE:
 982                         map->format.format_reg = regmap_format_64_native;
 983                         break;
 984                 default:
 985                         goto err_hwlock;
 986                 }
 987                 break;
 988 #endif
 989
 990         default:
 991                 goto err_hwlock;
 992         }
 993
 994         if (val_endian == REGMAP_ENDIAN_NATIVE)
 995                 map->format.parse_inplace = regmap_parse_inplace_noop;
 996
 997         switch (config->val_bits) {
 998         case 8:
 999                 map->format.format_val = regmap_format_8;
1000                 map->format.parse_val = regmap_parse_8;
1001                 map->format.parse_inplace = regmap_parse_inplace_noop;
1002                 break;
1003         case 16:
1004                 switch (val_endian) {
1005                 case REGMAP_ENDIAN_BIG:
1006                         map->format.format_val = regmap_format_16_be;
1007                         map->format.parse_val = regmap_parse_16_be;
1008                         map->format.parse_inplace = regmap_parse_16_be_inplace;
1009                         break;
1010                 case REGMAP_ENDIAN_LITTLE:
1011                         map->format.format_val = regmap_format_16_le;
1012                         map->format.parse_val = regmap_parse_16_le;
1013                         map->format.parse_inplace = regmap_parse_16_le_inplace;
1014                         break;
1015                 case REGMAP_ENDIAN_NATIVE:
1016                         map->format.format_val = regmap_format_16_native;
1017                         map->format.parse_val = regmap_parse_16_native;
1018                         break;
1019                 default:
1020                         goto err_hwlock;
1021                 }
1022                 break;
1023         case 24:
1024                 if (val_endian != REGMAP_ENDIAN_BIG)
1025                         goto err_hwlock;
1026                 map->format.format_val = regmap_format_24;
1027                 map->format.parse_val = regmap_parse_24;
1028                 break;
1029         case 32:
1030                 switch (val_endian) {
1031                 case REGMAP_ENDIAN_BIG:
1032                         map->format.format_val = regmap_format_32_be;
1033                         map->format.parse_val = regmap_parse_32_be;
1034                         map->format.parse_inplace = regmap_parse_32_be_inplace;
1035                         break;
1036                 case REGMAP_ENDIAN_LITTLE:
1037                         map->format.format_val = regmap_format_32_le;
1038                         map->format.parse_val = regmap_parse_32_le;
1039                         map->format.parse_inplace = regmap_parse_32_le_inplace;
1040                         break;
1041                 case REGMAP_ENDIAN_NATIVE:
1042                         map->format.format_val = regmap_format_32_native;
1043                         map->format.parse_val = regmap_parse_32_native;
1044                         break;
1045                 default:
1046                         goto err_hwlock;
1047                 }
1048                 break;
1049 #ifdef CONFIG_64BIT
1050         case 64:
1051                 switch (val_endian) {
1052                 case REGMAP_ENDIAN_BIG:
1053                         map->format.format_val = regmap_format_64_be;
1054                         map->format.parse_val = regmap_parse_64_be;
1055                         map->format.parse_inplace = regmap_parse_64_be_inplace;
1056                         break;
1057                 case REGMAP_ENDIAN_LITTLE:
1058                         map->format.format_val = regmap_format_64_le;
1059                         map->format.parse_val = regmap_parse_64_le;
1060                         map->format.parse_inplace = regmap_parse_64_le_inplace;
1061                         break;
1062                 case REGMAP_ENDIAN_NATIVE:
1063                         map->format.format_val = regmap_format_64_native;
1064                         map->format.parse_val = regmap_parse_64_native;
1065                         break;
1066                 default:
1067                         goto err_hwlock;
1068                 }
1069                 break;
1070 #endif
1071         }
1072
1073         if (map->format.format_write) {
1074                 if ((reg_endian != REGMAP_ENDIAN_BIG) ||
1075                     (val_endian != REGMAP_ENDIAN_BIG))
1076                         goto err_hwlock;
1077                 map->use_single_write = true;
1078         }
1079
1080         if (!map->format.format_write &&
1081             !(map->format.format_reg && map->format.format_val))
1082                 goto err_hwlock;
1083
1084         map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
1085         if (map->work_buf == NULL) {
1086                 ret = -ENOMEM;
1087                 goto err_hwlock;
1088         }
1089
1090         if (map->format.format_write) {
1091                 map->defer_caching = false;
1092                 map->reg_write = _regmap_bus_formatted_write;
1093         } else if (map->format.format_val) {
1094                 map->defer_caching = true;
1095                 map->reg_write = _regmap_bus_raw_write;
1096         }
1097
1098 skip_format_initialization:
1099
1100         map->range_tree = RB_ROOT;
1101         for (i = 0; i < config->num_ranges; i++) {
1102                 const struct regmap_range_cfg *range_cfg = &config->ranges[i];
1103                 struct regmap_range_node *new;
1104
1105                 /* Sanity check */
1106                 if (range_cfg->range_max < range_cfg->range_min) {
1107                         dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
1108                                 range_cfg->range_max, range_cfg->range_min);
1109                         goto err_range;
1110                 }
1111
1112                 if (range_cfg->range_max > map->max_register) {
1113                         dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
1114                                 range_cfg->range_max, map->max_register);
1115                         goto err_range;
1116                 }
1117
1118                 if (range_cfg->selector_reg > map->max_register) {
1119                         dev_err(map->dev,
1120                                 "Invalid range %d: selector out of map\n", i);
1121                         goto err_range;
1122                 }
1123
1124                 if (range_cfg->window_len == 0) {
1125                         dev_err(map->dev, "Invalid range %d: window_len 0\n",
1126                                 i);
1127                         goto err_range;
1128                 }
1129
1130                 /* Make sure, that this register range has no selector
1131                    or data window within its boundary */
1132                 for (j = 0; j < config->num_ranges; j++) {
1133                         unsigned sel_reg = config->ranges[j].selector_reg;
1134                         unsigned win_min = config->ranges[j].window_start;
1135                         unsigned win_max = win_min +
1136                                            config->ranges[j].window_len - 1;
1137
1138                         /* Allow data window inside its own virtual range */
1139                         if (j == i)
1140                                 continue;
1141
1142                         if (range_cfg->range_min <= sel_reg &&
1143                             sel_reg <= range_cfg->range_max) {
1144                                 dev_err(map->dev,
1145                                         "Range %d: selector for %d in window\n",
1146                                         i, j);
1147                                 goto err_range;
1148                         }
1149
1150                         if (!(win_max < range_cfg->range_min ||
1151                               win_min > range_cfg->range_max)) {
1152                                 dev_err(map->dev,
1153                                         "Range %d: window for %d in window\n",
1154                                         i, j);
1155                                 goto err_range;
1156                         }
1157                 }
1158
1159                 new = kzalloc(sizeof(*new), GFP_KERNEL);
1160                 if (new == NULL) {
1161                         ret = -ENOMEM;
1162                         goto err_range;
1163                 }
1164
1165                 new->map = map;
1166                 new->name = range_cfg->name;
1167                 new->range_min = range_cfg->range_min;
1168                 new->range_max = range_cfg->range_max;
1169                 new->selector_reg = range_cfg->selector_reg;
1170                 new->selector_mask = range_cfg->selector_mask;
1171                 new->selector_shift = range_cfg->selector_shift;
1172                 new->window_start = range_cfg->window_start;
1173                 new->window_len = range_cfg->window_len;
1174
1175                 if (!_regmap_range_add(map, new)) {
1176                         dev_err(map->dev, "Failed to add range %d\n", i);
1177                         kfree(new);
1178                         goto err_range;
1179                 }
1180
1181                 if (map->selector_work_buf == NULL) {
1182                         map->selector_work_buf =
1183                                 kzalloc(map->format.buf_size, GFP_KERNEL);
1184                         if (map->selector_work_buf == NULL) {
1185                                 ret = -ENOMEM;
1186                                 goto err_range;
1187                         }
1188                 }
1189         }
1190
1191         ret = regcache_init(map, config);
1192         if (ret != 0)
1193                 goto err_range;
1194
1195         if (dev) {
1196                 ret = regmap_attach_dev(dev, map, config);
1197                 if (ret != 0)
1198                         goto err_regcache;
1199         } else {
1200                 regmap_debugfs_init(map);
1201         }
1202
1203         return map;
1204
1205 err_regcache:
1206         regcache_exit(map);
1207 err_range:
1208         regmap_range_exit(map);
1209         kfree(map->work_buf);
1210 err_hwlock:
1211         if (map->hwlock)
1212                 hwspin_lock_free(map->hwlock);
1213 err_name:
1214         kfree_const(map->name);
1215 err_map:
1216         kfree(map);
1217 err:
1218         return ERR_PTR(ret);
1219 }
1220 EXPORT_SYMBOL_GPL(__regmap_init);
1221
1222 static void devm_regmap_release(struct device *dev, void *res)
1223 {
1224         regmap_exit(*(struct regmap **)res);
1225 }
1226
1227 struct regmap *__devm_regmap_init(struct device *dev,
1228                                   const struct regmap_bus *bus,
1229                                   void *bus_context,
1230                                   const struct regmap_config *config,
1231                                   struct lock_class_key *lock_key,
1232                                   const char *lock_name)
1233 {
1234         struct regmap **ptr, *regmap;
1235
1236         ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
1237         if (!ptr)
1238                 return ERR_PTR(-ENOMEM);
1239
1240         regmap = __regmap_init(dev, bus, bus_context, config,
1241                                lock_key, lock_name);
1242         if (!IS_ERR(regmap)) {
1243                 *ptr = regmap;
1244                 devres_add(dev, ptr);
1245         } else {
1246                 devres_free(ptr);
1247         }
1248
1249         return regmap;
1250 }
1251 EXPORT_SYMBOL_GPL(__devm_regmap_init);
1252
1253 static void regmap_field_init(struct regmap_field *rm_field,
1254         struct regmap *regmap, struct reg_field reg_field)
1255 {
1256         rm_field->regmap = regmap;
1257         rm_field->reg = reg_field.reg;
1258         rm_field->shift = reg_field.lsb;
1259         rm_field->mask = GENMASK(reg_field.msb, reg_field.lsb);
1260         rm_field->id_size = reg_field.id_size;
1261         rm_field->id_offset = reg_field.id_offset;
1262 }
1263
1264 /**
1265  * devm_regmap_field_alloc() - Allocate and initialise a register field.
1266  *
1267  * @dev: Device that will be interacted with
1268  * @regmap: regmap bank in which this register field is located.
1269  * @reg_field: Register field with in the bank.
1270  *
1271  * The return value will be an ERR_PTR() on error or a valid pointer
1272  * to a struct regmap_field. The regmap_field will be automatically freed
1273  * by the device management code.
1274  */
1275 struct regmap_field *devm_regmap_field_alloc(struct device *dev,
1276                 struct regmap *regmap, struct reg_field reg_field)
1277 {
1278         struct regmap_field *rm_field = devm_kzalloc(dev,
1279                                         sizeof(*rm_field), GFP_KERNEL);
1280         if (!rm_field)
1281                 return ERR_PTR(-ENOMEM);
1282
1283         regmap_field_init(rm_field, regmap, reg_field);
1284
1285         return rm_field;
1286
1287 }
1288 EXPORT_SYMBOL_GPL(devm_regmap_field_alloc);
1289
1290
1291 /**
1292  * regmap_field_bulk_alloc() - Allocate and initialise a bulk register field.
1293  *
1294  * @regmap: regmap bank in which this register field is located.
1295  * @rm_field: regmap register fields within the bank.
1296  * @reg_field: Register fields within the bank.
1297  * @num_fields: Number of register fields.
1298  *
1299  * The return value will be an -ENOMEM on error or zero for success.
1300  * Newly allocated regmap_fields should be freed by calling
1301  * regmap_field_bulk_free()
1302  */
1303 int regmap_field_bulk_alloc(struct regmap *regmap,
1304                             struct regmap_field **rm_field,
1305                             struct reg_field *reg_field,
1306                             int num_fields)
1307 {
1308         struct regmap_field *rf;
1309         int i;
1310
1311         rf = kcalloc(num_fields, sizeof(*rf), GFP_KERNEL);
1312         if (!rf)
1313                 return -ENOMEM;
1314
1315         for (i = 0; i < num_fields; i++) {
1316                 regmap_field_init(&rf[i], regmap, reg_field[i]);
1317                 rm_field[i] = &rf[i];
1318         }
1319
1320         return 0;
1321 }
1322 EXPORT_SYMBOL_GPL(regmap_field_bulk_alloc);
1323
1324 /**
1325  * devm_regmap_field_bulk_alloc() - Allocate and initialise a bulk register
1326  * fields.
1327  *
1328  * @dev: Device that will be interacted with
1329  * @regmap: regmap bank in which this register field is located.
1330  * @rm_field: regmap register fields within the bank.
1331  * @reg_field: Register fields within the bank.
1332  * @num_fields: Number of register fields.
1333  *
1334  * The return value will be an -ENOMEM on error or zero for success.
1335  * Newly allocated regmap_fields will be automatically freed by the
1336  * device management code.
1337  */
1338 int devm_regmap_field_bulk_alloc(struct device *dev,
1339                                  struct regmap *regmap,
1340                                  struct regmap_field **rm_field,
1341                                  struct reg_field *reg_field,
1342                                  int num_fields)
1343 {
1344         struct regmap_field *rf;
1345         int i;
1346
1347         rf = devm_kcalloc(dev, num_fields, sizeof(*rf), GFP_KERNEL);
1348         if (!rf)
1349                 return -ENOMEM;
1350
1351         for (i = 0; i < num_fields; i++) {
1352                 regmap_field_init(&rf[i], regmap, reg_field[i]);
1353                 rm_field[i] = &rf[i];
1354         }
1355
1356         return 0;
1357 }
1358 EXPORT_SYMBOL_GPL(devm_regmap_field_bulk_alloc);
1359
1360 /**
1361  * regmap_field_bulk_free() - Free register field allocated using
1362  *                       regmap_field_bulk_alloc.
1363  *
1364  * @field: regmap fields which should be freed.
1365  */
1366 void regmap_field_bulk_free(struct regmap_field *field)
1367 {
1368         kfree(field);
1369 }
1370 EXPORT_SYMBOL_GPL(regmap_field_bulk_free);
1371
1372 /**
1373  * devm_regmap_field_bulk_free() - Free a bulk register field allocated using
1374  *                            devm_regmap_field_bulk_alloc.
1375  *
1376  * @dev: Device that will be interacted with
1377  * @field: regmap field which should be freed.
1378  *
1379  * Free register field allocated using devm_regmap_field_bulk_alloc(). Usually
1380  * drivers need not call this function, as the memory allocated via devm
1381  * will be freed as per device-driver life-cycle.
1382  */
1383 void devm_regmap_field_bulk_free(struct device *dev,
1384                                  struct regmap_field *field)
1385 {
1386         devm_kfree(dev, field);
1387 }
1388 EXPORT_SYMBOL_GPL(devm_regmap_field_bulk_free);
1389
1390 /**
1391  * devm_regmap_field_free() - Free a register field allocated using
1392  *                            devm_regmap_field_alloc.
1393  *
1394  * @dev: Device that will be interacted with
1395  * @field: regmap field which should be freed.
1396  *
1397  * Free register field allocated using devm_regmap_field_alloc(). Usually
1398  * drivers need not call this function, as the memory allocated via devm
1399  * will be freed as per device-driver life-cyle.
1400  */
1401 void devm_regmap_field_free(struct device *dev,
1402         struct regmap_field *field)
1403 {
1404         devm_kfree(dev, field);
1405 }
1406 EXPORT_SYMBOL_GPL(devm_regmap_field_free);
1407
1408 /**
1409  * regmap_field_alloc() - Allocate and initialise a register field.
1410  *
1411  * @regmap: regmap bank in which this register field is located.
1412  * @reg_field: Register field with in the bank.
1413  *
1414  * The return value will be an ERR_PTR() on error or a valid pointer
1415  * to a struct regmap_field. The regmap_field should be freed by the
1416  * user once its finished working with it using regmap_field_free().
1417  */
1418 struct regmap_field *regmap_field_alloc(struct regmap *regmap,
1419                 struct reg_field reg_field)
1420 {
1421         struct regmap_field *rm_field = kzalloc(sizeof(*rm_field), GFP_KERNEL);
1422
1423         if (!rm_field)
1424                 return ERR_PTR(-ENOMEM);
1425
1426         regmap_field_init(rm_field, regmap, reg_field);
1427
1428         return rm_field;
1429 }
1430 EXPORT_SYMBOL_GPL(regmap_field_alloc);
1431
1432 /**
1433  * regmap_field_free() - Free register field allocated using
1434  *                       regmap_field_alloc.
1435  *
1436  * @field: regmap field which should be freed.
1437  */
1438 void regmap_field_free(struct regmap_field *field)
1439 {
1440         kfree(field);
1441 }
1442 EXPORT_SYMBOL_GPL(regmap_field_free);
1443
1444 /**
1445  * regmap_reinit_cache() - Reinitialise the current register cache
1446  *
1447  * @map: Register map to operate on.
1448  * @config: New configuration.  Only the cache data will be used.
1449  *
1450  * Discard any existing register cache for the map and initialize a
1451  * new cache.  This can be used to restore the cache to defaults or to
1452  * update the cache configuration to reflect runtime discovery of the
1453  * hardware.
1454  *
1455  * No explicit locking is done here, the user needs to ensure that
1456  * this function will not race with other calls to regmap.
1457  */
1458 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
1459 {
1460         int ret;
1461
1462         regcache_exit(map);
1463         regmap_debugfs_exit(map);
1464
1465         map->max_register = config->max_register;
1466         map->writeable_reg = config->writeable_reg;
1467         map->readable_reg = config->readable_reg;
1468         map->volatile_reg = config->volatile_reg;
1469         map->precious_reg = config->precious_reg;
1470         map->writeable_noinc_reg = config->writeable_noinc_reg;
1471         map->readable_noinc_reg = config->readable_noinc_reg;
1472         map->cache_type = config->cache_type;
1473
1474         ret = regmap_set_name(map, config);
1475         if (ret)
1476                 return ret;
1477
1478         regmap_debugfs_init(map);
1479
1480         map->cache_bypass = false;
1481         map->cache_only = false;
1482
1483         return regcache_init(map, config);
1484 }
1485 EXPORT_SYMBOL_GPL(regmap_reinit_cache);
1486
1487 /**
1488  * regmap_exit() - Free a previously allocated register map
1489  *
1490  * @map: Register map to operate on.
1491  */
1492 void regmap_exit(struct regmap *map)
1493 {
1494         struct regmap_async *async;
1495
1496         regcache_exit(map);
1497         regmap_debugfs_exit(map);
1498         regmap_range_exit(map);
1499         if (map->bus && map->bus->free_context)
1500                 map->bus->free_context(map->bus_context);
1501         kfree(map->work_buf);
1502         while (!list_empty(&map->async_free)) {
1503                 async = list_first_entry_or_null(&map->async_free,
1504                                                  struct regmap_async,
1505                                                  list);
1506                 list_del(&async->list);
1507                 kfree(async->work_buf);
1508                 kfree(async);
1509         }
1510         if (map->hwlock)
1511                 hwspin_lock_free(map->hwlock);
1512         if (map->lock == regmap_lock_mutex)
1513                 mutex_destroy(&map->mutex);
1514         kfree_const(map->name);
1515         kfree(map->patch);
1516         kfree(map);
1517 }
1518 EXPORT_SYMBOL_GPL(regmap_exit);
1519
1520 static int dev_get_regmap_match(struct device *dev, void *res, void *data)
1521 {
1522         struct regmap **r = res;
1523         if (!r || !*r) {
1524                 WARN_ON(!r || !*r);
1525                 return 0;
1526         }
1527
1528         /* If the user didn't specify a name match any */
1529         if (data)
1530                 return (*r)->name && !strcmp((*r)->name, data);
1531         else
1532                 return 1;
1533 }
1534
1535 /**
1536  * dev_get_regmap() - Obtain the regmap (if any) for a device
1537  *
1538  * @dev: Device to retrieve the map for
1539  * @name: Optional name for the register map, usually NULL.
1540  *
1541  * Returns the regmap for the device if one is present, or NULL.  If
1542  * name is specified then it must match the name specified when
1543  * registering the device, if it is NULL then the first regmap found
1544  * will be used.  Devices with multiple register maps are very rare,
1545  * generic code should normally not need to specify a name.
1546  */
1547 struct regmap *dev_get_regmap(struct device *dev, const char *name)
1548 {
1549         struct regmap **r = devres_find(dev, dev_get_regmap_release,
1550                                         dev_get_regmap_match, (void *)name);
1551
1552         if (!r)
1553                 return NULL;
1554         return *r;
1555 }
1556 EXPORT_SYMBOL_GPL(dev_get_regmap);
1557
1558 /**
1559  * regmap_get_device() - Obtain the device from a regmap
1560  *
1561  * @map: Register map to operate on.
1562  *
1563  * Returns the underlying device that the regmap has been created for.
1564  */
1565 struct device *regmap_get_device(struct regmap *map)
1566 {
1567         return map->dev;
1568 }
1569 EXPORT_SYMBOL_GPL(regmap_get_device);
1570
1571 static int _regmap_select_page(struct regmap *map, unsigned int *reg,
1572                                struct regmap_range_node *range,
1573                                unsigned int val_num)
1574 {
1575         void *orig_work_buf;
1576         unsigned int win_offset;
1577         unsigned int win_page;
1578         bool page_chg;
1579         int ret;
1580
1581         win_offset = (*reg - range->range_min) % range->window_len;
1582         win_page = (*reg - range->range_min) / range->window_len;
1583
1584         if (val_num > 1) {
1585                 /* Bulk write shouldn't cross range boundary */
1586                 if (*reg + val_num - 1 > range->range_max)
1587                         return -EINVAL;
1588
1589                 /* ... or single page boundary */
1590                 if (val_num > range->window_len - win_offset)
1591                         return -EINVAL;
1592         }
1593
1594         /* It is possible to have selector register inside data window.
1595            In that case, selector register is located on every page and
1596            it needs no page switching, when accessed alone. */
1597         if (val_num > 1 ||
1598             range->window_start + win_offset != range->selector_reg) {
1599                 /* Use separate work_buf during page switching */
1600                 orig_work_buf = map->work_buf;
1601                 map->work_buf = map->selector_work_buf;
1602
1603                 ret = _regmap_update_bits(map, range->selector_reg,
1604                                           range->selector_mask,
1605                                           win_page << range->selector_shift,
1606                                           &page_chg, false);
1607
1608                 map->work_buf = orig_work_buf;
1609
1610                 if (ret != 0)
1611                         return ret;
1612         }
1613
1614         *reg = range->window_start + win_offset;
1615
1616         return 0;
1617 }
1618
1619 static void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
1620                                           unsigned long mask)
1621 {
1622         u8 *buf;
1623         int i;
1624
1625         if (!mask || !map->work_buf)
1626                 return;
1627
1628         buf = map->work_buf;
1629
1630         for (i = 0; i < max_bytes; i++)
1631                 buf[i] |= (mask >> (8 * i)) & 0xff;
1632 }
1633
1634 static int _regmap_raw_write_impl(struct regmap *map, unsigned int reg,
1635                                   const void *val, size_t val_len, bool noinc)
1636 {
1637         struct regmap_range_node *range;
1638         unsigned long flags;
1639         void *work_val = map->work_buf + map->format.reg_bytes +
1640                 map->format.pad_bytes;
1641         void *buf;
1642         int ret = -ENOTSUPP;
1643         size_t len;
1644         int i;
1645
1646         /* Check for unwritable or noinc registers in range
1647          * before we start
1648          */
1649         if (!regmap_writeable_noinc(map, reg)) {
1650                 for (i = 0; i < val_len / map->format.val_bytes; i++) {
1651                         unsigned int element =
1652                                 reg + regmap_get_offset(map, i);
1653                         if (!regmap_writeable(map, element) ||
1654                                 regmap_writeable_noinc(map, element))
1655                                 return -EINVAL;
1656                 }
1657         }
1658
1659         if (!map->cache_bypass && map->format.parse_val) {
1660                 unsigned int ival, offset;
1661                 int val_bytes = map->format.val_bytes;
1662
1663                 /* Cache the last written value for noinc writes */
1664                 i = noinc ? val_len - val_bytes : 0;
1665                 for (; i < val_len; i += val_bytes) {
1666                         ival = map->format.parse_val(val + i);
1667                         offset = noinc ? 0 : regmap_get_offset(map, i / val_bytes);
1668                         ret = regcache_write(map, reg + offset, ival);
1669                         if (ret) {
1670                                 dev_err(map->dev,
1671                                         "Error in caching of register: %x ret: %d\n",
1672                                         reg + offset, ret);
1673                                 return ret;
1674                         }
1675                 }
1676                 if (map->cache_only) {
1677                         map->cache_dirty = true;
1678                         return 0;
1679                 }
1680         }
1681
1682         range = _regmap_range_lookup(map, reg);
1683         if (range) {
1684                 int val_num = val_len / map->format.val_bytes;
1685                 int win_offset = (reg - range->range_min) % range->window_len;
1686                 int win_residue = range->window_len - win_offset;
1687
1688                 /* If the write goes beyond the end of the window split it */
1689                 while (val_num > win_residue) {
1690                         dev_dbg(map->dev, "Writing window %d/%zu\n",
1691                                 win_residue, val_len / map->format.val_bytes);
1692                         ret = _regmap_raw_write_impl(map, reg, val,
1693                                                      win_residue *
1694                                                      map->format.val_bytes, noinc);
1695                         if (ret != 0)
1696                                 return ret;
1697
1698                         reg += win_residue;
1699                         val_num -= win_residue;
1700                         val += win_residue * map->format.val_bytes;
1701                         val_len -= win_residue * map->format.val_bytes;
1702
1703                         win_offset = (reg - range->range_min) %
1704                                 range->window_len;
1705                         win_residue = range->window_len - win_offset;
1706                 }
1707
1708                 ret = _regmap_select_page(map, &reg, range, noinc ? 1 : val_num);
1709                 if (ret != 0)
1710                         return ret;
1711         }
1712
1713         map->format.format_reg(map->work_buf, reg, map->reg_shift);
1714         regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
1715                                       map->write_flag_mask);
1716
1717         /*
1718          * Essentially all I/O mechanisms will be faster with a single
1719          * buffer to write.  Since register syncs often generate raw
1720          * writes of single registers optimise that case.
1721          */
1722         if (val != work_val && val_len == map->format.val_bytes) {
1723                 memcpy(work_val, val, map->format.val_bytes);
1724                 val = work_val;
1725         }
1726
1727         if (map->async && map->bus && map->bus->async_write) {
1728                 struct regmap_async *async;
1729
1730                 trace_regmap_async_write_start(map, reg, val_len);
1731
1732                 spin_lock_irqsave(&map->async_lock, flags);
1733                 async = list_first_entry_or_null(&map->async_free,
1734                                                  struct regmap_async,
1735                                                  list);
1736                 if (async)
1737                         list_del(&async->list);
1738                 spin_unlock_irqrestore(&map->async_lock, flags);
1739
1740                 if (!async) {
1741                         async = map->bus->async_alloc();
1742                         if (!async)
1743                                 return -ENOMEM;
1744
1745                         async->work_buf = kzalloc(map->format.buf_size,
1746                                                   GFP_KERNEL | GFP_DMA);
1747                         if (!async->work_buf) {
1748                                 kfree(async);
1749                                 return -ENOMEM;
1750                         }
1751                 }
1752
1753                 async->map = map;
1754
1755                 /* If the caller supplied the value we can use it safely. */
1756                 memcpy(async->work_buf, map->work_buf, map->format.pad_bytes +
1757                        map->format.reg_bytes + map->format.val_bytes);
1758
1759                 spin_lock_irqsave(&map->async_lock, flags);
1760                 list_add_tail(&async->list, &map->async_list);
1761                 spin_unlock_irqrestore(&map->async_lock, flags);
1762
1763                 if (val != work_val)
1764                         ret = map->bus->async_write(map->bus_context,
1765                                                     async->work_buf,
1766                                                     map->format.reg_bytes +
1767                                                     map->format.pad_bytes,
1768                                                     val, val_len, async);
1769                 else
1770                         ret = map->bus->async_write(map->bus_context,
1771                                                     async->work_buf,
1772                                                     map->format.reg_bytes +
1773                                                     map->format.pad_bytes +
1774                                                     val_len, NULL, 0, async);
1775
1776                 if (ret != 0) {
1777                         dev_err(map->dev, "Failed to schedule write: %d\n",
1778                                 ret);
1779
1780                         spin_lock_irqsave(&map->async_lock, flags);
1781                         list_move(&async->list, &map->async_free);
1782                         spin_unlock_irqrestore(&map->async_lock, flags);
1783                 }
1784
1785                 return ret;
1786         }
1787
1788         trace_regmap_hw_write_start(map, reg, val_len / map->format.val_bytes);
1789
1790         /* If we're doing a single register write we can probably just
1791          * send the work_buf directly, otherwise try to do a gather
1792          * write.
1793          */
1794         if (val == work_val)
1795                 ret = map->write(map->bus_context, map->work_buf,
1796                                  map->format.reg_bytes +
1797                                  map->format.pad_bytes +
1798                                  val_len);
1799         else if (map->bus && map->bus->gather_write)
1800                 ret = map->bus->gather_write(map->bus_context, map->work_buf,
1801                                              map->format.reg_bytes +
1802                                              map->format.pad_bytes,
1803                                              val, val_len);
1804         else
1805                 ret = -ENOTSUPP;
1806
1807         /* If that didn't work fall back on linearising by hand. */
1808         if (ret == -ENOTSUPP) {
1809                 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
1810                 buf = kzalloc(len, GFP_KERNEL);
1811                 if (!buf)
1812                         return -ENOMEM;
1813
1814                 memcpy(buf, map->work_buf, map->format.reg_bytes);
1815                 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
1816                        val, val_len);
1817                 ret = map->write(map->bus_context, buf, len);
1818
1819                 kfree(buf);
1820         } else if (ret != 0 && !map->cache_bypass && map->format.parse_val) {
1821                 /* regcache_drop_region() takes lock that we already have,
1822                  * thus call map->cache_ops->drop() directly
1823                  */
1824                 if (map->cache_ops && map->cache_ops->drop)
1825                         map->cache_ops->drop(map, reg, reg + 1);
1826         }
1827
1828         trace_regmap_hw_write_done(map, reg, val_len / map->format.val_bytes);
1829
1830         return ret;
1831 }
1832
1833 /**
1834  * regmap_can_raw_write - Test if regmap_raw_write() is supported
1835  *
1836  * @map: Map to check.
1837  */
1838 bool regmap_can_raw_write(struct regmap *map)
1839 {
1840         return map->bus && map->bus->write && map->format.format_val &&
1841                 map->format.format_reg;
1842 }
1843 EXPORT_SYMBOL_GPL(regmap_can_raw_write);
1844
1845 /**
1846  * regmap_get_raw_read_max - Get the maximum size we can read
1847  *
1848  * @map: Map to check.
1849  */
1850 size_t regmap_get_raw_read_max(struct regmap *map)
1851 {
1852         return map->max_raw_read;
1853 }
1854 EXPORT_SYMBOL_GPL(regmap_get_raw_read_max);
1855
1856 /**
1857  * regmap_get_raw_write_max - Get the maximum size we can read
1858  *
1859  * @map: Map to check.
1860  */
1861 size_t regmap_get_raw_write_max(struct regmap *map)
1862 {
1863         return map->max_raw_write;
1864 }
1865 EXPORT_SYMBOL_GPL(regmap_get_raw_write_max);
1866
1867 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
1868                                        unsigned int val)
1869 {
1870         int ret;
1871         struct regmap_range_node *range;
1872         struct regmap *map = context;
1873
1874         WARN_ON(!map->format.format_write);
1875
1876         range = _regmap_range_lookup(map, reg);
1877         if (range) {
1878                 ret = _regmap_select_page(map, &reg, range, 1);
1879                 if (ret != 0)
1880                         return ret;
1881         }
1882
1883         map->format.format_write(map, reg, val);
1884
1885         trace_regmap_hw_write_start(map, reg, 1);
1886
1887         ret = map->write(map->bus_context, map->work_buf, map->format.buf_size);
1888
1889         trace_regmap_hw_write_done(map, reg, 1);
1890
1891         return ret;
1892 }
1893
1894 static int _regmap_bus_reg_write(void *context, unsigned int reg,
1895                                  unsigned int val)
1896 {
1897         struct regmap *map = context;
1898
1899         return map->bus->reg_write(map->bus_context, reg, val);
1900 }
1901
1902 static int _regmap_bus_raw_write(void *context, unsigned int reg,
1903                                  unsigned int val)
1904 {
1905         struct regmap *map = context;
1906
1907         WARN_ON(!map->format.format_val);
1908
1909         map->format.format_val(map->work_buf + map->format.reg_bytes
1910                                + map->format.pad_bytes, val, 0);
1911         return _regmap_raw_write_impl(map, reg,
1912                                       map->work_buf +
1913                                       map->format.reg_bytes +
1914                                       map->format.pad_bytes,
1915                                       map->format.val_bytes,
1916                                       false);
1917 }
1918
1919 static inline void *_regmap_map_get_context(struct regmap *map)
1920 {
1921         return (map->bus || (!map->bus && map->read)) ? map : map->bus_context;
1922 }
1923
1924 int _regmap_write(struct regmap *map, unsigned int reg,
1925                   unsigned int val)
1926 {
1927         int ret;
1928         void *context = _regmap_map_get_context(map);
1929
1930         if (!regmap_writeable(map, reg))
1931                 return -EIO;
1932
1933         if (!map->cache_bypass && !map->defer_caching) {
1934                 ret = regcache_write(map, reg, val);
1935                 if (ret != 0)
1936                         return ret;
1937                 if (map->cache_only) {
1938                         map->cache_dirty = true;
1939                         return 0;
1940                 }
1941         }
1942
1943         if (regmap_should_log(map))
1944                 dev_info(map->dev, "%x <= %x\n", reg, val);
1945
1946         trace_regmap_reg_write(map, reg, val);
1947
1948         return map->reg_write(context, reg, val);
1949 }
1950
1951 /**
1952  * regmap_write() - Write a value to a single register
1953  *
1954  * @map: Register map to write to
1955  * @reg: Register to write to
1956  * @val: Value to be written
1957  *
1958  * A value of zero will be returned on success, a negative errno will
1959  * be returned in error cases.
1960  */
1961 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1962 {
1963         int ret;
1964
1965         if (!IS_ALIGNED(reg, map->reg_stride))
1966                 return -EINVAL;
1967
1968         map->lock(map->lock_arg);
1969
1970         ret = _regmap_write(map, reg, val);
1971
1972         map->unlock(map->lock_arg);
1973
1974         return ret;
1975 }
1976 EXPORT_SYMBOL_GPL(regmap_write);
1977
1978 /**
1979  * regmap_write_async() - Write a value to a single register asynchronously
1980  *
1981  * @map: Register map to write to
1982  * @reg: Register to write to
1983  * @val: Value to be written
1984  *
1985  * A value of zero will be returned on success, a negative errno will
1986  * be returned in error cases.
1987  */
1988 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val)
1989 {
1990         int ret;
1991
1992         if (!IS_ALIGNED(reg, map->reg_stride))
1993                 return -EINVAL;
1994
1995         map->lock(map->lock_arg);
1996
1997         map->async = true;
1998
1999         ret = _regmap_write(map, reg, val);
2000
2001         map->async = false;
2002
2003         map->unlock(map->lock_arg);
2004
2005         return ret;
2006 }
2007 EXPORT_SYMBOL_GPL(regmap_write_async);
2008
2009 int _regmap_raw_write(struct regmap *map, unsigned int reg,
2010                       const void *val, size_t val_len, bool noinc)
2011 {
2012         size_t val_bytes = map->format.val_bytes;
2013         size_t val_count = val_len / val_bytes;
2014         size_t chunk_count, chunk_bytes;
2015         size_t chunk_regs = val_count;
2016         int ret, i;
2017
2018         if (!val_count)
2019                 return -EINVAL;
2020
2021         if (map->use_single_write)
2022                 chunk_regs = 1;
2023         else if (map->max_raw_write && val_len > map->max_raw_write)
2024                 chunk_regs = map->max_raw_write / val_bytes;
2025
2026         chunk_count = val_count / chunk_regs;
2027         chunk_bytes = chunk_regs * val_bytes;
2028
2029         /* Write as many bytes as possible with chunk_size */
2030         for (i = 0; i < chunk_count; i++) {
2031                 ret = _regmap_raw_write_impl(map, reg, val, chunk_bytes, noinc);
2032                 if (ret)
2033                         return ret;
2034
2035                 reg += regmap_get_offset(map, chunk_regs);
2036                 val += chunk_bytes;
2037                 val_len -= chunk_bytes;
2038         }
2039
2040         /* Write remaining bytes */
2041         if (val_len)
2042                 ret = _regmap_raw_write_impl(map, reg, val, val_len, noinc);
2043
2044         return ret;
2045 }
2046
2047 /**
2048  * regmap_raw_write() - Write raw values to one or more registers
2049  *
2050  * @map: Register map to write to
2051  * @reg: Initial register to write to
2052  * @val: Block of data to be written, laid out for direct transmission to the
2053  *       device
2054  * @val_len: Length of data pointed to by val.
2055  *
2056  * This function is intended to be used for things like firmware
2057  * download where a large block of data needs to be transferred to the
2058  * device.  No formatting will be done on the data provided.
2059  *
2060  * A value of zero will be returned on success, a negative errno will
2061  * be returned in error cases.
2062  */
2063 int regmap_raw_write(struct regmap *map, unsigned int reg,
2064                      const void *val, size_t val_len)
2065 {
2066         int ret;
2067
2068         if (!regmap_can_raw_write(map))
2069                 return -EINVAL;
2070         if (val_len % map->format.val_bytes)
2071                 return -EINVAL;
2072
2073         map->lock(map->lock_arg);
2074
2075         ret = _regmap_raw_write(map, reg, val, val_len, false);
2076
2077         map->unlock(map->lock_arg);
2078
2079         return ret;
2080 }
2081 EXPORT_SYMBOL_GPL(regmap_raw_write);
2082
2083 /**
2084  * regmap_noinc_write(): Write data from a register without incrementing the
2085  *                      register number
2086  *
2087  * @map: Register map to write to
2088  * @reg: Register to write to
2089  * @val: Pointer to data buffer
2090  * @val_len: Length of output buffer in bytes.
2091  *
2092  * The regmap API usually assumes that bulk bus write operations will write a
2093  * range of registers. Some devices have certain registers for which a write
2094  * operation can write to an internal FIFO.
2095  *
2096  * The target register must be volatile but registers after it can be
2097  * completely unrelated cacheable registers.
2098  *
2099  * This will attempt multiple writes as required to write val_len bytes.
2100  *
2101  * A value of zero will be returned on success, a negative errno will be
2102  * returned in error cases.
2103  */
2104 int regmap_noinc_write(struct regmap *map, unsigned int reg,
2105                       const void *val, size_t val_len)
2106 {
2107         size_t write_len;
2108         int ret;
2109
2110         if (!map->bus)
2111                 return -EINVAL;
2112         if (!map->bus->write)
2113                 return -ENOTSUPP;
2114         if (val_len % map->format.val_bytes)
2115                 return -EINVAL;
2116         if (!IS_ALIGNED(reg, map->reg_stride))
2117                 return -EINVAL;
2118         if (val_len == 0)
2119                 return -EINVAL;
2120
2121         map->lock(map->lock_arg);
2122
2123         if (!regmap_volatile(map, reg) || !regmap_writeable_noinc(map, reg)) {
2124                 ret = -EINVAL;
2125                 goto out_unlock;
2126         }
2127
2128         while (val_len) {
2129                 if (map->max_raw_write && map->max_raw_write < val_len)
2130                         write_len = map->max_raw_write;
2131                 else
2132                         write_len = val_len;
2133                 ret = _regmap_raw_write(map, reg, val, write_len, true);
2134                 if (ret)
2135                         goto out_unlock;
2136                 val = ((u8 *)val) + write_len;
2137                 val_len -= write_len;
2138         }
2139
2140 out_unlock:
2141         map->unlock(map->lock_arg);
2142         return ret;
2143 }
2144 EXPORT_SYMBOL_GPL(regmap_noinc_write);
2145
2146 /**
2147  * regmap_field_update_bits_base() - Perform a read/modify/write cycle a
2148  *                                   register field.
2149  *
2150  * @field: Register field to write to
2151  * @mask: Bitmask to change
2152  * @val: Value to be written
2153  * @change: Boolean indicating if a write was done
2154  * @async: Boolean indicating asynchronously
2155  * @force: Boolean indicating use force update
2156  *
2157  * Perform a read/modify/write cycle on the register field with change,
2158  * async, force option.
2159  *
2160  * A value of zero will be returned on success, a negative errno will
2161  * be returned in error cases.
2162  */
2163 int regmap_field_update_bits_base(struct regmap_field *field,
2164                                   unsigned int mask, unsigned int val,
2165                                   bool *change, bool async, bool force)
2166 {
2167         mask = (mask << field->shift) & field->mask;
2168
2169         return regmap_update_bits_base(field->regmap, field->reg,
2170                                        mask, val << field->shift,
2171                                        change, async, force);
2172 }
2173 EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);
2174
2175 /**
2176  * regmap_fields_update_bits_base() - Perform a read/modify/write cycle a
2177  *                                    register field with port ID
2178  *
2179  * @field: Register field to write to
2180  * @id: port ID
2181  * @mask: Bitmask to change
2182  * @val: Value to be written
2183  * @change: Boolean indicating if a write was done
2184  * @async: Boolean indicating asynchronously
2185  * @force: Boolean indicating use force update
2186  *
2187  * A value of zero will be returned on success, a negative errno will
2188  * be returned in error cases.
2189  */
2190 int regmap_fields_update_bits_base(struct regmap_field *field, unsigned int id,
2191                                    unsigned int mask, unsigned int val,
2192                                    bool *change, bool async, bool force)
2193 {
2194         if (id >= field->id_size)
2195                 return -EINVAL;
2196
2197         mask = (mask << field->shift) & field->mask;
2198
2199         return regmap_update_bits_base(field->regmap,
2200                                        field->reg + (field->id_offset * id),
2201                                        mask, val << field->shift,
2202                                        change, async, force);
2203 }
2204 EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);
2205
2206 /**
2207  * regmap_bulk_write() - Write multiple registers to the device
2208  *
2209  * @map: Register map to write to
2210  * @reg: First register to be write from
2211  * @val: Block of data to be written, in native register size for device
2212  * @val_count: Number of registers to write
2213  *
2214  * This function is intended to be used for writing a large block of
2215  * data to the device either in single transfer or multiple transfer.
2216  *
2217  * A value of zero will be returned on success, a negative errno will
2218  * be returned in error cases.
2219  */
2220 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
2221                      size_t val_count)
2222 {
2223         int ret = 0, i;
2224         size_t val_bytes = map->format.val_bytes;
2225
2226         if (!IS_ALIGNED(reg, map->reg_stride))
2227                 return -EINVAL;
2228
2229         /*
2230          * Some devices don't support bulk write, for them we have a series of
2231          * single write operations.
2232          */
2233         if (!map->bus || !map->format.parse_inplace) {
2234                 map->lock(map->lock_arg);
2235                 for (i = 0; i < val_count; i++) {
2236                         unsigned int ival;
2237
2238                         switch (val_bytes) {
2239                         case 1:
2240                                 ival = *(u8 *)(val + (i * val_bytes));
2241                                 break;
2242                         case 2:
2243                                 ival = *(u16 *)(val + (i * val_bytes));
2244                                 break;
2245                         case 4:
2246                                 ival = *(u32 *)(val + (i * val_bytes));
2247                                 break;
2248 #ifdef CONFIG_64BIT
2249                         case 8:
2250                                 ival = *(u64 *)(val + (i * val_bytes));
2251                                 break;
2252 #endif
2253                         default:
2254                                 ret = -EINVAL;
2255                                 goto out;
2256                         }
2257
2258                         ret = _regmap_write(map,
2259                                             reg + regmap_get_offset(map, i),
2260                                             ival);
2261                         if (ret != 0)
2262                                 goto out;
2263                 }
2264 out:
2265                 map->unlock(map->lock_arg);
2266         } else {
2267                 void *wval;
2268
2269                 wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
2270                 if (!wval)
2271                         return -ENOMEM;
2272
2273                 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2274                         map->format.parse_inplace(wval + i);
2275
2276                 ret = regmap_raw_write(map, reg, wval, val_bytes * val_count);
2277
2278                 kfree(wval);
2279         }
2280         return ret;
2281 }
2282 EXPORT_SYMBOL_GPL(regmap_bulk_write);
2283
2284 /*
2285  * _regmap_raw_multi_reg_write()
2286  *
2287  * the (register,newvalue) pairs in regs have not been formatted, but
2288  * they are all in the same page and have been changed to being page
2289  * relative. The page register has been written if that was necessary.
2290  */
2291 static int _regmap_raw_multi_reg_write(struct regmap *map,
2292                                        const struct reg_sequence *regs,
2293                                        size_t num_regs)
2294 {
2295         int ret;
2296         void *buf;
2297         int i;
2298         u8 *u8;
2299         size_t val_bytes = map->format.val_bytes;
2300         size_t reg_bytes = map->format.reg_bytes;
2301         size_t pad_bytes = map->format.pad_bytes;
2302         size_t pair_size = reg_bytes + pad_bytes + val_bytes;
2303         size_t len = pair_size * num_regs;
2304
2305         if (!len)
2306                 return -EINVAL;
2307
2308         buf = kzalloc(len, GFP_KERNEL);
2309         if (!buf)
2310                 return -ENOMEM;
2311
2312         /* We have to linearise by hand. */
2313
2314         u8 = buf;
2315
2316         for (i = 0; i < num_regs; i++) {
2317                 unsigned int reg = regs[i].reg;
2318                 unsigned int val = regs[i].def;
2319                 trace_regmap_hw_write_start(map, reg, 1);
2320                 map->format.format_reg(u8, reg, map->reg_shift);
2321                 u8 += reg_bytes + pad_bytes;
2322                 map->format.format_val(u8, val, 0);
2323                 u8 += val_bytes;
2324         }
2325         u8 = buf;
2326         *u8 |= map->write_flag_mask;
2327
2328         ret = map->write(map->bus_context, buf, len);
2329
2330         kfree(buf);
2331
2332         for (i = 0; i < num_regs; i++) {
2333                 int reg = regs[i].reg;
2334                 trace_regmap_hw_write_done(map, reg, 1);
2335         }
2336         return ret;
2337 }
2338
2339 static unsigned int _regmap_register_page(struct regmap *map,
2340                                           unsigned int reg,
2341                                           struct regmap_range_node *range)
2342 {
2343         unsigned int win_page = (reg - range->range_min) / range->window_len;
2344
2345         return win_page;
2346 }
2347
2348 static int _regmap_range_multi_paged_reg_write(struct regmap *map,
2349                                                struct reg_sequence *regs,
2350                                                size_t num_regs)
2351 {
2352         int ret;
2353         int i, n;
2354         struct reg_sequence *base;
2355         unsigned int this_page = 0;
2356         unsigned int page_change = 0;
2357         /*
2358          * the set of registers are not neccessarily in order, but
2359          * since the order of write must be preserved this algorithm
2360          * chops the set each time the page changes. This also applies
2361          * if there is a delay required at any point in the sequence.
2362          */
2363         base = regs;
2364         for (i = 0, n = 0; i < num_regs; i++, n++) {
2365                 unsigned int reg = regs[i].reg;
2366                 struct regmap_range_node *range;
2367
2368                 range = _regmap_range_lookup(map, reg);
2369                 if (range) {
2370                         unsigned int win_page = _regmap_register_page(map, reg,
2371                                                                       range);
2372
2373                         if (i == 0)
2374                                 this_page = win_page;
2375                         if (win_page != this_page) {
2376                                 this_page = win_page;
2377                                 page_change = 1;
2378                         }
2379                 }
2380
2381                 /* If we have both a page change and a delay make sure to
2382                  * write the regs and apply the delay before we change the
2383                  * page.
2384                  */
2385
2386                 if (page_change || regs[i].delay_us) {
2387
2388                                 /* For situations where the first write requires
2389                                  * a delay we need to make sure we don't call
2390                                  * raw_multi_reg_write with n=0
2391                                  * This can't occur with page breaks as we
2392                                  * never write on the first iteration
2393                                  */
2394                                 if (regs[i].delay_us && i == 0)
2395                                         n = 1;
2396
2397                                 ret = _regmap_raw_multi_reg_write(map, base, n);
2398                                 if (ret != 0)
2399                                         return ret;
2400
2401                                 if (regs[i].delay_us) {
2402                                         if (map->can_sleep)
2403                                                 fsleep(regs[i].delay_us);
2404                                         else
2405                                                 udelay(regs[i].delay_us);
2406                                 }
2407
2408                                 base += n;
2409                                 n = 0;
2410
2411                                 if (page_change) {
2412                                         ret = _regmap_select_page(map,
2413                                                                   &base[n].reg,
2414                                                                   range, 1);
2415                                         if (ret != 0)
2416                                                 return ret;
2417
2418                                         page_change = 0;
2419                                 }
2420
2421                 }
2422
2423         }
2424         if (n > 0)
2425                 return _regmap_raw_multi_reg_write(map, base, n);
2426         return 0;
2427 }
2428
2429 static int _regmap_multi_reg_write(struct regmap *map,
2430                                    const struct reg_sequence *regs,
2431                                    size_t num_regs)
2432 {
2433         int i;
2434         int ret;
2435
2436         if (!map->can_multi_write) {
2437                 for (i = 0; i < num_regs; i++) {
2438                         ret = _regmap_write(map, regs[i].reg, regs[i].def);
2439                         if (ret != 0)
2440                                 return ret;
2441
2442                         if (regs[i].delay_us) {
2443                                 if (map->can_sleep)
2444                                         fsleep(regs[i].delay_us);
2445                                 else
2446                                         udelay(regs[i].delay_us);
2447                         }
2448                 }
2449                 return 0;
2450         }
2451
2452         if (!map->format.parse_inplace)
2453                 return -EINVAL;
2454
2455         if (map->writeable_reg)
2456                 for (i = 0; i < num_regs; i++) {
2457                         int reg = regs[i].reg;
2458                         if (!map->writeable_reg(map->dev, reg))
2459                                 return -EINVAL;
2460                         if (!IS_ALIGNED(reg, map->reg_stride))
2461                                 return -EINVAL;
2462                 }
2463
2464         if (!map->cache_bypass) {
2465                 for (i = 0; i < num_regs; i++) {
2466                         unsigned int val = regs[i].def;
2467                         unsigned int reg = regs[i].reg;
2468                         ret = regcache_write(map, reg, val);
2469                         if (ret) {
2470                                 dev_err(map->dev,
2471                                 "Error in caching of register: %x ret: %d\n",
2472                                                                 reg, ret);
2473                                 return ret;
2474                         }
2475                 }
2476                 if (map->cache_only) {
2477                         map->cache_dirty = true;
2478                         return 0;
2479                 }
2480         }
2481
2482         WARN_ON(!map->bus);
2483
2484         for (i = 0; i < num_regs; i++) {
2485                 unsigned int reg = regs[i].reg;
2486                 struct regmap_range_node *range;
2487
2488                 /* Coalesce all the writes between a page break or a delay
2489                  * in a sequence
2490                  */
2491                 range = _regmap_range_lookup(map, reg);
2492                 if (range || regs[i].delay_us) {
2493                         size_t len = sizeof(struct reg_sequence)*num_regs;
2494                         struct reg_sequence *base = kmemdup(regs, len,
2495                                                            GFP_KERNEL);
2496                         if (!base)
2497                                 return -ENOMEM;
2498                         ret = _regmap_range_multi_paged_reg_write(map, base,
2499                                                                   num_regs);
2500                         kfree(base);
2501
2502                         return ret;
2503                 }
2504         }
2505         return _regmap_raw_multi_reg_write(map, regs, num_regs);
2506 }
2507
2508 /**
2509  * regmap_multi_reg_write() - Write multiple registers to the device
2510  *
2511  * @map: Register map to write to
2512  * @regs: Array of structures containing register,value to be written
2513  * @num_regs: Number of registers to write
2514  *
2515  * Write multiple registers to the device where the set of register, value
2516  * pairs are supplied in any order, possibly not all in a single range.
2517  *
2518  * The 'normal' block write mode will send ultimately send data on the
2519  * target bus as R,V1,V2,V3,..,Vn where successively higher registers are
2520  * addressed. However, this alternative block multi write mode will send
2521  * the data as R1,V1,R2,V2,..,Rn,Vn on the target bus. The target device
2522  * must of course support the mode.
2523  *
2524  * A value of zero will be returned on success, a negative errno will be
2525  * returned in error cases.
2526  */
2527 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
2528                            int num_regs)
2529 {
2530         int ret;
2531
2532         map->lock(map->lock_arg);
2533
2534         ret = _regmap_multi_reg_write(map, regs, num_regs);
2535
2536         map->unlock(map->lock_arg);
2537
2538         return ret;
2539 }
2540 EXPORT_SYMBOL_GPL(regmap_multi_reg_write);
2541
2542 /**
2543  * regmap_multi_reg_write_bypassed() - Write multiple registers to the
2544  *                                     device but not the cache
2545  *
2546  * @map: Register map to write to
2547  * @regs: Array of structures containing register,value to be written
2548  * @num_regs: Number of registers to write
2549  *
2550  * Write multiple registers to the device but not the cache where the set
2551  * of register are supplied in any order.
2552  *
2553  * This function is intended to be used for writing a large block of data
2554  * atomically to the device in single transfer for those I2C client devices
2555  * that implement this alternative block write mode.
2556  *
2557  * A value of zero will be returned on success, a negative errno will
2558  * be returned in error cases.
2559  */
2560 int regmap_multi_reg_write_bypassed(struct regmap *map,
2561                                     const struct reg_sequence *regs,
2562                                     int num_regs)
2563 {
2564         int ret;
2565         bool bypass;
2566
2567         map->lock(map->lock_arg);
2568
2569         bypass = map->cache_bypass;
2570         map->cache_bypass = true;
2571
2572         ret = _regmap_multi_reg_write(map, regs, num_regs);
2573
2574         map->cache_bypass = bypass;
2575
2576         map->unlock(map->lock_arg);
2577
2578         return ret;
2579 }
2580 EXPORT_SYMBOL_GPL(regmap_multi_reg_write_bypassed);
2581
2582 /**
2583  * regmap_raw_write_async() - Write raw values to one or more registers
2584  *                            asynchronously
2585  *
2586  * @map: Register map to write to
2587  * @reg: Initial register to write to
2588  * @val: Block of data to be written, laid out for direct transmission to the
2589  *       device.  Must be valid until regmap_async_complete() is called.
2590  * @val_len: Length of data pointed to by val.
2591  *
2592  * This function is intended to be used for things like firmware
2593  * download where a large block of data needs to be transferred to the
2594  * device.  No formatting will be done on the data provided.
2595  *
2596  * If supported by the underlying bus the write will be scheduled
2597  * asynchronously, helping maximise I/O speed on higher speed buses
2598  * like SPI.  regmap_async_complete() can be called to ensure that all
2599  * asynchrnous writes have been completed.
2600  *
2601  * A value of zero will be returned on success, a negative errno will
2602  * be returned in error cases.
2603  */
2604 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
2605                            const void *val, size_t val_len)
2606 {
2607         int ret;
2608
2609         if (val_len % map->format.val_bytes)
2610                 return -EINVAL;
2611         if (!IS_ALIGNED(reg, map->reg_stride))
2612                 return -EINVAL;
2613
2614         map->lock(map->lock_arg);
2615
2616         map->async = true;
2617
2618         ret = _regmap_raw_write(map, reg, val, val_len, false);
2619
2620         map->async = false;
2621
2622         map->unlock(map->lock_arg);
2623
2624         return ret;
2625 }
2626 EXPORT_SYMBOL_GPL(regmap_raw_write_async);
2627
2628 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2629                             unsigned int val_len, bool noinc)
2630 {
2631         struct regmap_range_node *range;
2632         int ret;
2633
2634         if (!map->read)
2635                 return -EINVAL;
2636
2637         range = _regmap_range_lookup(map, reg);
2638         if (range) {
2639                 ret = _regmap_select_page(map, &reg, range,
2640                                           noinc ? 1 : val_len / map->format.val_bytes);
2641                 if (ret != 0)
2642                         return ret;
2643         }
2644
2645         map->format.format_reg(map->work_buf, reg, map->reg_shift);
2646         regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
2647                                       map->read_flag_mask);
2648         trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
2649
2650         ret = map->read(map->bus_context, map->work_buf,
2651                         map->format.reg_bytes + map->format.pad_bytes,
2652                         val, val_len);
2653
2654         trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
2655
2656         return ret;
2657 }
2658
2659 static int _regmap_bus_reg_read(void *context, unsigned int reg,
2660                                 unsigned int *val)
2661 {
2662         struct regmap *map = context;
2663
2664         return map->bus->reg_read(map->bus_context, reg, val);
2665 }
2666
2667 static int _regmap_bus_read(void *context, unsigned int reg,
2668                             unsigned int *val)
2669 {
2670         int ret;
2671         struct regmap *map = context;
2672         void *work_val = map->work_buf + map->format.reg_bytes +
2673                 map->format.pad_bytes;
2674
2675         if (!map->format.parse_val)
2676                 return -EINVAL;
2677
2678         ret = _regmap_raw_read(map, reg, work_val, map->format.val_bytes, false);
2679         if (ret == 0)
2680                 *val = map->format.parse_val(work_val);
2681
2682         return ret;
2683 }
2684
2685 static int _regmap_read(struct regmap *map, unsigned int reg,
2686                         unsigned int *val)
2687 {
2688         int ret;
2689         void *context = _regmap_map_get_context(map);
2690
2691         if (!map->cache_bypass) {
2692                 ret = regcache_read(map, reg, val);
2693                 if (ret == 0)
2694                         return 0;
2695         }
2696
2697         if (map->cache_only)
2698                 return -EBUSY;
2699
2700         if (!regmap_readable(map, reg))
2701                 return -EIO;
2702
2703         ret = map->reg_read(context, reg, val);
2704         if (ret == 0) {
2705                 if (regmap_should_log(map))
2706                         dev_info(map->dev, "%x => %x\n", reg, *val);
2707
2708                 trace_regmap_reg_read(map, reg, *val);
2709
2710                 if (!map->cache_bypass)
2711                         regcache_write(map, reg, *val);
2712         }
2713
2714         return ret;
2715 }
2716
2717 /**
2718  * regmap_read() - Read a value from a single register
2719  *
2720  * @map: Register map to read from
2721  * @reg: Register to be read from
2722  * @val: Pointer to store read value
2723  *
2724  * A value of zero will be returned on success, a negative errno will
2725  * be returned in error cases.
2726  */
2727 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
2728 {
2729         int ret;
2730
2731         if (!IS_ALIGNED(reg, map->reg_stride))
2732                 return -EINVAL;
2733
2734         map->lock(map->lock_arg);
2735
2736         ret = _regmap_read(map, reg, val);
2737
2738         map->unlock(map->lock_arg);
2739
2740         return ret;
2741 }
2742 EXPORT_SYMBOL_GPL(regmap_read);
2743
2744 /**
2745  * regmap_raw_read() - Read raw data from the device
2746  *
2747  * @map: Register map to read from
2748  * @reg: First register to be read from
2749  * @val: Pointer to store read value
2750  * @val_len: Size of data to read
2751  *
2752  * A value of zero will be returned on success, a negative errno will
2753  * be returned in error cases.
2754  */
2755 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2756                     size_t val_len)
2757 {
2758         size_t val_bytes = map->format.val_bytes;
2759         size_t val_count = val_len / val_bytes;
2760         unsigned int v;
2761         int ret, i;
2762
2763         if (val_len % map->format.val_bytes)
2764                 return -EINVAL;
2765         if (!IS_ALIGNED(reg, map->reg_stride))
2766                 return -EINVAL;
2767         if (val_count == 0)
2768                 return -EINVAL;
2769
2770         map->lock(map->lock_arg);
2771
2772         if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
2773             map->cache_type == REGCACHE_NONE) {
2774                 size_t chunk_count, chunk_bytes;
2775                 size_t chunk_regs = val_count;
2776
2777                 if (!map->read) {
2778                         ret = -ENOTSUPP;
2779                         goto out;
2780                 }
2781
2782                 if (map->use_single_read)
2783                         chunk_regs = 1;
2784                 else if (map->max_raw_read && val_len > map->max_raw_read)
2785                         chunk_regs = map->max_raw_read / val_bytes;
2786
2787                 chunk_count = val_count / chunk_regs;
2788                 chunk_bytes = chunk_regs * val_bytes;
2789
2790                 /* Read bytes that fit into whole chunks */
2791                 for (i = 0; i < chunk_count; i++) {
2792                         ret = _regmap_raw_read(map, reg, val, chunk_bytes, false);
2793                         if (ret != 0)
2794                                 goto out;
2795
2796                         reg += regmap_get_offset(map, chunk_regs);
2797                         val += chunk_bytes;
2798                         val_len -= chunk_bytes;
2799                 }
2800
2801                 /* Read remaining bytes */
2802                 if (val_len) {
2803                         ret = _regmap_raw_read(map, reg, val, val_len, false);
2804                         if (ret != 0)
2805                                 goto out;
2806                 }
2807         } else {
2808                 /* Otherwise go word by word for the cache; should be low
2809                  * cost as we expect to hit the cache.
2810                  */
2811                 for (i = 0; i < val_count; i++) {
2812                         ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2813                                            &v);
2814                         if (ret != 0)
2815                                 goto out;
2816
2817                         map->format.format_val(val + (i * val_bytes), v, 0);
2818                 }
2819         }
2820
2821  out:
2822         map->unlock(map->lock_arg);
2823
2824         return ret;
2825 }
2826 EXPORT_SYMBOL_GPL(regmap_raw_read);
2827
2828 /**
2829  * regmap_noinc_read(): Read data from a register without incrementing the
2830  *                      register number
2831  *
2832  * @map: Register map to read from
2833  * @reg: Register to read from
2834  * @val: Pointer to data buffer
2835  * @val_len: Length of output buffer in bytes.
2836  *
2837  * The regmap API usually assumes that bulk read operations will read a
2838  * range of registers. Some devices have certain registers for which a read
2839  * operation read will read from an internal FIFO.
2840  *
2841  * The target register must be volatile but registers after it can be
2842  * completely unrelated cacheable registers.
2843  *
2844  * This will attempt multiple reads as required to read val_len bytes.
2845  *
2846  * A value of zero will be returned on success, a negative errno will be
2847  * returned in error cases.
2848  */
2849 int regmap_noinc_read(struct regmap *map, unsigned int reg,
2850                       void *val, size_t val_len)
2851 {
2852         size_t read_len;
2853         int ret;
2854
2855         if (val_len % map->format.val_bytes)
2856                 return -EINVAL;
2857         if (!IS_ALIGNED(reg, map->reg_stride))
2858                 return -EINVAL;
2859         if (val_len == 0)
2860                 return -EINVAL;
2861
2862         map->lock(map->lock_arg);
2863
2864         if (!regmap_volatile(map, reg) || !regmap_readable_noinc(map, reg)) {
2865                 ret = -EINVAL;
2866                 goto out_unlock;
2867         }
2868
2869         while (val_len) {
2870                 if (map->max_raw_read && map->max_raw_read < val_len)
2871                         read_len = map->max_raw_read;
2872                 else
2873                         read_len = val_len;
2874                 ret = _regmap_raw_read(map, reg, val, read_len, true);
2875                 if (ret)
2876                         goto out_unlock;
2877                 val = ((u8 *)val) + read_len;
2878                 val_len -= read_len;
2879         }
2880
2881 out_unlock:
2882         map->unlock(map->lock_arg);
2883         return ret;
2884 }
2885 EXPORT_SYMBOL_GPL(regmap_noinc_read);
2886
2887 /**
2888  * regmap_field_read(): Read a value to a single register field
2889  *
2890  * @field: Register field to read from
2891  * @val: Pointer to store read value
2892  *
2893  * A value of zero will be returned on success, a negative errno will
2894  * be returned in error cases.
2895  */
2896 int regmap_field_read(struct regmap_field *field, unsigned int *val)
2897 {
2898         int ret;
2899         unsigned int reg_val;
2900         ret = regmap_read(field->regmap, field->reg, &reg_val);
2901         if (ret != 0)
2902                 return ret;
2903
2904         reg_val &= field->mask;
2905         reg_val >>= field->shift;
2906         *val = reg_val;
2907
2908         return ret;
2909 }
2910 EXPORT_SYMBOL_GPL(regmap_field_read);
2911
2912 /**
2913  * regmap_fields_read() - Read a value to a single register field with port ID
2914  *
2915  * @field: Register field to read from
2916  * @id: port ID
2917  * @val: Pointer to store read value
2918  *
2919  * A value of zero will be returned on success, a negative errno will
2920  * be returned in error cases.
2921  */
2922 int regmap_fields_read(struct regmap_field *field, unsigned int id,
2923                        unsigned int *val)
2924 {
2925         int ret;
2926         unsigned int reg_val;
2927
2928         if (id >= field->id_size)
2929                 return -EINVAL;
2930
2931         ret = regmap_read(field->regmap,
2932                           field->reg + (field->id_offset * id),
2933                           &reg_val);
2934         if (ret != 0)
2935                 return ret;
2936
2937         reg_val &= field->mask;
2938         reg_val >>= field->shift;
2939         *val = reg_val;
2940
2941         return ret;
2942 }
2943 EXPORT_SYMBOL_GPL(regmap_fields_read);
2944
2945 /**
2946  * regmap_bulk_read() - Read multiple registers from the device
2947  *
2948  * @map: Register map to read from
2949  * @reg: First register to be read from
2950  * @val: Pointer to store read value, in native register size for device
2951  * @val_count: Number of registers to read
2952  *
2953  * A value of zero will be returned on success, a negative errno will
2954  * be returned in error cases.
2955  */
2956 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
2957                      size_t val_count)
2958 {
2959         int ret, i;
2960         size_t val_bytes = map->format.val_bytes;
2961         bool vol = regmap_volatile_range(map, reg, val_count);
2962
2963         if (!IS_ALIGNED(reg, map->reg_stride))
2964                 return -EINVAL;
2965         if (val_count == 0)
2966                 return -EINVAL;
2967
2968         if (map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
2969                 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
2970                 if (ret != 0)
2971                         return ret;
2972
2973                 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2974                         map->format.parse_inplace(val + i);
2975         } else {
2976 #ifdef CONFIG_64BIT
2977                 u64 *u64 = val;
2978 #endif
2979                 u32 *u32 = val;
2980                 u16 *u16 = val;
2981                 u8 *u8 = val;
2982
2983                 map->lock(map->lock_arg);
2984
2985                 for (i = 0; i < val_count; i++) {
2986                         unsigned int ival;
2987
2988                         ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2989                                            &ival);
2990                         if (ret != 0)
2991                                 goto out;
2992
2993                         switch (map->format.val_bytes) {
2994 #ifdef CONFIG_64BIT
2995                         case 8:
2996                                 u64[i] = ival;
2997                                 break;
2998 #endif
2999                         case 4:
3000                                 u32[i] = ival;
3001                                 break;
3002                         case 2:
3003                                 u16[i] = ival;
3004                                 break;
3005                         case 1:
3006                                 u8[i] = ival;
3007                                 break;
3008                         default:
3009                                 ret = -EINVAL;
3010                                 goto out;
3011                         }
3012                 }
3013
3014 out:
3015                 map->unlock(map->lock_arg);
3016         }
3017
3018         return ret;
3019 }
3020 EXPORT_SYMBOL_GPL(regmap_bulk_read);
3021
3022 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
3023                                unsigned int mask, unsigned int val,
3024                                bool *change, bool force_write)
3025 {
3026         int ret;
3027         unsigned int tmp, orig;
3028
3029         if (change)
3030                 *change = false;
3031
3032         if (regmap_volatile(map, reg) && map->reg_update_bits) {
3033                 ret = map->reg_update_bits(map->bus_context, reg, mask, val);
3034                 if (ret == 0 && change)
3035                         *change = true;
3036         } else {
3037                 ret = _regmap_read(map, reg, &orig);
3038                 if (ret != 0)
3039                         return ret;
3040
3041                 tmp = orig & ~mask;
3042                 tmp |= val & mask;
3043
3044                 if (force_write || (tmp != orig)) {
3045                         ret = _regmap_write(map, reg, tmp);
3046                         if (ret == 0 && change)
3047                                 *change = true;
3048                 }
3049         }
3050
3051         return ret;
3052 }
3053
3054 /**
3055  * regmap_update_bits_base() - Perform a read/modify/write cycle on a register
3056  *
3057  * @map: Register map to update
3058  * @reg: Register to update
3059  * @mask: Bitmask to change
3060  * @val: New value for bitmask
3061  * @change: Boolean indicating if a write was done
3062  * @async: Boolean indicating asynchronously
3063  * @force: Boolean indicating use force update
3064  *
3065  * Perform a read/modify/write cycle on a register map with change, async, force
3066  * options.
3067  *
3068  * If async is true:
3069  *
3070  * With most buses the read must be done synchronously so this is most useful
3071  * for devices with a cache which do not need to interact with the hardware to
3072  * determine the current register value.
3073  *
3074  * Returns zero for success, a negative number on error.
3075  */
3076 int regmap_update_bits_base(struct regmap *map, unsigned int reg,
3077                             unsigned int mask, unsigned int val,
3078                             bool *change, bool async, bool force)
3079 {
3080         int ret;
3081
3082         map->lock(map->lock_arg);
3083
3084         map->async = async;
3085
3086         ret = _regmap_update_bits(map, reg, mask, val, change, force);
3087
3088         map->async = false;
3089
3090         map->unlock(map->lock_arg);
3091
3092         return ret;
3093 }
3094 EXPORT_SYMBOL_GPL(regmap_update_bits_base);
3095
3096 /**
3097  * regmap_test_bits() - Check if all specified bits are set in a register.
3098  *
3099  * @map: Register map to operate on
3100  * @reg: Register to read from
3101  * @bits: Bits to test
3102  *
3103  * Returns 0 if at least one of the tested bits is not set, 1 if all tested
3104  * bits are set and a negative error number if the underlying regmap_read()
3105  * fails.
3106  */
3107 int regmap_test_bits(struct regmap *map, unsigned int reg, unsigned int bits)
3108 {
3109         unsigned int val, ret;
3110
3111         ret = regmap_read(map, reg, &val);
3112         if (ret)
3113                 return ret;
3114
3115         return (val & bits) == bits;
3116 }
3117 EXPORT_SYMBOL_GPL(regmap_test_bits);
3118
3119 void regmap_async_complete_cb(struct regmap_async *async, int ret)
3120 {
3121         struct regmap *map = async->map;
3122         bool wake;
3123
3124         trace_regmap_async_io_complete(map);
3125
3126         spin_lock(&map->async_lock);
3127         list_move(&async->list, &map->async_free);
3128         wake = list_empty(&map->async_list);
3129
3130         if (ret != 0)
3131                 map->async_ret = ret;
3132
3133         spin_unlock(&map->async_lock);
3134
3135         if (wake)
3136                 wake_up(&map->async_waitq);
3137 }
3138 EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
3139
3140 static int regmap_async_is_done(struct regmap *map)
3141 {
3142         unsigned long flags;
3143         int ret;
3144
3145         spin_lock_irqsave(&map->async_lock, flags);
3146         ret = list_empty(&map->async_list);
3147         spin_unlock_irqrestore(&map->async_lock, flags);
3148
3149         return ret;
3150 }
3151
3152 /**
3153  * regmap_async_complete - Ensure all asynchronous I/O has completed.
3154  *
3155  * @map: Map to operate on.
3156  *
3157  * Blocks until any pending asynchronous I/O has completed.  Returns
3158  * an error code for any failed I/O operations.
3159  */
3160 int regmap_async_complete(struct regmap *map)
3161 {
3162         unsigned long flags;
3163         int ret;
3164
3165         /* Nothing to do with no async support */
3166         if (!map->bus || !map->bus->async_write)
3167                 return 0;
3168
3169         trace_regmap_async_complete_start(map);
3170
3171         wait_event(map->async_waitq, regmap_async_is_done(map));
3172
3173         spin_lock_irqsave(&map->async_lock, flags);
3174         ret = map->async_ret;
3175         map->async_ret = 0;
3176         spin_unlock_irqrestore(&map->async_lock, flags);
3177
3178         trace_regmap_async_complete_done(map);
3179
3180         return ret;
3181 }
3182 EXPORT_SYMBOL_GPL(regmap_async_complete);
3183
3184 /**
3185  * regmap_register_patch - Register and apply register updates to be applied
3186  *                         on device initialistion
3187  *
3188  * @map: Register map to apply updates to.
3189  * @regs: Values to update.
3190  * @num_regs: Number of entries in regs.
3191  *
3192  * Register a set of register updates to be applied to the device
3193  * whenever the device registers are synchronised with the cache and
3194  * apply them immediately.  Typically this is used to apply
3195  * corrections to be applied to the device defaults on startup, such
3196  * as the updates some vendors provide to undocumented registers.
3197  *
3198  * The caller must ensure that this function cannot be called
3199  * concurrently with either itself or regcache_sync().
3200  */
3201 int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
3202                           int num_regs)
3203 {
3204         struct reg_sequence *p;
3205         int ret;
3206         bool bypass;
3207
3208         if (WARN_ONCE(num_regs <= 0, "invalid registers number (%d)\n",
3209             num_regs))
3210                 return 0;
3211
3212         p = krealloc(map->patch,
3213                      sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
3214                      GFP_KERNEL);
3215         if (p) {
3216                 memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
3217                 map->patch = p;
3218                 map->patch_regs += num_regs;
3219         } else {
3220                 return -ENOMEM;
3221         }
3222
3223         map->lock(map->lock_arg);
3224
3225         bypass = map->cache_bypass;
3226
3227         map->cache_bypass = true;
3228         map->async = true;
3229
3230         ret = _regmap_multi_reg_write(map, regs, num_regs);
3231
3232         map->async = false;
3233         map->cache_bypass = bypass;
3234
3235         map->unlock(map->lock_arg);
3236
3237         regmap_async_complete(map);
3238
3239         return ret;
3240 }
3241 EXPORT_SYMBOL_GPL(regmap_register_patch);
3242
3243 /**
3244  * regmap_get_val_bytes() - Report the size of a register value
3245  *
3246  * @map: Register map to operate on.
3247  *
3248  * Report the size of a register value, mainly intended to for use by
3249  * generic infrastructure built on top of regmap.
3250  */
3251 int regmap_get_val_bytes(struct regmap *map)
3252 {
3253         if (map->format.format_write)
3254                 return -EINVAL;
3255
3256         return map->format.val_bytes;
3257 }
3258 EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
3259
3260 /**
3261  * regmap_get_max_register() - Report the max register value
3262  *
3263  * @map: Register map to operate on.
3264  *
3265  * Report the max register value, mainly intended to for use by
3266  * generic infrastructure built on top of regmap.
3267  */
3268 int regmap_get_max_register(struct regmap *map)
3269 {
3270         return map->max_register ? map->max_register : -EINVAL;
3271 }
3272 EXPORT_SYMBOL_GPL(regmap_get_max_register);
3273
3274 /**
3275  * regmap_get_reg_stride() - Report the register address stride
3276  *
3277  * @map: Register map to operate on.
3278  *
3279  * Report the register address stride, mainly intended to for use by
3280  * generic infrastructure built on top of regmap.
3281  */
3282 int regmap_get_reg_stride(struct regmap *map)
3283 {
3284         return map->reg_stride;
3285 }
3286 EXPORT_SYMBOL_GPL(regmap_get_reg_stride);
3287
3288 int regmap_parse_val(struct regmap *map, const void *buf,
3289                         unsigned int *val)
3290 {
3291         if (!map->format.parse_val)
3292                 return -EINVAL;
3293
3294         *val = map->format.parse_val(buf);
3295
3296         return 0;
3297 }
3298 EXPORT_SYMBOL_GPL(regmap_parse_val);
3299
3300 static int __init regmap_initcall(void)
3301 {
3302         regmap_debugfs_initcall();
3303
3304         return 0;
3305 }
3306 postcore_initcall(regmap_initcall);