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 int (*regmap_hw_reg_update_bits
)(void *context
, unsigned int reg
,
300 unsigned int mask
, unsigned int val
);
301 typedef struct regmap_async
*(*regmap_hw_async_alloc
)(void);
302 typedef void (*regmap_hw_free_context
)(void *context
);
305 * Description of a hardware bus for the register map infrastructure.
307 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
308 * to perform locking. This field is ignored if custom lock/unlock
309 * functions are used (see fields lock/unlock of
310 * struct regmap_config).
311 * @write: Write operation.
312 * @gather_write: Write operation with split register/value, return -ENOTSUPP
313 * if not implemented on a given device.
314 * @async_write: Write operation which completes asynchronously, optional and
315 * must serialise with respect to non-async I/O.
316 * @reg_write: Write a single register value to the given register address. This
317 * write operation has to complete when returning from the function.
318 * @read: Read operation. Data is returned in the buffer used to transmit
320 * @reg_read: Read a single register value from a given register address.
321 * @free_context: Free context.
322 * @async_alloc: Allocate a regmap_async() structure.
323 * @read_flag_mask: Mask to be set in the top byte of the register when doing
325 * @reg_format_endian_default: Default endianness for formatted register
326 * addresses. Used when the regmap_config specifies DEFAULT. If this is
327 * DEFAULT, BIG is assumed.
328 * @val_format_endian_default: Default endianness for formatted register
329 * values. Used when the regmap_config specifies DEFAULT. If this is
330 * DEFAULT, BIG is assumed.
331 * @max_raw_read: Max raw read size that can be used on the bus.
332 * @max_raw_write: Max raw write size that can be used on the bus.
336 regmap_hw_write write
;
337 regmap_hw_gather_write gather_write
;
338 regmap_hw_async_write async_write
;
339 regmap_hw_reg_write reg_write
;
340 regmap_hw_reg_update_bits reg_update_bits
;
342 regmap_hw_reg_read reg_read
;
343 regmap_hw_free_context free_context
;
344 regmap_hw_async_alloc async_alloc
;
346 enum regmap_endian reg_format_endian_default
;
347 enum regmap_endian val_format_endian_default
;
349 size_t max_raw_write
;
353 * __regmap_init functions.
355 * These functions take a lock key and name parameter, and should not be called
356 * directly. Instead, use the regmap_init macros that generate a key and name
359 struct regmap
*__regmap_init(struct device
*dev
,
360 const struct regmap_bus
*bus
,
362 const struct regmap_config
*config
,
363 struct lock_class_key
*lock_key
,
364 const char *lock_name
);
365 struct regmap
*__regmap_init_i2c(struct i2c_client
*i2c
,
366 const struct regmap_config
*config
,
367 struct lock_class_key
*lock_key
,
368 const char *lock_name
);
369 struct regmap
*__regmap_init_spi(struct spi_device
*dev
,
370 const struct regmap_config
*config
,
371 struct lock_class_key
*lock_key
,
372 const char *lock_name
);
373 struct regmap
*__regmap_init_spmi_base(struct spmi_device
*dev
,
374 const struct regmap_config
*config
,
375 struct lock_class_key
*lock_key
,
376 const char *lock_name
);
377 struct regmap
*__regmap_init_spmi_ext(struct spmi_device
*dev
,
378 const struct regmap_config
*config
,
379 struct lock_class_key
*lock_key
,
380 const char *lock_name
);
381 struct regmap
*__regmap_init_mmio_clk(struct device
*dev
, const char *clk_id
,
383 const struct regmap_config
*config
,
384 struct lock_class_key
*lock_key
,
385 const char *lock_name
);
386 struct regmap
*__regmap_init_ac97(struct snd_ac97
*ac97
,
387 const struct regmap_config
*config
,
388 struct lock_class_key
*lock_key
,
389 const char *lock_name
);
391 struct regmap
*__devm_regmap_init(struct device
*dev
,
392 const struct regmap_bus
*bus
,
394 const struct regmap_config
*config
,
395 struct lock_class_key
*lock_key
,
396 const char *lock_name
);
397 struct regmap
*__devm_regmap_init_i2c(struct i2c_client
*i2c
,
398 const struct regmap_config
*config
,
399 struct lock_class_key
*lock_key
,
400 const char *lock_name
);
401 struct regmap
*__devm_regmap_init_spi(struct spi_device
*dev
,
402 const struct regmap_config
*config
,
403 struct lock_class_key
*lock_key
,
404 const char *lock_name
);
405 struct regmap
*__devm_regmap_init_spmi_base(struct spmi_device
*dev
,
406 const struct regmap_config
*config
,
407 struct lock_class_key
*lock_key
,
408 const char *lock_name
);
409 struct regmap
*__devm_regmap_init_spmi_ext(struct spmi_device
*dev
,
410 const struct regmap_config
*config
,
411 struct lock_class_key
*lock_key
,
412 const char *lock_name
);
413 struct regmap
*__devm_regmap_init_mmio_clk(struct device
*dev
,
416 const struct regmap_config
*config
,
417 struct lock_class_key
*lock_key
,
418 const char *lock_name
);
419 struct regmap
*__devm_regmap_init_ac97(struct snd_ac97
*ac97
,
420 const struct regmap_config
*config
,
421 struct lock_class_key
*lock_key
,
422 const char *lock_name
);
425 * Wrapper for regmap_init macros to include a unique lockdep key and name
426 * for each call. No-op if CONFIG_LOCKDEP is not set.
428 * @fn: Real function to call (in the form __[*_]regmap_init[_*])
429 * @name: Config variable name (#config in the calling macro)
431 #ifdef CONFIG_LOCKDEP
432 #define __regmap_lockdep_wrapper(fn, name, ...) \
435 static struct lock_class_key _key; \
436 fn(__VA_ARGS__, &_key, \
437 KBUILD_BASENAME ":" \
438 __stringify(__LINE__) ":" \
439 "(" name ")->lock"); \
443 #define __regmap_lockdep_wrapper(fn, name, ...) fn(__VA_ARGS__, NULL, NULL)
447 * regmap_init(): Initialise register map
449 * @dev: Device that will be interacted with
450 * @bus: Bus-specific callbacks to use with device
451 * @bus_context: Data passed to bus-specific callbacks
452 * @config: Configuration for register map
454 * The return value will be an ERR_PTR() on error or a valid pointer to
455 * a struct regmap. This function should generally not be called
456 * directly, it should be called by bus-specific init functions.
458 #define regmap_init(dev, bus, bus_context, config) \
459 __regmap_lockdep_wrapper(__regmap_init, #config, \
460 dev, bus, bus_context, config)
461 int regmap_attach_dev(struct device
*dev
, struct regmap
*map
,
462 const struct regmap_config
*config
);
465 * regmap_init_i2c(): Initialise register map
467 * @i2c: Device that will be interacted with
468 * @config: Configuration for register map
470 * The return value will be an ERR_PTR() on error or a valid pointer to
473 #define regmap_init_i2c(i2c, config) \
474 __regmap_lockdep_wrapper(__regmap_init_i2c, #config, \
478 * regmap_init_spi(): Initialise register map
480 * @spi: Device that will be interacted with
481 * @config: Configuration for register map
483 * The return value will be an ERR_PTR() on error or a valid pointer to
486 #define regmap_init_spi(dev, config) \
487 __regmap_lockdep_wrapper(__regmap_init_spi, #config, \
491 * regmap_init_spmi_base(): Create regmap for the Base register space
492 * @sdev: SPMI device that will be interacted with
493 * @config: Configuration for register map
495 * The return value will be an ERR_PTR() on error or a valid pointer to
498 #define regmap_init_spmi_base(dev, config) \
499 __regmap_lockdep_wrapper(__regmap_init_spmi_base, #config, \
503 * regmap_init_spmi_ext(): Create regmap for Ext register space
504 * @sdev: Device that will be interacted with
505 * @config: Configuration for register map
507 * The return value will be an ERR_PTR() on error or a valid pointer to
510 #define regmap_init_spmi_ext(dev, config) \
511 __regmap_lockdep_wrapper(__regmap_init_spmi_ext, #config, \
515 * regmap_init_mmio_clk(): Initialise register map with register clock
517 * @dev: Device that will be interacted with
518 * @clk_id: register clock consumer ID
519 * @regs: Pointer to memory-mapped IO region
520 * @config: Configuration for register map
522 * The return value will be an ERR_PTR() on error or a valid pointer to
525 #define regmap_init_mmio_clk(dev, clk_id, regs, config) \
526 __regmap_lockdep_wrapper(__regmap_init_mmio_clk, #config, \
527 dev, clk_id, regs, config)
530 * regmap_init_mmio(): Initialise register map
532 * @dev: Device that will be interacted with
533 * @regs: Pointer to memory-mapped IO region
534 * @config: Configuration for register map
536 * The return value will be an ERR_PTR() on error or a valid pointer to
539 #define regmap_init_mmio(dev, regs, config) \
540 regmap_init_mmio_clk(dev, NULL, regs, config)
543 * regmap_init_ac97(): Initialise AC'97 register map
545 * @ac97: Device that will be interacted with
546 * @config: Configuration for register map
548 * The return value will be an ERR_PTR() on error or a valid pointer to
551 #define regmap_init_ac97(ac97, config) \
552 __regmap_lockdep_wrapper(__regmap_init_ac97, #config, \
554 bool regmap_ac97_default_volatile(struct device
*dev
, unsigned int reg
);
557 * devm_regmap_init(): Initialise managed register map
559 * @dev: Device that will be interacted with
560 * @bus: Bus-specific callbacks to use with device
561 * @bus_context: Data passed to bus-specific callbacks
562 * @config: Configuration for register map
564 * The return value will be an ERR_PTR() on error or a valid pointer
565 * to a struct regmap. This function should generally not be called
566 * directly, it should be called by bus-specific init functions. The
567 * map will be automatically freed by the device management code.
569 #define devm_regmap_init(dev, bus, bus_context, config) \
570 __regmap_lockdep_wrapper(__devm_regmap_init, #config, \
571 dev, bus, bus_context, config)
574 * devm_regmap_init_i2c(): Initialise managed register map
576 * @i2c: Device that will be interacted with
577 * @config: Configuration for register map
579 * The return value will be an ERR_PTR() on error or a valid pointer
580 * to a struct regmap. The regmap will be automatically freed by the
581 * device management code.
583 #define devm_regmap_init_i2c(i2c, config) \
584 __regmap_lockdep_wrapper(__devm_regmap_init_i2c, #config, \
588 * devm_regmap_init_spi(): Initialise register map
590 * @spi: Device that will be interacted with
591 * @config: Configuration for register map
593 * The return value will be an ERR_PTR() on error or a valid pointer
594 * to a struct regmap. The map will be automatically freed by the
595 * device management code.
597 #define devm_regmap_init_spi(dev, config) \
598 __regmap_lockdep_wrapper(__devm_regmap_init_spi, #config, \
602 * devm_regmap_init_spmi_base(): Create managed regmap for Base register space
603 * @sdev: SPMI device that will be interacted with
604 * @config: Configuration for register map
606 * The return value will be an ERR_PTR() on error or a valid pointer
607 * to a struct regmap. The regmap will be automatically freed by the
608 * device management code.
610 #define devm_regmap_init_spmi_base(dev, config) \
611 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_base, #config, \
615 * devm_regmap_init_spmi_ext(): Create managed regmap for Ext register space
616 * @sdev: SPMI device that will be interacted with
617 * @config: Configuration for register map
619 * The return value will be an ERR_PTR() on error or a valid pointer
620 * to a struct regmap. The regmap will be automatically freed by the
621 * device management code.
623 #define devm_regmap_init_spmi_ext(dev, config) \
624 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_ext, #config, \
628 * devm_regmap_init_mmio_clk(): Initialise managed register map with clock
630 * @dev: Device that will be interacted with
631 * @clk_id: register clock consumer ID
632 * @regs: Pointer to memory-mapped IO region
633 * @config: Configuration for register map
635 * The return value will be an ERR_PTR() on error or a valid pointer
636 * to a struct regmap. The regmap will be automatically freed by the
637 * device management code.
639 #define devm_regmap_init_mmio_clk(dev, clk_id, regs, config) \
640 __regmap_lockdep_wrapper(__devm_regmap_init_mmio_clk, #config, \
641 dev, clk_id, regs, config)
644 * devm_regmap_init_mmio(): Initialise managed register map
646 * @dev: Device that will be interacted with
647 * @regs: Pointer to memory-mapped IO region
648 * @config: Configuration for register map
650 * The return value will be an ERR_PTR() on error or a valid pointer
651 * to a struct regmap. The regmap will be automatically freed by the
652 * device management code.
654 #define devm_regmap_init_mmio(dev, regs, config) \
655 devm_regmap_init_mmio_clk(dev, NULL, regs, config)
658 * devm_regmap_init_ac97(): Initialise AC'97 register map
660 * @ac97: Device that will be interacted with
661 * @config: Configuration for register map
663 * The return value will be an ERR_PTR() on error or a valid pointer
664 * to a struct regmap. The regmap will be automatically freed by the
665 * device management code.
667 #define devm_regmap_init_ac97(ac97, config) \
668 __regmap_lockdep_wrapper(__devm_regmap_init_ac97, #config, \
671 void regmap_exit(struct regmap
*map
);
672 int regmap_reinit_cache(struct regmap
*map
,
673 const struct regmap_config
*config
);
674 struct regmap
*dev_get_regmap(struct device
*dev
, const char *name
);
675 struct device
*regmap_get_device(struct regmap
*map
);
676 int regmap_write(struct regmap
*map
, unsigned int reg
, unsigned int val
);
677 int regmap_write_async(struct regmap
*map
, unsigned int reg
, unsigned int val
);
678 int regmap_raw_write(struct regmap
*map
, unsigned int reg
,
679 const void *val
, size_t val_len
);
680 int regmap_bulk_write(struct regmap
*map
, unsigned int reg
, const void *val
,
682 int regmap_multi_reg_write(struct regmap
*map
, const struct reg_sequence
*regs
,
684 int regmap_multi_reg_write_bypassed(struct regmap
*map
,
685 const struct reg_sequence
*regs
,
687 int regmap_raw_write_async(struct regmap
*map
, unsigned int reg
,
688 const void *val
, size_t val_len
);
689 int regmap_read(struct regmap
*map
, unsigned int reg
, unsigned int *val
);
690 int regmap_raw_read(struct regmap
*map
, unsigned int reg
,
691 void *val
, size_t val_len
);
692 int regmap_bulk_read(struct regmap
*map
, unsigned int reg
, void *val
,
694 int regmap_update_bits(struct regmap
*map
, unsigned int reg
,
695 unsigned int mask
, unsigned int val
);
696 int regmap_write_bits(struct regmap
*map
, unsigned int reg
,
697 unsigned int mask
, unsigned int val
);
698 int regmap_update_bits_async(struct regmap
*map
, unsigned int reg
,
699 unsigned int mask
, unsigned int val
);
700 int regmap_update_bits_check(struct regmap
*map
, unsigned int reg
,
701 unsigned int mask
, unsigned int val
,
703 int regmap_update_bits_check_async(struct regmap
*map
, unsigned int reg
,
704 unsigned int mask
, unsigned int val
,
706 int regmap_get_val_bytes(struct regmap
*map
);
707 int regmap_get_max_register(struct regmap
*map
);
708 int regmap_get_reg_stride(struct regmap
*map
);
709 int regmap_async_complete(struct regmap
*map
);
710 bool regmap_can_raw_write(struct regmap
*map
);
711 size_t regmap_get_raw_read_max(struct regmap
*map
);
712 size_t regmap_get_raw_write_max(struct regmap
*map
);
714 int regcache_sync(struct regmap
*map
);
715 int regcache_sync_region(struct regmap
*map
, unsigned int min
,
717 int regcache_drop_region(struct regmap
*map
, unsigned int min
,
719 void regcache_cache_only(struct regmap
*map
, bool enable
);
720 void regcache_cache_bypass(struct regmap
*map
, bool enable
);
721 void regcache_mark_dirty(struct regmap
*map
);
723 bool regmap_check_range_table(struct regmap
*map
, unsigned int reg
,
724 const struct regmap_access_table
*table
);
726 int regmap_register_patch(struct regmap
*map
, const struct reg_sequence
*regs
,
728 int regmap_parse_val(struct regmap
*map
, const void *buf
,
731 static inline bool regmap_reg_in_range(unsigned int reg
,
732 const struct regmap_range
*range
)
734 return reg
>= range
->range_min
&& reg
<= range
->range_max
;
737 bool regmap_reg_in_ranges(unsigned int reg
,
738 const struct regmap_range
*ranges
,
739 unsigned int nranges
);
742 * Description of an register field
744 * @reg: Offset of the register within the regmap bank
745 * @lsb: lsb of the register field.
746 * @msb: msb of the register field.
747 * @id_size: port size if it has some ports
748 * @id_offset: address offset for each ports
754 unsigned int id_size
;
755 unsigned int id_offset
;
758 #define REG_FIELD(_reg, _lsb, _msb) { \
764 struct regmap_field
*regmap_field_alloc(struct regmap
*regmap
,
765 struct reg_field reg_field
);
766 void regmap_field_free(struct regmap_field
*field
);
768 struct regmap_field
*devm_regmap_field_alloc(struct device
*dev
,
769 struct regmap
*regmap
, struct reg_field reg_field
);
770 void devm_regmap_field_free(struct device
*dev
, struct regmap_field
*field
);
772 int regmap_field_read(struct regmap_field
*field
, unsigned int *val
);
773 int regmap_field_write(struct regmap_field
*field
, unsigned int val
);
774 int regmap_field_update_bits(struct regmap_field
*field
,
775 unsigned int mask
, unsigned int val
);
777 int regmap_fields_write(struct regmap_field
*field
, unsigned int id
,
779 int regmap_fields_force_write(struct regmap_field
*field
, unsigned int id
,
781 int regmap_fields_read(struct regmap_field
*field
, unsigned int id
,
783 int regmap_fields_update_bits(struct regmap_field
*field
, unsigned int id
,
784 unsigned int mask
, unsigned int val
);
787 * Description of an IRQ for the generic regmap irq_chip.
789 * @reg_offset: Offset of the status/mask register within the bank
790 * @mask: Mask used to flag/control the register.
791 * @type_reg_offset: Offset register for the irq type setting.
792 * @type_rising_mask: Mask bit to configure RISING type irq.
793 * @type_falling_mask: Mask bit to configure FALLING type irq.
796 unsigned int reg_offset
;
798 unsigned int type_reg_offset
;
799 unsigned int type_rising_mask
;
800 unsigned int type_falling_mask
;
803 #define REGMAP_IRQ_REG(_irq, _off, _mask) \
804 [_irq] = { .reg_offset = (_off), .mask = (_mask) }
807 * Description of a generic regmap irq_chip. This is not intended to
808 * handle every possible interrupt controller, but it should handle a
809 * substantial proportion of those that are found in the wild.
811 * @name: Descriptive name for IRQ controller.
813 * @status_base: Base status register address.
814 * @mask_base: Base mask register address.
815 * @unmask_base: Base unmask register address. for chips who have
816 * separate mask and unmask registers
817 * @ack_base: Base ack address. If zero then the chip is clear on read.
818 * Using zero value is possible with @use_ack bit.
819 * @wake_base: Base address for wake enables. If zero unsupported.
820 * @type_base: Base address for irq type. If zero unsupported.
821 * @irq_reg_stride: Stride to use for chips where registers are not contiguous.
822 * @init_ack_masked: Ack all masked interrupts once during initalization.
823 * @mask_invert: Inverted mask register: cleared bits are masked out.
824 * @use_ack: Use @ack register even if it is zero.
825 * @ack_invert: Inverted ack register: cleared bits for ack.
826 * @wake_invert: Inverted wake register: cleared bits are wake enabled.
827 * @type_invert: Invert the type flags.
828 * @runtime_pm: Hold a runtime PM lock on the device when accessing it.
830 * @num_regs: Number of registers in each control bank.
831 * @irqs: Descriptors for individual IRQs. Interrupt numbers are
832 * assigned based on the index in the array of the interrupt.
833 * @num_irqs: Number of descriptors.
834 * @num_type_reg: Number of type registers.
835 * @type_reg_stride: Stride to use for chips where type registers are not
838 struct regmap_irq_chip
{
841 unsigned int status_base
;
842 unsigned int mask_base
;
843 unsigned int unmask_base
;
844 unsigned int ack_base
;
845 unsigned int wake_base
;
846 unsigned int type_base
;
847 unsigned int irq_reg_stride
;
848 bool init_ack_masked
:1;
858 const struct regmap_irq
*irqs
;
862 unsigned int type_reg_stride
;
865 struct regmap_irq_chip_data
;
867 int regmap_add_irq_chip(struct regmap
*map
, int irq
, int irq_flags
,
868 int irq_base
, const struct regmap_irq_chip
*chip
,
869 struct regmap_irq_chip_data
**data
);
870 void regmap_del_irq_chip(int irq
, struct regmap_irq_chip_data
*data
);
871 int regmap_irq_chip_get_base(struct regmap_irq_chip_data
*data
);
872 int regmap_irq_get_virq(struct regmap_irq_chip_data
*data
, int irq
);
873 struct irq_domain
*regmap_irq_get_domain(struct regmap_irq_chip_data
*data
);
878 * These stubs should only ever be called by generic code which has
879 * regmap based facilities, if they ever get called at runtime
880 * something is going wrong and something probably needs to select
884 static inline int regmap_write(struct regmap
*map
, unsigned int reg
,
887 WARN_ONCE(1, "regmap API is disabled");
891 static inline int regmap_write_async(struct regmap
*map
, unsigned int reg
,
894 WARN_ONCE(1, "regmap API is disabled");
898 static inline int regmap_raw_write(struct regmap
*map
, unsigned int reg
,
899 const void *val
, size_t val_len
)
901 WARN_ONCE(1, "regmap API is disabled");
905 static inline int regmap_raw_write_async(struct regmap
*map
, unsigned int reg
,
906 const void *val
, size_t val_len
)
908 WARN_ONCE(1, "regmap API is disabled");
912 static inline int regmap_bulk_write(struct regmap
*map
, unsigned int reg
,
913 const void *val
, size_t val_count
)
915 WARN_ONCE(1, "regmap API is disabled");
919 static inline int regmap_read(struct regmap
*map
, unsigned int reg
,
922 WARN_ONCE(1, "regmap API is disabled");
926 static inline int regmap_raw_read(struct regmap
*map
, unsigned int reg
,
927 void *val
, size_t val_len
)
929 WARN_ONCE(1, "regmap API is disabled");
933 static inline int regmap_bulk_read(struct regmap
*map
, unsigned int reg
,
934 void *val
, size_t val_count
)
936 WARN_ONCE(1, "regmap API is disabled");
940 static inline int regmap_update_bits(struct regmap
*map
, unsigned int reg
,
941 unsigned int mask
, unsigned int val
)
943 WARN_ONCE(1, "regmap API is disabled");
947 static inline int regmap_write_bits(struct regmap
*map
, unsigned int reg
,
948 unsigned int mask
, unsigned int val
)
950 WARN_ONCE(1, "regmap API is disabled");
954 static inline int regmap_update_bits_async(struct regmap
*map
,
956 unsigned int mask
, unsigned int val
)
958 WARN_ONCE(1, "regmap API is disabled");
962 static inline int regmap_update_bits_check(struct regmap
*map
,
964 unsigned int mask
, unsigned int val
,
967 WARN_ONCE(1, "regmap API is disabled");
971 static inline int regmap_update_bits_check_async(struct regmap
*map
,
977 WARN_ONCE(1, "regmap API is disabled");
981 static inline int regmap_get_val_bytes(struct regmap
*map
)
983 WARN_ONCE(1, "regmap API is disabled");
987 static inline int regmap_get_max_register(struct regmap
*map
)
989 WARN_ONCE(1, "regmap API is disabled");
993 static inline int regmap_get_reg_stride(struct regmap
*map
)
995 WARN_ONCE(1, "regmap API is disabled");
999 static inline int regcache_sync(struct regmap
*map
)
1001 WARN_ONCE(1, "regmap API is disabled");
1005 static inline int regcache_sync_region(struct regmap
*map
, unsigned int min
,
1008 WARN_ONCE(1, "regmap API is disabled");
1012 static inline int regcache_drop_region(struct regmap
*map
, unsigned int min
,
1015 WARN_ONCE(1, "regmap API is disabled");
1019 static inline void regcache_cache_only(struct regmap
*map
, bool enable
)
1021 WARN_ONCE(1, "regmap API is disabled");
1024 static inline void regcache_cache_bypass(struct regmap
*map
, bool enable
)
1026 WARN_ONCE(1, "regmap API is disabled");
1029 static inline void regcache_mark_dirty(struct regmap
*map
)
1031 WARN_ONCE(1, "regmap API is disabled");
1034 static inline void regmap_async_complete(struct regmap
*map
)
1036 WARN_ONCE(1, "regmap API is disabled");
1039 static inline int regmap_register_patch(struct regmap
*map
,
1040 const struct reg_sequence
*regs
,
1043 WARN_ONCE(1, "regmap API is disabled");
1047 static inline int regmap_parse_val(struct regmap
*map
, const void *buf
,
1050 WARN_ONCE(1, "regmap API is disabled");
1054 static inline struct regmap
*dev_get_regmap(struct device
*dev
,
1060 static inline struct device
*regmap_get_device(struct regmap
*map
)
1062 WARN_ONCE(1, "regmap API is disabled");