| 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 | #include <linux/err.h>
|
| 19 | #include <linux/bug.h>
|
| 20 |
|
| 21 | struct module;
|
| 22 | struct device;
|
| 23 | struct i2c_client;
|
| 24 | struct irq_domain;
|
| 25 | struct spi_device;
|
| 26 | struct spmi_device;
|
| 27 | struct regmap;
|
| 28 | struct regmap_range_cfg;
|
| 29 | struct regmap_field;
|
| 30 |
|
| 31 |
|
| 32 | enum regcache_type {
|
| 33 | REGCACHE_NONE,
|
| 34 | REGCACHE_RBTREE,
|
| 35 | REGCACHE_COMPRESSED,
|
| 36 | REGCACHE_FLAT,
|
| 37 | };
|
| 38 |
|
| 39 | |
| 40 | * Default value for a register. We use an array of structs rather
|
| 41 | * than a simple array as many modern devices have very sparse
|
| 42 | * register maps.
|
| 43 | *
|
| 44 | * @reg: Register address.
|
| 45 | * @def: Register default value.
|
| 46 |
|
| 47 | struct reg_default {
|
| 48 | unsigned int reg;
|
| 49 | unsigned int def;
|
| 50 | };
|
| 51 |
|
| 52 | #ifdef CONFIG_REGMAP
|
| 53 |
|
| 54 | enum regmap_endian {
|
| 55 |
|
| 56 | REGMAP_ENDIAN_DEFAULT = 0,
|
| 57 | REGMAP_ENDIAN_BIG,
|
| 58 | REGMAP_ENDIAN_LITTLE,
|
| 59 | REGMAP_ENDIAN_NATIVE,
|
| 60 | };
|
| 61 |
|
| 62 | |
| 63 | * A register range, used for access related checks
|
| 64 | * (readable/writeable/volatile/precious checks)
|
| 65 | *
|
| 66 | * @range_min: address of first register
|
| 67 | * @range_max: address of last register
|
| 68 |
|
| 69 | struct regmap_range {
|
| 70 | unsigned int range_min;
|
| 71 | unsigned int range_max;
|
| 72 | };
|
| 73 |
|
| 74 | #define regmap_reg_range(low, high) { .range_min = low, .range_max = high, }
|
| 75 |
|
| 76 | |
| 77 | * A table of ranges including some yes ranges and some no ranges.
|
| 78 | * If a register belongs to a no_range, the corresponding check function
|
| 79 | * will return false. If a register belongs to a yes range, the corresponding
|
| 80 | * check function will return true. "no_ranges" are searched first.
|
| 81 | *
|
| 82 | * @yes_ranges : pointer to an array of regmap ranges used as "yes ranges"
|
| 83 | * @n_yes_ranges: size of the above array
|
| 84 | * @no_ranges: pointer to an array of regmap ranges used as "no ranges"
|
| 85 | * @n_no_ranges: size of the above array
|
| 86 |
|
| 87 | struct regmap_access_table {
|
| 88 | const struct regmap_range *yes_ranges;
|
| 89 | unsigned int n_yes_ranges;
|
| 90 | const struct regmap_range *no_ranges;
|
| 91 | unsigned int n_no_ranges;
|
| 92 | };
|
| 93 |
|
| 94 | typedef void (*regmap_lock)(void *);
|
| 95 | typedef void (*regmap_unlock)(void *);
|
| 96 |
|
| 97 | |
| 98 | * Configuration for the register map of a device.
|
| 99 | *
|
| 100 | * @name: Optional name of the regmap. Useful when a device has multiple
|
| 101 | * register regions.
|
| 102 | *
|
| 103 | * @reg_bits: Number of bits in a register address, mandatory.
|
| 104 | * @reg_stride: The register address stride. Valid register addresses are a
|
| 105 | * multiple of this value. If set to 0, a value of 1 will be
|
| 106 | * used.
|
| 107 | * @pad_bits: Number of bits of padding between register and value.
|
| 108 | * @val_bits: Number of bits in a register value, mandatory.
|
| 109 | *
|
| 110 | * @writeable_reg: Optional callback returning true if the register
|
| 111 | * can be written to. If this field is NULL but wr_table
|
| 112 | * (see below) is not, the check is performed on such table
|
| 113 | * (a register is writeable if it belongs to one of the ranges
|
| 114 | * specified by wr_table).
|
| 115 | * @readable_reg: Optional callback returning true if the register
|
| 116 | * can be read from. If this field is NULL but rd_table
|
| 117 | * (see below) is not, the check is performed on such table
|
| 118 | * (a register is readable if it belongs to one of the ranges
|
| 119 | * specified by rd_table).
|
| 120 | * @volatile_reg: Optional callback returning true if the register
|
| 121 | * value can't be cached. If this field is NULL but
|
| 122 | * volatile_table (see below) is not, the check is performed on
|
| 123 | * such table (a register is volatile if it belongs to one of
|
| 124 | * the ranges specified by volatile_table).
|
| 125 | * @precious_reg: Optional callback returning true if the rgister
|
| 126 | * should not be read outside of a call from the driver
|
| 127 | * (eg, a clear on read interrupt status register). If this
|
| 128 | * field is NULL but precious_table (see below) is not, the
|
| 129 | * check is performed on such table (a register is precious if
|
| 130 | * it belongs to one of the ranges specified by precious_table).
|
| 131 | * @lock: Optional lock callback (overrides regmap's default lock
|
| 132 | * function, based on spinlock or mutex).
|
| 133 | * @unlock: As above for unlocking.
|
| 134 | * @lock_arg: this field is passed as the only argument of lock/unlock
|
| 135 | * functions (ignored in case regular lock/unlock functions
|
| 136 | * are not overridden).
|
| 137 | * @reg_read: Optional callback that if filled will be used to perform
|
| 138 | * all the reads from the registers. Should only be provided for
|
| 139 | * devices whos read operation cannot be represented as a simple read
|
| 140 | * operation on a bus such as SPI, I2C, etc. Most of the devices do
|
| 141 | * not need this.
|
| 142 | * @reg_write: Same as above for writing.
|
| 143 | * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
|
| 144 | * to perform locking. This field is ignored if custom lock/unlock
|
| 145 | * functions are used (see fields lock/unlock of struct regmap_config).
|
| 146 | * This field is a duplicate of a similar file in
|
| 147 | * 'struct regmap_bus' and serves exact same purpose.
|
| 148 | * Use it only for "no-bus" cases.
|
| 149 | * @max_register: Optional, specifies the maximum valid register index.
|
| 150 | * @wr_table: Optional, points to a struct regmap_access_table specifying
|
| 151 | * valid ranges for write access.
|
| 152 | * @rd_table: As above, for read access.
|
| 153 | * @volatile_table: As above, for volatile registers.
|
| 154 | * @precious_table: As above, for precious registers.
|
| 155 | * @reg_defaults: Power on reset values for registers (for use with
|
| 156 | * register cache support).
|
| 157 | * @num_reg_defaults: Number of elements in reg_defaults.
|
| 158 | *
|
| 159 | * @read_flag_mask: Mask to be set in the top byte of the register when doing
|
| 160 | * a read.
|
| 161 | * @write_flag_mask: Mask to be set in the top byte of the register when doing
|
| 162 | * a write. If both read_flag_mask and write_flag_mask are
|
| 163 | * empty the regmap_bus default masks are used.
|
| 164 | * @use_single_rw: If set, converts the bulk read and write operations into
|
| 165 | * a series of single read and write operations. This is useful
|
| 166 | * for device that does not support bulk read and write.
|
| 167 | *
|
| 168 | * @cache_type: The actual cache type.
|
| 169 | * @reg_defaults_raw: Power on reset values for registers (for use with
|
| 170 | * register cache support).
|
| 171 | * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
|
| 172 | * @reg_format_endian: Endianness for formatted register addresses. If this is
|
| 173 | * DEFAULT, the @reg_format_endian_default value from the
|
| 174 | * regmap bus is used.
|
| 175 | * @val_format_endian: Endianness for formatted register values. If this is
|
| 176 | * DEFAULT, the @reg_format_endian_default value from the
|
| 177 | * regmap bus is used.
|
| 178 | *
|
| 179 | * @ranges: Array of configuration entries for virtual address ranges.
|
| 180 | * @num_ranges: Number of range configuration entries.
|
| 181 |
|
| 182 | struct regmap_config {
|
| 183 | const char *name;
|
| 184 |
|
| 185 | int reg_bits;
|
| 186 | int reg_stride;
|
| 187 | int pad_bits;
|
| 188 | int val_bits;
|
| 189 |
|
| 190 | bool (*writeable_reg)(struct device *dev, unsigned int reg);
|
| 191 | bool (*readable_reg)(struct device *dev, unsigned int reg);
|
| 192 | bool (*volatile_reg)(struct device *dev, unsigned int reg);
|
| 193 | bool (*precious_reg)(struct device *dev, unsigned int reg);
|
| 194 | regmap_lock lock;
|
| 195 | regmap_unlock unlock;
|
| 196 | void *lock_arg;
|
| 197 |
|
| 198 | int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
|
| 199 | int (*reg_write)(void *context, unsigned int reg, unsigned int val);
|
| 200 |
|
| 201 | bool fast_io;
|
| 202 |
|
| 203 | unsigned int max_register;
|
| 204 | const struct regmap_access_table *wr_table;
|
| 205 | const struct regmap_access_table *rd_table;
|
| 206 | const struct regmap_access_table *volatile_table;
|
| 207 | const struct regmap_access_table *precious_table;
|
| 208 | const struct reg_default *reg_defaults;
|
| 209 | unsigned int num_reg_defaults;
|
| 210 | enum regcache_type cache_type;
|
| 211 | const void *reg_defaults_raw;
|
| 212 | unsigned int num_reg_defaults_raw;
|
| 213 |
|
| 214 | u8 read_flag_mask;
|
| 215 | u8 write_flag_mask;
|
| 216 |
|
| 217 | bool use_single_rw;
|
| 218 |
|
| 219 | enum regmap_endian reg_format_endian;
|
| 220 | enum regmap_endian val_format_endian;
|
| 221 |
|
| 222 | const struct regmap_range_cfg *ranges;
|
| 223 | unsigned int num_ranges;
|
| 224 | };
|
| 225 |
|
| 226 | |
| 227 | * Configuration for indirectly accessed or paged registers.
|
| 228 | * Registers, mapped to this virtual range, are accessed in two steps:
|
| 229 | * 1. page selector register update;
|
| 230 | * 2. access through data window registers.
|
| 231 | *
|
| 232 | * @name: Descriptive name for diagnostics
|
| 233 | *
|
| 234 | * @range_min: Address of the lowest register address in virtual range.
|
| 235 | * @range_max: Address of the highest register in virtual range.
|
| 236 | *
|
| 237 | * @page_sel_reg: Register with selector field.
|
| 238 | * @page_sel_mask: Bit shift for selector value.
|
| 239 | * @page_sel_shift: Bit mask for selector value.
|
| 240 | *
|
| 241 | * @window_start: Address of first (lowest) register in data window.
|
| 242 | * @window_len: Number of registers in data window.
|
| 243 |
|
| 244 | struct regmap_range_cfg {
|
| 245 | const char *name;
|
| 246 |
|
| 247 |
|
| 248 | unsigned int range_min;
|
| 249 | unsigned int range_max;
|
| 250 |
|
| 251 |
|
| 252 | unsigned int selector_reg;
|
| 253 | unsigned int selector_mask;
|
| 254 | int selector_shift;
|
| 255 |
|
| 256 |
|
| 257 | unsigned int window_start;
|
| 258 | unsigned int window_len;
|
| 259 | };
|
| 260 |
|
| 261 | struct regmap_async;
|
| 262 |
|
| 263 | typedef int (*regmap_hw_write)(void *context, const void *data,
|
| 264 | size_t count);
|
| 265 | typedef int (*regmap_hw_gather_write)(void *context,
|
| 266 | const void *reg, size_t reg_len,
|
| 267 | const void *val, size_t val_len);
|
| 268 | typedef int (*regmap_hw_async_write)(void *context,
|
| 269 | const void *reg, size_t reg_len,
|
| 270 | const void *val, size_t val_len,
|
| 271 | struct regmap_async *async);
|
| 272 | typedef int (*regmap_hw_read)(void *context,
|
| 273 | const void *reg_buf, size_t reg_size,
|
| 274 | void *val_buf, size_t val_size);
|
| 275 | typedef struct regmap_async *(*regmap_hw_async_alloc)(void);
|
| 276 | typedef void (*regmap_hw_free_context)(void *context);
|
| 277 |
|
| 278 | |
| 279 | * Description of a hardware bus for the register map infrastructure.
|
| 280 | *
|
| 281 | * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
|
| 282 | * to perform locking. This field is ignored if custom lock/unlock
|
| 283 | * functions are used (see fields lock/unlock of
|
| 284 | * struct regmap_config).
|
| 285 | * @write: Write operation.
|
| 286 | * @gather_write: Write operation with split register/value, return -ENOTSUPP
|
| 287 | * if not implemented on a given device.
|
| 288 | * @async_write: Write operation which completes asynchronously, optional and
|
| 289 | * must serialise with respect to non-async I/O.
|
| 290 | * @read: Read operation. Data is returned in the buffer used to transmit
|
| 291 | * data.
|
| 292 | * @async_alloc: Allocate a regmap_async() structure.
|
| 293 | * @read_flag_mask: Mask to be set in the top byte of the register when doing
|
| 294 | * a read.
|
| 295 | * @reg_format_endian_default: Default endianness for formatted register
|
| 296 | * addresses. Used when the regmap_config specifies DEFAULT. If this is
|
| 297 | * DEFAULT, BIG is assumed.
|
| 298 | * @val_format_endian_default: Default endianness for formatted register
|
| 299 | * values. Used when the regmap_config specifies DEFAULT. If this is
|
| 300 | * DEFAULT, BIG is assumed.
|
| 301 | * @async_size: Size of struct used for async work.
|
| 302 |
|
| 303 | struct regmap_bus {
|
| 304 | bool fast_io;
|
| 305 | regmap_hw_write write;
|
| 306 | regmap_hw_gather_write gather_write;
|
| 307 | regmap_hw_async_write async_write;
|
| 308 | regmap_hw_read read;
|
| 309 | regmap_hw_free_context free_context;
|
| 310 | regmap_hw_async_alloc async_alloc;
|
| 311 | u8 read_flag_mask;
|
| 312 | enum regmap_endian reg_format_endian_default;
|
| 313 | enum regmap_endian val_format_endian_default;
|
| 314 | };
|
| 315 |
|
| 316 | struct regmap *regmap_init(struct device *dev,
|
| 317 | const struct regmap_bus *bus,
|
| 318 | void *bus_context,
|
| 319 | const struct regmap_config *config);
|
| 320 | struct regmap *regmap_init_i2c(struct i2c_client *i2c,
|
| 321 | const struct regmap_config *config);
|
| 322 | struct regmap *regmap_init_spi(struct spi_device *dev,
|
| 323 | const struct regmap_config *config);
|
| 324 | struct regmap *regmap_init_spmi(struct spmi_device *dev,
|
| 325 | const struct regmap_config *config);
|
| 326 | struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
|
| 327 | void __iomem *regs,
|
| 328 | const struct regmap_config *config);
|
| 329 |
|
| 330 | struct regmap *devm_regmap_init(struct device *dev,
|
| 331 | const struct regmap_bus *bus,
|
| 332 | void *bus_context,
|
| 333 | const struct regmap_config *config);
|
| 334 | struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
|
| 335 | const struct regmap_config *config);
|
| 336 | struct regmap *devm_regmap_init_spi(struct spi_device *dev,
|
| 337 | const struct regmap_config *config);
|
| 338 | struct regmap *devm_regmap_init_spmi(struct spmi_device *dev,
|
| 339 | const struct regmap_config *config);
|
| 340 | struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
|
| 341 | void __iomem *regs,
|
| 342 | const struct regmap_config *config);
|
| 343 |
|
| 344 | |
| 345 | * regmap_init_mmio(): Initialise register map
|
| 346 | *
|
| 347 | * @dev: Device that will be interacted with
|
| 348 | * @regs: Pointer to memory-mapped IO region
|
| 349 | * @config: Configuration for register map
|
| 350 | *
|
| 351 | * The return value will be an ERR_PTR() on error or a valid pointer to
|
| 352 | * a struct regmap.
|
| 353 |
|
| 354 | static inline struct regmap *regmap_init_mmio(struct device *dev,
|
| 355 | void __iomem *regs,
|
| 356 | const struct regmap_config *config)
|
| 357 | {
|
| 358 | return regmap_init_mmio_clk(dev, NULL, regs, config);
|
| 359 | }
|
| 360 |
|
| 361 | |
| 362 | * devm_regmap_init_mmio(): Initialise managed register map
|
| 363 | *
|
| 364 | * @dev: Device that will be interacted with
|
| 365 | * @regs: Pointer to memory-mapped IO region
|
| 366 | * @config: Configuration for register map
|
| 367 | *
|
| 368 | * The return value will be an ERR_PTR() on error or a valid pointer
|
| 369 | * to a struct regmap. The regmap will be automatically freed by the
|
| 370 | * device management code.
|
| 371 |
|
| 372 | static inline struct regmap *devm_regmap_init_mmio(struct device *dev,
|
| 373 | void __iomem *regs,
|
| 374 | const struct regmap_config *config)
|
| 375 | {
|
| 376 | return devm_regmap_init_mmio_clk(dev, NULL, regs, config);
|
| 377 | }
|
| 378 |
|
| 379 | void regmap_exit(struct regmap *map);
|
| 380 | int regmap_reinit_cache(struct regmap *map,
|
| 381 | const struct regmap_config *config);
|
| 382 | struct regmap *dev_get_regmap(struct device *dev, const char *name);
|
| 383 | int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
|
| 384 | int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val);
|
| 385 | int regmap_raw_write(struct regmap *map, unsigned int reg,
|
| 386 | const void *val, size_t val_len);
|
| 387 | int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
|
| 388 | size_t val_count);
|
| 389 | int regmap_multi_reg_write(struct regmap *map, struct reg_default *regs,
|
| 390 | int num_regs);
|
| 391 | int regmap_raw_write_async(struct regmap *map, unsigned int reg,
|
| 392 | const void *val, size_t val_len);
|
| 393 | int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
|
| 394 | int regmap_raw_read(struct regmap *map, unsigned int reg,
|
| 395 | void *val, size_t val_len);
|
| 396 | int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
|
| 397 | size_t val_count);
|
| 398 | int regmap_update_bits(struct regmap *map, unsigned int reg,
|
| 399 | unsigned int mask, unsigned int val);
|
| 400 | int regmap_update_bits_async(struct regmap *map, unsigned int reg,
|
| 401 | unsigned int mask, unsigned int val);
|
| 402 | int regmap_update_bits_check(struct regmap *map, unsigned int reg,
|
| 403 | unsigned int mask, unsigned int val,
|
| 404 | bool *change);
|
| 405 | int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
|
| 406 | unsigned int mask, unsigned int val,
|
| 407 | bool *change);
|
| 408 | int regmap_get_val_bytes(struct regmap *map);
|
| 409 | int regmap_async_complete(struct regmap *map);
|
| 410 | bool regmap_can_raw_write(struct regmap *map);
|
| 411 |
|
| 412 | int regcache_sync(struct regmap *map);
|
| 413 | int regcache_sync_region(struct regmap *map, unsigned int min,
|
| 414 | unsigned int max);
|
| 415 | int regcache_drop_region(struct regmap *map, unsigned int min,
|
| 416 | unsigned int max);
|
| 417 | void regcache_cache_only(struct regmap *map, bool enable);
|
| 418 | void regcache_cache_bypass(struct regmap *map, bool enable);
|
| 419 | void regcache_mark_dirty(struct regmap *map);
|
| 420 |
|
| 421 | bool regmap_check_range_table(struct regmap *map, unsigned int reg,
|
| 422 | const struct regmap_access_table *table);
|
| 423 |
|
| 424 | int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
|
| 425 | int num_regs);
|
| 426 |
|
| 427 | static inline bool regmap_reg_in_range(unsigned int reg,
|
| 428 | const struct regmap_range *range)
|
| 429 | {
|
| 430 | return reg >= range->range_min && reg <= range->range_max;
|
| 431 | }
|
| 432 |
|
| 433 | bool regmap_reg_in_ranges(unsigned int reg,
|
| 434 | const struct regmap_range *ranges,
|
| 435 | unsigned int nranges);
|
| 436 |
|
| 437 | |
| 438 | * Description of an register field
|
| 439 | *
|
| 440 | * @reg: Offset of the register within the regmap bank
|
| 441 | * @lsb: lsb of the register field.
|
| 442 | * @reg: msb of the register field.
|
| 443 | * @id_size: port size if it has some ports
|
| 444 | * @id_offset: address offset for each ports
|
| 445 |
|
| 446 | struct reg_field {
|
| 447 | unsigned int reg;
|
| 448 | unsigned int lsb;
|
| 449 | unsigned int msb;
|
| 450 | unsigned int id_size;
|
| 451 | unsigned int id_offset;
|
| 452 | };
|
| 453 |
|
| 454 | #define REG_FIELD(_reg, _lsb, _msb) { \
|
| 455 | .reg = _reg, \
|
| 456 | .lsb = _lsb, \
|
| 457 | .msb = _msb, \
|
| 458 | }
|
| 459 |
|
| 460 | struct regmap_field *regmap_field_alloc(struct regmap *regmap,
|
| 461 | struct reg_field reg_field);
|
| 462 | void regmap_field_free(struct regmap_field *field);
|
| 463 |
|
| 464 | struct regmap_field *devm_regmap_field_alloc(struct device *dev,
|
| 465 | struct regmap *regmap, struct reg_field reg_field);
|
| 466 | void devm_regmap_field_free(struct device *dev, struct regmap_field *field);
|
| 467 |
|
| 468 | int regmap_field_read(struct regmap_field *field, unsigned int *val);
|
| 469 | int regmap_field_write(struct regmap_field *field, unsigned int val);
|
| 470 | int regmap_field_update_bits(struct regmap_field *field,
|
| 471 | unsigned int mask, unsigned int val);
|
| 472 |
|
| 473 | int regmap_fields_write(struct regmap_field *field, unsigned int id,
|
| 474 | unsigned int val);
|
| 475 | int regmap_fields_read(struct regmap_field *field, unsigned int id,
|
| 476 | unsigned int *val);
|
| 477 | int regmap_fields_update_bits(struct regmap_field *field, unsigned int id,
|
| 478 | unsigned int mask, unsigned int val);
|
| 479 |
|
| 480 | |
| 481 | * Description of an IRQ for the generic regmap irq_chip.
|
| 482 | *
|
| 483 | * @reg_offset: Offset of the status/mask register within the bank
|
| 484 | * @mask: Mask used to flag/control the register.
|
| 485 |
|
| 486 | struct regmap_irq {
|
| 487 | unsigned int reg_offset;
|
| 488 | unsigned int mask;
|
| 489 | };
|
| 490 |
|
| 491 | |
| 492 | * Description of a generic regmap irq_chip. This is not intended to
|
| 493 | * handle every possible interrupt controller, but it should handle a
|
| 494 | * substantial proportion of those that are found in the wild.
|
| 495 | *
|
| 496 | * @name: Descriptive name for IRQ controller.
|
| 497 | *
|
| 498 | * @status_base: Base status register address.
|
| 499 | * @mask_base: Base mask register address.
|
| 500 | * @ack_base: Base ack address. If zero then the chip is clear on read.
|
| 501 | * @wake_base: Base address for wake enables. If zero unsupported.
|
| 502 | * @irq_reg_stride: Stride to use for chips where registers are not contiguous.
|
| 503 | * @init_ack_masked: Ack all masked interrupts once during initalization.
|
| 504 | * @mask_invert: Inverted mask register: cleared bits are masked out.
|
| 505 | * @wake_invert: Inverted wake register: cleared bits are wake enabled.
|
| 506 | * @runtime_pm: Hold a runtime PM lock on the device when accessing it.
|
| 507 | *
|
| 508 | * @num_regs: Number of registers in each control bank.
|
| 509 | * @irqs: Descriptors for individual IRQs. Interrupt numbers are
|
| 510 | * assigned based on the index in the array of the interrupt.
|
| 511 | * @num_irqs: Number of descriptors.
|
| 512 |
|
| 513 | struct regmap_irq_chip {
|
| 514 | const char *name;
|
| 515 |
|
| 516 | unsigned int status_base;
|
| 517 | unsigned int mask_base;
|
| 518 | unsigned int ack_base;
|
| 519 | unsigned int wake_base;
|
| 520 | unsigned int irq_reg_stride;
|
| 521 | bool init_ack_masked:1;
|
| 522 | bool mask_invert:1;
|
| 523 | bool wake_invert:1;
|
| 524 | bool runtime_pm:1;
|
| 525 |
|
| 526 | int num_regs;
|
| 527 |
|
| 528 | const struct regmap_irq *irqs;
|
| 529 | int num_irqs;
|
| 530 | };
|
| 531 |
|
| 532 | struct regmap_irq_chip_data;
|
| 533 |
|
| 534 | int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
|
| 535 | int irq_base, const struct regmap_irq_chip *chip,
|
| 536 | struct regmap_irq_chip_data **data);
|
| 537 | void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
|
| 538 | int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
|
| 539 | int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
|
| 540 | struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data);
|
| 541 |
|
| 542 | #else
|
| 543 |
|
| 544 | |
| 545 | * These stubs should only ever be called by generic code which has
|
| 546 | * regmap based facilities, if they ever get called at runtime
|
| 547 | * something is going wrong and something probably needs to select
|
| 548 | * REGMAP.
|
| 549 |
|
| 550 |
|
| 551 | static inline int regmap_write(struct regmap *map, unsigned int reg,
|
| 552 | unsigned int val)
|
| 553 | {
|
| 554 | WARN_ONCE(1, "regmap API is disabled");
|
| 555 | return -EINVAL;
|
| 556 | }
|
| 557 |
|
| 558 | static inline int regmap_write_async(struct regmap *map, unsigned int reg,
|
| 559 | unsigned int val)
|
| 560 | {
|
| 561 | WARN_ONCE(1, "regmap API is disabled");
|
| 562 | return -EINVAL;
|
| 563 | }
|
| 564 |
|
| 565 | static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
|
| 566 | const void *val, size_t val_len)
|
| 567 | {
|
| 568 | WARN_ONCE(1, "regmap API is disabled");
|
| 569 | return -EINVAL;
|
| 570 | }
|
| 571 |
|
| 572 | static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg,
|
| 573 | const void *val, size_t val_len)
|
| 574 | {
|
| 575 | WARN_ONCE(1, "regmap API is disabled");
|
| 576 | return -EINVAL;
|
| 577 | }
|
| 578 |
|
| 579 | static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
|
| 580 | const void *val, size_t val_count)
|
| 581 | {
|
| 582 | WARN_ONCE(1, "regmap API is disabled");
|
| 583 | return -EINVAL;
|
| 584 | }
|
| 585 |
|
| 586 | static inline int regmap_read(struct regmap *map, unsigned int reg,
|
| 587 | unsigned int *val)
|
| 588 | {
|
| 589 | WARN_ONCE(1, "regmap API is disabled");
|
| 590 | return -EINVAL;
|
| 591 | }
|
| 592 |
|
| 593 | static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
|
| 594 | void *val, size_t val_len)
|
| 595 | {
|
| 596 | WARN_ONCE(1, "regmap API is disabled");
|
| 597 | return -EINVAL;
|
| 598 | }
|
| 599 |
|
| 600 | static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
|
| 601 | void *val, size_t val_count)
|
| 602 | {
|
| 603 | WARN_ONCE(1, "regmap API is disabled");
|
| 604 | return -EINVAL;
|
| 605 | }
|
| 606 |
|
| 607 | static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
|
| 608 | unsigned int mask, unsigned int val)
|
| 609 | {
|
| 610 | WARN_ONCE(1, "regmap API is disabled");
|
| 611 | return -EINVAL;
|
| 612 | }
|
| 613 |
|
| 614 | static inline int regmap_update_bits_async(struct regmap *map,
|
| 615 | unsigned int reg,
|
| 616 | unsigned int mask, unsigned int val)
|
| 617 | {
|
| 618 | WARN_ONCE(1, "regmap API is disabled");
|
| 619 | return -EINVAL;
|
| 620 | }
|
| 621 |
|
| 622 | static inline int regmap_update_bits_check(struct regmap *map,
|
| 623 | unsigned int reg,
|
| 624 | unsigned int mask, unsigned int val,
|
| 625 | bool *change)
|
| 626 | {
|
| 627 | WARN_ONCE(1, "regmap API is disabled");
|
| 628 | return -EINVAL;
|
| 629 | }
|
| 630 |
|
| 631 | static inline int regmap_update_bits_check_async(struct regmap *map,
|
| 632 | unsigned int reg,
|
| 633 | unsigned int mask,
|
| 634 | unsigned int val,
|
| 635 | bool *change)
|
| 636 | {
|
| 637 | WARN_ONCE(1, "regmap API is disabled");
|
| 638 | return -EINVAL;
|
| 639 | }
|
| 640 |
|
| 641 | static inline int regmap_get_val_bytes(struct regmap *map)
|
| 642 | {
|
| 643 | WARN_ONCE(1, "regmap API is disabled");
|
| 644 | return -EINVAL;
|
| 645 | }
|
| 646 |
|
| 647 | static inline int regcache_sync(struct regmap *map)
|
| 648 | {
|
| 649 | WARN_ONCE(1, "regmap API is disabled");
|
| 650 | return -EINVAL;
|
| 651 | }
|
| 652 |
|
| 653 | static inline int regcache_sync_region(struct regmap *map, unsigned int min,
|
| 654 | unsigned int max)
|
| 655 | {
|
| 656 | WARN_ONCE(1, "regmap API is disabled");
|
| 657 | return -EINVAL;
|
| 658 | }
|
| 659 |
|
| 660 | static inline int regcache_drop_region(struct regmap *map, unsigned int min,
|
| 661 | unsigned int max)
|
| 662 | {
|
| 663 | WARN_ONCE(1, "regmap API is disabled");
|
| 664 | return -EINVAL;
|
| 665 | }
|
| 666 |
|
| 667 | static inline void regcache_cache_only(struct regmap *map, bool enable)
|
| 668 | {
|
| 669 | WARN_ONCE(1, "regmap API is disabled");
|
| 670 | }
|
| 671 |
|
| 672 | static inline void regcache_cache_bypass(struct regmap *map, bool enable)
|
| 673 | {
|
| 674 | WARN_ONCE(1, "regmap API is disabled");
|
| 675 | }
|
| 676 |
|
| 677 | static inline void regcache_mark_dirty(struct regmap *map)
|
| 678 | {
|
| 679 | WARN_ONCE(1, "regmap API is disabled");
|
| 680 | }
|
| 681 |
|
| 682 | static inline void regmap_async_complete(struct regmap *map)
|
| 683 | {
|
| 684 | WARN_ONCE(1, "regmap API is disabled");
|
| 685 | }
|
| 686 |
|
| 687 | static inline int regmap_register_patch(struct regmap *map,
|
| 688 | const struct reg_default *regs,
|
| 689 | int num_regs)
|
| 690 | {
|
| 691 | WARN_ONCE(1, "regmap API is disabled");
|
| 692 | return -EINVAL;
|
| 693 | }
|
| 694 |
|
| 695 | static inline struct regmap *dev_get_regmap(struct device *dev,
|
| 696 | const char *name)
|
| 697 | {
|
| 698 | return NULL;
|
| 699 | }
|
| 700 |
|
| 701 | #endif
|
| 702 |
|
| 703 | #endif
|