drivers/base/regmap/regmap.c

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