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