1 // SPDX-License-Identifier: GPL-2.0
3 // Register map access API
5 // Copyright 2011 Wolfson Microelectronics plc
7 // Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
9 #include <linux/device.h>
10 #include <linux/slab.h>
11 #include <linux/export.h>
12 #include <linux/mutex.h>
13 #include <linux/err.h>
14 #include <linux/property.h>
15 #include <linux/rbtree.h>
16 #include <linux/sched.h>
17 #include <linux/delay.h>
18 #include <linux/log2.h>
19 #include <linux/hwspinlock.h>
20 #include <asm/unaligned.h>
22 #define CREATE_TRACE_POINTS
28 * Sometimes for failures during very early init the trace
29 * infrastructure isn't available early enough to be used. For this
30 * sort of problem defining LOG_DEVICE will add printks for basic
31 * register I/O on a specific device.
36 static inline bool regmap_should_log(struct regmap *map)
38 return (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0);
41 static inline bool regmap_should_log(struct regmap *map) { return false; }
45 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
46 unsigned int mask, unsigned int val,
47 bool *change, bool force_write);
49 static int _regmap_bus_reg_read(void *context, unsigned int reg,
51 static int _regmap_bus_read(void *context, unsigned int reg,
53 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
55 static int _regmap_bus_reg_write(void *context, unsigned int reg,
57 static int _regmap_bus_raw_write(void *context, unsigned int reg,
60 bool regmap_reg_in_ranges(unsigned int reg,
61 const struct regmap_range *ranges,
64 const struct regmap_range *r;
67 for (i = 0, r = ranges; i < nranges; i++, r++)
68 if (regmap_reg_in_range(reg, r))
72 EXPORT_SYMBOL_GPL(regmap_reg_in_ranges);
74 bool regmap_check_range_table(struct regmap *map, unsigned int reg,
75 const struct regmap_access_table *table)
77 /* Check "no ranges" first */
78 if (regmap_reg_in_ranges(reg, table->no_ranges, table->n_no_ranges))
81 /* In case zero "yes ranges" are supplied, any reg is OK */
82 if (!table->n_yes_ranges)
85 return regmap_reg_in_ranges(reg, table->yes_ranges,
88 EXPORT_SYMBOL_GPL(regmap_check_range_table);
90 bool regmap_writeable(struct regmap *map, unsigned int reg)
92 if (map->max_register && reg > map->max_register)
95 if (map->writeable_reg)
96 return map->writeable_reg(map->dev, reg);
99 return regmap_check_range_table(map, reg, map->wr_table);
104 bool regmap_cached(struct regmap *map, unsigned int reg)
109 if (map->cache_type == REGCACHE_NONE)
115 if (map->max_register && reg > map->max_register)
118 map->lock(map->lock_arg);
119 ret = regcache_read(map, reg, &val);
120 map->unlock(map->lock_arg);
127 bool regmap_readable(struct regmap *map, unsigned int reg)
132 if (map->max_register && reg > map->max_register)
135 if (map->format.format_write)
138 if (map->readable_reg)
139 return map->readable_reg(map->dev, reg);
142 return regmap_check_range_table(map, reg, map->rd_table);
147 bool regmap_volatile(struct regmap *map, unsigned int reg)
149 if (!map->format.format_write && !regmap_readable(map, reg))
152 if (map->volatile_reg)
153 return map->volatile_reg(map->dev, reg);
155 if (map->volatile_table)
156 return regmap_check_range_table(map, reg, map->volatile_table);
164 bool regmap_precious(struct regmap *map, unsigned int reg)
166 if (!regmap_readable(map, reg))
169 if (map->precious_reg)
170 return map->precious_reg(map->dev, reg);
172 if (map->precious_table)
173 return regmap_check_range_table(map, reg, map->precious_table);
178 bool regmap_writeable_noinc(struct regmap *map, unsigned int reg)
180 if (map->writeable_noinc_reg)
181 return map->writeable_noinc_reg(map->dev, reg);
183 if (map->wr_noinc_table)
184 return regmap_check_range_table(map, reg, map->wr_noinc_table);
189 bool regmap_readable_noinc(struct regmap *map, unsigned int reg)
191 if (map->readable_noinc_reg)
192 return map->readable_noinc_reg(map->dev, reg);
194 if (map->rd_noinc_table)
195 return regmap_check_range_table(map, reg, map->rd_noinc_table);
200 static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
205 for (i = 0; i < num; i++)
206 if (!regmap_volatile(map, reg + regmap_get_offset(map, i)))
212 static void regmap_format_12_20_write(struct regmap *map,
213 unsigned int reg, unsigned int val)
215 u8 *out = map->work_buf;
218 out[1] = (reg << 4) | (val >> 16);
224 static void regmap_format_2_6_write(struct regmap *map,
225 unsigned int reg, unsigned int val)
227 u8 *out = map->work_buf;
229 *out = (reg << 6) | val;
232 static void regmap_format_4_12_write(struct regmap *map,
233 unsigned int reg, unsigned int val)
235 __be16 *out = map->work_buf;
236 *out = cpu_to_be16((reg << 12) | val);
239 static void regmap_format_7_9_write(struct regmap *map,
240 unsigned int reg, unsigned int val)
242 __be16 *out = map->work_buf;
243 *out = cpu_to_be16((reg << 9) | val);
246 static void regmap_format_10_14_write(struct regmap *map,
247 unsigned int reg, unsigned int val)
249 u8 *out = map->work_buf;
252 out[1] = (val >> 8) | (reg << 6);
256 static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
263 static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
265 put_unaligned_be16(val << shift, buf);
268 static void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)
270 put_unaligned_le16(val << shift, buf);
273 static void regmap_format_16_native(void *buf, unsigned int val,
276 u16 v = val << shift;
278 memcpy(buf, &v, sizeof(v));
281 static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
292 static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
294 put_unaligned_be32(val << shift, buf);
297 static void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)
299 put_unaligned_le32(val << shift, buf);
302 static void regmap_format_32_native(void *buf, unsigned int val,
305 u32 v = val << shift;
307 memcpy(buf, &v, sizeof(v));
311 static void regmap_format_64_be(void *buf, unsigned int val, unsigned int shift)
313 put_unaligned_be64((u64) val << shift, buf);
316 static void regmap_format_64_le(void *buf, unsigned int val, unsigned int shift)
318 put_unaligned_le64((u64) val << shift, buf);
321 static void regmap_format_64_native(void *buf, unsigned int val,
324 u64 v = (u64) val << shift;
326 memcpy(buf, &v, sizeof(v));
330 static void regmap_parse_inplace_noop(void *buf)
334 static unsigned int regmap_parse_8(const void *buf)
341 static unsigned int regmap_parse_16_be(const void *buf)
343 return get_unaligned_be16(buf);
346 static unsigned int regmap_parse_16_le(const void *buf)
348 return get_unaligned_le16(buf);
351 static void regmap_parse_16_be_inplace(void *buf)
353 u16 v = get_unaligned_be16(buf);
355 memcpy(buf, &v, sizeof(v));
358 static void regmap_parse_16_le_inplace(void *buf)
360 u16 v = get_unaligned_le16(buf);
362 memcpy(buf, &v, sizeof(v));
365 static unsigned int regmap_parse_16_native(const void *buf)
369 memcpy(&v, buf, sizeof(v));
373 static unsigned int regmap_parse_24(const void *buf)
376 unsigned int ret = b[2];
377 ret |= ((unsigned int)b[1]) << 8;
378 ret |= ((unsigned int)b[0]) << 16;
383 static unsigned int regmap_parse_32_be(const void *buf)
385 return get_unaligned_be32(buf);
388 static unsigned int regmap_parse_32_le(const void *buf)
390 return get_unaligned_le32(buf);
393 static void regmap_parse_32_be_inplace(void *buf)
395 u32 v = get_unaligned_be32(buf);
397 memcpy(buf, &v, sizeof(v));
400 static void regmap_parse_32_le_inplace(void *buf)
402 u32 v = get_unaligned_le32(buf);
404 memcpy(buf, &v, sizeof(v));
407 static unsigned int regmap_parse_32_native(const void *buf)
411 memcpy(&v, buf, sizeof(v));
416 static unsigned int regmap_parse_64_be(const void *buf)
418 return get_unaligned_be64(buf);
421 static unsigned int regmap_parse_64_le(const void *buf)
423 return get_unaligned_le64(buf);
426 static void regmap_parse_64_be_inplace(void *buf)
428 u64 v = get_unaligned_be64(buf);
430 memcpy(buf, &v, sizeof(v));
433 static void regmap_parse_64_le_inplace(void *buf)
435 u64 v = get_unaligned_le64(buf);
437 memcpy(buf, &v, sizeof(v));
440 static unsigned int regmap_parse_64_native(const void *buf)
444 memcpy(&v, buf, sizeof(v));
449 static void regmap_lock_hwlock(void *__map)
451 struct regmap *map = __map;
453 hwspin_lock_timeout(map->hwlock, UINT_MAX);
456 static void regmap_lock_hwlock_irq(void *__map)
458 struct regmap *map = __map;
460 hwspin_lock_timeout_irq(map->hwlock, UINT_MAX);
463 static void regmap_lock_hwlock_irqsave(void *__map)
465 struct regmap *map = __map;
467 hwspin_lock_timeout_irqsave(map->hwlock, UINT_MAX,
468 &map->spinlock_flags);
471 static void regmap_unlock_hwlock(void *__map)
473 struct regmap *map = __map;
475 hwspin_unlock(map->hwlock);
478 static void regmap_unlock_hwlock_irq(void *__map)
480 struct regmap *map = __map;
482 hwspin_unlock_irq(map->hwlock);
485 static void regmap_unlock_hwlock_irqrestore(void *__map)
487 struct regmap *map = __map;
489 hwspin_unlock_irqrestore(map->hwlock, &map->spinlock_flags);
492 static void regmap_lock_unlock_none(void *__map)
497 static void regmap_lock_mutex(void *__map)
499 struct regmap *map = __map;
500 mutex_lock(&map->mutex);
503 static void regmap_unlock_mutex(void *__map)
505 struct regmap *map = __map;
506 mutex_unlock(&map->mutex);
509 static void regmap_lock_spinlock(void *__map)
510 __acquires(&map->spinlock)
512 struct regmap *map = __map;
515 spin_lock_irqsave(&map->spinlock, flags);
516 map->spinlock_flags = flags;
519 static void regmap_unlock_spinlock(void *__map)
520 __releases(&map->spinlock)
522 struct regmap *map = __map;
523 spin_unlock_irqrestore(&map->spinlock, map->spinlock_flags);
526 static void dev_get_regmap_release(struct device *dev, void *res)
529 * We don't actually have anything to do here; the goal here
530 * is not to manage the regmap but to provide a simple way to
531 * get the regmap back given a struct device.
535 static bool _regmap_range_add(struct regmap *map,
536 struct regmap_range_node *data)
538 struct rb_root *root = &map->range_tree;
539 struct rb_node **new = &(root->rb_node), *parent = NULL;
542 struct regmap_range_node *this =
543 rb_entry(*new, struct regmap_range_node, node);
546 if (data->range_max < this->range_min)
547 new = &((*new)->rb_left);
548 else if (data->range_min > this->range_max)
549 new = &((*new)->rb_right);
554 rb_link_node(&data->node, parent, new);
555 rb_insert_color(&data->node, root);
560 static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
563 struct rb_node *node = map->range_tree.rb_node;
566 struct regmap_range_node *this =
567 rb_entry(node, struct regmap_range_node, node);
569 if (reg < this->range_min)
570 node = node->rb_left;
571 else if (reg > this->range_max)
572 node = node->rb_right;
580 static void regmap_range_exit(struct regmap *map)
582 struct rb_node *next;
583 struct regmap_range_node *range_node;
585 next = rb_first(&map->range_tree);
587 range_node = rb_entry(next, struct regmap_range_node, node);
588 next = rb_next(&range_node->node);
589 rb_erase(&range_node->node, &map->range_tree);
593 kfree(map->selector_work_buf);
596 static int regmap_set_name(struct regmap *map, const struct regmap_config *config)
599 const char *name = kstrdup_const(config->name, GFP_KERNEL);
604 kfree_const(map->name);
611 int regmap_attach_dev(struct device *dev, struct regmap *map,
612 const struct regmap_config *config)
619 ret = regmap_set_name(map, config);
623 regmap_debugfs_init(map);
625 /* Add a devres resource for dev_get_regmap() */
626 m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
628 regmap_debugfs_exit(map);
636 EXPORT_SYMBOL_GPL(regmap_attach_dev);
638 static enum regmap_endian regmap_get_reg_endian(const struct regmap_bus *bus,
639 const struct regmap_config *config)
641 enum regmap_endian endian;
643 /* Retrieve the endianness specification from the regmap config */
644 endian = config->reg_format_endian;
646 /* If the regmap config specified a non-default value, use that */
647 if (endian != REGMAP_ENDIAN_DEFAULT)
650 /* Retrieve the endianness specification from the bus config */
651 if (bus && bus->reg_format_endian_default)
652 endian = bus->reg_format_endian_default;
654 /* If the bus specified a non-default value, use that */
655 if (endian != REGMAP_ENDIAN_DEFAULT)
658 /* Use this if no other value was found */
659 return REGMAP_ENDIAN_BIG;
662 enum regmap_endian regmap_get_val_endian(struct device *dev,
663 const struct regmap_bus *bus,
664 const struct regmap_config *config)
666 struct fwnode_handle *fwnode = dev ? dev_fwnode(dev) : NULL;
667 enum regmap_endian endian;
669 /* Retrieve the endianness specification from the regmap config */
670 endian = config->val_format_endian;
672 /* If the regmap config specified a non-default value, use that */
673 if (endian != REGMAP_ENDIAN_DEFAULT)
676 /* If the firmware node exist try to get endianness from it */
677 if (fwnode_property_read_bool(fwnode, "big-endian"))
678 endian = REGMAP_ENDIAN_BIG;
679 else if (fwnode_property_read_bool(fwnode, "little-endian"))
680 endian = REGMAP_ENDIAN_LITTLE;
681 else if (fwnode_property_read_bool(fwnode, "native-endian"))
682 endian = REGMAP_ENDIAN_NATIVE;
684 /* If the endianness was specified in fwnode, use that */
685 if (endian != REGMAP_ENDIAN_DEFAULT)
688 /* Retrieve the endianness specification from the bus config */
689 if (bus && bus->val_format_endian_default)
690 endian = bus->val_format_endian_default;
692 /* If the bus specified a non-default value, use that */
693 if (endian != REGMAP_ENDIAN_DEFAULT)
696 /* Use this if no other value was found */
697 return REGMAP_ENDIAN_BIG;
699 EXPORT_SYMBOL_GPL(regmap_get_val_endian);
701 struct regmap *__regmap_init(struct device *dev,
702 const struct regmap_bus *bus,
704 const struct regmap_config *config,
705 struct lock_class_key *lock_key,
706 const char *lock_name)
710 enum regmap_endian reg_endian, val_endian;
716 map = kzalloc(sizeof(*map), GFP_KERNEL);
722 ret = regmap_set_name(map, config);
726 ret = -EINVAL; /* Later error paths rely on this */
728 if (config->disable_locking) {
729 map->lock = map->unlock = regmap_lock_unlock_none;
730 map->can_sleep = config->can_sleep;
731 regmap_debugfs_disable(map);
732 } else if (config->lock && config->unlock) {
733 map->lock = config->lock;
734 map->unlock = config->unlock;
735 map->lock_arg = config->lock_arg;
736 map->can_sleep = config->can_sleep;
737 } else if (config->use_hwlock) {
738 map->hwlock = hwspin_lock_request_specific(config->hwlock_id);
744 switch (config->hwlock_mode) {
745 case HWLOCK_IRQSTATE:
746 map->lock = regmap_lock_hwlock_irqsave;
747 map->unlock = regmap_unlock_hwlock_irqrestore;
750 map->lock = regmap_lock_hwlock_irq;
751 map->unlock = regmap_unlock_hwlock_irq;
754 map->lock = regmap_lock_hwlock;
755 map->unlock = regmap_unlock_hwlock;
761 if ((bus && bus->fast_io) ||
763 spin_lock_init(&map->spinlock);
764 map->lock = regmap_lock_spinlock;
765 map->unlock = regmap_unlock_spinlock;
766 lockdep_set_class_and_name(&map->spinlock,
767 lock_key, lock_name);
769 mutex_init(&map->mutex);
770 map->lock = regmap_lock_mutex;
771 map->unlock = regmap_unlock_mutex;
772 map->can_sleep = true;
773 lockdep_set_class_and_name(&map->mutex,
774 lock_key, lock_name);
780 * When we write in fast-paths with regmap_bulk_write() don't allocate
781 * scratch buffers with sleeping allocations.
783 if ((bus && bus->fast_io) || config->fast_io)
784 map->alloc_flags = GFP_ATOMIC;
786 map->alloc_flags = GFP_KERNEL;
788 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
789 map->format.pad_bytes = config->pad_bits / 8;
790 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
791 map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
792 config->val_bits + config->pad_bits, 8);
793 map->reg_shift = config->pad_bits % 8;
794 if (config->reg_stride)
795 map->reg_stride = config->reg_stride;
798 if (is_power_of_2(map->reg_stride))
799 map->reg_stride_order = ilog2(map->reg_stride);
801 map->reg_stride_order = -1;
802 map->use_single_read = config->use_single_read || !bus || !bus->read;
803 map->use_single_write = config->use_single_write || !bus || !bus->write;
804 map->can_multi_write = config->can_multi_write && bus && bus->write;
806 map->max_raw_read = bus->max_raw_read;
807 map->max_raw_write = bus->max_raw_write;
811 map->bus_context = bus_context;
812 map->max_register = config->max_register;
813 map->wr_table = config->wr_table;
814 map->rd_table = config->rd_table;
815 map->volatile_table = config->volatile_table;
816 map->precious_table = config->precious_table;
817 map->wr_noinc_table = config->wr_noinc_table;
818 map->rd_noinc_table = config->rd_noinc_table;
819 map->writeable_reg = config->writeable_reg;
820 map->readable_reg = config->readable_reg;
821 map->volatile_reg = config->volatile_reg;
822 map->precious_reg = config->precious_reg;
823 map->writeable_noinc_reg = config->writeable_noinc_reg;
824 map->readable_noinc_reg = config->readable_noinc_reg;
825 map->cache_type = config->cache_type;
827 spin_lock_init(&map->async_lock);
828 INIT_LIST_HEAD(&map->async_list);
829 INIT_LIST_HEAD(&map->async_free);
830 init_waitqueue_head(&map->async_waitq);
832 if (config->read_flag_mask ||
833 config->write_flag_mask ||
834 config->zero_flag_mask) {
835 map->read_flag_mask = config->read_flag_mask;
836 map->write_flag_mask = config->write_flag_mask;
838 map->read_flag_mask = bus->read_flag_mask;
842 map->reg_read = config->reg_read;
843 map->reg_write = config->reg_write;
845 map->defer_caching = false;
846 goto skip_format_initialization;
847 } else if (!bus->read || !bus->write) {
848 map->reg_read = _regmap_bus_reg_read;
849 map->reg_write = _regmap_bus_reg_write;
850 map->reg_update_bits = bus->reg_update_bits;
852 map->defer_caching = false;
853 goto skip_format_initialization;
855 map->reg_read = _regmap_bus_read;
856 map->reg_update_bits = bus->reg_update_bits;
859 reg_endian = regmap_get_reg_endian(bus, config);
860 val_endian = regmap_get_val_endian(dev, bus, config);
862 switch (config->reg_bits + map->reg_shift) {
864 switch (config->val_bits) {
866 map->format.format_write = regmap_format_2_6_write;
874 switch (config->val_bits) {
876 map->format.format_write = regmap_format_4_12_write;
884 switch (config->val_bits) {
886 map->format.format_write = regmap_format_7_9_write;
894 switch (config->val_bits) {
896 map->format.format_write = regmap_format_10_14_write;
904 switch (config->val_bits) {
906 map->format.format_write = regmap_format_12_20_write;
914 map->format.format_reg = regmap_format_8;
918 switch (reg_endian) {
919 case REGMAP_ENDIAN_BIG:
920 map->format.format_reg = regmap_format_16_be;
922 case REGMAP_ENDIAN_LITTLE:
923 map->format.format_reg = regmap_format_16_le;
925 case REGMAP_ENDIAN_NATIVE:
926 map->format.format_reg = regmap_format_16_native;
934 if (reg_endian != REGMAP_ENDIAN_BIG)
936 map->format.format_reg = regmap_format_24;
940 switch (reg_endian) {
941 case REGMAP_ENDIAN_BIG:
942 map->format.format_reg = regmap_format_32_be;
944 case REGMAP_ENDIAN_LITTLE:
945 map->format.format_reg = regmap_format_32_le;
947 case REGMAP_ENDIAN_NATIVE:
948 map->format.format_reg = regmap_format_32_native;
957 switch (reg_endian) {
958 case REGMAP_ENDIAN_BIG:
959 map->format.format_reg = regmap_format_64_be;
961 case REGMAP_ENDIAN_LITTLE:
962 map->format.format_reg = regmap_format_64_le;
964 case REGMAP_ENDIAN_NATIVE:
965 map->format.format_reg = regmap_format_64_native;
977 if (val_endian == REGMAP_ENDIAN_NATIVE)
978 map->format.parse_inplace = regmap_parse_inplace_noop;
980 switch (config->val_bits) {
982 map->format.format_val = regmap_format_8;
983 map->format.parse_val = regmap_parse_8;
984 map->format.parse_inplace = regmap_parse_inplace_noop;
987 switch (val_endian) {
988 case REGMAP_ENDIAN_BIG:
989 map->format.format_val = regmap_format_16_be;
990 map->format.parse_val = regmap_parse_16_be;
991 map->format.parse_inplace = regmap_parse_16_be_inplace;
993 case REGMAP_ENDIAN_LITTLE:
994 map->format.format_val = regmap_format_16_le;
995 map->format.parse_val = regmap_parse_16_le;
996 map->format.parse_inplace = regmap_parse_16_le_inplace;
998 case REGMAP_ENDIAN_NATIVE:
999 map->format.format_val = regmap_format_16_native;
1000 map->format.parse_val = regmap_parse_16_native;
1007 if (val_endian != REGMAP_ENDIAN_BIG)
1009 map->format.format_val = regmap_format_24;
1010 map->format.parse_val = regmap_parse_24;
1013 switch (val_endian) {
1014 case REGMAP_ENDIAN_BIG:
1015 map->format.format_val = regmap_format_32_be;
1016 map->format.parse_val = regmap_parse_32_be;
1017 map->format.parse_inplace = regmap_parse_32_be_inplace;
1019 case REGMAP_ENDIAN_LITTLE:
1020 map->format.format_val = regmap_format_32_le;
1021 map->format.parse_val = regmap_parse_32_le;
1022 map->format.parse_inplace = regmap_parse_32_le_inplace;
1024 case REGMAP_ENDIAN_NATIVE:
1025 map->format.format_val = regmap_format_32_native;
1026 map->format.parse_val = regmap_parse_32_native;
1034 switch (val_endian) {
1035 case REGMAP_ENDIAN_BIG:
1036 map->format.format_val = regmap_format_64_be;
1037 map->format.parse_val = regmap_parse_64_be;
1038 map->format.parse_inplace = regmap_parse_64_be_inplace;
1040 case REGMAP_ENDIAN_LITTLE:
1041 map->format.format_val = regmap_format_64_le;
1042 map->format.parse_val = regmap_parse_64_le;
1043 map->format.parse_inplace = regmap_parse_64_le_inplace;
1045 case REGMAP_ENDIAN_NATIVE:
1046 map->format.format_val = regmap_format_64_native;
1047 map->format.parse_val = regmap_parse_64_native;
1056 if (map->format.format_write) {
1057 if ((reg_endian != REGMAP_ENDIAN_BIG) ||
1058 (val_endian != REGMAP_ENDIAN_BIG))
1060 map->use_single_write = true;
1063 if (!map->format.format_write &&
1064 !(map->format.format_reg && map->format.format_val))
1067 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
1068 if (map->work_buf == NULL) {
1073 if (map->format.format_write) {
1074 map->defer_caching = false;
1075 map->reg_write = _regmap_bus_formatted_write;
1076 } else if (map->format.format_val) {
1077 map->defer_caching = true;
1078 map->reg_write = _regmap_bus_raw_write;
1081 skip_format_initialization:
1083 map->range_tree = RB_ROOT;
1084 for (i = 0; i < config->num_ranges; i++) {
1085 const struct regmap_range_cfg *range_cfg = &config->ranges[i];
1086 struct regmap_range_node *new;
1089 if (range_cfg->range_max < range_cfg->range_min) {
1090 dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
1091 range_cfg->range_max, range_cfg->range_min);
1095 if (range_cfg->range_max > map->max_register) {
1096 dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
1097 range_cfg->range_max, map->max_register);
1101 if (range_cfg->selector_reg > map->max_register) {
1103 "Invalid range %d: selector out of map\n", i);
1107 if (range_cfg->window_len == 0) {
1108 dev_err(map->dev, "Invalid range %d: window_len 0\n",
1113 /* Make sure, that this register range has no selector
1114 or data window within its boundary */
1115 for (j = 0; j < config->num_ranges; j++) {
1116 unsigned sel_reg = config->ranges[j].selector_reg;
1117 unsigned win_min = config->ranges[j].window_start;
1118 unsigned win_max = win_min +
1119 config->ranges[j].window_len - 1;
1121 /* Allow data window inside its own virtual range */
1125 if (range_cfg->range_min <= sel_reg &&
1126 sel_reg <= range_cfg->range_max) {
1128 "Range %d: selector for %d in window\n",
1133 if (!(win_max < range_cfg->range_min ||
1134 win_min > range_cfg->range_max)) {
1136 "Range %d: window for %d in window\n",
1142 new = kzalloc(sizeof(*new), GFP_KERNEL);
1149 new->name = range_cfg->name;
1150 new->range_min = range_cfg->range_min;
1151 new->range_max = range_cfg->range_max;
1152 new->selector_reg = range_cfg->selector_reg;
1153 new->selector_mask = range_cfg->selector_mask;
1154 new->selector_shift = range_cfg->selector_shift;
1155 new->window_start = range_cfg->window_start;
1156 new->window_len = range_cfg->window_len;
1158 if (!_regmap_range_add(map, new)) {
1159 dev_err(map->dev, "Failed to add range %d\n", i);
1164 if (map->selector_work_buf == NULL) {
1165 map->selector_work_buf =
1166 kzalloc(map->format.buf_size, GFP_KERNEL);
1167 if (map->selector_work_buf == NULL) {
1174 ret = regcache_init(map, config);
1179 ret = regmap_attach_dev(dev, map, config);
1183 regmap_debugfs_init(map);
1191 regmap_range_exit(map);
1192 kfree(map->work_buf);
1195 hwspin_lock_free(map->hwlock);
1197 kfree_const(map->name);
1201 return ERR_PTR(ret);
1203 EXPORT_SYMBOL_GPL(__regmap_init);
1205 static void devm_regmap_release(struct device *dev, void *res)
1207 regmap_exit(*(struct regmap **)res);
1210 struct regmap *__devm_regmap_init(struct device *dev,
1211 const struct regmap_bus *bus,
1213 const struct regmap_config *config,
1214 struct lock_class_key *lock_key,
1215 const char *lock_name)
1217 struct regmap **ptr, *regmap;
1219 ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
1221 return ERR_PTR(-ENOMEM);
1223 regmap = __regmap_init(dev, bus, bus_context, config,
1224 lock_key, lock_name);
1225 if (!IS_ERR(regmap)) {
1227 devres_add(dev, ptr);
1234 EXPORT_SYMBOL_GPL(__devm_regmap_init);
1236 static void regmap_field_init(struct regmap_field *rm_field,
1237 struct regmap *regmap, struct reg_field reg_field)
1239 rm_field->regmap = regmap;
1240 rm_field->reg = reg_field.reg;
1241 rm_field->shift = reg_field.lsb;
1242 rm_field->mask = GENMASK(reg_field.msb, reg_field.lsb);
1243 rm_field->id_size = reg_field.id_size;
1244 rm_field->id_offset = reg_field.id_offset;
1248 * devm_regmap_field_alloc() - Allocate and initialise a register field.
1250 * @dev: Device that will be interacted with
1251 * @regmap: regmap bank in which this register field is located.
1252 * @reg_field: Register field with in the bank.
1254 * The return value will be an ERR_PTR() on error or a valid pointer
1255 * to a struct regmap_field. The regmap_field will be automatically freed
1256 * by the device management code.
1258 struct regmap_field *devm_regmap_field_alloc(struct device *dev,
1259 struct regmap *regmap, struct reg_field reg_field)
1261 struct regmap_field *rm_field = devm_kzalloc(dev,
1262 sizeof(*rm_field), GFP_KERNEL);
1264 return ERR_PTR(-ENOMEM);
1266 regmap_field_init(rm_field, regmap, reg_field);
1271 EXPORT_SYMBOL_GPL(devm_regmap_field_alloc);
1275 * regmap_field_bulk_alloc() - Allocate and initialise a bulk register field.
1277 * @regmap: regmap bank in which this register field is located.
1278 * @rm_field: regmap register fields within the bank.
1279 * @reg_field: Register fields within the bank.
1280 * @num_fields: Number of register fields.
1282 * The return value will be an -ENOMEM on error or zero for success.
1283 * Newly allocated regmap_fields should be freed by calling
1284 * regmap_field_bulk_free()
1286 int regmap_field_bulk_alloc(struct regmap *regmap,
1287 struct regmap_field **rm_field,
1288 struct reg_field *reg_field,
1291 struct regmap_field *rf;
1294 rf = kcalloc(num_fields, sizeof(*rf), GFP_KERNEL);
1298 for (i = 0; i < num_fields; i++) {
1299 regmap_field_init(&rf[i], regmap, reg_field[i]);
1300 rm_field[i] = &rf[i];
1305 EXPORT_SYMBOL_GPL(regmap_field_bulk_alloc);
1308 * devm_regmap_field_bulk_alloc() - Allocate and initialise a bulk register
1311 * @dev: Device that will be interacted with
1312 * @regmap: regmap bank in which this register field is located.
1313 * @rm_field: regmap register fields within the bank.
1314 * @reg_field: Register fields within the bank.
1315 * @num_fields: Number of register fields.
1317 * The return value will be an -ENOMEM on error or zero for success.
1318 * Newly allocated regmap_fields will be automatically freed by the
1319 * device management code.
1321 int devm_regmap_field_bulk_alloc(struct device *dev,
1322 struct regmap *regmap,
1323 struct regmap_field **rm_field,
1324 struct reg_field *reg_field,
1327 struct regmap_field *rf;
1330 rf = devm_kcalloc(dev, num_fields, sizeof(*rf), GFP_KERNEL);
1334 for (i = 0; i < num_fields; i++) {
1335 regmap_field_init(&rf[i], regmap, reg_field[i]);
1336 rm_field[i] = &rf[i];
1341 EXPORT_SYMBOL_GPL(devm_regmap_field_bulk_alloc);
1344 * regmap_field_bulk_free() - Free register field allocated using
1345 * regmap_field_bulk_alloc.
1347 * @field: regmap fields which should be freed.
1349 void regmap_field_bulk_free(struct regmap_field *field)
1353 EXPORT_SYMBOL_GPL(regmap_field_bulk_free);
1356 * devm_regmap_field_bulk_free() - Free a bulk register field allocated using
1357 * devm_regmap_field_bulk_alloc.
1359 * @dev: Device that will be interacted with
1360 * @field: regmap field which should be freed.
1362 * Free register field allocated using devm_regmap_field_bulk_alloc(). Usually
1363 * drivers need not call this function, as the memory allocated via devm
1364 * will be freed as per device-driver life-cycle.
1366 void devm_regmap_field_bulk_free(struct device *dev,
1367 struct regmap_field *field)
1369 devm_kfree(dev, field);
1371 EXPORT_SYMBOL_GPL(devm_regmap_field_bulk_free);
1374 * devm_regmap_field_free() - Free a register field allocated using
1375 * devm_regmap_field_alloc.
1377 * @dev: Device that will be interacted with
1378 * @field: regmap field which should be freed.
1380 * Free register field allocated using devm_regmap_field_alloc(). Usually
1381 * drivers need not call this function, as the memory allocated via devm
1382 * will be freed as per device-driver life-cyle.
1384 void devm_regmap_field_free(struct device *dev,
1385 struct regmap_field *field)
1387 devm_kfree(dev, field);
1389 EXPORT_SYMBOL_GPL(devm_regmap_field_free);
1392 * regmap_field_alloc() - Allocate and initialise a register field.
1394 * @regmap: regmap bank in which this register field is located.
1395 * @reg_field: Register field with in the bank.
1397 * The return value will be an ERR_PTR() on error or a valid pointer
1398 * to a struct regmap_field. The regmap_field should be freed by the
1399 * user once its finished working with it using regmap_field_free().
1401 struct regmap_field *regmap_field_alloc(struct regmap *regmap,
1402 struct reg_field reg_field)
1404 struct regmap_field *rm_field = kzalloc(sizeof(*rm_field), GFP_KERNEL);
1407 return ERR_PTR(-ENOMEM);
1409 regmap_field_init(rm_field, regmap, reg_field);
1413 EXPORT_SYMBOL_GPL(regmap_field_alloc);
1416 * regmap_field_free() - Free register field allocated using
1417 * regmap_field_alloc.
1419 * @field: regmap field which should be freed.
1421 void regmap_field_free(struct regmap_field *field)
1425 EXPORT_SYMBOL_GPL(regmap_field_free);
1428 * regmap_reinit_cache() - Reinitialise the current register cache
1430 * @map: Register map to operate on.
1431 * @config: New configuration. Only the cache data will be used.
1433 * Discard any existing register cache for the map and initialize a
1434 * new cache. This can be used to restore the cache to defaults or to
1435 * update the cache configuration to reflect runtime discovery of the
1438 * No explicit locking is done here, the user needs to ensure that
1439 * this function will not race with other calls to regmap.
1441 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
1446 regmap_debugfs_exit(map);
1448 map->max_register = config->max_register;
1449 map->writeable_reg = config->writeable_reg;
1450 map->readable_reg = config->readable_reg;
1451 map->volatile_reg = config->volatile_reg;
1452 map->precious_reg = config->precious_reg;
1453 map->writeable_noinc_reg = config->writeable_noinc_reg;
1454 map->readable_noinc_reg = config->readable_noinc_reg;
1455 map->cache_type = config->cache_type;
1457 ret = regmap_set_name(map, config);
1461 regmap_debugfs_init(map);
1463 map->cache_bypass = false;
1464 map->cache_only = false;
1466 return regcache_init(map, config);
1468 EXPORT_SYMBOL_GPL(regmap_reinit_cache);
1471 * regmap_exit() - Free a previously allocated register map
1473 * @map: Register map to operate on.
1475 void regmap_exit(struct regmap *map)
1477 struct regmap_async *async;
1480 regmap_debugfs_exit(map);
1481 regmap_range_exit(map);
1482 if (map->bus && map->bus->free_context)
1483 map->bus->free_context(map->bus_context);
1484 kfree(map->work_buf);
1485 while (!list_empty(&map->async_free)) {
1486 async = list_first_entry_or_null(&map->async_free,
1487 struct regmap_async,
1489 list_del(&async->list);
1490 kfree(async->work_buf);
1494 hwspin_lock_free(map->hwlock);
1495 if (map->lock == regmap_lock_mutex)
1496 mutex_destroy(&map->mutex);
1497 kfree_const(map->name);
1501 EXPORT_SYMBOL_GPL(regmap_exit);
1503 static int dev_get_regmap_match(struct device *dev, void *res, void *data)
1505 struct regmap **r = res;
1511 /* If the user didn't specify a name match any */
1513 return !strcmp((*r)->name, data);
1519 * dev_get_regmap() - Obtain the regmap (if any) for a device
1521 * @dev: Device to retrieve the map for
1522 * @name: Optional name for the register map, usually NULL.
1524 * Returns the regmap for the device if one is present, or NULL. If
1525 * name is specified then it must match the name specified when
1526 * registering the device, if it is NULL then the first regmap found
1527 * will be used. Devices with multiple register maps are very rare,
1528 * generic code should normally not need to specify a name.
1530 struct regmap *dev_get_regmap(struct device *dev, const char *name)
1532 struct regmap **r = devres_find(dev, dev_get_regmap_release,
1533 dev_get_regmap_match, (void *)name);
1539 EXPORT_SYMBOL_GPL(dev_get_regmap);
1542 * regmap_get_device() - Obtain the device from a regmap
1544 * @map: Register map to operate on.
1546 * Returns the underlying device that the regmap has been created for.
1548 struct device *regmap_get_device(struct regmap *map)
1552 EXPORT_SYMBOL_GPL(regmap_get_device);
1554 static int _regmap_select_page(struct regmap *map, unsigned int *reg,
1555 struct regmap_range_node *range,
1556 unsigned int val_num)
1558 void *orig_work_buf;
1559 unsigned int win_offset;
1560 unsigned int win_page;
1564 win_offset = (*reg - range->range_min) % range->window_len;
1565 win_page = (*reg - range->range_min) / range->window_len;
1568 /* Bulk write shouldn't cross range boundary */
1569 if (*reg + val_num - 1 > range->range_max)
1572 /* ... or single page boundary */
1573 if (val_num > range->window_len - win_offset)
1577 /* It is possible to have selector register inside data window.
1578 In that case, selector register is located on every page and
1579 it needs no page switching, when accessed alone. */
1581 range->window_start + win_offset != range->selector_reg) {
1582 /* Use separate work_buf during page switching */
1583 orig_work_buf = map->work_buf;
1584 map->work_buf = map->selector_work_buf;
1586 ret = _regmap_update_bits(map, range->selector_reg,
1587 range->selector_mask,
1588 win_page << range->selector_shift,
1591 map->work_buf = orig_work_buf;
1597 *reg = range->window_start + win_offset;
1602 static void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
1608 if (!mask || !map->work_buf)
1611 buf = map->work_buf;
1613 for (i = 0; i < max_bytes; i++)
1614 buf[i] |= (mask >> (8 * i)) & 0xff;
1617 static int _regmap_raw_write_impl(struct regmap *map, unsigned int reg,
1618 const void *val, size_t val_len, bool noinc)
1620 struct regmap_range_node *range;
1621 unsigned long flags;
1622 void *work_val = map->work_buf + map->format.reg_bytes +
1623 map->format.pad_bytes;
1625 int ret = -ENOTSUPP;
1631 /* Check for unwritable or noinc registers in range
1634 if (!regmap_writeable_noinc(map, reg)) {
1635 for (i = 0; i < val_len / map->format.val_bytes; i++) {
1636 unsigned int element =
1637 reg + regmap_get_offset(map, i);
1638 if (!regmap_writeable(map, element) ||
1639 regmap_writeable_noinc(map, element))
1644 if (!map->cache_bypass && map->format.parse_val) {
1646 int val_bytes = map->format.val_bytes;
1647 for (i = 0; i < val_len / val_bytes; i++) {
1648 ival = map->format.parse_val(val + (i * val_bytes));
1649 ret = regcache_write(map,
1650 reg + regmap_get_offset(map, i),
1654 "Error in caching of register: %x ret: %d\n",
1659 if (map->cache_only) {
1660 map->cache_dirty = true;
1665 range = _regmap_range_lookup(map, reg);
1667 int val_num = val_len / map->format.val_bytes;
1668 int win_offset = (reg - range->range_min) % range->window_len;
1669 int win_residue = range->window_len - win_offset;
1671 /* If the write goes beyond the end of the window split it */
1672 while (val_num > win_residue) {
1673 dev_dbg(map->dev, "Writing window %d/%zu\n",
1674 win_residue, val_len / map->format.val_bytes);
1675 ret = _regmap_raw_write_impl(map, reg, val,
1677 map->format.val_bytes, noinc);
1682 val_num -= win_residue;
1683 val += win_residue * map->format.val_bytes;
1684 val_len -= win_residue * map->format.val_bytes;
1686 win_offset = (reg - range->range_min) %
1688 win_residue = range->window_len - win_offset;
1691 ret = _regmap_select_page(map, ®, range, noinc ? 1 : val_num);
1696 map->format.format_reg(map->work_buf, reg, map->reg_shift);
1697 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
1698 map->write_flag_mask);
1701 * Essentially all I/O mechanisms will be faster with a single
1702 * buffer to write. Since register syncs often generate raw
1703 * writes of single registers optimise that case.
1705 if (val != work_val && val_len == map->format.val_bytes) {
1706 memcpy(work_val, val, map->format.val_bytes);
1710 if (map->async && map->bus->async_write) {
1711 struct regmap_async *async;
1713 trace_regmap_async_write_start(map, reg, val_len);
1715 spin_lock_irqsave(&map->async_lock, flags);
1716 async = list_first_entry_or_null(&map->async_free,
1717 struct regmap_async,
1720 list_del(&async->list);
1721 spin_unlock_irqrestore(&map->async_lock, flags);
1724 async = map->bus->async_alloc();
1728 async->work_buf = kzalloc(map->format.buf_size,
1729 GFP_KERNEL | GFP_DMA);
1730 if (!async->work_buf) {
1738 /* If the caller supplied the value we can use it safely. */
1739 memcpy(async->work_buf, map->work_buf, map->format.pad_bytes +
1740 map->format.reg_bytes + map->format.val_bytes);
1742 spin_lock_irqsave(&map->async_lock, flags);
1743 list_add_tail(&async->list, &map->async_list);
1744 spin_unlock_irqrestore(&map->async_lock, flags);
1746 if (val != work_val)
1747 ret = map->bus->async_write(map->bus_context,
1749 map->format.reg_bytes +
1750 map->format.pad_bytes,
1751 val, val_len, async);
1753 ret = map->bus->async_write(map->bus_context,
1755 map->format.reg_bytes +
1756 map->format.pad_bytes +
1757 val_len, NULL, 0, async);
1760 dev_err(map->dev, "Failed to schedule write: %d\n",
1763 spin_lock_irqsave(&map->async_lock, flags);
1764 list_move(&async->list, &map->async_free);
1765 spin_unlock_irqrestore(&map->async_lock, flags);
1771 trace_regmap_hw_write_start(map, reg, val_len / map->format.val_bytes);
1773 /* If we're doing a single register write we can probably just
1774 * send the work_buf directly, otherwise try to do a gather
1777 if (val == work_val)
1778 ret = map->bus->write(map->bus_context, map->work_buf,
1779 map->format.reg_bytes +
1780 map->format.pad_bytes +
1782 else if (map->bus->gather_write)
1783 ret = map->bus->gather_write(map->bus_context, map->work_buf,
1784 map->format.reg_bytes +
1785 map->format.pad_bytes,
1790 /* If that didn't work fall back on linearising by hand. */
1791 if (ret == -ENOTSUPP) {
1792 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
1793 buf = kzalloc(len, GFP_KERNEL);
1797 memcpy(buf, map->work_buf, map->format.reg_bytes);
1798 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
1800 ret = map->bus->write(map->bus_context, buf, len);
1803 } else if (ret != 0 && !map->cache_bypass && map->format.parse_val) {
1804 /* regcache_drop_region() takes lock that we already have,
1805 * thus call map->cache_ops->drop() directly
1807 if (map->cache_ops && map->cache_ops->drop)
1808 map->cache_ops->drop(map, reg, reg + 1);
1811 trace_regmap_hw_write_done(map, reg, val_len / map->format.val_bytes);
1817 * regmap_can_raw_write - Test if regmap_raw_write() is supported
1819 * @map: Map to check.
1821 bool regmap_can_raw_write(struct regmap *map)
1823 return map->bus && map->bus->write && map->format.format_val &&
1824 map->format.format_reg;
1826 EXPORT_SYMBOL_GPL(regmap_can_raw_write);
1829 * regmap_get_raw_read_max - Get the maximum size we can read
1831 * @map: Map to check.
1833 size_t regmap_get_raw_read_max(struct regmap *map)
1835 return map->max_raw_read;
1837 EXPORT_SYMBOL_GPL(regmap_get_raw_read_max);
1840 * regmap_get_raw_write_max - Get the maximum size we can read
1842 * @map: Map to check.
1844 size_t regmap_get_raw_write_max(struct regmap *map)
1846 return map->max_raw_write;
1848 EXPORT_SYMBOL_GPL(regmap_get_raw_write_max);
1850 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
1854 struct regmap_range_node *range;
1855 struct regmap *map = context;
1857 WARN_ON(!map->bus || !map->format.format_write);
1859 range = _regmap_range_lookup(map, reg);
1861 ret = _regmap_select_page(map, ®, range, 1);
1866 map->format.format_write(map, reg, val);
1868 trace_regmap_hw_write_start(map, reg, 1);
1870 ret = map->bus->write(map->bus_context, map->work_buf,
1871 map->format.buf_size);
1873 trace_regmap_hw_write_done(map, reg, 1);
1878 static int _regmap_bus_reg_write(void *context, unsigned int reg,
1881 struct regmap *map = context;
1883 return map->bus->reg_write(map->bus_context, reg, val);
1886 static int _regmap_bus_raw_write(void *context, unsigned int reg,
1889 struct regmap *map = context;
1891 WARN_ON(!map->bus || !map->format.format_val);
1893 map->format.format_val(map->work_buf + map->format.reg_bytes
1894 + map->format.pad_bytes, val, 0);
1895 return _regmap_raw_write_impl(map, reg,
1897 map->format.reg_bytes +
1898 map->format.pad_bytes,
1899 map->format.val_bytes,
1903 static inline void *_regmap_map_get_context(struct regmap *map)
1905 return (map->bus) ? map : map->bus_context;
1908 int _regmap_write(struct regmap *map, unsigned int reg,
1912 void *context = _regmap_map_get_context(map);
1914 if (!regmap_writeable(map, reg))
1917 if (!map->cache_bypass && !map->defer_caching) {
1918 ret = regcache_write(map, reg, val);
1921 if (map->cache_only) {
1922 map->cache_dirty = true;
1927 if (regmap_should_log(map))
1928 dev_info(map->dev, "%x <= %x\n", reg, val);
1930 trace_regmap_reg_write(map, reg, val);
1932 return map->reg_write(context, reg, val);
1936 * regmap_write() - Write a value to a single register
1938 * @map: Register map to write to
1939 * @reg: Register to write to
1940 * @val: Value to be written
1942 * A value of zero will be returned on success, a negative errno will
1943 * be returned in error cases.
1945 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1949 if (!IS_ALIGNED(reg, map->reg_stride))
1952 map->lock(map->lock_arg);
1954 ret = _regmap_write(map, reg, val);
1956 map->unlock(map->lock_arg);
1960 EXPORT_SYMBOL_GPL(regmap_write);
1963 * regmap_write_async() - Write a value to a single register asynchronously
1965 * @map: Register map to write to
1966 * @reg: Register to write to
1967 * @val: Value to be written
1969 * A value of zero will be returned on success, a negative errno will
1970 * be returned in error cases.
1972 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val)
1976 if (!IS_ALIGNED(reg, map->reg_stride))
1979 map->lock(map->lock_arg);
1983 ret = _regmap_write(map, reg, val);
1987 map->unlock(map->lock_arg);
1991 EXPORT_SYMBOL_GPL(regmap_write_async);
1993 int _regmap_raw_write(struct regmap *map, unsigned int reg,
1994 const void *val, size_t val_len, bool noinc)
1996 size_t val_bytes = map->format.val_bytes;
1997 size_t val_count = val_len / val_bytes;
1998 size_t chunk_count, chunk_bytes;
1999 size_t chunk_regs = val_count;
2005 if (map->use_single_write)
2007 else if (map->max_raw_write && val_len > map->max_raw_write)
2008 chunk_regs = map->max_raw_write / val_bytes;
2010 chunk_count = val_count / chunk_regs;
2011 chunk_bytes = chunk_regs * val_bytes;
2013 /* Write as many bytes as possible with chunk_size */
2014 for (i = 0; i < chunk_count; i++) {
2015 ret = _regmap_raw_write_impl(map, reg, val, chunk_bytes, noinc);
2019 reg += regmap_get_offset(map, chunk_regs);
2021 val_len -= chunk_bytes;
2024 /* Write remaining bytes */
2026 ret = _regmap_raw_write_impl(map, reg, val, val_len, noinc);
2032 * regmap_raw_write() - Write raw values to one or more registers
2034 * @map: Register map to write to
2035 * @reg: Initial register to write to
2036 * @val: Block of data to be written, laid out for direct transmission to the
2038 * @val_len: Length of data pointed to by val.
2040 * This function is intended to be used for things like firmware
2041 * download where a large block of data needs to be transferred to the
2042 * device. No formatting will be done on the data provided.
2044 * A value of zero will be returned on success, a negative errno will
2045 * be returned in error cases.
2047 int regmap_raw_write(struct regmap *map, unsigned int reg,
2048 const void *val, size_t val_len)
2052 if (!regmap_can_raw_write(map))
2054 if (val_len % map->format.val_bytes)
2057 map->lock(map->lock_arg);
2059 ret = _regmap_raw_write(map, reg, val, val_len, false);
2061 map->unlock(map->lock_arg);
2065 EXPORT_SYMBOL_GPL(regmap_raw_write);
2068 * regmap_noinc_write(): Write data from a register without incrementing the
2071 * @map: Register map to write to
2072 * @reg: Register to write to
2073 * @val: Pointer to data buffer
2074 * @val_len: Length of output buffer in bytes.
2076 * The regmap API usually assumes that bulk bus write operations will write a
2077 * range of registers. Some devices have certain registers for which a write
2078 * operation can write to an internal FIFO.
2080 * The target register must be volatile but registers after it can be
2081 * completely unrelated cacheable registers.
2083 * This will attempt multiple writes as required to write val_len bytes.
2085 * A value of zero will be returned on success, a negative errno will be
2086 * returned in error cases.
2088 int regmap_noinc_write(struct regmap *map, unsigned int reg,
2089 const void *val, size_t val_len)
2096 if (!map->bus->write)
2098 if (val_len % map->format.val_bytes)
2100 if (!IS_ALIGNED(reg, map->reg_stride))
2105 map->lock(map->lock_arg);
2107 if (!regmap_volatile(map, reg) || !regmap_writeable_noinc(map, reg)) {
2113 if (map->max_raw_write && map->max_raw_write < val_len)
2114 write_len = map->max_raw_write;
2116 write_len = val_len;
2117 ret = _regmap_raw_write(map, reg, val, write_len, true);
2120 val = ((u8 *)val) + write_len;
2121 val_len -= write_len;
2125 map->unlock(map->lock_arg);
2128 EXPORT_SYMBOL_GPL(regmap_noinc_write);
2131 * regmap_field_update_bits_base() - Perform a read/modify/write cycle a
2134 * @field: Register field to write to
2135 * @mask: Bitmask to change
2136 * @val: Value to be written
2137 * @change: Boolean indicating if a write was done
2138 * @async: Boolean indicating asynchronously
2139 * @force: Boolean indicating use force update
2141 * Perform a read/modify/write cycle on the register field with change,
2142 * async, force option.
2144 * A value of zero will be returned on success, a negative errno will
2145 * be returned in error cases.
2147 int regmap_field_update_bits_base(struct regmap_field *field,
2148 unsigned int mask, unsigned int val,
2149 bool *change, bool async, bool force)
2151 mask = (mask << field->shift) & field->mask;
2153 return regmap_update_bits_base(field->regmap, field->reg,
2154 mask, val << field->shift,
2155 change, async, force);
2157 EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);
2160 * regmap_fields_update_bits_base() - Perform a read/modify/write cycle a
2161 * register field with port ID
2163 * @field: Register field to write to
2165 * @mask: Bitmask to change
2166 * @val: Value to be written
2167 * @change: Boolean indicating if a write was done
2168 * @async: Boolean indicating asynchronously
2169 * @force: Boolean indicating use force update
2171 * A value of zero will be returned on success, a negative errno will
2172 * be returned in error cases.
2174 int regmap_fields_update_bits_base(struct regmap_field *field, unsigned int id,
2175 unsigned int mask, unsigned int val,
2176 bool *change, bool async, bool force)
2178 if (id >= field->id_size)
2181 mask = (mask << field->shift) & field->mask;
2183 return regmap_update_bits_base(field->regmap,
2184 field->reg + (field->id_offset * id),
2185 mask, val << field->shift,
2186 change, async, force);
2188 EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);
2191 * regmap_bulk_write() - Write multiple registers to the device
2193 * @map: Register map to write to
2194 * @reg: First register to be write from
2195 * @val: Block of data to be written, in native register size for device
2196 * @val_count: Number of registers to write
2198 * This function is intended to be used for writing a large block of
2199 * data to the device either in single transfer or multiple transfer.
2201 * A value of zero will be returned on success, a negative errno will
2202 * be returned in error cases.
2204 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
2208 size_t val_bytes = map->format.val_bytes;
2210 if (!IS_ALIGNED(reg, map->reg_stride))
2214 * Some devices don't support bulk write, for them we have a series of
2215 * single write operations.
2217 if (!map->bus || !map->format.parse_inplace) {
2218 map->lock(map->lock_arg);
2219 for (i = 0; i < val_count; i++) {
2222 switch (val_bytes) {
2224 ival = *(u8 *)(val + (i * val_bytes));
2227 ival = *(u16 *)(val + (i * val_bytes));
2230 ival = *(u32 *)(val + (i * val_bytes));
2234 ival = *(u64 *)(val + (i * val_bytes));
2242 ret = _regmap_write(map,
2243 reg + regmap_get_offset(map, i),
2249 map->unlock(map->lock_arg);
2253 wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
2257 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2258 map->format.parse_inplace(wval + i);
2260 ret = regmap_raw_write(map, reg, wval, val_bytes * val_count);
2266 EXPORT_SYMBOL_GPL(regmap_bulk_write);
2269 * _regmap_raw_multi_reg_write()
2271 * the (register,newvalue) pairs in regs have not been formatted, but
2272 * they are all in the same page and have been changed to being page
2273 * relative. The page register has been written if that was necessary.
2275 static int _regmap_raw_multi_reg_write(struct regmap *map,
2276 const struct reg_sequence *regs,
2283 size_t val_bytes = map->format.val_bytes;
2284 size_t reg_bytes = map->format.reg_bytes;
2285 size_t pad_bytes = map->format.pad_bytes;
2286 size_t pair_size = reg_bytes + pad_bytes + val_bytes;
2287 size_t len = pair_size * num_regs;
2292 buf = kzalloc(len, GFP_KERNEL);
2296 /* We have to linearise by hand. */
2300 for (i = 0; i < num_regs; i++) {
2301 unsigned int reg = regs[i].reg;
2302 unsigned int val = regs[i].def;
2303 trace_regmap_hw_write_start(map, reg, 1);
2304 map->format.format_reg(u8, reg, map->reg_shift);
2305 u8 += reg_bytes + pad_bytes;
2306 map->format.format_val(u8, val, 0);
2310 *u8 |= map->write_flag_mask;
2312 ret = map->bus->write(map->bus_context, buf, len);
2316 for (i = 0; i < num_regs; i++) {
2317 int reg = regs[i].reg;
2318 trace_regmap_hw_write_done(map, reg, 1);
2323 static unsigned int _regmap_register_page(struct regmap *map,
2325 struct regmap_range_node *range)
2327 unsigned int win_page = (reg - range->range_min) / range->window_len;
2332 static int _regmap_range_multi_paged_reg_write(struct regmap *map,
2333 struct reg_sequence *regs,
2338 struct reg_sequence *base;
2339 unsigned int this_page = 0;
2340 unsigned int page_change = 0;
2342 * the set of registers are not neccessarily in order, but
2343 * since the order of write must be preserved this algorithm
2344 * chops the set each time the page changes. This also applies
2345 * if there is a delay required at any point in the sequence.
2348 for (i = 0, n = 0; i < num_regs; i++, n++) {
2349 unsigned int reg = regs[i].reg;
2350 struct regmap_range_node *range;
2352 range = _regmap_range_lookup(map, reg);
2354 unsigned int win_page = _regmap_register_page(map, reg,
2358 this_page = win_page;
2359 if (win_page != this_page) {
2360 this_page = win_page;
2365 /* If we have both a page change and a delay make sure to
2366 * write the regs and apply the delay before we change the
2370 if (page_change || regs[i].delay_us) {
2372 /* For situations where the first write requires
2373 * a delay we need to make sure we don't call
2374 * raw_multi_reg_write with n=0
2375 * This can't occur with page breaks as we
2376 * never write on the first iteration
2378 if (regs[i].delay_us && i == 0)
2381 ret = _regmap_raw_multi_reg_write(map, base, n);
2385 if (regs[i].delay_us) {
2387 fsleep(regs[i].delay_us);
2389 udelay(regs[i].delay_us);
2396 ret = _regmap_select_page(map,
2409 return _regmap_raw_multi_reg_write(map, base, n);
2413 static int _regmap_multi_reg_write(struct regmap *map,
2414 const struct reg_sequence *regs,
2420 if (!map->can_multi_write) {
2421 for (i = 0; i < num_regs; i++) {
2422 ret = _regmap_write(map, regs[i].reg, regs[i].def);
2426 if (regs[i].delay_us) {
2428 fsleep(regs[i].delay_us);
2430 udelay(regs[i].delay_us);
2436 if (!map->format.parse_inplace)
2439 if (map->writeable_reg)
2440 for (i = 0; i < num_regs; i++) {
2441 int reg = regs[i].reg;
2442 if (!map->writeable_reg(map->dev, reg))
2444 if (!IS_ALIGNED(reg, map->reg_stride))
2448 if (!map->cache_bypass) {
2449 for (i = 0; i < num_regs; i++) {
2450 unsigned int val = regs[i].def;
2451 unsigned int reg = regs[i].reg;
2452 ret = regcache_write(map, reg, val);
2455 "Error in caching of register: %x ret: %d\n",
2460 if (map->cache_only) {
2461 map->cache_dirty = true;
2468 for (i = 0; i < num_regs; i++) {
2469 unsigned int reg = regs[i].reg;
2470 struct regmap_range_node *range;
2472 /* Coalesce all the writes between a page break or a delay
2475 range = _regmap_range_lookup(map, reg);
2476 if (range || regs[i].delay_us) {
2477 size_t len = sizeof(struct reg_sequence)*num_regs;
2478 struct reg_sequence *base = kmemdup(regs, len,
2482 ret = _regmap_range_multi_paged_reg_write(map, base,
2489 return _regmap_raw_multi_reg_write(map, regs, num_regs);
2493 * regmap_multi_reg_write() - Write multiple registers to the device
2495 * @map: Register map to write to
2496 * @regs: Array of structures containing register,value to be written
2497 * @num_regs: Number of registers to write
2499 * Write multiple registers to the device where the set of register, value
2500 * pairs are supplied in any order, possibly not all in a single range.
2502 * The 'normal' block write mode will send ultimately send data on the
2503 * target bus as R,V1,V2,V3,..,Vn where successively higher registers are
2504 * addressed. However, this alternative block multi write mode will send
2505 * the data as R1,V1,R2,V2,..,Rn,Vn on the target bus. The target device
2506 * must of course support the mode.
2508 * A value of zero will be returned on success, a negative errno will be
2509 * returned in error cases.
2511 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
2516 map->lock(map->lock_arg);
2518 ret = _regmap_multi_reg_write(map, regs, num_regs);
2520 map->unlock(map->lock_arg);
2524 EXPORT_SYMBOL_GPL(regmap_multi_reg_write);
2527 * regmap_multi_reg_write_bypassed() - Write multiple registers to the
2528 * device but not the cache
2530 * @map: Register map to write to
2531 * @regs: Array of structures containing register,value to be written
2532 * @num_regs: Number of registers to write
2534 * Write multiple registers to the device but not the cache where the set
2535 * of register are supplied in any order.
2537 * This function is intended to be used for writing a large block of data
2538 * atomically to the device in single transfer for those I2C client devices
2539 * that implement this alternative block write mode.
2541 * A value of zero will be returned on success, a negative errno will
2542 * be returned in error cases.
2544 int regmap_multi_reg_write_bypassed(struct regmap *map,
2545 const struct reg_sequence *regs,
2551 map->lock(map->lock_arg);
2553 bypass = map->cache_bypass;
2554 map->cache_bypass = true;
2556 ret = _regmap_multi_reg_write(map, regs, num_regs);
2558 map->cache_bypass = bypass;
2560 map->unlock(map->lock_arg);
2564 EXPORT_SYMBOL_GPL(regmap_multi_reg_write_bypassed);
2567 * regmap_raw_write_async() - Write raw values to one or more registers
2570 * @map: Register map to write to
2571 * @reg: Initial register to write to
2572 * @val: Block of data to be written, laid out for direct transmission to the
2573 * device. Must be valid until regmap_async_complete() is called.
2574 * @val_len: Length of data pointed to by val.
2576 * This function is intended to be used for things like firmware
2577 * download where a large block of data needs to be transferred to the
2578 * device. No formatting will be done on the data provided.
2580 * If supported by the underlying bus the write will be scheduled
2581 * asynchronously, helping maximise I/O speed on higher speed buses
2582 * like SPI. regmap_async_complete() can be called to ensure that all
2583 * asynchrnous writes have been completed.
2585 * A value of zero will be returned on success, a negative errno will
2586 * be returned in error cases.
2588 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
2589 const void *val, size_t val_len)
2593 if (val_len % map->format.val_bytes)
2595 if (!IS_ALIGNED(reg, map->reg_stride))
2598 map->lock(map->lock_arg);
2602 ret = _regmap_raw_write(map, reg, val, val_len, false);
2606 map->unlock(map->lock_arg);
2610 EXPORT_SYMBOL_GPL(regmap_raw_write_async);
2612 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2613 unsigned int val_len, bool noinc)
2615 struct regmap_range_node *range;
2620 if (!map->bus || !map->bus->read)
2623 range = _regmap_range_lookup(map, reg);
2625 ret = _regmap_select_page(map, ®, range,
2626 noinc ? 1 : val_len / map->format.val_bytes);
2631 map->format.format_reg(map->work_buf, reg, map->reg_shift);
2632 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
2633 map->read_flag_mask);
2634 trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
2636 ret = map->bus->read(map->bus_context, map->work_buf,
2637 map->format.reg_bytes + map->format.pad_bytes,
2640 trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
2645 static int _regmap_bus_reg_read(void *context, unsigned int reg,
2648 struct regmap *map = context;
2650 return map->bus->reg_read(map->bus_context, reg, val);
2653 static int _regmap_bus_read(void *context, unsigned int reg,
2657 struct regmap *map = context;
2658 void *work_val = map->work_buf + map->format.reg_bytes +
2659 map->format.pad_bytes;
2661 if (!map->format.parse_val)
2664 ret = _regmap_raw_read(map, reg, work_val, map->format.val_bytes, false);
2666 *val = map->format.parse_val(work_val);
2671 static int _regmap_read(struct regmap *map, unsigned int reg,
2675 void *context = _regmap_map_get_context(map);
2677 if (!map->cache_bypass) {
2678 ret = regcache_read(map, reg, val);
2683 if (map->cache_only)
2686 if (!regmap_readable(map, reg))
2689 ret = map->reg_read(context, reg, val);
2691 if (regmap_should_log(map))
2692 dev_info(map->dev, "%x => %x\n", reg, *val);
2694 trace_regmap_reg_read(map, reg, *val);
2696 if (!map->cache_bypass)
2697 regcache_write(map, reg, *val);
2704 * regmap_read() - Read a value from a single register
2706 * @map: Register map to read from
2707 * @reg: Register to be read from
2708 * @val: Pointer to store read value
2710 * A value of zero will be returned on success, a negative errno will
2711 * be returned in error cases.
2713 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
2717 if (!IS_ALIGNED(reg, map->reg_stride))
2720 map->lock(map->lock_arg);
2722 ret = _regmap_read(map, reg, val);
2724 map->unlock(map->lock_arg);
2728 EXPORT_SYMBOL_GPL(regmap_read);
2731 * regmap_raw_read() - Read raw data from the device
2733 * @map: Register map to read from
2734 * @reg: First register to be read from
2735 * @val: Pointer to store read value
2736 * @val_len: Size of data to read
2738 * A value of zero will be returned on success, a negative errno will
2739 * be returned in error cases.
2741 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2744 size_t val_bytes = map->format.val_bytes;
2745 size_t val_count = val_len / val_bytes;
2751 if (val_len % map->format.val_bytes)
2753 if (!IS_ALIGNED(reg, map->reg_stride))
2758 map->lock(map->lock_arg);
2760 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
2761 map->cache_type == REGCACHE_NONE) {
2762 size_t chunk_count, chunk_bytes;
2763 size_t chunk_regs = val_count;
2765 if (!map->bus->read) {
2770 if (map->use_single_read)
2772 else if (map->max_raw_read && val_len > map->max_raw_read)
2773 chunk_regs = map->max_raw_read / val_bytes;
2775 chunk_count = val_count / chunk_regs;
2776 chunk_bytes = chunk_regs * val_bytes;
2778 /* Read bytes that fit into whole chunks */
2779 for (i = 0; i < chunk_count; i++) {
2780 ret = _regmap_raw_read(map, reg, val, chunk_bytes, false);
2784 reg += regmap_get_offset(map, chunk_regs);
2786 val_len -= chunk_bytes;
2789 /* Read remaining bytes */
2791 ret = _regmap_raw_read(map, reg, val, val_len, false);
2796 /* Otherwise go word by word for the cache; should be low
2797 * cost as we expect to hit the cache.
2799 for (i = 0; i < val_count; i++) {
2800 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2805 map->format.format_val(val + (i * val_bytes), v, 0);
2810 map->unlock(map->lock_arg);
2814 EXPORT_SYMBOL_GPL(regmap_raw_read);
2817 * regmap_noinc_read(): Read data from a register without incrementing the
2820 * @map: Register map to read from
2821 * @reg: Register to read from
2822 * @val: Pointer to data buffer
2823 * @val_len: Length of output buffer in bytes.
2825 * The regmap API usually assumes that bulk bus read operations will read a
2826 * range of registers. Some devices have certain registers for which a read
2827 * operation read will read from an internal FIFO.
2829 * The target register must be volatile but registers after it can be
2830 * completely unrelated cacheable registers.
2832 * This will attempt multiple reads as required to read val_len bytes.
2834 * A value of zero will be returned on success, a negative errno will be
2835 * returned in error cases.
2837 int regmap_noinc_read(struct regmap *map, unsigned int reg,
2838 void *val, size_t val_len)
2845 if (!map->bus->read)
2847 if (val_len % map->format.val_bytes)
2849 if (!IS_ALIGNED(reg, map->reg_stride))
2854 map->lock(map->lock_arg);
2856 if (!regmap_volatile(map, reg) || !regmap_readable_noinc(map, reg)) {
2862 if (map->max_raw_read && map->max_raw_read < val_len)
2863 read_len = map->max_raw_read;
2866 ret = _regmap_raw_read(map, reg, val, read_len, true);
2869 val = ((u8 *)val) + read_len;
2870 val_len -= read_len;
2874 map->unlock(map->lock_arg);
2877 EXPORT_SYMBOL_GPL(regmap_noinc_read);
2880 * regmap_field_read(): Read a value to a single register field
2882 * @field: Register field to read from
2883 * @val: Pointer to store read value
2885 * A value of zero will be returned on success, a negative errno will
2886 * be returned in error cases.
2888 int regmap_field_read(struct regmap_field *field, unsigned int *val)
2891 unsigned int reg_val;
2892 ret = regmap_read(field->regmap, field->reg, ®_val);
2896 reg_val &= field->mask;
2897 reg_val >>= field->shift;
2902 EXPORT_SYMBOL_GPL(regmap_field_read);
2905 * regmap_fields_read() - Read a value to a single register field with port ID
2907 * @field: Register field to read from
2909 * @val: Pointer to store read value
2911 * A value of zero will be returned on success, a negative errno will
2912 * be returned in error cases.
2914 int regmap_fields_read(struct regmap_field *field, unsigned int id,
2918 unsigned int reg_val;
2920 if (id >= field->id_size)
2923 ret = regmap_read(field->regmap,
2924 field->reg + (field->id_offset * id),
2929 reg_val &= field->mask;
2930 reg_val >>= field->shift;
2935 EXPORT_SYMBOL_GPL(regmap_fields_read);
2938 * regmap_bulk_read() - Read multiple registers from the device
2940 * @map: Register map to read from
2941 * @reg: First register to be read from
2942 * @val: Pointer to store read value, in native register size for device
2943 * @val_count: Number of registers to read
2945 * A value of zero will be returned on success, a negative errno will
2946 * be returned in error cases.
2948 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
2952 size_t val_bytes = map->format.val_bytes;
2953 bool vol = regmap_volatile_range(map, reg, val_count);
2955 if (!IS_ALIGNED(reg, map->reg_stride))
2960 if (map->bus && map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
2961 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
2965 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2966 map->format.parse_inplace(val + i);
2975 map->lock(map->lock_arg);
2977 for (i = 0; i < val_count; i++) {
2980 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2985 switch (map->format.val_bytes) {
3007 map->unlock(map->lock_arg);
3012 EXPORT_SYMBOL_GPL(regmap_bulk_read);
3014 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
3015 unsigned int mask, unsigned int val,
3016 bool *change, bool force_write)
3019 unsigned int tmp, orig;
3024 if (regmap_volatile(map, reg) && map->reg_update_bits) {
3025 ret = map->reg_update_bits(map->bus_context, reg, mask, val);
3026 if (ret == 0 && change)
3029 ret = _regmap_read(map, reg, &orig);
3036 if (force_write || (tmp != orig)) {
3037 ret = _regmap_write(map, reg, tmp);
3038 if (ret == 0 && change)
3047 * regmap_update_bits_base() - Perform a read/modify/write cycle on a register
3049 * @map: Register map to update
3050 * @reg: Register to update
3051 * @mask: Bitmask to change
3052 * @val: New value for bitmask
3053 * @change: Boolean indicating if a write was done
3054 * @async: Boolean indicating asynchronously
3055 * @force: Boolean indicating use force update
3057 * Perform a read/modify/write cycle on a register map with change, async, force
3062 * With most buses the read must be done synchronously so this is most useful
3063 * for devices with a cache which do not need to interact with the hardware to
3064 * determine the current register value.
3066 * Returns zero for success, a negative number on error.
3068 int regmap_update_bits_base(struct regmap *map, unsigned int reg,
3069 unsigned int mask, unsigned int val,
3070 bool *change, bool async, bool force)
3074 map->lock(map->lock_arg);
3078 ret = _regmap_update_bits(map, reg, mask, val, change, force);
3082 map->unlock(map->lock_arg);
3086 EXPORT_SYMBOL_GPL(regmap_update_bits_base);
3089 * regmap_test_bits() - Check if all specified bits are set in a register.
3091 * @map: Register map to operate on
3092 * @reg: Register to read from
3093 * @bits: Bits to test
3095 * Returns 0 if at least one of the tested bits is not set, 1 if all tested
3096 * bits are set and a negative error number if the underlying regmap_read()
3099 int regmap_test_bits(struct regmap *map, unsigned int reg, unsigned int bits)
3101 unsigned int val, ret;
3103 ret = regmap_read(map, reg, &val);
3107 return (val & bits) == bits;
3109 EXPORT_SYMBOL_GPL(regmap_test_bits);
3111 void regmap_async_complete_cb(struct regmap_async *async, int ret)
3113 struct regmap *map = async->map;
3116 trace_regmap_async_io_complete(map);
3118 spin_lock(&map->async_lock);
3119 list_move(&async->list, &map->async_free);
3120 wake = list_empty(&map->async_list);
3123 map->async_ret = ret;
3125 spin_unlock(&map->async_lock);
3128 wake_up(&map->async_waitq);
3130 EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
3132 static int regmap_async_is_done(struct regmap *map)
3134 unsigned long flags;
3137 spin_lock_irqsave(&map->async_lock, flags);
3138 ret = list_empty(&map->async_list);
3139 spin_unlock_irqrestore(&map->async_lock, flags);
3145 * regmap_async_complete - Ensure all asynchronous I/O has completed.
3147 * @map: Map to operate on.
3149 * Blocks until any pending asynchronous I/O has completed. Returns
3150 * an error code for any failed I/O operations.
3152 int regmap_async_complete(struct regmap *map)
3154 unsigned long flags;
3157 /* Nothing to do with no async support */
3158 if (!map->bus || !map->bus->async_write)
3161 trace_regmap_async_complete_start(map);
3163 wait_event(map->async_waitq, regmap_async_is_done(map));
3165 spin_lock_irqsave(&map->async_lock, flags);
3166 ret = map->async_ret;
3168 spin_unlock_irqrestore(&map->async_lock, flags);
3170 trace_regmap_async_complete_done(map);
3174 EXPORT_SYMBOL_GPL(regmap_async_complete);
3177 * regmap_register_patch - Register and apply register updates to be applied
3178 * on device initialistion
3180 * @map: Register map to apply updates to.
3181 * @regs: Values to update.
3182 * @num_regs: Number of entries in regs.
3184 * Register a set of register updates to be applied to the device
3185 * whenever the device registers are synchronised with the cache and
3186 * apply them immediately. Typically this is used to apply
3187 * corrections to be applied to the device defaults on startup, such
3188 * as the updates some vendors provide to undocumented registers.
3190 * The caller must ensure that this function cannot be called
3191 * concurrently with either itself or regcache_sync().
3193 int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
3196 struct reg_sequence *p;
3200 if (WARN_ONCE(num_regs <= 0, "invalid registers number (%d)\n",
3204 p = krealloc(map->patch,
3205 sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
3208 memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
3210 map->patch_regs += num_regs;
3215 map->lock(map->lock_arg);
3217 bypass = map->cache_bypass;
3219 map->cache_bypass = true;
3222 ret = _regmap_multi_reg_write(map, regs, num_regs);
3225 map->cache_bypass = bypass;
3227 map->unlock(map->lock_arg);
3229 regmap_async_complete(map);
3233 EXPORT_SYMBOL_GPL(regmap_register_patch);
3236 * regmap_get_val_bytes() - Report the size of a register value
3238 * @map: Register map to operate on.
3240 * Report the size of a register value, mainly intended to for use by
3241 * generic infrastructure built on top of regmap.
3243 int regmap_get_val_bytes(struct regmap *map)
3245 if (map->format.format_write)
3248 return map->format.val_bytes;
3250 EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
3253 * regmap_get_max_register() - Report the max register value
3255 * @map: Register map to operate on.
3257 * Report the max register value, mainly intended to for use by
3258 * generic infrastructure built on top of regmap.
3260 int regmap_get_max_register(struct regmap *map)
3262 return map->max_register ? map->max_register : -EINVAL;
3264 EXPORT_SYMBOL_GPL(regmap_get_max_register);
3267 * regmap_get_reg_stride() - Report the register address stride
3269 * @map: Register map to operate on.
3271 * Report the register address stride, mainly intended to for use by
3272 * generic infrastructure built on top of regmap.
3274 int regmap_get_reg_stride(struct regmap *map)
3276 return map->reg_stride;
3278 EXPORT_SYMBOL_GPL(regmap_get_reg_stride);
3280 int regmap_parse_val(struct regmap *map, const void *buf,
3283 if (!map->format.parse_val)
3286 *val = map->format.parse_val(buf);
3290 EXPORT_SYMBOL_GPL(regmap_parse_val);
3292 static int __init regmap_initcall(void)
3294 regmap_debugfs_initcall();
3298 postcore_initcall(regmap_initcall);