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 == 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 (*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",
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,
1513 /* If that didn't work fall back on linearising by hand. */
1514 if (ret == -ENOTSUPP) {
1515 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
1516 buf = kzalloc(len, GFP_KERNEL);
1520 memcpy(buf, map->work_buf, map->format.reg_bytes);
1521 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
1523 ret = map->bus->write(map->bus_context, buf, len);
1526 } else if (ret != 0 && !map->cache_bypass && map->format.parse_val) {
1527 /* regcache_drop_region() takes lock that we already have,
1528 * thus call map->cache_ops->drop() directly
1530 if (map->cache_ops && map->cache_ops->drop)
1531 map->cache_ops->drop(map, reg, reg + 1);
1534 trace_regmap_hw_write_done(map, reg, val_len / map->format.val_bytes);
1540 * regmap_can_raw_write - Test if regmap_raw_write() is supported
1542 * @map: Map to check.
1544 bool regmap_can_raw_write(struct regmap *map)
1546 return map->bus && map->bus->write && map->format.format_val &&
1547 map->format.format_reg;
1549 EXPORT_SYMBOL_GPL(regmap_can_raw_write);
1552 * regmap_get_raw_read_max - Get the maximum size we can read
1554 * @map: Map to check.
1556 size_t regmap_get_raw_read_max(struct regmap *map)
1558 return map->max_raw_read;
1560 EXPORT_SYMBOL_GPL(regmap_get_raw_read_max);
1563 * regmap_get_raw_write_max - Get the maximum size we can read
1565 * @map: Map to check.
1567 size_t regmap_get_raw_write_max(struct regmap *map)
1569 return map->max_raw_write;
1571 EXPORT_SYMBOL_GPL(regmap_get_raw_write_max);
1573 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
1577 struct regmap_range_node *range;
1578 struct regmap *map = context;
1580 WARN_ON(!map->bus || !map->format.format_write);
1582 range = _regmap_range_lookup(map, reg);
1584 ret = _regmap_select_page(map, ®, range, 1);
1589 map->format.format_write(map, reg, val);
1591 trace_regmap_hw_write_start(map, reg, 1);
1593 ret = map->bus->write(map->bus_context, map->work_buf,
1594 map->format.buf_size);
1596 trace_regmap_hw_write_done(map, reg, 1);
1601 static int _regmap_bus_reg_write(void *context, unsigned int reg,
1604 struct regmap *map = context;
1606 return map->bus->reg_write(map->bus_context, reg, val);
1609 static int _regmap_bus_raw_write(void *context, unsigned int reg,
1612 struct regmap *map = context;
1614 WARN_ON(!map->bus || !map->format.format_val);
1616 map->format.format_val(map->work_buf + map->format.reg_bytes
1617 + map->format.pad_bytes, val, 0);
1618 return _regmap_raw_write(map, reg,
1620 map->format.reg_bytes +
1621 map->format.pad_bytes,
1622 map->format.val_bytes);
1625 static inline void *_regmap_map_get_context(struct regmap *map)
1627 return (map->bus) ? map : map->bus_context;
1630 int _regmap_write(struct regmap *map, unsigned int reg,
1634 void *context = _regmap_map_get_context(map);
1636 if (!regmap_writeable(map, reg))
1639 if (!map->cache_bypass && !map->defer_caching) {
1640 ret = regcache_write(map, reg, val);
1643 if (map->cache_only) {
1644 map->cache_dirty = true;
1650 if (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
1651 dev_info(map->dev, "%x <= %x\n", reg, val);
1654 trace_regmap_reg_write(map, reg, val);
1656 return map->reg_write(context, reg, val);
1660 * regmap_write() - Write a value to a single register
1662 * @map: Register map to write to
1663 * @reg: Register to write to
1664 * @val: Value to be written
1666 * A value of zero will be returned on success, a negative errno will
1667 * be returned in error cases.
1669 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1673 if (!IS_ALIGNED(reg, map->reg_stride))
1676 map->lock(map->lock_arg);
1678 ret = _regmap_write(map, reg, val);
1680 map->unlock(map->lock_arg);
1684 EXPORT_SYMBOL_GPL(regmap_write);
1687 * regmap_write_async() - Write a value to a single register asynchronously
1689 * @map: Register map to write to
1690 * @reg: Register to write to
1691 * @val: Value to be written
1693 * A value of zero will be returned on success, a negative errno will
1694 * be returned in error cases.
1696 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val)
1700 if (!IS_ALIGNED(reg, map->reg_stride))
1703 map->lock(map->lock_arg);
1707 ret = _regmap_write(map, reg, val);
1711 map->unlock(map->lock_arg);
1715 EXPORT_SYMBOL_GPL(regmap_write_async);
1718 * regmap_raw_write() - Write raw values to one or more registers
1720 * @map: Register map to write to
1721 * @reg: Initial register to write to
1722 * @val: Block of data to be written, laid out for direct transmission to the
1724 * @val_len: Length of data pointed to by val.
1726 * This function is intended to be used for things like firmware
1727 * download where a large block of data needs to be transferred to the
1728 * device. No formatting will be done on the data provided.
1730 * A value of zero will be returned on success, a negative errno will
1731 * be returned in error cases.
1733 int regmap_raw_write(struct regmap *map, unsigned int reg,
1734 const void *val, size_t val_len)
1738 if (!regmap_can_raw_write(map))
1740 if (val_len % map->format.val_bytes)
1742 if (map->max_raw_write && map->max_raw_write > val_len)
1745 map->lock(map->lock_arg);
1747 ret = _regmap_raw_write(map, reg, val, val_len);
1749 map->unlock(map->lock_arg);
1753 EXPORT_SYMBOL_GPL(regmap_raw_write);
1756 * regmap_field_update_bits_base() - Perform a read/modify/write cycle a
1759 * @field: Register field to write to
1760 * @mask: Bitmask to change
1761 * @val: Value to be written
1762 * @change: Boolean indicating if a write was done
1763 * @async: Boolean indicating asynchronously
1764 * @force: Boolean indicating use force update
1766 * Perform a read/modify/write cycle on the register field with change,
1767 * async, force option.
1769 * A value of zero will be returned on success, a negative errno will
1770 * be returned in error cases.
1772 int regmap_field_update_bits_base(struct regmap_field *field,
1773 unsigned int mask, unsigned int val,
1774 bool *change, bool async, bool force)
1776 mask = (mask << field->shift) & field->mask;
1778 return regmap_update_bits_base(field->regmap, field->reg,
1779 mask, val << field->shift,
1780 change, async, force);
1782 EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);
1785 * regmap_fields_update_bits_base() - Perform a read/modify/write cycle a
1786 * register field with port ID
1788 * @field: Register field to write to
1790 * @mask: Bitmask to change
1791 * @val: Value to be written
1792 * @change: Boolean indicating if a write was done
1793 * @async: Boolean indicating asynchronously
1794 * @force: Boolean indicating use force update
1796 * A value of zero will be returned on success, a negative errno will
1797 * be returned in error cases.
1799 int regmap_fields_update_bits_base(struct regmap_field *field, unsigned int id,
1800 unsigned int mask, unsigned int val,
1801 bool *change, bool async, bool force)
1803 if (id >= field->id_size)
1806 mask = (mask << field->shift) & field->mask;
1808 return regmap_update_bits_base(field->regmap,
1809 field->reg + (field->id_offset * id),
1810 mask, val << field->shift,
1811 change, async, force);
1813 EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);
1816 * regmap_bulk_write() - Write multiple registers to the device
1818 * @map: Register map to write to
1819 * @reg: First register to be write from
1820 * @val: Block of data to be written, in native register size for device
1821 * @val_count: Number of registers to write
1823 * This function is intended to be used for writing a large block of
1824 * data to the device either in single transfer or multiple transfer.
1826 * A value of zero will be returned on success, a negative errno will
1827 * be returned in error cases.
1829 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
1833 size_t val_bytes = map->format.val_bytes;
1834 size_t total_size = val_bytes * val_count;
1836 if (!IS_ALIGNED(reg, map->reg_stride))
1840 * Some devices don't support bulk write, for
1841 * them we have a series of single write operations in the first two if
1844 * The first if block is used for memory mapped io. It does not allow
1845 * val_bytes of 3 for example.
1846 * The second one is for busses that do not provide raw I/O.
1847 * The third one is used for busses which do not have these limitations
1848 * and can write arbitrary value lengths.
1851 map->lock(map->lock_arg);
1852 for (i = 0; i < val_count; i++) {
1855 switch (val_bytes) {
1857 ival = *(u8 *)(val + (i * val_bytes));
1860 ival = *(u16 *)(val + (i * val_bytes));
1863 ival = *(u32 *)(val + (i * val_bytes));
1867 ival = *(u64 *)(val + (i * val_bytes));
1875 ret = _regmap_write(map,
1876 reg + regmap_get_offset(map, i),
1882 map->unlock(map->lock_arg);
1883 } else if (map->bus && !map->format.parse_inplace) {
1885 const u16 *u16 = val;
1886 const u32 *u32 = val;
1889 for (i = 0; i < val_count; i++) {
1890 switch (map->format.val_bytes) {
1904 ret = regmap_write(map, reg + (i * map->reg_stride),
1909 } else if (map->use_single_write ||
1910 (map->max_raw_write && map->max_raw_write < total_size)) {
1911 int chunk_stride = map->reg_stride;
1912 size_t chunk_size = val_bytes;
1913 size_t chunk_count = val_count;
1915 if (!map->use_single_write) {
1916 chunk_size = map->max_raw_write;
1917 if (chunk_size % val_bytes)
1918 chunk_size -= chunk_size % val_bytes;
1919 chunk_count = total_size / chunk_size;
1920 chunk_stride *= chunk_size / val_bytes;
1923 map->lock(map->lock_arg);
1924 /* Write as many bytes as possible with chunk_size */
1925 for (i = 0; i < chunk_count; i++) {
1926 ret = _regmap_raw_write(map,
1927 reg + (i * chunk_stride),
1928 val + (i * chunk_size),
1934 /* Write remaining bytes */
1935 if (!ret && chunk_size * i < total_size) {
1936 ret = _regmap_raw_write(map, reg + (i * chunk_stride),
1937 val + (i * chunk_size),
1938 total_size - i * chunk_size);
1940 map->unlock(map->lock_arg);
1947 wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
1949 dev_err(map->dev, "Error in memory allocation\n");
1952 for (i = 0; i < val_count * val_bytes; i += val_bytes)
1953 map->format.parse_inplace(wval + i);
1955 map->lock(map->lock_arg);
1956 ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count);
1957 map->unlock(map->lock_arg);
1963 EXPORT_SYMBOL_GPL(regmap_bulk_write);
1966 * _regmap_raw_multi_reg_write()
1968 * the (register,newvalue) pairs in regs have not been formatted, but
1969 * they are all in the same page and have been changed to being page
1970 * relative. The page register has been written if that was necessary.
1972 static int _regmap_raw_multi_reg_write(struct regmap *map,
1973 const struct reg_sequence *regs,
1980 size_t val_bytes = map->format.val_bytes;
1981 size_t reg_bytes = map->format.reg_bytes;
1982 size_t pad_bytes = map->format.pad_bytes;
1983 size_t pair_size = reg_bytes + pad_bytes + val_bytes;
1984 size_t len = pair_size * num_regs;
1989 buf = kzalloc(len, GFP_KERNEL);
1993 /* We have to linearise by hand. */
1997 for (i = 0; i < num_regs; i++) {
1998 unsigned int reg = regs[i].reg;
1999 unsigned int val = regs[i].def;
2000 trace_regmap_hw_write_start(map, reg, 1);
2001 map->format.format_reg(u8, reg, map->reg_shift);
2002 u8 += reg_bytes + pad_bytes;
2003 map->format.format_val(u8, val, 0);
2007 *u8 |= map->write_flag_mask;
2009 ret = map->bus->write(map->bus_context, buf, len);
2013 for (i = 0; i < num_regs; i++) {
2014 int reg = regs[i].reg;
2015 trace_regmap_hw_write_done(map, reg, 1);
2020 static unsigned int _regmap_register_page(struct regmap *map,
2022 struct regmap_range_node *range)
2024 unsigned int win_page = (reg - range->range_min) / range->window_len;
2029 static int _regmap_range_multi_paged_reg_write(struct regmap *map,
2030 struct reg_sequence *regs,
2035 struct reg_sequence *base;
2036 unsigned int this_page = 0;
2037 unsigned int page_change = 0;
2039 * the set of registers are not neccessarily in order, but
2040 * since the order of write must be preserved this algorithm
2041 * chops the set each time the page changes. This also applies
2042 * if there is a delay required at any point in the sequence.
2045 for (i = 0, n = 0; i < num_regs; i++, n++) {
2046 unsigned int reg = regs[i].reg;
2047 struct regmap_range_node *range;
2049 range = _regmap_range_lookup(map, reg);
2051 unsigned int win_page = _regmap_register_page(map, reg,
2055 this_page = win_page;
2056 if (win_page != this_page) {
2057 this_page = win_page;
2062 /* If we have both a page change and a delay make sure to
2063 * write the regs and apply the delay before we change the
2067 if (page_change || regs[i].delay_us) {
2069 /* For situations where the first write requires
2070 * a delay we need to make sure we don't call
2071 * raw_multi_reg_write with n=0
2072 * This can't occur with page breaks as we
2073 * never write on the first iteration
2075 if (regs[i].delay_us && i == 0)
2078 ret = _regmap_raw_multi_reg_write(map, base, n);
2082 if (regs[i].delay_us)
2083 udelay(regs[i].delay_us);
2089 ret = _regmap_select_page(map,
2102 return _regmap_raw_multi_reg_write(map, base, n);
2106 static int _regmap_multi_reg_write(struct regmap *map,
2107 const struct reg_sequence *regs,
2113 if (!map->can_multi_write) {
2114 for (i = 0; i < num_regs; i++) {
2115 ret = _regmap_write(map, regs[i].reg, regs[i].def);
2119 if (regs[i].delay_us)
2120 udelay(regs[i].delay_us);
2125 if (!map->format.parse_inplace)
2128 if (map->writeable_reg)
2129 for (i = 0; i < num_regs; i++) {
2130 int reg = regs[i].reg;
2131 if (!map->writeable_reg(map->dev, reg))
2133 if (!IS_ALIGNED(reg, map->reg_stride))
2137 if (!map->cache_bypass) {
2138 for (i = 0; i < num_regs; i++) {
2139 unsigned int val = regs[i].def;
2140 unsigned int reg = regs[i].reg;
2141 ret = regcache_write(map, reg, val);
2144 "Error in caching of register: %x ret: %d\n",
2149 if (map->cache_only) {
2150 map->cache_dirty = true;
2157 for (i = 0; i < num_regs; i++) {
2158 unsigned int reg = regs[i].reg;
2159 struct regmap_range_node *range;
2161 /* Coalesce all the writes between a page break or a delay
2164 range = _regmap_range_lookup(map, reg);
2165 if (range || regs[i].delay_us) {
2166 size_t len = sizeof(struct reg_sequence)*num_regs;
2167 struct reg_sequence *base = kmemdup(regs, len,
2171 ret = _regmap_range_multi_paged_reg_write(map, base,
2178 return _regmap_raw_multi_reg_write(map, regs, num_regs);
2182 * regmap_multi_reg_write() - Write multiple registers to the device
2184 * @map: Register map to write to
2185 * @regs: Array of structures containing register,value to be written
2186 * @num_regs: Number of registers to write
2188 * Write multiple registers to the device where the set of register, value
2189 * pairs are supplied in any order, possibly not all in a single range.
2191 * The 'normal' block write mode will send ultimately send data on the
2192 * target bus as R,V1,V2,V3,..,Vn where successively higher registers are
2193 * addressed. However, this alternative block multi write mode will send
2194 * the data as R1,V1,R2,V2,..,Rn,Vn on the target bus. The target device
2195 * must of course support the mode.
2197 * A value of zero will be returned on success, a negative errno will be
2198 * returned in error cases.
2200 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
2205 map->lock(map->lock_arg);
2207 ret = _regmap_multi_reg_write(map, regs, num_regs);
2209 map->unlock(map->lock_arg);
2213 EXPORT_SYMBOL_GPL(regmap_multi_reg_write);
2216 * regmap_multi_reg_write_bypassed() - Write multiple registers to the
2217 * device but not the cache
2219 * @map: Register map to write to
2220 * @regs: Array of structures containing register,value to be written
2221 * @num_regs: Number of registers to write
2223 * Write multiple registers to the device but not the cache where the set
2224 * of register are supplied in any order.
2226 * This function is intended to be used for writing a large block of data
2227 * atomically to the device in single transfer for those I2C client devices
2228 * that implement this alternative block write mode.
2230 * A value of zero will be returned on success, a negative errno will
2231 * be returned in error cases.
2233 int regmap_multi_reg_write_bypassed(struct regmap *map,
2234 const struct reg_sequence *regs,
2240 map->lock(map->lock_arg);
2242 bypass = map->cache_bypass;
2243 map->cache_bypass = true;
2245 ret = _regmap_multi_reg_write(map, regs, num_regs);
2247 map->cache_bypass = bypass;
2249 map->unlock(map->lock_arg);
2253 EXPORT_SYMBOL_GPL(regmap_multi_reg_write_bypassed);
2256 * regmap_raw_write_async() - Write raw values to one or more registers
2259 * @map: Register map to write to
2260 * @reg: Initial register to write to
2261 * @val: Block of data to be written, laid out for direct transmission to the
2262 * device. Must be valid until regmap_async_complete() is called.
2263 * @val_len: Length of data pointed to by val.
2265 * This function is intended to be used for things like firmware
2266 * download where a large block of data needs to be transferred to the
2267 * device. No formatting will be done on the data provided.
2269 * If supported by the underlying bus the write will be scheduled
2270 * asynchronously, helping maximise I/O speed on higher speed buses
2271 * like SPI. regmap_async_complete() can be called to ensure that all
2272 * asynchrnous writes have been completed.
2274 * A value of zero will be returned on success, a negative errno will
2275 * be returned in error cases.
2277 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
2278 const void *val, size_t val_len)
2282 if (val_len % map->format.val_bytes)
2284 if (!IS_ALIGNED(reg, map->reg_stride))
2287 map->lock(map->lock_arg);
2291 ret = _regmap_raw_write(map, reg, val, val_len);
2295 map->unlock(map->lock_arg);
2299 EXPORT_SYMBOL_GPL(regmap_raw_write_async);
2301 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2302 unsigned int val_len)
2304 struct regmap_range_node *range;
2309 if (!map->bus || !map->bus->read)
2312 range = _regmap_range_lookup(map, reg);
2314 ret = _regmap_select_page(map, ®, range,
2315 val_len / map->format.val_bytes);
2320 map->format.format_reg(map->work_buf, reg, map->reg_shift);
2321 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
2322 map->read_flag_mask);
2323 trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
2325 ret = map->bus->read(map->bus_context, map->work_buf,
2326 map->format.reg_bytes + map->format.pad_bytes,
2329 trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
2334 static int _regmap_bus_reg_read(void *context, unsigned int reg,
2337 struct regmap *map = context;
2339 return map->bus->reg_read(map->bus_context, reg, val);
2342 static int _regmap_bus_read(void *context, unsigned int reg,
2346 struct regmap *map = context;
2348 if (!map->format.parse_val)
2351 ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
2353 *val = map->format.parse_val(map->work_buf);
2358 static int _regmap_read(struct regmap *map, unsigned int reg,
2362 void *context = _regmap_map_get_context(map);
2364 if (!map->cache_bypass) {
2365 ret = regcache_read(map, reg, val);
2370 if (map->cache_only)
2373 if (!regmap_readable(map, reg))
2376 ret = map->reg_read(context, reg, val);
2379 if (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
2380 dev_info(map->dev, "%x => %x\n", reg, *val);
2383 trace_regmap_reg_read(map, reg, *val);
2385 if (!map->cache_bypass)
2386 regcache_write(map, reg, *val);
2393 * regmap_read() - Read a value from a single register
2395 * @map: Register map to read from
2396 * @reg: Register to be read from
2397 * @val: Pointer to store read value
2399 * A value of zero will be returned on success, a negative errno will
2400 * be returned in error cases.
2402 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
2406 if (!IS_ALIGNED(reg, map->reg_stride))
2409 map->lock(map->lock_arg);
2411 ret = _regmap_read(map, reg, val);
2413 map->unlock(map->lock_arg);
2417 EXPORT_SYMBOL_GPL(regmap_read);
2420 * regmap_raw_read() - Read raw data from the device
2422 * @map: Register map to read from
2423 * @reg: First register to be read from
2424 * @val: Pointer to store read value
2425 * @val_len: Size of data to read
2427 * A value of zero will be returned on success, a negative errno will
2428 * be returned in error cases.
2430 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2433 size_t val_bytes = map->format.val_bytes;
2434 size_t val_count = val_len / val_bytes;
2440 if (val_len % map->format.val_bytes)
2442 if (!IS_ALIGNED(reg, map->reg_stride))
2447 map->lock(map->lock_arg);
2449 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
2450 map->cache_type == REGCACHE_NONE) {
2451 if (!map->bus->read) {
2455 if (map->max_raw_read && map->max_raw_read < val_len) {
2460 /* Physical block read if there's no cache involved */
2461 ret = _regmap_raw_read(map, reg, val, val_len);
2464 /* Otherwise go word by word for the cache; should be low
2465 * cost as we expect to hit the cache.
2467 for (i = 0; i < val_count; i++) {
2468 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2473 map->format.format_val(val + (i * val_bytes), v, 0);
2478 map->unlock(map->lock_arg);
2482 EXPORT_SYMBOL_GPL(regmap_raw_read);
2485 * regmap_field_read() - Read a value to a single register field
2487 * @field: Register field to read from
2488 * @val: Pointer to store read value
2490 * A value of zero will be returned on success, a negative errno will
2491 * be returned in error cases.
2493 int regmap_field_read(struct regmap_field *field, unsigned int *val)
2496 unsigned int reg_val;
2497 ret = regmap_read(field->regmap, field->reg, ®_val);
2501 reg_val &= field->mask;
2502 reg_val >>= field->shift;
2507 EXPORT_SYMBOL_GPL(regmap_field_read);
2510 * regmap_fields_read() - Read a value to a single register field with port ID
2512 * @field: Register field to read from
2514 * @val: Pointer to store read value
2516 * A value of zero will be returned on success, a negative errno will
2517 * be returned in error cases.
2519 int regmap_fields_read(struct regmap_field *field, unsigned int id,
2523 unsigned int reg_val;
2525 if (id >= field->id_size)
2528 ret = regmap_read(field->regmap,
2529 field->reg + (field->id_offset * id),
2534 reg_val &= field->mask;
2535 reg_val >>= field->shift;
2540 EXPORT_SYMBOL_GPL(regmap_fields_read);
2543 * regmap_bulk_read() - Read multiple registers from the device
2545 * @map: Register map to read from
2546 * @reg: First register to be read from
2547 * @val: Pointer to store read value, in native register size for device
2548 * @val_count: Number of registers to read
2550 * A value of zero will be returned on success, a negative errno will
2551 * be returned in error cases.
2553 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
2557 size_t val_bytes = map->format.val_bytes;
2558 bool vol = regmap_volatile_range(map, reg, val_count);
2560 if (!IS_ALIGNED(reg, map->reg_stride))
2563 if (map->bus && map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
2565 * Some devices does not support bulk read, for
2566 * them we have a series of single read operations.
2568 size_t total_size = val_bytes * val_count;
2570 if (!map->use_single_read &&
2571 (!map->max_raw_read || map->max_raw_read > total_size)) {
2572 ret = regmap_raw_read(map, reg, val,
2573 val_bytes * val_count);
2578 * Some devices do not support bulk read or do not
2579 * support large bulk reads, for them we have a series
2580 * of read operations.
2582 int chunk_stride = map->reg_stride;
2583 size_t chunk_size = val_bytes;
2584 size_t chunk_count = val_count;
2586 if (!map->use_single_read) {
2587 chunk_size = map->max_raw_read;
2588 if (chunk_size % val_bytes)
2589 chunk_size -= chunk_size % val_bytes;
2590 chunk_count = total_size / chunk_size;
2591 chunk_stride *= chunk_size / val_bytes;
2594 /* Read bytes that fit into a multiple of chunk_size */
2595 for (i = 0; i < chunk_count; i++) {
2596 ret = regmap_raw_read(map,
2597 reg + (i * chunk_stride),
2598 val + (i * chunk_size),
2604 /* Read remaining bytes */
2605 if (chunk_size * i < total_size) {
2606 ret = regmap_raw_read(map,
2607 reg + (i * chunk_stride),
2608 val + (i * chunk_size),
2609 total_size - i * chunk_size);
2615 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2616 map->format.parse_inplace(val + i);
2618 for (i = 0; i < val_count; i++) {
2620 ret = regmap_read(map, reg + regmap_get_offset(map, i),
2625 if (map->format.format_val) {
2626 map->format.format_val(val + (i * val_bytes), ival, 0);
2628 /* Devices providing read and write
2629 * operations can use the bulk I/O
2630 * functions if they define a val_bytes,
2631 * we assume that the values are native
2641 switch (map->format.val_bytes) {
2665 EXPORT_SYMBOL_GPL(regmap_bulk_read);
2667 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
2668 unsigned int mask, unsigned int val,
2669 bool *change, bool force_write)
2672 unsigned int tmp, orig;
2677 if (regmap_volatile(map, reg) && map->reg_update_bits) {
2678 ret = map->reg_update_bits(map->bus_context, reg, mask, val);
2679 if (ret == 0 && change)
2682 ret = _regmap_read(map, reg, &orig);
2689 if (force_write || (tmp != orig)) {
2690 ret = _regmap_write(map, reg, tmp);
2691 if (ret == 0 && change)
2700 * regmap_update_bits_base() - Perform a read/modify/write cycle on a register
2702 * @map: Register map to update
2703 * @reg: Register to update
2704 * @mask: Bitmask to change
2705 * @val: New value for bitmask
2706 * @change: Boolean indicating if a write was done
2707 * @async: Boolean indicating asynchronously
2708 * @force: Boolean indicating use force update
2710 * Perform a read/modify/write cycle on a register map with change, async, force
2715 * With most buses the read must be done synchronously so this is most useful
2716 * for devices with a cache which do not need to interact with the hardware to
2717 * determine the current register value.
2719 * Returns zero for success, a negative number on error.
2721 int regmap_update_bits_base(struct regmap *map, unsigned int reg,
2722 unsigned int mask, unsigned int val,
2723 bool *change, bool async, bool force)
2727 map->lock(map->lock_arg);
2731 ret = _regmap_update_bits(map, reg, mask, val, change, force);
2735 map->unlock(map->lock_arg);
2739 EXPORT_SYMBOL_GPL(regmap_update_bits_base);
2741 void regmap_async_complete_cb(struct regmap_async *async, int ret)
2743 struct regmap *map = async->map;
2746 trace_regmap_async_io_complete(map);
2748 spin_lock(&map->async_lock);
2749 list_move(&async->list, &map->async_free);
2750 wake = list_empty(&map->async_list);
2753 map->async_ret = ret;
2755 spin_unlock(&map->async_lock);
2758 wake_up(&map->async_waitq);
2760 EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
2762 static int regmap_async_is_done(struct regmap *map)
2764 unsigned long flags;
2767 spin_lock_irqsave(&map->async_lock, flags);
2768 ret = list_empty(&map->async_list);
2769 spin_unlock_irqrestore(&map->async_lock, flags);
2775 * regmap_async_complete - Ensure all asynchronous I/O has completed.
2777 * @map: Map to operate on.
2779 * Blocks until any pending asynchronous I/O has completed. Returns
2780 * an error code for any failed I/O operations.
2782 int regmap_async_complete(struct regmap *map)
2784 unsigned long flags;
2787 /* Nothing to do with no async support */
2788 if (!map->bus || !map->bus->async_write)
2791 trace_regmap_async_complete_start(map);
2793 wait_event(map->async_waitq, regmap_async_is_done(map));
2795 spin_lock_irqsave(&map->async_lock, flags);
2796 ret = map->async_ret;
2798 spin_unlock_irqrestore(&map->async_lock, flags);
2800 trace_regmap_async_complete_done(map);
2804 EXPORT_SYMBOL_GPL(regmap_async_complete);
2807 * regmap_register_patch - Register and apply register updates to be applied
2808 * on device initialistion
2810 * @map: Register map to apply updates to.
2811 * @regs: Values to update.
2812 * @num_regs: Number of entries in regs.
2814 * Register a set of register updates to be applied to the device
2815 * whenever the device registers are synchronised with the cache and
2816 * apply them immediately. Typically this is used to apply
2817 * corrections to be applied to the device defaults on startup, such
2818 * as the updates some vendors provide to undocumented registers.
2820 * The caller must ensure that this function cannot be called
2821 * concurrently with either itself or regcache_sync().
2823 int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
2826 struct reg_sequence *p;
2830 if (WARN_ONCE(num_regs <= 0, "invalid registers number (%d)\n",
2834 p = krealloc(map->patch,
2835 sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
2838 memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
2840 map->patch_regs += num_regs;
2845 map->lock(map->lock_arg);
2847 bypass = map->cache_bypass;
2849 map->cache_bypass = true;
2852 ret = _regmap_multi_reg_write(map, regs, num_regs);
2855 map->cache_bypass = bypass;
2857 map->unlock(map->lock_arg);
2859 regmap_async_complete(map);
2863 EXPORT_SYMBOL_GPL(regmap_register_patch);
2866 * regmap_get_val_bytes() - Report the size of a register value
2868 * @map: Register map to operate on.
2870 * Report the size of a register value, mainly intended to for use by
2871 * generic infrastructure built on top of regmap.
2873 int regmap_get_val_bytes(struct regmap *map)
2875 if (map->format.format_write)
2878 return map->format.val_bytes;
2880 EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
2883 * regmap_get_max_register() - Report the max register value
2885 * @map: Register map to operate on.
2887 * Report the max register value, mainly intended to for use by
2888 * generic infrastructure built on top of regmap.
2890 int regmap_get_max_register(struct regmap *map)
2892 return map->max_register ? map->max_register : -EINVAL;
2894 EXPORT_SYMBOL_GPL(regmap_get_max_register);
2897 * regmap_get_reg_stride() - Report the register address stride
2899 * @map: Register map to operate on.
2901 * Report the register address stride, mainly intended to for use by
2902 * generic infrastructure built on top of regmap.
2904 int regmap_get_reg_stride(struct regmap *map)
2906 return map->reg_stride;
2908 EXPORT_SYMBOL_GPL(regmap_get_reg_stride);
2910 int regmap_parse_val(struct regmap *map, const void *buf,
2913 if (!map->format.parse_val)
2916 *val = map->format.parse_val(buf);
2920 EXPORT_SYMBOL_GPL(regmap_parse_val);
2922 static int __init regmap_initcall(void)
2924 regmap_debugfs_initcall();
2928 postcore_initcall(regmap_initcall);