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_is_set && 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_is_set && 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_is_set && 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->max_register_is_set = map->max_register ?: config->max_register_is_0;
791 map->wr_table = config->wr_table;
792 map->rd_table = config->rd_table;
793 map->volatile_table = config->volatile_table;
794 map->precious_table = config->precious_table;
795 map->wr_noinc_table = config->wr_noinc_table;
796 map->rd_noinc_table = config->rd_noinc_table;
797 map->writeable_reg = config->writeable_reg;
798 map->readable_reg = config->readable_reg;
799 map->volatile_reg = config->volatile_reg;
800 map->precious_reg = config->precious_reg;
801 map->writeable_noinc_reg = config->writeable_noinc_reg;
802 map->readable_noinc_reg = config->readable_noinc_reg;
803 map->cache_type = config->cache_type;
805 spin_lock_init(&map->async_lock);
806 INIT_LIST_HEAD(&map->async_list);
807 INIT_LIST_HEAD(&map->async_free);
808 init_waitqueue_head(&map->async_waitq);
813 map->read_flag_mask = config->read_flag_mask;
814 map->write_flag_mask = config->write_flag_mask;
816 map->read_flag_mask = bus->read_flag_mask;
820 map->reg_read = _regmap_bus_read;
822 map->reg_update_bits = config->reg_update_bits;
825 map->read = config->read;
826 map->write = config->write;
831 map->reg_read = config->reg_read;
832 map->reg_write = config->reg_write;
833 map->reg_update_bits = config->reg_update_bits;
835 map->defer_caching = false;
838 map->reg_read = _regmap_bus_reg_read;
839 map->reg_write = _regmap_bus_reg_write;
840 map->reg_update_bits = bus->reg_update_bits;
842 map->defer_caching = false;
845 map->reg_read = _regmap_bus_read;
846 map->reg_update_bits = bus->reg_update_bits;
848 map->read = bus->read;
849 map->write = bus->write;
855 switch (config->reg_bits + map->reg_shift) {
859 map->format.format_write = regmap_format_2_6_write;
869 map->format.format_write = regmap_format_4_12_write;
879 map->format.format_write = regmap_format_7_9_write;
882 map->format.format_write = regmap_format_7_17_write;
892 map->format.format_write = regmap_format_10_14_write;
902 map->format.format_write = regmap_format_12_20_write;
910 map->format.format_reg = regmap_format_8;
916 map->format.format_reg = regmap_format_16_be;
919 map->format.format_reg = regmap_format_16_le;
922 map->format.format_reg = regmap_format_16_native;
932 map->format.format_reg = regmap_format_24_be;
942 map->format.format_reg = regmap_format_32_be;
945 map->format.format_reg = regmap_format_32_le;
948 map->format.format_reg = regmap_format_32_native;
960 map->format.parse_inplace = regmap_parse_inplace_noop;
964 map->format.format_val = regmap_format_8;
965 map->format.parse_val = regmap_parse_8;
966 map->format.parse_inplace = regmap_parse_inplace_noop;
971 map->format.format_val = regmap_format_16_be;
972 map->format.parse_val = regmap_parse_16_be;
973 map->format.parse_inplace = regmap_parse_16_be_inplace;
976 map->format.format_val = regmap_format_16_le;
977 map->format.parse_val = regmap_parse_16_le;
978 map->format.parse_inplace = regmap_parse_16_le_inplace;
981 map->format.format_val = regmap_format_16_native;
982 map->format.parse_val = regmap_parse_16_native;
991 map->format.format_val = regmap_format_24_be;
992 map->format.parse_val = regmap_parse_24_be;
1001 map->format.format_val = regmap_format_32_be;
1002 map->format.parse_val = regmap_parse_32_be;
1003 map->format.parse_inplace = regmap_parse_32_be_inplace;
1006 map->format.format_val = regmap_format_32_le;
1007 map->format.parse_val = regmap_parse_32_le;
1008 map->format.parse_inplace = regmap_parse_32_le_inplace;
1011 map->format.format_val = regmap_format_32_native;
1012 map->format.parse_val = regmap_parse_32_native;
1020 if (map->format.format_write) {
1024 map->use_single_write = true;
1027 if (!map->format.format_write &&
1028 !(map->format.format_reg && map->format.format_val))
1031 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
1032 if (map->work_buf == NULL) {
1037 if (map->format.format_write) {
1038 map->defer_caching = false;
1039 map->reg_write = _regmap_bus_formatted_write;
1040 } else if (map->format.format_val) {
1041 map->defer_caching = true;
1042 map->reg_write = _regmap_bus_raw_write;
1047 map->range_tree = RB_ROOT;
1054 dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
1059 if (range_cfg->range_max > map->max_register) {
1060 dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
1061 range_cfg->range_max, map->max_register);
1065 if (range_cfg->selector_reg > map->max_register) {
1066 dev_err(map->dev,
1067 "Invalid range %d: selector out of map\n", i);
1072 dev_err(map->dev, "Invalid range %d: window_len 0\n",
1091 dev_err(map->dev,
1099 dev_err(map->dev,
1112 new->map = map;
1122 if (!_regmap_range_add(map, new)) {
1123 dev_err(map->dev, "Failed to add range %d\n", i);
1128 if (map->selector_work_buf == NULL) {
1129 map->selector_work_buf =
1130 kzalloc(map->format.buf_size, GFP_KERNEL);
1131 if (map->selector_work_buf == NULL) {
1138 ret = regcache_init(map, config);
1143 ret = regmap_attach_dev(dev, map, config);
1147 regmap_debugfs_init(map);
1150 return map;
1153 regcache_exit(map);
1155 regmap_range_exit(map);
1156 kfree(map->work_buf);
1158 if (map->hwlock)
1159 hwspin_lock_free(map->hwlock);
1161 kfree_const(map->name);
1163 kfree(map);
1397 * @map: Register map to operate on.
1400 * Discard any existing register cache for the map and initialize a
1408 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
1412 regcache_exit(map);
1413 regmap_debugfs_exit(map);
1415 map->max_register = config->max_register;
1416 map->max_register_is_set = map->max_register ?: config->max_register_is_0;
1417 map->writeable_reg = config->writeable_reg;
1418 map->readable_reg = config->readable_reg;
1419 map->volatile_reg = config->volatile_reg;
1420 map->precious_reg = config->precious_reg;
1421 map->writeable_noinc_reg = config->writeable_noinc_reg;
1422 map->readable_noinc_reg = config->readable_noinc_reg;
1423 map->cache_type = config->cache_type;
1425 ret = regmap_set_name(map, config);
1429 regmap_debugfs_init(map);
1431 map->cache_bypass = false;
1432 map->cache_only = false;
1434 return regcache_init(map, config);
1439 * regmap_exit() - Free a previously allocated register map
1441 * @map: Register map to operate on.
1443 void regmap_exit(struct regmap *map)
1447 regcache_exit(map);
1448 regmap_debugfs_exit(map);
1449 regmap_range_exit(map);
1450 if (map->bus && map->bus->free_context)
1451 map->bus->free_context(map->bus_context);
1452 kfree(map->work_buf);
1453 while (!list_empty(&map->async_free)) {
1454 async = list_first_entry_or_null(&map->async_free,
1461 if (map->hwlock)
1462 hwspin_lock_free(map->hwlock);
1463 if (map->lock == regmap_lock_mutex)
1464 mutex_destroy(&map->mutex);
1465 kfree_const(map->name);
1466 kfree(map->patch);
1467 if (map->bus && map->bus->free_on_exit)
1468 kfree(map->bus);
1469 kfree(map);
1491 * @dev: Device to retrieve the map for
1492 * @name: Optional name for the register map, usually NULL.
1514 * @map: Register map to operate on.
1518 struct device *regmap_get_device(struct regmap *map)
1520 return map->dev;
1524 static int _regmap_select_page(struct regmap *map, unsigned int *reg,
1553 orig_work_buf = map->work_buf;
1554 map->work_buf = map->selector_work_buf;
1556 ret = _regmap_update_bits(map, range->selector_reg,
1561 map->work_buf = orig_work_buf;
1572 static void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
1578 if (!mask || !map->work_buf)
1581 buf = map->work_buf;
1587 static unsigned int regmap_reg_addr(struct regmap *map, unsigned int reg)
1589 reg += map->reg_base;
1591 if (map->format.reg_shift > 0)
1592 reg >>= map->format.reg_shift;
1593 else if (map->format.reg_shift < 0)
1594 reg <<= -(map->format.reg_shift);
1599 static int _regmap_raw_write_impl(struct regmap *map, unsigned int reg,
1604 void *work_val = map->work_buf + map->format.reg_bytes +
1605 map->format.pad_bytes;
1614 if (!regmap_writeable_noinc(map, reg)) {
1615 for (i = 0; i < val_len / map->format.val_bytes; i++) {
1617 reg + regmap_get_offset(map, i);
1618 if (!regmap_writeable(map, element) ||
1619 regmap_writeable_noinc(map, element))
1624 if (!map->cache_bypass && map->format.parse_val) {
1626 int val_bytes = map->format.val_bytes;
1631 ival = map->format.parse_val(val + i);
1632 offset = noinc ? 0 : regmap_get_offset(map, i / val_bytes);
1633 ret = regcache_write(map, reg + offset, ival);
1635 dev_err(map->dev,
1641 if (map->cache_only) {
1642 map->cache_dirty = true;
1647 range = _regmap_range_lookup(map, reg);
1649 int val_num = val_len / map->format.val_bytes;
1655 dev_dbg(map->dev, "Writing window %d/%zu\n",
1656 win_residue, val_len / map->format.val_bytes);
1657 ret = _regmap_raw_write_impl(map, reg, val,
1659 map->format.val_bytes, noinc);
1665 val += win_residue * map->format.val_bytes;
1666 val_len -= win_residue * map->format.val_bytes;
1673 ret = _regmap_select_page(map, ®, range, noinc ? 1 : val_num);
1678 reg = regmap_reg_addr(map, reg);
1679 map->format.format_reg(map->work_buf, reg, map->reg_shift);
1680 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
1681 map->write_flag_mask);
1688 if (val != work_val && val_len == map->format.val_bytes) {
1689 memcpy(work_val, val, map->format.val_bytes);
1693 if (map->async && map->bus && map->bus->async_write) {
1696 trace_regmap_async_write_start(map, reg, val_len);
1698 spin_lock_irqsave(&map->async_lock, flags);
1699 async = list_first_entry_or_null(&map->async_free,
1704 spin_unlock_irqrestore(&map->async_lock, flags);
1707 async = map->bus->async_alloc();
1711 async->work_buf = kzalloc(map->format.buf_size,
1719 async->map = map;
1722 memcpy(async->work_buf, map->work_buf, map->format.pad_bytes +
1723 map->format.reg_bytes + map->format.val_bytes);
1725 spin_lock_irqsave(&map->async_lock, flags);
1726 list_add_tail(&async->list, &map->async_list);
1727 spin_unlock_irqrestore(&map->async_lock, flags);
1730 ret = map->bus->async_write(map->bus_context,
1732 map->format.reg_bytes +
1733 map->format.pad_bytes,
1736 ret = map->bus->async_write(map->bus_context,
1738 map->format.reg_bytes +
1739 map->format.pad_bytes +
1743 dev_err(map->dev, "Failed to schedule write: %d\n",
1746 spin_lock_irqsave(&map->async_lock, flags);
1747 list_move(&async->list, &map->async_free);
1748 spin_unlock_irqrestore(&map->async_lock, flags);
1754 trace_regmap_hw_write_start(map, reg, val_len / map->format.val_bytes);
1761 ret = map->write(map->bus_context, map->work_buf,
1762 map->format.reg_bytes +
1763 map->format.pad_bytes +
1765 else if (map->bus && map->bus->gather_write)
1766 ret = map->bus->gather_write(map->bus_context, map->work_buf,
1767 map->format.reg_bytes +
1768 map->format.pad_bytes,
1775 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
1780 memcpy(buf, map->work_buf, map->format.reg_bytes);
1781 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
1783 ret = map->write(map->bus_context, buf, len);
1786 } else if (ret != 0 && !map->cache_bypass && map->format.parse_val) {
1788 * thus call map->cache_ops->drop() directly
1790 if (map->cache_ops && map->cache_ops->drop)
1791 map->cache_ops->drop(map, reg, reg + 1);
1794 trace_regmap_hw_write_done(map, reg, val_len / map->format.val_bytes);
1802 * @map: Map to check.
1804 bool regmap_can_raw_write(struct regmap *map)
1806 return map->write && map->format.format_val && map->format.format_reg;
1813 * @map: Map to check.
1815 size_t regmap_get_raw_read_max(struct regmap *map)
1817 return map->max_raw_read;
1824 * @map: Map to check.
1826 size_t regmap_get_raw_write_max(struct regmap *map)
1828 return map->max_raw_write;
1837 struct regmap *map = context;
1839 WARN_ON(!map->format.format_write);
1841 range = _regmap_range_lookup(map, reg);
1843 ret = _regmap_select_page(map, ®, range, 1);
1848 reg = regmap_reg_addr(map, reg);
1849 map->format.format_write(map, reg, val);
1851 trace_regmap_hw_write_start(map, reg, 1);
1853 ret = map->write(map->bus_context, map->work_buf, map->format.buf_size);
1855 trace_regmap_hw_write_done(map, reg, 1);
1863 struct regmap *map = context;
1867 range = _regmap_range_lookup(map, reg);
1869 ret = _regmap_select_page(map, ®, range, 1);
1874 reg = regmap_reg_addr(map, reg);
1875 return map->bus->reg_write(map->bus_context, reg, val);
1881 struct regmap *map = context;
1883 WARN_ON(!map->format.format_val);
1885 map->format.format_val(map->work_buf + map->format.reg_bytes
1886 + map->format.pad_bytes, val, 0);
1887 return _regmap_raw_write_impl(map, reg,
1888 map->work_buf +
1889 map->format.reg_bytes +
1890 map->format.pad_bytes,
1891 map->format.val_bytes,
1895 static inline void *_regmap_map_get_context(struct regmap *map)
1897 return (map->bus || (!map->bus && map->read)) ? map : map->bus_context;
1900 int _regmap_write(struct regmap *map, unsigned int reg,
1904 void *context = _regmap_map_get_context(map);
1906 if (!regmap_writeable(map, reg))
1909 if (!map->cache_bypass && !map->defer_caching) {
1910 ret = regcache_write(map, reg, val);
1913 if (map->cache_only) {
1914 map->cache_dirty = true;
1919 ret = map->reg_write(context, reg, val);
1921 if (regmap_should_log(map))
1922 dev_info(map->dev, "%x <= %x\n", reg, val);
1924 trace_regmap_reg_write(map, reg, val);
1933 * @map: Register map to write to
1940 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1944 if (!IS_ALIGNED(reg, map->reg_stride))
1947 map->lock(map->lock_arg);
1949 ret = _regmap_write(map, reg, val);
1951 map->unlock(map->lock_arg);
1960 * @map: Register map to write to
1967 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val)
1971 if (!IS_ALIGNED(reg, map->reg_stride))
1974 map->lock(map->lock_arg);
1976 map->async = true;
1978 ret = _regmap_write(map, reg, val);
1980 map->async = false;
1982 map->unlock(map->lock_arg);
1988 int _regmap_raw_write(struct regmap *map, unsigned int reg,
1991 size_t val_bytes = map->format.val_bytes;
2000 if (map->use_single_write)
2002 else if (map->max_raw_write && val_len > map->max_raw_write)
2003 chunk_regs = map->max_raw_write / val_bytes;
2010 ret = _regmap_raw_write_impl(map, reg, val, chunk_bytes, noinc);
2014 reg += regmap_get_offset(map, chunk_regs);
2021 ret = _regmap_raw_write_impl(map, reg, val, val_len, noinc);
2029 * @map: Register map to write to
2042 int regmap_raw_write(struct regmap *map, unsigned int reg,
2047 if (!regmap_can_raw_write(map))
2049 if (val_len % map->format.val_bytes)
2052 map->lock(map->lock_arg);
2054 ret = _regmap_raw_write(map, reg, val, val_len, false);
2056 map->unlock(map->lock_arg);
2062 static int regmap_noinc_readwrite(struct regmap *map, unsigned int reg,
2065 size_t val_bytes = map->format.val_bytes;
2100 if (!map->cache_bypass && !map->defer_caching) {
2101 ret = regcache_write(map, reg, lastval);
2104 if (map->cache_only) {
2105 map->cache_dirty = true;
2109 ret = map->bus->reg_noinc_write(map->bus_context, reg, val, val_count);
2111 ret = map->bus->reg_noinc_read(map->bus_context, reg, val, val_count);
2114 if (!ret && regmap_should_log(map)) {
2115 dev_info(map->dev, "%x %s [", reg, write ? "<=" : "=>");
2144 * @map: Register map to write to
2161 int regmap_noinc_write(struct regmap *map, unsigned int reg,
2167 if (!map->write && !(map->bus && map->bus->reg_noinc_write))
2169 if (val_len % map->format.val_bytes)
2171 if (!IS_ALIGNED(reg, map->reg_stride))
2176 map->lock(map->lock_arg);
2178 if (!regmap_volatile(map, reg) || !regmap_writeable_noinc(map, reg)) {
2187 if (map->bus->reg_noinc_write) {
2188 ret = regmap_noinc_readwrite(map, reg, (void *)val, val_len, true);
2193 if (map->max_raw_write && map->max_raw_write < val_len)
2194 write_len = map->max_raw_write;
2197 ret = _regmap_raw_write(map, reg, val, write_len, true);
2205 map->unlock(map->lock_arg);
2295 * @map: Register map to write to
2306 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
2310 size_t val_bytes = map->format.val_bytes;
2312 if (!IS_ALIGNED(reg, map->reg_stride))
2319 if (!map->write || !map->format.parse_inplace) {
2320 map->lock(map->lock_arg);
2339 ret = _regmap_write(map,
2340 reg + regmap_get_offset(map, i),
2346 map->unlock(map->lock_arg);
2350 wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
2355 map->format.parse_inplace(wval + i);
2357 ret = regmap_raw_write(map, reg, wval, val_bytes * val_count);
2363 trace_regmap_bulk_write(map, reg, val, val_bytes * val_count);
2376 static int _regmap_raw_multi_reg_write(struct regmap *map,
2384 size_t val_bytes = map->format.val_bytes;
2385 size_t reg_bytes = map->format.reg_bytes;
2386 size_t pad_bytes = map->format.pad_bytes;
2404 trace_regmap_hw_write_start(map, reg, 1);
2405 reg = regmap_reg_addr(map, reg);
2406 map->format.format_reg(u8, reg, map->reg_shift);
2408 map->format.format_val(u8, val, 0);
2412 *u8 |= map->write_flag_mask;
2414 ret = map->write(map->bus_context, buf, len);
2420 trace_regmap_hw_write_done(map, reg, 1);
2425 static unsigned int _regmap_register_page(struct regmap *map,
2434 static int _regmap_range_multi_paged_reg_write(struct regmap *map,
2454 range = _regmap_range_lookup(map, reg);
2456 unsigned int win_page = _regmap_register_page(map, reg,
2483 ret = _regmap_raw_multi_reg_write(map, base, n);
2488 if (map->can_sleep)
2498 ret = _regmap_select_page(map,
2511 return _regmap_raw_multi_reg_write(map, base, n);
2515 static int _regmap_multi_reg_write(struct regmap *map,
2522 if (!map->can_multi_write) {
2524 ret = _regmap_write(map, regs[i].reg, regs[i].def);
2529 if (map->can_sleep)
2538 if (!map->format.parse_inplace)
2541 if (map->writeable_reg)
2544 if (!map->writeable_reg(map->dev, reg))
2546 if (!IS_ALIGNED(reg, map->reg_stride))
2550 if (!map->cache_bypass) {
2554 ret = regcache_write(map, reg, val);
2556 dev_err(map->dev,
2562 if (map->cache_only) {
2563 map->cache_dirty = true;
2568 WARN_ON(!map->bus);
2577 range = _regmap_range_lookup(map, reg);
2584 ret = _regmap_range_multi_paged_reg_write(map, base,
2591 return _regmap_raw_multi_reg_write(map, regs, num_regs);
2597 * @map: Register map to write to
2613 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
2618 map->lock(map->lock_arg);
2620 ret = _regmap_multi_reg_write(map, regs, num_regs);
2622 map->unlock(map->lock_arg);
2632 * @map: Register map to write to
2646 int regmap_multi_reg_write_bypassed(struct regmap *map,
2653 map->lock(map->lock_arg);
2655 bypass = map->cache_bypass;
2656 map->cache_bypass = true;
2658 ret = _regmap_multi_reg_write(map, regs, num_regs);
2660 map->cache_bypass = bypass;
2662 map->unlock(map->lock_arg);
2672 * @map: Register map to write to
2690 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
2695 if (val_len % map->format.val_bytes)
2697 if (!IS_ALIGNED(reg, map->reg_stride))
2700 map->lock(map->lock_arg);
2702 map->async = true;
2704 ret = _regmap_raw_write(map, reg, val, val_len, false);
2706 map->async = false;
2708 map->unlock(map->lock_arg);
2714 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2720 if (!map->read)
2723 range = _regmap_range_lookup(map, reg);
2725 ret = _regmap_select_page(map, ®, range,
2726 noinc ? 1 : val_len / map->format.val_bytes);
2731 reg = regmap_reg_addr(map, reg);
2732 map->format.format_reg(map->work_buf, reg, map->reg_shift);
2733 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
2734 map->read_flag_mask);
2735 trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
2737 ret = map->read(map->bus_context, map->work_buf,
2738 map->format.reg_bytes + map->format.pad_bytes,
2741 trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
2749 struct regmap *map = context;
2753 range = _regmap_range_lookup(map, reg);
2755 ret = _regmap_select_page(map, ®, range, 1);
2760 reg = regmap_reg_addr(map, reg);
2761 return map->bus->reg_read(map->bus_context, reg, val);
2768 struct regmap *map = context;
2769 void *work_val = map->work_buf + map->format.reg_bytes +
2770 map->format.pad_bytes;
2772 if (!map->format.parse_val)
2775 ret = _regmap_raw_read(map, reg, work_val, map->format.val_bytes, false);
2777 *val = map->format.parse_val(work_val);
2782 static int _regmap_read(struct regmap *map, unsigned int reg,
2786 void *context = _regmap_map_get_context(map);
2788 if (!map->cache_bypass) {
2789 ret = regcache_read(map, reg, val);
2794 if (map->cache_only)
2797 if (!regmap_readable(map, reg))
2800 ret = map->reg_read(context, reg, val);
2802 if (regmap_should_log(map))
2803 dev_info(map->dev, "%x => %x\n", reg, *val);
2805 trace_regmap_reg_read(map, reg, *val);
2807 if (!map->cache_bypass)
2808 regcache_write(map, reg, *val);
2817 * @map: Register map to read from
2824 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
2828 if (!IS_ALIGNED(reg, map->reg_stride))
2831 map->lock(map->lock_arg);
2833 ret = _regmap_read(map, reg, val);
2835 map->unlock(map->lock_arg);
2844 * @map: Register map to read from
2852 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2855 size_t val_bytes = map->format.val_bytes;
2860 if (val_len % map->format.val_bytes)
2862 if (!IS_ALIGNED(reg, map->reg_stride))
2867 map->lock(map->lock_arg);
2869 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
2870 map->cache_type == REGCACHE_NONE) {
2874 if (!map->cache_bypass && map->cache_only) {
2879 if (!map->read) {
2884 if (map->use_single_read)
2886 else if (map->max_raw_read && val_len > map->max_raw_read)
2887 chunk_regs = map->max_raw_read / val_bytes;
2894 ret = _regmap_raw_read(map, reg, val, chunk_bytes, false);
2898 reg += regmap_get_offset(map, chunk_regs);
2905 ret = _regmap_raw_read(map, reg, val, val_len, false);
2914 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2919 map->format.format_val(val + (i * val_bytes), v, 0);
2924 map->unlock(map->lock_arg);
2934 * @map: Register map to read from
2951 int regmap_noinc_read(struct regmap *map, unsigned int reg,
2957 if (!map->read)
2960 if (val_len % map->format.val_bytes)
2962 if (!IS_ALIGNED(reg, map->reg_stride))
2967 map->lock(map->lock_arg);
2969 if (!regmap_volatile(map, reg) || !regmap_readable_noinc(map, reg)) {
2980 if (!map->cache_bypass && map->cache_only) {
2986 if (map->bus->reg_noinc_read) {
2987 ret = regmap_noinc_readwrite(map, reg, val, val_len, false);
2992 if (map->max_raw_read && map->max_raw_read < val_len)
2993 read_len = map->max_raw_read;
2996 ret = _regmap_raw_read(map, reg, val, read_len, true);
3004 map->unlock(map->lock_arg);
3070 * @map: Register map to read from
3078 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
3082 size_t val_bytes = map->format.val_bytes;
3083 bool vol = regmap_volatile_range(map, reg, val_count);
3085 if (!IS_ALIGNED(reg, map->reg_stride))
3090 if (map->read && map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
3091 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
3096 map->format.parse_inplace(val + i);
3102 map->lock(map->lock_arg);
3107 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
3112 switch (map->format.val_bytes) {
3129 map->unlock(map->lock_arg);
3133 trace_regmap_bulk_read(map, reg, val, val_bytes * val_count);
3139 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
3149 if (regmap_volatile(map, reg) && map->reg_update_bits) {
3150 reg = regmap_reg_addr(map, reg);
3151 ret = map->reg_update_bits(map->bus_context, reg, mask, val);
3155 ret = _regmap_read(map, reg, &orig);
3162 if (force_write || (tmp != orig) || map->force_write_field) {
3163 ret = _regmap_write(map, reg, tmp);
3175 * @map: Register map to update
3183 * Perform a read/modify/write cycle on a register map with change, async, force
3194 int regmap_update_bits_base(struct regmap *map, unsigned int reg,
3200 map->lock(map->lock_arg);
3202 map->async = async;
3204 ret = _regmap_update_bits(map, reg, mask, val, change, force);
3206 map->async = false;
3208 map->unlock(map->lock_arg);
3217 * @map: Register map to operate on
3225 int regmap_test_bits(struct regmap *map, unsigned int reg, unsigned int bits)
3229 ret = regmap_read(map, reg, &val);
3239 struct regmap *map = async->map;
3242 trace_regmap_async_io_complete(map);
3244 spin_lock(&map->async_lock);
3245 list_move(&async->list, &map->async_free);
3246 wake = list_empty(&map->async_list);
3249 map->async_ret = ret;
3251 spin_unlock(&map->async_lock);
3254 wake_up(&map->async_waitq);
3258 static int regmap_async_is_done(struct regmap *map)
3263 spin_lock_irqsave(&map->async_lock, flags);
3264 ret = list_empty(&map->async_list);
3265 spin_unlock_irqrestore(&map->async_lock, flags);
3273 * @map: Map to operate on.
3278 int regmap_async_complete(struct regmap *map)
3284 if (!map->bus || !map->bus->async_write)
3287 trace_regmap_async_complete_start(map);
3289 wait_event(map->async_waitq, regmap_async_is_done(map));
3291 spin_lock_irqsave(&map->async_lock, flags);
3292 ret = map->async_ret;
3293 map->async_ret = 0;
3294 spin_unlock_irqrestore(&map->async_lock, flags);
3296 trace_regmap_async_complete_done(map);
3306 * @map: Register map to apply updates to.
3319 int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
3330 p = krealloc(map->patch,
3331 sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
3334 memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
3335 map->patch = p;
3336 map->patch_regs += num_regs;
3341 map->lock(map->lock_arg);
3343 bypass = map->cache_bypass;
3345 map->cache_bypass = true;
3346 map->async = true;
3348 ret = _regmap_multi_reg_write(map, regs, num_regs);
3350 map->async = false;
3351 map->cache_bypass = bypass;
3353 map->unlock(map->lock_arg);
3355 regmap_async_complete(map);
3364 * @map: Register map to operate on.
3369 int regmap_get_val_bytes(struct regmap *map)
3371 if (map->format.format_write)
3374 return map->format.val_bytes;
3381 * @map: Register map to operate on.
3386 int regmap_get_max_register(struct regmap *map)
3388 return map->max_register_is_set ? map->max_register : -EINVAL;
3395 * @map: Register map to operate on.
3400 int regmap_get_reg_stride(struct regmap *map)
3402 return map->reg_stride;
3409 * @map: Register map to operate on.
3413 bool regmap_might_sleep(struct regmap *map)
3415 return map->can_sleep;
3419 int regmap_parse_val(struct regmap *map, const void *buf,
3422 if (!map->format.parse_val)
3425 *val = map->format.parse_val(buf);