Linux 5.1.15
[linux/fpc-iii.git] / drivers / base / regmap / regmap.c
blob4f822e087def2dc498fdf436c5428ffabe836d25
1 /*
2 * Register map access API
4 * Copyright 2011 Wolfson Microelectronics plc
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/device.h>
14 #include <linux/slab.h>
15 #include <linux/export.h>
16 #include <linux/mutex.h>
17 #include <linux/err.h>
18 #include <linux/of.h>
19 #include <linux/rbtree.h>
20 #include <linux/sched.h>
21 #include <linux/delay.h>
22 #include <linux/log2.h>
23 #include <linux/hwspinlock.h>
25 #define CREATE_TRACE_POINTS
26 #include "trace.h"
28 #include "internal.h"
31 * Sometimes for failures during very early init the trace
32 * infrastructure isn't available early enough to be used. For this
33 * sort of problem defining LOG_DEVICE will add printks for basic
34 * register I/O on a specific device.
36 #undef LOG_DEVICE
38 #ifdef LOG_DEVICE
39 static inline bool regmap_should_log(struct regmap *map)
41 return (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0);
43 #else
44 static inline bool regmap_should_log(struct regmap *map) { return false; }
45 #endif
48 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
49 unsigned int mask, unsigned int val,
50 bool *change, bool force_write);
52 static int _regmap_bus_reg_read(void *context, unsigned int reg,
53 unsigned int *val);
54 static int _regmap_bus_read(void *context, unsigned int reg,
55 unsigned int *val);
56 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
57 unsigned int val);
58 static int _regmap_bus_reg_write(void *context, unsigned int reg,
59 unsigned int val);
60 static int _regmap_bus_raw_write(void *context, unsigned int reg,
61 unsigned int val);
63 bool regmap_reg_in_ranges(unsigned int reg,
64 const struct regmap_range *ranges,
65 unsigned int nranges)
67 const struct regmap_range *r;
68 int i;
70 for (i = 0, r = ranges; i < nranges; i++, r++)
71 if (regmap_reg_in_range(reg, r))
72 return true;
73 return false;
75 EXPORT_SYMBOL_GPL(regmap_reg_in_ranges);
77 bool regmap_check_range_table(struct regmap *map, unsigned int reg,
78 const struct regmap_access_table *table)
80 /* Check "no ranges" first */
81 if (regmap_reg_in_ranges(reg, table->no_ranges, table->n_no_ranges))
82 return false;
84 /* In case zero "yes ranges" are supplied, any reg is OK */
85 if (!table->n_yes_ranges)
86 return true;
88 return regmap_reg_in_ranges(reg, table->yes_ranges,
89 table->n_yes_ranges);
91 EXPORT_SYMBOL_GPL(regmap_check_range_table);
93 bool regmap_writeable(struct regmap *map, unsigned int reg)
95 if (map->max_register && reg > map->max_register)
96 return false;
98 if (map->writeable_reg)
99 return map->writeable_reg(map->dev, reg);
101 if (map->wr_table)
102 return regmap_check_range_table(map, reg, map->wr_table);
104 return true;
107 bool regmap_cached(struct regmap *map, unsigned int reg)
109 int ret;
110 unsigned int val;
112 if (map->cache_type == REGCACHE_NONE)
113 return false;
115 if (!map->cache_ops)
116 return false;
118 if (map->max_register && reg > map->max_register)
119 return false;
121 map->lock(map->lock_arg);
122 ret = regcache_read(map, reg, &val);
123 map->unlock(map->lock_arg);
124 if (ret)
125 return false;
127 return true;
130 bool regmap_readable(struct regmap *map, unsigned int reg)
132 if (!map->reg_read)
133 return false;
135 if (map->max_register && reg > map->max_register)
136 return false;
138 if (map->format.format_write)
139 return false;
141 if (map->readable_reg)
142 return map->readable_reg(map->dev, reg);
144 if (map->rd_table)
145 return regmap_check_range_table(map, reg, map->rd_table);
147 return true;
150 bool regmap_volatile(struct regmap *map, unsigned int reg)
152 if (!map->format.format_write && !regmap_readable(map, reg))
153 return false;
155 if (map->volatile_reg)
156 return map->volatile_reg(map->dev, reg);
158 if (map->volatile_table)
159 return regmap_check_range_table(map, reg, map->volatile_table);
161 if (map->cache_ops)
162 return false;
163 else
164 return true;
167 bool regmap_precious(struct regmap *map, unsigned int reg)
169 if (!regmap_readable(map, reg))
170 return false;
172 if (map->precious_reg)
173 return map->precious_reg(map->dev, reg);
175 if (map->precious_table)
176 return regmap_check_range_table(map, reg, map->precious_table);
178 return false;
181 bool regmap_writeable_noinc(struct regmap *map, unsigned int reg)
183 if (map->writeable_noinc_reg)
184 return map->writeable_noinc_reg(map->dev, reg);
186 if (map->wr_noinc_table)
187 return regmap_check_range_table(map, reg, map->wr_noinc_table);
189 return true;
192 bool regmap_readable_noinc(struct regmap *map, unsigned int reg)
194 if (map->readable_noinc_reg)
195 return map->readable_noinc_reg(map->dev, reg);
197 if (map->rd_noinc_table)
198 return regmap_check_range_table(map, reg, map->rd_noinc_table);
200 return true;
203 static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
204 size_t num)
206 unsigned int i;
208 for (i = 0; i < num; i++)
209 if (!regmap_volatile(map, reg + regmap_get_offset(map, i)))
210 return false;
212 return true;
215 static void regmap_format_2_6_write(struct regmap *map,
216 unsigned int reg, unsigned int val)
218 u8 *out = map->work_buf;
220 *out = (reg << 6) | val;
223 static void regmap_format_4_12_write(struct regmap *map,
224 unsigned int reg, unsigned int val)
226 __be16 *out = map->work_buf;
227 *out = cpu_to_be16((reg << 12) | val);
230 static void regmap_format_7_9_write(struct regmap *map,
231 unsigned int reg, unsigned int val)
233 __be16 *out = map->work_buf;
234 *out = cpu_to_be16((reg << 9) | val);
237 static void regmap_format_10_14_write(struct regmap *map,
238 unsigned int reg, unsigned int val)
240 u8 *out = map->work_buf;
242 out[2] = val;
243 out[1] = (val >> 8) | (reg << 6);
244 out[0] = reg >> 2;
247 static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
249 u8 *b = buf;
251 b[0] = val << shift;
254 static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
256 __be16 *b = buf;
258 b[0] = cpu_to_be16(val << shift);
261 static void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)
263 __le16 *b = buf;
265 b[0] = cpu_to_le16(val << shift);
268 static void regmap_format_16_native(void *buf, unsigned int val,
269 unsigned int shift)
271 *(u16 *)buf = val << shift;
274 static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
276 u8 *b = buf;
278 val <<= shift;
280 b[0] = val >> 16;
281 b[1] = val >> 8;
282 b[2] = val;
285 static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
287 __be32 *b = buf;
289 b[0] = cpu_to_be32(val << shift);
292 static void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)
294 __le32 *b = buf;
296 b[0] = cpu_to_le32(val << shift);
299 static void regmap_format_32_native(void *buf, unsigned int val,
300 unsigned int shift)
302 *(u32 *)buf = val << shift;
305 #ifdef CONFIG_64BIT
306 static void regmap_format_64_be(void *buf, unsigned int val, unsigned int shift)
308 __be64 *b = buf;
310 b[0] = cpu_to_be64((u64)val << shift);
313 static void regmap_format_64_le(void *buf, unsigned int val, unsigned int shift)
315 __le64 *b = buf;
317 b[0] = cpu_to_le64((u64)val << shift);
320 static void regmap_format_64_native(void *buf, unsigned int val,
321 unsigned int shift)
323 *(u64 *)buf = (u64)val << shift;
325 #endif
327 static void regmap_parse_inplace_noop(void *buf)
331 static unsigned int regmap_parse_8(const void *buf)
333 const u8 *b = buf;
335 return b[0];
338 static unsigned int regmap_parse_16_be(const void *buf)
340 const __be16 *b = buf;
342 return be16_to_cpu(b[0]);
345 static unsigned int regmap_parse_16_le(const void *buf)
347 const __le16 *b = buf;
349 return le16_to_cpu(b[0]);
352 static void regmap_parse_16_be_inplace(void *buf)
354 __be16 *b = buf;
356 b[0] = be16_to_cpu(b[0]);
359 static void regmap_parse_16_le_inplace(void *buf)
361 __le16 *b = buf;
363 b[0] = le16_to_cpu(b[0]);
366 static unsigned int regmap_parse_16_native(const void *buf)
368 return *(u16 *)buf;
371 static unsigned int regmap_parse_24(const void *buf)
373 const u8 *b = buf;
374 unsigned int ret = b[2];
375 ret |= ((unsigned int)b[1]) << 8;
376 ret |= ((unsigned int)b[0]) << 16;
378 return ret;
381 static unsigned int regmap_parse_32_be(const void *buf)
383 const __be32 *b = buf;
385 return be32_to_cpu(b[0]);
388 static unsigned int regmap_parse_32_le(const void *buf)
390 const __le32 *b = buf;
392 return le32_to_cpu(b[0]);
395 static void regmap_parse_32_be_inplace(void *buf)
397 __be32 *b = buf;
399 b[0] = be32_to_cpu(b[0]);
402 static void regmap_parse_32_le_inplace(void *buf)
404 __le32 *b = buf;
406 b[0] = le32_to_cpu(b[0]);
409 static unsigned int regmap_parse_32_native(const void *buf)
411 return *(u32 *)buf;
414 #ifdef CONFIG_64BIT
415 static unsigned int regmap_parse_64_be(const void *buf)
417 const __be64 *b = buf;
419 return be64_to_cpu(b[0]);
422 static unsigned int regmap_parse_64_le(const void *buf)
424 const __le64 *b = buf;
426 return le64_to_cpu(b[0]);
429 static void regmap_parse_64_be_inplace(void *buf)
431 __be64 *b = buf;
433 b[0] = be64_to_cpu(b[0]);
436 static void regmap_parse_64_le_inplace(void *buf)
438 __le64 *b = buf;
440 b[0] = le64_to_cpu(b[0]);
443 static unsigned int regmap_parse_64_native(const void *buf)
445 return *(u64 *)buf;
447 #endif
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;
513 unsigned long flags;
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;
541 while (*new) {
542 struct regmap_range_node *this =
543 rb_entry(*new, struct regmap_range_node, node);
545 parent = *new;
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);
550 else
551 return false;
554 rb_link_node(&data->node, parent, new);
555 rb_insert_color(&data->node, root);
557 return true;
560 static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
561 unsigned int reg)
563 struct rb_node *node = map->range_tree.rb_node;
565 while (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;
573 else
574 return this;
577 return NULL;
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);
586 while (next) {
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);
590 kfree(range_node);
593 kfree(map->selector_work_buf);
596 int regmap_attach_dev(struct device *dev, struct regmap *map,
597 const struct regmap_config *config)
599 struct regmap **m;
601 map->dev = dev;
603 regmap_debugfs_init(map, config->name);
605 /* Add a devres resource for dev_get_regmap() */
606 m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
607 if (!m) {
608 regmap_debugfs_exit(map);
609 return -ENOMEM;
611 *m = map;
612 devres_add(dev, m);
614 return 0;
616 EXPORT_SYMBOL_GPL(regmap_attach_dev);
618 static enum regmap_endian regmap_get_reg_endian(const struct regmap_bus *bus,
619 const struct regmap_config *config)
621 enum regmap_endian endian;
623 /* Retrieve the endianness specification from the regmap config */
624 endian = config->reg_format_endian;
626 /* If the regmap config specified a non-default value, use that */
627 if (endian != REGMAP_ENDIAN_DEFAULT)
628 return endian;
630 /* Retrieve the endianness specification from the bus config */
631 if (bus && bus->reg_format_endian_default)
632 endian = bus->reg_format_endian_default;
634 /* If the bus specified a non-default value, use that */
635 if (endian != REGMAP_ENDIAN_DEFAULT)
636 return endian;
638 /* Use this if no other value was found */
639 return REGMAP_ENDIAN_BIG;
642 enum regmap_endian regmap_get_val_endian(struct device *dev,
643 const struct regmap_bus *bus,
644 const struct regmap_config *config)
646 struct device_node *np;
647 enum regmap_endian endian;
649 /* Retrieve the endianness specification from the regmap config */
650 endian = config->val_format_endian;
652 /* If the regmap config specified a non-default value, use that */
653 if (endian != REGMAP_ENDIAN_DEFAULT)
654 return endian;
656 /* If the dev and dev->of_node exist try to get endianness from DT */
657 if (dev && dev->of_node) {
658 np = dev->of_node;
660 /* Parse the device's DT node for an endianness specification */
661 if (of_property_read_bool(np, "big-endian"))
662 endian = REGMAP_ENDIAN_BIG;
663 else if (of_property_read_bool(np, "little-endian"))
664 endian = REGMAP_ENDIAN_LITTLE;
665 else if (of_property_read_bool(np, "native-endian"))
666 endian = REGMAP_ENDIAN_NATIVE;
668 /* If the endianness was specified in DT, use that */
669 if (endian != REGMAP_ENDIAN_DEFAULT)
670 return endian;
673 /* Retrieve the endianness specification from the bus config */
674 if (bus && bus->val_format_endian_default)
675 endian = bus->val_format_endian_default;
677 /* If the bus specified a non-default value, use that */
678 if (endian != REGMAP_ENDIAN_DEFAULT)
679 return endian;
681 /* Use this if no other value was found */
682 return REGMAP_ENDIAN_BIG;
684 EXPORT_SYMBOL_GPL(regmap_get_val_endian);
686 struct regmap *__regmap_init(struct device *dev,
687 const struct regmap_bus *bus,
688 void *bus_context,
689 const struct regmap_config *config,
690 struct lock_class_key *lock_key,
691 const char *lock_name)
693 struct regmap *map;
694 int ret = -EINVAL;
695 enum regmap_endian reg_endian, val_endian;
696 int i, j;
698 if (!config)
699 goto err;
701 map = kzalloc(sizeof(*map), GFP_KERNEL);
702 if (map == NULL) {
703 ret = -ENOMEM;
704 goto err;
707 if (config->name) {
708 map->name = kstrdup_const(config->name, GFP_KERNEL);
709 if (!map->name) {
710 ret = -ENOMEM;
711 goto err_map;
715 if (config->disable_locking) {
716 map->lock = map->unlock = regmap_lock_unlock_none;
717 regmap_debugfs_disable(map);
718 } else if (config->lock && config->unlock) {
719 map->lock = config->lock;
720 map->unlock = config->unlock;
721 map->lock_arg = config->lock_arg;
722 } else if (config->use_hwlock) {
723 map->hwlock = hwspin_lock_request_specific(config->hwlock_id);
724 if (!map->hwlock) {
725 ret = -ENXIO;
726 goto err_name;
729 switch (config->hwlock_mode) {
730 case HWLOCK_IRQSTATE:
731 map->lock = regmap_lock_hwlock_irqsave;
732 map->unlock = regmap_unlock_hwlock_irqrestore;
733 break;
734 case HWLOCK_IRQ:
735 map->lock = regmap_lock_hwlock_irq;
736 map->unlock = regmap_unlock_hwlock_irq;
737 break;
738 default:
739 map->lock = regmap_lock_hwlock;
740 map->unlock = regmap_unlock_hwlock;
741 break;
744 map->lock_arg = map;
745 } else {
746 if ((bus && bus->fast_io) ||
747 config->fast_io) {
748 spin_lock_init(&map->spinlock);
749 map->lock = regmap_lock_spinlock;
750 map->unlock = regmap_unlock_spinlock;
751 lockdep_set_class_and_name(&map->spinlock,
752 lock_key, lock_name);
753 } else {
754 mutex_init(&map->mutex);
755 map->lock = regmap_lock_mutex;
756 map->unlock = regmap_unlock_mutex;
757 lockdep_set_class_and_name(&map->mutex,
758 lock_key, lock_name);
760 map->lock_arg = map;
764 * When we write in fast-paths with regmap_bulk_write() don't allocate
765 * scratch buffers with sleeping allocations.
767 if ((bus && bus->fast_io) || config->fast_io)
768 map->alloc_flags = GFP_ATOMIC;
769 else
770 map->alloc_flags = GFP_KERNEL;
772 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
773 map->format.pad_bytes = config->pad_bits / 8;
774 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
775 map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
776 config->val_bits + config->pad_bits, 8);
777 map->reg_shift = config->pad_bits % 8;
778 if (config->reg_stride)
779 map->reg_stride = config->reg_stride;
780 else
781 map->reg_stride = 1;
782 if (is_power_of_2(map->reg_stride))
783 map->reg_stride_order = ilog2(map->reg_stride);
784 else
785 map->reg_stride_order = -1;
786 map->use_single_read = config->use_single_read || !bus || !bus->read;
787 map->use_single_write = config->use_single_write || !bus || !bus->write;
788 map->can_multi_write = config->can_multi_write && bus && bus->write;
789 if (bus) {
790 map->max_raw_read = bus->max_raw_read;
791 map->max_raw_write = bus->max_raw_write;
793 map->dev = dev;
794 map->bus = bus;
795 map->bus_context = bus_context;
796 map->max_register = config->max_register;
797 map->wr_table = config->wr_table;
798 map->rd_table = config->rd_table;
799 map->volatile_table = config->volatile_table;
800 map->precious_table = config->precious_table;
801 map->wr_noinc_table = config->wr_noinc_table;
802 map->rd_noinc_table = config->rd_noinc_table;
803 map->writeable_reg = config->writeable_reg;
804 map->readable_reg = config->readable_reg;
805 map->volatile_reg = config->volatile_reg;
806 map->precious_reg = config->precious_reg;
807 map->writeable_noinc_reg = config->writeable_noinc_reg;
808 map->readable_noinc_reg = config->readable_noinc_reg;
809 map->cache_type = config->cache_type;
811 spin_lock_init(&map->async_lock);
812 INIT_LIST_HEAD(&map->async_list);
813 INIT_LIST_HEAD(&map->async_free);
814 init_waitqueue_head(&map->async_waitq);
816 if (config->read_flag_mask ||
817 config->write_flag_mask ||
818 config->zero_flag_mask) {
819 map->read_flag_mask = config->read_flag_mask;
820 map->write_flag_mask = config->write_flag_mask;
821 } else if (bus) {
822 map->read_flag_mask = bus->read_flag_mask;
825 if (!bus) {
826 map->reg_read = config->reg_read;
827 map->reg_write = config->reg_write;
829 map->defer_caching = false;
830 goto skip_format_initialization;
831 } else if (!bus->read || !bus->write) {
832 map->reg_read = _regmap_bus_reg_read;
833 map->reg_write = _regmap_bus_reg_write;
835 map->defer_caching = false;
836 goto skip_format_initialization;
837 } else {
838 map->reg_read = _regmap_bus_read;
839 map->reg_update_bits = bus->reg_update_bits;
842 reg_endian = regmap_get_reg_endian(bus, config);
843 val_endian = regmap_get_val_endian(dev, bus, config);
845 switch (config->reg_bits + map->reg_shift) {
846 case 2:
847 switch (config->val_bits) {
848 case 6:
849 map->format.format_write = regmap_format_2_6_write;
850 break;
851 default:
852 goto err_hwlock;
854 break;
856 case 4:
857 switch (config->val_bits) {
858 case 12:
859 map->format.format_write = regmap_format_4_12_write;
860 break;
861 default:
862 goto err_hwlock;
864 break;
866 case 7:
867 switch (config->val_bits) {
868 case 9:
869 map->format.format_write = regmap_format_7_9_write;
870 break;
871 default:
872 goto err_hwlock;
874 break;
876 case 10:
877 switch (config->val_bits) {
878 case 14:
879 map->format.format_write = regmap_format_10_14_write;
880 break;
881 default:
882 goto err_hwlock;
884 break;
886 case 8:
887 map->format.format_reg = regmap_format_8;
888 break;
890 case 16:
891 switch (reg_endian) {
892 case REGMAP_ENDIAN_BIG:
893 map->format.format_reg = regmap_format_16_be;
894 break;
895 case REGMAP_ENDIAN_LITTLE:
896 map->format.format_reg = regmap_format_16_le;
897 break;
898 case REGMAP_ENDIAN_NATIVE:
899 map->format.format_reg = regmap_format_16_native;
900 break;
901 default:
902 goto err_hwlock;
904 break;
906 case 24:
907 if (reg_endian != REGMAP_ENDIAN_BIG)
908 goto err_hwlock;
909 map->format.format_reg = regmap_format_24;
910 break;
912 case 32:
913 switch (reg_endian) {
914 case REGMAP_ENDIAN_BIG:
915 map->format.format_reg = regmap_format_32_be;
916 break;
917 case REGMAP_ENDIAN_LITTLE:
918 map->format.format_reg = regmap_format_32_le;
919 break;
920 case REGMAP_ENDIAN_NATIVE:
921 map->format.format_reg = regmap_format_32_native;
922 break;
923 default:
924 goto err_hwlock;
926 break;
928 #ifdef CONFIG_64BIT
929 case 64:
930 switch (reg_endian) {
931 case REGMAP_ENDIAN_BIG:
932 map->format.format_reg = regmap_format_64_be;
933 break;
934 case REGMAP_ENDIAN_LITTLE:
935 map->format.format_reg = regmap_format_64_le;
936 break;
937 case REGMAP_ENDIAN_NATIVE:
938 map->format.format_reg = regmap_format_64_native;
939 break;
940 default:
941 goto err_hwlock;
943 break;
944 #endif
946 default:
947 goto err_hwlock;
950 if (val_endian == REGMAP_ENDIAN_NATIVE)
951 map->format.parse_inplace = regmap_parse_inplace_noop;
953 switch (config->val_bits) {
954 case 8:
955 map->format.format_val = regmap_format_8;
956 map->format.parse_val = regmap_parse_8;
957 map->format.parse_inplace = regmap_parse_inplace_noop;
958 break;
959 case 16:
960 switch (val_endian) {
961 case REGMAP_ENDIAN_BIG:
962 map->format.format_val = regmap_format_16_be;
963 map->format.parse_val = regmap_parse_16_be;
964 map->format.parse_inplace = regmap_parse_16_be_inplace;
965 break;
966 case REGMAP_ENDIAN_LITTLE:
967 map->format.format_val = regmap_format_16_le;
968 map->format.parse_val = regmap_parse_16_le;
969 map->format.parse_inplace = regmap_parse_16_le_inplace;
970 break;
971 case REGMAP_ENDIAN_NATIVE:
972 map->format.format_val = regmap_format_16_native;
973 map->format.parse_val = regmap_parse_16_native;
974 break;
975 default:
976 goto err_hwlock;
978 break;
979 case 24:
980 if (val_endian != REGMAP_ENDIAN_BIG)
981 goto err_hwlock;
982 map->format.format_val = regmap_format_24;
983 map->format.parse_val = regmap_parse_24;
984 break;
985 case 32:
986 switch (val_endian) {
987 case REGMAP_ENDIAN_BIG:
988 map->format.format_val = regmap_format_32_be;
989 map->format.parse_val = regmap_parse_32_be;
990 map->format.parse_inplace = regmap_parse_32_be_inplace;
991 break;
992 case REGMAP_ENDIAN_LITTLE:
993 map->format.format_val = regmap_format_32_le;
994 map->format.parse_val = regmap_parse_32_le;
995 map->format.parse_inplace = regmap_parse_32_le_inplace;
996 break;
997 case REGMAP_ENDIAN_NATIVE:
998 map->format.format_val = regmap_format_32_native;
999 map->format.parse_val = regmap_parse_32_native;
1000 break;
1001 default:
1002 goto err_hwlock;
1004 break;
1005 #ifdef CONFIG_64BIT
1006 case 64:
1007 switch (val_endian) {
1008 case REGMAP_ENDIAN_BIG:
1009 map->format.format_val = regmap_format_64_be;
1010 map->format.parse_val = regmap_parse_64_be;
1011 map->format.parse_inplace = regmap_parse_64_be_inplace;
1012 break;
1013 case REGMAP_ENDIAN_LITTLE:
1014 map->format.format_val = regmap_format_64_le;
1015 map->format.parse_val = regmap_parse_64_le;
1016 map->format.parse_inplace = regmap_parse_64_le_inplace;
1017 break;
1018 case REGMAP_ENDIAN_NATIVE:
1019 map->format.format_val = regmap_format_64_native;
1020 map->format.parse_val = regmap_parse_64_native;
1021 break;
1022 default:
1023 goto err_hwlock;
1025 break;
1026 #endif
1029 if (map->format.format_write) {
1030 if ((reg_endian != REGMAP_ENDIAN_BIG) ||
1031 (val_endian != REGMAP_ENDIAN_BIG))
1032 goto err_hwlock;
1033 map->use_single_write = true;
1036 if (!map->format.format_write &&
1037 !(map->format.format_reg && map->format.format_val))
1038 goto err_hwlock;
1040 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
1041 if (map->work_buf == NULL) {
1042 ret = -ENOMEM;
1043 goto err_hwlock;
1046 if (map->format.format_write) {
1047 map->defer_caching = false;
1048 map->reg_write = _regmap_bus_formatted_write;
1049 } else if (map->format.format_val) {
1050 map->defer_caching = true;
1051 map->reg_write = _regmap_bus_raw_write;
1054 skip_format_initialization:
1056 map->range_tree = RB_ROOT;
1057 for (i = 0; i < config->num_ranges; i++) {
1058 const struct regmap_range_cfg *range_cfg = &config->ranges[i];
1059 struct regmap_range_node *new;
1061 /* Sanity check */
1062 if (range_cfg->range_max < range_cfg->range_min) {
1063 dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
1064 range_cfg->range_max, range_cfg->range_min);
1065 goto err_range;
1068 if (range_cfg->range_max > map->max_register) {
1069 dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
1070 range_cfg->range_max, map->max_register);
1071 goto err_range;
1074 if (range_cfg->selector_reg > map->max_register) {
1075 dev_err(map->dev,
1076 "Invalid range %d: selector out of map\n", i);
1077 goto err_range;
1080 if (range_cfg->window_len == 0) {
1081 dev_err(map->dev, "Invalid range %d: window_len 0\n",
1083 goto err_range;
1086 /* Make sure, that this register range has no selector
1087 or data window within its boundary */
1088 for (j = 0; j < config->num_ranges; j++) {
1089 unsigned sel_reg = config->ranges[j].selector_reg;
1090 unsigned win_min = config->ranges[j].window_start;
1091 unsigned win_max = win_min +
1092 config->ranges[j].window_len - 1;
1094 /* Allow data window inside its own virtual range */
1095 if (j == i)
1096 continue;
1098 if (range_cfg->range_min <= sel_reg &&
1099 sel_reg <= range_cfg->range_max) {
1100 dev_err(map->dev,
1101 "Range %d: selector for %d in window\n",
1102 i, j);
1103 goto err_range;
1106 if (!(win_max < range_cfg->range_min ||
1107 win_min > range_cfg->range_max)) {
1108 dev_err(map->dev,
1109 "Range %d: window for %d in window\n",
1110 i, j);
1111 goto err_range;
1115 new = kzalloc(sizeof(*new), GFP_KERNEL);
1116 if (new == NULL) {
1117 ret = -ENOMEM;
1118 goto err_range;
1121 new->map = map;
1122 new->name = range_cfg->name;
1123 new->range_min = range_cfg->range_min;
1124 new->range_max = range_cfg->range_max;
1125 new->selector_reg = range_cfg->selector_reg;
1126 new->selector_mask = range_cfg->selector_mask;
1127 new->selector_shift = range_cfg->selector_shift;
1128 new->window_start = range_cfg->window_start;
1129 new->window_len = range_cfg->window_len;
1131 if (!_regmap_range_add(map, new)) {
1132 dev_err(map->dev, "Failed to add range %d\n", i);
1133 kfree(new);
1134 goto err_range;
1137 if (map->selector_work_buf == NULL) {
1138 map->selector_work_buf =
1139 kzalloc(map->format.buf_size, GFP_KERNEL);
1140 if (map->selector_work_buf == NULL) {
1141 ret = -ENOMEM;
1142 goto err_range;
1147 ret = regcache_init(map, config);
1148 if (ret != 0)
1149 goto err_range;
1151 if (dev) {
1152 ret = regmap_attach_dev(dev, map, config);
1153 if (ret != 0)
1154 goto err_regcache;
1155 } else {
1156 regmap_debugfs_init(map, config->name);
1159 return map;
1161 err_regcache:
1162 regcache_exit(map);
1163 err_range:
1164 regmap_range_exit(map);
1165 kfree(map->work_buf);
1166 err_hwlock:
1167 if (map->hwlock)
1168 hwspin_lock_free(map->hwlock);
1169 err_name:
1170 kfree_const(map->name);
1171 err_map:
1172 kfree(map);
1173 err:
1174 return ERR_PTR(ret);
1176 EXPORT_SYMBOL_GPL(__regmap_init);
1178 static void devm_regmap_release(struct device *dev, void *res)
1180 regmap_exit(*(struct regmap **)res);
1183 struct regmap *__devm_regmap_init(struct device *dev,
1184 const struct regmap_bus *bus,
1185 void *bus_context,
1186 const struct regmap_config *config,
1187 struct lock_class_key *lock_key,
1188 const char *lock_name)
1190 struct regmap **ptr, *regmap;
1192 ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
1193 if (!ptr)
1194 return ERR_PTR(-ENOMEM);
1196 regmap = __regmap_init(dev, bus, bus_context, config,
1197 lock_key, lock_name);
1198 if (!IS_ERR(regmap)) {
1199 *ptr = regmap;
1200 devres_add(dev, ptr);
1201 } else {
1202 devres_free(ptr);
1205 return regmap;
1207 EXPORT_SYMBOL_GPL(__devm_regmap_init);
1209 static void regmap_field_init(struct regmap_field *rm_field,
1210 struct regmap *regmap, struct reg_field reg_field)
1212 rm_field->regmap = regmap;
1213 rm_field->reg = reg_field.reg;
1214 rm_field->shift = reg_field.lsb;
1215 rm_field->mask = GENMASK(reg_field.msb, reg_field.lsb);
1216 rm_field->id_size = reg_field.id_size;
1217 rm_field->id_offset = reg_field.id_offset;
1221 * devm_regmap_field_alloc() - Allocate and initialise a register field.
1223 * @dev: Device that will be interacted with
1224 * @regmap: regmap bank in which this register field is located.
1225 * @reg_field: Register field with in the bank.
1227 * The return value will be an ERR_PTR() on error or a valid pointer
1228 * to a struct regmap_field. The regmap_field will be automatically freed
1229 * by the device management code.
1231 struct regmap_field *devm_regmap_field_alloc(struct device *dev,
1232 struct regmap *regmap, struct reg_field reg_field)
1234 struct regmap_field *rm_field = devm_kzalloc(dev,
1235 sizeof(*rm_field), GFP_KERNEL);
1236 if (!rm_field)
1237 return ERR_PTR(-ENOMEM);
1239 regmap_field_init(rm_field, regmap, reg_field);
1241 return rm_field;
1244 EXPORT_SYMBOL_GPL(devm_regmap_field_alloc);
1247 * devm_regmap_field_free() - Free a register field allocated using
1248 * devm_regmap_field_alloc.
1250 * @dev: Device that will be interacted with
1251 * @field: regmap field which should be freed.
1253 * Free register field allocated using devm_regmap_field_alloc(). Usually
1254 * drivers need not call this function, as the memory allocated via devm
1255 * will be freed as per device-driver life-cyle.
1257 void devm_regmap_field_free(struct device *dev,
1258 struct regmap_field *field)
1260 devm_kfree(dev, field);
1262 EXPORT_SYMBOL_GPL(devm_regmap_field_free);
1265 * regmap_field_alloc() - Allocate and initialise a register field.
1267 * @regmap: regmap bank in which this register field is located.
1268 * @reg_field: Register field with in the bank.
1270 * The return value will be an ERR_PTR() on error or a valid pointer
1271 * to a struct regmap_field. The regmap_field should be freed by the
1272 * user once its finished working with it using regmap_field_free().
1274 struct regmap_field *regmap_field_alloc(struct regmap *regmap,
1275 struct reg_field reg_field)
1277 struct regmap_field *rm_field = kzalloc(sizeof(*rm_field), GFP_KERNEL);
1279 if (!rm_field)
1280 return ERR_PTR(-ENOMEM);
1282 regmap_field_init(rm_field, regmap, reg_field);
1284 return rm_field;
1286 EXPORT_SYMBOL_GPL(regmap_field_alloc);
1289 * regmap_field_free() - Free register field allocated using
1290 * regmap_field_alloc.
1292 * @field: regmap field which should be freed.
1294 void regmap_field_free(struct regmap_field *field)
1296 kfree(field);
1298 EXPORT_SYMBOL_GPL(regmap_field_free);
1301 * regmap_reinit_cache() - Reinitialise the current register cache
1303 * @map: Register map to operate on.
1304 * @config: New configuration. Only the cache data will be used.
1306 * Discard any existing register cache for the map and initialize a
1307 * new cache. This can be used to restore the cache to defaults or to
1308 * update the cache configuration to reflect runtime discovery of the
1309 * hardware.
1311 * No explicit locking is done here, the user needs to ensure that
1312 * this function will not race with other calls to regmap.
1314 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
1316 regcache_exit(map);
1317 regmap_debugfs_exit(map);
1319 map->max_register = config->max_register;
1320 map->writeable_reg = config->writeable_reg;
1321 map->readable_reg = config->readable_reg;
1322 map->volatile_reg = config->volatile_reg;
1323 map->precious_reg = config->precious_reg;
1324 map->writeable_noinc_reg = config->writeable_noinc_reg;
1325 map->readable_noinc_reg = config->readable_noinc_reg;
1326 map->cache_type = config->cache_type;
1328 regmap_debugfs_init(map, config->name);
1330 map->cache_bypass = false;
1331 map->cache_only = false;
1333 return regcache_init(map, config);
1335 EXPORT_SYMBOL_GPL(regmap_reinit_cache);
1338 * regmap_exit() - Free a previously allocated register map
1340 * @map: Register map to operate on.
1342 void regmap_exit(struct regmap *map)
1344 struct regmap_async *async;
1346 regcache_exit(map);
1347 regmap_debugfs_exit(map);
1348 regmap_range_exit(map);
1349 if (map->bus && map->bus->free_context)
1350 map->bus->free_context(map->bus_context);
1351 kfree(map->work_buf);
1352 while (!list_empty(&map->async_free)) {
1353 async = list_first_entry_or_null(&map->async_free,
1354 struct regmap_async,
1355 list);
1356 list_del(&async->list);
1357 kfree(async->work_buf);
1358 kfree(async);
1360 if (map->hwlock)
1361 hwspin_lock_free(map->hwlock);
1362 kfree_const(map->name);
1363 kfree(map);
1365 EXPORT_SYMBOL_GPL(regmap_exit);
1367 static int dev_get_regmap_match(struct device *dev, void *res, void *data)
1369 struct regmap **r = res;
1370 if (!r || !*r) {
1371 WARN_ON(!r || !*r);
1372 return 0;
1375 /* If the user didn't specify a name match any */
1376 if (data)
1377 return (*r)->name == data;
1378 else
1379 return 1;
1383 * dev_get_regmap() - Obtain the regmap (if any) for a device
1385 * @dev: Device to retrieve the map for
1386 * @name: Optional name for the register map, usually NULL.
1388 * Returns the regmap for the device if one is present, or NULL. If
1389 * name is specified then it must match the name specified when
1390 * registering the device, if it is NULL then the first regmap found
1391 * will be used. Devices with multiple register maps are very rare,
1392 * generic code should normally not need to specify a name.
1394 struct regmap *dev_get_regmap(struct device *dev, const char *name)
1396 struct regmap **r = devres_find(dev, dev_get_regmap_release,
1397 dev_get_regmap_match, (void *)name);
1399 if (!r)
1400 return NULL;
1401 return *r;
1403 EXPORT_SYMBOL_GPL(dev_get_regmap);
1406 * regmap_get_device() - Obtain the device from a regmap
1408 * @map: Register map to operate on.
1410 * Returns the underlying device that the regmap has been created for.
1412 struct device *regmap_get_device(struct regmap *map)
1414 return map->dev;
1416 EXPORT_SYMBOL_GPL(regmap_get_device);
1418 static int _regmap_select_page(struct regmap *map, unsigned int *reg,
1419 struct regmap_range_node *range,
1420 unsigned int val_num)
1422 void *orig_work_buf;
1423 unsigned int win_offset;
1424 unsigned int win_page;
1425 bool page_chg;
1426 int ret;
1428 win_offset = (*reg - range->range_min) % range->window_len;
1429 win_page = (*reg - range->range_min) / range->window_len;
1431 if (val_num > 1) {
1432 /* Bulk write shouldn't cross range boundary */
1433 if (*reg + val_num - 1 > range->range_max)
1434 return -EINVAL;
1436 /* ... or single page boundary */
1437 if (val_num > range->window_len - win_offset)
1438 return -EINVAL;
1441 /* It is possible to have selector register inside data window.
1442 In that case, selector register is located on every page and
1443 it needs no page switching, when accessed alone. */
1444 if (val_num > 1 ||
1445 range->window_start + win_offset != range->selector_reg) {
1446 /* Use separate work_buf during page switching */
1447 orig_work_buf = map->work_buf;
1448 map->work_buf = map->selector_work_buf;
1450 ret = _regmap_update_bits(map, range->selector_reg,
1451 range->selector_mask,
1452 win_page << range->selector_shift,
1453 &page_chg, false);
1455 map->work_buf = orig_work_buf;
1457 if (ret != 0)
1458 return ret;
1461 *reg = range->window_start + win_offset;
1463 return 0;
1466 static void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
1467 unsigned long mask)
1469 u8 *buf;
1470 int i;
1472 if (!mask || !map->work_buf)
1473 return;
1475 buf = map->work_buf;
1477 for (i = 0; i < max_bytes; i++)
1478 buf[i] |= (mask >> (8 * i)) & 0xff;
1481 static int _regmap_raw_write_impl(struct regmap *map, unsigned int reg,
1482 const void *val, size_t val_len)
1484 struct regmap_range_node *range;
1485 unsigned long flags;
1486 void *work_val = map->work_buf + map->format.reg_bytes +
1487 map->format.pad_bytes;
1488 void *buf;
1489 int ret = -ENOTSUPP;
1490 size_t len;
1491 int i;
1493 WARN_ON(!map->bus);
1495 /* Check for unwritable registers before we start */
1496 if (map->writeable_reg)
1497 for (i = 0; i < val_len / map->format.val_bytes; i++)
1498 if (!map->writeable_reg(map->dev,
1499 reg + regmap_get_offset(map, i)))
1500 return -EINVAL;
1502 if (!map->cache_bypass && map->format.parse_val) {
1503 unsigned int ival;
1504 int val_bytes = map->format.val_bytes;
1505 for (i = 0; i < val_len / val_bytes; i++) {
1506 ival = map->format.parse_val(val + (i * val_bytes));
1507 ret = regcache_write(map,
1508 reg + regmap_get_offset(map, i),
1509 ival);
1510 if (ret) {
1511 dev_err(map->dev,
1512 "Error in caching of register: %x ret: %d\n",
1513 reg + i, ret);
1514 return ret;
1517 if (map->cache_only) {
1518 map->cache_dirty = true;
1519 return 0;
1523 range = _regmap_range_lookup(map, reg);
1524 if (range) {
1525 int val_num = val_len / map->format.val_bytes;
1526 int win_offset = (reg - range->range_min) % range->window_len;
1527 int win_residue = range->window_len - win_offset;
1529 /* If the write goes beyond the end of the window split it */
1530 while (val_num > win_residue) {
1531 dev_dbg(map->dev, "Writing window %d/%zu\n",
1532 win_residue, val_len / map->format.val_bytes);
1533 ret = _regmap_raw_write_impl(map, reg, val,
1534 win_residue *
1535 map->format.val_bytes);
1536 if (ret != 0)
1537 return ret;
1539 reg += win_residue;
1540 val_num -= win_residue;
1541 val += win_residue * map->format.val_bytes;
1542 val_len -= win_residue * map->format.val_bytes;
1544 win_offset = (reg - range->range_min) %
1545 range->window_len;
1546 win_residue = range->window_len - win_offset;
1549 ret = _regmap_select_page(map, &reg, range, val_num);
1550 if (ret != 0)
1551 return ret;
1554 map->format.format_reg(map->work_buf, reg, map->reg_shift);
1555 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
1556 map->write_flag_mask);
1559 * Essentially all I/O mechanisms will be faster with a single
1560 * buffer to write. Since register syncs often generate raw
1561 * writes of single registers optimise that case.
1563 if (val != work_val && val_len == map->format.val_bytes) {
1564 memcpy(work_val, val, map->format.val_bytes);
1565 val = work_val;
1568 if (map->async && map->bus->async_write) {
1569 struct regmap_async *async;
1571 trace_regmap_async_write_start(map, reg, val_len);
1573 spin_lock_irqsave(&map->async_lock, flags);
1574 async = list_first_entry_or_null(&map->async_free,
1575 struct regmap_async,
1576 list);
1577 if (async)
1578 list_del(&async->list);
1579 spin_unlock_irqrestore(&map->async_lock, flags);
1581 if (!async) {
1582 async = map->bus->async_alloc();
1583 if (!async)
1584 return -ENOMEM;
1586 async->work_buf = kzalloc(map->format.buf_size,
1587 GFP_KERNEL | GFP_DMA);
1588 if (!async->work_buf) {
1589 kfree(async);
1590 return -ENOMEM;
1594 async->map = map;
1596 /* If the caller supplied the value we can use it safely. */
1597 memcpy(async->work_buf, map->work_buf, map->format.pad_bytes +
1598 map->format.reg_bytes + map->format.val_bytes);
1600 spin_lock_irqsave(&map->async_lock, flags);
1601 list_add_tail(&async->list, &map->async_list);
1602 spin_unlock_irqrestore(&map->async_lock, flags);
1604 if (val != work_val)
1605 ret = map->bus->async_write(map->bus_context,
1606 async->work_buf,
1607 map->format.reg_bytes +
1608 map->format.pad_bytes,
1609 val, val_len, async);
1610 else
1611 ret = map->bus->async_write(map->bus_context,
1612 async->work_buf,
1613 map->format.reg_bytes +
1614 map->format.pad_bytes +
1615 val_len, NULL, 0, async);
1617 if (ret != 0) {
1618 dev_err(map->dev, "Failed to schedule write: %d\n",
1619 ret);
1621 spin_lock_irqsave(&map->async_lock, flags);
1622 list_move(&async->list, &map->async_free);
1623 spin_unlock_irqrestore(&map->async_lock, flags);
1626 return ret;
1629 trace_regmap_hw_write_start(map, reg, val_len / map->format.val_bytes);
1631 /* If we're doing a single register write we can probably just
1632 * send the work_buf directly, otherwise try to do a gather
1633 * write.
1635 if (val == work_val)
1636 ret = map->bus->write(map->bus_context, map->work_buf,
1637 map->format.reg_bytes +
1638 map->format.pad_bytes +
1639 val_len);
1640 else if (map->bus->gather_write)
1641 ret = map->bus->gather_write(map->bus_context, map->work_buf,
1642 map->format.reg_bytes +
1643 map->format.pad_bytes,
1644 val, val_len);
1646 /* If that didn't work fall back on linearising by hand. */
1647 if (ret == -ENOTSUPP) {
1648 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
1649 buf = kzalloc(len, GFP_KERNEL);
1650 if (!buf)
1651 return -ENOMEM;
1653 memcpy(buf, map->work_buf, map->format.reg_bytes);
1654 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
1655 val, val_len);
1656 ret = map->bus->write(map->bus_context, buf, len);
1658 kfree(buf);
1659 } else if (ret != 0 && !map->cache_bypass && map->format.parse_val) {
1660 /* regcache_drop_region() takes lock that we already have,
1661 * thus call map->cache_ops->drop() directly
1663 if (map->cache_ops && map->cache_ops->drop)
1664 map->cache_ops->drop(map, reg, reg + 1);
1667 trace_regmap_hw_write_done(map, reg, val_len / map->format.val_bytes);
1669 return ret;
1673 * regmap_can_raw_write - Test if regmap_raw_write() is supported
1675 * @map: Map to check.
1677 bool regmap_can_raw_write(struct regmap *map)
1679 return map->bus && map->bus->write && map->format.format_val &&
1680 map->format.format_reg;
1682 EXPORT_SYMBOL_GPL(regmap_can_raw_write);
1685 * regmap_get_raw_read_max - Get the maximum size we can read
1687 * @map: Map to check.
1689 size_t regmap_get_raw_read_max(struct regmap *map)
1691 return map->max_raw_read;
1693 EXPORT_SYMBOL_GPL(regmap_get_raw_read_max);
1696 * regmap_get_raw_write_max - Get the maximum size we can read
1698 * @map: Map to check.
1700 size_t regmap_get_raw_write_max(struct regmap *map)
1702 return map->max_raw_write;
1704 EXPORT_SYMBOL_GPL(regmap_get_raw_write_max);
1706 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
1707 unsigned int val)
1709 int ret;
1710 struct regmap_range_node *range;
1711 struct regmap *map = context;
1713 WARN_ON(!map->bus || !map->format.format_write);
1715 range = _regmap_range_lookup(map, reg);
1716 if (range) {
1717 ret = _regmap_select_page(map, &reg, range, 1);
1718 if (ret != 0)
1719 return ret;
1722 map->format.format_write(map, reg, val);
1724 trace_regmap_hw_write_start(map, reg, 1);
1726 ret = map->bus->write(map->bus_context, map->work_buf,
1727 map->format.buf_size);
1729 trace_regmap_hw_write_done(map, reg, 1);
1731 return ret;
1734 static int _regmap_bus_reg_write(void *context, unsigned int reg,
1735 unsigned int val)
1737 struct regmap *map = context;
1739 return map->bus->reg_write(map->bus_context, reg, val);
1742 static int _regmap_bus_raw_write(void *context, unsigned int reg,
1743 unsigned int val)
1745 struct regmap *map = context;
1747 WARN_ON(!map->bus || !map->format.format_val);
1749 map->format.format_val(map->work_buf + map->format.reg_bytes
1750 + map->format.pad_bytes, val, 0);
1751 return _regmap_raw_write_impl(map, reg,
1752 map->work_buf +
1753 map->format.reg_bytes +
1754 map->format.pad_bytes,
1755 map->format.val_bytes);
1758 static inline void *_regmap_map_get_context(struct regmap *map)
1760 return (map->bus) ? map : map->bus_context;
1763 int _regmap_write(struct regmap *map, unsigned int reg,
1764 unsigned int val)
1766 int ret;
1767 void *context = _regmap_map_get_context(map);
1769 if (!regmap_writeable(map, reg))
1770 return -EIO;
1772 if (!map->cache_bypass && !map->defer_caching) {
1773 ret = regcache_write(map, reg, val);
1774 if (ret != 0)
1775 return ret;
1776 if (map->cache_only) {
1777 map->cache_dirty = true;
1778 return 0;
1782 if (regmap_should_log(map))
1783 dev_info(map->dev, "%x <= %x\n", reg, val);
1785 trace_regmap_reg_write(map, reg, val);
1787 return map->reg_write(context, reg, val);
1791 * regmap_write() - Write a value to a single register
1793 * @map: Register map to write to
1794 * @reg: Register to write to
1795 * @val: Value to be written
1797 * A value of zero will be returned on success, a negative errno will
1798 * be returned in error cases.
1800 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1802 int ret;
1804 if (!IS_ALIGNED(reg, map->reg_stride))
1805 return -EINVAL;
1807 map->lock(map->lock_arg);
1809 ret = _regmap_write(map, reg, val);
1811 map->unlock(map->lock_arg);
1813 return ret;
1815 EXPORT_SYMBOL_GPL(regmap_write);
1818 * regmap_write_async() - Write a value to a single register asynchronously
1820 * @map: Register map to write to
1821 * @reg: Register to write to
1822 * @val: Value to be written
1824 * A value of zero will be returned on success, a negative errno will
1825 * be returned in error cases.
1827 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val)
1829 int ret;
1831 if (!IS_ALIGNED(reg, map->reg_stride))
1832 return -EINVAL;
1834 map->lock(map->lock_arg);
1836 map->async = true;
1838 ret = _regmap_write(map, reg, val);
1840 map->async = false;
1842 map->unlock(map->lock_arg);
1844 return ret;
1846 EXPORT_SYMBOL_GPL(regmap_write_async);
1848 int _regmap_raw_write(struct regmap *map, unsigned int reg,
1849 const void *val, size_t val_len)
1851 size_t val_bytes = map->format.val_bytes;
1852 size_t val_count = val_len / val_bytes;
1853 size_t chunk_count, chunk_bytes;
1854 size_t chunk_regs = val_count;
1855 int ret, i;
1857 if (!val_count)
1858 return -EINVAL;
1860 if (map->use_single_write)
1861 chunk_regs = 1;
1862 else if (map->max_raw_write && val_len > map->max_raw_write)
1863 chunk_regs = map->max_raw_write / val_bytes;
1865 chunk_count = val_count / chunk_regs;
1866 chunk_bytes = chunk_regs * val_bytes;
1868 /* Write as many bytes as possible with chunk_size */
1869 for (i = 0; i < chunk_count; i++) {
1870 ret = _regmap_raw_write_impl(map, reg, val, chunk_bytes);
1871 if (ret)
1872 return ret;
1874 reg += regmap_get_offset(map, chunk_regs);
1875 val += chunk_bytes;
1876 val_len -= chunk_bytes;
1879 /* Write remaining bytes */
1880 if (val_len)
1881 ret = _regmap_raw_write_impl(map, reg, val, val_len);
1883 return ret;
1887 * regmap_raw_write() - Write raw values to one or more registers
1889 * @map: Register map to write to
1890 * @reg: Initial register to write to
1891 * @val: Block of data to be written, laid out for direct transmission to the
1892 * device
1893 * @val_len: Length of data pointed to by val.
1895 * This function is intended to be used for things like firmware
1896 * download where a large block of data needs to be transferred to the
1897 * device. No formatting will be done on the data provided.
1899 * A value of zero will be returned on success, a negative errno will
1900 * be returned in error cases.
1902 int regmap_raw_write(struct regmap *map, unsigned int reg,
1903 const void *val, size_t val_len)
1905 int ret;
1907 if (!regmap_can_raw_write(map))
1908 return -EINVAL;
1909 if (val_len % map->format.val_bytes)
1910 return -EINVAL;
1912 map->lock(map->lock_arg);
1914 ret = _regmap_raw_write(map, reg, val, val_len);
1916 map->unlock(map->lock_arg);
1918 return ret;
1920 EXPORT_SYMBOL_GPL(regmap_raw_write);
1923 * regmap_noinc_write(): Write data from a register without incrementing the
1924 * register number
1926 * @map: Register map to write to
1927 * @reg: Register to write to
1928 * @val: Pointer to data buffer
1929 * @val_len: Length of output buffer in bytes.
1931 * The regmap API usually assumes that bulk bus write operations will write a
1932 * range of registers. Some devices have certain registers for which a write
1933 * operation can write to an internal FIFO.
1935 * The target register must be volatile but registers after it can be
1936 * completely unrelated cacheable registers.
1938 * This will attempt multiple writes as required to write val_len bytes.
1940 * A value of zero will be returned on success, a negative errno will be
1941 * returned in error cases.
1943 int regmap_noinc_write(struct regmap *map, unsigned int reg,
1944 const void *val, size_t val_len)
1946 size_t write_len;
1947 int ret;
1949 if (!map->bus)
1950 return -EINVAL;
1951 if (!map->bus->write)
1952 return -ENOTSUPP;
1953 if (val_len % map->format.val_bytes)
1954 return -EINVAL;
1955 if (!IS_ALIGNED(reg, map->reg_stride))
1956 return -EINVAL;
1957 if (val_len == 0)
1958 return -EINVAL;
1960 map->lock(map->lock_arg);
1962 if (!regmap_volatile(map, reg) || !regmap_writeable_noinc(map, reg)) {
1963 ret = -EINVAL;
1964 goto out_unlock;
1967 while (val_len) {
1968 if (map->max_raw_write && map->max_raw_write < val_len)
1969 write_len = map->max_raw_write;
1970 else
1971 write_len = val_len;
1972 ret = _regmap_raw_write(map, reg, val, write_len);
1973 if (ret)
1974 goto out_unlock;
1975 val = ((u8 *)val) + write_len;
1976 val_len -= write_len;
1979 out_unlock:
1980 map->unlock(map->lock_arg);
1981 return ret;
1983 EXPORT_SYMBOL_GPL(regmap_noinc_write);
1986 * regmap_field_update_bits_base() - Perform a read/modify/write cycle a
1987 * register field.
1989 * @field: Register field to write to
1990 * @mask: Bitmask to change
1991 * @val: Value to be written
1992 * @change: Boolean indicating if a write was done
1993 * @async: Boolean indicating asynchronously
1994 * @force: Boolean indicating use force update
1996 * Perform a read/modify/write cycle on the register field with change,
1997 * async, force option.
1999 * A value of zero will be returned on success, a negative errno will
2000 * be returned in error cases.
2002 int regmap_field_update_bits_base(struct regmap_field *field,
2003 unsigned int mask, unsigned int val,
2004 bool *change, bool async, bool force)
2006 mask = (mask << field->shift) & field->mask;
2008 return regmap_update_bits_base(field->regmap, field->reg,
2009 mask, val << field->shift,
2010 change, async, force);
2012 EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);
2015 * regmap_fields_update_bits_base() - Perform a read/modify/write cycle a
2016 * register field with port ID
2018 * @field: Register field to write to
2019 * @id: port ID
2020 * @mask: Bitmask to change
2021 * @val: Value to be written
2022 * @change: Boolean indicating if a write was done
2023 * @async: Boolean indicating asynchronously
2024 * @force: Boolean indicating use force update
2026 * A value of zero will be returned on success, a negative errno will
2027 * be returned in error cases.
2029 int regmap_fields_update_bits_base(struct regmap_field *field, unsigned int id,
2030 unsigned int mask, unsigned int val,
2031 bool *change, bool async, bool force)
2033 if (id >= field->id_size)
2034 return -EINVAL;
2036 mask = (mask << field->shift) & field->mask;
2038 return regmap_update_bits_base(field->regmap,
2039 field->reg + (field->id_offset * id),
2040 mask, val << field->shift,
2041 change, async, force);
2043 EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);
2046 * regmap_bulk_write() - Write multiple registers to the device
2048 * @map: Register map to write to
2049 * @reg: First register to be write from
2050 * @val: Block of data to be written, in native register size for device
2051 * @val_count: Number of registers to write
2053 * This function is intended to be used for writing a large block of
2054 * data to the device either in single transfer or multiple transfer.
2056 * A value of zero will be returned on success, a negative errno will
2057 * be returned in error cases.
2059 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
2060 size_t val_count)
2062 int ret = 0, i;
2063 size_t val_bytes = map->format.val_bytes;
2065 if (!IS_ALIGNED(reg, map->reg_stride))
2066 return -EINVAL;
2069 * Some devices don't support bulk write, for them we have a series of
2070 * single write operations.
2072 if (!map->bus || !map->format.parse_inplace) {
2073 map->lock(map->lock_arg);
2074 for (i = 0; i < val_count; i++) {
2075 unsigned int ival;
2077 switch (val_bytes) {
2078 case 1:
2079 ival = *(u8 *)(val + (i * val_bytes));
2080 break;
2081 case 2:
2082 ival = *(u16 *)(val + (i * val_bytes));
2083 break;
2084 case 4:
2085 ival = *(u32 *)(val + (i * val_bytes));
2086 break;
2087 #ifdef CONFIG_64BIT
2088 case 8:
2089 ival = *(u64 *)(val + (i * val_bytes));
2090 break;
2091 #endif
2092 default:
2093 ret = -EINVAL;
2094 goto out;
2097 ret = _regmap_write(map,
2098 reg + regmap_get_offset(map, i),
2099 ival);
2100 if (ret != 0)
2101 goto out;
2103 out:
2104 map->unlock(map->lock_arg);
2105 } else {
2106 void *wval;
2108 wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
2109 if (!wval)
2110 return -ENOMEM;
2112 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2113 map->format.parse_inplace(wval + i);
2115 ret = regmap_raw_write(map, reg, wval, val_bytes * val_count);
2117 kfree(wval);
2119 return ret;
2121 EXPORT_SYMBOL_GPL(regmap_bulk_write);
2124 * _regmap_raw_multi_reg_write()
2126 * the (register,newvalue) pairs in regs have not been formatted, but
2127 * they are all in the same page and have been changed to being page
2128 * relative. The page register has been written if that was necessary.
2130 static int _regmap_raw_multi_reg_write(struct regmap *map,
2131 const struct reg_sequence *regs,
2132 size_t num_regs)
2134 int ret;
2135 void *buf;
2136 int i;
2137 u8 *u8;
2138 size_t val_bytes = map->format.val_bytes;
2139 size_t reg_bytes = map->format.reg_bytes;
2140 size_t pad_bytes = map->format.pad_bytes;
2141 size_t pair_size = reg_bytes + pad_bytes + val_bytes;
2142 size_t len = pair_size * num_regs;
2144 if (!len)
2145 return -EINVAL;
2147 buf = kzalloc(len, GFP_KERNEL);
2148 if (!buf)
2149 return -ENOMEM;
2151 /* We have to linearise by hand. */
2153 u8 = buf;
2155 for (i = 0; i < num_regs; i++) {
2156 unsigned int reg = regs[i].reg;
2157 unsigned int val = regs[i].def;
2158 trace_regmap_hw_write_start(map, reg, 1);
2159 map->format.format_reg(u8, reg, map->reg_shift);
2160 u8 += reg_bytes + pad_bytes;
2161 map->format.format_val(u8, val, 0);
2162 u8 += val_bytes;
2164 u8 = buf;
2165 *u8 |= map->write_flag_mask;
2167 ret = map->bus->write(map->bus_context, buf, len);
2169 kfree(buf);
2171 for (i = 0; i < num_regs; i++) {
2172 int reg = regs[i].reg;
2173 trace_regmap_hw_write_done(map, reg, 1);
2175 return ret;
2178 static unsigned int _regmap_register_page(struct regmap *map,
2179 unsigned int reg,
2180 struct regmap_range_node *range)
2182 unsigned int win_page = (reg - range->range_min) / range->window_len;
2184 return win_page;
2187 static int _regmap_range_multi_paged_reg_write(struct regmap *map,
2188 struct reg_sequence *regs,
2189 size_t num_regs)
2191 int ret;
2192 int i, n;
2193 struct reg_sequence *base;
2194 unsigned int this_page = 0;
2195 unsigned int page_change = 0;
2197 * the set of registers are not neccessarily in order, but
2198 * since the order of write must be preserved this algorithm
2199 * chops the set each time the page changes. This also applies
2200 * if there is a delay required at any point in the sequence.
2202 base = regs;
2203 for (i = 0, n = 0; i < num_regs; i++, n++) {
2204 unsigned int reg = regs[i].reg;
2205 struct regmap_range_node *range;
2207 range = _regmap_range_lookup(map, reg);
2208 if (range) {
2209 unsigned int win_page = _regmap_register_page(map, reg,
2210 range);
2212 if (i == 0)
2213 this_page = win_page;
2214 if (win_page != this_page) {
2215 this_page = win_page;
2216 page_change = 1;
2220 /* If we have both a page change and a delay make sure to
2221 * write the regs and apply the delay before we change the
2222 * page.
2225 if (page_change || regs[i].delay_us) {
2227 /* For situations where the first write requires
2228 * a delay we need to make sure we don't call
2229 * raw_multi_reg_write with n=0
2230 * This can't occur with page breaks as we
2231 * never write on the first iteration
2233 if (regs[i].delay_us && i == 0)
2234 n = 1;
2236 ret = _regmap_raw_multi_reg_write(map, base, n);
2237 if (ret != 0)
2238 return ret;
2240 if (regs[i].delay_us)
2241 udelay(regs[i].delay_us);
2243 base += n;
2244 n = 0;
2246 if (page_change) {
2247 ret = _regmap_select_page(map,
2248 &base[n].reg,
2249 range, 1);
2250 if (ret != 0)
2251 return ret;
2253 page_change = 0;
2259 if (n > 0)
2260 return _regmap_raw_multi_reg_write(map, base, n);
2261 return 0;
2264 static int _regmap_multi_reg_write(struct regmap *map,
2265 const struct reg_sequence *regs,
2266 size_t num_regs)
2268 int i;
2269 int ret;
2271 if (!map->can_multi_write) {
2272 for (i = 0; i < num_regs; i++) {
2273 ret = _regmap_write(map, regs[i].reg, regs[i].def);
2274 if (ret != 0)
2275 return ret;
2277 if (regs[i].delay_us)
2278 udelay(regs[i].delay_us);
2280 return 0;
2283 if (!map->format.parse_inplace)
2284 return -EINVAL;
2286 if (map->writeable_reg)
2287 for (i = 0; i < num_regs; i++) {
2288 int reg = regs[i].reg;
2289 if (!map->writeable_reg(map->dev, reg))
2290 return -EINVAL;
2291 if (!IS_ALIGNED(reg, map->reg_stride))
2292 return -EINVAL;
2295 if (!map->cache_bypass) {
2296 for (i = 0; i < num_regs; i++) {
2297 unsigned int val = regs[i].def;
2298 unsigned int reg = regs[i].reg;
2299 ret = regcache_write(map, reg, val);
2300 if (ret) {
2301 dev_err(map->dev,
2302 "Error in caching of register: %x ret: %d\n",
2303 reg, ret);
2304 return ret;
2307 if (map->cache_only) {
2308 map->cache_dirty = true;
2309 return 0;
2313 WARN_ON(!map->bus);
2315 for (i = 0; i < num_regs; i++) {
2316 unsigned int reg = regs[i].reg;
2317 struct regmap_range_node *range;
2319 /* Coalesce all the writes between a page break or a delay
2320 * in a sequence
2322 range = _regmap_range_lookup(map, reg);
2323 if (range || regs[i].delay_us) {
2324 size_t len = sizeof(struct reg_sequence)*num_regs;
2325 struct reg_sequence *base = kmemdup(regs, len,
2326 GFP_KERNEL);
2327 if (!base)
2328 return -ENOMEM;
2329 ret = _regmap_range_multi_paged_reg_write(map, base,
2330 num_regs);
2331 kfree(base);
2333 return ret;
2336 return _regmap_raw_multi_reg_write(map, regs, num_regs);
2340 * regmap_multi_reg_write() - Write multiple registers to the device
2342 * @map: Register map to write to
2343 * @regs: Array of structures containing register,value to be written
2344 * @num_regs: Number of registers to write
2346 * Write multiple registers to the device where the set of register, value
2347 * pairs are supplied in any order, possibly not all in a single range.
2349 * The 'normal' block write mode will send ultimately send data on the
2350 * target bus as R,V1,V2,V3,..,Vn where successively higher registers are
2351 * addressed. However, this alternative block multi write mode will send
2352 * the data as R1,V1,R2,V2,..,Rn,Vn on the target bus. The target device
2353 * must of course support the mode.
2355 * A value of zero will be returned on success, a negative errno will be
2356 * returned in error cases.
2358 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
2359 int num_regs)
2361 int ret;
2363 map->lock(map->lock_arg);
2365 ret = _regmap_multi_reg_write(map, regs, num_regs);
2367 map->unlock(map->lock_arg);
2369 return ret;
2371 EXPORT_SYMBOL_GPL(regmap_multi_reg_write);
2374 * regmap_multi_reg_write_bypassed() - Write multiple registers to the
2375 * device but not the cache
2377 * @map: Register map to write to
2378 * @regs: Array of structures containing register,value to be written
2379 * @num_regs: Number of registers to write
2381 * Write multiple registers to the device but not the cache where the set
2382 * of register are supplied in any order.
2384 * This function is intended to be used for writing a large block of data
2385 * atomically to the device in single transfer for those I2C client devices
2386 * that implement this alternative block write mode.
2388 * A value of zero will be returned on success, a negative errno will
2389 * be returned in error cases.
2391 int regmap_multi_reg_write_bypassed(struct regmap *map,
2392 const struct reg_sequence *regs,
2393 int num_regs)
2395 int ret;
2396 bool bypass;
2398 map->lock(map->lock_arg);
2400 bypass = map->cache_bypass;
2401 map->cache_bypass = true;
2403 ret = _regmap_multi_reg_write(map, regs, num_regs);
2405 map->cache_bypass = bypass;
2407 map->unlock(map->lock_arg);
2409 return ret;
2411 EXPORT_SYMBOL_GPL(regmap_multi_reg_write_bypassed);
2414 * regmap_raw_write_async() - Write raw values to one or more registers
2415 * asynchronously
2417 * @map: Register map to write to
2418 * @reg: Initial register to write to
2419 * @val: Block of data to be written, laid out for direct transmission to the
2420 * device. Must be valid until regmap_async_complete() is called.
2421 * @val_len: Length of data pointed to by val.
2423 * This function is intended to be used for things like firmware
2424 * download where a large block of data needs to be transferred to the
2425 * device. No formatting will be done on the data provided.
2427 * If supported by the underlying bus the write will be scheduled
2428 * asynchronously, helping maximise I/O speed on higher speed buses
2429 * like SPI. regmap_async_complete() can be called to ensure that all
2430 * asynchrnous writes have been completed.
2432 * A value of zero will be returned on success, a negative errno will
2433 * be returned in error cases.
2435 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
2436 const void *val, size_t val_len)
2438 int ret;
2440 if (val_len % map->format.val_bytes)
2441 return -EINVAL;
2442 if (!IS_ALIGNED(reg, map->reg_stride))
2443 return -EINVAL;
2445 map->lock(map->lock_arg);
2447 map->async = true;
2449 ret = _regmap_raw_write(map, reg, val, val_len);
2451 map->async = false;
2453 map->unlock(map->lock_arg);
2455 return ret;
2457 EXPORT_SYMBOL_GPL(regmap_raw_write_async);
2459 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2460 unsigned int val_len)
2462 struct regmap_range_node *range;
2463 int ret;
2465 WARN_ON(!map->bus);
2467 if (!map->bus || !map->bus->read)
2468 return -EINVAL;
2470 range = _regmap_range_lookup(map, reg);
2471 if (range) {
2472 ret = _regmap_select_page(map, &reg, range,
2473 val_len / map->format.val_bytes);
2474 if (ret != 0)
2475 return ret;
2478 map->format.format_reg(map->work_buf, reg, map->reg_shift);
2479 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
2480 map->read_flag_mask);
2481 trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
2483 ret = map->bus->read(map->bus_context, map->work_buf,
2484 map->format.reg_bytes + map->format.pad_bytes,
2485 val, val_len);
2487 trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
2489 return ret;
2492 static int _regmap_bus_reg_read(void *context, unsigned int reg,
2493 unsigned int *val)
2495 struct regmap *map = context;
2497 return map->bus->reg_read(map->bus_context, reg, val);
2500 static int _regmap_bus_read(void *context, unsigned int reg,
2501 unsigned int *val)
2503 int ret;
2504 struct regmap *map = context;
2505 void *work_val = map->work_buf + map->format.reg_bytes +
2506 map->format.pad_bytes;
2508 if (!map->format.parse_val)
2509 return -EINVAL;
2511 ret = _regmap_raw_read(map, reg, work_val, map->format.val_bytes);
2512 if (ret == 0)
2513 *val = map->format.parse_val(work_val);
2515 return ret;
2518 static int _regmap_read(struct regmap *map, unsigned int reg,
2519 unsigned int *val)
2521 int ret;
2522 void *context = _regmap_map_get_context(map);
2524 if (!map->cache_bypass) {
2525 ret = regcache_read(map, reg, val);
2526 if (ret == 0)
2527 return 0;
2530 if (map->cache_only)
2531 return -EBUSY;
2533 if (!regmap_readable(map, reg))
2534 return -EIO;
2536 ret = map->reg_read(context, reg, val);
2537 if (ret == 0) {
2538 if (regmap_should_log(map))
2539 dev_info(map->dev, "%x => %x\n", reg, *val);
2541 trace_regmap_reg_read(map, reg, *val);
2543 if (!map->cache_bypass)
2544 regcache_write(map, reg, *val);
2547 return ret;
2551 * regmap_read() - Read a value from a single register
2553 * @map: Register map to read from
2554 * @reg: Register to be read from
2555 * @val: Pointer to store read value
2557 * A value of zero will be returned on success, a negative errno will
2558 * be returned in error cases.
2560 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
2562 int ret;
2564 if (!IS_ALIGNED(reg, map->reg_stride))
2565 return -EINVAL;
2567 map->lock(map->lock_arg);
2569 ret = _regmap_read(map, reg, val);
2571 map->unlock(map->lock_arg);
2573 return ret;
2575 EXPORT_SYMBOL_GPL(regmap_read);
2578 * regmap_raw_read() - Read raw data from the device
2580 * @map: Register map to read from
2581 * @reg: First register to be read from
2582 * @val: Pointer to store read value
2583 * @val_len: Size of data to read
2585 * A value of zero will be returned on success, a negative errno will
2586 * be returned in error cases.
2588 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2589 size_t val_len)
2591 size_t val_bytes = map->format.val_bytes;
2592 size_t val_count = val_len / val_bytes;
2593 unsigned int v;
2594 int ret, i;
2596 if (!map->bus)
2597 return -EINVAL;
2598 if (val_len % map->format.val_bytes)
2599 return -EINVAL;
2600 if (!IS_ALIGNED(reg, map->reg_stride))
2601 return -EINVAL;
2602 if (val_count == 0)
2603 return -EINVAL;
2605 map->lock(map->lock_arg);
2607 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
2608 map->cache_type == REGCACHE_NONE) {
2609 size_t chunk_count, chunk_bytes;
2610 size_t chunk_regs = val_count;
2612 if (!map->bus->read) {
2613 ret = -ENOTSUPP;
2614 goto out;
2617 if (map->use_single_read)
2618 chunk_regs = 1;
2619 else if (map->max_raw_read && val_len > map->max_raw_read)
2620 chunk_regs = map->max_raw_read / val_bytes;
2622 chunk_count = val_count / chunk_regs;
2623 chunk_bytes = chunk_regs * val_bytes;
2625 /* Read bytes that fit into whole chunks */
2626 for (i = 0; i < chunk_count; i++) {
2627 ret = _regmap_raw_read(map, reg, val, chunk_bytes);
2628 if (ret != 0)
2629 goto out;
2631 reg += regmap_get_offset(map, chunk_regs);
2632 val += chunk_bytes;
2633 val_len -= chunk_bytes;
2636 /* Read remaining bytes */
2637 if (val_len) {
2638 ret = _regmap_raw_read(map, reg, val, val_len);
2639 if (ret != 0)
2640 goto out;
2642 } else {
2643 /* Otherwise go word by word for the cache; should be low
2644 * cost as we expect to hit the cache.
2646 for (i = 0; i < val_count; i++) {
2647 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2648 &v);
2649 if (ret != 0)
2650 goto out;
2652 map->format.format_val(val + (i * val_bytes), v, 0);
2656 out:
2657 map->unlock(map->lock_arg);
2659 return ret;
2661 EXPORT_SYMBOL_GPL(regmap_raw_read);
2664 * regmap_noinc_read(): Read data from a register without incrementing the
2665 * register number
2667 * @map: Register map to read from
2668 * @reg: Register to read from
2669 * @val: Pointer to data buffer
2670 * @val_len: Length of output buffer in bytes.
2672 * The regmap API usually assumes that bulk bus read operations will read a
2673 * range of registers. Some devices have certain registers for which a read
2674 * operation read will read from an internal FIFO.
2676 * The target register must be volatile but registers after it can be
2677 * completely unrelated cacheable registers.
2679 * This will attempt multiple reads as required to read val_len bytes.
2681 * A value of zero will be returned on success, a negative errno will be
2682 * returned in error cases.
2684 int regmap_noinc_read(struct regmap *map, unsigned int reg,
2685 void *val, size_t val_len)
2687 size_t read_len;
2688 int ret;
2690 if (!map->bus)
2691 return -EINVAL;
2692 if (!map->bus->read)
2693 return -ENOTSUPP;
2694 if (val_len % map->format.val_bytes)
2695 return -EINVAL;
2696 if (!IS_ALIGNED(reg, map->reg_stride))
2697 return -EINVAL;
2698 if (val_len == 0)
2699 return -EINVAL;
2701 map->lock(map->lock_arg);
2703 if (!regmap_volatile(map, reg) || !regmap_readable_noinc(map, reg)) {
2704 ret = -EINVAL;
2705 goto out_unlock;
2708 while (val_len) {
2709 if (map->max_raw_read && map->max_raw_read < val_len)
2710 read_len = map->max_raw_read;
2711 else
2712 read_len = val_len;
2713 ret = _regmap_raw_read(map, reg, val, read_len);
2714 if (ret)
2715 goto out_unlock;
2716 val = ((u8 *)val) + read_len;
2717 val_len -= read_len;
2720 out_unlock:
2721 map->unlock(map->lock_arg);
2722 return ret;
2724 EXPORT_SYMBOL_GPL(regmap_noinc_read);
2727 * regmap_field_read(): Read a value to a single register field
2729 * @field: Register field to read from
2730 * @val: Pointer to store read value
2732 * A value of zero will be returned on success, a negative errno will
2733 * be returned in error cases.
2735 int regmap_field_read(struct regmap_field *field, unsigned int *val)
2737 int ret;
2738 unsigned int reg_val;
2739 ret = regmap_read(field->regmap, field->reg, &reg_val);
2740 if (ret != 0)
2741 return ret;
2743 reg_val &= field->mask;
2744 reg_val >>= field->shift;
2745 *val = reg_val;
2747 return ret;
2749 EXPORT_SYMBOL_GPL(regmap_field_read);
2752 * regmap_fields_read() - Read a value to a single register field with port ID
2754 * @field: Register field to read from
2755 * @id: port ID
2756 * @val: Pointer to store read value
2758 * A value of zero will be returned on success, a negative errno will
2759 * be returned in error cases.
2761 int regmap_fields_read(struct regmap_field *field, unsigned int id,
2762 unsigned int *val)
2764 int ret;
2765 unsigned int reg_val;
2767 if (id >= field->id_size)
2768 return -EINVAL;
2770 ret = regmap_read(field->regmap,
2771 field->reg + (field->id_offset * id),
2772 &reg_val);
2773 if (ret != 0)
2774 return ret;
2776 reg_val &= field->mask;
2777 reg_val >>= field->shift;
2778 *val = reg_val;
2780 return ret;
2782 EXPORT_SYMBOL_GPL(regmap_fields_read);
2785 * regmap_bulk_read() - Read multiple registers from the device
2787 * @map: Register map to read from
2788 * @reg: First register to be read from
2789 * @val: Pointer to store read value, in native register size for device
2790 * @val_count: Number of registers to read
2792 * A value of zero will be returned on success, a negative errno will
2793 * be returned in error cases.
2795 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
2796 size_t val_count)
2798 int ret, i;
2799 size_t val_bytes = map->format.val_bytes;
2800 bool vol = regmap_volatile_range(map, reg, val_count);
2802 if (!IS_ALIGNED(reg, map->reg_stride))
2803 return -EINVAL;
2804 if (val_count == 0)
2805 return -EINVAL;
2807 if (map->bus && map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
2808 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
2809 if (ret != 0)
2810 return ret;
2812 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2813 map->format.parse_inplace(val + i);
2814 } else {
2815 #ifdef CONFIG_64BIT
2816 u64 *u64 = val;
2817 #endif
2818 u32 *u32 = val;
2819 u16 *u16 = val;
2820 u8 *u8 = val;
2822 map->lock(map->lock_arg);
2824 for (i = 0; i < val_count; i++) {
2825 unsigned int ival;
2827 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2828 &ival);
2829 if (ret != 0)
2830 goto out;
2832 switch (map->format.val_bytes) {
2833 #ifdef CONFIG_64BIT
2834 case 8:
2835 u64[i] = ival;
2836 break;
2837 #endif
2838 case 4:
2839 u32[i] = ival;
2840 break;
2841 case 2:
2842 u16[i] = ival;
2843 break;
2844 case 1:
2845 u8[i] = ival;
2846 break;
2847 default:
2848 ret = -EINVAL;
2849 goto out;
2853 out:
2854 map->unlock(map->lock_arg);
2857 return ret;
2859 EXPORT_SYMBOL_GPL(regmap_bulk_read);
2861 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
2862 unsigned int mask, unsigned int val,
2863 bool *change, bool force_write)
2865 int ret;
2866 unsigned int tmp, orig;
2868 if (change)
2869 *change = false;
2871 if (regmap_volatile(map, reg) && map->reg_update_bits) {
2872 ret = map->reg_update_bits(map->bus_context, reg, mask, val);
2873 if (ret == 0 && change)
2874 *change = true;
2875 } else {
2876 ret = _regmap_read(map, reg, &orig);
2877 if (ret != 0)
2878 return ret;
2880 tmp = orig & ~mask;
2881 tmp |= val & mask;
2883 if (force_write || (tmp != orig)) {
2884 ret = _regmap_write(map, reg, tmp);
2885 if (ret == 0 && change)
2886 *change = true;
2890 return ret;
2894 * regmap_update_bits_base() - Perform a read/modify/write cycle on a register
2896 * @map: Register map to update
2897 * @reg: Register to update
2898 * @mask: Bitmask to change
2899 * @val: New value for bitmask
2900 * @change: Boolean indicating if a write was done
2901 * @async: Boolean indicating asynchronously
2902 * @force: Boolean indicating use force update
2904 * Perform a read/modify/write cycle on a register map with change, async, force
2905 * options.
2907 * If async is true:
2909 * With most buses the read must be done synchronously so this is most useful
2910 * for devices with a cache which do not need to interact with the hardware to
2911 * determine the current register value.
2913 * Returns zero for success, a negative number on error.
2915 int regmap_update_bits_base(struct regmap *map, unsigned int reg,
2916 unsigned int mask, unsigned int val,
2917 bool *change, bool async, bool force)
2919 int ret;
2921 map->lock(map->lock_arg);
2923 map->async = async;
2925 ret = _regmap_update_bits(map, reg, mask, val, change, force);
2927 map->async = false;
2929 map->unlock(map->lock_arg);
2931 return ret;
2933 EXPORT_SYMBOL_GPL(regmap_update_bits_base);
2935 void regmap_async_complete_cb(struct regmap_async *async, int ret)
2937 struct regmap *map = async->map;
2938 bool wake;
2940 trace_regmap_async_io_complete(map);
2942 spin_lock(&map->async_lock);
2943 list_move(&async->list, &map->async_free);
2944 wake = list_empty(&map->async_list);
2946 if (ret != 0)
2947 map->async_ret = ret;
2949 spin_unlock(&map->async_lock);
2951 if (wake)
2952 wake_up(&map->async_waitq);
2954 EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
2956 static int regmap_async_is_done(struct regmap *map)
2958 unsigned long flags;
2959 int ret;
2961 spin_lock_irqsave(&map->async_lock, flags);
2962 ret = list_empty(&map->async_list);
2963 spin_unlock_irqrestore(&map->async_lock, flags);
2965 return ret;
2969 * regmap_async_complete - Ensure all asynchronous I/O has completed.
2971 * @map: Map to operate on.
2973 * Blocks until any pending asynchronous I/O has completed. Returns
2974 * an error code for any failed I/O operations.
2976 int regmap_async_complete(struct regmap *map)
2978 unsigned long flags;
2979 int ret;
2981 /* Nothing to do with no async support */
2982 if (!map->bus || !map->bus->async_write)
2983 return 0;
2985 trace_regmap_async_complete_start(map);
2987 wait_event(map->async_waitq, regmap_async_is_done(map));
2989 spin_lock_irqsave(&map->async_lock, flags);
2990 ret = map->async_ret;
2991 map->async_ret = 0;
2992 spin_unlock_irqrestore(&map->async_lock, flags);
2994 trace_regmap_async_complete_done(map);
2996 return ret;
2998 EXPORT_SYMBOL_GPL(regmap_async_complete);
3001 * regmap_register_patch - Register and apply register updates to be applied
3002 * on device initialistion
3004 * @map: Register map to apply updates to.
3005 * @regs: Values to update.
3006 * @num_regs: Number of entries in regs.
3008 * Register a set of register updates to be applied to the device
3009 * whenever the device registers are synchronised with the cache and
3010 * apply them immediately. Typically this is used to apply
3011 * corrections to be applied to the device defaults on startup, such
3012 * as the updates some vendors provide to undocumented registers.
3014 * The caller must ensure that this function cannot be called
3015 * concurrently with either itself or regcache_sync().
3017 int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
3018 int num_regs)
3020 struct reg_sequence *p;
3021 int ret;
3022 bool bypass;
3024 if (WARN_ONCE(num_regs <= 0, "invalid registers number (%d)\n",
3025 num_regs))
3026 return 0;
3028 p = krealloc(map->patch,
3029 sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
3030 GFP_KERNEL);
3031 if (p) {
3032 memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
3033 map->patch = p;
3034 map->patch_regs += num_regs;
3035 } else {
3036 return -ENOMEM;
3039 map->lock(map->lock_arg);
3041 bypass = map->cache_bypass;
3043 map->cache_bypass = true;
3044 map->async = true;
3046 ret = _regmap_multi_reg_write(map, regs, num_regs);
3048 map->async = false;
3049 map->cache_bypass = bypass;
3051 map->unlock(map->lock_arg);
3053 regmap_async_complete(map);
3055 return ret;
3057 EXPORT_SYMBOL_GPL(regmap_register_patch);
3060 * regmap_get_val_bytes() - Report the size of a register value
3062 * @map: Register map to operate on.
3064 * Report the size of a register value, mainly intended to for use by
3065 * generic infrastructure built on top of regmap.
3067 int regmap_get_val_bytes(struct regmap *map)
3069 if (map->format.format_write)
3070 return -EINVAL;
3072 return map->format.val_bytes;
3074 EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
3077 * regmap_get_max_register() - Report the max register value
3079 * @map: Register map to operate on.
3081 * Report the max register value, mainly intended to for use by
3082 * generic infrastructure built on top of regmap.
3084 int regmap_get_max_register(struct regmap *map)
3086 return map->max_register ? map->max_register : -EINVAL;
3088 EXPORT_SYMBOL_GPL(regmap_get_max_register);
3091 * regmap_get_reg_stride() - Report the register address stride
3093 * @map: Register map to operate on.
3095 * Report the register address stride, mainly intended to for use by
3096 * generic infrastructure built on top of regmap.
3098 int regmap_get_reg_stride(struct regmap *map)
3100 return map->reg_stride;
3102 EXPORT_SYMBOL_GPL(regmap_get_reg_stride);
3104 int regmap_parse_val(struct regmap *map, const void *buf,
3105 unsigned int *val)
3107 if (!map->format.parse_val)
3108 return -EINVAL;
3110 *val = map->format.parse_val(buf);
3112 return 0;
3114 EXPORT_SYMBOL_GPL(regmap_parse_val);
3116 static int __init regmap_initcall(void)
3118 regmap_debugfs_initcall();
3120 return 0;
3122 postcore_initcall(regmap_initcall);