Lines Matching refs:map
3 // Register map access API
36 static inline bool regmap_should_log(struct regmap *map)
38 return (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0);
41 static inline bool regmap_should_log(struct regmap *map) { return false; }
45 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
74 bool regmap_check_range_table(struct regmap *map, unsigned int reg,
90 bool regmap_writeable(struct regmap *map, unsigned int reg)
92 if (map->max_register && reg > map->max_register)
95 if (map->writeable_reg)
96 return map->writeable_reg(map->dev, reg);
98 if (map->wr_table)
99 return regmap_check_range_table(map, reg, map->wr_table);
104 bool regmap_cached(struct regmap *map, unsigned int reg)
109 if (map->cache_type == REGCACHE_NONE)
112 if (!map->cache_ops)
115 if (map->max_register && reg > map->max_register)
118 map->lock(map->lock_arg);
119 ret = regcache_read(map, reg, &val);
120 map->unlock(map->lock_arg);
127 bool regmap_readable(struct regmap *map, unsigned int reg)
129 if (!map->reg_read)
132 if (map->max_register && reg > map->max_register)
135 if (map->format.format_write)
138 if (map->readable_reg)
139 return map->readable_reg(map->dev, reg);
141 if (map->rd_table)
142 return regmap_check_range_table(map, reg, map->rd_table);
147 bool regmap_volatile(struct regmap *map, unsigned int reg)
149 if (!map->format.format_write && !regmap_readable(map, reg))
152 if (map->volatile_reg)
153 return map->volatile_reg(map->dev, reg);
155 if (map->volatile_table)
156 return regmap_check_range_table(map, reg, map->volatile_table);
158 if (map->cache_ops)
164 bool regmap_precious(struct regmap *map, unsigned int reg)
166 if (!regmap_readable(map, reg))
169 if (map->precious_reg)
170 return map->precious_reg(map->dev, reg);
172 if (map->precious_table)
173 return regmap_check_range_table(map, reg, map->precious_table);
178 bool regmap_writeable_noinc(struct regmap *map, unsigned int reg)
180 if (map->writeable_noinc_reg)
181 return map->writeable_noinc_reg(map->dev, reg);
183 if (map->wr_noinc_table)
184 return regmap_check_range_table(map, reg, map->wr_noinc_table);
189 bool regmap_readable_noinc(struct regmap *map, unsigned int reg)
191 if (map->readable_noinc_reg)
192 return map->readable_noinc_reg(map->dev, reg);
194 if (map->rd_noinc_table)
195 return regmap_check_range_table(map, reg, map->rd_noinc_table);
200 static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
206 if (!regmap_volatile(map, reg + regmap_get_offset(map, i)))
212 static void regmap_format_12_20_write(struct regmap *map,
215 u8 *out = map->work_buf;
224 static void regmap_format_2_6_write(struct regmap *map,
227 u8 *out = map->work_buf;
232 static void regmap_format_4_12_write(struct regmap *map,
235 __be16 *out = map->work_buf;
239 static void regmap_format_7_9_write(struct regmap *map,
242 __be16 *out = map->work_buf;
246 static void regmap_format_7_17_write(struct regmap *map,
249 u8 *out = map->work_buf;
256 static void regmap_format_10_14_write(struct regmap *map,
259 u8 *out = map->work_buf;
396 struct regmap *map = __map;
398 hwspin_lock_timeout(map->hwlock, UINT_MAX);
403 struct regmap *map = __map;
405 hwspin_lock_timeout_irq(map->hwlock, UINT_MAX);
410 struct regmap *map = __map;
412 hwspin_lock_timeout_irqsave(map->hwlock, UINT_MAX,
413 &map->spinlock_flags);
418 struct regmap *map = __map;
420 hwspin_unlock(map->hwlock);
425 struct regmap *map = __map;
427 hwspin_unlock_irq(map->hwlock);
432 struct regmap *map = __map;
434 hwspin_unlock_irqrestore(map->hwlock, &map->spinlock_flags);
444 struct regmap *map = __map;
445 mutex_lock(&map->mutex);
450 struct regmap *map = __map;
451 mutex_unlock(&map->mutex);
455 __acquires(&map->spinlock)
457 struct regmap *map = __map;
460 spin_lock_irqsave(&map->spinlock, flags);
461 map->spinlock_flags = flags;
465 __releases(&map->spinlock)
467 struct regmap *map = __map;
468 spin_unlock_irqrestore(&map->spinlock, map->spinlock_flags);
472 __acquires(&map->raw_spinlock)
474 struct regmap *map = __map;
477 raw_spin_lock_irqsave(&map->raw_spinlock, flags);
478 map->raw_spinlock_flags = flags;
482 __releases(&map->raw_spinlock)
484 struct regmap *map = __map;
485 raw_spin_unlock_irqrestore(&map->raw_spinlock, map->raw_spinlock_flags);
497 static bool _regmap_range_add(struct regmap *map,
500 struct rb_root *root = &map->range_tree;
522 static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
525 struct rb_node *node = map->range_tree.rb_node;
542 static void regmap_range_exit(struct regmap *map)
547 next = rb_first(&map->range_tree);
551 rb_erase(&range_node->node, &map->range_tree);
555 kfree(map->selector_work_buf);
558 static int regmap_set_name(struct regmap *map, const struct regmap_config *config)
566 kfree_const(map->name);
567 map->name = name;
573 int regmap_attach_dev(struct device *dev, struct regmap *map,
579 map->dev = dev;
581 ret = regmap_set_name(map, config);
585 regmap_debugfs_exit(map);
586 regmap_debugfs_init(map);
591 regmap_debugfs_exit(map);
594 *m = map;
671 struct regmap *map;
679 map = kzalloc(sizeof(*map), GFP_KERNEL);
680 if (map == NULL) {
685 ret = regmap_set_name(map, config);
692 map->lock = map->unlock = regmap_lock_unlock_none;
693 map->can_sleep = config->can_sleep;
694 regmap_debugfs_disable(map);
696 map->lock = config->lock;
697 map->unlock = config->unlock;
698 map->lock_arg = config->lock_arg;
699 map->can_sleep = config->can_sleep;
701 map->hwlock = hwspin_lock_request_specific(config->hwlock_id);
702 if (!map->hwlock) {
709 map->lock = regmap_lock_hwlock_irqsave;
710 map->unlock = regmap_unlock_hwlock_irqrestore;
713 map->lock = regmap_lock_hwlock_irq;
714 map->unlock = regmap_unlock_hwlock_irq;
717 map->lock = regmap_lock_hwlock;
718 map->unlock = regmap_unlock_hwlock;
722 map->lock_arg = map;
727 raw_spin_lock_init(&map->raw_spinlock);
728 map->lock = regmap_lock_raw_spinlock;
729 map->unlock = regmap_unlock_raw_spinlock;
730 lockdep_set_class_and_name(&map->raw_spinlock,
733 spin_lock_init(&map->spinlock);
734 map->lock = regmap_lock_spinlock;
735 map->unlock = regmap_unlock_spinlock;
736 lockdep_set_class_and_name(&map->spinlock,
740 mutex_init(&map->mutex);
741 map->lock = regmap_lock_mutex;
742 map->unlock = regmap_unlock_mutex;
743 map->can_sleep = true;
744 lockdep_set_class_and_name(&map->mutex,
747 map->lock_arg = map;
755 map->alloc_flags = GFP_ATOMIC;
757 map->alloc_flags = GFP_KERNEL;
759 map->reg_base = config->reg_base;
761 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
762 map->format.pad_bytes = config->pad_bits / 8;
763 map->format.reg_shift = config->reg_shift;
764 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
765 map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
767 map->reg_shift = config->pad_bits % 8;
769 map->reg_stride = config->reg_stride;
771 map->reg_stride = 1;
772 if (is_power_of_2(map->reg_stride))
773 map->reg_stride_order = ilog2(map->reg_stride);
775 map->reg_stride_order = -1;
776 map->use_single_read = config->use_single_read || !(config->read || (bus && bus->read));
777 map->use_single_write = config->use_single_write || !(config->write || (bus && bus->write));
778 map->can_multi_write = config->can_multi_write && (config->write || (bus && bus->write));
780 map->max_raw_read = bus->max_raw_read;
781 map->max_raw_write = bus->max_raw_write;
783 map->max_raw_read = config->max_raw_read;
784 map->max_raw_write = config->max_raw_write;
786 map->dev = dev;
787 map->bus = bus;
788 map->bus_context = bus_context;
789 map->max_register = config->max_register;
790 map->wr_table = config->wr_table;
791 map->rd_table = config->rd_table;
792 map->volatile_table = config->volatile_table;
793 map->precious_table = config->precious_table;
794 map->wr_noinc_table = config->wr_noinc_table;
795 map->rd_noinc_table = config->rd_noinc_table;
796 map->writeable_reg = config->writeable_reg;
797 map->readable_reg = config->readable_reg;
798 map->volatile_reg = config->volatile_reg;
799 map->precious_reg = config->precious_reg;
800 map->writeable_noinc_reg = config->writeable_noinc_reg;
801 map->readable_noinc_reg = config->readable_noinc_reg;
802 map->cache_type = config->cache_type;
804 spin_lock_init(&map->async_lock);
805 INIT_LIST_HEAD(&map->async_list);
806 INIT_LIST_HEAD(&map->async_free);
807 init_waitqueue_head(&map->async_waitq);
812 map->read_flag_mask = config->read_flag_mask;
813 map->write_flag_mask = config->write_flag_mask;
815 map->read_flag_mask = bus->read_flag_mask;
819 map->reg_read = _regmap_bus_read;
821 map->reg_update_bits = config->reg_update_bits;
824 map->read = config->read;
825 map->write = config->write;
830 map->reg_read = config->reg_read;
831 map->reg_write = config->reg_write;
832 map->reg_update_bits = config->reg_update_bits;
834 map->defer_caching = false;
837 map->reg_read = _regmap_bus_reg_read;
838 map->reg_write = _regmap_bus_reg_write;
839 map->reg_update_bits = bus->reg_update_bits;
841 map->defer_caching = false;
844 map->reg_read = _regmap_bus_read;
845 map->reg_update_bits = bus->reg_update_bits;
847 map->read = bus->read;
848 map->write = bus->write;
854 switch (config->reg_bits + map->reg_shift) {
858 map->format.format_write = regmap_format_2_6_write;
868 map->format.format_write = regmap_format_4_12_write;
878 map->format.format_write = regmap_format_7_9_write;
881 map->format.format_write = regmap_format_7_17_write;
891 map->format.format_write = regmap_format_10_14_write;
901 map->format.format_write = regmap_format_12_20_write;
909 map->format.format_reg = regmap_format_8;
915 map->format.format_reg = regmap_format_16_be;
918 map->format.format_reg = regmap_format_16_le;
921 map->format.format_reg = regmap_format_16_native;
931 map->format.format_reg = regmap_format_24_be;
941 map->format.format_reg = regmap_format_32_be;
944 map->format.format_reg = regmap_format_32_le;
947 map->format.format_reg = regmap_format_32_native;
959 map->format.parse_inplace = regmap_parse_inplace_noop;
963 map->format.format_val = regmap_format_8;
964 map->format.parse_val = regmap_parse_8;
965 map->format.parse_inplace = regmap_parse_inplace_noop;
970 map->format.format_val = regmap_format_16_be;
971 map->format.parse_val = regmap_parse_16_be;
972 map->format.parse_inplace = regmap_parse_16_be_inplace;
975 map->format.format_val = regmap_format_16_le;
976 map->format.parse_val = regmap_parse_16_le;
977 map->format.parse_inplace = regmap_parse_16_le_inplace;
980 map->format.format_val = regmap_format_16_native;
981 map->format.parse_val = regmap_parse_16_native;
990 map->format.format_val = regmap_format_24_be;
991 map->format.parse_val = regmap_parse_24_be;
1000 map->format.format_val = regmap_format_32_be;
1001 map->format.parse_val = regmap_parse_32_be;
1002 map->format.parse_inplace = regmap_parse_32_be_inplace;
1005 map->format.format_val = regmap_format_32_le;
1006 map->format.parse_val = regmap_parse_32_le;
1007 map->format.parse_inplace = regmap_parse_32_le_inplace;
1010 map->format.format_val = regmap_format_32_native;
1011 map->format.parse_val = regmap_parse_32_native;
1019 if (map->format.format_write) {
1023 map->use_single_write = true;
1026 if (!map->format.format_write &&
1027 !(map->format.format_reg && map->format.format_val))
1030 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
1031 if (map->work_buf == NULL) {
1036 if (map->format.format_write) {
1037 map->defer_caching = false;
1038 map->reg_write = _regmap_bus_formatted_write;
1039 } else if (map->format.format_val) {
1040 map->defer_caching = true;
1041 map->reg_write = _regmap_bus_raw_write;
1046 map->range_tree = RB_ROOT;
1053 dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
1058 if (range_cfg->range_max > map->max_register) {
1059 dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
1060 range_cfg->range_max, map->max_register);
1064 if (range_cfg->selector_reg > map->max_register) {
1065 dev_err(map->dev,
1066 "Invalid range %d: selector out of map\n", i);
1071 dev_err(map->dev, "Invalid range %d: window_len 0\n",
1090 dev_err(map->dev,
1098 dev_err(map->dev,
1111 new->map = map;
1121 if (!_regmap_range_add(map, new)) {
1122 dev_err(map->dev, "Failed to add range %d\n", i);
1127 if (map->selector_work_buf == NULL) {
1128 map->selector_work_buf =
1129 kzalloc(map->format.buf_size, GFP_KERNEL);
1130 if (map->selector_work_buf == NULL) {
1137 ret = regcache_init(map, config);
1142 ret = regmap_attach_dev(dev, map, config);
1146 regmap_debugfs_init(map);
1149 return map;
1152 regcache_exit(map);
1154 regmap_range_exit(map);
1155 kfree(map->work_buf);
1157 if (map->hwlock)
1158 hwspin_lock_free(map->hwlock);
1160 kfree_const(map->name);
1162 kfree(map);
1396 * @map: Register map to operate on.
1399 * Discard any existing register cache for the map and initialize a
1407 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
1411 regcache_exit(map);
1412 regmap_debugfs_exit(map);
1414 map->max_register = config->max_register;
1415 map->writeable_reg = config->writeable_reg;
1416 map->readable_reg = config->readable_reg;
1417 map->volatile_reg = config->volatile_reg;
1418 map->precious_reg = config->precious_reg;
1419 map->writeable_noinc_reg = config->writeable_noinc_reg;
1420 map->readable_noinc_reg = config->readable_noinc_reg;
1421 map->cache_type = config->cache_type;
1423 ret = regmap_set_name(map, config);
1427 regmap_debugfs_init(map);
1429 map->cache_bypass = false;
1430 map->cache_only = false;
1432 return regcache_init(map, config);
1437 * regmap_exit() - Free a previously allocated register map
1439 * @map: Register map to operate on.
1441 void regmap_exit(struct regmap *map)
1445 regcache_exit(map);
1446 regmap_debugfs_exit(map);
1447 regmap_range_exit(map);
1448 if (map->bus && map->bus->free_context)
1449 map->bus->free_context(map->bus_context);
1450 kfree(map->work_buf);
1451 while (!list_empty(&map->async_free)) {
1452 async = list_first_entry_or_null(&map->async_free,
1459 if (map->hwlock)
1460 hwspin_lock_free(map->hwlock);
1461 if (map->lock == regmap_lock_mutex)
1462 mutex_destroy(&map->mutex);
1463 kfree_const(map->name);
1464 kfree(map->patch);
1465 if (map->bus && map->bus->free_on_exit)
1466 kfree(map->bus);
1467 kfree(map);
1489 * @dev: Device to retrieve the map for
1490 * @name: Optional name for the register map, usually NULL.
1512 * @map: Register map to operate on.
1516 struct device *regmap_get_device(struct regmap *map)
1518 return map->dev;
1522 static int _regmap_select_page(struct regmap *map, unsigned int *reg,
1551 orig_work_buf = map->work_buf;
1552 map->work_buf = map->selector_work_buf;
1554 ret = _regmap_update_bits(map, range->selector_reg,
1559 map->work_buf = orig_work_buf;
1570 static void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
1576 if (!mask || !map->work_buf)
1579 buf = map->work_buf;
1585 static unsigned int regmap_reg_addr(struct regmap *map, unsigned int reg)
1587 reg += map->reg_base;
1589 if (map->format.reg_shift > 0)
1590 reg >>= map->format.reg_shift;
1591 else if (map->format.reg_shift < 0)
1592 reg <<= -(map->format.reg_shift);
1597 static int _regmap_raw_write_impl(struct regmap *map, unsigned int reg,
1602 void *work_val = map->work_buf + map->format.reg_bytes +
1603 map->format.pad_bytes;
1612 if (!regmap_writeable_noinc(map, reg)) {
1613 for (i = 0; i < val_len / map->format.val_bytes; i++) {
1615 reg + regmap_get_offset(map, i);
1616 if (!regmap_writeable(map, element) ||
1617 regmap_writeable_noinc(map, element))
1622 if (!map->cache_bypass && map->format.parse_val) {
1624 int val_bytes = map->format.val_bytes;
1629 ival = map->format.parse_val(val + i);
1630 offset = noinc ? 0 : regmap_get_offset(map, i / val_bytes);
1631 ret = regcache_write(map, reg + offset, ival);
1633 dev_err(map->dev,
1639 if (map->cache_only) {
1640 map->cache_dirty = true;
1645 range = _regmap_range_lookup(map, reg);
1647 int val_num = val_len / map->format.val_bytes;
1653 dev_dbg(map->dev, "Writing window %d/%zu\n",
1654 win_residue, val_len / map->format.val_bytes);
1655 ret = _regmap_raw_write_impl(map, reg, val,
1657 map->format.val_bytes, noinc);
1663 val += win_residue * map->format.val_bytes;
1664 val_len -= win_residue * map->format.val_bytes;
1671 ret = _regmap_select_page(map, ®, range, noinc ? 1 : val_num);
1676 reg = regmap_reg_addr(map, reg);
1677 map->format.format_reg(map->work_buf, reg, map->reg_shift);
1678 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
1679 map->write_flag_mask);
1686 if (val != work_val && val_len == map->format.val_bytes) {
1687 memcpy(work_val, val, map->format.val_bytes);
1691 if (map->async && map->bus && map->bus->async_write) {
1694 trace_regmap_async_write_start(map, reg, val_len);
1696 spin_lock_irqsave(&map->async_lock, flags);
1697 async = list_first_entry_or_null(&map->async_free,
1702 spin_unlock_irqrestore(&map->async_lock, flags);
1705 async = map->bus->async_alloc();
1709 async->work_buf = kzalloc(map->format.buf_size,
1717 async->map = map;
1720 memcpy(async->work_buf, map->work_buf, map->format.pad_bytes +
1721 map->format.reg_bytes + map->format.val_bytes);
1723 spin_lock_irqsave(&map->async_lock, flags);
1724 list_add_tail(&async->list, &map->async_list);
1725 spin_unlock_irqrestore(&map->async_lock, flags);
1728 ret = map->bus->async_write(map->bus_context,
1730 map->format.reg_bytes +
1731 map->format.pad_bytes,
1734 ret = map->bus->async_write(map->bus_context,
1736 map->format.reg_bytes +
1737 map->format.pad_bytes +
1741 dev_err(map->dev, "Failed to schedule write: %d\n",
1744 spin_lock_irqsave(&map->async_lock, flags);
1745 list_move(&async->list, &map->async_free);
1746 spin_unlock_irqrestore(&map->async_lock, flags);
1752 trace_regmap_hw_write_start(map, reg, val_len / map->format.val_bytes);
1759 ret = map->write(map->bus_context, map->work_buf,
1760 map->format.reg_bytes +
1761 map->format.pad_bytes +
1763 else if (map->bus && map->bus->gather_write)
1764 ret = map->bus->gather_write(map->bus_context, map->work_buf,
1765 map->format.reg_bytes +
1766 map->format.pad_bytes,
1773 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
1778 memcpy(buf, map->work_buf, map->format.reg_bytes);
1779 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
1781 ret = map->write(map->bus_context, buf, len);
1784 } else if (ret != 0 && !map->cache_bypass && map->format.parse_val) {
1786 * thus call map->cache_ops->drop() directly
1788 if (map->cache_ops && map->cache_ops->drop)
1789 map->cache_ops->drop(map, reg, reg + 1);
1792 trace_regmap_hw_write_done(map, reg, val_len / map->format.val_bytes);
1800 * @map: Map to check.
1802 bool regmap_can_raw_write(struct regmap *map)
1804 return map->write && map->format.format_val && map->format.format_reg;
1811 * @map: Map to check.
1813 size_t regmap_get_raw_read_max(struct regmap *map)
1815 return map->max_raw_read;
1822 * @map: Map to check.
1824 size_t regmap_get_raw_write_max(struct regmap *map)
1826 return map->max_raw_write;
1835 struct regmap *map = context;
1837 WARN_ON(!map->format.format_write);
1839 range = _regmap_range_lookup(map, reg);
1841 ret = _regmap_select_page(map, ®, range, 1);
1846 reg = regmap_reg_addr(map, reg);
1847 map->format.format_write(map, reg, val);
1849 trace_regmap_hw_write_start(map, reg, 1);
1851 ret = map->write(map->bus_context, map->work_buf, map->format.buf_size);
1853 trace_regmap_hw_write_done(map, reg, 1);
1861 struct regmap *map = context;
1865 range = _regmap_range_lookup(map, reg);
1867 ret = _regmap_select_page(map, ®, range, 1);
1872 reg = regmap_reg_addr(map, reg);
1873 return map->bus->reg_write(map->bus_context, reg, val);
1879 struct regmap *map = context;
1881 WARN_ON(!map->format.format_val);
1883 map->format.format_val(map->work_buf + map->format.reg_bytes
1884 + map->format.pad_bytes, val, 0);
1885 return _regmap_raw_write_impl(map, reg,
1886 map->work_buf +
1887 map->format.reg_bytes +
1888 map->format.pad_bytes,
1889 map->format.val_bytes,
1893 static inline void *_regmap_map_get_context(struct regmap *map)
1895 return (map->bus || (!map->bus && map->read)) ? map : map->bus_context;
1898 int _regmap_write(struct regmap *map, unsigned int reg,
1902 void *context = _regmap_map_get_context(map);
1904 if (!regmap_writeable(map, reg))
1907 if (!map->cache_bypass && !map->defer_caching) {
1908 ret = regcache_write(map, reg, val);
1911 if (map->cache_only) {
1912 map->cache_dirty = true;
1917 ret = map->reg_write(context, reg, val);
1919 if (regmap_should_log(map))
1920 dev_info(map->dev, "%x <= %x\n", reg, val);
1922 trace_regmap_reg_write(map, reg, val);
1931 * @map: Register map to write to
1938 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1942 if (!IS_ALIGNED(reg, map->reg_stride))
1945 map->lock(map->lock_arg);
1947 ret = _regmap_write(map, reg, val);
1949 map->unlock(map->lock_arg);
1958 * @map: Register map to write to
1965 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val)
1969 if (!IS_ALIGNED(reg, map->reg_stride))
1972 map->lock(map->lock_arg);
1974 map->async = true;
1976 ret = _regmap_write(map, reg, val);
1978 map->async = false;
1980 map->unlock(map->lock_arg);
1986 int _regmap_raw_write(struct regmap *map, unsigned int reg,
1989 size_t val_bytes = map->format.val_bytes;
1998 if (map->use_single_write)
2000 else if (map->max_raw_write && val_len > map->max_raw_write)
2001 chunk_regs = map->max_raw_write / val_bytes;
2008 ret = _regmap_raw_write_impl(map, reg, val, chunk_bytes, noinc);
2012 reg += regmap_get_offset(map, chunk_regs);
2019 ret = _regmap_raw_write_impl(map, reg, val, val_len, noinc);
2027 * @map: Register map to write to
2040 int regmap_raw_write(struct regmap *map, unsigned int reg,
2045 if (!regmap_can_raw_write(map))
2047 if (val_len % map->format.val_bytes)
2050 map->lock(map->lock_arg);
2052 ret = _regmap_raw_write(map, reg, val, val_len, false);
2054 map->unlock(map->lock_arg);
2060 static int regmap_noinc_readwrite(struct regmap *map, unsigned int reg,
2063 size_t val_bytes = map->format.val_bytes;
2098 if (!map->cache_bypass && !map->defer_caching) {
2099 ret = regcache_write(map, reg, lastval);
2102 if (map->cache_only) {
2103 map->cache_dirty = true;
2107 ret = map->bus->reg_noinc_write(map->bus_context, reg, val, val_count);
2109 ret = map->bus->reg_noinc_read(map->bus_context, reg, val, val_count);
2112 if (!ret && regmap_should_log(map)) {
2113 dev_info(map->dev, "%x %s [", reg, write ? "<=" : "=>");
2142 * @map: Register map to write to
2159 int regmap_noinc_write(struct regmap *map, unsigned int reg,
2165 if (!map->write && !(map->bus && map->bus->reg_noinc_write))
2167 if (val_len % map->format.val_bytes)
2169 if (!IS_ALIGNED(reg, map->reg_stride))
2174 map->lock(map->lock_arg);
2176 if (!regmap_volatile(map, reg) || !regmap_writeable_noinc(map, reg)) {
2185 if (map->bus->reg_noinc_write) {
2186 ret = regmap_noinc_readwrite(map, reg, (void *)val, val_len, true);
2191 if (map->max_raw_write && map->max_raw_write < val_len)
2192 write_len = map->max_raw_write;
2195 ret = _regmap_raw_write(map, reg, val, write_len, true);
2203 map->unlock(map->lock_arg);
2293 * @map: Register map to write to
2304 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
2308 size_t val_bytes = map->format.val_bytes;
2310 if (!IS_ALIGNED(reg, map->reg_stride))
2317 if (!map->write || !map->format.parse_inplace) {
2318 map->lock(map->lock_arg);
2337 ret = _regmap_write(map,
2338 reg + regmap_get_offset(map, i),
2344 map->unlock(map->lock_arg);
2348 wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
2353 map->format.parse_inplace(wval + i);
2355 ret = regmap_raw_write(map, reg, wval, val_bytes * val_count);
2361 trace_regmap_bulk_write(map, reg, val, val_bytes * val_count);
2374 static int _regmap_raw_multi_reg_write(struct regmap *map,
2382 size_t val_bytes = map->format.val_bytes;
2383 size_t reg_bytes = map->format.reg_bytes;
2384 size_t pad_bytes = map->format.pad_bytes;
2402 trace_regmap_hw_write_start(map, reg, 1);
2403 reg = regmap_reg_addr(map, reg);
2404 map->format.format_reg(u8, reg, map->reg_shift);
2406 map->format.format_val(u8, val, 0);
2410 *u8 |= map->write_flag_mask;
2412 ret = map->write(map->bus_context, buf, len);
2418 trace_regmap_hw_write_done(map, reg, 1);
2423 static unsigned int _regmap_register_page(struct regmap *map,
2432 static int _regmap_range_multi_paged_reg_write(struct regmap *map,
2452 range = _regmap_range_lookup(map, reg);
2454 unsigned int win_page = _regmap_register_page(map, reg,
2481 ret = _regmap_raw_multi_reg_write(map, base, n);
2486 if (map->can_sleep)
2496 ret = _regmap_select_page(map,
2509 return _regmap_raw_multi_reg_write(map, base, n);
2513 static int _regmap_multi_reg_write(struct regmap *map,
2520 if (!map->can_multi_write) {
2522 ret = _regmap_write(map, regs[i].reg, regs[i].def);
2527 if (map->can_sleep)
2536 if (!map->format.parse_inplace)
2539 if (map->writeable_reg)
2542 if (!map->writeable_reg(map->dev, reg))
2544 if (!IS_ALIGNED(reg, map->reg_stride))
2548 if (!map->cache_bypass) {
2552 ret = regcache_write(map, reg, val);
2554 dev_err(map->dev,
2560 if (map->cache_only) {
2561 map->cache_dirty = true;
2566 WARN_ON(!map->bus);
2575 range = _regmap_range_lookup(map, reg);
2582 ret = _regmap_range_multi_paged_reg_write(map, base,
2589 return _regmap_raw_multi_reg_write(map, regs, num_regs);
2595 * @map: Register map to write to
2611 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
2616 map->lock(map->lock_arg);
2618 ret = _regmap_multi_reg_write(map, regs, num_regs);
2620 map->unlock(map->lock_arg);
2630 * @map: Register map to write to
2644 int regmap_multi_reg_write_bypassed(struct regmap *map,
2651 map->lock(map->lock_arg);
2653 bypass = map->cache_bypass;
2654 map->cache_bypass = true;
2656 ret = _regmap_multi_reg_write(map, regs, num_regs);
2658 map->cache_bypass = bypass;
2660 map->unlock(map->lock_arg);
2670 * @map: Register map to write to
2688 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
2693 if (val_len % map->format.val_bytes)
2695 if (!IS_ALIGNED(reg, map->reg_stride))
2698 map->lock(map->lock_arg);
2700 map->async = true;
2702 ret = _regmap_raw_write(map, reg, val, val_len, false);
2704 map->async = false;
2706 map->unlock(map->lock_arg);
2712 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2718 if (!map->read)
2721 range = _regmap_range_lookup(map, reg);
2723 ret = _regmap_select_page(map, ®, range,
2724 noinc ? 1 : val_len / map->format.val_bytes);
2729 reg = regmap_reg_addr(map, reg);
2730 map->format.format_reg(map->work_buf, reg, map->reg_shift);
2731 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
2732 map->read_flag_mask);
2733 trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
2735 ret = map->read(map->bus_context, map->work_buf,
2736 map->format.reg_bytes + map->format.pad_bytes,
2739 trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
2747 struct regmap *map = context;
2751 range = _regmap_range_lookup(map, reg);
2753 ret = _regmap_select_page(map, ®, range, 1);
2758 reg = regmap_reg_addr(map, reg);
2759 return map->bus->reg_read(map->bus_context, reg, val);
2766 struct regmap *map = context;
2767 void *work_val = map->work_buf + map->format.reg_bytes +
2768 map->format.pad_bytes;
2770 if (!map->format.parse_val)
2773 ret = _regmap_raw_read(map, reg, work_val, map->format.val_bytes, false);
2775 *val = map->format.parse_val(work_val);
2780 static int _regmap_read(struct regmap *map, unsigned int reg,
2784 void *context = _regmap_map_get_context(map);
2786 if (!map->cache_bypass) {
2787 ret = regcache_read(map, reg, val);
2792 if (map->cache_only)
2795 if (!regmap_readable(map, reg))
2798 ret = map->reg_read(context, reg, val);
2800 if (regmap_should_log(map))
2801 dev_info(map->dev, "%x => %x\n", reg, *val);
2803 trace_regmap_reg_read(map, reg, *val);
2805 if (!map->cache_bypass)
2806 regcache_write(map, reg, *val);
2815 * @map: Register map to read from
2822 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
2826 if (!IS_ALIGNED(reg, map->reg_stride))
2829 map->lock(map->lock_arg);
2831 ret = _regmap_read(map, reg, val);
2833 map->unlock(map->lock_arg);
2842 * @map: Register map to read from
2850 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2853 size_t val_bytes = map->format.val_bytes;
2858 if (val_len % map->format.val_bytes)
2860 if (!IS_ALIGNED(reg, map->reg_stride))
2865 map->lock(map->lock_arg);
2867 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
2868 map->cache_type == REGCACHE_NONE) {
2872 if (!map->cache_bypass && map->cache_only) {
2877 if (!map->read) {
2882 if (map->use_single_read)
2884 else if (map->max_raw_read && val_len > map->max_raw_read)
2885 chunk_regs = map->max_raw_read / val_bytes;
2892 ret = _regmap_raw_read(map, reg, val, chunk_bytes, false);
2896 reg += regmap_get_offset(map, chunk_regs);
2903 ret = _regmap_raw_read(map, reg, val, val_len, false);
2912 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2917 map->format.format_val(val + (i * val_bytes), v, 0);
2922 map->unlock(map->lock_arg);
2932 * @map: Register map to read from
2949 int regmap_noinc_read(struct regmap *map, unsigned int reg,
2955 if (!map->read)
2958 if (val_len % map->format.val_bytes)
2960 if (!IS_ALIGNED(reg, map->reg_stride))
2965 map->lock(map->lock_arg);
2967 if (!regmap_volatile(map, reg) || !regmap_readable_noinc(map, reg)) {
2978 if (!map->cache_bypass && map->cache_only) {
2984 if (map->bus->reg_noinc_read) {
2985 ret = regmap_noinc_readwrite(map, reg, val, val_len, false);
2990 if (map->max_raw_read && map->max_raw_read < val_len)
2991 read_len = map->max_raw_read;
2994 ret = _regmap_raw_read(map, reg, val, read_len, true);
3002 map->unlock(map->lock_arg);
3068 * @map: Register map to read from
3076 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
3080 size_t val_bytes = map->format.val_bytes;
3081 bool vol = regmap_volatile_range(map, reg, val_count);
3083 if (!IS_ALIGNED(reg, map->reg_stride))
3088 if (map->read && map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
3089 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
3094 map->format.parse_inplace(val + i);
3100 map->lock(map->lock_arg);
3105 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
3110 switch (map->format.val_bytes) {
3127 map->unlock(map->lock_arg);
3131 trace_regmap_bulk_read(map, reg, val, val_bytes * val_count);
3137 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
3147 if (regmap_volatile(map, reg) && map->reg_update_bits) {
3148 reg = regmap_reg_addr(map, reg);
3149 ret = map->reg_update_bits(map->bus_context, reg, mask, val);
3153 ret = _regmap_read(map, reg, &orig);
3160 if (force_write || (tmp != orig) || map->force_write_field) {
3161 ret = _regmap_write(map, reg, tmp);
3173 * @map: Register map to update
3181 * Perform a read/modify/write cycle on a register map with change, async, force
3192 int regmap_update_bits_base(struct regmap *map, unsigned int reg,
3198 map->lock(map->lock_arg);
3200 map->async = async;
3202 ret = _regmap_update_bits(map, reg, mask, val, change, force);
3204 map->async = false;
3206 map->unlock(map->lock_arg);
3215 * @map: Register map to operate on
3223 int regmap_test_bits(struct regmap *map, unsigned int reg, unsigned int bits)
3227 ret = regmap_read(map, reg, &val);
3237 struct regmap *map = async->map;
3240 trace_regmap_async_io_complete(map);
3242 spin_lock(&map->async_lock);
3243 list_move(&async->list, &map->async_free);
3244 wake = list_empty(&map->async_list);
3247 map->async_ret = ret;
3249 spin_unlock(&map->async_lock);
3252 wake_up(&map->async_waitq);
3256 static int regmap_async_is_done(struct regmap *map)
3261 spin_lock_irqsave(&map->async_lock, flags);
3262 ret = list_empty(&map->async_list);
3263 spin_unlock_irqrestore(&map->async_lock, flags);
3271 * @map: Map to operate on.
3276 int regmap_async_complete(struct regmap *map)
3282 if (!map->bus || !map->bus->async_write)
3285 trace_regmap_async_complete_start(map);
3287 wait_event(map->async_waitq, regmap_async_is_done(map));
3289 spin_lock_irqsave(&map->async_lock, flags);
3290 ret = map->async_ret;
3291 map->async_ret = 0;
3292 spin_unlock_irqrestore(&map->async_lock, flags);
3294 trace_regmap_async_complete_done(map);
3304 * @map: Register map to apply updates to.
3317 int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
3328 p = krealloc(map->patch,
3329 sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
3332 memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
3333 map->patch = p;
3334 map->patch_regs += num_regs;
3339 map->lock(map->lock_arg);
3341 bypass = map->cache_bypass;
3343 map->cache_bypass = true;
3344 map->async = true;
3346 ret = _regmap_multi_reg_write(map, regs, num_regs);
3348 map->async = false;
3349 map->cache_bypass = bypass;
3351 map->unlock(map->lock_arg);
3353 regmap_async_complete(map);
3362 * @map: Register map to operate on.
3367 int regmap_get_val_bytes(struct regmap *map)
3369 if (map->format.format_write)
3372 return map->format.val_bytes;
3379 * @map: Register map to operate on.
3384 int regmap_get_max_register(struct regmap *map)
3386 return map->max_register ? map->max_register : -EINVAL;
3393 * @map: Register map to operate on.
3398 int regmap_get_reg_stride(struct regmap *map)
3400 return map->reg_stride;
3407 * @map: Register map to operate on.
3411 bool regmap_might_sleep(struct regmap *map)
3413 return map->can_sleep;
3417 int regmap_parse_val(struct regmap *map, const void *buf,
3420 if (!map->format.parse_val)
3423 *val = map->format.parse_val(buf);