2 * Register map access API
4 * Copyright 2011 Wolfson Microelectronics plc
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
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.
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>
19 #include <linux/rbtree.h>
20 #include <linux/sched.h>
21 #include <linux/delay.h>
22 #include <linux/log2.h>
24 #define CREATE_TRACE_POINTS
30 * Sometimes for failures during very early init the trace
31 * infrastructure isn't available early enough to be used. For this
32 * sort of problem defining LOG_DEVICE will add printks for basic
33 * register I/O on a specific device.
37 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
38 unsigned int mask, unsigned int val,
39 bool *change, bool force_write);
41 static int _regmap_bus_reg_read(void *context, unsigned int reg,
43 static int _regmap_bus_read(void *context, unsigned int reg,
45 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
47 static int _regmap_bus_reg_write(void *context, unsigned int reg,
49 static int _regmap_bus_raw_write(void *context, unsigned int reg,
52 bool regmap_reg_in_ranges(unsigned int reg,
53 const struct regmap_range *ranges,
56 const struct regmap_range *r;
59 for (i = 0, r = ranges; i < nranges; i++, r++)
60 if (regmap_reg_in_range(reg, r))
64 EXPORT_SYMBOL_GPL(regmap_reg_in_ranges);
66 bool regmap_check_range_table(struct regmap *map, unsigned int reg,
67 const struct regmap_access_table *table)
69 /* Check "no ranges" first */
70 if (regmap_reg_in_ranges(reg, table->no_ranges, table->n_no_ranges))
73 /* In case zero "yes ranges" are supplied, any reg is OK */
74 if (!table->n_yes_ranges)
77 return regmap_reg_in_ranges(reg, table->yes_ranges,
80 EXPORT_SYMBOL_GPL(regmap_check_range_table);
82 bool regmap_writeable(struct regmap *map, unsigned int reg)
84 if (map->max_register && reg > map->max_register)
87 if (map->writeable_reg)
88 return map->writeable_reg(map->dev, reg);
91 return regmap_check_range_table(map, reg, map->wr_table);
96 bool regmap_cached(struct regmap *map, unsigned int reg)
101 if (map->cache_type == REGCACHE_NONE)
107 if (map->max_register && reg > map->max_register)
110 map->lock(map->lock_arg);
111 ret = regcache_read(map, reg, &val);
112 map->unlock(map->lock_arg);
119 bool regmap_readable(struct regmap *map, unsigned int reg)
124 if (map->max_register && reg > map->max_register)
127 if (map->format.format_write)
130 if (map->readable_reg)
131 return map->readable_reg(map->dev, reg);
134 return regmap_check_range_table(map, reg, map->rd_table);
139 bool regmap_volatile(struct regmap *map, unsigned int reg)
141 if (!map->format.format_write && !regmap_readable(map, reg))
144 if (map->volatile_reg)
145 return map->volatile_reg(map->dev, reg);
147 if (map->volatile_table)
148 return regmap_check_range_table(map, reg, map->volatile_table);
156 bool regmap_precious(struct regmap *map, unsigned int reg)
158 if (!regmap_readable(map, reg))
161 if (map->precious_reg)
162 return map->precious_reg(map->dev, reg);
164 if (map->precious_table)
165 return regmap_check_range_table(map, reg, map->precious_table);
170 static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
175 for (i = 0; i < num; i++)
176 if (!regmap_volatile(map, reg + i))
182 static void regmap_format_2_6_write(struct regmap *map,
183 unsigned int reg, unsigned int val)
185 u8 *out = map->work_buf;
187 *out = (reg << 6) | val;
190 static void regmap_format_4_12_write(struct regmap *map,
191 unsigned int reg, unsigned int val)
193 __be16 *out = map->work_buf;
194 *out = cpu_to_be16((reg << 12) | val);
197 static void regmap_format_7_9_write(struct regmap *map,
198 unsigned int reg, unsigned int val)
200 __be16 *out = map->work_buf;
201 *out = cpu_to_be16((reg << 9) | val);
204 static void regmap_format_10_14_write(struct regmap *map,
205 unsigned int reg, unsigned int val)
207 u8 *out = map->work_buf;
210 out[1] = (val >> 8) | (reg << 6);
214 static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
221 static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
225 b[0] = cpu_to_be16(val << shift);
228 static void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)
232 b[0] = cpu_to_le16(val << shift);
235 static void regmap_format_16_native(void *buf, unsigned int val,
238 *(u16 *)buf = val << shift;
241 static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
252 static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
256 b[0] = cpu_to_be32(val << shift);
259 static void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)
263 b[0] = cpu_to_le32(val << shift);
266 static void regmap_format_32_native(void *buf, unsigned int val,
269 *(u32 *)buf = val << shift;
273 static void regmap_format_64_be(void *buf, unsigned int val, unsigned int shift)
277 b[0] = cpu_to_be64((u64)val << shift);
280 static void regmap_format_64_le(void *buf, unsigned int val, unsigned int shift)
284 b[0] = cpu_to_le64((u64)val << shift);
287 static void regmap_format_64_native(void *buf, unsigned int val,
290 *(u64 *)buf = (u64)val << shift;
294 static void regmap_parse_inplace_noop(void *buf)
298 static unsigned int regmap_parse_8(const void *buf)
305 static unsigned int regmap_parse_16_be(const void *buf)
307 const __be16 *b = buf;
309 return be16_to_cpu(b[0]);
312 static unsigned int regmap_parse_16_le(const void *buf)
314 const __le16 *b = buf;
316 return le16_to_cpu(b[0]);
319 static void regmap_parse_16_be_inplace(void *buf)
323 b[0] = be16_to_cpu(b[0]);
326 static void regmap_parse_16_le_inplace(void *buf)
330 b[0] = le16_to_cpu(b[0]);
333 static unsigned int regmap_parse_16_native(const void *buf)
338 static unsigned int regmap_parse_24(const void *buf)
341 unsigned int ret = b[2];
342 ret |= ((unsigned int)b[1]) << 8;
343 ret |= ((unsigned int)b[0]) << 16;
348 static unsigned int regmap_parse_32_be(const void *buf)
350 const __be32 *b = buf;
352 return be32_to_cpu(b[0]);
355 static unsigned int regmap_parse_32_le(const void *buf)
357 const __le32 *b = buf;
359 return le32_to_cpu(b[0]);
362 static void regmap_parse_32_be_inplace(void *buf)
366 b[0] = be32_to_cpu(b[0]);
369 static void regmap_parse_32_le_inplace(void *buf)
373 b[0] = le32_to_cpu(b[0]);
376 static unsigned int regmap_parse_32_native(const void *buf)
382 static unsigned int regmap_parse_64_be(const void *buf)
384 const __be64 *b = buf;
386 return be64_to_cpu(b[0]);
389 static unsigned int regmap_parse_64_le(const void *buf)
391 const __le64 *b = buf;
393 return le64_to_cpu(b[0]);
396 static void regmap_parse_64_be_inplace(void *buf)
400 b[0] = be64_to_cpu(b[0]);
403 static void regmap_parse_64_le_inplace(void *buf)
407 b[0] = le64_to_cpu(b[0]);
410 static unsigned int regmap_parse_64_native(const void *buf)
416 static void regmap_lock_mutex(void *__map)
418 struct regmap *map = __map;
419 mutex_lock(&map->mutex);
422 static void regmap_unlock_mutex(void *__map)
424 struct regmap *map = __map;
425 mutex_unlock(&map->mutex);
428 static void regmap_lock_spinlock(void *__map)
429 __acquires(&map->spinlock)
431 struct regmap *map = __map;
434 spin_lock_irqsave(&map->spinlock, flags);
435 map->spinlock_flags = flags;
438 static void regmap_unlock_spinlock(void *__map)
439 __releases(&map->spinlock)
441 struct regmap *map = __map;
442 spin_unlock_irqrestore(&map->spinlock, map->spinlock_flags);
445 static void dev_get_regmap_release(struct device *dev, void *res)
448 * We don't actually have anything to do here; the goal here
449 * is not to manage the regmap but to provide a simple way to
450 * get the regmap back given a struct device.
454 static bool _regmap_range_add(struct regmap *map,
455 struct regmap_range_node *data)
457 struct rb_root *root = &map->range_tree;
458 struct rb_node **new = &(root->rb_node), *parent = NULL;
461 struct regmap_range_node *this =
462 rb_entry(*new, struct regmap_range_node, node);
465 if (data->range_max < this->range_min)
466 new = &((*new)->rb_left);
467 else if (data->range_min > this->range_max)
468 new = &((*new)->rb_right);
473 rb_link_node(&data->node, parent, new);
474 rb_insert_color(&data->node, root);
479 static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
482 struct rb_node *node = map->range_tree.rb_node;
485 struct regmap_range_node *this =
486 rb_entry(node, struct regmap_range_node, node);
488 if (reg < this->range_min)
489 node = node->rb_left;
490 else if (reg > this->range_max)
491 node = node->rb_right;
499 static void regmap_range_exit(struct regmap *map)
501 struct rb_node *next;
502 struct regmap_range_node *range_node;
504 next = rb_first(&map->range_tree);
506 range_node = rb_entry(next, struct regmap_range_node, node);
507 next = rb_next(&range_node->node);
508 rb_erase(&range_node->node, &map->range_tree);
512 kfree(map->selector_work_buf);
515 int regmap_attach_dev(struct device *dev, struct regmap *map,
516 const struct regmap_config *config)
522 regmap_debugfs_init(map, config->name);
524 /* Add a devres resource for dev_get_regmap() */
525 m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
527 regmap_debugfs_exit(map);
535 EXPORT_SYMBOL_GPL(regmap_attach_dev);
537 static enum regmap_endian regmap_get_reg_endian(const struct regmap_bus *bus,
538 const struct regmap_config *config)
540 enum regmap_endian endian;
542 /* Retrieve the endianness specification from the regmap config */
543 endian = config->reg_format_endian;
545 /* If the regmap config specified a non-default value, use that */
546 if (endian != REGMAP_ENDIAN_DEFAULT)
549 /* Retrieve the endianness specification from the bus config */
550 if (bus && bus->reg_format_endian_default)
551 endian = bus->reg_format_endian_default;
553 /* If the bus specified a non-default value, use that */
554 if (endian != REGMAP_ENDIAN_DEFAULT)
557 /* Use this if no other value was found */
558 return REGMAP_ENDIAN_BIG;
561 enum regmap_endian regmap_get_val_endian(struct device *dev,
562 const struct regmap_bus *bus,
563 const struct regmap_config *config)
565 struct device_node *np;
566 enum regmap_endian endian;
568 /* Retrieve the endianness specification from the regmap config */
569 endian = config->val_format_endian;
571 /* If the regmap config specified a non-default value, use that */
572 if (endian != REGMAP_ENDIAN_DEFAULT)
575 /* If the dev and dev->of_node exist try to get endianness from DT */
576 if (dev && dev->of_node) {
579 /* Parse the device's DT node for an endianness specification */
580 if (of_property_read_bool(np, "big-endian"))
581 endian = REGMAP_ENDIAN_BIG;
582 else if (of_property_read_bool(np, "little-endian"))
583 endian = REGMAP_ENDIAN_LITTLE;
584 else if (of_property_read_bool(np, "native-endian"))
585 endian = REGMAP_ENDIAN_NATIVE;
587 /* If the endianness was specified in DT, use that */
588 if (endian != REGMAP_ENDIAN_DEFAULT)
592 /* Retrieve the endianness specification from the bus config */
593 if (bus && bus->val_format_endian_default)
594 endian = bus->val_format_endian_default;
596 /* If the bus specified a non-default value, use that */
597 if (endian != REGMAP_ENDIAN_DEFAULT)
600 /* Use this if no other value was found */
601 return REGMAP_ENDIAN_BIG;
603 EXPORT_SYMBOL_GPL(regmap_get_val_endian);
605 struct regmap *__regmap_init(struct device *dev,
606 const struct regmap_bus *bus,
608 const struct regmap_config *config,
609 struct lock_class_key *lock_key,
610 const char *lock_name)
614 enum regmap_endian reg_endian, val_endian;
620 map = kzalloc(sizeof(*map), GFP_KERNEL);
626 if (config->lock && config->unlock) {
627 map->lock = config->lock;
628 map->unlock = config->unlock;
629 map->lock_arg = config->lock_arg;
631 if ((bus && bus->fast_io) ||
633 spin_lock_init(&map->spinlock);
634 map->lock = regmap_lock_spinlock;
635 map->unlock = regmap_unlock_spinlock;
636 lockdep_set_class_and_name(&map->spinlock,
637 lock_key, lock_name);
639 mutex_init(&map->mutex);
640 map->lock = regmap_lock_mutex;
641 map->unlock = regmap_unlock_mutex;
642 lockdep_set_class_and_name(&map->mutex,
643 lock_key, lock_name);
649 * When we write in fast-paths with regmap_bulk_write() don't allocate
650 * scratch buffers with sleeping allocations.
652 if ((bus && bus->fast_io) || config->fast_io)
653 map->alloc_flags = GFP_ATOMIC;
655 map->alloc_flags = GFP_KERNEL;
657 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
658 map->format.pad_bytes = config->pad_bits / 8;
659 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
660 map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
661 config->val_bits + config->pad_bits, 8);
662 map->reg_shift = config->pad_bits % 8;
663 if (config->reg_stride)
664 map->reg_stride = config->reg_stride;
667 if (is_power_of_2(map->reg_stride))
668 map->reg_stride_order = ilog2(map->reg_stride);
670 map->reg_stride_order = -1;
671 map->use_single_read = config->use_single_rw || !bus || !bus->read;
672 map->use_single_write = config->use_single_rw || !bus || !bus->write;
673 map->can_multi_write = config->can_multi_write && bus && bus->write;
675 map->max_raw_read = bus->max_raw_read;
676 map->max_raw_write = bus->max_raw_write;
680 map->bus_context = bus_context;
681 map->max_register = config->max_register;
682 map->wr_table = config->wr_table;
683 map->rd_table = config->rd_table;
684 map->volatile_table = config->volatile_table;
685 map->precious_table = config->precious_table;
686 map->writeable_reg = config->writeable_reg;
687 map->readable_reg = config->readable_reg;
688 map->volatile_reg = config->volatile_reg;
689 map->precious_reg = config->precious_reg;
690 map->cache_type = config->cache_type;
691 map->name = config->name;
693 spin_lock_init(&map->async_lock);
694 INIT_LIST_HEAD(&map->async_list);
695 INIT_LIST_HEAD(&map->async_free);
696 init_waitqueue_head(&map->async_waitq);
698 if (config->read_flag_mask || config->write_flag_mask) {
699 map->read_flag_mask = config->read_flag_mask;
700 map->write_flag_mask = config->write_flag_mask;
702 map->read_flag_mask = bus->read_flag_mask;
706 map->reg_read = config->reg_read;
707 map->reg_write = config->reg_write;
709 map->defer_caching = false;
710 goto skip_format_initialization;
711 } else if (!bus->read || !bus->write) {
712 map->reg_read = _regmap_bus_reg_read;
713 map->reg_write = _regmap_bus_reg_write;
715 map->defer_caching = false;
716 goto skip_format_initialization;
718 map->reg_read = _regmap_bus_read;
719 map->reg_update_bits = bus->reg_update_bits;
722 reg_endian = regmap_get_reg_endian(bus, config);
723 val_endian = regmap_get_val_endian(dev, bus, config);
725 switch (config->reg_bits + map->reg_shift) {
727 switch (config->val_bits) {
729 map->format.format_write = regmap_format_2_6_write;
737 switch (config->val_bits) {
739 map->format.format_write = regmap_format_4_12_write;
747 switch (config->val_bits) {
749 map->format.format_write = regmap_format_7_9_write;
757 switch (config->val_bits) {
759 map->format.format_write = regmap_format_10_14_write;
767 map->format.format_reg = regmap_format_8;
771 switch (reg_endian) {
772 case REGMAP_ENDIAN_BIG:
773 map->format.format_reg = regmap_format_16_be;
775 case REGMAP_ENDIAN_LITTLE:
776 map->format.format_reg = regmap_format_16_le;
778 case REGMAP_ENDIAN_NATIVE:
779 map->format.format_reg = regmap_format_16_native;
787 if (reg_endian != REGMAP_ENDIAN_BIG)
789 map->format.format_reg = regmap_format_24;
793 switch (reg_endian) {
794 case REGMAP_ENDIAN_BIG:
795 map->format.format_reg = regmap_format_32_be;
797 case REGMAP_ENDIAN_LITTLE:
798 map->format.format_reg = regmap_format_32_le;
800 case REGMAP_ENDIAN_NATIVE:
801 map->format.format_reg = regmap_format_32_native;
810 switch (reg_endian) {
811 case REGMAP_ENDIAN_BIG:
812 map->format.format_reg = regmap_format_64_be;
814 case REGMAP_ENDIAN_LITTLE:
815 map->format.format_reg = regmap_format_64_le;
817 case REGMAP_ENDIAN_NATIVE:
818 map->format.format_reg = regmap_format_64_native;
830 if (val_endian == REGMAP_ENDIAN_NATIVE)
831 map->format.parse_inplace = regmap_parse_inplace_noop;
833 switch (config->val_bits) {
835 map->format.format_val = regmap_format_8;
836 map->format.parse_val = regmap_parse_8;
837 map->format.parse_inplace = regmap_parse_inplace_noop;
840 switch (val_endian) {
841 case REGMAP_ENDIAN_BIG:
842 map->format.format_val = regmap_format_16_be;
843 map->format.parse_val = regmap_parse_16_be;
844 map->format.parse_inplace = regmap_parse_16_be_inplace;
846 case REGMAP_ENDIAN_LITTLE:
847 map->format.format_val = regmap_format_16_le;
848 map->format.parse_val = regmap_parse_16_le;
849 map->format.parse_inplace = regmap_parse_16_le_inplace;
851 case REGMAP_ENDIAN_NATIVE:
852 map->format.format_val = regmap_format_16_native;
853 map->format.parse_val = regmap_parse_16_native;
860 if (val_endian != REGMAP_ENDIAN_BIG)
862 map->format.format_val = regmap_format_24;
863 map->format.parse_val = regmap_parse_24;
866 switch (val_endian) {
867 case REGMAP_ENDIAN_BIG:
868 map->format.format_val = regmap_format_32_be;
869 map->format.parse_val = regmap_parse_32_be;
870 map->format.parse_inplace = regmap_parse_32_be_inplace;
872 case REGMAP_ENDIAN_LITTLE:
873 map->format.format_val = regmap_format_32_le;
874 map->format.parse_val = regmap_parse_32_le;
875 map->format.parse_inplace = regmap_parse_32_le_inplace;
877 case REGMAP_ENDIAN_NATIVE:
878 map->format.format_val = regmap_format_32_native;
879 map->format.parse_val = regmap_parse_32_native;
887 switch (val_endian) {
888 case REGMAP_ENDIAN_BIG:
889 map->format.format_val = regmap_format_64_be;
890 map->format.parse_val = regmap_parse_64_be;
891 map->format.parse_inplace = regmap_parse_64_be_inplace;
893 case REGMAP_ENDIAN_LITTLE:
894 map->format.format_val = regmap_format_64_le;
895 map->format.parse_val = regmap_parse_64_le;
896 map->format.parse_inplace = regmap_parse_64_le_inplace;
898 case REGMAP_ENDIAN_NATIVE:
899 map->format.format_val = regmap_format_64_native;
900 map->format.parse_val = regmap_parse_64_native;
909 if (map->format.format_write) {
910 if ((reg_endian != REGMAP_ENDIAN_BIG) ||
911 (val_endian != REGMAP_ENDIAN_BIG))
913 map->use_single_write = true;
916 if (!map->format.format_write &&
917 !(map->format.format_reg && map->format.format_val))
920 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
921 if (map->work_buf == NULL) {
926 if (map->format.format_write) {
927 map->defer_caching = false;
928 map->reg_write = _regmap_bus_formatted_write;
929 } else if (map->format.format_val) {
930 map->defer_caching = true;
931 map->reg_write = _regmap_bus_raw_write;
934 skip_format_initialization:
936 map->range_tree = RB_ROOT;
937 for (i = 0; i < config->num_ranges; i++) {
938 const struct regmap_range_cfg *range_cfg = &config->ranges[i];
939 struct regmap_range_node *new;
942 if (range_cfg->range_max < range_cfg->range_min) {
943 dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
944 range_cfg->range_max, range_cfg->range_min);
948 if (range_cfg->range_max > map->max_register) {
949 dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
950 range_cfg->range_max, map->max_register);
954 if (range_cfg->selector_reg > map->max_register) {
956 "Invalid range %d: selector out of map\n", i);
960 if (range_cfg->window_len == 0) {
961 dev_err(map->dev, "Invalid range %d: window_len 0\n",
966 /* Make sure, that this register range has no selector
967 or data window within its boundary */
968 for (j = 0; j < config->num_ranges; j++) {
969 unsigned sel_reg = config->ranges[j].selector_reg;
970 unsigned win_min = config->ranges[j].window_start;
971 unsigned win_max = win_min +
972 config->ranges[j].window_len - 1;
974 /* Allow data window inside its own virtual range */
978 if (range_cfg->range_min <= sel_reg &&
979 sel_reg <= range_cfg->range_max) {
981 "Range %d: selector for %d in window\n",
986 if (!(win_max < range_cfg->range_min ||
987 win_min > range_cfg->range_max)) {
989 "Range %d: window for %d in window\n",
995 new = kzalloc(sizeof(*new), GFP_KERNEL);
1002 new->name = range_cfg->name;
1003 new->range_min = range_cfg->range_min;
1004 new->range_max = range_cfg->range_max;
1005 new->selector_reg = range_cfg->selector_reg;
1006 new->selector_mask = range_cfg->selector_mask;
1007 new->selector_shift = range_cfg->selector_shift;
1008 new->window_start = range_cfg->window_start;
1009 new->window_len = range_cfg->window_len;
1011 if (!_regmap_range_add(map, new)) {
1012 dev_err(map->dev, "Failed to add range %d\n", i);
1017 if (map->selector_work_buf == NULL) {
1018 map->selector_work_buf =
1019 kzalloc(map->format.buf_size, GFP_KERNEL);
1020 if (map->selector_work_buf == NULL) {
1027 ret = regcache_init(map, config);
1032 ret = regmap_attach_dev(dev, map, config);
1042 regmap_range_exit(map);
1043 kfree(map->work_buf);
1047 return ERR_PTR(ret);
1049 EXPORT_SYMBOL_GPL(__regmap_init);
1051 static void devm_regmap_release(struct device *dev, void *res)
1053 regmap_exit(*(struct regmap **)res);
1056 struct regmap *__devm_regmap_init(struct device *dev,
1057 const struct regmap_bus *bus,
1059 const struct regmap_config *config,
1060 struct lock_class_key *lock_key,
1061 const char *lock_name)
1063 struct regmap **ptr, *regmap;
1065 ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
1067 return ERR_PTR(-ENOMEM);
1069 regmap = __regmap_init(dev, bus, bus_context, config,
1070 lock_key, lock_name);
1071 if (!IS_ERR(regmap)) {
1073 devres_add(dev, ptr);
1080 EXPORT_SYMBOL_GPL(__devm_regmap_init);
1082 static void regmap_field_init(struct regmap_field *rm_field,
1083 struct regmap *regmap, struct reg_field reg_field)
1085 rm_field->regmap = regmap;
1086 rm_field->reg = reg_field.reg;
1087 rm_field->shift = reg_field.lsb;
1088 rm_field->mask = GENMASK(reg_field.msb, reg_field.lsb);
1089 rm_field->id_size = reg_field.id_size;
1090 rm_field->id_offset = reg_field.id_offset;
1094 * devm_regmap_field_alloc() - Allocate and initialise a register field.
1096 * @dev: Device that will be interacted with
1097 * @regmap: regmap bank in which this register field is located.
1098 * @reg_field: Register field with in the bank.
1100 * The return value will be an ERR_PTR() on error or a valid pointer
1101 * to a struct regmap_field. The regmap_field will be automatically freed
1102 * by the device management code.
1104 struct regmap_field *devm_regmap_field_alloc(struct device *dev,
1105 struct regmap *regmap, struct reg_field reg_field)
1107 struct regmap_field *rm_field = devm_kzalloc(dev,
1108 sizeof(*rm_field), GFP_KERNEL);
1110 return ERR_PTR(-ENOMEM);
1112 regmap_field_init(rm_field, regmap, reg_field);
1117 EXPORT_SYMBOL_GPL(devm_regmap_field_alloc);
1120 * devm_regmap_field_free() - Free a register field allocated using
1121 * devm_regmap_field_alloc.
1123 * @dev: Device that will be interacted with
1124 * @field: regmap field which should be freed.
1126 * Free register field allocated using devm_regmap_field_alloc(). Usually
1127 * drivers need not call this function, as the memory allocated via devm
1128 * will be freed as per device-driver life-cyle.
1130 void devm_regmap_field_free(struct device *dev,
1131 struct regmap_field *field)
1133 devm_kfree(dev, field);
1135 EXPORT_SYMBOL_GPL(devm_regmap_field_free);
1138 * regmap_field_alloc() - Allocate and initialise a register field.
1140 * @regmap: regmap bank in which this register field is located.
1141 * @reg_field: Register field with in the bank.
1143 * The return value will be an ERR_PTR() on error or a valid pointer
1144 * to a struct regmap_field. The regmap_field should be freed by the
1145 * user once its finished working with it using regmap_field_free().
1147 struct regmap_field *regmap_field_alloc(struct regmap *regmap,
1148 struct reg_field reg_field)
1150 struct regmap_field *rm_field = kzalloc(sizeof(*rm_field), GFP_KERNEL);
1153 return ERR_PTR(-ENOMEM);
1155 regmap_field_init(rm_field, regmap, reg_field);
1159 EXPORT_SYMBOL_GPL(regmap_field_alloc);
1162 * regmap_field_free() - Free register field allocated using
1163 * regmap_field_alloc.
1165 * @field: regmap field which should be freed.
1167 void regmap_field_free(struct regmap_field *field)
1171 EXPORT_SYMBOL_GPL(regmap_field_free);
1174 * regmap_reinit_cache() - Reinitialise the current register cache
1176 * @map: Register map to operate on.
1177 * @config: New configuration. Only the cache data will be used.
1179 * Discard any existing register cache for the map and initialize a
1180 * new cache. This can be used to restore the cache to defaults or to
1181 * update the cache configuration to reflect runtime discovery of the
1184 * No explicit locking is done here, the user needs to ensure that
1185 * this function will not race with other calls to regmap.
1187 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
1190 regmap_debugfs_exit(map);
1192 map->max_register = config->max_register;
1193 map->writeable_reg = config->writeable_reg;
1194 map->readable_reg = config->readable_reg;
1195 map->volatile_reg = config->volatile_reg;
1196 map->precious_reg = config->precious_reg;
1197 map->cache_type = config->cache_type;
1199 regmap_debugfs_init(map, config->name);
1201 map->cache_bypass = false;
1202 map->cache_only = false;
1204 return regcache_init(map, config);
1206 EXPORT_SYMBOL_GPL(regmap_reinit_cache);
1209 * regmap_exit() - Free a previously allocated register map
1211 * @map: Register map to operate on.
1213 void regmap_exit(struct regmap *map)
1215 struct regmap_async *async;
1218 regmap_debugfs_exit(map);
1219 regmap_range_exit(map);
1220 if (map->bus && map->bus->free_context)
1221 map->bus->free_context(map->bus_context);
1222 kfree(map->work_buf);
1223 while (!list_empty(&map->async_free)) {
1224 async = list_first_entry_or_null(&map->async_free,
1225 struct regmap_async,
1227 list_del(&async->list);
1228 kfree(async->work_buf);
1233 EXPORT_SYMBOL_GPL(regmap_exit);
1235 static int dev_get_regmap_match(struct device *dev, void *res, void *data)
1237 struct regmap **r = res;
1243 /* If the user didn't specify a name match any */
1245 return !strcmp((*r)->name, data);
1251 * dev_get_regmap() - Obtain the regmap (if any) for a device
1253 * @dev: Device to retrieve the map for
1254 * @name: Optional name for the register map, usually NULL.
1256 * Returns the regmap for the device if one is present, or NULL. If
1257 * name is specified then it must match the name specified when
1258 * registering the device, if it is NULL then the first regmap found
1259 * will be used. Devices with multiple register maps are very rare,
1260 * generic code should normally not need to specify a name.
1262 struct regmap *dev_get_regmap(struct device *dev, const char *name)
1264 struct regmap **r = devres_find(dev, dev_get_regmap_release,
1265 dev_get_regmap_match, (void *)name);
1271 EXPORT_SYMBOL_GPL(dev_get_regmap);
1274 * regmap_get_device() - Obtain the device from a regmap
1276 * @map: Register map to operate on.
1278 * Returns the underlying device that the regmap has been created for.
1280 struct device *regmap_get_device(struct regmap *map)
1284 EXPORT_SYMBOL_GPL(regmap_get_device);
1286 static int _regmap_select_page(struct regmap *map, unsigned int *reg,
1287 struct regmap_range_node *range,
1288 unsigned int val_num)
1290 void *orig_work_buf;
1291 unsigned int win_offset;
1292 unsigned int win_page;
1296 win_offset = (*reg - range->range_min) % range->window_len;
1297 win_page = (*reg - range->range_min) / range->window_len;
1300 /* Bulk write shouldn't cross range boundary */
1301 if (*reg + val_num - 1 > range->range_max)
1304 /* ... or single page boundary */
1305 if (val_num > range->window_len - win_offset)
1309 /* It is possible to have selector register inside data window.
1310 In that case, selector register is located on every page and
1311 it needs no page switching, when accessed alone. */
1313 range->window_start + win_offset != range->selector_reg) {
1314 /* Use separate work_buf during page switching */
1315 orig_work_buf = map->work_buf;
1316 map->work_buf = map->selector_work_buf;
1318 ret = _regmap_update_bits(map, range->selector_reg,
1319 range->selector_mask,
1320 win_page << range->selector_shift,
1323 map->work_buf = orig_work_buf;
1329 *reg = range->window_start + win_offset;
1334 static void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
1340 if (!mask || !map->work_buf)
1343 buf = map->work_buf;
1345 for (i = 0; i < max_bytes; i++)
1346 buf[i] |= (mask >> (8 * i)) & 0xff;
1349 int _regmap_raw_write(struct regmap *map, unsigned int reg,
1350 const void *val, size_t val_len)
1352 struct regmap_range_node *range;
1353 unsigned long flags;
1354 void *work_val = map->work_buf + map->format.reg_bytes +
1355 map->format.pad_bytes;
1357 int ret = -ENOTSUPP;
1363 /* Check for unwritable registers before we start */
1364 if (map->writeable_reg)
1365 for (i = 0; i < val_len / map->format.val_bytes; i++)
1366 if (!map->writeable_reg(map->dev,
1367 reg + regmap_get_offset(map, i)))
1370 if (!map->cache_bypass && map->format.parse_val) {
1372 int val_bytes = map->format.val_bytes;
1373 for (i = 0; i < val_len / val_bytes; i++) {
1374 ival = map->format.parse_val(val + (i * val_bytes));
1375 ret = regcache_write(map,
1376 reg + regmap_get_offset(map, i),
1380 "Error in caching of register: %x ret: %d\n",
1381 reg + regmap_get_offset(map, i), ret);
1385 if (map->cache_only) {
1386 map->cache_dirty = true;
1391 range = _regmap_range_lookup(map, reg);
1393 int val_num = val_len / map->format.val_bytes;
1394 int win_offset = (reg - range->range_min) % range->window_len;
1395 int win_residue = range->window_len - win_offset;
1397 /* If the write goes beyond the end of the window split it */
1398 while (val_num > win_residue) {
1399 dev_dbg(map->dev, "Writing window %d/%zu\n",
1400 win_residue, val_len / map->format.val_bytes);
1401 ret = _regmap_raw_write(map, reg, val, win_residue *
1402 map->format.val_bytes);
1407 val_num -= win_residue;
1408 val += win_residue * map->format.val_bytes;
1409 val_len -= win_residue * map->format.val_bytes;
1411 win_offset = (reg - range->range_min) %
1413 win_residue = range->window_len - win_offset;
1416 ret = _regmap_select_page(map, ®, range, val_num);
1421 map->format.format_reg(map->work_buf, reg, map->reg_shift);
1422 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
1423 map->write_flag_mask);
1426 * Essentially all I/O mechanisms will be faster with a single
1427 * buffer to write. Since register syncs often generate raw
1428 * writes of single registers optimise that case.
1430 if (val != work_val && val_len == map->format.val_bytes) {
1431 memcpy(work_val, val, map->format.val_bytes);
1435 if (map->async && map->bus->async_write) {
1436 struct regmap_async *async;
1438 trace_regmap_async_write_start(map, reg, val_len);
1440 spin_lock_irqsave(&map->async_lock, flags);
1441 async = list_first_entry_or_null(&map->async_free,
1442 struct regmap_async,
1445 list_del(&async->list);
1446 spin_unlock_irqrestore(&map->async_lock, flags);
1449 async = map->bus->async_alloc();
1453 async->work_buf = kzalloc(map->format.buf_size,
1454 GFP_KERNEL | GFP_DMA);
1455 if (!async->work_buf) {
1463 /* If the caller supplied the value we can use it safely. */
1464 memcpy(async->work_buf, map->work_buf, map->format.pad_bytes +
1465 map->format.reg_bytes + map->format.val_bytes);
1467 spin_lock_irqsave(&map->async_lock, flags);
1468 list_add_tail(&async->list, &map->async_list);
1469 spin_unlock_irqrestore(&map->async_lock, flags);
1471 if (val != work_val)
1472 ret = map->bus->async_write(map->bus_context,
1474 map->format.reg_bytes +
1475 map->format.pad_bytes,
1476 val, val_len, async);
1478 ret = map->bus->async_write(map->bus_context,
1480 map->format.reg_bytes +
1481 map->format.pad_bytes +
1482 val_len, NULL, 0, async);
1485 dev_err(map->dev, "Failed to schedule write: %d\n",
1488 spin_lock_irqsave(&map->async_lock, flags);
1489 list_move(&async->list, &map->async_free);
1490 spin_unlock_irqrestore(&map->async_lock, flags);
1496 trace_regmap_hw_write_start(map, reg, val_len / map->format.val_bytes);
1498 /* If we're doing a single register write we can probably just
1499 * send the work_buf directly, otherwise try to do a gather
1502 if (val == work_val)
1503 ret = map->bus->write(map->bus_context, map->work_buf,
1504 map->format.reg_bytes +
1505 map->format.pad_bytes +
1507 else if (map->bus->gather_write)
1508 ret = map->bus->gather_write(map->bus_context, map->work_buf,
1509 map->format.reg_bytes +
1510 map->format.pad_bytes,
1515 /* If that didn't work fall back on linearising by hand. */
1516 if (ret == -ENOTSUPP) {
1517 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
1518 buf = kzalloc(len, GFP_KERNEL);
1522 memcpy(buf, map->work_buf, map->format.reg_bytes);
1523 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
1525 ret = map->bus->write(map->bus_context, buf, len);
1528 } else if (ret != 0 && !map->cache_bypass && map->format.parse_val) {
1529 /* regcache_drop_region() takes lock that we already have,
1530 * thus call map->cache_ops->drop() directly
1532 if (map->cache_ops && map->cache_ops->drop)
1533 map->cache_ops->drop(map, reg, reg + 1);
1536 trace_regmap_hw_write_done(map, reg, val_len / map->format.val_bytes);
1542 * regmap_can_raw_write - Test if regmap_raw_write() is supported
1544 * @map: Map to check.
1546 bool regmap_can_raw_write(struct regmap *map)
1548 return map->bus && map->bus->write && map->format.format_val &&
1549 map->format.format_reg;
1551 EXPORT_SYMBOL_GPL(regmap_can_raw_write);
1554 * regmap_get_raw_read_max - Get the maximum size we can read
1556 * @map: Map to check.
1558 size_t regmap_get_raw_read_max(struct regmap *map)
1560 return map->max_raw_read;
1562 EXPORT_SYMBOL_GPL(regmap_get_raw_read_max);
1565 * regmap_get_raw_write_max - Get the maximum size we can read
1567 * @map: Map to check.
1569 size_t regmap_get_raw_write_max(struct regmap *map)
1571 return map->max_raw_write;
1573 EXPORT_SYMBOL_GPL(regmap_get_raw_write_max);
1575 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
1579 struct regmap_range_node *range;
1580 struct regmap *map = context;
1582 WARN_ON(!map->bus || !map->format.format_write);
1584 range = _regmap_range_lookup(map, reg);
1586 ret = _regmap_select_page(map, ®, range, 1);
1591 map->format.format_write(map, reg, val);
1593 trace_regmap_hw_write_start(map, reg, 1);
1595 ret = map->bus->write(map->bus_context, map->work_buf,
1596 map->format.buf_size);
1598 trace_regmap_hw_write_done(map, reg, 1);
1603 static int _regmap_bus_reg_write(void *context, unsigned int reg,
1606 struct regmap *map = context;
1608 return map->bus->reg_write(map->bus_context, reg, val);
1611 static int _regmap_bus_raw_write(void *context, unsigned int reg,
1614 struct regmap *map = context;
1616 WARN_ON(!map->bus || !map->format.format_val);
1618 map->format.format_val(map->work_buf + map->format.reg_bytes
1619 + map->format.pad_bytes, val, 0);
1620 return _regmap_raw_write(map, reg,
1622 map->format.reg_bytes +
1623 map->format.pad_bytes,
1624 map->format.val_bytes);
1627 static inline void *_regmap_map_get_context(struct regmap *map)
1629 return (map->bus) ? map : map->bus_context;
1632 int _regmap_write(struct regmap *map, unsigned int reg,
1636 void *context = _regmap_map_get_context(map);
1638 if (!regmap_writeable(map, reg))
1641 if (!map->cache_bypass && !map->defer_caching) {
1642 ret = regcache_write(map, reg, val);
1645 if (map->cache_only) {
1646 map->cache_dirty = true;
1652 if (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
1653 dev_info(map->dev, "%x <= %x\n", reg, val);
1656 trace_regmap_reg_write(map, reg, val);
1658 return map->reg_write(context, reg, val);
1662 * regmap_write() - Write a value to a single register
1664 * @map: Register map to write to
1665 * @reg: Register to write to
1666 * @val: Value to be written
1668 * A value of zero will be returned on success, a negative errno will
1669 * be returned in error cases.
1671 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1675 if (!IS_ALIGNED(reg, map->reg_stride))
1678 map->lock(map->lock_arg);
1680 ret = _regmap_write(map, reg, val);
1682 map->unlock(map->lock_arg);
1686 EXPORT_SYMBOL_GPL(regmap_write);
1689 * regmap_write_async() - Write a value to a single register asynchronously
1691 * @map: Register map to write to
1692 * @reg: Register to write to
1693 * @val: Value to be written
1695 * A value of zero will be returned on success, a negative errno will
1696 * be returned in error cases.
1698 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val)
1702 if (!IS_ALIGNED(reg, map->reg_stride))
1705 map->lock(map->lock_arg);
1709 ret = _regmap_write(map, reg, val);
1713 map->unlock(map->lock_arg);
1717 EXPORT_SYMBOL_GPL(regmap_write_async);
1720 * regmap_raw_write() - Write raw values to one or more registers
1722 * @map: Register map to write to
1723 * @reg: Initial register to write to
1724 * @val: Block of data to be written, laid out for direct transmission to the
1726 * @val_len: Length of data pointed to by val.
1728 * This function is intended to be used for things like firmware
1729 * download where a large block of data needs to be transferred to the
1730 * device. No formatting will be done on the data provided.
1732 * A value of zero will be returned on success, a negative errno will
1733 * be returned in error cases.
1735 int regmap_raw_write(struct regmap *map, unsigned int reg,
1736 const void *val, size_t val_len)
1740 if (!regmap_can_raw_write(map))
1742 if (val_len % map->format.val_bytes)
1744 if (map->max_raw_write && map->max_raw_write < val_len)
1747 map->lock(map->lock_arg);
1749 ret = _regmap_raw_write(map, reg, val, val_len);
1751 map->unlock(map->lock_arg);
1755 EXPORT_SYMBOL_GPL(regmap_raw_write);
1758 * regmap_field_update_bits_base() - Perform a read/modify/write cycle a
1761 * @field: Register field to write to
1762 * @mask: Bitmask to change
1763 * @val: Value to be written
1764 * @change: Boolean indicating if a write was done
1765 * @async: Boolean indicating asynchronously
1766 * @force: Boolean indicating use force update
1768 * Perform a read/modify/write cycle on the register field with change,
1769 * async, force option.
1771 * A value of zero will be returned on success, a negative errno will
1772 * be returned in error cases.
1774 int regmap_field_update_bits_base(struct regmap_field *field,
1775 unsigned int mask, unsigned int val,
1776 bool *change, bool async, bool force)
1778 mask = (mask << field->shift) & field->mask;
1780 return regmap_update_bits_base(field->regmap, field->reg,
1781 mask, val << field->shift,
1782 change, async, force);
1784 EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);
1787 * regmap_fields_update_bits_base() - Perform a read/modify/write cycle a
1788 * register field with port ID
1790 * @field: Register field to write to
1792 * @mask: Bitmask to change
1793 * @val: Value to be written
1794 * @change: Boolean indicating if a write was done
1795 * @async: Boolean indicating asynchronously
1796 * @force: Boolean indicating use force update
1798 * A value of zero will be returned on success, a negative errno will
1799 * be returned in error cases.
1801 int regmap_fields_update_bits_base(struct regmap_field *field, unsigned int id,
1802 unsigned int mask, unsigned int val,
1803 bool *change, bool async, bool force)
1805 if (id >= field->id_size)
1808 mask = (mask << field->shift) & field->mask;
1810 return regmap_update_bits_base(field->regmap,
1811 field->reg + (field->id_offset * id),
1812 mask, val << field->shift,
1813 change, async, force);
1815 EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);
1818 * regmap_bulk_write() - Write multiple registers to the device
1820 * @map: Register map to write to
1821 * @reg: First register to be write from
1822 * @val: Block of data to be written, in native register size for device
1823 * @val_count: Number of registers to write
1825 * This function is intended to be used for writing a large block of
1826 * data to the device either in single transfer or multiple transfer.
1828 * A value of zero will be returned on success, a negative errno will
1829 * be returned in error cases.
1831 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
1835 size_t val_bytes = map->format.val_bytes;
1836 size_t total_size = val_bytes * val_count;
1838 if (!IS_ALIGNED(reg, map->reg_stride))
1842 * Some devices don't support bulk write, for
1843 * them we have a series of single write operations in the first two if
1846 * The first if block is used for memory mapped io. It does not allow
1847 * val_bytes of 3 for example.
1848 * The second one is for busses that do not provide raw I/O.
1849 * The third one is used for busses which do not have these limitations
1850 * and can write arbitrary value lengths.
1853 map->lock(map->lock_arg);
1854 for (i = 0; i < val_count; i++) {
1857 switch (val_bytes) {
1859 ival = *(u8 *)(val + (i * val_bytes));
1862 ival = *(u16 *)(val + (i * val_bytes));
1865 ival = *(u32 *)(val + (i * val_bytes));
1869 ival = *(u64 *)(val + (i * val_bytes));
1877 ret = _regmap_write(map,
1878 reg + regmap_get_offset(map, i),
1884 map->unlock(map->lock_arg);
1885 } else if (map->bus && !map->format.parse_inplace) {
1887 const u16 *u16 = val;
1888 const u32 *u32 = val;
1891 for (i = 0; i < val_count; i++) {
1892 switch (map->format.val_bytes) {
1906 ret = regmap_write(map, reg + (i * map->reg_stride),
1911 } else if (map->use_single_write ||
1912 (map->max_raw_write && map->max_raw_write < total_size)) {
1913 int chunk_stride = map->reg_stride;
1914 size_t chunk_size = val_bytes;
1915 size_t chunk_count = val_count;
1917 if (!map->use_single_write) {
1918 chunk_size = map->max_raw_write;
1919 if (chunk_size % val_bytes)
1920 chunk_size -= chunk_size % val_bytes;
1921 chunk_count = total_size / chunk_size;
1922 chunk_stride *= chunk_size / val_bytes;
1925 map->lock(map->lock_arg);
1926 /* Write as many bytes as possible with chunk_size */
1927 for (i = 0; i < chunk_count; i++) {
1928 ret = _regmap_raw_write(map,
1929 reg + (i * chunk_stride),
1930 val + (i * chunk_size),
1936 /* Write remaining bytes */
1937 if (!ret && chunk_size * i < total_size) {
1938 ret = _regmap_raw_write(map, reg + (i * chunk_stride),
1939 val + (i * chunk_size),
1940 total_size - i * chunk_size);
1942 map->unlock(map->lock_arg);
1949 wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
1951 dev_err(map->dev, "Error in memory allocation\n");
1954 for (i = 0; i < val_count * val_bytes; i += val_bytes)
1955 map->format.parse_inplace(wval + i);
1957 map->lock(map->lock_arg);
1958 ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count);
1959 map->unlock(map->lock_arg);
1965 EXPORT_SYMBOL_GPL(regmap_bulk_write);
1968 * _regmap_raw_multi_reg_write()
1970 * the (register,newvalue) pairs in regs have not been formatted, but
1971 * they are all in the same page and have been changed to being page
1972 * relative. The page register has been written if that was necessary.
1974 static int _regmap_raw_multi_reg_write(struct regmap *map,
1975 const struct reg_sequence *regs,
1982 size_t val_bytes = map->format.val_bytes;
1983 size_t reg_bytes = map->format.reg_bytes;
1984 size_t pad_bytes = map->format.pad_bytes;
1985 size_t pair_size = reg_bytes + pad_bytes + val_bytes;
1986 size_t len = pair_size * num_regs;
1991 buf = kzalloc(len, GFP_KERNEL);
1995 /* We have to linearise by hand. */
1999 for (i = 0; i < num_regs; i++) {
2000 unsigned int reg = regs[i].reg;
2001 unsigned int val = regs[i].def;
2002 trace_regmap_hw_write_start(map, reg, 1);
2003 map->format.format_reg(u8, reg, map->reg_shift);
2004 u8 += reg_bytes + pad_bytes;
2005 map->format.format_val(u8, val, 0);
2009 *u8 |= map->write_flag_mask;
2011 ret = map->bus->write(map->bus_context, buf, len);
2015 for (i = 0; i < num_regs; i++) {
2016 int reg = regs[i].reg;
2017 trace_regmap_hw_write_done(map, reg, 1);
2022 static unsigned int _regmap_register_page(struct regmap *map,
2024 struct regmap_range_node *range)
2026 unsigned int win_page = (reg - range->range_min) / range->window_len;
2031 static int _regmap_range_multi_paged_reg_write(struct regmap *map,
2032 struct reg_sequence *regs,
2037 struct reg_sequence *base;
2038 unsigned int this_page = 0;
2039 unsigned int page_change = 0;
2041 * the set of registers are not neccessarily in order, but
2042 * since the order of write must be preserved this algorithm
2043 * chops the set each time the page changes. This also applies
2044 * if there is a delay required at any point in the sequence.
2047 for (i = 0, n = 0; i < num_regs; i++, n++) {
2048 unsigned int reg = regs[i].reg;
2049 struct regmap_range_node *range;
2051 range = _regmap_range_lookup(map, reg);
2053 unsigned int win_page = _regmap_register_page(map, reg,
2057 this_page = win_page;
2058 if (win_page != this_page) {
2059 this_page = win_page;
2064 /* If we have both a page change and a delay make sure to
2065 * write the regs and apply the delay before we change the
2069 if (page_change || regs[i].delay_us) {
2071 /* For situations where the first write requires
2072 * a delay we need to make sure we don't call
2073 * raw_multi_reg_write with n=0
2074 * This can't occur with page breaks as we
2075 * never write on the first iteration
2077 if (regs[i].delay_us && i == 0)
2080 ret = _regmap_raw_multi_reg_write(map, base, n);
2084 if (regs[i].delay_us)
2085 udelay(regs[i].delay_us);
2091 ret = _regmap_select_page(map,
2104 return _regmap_raw_multi_reg_write(map, base, n);
2108 static int _regmap_multi_reg_write(struct regmap *map,
2109 const struct reg_sequence *regs,
2115 if (!map->can_multi_write) {
2116 for (i = 0; i < num_regs; i++) {
2117 ret = _regmap_write(map, regs[i].reg, regs[i].def);
2121 if (regs[i].delay_us)
2122 udelay(regs[i].delay_us);
2127 if (!map->format.parse_inplace)
2130 if (map->writeable_reg)
2131 for (i = 0; i < num_regs; i++) {
2132 int reg = regs[i].reg;
2133 if (!map->writeable_reg(map->dev, reg))
2135 if (!IS_ALIGNED(reg, map->reg_stride))
2139 if (!map->cache_bypass) {
2140 for (i = 0; i < num_regs; i++) {
2141 unsigned int val = regs[i].def;
2142 unsigned int reg = regs[i].reg;
2143 ret = regcache_write(map, reg, val);
2146 "Error in caching of register: %x ret: %d\n",
2151 if (map->cache_only) {
2152 map->cache_dirty = true;
2159 for (i = 0; i < num_regs; i++) {
2160 unsigned int reg = regs[i].reg;
2161 struct regmap_range_node *range;
2163 /* Coalesce all the writes between a page break or a delay
2166 range = _regmap_range_lookup(map, reg);
2167 if (range || regs[i].delay_us) {
2168 size_t len = sizeof(struct reg_sequence)*num_regs;
2169 struct reg_sequence *base = kmemdup(regs, len,
2173 ret = _regmap_range_multi_paged_reg_write(map, base,
2180 return _regmap_raw_multi_reg_write(map, regs, num_regs);
2184 * regmap_multi_reg_write() - Write multiple registers to the device
2186 * @map: Register map to write to
2187 * @regs: Array of structures containing register,value to be written
2188 * @num_regs: Number of registers to write
2190 * Write multiple registers to the device where the set of register, value
2191 * pairs are supplied in any order, possibly not all in a single range.
2193 * The 'normal' block write mode will send ultimately send data on the
2194 * target bus as R,V1,V2,V3,..,Vn where successively higher registers are
2195 * addressed. However, this alternative block multi write mode will send
2196 * the data as R1,V1,R2,V2,..,Rn,Vn on the target bus. The target device
2197 * must of course support the mode.
2199 * A value of zero will be returned on success, a negative errno will be
2200 * returned in error cases.
2202 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
2207 map->lock(map->lock_arg);
2209 ret = _regmap_multi_reg_write(map, regs, num_regs);
2211 map->unlock(map->lock_arg);
2215 EXPORT_SYMBOL_GPL(regmap_multi_reg_write);
2218 * regmap_multi_reg_write_bypassed() - Write multiple registers to the
2219 * device but not the cache
2221 * @map: Register map to write to
2222 * @regs: Array of structures containing register,value to be written
2223 * @num_regs: Number of registers to write
2225 * Write multiple registers to the device but not the cache where the set
2226 * of register are supplied in any order.
2228 * This function is intended to be used for writing a large block of data
2229 * atomically to the device in single transfer for those I2C client devices
2230 * that implement this alternative block write mode.
2232 * A value of zero will be returned on success, a negative errno will
2233 * be returned in error cases.
2235 int regmap_multi_reg_write_bypassed(struct regmap *map,
2236 const struct reg_sequence *regs,
2242 map->lock(map->lock_arg);
2244 bypass = map->cache_bypass;
2245 map->cache_bypass = true;
2247 ret = _regmap_multi_reg_write(map, regs, num_regs);
2249 map->cache_bypass = bypass;
2251 map->unlock(map->lock_arg);
2255 EXPORT_SYMBOL_GPL(regmap_multi_reg_write_bypassed);
2258 * regmap_raw_write_async() - Write raw values to one or more registers
2261 * @map: Register map to write to
2262 * @reg: Initial register to write to
2263 * @val: Block of data to be written, laid out for direct transmission to the
2264 * device. Must be valid until regmap_async_complete() is called.
2265 * @val_len: Length of data pointed to by val.
2267 * This function is intended to be used for things like firmware
2268 * download where a large block of data needs to be transferred to the
2269 * device. No formatting will be done on the data provided.
2271 * If supported by the underlying bus the write will be scheduled
2272 * asynchronously, helping maximise I/O speed on higher speed buses
2273 * like SPI. regmap_async_complete() can be called to ensure that all
2274 * asynchrnous writes have been completed.
2276 * A value of zero will be returned on success, a negative errno will
2277 * be returned in error cases.
2279 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
2280 const void *val, size_t val_len)
2284 if (val_len % map->format.val_bytes)
2286 if (!IS_ALIGNED(reg, map->reg_stride))
2289 map->lock(map->lock_arg);
2293 ret = _regmap_raw_write(map, reg, val, val_len);
2297 map->unlock(map->lock_arg);
2301 EXPORT_SYMBOL_GPL(regmap_raw_write_async);
2303 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2304 unsigned int val_len)
2306 struct regmap_range_node *range;
2311 if (!map->bus || !map->bus->read)
2314 range = _regmap_range_lookup(map, reg);
2316 ret = _regmap_select_page(map, ®, range,
2317 val_len / map->format.val_bytes);
2322 map->format.format_reg(map->work_buf, reg, map->reg_shift);
2323 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
2324 map->read_flag_mask);
2325 trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
2327 ret = map->bus->read(map->bus_context, map->work_buf,
2328 map->format.reg_bytes + map->format.pad_bytes,
2331 trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
2336 static int _regmap_bus_reg_read(void *context, unsigned int reg,
2339 struct regmap *map = context;
2341 return map->bus->reg_read(map->bus_context, reg, val);
2344 static int _regmap_bus_read(void *context, unsigned int reg,
2348 struct regmap *map = context;
2350 if (!map->format.parse_val)
2353 ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
2355 *val = map->format.parse_val(map->work_buf);
2360 static int _regmap_read(struct regmap *map, unsigned int reg,
2364 void *context = _regmap_map_get_context(map);
2366 if (!map->cache_bypass) {
2367 ret = regcache_read(map, reg, val);
2372 if (map->cache_only)
2375 if (!regmap_readable(map, reg))
2378 ret = map->reg_read(context, reg, val);
2381 if (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
2382 dev_info(map->dev, "%x => %x\n", reg, *val);
2385 trace_regmap_reg_read(map, reg, *val);
2387 if (!map->cache_bypass)
2388 regcache_write(map, reg, *val);
2395 * regmap_read() - Read a value from a single register
2397 * @map: Register map to read from
2398 * @reg: Register to be read from
2399 * @val: Pointer to store read value
2401 * A value of zero will be returned on success, a negative errno will
2402 * be returned in error cases.
2404 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
2408 if (!IS_ALIGNED(reg, map->reg_stride))
2411 map->lock(map->lock_arg);
2413 ret = _regmap_read(map, reg, val);
2415 map->unlock(map->lock_arg);
2419 EXPORT_SYMBOL_GPL(regmap_read);
2422 * regmap_raw_read() - Read raw data from the device
2424 * @map: Register map to read from
2425 * @reg: First register to be read from
2426 * @val: Pointer to store read value
2427 * @val_len: Size of data to read
2429 * A value of zero will be returned on success, a negative errno will
2430 * be returned in error cases.
2432 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2435 size_t val_bytes = map->format.val_bytes;
2436 size_t val_count = val_len / val_bytes;
2442 if (val_len % map->format.val_bytes)
2444 if (!IS_ALIGNED(reg, map->reg_stride))
2449 map->lock(map->lock_arg);
2451 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
2452 map->cache_type == REGCACHE_NONE) {
2453 if (!map->bus->read) {
2457 if (map->max_raw_read && map->max_raw_read < val_len) {
2462 /* Physical block read if there's no cache involved */
2463 ret = _regmap_raw_read(map, reg, val, val_len);
2466 /* Otherwise go word by word for the cache; should be low
2467 * cost as we expect to hit the cache.
2469 for (i = 0; i < val_count; i++) {
2470 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2475 map->format.format_val(val + (i * val_bytes), v, 0);
2480 map->unlock(map->lock_arg);
2484 EXPORT_SYMBOL_GPL(regmap_raw_read);
2487 * regmap_field_read() - Read a value to a single register field
2489 * @field: Register field to read from
2490 * @val: Pointer to store read value
2492 * A value of zero will be returned on success, a negative errno will
2493 * be returned in error cases.
2495 int regmap_field_read(struct regmap_field *field, unsigned int *val)
2498 unsigned int reg_val;
2499 ret = regmap_read(field->regmap, field->reg, ®_val);
2503 reg_val &= field->mask;
2504 reg_val >>= field->shift;
2509 EXPORT_SYMBOL_GPL(regmap_field_read);
2512 * regmap_fields_read() - Read a value to a single register field with port ID
2514 * @field: Register field to read from
2516 * @val: Pointer to store read value
2518 * A value of zero will be returned on success, a negative errno will
2519 * be returned in error cases.
2521 int regmap_fields_read(struct regmap_field *field, unsigned int id,
2525 unsigned int reg_val;
2527 if (id >= field->id_size)
2530 ret = regmap_read(field->regmap,
2531 field->reg + (field->id_offset * id),
2536 reg_val &= field->mask;
2537 reg_val >>= field->shift;
2542 EXPORT_SYMBOL_GPL(regmap_fields_read);
2545 * regmap_bulk_read() - Read multiple registers from the device
2547 * @map: Register map to read from
2548 * @reg: First register to be read from
2549 * @val: Pointer to store read value, in native register size for device
2550 * @val_count: Number of registers to read
2552 * A value of zero will be returned on success, a negative errno will
2553 * be returned in error cases.
2555 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
2559 size_t val_bytes = map->format.val_bytes;
2560 bool vol = regmap_volatile_range(map, reg, val_count);
2562 if (!IS_ALIGNED(reg, map->reg_stride))
2565 if (map->bus && map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
2567 * Some devices does not support bulk read, for
2568 * them we have a series of single read operations.
2570 size_t total_size = val_bytes * val_count;
2572 if (!map->use_single_read &&
2573 (!map->max_raw_read || map->max_raw_read > total_size)) {
2574 ret = regmap_raw_read(map, reg, val,
2575 val_bytes * val_count);
2580 * Some devices do not support bulk read or do not
2581 * support large bulk reads, for them we have a series
2582 * of read operations.
2584 int chunk_stride = map->reg_stride;
2585 size_t chunk_size = val_bytes;
2586 size_t chunk_count = val_count;
2588 if (!map->use_single_read) {
2589 chunk_size = map->max_raw_read;
2590 if (chunk_size % val_bytes)
2591 chunk_size -= chunk_size % val_bytes;
2592 chunk_count = total_size / chunk_size;
2593 chunk_stride *= chunk_size / val_bytes;
2596 /* Read bytes that fit into a multiple of chunk_size */
2597 for (i = 0; i < chunk_count; i++) {
2598 ret = regmap_raw_read(map,
2599 reg + (i * chunk_stride),
2600 val + (i * chunk_size),
2606 /* Read remaining bytes */
2607 if (chunk_size * i < total_size) {
2608 ret = regmap_raw_read(map,
2609 reg + (i * chunk_stride),
2610 val + (i * chunk_size),
2611 total_size - i * chunk_size);
2617 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2618 map->format.parse_inplace(val + i);
2620 for (i = 0; i < val_count; i++) {
2622 ret = regmap_read(map, reg + regmap_get_offset(map, i),
2627 if (map->format.format_val) {
2628 map->format.format_val(val + (i * val_bytes), ival, 0);
2630 /* Devices providing read and write
2631 * operations can use the bulk I/O
2632 * functions if they define a val_bytes,
2633 * we assume that the values are native
2643 switch (map->format.val_bytes) {
2667 EXPORT_SYMBOL_GPL(regmap_bulk_read);
2669 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
2670 unsigned int mask, unsigned int val,
2671 bool *change, bool force_write)
2674 unsigned int tmp, orig;
2679 if (regmap_volatile(map, reg) && map->reg_update_bits) {
2680 ret = map->reg_update_bits(map->bus_context, reg, mask, val);
2681 if (ret == 0 && change)
2684 ret = _regmap_read(map, reg, &orig);
2691 if (force_write || (tmp != orig)) {
2692 ret = _regmap_write(map, reg, tmp);
2693 if (ret == 0 && change)
2702 * regmap_update_bits_base() - Perform a read/modify/write cycle on a register
2704 * @map: Register map to update
2705 * @reg: Register to update
2706 * @mask: Bitmask to change
2707 * @val: New value for bitmask
2708 * @change: Boolean indicating if a write was done
2709 * @async: Boolean indicating asynchronously
2710 * @force: Boolean indicating use force update
2712 * Perform a read/modify/write cycle on a register map with change, async, force
2717 * With most buses the read must be done synchronously so this is most useful
2718 * for devices with a cache which do not need to interact with the hardware to
2719 * determine the current register value.
2721 * Returns zero for success, a negative number on error.
2723 int regmap_update_bits_base(struct regmap *map, unsigned int reg,
2724 unsigned int mask, unsigned int val,
2725 bool *change, bool async, bool force)
2729 map->lock(map->lock_arg);
2733 ret = _regmap_update_bits(map, reg, mask, val, change, force);
2737 map->unlock(map->lock_arg);
2741 EXPORT_SYMBOL_GPL(regmap_update_bits_base);
2743 void regmap_async_complete_cb(struct regmap_async *async, int ret)
2745 struct regmap *map = async->map;
2748 trace_regmap_async_io_complete(map);
2750 spin_lock(&map->async_lock);
2751 list_move(&async->list, &map->async_free);
2752 wake = list_empty(&map->async_list);
2755 map->async_ret = ret;
2757 spin_unlock(&map->async_lock);
2760 wake_up(&map->async_waitq);
2762 EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
2764 static int regmap_async_is_done(struct regmap *map)
2766 unsigned long flags;
2769 spin_lock_irqsave(&map->async_lock, flags);
2770 ret = list_empty(&map->async_list);
2771 spin_unlock_irqrestore(&map->async_lock, flags);
2777 * regmap_async_complete - Ensure all asynchronous I/O has completed.
2779 * @map: Map to operate on.
2781 * Blocks until any pending asynchronous I/O has completed. Returns
2782 * an error code for any failed I/O operations.
2784 int regmap_async_complete(struct regmap *map)
2786 unsigned long flags;
2789 /* Nothing to do with no async support */
2790 if (!map->bus || !map->bus->async_write)
2793 trace_regmap_async_complete_start(map);
2795 wait_event(map->async_waitq, regmap_async_is_done(map));
2797 spin_lock_irqsave(&map->async_lock, flags);
2798 ret = map->async_ret;
2800 spin_unlock_irqrestore(&map->async_lock, flags);
2802 trace_regmap_async_complete_done(map);
2806 EXPORT_SYMBOL_GPL(regmap_async_complete);
2809 * regmap_register_patch - Register and apply register updates to be applied
2810 * on device initialistion
2812 * @map: Register map to apply updates to.
2813 * @regs: Values to update.
2814 * @num_regs: Number of entries in regs.
2816 * Register a set of register updates to be applied to the device
2817 * whenever the device registers are synchronised with the cache and
2818 * apply them immediately. Typically this is used to apply
2819 * corrections to be applied to the device defaults on startup, such
2820 * as the updates some vendors provide to undocumented registers.
2822 * The caller must ensure that this function cannot be called
2823 * concurrently with either itself or regcache_sync().
2825 int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
2828 struct reg_sequence *p;
2832 if (WARN_ONCE(num_regs <= 0, "invalid registers number (%d)\n",
2836 p = krealloc(map->patch,
2837 sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
2840 memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
2842 map->patch_regs += num_regs;
2847 map->lock(map->lock_arg);
2849 bypass = map->cache_bypass;
2851 map->cache_bypass = true;
2854 ret = _regmap_multi_reg_write(map, regs, num_regs);
2857 map->cache_bypass = bypass;
2859 map->unlock(map->lock_arg);
2861 regmap_async_complete(map);
2865 EXPORT_SYMBOL_GPL(regmap_register_patch);
2868 * regmap_get_val_bytes() - Report the size of a register value
2870 * @map: Register map to operate on.
2872 * Report the size of a register value, mainly intended to for use by
2873 * generic infrastructure built on top of regmap.
2875 int regmap_get_val_bytes(struct regmap *map)
2877 if (map->format.format_write)
2880 return map->format.val_bytes;
2882 EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
2885 * regmap_get_max_register() - Report the max register value
2887 * @map: Register map to operate on.
2889 * Report the max register value, mainly intended to for use by
2890 * generic infrastructure built on top of regmap.
2892 int regmap_get_max_register(struct regmap *map)
2894 return map->max_register ? map->max_register : -EINVAL;
2896 EXPORT_SYMBOL_GPL(regmap_get_max_register);
2899 * regmap_get_reg_stride() - Report the register address stride
2901 * @map: Register map to operate on.
2903 * Report the register address stride, mainly intended to for use by
2904 * generic infrastructure built on top of regmap.
2906 int regmap_get_reg_stride(struct regmap *map)
2908 return map->reg_stride;
2910 EXPORT_SYMBOL_GPL(regmap_get_reg_stride);
2912 int regmap_parse_val(struct regmap *map, const void *buf,
2915 if (!map->format.parse_val)
2918 *val = map->format.parse_val(buf);
2922 EXPORT_SYMBOL_GPL(regmap_parse_val);
2924 static int __init regmap_initcall(void)
2926 regmap_debugfs_initcall();
2930 postcore_initcall(regmap_initcall);