1 /* SPDX-License-Identifier: GPL-2.0 */ 2 /* 3 * Register map access API internal header 4 * 5 * Copyright 2011 Wolfson Microelectronics plc 6 * 7 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 8 */ 9 10 #ifndef _REGMAP_INTERNAL_H 11 #define _REGMAP_INTERNAL_H 12 13 #include <linux/device.h> 14 #include <linux/regmap.h> 15 #include <linux/fs.h> 16 #include <linux/list.h> 17 #include <linux/wait.h> 18 19 struct regmap; 20 struct regcache_ops; 21 22 struct regmap_debugfs_off_cache { 23 struct list_head list; 24 off_t min; 25 off_t max; 26 unsigned int base_reg; 27 unsigned int max_reg; 28 }; 29 30 struct regmap_format { 31 size_t buf_size; 32 size_t reg_bytes; 33 size_t pad_bytes; 34 size_t val_bytes; 35 s8 reg_shift; 36 void (*format_write)(struct regmap *map, 37 unsigned int reg, unsigned int val); 38 void (*format_reg)(void *buf, unsigned int reg, unsigned int shift); 39 void (*format_val)(void *buf, unsigned int val, unsigned int shift); 40 unsigned int (*parse_val)(const void *buf); 41 void (*parse_inplace)(void *buf); 42 }; 43 44 struct regmap_async { 45 struct list_head list; 46 struct regmap *map; 47 void *work_buf; 48 }; 49 50 struct regmap { 51 union { 52 struct mutex mutex; 53 struct { 54 spinlock_t spinlock; 55 unsigned long spinlock_flags; 56 }; 57 struct { 58 raw_spinlock_t raw_spinlock; 59 unsigned long raw_spinlock_flags; 60 }; 61 }; 62 regmap_lock lock; 63 regmap_unlock unlock; 64 void *lock_arg; /* This is passed to lock/unlock functions */ 65 gfp_t alloc_flags; 66 unsigned int reg_base; 67 68 struct device *dev; /* Device we do I/O on */ 69 void *work_buf; /* Scratch buffer used to format I/O */ 70 struct regmap_format format; /* Buffer format */ 71 const struct regmap_bus *bus; 72 void *bus_context; 73 const char *name; 74 75 bool async; 76 spinlock_t async_lock; 77 wait_queue_head_t async_waitq; 78 struct list_head async_list; 79 struct list_head async_free; 80 int async_ret; 81 82 #ifdef CONFIG_DEBUG_FS 83 bool debugfs_disable; 84 struct dentry *debugfs; 85 const char *debugfs_name; 86 87 unsigned int debugfs_reg_len; 88 unsigned int debugfs_val_len; 89 unsigned int debugfs_tot_len; 90 91 struct list_head debugfs_off_cache; 92 struct mutex cache_lock; 93 #endif 94 95 unsigned int max_register; 96 bool max_register_is_set; 97 bool (*writeable_reg)(struct device *dev, unsigned int reg); 98 bool (*readable_reg)(struct device *dev, unsigned int reg); 99 bool (*volatile_reg)(struct device *dev, unsigned int reg); 100 bool (*precious_reg)(struct device *dev, unsigned int reg); 101 bool (*writeable_noinc_reg)(struct device *dev, unsigned int reg); 102 bool (*readable_noinc_reg)(struct device *dev, unsigned int reg); 103 const struct regmap_access_table *wr_table; 104 const struct regmap_access_table *rd_table; 105 const struct regmap_access_table *volatile_table; 106 const struct regmap_access_table *precious_table; 107 const struct regmap_access_table *wr_noinc_table; 108 const struct regmap_access_table *rd_noinc_table; 109 110 int (*reg_read)(void *context, unsigned int reg, unsigned int *val); 111 int (*reg_write)(void *context, unsigned int reg, unsigned int val); 112 int (*reg_update_bits)(void *context, unsigned int reg, 113 unsigned int mask, unsigned int val); 114 /* Bulk read/write */ 115 int (*read)(void *context, const void *reg_buf, size_t reg_size, 116 void *val_buf, size_t val_size); 117 int (*write)(void *context, const void *data, size_t count); 118 119 bool defer_caching; 120 121 unsigned long read_flag_mask; 122 unsigned long write_flag_mask; 123 124 /* number of bits to (left) shift the reg value when formatting*/ 125 int reg_shift; 126 int reg_stride; 127 int reg_stride_order; 128 129 /* If set, will always write field to HW. */ 130 bool force_write_field; 131 132 /* regcache specific members */ 133 const struct regcache_ops *cache_ops; 134 enum regcache_type cache_type; 135 136 /* number of bytes in reg_defaults_raw */ 137 unsigned int cache_size_raw; 138 /* number of bytes per word in reg_defaults_raw */ 139 unsigned int cache_word_size; 140 /* number of entries in reg_defaults */ 141 unsigned int num_reg_defaults; 142 /* number of entries in reg_defaults_raw */ 143 unsigned int num_reg_defaults_raw; 144 145 /* if set, only the cache is modified not the HW */ 146 bool cache_only; 147 /* if set, only the HW is modified not the cache */ 148 bool cache_bypass; 149 /* if set, remember to free reg_defaults_raw */ 150 bool cache_free; 151 152 struct reg_default *reg_defaults; 153 const void *reg_defaults_raw; 154 void *cache; 155 /* if set, the cache contains newer data than the HW */ 156 bool cache_dirty; 157 /* if set, the HW registers are known to match map->reg_defaults */ 158 bool no_sync_defaults; 159 160 struct reg_sequence *patch; 161 int patch_regs; 162 163 /* if set, converts bulk read to single read */ 164 bool use_single_read; 165 /* if set, converts bulk write to single write */ 166 bool use_single_write; 167 /* if set, the device supports multi write mode */ 168 bool can_multi_write; 169 170 /* if set, raw reads/writes are limited to this size */ 171 size_t max_raw_read; 172 size_t max_raw_write; 173 174 struct rb_root range_tree; 175 void *selector_work_buf; /* Scratch buffer used for selector */ 176 177 struct hwspinlock *hwlock; 178 179 /* if set, the regmap core can sleep */ 180 bool can_sleep; 181 }; 182 183 struct regcache_ops { 184 const char *name; 185 enum regcache_type type; 186 int (*init)(struct regmap *map); 187 int (*exit)(struct regmap *map); 188 #ifdef CONFIG_DEBUG_FS 189 void (*debugfs_init)(struct regmap *map); 190 #endif 191 int (*read)(struct regmap *map, unsigned int reg, unsigned int *value); 192 int (*write)(struct regmap *map, unsigned int reg, unsigned int value); 193 int (*sync)(struct regmap *map, unsigned int min, unsigned int max); 194 int (*drop)(struct regmap *map, unsigned int min, unsigned int max); 195 }; 196 197 bool regmap_cached(struct regmap *map, unsigned int reg); 198 bool regmap_writeable(struct regmap *map, unsigned int reg); 199 bool regmap_readable(struct regmap *map, unsigned int reg); 200 bool regmap_volatile(struct regmap *map, unsigned int reg); 201 bool regmap_precious(struct regmap *map, unsigned int reg); 202 bool regmap_writeable_noinc(struct regmap *map, unsigned int reg); 203 bool regmap_readable_noinc(struct regmap *map, unsigned int reg); 204 205 int _regmap_write(struct regmap *map, unsigned int reg, 206 unsigned int val); 207 208 struct regmap_range_node { 209 struct rb_node node; 210 const char *name; 211 struct regmap *map; 212 213 unsigned int range_min; 214 unsigned int range_max; 215 216 unsigned int selector_reg; 217 unsigned int selector_mask; 218 int selector_shift; 219 220 unsigned int window_start; 221 unsigned int window_len; 222 }; 223 224 struct regmap_field { 225 struct regmap *regmap; 226 unsigned int mask; 227 /* lsb */ 228 unsigned int shift; 229 unsigned int reg; 230 231 unsigned int id_size; 232 unsigned int id_offset; 233 }; 234 235 #ifdef CONFIG_DEBUG_FS 236 extern void regmap_debugfs_initcall(void); 237 extern void regmap_debugfs_init(struct regmap *map); 238 extern void regmap_debugfs_exit(struct regmap *map); 239 240 static inline void regmap_debugfs_disable(struct regmap *map) 241 { 242 map->debugfs_disable = true; 243 } 244 245 #else 246 static inline void regmap_debugfs_initcall(void) { } 247 static inline void regmap_debugfs_init(struct regmap *map) { } 248 static inline void regmap_debugfs_exit(struct regmap *map) { } 249 static inline void regmap_debugfs_disable(struct regmap *map) { } 250 #endif 251 252 /* regcache core declarations */ 253 int regcache_init(struct regmap *map, const struct regmap_config *config); 254 void regcache_exit(struct regmap *map); 255 int regcache_read(struct regmap *map, 256 unsigned int reg, unsigned int *value); 257 int regcache_write(struct regmap *map, 258 unsigned int reg, unsigned int value); 259 int regcache_sync(struct regmap *map); 260 int regcache_sync_block(struct regmap *map, void *block, 261 unsigned long *cache_present, 262 unsigned int block_base, unsigned int start, 263 unsigned int end); 264 bool regcache_reg_needs_sync(struct regmap *map, unsigned int reg, 265 unsigned int val); 266 267 static inline const void *regcache_get_val_addr(struct regmap *map, 268 const void *base, 269 unsigned int idx) 270 { 271 return base + (map->cache_word_size * idx); 272 } 273 274 unsigned int regcache_get_val(struct regmap *map, const void *base, 275 unsigned int idx); 276 void regcache_set_val(struct regmap *map, void *base, unsigned int idx, 277 unsigned int val); 278 int regcache_lookup_reg(struct regmap *map, unsigned int reg); 279 int regcache_sync_val(struct regmap *map, unsigned int reg, unsigned int val); 280 281 int _regmap_raw_write(struct regmap *map, unsigned int reg, 282 const void *val, size_t val_len, bool noinc); 283 284 void regmap_async_complete_cb(struct regmap_async *async, int ret); 285 286 enum regmap_endian regmap_get_val_endian(struct device *dev, 287 const struct regmap_bus *bus, 288 const struct regmap_config *config); 289 290 extern struct regcache_ops regcache_rbtree_ops; 291 extern struct regcache_ops regcache_maple_ops; 292 extern struct regcache_ops regcache_flat_ops; 293 294 static inline const char *regmap_name(const struct regmap *map) 295 { 296 if (map->dev) 297 return dev_name(map->dev); 298 299 return map->name; 300 } 301 302 static inline unsigned int regmap_get_offset(const struct regmap *map, 303 unsigned int index) 304 { 305 if (map->reg_stride_order >= 0) 306 return index << map->reg_stride_order; 307 else 308 return index * map->reg_stride; 309 } 310 311 static inline unsigned int regcache_get_index_by_order(const struct regmap *map, 312 unsigned int reg) 313 { 314 return reg >> map->reg_stride_order; 315 } 316 317 struct regmap_ram_data { 318 unsigned int *vals; /* Allocatd by caller */ 319 bool *read; 320 bool *written; 321 enum regmap_endian reg_endian; 322 bool (*noinc_reg)(struct regmap_ram_data *data, unsigned int reg); 323 }; 324 325 /* 326 * Create a test register map with data stored in RAM, not intended 327 * for practical use. 328 */ 329 struct regmap *__regmap_init_ram(const struct regmap_config *config, 330 struct regmap_ram_data *data, 331 struct lock_class_key *lock_key, 332 const char *lock_name); 333 334 #define regmap_init_ram(config, data) \ 335 __regmap_lockdep_wrapper(__regmap_init_ram, #config, config, data) 336 337 struct regmap *__regmap_init_raw_ram(const struct regmap_config *config, 338 struct regmap_ram_data *data, 339 struct lock_class_key *lock_key, 340 const char *lock_name); 341 342 #define regmap_init_raw_ram(config, data) \ 343 __regmap_lockdep_wrapper(__regmap_init_raw_ram, #config, config, data) 344 345 #endif 346