1 #ifndef __LINUX_REGMAP_H 2 #define __LINUX_REGMAP_H 3 4 /* 5 * Register map access API 6 * 7 * Copyright 2011 Wolfson Microelectronics plc 8 * 9 * Author: Mark Brown <[email protected]> 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License version 2 as 13 * published by the Free Software Foundation. 14 */ 15 16 #include <linux/list.h> 17 #include <linux/rbtree.h> 18 19 struct module; 20 struct device; 21 struct i2c_client; 22 struct spi_device; 23 struct regmap; 24 struct regmap_range_cfg; 25 26 /* An enum of all the supported cache types */ 27 enum regcache_type { 28 REGCACHE_NONE, 29 REGCACHE_RBTREE, 30 REGCACHE_COMPRESSED 31 }; 32 33 /** 34 * Default value for a register. We use an array of structs rather 35 * than a simple array as many modern devices have very sparse 36 * register maps. 37 * 38 * @reg: Register address. 39 * @def: Register default value. 40 */ 41 struct reg_default { 42 unsigned int reg; 43 unsigned int def; 44 }; 45 46 #ifdef CONFIG_REGMAP 47 48 enum regmap_endian { 49 /* Unspecified -> 0 -> Backwards compatible default */ 50 REGMAP_ENDIAN_DEFAULT = 0, 51 REGMAP_ENDIAN_BIG, 52 REGMAP_ENDIAN_LITTLE, 53 REGMAP_ENDIAN_NATIVE, 54 }; 55 56 /** 57 * Configuration for the register map of a device. 58 * 59 * @name: Optional name of the regmap. Useful when a device has multiple 60 * register regions. 61 * 62 * @reg_bits: Number of bits in a register address, mandatory. 63 * @reg_stride: The register address stride. Valid register addresses are a 64 * multiple of this value. If set to 0, a value of 1 will be 65 * used. 66 * @pad_bits: Number of bits of padding between register and value. 67 * @val_bits: Number of bits in a register value, mandatory. 68 * 69 * @writeable_reg: Optional callback returning true if the register 70 * can be written to. 71 * @readable_reg: Optional callback returning true if the register 72 * can be read from. 73 * @volatile_reg: Optional callback returning true if the register 74 * value can't be cached. 75 * @precious_reg: Optional callback returning true if the rgister 76 * should not be read outside of a call from the driver 77 * (eg, a clear on read interrupt status register). 78 * 79 * @max_register: Optional, specifies the maximum valid register index. 80 * @reg_defaults: Power on reset values for registers (for use with 81 * register cache support). 82 * @num_reg_defaults: Number of elements in reg_defaults. 83 * 84 * @read_flag_mask: Mask to be set in the top byte of the register when doing 85 * a read. 86 * @write_flag_mask: Mask to be set in the top byte of the register when doing 87 * a write. If both read_flag_mask and write_flag_mask are 88 * empty the regmap_bus default masks are used. 89 * @use_single_rw: If set, converts the bulk read and write operations into 90 * a series of single read and write operations. This is useful 91 * for device that does not support bulk read and write. 92 * 93 * @cache_type: The actual cache type. 94 * @reg_defaults_raw: Power on reset values for registers (for use with 95 * register cache support). 96 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw. 97 * @reg_format_endian: Endianness for formatted register addresses. If this is 98 * DEFAULT, the @reg_format_endian_default value from the 99 * regmap bus is used. 100 * @val_format_endian: Endianness for formatted register values. If this is 101 * DEFAULT, the @reg_format_endian_default value from the 102 * regmap bus is used. 103 * 104 * @ranges: Array of configuration entries for virtual address ranges. 105 * @num_ranges: Number of range configuration entries. 106 */ 107 struct regmap_config { 108 const char *name; 109 110 int reg_bits; 111 int reg_stride; 112 int pad_bits; 113 int val_bits; 114 115 bool (*writeable_reg)(struct device *dev, unsigned int reg); 116 bool (*readable_reg)(struct device *dev, unsigned int reg); 117 bool (*volatile_reg)(struct device *dev, unsigned int reg); 118 bool (*precious_reg)(struct device *dev, unsigned int reg); 119 120 unsigned int max_register; 121 const struct reg_default *reg_defaults; 122 unsigned int num_reg_defaults; 123 enum regcache_type cache_type; 124 const void *reg_defaults_raw; 125 unsigned int num_reg_defaults_raw; 126 127 u8 read_flag_mask; 128 u8 write_flag_mask; 129 130 bool use_single_rw; 131 132 enum regmap_endian reg_format_endian; 133 enum regmap_endian val_format_endian; 134 135 const struct regmap_range_cfg *ranges; 136 unsigned int n_ranges; 137 }; 138 139 /** 140 * Configuration for indirectly accessed or paged registers. 141 * Registers, mapped to this virtual range, are accessed in two steps: 142 * 1. page selector register update; 143 * 2. access through data window registers. 144 * 145 * @range_min: Address of the lowest register address in virtual range. 146 * @range_max: Address of the highest register in virtual range. 147 * 148 * @page_sel_reg: Register with selector field. 149 * @page_sel_mask: Bit shift for selector value. 150 * @page_sel_shift: Bit mask for selector value. 151 * 152 * @window_start: Address of first (lowest) register in data window. 153 * @window_len: Number of registers in data window. 154 */ 155 struct regmap_range_cfg { 156 /* Registers of virtual address range */ 157 unsigned int range_min; 158 unsigned int range_max; 159 160 /* Page selector for indirect addressing */ 161 unsigned int selector_reg; 162 unsigned int selector_mask; 163 int selector_shift; 164 165 /* Data window (per each page) */ 166 unsigned int window_start; 167 unsigned int window_len; 168 }; 169 170 typedef int (*regmap_hw_write)(void *context, const void *data, 171 size_t count); 172 typedef int (*regmap_hw_gather_write)(void *context, 173 const void *reg, size_t reg_len, 174 const void *val, size_t val_len); 175 typedef int (*regmap_hw_read)(void *context, 176 const void *reg_buf, size_t reg_size, 177 void *val_buf, size_t val_size); 178 typedef void (*regmap_hw_free_context)(void *context); 179 180 /** 181 * Description of a hardware bus for the register map infrastructure. 182 * 183 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex 184 * to perform locking. 185 * @write: Write operation. 186 * @gather_write: Write operation with split register/value, return -ENOTSUPP 187 * if not implemented on a given device. 188 * @read: Read operation. Data is returned in the buffer used to transmit 189 * data. 190 * @read_flag_mask: Mask to be set in the top byte of the register when doing 191 * a read. 192 * @reg_format_endian_default: Default endianness for formatted register 193 * addresses. Used when the regmap_config specifies DEFAULT. If this is 194 * DEFAULT, BIG is assumed. 195 * @val_format_endian_default: Default endianness for formatted register 196 * values. Used when the regmap_config specifies DEFAULT. If this is 197 * DEFAULT, BIG is assumed. 198 */ 199 struct regmap_bus { 200 bool fast_io; 201 regmap_hw_write write; 202 regmap_hw_gather_write gather_write; 203 regmap_hw_read read; 204 regmap_hw_free_context free_context; 205 u8 read_flag_mask; 206 enum regmap_endian reg_format_endian_default; 207 enum regmap_endian val_format_endian_default; 208 }; 209 210 struct regmap *regmap_init(struct device *dev, 211 const struct regmap_bus *bus, 212 void *bus_context, 213 const struct regmap_config *config); 214 struct regmap *regmap_init_i2c(struct i2c_client *i2c, 215 const struct regmap_config *config); 216 struct regmap *regmap_init_spi(struct spi_device *dev, 217 const struct regmap_config *config); 218 struct regmap *regmap_init_mmio(struct device *dev, 219 void __iomem *regs, 220 const struct regmap_config *config); 221 222 struct regmap *devm_regmap_init(struct device *dev, 223 const struct regmap_bus *bus, 224 void *bus_context, 225 const struct regmap_config *config); 226 struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c, 227 const struct regmap_config *config); 228 struct regmap *devm_regmap_init_spi(struct spi_device *dev, 229 const struct regmap_config *config); 230 struct regmap *devm_regmap_init_mmio(struct device *dev, 231 void __iomem *regs, 232 const struct regmap_config *config); 233 234 void regmap_exit(struct regmap *map); 235 int regmap_reinit_cache(struct regmap *map, 236 const struct regmap_config *config); 237 struct regmap *dev_get_regmap(struct device *dev, const char *name); 238 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val); 239 int regmap_raw_write(struct regmap *map, unsigned int reg, 240 const void *val, size_t val_len); 241 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val, 242 size_t val_count); 243 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val); 244 int regmap_raw_read(struct regmap *map, unsigned int reg, 245 void *val, size_t val_len); 246 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val, 247 size_t val_count); 248 int regmap_update_bits(struct regmap *map, unsigned int reg, 249 unsigned int mask, unsigned int val); 250 int regmap_update_bits_check(struct regmap *map, unsigned int reg, 251 unsigned int mask, unsigned int val, 252 bool *change); 253 int regmap_get_val_bytes(struct regmap *map); 254 255 int regcache_sync(struct regmap *map); 256 int regcache_sync_region(struct regmap *map, unsigned int min, 257 unsigned int max); 258 void regcache_cache_only(struct regmap *map, bool enable); 259 void regcache_cache_bypass(struct regmap *map, bool enable); 260 void regcache_mark_dirty(struct regmap *map); 261 262 int regmap_register_patch(struct regmap *map, const struct reg_default *regs, 263 int num_regs); 264 265 /** 266 * Description of an IRQ for the generic regmap irq_chip. 267 * 268 * @reg_offset: Offset of the status/mask register within the bank 269 * @mask: Mask used to flag/control the register. 270 */ 271 struct regmap_irq { 272 unsigned int reg_offset; 273 unsigned int mask; 274 }; 275 276 /** 277 * Description of a generic regmap irq_chip. This is not intended to 278 * handle every possible interrupt controller, but it should handle a 279 * substantial proportion of those that are found in the wild. 280 * 281 * @name: Descriptive name for IRQ controller. 282 * 283 * @status_base: Base status register address. 284 * @mask_base: Base mask register address. 285 * @ack_base: Base ack address. If zero then the chip is clear on read. 286 * @wake_base: Base address for wake enables. If zero unsupported. 287 * @irq_reg_stride: Stride to use for chips where registers are not contiguous. 288 * 289 * @num_regs: Number of registers in each control bank. 290 * @irqs: Descriptors for individual IRQs. Interrupt numbers are 291 * assigned based on the index in the array of the interrupt. 292 * @num_irqs: Number of descriptors. 293 */ 294 struct regmap_irq_chip { 295 const char *name; 296 297 unsigned int status_base; 298 unsigned int mask_base; 299 unsigned int ack_base; 300 unsigned int wake_base; 301 unsigned int irq_reg_stride; 302 303 int num_regs; 304 305 const struct regmap_irq *irqs; 306 int num_irqs; 307 }; 308 309 struct regmap_irq_chip_data; 310 311 int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags, 312 int irq_base, const struct regmap_irq_chip *chip, 313 struct regmap_irq_chip_data **data); 314 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data); 315 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data); 316 int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq); 317 318 #else 319 320 /* 321 * These stubs should only ever be called by generic code which has 322 * regmap based facilities, if they ever get called at runtime 323 * something is going wrong and something probably needs to select 324 * REGMAP. 325 */ 326 327 static inline int regmap_write(struct regmap *map, unsigned int reg, 328 unsigned int val) 329 { 330 WARN_ONCE(1, "regmap API is disabled"); 331 return -EINVAL; 332 } 333 334 static inline int regmap_raw_write(struct regmap *map, unsigned int reg, 335 const void *val, size_t val_len) 336 { 337 WARN_ONCE(1, "regmap API is disabled"); 338 return -EINVAL; 339 } 340 341 static inline int regmap_bulk_write(struct regmap *map, unsigned int reg, 342 const void *val, size_t val_count) 343 { 344 WARN_ONCE(1, "regmap API is disabled"); 345 return -EINVAL; 346 } 347 348 static inline int regmap_read(struct regmap *map, unsigned int reg, 349 unsigned int *val) 350 { 351 WARN_ONCE(1, "regmap API is disabled"); 352 return -EINVAL; 353 } 354 355 static inline int regmap_raw_read(struct regmap *map, unsigned int reg, 356 void *val, size_t val_len) 357 { 358 WARN_ONCE(1, "regmap API is disabled"); 359 return -EINVAL; 360 } 361 362 static inline int regmap_bulk_read(struct regmap *map, unsigned int reg, 363 void *val, size_t val_count) 364 { 365 WARN_ONCE(1, "regmap API is disabled"); 366 return -EINVAL; 367 } 368 369 static inline int regmap_update_bits(struct regmap *map, unsigned int reg, 370 unsigned int mask, unsigned int val) 371 { 372 WARN_ONCE(1, "regmap API is disabled"); 373 return -EINVAL; 374 } 375 376 static inline int regmap_update_bits_check(struct regmap *map, 377 unsigned int reg, 378 unsigned int mask, unsigned int val, 379 bool *change) 380 { 381 WARN_ONCE(1, "regmap API is disabled"); 382 return -EINVAL; 383 } 384 385 static inline int regmap_get_val_bytes(struct regmap *map) 386 { 387 WARN_ONCE(1, "regmap API is disabled"); 388 return -EINVAL; 389 } 390 391 static inline int regcache_sync(struct regmap *map) 392 { 393 WARN_ONCE(1, "regmap API is disabled"); 394 return -EINVAL; 395 } 396 397 static inline int regcache_sync_region(struct regmap *map, unsigned int min, 398 unsigned int max) 399 { 400 WARN_ONCE(1, "regmap API is disabled"); 401 return -EINVAL; 402 } 403 404 static inline void regcache_cache_only(struct regmap *map, bool enable) 405 { 406 WARN_ONCE(1, "regmap API is disabled"); 407 } 408 409 static inline void regcache_cache_bypass(struct regmap *map, bool enable) 410 { 411 WARN_ONCE(1, "regmap API is disabled"); 412 } 413 414 static inline void regcache_mark_dirty(struct regmap *map) 415 { 416 WARN_ONCE(1, "regmap API is disabled"); 417 } 418 419 static inline int regmap_register_patch(struct regmap *map, 420 const struct reg_default *regs, 421 int num_regs) 422 { 423 WARN_ONCE(1, "regmap API is disabled"); 424 return -EINVAL; 425 } 426 427 static inline struct regmap *dev_get_regmap(struct device *dev, 428 const char *name) 429 { 430 return NULL; 431 } 432 433 #endif 434 435 #endif 436