1 #ifndef __LINUX_REGMAP_H
2 #define __LINUX_REGMAP_H
5 * Register map access API
7 * Copyright 2011 Wolfson Microelectronics plc
9 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
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.
16 #include <linux/list.h>
17 #include <linux/rbtree.h>
18 #include <linux/err.h>
19 #include <linux/bug.h>
20 #include <linux/lockdep.h>
29 struct regmap_range_cfg;
33 /* An enum of all the supported cache types */
42 * Default value for a register. We use an array of structs rather
43 * than a simple array as many modern devices have very sparse
46 * @reg: Register address.
47 * @def: Register default value.
55 * Register/value pairs for sequences of writes with an optional delay in
56 * microseconds to be applied after each write.
58 * @reg: Register address.
59 * @def: Register value.
60 * @delay_us: Delay to be applied after the register write in microseconds
65 unsigned int delay_us;
71 /* Unspecified -> 0 -> Backwards compatible default */
72 REGMAP_ENDIAN_DEFAULT = 0,
79 * A register range, used for access related checks
80 * (readable/writeable/volatile/precious checks)
82 * @range_min: address of first register
83 * @range_max: address of last register
86 unsigned int range_min;
87 unsigned int range_max;
90 #define regmap_reg_range(low, high) { .range_min = low, .range_max = high, }
93 * A table of ranges including some yes ranges and some no ranges.
94 * If a register belongs to a no_range, the corresponding check function
95 * will return false. If a register belongs to a yes range, the corresponding
96 * check function will return true. "no_ranges" are searched first.
98 * @yes_ranges : pointer to an array of regmap ranges used as "yes ranges"
99 * @n_yes_ranges: size of the above array
100 * @no_ranges: pointer to an array of regmap ranges used as "no ranges"
101 * @n_no_ranges: size of the above array
103 struct regmap_access_table {
104 const struct regmap_range *yes_ranges;
105 unsigned int n_yes_ranges;
106 const struct regmap_range *no_ranges;
107 unsigned int n_no_ranges;
110 typedef void (*regmap_lock)(void *);
111 typedef void (*regmap_unlock)(void *);
114 * Configuration for the register map of a device.
116 * @name: Optional name of the regmap. Useful when a device has multiple
119 * @reg_bits: Number of bits in a register address, mandatory.
120 * @reg_stride: The register address stride. Valid register addresses are a
121 * multiple of this value. If set to 0, a value of 1 will be
123 * @pad_bits: Number of bits of padding between register and value.
124 * @val_bits: Number of bits in a register value, mandatory.
126 * @writeable_reg: Optional callback returning true if the register
127 * can be written to. If this field is NULL but wr_table
128 * (see below) is not, the check is performed on such table
129 * (a register is writeable if it belongs to one of the ranges
130 * specified by wr_table).
131 * @readable_reg: Optional callback returning true if the register
132 * can be read from. If this field is NULL but rd_table
133 * (see below) is not, the check is performed on such table
134 * (a register is readable if it belongs to one of the ranges
135 * specified by rd_table).
136 * @volatile_reg: Optional callback returning true if the register
137 * value can't be cached. If this field is NULL but
138 * volatile_table (see below) is not, the check is performed on
139 * such table (a register is volatile if it belongs to one of
140 * the ranges specified by volatile_table).
141 * @precious_reg: Optional callback returning true if the register
142 * should not be read outside of a call from the driver
143 * (e.g., a clear on read interrupt status register). If this
144 * field is NULL but precious_table (see below) is not, the
145 * check is performed on such table (a register is precious if
146 * it belongs to one of the ranges specified by precious_table).
147 * @lock: Optional lock callback (overrides regmap's default lock
148 * function, based on spinlock or mutex).
149 * @unlock: As above for unlocking.
150 * @lock_arg: this field is passed as the only argument of lock/unlock
151 * functions (ignored in case regular lock/unlock functions
152 * are not overridden).
153 * @reg_read: Optional callback that if filled will be used to perform
154 * all the reads from the registers. Should only be provided for
155 * devices whose read operation cannot be represented as a simple
156 * read operation on a bus such as SPI, I2C, etc. Most of the
157 * devices do not need this.
158 * @reg_write: Same as above for writing.
159 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
160 * to perform locking. This field is ignored if custom lock/unlock
161 * functions are used (see fields lock/unlock of struct regmap_config).
162 * This field is a duplicate of a similar file in
163 * 'struct regmap_bus' and serves exact same purpose.
164 * Use it only for "no-bus" cases.
165 * @max_register: Optional, specifies the maximum valid register index.
166 * @wr_table: Optional, points to a struct regmap_access_table specifying
167 * valid ranges for write access.
168 * @rd_table: As above, for read access.
169 * @volatile_table: As above, for volatile registers.
170 * @precious_table: As above, for precious registers.
171 * @reg_defaults: Power on reset values for registers (for use with
172 * register cache support).
173 * @num_reg_defaults: Number of elements in reg_defaults.
175 * @read_flag_mask: Mask to be set in the top byte of the register when doing
177 * @write_flag_mask: Mask to be set in the top byte of the register when doing
178 * a write. If both read_flag_mask and write_flag_mask are
179 * empty the regmap_bus default masks are used.
180 * @use_single_rw: If set, converts the bulk read and write operations into
181 * a series of single read and write operations. This is useful
182 * for device that does not support bulk read and write.
183 * @can_multi_write: If set, the device supports the multi write mode of bulk
184 * write operations, if clear multi write requests will be
185 * split into individual write operations
187 * @cache_type: The actual cache type.
188 * @reg_defaults_raw: Power on reset values for registers (for use with
189 * register cache support).
190 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
191 * @reg_format_endian: Endianness for formatted register addresses. If this is
192 * DEFAULT, the @reg_format_endian_default value from the
193 * regmap bus is used.
194 * @val_format_endian: Endianness for formatted register values. If this is
195 * DEFAULT, the @reg_format_endian_default value from the
196 * regmap bus is used.
198 * @ranges: Array of configuration entries for virtual address ranges.
199 * @num_ranges: Number of range configuration entries.
201 struct regmap_config {
209 bool (*writeable_reg)(struct device *dev, unsigned int reg);
210 bool (*readable_reg)(struct device *dev, unsigned int reg);
211 bool (*volatile_reg)(struct device *dev, unsigned int reg);
212 bool (*precious_reg)(struct device *dev, unsigned int reg);
214 regmap_unlock unlock;
217 int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
218 int (*reg_write)(void *context, unsigned int reg, unsigned int val);
222 unsigned int max_register;
223 const struct regmap_access_table *wr_table;
224 const struct regmap_access_table *rd_table;
225 const struct regmap_access_table *volatile_table;
226 const struct regmap_access_table *precious_table;
227 const struct reg_default *reg_defaults;
228 unsigned int num_reg_defaults;
229 enum regcache_type cache_type;
230 const void *reg_defaults_raw;
231 unsigned int num_reg_defaults_raw;
237 bool can_multi_write;
239 enum regmap_endian reg_format_endian;
240 enum regmap_endian val_format_endian;
242 const struct regmap_range_cfg *ranges;
243 unsigned int num_ranges;
247 * Configuration for indirectly accessed or paged registers.
248 * Registers, mapped to this virtual range, are accessed in two steps:
249 * 1. page selector register update;
250 * 2. access through data window registers.
252 * @name: Descriptive name for diagnostics
254 * @range_min: Address of the lowest register address in virtual range.
255 * @range_max: Address of the highest register in virtual range.
257 * @page_sel_reg: Register with selector field.
258 * @page_sel_mask: Bit shift for selector value.
259 * @page_sel_shift: Bit mask for selector value.
261 * @window_start: Address of first (lowest) register in data window.
262 * @window_len: Number of registers in data window.
264 struct regmap_range_cfg {
267 /* Registers of virtual address range */
268 unsigned int range_min;
269 unsigned int range_max;
271 /* Page selector for indirect addressing */
272 unsigned int selector_reg;
273 unsigned int selector_mask;
276 /* Data window (per each page) */
277 unsigned int window_start;
278 unsigned int window_len;
283 typedef int (*regmap_hw_write)(void *context, const void *data,
285 typedef int (*regmap_hw_gather_write)(void *context,
286 const void *reg, size_t reg_len,
287 const void *val, size_t val_len);
288 typedef int (*regmap_hw_async_write)(void *context,
289 const void *reg, size_t reg_len,
290 const void *val, size_t val_len,
291 struct regmap_async *async);
292 typedef int (*regmap_hw_read)(void *context,
293 const void *reg_buf, size_t reg_size,
294 void *val_buf, size_t val_size);
295 typedef int (*regmap_hw_reg_read)(void *context, unsigned int reg,
297 typedef int (*regmap_hw_reg_write)(void *context, unsigned int reg,
299 typedef struct regmap_async *(*regmap_hw_async_alloc)(void);
300 typedef void (*regmap_hw_free_context)(void *context);
303 * Description of a hardware bus for the register map infrastructure.
305 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
306 * to perform locking. This field is ignored if custom lock/unlock
307 * functions are used (see fields lock/unlock of
308 * struct regmap_config).
309 * @write: Write operation.
310 * @gather_write: Write operation with split register/value, return -ENOTSUPP
311 * if not implemented on a given device.
312 * @async_write: Write operation which completes asynchronously, optional and
313 * must serialise with respect to non-async I/O.
314 * @reg_write: Write a single register value to the given register address. This
315 * write operation has to complete when returning from the function.
316 * @read: Read operation. Data is returned in the buffer used to transmit
318 * @reg_read: Read a single register value from a given register address.
319 * @free_context: Free context.
320 * @async_alloc: Allocate a regmap_async() structure.
321 * @read_flag_mask: Mask to be set in the top byte of the register when doing
323 * @reg_format_endian_default: Default endianness for formatted register
324 * addresses. Used when the regmap_config specifies DEFAULT. If this is
325 * DEFAULT, BIG is assumed.
326 * @val_format_endian_default: Default endianness for formatted register
327 * values. Used when the regmap_config specifies DEFAULT. If this is
328 * DEFAULT, BIG is assumed.
329 * @max_raw_read: Max raw read size that can be used on the bus.
330 * @max_raw_write: Max raw write size that can be used on the bus.
334 regmap_hw_write write;
335 regmap_hw_gather_write gather_write;
336 regmap_hw_async_write async_write;
337 regmap_hw_reg_write reg_write;
339 regmap_hw_reg_read reg_read;
340 regmap_hw_free_context free_context;
341 regmap_hw_async_alloc async_alloc;
343 enum regmap_endian reg_format_endian_default;
344 enum regmap_endian val_format_endian_default;
346 size_t max_raw_write;
350 * __regmap_init functions.
352 * These functions take a lock key and name parameter, and should not be called
353 * directly. Instead, use the regmap_init macros that generate a key and name
356 struct regmap *__regmap_init(struct device *dev,
357 const struct regmap_bus *bus,
359 const struct regmap_config *config,
360 struct lock_class_key *lock_key,
361 const char *lock_name);
362 struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
363 const struct regmap_config *config,
364 struct lock_class_key *lock_key,
365 const char *lock_name);
366 struct regmap *__regmap_init_spi(struct spi_device *dev,
367 const struct regmap_config *config,
368 struct lock_class_key *lock_key,
369 const char *lock_name);
370 struct regmap *__regmap_init_spmi_base(struct spmi_device *dev,
371 const struct regmap_config *config,
372 struct lock_class_key *lock_key,
373 const char *lock_name);
374 struct regmap *__regmap_init_spmi_ext(struct spmi_device *dev,
375 const struct regmap_config *config,
376 struct lock_class_key *lock_key,
377 const char *lock_name);
378 struct regmap *__regmap_init_mmio_clk(struct device *dev, const char *clk_id,
380 const struct regmap_config *config,
381 struct lock_class_key *lock_key,
382 const char *lock_name);
383 struct regmap *__regmap_init_ac97(struct snd_ac97 *ac97,
384 const struct regmap_config *config,
385 struct lock_class_key *lock_key,
386 const char *lock_name);
388 struct regmap *__devm_regmap_init(struct device *dev,
389 const struct regmap_bus *bus,
391 const struct regmap_config *config,
392 struct lock_class_key *lock_key,
393 const char *lock_name);
394 struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
395 const struct regmap_config *config,
396 struct lock_class_key *lock_key,
397 const char *lock_name);
398 struct regmap *__devm_regmap_init_spi(struct spi_device *dev,
399 const struct regmap_config *config,
400 struct lock_class_key *lock_key,
401 const char *lock_name);
402 struct regmap *__devm_regmap_init_spmi_base(struct spmi_device *dev,
403 const struct regmap_config *config,
404 struct lock_class_key *lock_key,
405 const char *lock_name);
406 struct regmap *__devm_regmap_init_spmi_ext(struct spmi_device *dev,
407 const struct regmap_config *config,
408 struct lock_class_key *lock_key,
409 const char *lock_name);
410 struct regmap *__devm_regmap_init_mmio_clk(struct device *dev,
413 const struct regmap_config *config,
414 struct lock_class_key *lock_key,
415 const char *lock_name);
416 struct regmap *__devm_regmap_init_ac97(struct snd_ac97 *ac97,
417 const struct regmap_config *config,
418 struct lock_class_key *lock_key,
419 const char *lock_name);
422 * Wrapper for regmap_init macros to include a unique lockdep key and name
423 * for each call. No-op if CONFIG_LOCKDEP is not set.
425 * @fn: Real function to call (in the form __[*_]regmap_init[_*])
426 * @name: Config variable name (#config in the calling macro)
428 #ifdef CONFIG_LOCKDEP
429 #define __regmap_lockdep_wrapper(fn, name, ...) \
432 static struct lock_class_key _key; \
433 fn(__VA_ARGS__, &_key, \
434 KBUILD_BASENAME ":" \
435 __stringify(__LINE__) ":" \
436 "(" name ")->lock"); \
440 #define __regmap_lockdep_wrapper(fn, name, ...) fn(__VA_ARGS__, NULL, NULL)
444 * regmap_init(): Initialise register map
446 * @dev: Device that will be interacted with
447 * @bus: Bus-specific callbacks to use with device
448 * @bus_context: Data passed to bus-specific callbacks
449 * @config: Configuration for register map
451 * The return value will be an ERR_PTR() on error or a valid pointer to
452 * a struct regmap. This function should generally not be called
453 * directly, it should be called by bus-specific init functions.
455 #define regmap_init(dev, bus, bus_context, config) \
456 __regmap_lockdep_wrapper(__regmap_init, #config, \
457 dev, bus, bus_context, config)
458 int regmap_attach_dev(struct device *dev, struct regmap *map,
459 const struct regmap_config *config);
462 * regmap_init_i2c(): Initialise register map
464 * @i2c: Device that will be interacted with
465 * @config: Configuration for register map
467 * The return value will be an ERR_PTR() on error or a valid pointer to
470 #define regmap_init_i2c(i2c, config) \
471 __regmap_lockdep_wrapper(__regmap_init_i2c, #config, \
475 * regmap_init_spi(): Initialise register map
477 * @spi: Device that will be interacted with
478 * @config: Configuration for register map
480 * The return value will be an ERR_PTR() on error or a valid pointer to
483 #define regmap_init_spi(dev, config) \
484 __regmap_lockdep_wrapper(__regmap_init_spi, #config, \
488 * regmap_init_spmi_base(): Create regmap for the Base register space
489 * @sdev: SPMI device that will be interacted with
490 * @config: Configuration for register map
492 * The return value will be an ERR_PTR() on error or a valid pointer to
495 #define regmap_init_spmi_base(dev, config) \
496 __regmap_lockdep_wrapper(__regmap_init_spmi_base, #config, \
500 * regmap_init_spmi_ext(): Create regmap for Ext register space
501 * @sdev: Device that will be interacted with
502 * @config: Configuration for register map
504 * The return value will be an ERR_PTR() on error or a valid pointer to
507 #define regmap_init_spmi_ext(dev, config) \
508 __regmap_lockdep_wrapper(__regmap_init_spmi_ext, #config, \
512 * regmap_init_mmio_clk(): Initialise register map with register clock
514 * @dev: Device that will be interacted with
515 * @clk_id: register clock consumer ID
516 * @regs: Pointer to memory-mapped IO region
517 * @config: Configuration for register map
519 * The return value will be an ERR_PTR() on error or a valid pointer to
522 #define regmap_init_mmio_clk(dev, clk_id, regs, config) \
523 __regmap_lockdep_wrapper(__regmap_init_mmio_clk, #config, \
524 dev, clk_id, regs, config)
527 * regmap_init_mmio(): Initialise register map
529 * @dev: Device that will be interacted with
530 * @regs: Pointer to memory-mapped IO region
531 * @config: Configuration for register map
533 * The return value will be an ERR_PTR() on error or a valid pointer to
536 #define regmap_init_mmio(dev, regs, config) \
537 regmap_init_mmio_clk(dev, NULL, regs, config)
540 * regmap_init_ac97(): Initialise AC'97 register map
542 * @ac97: Device that will be interacted with
543 * @config: Configuration for register map
545 * The return value will be an ERR_PTR() on error or a valid pointer to
548 #define regmap_init_ac97(ac97, config) \
549 __regmap_lockdep_wrapper(__regmap_init_ac97, #config, \
551 bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
554 * devm_regmap_init(): Initialise managed register map
556 * @dev: Device that will be interacted with
557 * @bus: Bus-specific callbacks to use with device
558 * @bus_context: Data passed to bus-specific callbacks
559 * @config: Configuration for register map
561 * The return value will be an ERR_PTR() on error or a valid pointer
562 * to a struct regmap. This function should generally not be called
563 * directly, it should be called by bus-specific init functions. The
564 * map will be automatically freed by the device management code.
566 #define devm_regmap_init(dev, bus, bus_context, config) \
567 __regmap_lockdep_wrapper(__devm_regmap_init, #config, \
568 dev, bus, bus_context, config)
571 * devm_regmap_init_i2c(): Initialise managed register map
573 * @i2c: Device that will be interacted with
574 * @config: Configuration for register map
576 * The return value will be an ERR_PTR() on error or a valid pointer
577 * to a struct regmap. The regmap will be automatically freed by the
578 * device management code.
580 #define devm_regmap_init_i2c(i2c, config) \
581 __regmap_lockdep_wrapper(__devm_regmap_init_i2c, #config, \
585 * devm_regmap_init_spi(): Initialise register map
587 * @spi: Device that will be interacted with
588 * @config: Configuration for register map
590 * The return value will be an ERR_PTR() on error or a valid pointer
591 * to a struct regmap. The map will be automatically freed by the
592 * device management code.
594 #define devm_regmap_init_spi(dev, config) \
595 __regmap_lockdep_wrapper(__devm_regmap_init_spi, #config, \
599 * devm_regmap_init_spmi_base(): Create managed regmap for Base register space
600 * @sdev: SPMI device that will be interacted with
601 * @config: Configuration for register map
603 * The return value will be an ERR_PTR() on error or a valid pointer
604 * to a struct regmap. The regmap will be automatically freed by the
605 * device management code.
607 #define devm_regmap_init_spmi_base(dev, config) \
608 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_base, #config, \
612 * devm_regmap_init_spmi_ext(): Create managed regmap for Ext register space
613 * @sdev: SPMI device that will be interacted with
614 * @config: Configuration for register map
616 * The return value will be an ERR_PTR() on error or a valid pointer
617 * to a struct regmap. The regmap will be automatically freed by the
618 * device management code.
620 #define devm_regmap_init_spmi_ext(dev, config) \
621 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_ext, #config, \
625 * devm_regmap_init_mmio_clk(): Initialise managed register map with clock
627 * @dev: Device that will be interacted with
628 * @clk_id: register clock consumer ID
629 * @regs: Pointer to memory-mapped IO region
630 * @config: Configuration for register map
632 * The return value will be an ERR_PTR() on error or a valid pointer
633 * to a struct regmap. The regmap will be automatically freed by the
634 * device management code.
636 #define devm_regmap_init_mmio_clk(dev, clk_id, regs, config) \
637 __regmap_lockdep_wrapper(__devm_regmap_init_mmio_clk, #config, \
638 dev, clk_id, regs, config)
641 * devm_regmap_init_mmio(): Initialise managed register map
643 * @dev: Device that will be interacted with
644 * @regs: Pointer to memory-mapped IO region
645 * @config: Configuration for register map
647 * The return value will be an ERR_PTR() on error or a valid pointer
648 * to a struct regmap. The regmap will be automatically freed by the
649 * device management code.
651 #define devm_regmap_init_mmio(dev, regs, config) \
652 devm_regmap_init_mmio_clk(dev, NULL, regs, config)
655 * devm_regmap_init_ac97(): Initialise AC'97 register map
657 * @ac97: Device that will be interacted with
658 * @config: Configuration for register map
660 * The return value will be an ERR_PTR() on error or a valid pointer
661 * to a struct regmap. The regmap will be automatically freed by the
662 * device management code.
664 #define devm_regmap_init_ac97(ac97, config) \
665 __regmap_lockdep_wrapper(__devm_regmap_init_ac97, #config, \
668 void regmap_exit(struct regmap *map);
669 int regmap_reinit_cache(struct regmap *map,
670 const struct regmap_config *config);
671 struct regmap *dev_get_regmap(struct device *dev, const char *name);
672 struct device *regmap_get_device(struct regmap *map);
673 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
674 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val);
675 int regmap_raw_write(struct regmap *map, unsigned int reg,
676 const void *val, size_t val_len);
677 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
679 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
681 int regmap_multi_reg_write_bypassed(struct regmap *map,
682 const struct reg_sequence *regs,
684 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
685 const void *val, size_t val_len);
686 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
687 int regmap_raw_read(struct regmap *map, unsigned int reg,
688 void *val, size_t val_len);
689 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
691 int regmap_update_bits(struct regmap *map, unsigned int reg,
692 unsigned int mask, unsigned int val);
693 int regmap_write_bits(struct regmap *map, unsigned int reg,
694 unsigned int mask, unsigned int val);
695 int regmap_update_bits_async(struct regmap *map, unsigned int reg,
696 unsigned int mask, unsigned int val);
697 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
698 unsigned int mask, unsigned int val,
700 int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
701 unsigned int mask, unsigned int val,
703 int regmap_get_val_bytes(struct regmap *map);
704 int regmap_get_max_register(struct regmap *map);
705 int regmap_get_reg_stride(struct regmap *map);
706 int regmap_async_complete(struct regmap *map);
707 bool regmap_can_raw_write(struct regmap *map);
708 size_t regmap_get_raw_read_max(struct regmap *map);
709 size_t regmap_get_raw_write_max(struct regmap *map);
711 int regcache_sync(struct regmap *map);
712 int regcache_sync_region(struct regmap *map, unsigned int min,
714 int regcache_drop_region(struct regmap *map, unsigned int min,
716 void regcache_cache_only(struct regmap *map, bool enable);
717 void regcache_cache_bypass(struct regmap *map, bool enable);
718 void regcache_mark_dirty(struct regmap *map);
720 bool regmap_check_range_table(struct regmap *map, unsigned int reg,
721 const struct regmap_access_table *table);
723 int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
725 int regmap_parse_val(struct regmap *map, const void *buf,
728 static inline bool regmap_reg_in_range(unsigned int reg,
729 const struct regmap_range *range)
731 return reg >= range->range_min && reg <= range->range_max;
734 bool regmap_reg_in_ranges(unsigned int reg,
735 const struct regmap_range *ranges,
736 unsigned int nranges);
739 * Description of an register field
741 * @reg: Offset of the register within the regmap bank
742 * @lsb: lsb of the register field.
743 * @msb: msb of the register field.
744 * @id_size: port size if it has some ports
745 * @id_offset: address offset for each ports
751 unsigned int id_size;
752 unsigned int id_offset;
755 #define REG_FIELD(_reg, _lsb, _msb) { \
761 struct regmap_field *regmap_field_alloc(struct regmap *regmap,
762 struct reg_field reg_field);
763 void regmap_field_free(struct regmap_field *field);
765 struct regmap_field *devm_regmap_field_alloc(struct device *dev,
766 struct regmap *regmap, struct reg_field reg_field);
767 void devm_regmap_field_free(struct device *dev, struct regmap_field *field);
769 int regmap_field_read(struct regmap_field *field, unsigned int *val);
770 int regmap_field_write(struct regmap_field *field, unsigned int val);
771 int regmap_field_update_bits(struct regmap_field *field,
772 unsigned int mask, unsigned int val);
774 int regmap_fields_write(struct regmap_field *field, unsigned int id,
776 int regmap_fields_force_write(struct regmap_field *field, unsigned int id,
778 int regmap_fields_read(struct regmap_field *field, unsigned int id,
780 int regmap_fields_update_bits(struct regmap_field *field, unsigned int id,
781 unsigned int mask, unsigned int val);
784 * Description of an IRQ for the generic regmap irq_chip.
786 * @reg_offset: Offset of the status/mask register within the bank
787 * @mask: Mask used to flag/control the register.
790 unsigned int reg_offset;
795 * Description of a generic regmap irq_chip. This is not intended to
796 * handle every possible interrupt controller, but it should handle a
797 * substantial proportion of those that are found in the wild.
799 * @name: Descriptive name for IRQ controller.
801 * @status_base: Base status register address.
802 * @mask_base: Base mask register address.
803 * @ack_base: Base ack address. If zero then the chip is clear on read.
804 * Using zero value is possible with @use_ack bit.
805 * @wake_base: Base address for wake enables. If zero unsupported.
806 * @irq_reg_stride: Stride to use for chips where registers are not contiguous.
807 * @init_ack_masked: Ack all masked interrupts once during initalization.
808 * @mask_invert: Inverted mask register: cleared bits are masked out.
809 * @use_ack: Use @ack register even if it is zero.
810 * @wake_invert: Inverted wake register: cleared bits are wake enabled.
811 * @runtime_pm: Hold a runtime PM lock on the device when accessing it.
813 * @num_regs: Number of registers in each control bank.
814 * @irqs: Descriptors for individual IRQs. Interrupt numbers are
815 * assigned based on the index in the array of the interrupt.
816 * @num_irqs: Number of descriptors.
818 struct regmap_irq_chip {
821 unsigned int status_base;
822 unsigned int mask_base;
823 unsigned int ack_base;
824 unsigned int wake_base;
825 unsigned int irq_reg_stride;
826 bool init_ack_masked:1;
834 const struct regmap_irq *irqs;
838 struct regmap_irq_chip_data;
840 int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
841 int irq_base, const struct regmap_irq_chip *chip,
842 struct regmap_irq_chip_data **data);
843 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
844 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
845 int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
846 struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data);
851 * These stubs should only ever be called by generic code which has
852 * regmap based facilities, if they ever get called at runtime
853 * something is going wrong and something probably needs to select
857 static inline int regmap_write(struct regmap *map, unsigned int reg,
860 WARN_ONCE(1, "regmap API is disabled");
864 static inline int regmap_write_async(struct regmap *map, unsigned int reg,
867 WARN_ONCE(1, "regmap API is disabled");
871 static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
872 const void *val, size_t val_len)
874 WARN_ONCE(1, "regmap API is disabled");
878 static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg,
879 const void *val, size_t val_len)
881 WARN_ONCE(1, "regmap API is disabled");
885 static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
886 const void *val, size_t val_count)
888 WARN_ONCE(1, "regmap API is disabled");
892 static inline int regmap_read(struct regmap *map, unsigned int reg,
895 WARN_ONCE(1, "regmap API is disabled");
899 static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
900 void *val, size_t val_len)
902 WARN_ONCE(1, "regmap API is disabled");
906 static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
907 void *val, size_t val_count)
909 WARN_ONCE(1, "regmap API is disabled");
913 static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
914 unsigned int mask, unsigned int val)
916 WARN_ONCE(1, "regmap API is disabled");
920 static inline int regmap_write_bits(struct regmap *map, unsigned int reg,
921 unsigned int mask, unsigned int val)
923 WARN_ONCE(1, "regmap API is disabled");
927 static inline int regmap_update_bits_async(struct regmap *map,
929 unsigned int mask, unsigned int val)
931 WARN_ONCE(1, "regmap API is disabled");
935 static inline int regmap_update_bits_check(struct regmap *map,
937 unsigned int mask, unsigned int val,
940 WARN_ONCE(1, "regmap API is disabled");
944 static inline int regmap_update_bits_check_async(struct regmap *map,
950 WARN_ONCE(1, "regmap API is disabled");
954 static inline int regmap_get_val_bytes(struct regmap *map)
956 WARN_ONCE(1, "regmap API is disabled");
960 static inline int regmap_get_max_register(struct regmap *map)
962 WARN_ONCE(1, "regmap API is disabled");
966 static inline int regmap_get_reg_stride(struct regmap *map)
968 WARN_ONCE(1, "regmap API is disabled");
972 static inline int regcache_sync(struct regmap *map)
974 WARN_ONCE(1, "regmap API is disabled");
978 static inline int regcache_sync_region(struct regmap *map, unsigned int min,
981 WARN_ONCE(1, "regmap API is disabled");
985 static inline int regcache_drop_region(struct regmap *map, unsigned int min,
988 WARN_ONCE(1, "regmap API is disabled");
992 static inline void regcache_cache_only(struct regmap *map, bool enable)
994 WARN_ONCE(1, "regmap API is disabled");
997 static inline void regcache_cache_bypass(struct regmap *map, bool enable)
999 WARN_ONCE(1, "regmap API is disabled");
1002 static inline void regcache_mark_dirty(struct regmap *map)
1004 WARN_ONCE(1, "regmap API is disabled");
1007 static inline void regmap_async_complete(struct regmap *map)
1009 WARN_ONCE(1, "regmap API is disabled");
1012 static inline int regmap_register_patch(struct regmap *map,
1013 const struct reg_default *regs,
1016 WARN_ONCE(1, "regmap API is disabled");
1020 static inline int regmap_parse_val(struct regmap *map, const void *buf,
1023 WARN_ONCE(1, "regmap API is disabled");
1027 static inline struct regmap *dev_get_regmap(struct device *dev,
1033 static inline struct device *regmap_get_device(struct regmap *map)
1035 WARN_ONCE(1, "regmap API is disabled");