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