drivers/base/regmap/regmap.c

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