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_exit(map);
624 regmap_debugfs_init(map);
626 /* Add a devres resource for dev_get_regmap() */
627 m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
629 regmap_debugfs_exit(map);
637 EXPORT_SYMBOL_GPL(regmap_attach_dev);
639 static enum regmap_endian regmap_get_reg_endian(const struct regmap_bus *bus,
640 const struct regmap_config *config)
642 enum regmap_endian endian;
644 /* Retrieve the endianness specification from the regmap config */
645 endian = config->reg_format_endian;
647 /* If the regmap config specified a non-default value, use that */
648 if (endian != REGMAP_ENDIAN_DEFAULT)
651 /* Retrieve the endianness specification from the bus config */
652 if (bus && bus->reg_format_endian_default)
653 endian = bus->reg_format_endian_default;
655 /* If the bus specified a non-default value, use that */
656 if (endian != REGMAP_ENDIAN_DEFAULT)
659 /* Use this if no other value was found */
660 return REGMAP_ENDIAN_BIG;
663 enum regmap_endian regmap_get_val_endian(struct device *dev,
664 const struct regmap_bus *bus,
665 const struct regmap_config *config)
667 struct fwnode_handle *fwnode = dev ? dev_fwnode(dev) : NULL;
668 enum regmap_endian endian;
670 /* Retrieve the endianness specification from the regmap config */
671 endian = config->val_format_endian;
673 /* If the regmap config specified a non-default value, use that */
674 if (endian != REGMAP_ENDIAN_DEFAULT)
677 /* If the firmware node exist try to get endianness from it */
678 if (fwnode_property_read_bool(fwnode, "big-endian"))
679 endian = REGMAP_ENDIAN_BIG;
680 else if (fwnode_property_read_bool(fwnode, "little-endian"))
681 endian = REGMAP_ENDIAN_LITTLE;
682 else if (fwnode_property_read_bool(fwnode, "native-endian"))
683 endian = REGMAP_ENDIAN_NATIVE;
685 /* If the endianness was specified in fwnode, use that */
686 if (endian != REGMAP_ENDIAN_DEFAULT)
689 /* Retrieve the endianness specification from the bus config */
690 if (bus && bus->val_format_endian_default)
691 endian = bus->val_format_endian_default;
693 /* If the bus specified a non-default value, use that */
694 if (endian != REGMAP_ENDIAN_DEFAULT)
697 /* Use this if no other value was found */
698 return REGMAP_ENDIAN_BIG;
700 EXPORT_SYMBOL_GPL(regmap_get_val_endian);
702 struct regmap *__regmap_init(struct device *dev,
703 const struct regmap_bus *bus,
705 const struct regmap_config *config,
706 struct lock_class_key *lock_key,
707 const char *lock_name)
711 enum regmap_endian reg_endian, val_endian;
717 map = kzalloc(sizeof(*map), GFP_KERNEL);
723 ret = regmap_set_name(map, config);
727 ret = -EINVAL; /* Later error paths rely on this */
729 if (config->disable_locking) {
730 map->lock = map->unlock = regmap_lock_unlock_none;
731 map->can_sleep = config->can_sleep;
732 regmap_debugfs_disable(map);
733 } else if (config->lock && config->unlock) {
734 map->lock = config->lock;
735 map->unlock = config->unlock;
736 map->lock_arg = config->lock_arg;
737 map->can_sleep = config->can_sleep;
738 } else if (config->use_hwlock) {
739 map->hwlock = hwspin_lock_request_specific(config->hwlock_id);
745 switch (config->hwlock_mode) {
746 case HWLOCK_IRQSTATE:
747 map->lock = regmap_lock_hwlock_irqsave;
748 map->unlock = regmap_unlock_hwlock_irqrestore;
751 map->lock = regmap_lock_hwlock_irq;
752 map->unlock = regmap_unlock_hwlock_irq;
755 map->lock = regmap_lock_hwlock;
756 map->unlock = regmap_unlock_hwlock;
762 if ((bus && bus->fast_io) ||
764 spin_lock_init(&map->spinlock);
765 map->lock = regmap_lock_spinlock;
766 map->unlock = regmap_unlock_spinlock;
767 lockdep_set_class_and_name(&map->spinlock,
768 lock_key, lock_name);
770 mutex_init(&map->mutex);
771 map->lock = regmap_lock_mutex;
772 map->unlock = regmap_unlock_mutex;
773 map->can_sleep = true;
774 lockdep_set_class_and_name(&map->mutex,
775 lock_key, lock_name);
781 * When we write in fast-paths with regmap_bulk_write() don't allocate
782 * scratch buffers with sleeping allocations.
784 if ((bus && bus->fast_io) || config->fast_io)
785 map->alloc_flags = GFP_ATOMIC;
787 map->alloc_flags = GFP_KERNEL;
789 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
790 map->format.pad_bytes = config->pad_bits / 8;
791 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
792 map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
793 config->val_bits + config->pad_bits, 8);
794 map->reg_shift = config->pad_bits % 8;
795 if (config->reg_stride)
796 map->reg_stride = config->reg_stride;
799 if (is_power_of_2(map->reg_stride))
800 map->reg_stride_order = ilog2(map->reg_stride);
802 map->reg_stride_order = -1;
803 map->use_single_read = config->use_single_read || !(config->read || (bus && bus->read));
804 map->use_single_write = config->use_single_write || !(config->write || (bus && bus->write));
805 map->can_multi_write = config->can_multi_write && (config->write || (bus && bus->write));
807 map->max_raw_read = bus->max_raw_read;
808 map->max_raw_write = bus->max_raw_write;
809 } else if (config->max_raw_read && config->max_raw_write) {
810 map->max_raw_read = config->max_raw_read;
811 map->max_raw_write = config->max_raw_write;
815 map->bus_context = bus_context;
816 map->max_register = config->max_register;
817 map->wr_table = config->wr_table;
818 map->rd_table = config->rd_table;
819 map->volatile_table = config->volatile_table;
820 map->precious_table = config->precious_table;
821 map->wr_noinc_table = config->wr_noinc_table;
822 map->rd_noinc_table = config->rd_noinc_table;
823 map->writeable_reg = config->writeable_reg;
824 map->readable_reg = config->readable_reg;
825 map->volatile_reg = config->volatile_reg;
826 map->precious_reg = config->precious_reg;
827 map->writeable_noinc_reg = config->writeable_noinc_reg;
828 map->readable_noinc_reg = config->readable_noinc_reg;
829 map->cache_type = config->cache_type;
831 spin_lock_init(&map->async_lock);
832 INIT_LIST_HEAD(&map->async_list);
833 INIT_LIST_HEAD(&map->async_free);
834 init_waitqueue_head(&map->async_waitq);
836 if (config->read_flag_mask ||
837 config->write_flag_mask ||
838 config->zero_flag_mask) {
839 map->read_flag_mask = config->read_flag_mask;
840 map->write_flag_mask = config->write_flag_mask;
842 map->read_flag_mask = bus->read_flag_mask;
845 if (config && config->read && config->write) {
846 map->reg_read = _regmap_bus_read;
848 /* Bulk read/write */
849 map->read = config->read;
850 map->write = config->write;
852 reg_endian = REGMAP_ENDIAN_NATIVE;
853 val_endian = REGMAP_ENDIAN_NATIVE;
855 map->reg_read = config->reg_read;
856 map->reg_write = config->reg_write;
857 map->reg_update_bits = config->reg_update_bits;
859 map->defer_caching = false;
860 goto skip_format_initialization;
861 } else if (!bus->read || !bus->write) {
862 map->reg_read = _regmap_bus_reg_read;
863 map->reg_write = _regmap_bus_reg_write;
864 map->reg_update_bits = bus->reg_update_bits;
866 map->defer_caching = false;
867 goto skip_format_initialization;
869 map->reg_read = _regmap_bus_read;
870 map->reg_update_bits = bus->reg_update_bits;
871 /* Bulk read/write */
872 map->read = bus->read;
873 map->write = bus->write;
875 reg_endian = regmap_get_reg_endian(bus, config);
876 val_endian = regmap_get_val_endian(dev, bus, config);
879 switch (config->reg_bits + map->reg_shift) {
881 switch (config->val_bits) {
883 map->format.format_write = regmap_format_2_6_write;
891 switch (config->val_bits) {
893 map->format.format_write = regmap_format_4_12_write;
901 switch (config->val_bits) {
903 map->format.format_write = regmap_format_7_9_write;
911 switch (config->val_bits) {
913 map->format.format_write = regmap_format_10_14_write;
921 switch (config->val_bits) {
923 map->format.format_write = regmap_format_12_20_write;
931 map->format.format_reg = regmap_format_8;
935 switch (reg_endian) {
936 case REGMAP_ENDIAN_BIG:
937 map->format.format_reg = regmap_format_16_be;
939 case REGMAP_ENDIAN_LITTLE:
940 map->format.format_reg = regmap_format_16_le;
942 case REGMAP_ENDIAN_NATIVE:
943 map->format.format_reg = regmap_format_16_native;
951 if (reg_endian != REGMAP_ENDIAN_BIG)
953 map->format.format_reg = regmap_format_24;
957 switch (reg_endian) {
958 case REGMAP_ENDIAN_BIG:
959 map->format.format_reg = regmap_format_32_be;
961 case REGMAP_ENDIAN_LITTLE:
962 map->format.format_reg = regmap_format_32_le;
964 case REGMAP_ENDIAN_NATIVE:
965 map->format.format_reg = regmap_format_32_native;
974 switch (reg_endian) {
975 case REGMAP_ENDIAN_BIG:
976 map->format.format_reg = regmap_format_64_be;
978 case REGMAP_ENDIAN_LITTLE:
979 map->format.format_reg = regmap_format_64_le;
981 case REGMAP_ENDIAN_NATIVE:
982 map->format.format_reg = regmap_format_64_native;
994 if (val_endian == REGMAP_ENDIAN_NATIVE)
995 map->format.parse_inplace = regmap_parse_inplace_noop;
997 switch (config->val_bits) {
999 map->format.format_val = regmap_format_8;
1000 map->format.parse_val = regmap_parse_8;
1001 map->format.parse_inplace = regmap_parse_inplace_noop;
1004 switch (val_endian) {
1005 case REGMAP_ENDIAN_BIG:
1006 map->format.format_val = regmap_format_16_be;
1007 map->format.parse_val = regmap_parse_16_be;
1008 map->format.parse_inplace = regmap_parse_16_be_inplace;
1010 case REGMAP_ENDIAN_LITTLE:
1011 map->format.format_val = regmap_format_16_le;
1012 map->format.parse_val = regmap_parse_16_le;
1013 map->format.parse_inplace = regmap_parse_16_le_inplace;
1015 case REGMAP_ENDIAN_NATIVE:
1016 map->format.format_val = regmap_format_16_native;
1017 map->format.parse_val = regmap_parse_16_native;
1024 if (val_endian != REGMAP_ENDIAN_BIG)
1026 map->format.format_val = regmap_format_24;
1027 map->format.parse_val = regmap_parse_24;
1030 switch (val_endian) {
1031 case REGMAP_ENDIAN_BIG:
1032 map->format.format_val = regmap_format_32_be;
1033 map->format.parse_val = regmap_parse_32_be;
1034 map->format.parse_inplace = regmap_parse_32_be_inplace;
1036 case REGMAP_ENDIAN_LITTLE:
1037 map->format.format_val = regmap_format_32_le;
1038 map->format.parse_val = regmap_parse_32_le;
1039 map->format.parse_inplace = regmap_parse_32_le_inplace;
1041 case REGMAP_ENDIAN_NATIVE:
1042 map->format.format_val = regmap_format_32_native;
1043 map->format.parse_val = regmap_parse_32_native;
1051 switch (val_endian) {
1052 case REGMAP_ENDIAN_BIG:
1053 map->format.format_val = regmap_format_64_be;
1054 map->format.parse_val = regmap_parse_64_be;
1055 map->format.parse_inplace = regmap_parse_64_be_inplace;
1057 case REGMAP_ENDIAN_LITTLE:
1058 map->format.format_val = regmap_format_64_le;
1059 map->format.parse_val = regmap_parse_64_le;
1060 map->format.parse_inplace = regmap_parse_64_le_inplace;
1062 case REGMAP_ENDIAN_NATIVE:
1063 map->format.format_val = regmap_format_64_native;
1064 map->format.parse_val = regmap_parse_64_native;
1073 if (map->format.format_write) {
1074 if ((reg_endian != REGMAP_ENDIAN_BIG) ||
1075 (val_endian != REGMAP_ENDIAN_BIG))
1077 map->use_single_write = true;
1080 if (!map->format.format_write &&
1081 !(map->format.format_reg && map->format.format_val))
1084 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
1085 if (map->work_buf == NULL) {
1090 if (map->format.format_write) {
1091 map->defer_caching = false;
1092 map->reg_write = _regmap_bus_formatted_write;
1093 } else if (map->format.format_val) {
1094 map->defer_caching = true;
1095 map->reg_write = _regmap_bus_raw_write;
1098 skip_format_initialization:
1100 map->range_tree = RB_ROOT;
1101 for (i = 0; i < config->num_ranges; i++) {
1102 const struct regmap_range_cfg *range_cfg = &config->ranges[i];
1103 struct regmap_range_node *new;
1106 if (range_cfg->range_max < range_cfg->range_min) {
1107 dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
1108 range_cfg->range_max, range_cfg->range_min);
1112 if (range_cfg->range_max > map->max_register) {
1113 dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
1114 range_cfg->range_max, map->max_register);
1118 if (range_cfg->selector_reg > map->max_register) {
1120 "Invalid range %d: selector out of map\n", i);
1124 if (range_cfg->window_len == 0) {
1125 dev_err(map->dev, "Invalid range %d: window_len 0\n",
1130 /* Make sure, that this register range has no selector
1131 or data window within its boundary */
1132 for (j = 0; j < config->num_ranges; j++) {
1133 unsigned sel_reg = config->ranges[j].selector_reg;
1134 unsigned win_min = config->ranges[j].window_start;
1135 unsigned win_max = win_min +
1136 config->ranges[j].window_len - 1;
1138 /* Allow data window inside its own virtual range */
1142 if (range_cfg->range_min <= sel_reg &&
1143 sel_reg <= range_cfg->range_max) {
1145 "Range %d: selector for %d in window\n",
1150 if (!(win_max < range_cfg->range_min ||
1151 win_min > range_cfg->range_max)) {
1153 "Range %d: window for %d in window\n",
1159 new = kzalloc(sizeof(*new), GFP_KERNEL);
1166 new->name = range_cfg->name;
1167 new->range_min = range_cfg->range_min;
1168 new->range_max = range_cfg->range_max;
1169 new->selector_reg = range_cfg->selector_reg;
1170 new->selector_mask = range_cfg->selector_mask;
1171 new->selector_shift = range_cfg->selector_shift;
1172 new->window_start = range_cfg->window_start;
1173 new->window_len = range_cfg->window_len;
1175 if (!_regmap_range_add(map, new)) {
1176 dev_err(map->dev, "Failed to add range %d\n", i);
1181 if (map->selector_work_buf == NULL) {
1182 map->selector_work_buf =
1183 kzalloc(map->format.buf_size, GFP_KERNEL);
1184 if (map->selector_work_buf == NULL) {
1191 ret = regcache_init(map, config);
1196 ret = regmap_attach_dev(dev, map, config);
1200 regmap_debugfs_init(map);
1208 regmap_range_exit(map);
1209 kfree(map->work_buf);
1212 hwspin_lock_free(map->hwlock);
1214 kfree_const(map->name);
1218 return ERR_PTR(ret);
1220 EXPORT_SYMBOL_GPL(__regmap_init);
1222 static void devm_regmap_release(struct device *dev, void *res)
1224 regmap_exit(*(struct regmap **)res);
1227 struct regmap *__devm_regmap_init(struct device *dev,
1228 const struct regmap_bus *bus,
1230 const struct regmap_config *config,
1231 struct lock_class_key *lock_key,
1232 const char *lock_name)
1234 struct regmap **ptr, *regmap;
1236 ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
1238 return ERR_PTR(-ENOMEM);
1240 regmap = __regmap_init(dev, bus, bus_context, config,
1241 lock_key, lock_name);
1242 if (!IS_ERR(regmap)) {
1244 devres_add(dev, ptr);
1251 EXPORT_SYMBOL_GPL(__devm_regmap_init);
1253 static void regmap_field_init(struct regmap_field *rm_field,
1254 struct regmap *regmap, struct reg_field reg_field)
1256 rm_field->regmap = regmap;
1257 rm_field->reg = reg_field.reg;
1258 rm_field->shift = reg_field.lsb;
1259 rm_field->mask = GENMASK(reg_field.msb, reg_field.lsb);
1260 rm_field->id_size = reg_field.id_size;
1261 rm_field->id_offset = reg_field.id_offset;
1265 * devm_regmap_field_alloc() - Allocate and initialise a register field.
1267 * @dev: Device that will be interacted with
1268 * @regmap: regmap bank in which this register field is located.
1269 * @reg_field: Register field with in the bank.
1271 * The return value will be an ERR_PTR() on error or a valid pointer
1272 * to a struct regmap_field. The regmap_field will be automatically freed
1273 * by the device management code.
1275 struct regmap_field *devm_regmap_field_alloc(struct device *dev,
1276 struct regmap *regmap, struct reg_field reg_field)
1278 struct regmap_field *rm_field = devm_kzalloc(dev,
1279 sizeof(*rm_field), GFP_KERNEL);
1281 return ERR_PTR(-ENOMEM);
1283 regmap_field_init(rm_field, regmap, reg_field);
1288 EXPORT_SYMBOL_GPL(devm_regmap_field_alloc);
1292 * regmap_field_bulk_alloc() - Allocate and initialise a bulk register field.
1294 * @regmap: regmap bank in which this register field is located.
1295 * @rm_field: regmap register fields within the bank.
1296 * @reg_field: Register fields within the bank.
1297 * @num_fields: Number of register fields.
1299 * The return value will be an -ENOMEM on error or zero for success.
1300 * Newly allocated regmap_fields should be freed by calling
1301 * regmap_field_bulk_free()
1303 int regmap_field_bulk_alloc(struct regmap *regmap,
1304 struct regmap_field **rm_field,
1305 struct reg_field *reg_field,
1308 struct regmap_field *rf;
1311 rf = kcalloc(num_fields, sizeof(*rf), GFP_KERNEL);
1315 for (i = 0; i < num_fields; i++) {
1316 regmap_field_init(&rf[i], regmap, reg_field[i]);
1317 rm_field[i] = &rf[i];
1322 EXPORT_SYMBOL_GPL(regmap_field_bulk_alloc);
1325 * devm_regmap_field_bulk_alloc() - Allocate and initialise a bulk register
1328 * @dev: Device that will be interacted with
1329 * @regmap: regmap bank in which this register field is located.
1330 * @rm_field: regmap register fields within the bank.
1331 * @reg_field: Register fields within the bank.
1332 * @num_fields: Number of register fields.
1334 * The return value will be an -ENOMEM on error or zero for success.
1335 * Newly allocated regmap_fields will be automatically freed by the
1336 * device management code.
1338 int devm_regmap_field_bulk_alloc(struct device *dev,
1339 struct regmap *regmap,
1340 struct regmap_field **rm_field,
1341 struct reg_field *reg_field,
1344 struct regmap_field *rf;
1347 rf = devm_kcalloc(dev, num_fields, sizeof(*rf), GFP_KERNEL);
1351 for (i = 0; i < num_fields; i++) {
1352 regmap_field_init(&rf[i], regmap, reg_field[i]);
1353 rm_field[i] = &rf[i];
1358 EXPORT_SYMBOL_GPL(devm_regmap_field_bulk_alloc);
1361 * regmap_field_bulk_free() - Free register field allocated using
1362 * regmap_field_bulk_alloc.
1364 * @field: regmap fields which should be freed.
1366 void regmap_field_bulk_free(struct regmap_field *field)
1370 EXPORT_SYMBOL_GPL(regmap_field_bulk_free);
1373 * devm_regmap_field_bulk_free() - Free a bulk register field allocated using
1374 * devm_regmap_field_bulk_alloc.
1376 * @dev: Device that will be interacted with
1377 * @field: regmap field which should be freed.
1379 * Free register field allocated using devm_regmap_field_bulk_alloc(). Usually
1380 * drivers need not call this function, as the memory allocated via devm
1381 * will be freed as per device-driver life-cycle.
1383 void devm_regmap_field_bulk_free(struct device *dev,
1384 struct regmap_field *field)
1386 devm_kfree(dev, field);
1388 EXPORT_SYMBOL_GPL(devm_regmap_field_bulk_free);
1391 * devm_regmap_field_free() - Free a register field allocated using
1392 * devm_regmap_field_alloc.
1394 * @dev: Device that will be interacted with
1395 * @field: regmap field which should be freed.
1397 * Free register field allocated using devm_regmap_field_alloc(). Usually
1398 * drivers need not call this function, as the memory allocated via devm
1399 * will be freed as per device-driver life-cyle.
1401 void devm_regmap_field_free(struct device *dev,
1402 struct regmap_field *field)
1404 devm_kfree(dev, field);
1406 EXPORT_SYMBOL_GPL(devm_regmap_field_free);
1409 * regmap_field_alloc() - Allocate and initialise a register field.
1411 * @regmap: regmap bank in which this register field is located.
1412 * @reg_field: Register field with in the bank.
1414 * The return value will be an ERR_PTR() on error or a valid pointer
1415 * to a struct regmap_field. The regmap_field should be freed by the
1416 * user once its finished working with it using regmap_field_free().
1418 struct regmap_field *regmap_field_alloc(struct regmap *regmap,
1419 struct reg_field reg_field)
1421 struct regmap_field *rm_field = kzalloc(sizeof(*rm_field), GFP_KERNEL);
1424 return ERR_PTR(-ENOMEM);
1426 regmap_field_init(rm_field, regmap, reg_field);
1430 EXPORT_SYMBOL_GPL(regmap_field_alloc);
1433 * regmap_field_free() - Free register field allocated using
1434 * regmap_field_alloc.
1436 * @field: regmap field which should be freed.
1438 void regmap_field_free(struct regmap_field *field)
1442 EXPORT_SYMBOL_GPL(regmap_field_free);
1445 * regmap_reinit_cache() - Reinitialise the current register cache
1447 * @map: Register map to operate on.
1448 * @config: New configuration. Only the cache data will be used.
1450 * Discard any existing register cache for the map and initialize a
1451 * new cache. This can be used to restore the cache to defaults or to
1452 * update the cache configuration to reflect runtime discovery of the
1455 * No explicit locking is done here, the user needs to ensure that
1456 * this function will not race with other calls to regmap.
1458 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
1463 regmap_debugfs_exit(map);
1465 map->max_register = config->max_register;
1466 map->writeable_reg = config->writeable_reg;
1467 map->readable_reg = config->readable_reg;
1468 map->volatile_reg = config->volatile_reg;
1469 map->precious_reg = config->precious_reg;
1470 map->writeable_noinc_reg = config->writeable_noinc_reg;
1471 map->readable_noinc_reg = config->readable_noinc_reg;
1472 map->cache_type = config->cache_type;
1474 ret = regmap_set_name(map, config);
1478 regmap_debugfs_init(map);
1480 map->cache_bypass = false;
1481 map->cache_only = false;
1483 return regcache_init(map, config);
1485 EXPORT_SYMBOL_GPL(regmap_reinit_cache);
1488 * regmap_exit() - Free a previously allocated register map
1490 * @map: Register map to operate on.
1492 void regmap_exit(struct regmap *map)
1494 struct regmap_async *async;
1497 regmap_debugfs_exit(map);
1498 regmap_range_exit(map);
1499 if (map->bus && map->bus->free_context)
1500 map->bus->free_context(map->bus_context);
1501 kfree(map->work_buf);
1502 while (!list_empty(&map->async_free)) {
1503 async = list_first_entry_or_null(&map->async_free,
1504 struct regmap_async,
1506 list_del(&async->list);
1507 kfree(async->work_buf);
1511 hwspin_lock_free(map->hwlock);
1512 if (map->lock == regmap_lock_mutex)
1513 mutex_destroy(&map->mutex);
1514 kfree_const(map->name);
1518 EXPORT_SYMBOL_GPL(regmap_exit);
1520 static int dev_get_regmap_match(struct device *dev, void *res, void *data)
1522 struct regmap **r = res;
1528 /* If the user didn't specify a name match any */
1530 return (*r)->name && !strcmp((*r)->name, data);
1536 * dev_get_regmap() - Obtain the regmap (if any) for a device
1538 * @dev: Device to retrieve the map for
1539 * @name: Optional name for the register map, usually NULL.
1541 * Returns the regmap for the device if one is present, or NULL. If
1542 * name is specified then it must match the name specified when
1543 * registering the device, if it is NULL then the first regmap found
1544 * will be used. Devices with multiple register maps are very rare,
1545 * generic code should normally not need to specify a name.
1547 struct regmap *dev_get_regmap(struct device *dev, const char *name)
1549 struct regmap **r = devres_find(dev, dev_get_regmap_release,
1550 dev_get_regmap_match, (void *)name);
1556 EXPORT_SYMBOL_GPL(dev_get_regmap);
1559 * regmap_get_device() - Obtain the device from a regmap
1561 * @map: Register map to operate on.
1563 * Returns the underlying device that the regmap has been created for.
1565 struct device *regmap_get_device(struct regmap *map)
1569 EXPORT_SYMBOL_GPL(regmap_get_device);
1571 static int _regmap_select_page(struct regmap *map, unsigned int *reg,
1572 struct regmap_range_node *range,
1573 unsigned int val_num)
1575 void *orig_work_buf;
1576 unsigned int win_offset;
1577 unsigned int win_page;
1581 win_offset = (*reg - range->range_min) % range->window_len;
1582 win_page = (*reg - range->range_min) / range->window_len;
1585 /* Bulk write shouldn't cross range boundary */
1586 if (*reg + val_num - 1 > range->range_max)
1589 /* ... or single page boundary */
1590 if (val_num > range->window_len - win_offset)
1594 /* It is possible to have selector register inside data window.
1595 In that case, selector register is located on every page and
1596 it needs no page switching, when accessed alone. */
1598 range->window_start + win_offset != range->selector_reg) {
1599 /* Use separate work_buf during page switching */
1600 orig_work_buf = map->work_buf;
1601 map->work_buf = map->selector_work_buf;
1603 ret = _regmap_update_bits(map, range->selector_reg,
1604 range->selector_mask,
1605 win_page << range->selector_shift,
1608 map->work_buf = orig_work_buf;
1614 *reg = range->window_start + win_offset;
1619 static void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
1625 if (!mask || !map->work_buf)
1628 buf = map->work_buf;
1630 for (i = 0; i < max_bytes; i++)
1631 buf[i] |= (mask >> (8 * i)) & 0xff;
1634 static int _regmap_raw_write_impl(struct regmap *map, unsigned int reg,
1635 const void *val, size_t val_len, bool noinc)
1637 struct regmap_range_node *range;
1638 unsigned long flags;
1639 void *work_val = map->work_buf + map->format.reg_bytes +
1640 map->format.pad_bytes;
1642 int ret = -ENOTSUPP;
1646 /* Check for unwritable or noinc registers in range
1649 if (!regmap_writeable_noinc(map, reg)) {
1650 for (i = 0; i < val_len / map->format.val_bytes; i++) {
1651 unsigned int element =
1652 reg + regmap_get_offset(map, i);
1653 if (!regmap_writeable(map, element) ||
1654 regmap_writeable_noinc(map, element))
1659 if (!map->cache_bypass && map->format.parse_val) {
1660 unsigned int ival, offset;
1661 int val_bytes = map->format.val_bytes;
1663 /* Cache the last written value for noinc writes */
1664 i = noinc ? val_len - val_bytes : 0;
1665 for (; i < val_len; i += val_bytes) {
1666 ival = map->format.parse_val(val + i);
1667 offset = noinc ? 0 : regmap_get_offset(map, i / val_bytes);
1668 ret = regcache_write(map, reg + offset, ival);
1671 "Error in caching of register: %x ret: %d\n",
1676 if (map->cache_only) {
1677 map->cache_dirty = true;
1682 range = _regmap_range_lookup(map, reg);
1684 int val_num = val_len / map->format.val_bytes;
1685 int win_offset = (reg - range->range_min) % range->window_len;
1686 int win_residue = range->window_len - win_offset;
1688 /* If the write goes beyond the end of the window split it */
1689 while (val_num > win_residue) {
1690 dev_dbg(map->dev, "Writing window %d/%zu\n",
1691 win_residue, val_len / map->format.val_bytes);
1692 ret = _regmap_raw_write_impl(map, reg, val,
1694 map->format.val_bytes, noinc);
1699 val_num -= win_residue;
1700 val += win_residue * map->format.val_bytes;
1701 val_len -= win_residue * map->format.val_bytes;
1703 win_offset = (reg - range->range_min) %
1705 win_residue = range->window_len - win_offset;
1708 ret = _regmap_select_page(map, ®, range, noinc ? 1 : val_num);
1713 map->format.format_reg(map->work_buf, reg, map->reg_shift);
1714 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
1715 map->write_flag_mask);
1718 * Essentially all I/O mechanisms will be faster with a single
1719 * buffer to write. Since register syncs often generate raw
1720 * writes of single registers optimise that case.
1722 if (val != work_val && val_len == map->format.val_bytes) {
1723 memcpy(work_val, val, map->format.val_bytes);
1727 if (map->async && map->bus && map->bus->async_write) {
1728 struct regmap_async *async;
1730 trace_regmap_async_write_start(map, reg, val_len);
1732 spin_lock_irqsave(&map->async_lock, flags);
1733 async = list_first_entry_or_null(&map->async_free,
1734 struct regmap_async,
1737 list_del(&async->list);
1738 spin_unlock_irqrestore(&map->async_lock, flags);
1741 async = map->bus->async_alloc();
1745 async->work_buf = kzalloc(map->format.buf_size,
1746 GFP_KERNEL | GFP_DMA);
1747 if (!async->work_buf) {
1755 /* If the caller supplied the value we can use it safely. */
1756 memcpy(async->work_buf, map->work_buf, map->format.pad_bytes +
1757 map->format.reg_bytes + map->format.val_bytes);
1759 spin_lock_irqsave(&map->async_lock, flags);
1760 list_add_tail(&async->list, &map->async_list);
1761 spin_unlock_irqrestore(&map->async_lock, flags);
1763 if (val != work_val)
1764 ret = map->bus->async_write(map->bus_context,
1766 map->format.reg_bytes +
1767 map->format.pad_bytes,
1768 val, val_len, async);
1770 ret = map->bus->async_write(map->bus_context,
1772 map->format.reg_bytes +
1773 map->format.pad_bytes +
1774 val_len, NULL, 0, async);
1777 dev_err(map->dev, "Failed to schedule write: %d\n",
1780 spin_lock_irqsave(&map->async_lock, flags);
1781 list_move(&async->list, &map->async_free);
1782 spin_unlock_irqrestore(&map->async_lock, flags);
1788 trace_regmap_hw_write_start(map, reg, val_len / map->format.val_bytes);
1790 /* If we're doing a single register write we can probably just
1791 * send the work_buf directly, otherwise try to do a gather
1794 if (val == work_val)
1795 ret = map->write(map->bus_context, map->work_buf,
1796 map->format.reg_bytes +
1797 map->format.pad_bytes +
1799 else if (map->bus && map->bus->gather_write)
1800 ret = map->bus->gather_write(map->bus_context, map->work_buf,
1801 map->format.reg_bytes +
1802 map->format.pad_bytes,
1807 /* If that didn't work fall back on linearising by hand. */
1808 if (ret == -ENOTSUPP) {
1809 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
1810 buf = kzalloc(len, GFP_KERNEL);
1814 memcpy(buf, map->work_buf, map->format.reg_bytes);
1815 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
1817 ret = map->write(map->bus_context, buf, len);
1820 } else if (ret != 0 && !map->cache_bypass && map->format.parse_val) {
1821 /* regcache_drop_region() takes lock that we already have,
1822 * thus call map->cache_ops->drop() directly
1824 if (map->cache_ops && map->cache_ops->drop)
1825 map->cache_ops->drop(map, reg, reg + 1);
1828 trace_regmap_hw_write_done(map, reg, val_len / map->format.val_bytes);
1834 * regmap_can_raw_write - Test if regmap_raw_write() is supported
1836 * @map: Map to check.
1838 bool regmap_can_raw_write(struct regmap *map)
1840 return map->bus && map->bus->write && map->format.format_val &&
1841 map->format.format_reg;
1843 EXPORT_SYMBOL_GPL(regmap_can_raw_write);
1846 * regmap_get_raw_read_max - Get the maximum size we can read
1848 * @map: Map to check.
1850 size_t regmap_get_raw_read_max(struct regmap *map)
1852 return map->max_raw_read;
1854 EXPORT_SYMBOL_GPL(regmap_get_raw_read_max);
1857 * regmap_get_raw_write_max - Get the maximum size we can read
1859 * @map: Map to check.
1861 size_t regmap_get_raw_write_max(struct regmap *map)
1863 return map->max_raw_write;
1865 EXPORT_SYMBOL_GPL(regmap_get_raw_write_max);
1867 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
1871 struct regmap_range_node *range;
1872 struct regmap *map = context;
1874 WARN_ON(!map->format.format_write);
1876 range = _regmap_range_lookup(map, reg);
1878 ret = _regmap_select_page(map, ®, range, 1);
1883 map->format.format_write(map, reg, val);
1885 trace_regmap_hw_write_start(map, reg, 1);
1887 ret = map->write(map->bus_context, map->work_buf, map->format.buf_size);
1889 trace_regmap_hw_write_done(map, reg, 1);
1894 static int _regmap_bus_reg_write(void *context, unsigned int reg,
1897 struct regmap *map = context;
1899 return map->bus->reg_write(map->bus_context, reg, val);
1902 static int _regmap_bus_raw_write(void *context, unsigned int reg,
1905 struct regmap *map = context;
1907 WARN_ON(!map->format.format_val);
1909 map->format.format_val(map->work_buf + map->format.reg_bytes
1910 + map->format.pad_bytes, val, 0);
1911 return _regmap_raw_write_impl(map, reg,
1913 map->format.reg_bytes +
1914 map->format.pad_bytes,
1915 map->format.val_bytes,
1919 static inline void *_regmap_map_get_context(struct regmap *map)
1921 return (map->bus || (!map->bus && map->read)) ? map : map->bus_context;
1924 int _regmap_write(struct regmap *map, unsigned int reg,
1928 void *context = _regmap_map_get_context(map);
1930 if (!regmap_writeable(map, reg))
1933 if (!map->cache_bypass && !map->defer_caching) {
1934 ret = regcache_write(map, reg, val);
1937 if (map->cache_only) {
1938 map->cache_dirty = true;
1943 if (regmap_should_log(map))
1944 dev_info(map->dev, "%x <= %x\n", reg, val);
1946 trace_regmap_reg_write(map, reg, val);
1948 return map->reg_write(context, reg, val);
1952 * regmap_write() - Write a value to a single register
1954 * @map: Register map to write to
1955 * @reg: Register to write to
1956 * @val: Value to be written
1958 * A value of zero will be returned on success, a negative errno will
1959 * be returned in error cases.
1961 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1965 if (!IS_ALIGNED(reg, map->reg_stride))
1968 map->lock(map->lock_arg);
1970 ret = _regmap_write(map, reg, val);
1972 map->unlock(map->lock_arg);
1976 EXPORT_SYMBOL_GPL(regmap_write);
1979 * regmap_write_async() - Write a value to a single register asynchronously
1981 * @map: Register map to write to
1982 * @reg: Register to write to
1983 * @val: Value to be written
1985 * A value of zero will be returned on success, a negative errno will
1986 * be returned in error cases.
1988 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val)
1992 if (!IS_ALIGNED(reg, map->reg_stride))
1995 map->lock(map->lock_arg);
1999 ret = _regmap_write(map, reg, val);
2003 map->unlock(map->lock_arg);
2007 EXPORT_SYMBOL_GPL(regmap_write_async);
2009 int _regmap_raw_write(struct regmap *map, unsigned int reg,
2010 const void *val, size_t val_len, bool noinc)
2012 size_t val_bytes = map->format.val_bytes;
2013 size_t val_count = val_len / val_bytes;
2014 size_t chunk_count, chunk_bytes;
2015 size_t chunk_regs = val_count;
2021 if (map->use_single_write)
2023 else if (map->max_raw_write && val_len > map->max_raw_write)
2024 chunk_regs = map->max_raw_write / val_bytes;
2026 chunk_count = val_count / chunk_regs;
2027 chunk_bytes = chunk_regs * val_bytes;
2029 /* Write as many bytes as possible with chunk_size */
2030 for (i = 0; i < chunk_count; i++) {
2031 ret = _regmap_raw_write_impl(map, reg, val, chunk_bytes, noinc);
2035 reg += regmap_get_offset(map, chunk_regs);
2037 val_len -= chunk_bytes;
2040 /* Write remaining bytes */
2042 ret = _regmap_raw_write_impl(map, reg, val, val_len, noinc);
2048 * regmap_raw_write() - Write raw values to one or more registers
2050 * @map: Register map to write to
2051 * @reg: Initial register to write to
2052 * @val: Block of data to be written, laid out for direct transmission to the
2054 * @val_len: Length of data pointed to by val.
2056 * This function is intended to be used for things like firmware
2057 * download where a large block of data needs to be transferred to the
2058 * device. No formatting will be done on the data provided.
2060 * A value of zero will be returned on success, a negative errno will
2061 * be returned in error cases.
2063 int regmap_raw_write(struct regmap *map, unsigned int reg,
2064 const void *val, size_t val_len)
2068 if (!regmap_can_raw_write(map))
2070 if (val_len % map->format.val_bytes)
2073 map->lock(map->lock_arg);
2075 ret = _regmap_raw_write(map, reg, val, val_len, false);
2077 map->unlock(map->lock_arg);
2081 EXPORT_SYMBOL_GPL(regmap_raw_write);
2084 * regmap_noinc_write(): Write data from a register without incrementing the
2087 * @map: Register map to write to
2088 * @reg: Register to write to
2089 * @val: Pointer to data buffer
2090 * @val_len: Length of output buffer in bytes.
2092 * The regmap API usually assumes that bulk bus write operations will write a
2093 * range of registers. Some devices have certain registers for which a write
2094 * operation can write to an internal FIFO.
2096 * The target register must be volatile but registers after it can be
2097 * completely unrelated cacheable registers.
2099 * This will attempt multiple writes as required to write val_len bytes.
2101 * A value of zero will be returned on success, a negative errno will be
2102 * returned in error cases.
2104 int regmap_noinc_write(struct regmap *map, unsigned int reg,
2105 const void *val, size_t val_len)
2112 if (!map->bus->write)
2114 if (val_len % map->format.val_bytes)
2116 if (!IS_ALIGNED(reg, map->reg_stride))
2121 map->lock(map->lock_arg);
2123 if (!regmap_volatile(map, reg) || !regmap_writeable_noinc(map, reg)) {
2129 if (map->max_raw_write && map->max_raw_write < val_len)
2130 write_len = map->max_raw_write;
2132 write_len = val_len;
2133 ret = _regmap_raw_write(map, reg, val, write_len, true);
2136 val = ((u8 *)val) + write_len;
2137 val_len -= write_len;
2141 map->unlock(map->lock_arg);
2144 EXPORT_SYMBOL_GPL(regmap_noinc_write);
2147 * regmap_field_update_bits_base() - Perform a read/modify/write cycle a
2150 * @field: Register field to write to
2151 * @mask: Bitmask to change
2152 * @val: Value to be written
2153 * @change: Boolean indicating if a write was done
2154 * @async: Boolean indicating asynchronously
2155 * @force: Boolean indicating use force update
2157 * Perform a read/modify/write cycle on the register field with change,
2158 * async, force option.
2160 * A value of zero will be returned on success, a negative errno will
2161 * be returned in error cases.
2163 int regmap_field_update_bits_base(struct regmap_field *field,
2164 unsigned int mask, unsigned int val,
2165 bool *change, bool async, bool force)
2167 mask = (mask << field->shift) & field->mask;
2169 return regmap_update_bits_base(field->regmap, field->reg,
2170 mask, val << field->shift,
2171 change, async, force);
2173 EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);
2176 * regmap_fields_update_bits_base() - Perform a read/modify/write cycle a
2177 * register field with port ID
2179 * @field: Register field to write to
2181 * @mask: Bitmask to change
2182 * @val: Value to be written
2183 * @change: Boolean indicating if a write was done
2184 * @async: Boolean indicating asynchronously
2185 * @force: Boolean indicating use force update
2187 * A value of zero will be returned on success, a negative errno will
2188 * be returned in error cases.
2190 int regmap_fields_update_bits_base(struct regmap_field *field, unsigned int id,
2191 unsigned int mask, unsigned int val,
2192 bool *change, bool async, bool force)
2194 if (id >= field->id_size)
2197 mask = (mask << field->shift) & field->mask;
2199 return regmap_update_bits_base(field->regmap,
2200 field->reg + (field->id_offset * id),
2201 mask, val << field->shift,
2202 change, async, force);
2204 EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);
2207 * regmap_bulk_write() - Write multiple registers to the device
2209 * @map: Register map to write to
2210 * @reg: First register to be write from
2211 * @val: Block of data to be written, in native register size for device
2212 * @val_count: Number of registers to write
2214 * This function is intended to be used for writing a large block of
2215 * data to the device either in single transfer or multiple transfer.
2217 * A value of zero will be returned on success, a negative errno will
2218 * be returned in error cases.
2220 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
2224 size_t val_bytes = map->format.val_bytes;
2226 if (!IS_ALIGNED(reg, map->reg_stride))
2230 * Some devices don't support bulk write, for them we have a series of
2231 * single write operations.
2233 if (!map->bus || !map->format.parse_inplace) {
2234 map->lock(map->lock_arg);
2235 for (i = 0; i < val_count; i++) {
2238 switch (val_bytes) {
2240 ival = *(u8 *)(val + (i * val_bytes));
2243 ival = *(u16 *)(val + (i * val_bytes));
2246 ival = *(u32 *)(val + (i * val_bytes));
2250 ival = *(u64 *)(val + (i * val_bytes));
2258 ret = _regmap_write(map,
2259 reg + regmap_get_offset(map, i),
2265 map->unlock(map->lock_arg);
2269 wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
2273 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2274 map->format.parse_inplace(wval + i);
2276 ret = regmap_raw_write(map, reg, wval, val_bytes * val_count);
2282 EXPORT_SYMBOL_GPL(regmap_bulk_write);
2285 * _regmap_raw_multi_reg_write()
2287 * the (register,newvalue) pairs in regs have not been formatted, but
2288 * they are all in the same page and have been changed to being page
2289 * relative. The page register has been written if that was necessary.
2291 static int _regmap_raw_multi_reg_write(struct regmap *map,
2292 const struct reg_sequence *regs,
2299 size_t val_bytes = map->format.val_bytes;
2300 size_t reg_bytes = map->format.reg_bytes;
2301 size_t pad_bytes = map->format.pad_bytes;
2302 size_t pair_size = reg_bytes + pad_bytes + val_bytes;
2303 size_t len = pair_size * num_regs;
2308 buf = kzalloc(len, GFP_KERNEL);
2312 /* We have to linearise by hand. */
2316 for (i = 0; i < num_regs; i++) {
2317 unsigned int reg = regs[i].reg;
2318 unsigned int val = regs[i].def;
2319 trace_regmap_hw_write_start(map, reg, 1);
2320 map->format.format_reg(u8, reg, map->reg_shift);
2321 u8 += reg_bytes + pad_bytes;
2322 map->format.format_val(u8, val, 0);
2326 *u8 |= map->write_flag_mask;
2328 ret = map->write(map->bus_context, buf, len);
2332 for (i = 0; i < num_regs; i++) {
2333 int reg = regs[i].reg;
2334 trace_regmap_hw_write_done(map, reg, 1);
2339 static unsigned int _regmap_register_page(struct regmap *map,
2341 struct regmap_range_node *range)
2343 unsigned int win_page = (reg - range->range_min) / range->window_len;
2348 static int _regmap_range_multi_paged_reg_write(struct regmap *map,
2349 struct reg_sequence *regs,
2354 struct reg_sequence *base;
2355 unsigned int this_page = 0;
2356 unsigned int page_change = 0;
2358 * the set of registers are not neccessarily in order, but
2359 * since the order of write must be preserved this algorithm
2360 * chops the set each time the page changes. This also applies
2361 * if there is a delay required at any point in the sequence.
2364 for (i = 0, n = 0; i < num_regs; i++, n++) {
2365 unsigned int reg = regs[i].reg;
2366 struct regmap_range_node *range;
2368 range = _regmap_range_lookup(map, reg);
2370 unsigned int win_page = _regmap_register_page(map, reg,
2374 this_page = win_page;
2375 if (win_page != this_page) {
2376 this_page = win_page;
2381 /* If we have both a page change and a delay make sure to
2382 * write the regs and apply the delay before we change the
2386 if (page_change || regs[i].delay_us) {
2388 /* For situations where the first write requires
2389 * a delay we need to make sure we don't call
2390 * raw_multi_reg_write with n=0
2391 * This can't occur with page breaks as we
2392 * never write on the first iteration
2394 if (regs[i].delay_us && i == 0)
2397 ret = _regmap_raw_multi_reg_write(map, base, n);
2401 if (regs[i].delay_us) {
2403 fsleep(regs[i].delay_us);
2405 udelay(regs[i].delay_us);
2412 ret = _regmap_select_page(map,
2425 return _regmap_raw_multi_reg_write(map, base, n);
2429 static int _regmap_multi_reg_write(struct regmap *map,
2430 const struct reg_sequence *regs,
2436 if (!map->can_multi_write) {
2437 for (i = 0; i < num_regs; i++) {
2438 ret = _regmap_write(map, regs[i].reg, regs[i].def);
2442 if (regs[i].delay_us) {
2444 fsleep(regs[i].delay_us);
2446 udelay(regs[i].delay_us);
2452 if (!map->format.parse_inplace)
2455 if (map->writeable_reg)
2456 for (i = 0; i < num_regs; i++) {
2457 int reg = regs[i].reg;
2458 if (!map->writeable_reg(map->dev, reg))
2460 if (!IS_ALIGNED(reg, map->reg_stride))
2464 if (!map->cache_bypass) {
2465 for (i = 0; i < num_regs; i++) {
2466 unsigned int val = regs[i].def;
2467 unsigned int reg = regs[i].reg;
2468 ret = regcache_write(map, reg, val);
2471 "Error in caching of register: %x ret: %d\n",
2476 if (map->cache_only) {
2477 map->cache_dirty = true;
2484 for (i = 0; i < num_regs; i++) {
2485 unsigned int reg = regs[i].reg;
2486 struct regmap_range_node *range;
2488 /* Coalesce all the writes between a page break or a delay
2491 range = _regmap_range_lookup(map, reg);
2492 if (range || regs[i].delay_us) {
2493 size_t len = sizeof(struct reg_sequence)*num_regs;
2494 struct reg_sequence *base = kmemdup(regs, len,
2498 ret = _regmap_range_multi_paged_reg_write(map, base,
2505 return _regmap_raw_multi_reg_write(map, regs, num_regs);
2509 * regmap_multi_reg_write() - Write multiple registers to the device
2511 * @map: Register map to write to
2512 * @regs: Array of structures containing register,value to be written
2513 * @num_regs: Number of registers to write
2515 * Write multiple registers to the device where the set of register, value
2516 * pairs are supplied in any order, possibly not all in a single range.
2518 * The 'normal' block write mode will send ultimately send data on the
2519 * target bus as R,V1,V2,V3,..,Vn where successively higher registers are
2520 * addressed. However, this alternative block multi write mode will send
2521 * the data as R1,V1,R2,V2,..,Rn,Vn on the target bus. The target device
2522 * must of course support the mode.
2524 * A value of zero will be returned on success, a negative errno will be
2525 * returned in error cases.
2527 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
2532 map->lock(map->lock_arg);
2534 ret = _regmap_multi_reg_write(map, regs, num_regs);
2536 map->unlock(map->lock_arg);
2540 EXPORT_SYMBOL_GPL(regmap_multi_reg_write);
2543 * regmap_multi_reg_write_bypassed() - Write multiple registers to the
2544 * device but not the cache
2546 * @map: Register map to write to
2547 * @regs: Array of structures containing register,value to be written
2548 * @num_regs: Number of registers to write
2550 * Write multiple registers to the device but not the cache where the set
2551 * of register are supplied in any order.
2553 * This function is intended to be used for writing a large block of data
2554 * atomically to the device in single transfer for those I2C client devices
2555 * that implement this alternative block write mode.
2557 * A value of zero will be returned on success, a negative errno will
2558 * be returned in error cases.
2560 int regmap_multi_reg_write_bypassed(struct regmap *map,
2561 const struct reg_sequence *regs,
2567 map->lock(map->lock_arg);
2569 bypass = map->cache_bypass;
2570 map->cache_bypass = true;
2572 ret = _regmap_multi_reg_write(map, regs, num_regs);
2574 map->cache_bypass = bypass;
2576 map->unlock(map->lock_arg);
2580 EXPORT_SYMBOL_GPL(regmap_multi_reg_write_bypassed);
2583 * regmap_raw_write_async() - Write raw values to one or more registers
2586 * @map: Register map to write to
2587 * @reg: Initial register to write to
2588 * @val: Block of data to be written, laid out for direct transmission to the
2589 * device. Must be valid until regmap_async_complete() is called.
2590 * @val_len: Length of data pointed to by val.
2592 * This function is intended to be used for things like firmware
2593 * download where a large block of data needs to be transferred to the
2594 * device. No formatting will be done on the data provided.
2596 * If supported by the underlying bus the write will be scheduled
2597 * asynchronously, helping maximise I/O speed on higher speed buses
2598 * like SPI. regmap_async_complete() can be called to ensure that all
2599 * asynchrnous writes have been completed.
2601 * A value of zero will be returned on success, a negative errno will
2602 * be returned in error cases.
2604 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
2605 const void *val, size_t val_len)
2609 if (val_len % map->format.val_bytes)
2611 if (!IS_ALIGNED(reg, map->reg_stride))
2614 map->lock(map->lock_arg);
2618 ret = _regmap_raw_write(map, reg, val, val_len, false);
2622 map->unlock(map->lock_arg);
2626 EXPORT_SYMBOL_GPL(regmap_raw_write_async);
2628 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2629 unsigned int val_len, bool noinc)
2631 struct regmap_range_node *range;
2637 range = _regmap_range_lookup(map, reg);
2639 ret = _regmap_select_page(map, ®, range,
2640 noinc ? 1 : val_len / map->format.val_bytes);
2645 map->format.format_reg(map->work_buf, reg, map->reg_shift);
2646 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
2647 map->read_flag_mask);
2648 trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
2650 ret = map->read(map->bus_context, map->work_buf,
2651 map->format.reg_bytes + map->format.pad_bytes,
2654 trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
2659 static int _regmap_bus_reg_read(void *context, unsigned int reg,
2662 struct regmap *map = context;
2664 return map->bus->reg_read(map->bus_context, reg, val);
2667 static int _regmap_bus_read(void *context, unsigned int reg,
2671 struct regmap *map = context;
2672 void *work_val = map->work_buf + map->format.reg_bytes +
2673 map->format.pad_bytes;
2675 if (!map->format.parse_val)
2678 ret = _regmap_raw_read(map, reg, work_val, map->format.val_bytes, false);
2680 *val = map->format.parse_val(work_val);
2685 static int _regmap_read(struct regmap *map, unsigned int reg,
2689 void *context = _regmap_map_get_context(map);
2691 if (!map->cache_bypass) {
2692 ret = regcache_read(map, reg, val);
2697 if (map->cache_only)
2700 if (!regmap_readable(map, reg))
2703 ret = map->reg_read(context, reg, val);
2705 if (regmap_should_log(map))
2706 dev_info(map->dev, "%x => %x\n", reg, *val);
2708 trace_regmap_reg_read(map, reg, *val);
2710 if (!map->cache_bypass)
2711 regcache_write(map, reg, *val);
2718 * regmap_read() - Read a value from a single register
2720 * @map: Register map to read from
2721 * @reg: Register to be read from
2722 * @val: Pointer to store read value
2724 * A value of zero will be returned on success, a negative errno will
2725 * be returned in error cases.
2727 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
2731 if (!IS_ALIGNED(reg, map->reg_stride))
2734 map->lock(map->lock_arg);
2736 ret = _regmap_read(map, reg, val);
2738 map->unlock(map->lock_arg);
2742 EXPORT_SYMBOL_GPL(regmap_read);
2745 * regmap_raw_read() - Read raw data from the device
2747 * @map: Register map to read from
2748 * @reg: First register to be read from
2749 * @val: Pointer to store read value
2750 * @val_len: Size of data to read
2752 * A value of zero will be returned on success, a negative errno will
2753 * be returned in error cases.
2755 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2758 size_t val_bytes = map->format.val_bytes;
2759 size_t val_count = val_len / val_bytes;
2763 if (val_len % map->format.val_bytes)
2765 if (!IS_ALIGNED(reg, map->reg_stride))
2770 map->lock(map->lock_arg);
2772 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
2773 map->cache_type == REGCACHE_NONE) {
2774 size_t chunk_count, chunk_bytes;
2775 size_t chunk_regs = val_count;
2782 if (map->use_single_read)
2784 else if (map->max_raw_read && val_len > map->max_raw_read)
2785 chunk_regs = map->max_raw_read / val_bytes;
2787 chunk_count = val_count / chunk_regs;
2788 chunk_bytes = chunk_regs * val_bytes;
2790 /* Read bytes that fit into whole chunks */
2791 for (i = 0; i < chunk_count; i++) {
2792 ret = _regmap_raw_read(map, reg, val, chunk_bytes, false);
2796 reg += regmap_get_offset(map, chunk_regs);
2798 val_len -= chunk_bytes;
2801 /* Read remaining bytes */
2803 ret = _regmap_raw_read(map, reg, val, val_len, false);
2808 /* Otherwise go word by word for the cache; should be low
2809 * cost as we expect to hit the cache.
2811 for (i = 0; i < val_count; i++) {
2812 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2817 map->format.format_val(val + (i * val_bytes), v, 0);
2822 map->unlock(map->lock_arg);
2826 EXPORT_SYMBOL_GPL(regmap_raw_read);
2829 * regmap_noinc_read(): Read data from a register without incrementing the
2832 * @map: Register map to read from
2833 * @reg: Register to read from
2834 * @val: Pointer to data buffer
2835 * @val_len: Length of output buffer in bytes.
2837 * The regmap API usually assumes that bulk read operations will read a
2838 * range of registers. Some devices have certain registers for which a read
2839 * operation read will read from an internal FIFO.
2841 * The target register must be volatile but registers after it can be
2842 * completely unrelated cacheable registers.
2844 * This will attempt multiple reads as required to read val_len bytes.
2846 * A value of zero will be returned on success, a negative errno will be
2847 * returned in error cases.
2849 int regmap_noinc_read(struct regmap *map, unsigned int reg,
2850 void *val, size_t val_len)
2855 if (val_len % map->format.val_bytes)
2857 if (!IS_ALIGNED(reg, map->reg_stride))
2862 map->lock(map->lock_arg);
2864 if (!regmap_volatile(map, reg) || !regmap_readable_noinc(map, reg)) {
2870 if (map->max_raw_read && map->max_raw_read < val_len)
2871 read_len = map->max_raw_read;
2874 ret = _regmap_raw_read(map, reg, val, read_len, true);
2877 val = ((u8 *)val) + read_len;
2878 val_len -= read_len;
2882 map->unlock(map->lock_arg);
2885 EXPORT_SYMBOL_GPL(regmap_noinc_read);
2888 * regmap_field_read(): Read a value to a single register field
2890 * @field: Register field to read from
2891 * @val: Pointer to store read value
2893 * A value of zero will be returned on success, a negative errno will
2894 * be returned in error cases.
2896 int regmap_field_read(struct regmap_field *field, unsigned int *val)
2899 unsigned int reg_val;
2900 ret = regmap_read(field->regmap, field->reg, ®_val);
2904 reg_val &= field->mask;
2905 reg_val >>= field->shift;
2910 EXPORT_SYMBOL_GPL(regmap_field_read);
2913 * regmap_fields_read() - Read a value to a single register field with port ID
2915 * @field: Register field to read from
2917 * @val: Pointer to store read value
2919 * A value of zero will be returned on success, a negative errno will
2920 * be returned in error cases.
2922 int regmap_fields_read(struct regmap_field *field, unsigned int id,
2926 unsigned int reg_val;
2928 if (id >= field->id_size)
2931 ret = regmap_read(field->regmap,
2932 field->reg + (field->id_offset * id),
2937 reg_val &= field->mask;
2938 reg_val >>= field->shift;
2943 EXPORT_SYMBOL_GPL(regmap_fields_read);
2946 * regmap_bulk_read() - Read multiple registers from the device
2948 * @map: Register map to read from
2949 * @reg: First register to be read from
2950 * @val: Pointer to store read value, in native register size for device
2951 * @val_count: Number of registers to read
2953 * A value of zero will be returned on success, a negative errno will
2954 * be returned in error cases.
2956 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
2960 size_t val_bytes = map->format.val_bytes;
2961 bool vol = regmap_volatile_range(map, reg, val_count);
2963 if (!IS_ALIGNED(reg, map->reg_stride))
2968 if (map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
2969 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
2973 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2974 map->format.parse_inplace(val + i);
2983 map->lock(map->lock_arg);
2985 for (i = 0; i < val_count; i++) {
2988 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2993 switch (map->format.val_bytes) {
3015 map->unlock(map->lock_arg);
3020 EXPORT_SYMBOL_GPL(regmap_bulk_read);
3022 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
3023 unsigned int mask, unsigned int val,
3024 bool *change, bool force_write)
3027 unsigned int tmp, orig;
3032 if (regmap_volatile(map, reg) && map->reg_update_bits) {
3033 ret = map->reg_update_bits(map->bus_context, reg, mask, val);
3034 if (ret == 0 && change)
3037 ret = _regmap_read(map, reg, &orig);
3044 if (force_write || (tmp != orig)) {
3045 ret = _regmap_write(map, reg, tmp);
3046 if (ret == 0 && change)
3055 * regmap_update_bits_base() - Perform a read/modify/write cycle on a register
3057 * @map: Register map to update
3058 * @reg: Register to update
3059 * @mask: Bitmask to change
3060 * @val: New value for bitmask
3061 * @change: Boolean indicating if a write was done
3062 * @async: Boolean indicating asynchronously
3063 * @force: Boolean indicating use force update
3065 * Perform a read/modify/write cycle on a register map with change, async, force
3070 * With most buses the read must be done synchronously so this is most useful
3071 * for devices with a cache which do not need to interact with the hardware to
3072 * determine the current register value.
3074 * Returns zero for success, a negative number on error.
3076 int regmap_update_bits_base(struct regmap *map, unsigned int reg,
3077 unsigned int mask, unsigned int val,
3078 bool *change, bool async, bool force)
3082 map->lock(map->lock_arg);
3086 ret = _regmap_update_bits(map, reg, mask, val, change, force);
3090 map->unlock(map->lock_arg);
3094 EXPORT_SYMBOL_GPL(regmap_update_bits_base);
3097 * regmap_test_bits() - Check if all specified bits are set in a register.
3099 * @map: Register map to operate on
3100 * @reg: Register to read from
3101 * @bits: Bits to test
3103 * Returns 0 if at least one of the tested bits is not set, 1 if all tested
3104 * bits are set and a negative error number if the underlying regmap_read()
3107 int regmap_test_bits(struct regmap *map, unsigned int reg, unsigned int bits)
3109 unsigned int val, ret;
3111 ret = regmap_read(map, reg, &val);
3115 return (val & bits) == bits;
3117 EXPORT_SYMBOL_GPL(regmap_test_bits);
3119 void regmap_async_complete_cb(struct regmap_async *async, int ret)
3121 struct regmap *map = async->map;
3124 trace_regmap_async_io_complete(map);
3126 spin_lock(&map->async_lock);
3127 list_move(&async->list, &map->async_free);
3128 wake = list_empty(&map->async_list);
3131 map->async_ret = ret;
3133 spin_unlock(&map->async_lock);
3136 wake_up(&map->async_waitq);
3138 EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
3140 static int regmap_async_is_done(struct regmap *map)
3142 unsigned long flags;
3145 spin_lock_irqsave(&map->async_lock, flags);
3146 ret = list_empty(&map->async_list);
3147 spin_unlock_irqrestore(&map->async_lock, flags);
3153 * regmap_async_complete - Ensure all asynchronous I/O has completed.
3155 * @map: Map to operate on.
3157 * Blocks until any pending asynchronous I/O has completed. Returns
3158 * an error code for any failed I/O operations.
3160 int regmap_async_complete(struct regmap *map)
3162 unsigned long flags;
3165 /* Nothing to do with no async support */
3166 if (!map->bus || !map->bus->async_write)
3169 trace_regmap_async_complete_start(map);
3171 wait_event(map->async_waitq, regmap_async_is_done(map));
3173 spin_lock_irqsave(&map->async_lock, flags);
3174 ret = map->async_ret;
3176 spin_unlock_irqrestore(&map->async_lock, flags);
3178 trace_regmap_async_complete_done(map);
3182 EXPORT_SYMBOL_GPL(regmap_async_complete);
3185 * regmap_register_patch - Register and apply register updates to be applied
3186 * on device initialistion
3188 * @map: Register map to apply updates to.
3189 * @regs: Values to update.
3190 * @num_regs: Number of entries in regs.
3192 * Register a set of register updates to be applied to the device
3193 * whenever the device registers are synchronised with the cache and
3194 * apply them immediately. Typically this is used to apply
3195 * corrections to be applied to the device defaults on startup, such
3196 * as the updates some vendors provide to undocumented registers.
3198 * The caller must ensure that this function cannot be called
3199 * concurrently with either itself or regcache_sync().
3201 int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
3204 struct reg_sequence *p;
3208 if (WARN_ONCE(num_regs <= 0, "invalid registers number (%d)\n",
3212 p = krealloc(map->patch,
3213 sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
3216 memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
3218 map->patch_regs += num_regs;
3223 map->lock(map->lock_arg);
3225 bypass = map->cache_bypass;
3227 map->cache_bypass = true;
3230 ret = _regmap_multi_reg_write(map, regs, num_regs);
3233 map->cache_bypass = bypass;
3235 map->unlock(map->lock_arg);
3237 regmap_async_complete(map);
3241 EXPORT_SYMBOL_GPL(regmap_register_patch);
3244 * regmap_get_val_bytes() - Report the size of a register value
3246 * @map: Register map to operate on.
3248 * Report the size of a register value, mainly intended to for use by
3249 * generic infrastructure built on top of regmap.
3251 int regmap_get_val_bytes(struct regmap *map)
3253 if (map->format.format_write)
3256 return map->format.val_bytes;
3258 EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
3261 * regmap_get_max_register() - Report the max register value
3263 * @map: Register map to operate on.
3265 * Report the max register value, mainly intended to for use by
3266 * generic infrastructure built on top of regmap.
3268 int regmap_get_max_register(struct regmap *map)
3270 return map->max_register ? map->max_register : -EINVAL;
3272 EXPORT_SYMBOL_GPL(regmap_get_max_register);
3275 * regmap_get_reg_stride() - Report the register address stride
3277 * @map: Register map to operate on.
3279 * Report the register address stride, mainly intended to for use by
3280 * generic infrastructure built on top of regmap.
3282 int regmap_get_reg_stride(struct regmap *map)
3284 return map->reg_stride;
3286 EXPORT_SYMBOL_GPL(regmap_get_reg_stride);
3288 int regmap_parse_val(struct regmap *map, const void *buf,
3291 if (!map->format.parse_val)
3294 *val = map->format.parse_val(buf);
3298 EXPORT_SYMBOL_GPL(regmap_parse_val);
3300 static int __init regmap_initcall(void)
3302 regmap_debugfs_initcall();
3306 postcore_initcall(regmap_initcall);