1 /* SPDX-License-Identifier: GPL-2.0-only */
2 #ifndef __LINUX_REGMAP_H
3 #define __LINUX_REGMAP_H
6 * Register map access API
8 * Copyright 2011 Wolfson Microelectronics plc
10 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
13 #include <linux/list.h>
14 #include <linux/rbtree.h>
15 #include <linux/ktime.h>
16 #include <linux/delay.h>
17 #include <linux/err.h>
18 #include <linux/bug.h>
19 #include <linux/lockdep.h>
30 struct regmap_range_cfg
;
35 /* An enum of all the supported cache types */
44 * struct reg_default - Default value for a register.
46 * @reg: Register address.
47 * @def: Register default value.
49 * We use an array of structs rather than a simple array as many modern devices
50 * have very sparse register maps.
58 * struct reg_sequence - An individual write from a sequence of writes.
60 * @reg: Register address.
61 * @def: Register value.
62 * @delay_us: Delay to be applied after the register write in microseconds
64 * Register/value pairs for sequences of writes with an optional delay in
65 * microseconds to be applied after each write.
70 unsigned int delay_us
;
73 #define regmap_update_bits(map, reg, mask, val) \
74 regmap_update_bits_base(map, reg, mask, val, NULL, false, false)
75 #define regmap_update_bits_async(map, reg, mask, val)\
76 regmap_update_bits_base(map, reg, mask, val, NULL, true, false)
77 #define regmap_update_bits_check(map, reg, mask, val, change)\
78 regmap_update_bits_base(map, reg, mask, val, change, false, false)
79 #define regmap_update_bits_check_async(map, reg, mask, val, change)\
80 regmap_update_bits_base(map, reg, mask, val, change, true, false)
82 #define regmap_write_bits(map, reg, mask, val) \
83 regmap_update_bits_base(map, reg, mask, val, NULL, false, true)
85 #define regmap_field_write(field, val) \
86 regmap_field_update_bits_base(field, ~0, val, NULL, false, false)
87 #define regmap_field_force_write(field, val) \
88 regmap_field_update_bits_base(field, ~0, val, NULL, false, true)
89 #define regmap_field_update_bits(field, mask, val)\
90 regmap_field_update_bits_base(field, mask, val, NULL, false, false)
91 #define regmap_field_force_update_bits(field, mask, val) \
92 regmap_field_update_bits_base(field, mask, val, NULL, false, true)
94 #define regmap_fields_write(field, id, val) \
95 regmap_fields_update_bits_base(field, id, ~0, val, NULL, false, false)
96 #define regmap_fields_force_write(field, id, val) \
97 regmap_fields_update_bits_base(field, id, ~0, val, NULL, false, true)
98 #define regmap_fields_update_bits(field, id, mask, val)\
99 regmap_fields_update_bits_base(field, id, mask, val, NULL, false, false)
100 #define regmap_fields_force_update_bits(field, id, mask, val) \
101 regmap_fields_update_bits_base(field, id, mask, val, NULL, false, true)
104 * regmap_read_poll_timeout - Poll until a condition is met or a timeout occurs
106 * @map: Regmap to read from
107 * @addr: Address to poll
108 * @val: Unsigned integer variable to read the value into
109 * @cond: Break condition (usually involving @val)
110 * @sleep_us: Maximum time to sleep between reads in us (0
111 * tight-loops). Should be less than ~20ms since usleep_range
112 * is used (see Documentation/timers/timers-howto.txt).
113 * @timeout_us: Timeout in us, 0 means never timeout
115 * Returns 0 on success and -ETIMEDOUT upon a timeout or the regmap_read
116 * error return value in case of a error read. In the two former cases,
117 * the last read value at @addr is stored in @val. Must not be called
118 * from atomic context if sleep_us or timeout_us are used.
120 * This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
122 #define regmap_read_poll_timeout(map, addr, val, cond, sleep_us, timeout_us) \
124 u64 __timeout_us = (timeout_us); \
125 unsigned long __sleep_us = (sleep_us); \
126 ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
128 might_sleep_if(__sleep_us); \
130 __ret = regmap_read((map), (addr), &(val)); \
135 if ((__timeout_us) && \
136 ktime_compare(ktime_get(), __timeout) > 0) { \
137 __ret = regmap_read((map), (addr), &(val)); \
141 usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
143 __ret ?: ((cond) ? 0 : -ETIMEDOUT); \
147 * regmap_field_read_poll_timeout - Poll until a condition is met or timeout
149 * @field: Regmap field to read from
150 * @val: Unsigned integer variable to read the value into
151 * @cond: Break condition (usually involving @val)
152 * @sleep_us: Maximum time to sleep between reads in us (0
153 * tight-loops). Should be less than ~20ms since usleep_range
154 * is used (see Documentation/timers/timers-howto.txt).
155 * @timeout_us: Timeout in us, 0 means never timeout
157 * Returns 0 on success and -ETIMEDOUT upon a timeout or the regmap_field_read
158 * error return value in case of a error read. In the two former cases,
159 * the last read value at @addr is stored in @val. Must not be called
160 * from atomic context if sleep_us or timeout_us are used.
162 * This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
164 #define regmap_field_read_poll_timeout(field, val, cond, sleep_us, timeout_us) \
166 u64 __timeout_us = (timeout_us); \
167 unsigned long __sleep_us = (sleep_us); \
168 ktime_t timeout = ktime_add_us(ktime_get(), __timeout_us); \
170 might_sleep_if(__sleep_us); \
172 pollret = regmap_field_read((field), &(val)); \
177 if (__timeout_us && ktime_compare(ktime_get(), timeout) > 0) { \
178 pollret = regmap_field_read((field), &(val)); \
182 usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
184 pollret ?: ((cond) ? 0 : -ETIMEDOUT); \
190 /* Unspecified -> 0 -> Backwards compatible default */
191 REGMAP_ENDIAN_DEFAULT
= 0,
193 REGMAP_ENDIAN_LITTLE
,
194 REGMAP_ENDIAN_NATIVE
,
198 * struct regmap_range - A register range, used for access related checks
199 * (readable/writeable/volatile/precious checks)
201 * @range_min: address of first register
202 * @range_max: address of last register
204 struct regmap_range
{
205 unsigned int range_min
;
206 unsigned int range_max
;
209 #define regmap_reg_range(low, high) { .range_min = low, .range_max = high, }
212 * struct regmap_access_table - A table of register ranges for access checks
214 * @yes_ranges : pointer to an array of regmap ranges used as "yes ranges"
215 * @n_yes_ranges: size of the above array
216 * @no_ranges: pointer to an array of regmap ranges used as "no ranges"
217 * @n_no_ranges: size of the above array
219 * A table of ranges including some yes ranges and some no ranges.
220 * If a register belongs to a no_range, the corresponding check function
221 * will return false. If a register belongs to a yes range, the corresponding
222 * check function will return true. "no_ranges" are searched first.
224 struct regmap_access_table
{
225 const struct regmap_range
*yes_ranges
;
226 unsigned int n_yes_ranges
;
227 const struct regmap_range
*no_ranges
;
228 unsigned int n_no_ranges
;
231 typedef void (*regmap_lock
)(void *);
232 typedef void (*regmap_unlock
)(void *);
235 * struct regmap_config - Configuration for the register map of a device.
237 * @name: Optional name of the regmap. Useful when a device has multiple
240 * @reg_bits: Number of bits in a register address, mandatory.
241 * @reg_stride: The register address stride. Valid register addresses are a
242 * multiple of this value. If set to 0, a value of 1 will be
244 * @pad_bits: Number of bits of padding between register and value.
245 * @val_bits: Number of bits in a register value, mandatory.
247 * @writeable_reg: Optional callback returning true if the register
248 * can be written to. If this field is NULL but wr_table
249 * (see below) is not, the check is performed on such table
250 * (a register is writeable if it belongs to one of the ranges
251 * specified by wr_table).
252 * @readable_reg: Optional callback returning true if the register
253 * can be read from. If this field is NULL but rd_table
254 * (see below) is not, the check is performed on such table
255 * (a register is readable if it belongs to one of the ranges
256 * specified by rd_table).
257 * @volatile_reg: Optional callback returning true if the register
258 * value can't be cached. If this field is NULL but
259 * volatile_table (see below) is not, the check is performed on
260 * such table (a register is volatile if it belongs to one of
261 * the ranges specified by volatile_table).
262 * @precious_reg: Optional callback returning true if the register
263 * should not be read outside of a call from the driver
264 * (e.g., a clear on read interrupt status register). If this
265 * field is NULL but precious_table (see below) is not, the
266 * check is performed on such table (a register is precious if
267 * it belongs to one of the ranges specified by precious_table).
268 * @writeable_noinc_reg: Optional callback returning true if the register
269 * supports multiple write operations without incrementing
270 * the register number. If this field is NULL but
271 * wr_noinc_table (see below) is not, the check is
272 * performed on such table (a register is no increment
273 * writeable if it belongs to one of the ranges specified
274 * by wr_noinc_table).
275 * @readable_noinc_reg: Optional callback returning true if the register
276 * supports multiple read operations without incrementing
277 * the register number. If this field is NULL but
278 * rd_noinc_table (see below) is not, the check is
279 * performed on such table (a register is no increment
280 * readable if it belongs to one of the ranges specified
281 * by rd_noinc_table).
282 * @disable_locking: This regmap is either protected by external means or
283 * is guaranteed not be be accessed from multiple threads.
284 * Don't use any locking mechanisms.
285 * @lock: Optional lock callback (overrides regmap's default lock
286 * function, based on spinlock or mutex).
287 * @unlock: As above for unlocking.
288 * @lock_arg: this field is passed as the only argument of lock/unlock
289 * functions (ignored in case regular lock/unlock functions
290 * are not overridden).
291 * @reg_read: Optional callback that if filled will be used to perform
292 * all the reads from the registers. Should only be provided for
293 * devices whose read operation cannot be represented as a simple
294 * read operation on a bus such as SPI, I2C, etc. Most of the
295 * devices do not need this.
296 * @reg_write: Same as above for writing.
297 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
298 * to perform locking. This field is ignored if custom lock/unlock
299 * functions are used (see fields lock/unlock of struct regmap_config).
300 * This field is a duplicate of a similar file in
301 * 'struct regmap_bus' and serves exact same purpose.
302 * Use it only for "no-bus" cases.
303 * @max_register: Optional, specifies the maximum valid register address.
304 * @wr_table: Optional, points to a struct regmap_access_table specifying
305 * valid ranges for write access.
306 * @rd_table: As above, for read access.
307 * @volatile_table: As above, for volatile registers.
308 * @precious_table: As above, for precious registers.
309 * @wr_noinc_table: As above, for no increment writeable registers.
310 * @rd_noinc_table: As above, for no increment readable registers.
311 * @reg_defaults: Power on reset values for registers (for use with
312 * register cache support).
313 * @num_reg_defaults: Number of elements in reg_defaults.
315 * @read_flag_mask: Mask to be set in the top bytes of the register when doing
317 * @write_flag_mask: Mask to be set in the top bytes of the register when doing
318 * a write. If both read_flag_mask and write_flag_mask are
319 * empty and zero_flag_mask is not set the regmap_bus default
321 * @zero_flag_mask: If set, read_flag_mask and write_flag_mask are used even
322 * if they are both empty.
323 * @use_single_read: If set, converts the bulk read operation into a series of
324 * single read operations. This is useful for a device that
325 * does not support bulk read.
326 * @use_single_write: If set, converts the bulk write operation into a series of
327 * single write operations. This is useful for a device that
328 * does not support bulk write.
329 * @can_multi_write: If set, the device supports the multi write mode of bulk
330 * write operations, if clear multi write requests will be
331 * split into individual write operations
333 * @cache_type: The actual cache type.
334 * @reg_defaults_raw: Power on reset values for registers (for use with
335 * register cache support).
336 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
337 * @reg_format_endian: Endianness for formatted register addresses. If this is
338 * DEFAULT, the @reg_format_endian_default value from the
339 * regmap bus is used.
340 * @val_format_endian: Endianness for formatted register values. If this is
341 * DEFAULT, the @reg_format_endian_default value from the
342 * regmap bus is used.
344 * @ranges: Array of configuration entries for virtual address ranges.
345 * @num_ranges: Number of range configuration entries.
346 * @use_hwlock: Indicate if a hardware spinlock should be used.
347 * @hwlock_id: Specify the hardware spinlock id.
348 * @hwlock_mode: The hardware spinlock mode, should be HWLOCK_IRQSTATE,
351 struct regmap_config
{
359 bool (*writeable_reg
)(struct device
*dev
, unsigned int reg
);
360 bool (*readable_reg
)(struct device
*dev
, unsigned int reg
);
361 bool (*volatile_reg
)(struct device
*dev
, unsigned int reg
);
362 bool (*precious_reg
)(struct device
*dev
, unsigned int reg
);
363 bool (*writeable_noinc_reg
)(struct device
*dev
, unsigned int reg
);
364 bool (*readable_noinc_reg
)(struct device
*dev
, unsigned int reg
);
366 bool disable_locking
;
368 regmap_unlock unlock
;
371 int (*reg_read
)(void *context
, unsigned int reg
, unsigned int *val
);
372 int (*reg_write
)(void *context
, unsigned int reg
, unsigned int val
);
376 unsigned int max_register
;
377 const struct regmap_access_table
*wr_table
;
378 const struct regmap_access_table
*rd_table
;
379 const struct regmap_access_table
*volatile_table
;
380 const struct regmap_access_table
*precious_table
;
381 const struct regmap_access_table
*wr_noinc_table
;
382 const struct regmap_access_table
*rd_noinc_table
;
383 const struct reg_default
*reg_defaults
;
384 unsigned int num_reg_defaults
;
385 enum regcache_type cache_type
;
386 const void *reg_defaults_raw
;
387 unsigned int num_reg_defaults_raw
;
389 unsigned long read_flag_mask
;
390 unsigned long write_flag_mask
;
393 bool use_single_read
;
394 bool use_single_write
;
395 bool can_multi_write
;
397 enum regmap_endian reg_format_endian
;
398 enum regmap_endian val_format_endian
;
400 const struct regmap_range_cfg
*ranges
;
401 unsigned int num_ranges
;
404 unsigned int hwlock_id
;
405 unsigned int hwlock_mode
;
409 * struct regmap_range_cfg - Configuration for indirectly accessed or paged
412 * @name: Descriptive name for diagnostics
414 * @range_min: Address of the lowest register address in virtual range.
415 * @range_max: Address of the highest register in virtual range.
417 * @selector_reg: Register with selector field.
418 * @selector_mask: Bit shift for selector value.
419 * @selector_shift: Bit mask for selector value.
421 * @window_start: Address of first (lowest) register in data window.
422 * @window_len: Number of registers in data window.
424 * Registers, mapped to this virtual range, are accessed in two steps:
425 * 1. page selector register update;
426 * 2. access through data window registers.
428 struct regmap_range_cfg
{
431 /* Registers of virtual address range */
432 unsigned int range_min
;
433 unsigned int range_max
;
435 /* Page selector for indirect addressing */
436 unsigned int selector_reg
;
437 unsigned int selector_mask
;
440 /* Data window (per each page) */
441 unsigned int window_start
;
442 unsigned int window_len
;
447 typedef int (*regmap_hw_write
)(void *context
, const void *data
,
449 typedef int (*regmap_hw_gather_write
)(void *context
,
450 const void *reg
, size_t reg_len
,
451 const void *val
, size_t val_len
);
452 typedef int (*regmap_hw_async_write
)(void *context
,
453 const void *reg
, size_t reg_len
,
454 const void *val
, size_t val_len
,
455 struct regmap_async
*async
);
456 typedef int (*regmap_hw_read
)(void *context
,
457 const void *reg_buf
, size_t reg_size
,
458 void *val_buf
, size_t val_size
);
459 typedef int (*regmap_hw_reg_read
)(void *context
, unsigned int reg
,
461 typedef int (*regmap_hw_reg_write
)(void *context
, unsigned int reg
,
463 typedef int (*regmap_hw_reg_update_bits
)(void *context
, unsigned int reg
,
464 unsigned int mask
, unsigned int val
);
465 typedef struct regmap_async
*(*regmap_hw_async_alloc
)(void);
466 typedef void (*regmap_hw_free_context
)(void *context
);
469 * struct regmap_bus - Description of a hardware bus for the register map
472 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
473 * to perform locking. This field is ignored if custom lock/unlock
474 * functions are used (see fields lock/unlock of
475 * struct regmap_config).
476 * @write: Write operation.
477 * @gather_write: Write operation with split register/value, return -ENOTSUPP
478 * if not implemented on a given device.
479 * @async_write: Write operation which completes asynchronously, optional and
480 * must serialise with respect to non-async I/O.
481 * @reg_write: Write a single register value to the given register address. This
482 * write operation has to complete when returning from the function.
483 * @reg_update_bits: Update bits operation to be used against volatile
484 * registers, intended for devices supporting some mechanism
485 * for setting clearing bits without having to
487 * @read: Read operation. Data is returned in the buffer used to transmit
489 * @reg_read: Read a single register value from a given register address.
490 * @free_context: Free context.
491 * @async_alloc: Allocate a regmap_async() structure.
492 * @read_flag_mask: Mask to be set in the top byte of the register when doing
494 * @reg_format_endian_default: Default endianness for formatted register
495 * addresses. Used when the regmap_config specifies DEFAULT. If this is
496 * DEFAULT, BIG is assumed.
497 * @val_format_endian_default: Default endianness for formatted register
498 * values. Used when the regmap_config specifies DEFAULT. If this is
499 * DEFAULT, BIG is assumed.
500 * @max_raw_read: Max raw read size that can be used on the bus.
501 * @max_raw_write: Max raw write size that can be used on the bus.
505 regmap_hw_write write
;
506 regmap_hw_gather_write gather_write
;
507 regmap_hw_async_write async_write
;
508 regmap_hw_reg_write reg_write
;
509 regmap_hw_reg_update_bits reg_update_bits
;
511 regmap_hw_reg_read reg_read
;
512 regmap_hw_free_context free_context
;
513 regmap_hw_async_alloc async_alloc
;
515 enum regmap_endian reg_format_endian_default
;
516 enum regmap_endian val_format_endian_default
;
518 size_t max_raw_write
;
522 * __regmap_init functions.
524 * These functions take a lock key and name parameter, and should not be called
525 * directly. Instead, use the regmap_init macros that generate a key and name
528 struct regmap
*__regmap_init(struct device
*dev
,
529 const struct regmap_bus
*bus
,
531 const struct regmap_config
*config
,
532 struct lock_class_key
*lock_key
,
533 const char *lock_name
);
534 struct regmap
*__regmap_init_i2c(struct i2c_client
*i2c
,
535 const struct regmap_config
*config
,
536 struct lock_class_key
*lock_key
,
537 const char *lock_name
);
538 struct regmap
*__regmap_init_sccb(struct i2c_client
*i2c
,
539 const struct regmap_config
*config
,
540 struct lock_class_key
*lock_key
,
541 const char *lock_name
);
542 struct regmap
*__regmap_init_slimbus(struct slim_device
*slimbus
,
543 const struct regmap_config
*config
,
544 struct lock_class_key
*lock_key
,
545 const char *lock_name
);
546 struct regmap
*__regmap_init_spi(struct spi_device
*dev
,
547 const struct regmap_config
*config
,
548 struct lock_class_key
*lock_key
,
549 const char *lock_name
);
550 struct regmap
*__regmap_init_spmi_base(struct spmi_device
*dev
,
551 const struct regmap_config
*config
,
552 struct lock_class_key
*lock_key
,
553 const char *lock_name
);
554 struct regmap
*__regmap_init_spmi_ext(struct spmi_device
*dev
,
555 const struct regmap_config
*config
,
556 struct lock_class_key
*lock_key
,
557 const char *lock_name
);
558 struct regmap
*__regmap_init_w1(struct device
*w1_dev
,
559 const struct regmap_config
*config
,
560 struct lock_class_key
*lock_key
,
561 const char *lock_name
);
562 struct regmap
*__regmap_init_mmio_clk(struct device
*dev
, const char *clk_id
,
564 const struct regmap_config
*config
,
565 struct lock_class_key
*lock_key
,
566 const char *lock_name
);
567 struct regmap
*__regmap_init_ac97(struct snd_ac97
*ac97
,
568 const struct regmap_config
*config
,
569 struct lock_class_key
*lock_key
,
570 const char *lock_name
);
571 struct regmap
*__regmap_init_sdw(struct sdw_slave
*sdw
,
572 const struct regmap_config
*config
,
573 struct lock_class_key
*lock_key
,
574 const char *lock_name
);
576 struct regmap
*__devm_regmap_init(struct device
*dev
,
577 const struct regmap_bus
*bus
,
579 const struct regmap_config
*config
,
580 struct lock_class_key
*lock_key
,
581 const char *lock_name
);
582 struct regmap
*__devm_regmap_init_i2c(struct i2c_client
*i2c
,
583 const struct regmap_config
*config
,
584 struct lock_class_key
*lock_key
,
585 const char *lock_name
);
586 struct regmap
*__devm_regmap_init_sccb(struct i2c_client
*i2c
,
587 const struct regmap_config
*config
,
588 struct lock_class_key
*lock_key
,
589 const char *lock_name
);
590 struct regmap
*__devm_regmap_init_spi(struct spi_device
*dev
,
591 const struct regmap_config
*config
,
592 struct lock_class_key
*lock_key
,
593 const char *lock_name
);
594 struct regmap
*__devm_regmap_init_spmi_base(struct spmi_device
*dev
,
595 const struct regmap_config
*config
,
596 struct lock_class_key
*lock_key
,
597 const char *lock_name
);
598 struct regmap
*__devm_regmap_init_spmi_ext(struct spmi_device
*dev
,
599 const struct regmap_config
*config
,
600 struct lock_class_key
*lock_key
,
601 const char *lock_name
);
602 struct regmap
*__devm_regmap_init_w1(struct device
*w1_dev
,
603 const struct regmap_config
*config
,
604 struct lock_class_key
*lock_key
,
605 const char *lock_name
);
606 struct regmap
*__devm_regmap_init_mmio_clk(struct device
*dev
,
609 const struct regmap_config
*config
,
610 struct lock_class_key
*lock_key
,
611 const char *lock_name
);
612 struct regmap
*__devm_regmap_init_ac97(struct snd_ac97
*ac97
,
613 const struct regmap_config
*config
,
614 struct lock_class_key
*lock_key
,
615 const char *lock_name
);
616 struct regmap
*__devm_regmap_init_sdw(struct sdw_slave
*sdw
,
617 const struct regmap_config
*config
,
618 struct lock_class_key
*lock_key
,
619 const char *lock_name
);
620 struct regmap
*__devm_regmap_init_slimbus(struct slim_device
*slimbus
,
621 const struct regmap_config
*config
,
622 struct lock_class_key
*lock_key
,
623 const char *lock_name
);
625 * Wrapper for regmap_init macros to include a unique lockdep key and name
626 * for each call. No-op if CONFIG_LOCKDEP is not set.
628 * @fn: Real function to call (in the form __[*_]regmap_init[_*])
629 * @name: Config variable name (#config in the calling macro)
631 #ifdef CONFIG_LOCKDEP
632 #define __regmap_lockdep_wrapper(fn, name, ...) \
635 static struct lock_class_key _key; \
636 fn(__VA_ARGS__, &_key, \
637 KBUILD_BASENAME ":" \
638 __stringify(__LINE__) ":" \
639 "(" name ")->lock"); \
643 #define __regmap_lockdep_wrapper(fn, name, ...) fn(__VA_ARGS__, NULL, NULL)
647 * regmap_init() - Initialise register map
649 * @dev: Device that will be interacted with
650 * @bus: Bus-specific callbacks to use with device
651 * @bus_context: Data passed to bus-specific callbacks
652 * @config: Configuration for register map
654 * The return value will be an ERR_PTR() on error or a valid pointer to
655 * a struct regmap. This function should generally not be called
656 * directly, it should be called by bus-specific init functions.
658 #define regmap_init(dev, bus, bus_context, config) \
659 __regmap_lockdep_wrapper(__regmap_init, #config, \
660 dev, bus, bus_context, config)
661 int regmap_attach_dev(struct device
*dev
, struct regmap
*map
,
662 const struct regmap_config
*config
);
665 * regmap_init_i2c() - Initialise register map
667 * @i2c: Device that will be interacted with
668 * @config: Configuration for register map
670 * The return value will be an ERR_PTR() on error or a valid pointer to
673 #define regmap_init_i2c(i2c, config) \
674 __regmap_lockdep_wrapper(__regmap_init_i2c, #config, \
678 * regmap_init_sccb() - Initialise register map
680 * @i2c: Device that will be interacted with
681 * @config: Configuration for register map
683 * The return value will be an ERR_PTR() on error or a valid pointer to
686 #define regmap_init_sccb(i2c, config) \
687 __regmap_lockdep_wrapper(__regmap_init_sccb, #config, \
691 * regmap_init_slimbus() - Initialise register map
693 * @slimbus: Device that will be interacted with
694 * @config: Configuration for register map
696 * The return value will be an ERR_PTR() on error or a valid pointer to
699 #define regmap_init_slimbus(slimbus, config) \
700 __regmap_lockdep_wrapper(__regmap_init_slimbus, #config, \
704 * regmap_init_spi() - Initialise register map
706 * @dev: Device that will be interacted with
707 * @config: Configuration for register map
709 * The return value will be an ERR_PTR() on error or a valid pointer to
712 #define regmap_init_spi(dev, config) \
713 __regmap_lockdep_wrapper(__regmap_init_spi, #config, \
717 * regmap_init_spmi_base() - Create regmap for the Base register space
719 * @dev: SPMI device that will be interacted with
720 * @config: Configuration for register map
722 * The return value will be an ERR_PTR() on error or a valid pointer to
725 #define regmap_init_spmi_base(dev, config) \
726 __regmap_lockdep_wrapper(__regmap_init_spmi_base, #config, \
730 * regmap_init_spmi_ext() - Create regmap for Ext register space
732 * @dev: Device that will be interacted with
733 * @config: Configuration for register map
735 * The return value will be an ERR_PTR() on error or a valid pointer to
738 #define regmap_init_spmi_ext(dev, config) \
739 __regmap_lockdep_wrapper(__regmap_init_spmi_ext, #config, \
743 * regmap_init_w1() - Initialise register map
745 * @w1_dev: Device that will be interacted with
746 * @config: Configuration for register map
748 * The return value will be an ERR_PTR() on error or a valid pointer to
751 #define regmap_init_w1(w1_dev, config) \
752 __regmap_lockdep_wrapper(__regmap_init_w1, #config, \
756 * regmap_init_mmio_clk() - Initialise register map with register clock
758 * @dev: Device that will be interacted with
759 * @clk_id: register clock consumer ID
760 * @regs: Pointer to memory-mapped IO region
761 * @config: Configuration for register map
763 * The return value will be an ERR_PTR() on error or a valid pointer to
766 #define regmap_init_mmio_clk(dev, clk_id, regs, config) \
767 __regmap_lockdep_wrapper(__regmap_init_mmio_clk, #config, \
768 dev, clk_id, regs, config)
771 * regmap_init_mmio() - Initialise register map
773 * @dev: Device that will be interacted with
774 * @regs: Pointer to memory-mapped IO region
775 * @config: Configuration for register map
777 * The return value will be an ERR_PTR() on error or a valid pointer to
780 #define regmap_init_mmio(dev, regs, config) \
781 regmap_init_mmio_clk(dev, NULL, regs, config)
784 * regmap_init_ac97() - Initialise AC'97 register map
786 * @ac97: Device that will be interacted with
787 * @config: Configuration for register map
789 * The return value will be an ERR_PTR() on error or a valid pointer to
792 #define regmap_init_ac97(ac97, config) \
793 __regmap_lockdep_wrapper(__regmap_init_ac97, #config, \
795 bool regmap_ac97_default_volatile(struct device
*dev
, unsigned int reg
);
798 * regmap_init_sdw() - Initialise register map
800 * @sdw: Device that will be interacted with
801 * @config: Configuration for register map
803 * The return value will be an ERR_PTR() on error or a valid pointer to
806 #define regmap_init_sdw(sdw, config) \
807 __regmap_lockdep_wrapper(__regmap_init_sdw, #config, \
812 * devm_regmap_init() - Initialise managed register map
814 * @dev: Device that will be interacted with
815 * @bus: Bus-specific callbacks to use with device
816 * @bus_context: Data passed to bus-specific callbacks
817 * @config: Configuration for register map
819 * The return value will be an ERR_PTR() on error or a valid pointer
820 * to a struct regmap. This function should generally not be called
821 * directly, it should be called by bus-specific init functions. The
822 * map will be automatically freed by the device management code.
824 #define devm_regmap_init(dev, bus, bus_context, config) \
825 __regmap_lockdep_wrapper(__devm_regmap_init, #config, \
826 dev, bus, bus_context, config)
829 * devm_regmap_init_i2c() - Initialise managed register map
831 * @i2c: Device that will be interacted with
832 * @config: Configuration for register map
834 * The return value will be an ERR_PTR() on error or a valid pointer
835 * to a struct regmap. The regmap will be automatically freed by the
836 * device management code.
838 #define devm_regmap_init_i2c(i2c, config) \
839 __regmap_lockdep_wrapper(__devm_regmap_init_i2c, #config, \
843 * devm_regmap_init_sccb() - Initialise managed register map
845 * @i2c: Device that will be interacted with
846 * @config: Configuration for register map
848 * The return value will be an ERR_PTR() on error or a valid pointer
849 * to a struct regmap. The regmap will be automatically freed by the
850 * device management code.
852 #define devm_regmap_init_sccb(i2c, config) \
853 __regmap_lockdep_wrapper(__devm_regmap_init_sccb, #config, \
857 * devm_regmap_init_spi() - Initialise register map
859 * @dev: Device that will be interacted with
860 * @config: Configuration for register map
862 * The return value will be an ERR_PTR() on error or a valid pointer
863 * to a struct regmap. The map will be automatically freed by the
864 * device management code.
866 #define devm_regmap_init_spi(dev, config) \
867 __regmap_lockdep_wrapper(__devm_regmap_init_spi, #config, \
871 * devm_regmap_init_spmi_base() - Create managed regmap for Base register space
873 * @dev: SPMI device that will be interacted with
874 * @config: Configuration for register map
876 * The return value will be an ERR_PTR() on error or a valid pointer
877 * to a struct regmap. The regmap will be automatically freed by the
878 * device management code.
880 #define devm_regmap_init_spmi_base(dev, config) \
881 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_base, #config, \
885 * devm_regmap_init_spmi_ext() - Create managed regmap for Ext register space
887 * @dev: SPMI device that will be interacted with
888 * @config: Configuration for register map
890 * The return value will be an ERR_PTR() on error or a valid pointer
891 * to a struct regmap. The regmap will be automatically freed by the
892 * device management code.
894 #define devm_regmap_init_spmi_ext(dev, config) \
895 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_ext, #config, \
899 * devm_regmap_init_w1() - Initialise managed register map
901 * @w1_dev: Device that will be interacted with
902 * @config: Configuration for register map
904 * The return value will be an ERR_PTR() on error or a valid pointer
905 * to a struct regmap. The regmap will be automatically freed by the
906 * device management code.
908 #define devm_regmap_init_w1(w1_dev, config) \
909 __regmap_lockdep_wrapper(__devm_regmap_init_w1, #config, \
912 * devm_regmap_init_mmio_clk() - Initialise managed register map with clock
914 * @dev: Device that will be interacted with
915 * @clk_id: register clock consumer ID
916 * @regs: Pointer to memory-mapped IO region
917 * @config: Configuration for register map
919 * The return value will be an ERR_PTR() on error or a valid pointer
920 * to a struct regmap. The regmap will be automatically freed by the
921 * device management code.
923 #define devm_regmap_init_mmio_clk(dev, clk_id, regs, config) \
924 __regmap_lockdep_wrapper(__devm_regmap_init_mmio_clk, #config, \
925 dev, clk_id, regs, config)
928 * devm_regmap_init_mmio() - Initialise managed register map
930 * @dev: Device that will be interacted with
931 * @regs: Pointer to memory-mapped IO region
932 * @config: Configuration for register map
934 * The return value will be an ERR_PTR() on error or a valid pointer
935 * to a struct regmap. The regmap will be automatically freed by the
936 * device management code.
938 #define devm_regmap_init_mmio(dev, regs, config) \
939 devm_regmap_init_mmio_clk(dev, NULL, regs, config)
942 * devm_regmap_init_ac97() - Initialise AC'97 register map
944 * @ac97: Device that will be interacted with
945 * @config: Configuration for register map
947 * The return value will be an ERR_PTR() on error or a valid pointer
948 * to a struct regmap. The regmap will be automatically freed by the
949 * device management code.
951 #define devm_regmap_init_ac97(ac97, config) \
952 __regmap_lockdep_wrapper(__devm_regmap_init_ac97, #config, \
956 * devm_regmap_init_sdw() - Initialise managed register map
958 * @sdw: Device that will be interacted with
959 * @config: Configuration for register map
961 * The return value will be an ERR_PTR() on error or a valid pointer
962 * to a struct regmap. The regmap will be automatically freed by the
963 * device management code.
965 #define devm_regmap_init_sdw(sdw, config) \
966 __regmap_lockdep_wrapper(__devm_regmap_init_sdw, #config, \
970 * devm_regmap_init_slimbus() - Initialise managed register map
972 * @slimbus: Device that will be interacted with
973 * @config: Configuration for register map
975 * The return value will be an ERR_PTR() on error or a valid pointer
976 * to a struct regmap. The regmap will be automatically freed by the
977 * device management code.
979 #define devm_regmap_init_slimbus(slimbus, config) \
980 __regmap_lockdep_wrapper(__devm_regmap_init_slimbus, #config, \
982 int regmap_mmio_attach_clk(struct regmap
*map
, struct clk
*clk
);
983 void regmap_mmio_detach_clk(struct regmap
*map
);
984 void regmap_exit(struct regmap
*map
);
985 int regmap_reinit_cache(struct regmap
*map
,
986 const struct regmap_config
*config
);
987 struct regmap
*dev_get_regmap(struct device
*dev
, const char *name
);
988 struct device
*regmap_get_device(struct regmap
*map
);
989 int regmap_write(struct regmap
*map
, unsigned int reg
, unsigned int val
);
990 int regmap_write_async(struct regmap
*map
, unsigned int reg
, unsigned int val
);
991 int regmap_raw_write(struct regmap
*map
, unsigned int reg
,
992 const void *val
, size_t val_len
);
993 int regmap_noinc_write(struct regmap
*map
, unsigned int reg
,
994 const void *val
, size_t val_len
);
995 int regmap_bulk_write(struct regmap
*map
, unsigned int reg
, const void *val
,
997 int regmap_multi_reg_write(struct regmap
*map
, const struct reg_sequence
*regs
,
999 int regmap_multi_reg_write_bypassed(struct regmap
*map
,
1000 const struct reg_sequence
*regs
,
1002 int regmap_raw_write_async(struct regmap
*map
, unsigned int reg
,
1003 const void *val
, size_t val_len
);
1004 int regmap_read(struct regmap
*map
, unsigned int reg
, unsigned int *val
);
1005 int regmap_raw_read(struct regmap
*map
, unsigned int reg
,
1006 void *val
, size_t val_len
);
1007 int regmap_noinc_read(struct regmap
*map
, unsigned int reg
,
1008 void *val
, size_t val_len
);
1009 int regmap_bulk_read(struct regmap
*map
, unsigned int reg
, void *val
,
1011 int regmap_update_bits_base(struct regmap
*map
, unsigned int reg
,
1012 unsigned int mask
, unsigned int val
,
1013 bool *change
, bool async
, bool force
);
1014 int regmap_get_val_bytes(struct regmap
*map
);
1015 int regmap_get_max_register(struct regmap
*map
);
1016 int regmap_get_reg_stride(struct regmap
*map
);
1017 int regmap_async_complete(struct regmap
*map
);
1018 bool regmap_can_raw_write(struct regmap
*map
);
1019 size_t regmap_get_raw_read_max(struct regmap
*map
);
1020 size_t regmap_get_raw_write_max(struct regmap
*map
);
1022 int regcache_sync(struct regmap
*map
);
1023 int regcache_sync_region(struct regmap
*map
, unsigned int min
,
1025 int regcache_drop_region(struct regmap
*map
, unsigned int min
,
1027 void regcache_cache_only(struct regmap
*map
, bool enable
);
1028 void regcache_cache_bypass(struct regmap
*map
, bool enable
);
1029 void regcache_mark_dirty(struct regmap
*map
);
1031 bool regmap_check_range_table(struct regmap
*map
, unsigned int reg
,
1032 const struct regmap_access_table
*table
);
1034 int regmap_register_patch(struct regmap
*map
, const struct reg_sequence
*regs
,
1036 int regmap_parse_val(struct regmap
*map
, const void *buf
,
1039 static inline bool regmap_reg_in_range(unsigned int reg
,
1040 const struct regmap_range
*range
)
1042 return reg
>= range
->range_min
&& reg
<= range
->range_max
;
1045 bool regmap_reg_in_ranges(unsigned int reg
,
1046 const struct regmap_range
*ranges
,
1047 unsigned int nranges
);
1050 * struct reg_field - Description of an register field
1052 * @reg: Offset of the register within the regmap bank
1053 * @lsb: lsb of the register field.
1054 * @msb: msb of the register field.
1055 * @id_size: port size if it has some ports
1056 * @id_offset: address offset for each ports
1062 unsigned int id_size
;
1063 unsigned int id_offset
;
1066 #define REG_FIELD(_reg, _lsb, _msb) { \
1072 struct regmap_field
*regmap_field_alloc(struct regmap
*regmap
,
1073 struct reg_field reg_field
);
1074 void regmap_field_free(struct regmap_field
*field
);
1076 struct regmap_field
*devm_regmap_field_alloc(struct device
*dev
,
1077 struct regmap
*regmap
, struct reg_field reg_field
);
1078 void devm_regmap_field_free(struct device
*dev
, struct regmap_field
*field
);
1080 int regmap_field_read(struct regmap_field
*field
, unsigned int *val
);
1081 int regmap_field_update_bits_base(struct regmap_field
*field
,
1082 unsigned int mask
, unsigned int val
,
1083 bool *change
, bool async
, bool force
);
1084 int regmap_fields_read(struct regmap_field
*field
, unsigned int id
,
1086 int regmap_fields_update_bits_base(struct regmap_field
*field
, unsigned int id
,
1087 unsigned int mask
, unsigned int val
,
1088 bool *change
, bool async
, bool force
);
1090 * struct regmap_irq_type - IRQ type definitions.
1092 * @type_reg_offset: Offset register for the irq type setting.
1093 * @type_rising_val: Register value to configure RISING type irq.
1094 * @type_falling_val: Register value to configure FALLING type irq.
1095 * @type_level_low_val: Register value to configure LEVEL_LOW type irq.
1096 * @type_level_high_val: Register value to configure LEVEL_HIGH type irq.
1097 * @types_supported: logical OR of IRQ_TYPE_* flags indicating supported types.
1099 struct regmap_irq_type
{
1100 unsigned int type_reg_offset
;
1101 unsigned int type_reg_mask
;
1102 unsigned int type_rising_val
;
1103 unsigned int type_falling_val
;
1104 unsigned int type_level_low_val
;
1105 unsigned int type_level_high_val
;
1106 unsigned int types_supported
;
1110 * struct regmap_irq - Description of an IRQ for the generic regmap irq_chip.
1112 * @reg_offset: Offset of the status/mask register within the bank
1113 * @mask: Mask used to flag/control the register.
1114 * @type: IRQ trigger type setting details if supported.
1117 unsigned int reg_offset
;
1119 struct regmap_irq_type type
;
1122 #define REGMAP_IRQ_REG(_irq, _off, _mask) \
1123 [_irq] = { .reg_offset = (_off), .mask = (_mask) }
1125 #define REGMAP_IRQ_REG_LINE(_id, _reg_bits) \
1127 .mask = BIT((_id) % (_reg_bits)), \
1128 .reg_offset = (_id) / (_reg_bits), \
1131 #define REGMAP_IRQ_MAIN_REG_OFFSET(arr) \
1132 { .num_regs = ARRAY_SIZE((arr)), .offset = &(arr)[0] }
1134 struct regmap_irq_sub_irq_map
{
1135 unsigned int num_regs
;
1136 unsigned int *offset
;
1140 * struct regmap_irq_chip - Description of a generic regmap irq_chip.
1142 * @name: Descriptive name for IRQ controller.
1144 * @main_status: Base main status register address. For chips which have
1145 * interrupts arranged in separate sub-irq blocks with own IRQ
1146 * registers and which have a main IRQ registers indicating
1147 * sub-irq blocks with unhandled interrupts. For such chips fill
1148 * sub-irq register information in status_base, mask_base and
1150 * @num_main_status_bits: Should be given to chips where number of meaningfull
1151 * main status bits differs from num_regs.
1152 * @sub_reg_offsets: arrays of mappings from main register bits to sub irq
1153 * registers. First item in array describes the registers
1154 * for first main status bit. Second array for second bit etc.
1155 * Offset is given as sub register status offset to
1156 * status_base. Should contain num_regs arrays.
1157 * Can be provided for chips with more complex mapping than
1158 * 1.st bit to 1.st sub-reg, 2.nd bit to 2.nd sub-reg, ...
1159 * @num_main_regs: Number of 'main status' irq registers for chips which have
1162 * @status_base: Base status register address.
1163 * @mask_base: Base mask register address.
1164 * @mask_writeonly: Base mask register is write only.
1165 * @unmask_base: Base unmask register address. for chips who have
1166 * separate mask and unmask registers
1167 * @ack_base: Base ack address. If zero then the chip is clear on read.
1168 * Using zero value is possible with @use_ack bit.
1169 * @wake_base: Base address for wake enables. If zero unsupported.
1170 * @type_base: Base address for irq type. If zero unsupported.
1171 * @irq_reg_stride: Stride to use for chips where registers are not contiguous.
1172 * @init_ack_masked: Ack all masked interrupts once during initalization.
1173 * @mask_invert: Inverted mask register: cleared bits are masked out.
1174 * @use_ack: Use @ack register even if it is zero.
1175 * @ack_invert: Inverted ack register: cleared bits for ack.
1176 * @wake_invert: Inverted wake register: cleared bits are wake enabled.
1177 * @type_invert: Invert the type flags.
1178 * @type_in_mask: Use the mask registers for controlling irq type. For
1179 * interrupts defining type_rising/falling_mask use mask_base
1180 * for edge configuration and never update bits in type_base.
1181 * @clear_on_unmask: For chips with interrupts cleared on read: read the status
1182 * registers before unmasking interrupts to clear any bits
1183 * set when they were masked.
1184 * @runtime_pm: Hold a runtime PM lock on the device when accessing it.
1186 * @num_regs: Number of registers in each control bank.
1187 * @irqs: Descriptors for individual IRQs. Interrupt numbers are
1188 * assigned based on the index in the array of the interrupt.
1189 * @num_irqs: Number of descriptors.
1190 * @num_type_reg: Number of type registers.
1191 * @type_reg_stride: Stride to use for chips where type registers are not
1193 * @handle_pre_irq: Driver specific callback to handle interrupt from device
1194 * before regmap_irq_handler process the interrupts.
1195 * @handle_post_irq: Driver specific callback to handle interrupt from device
1196 * after handling the interrupts in regmap_irq_handler().
1197 * @irq_drv_data: Driver specific IRQ data which is passed as parameter when
1198 * driver specific pre/post interrupt handler is called.
1200 * This is not intended to handle every possible interrupt controller, but
1201 * it should handle a substantial proportion of those that are found in the
1204 struct regmap_irq_chip
{
1207 unsigned int main_status
;
1208 unsigned int num_main_status_bits
;
1209 struct regmap_irq_sub_irq_map
*sub_reg_offsets
;
1212 unsigned int status_base
;
1213 unsigned int mask_base
;
1214 unsigned int unmask_base
;
1215 unsigned int ack_base
;
1216 unsigned int wake_base
;
1217 unsigned int type_base
;
1218 unsigned int irq_reg_stride
;
1219 bool mask_writeonly
:1;
1220 bool init_ack_masked
:1;
1227 bool type_in_mask
:1;
1228 bool clear_on_unmask
:1;
1232 const struct regmap_irq
*irqs
;
1236 unsigned int type_reg_stride
;
1238 int (*handle_pre_irq
)(void *irq_drv_data
);
1239 int (*handle_post_irq
)(void *irq_drv_data
);
1243 struct regmap_irq_chip_data
;
1245 int regmap_add_irq_chip(struct regmap
*map
, int irq
, int irq_flags
,
1246 int irq_base
, const struct regmap_irq_chip
*chip
,
1247 struct regmap_irq_chip_data
**data
);
1248 void regmap_del_irq_chip(int irq
, struct regmap_irq_chip_data
*data
);
1250 int devm_regmap_add_irq_chip(struct device
*dev
, struct regmap
*map
, int irq
,
1251 int irq_flags
, int irq_base
,
1252 const struct regmap_irq_chip
*chip
,
1253 struct regmap_irq_chip_data
**data
);
1254 void devm_regmap_del_irq_chip(struct device
*dev
, int irq
,
1255 struct regmap_irq_chip_data
*data
);
1257 int regmap_irq_chip_get_base(struct regmap_irq_chip_data
*data
);
1258 int regmap_irq_get_virq(struct regmap_irq_chip_data
*data
, int irq
);
1259 struct irq_domain
*regmap_irq_get_domain(struct regmap_irq_chip_data
*data
);
1264 * These stubs should only ever be called by generic code which has
1265 * regmap based facilities, if they ever get called at runtime
1266 * something is going wrong and something probably needs to select
1270 static inline int regmap_write(struct regmap
*map
, unsigned int reg
,
1273 WARN_ONCE(1, "regmap API is disabled");
1277 static inline int regmap_write_async(struct regmap
*map
, unsigned int reg
,
1280 WARN_ONCE(1, "regmap API is disabled");
1284 static inline int regmap_raw_write(struct regmap
*map
, unsigned int reg
,
1285 const void *val
, size_t val_len
)
1287 WARN_ONCE(1, "regmap API is disabled");
1291 static inline int regmap_raw_write_async(struct regmap
*map
, unsigned int reg
,
1292 const void *val
, size_t val_len
)
1294 WARN_ONCE(1, "regmap API is disabled");
1298 static inline int regmap_noinc_write(struct regmap
*map
, unsigned int reg
,
1299 const void *val
, size_t val_len
)
1301 WARN_ONCE(1, "regmap API is disabled");
1305 static inline int regmap_bulk_write(struct regmap
*map
, unsigned int reg
,
1306 const void *val
, size_t val_count
)
1308 WARN_ONCE(1, "regmap API is disabled");
1312 static inline int regmap_read(struct regmap
*map
, unsigned int reg
,
1315 WARN_ONCE(1, "regmap API is disabled");
1319 static inline int regmap_raw_read(struct regmap
*map
, unsigned int reg
,
1320 void *val
, size_t val_len
)
1322 WARN_ONCE(1, "regmap API is disabled");
1326 static inline int regmap_noinc_read(struct regmap
*map
, unsigned int reg
,
1327 void *val
, size_t val_len
)
1329 WARN_ONCE(1, "regmap API is disabled");
1333 static inline int regmap_bulk_read(struct regmap
*map
, unsigned int reg
,
1334 void *val
, size_t val_count
)
1336 WARN_ONCE(1, "regmap API is disabled");
1340 static inline int regmap_update_bits_base(struct regmap
*map
, unsigned int reg
,
1341 unsigned int mask
, unsigned int val
,
1342 bool *change
, bool async
, bool force
)
1344 WARN_ONCE(1, "regmap API is disabled");
1348 static inline int regmap_field_update_bits_base(struct regmap_field
*field
,
1349 unsigned int mask
, unsigned int val
,
1350 bool *change
, bool async
, bool force
)
1352 WARN_ONCE(1, "regmap API is disabled");
1356 static inline int regmap_fields_update_bits_base(struct regmap_field
*field
,
1358 unsigned int mask
, unsigned int val
,
1359 bool *change
, bool async
, bool force
)
1361 WARN_ONCE(1, "regmap API is disabled");
1365 static inline int regmap_get_val_bytes(struct regmap
*map
)
1367 WARN_ONCE(1, "regmap API is disabled");
1371 static inline int regmap_get_max_register(struct regmap
*map
)
1373 WARN_ONCE(1, "regmap API is disabled");
1377 static inline int regmap_get_reg_stride(struct regmap
*map
)
1379 WARN_ONCE(1, "regmap API is disabled");
1383 static inline int regcache_sync(struct regmap
*map
)
1385 WARN_ONCE(1, "regmap API is disabled");
1389 static inline int regcache_sync_region(struct regmap
*map
, unsigned int min
,
1392 WARN_ONCE(1, "regmap API is disabled");
1396 static inline int regcache_drop_region(struct regmap
*map
, unsigned int min
,
1399 WARN_ONCE(1, "regmap API is disabled");
1403 static inline void regcache_cache_only(struct regmap
*map
, bool enable
)
1405 WARN_ONCE(1, "regmap API is disabled");
1408 static inline void regcache_cache_bypass(struct regmap
*map
, bool enable
)
1410 WARN_ONCE(1, "regmap API is disabled");
1413 static inline void regcache_mark_dirty(struct regmap
*map
)
1415 WARN_ONCE(1, "regmap API is disabled");
1418 static inline void regmap_async_complete(struct regmap
*map
)
1420 WARN_ONCE(1, "regmap API is disabled");
1423 static inline int regmap_register_patch(struct regmap
*map
,
1424 const struct reg_sequence
*regs
,
1427 WARN_ONCE(1, "regmap API is disabled");
1431 static inline int regmap_parse_val(struct regmap
*map
, const void *buf
,
1434 WARN_ONCE(1, "regmap API is disabled");
1438 static inline struct regmap
*dev_get_regmap(struct device
*dev
,
1444 static inline struct device
*regmap_get_device(struct regmap
*map
)
1446 WARN_ONCE(1, "regmap API is disabled");