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/rbtree.h>
20 #define CREATE_TRACE_POINTS
21 #include <trace/events/regmap.h>
26 * Sometimes for failures during very early init the trace
27 * infrastructure isn't available early enough to be used. For this
28 * sort of problem defining LOG_DEVICE will add printks for basic
29 * register I/O on a specific device.
33 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
34 unsigned int mask, unsigned int val,
37 bool regmap_reg_in_ranges(unsigned int reg,
38 const struct regmap_range *ranges,
41 const struct regmap_range *r;
44 for (i = 0, r = ranges; i < nranges; i++, r++)
45 if (regmap_reg_in_range(reg, r))
49 EXPORT_SYMBOL_GPL(regmap_reg_in_ranges);
51 static bool _regmap_check_range_table(struct regmap *map,
53 const struct regmap_access_table *table)
55 /* Check "no ranges" first */
56 if (regmap_reg_in_ranges(reg, table->no_ranges, table->n_no_ranges))
59 /* In case zero "yes ranges" are supplied, any reg is OK */
60 if (!table->n_yes_ranges)
63 return regmap_reg_in_ranges(reg, table->yes_ranges,
67 bool regmap_writeable(struct regmap *map, unsigned int reg)
69 if (map->max_register && reg > map->max_register)
72 if (map->writeable_reg)
73 return map->writeable_reg(map->dev, reg);
76 return _regmap_check_range_table(map, reg, map->wr_table);
81 bool regmap_readable(struct regmap *map, unsigned int reg)
83 if (map->max_register && reg > map->max_register)
86 if (map->format.format_write)
89 if (map->readable_reg)
90 return map->readable_reg(map->dev, reg);
93 return _regmap_check_range_table(map, reg, map->rd_table);
98 bool regmap_volatile(struct regmap *map, unsigned int reg)
100 if (!regmap_readable(map, reg))
103 if (map->volatile_reg)
104 return map->volatile_reg(map->dev, reg);
106 if (map->volatile_table)
107 return _regmap_check_range_table(map, reg, map->volatile_table);
112 bool regmap_precious(struct regmap *map, unsigned int reg)
114 if (!regmap_readable(map, reg))
117 if (map->precious_reg)
118 return map->precious_reg(map->dev, reg);
120 if (map->precious_table)
121 return _regmap_check_range_table(map, reg, map->precious_table);
126 static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
131 for (i = 0; i < num; i++)
132 if (!regmap_volatile(map, reg + i))
138 static void regmap_format_2_6_write(struct regmap *map,
139 unsigned int reg, unsigned int val)
141 u8 *out = map->work_buf;
143 *out = (reg << 6) | val;
146 static void regmap_format_4_12_write(struct regmap *map,
147 unsigned int reg, unsigned int val)
149 __be16 *out = map->work_buf;
150 *out = cpu_to_be16((reg << 12) | val);
153 static void regmap_format_7_9_write(struct regmap *map,
154 unsigned int reg, unsigned int val)
156 __be16 *out = map->work_buf;
157 *out = cpu_to_be16((reg << 9) | val);
160 static void regmap_format_10_14_write(struct regmap *map,
161 unsigned int reg, unsigned int val)
163 u8 *out = map->work_buf;
166 out[1] = (val >> 8) | (reg << 6);
170 static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
177 static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
181 b[0] = cpu_to_be16(val << shift);
184 static void regmap_format_16_native(void *buf, unsigned int val,
187 *(u16 *)buf = val << shift;
190 static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
201 static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
205 b[0] = cpu_to_be32(val << shift);
208 static void regmap_format_32_native(void *buf, unsigned int val,
211 *(u32 *)buf = val << shift;
214 static unsigned int regmap_parse_8(void *buf)
221 static unsigned int regmap_parse_16_be(void *buf)
225 b[0] = be16_to_cpu(b[0]);
230 static unsigned int regmap_parse_16_native(void *buf)
235 static unsigned int regmap_parse_24(void *buf)
238 unsigned int ret = b[2];
239 ret |= ((unsigned int)b[1]) << 8;
240 ret |= ((unsigned int)b[0]) << 16;
245 static unsigned int regmap_parse_32_be(void *buf)
249 b[0] = be32_to_cpu(b[0]);
254 static unsigned int regmap_parse_32_native(void *buf)
259 static void regmap_lock_mutex(void *__map)
261 struct regmap *map = __map;
262 mutex_lock(&map->mutex);
265 static void regmap_unlock_mutex(void *__map)
267 struct regmap *map = __map;
268 mutex_unlock(&map->mutex);
271 static void regmap_lock_spinlock(void *__map)
273 struct regmap *map = __map;
274 spin_lock(&map->spinlock);
277 static void regmap_unlock_spinlock(void *__map)
279 struct regmap *map = __map;
280 spin_unlock(&map->spinlock);
283 static void dev_get_regmap_release(struct device *dev, void *res)
286 * We don't actually have anything to do here; the goal here
287 * is not to manage the regmap but to provide a simple way to
288 * get the regmap back given a struct device.
292 static bool _regmap_range_add(struct regmap *map,
293 struct regmap_range_node *data)
295 struct rb_root *root = &map->range_tree;
296 struct rb_node **new = &(root->rb_node), *parent = NULL;
299 struct regmap_range_node *this =
300 container_of(*new, struct regmap_range_node, node);
303 if (data->range_max < this->range_min)
304 new = &((*new)->rb_left);
305 else if (data->range_min > this->range_max)
306 new = &((*new)->rb_right);
311 rb_link_node(&data->node, parent, new);
312 rb_insert_color(&data->node, root);
317 static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
320 struct rb_node *node = map->range_tree.rb_node;
323 struct regmap_range_node *this =
324 container_of(node, struct regmap_range_node, node);
326 if (reg < this->range_min)
327 node = node->rb_left;
328 else if (reg > this->range_max)
329 node = node->rb_right;
337 static void regmap_range_exit(struct regmap *map)
339 struct rb_node *next;
340 struct regmap_range_node *range_node;
342 next = rb_first(&map->range_tree);
344 range_node = rb_entry(next, struct regmap_range_node, node);
345 next = rb_next(&range_node->node);
346 rb_erase(&range_node->node, &map->range_tree);
350 kfree(map->selector_work_buf);
354 * regmap_init(): Initialise register map
356 * @dev: Device that will be interacted with
357 * @bus: Bus-specific callbacks to use with device
358 * @bus_context: Data passed to bus-specific callbacks
359 * @config: Configuration for register map
361 * The return value will be an ERR_PTR() on error or a valid pointer to
362 * a struct regmap. This function should generally not be called
363 * directly, it should be called by bus-specific init functions.
365 struct regmap *regmap_init(struct device *dev,
366 const struct regmap_bus *bus,
368 const struct regmap_config *config)
370 struct regmap *map, **m;
372 enum regmap_endian reg_endian, val_endian;
378 map = kzalloc(sizeof(*map), GFP_KERNEL);
384 if (config->lock && config->unlock) {
385 map->lock = config->lock;
386 map->unlock = config->unlock;
387 map->lock_arg = config->lock_arg;
390 spin_lock_init(&map->spinlock);
391 map->lock = regmap_lock_spinlock;
392 map->unlock = regmap_unlock_spinlock;
394 mutex_init(&map->mutex);
395 map->lock = regmap_lock_mutex;
396 map->unlock = regmap_unlock_mutex;
400 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
401 map->format.pad_bytes = config->pad_bits / 8;
402 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
403 map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
404 config->val_bits + config->pad_bits, 8);
405 map->reg_shift = config->pad_bits % 8;
406 if (config->reg_stride)
407 map->reg_stride = config->reg_stride;
410 map->use_single_rw = config->use_single_rw;
413 map->bus_context = bus_context;
414 map->max_register = config->max_register;
415 map->wr_table = config->wr_table;
416 map->rd_table = config->rd_table;
417 map->volatile_table = config->volatile_table;
418 map->precious_table = config->precious_table;
419 map->writeable_reg = config->writeable_reg;
420 map->readable_reg = config->readable_reg;
421 map->volatile_reg = config->volatile_reg;
422 map->precious_reg = config->precious_reg;
423 map->cache_type = config->cache_type;
424 map->name = config->name;
426 if (config->read_flag_mask || config->write_flag_mask) {
427 map->read_flag_mask = config->read_flag_mask;
428 map->write_flag_mask = config->write_flag_mask;
430 map->read_flag_mask = bus->read_flag_mask;
433 reg_endian = config->reg_format_endian;
434 if (reg_endian == REGMAP_ENDIAN_DEFAULT)
435 reg_endian = bus->reg_format_endian_default;
436 if (reg_endian == REGMAP_ENDIAN_DEFAULT)
437 reg_endian = REGMAP_ENDIAN_BIG;
439 val_endian = config->val_format_endian;
440 if (val_endian == REGMAP_ENDIAN_DEFAULT)
441 val_endian = bus->val_format_endian_default;
442 if (val_endian == REGMAP_ENDIAN_DEFAULT)
443 val_endian = REGMAP_ENDIAN_BIG;
445 switch (config->reg_bits + map->reg_shift) {
447 switch (config->val_bits) {
449 map->format.format_write = regmap_format_2_6_write;
457 switch (config->val_bits) {
459 map->format.format_write = regmap_format_4_12_write;
467 switch (config->val_bits) {
469 map->format.format_write = regmap_format_7_9_write;
477 switch (config->val_bits) {
479 map->format.format_write = regmap_format_10_14_write;
487 map->format.format_reg = regmap_format_8;
491 switch (reg_endian) {
492 case REGMAP_ENDIAN_BIG:
493 map->format.format_reg = regmap_format_16_be;
495 case REGMAP_ENDIAN_NATIVE:
496 map->format.format_reg = regmap_format_16_native;
504 if (reg_endian != REGMAP_ENDIAN_BIG)
506 map->format.format_reg = regmap_format_24;
510 switch (reg_endian) {
511 case REGMAP_ENDIAN_BIG:
512 map->format.format_reg = regmap_format_32_be;
514 case REGMAP_ENDIAN_NATIVE:
515 map->format.format_reg = regmap_format_32_native;
526 switch (config->val_bits) {
528 map->format.format_val = regmap_format_8;
529 map->format.parse_val = regmap_parse_8;
532 switch (val_endian) {
533 case REGMAP_ENDIAN_BIG:
534 map->format.format_val = regmap_format_16_be;
535 map->format.parse_val = regmap_parse_16_be;
537 case REGMAP_ENDIAN_NATIVE:
538 map->format.format_val = regmap_format_16_native;
539 map->format.parse_val = regmap_parse_16_native;
546 if (val_endian != REGMAP_ENDIAN_BIG)
548 map->format.format_val = regmap_format_24;
549 map->format.parse_val = regmap_parse_24;
552 switch (val_endian) {
553 case REGMAP_ENDIAN_BIG:
554 map->format.format_val = regmap_format_32_be;
555 map->format.parse_val = regmap_parse_32_be;
557 case REGMAP_ENDIAN_NATIVE:
558 map->format.format_val = regmap_format_32_native;
559 map->format.parse_val = regmap_parse_32_native;
567 if (map->format.format_write) {
568 if ((reg_endian != REGMAP_ENDIAN_BIG) ||
569 (val_endian != REGMAP_ENDIAN_BIG))
571 map->use_single_rw = true;
574 if (!map->format.format_write &&
575 !(map->format.format_reg && map->format.format_val))
578 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
579 if (map->work_buf == NULL) {
584 map->range_tree = RB_ROOT;
585 for (i = 0; i < config->num_ranges; i++) {
586 const struct regmap_range_cfg *range_cfg = &config->ranges[i];
587 struct regmap_range_node *new;
590 if (range_cfg->range_max < range_cfg->range_min) {
591 dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
592 range_cfg->range_max, range_cfg->range_min);
596 if (range_cfg->range_max > map->max_register) {
597 dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
598 range_cfg->range_max, map->max_register);
602 if (range_cfg->selector_reg > map->max_register) {
604 "Invalid range %d: selector out of map\n", i);
608 if (range_cfg->window_len == 0) {
609 dev_err(map->dev, "Invalid range %d: window_len 0\n",
614 /* Make sure, that this register range has no selector
615 or data window within its boundary */
616 for (j = 0; j < config->num_ranges; j++) {
617 unsigned sel_reg = config->ranges[j].selector_reg;
618 unsigned win_min = config->ranges[j].window_start;
619 unsigned win_max = win_min +
620 config->ranges[j].window_len - 1;
622 if (range_cfg->range_min <= sel_reg &&
623 sel_reg <= range_cfg->range_max) {
625 "Range %d: selector for %d in window\n",
630 if (!(win_max < range_cfg->range_min ||
631 win_min > range_cfg->range_max)) {
633 "Range %d: window for %d in window\n",
639 new = kzalloc(sizeof(*new), GFP_KERNEL);
646 new->name = range_cfg->name;
647 new->range_min = range_cfg->range_min;
648 new->range_max = range_cfg->range_max;
649 new->selector_reg = range_cfg->selector_reg;
650 new->selector_mask = range_cfg->selector_mask;
651 new->selector_shift = range_cfg->selector_shift;
652 new->window_start = range_cfg->window_start;
653 new->window_len = range_cfg->window_len;
655 if (_regmap_range_add(map, new) == false) {
656 dev_err(map->dev, "Failed to add range %d\n", i);
661 if (map->selector_work_buf == NULL) {
662 map->selector_work_buf =
663 kzalloc(map->format.buf_size, GFP_KERNEL);
664 if (map->selector_work_buf == NULL) {
671 ret = regcache_init(map, config);
675 regmap_debugfs_init(map, config->name);
677 /* Add a devres resource for dev_get_regmap() */
678 m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
689 regmap_debugfs_exit(map);
692 regmap_range_exit(map);
693 kfree(map->work_buf);
699 EXPORT_SYMBOL_GPL(regmap_init);
701 static void devm_regmap_release(struct device *dev, void *res)
703 regmap_exit(*(struct regmap **)res);
707 * devm_regmap_init(): Initialise managed register map
709 * @dev: Device that will be interacted with
710 * @bus: Bus-specific callbacks to use with device
711 * @bus_context: Data passed to bus-specific callbacks
712 * @config: Configuration for register map
714 * The return value will be an ERR_PTR() on error or a valid pointer
715 * to a struct regmap. This function should generally not be called
716 * directly, it should be called by bus-specific init functions. The
717 * map will be automatically freed by the device management code.
719 struct regmap *devm_regmap_init(struct device *dev,
720 const struct regmap_bus *bus,
722 const struct regmap_config *config)
724 struct regmap **ptr, *regmap;
726 ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
728 return ERR_PTR(-ENOMEM);
730 regmap = regmap_init(dev, bus, bus_context, config);
731 if (!IS_ERR(regmap)) {
733 devres_add(dev, ptr);
740 EXPORT_SYMBOL_GPL(devm_regmap_init);
743 * regmap_reinit_cache(): Reinitialise the current register cache
745 * @map: Register map to operate on.
746 * @config: New configuration. Only the cache data will be used.
748 * Discard any existing register cache for the map and initialize a
749 * new cache. This can be used to restore the cache to defaults or to
750 * update the cache configuration to reflect runtime discovery of the
753 * No explicit locking is done here, the user needs to ensure that
754 * this function will not race with other calls to regmap.
756 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
759 regmap_debugfs_exit(map);
761 map->max_register = config->max_register;
762 map->writeable_reg = config->writeable_reg;
763 map->readable_reg = config->readable_reg;
764 map->volatile_reg = config->volatile_reg;
765 map->precious_reg = config->precious_reg;
766 map->cache_type = config->cache_type;
768 regmap_debugfs_init(map, config->name);
770 map->cache_bypass = false;
771 map->cache_only = false;
773 return regcache_init(map, config);
775 EXPORT_SYMBOL_GPL(regmap_reinit_cache);
778 * regmap_exit(): Free a previously allocated register map
780 void regmap_exit(struct regmap *map)
783 regmap_debugfs_exit(map);
784 regmap_range_exit(map);
785 if (map->bus->free_context)
786 map->bus->free_context(map->bus_context);
787 kfree(map->work_buf);
790 EXPORT_SYMBOL_GPL(regmap_exit);
792 static int dev_get_regmap_match(struct device *dev, void *res, void *data)
794 struct regmap **r = res;
800 /* If the user didn't specify a name match any */
802 return (*r)->name == data;
808 * dev_get_regmap(): Obtain the regmap (if any) for a device
810 * @dev: Device to retrieve the map for
811 * @name: Optional name for the register map, usually NULL.
813 * Returns the regmap for the device if one is present, or NULL. If
814 * name is specified then it must match the name specified when
815 * registering the device, if it is NULL then the first regmap found
816 * will be used. Devices with multiple register maps are very rare,
817 * generic code should normally not need to specify a name.
819 struct regmap *dev_get_regmap(struct device *dev, const char *name)
821 struct regmap **r = devres_find(dev, dev_get_regmap_release,
822 dev_get_regmap_match, (void *)name);
828 EXPORT_SYMBOL_GPL(dev_get_regmap);
830 static int _regmap_select_page(struct regmap *map, unsigned int *reg,
831 struct regmap_range_node *range,
832 unsigned int val_num)
835 unsigned int win_offset;
836 unsigned int win_page;
840 win_offset = (*reg - range->range_min) % range->window_len;
841 win_page = (*reg - range->range_min) / range->window_len;
844 /* Bulk write shouldn't cross range boundary */
845 if (*reg + val_num - 1 > range->range_max)
848 /* ... or single page boundary */
849 if (val_num > range->window_len - win_offset)
853 /* It is possible to have selector register inside data window.
854 In that case, selector register is located on every page and
855 it needs no page switching, when accessed alone. */
857 range->window_start + win_offset != range->selector_reg) {
858 /* Use separate work_buf during page switching */
859 orig_work_buf = map->work_buf;
860 map->work_buf = map->selector_work_buf;
862 ret = _regmap_update_bits(map, range->selector_reg,
863 range->selector_mask,
864 win_page << range->selector_shift,
867 map->work_buf = orig_work_buf;
873 *reg = range->window_start + win_offset;
878 static int _regmap_raw_write(struct regmap *map, unsigned int reg,
879 const void *val, size_t val_len)
881 struct regmap_range_node *range;
882 u8 *u8 = map->work_buf;
888 /* Check for unwritable registers before we start */
889 if (map->writeable_reg)
890 for (i = 0; i < val_len / map->format.val_bytes; i++)
891 if (!map->writeable_reg(map->dev,
892 reg + (i * map->reg_stride)))
895 if (!map->cache_bypass && map->format.parse_val) {
897 int val_bytes = map->format.val_bytes;
898 for (i = 0; i < val_len / val_bytes; i++) {
899 memcpy(map->work_buf, val + (i * val_bytes), val_bytes);
900 ival = map->format.parse_val(map->work_buf);
901 ret = regcache_write(map, reg + (i * map->reg_stride),
905 "Error in caching of register: %x ret: %d\n",
910 if (map->cache_only) {
911 map->cache_dirty = true;
916 range = _regmap_range_lookup(map, reg);
918 int val_num = val_len / map->format.val_bytes;
919 int win_offset = (reg - range->range_min) % range->window_len;
920 int win_residue = range->window_len - win_offset;
922 /* If the write goes beyond the end of the window split it */
923 while (val_num > win_residue) {
924 dev_dbg(map->dev, "Writing window %d/%zu\n",
925 win_residue, val_len / map->format.val_bytes);
926 ret = _regmap_raw_write(map, reg, val, win_residue *
927 map->format.val_bytes);
932 val_num -= win_residue;
933 val += win_residue * map->format.val_bytes;
934 val_len -= win_residue * map->format.val_bytes;
936 win_offset = (reg - range->range_min) %
938 win_residue = range->window_len - win_offset;
941 ret = _regmap_select_page(map, ®, range, val_num);
946 map->format.format_reg(map->work_buf, reg, map->reg_shift);
948 u8[0] |= map->write_flag_mask;
950 trace_regmap_hw_write_start(map->dev, reg,
951 val_len / map->format.val_bytes);
953 /* If we're doing a single register write we can probably just
954 * send the work_buf directly, otherwise try to do a gather
957 if (val == (map->work_buf + map->format.pad_bytes +
958 map->format.reg_bytes))
959 ret = map->bus->write(map->bus_context, map->work_buf,
960 map->format.reg_bytes +
961 map->format.pad_bytes +
963 else if (map->bus->gather_write)
964 ret = map->bus->gather_write(map->bus_context, map->work_buf,
965 map->format.reg_bytes +
966 map->format.pad_bytes,
969 /* If that didn't work fall back on linearising by hand. */
970 if (ret == -ENOTSUPP) {
971 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
972 buf = kzalloc(len, GFP_KERNEL);
976 memcpy(buf, map->work_buf, map->format.reg_bytes);
977 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
979 ret = map->bus->write(map->bus_context, buf, len);
984 trace_regmap_hw_write_done(map->dev, reg,
985 val_len / map->format.val_bytes);
990 int _regmap_write(struct regmap *map, unsigned int reg,
993 struct regmap_range_node *range;
995 BUG_ON(!map->format.format_write && !map->format.format_val);
997 if (!map->cache_bypass && map->format.format_write) {
998 ret = regcache_write(map, reg, val);
1001 if (map->cache_only) {
1002 map->cache_dirty = true;
1008 if (strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
1009 dev_info(map->dev, "%x <= %x\n", reg, val);
1012 trace_regmap_reg_write(map->dev, reg, val);
1014 if (map->format.format_write) {
1015 range = _regmap_range_lookup(map, reg);
1017 ret = _regmap_select_page(map, ®, range, 1);
1022 map->format.format_write(map, reg, val);
1024 trace_regmap_hw_write_start(map->dev, reg, 1);
1026 ret = map->bus->write(map->bus_context, map->work_buf,
1027 map->format.buf_size);
1029 trace_regmap_hw_write_done(map->dev, reg, 1);
1033 map->format.format_val(map->work_buf + map->format.reg_bytes
1034 + map->format.pad_bytes, val, 0);
1035 return _regmap_raw_write(map, reg,
1037 map->format.reg_bytes +
1038 map->format.pad_bytes,
1039 map->format.val_bytes);
1044 * regmap_write(): Write a value to a single register
1046 * @map: Register map to write to
1047 * @reg: Register to write to
1048 * @val: Value to be written
1050 * A value of zero will be returned on success, a negative errno will
1051 * be returned in error cases.
1053 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1057 if (reg % map->reg_stride)
1060 map->lock(map->lock_arg);
1062 ret = _regmap_write(map, reg, val);
1064 map->unlock(map->lock_arg);
1068 EXPORT_SYMBOL_GPL(regmap_write);
1071 * regmap_raw_write(): Write raw values to one or more registers
1073 * @map: Register map to write to
1074 * @reg: Initial register to write to
1075 * @val: Block of data to be written, laid out for direct transmission to the
1077 * @val_len: Length of data pointed to by val.
1079 * This function is intended to be used for things like firmware
1080 * download where a large block of data needs to be transferred to the
1081 * device. No formatting will be done on the data provided.
1083 * A value of zero will be returned on success, a negative errno will
1084 * be returned in error cases.
1086 int regmap_raw_write(struct regmap *map, unsigned int reg,
1087 const void *val, size_t val_len)
1091 if (val_len % map->format.val_bytes)
1093 if (reg % map->reg_stride)
1096 map->lock(map->lock_arg);
1098 ret = _regmap_raw_write(map, reg, val, val_len);
1100 map->unlock(map->lock_arg);
1104 EXPORT_SYMBOL_GPL(regmap_raw_write);
1107 * regmap_bulk_write(): Write multiple registers to the device
1109 * @map: Register map to write to
1110 * @reg: First register to be write from
1111 * @val: Block of data to be written, in native register size for device
1112 * @val_count: Number of registers to write
1114 * This function is intended to be used for writing a large block of
1115 * data to the device either in single transfer or multiple transfer.
1117 * A value of zero will be returned on success, a negative errno will
1118 * be returned in error cases.
1120 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
1124 size_t val_bytes = map->format.val_bytes;
1127 if (!map->format.parse_val)
1129 if (reg % map->reg_stride)
1132 map->lock(map->lock_arg);
1134 /* No formatting is require if val_byte is 1 */
1135 if (val_bytes == 1) {
1138 wval = kmemdup(val, val_count * val_bytes, GFP_KERNEL);
1141 dev_err(map->dev, "Error in memory allocation\n");
1144 for (i = 0; i < val_count * val_bytes; i += val_bytes)
1145 map->format.parse_val(wval + i);
1148 * Some devices does not support bulk write, for
1149 * them we have a series of single write operations.
1151 if (map->use_single_rw) {
1152 for (i = 0; i < val_count; i++) {
1153 ret = regmap_raw_write(map,
1154 reg + (i * map->reg_stride),
1155 val + (i * val_bytes),
1161 ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count);
1168 map->unlock(map->lock_arg);
1171 EXPORT_SYMBOL_GPL(regmap_bulk_write);
1173 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
1174 unsigned int val_len)
1176 struct regmap_range_node *range;
1177 u8 *u8 = map->work_buf;
1180 range = _regmap_range_lookup(map, reg);
1182 ret = _regmap_select_page(map, ®, range,
1183 val_len / map->format.val_bytes);
1188 map->format.format_reg(map->work_buf, reg, map->reg_shift);
1191 * Some buses or devices flag reads by setting the high bits in the
1192 * register addresss; since it's always the high bits for all
1193 * current formats we can do this here rather than in
1194 * formatting. This may break if we get interesting formats.
1196 u8[0] |= map->read_flag_mask;
1198 trace_regmap_hw_read_start(map->dev, reg,
1199 val_len / map->format.val_bytes);
1201 ret = map->bus->read(map->bus_context, map->work_buf,
1202 map->format.reg_bytes + map->format.pad_bytes,
1205 trace_regmap_hw_read_done(map->dev, reg,
1206 val_len / map->format.val_bytes);
1211 static int _regmap_read(struct regmap *map, unsigned int reg,
1216 if (!map->cache_bypass) {
1217 ret = regcache_read(map, reg, val);
1222 if (!map->format.parse_val)
1225 if (map->cache_only)
1228 ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
1230 *val = map->format.parse_val(map->work_buf);
1233 if (strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
1234 dev_info(map->dev, "%x => %x\n", reg, *val);
1237 trace_regmap_reg_read(map->dev, reg, *val);
1240 if (ret == 0 && !map->cache_bypass)
1241 regcache_write(map, reg, *val);
1247 * regmap_read(): Read a value from a single register
1249 * @map: Register map to write to
1250 * @reg: Register to be read from
1251 * @val: Pointer to store read value
1253 * A value of zero will be returned on success, a negative errno will
1254 * be returned in error cases.
1256 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
1260 if (reg % map->reg_stride)
1263 map->lock(map->lock_arg);
1265 ret = _regmap_read(map, reg, val);
1267 map->unlock(map->lock_arg);
1271 EXPORT_SYMBOL_GPL(regmap_read);
1274 * regmap_raw_read(): Read raw data from the device
1276 * @map: Register map to write to
1277 * @reg: First register to be read from
1278 * @val: Pointer to store read value
1279 * @val_len: Size of data to read
1281 * A value of zero will be returned on success, a negative errno will
1282 * be returned in error cases.
1284 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
1287 size_t val_bytes = map->format.val_bytes;
1288 size_t val_count = val_len / val_bytes;
1292 if (val_len % map->format.val_bytes)
1294 if (reg % map->reg_stride)
1297 map->lock(map->lock_arg);
1299 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
1300 map->cache_type == REGCACHE_NONE) {
1301 /* Physical block read if there's no cache involved */
1302 ret = _regmap_raw_read(map, reg, val, val_len);
1305 /* Otherwise go word by word for the cache; should be low
1306 * cost as we expect to hit the cache.
1308 for (i = 0; i < val_count; i++) {
1309 ret = _regmap_read(map, reg + (i * map->reg_stride),
1314 map->format.format_val(val + (i * val_bytes), v, 0);
1319 map->unlock(map->lock_arg);
1323 EXPORT_SYMBOL_GPL(regmap_raw_read);
1326 * regmap_bulk_read(): Read multiple registers from the device
1328 * @map: Register map to write to
1329 * @reg: First register to be read from
1330 * @val: Pointer to store read value, in native register size for device
1331 * @val_count: Number of registers to read
1333 * A value of zero will be returned on success, a negative errno will
1334 * be returned in error cases.
1336 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
1340 size_t val_bytes = map->format.val_bytes;
1341 bool vol = regmap_volatile_range(map, reg, val_count);
1343 if (!map->format.parse_val)
1345 if (reg % map->reg_stride)
1348 if (vol || map->cache_type == REGCACHE_NONE) {
1350 * Some devices does not support bulk read, for
1351 * them we have a series of single read operations.
1353 if (map->use_single_rw) {
1354 for (i = 0; i < val_count; i++) {
1355 ret = regmap_raw_read(map,
1356 reg + (i * map->reg_stride),
1357 val + (i * val_bytes),
1363 ret = regmap_raw_read(map, reg, val,
1364 val_bytes * val_count);
1369 for (i = 0; i < val_count * val_bytes; i += val_bytes)
1370 map->format.parse_val(val + i);
1372 for (i = 0; i < val_count; i++) {
1374 ret = regmap_read(map, reg + (i * map->reg_stride),
1378 memcpy(val + (i * val_bytes), &ival, val_bytes);
1384 EXPORT_SYMBOL_GPL(regmap_bulk_read);
1386 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
1387 unsigned int mask, unsigned int val,
1391 unsigned int tmp, orig;
1393 ret = _regmap_read(map, reg, &orig);
1401 ret = _regmap_write(map, reg, tmp);
1411 * regmap_update_bits: Perform a read/modify/write cycle on the register map
1413 * @map: Register map to update
1414 * @reg: Register to update
1415 * @mask: Bitmask to change
1416 * @val: New value for bitmask
1418 * Returns zero for success, a negative number on error.
1420 int regmap_update_bits(struct regmap *map, unsigned int reg,
1421 unsigned int mask, unsigned int val)
1426 map->lock(map->lock_arg);
1427 ret = _regmap_update_bits(map, reg, mask, val, &change);
1428 map->unlock(map->lock_arg);
1432 EXPORT_SYMBOL_GPL(regmap_update_bits);
1435 * regmap_update_bits_check: Perform a read/modify/write cycle on the
1436 * register map and report if updated
1438 * @map: Register map to update
1439 * @reg: Register to update
1440 * @mask: Bitmask to change
1441 * @val: New value for bitmask
1442 * @change: Boolean indicating if a write was done
1444 * Returns zero for success, a negative number on error.
1446 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
1447 unsigned int mask, unsigned int val,
1452 map->lock(map->lock_arg);
1453 ret = _regmap_update_bits(map, reg, mask, val, change);
1454 map->unlock(map->lock_arg);
1457 EXPORT_SYMBOL_GPL(regmap_update_bits_check);
1460 * regmap_register_patch: Register and apply register updates to be applied
1461 * on device initialistion
1463 * @map: Register map to apply updates to.
1464 * @regs: Values to update.
1465 * @num_regs: Number of entries in regs.
1467 * Register a set of register updates to be applied to the device
1468 * whenever the device registers are synchronised with the cache and
1469 * apply them immediately. Typically this is used to apply
1470 * corrections to be applied to the device defaults on startup, such
1471 * as the updates some vendors provide to undocumented registers.
1473 int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
1479 /* If needed the implementation can be extended to support this */
1483 map->lock(map->lock_arg);
1485 bypass = map->cache_bypass;
1487 map->cache_bypass = true;
1489 /* Write out first; it's useful to apply even if we fail later. */
1490 for (i = 0; i < num_regs; i++) {
1491 ret = _regmap_write(map, regs[i].reg, regs[i].def);
1493 dev_err(map->dev, "Failed to write %x = %x: %d\n",
1494 regs[i].reg, regs[i].def, ret);
1499 map->patch = kcalloc(num_regs, sizeof(struct reg_default), GFP_KERNEL);
1500 if (map->patch != NULL) {
1501 memcpy(map->patch, regs,
1502 num_regs * sizeof(struct reg_default));
1503 map->patch_regs = num_regs;
1509 map->cache_bypass = bypass;
1511 map->unlock(map->lock_arg);
1515 EXPORT_SYMBOL_GPL(regmap_register_patch);
1518 * regmap_get_val_bytes(): Report the size of a register value
1520 * Report the size of a register value, mainly intended to for use by
1521 * generic infrastructure built on top of regmap.
1523 int regmap_get_val_bytes(struct regmap *map)
1525 if (map->format.format_write)
1528 return map->format.val_bytes;
1530 EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
1532 static int __init regmap_initcall(void)
1534 regmap_debugfs_initcall();
1538 postcore_initcall(regmap_initcall);