drivers/base/regmap/regmap.c

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