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
);