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 ret = map->reg_write(context, reg, val);
1929 if (regmap_should_log(map))
1930 dev_info(map->dev, "%x <= %x\n", reg, val);
1932 trace_regmap_reg_write(map, reg, val);
1939 * regmap_write() - Write a value to a single register
1941 * @map: Register map to write to
1942 * @reg: Register to write to
1943 * @val: Value to be written
1945 * A value of zero will be returned on success, a negative errno will
1946 * be returned in error cases.
1948 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1952 if (!IS_ALIGNED(reg, map->reg_stride))
1955 map->lock(map->lock_arg);
1957 ret = _regmap_write(map, reg, val);
1959 map->unlock(map->lock_arg);
1963 EXPORT_SYMBOL_GPL(regmap_write);
1966 * regmap_write_async() - Write a value to a single register asynchronously
1968 * @map: Register map to write to
1969 * @reg: Register to write to
1970 * @val: Value to be written
1972 * A value of zero will be returned on success, a negative errno will
1973 * be returned in error cases.
1975 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val)
1979 if (!IS_ALIGNED(reg, map->reg_stride))
1982 map->lock(map->lock_arg);
1986 ret = _regmap_write(map, reg, val);
1990 map->unlock(map->lock_arg);
1994 EXPORT_SYMBOL_GPL(regmap_write_async);
1996 int _regmap_raw_write(struct regmap *map, unsigned int reg,
1997 const void *val, size_t val_len, bool noinc)
1999 size_t val_bytes = map->format.val_bytes;
2000 size_t val_count = val_len / val_bytes;
2001 size_t chunk_count, chunk_bytes;
2002 size_t chunk_regs = val_count;
2008 if (map->use_single_write)
2010 else if (map->max_raw_write && val_len > map->max_raw_write)
2011 chunk_regs = map->max_raw_write / val_bytes;
2013 chunk_count = val_count / chunk_regs;
2014 chunk_bytes = chunk_regs * val_bytes;
2016 /* Write as many bytes as possible with chunk_size */
2017 for (i = 0; i < chunk_count; i++) {
2018 ret = _regmap_raw_write_impl(map, reg, val, chunk_bytes, noinc);
2022 reg += regmap_get_offset(map, chunk_regs);
2024 val_len -= chunk_bytes;
2027 /* Write remaining bytes */
2029 ret = _regmap_raw_write_impl(map, reg, val, val_len, noinc);
2035 * regmap_raw_write() - Write raw values to one or more registers
2037 * @map: Register map to write to
2038 * @reg: Initial register to write to
2039 * @val: Block of data to be written, laid out for direct transmission to the
2041 * @val_len: Length of data pointed to by val.
2043 * This function is intended to be used for things like firmware
2044 * download where a large block of data needs to be transferred to the
2045 * device. No formatting will be done on the data provided.
2047 * A value of zero will be returned on success, a negative errno will
2048 * be returned in error cases.
2050 int regmap_raw_write(struct regmap *map, unsigned int reg,
2051 const void *val, size_t val_len)
2055 if (!regmap_can_raw_write(map))
2057 if (val_len % map->format.val_bytes)
2060 map->lock(map->lock_arg);
2062 ret = _regmap_raw_write(map, reg, val, val_len, false);
2064 map->unlock(map->lock_arg);
2068 EXPORT_SYMBOL_GPL(regmap_raw_write);
2071 * regmap_noinc_write(): Write data from a register without incrementing the
2074 * @map: Register map to write to
2075 * @reg: Register to write to
2076 * @val: Pointer to data buffer
2077 * @val_len: Length of output buffer in bytes.
2079 * The regmap API usually assumes that bulk bus write operations will write a
2080 * range of registers. Some devices have certain registers for which a write
2081 * operation can write to an internal FIFO.
2083 * The target register must be volatile but registers after it can be
2084 * completely unrelated cacheable registers.
2086 * This will attempt multiple writes as required to write val_len bytes.
2088 * A value of zero will be returned on success, a negative errno will be
2089 * returned in error cases.
2091 int regmap_noinc_write(struct regmap *map, unsigned int reg,
2092 const void *val, size_t val_len)
2099 if (!map->bus->write)
2101 if (val_len % map->format.val_bytes)
2103 if (!IS_ALIGNED(reg, map->reg_stride))
2108 map->lock(map->lock_arg);
2110 if (!regmap_volatile(map, reg) || !regmap_writeable_noinc(map, reg)) {
2116 if (map->max_raw_write && map->max_raw_write < val_len)
2117 write_len = map->max_raw_write;
2119 write_len = val_len;
2120 ret = _regmap_raw_write(map, reg, val, write_len, true);
2123 val = ((u8 *)val) + write_len;
2124 val_len -= write_len;
2128 map->unlock(map->lock_arg);
2131 EXPORT_SYMBOL_GPL(regmap_noinc_write);
2134 * regmap_field_update_bits_base() - Perform a read/modify/write cycle a
2137 * @field: Register field to write to
2138 * @mask: Bitmask to change
2139 * @val: Value to be written
2140 * @change: Boolean indicating if a write was done
2141 * @async: Boolean indicating asynchronously
2142 * @force: Boolean indicating use force update
2144 * Perform a read/modify/write cycle on the register field with change,
2145 * async, force option.
2147 * A value of zero will be returned on success, a negative errno will
2148 * be returned in error cases.
2150 int regmap_field_update_bits_base(struct regmap_field *field,
2151 unsigned int mask, unsigned int val,
2152 bool *change, bool async, bool force)
2154 mask = (mask << field->shift) & field->mask;
2156 return regmap_update_bits_base(field->regmap, field->reg,
2157 mask, val << field->shift,
2158 change, async, force);
2160 EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);
2163 * regmap_fields_update_bits_base() - Perform a read/modify/write cycle a
2164 * register field with port ID
2166 * @field: Register field to write to
2168 * @mask: Bitmask to change
2169 * @val: Value to be written
2170 * @change: Boolean indicating if a write was done
2171 * @async: Boolean indicating asynchronously
2172 * @force: Boolean indicating use force update
2174 * A value of zero will be returned on success, a negative errno will
2175 * be returned in error cases.
2177 int regmap_fields_update_bits_base(struct regmap_field *field, unsigned int id,
2178 unsigned int mask, unsigned int val,
2179 bool *change, bool async, bool force)
2181 if (id >= field->id_size)
2184 mask = (mask << field->shift) & field->mask;
2186 return regmap_update_bits_base(field->regmap,
2187 field->reg + (field->id_offset * id),
2188 mask, val << field->shift,
2189 change, async, force);
2191 EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);
2194 * regmap_bulk_write() - Write multiple registers to the device
2196 * @map: Register map to write to
2197 * @reg: First register to be write from
2198 * @val: Block of data to be written, in native register size for device
2199 * @val_count: Number of registers to write
2201 * This function is intended to be used for writing a large block of
2202 * data to the device either in single transfer or multiple transfer.
2204 * A value of zero will be returned on success, a negative errno will
2205 * be returned in error cases.
2207 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
2211 size_t val_bytes = map->format.val_bytes;
2213 if (!IS_ALIGNED(reg, map->reg_stride))
2217 * Some devices don't support bulk write, for them we have a series of
2218 * single write operations.
2220 if (!map->bus || !map->format.parse_inplace) {
2221 map->lock(map->lock_arg);
2222 for (i = 0; i < val_count; i++) {
2225 switch (val_bytes) {
2227 ival = *(u8 *)(val + (i * val_bytes));
2230 ival = *(u16 *)(val + (i * val_bytes));
2233 ival = *(u32 *)(val + (i * val_bytes));
2237 ival = *(u64 *)(val + (i * val_bytes));
2245 ret = _regmap_write(map,
2246 reg + regmap_get_offset(map, i),
2252 map->unlock(map->lock_arg);
2256 wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
2260 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2261 map->format.parse_inplace(wval + i);
2263 ret = regmap_raw_write(map, reg, wval, val_bytes * val_count);
2269 EXPORT_SYMBOL_GPL(regmap_bulk_write);
2272 * _regmap_raw_multi_reg_write()
2274 * the (register,newvalue) pairs in regs have not been formatted, but
2275 * they are all in the same page and have been changed to being page
2276 * relative. The page register has been written if that was necessary.
2278 static int _regmap_raw_multi_reg_write(struct regmap *map,
2279 const struct reg_sequence *regs,
2286 size_t val_bytes = map->format.val_bytes;
2287 size_t reg_bytes = map->format.reg_bytes;
2288 size_t pad_bytes = map->format.pad_bytes;
2289 size_t pair_size = reg_bytes + pad_bytes + val_bytes;
2290 size_t len = pair_size * num_regs;
2295 buf = kzalloc(len, GFP_KERNEL);
2299 /* We have to linearise by hand. */
2303 for (i = 0; i < num_regs; i++) {
2304 unsigned int reg = regs[i].reg;
2305 unsigned int val = regs[i].def;
2306 trace_regmap_hw_write_start(map, reg, 1);
2307 map->format.format_reg(u8, reg, map->reg_shift);
2308 u8 += reg_bytes + pad_bytes;
2309 map->format.format_val(u8, val, 0);
2313 *u8 |= map->write_flag_mask;
2315 ret = map->bus->write(map->bus_context, buf, len);
2319 for (i = 0; i < num_regs; i++) {
2320 int reg = regs[i].reg;
2321 trace_regmap_hw_write_done(map, reg, 1);
2326 static unsigned int _regmap_register_page(struct regmap *map,
2328 struct regmap_range_node *range)
2330 unsigned int win_page = (reg - range->range_min) / range->window_len;
2335 static int _regmap_range_multi_paged_reg_write(struct regmap *map,
2336 struct reg_sequence *regs,
2341 struct reg_sequence *base;
2342 unsigned int this_page = 0;
2343 unsigned int page_change = 0;
2345 * the set of registers are not neccessarily in order, but
2346 * since the order of write must be preserved this algorithm
2347 * chops the set each time the page changes. This also applies
2348 * if there is a delay required at any point in the sequence.
2351 for (i = 0, n = 0; i < num_regs; i++, n++) {
2352 unsigned int reg = regs[i].reg;
2353 struct regmap_range_node *range;
2355 range = _regmap_range_lookup(map, reg);
2357 unsigned int win_page = _regmap_register_page(map, reg,
2361 this_page = win_page;
2362 if (win_page != this_page) {
2363 this_page = win_page;
2368 /* If we have both a page change and a delay make sure to
2369 * write the regs and apply the delay before we change the
2373 if (page_change || regs[i].delay_us) {
2375 /* For situations where the first write requires
2376 * a delay we need to make sure we don't call
2377 * raw_multi_reg_write with n=0
2378 * This can't occur with page breaks as we
2379 * never write on the first iteration
2381 if (regs[i].delay_us && i == 0)
2384 ret = _regmap_raw_multi_reg_write(map, base, n);
2388 if (regs[i].delay_us) {
2390 fsleep(regs[i].delay_us);
2392 udelay(regs[i].delay_us);
2399 ret = _regmap_select_page(map,
2412 return _regmap_raw_multi_reg_write(map, base, n);
2416 static int _regmap_multi_reg_write(struct regmap *map,
2417 const struct reg_sequence *regs,
2423 if (!map->can_multi_write) {
2424 for (i = 0; i < num_regs; i++) {
2425 ret = _regmap_write(map, regs[i].reg, regs[i].def);
2429 if (regs[i].delay_us) {
2431 fsleep(regs[i].delay_us);
2433 udelay(regs[i].delay_us);
2439 if (!map->format.parse_inplace)
2442 if (map->writeable_reg)
2443 for (i = 0; i < num_regs; i++) {
2444 int reg = regs[i].reg;
2445 if (!map->writeable_reg(map->dev, reg))
2447 if (!IS_ALIGNED(reg, map->reg_stride))
2451 if (!map->cache_bypass) {
2452 for (i = 0; i < num_regs; i++) {
2453 unsigned int val = regs[i].def;
2454 unsigned int reg = regs[i].reg;
2455 ret = regcache_write(map, reg, val);
2458 "Error in caching of register: %x ret: %d\n",
2463 if (map->cache_only) {
2464 map->cache_dirty = true;
2471 for (i = 0; i < num_regs; i++) {
2472 unsigned int reg = regs[i].reg;
2473 struct regmap_range_node *range;
2475 /* Coalesce all the writes between a page break or a delay
2478 range = _regmap_range_lookup(map, reg);
2479 if (range || regs[i].delay_us) {
2480 size_t len = sizeof(struct reg_sequence)*num_regs;
2481 struct reg_sequence *base = kmemdup(regs, len,
2485 ret = _regmap_range_multi_paged_reg_write(map, base,
2492 return _regmap_raw_multi_reg_write(map, regs, num_regs);
2496 * regmap_multi_reg_write() - Write multiple registers to the device
2498 * @map: Register map to write to
2499 * @regs: Array of structures containing register,value to be written
2500 * @num_regs: Number of registers to write
2502 * Write multiple registers to the device where the set of register, value
2503 * pairs are supplied in any order, possibly not all in a single range.
2505 * The 'normal' block write mode will send ultimately send data on the
2506 * target bus as R,V1,V2,V3,..,Vn where successively higher registers are
2507 * addressed. However, this alternative block multi write mode will send
2508 * the data as R1,V1,R2,V2,..,Rn,Vn on the target bus. The target device
2509 * must of course support the mode.
2511 * A value of zero will be returned on success, a negative errno will be
2512 * returned in error cases.
2514 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
2519 map->lock(map->lock_arg);
2521 ret = _regmap_multi_reg_write(map, regs, num_regs);
2523 map->unlock(map->lock_arg);
2527 EXPORT_SYMBOL_GPL(regmap_multi_reg_write);
2530 * regmap_multi_reg_write_bypassed() - Write multiple registers to the
2531 * device but not the cache
2533 * @map: Register map to write to
2534 * @regs: Array of structures containing register,value to be written
2535 * @num_regs: Number of registers to write
2537 * Write multiple registers to the device but not the cache where the set
2538 * of register are supplied in any order.
2540 * This function is intended to be used for writing a large block of data
2541 * atomically to the device in single transfer for those I2C client devices
2542 * that implement this alternative block write mode.
2544 * A value of zero will be returned on success, a negative errno will
2545 * be returned in error cases.
2547 int regmap_multi_reg_write_bypassed(struct regmap *map,
2548 const struct reg_sequence *regs,
2554 map->lock(map->lock_arg);
2556 bypass = map->cache_bypass;
2557 map->cache_bypass = true;
2559 ret = _regmap_multi_reg_write(map, regs, num_regs);
2561 map->cache_bypass = bypass;
2563 map->unlock(map->lock_arg);
2567 EXPORT_SYMBOL_GPL(regmap_multi_reg_write_bypassed);
2570 * regmap_raw_write_async() - Write raw values to one or more registers
2573 * @map: Register map to write to
2574 * @reg: Initial register to write to
2575 * @val: Block of data to be written, laid out for direct transmission to the
2576 * device. Must be valid until regmap_async_complete() is called.
2577 * @val_len: Length of data pointed to by val.
2579 * This function is intended to be used for things like firmware
2580 * download where a large block of data needs to be transferred to the
2581 * device. No formatting will be done on the data provided.
2583 * If supported by the underlying bus the write will be scheduled
2584 * asynchronously, helping maximise I/O speed on higher speed buses
2585 * like SPI. regmap_async_complete() can be called to ensure that all
2586 * asynchrnous writes have been completed.
2588 * A value of zero will be returned on success, a negative errno will
2589 * be returned in error cases.
2591 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
2592 const void *val, size_t val_len)
2596 if (val_len % map->format.val_bytes)
2598 if (!IS_ALIGNED(reg, map->reg_stride))
2601 map->lock(map->lock_arg);
2605 ret = _regmap_raw_write(map, reg, val, val_len, false);
2609 map->unlock(map->lock_arg);
2613 EXPORT_SYMBOL_GPL(regmap_raw_write_async);
2615 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2616 unsigned int val_len, bool noinc)
2618 struct regmap_range_node *range;
2623 if (!map->bus || !map->bus->read)
2626 range = _regmap_range_lookup(map, reg);
2628 ret = _regmap_select_page(map, ®, range,
2629 noinc ? 1 : val_len / map->format.val_bytes);
2634 map->format.format_reg(map->work_buf, reg, map->reg_shift);
2635 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
2636 map->read_flag_mask);
2637 trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
2639 ret = map->bus->read(map->bus_context, map->work_buf,
2640 map->format.reg_bytes + map->format.pad_bytes,
2643 trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
2648 static int _regmap_bus_reg_read(void *context, unsigned int reg,
2651 struct regmap *map = context;
2653 return map->bus->reg_read(map->bus_context, reg, val);
2656 static int _regmap_bus_read(void *context, unsigned int reg,
2660 struct regmap *map = context;
2661 void *work_val = map->work_buf + map->format.reg_bytes +
2662 map->format.pad_bytes;
2664 if (!map->format.parse_val)
2667 ret = _regmap_raw_read(map, reg, work_val, map->format.val_bytes, false);
2669 *val = map->format.parse_val(work_val);
2674 static int _regmap_read(struct regmap *map, unsigned int reg,
2678 void *context = _regmap_map_get_context(map);
2680 if (!map->cache_bypass) {
2681 ret = regcache_read(map, reg, val);
2686 if (map->cache_only)
2689 if (!regmap_readable(map, reg))
2692 ret = map->reg_read(context, reg, val);
2694 if (regmap_should_log(map))
2695 dev_info(map->dev, "%x => %x\n", reg, *val);
2697 trace_regmap_reg_read(map, reg, *val);
2699 if (!map->cache_bypass)
2700 regcache_write(map, reg, *val);
2707 * regmap_read() - Read a value from a single register
2709 * @map: Register map to read from
2710 * @reg: Register to be read from
2711 * @val: Pointer to store read value
2713 * A value of zero will be returned on success, a negative errno will
2714 * be returned in error cases.
2716 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
2720 if (!IS_ALIGNED(reg, map->reg_stride))
2723 map->lock(map->lock_arg);
2725 ret = _regmap_read(map, reg, val);
2727 map->unlock(map->lock_arg);
2731 EXPORT_SYMBOL_GPL(regmap_read);
2734 * regmap_raw_read() - Read raw data from the device
2736 * @map: Register map to read from
2737 * @reg: First register to be read from
2738 * @val: Pointer to store read value
2739 * @val_len: Size of data to read
2741 * A value of zero will be returned on success, a negative errno will
2742 * be returned in error cases.
2744 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2747 size_t val_bytes = map->format.val_bytes;
2748 size_t val_count = val_len / val_bytes;
2754 if (val_len % map->format.val_bytes)
2756 if (!IS_ALIGNED(reg, map->reg_stride))
2761 map->lock(map->lock_arg);
2763 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
2764 map->cache_type == REGCACHE_NONE) {
2765 size_t chunk_count, chunk_bytes;
2766 size_t chunk_regs = val_count;
2768 if (!map->bus->read) {
2773 if (map->use_single_read)
2775 else if (map->max_raw_read && val_len > map->max_raw_read)
2776 chunk_regs = map->max_raw_read / val_bytes;
2778 chunk_count = val_count / chunk_regs;
2779 chunk_bytes = chunk_regs * val_bytes;
2781 /* Read bytes that fit into whole chunks */
2782 for (i = 0; i < chunk_count; i++) {
2783 ret = _regmap_raw_read(map, reg, val, chunk_bytes, false);
2787 reg += regmap_get_offset(map, chunk_regs);
2789 val_len -= chunk_bytes;
2792 /* Read remaining bytes */
2794 ret = _regmap_raw_read(map, reg, val, val_len, false);
2799 /* Otherwise go word by word for the cache; should be low
2800 * cost as we expect to hit the cache.
2802 for (i = 0; i < val_count; i++) {
2803 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2808 map->format.format_val(val + (i * val_bytes), v, 0);
2813 map->unlock(map->lock_arg);
2817 EXPORT_SYMBOL_GPL(regmap_raw_read);
2820 * regmap_noinc_read(): Read data from a register without incrementing the
2823 * @map: Register map to read from
2824 * @reg: Register to read from
2825 * @val: Pointer to data buffer
2826 * @val_len: Length of output buffer in bytes.
2828 * The regmap API usually assumes that bulk bus read operations will read a
2829 * range of registers. Some devices have certain registers for which a read
2830 * operation read will read from an internal FIFO.
2832 * The target register must be volatile but registers after it can be
2833 * completely unrelated cacheable registers.
2835 * This will attempt multiple reads as required to read val_len bytes.
2837 * A value of zero will be returned on success, a negative errno will be
2838 * returned in error cases.
2840 int regmap_noinc_read(struct regmap *map, unsigned int reg,
2841 void *val, size_t val_len)
2848 if (!map->bus->read)
2850 if (val_len % map->format.val_bytes)
2852 if (!IS_ALIGNED(reg, map->reg_stride))
2857 map->lock(map->lock_arg);
2859 if (!regmap_volatile(map, reg) || !regmap_readable_noinc(map, reg)) {
2865 if (map->max_raw_read && map->max_raw_read < val_len)
2866 read_len = map->max_raw_read;
2869 ret = _regmap_raw_read(map, reg, val, read_len, true);
2872 val = ((u8 *)val) + read_len;
2873 val_len -= read_len;
2877 map->unlock(map->lock_arg);
2880 EXPORT_SYMBOL_GPL(regmap_noinc_read);
2883 * regmap_field_read(): Read a value to a single register field
2885 * @field: Register field to read from
2886 * @val: Pointer to store read value
2888 * A value of zero will be returned on success, a negative errno will
2889 * be returned in error cases.
2891 int regmap_field_read(struct regmap_field *field, unsigned int *val)
2894 unsigned int reg_val;
2895 ret = regmap_read(field->regmap, field->reg, ®_val);
2899 reg_val &= field->mask;
2900 reg_val >>= field->shift;
2905 EXPORT_SYMBOL_GPL(regmap_field_read);
2908 * regmap_fields_read() - Read a value to a single register field with port ID
2910 * @field: Register field to read from
2912 * @val: Pointer to store read value
2914 * A value of zero will be returned on success, a negative errno will
2915 * be returned in error cases.
2917 int regmap_fields_read(struct regmap_field *field, unsigned int id,
2921 unsigned int reg_val;
2923 if (id >= field->id_size)
2926 ret = regmap_read(field->regmap,
2927 field->reg + (field->id_offset * id),
2932 reg_val &= field->mask;
2933 reg_val >>= field->shift;
2938 EXPORT_SYMBOL_GPL(regmap_fields_read);
2941 * regmap_bulk_read() - Read multiple registers from the device
2943 * @map: Register map to read from
2944 * @reg: First register to be read from
2945 * @val: Pointer to store read value, in native register size for device
2946 * @val_count: Number of registers to read
2948 * A value of zero will be returned on success, a negative errno will
2949 * be returned in error cases.
2951 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
2955 size_t val_bytes = map->format.val_bytes;
2956 bool vol = regmap_volatile_range(map, reg, val_count);
2958 if (!IS_ALIGNED(reg, map->reg_stride))
2963 if (map->bus && map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
2964 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
2968 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2969 map->format.parse_inplace(val + i);
2978 map->lock(map->lock_arg);
2980 for (i = 0; i < val_count; i++) {
2983 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2988 switch (map->format.val_bytes) {
3010 map->unlock(map->lock_arg);
3015 EXPORT_SYMBOL_GPL(regmap_bulk_read);
3017 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
3018 unsigned int mask, unsigned int val,
3019 bool *change, bool force_write)
3022 unsigned int tmp, orig;
3027 if (regmap_volatile(map, reg) && map->reg_update_bits) {
3028 ret = map->reg_update_bits(map->bus_context, reg, mask, val);
3029 if (ret == 0 && change)
3032 ret = _regmap_read(map, reg, &orig);
3039 if (force_write || (tmp != orig)) {
3040 ret = _regmap_write(map, reg, tmp);
3041 if (ret == 0 && change)
3050 * regmap_update_bits_base() - Perform a read/modify/write cycle on a register
3052 * @map: Register map to update
3053 * @reg: Register to update
3054 * @mask: Bitmask to change
3055 * @val: New value for bitmask
3056 * @change: Boolean indicating if a write was done
3057 * @async: Boolean indicating asynchronously
3058 * @force: Boolean indicating use force update
3060 * Perform a read/modify/write cycle on a register map with change, async, force
3065 * With most buses the read must be done synchronously so this is most useful
3066 * for devices with a cache which do not need to interact with the hardware to
3067 * determine the current register value.
3069 * Returns zero for success, a negative number on error.
3071 int regmap_update_bits_base(struct regmap *map, unsigned int reg,
3072 unsigned int mask, unsigned int val,
3073 bool *change, bool async, bool force)
3077 map->lock(map->lock_arg);
3081 ret = _regmap_update_bits(map, reg, mask, val, change, force);
3085 map->unlock(map->lock_arg);
3089 EXPORT_SYMBOL_GPL(regmap_update_bits_base);
3092 * regmap_test_bits() - Check if all specified bits are set in a register.
3094 * @map: Register map to operate on
3095 * @reg: Register to read from
3096 * @bits: Bits to test
3098 * Returns 0 if at least one of the tested bits is not set, 1 if all tested
3099 * bits are set and a negative error number if the underlying regmap_read()
3102 int regmap_test_bits(struct regmap *map, unsigned int reg, unsigned int bits)
3104 unsigned int val, ret;
3106 ret = regmap_read(map, reg, &val);
3110 return (val & bits) == bits;
3112 EXPORT_SYMBOL_GPL(regmap_test_bits);
3114 void regmap_async_complete_cb(struct regmap_async *async, int ret)
3116 struct regmap *map = async->map;
3119 trace_regmap_async_io_complete(map);
3121 spin_lock(&map->async_lock);
3122 list_move(&async->list, &map->async_free);
3123 wake = list_empty(&map->async_list);
3126 map->async_ret = ret;
3128 spin_unlock(&map->async_lock);
3131 wake_up(&map->async_waitq);
3133 EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
3135 static int regmap_async_is_done(struct regmap *map)
3137 unsigned long flags;
3140 spin_lock_irqsave(&map->async_lock, flags);
3141 ret = list_empty(&map->async_list);
3142 spin_unlock_irqrestore(&map->async_lock, flags);
3148 * regmap_async_complete - Ensure all asynchronous I/O has completed.
3150 * @map: Map to operate on.
3152 * Blocks until any pending asynchronous I/O has completed. Returns
3153 * an error code for any failed I/O operations.
3155 int regmap_async_complete(struct regmap *map)
3157 unsigned long flags;
3160 /* Nothing to do with no async support */
3161 if (!map->bus || !map->bus->async_write)
3164 trace_regmap_async_complete_start(map);
3166 wait_event(map->async_waitq, regmap_async_is_done(map));
3168 spin_lock_irqsave(&map->async_lock, flags);
3169 ret = map->async_ret;
3171 spin_unlock_irqrestore(&map->async_lock, flags);
3173 trace_regmap_async_complete_done(map);
3177 EXPORT_SYMBOL_GPL(regmap_async_complete);
3180 * regmap_register_patch - Register and apply register updates to be applied
3181 * on device initialistion
3183 * @map: Register map to apply updates to.
3184 * @regs: Values to update.
3185 * @num_regs: Number of entries in regs.
3187 * Register a set of register updates to be applied to the device
3188 * whenever the device registers are synchronised with the cache and
3189 * apply them immediately. Typically this is used to apply
3190 * corrections to be applied to the device defaults on startup, such
3191 * as the updates some vendors provide to undocumented registers.
3193 * The caller must ensure that this function cannot be called
3194 * concurrently with either itself or regcache_sync().
3196 int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
3199 struct reg_sequence *p;
3203 if (WARN_ONCE(num_regs <= 0, "invalid registers number (%d)\n",
3207 p = krealloc(map->patch,
3208 sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
3211 memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
3213 map->patch_regs += num_regs;
3218 map->lock(map->lock_arg);
3220 bypass = map->cache_bypass;
3222 map->cache_bypass = true;
3225 ret = _regmap_multi_reg_write(map, regs, num_regs);
3228 map->cache_bypass = bypass;
3230 map->unlock(map->lock_arg);
3232 regmap_async_complete(map);
3236 EXPORT_SYMBOL_GPL(regmap_register_patch);
3239 * regmap_get_val_bytes() - Report the size of a register value
3241 * @map: Register map to operate on.
3243 * Report the size of a register value, mainly intended to for use by
3244 * generic infrastructure built on top of regmap.
3246 int regmap_get_val_bytes(struct regmap *map)
3248 if (map->format.format_write)
3251 return map->format.val_bytes;
3253 EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
3256 * regmap_get_max_register() - Report the max register value
3258 * @map: Register map to operate on.
3260 * Report the max register value, mainly intended to for use by
3261 * generic infrastructure built on top of regmap.
3263 int regmap_get_max_register(struct regmap *map)
3265 return map->max_register ? map->max_register : -EINVAL;
3267 EXPORT_SYMBOL_GPL(regmap_get_max_register);
3270 * regmap_get_reg_stride() - Report the register address stride
3272 * @map: Register map to operate on.
3274 * Report the register address stride, mainly intended to for use by
3275 * generic infrastructure built on top of regmap.
3277 int regmap_get_reg_stride(struct regmap *map)
3279 return map->reg_stride;
3281 EXPORT_SYMBOL_GPL(regmap_get_reg_stride);
3283 int regmap_parse_val(struct regmap *map, const void *buf,
3286 if (!map->format.parse_val)
3289 *val = map->format.parse_val(buf);
3293 EXPORT_SYMBOL_GPL(regmap_parse_val);
3295 static int __init regmap_initcall(void)
3297 regmap_debugfs_initcall();
3301 postcore_initcall(regmap_initcall);