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 18 struct module; 19 struct device; 20 struct i2c_client; 21 struct spi_device; 22 struct regmap; 23 24 /* An enum of all the supported cache types */ 25 enum regcache_type { 26 REGCACHE_NONE, 27 REGCACHE_RBTREE, 28 REGCACHE_COMPRESSED 29 }; 30 31 /** 32 * Default value for a register. We use an array of structs rather 33 * than a simple array as many modern devices have very sparse 34 * register maps. 35 * 36 * @reg: Register address. 37 * @def: Register default value. 38 */ 39 struct reg_default { 40 unsigned int reg; 41 unsigned int def; 42 }; 43 44 #ifdef CONFIG_REGMAP 45 46 /** 47 * Configuration for the register map of a device. 48 * 49 * @name: Optional name of the regmap. Useful when a device has multiple 50 * register regions. 51 * 52 * @reg_bits: Number of bits in a register address, mandatory. 53 * @reg_stride: The register address stride. Valid register addresses are a 54 * multiple of this value. If set to 0, a value of 1 will be 55 * used. 56 * @pad_bits: Number of bits of padding between register and value. 57 * @val_bits: Number of bits in a register value, mandatory. 58 * 59 * @writeable_reg: Optional callback returning true if the register 60 * can be written to. 61 * @readable_reg: Optional callback returning true if the register 62 * can be read from. 63 * @volatile_reg: Optional callback returning true if the register 64 * value can't be cached. 65 * @precious_reg: Optional callback returning true if the rgister 66 * should not be read outside of a call from the driver 67 * (eg, a clear on read interrupt status register). 68 * 69 * @max_register: Optional, specifies the maximum valid register index. 70 * @reg_defaults: Power on reset values for registers (for use with 71 * register cache support). 72 * @num_reg_defaults: Number of elements in reg_defaults. 73 * 74 * @read_flag_mask: Mask to be set in the top byte of the register when doing 75 * a read. 76 * @write_flag_mask: Mask to be set in the top byte of the register when doing 77 * a write. If both read_flag_mask and write_flag_mask are 78 * empty the regmap_bus default masks are used. 79 * @use_single_rw: If set, converts the bulk read and write operations into 80 * a series of single read and write operations. This is useful 81 * for device that does not support bulk read and write. 82 * 83 * @cache_type: The actual cache type. 84 * @reg_defaults_raw: Power on reset values for registers (for use with 85 * register cache support). 86 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw. 87 */ 88 struct regmap_config { 89 const char *name; 90 91 int reg_bits; 92 int reg_stride; 93 int pad_bits; 94 int val_bits; 95 96 bool (*writeable_reg)(struct device *dev, unsigned int reg); 97 bool (*readable_reg)(struct device *dev, unsigned int reg); 98 bool (*volatile_reg)(struct device *dev, unsigned int reg); 99 bool (*precious_reg)(struct device *dev, unsigned int reg); 100 101 unsigned int max_register; 102 const struct reg_default *reg_defaults; 103 unsigned int num_reg_defaults; 104 enum regcache_type cache_type; 105 const void *reg_defaults_raw; 106 unsigned int num_reg_defaults_raw; 107 108 u8 read_flag_mask; 109 u8 write_flag_mask; 110 111 bool use_single_rw; 112 }; 113 114 typedef int (*regmap_hw_write)(void *context, const void *data, 115 size_t count); 116 typedef int (*regmap_hw_gather_write)(void *context, 117 const void *reg, size_t reg_len, 118 const void *val, size_t val_len); 119 typedef int (*regmap_hw_read)(void *context, 120 const void *reg_buf, size_t reg_size, 121 void *val_buf, size_t val_size); 122 typedef void (*regmap_hw_free_context)(void *context); 123 124 /** 125 * Description of a hardware bus for the register map infrastructure. 126 * 127 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex 128 * to perform locking. 129 * @write: Write operation. 130 * @gather_write: Write operation with split register/value, return -ENOTSUPP 131 * if not implemented on a given device. 132 * @read: Read operation. Data is returned in the buffer used to transmit 133 * data. 134 * @read_flag_mask: Mask to be set in the top byte of the register when doing 135 * a read. 136 */ 137 struct regmap_bus { 138 bool fast_io; 139 regmap_hw_write write; 140 regmap_hw_gather_write gather_write; 141 regmap_hw_read read; 142 regmap_hw_free_context free_context; 143 u8 read_flag_mask; 144 }; 145 146 struct regmap *regmap_init(struct device *dev, 147 const struct regmap_bus *bus, 148 void *bus_context, 149 const struct regmap_config *config); 150 struct regmap *regmap_init_i2c(struct i2c_client *i2c, 151 const struct regmap_config *config); 152 struct regmap *regmap_init_spi(struct spi_device *dev, 153 const struct regmap_config *config); 154 struct regmap *regmap_init_mmio(struct device *dev, 155 void __iomem *regs, 156 const struct regmap_config *config); 157 158 struct regmap *devm_regmap_init(struct device *dev, 159 const struct regmap_bus *bus, 160 void *bus_context, 161 const struct regmap_config *config); 162 struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c, 163 const struct regmap_config *config); 164 struct regmap *devm_regmap_init_spi(struct spi_device *dev, 165 const struct regmap_config *config); 166 struct regmap *devm_regmap_init_mmio(struct device *dev, 167 void __iomem *regs, 168 const struct regmap_config *config); 169 170 void regmap_exit(struct regmap *map); 171 int regmap_reinit_cache(struct regmap *map, 172 const struct regmap_config *config); 173 struct regmap *dev_get_regmap(struct device *dev, const char *name); 174 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val); 175 int regmap_raw_write(struct regmap *map, unsigned int reg, 176 const void *val, size_t val_len); 177 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val, 178 size_t val_count); 179 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val); 180 int regmap_raw_read(struct regmap *map, unsigned int reg, 181 void *val, size_t val_len); 182 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val, 183 size_t val_count); 184 int regmap_update_bits(struct regmap *map, unsigned int reg, 185 unsigned int mask, unsigned int val); 186 int regmap_update_bits_check(struct regmap *map, unsigned int reg, 187 unsigned int mask, unsigned int val, 188 bool *change); 189 int regmap_get_val_bytes(struct regmap *map); 190 191 int regcache_sync(struct regmap *map); 192 int regcache_sync_region(struct regmap *map, unsigned int min, 193 unsigned int max); 194 void regcache_cache_only(struct regmap *map, bool enable); 195 void regcache_cache_bypass(struct regmap *map, bool enable); 196 void regcache_mark_dirty(struct regmap *map); 197 198 int regmap_register_patch(struct regmap *map, const struct reg_default *regs, 199 int num_regs); 200 201 /** 202 * Description of an IRQ for the generic regmap irq_chip. 203 * 204 * @reg_offset: Offset of the status/mask register within the bank 205 * @mask: Mask used to flag/control the register. 206 */ 207 struct regmap_irq { 208 unsigned int reg_offset; 209 unsigned int mask; 210 }; 211 212 /** 213 * Description of a generic regmap irq_chip. This is not intended to 214 * handle every possible interrupt controller, but it should handle a 215 * substantial proportion of those that are found in the wild. 216 * 217 * @name: Descriptive name for IRQ controller. 218 * 219 * @status_base: Base status register address. 220 * @mask_base: Base mask register address. 221 * @ack_base: Base ack address. If zero then the chip is clear on read. 222 * @irq_reg_stride: Stride to use for chips where registers are not contiguous. 223 * 224 * @num_regs: Number of registers in each control bank. 225 * @irqs: Descriptors for individual IRQs. Interrupt numbers are 226 * assigned based on the index in the array of the interrupt. 227 * @num_irqs: Number of descriptors. 228 */ 229 struct regmap_irq_chip { 230 const char *name; 231 232 unsigned int status_base; 233 unsigned int mask_base; 234 unsigned int ack_base; 235 unsigned int irq_reg_stride; 236 237 int num_regs; 238 239 const struct regmap_irq *irqs; 240 int num_irqs; 241 }; 242 243 struct regmap_irq_chip_data; 244 245 int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags, 246 int irq_base, struct regmap_irq_chip *chip, 247 struct regmap_irq_chip_data **data); 248 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data); 249 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data); 250 int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq); 251 252 #else 253 254 /* 255 * These stubs should only ever be called by generic code which has 256 * regmap based facilities, if they ever get called at runtime 257 * something is going wrong and something probably needs to select 258 * REGMAP. 259 */ 260 261 static inline int regmap_write(struct regmap *map, unsigned int reg, 262 unsigned int val) 263 { 264 WARN_ONCE(1, "regmap API is disabled"); 265 return -EINVAL; 266 } 267 268 static inline int regmap_raw_write(struct regmap *map, unsigned int reg, 269 const void *val, size_t val_len) 270 { 271 WARN_ONCE(1, "regmap API is disabled"); 272 return -EINVAL; 273 } 274 275 static inline int regmap_bulk_write(struct regmap *map, unsigned int reg, 276 const void *val, size_t val_count) 277 { 278 WARN_ONCE(1, "regmap API is disabled"); 279 return -EINVAL; 280 } 281 282 static inline int regmap_read(struct regmap *map, unsigned int reg, 283 unsigned int *val) 284 { 285 WARN_ONCE(1, "regmap API is disabled"); 286 return -EINVAL; 287 } 288 289 static inline int regmap_raw_read(struct regmap *map, unsigned int reg, 290 void *val, size_t val_len) 291 { 292 WARN_ONCE(1, "regmap API is disabled"); 293 return -EINVAL; 294 } 295 296 static inline int regmap_bulk_read(struct regmap *map, unsigned int reg, 297 void *val, size_t val_count) 298 { 299 WARN_ONCE(1, "regmap API is disabled"); 300 return -EINVAL; 301 } 302 303 static inline int regmap_update_bits(struct regmap *map, unsigned int reg, 304 unsigned int mask, unsigned int val) 305 { 306 WARN_ONCE(1, "regmap API is disabled"); 307 return -EINVAL; 308 } 309 310 static inline int regmap_update_bits_check(struct regmap *map, 311 unsigned int reg, 312 unsigned int mask, unsigned int val, 313 bool *change) 314 { 315 WARN_ONCE(1, "regmap API is disabled"); 316 return -EINVAL; 317 } 318 319 static inline int regmap_get_val_bytes(struct regmap *map) 320 { 321 WARN_ONCE(1, "regmap API is disabled"); 322 return -EINVAL; 323 } 324 325 static inline int regcache_sync(struct regmap *map) 326 { 327 WARN_ONCE(1, "regmap API is disabled"); 328 return -EINVAL; 329 } 330 331 static inline int regcache_sync_region(struct regmap *map, unsigned int min, 332 unsigned int max) 333 { 334 WARN_ONCE(1, "regmap API is disabled"); 335 return -EINVAL; 336 } 337 338 static inline void regcache_cache_only(struct regmap *map, bool enable) 339 { 340 WARN_ONCE(1, "regmap API is disabled"); 341 } 342 343 static inline void regcache_cache_bypass(struct regmap *map, bool enable) 344 { 345 WARN_ONCE(1, "regmap API is disabled"); 346 } 347 348 static inline void regcache_mark_dirty(struct regmap *map) 349 { 350 WARN_ONCE(1, "regmap API is disabled"); 351 } 352 353 static inline int regmap_register_patch(struct regmap *map, 354 const struct reg_default *regs, 355 int num_regs) 356 { 357 WARN_ONCE(1, "regmap API is disabled"); 358 return -EINVAL; 359 } 360 361 static inline struct regmap *dev_get_regmap(struct device *dev, 362 const char *name) 363 { 364 WARN_ONCE(1, "regmap API is disabled"); 365 return NULL; 366 } 367 368 #endif 369 370 #endif 371