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/delay.h>
19 #include <linux/err.h>
20 #include <linux/bug.h>
21 #include <linux/lockdep.h>
32 struct regmap_range_cfg;
37 /* An enum of all the supported cache types */
46 * struct reg_default - Default value for a register.
48 * @reg: Register address.
49 * @def: Register default value.
51 * We use an array of structs rather than a simple array as many modern devices
52 * have very sparse register maps.
60 * struct reg_sequence - An individual write from a sequence of writes.
62 * @reg: Register address.
63 * @def: Register value.
64 * @delay_us: Delay to be applied after the register write in microseconds
66 * Register/value pairs for sequences of writes with an optional delay in
67 * microseconds to be applied after each write.
72 unsigned int delay_us;
75 #define regmap_update_bits(map, reg, mask, val) \
76 regmap_update_bits_base(map, reg, mask, val, NULL, false, false)
77 #define regmap_update_bits_async(map, reg, mask, val)\
78 regmap_update_bits_base(map, reg, mask, val, NULL, true, false)
79 #define regmap_update_bits_check(map, reg, mask, val, change)\
80 regmap_update_bits_base(map, reg, mask, val, change, false, false)
81 #define regmap_update_bits_check_async(map, reg, mask, val, change)\
82 regmap_update_bits_base(map, reg, mask, val, change, true, false)
84 #define regmap_write_bits(map, reg, mask, val) \
85 regmap_update_bits_base(map, reg, mask, val, NULL, false, true)
87 #define regmap_field_write(field, val) \
88 regmap_field_update_bits_base(field, ~0, val, NULL, false, false)
89 #define regmap_field_force_write(field, val) \
90 regmap_field_update_bits_base(field, ~0, val, NULL, false, true)
91 #define regmap_field_update_bits(field, mask, val)\
92 regmap_field_update_bits_base(field, mask, val, NULL, false, false)
93 #define regmap_field_force_update_bits(field, mask, val) \
94 regmap_field_update_bits_base(field, mask, val, NULL, false, true)
96 #define regmap_fields_write(field, id, val) \
97 regmap_fields_update_bits_base(field, id, ~0, val, NULL, false, false)
98 #define regmap_fields_force_write(field, id, val) \
99 regmap_fields_update_bits_base(field, id, ~0, val, NULL, false, true)
100 #define regmap_fields_update_bits(field, id, mask, val)\
101 regmap_fields_update_bits_base(field, id, mask, val, NULL, false, false)
102 #define regmap_fields_force_update_bits(field, id, mask, val) \
103 regmap_fields_update_bits_base(field, id, mask, val, NULL, false, true)
106 * regmap_read_poll_timeout - Poll until a condition is met or a timeout occurs
108 * @map: Regmap to read from
109 * @addr: Address to poll
110 * @val: Unsigned integer variable to read the value into
111 * @cond: Break condition (usually involving @val)
112 * @sleep_us: Maximum time to sleep between reads in us (0
113 * tight-loops). Should be less than ~20ms since usleep_range
114 * is used (see Documentation/timers/timers-howto.txt).
115 * @timeout_us: Timeout in us, 0 means never timeout
117 * Returns 0 on success and -ETIMEDOUT upon a timeout or the regmap_read
118 * error return value in case of a error read. In the two former cases,
119 * the last read value at @addr is stored in @val. Must not be called
120 * from atomic context if sleep_us or timeout_us are used.
122 * This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
124 #define regmap_read_poll_timeout(map, addr, val, cond, sleep_us, timeout_us) \
126 u64 __timeout_us = (timeout_us); \
127 unsigned long __sleep_us = (sleep_us); \
128 ktime_t __timeout = ktime_add_us(ktime_get(), __timeout_us); \
130 might_sleep_if(__sleep_us); \
132 __ret = regmap_read((map), (addr), &(val)); \
137 if ((__timeout_us) && \
138 ktime_compare(ktime_get(), __timeout) > 0) { \
139 __ret = regmap_read((map), (addr), &(val)); \
143 usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
145 __ret ?: ((cond) ? 0 : -ETIMEDOUT); \
149 * regmap_field_read_poll_timeout - Poll until a condition is met or timeout
151 * @field: Regmap field to read from
152 * @val: Unsigned integer variable to read the value into
153 * @cond: Break condition (usually involving @val)
154 * @sleep_us: Maximum time to sleep between reads in us (0
155 * tight-loops). Should be less than ~20ms since usleep_range
156 * is used (see Documentation/timers/timers-howto.txt).
157 * @timeout_us: Timeout in us, 0 means never timeout
159 * Returns 0 on success and -ETIMEDOUT upon a timeout or the regmap_field_read
160 * error return value in case of a error read. In the two former cases,
161 * the last read value at @addr is stored in @val. Must not be called
162 * from atomic context if sleep_us or timeout_us are used.
164 * This is modelled after the readx_poll_timeout macros in linux/iopoll.h.
166 #define regmap_field_read_poll_timeout(field, val, cond, sleep_us, timeout_us) \
168 u64 __timeout_us = (timeout_us); \
169 unsigned long __sleep_us = (sleep_us); \
170 ktime_t timeout = ktime_add_us(ktime_get(), __timeout_us); \
172 might_sleep_if(__sleep_us); \
174 pollret = regmap_field_read((field), &(val)); \
179 if (__timeout_us && ktime_compare(ktime_get(), timeout) > 0) { \
180 pollret = regmap_field_read((field), &(val)); \
184 usleep_range((__sleep_us >> 2) + 1, __sleep_us); \
186 pollret ?: ((cond) ? 0 : -ETIMEDOUT); \
192 /* Unspecified -> 0 -> Backwards compatible default */
193 REGMAP_ENDIAN_DEFAULT = 0,
195 REGMAP_ENDIAN_LITTLE,
196 REGMAP_ENDIAN_NATIVE,
200 * struct regmap_range - A register range, used for access related checks
201 * (readable/writeable/volatile/precious checks)
203 * @range_min: address of first register
204 * @range_max: address of last register
206 struct regmap_range {
207 unsigned int range_min;
208 unsigned int range_max;
211 #define regmap_reg_range(low, high) { .range_min = low, .range_max = high, }
214 * struct regmap_access_table - A table of register ranges for access checks
216 * @yes_ranges : pointer to an array of regmap ranges used as "yes ranges"
217 * @n_yes_ranges: size of the above array
218 * @no_ranges: pointer to an array of regmap ranges used as "no ranges"
219 * @n_no_ranges: size of the above array
221 * A table of ranges including some yes ranges and some no ranges.
222 * If a register belongs to a no_range, the corresponding check function
223 * will return false. If a register belongs to a yes range, the corresponding
224 * check function will return true. "no_ranges" are searched first.
226 struct regmap_access_table {
227 const struct regmap_range *yes_ranges;
228 unsigned int n_yes_ranges;
229 const struct regmap_range *no_ranges;
230 unsigned int n_no_ranges;
233 typedef void (*regmap_lock)(void *);
234 typedef void (*regmap_unlock)(void *);
237 * struct regmap_config - Configuration for the register map of a device.
239 * @name: Optional name of the regmap. Useful when a device has multiple
242 * @reg_bits: Number of bits in a register address, mandatory.
243 * @reg_stride: The register address stride. Valid register addresses are a
244 * multiple of this value. If set to 0, a value of 1 will be
246 * @pad_bits: Number of bits of padding between register and value.
247 * @val_bits: Number of bits in a register value, mandatory.
249 * @writeable_reg: Optional callback returning true if the register
250 * can be written to. If this field is NULL but wr_table
251 * (see below) is not, the check is performed on such table
252 * (a register is writeable if it belongs to one of the ranges
253 * specified by wr_table).
254 * @readable_reg: Optional callback returning true if the register
255 * can be read from. If this field is NULL but rd_table
256 * (see below) is not, the check is performed on such table
257 * (a register is readable if it belongs to one of the ranges
258 * specified by rd_table).
259 * @volatile_reg: Optional callback returning true if the register
260 * value can't be cached. If this field is NULL but
261 * volatile_table (see below) is not, the check is performed on
262 * such table (a register is volatile if it belongs to one of
263 * the ranges specified by volatile_table).
264 * @precious_reg: Optional callback returning true if the register
265 * should not be read outside of a call from the driver
266 * (e.g., a clear on read interrupt status register). If this
267 * field is NULL but precious_table (see below) is not, the
268 * check is performed on such table (a register is precious if
269 * it belongs to one of the ranges specified by precious_table).
270 * @disable_locking: This regmap is either protected by external means or
271 * is guaranteed not be be accessed from multiple threads.
272 * Don't use any locking mechanisms.
273 * @lock: Optional lock callback (overrides regmap's default lock
274 * function, based on spinlock or mutex).
275 * @unlock: As above for unlocking.
276 * @lock_arg: this field is passed as the only argument of lock/unlock
277 * functions (ignored in case regular lock/unlock functions
278 * are not overridden).
279 * @reg_read: Optional callback that if filled will be used to perform
280 * all the reads from the registers. Should only be provided for
281 * devices whose read operation cannot be represented as a simple
282 * read operation on a bus such as SPI, I2C, etc. Most of the
283 * devices do not need this.
284 * @reg_write: Same as above for writing.
285 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
286 * to perform locking. This field is ignored if custom lock/unlock
287 * functions are used (see fields lock/unlock of struct regmap_config).
288 * This field is a duplicate of a similar file in
289 * 'struct regmap_bus' and serves exact same purpose.
290 * Use it only for "no-bus" cases.
291 * @max_register: Optional, specifies the maximum valid register address.
292 * @wr_table: Optional, points to a struct regmap_access_table specifying
293 * valid ranges for write access.
294 * @rd_table: As above, for read access.
295 * @volatile_table: As above, for volatile registers.
296 * @precious_table: As above, for precious registers.
297 * @reg_defaults: Power on reset values for registers (for use with
298 * register cache support).
299 * @num_reg_defaults: Number of elements in reg_defaults.
301 * @read_flag_mask: Mask to be set in the top bytes of the register when doing
303 * @write_flag_mask: Mask to be set in the top bytes of the register when doing
304 * a write. If both read_flag_mask and write_flag_mask are
305 * empty and zero_flag_mask is not set the regmap_bus default
307 * @zero_flag_mask: If set, read_flag_mask and write_flag_mask are used even
308 * if they are both empty.
309 * @use_single_rw: If set, converts the bulk read and write operations into
310 * a series of single read and write operations. This is useful
311 * for device that does not support bulk read and write.
312 * @can_multi_write: If set, the device supports the multi write mode of bulk
313 * write operations, if clear multi write requests will be
314 * split into individual write operations
316 * @cache_type: The actual cache type.
317 * @reg_defaults_raw: Power on reset values for registers (for use with
318 * register cache support).
319 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
320 * @reg_format_endian: Endianness for formatted register addresses. If this is
321 * DEFAULT, the @reg_format_endian_default value from the
322 * regmap bus is used.
323 * @val_format_endian: Endianness for formatted register values. If this is
324 * DEFAULT, the @reg_format_endian_default value from the
325 * regmap bus is used.
327 * @ranges: Array of configuration entries for virtual address ranges.
328 * @num_ranges: Number of range configuration entries.
329 * @use_hwlock: Indicate if a hardware spinlock should be used.
330 * @hwlock_id: Specify the hardware spinlock id.
331 * @hwlock_mode: The hardware spinlock mode, should be HWLOCK_IRQSTATE,
334 struct regmap_config {
342 bool (*writeable_reg)(struct device *dev, unsigned int reg);
343 bool (*readable_reg)(struct device *dev, unsigned int reg);
344 bool (*volatile_reg)(struct device *dev, unsigned int reg);
345 bool (*precious_reg)(struct device *dev, unsigned int reg);
347 bool disable_locking;
349 regmap_unlock unlock;
352 int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
353 int (*reg_write)(void *context, unsigned int reg, unsigned int val);
357 unsigned int max_register;
358 const struct regmap_access_table *wr_table;
359 const struct regmap_access_table *rd_table;
360 const struct regmap_access_table *volatile_table;
361 const struct regmap_access_table *precious_table;
362 const struct reg_default *reg_defaults;
363 unsigned int num_reg_defaults;
364 enum regcache_type cache_type;
365 const void *reg_defaults_raw;
366 unsigned int num_reg_defaults_raw;
368 unsigned long read_flag_mask;
369 unsigned long write_flag_mask;
373 bool can_multi_write;
375 enum regmap_endian reg_format_endian;
376 enum regmap_endian val_format_endian;
378 const struct regmap_range_cfg *ranges;
379 unsigned int num_ranges;
382 unsigned int hwlock_id;
383 unsigned int hwlock_mode;
387 * struct regmap_range_cfg - Configuration for indirectly accessed or paged
390 * @name: Descriptive name for diagnostics
392 * @range_min: Address of the lowest register address in virtual range.
393 * @range_max: Address of the highest register in virtual range.
395 * @selector_reg: Register with selector field.
396 * @selector_mask: Bit shift for selector value.
397 * @selector_shift: Bit mask for selector value.
399 * @window_start: Address of first (lowest) register in data window.
400 * @window_len: Number of registers in data window.
402 * Registers, mapped to this virtual range, are accessed in two steps:
403 * 1. page selector register update;
404 * 2. access through data window registers.
406 struct regmap_range_cfg {
409 /* Registers of virtual address range */
410 unsigned int range_min;
411 unsigned int range_max;
413 /* Page selector for indirect addressing */
414 unsigned int selector_reg;
415 unsigned int selector_mask;
418 /* Data window (per each page) */
419 unsigned int window_start;
420 unsigned int window_len;
425 typedef int (*regmap_hw_write)(void *context, const void *data,
427 typedef int (*regmap_hw_gather_write)(void *context,
428 const void *reg, size_t reg_len,
429 const void *val, size_t val_len);
430 typedef int (*regmap_hw_async_write)(void *context,
431 const void *reg, size_t reg_len,
432 const void *val, size_t val_len,
433 struct regmap_async *async);
434 typedef int (*regmap_hw_read)(void *context,
435 const void *reg_buf, size_t reg_size,
436 void *val_buf, size_t val_size);
437 typedef int (*regmap_hw_reg_read)(void *context, unsigned int reg,
439 typedef int (*regmap_hw_reg_write)(void *context, unsigned int reg,
441 typedef int (*regmap_hw_reg_update_bits)(void *context, unsigned int reg,
442 unsigned int mask, unsigned int val);
443 typedef struct regmap_async *(*regmap_hw_async_alloc)(void);
444 typedef void (*regmap_hw_free_context)(void *context);
447 * struct regmap_bus - Description of a hardware bus for the register map
450 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
451 * to perform locking. This field is ignored if custom lock/unlock
452 * functions are used (see fields lock/unlock of
453 * struct regmap_config).
454 * @write: Write operation.
455 * @gather_write: Write operation with split register/value, return -ENOTSUPP
456 * if not implemented on a given device.
457 * @async_write: Write operation which completes asynchronously, optional and
458 * must serialise with respect to non-async I/O.
459 * @reg_write: Write a single register value to the given register address. This
460 * write operation has to complete when returning from the function.
461 * @reg_update_bits: Update bits operation to be used against volatile
462 * registers, intended for devices supporting some mechanism
463 * for setting clearing bits without having to
465 * @read: Read operation. Data is returned in the buffer used to transmit
467 * @reg_read: Read a single register value from a given register address.
468 * @free_context: Free context.
469 * @async_alloc: Allocate a regmap_async() structure.
470 * @read_flag_mask: Mask to be set in the top byte of the register when doing
472 * @reg_format_endian_default: Default endianness for formatted register
473 * addresses. Used when the regmap_config specifies DEFAULT. If this is
474 * DEFAULT, BIG is assumed.
475 * @val_format_endian_default: Default endianness for formatted register
476 * values. Used when the regmap_config specifies DEFAULT. If this is
477 * DEFAULT, BIG is assumed.
478 * @max_raw_read: Max raw read size that can be used on the bus.
479 * @max_raw_write: Max raw write size that can be used on the bus.
483 regmap_hw_write write;
484 regmap_hw_gather_write gather_write;
485 regmap_hw_async_write async_write;
486 regmap_hw_reg_write reg_write;
487 regmap_hw_reg_update_bits reg_update_bits;
489 regmap_hw_reg_read reg_read;
490 regmap_hw_free_context free_context;
491 regmap_hw_async_alloc async_alloc;
493 enum regmap_endian reg_format_endian_default;
494 enum regmap_endian val_format_endian_default;
496 size_t max_raw_write;
500 * __regmap_init functions.
502 * These functions take a lock key and name parameter, and should not be called
503 * directly. Instead, use the regmap_init macros that generate a key and name
506 struct regmap *__regmap_init(struct device *dev,
507 const struct regmap_bus *bus,
509 const struct regmap_config *config,
510 struct lock_class_key *lock_key,
511 const char *lock_name);
512 struct regmap *__regmap_init_i2c(struct i2c_client *i2c,
513 const struct regmap_config *config,
514 struct lock_class_key *lock_key,
515 const char *lock_name);
516 struct regmap *__regmap_init_slimbus(struct slim_device *slimbus,
517 const struct regmap_config *config,
518 struct lock_class_key *lock_key,
519 const char *lock_name);
520 struct regmap *__regmap_init_spi(struct spi_device *dev,
521 const struct regmap_config *config,
522 struct lock_class_key *lock_key,
523 const char *lock_name);
524 struct regmap *__regmap_init_spmi_base(struct spmi_device *dev,
525 const struct regmap_config *config,
526 struct lock_class_key *lock_key,
527 const char *lock_name);
528 struct regmap *__regmap_init_spmi_ext(struct spmi_device *dev,
529 const struct regmap_config *config,
530 struct lock_class_key *lock_key,
531 const char *lock_name);
532 struct regmap *__regmap_init_w1(struct device *w1_dev,
533 const struct regmap_config *config,
534 struct lock_class_key *lock_key,
535 const char *lock_name);
536 struct regmap *__regmap_init_mmio_clk(struct device *dev, const char *clk_id,
538 const struct regmap_config *config,
539 struct lock_class_key *lock_key,
540 const char *lock_name);
541 struct regmap *__regmap_init_ac97(struct snd_ac97 *ac97,
542 const struct regmap_config *config,
543 struct lock_class_key *lock_key,
544 const char *lock_name);
545 struct regmap *__regmap_init_sdw(struct sdw_slave *sdw,
546 const struct regmap_config *config,
547 struct lock_class_key *lock_key,
548 const char *lock_name);
550 struct regmap *__devm_regmap_init(struct device *dev,
551 const struct regmap_bus *bus,
553 const struct regmap_config *config,
554 struct lock_class_key *lock_key,
555 const char *lock_name);
556 struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
557 const struct regmap_config *config,
558 struct lock_class_key *lock_key,
559 const char *lock_name);
560 struct regmap *__devm_regmap_init_spi(struct spi_device *dev,
561 const struct regmap_config *config,
562 struct lock_class_key *lock_key,
563 const char *lock_name);
564 struct regmap *__devm_regmap_init_spmi_base(struct spmi_device *dev,
565 const struct regmap_config *config,
566 struct lock_class_key *lock_key,
567 const char *lock_name);
568 struct regmap *__devm_regmap_init_spmi_ext(struct spmi_device *dev,
569 const struct regmap_config *config,
570 struct lock_class_key *lock_key,
571 const char *lock_name);
572 struct regmap *__devm_regmap_init_w1(struct device *w1_dev,
573 const struct regmap_config *config,
574 struct lock_class_key *lock_key,
575 const char *lock_name);
576 struct regmap *__devm_regmap_init_mmio_clk(struct device *dev,
579 const struct regmap_config *config,
580 struct lock_class_key *lock_key,
581 const char *lock_name);
582 struct regmap *__devm_regmap_init_ac97(struct snd_ac97 *ac97,
583 const struct regmap_config *config,
584 struct lock_class_key *lock_key,
585 const char *lock_name);
586 struct regmap *__devm_regmap_init_sdw(struct sdw_slave *sdw,
587 const struct regmap_config *config,
588 struct lock_class_key *lock_key,
589 const char *lock_name);
592 * Wrapper for regmap_init macros to include a unique lockdep key and name
593 * for each call. No-op if CONFIG_LOCKDEP is not set.
595 * @fn: Real function to call (in the form __[*_]regmap_init[_*])
596 * @name: Config variable name (#config in the calling macro)
598 #ifdef CONFIG_LOCKDEP
599 #define __regmap_lockdep_wrapper(fn, name, ...) \
602 static struct lock_class_key _key; \
603 fn(__VA_ARGS__, &_key, \
604 KBUILD_BASENAME ":" \
605 __stringify(__LINE__) ":" \
606 "(" name ")->lock"); \
610 #define __regmap_lockdep_wrapper(fn, name, ...) fn(__VA_ARGS__, NULL, NULL)
614 * regmap_init() - Initialise register map
616 * @dev: Device that will be interacted with
617 * @bus: Bus-specific callbacks to use with device
618 * @bus_context: Data passed to bus-specific callbacks
619 * @config: Configuration for register map
621 * The return value will be an ERR_PTR() on error or a valid pointer to
622 * a struct regmap. This function should generally not be called
623 * directly, it should be called by bus-specific init functions.
625 #define regmap_init(dev, bus, bus_context, config) \
626 __regmap_lockdep_wrapper(__regmap_init, #config, \
627 dev, bus, bus_context, config)
628 int regmap_attach_dev(struct device *dev, struct regmap *map,
629 const struct regmap_config *config);
632 * regmap_init_i2c() - Initialise register map
634 * @i2c: Device that will be interacted with
635 * @config: Configuration for register map
637 * The return value will be an ERR_PTR() on error or a valid pointer to
640 #define regmap_init_i2c(i2c, config) \
641 __regmap_lockdep_wrapper(__regmap_init_i2c, #config, \
645 * regmap_init_slimbus() - Initialise register map
647 * @slimbus: Device that will be interacted with
648 * @config: Configuration for register map
650 * The return value will be an ERR_PTR() on error or a valid pointer to
653 #define regmap_init_slimbus(slimbus, config) \
654 __regmap_lockdep_wrapper(__regmap_init_slimbus, #config, \
658 * regmap_init_spi() - Initialise register map
660 * @dev: 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 to
666 #define regmap_init_spi(dev, config) \
667 __regmap_lockdep_wrapper(__regmap_init_spi, #config, \
671 * regmap_init_spmi_base() - Create regmap for the Base register space
673 * @dev: SPMI device that will be interacted with
674 * @config: Configuration for register map
676 * The return value will be an ERR_PTR() on error or a valid pointer to
679 #define regmap_init_spmi_base(dev, config) \
680 __regmap_lockdep_wrapper(__regmap_init_spmi_base, #config, \
684 * regmap_init_spmi_ext() - Create regmap for Ext register space
686 * @dev: Device that will be interacted with
687 * @config: Configuration for register map
689 * The return value will be an ERR_PTR() on error or a valid pointer to
692 #define regmap_init_spmi_ext(dev, config) \
693 __regmap_lockdep_wrapper(__regmap_init_spmi_ext, #config, \
697 * regmap_init_w1() - Initialise register map
699 * @w1_dev: Device that will be interacted with
700 * @config: Configuration for register map
702 * The return value will be an ERR_PTR() on error or a valid pointer to
705 #define regmap_init_w1(w1_dev, config) \
706 __regmap_lockdep_wrapper(__regmap_init_w1, #config, \
710 * regmap_init_mmio_clk() - Initialise register map with register clock
712 * @dev: Device that will be interacted with
713 * @clk_id: register clock consumer ID
714 * @regs: Pointer to memory-mapped IO region
715 * @config: Configuration for register map
717 * The return value will be an ERR_PTR() on error or a valid pointer to
720 #define regmap_init_mmio_clk(dev, clk_id, regs, config) \
721 __regmap_lockdep_wrapper(__regmap_init_mmio_clk, #config, \
722 dev, clk_id, regs, config)
725 * regmap_init_mmio() - Initialise register map
727 * @dev: Device that will be interacted with
728 * @regs: Pointer to memory-mapped IO region
729 * @config: Configuration for register map
731 * The return value will be an ERR_PTR() on error or a valid pointer to
734 #define regmap_init_mmio(dev, regs, config) \
735 regmap_init_mmio_clk(dev, NULL, regs, config)
738 * regmap_init_ac97() - Initialise AC'97 register map
740 * @ac97: Device that will be interacted with
741 * @config: Configuration for register map
743 * The return value will be an ERR_PTR() on error or a valid pointer to
746 #define regmap_init_ac97(ac97, config) \
747 __regmap_lockdep_wrapper(__regmap_init_ac97, #config, \
749 bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
752 * regmap_init_sdw() - Initialise register map
754 * @sdw: Device that will be interacted with
755 * @config: Configuration for register map
757 * The return value will be an ERR_PTR() on error or a valid pointer to
760 #define regmap_init_sdw(sdw, config) \
761 __regmap_lockdep_wrapper(__regmap_init_sdw, #config, \
766 * devm_regmap_init() - Initialise managed register map
768 * @dev: Device that will be interacted with
769 * @bus: Bus-specific callbacks to use with device
770 * @bus_context: Data passed to bus-specific callbacks
771 * @config: Configuration for register map
773 * The return value will be an ERR_PTR() on error or a valid pointer
774 * to a struct regmap. This function should generally not be called
775 * directly, it should be called by bus-specific init functions. The
776 * map will be automatically freed by the device management code.
778 #define devm_regmap_init(dev, bus, bus_context, config) \
779 __regmap_lockdep_wrapper(__devm_regmap_init, #config, \
780 dev, bus, bus_context, config)
783 * devm_regmap_init_i2c() - Initialise managed register map
785 * @i2c: Device that will be interacted with
786 * @config: Configuration for register map
788 * The return value will be an ERR_PTR() on error or a valid pointer
789 * to a struct regmap. The regmap will be automatically freed by the
790 * device management code.
792 #define devm_regmap_init_i2c(i2c, config) \
793 __regmap_lockdep_wrapper(__devm_regmap_init_i2c, #config, \
797 * devm_regmap_init_spi() - Initialise register map
799 * @dev: Device that will be interacted with
800 * @config: Configuration for register map
802 * The return value will be an ERR_PTR() on error or a valid pointer
803 * to a struct regmap. The map will be automatically freed by the
804 * device management code.
806 #define devm_regmap_init_spi(dev, config) \
807 __regmap_lockdep_wrapper(__devm_regmap_init_spi, #config, \
811 * devm_regmap_init_spmi_base() - Create managed regmap for Base register space
813 * @dev: SPMI device that will be interacted with
814 * @config: Configuration for register map
816 * The return value will be an ERR_PTR() on error or a valid pointer
817 * to a struct regmap. The regmap will be automatically freed by the
818 * device management code.
820 #define devm_regmap_init_spmi_base(dev, config) \
821 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_base, #config, \
825 * devm_regmap_init_spmi_ext() - Create managed regmap for Ext register space
827 * @dev: SPMI device that will be interacted with
828 * @config: Configuration for register map
830 * The return value will be an ERR_PTR() on error or a valid pointer
831 * to a struct regmap. The regmap will be automatically freed by the
832 * device management code.
834 #define devm_regmap_init_spmi_ext(dev, config) \
835 __regmap_lockdep_wrapper(__devm_regmap_init_spmi_ext, #config, \
839 * devm_regmap_init_w1() - Initialise managed register map
841 * @w1_dev: Device that will be interacted with
842 * @config: Configuration for register map
844 * The return value will be an ERR_PTR() on error or a valid pointer
845 * to a struct regmap. The regmap will be automatically freed by the
846 * device management code.
848 #define devm_regmap_init_w1(w1_dev, config) \
849 __regmap_lockdep_wrapper(__devm_regmap_init_w1, #config, \
852 * devm_regmap_init_mmio_clk() - Initialise managed register map with clock
854 * @dev: Device that will be interacted with
855 * @clk_id: register clock consumer ID
856 * @regs: Pointer to memory-mapped IO region
857 * @config: Configuration for register map
859 * The return value will be an ERR_PTR() on error or a valid pointer
860 * to a struct regmap. The regmap will be automatically freed by the
861 * device management code.
863 #define devm_regmap_init_mmio_clk(dev, clk_id, regs, config) \
864 __regmap_lockdep_wrapper(__devm_regmap_init_mmio_clk, #config, \
865 dev, clk_id, regs, config)
868 * devm_regmap_init_mmio() - Initialise managed register map
870 * @dev: Device that will be interacted with
871 * @regs: Pointer to memory-mapped IO region
872 * @config: Configuration for register map
874 * The return value will be an ERR_PTR() on error or a valid pointer
875 * to a struct regmap. The regmap will be automatically freed by the
876 * device management code.
878 #define devm_regmap_init_mmio(dev, regs, config) \
879 devm_regmap_init_mmio_clk(dev, NULL, regs, config)
882 * devm_regmap_init_ac97() - Initialise AC'97 register map
884 * @ac97: Device that will be interacted with
885 * @config: Configuration for register map
887 * The return value will be an ERR_PTR() on error or a valid pointer
888 * to a struct regmap. The regmap will be automatically freed by the
889 * device management code.
891 #define devm_regmap_init_ac97(ac97, config) \
892 __regmap_lockdep_wrapper(__devm_regmap_init_ac97, #config, \
896 * devm_regmap_init_sdw() - Initialise managed register map
898 * @sdw: Device that will be interacted with
899 * @config: Configuration for register map
901 * The return value will be an ERR_PTR() on error or a valid pointer
902 * to a struct regmap. The regmap will be automatically freed by the
903 * device management code.
905 #define devm_regmap_init_sdw(sdw, config) \
906 __regmap_lockdep_wrapper(__devm_regmap_init_sdw, #config, \
909 int regmap_mmio_attach_clk(struct regmap *map, struct clk *clk);
910 void regmap_mmio_detach_clk(struct regmap *map);
911 void regmap_exit(struct regmap *map);
912 int regmap_reinit_cache(struct regmap *map,
913 const struct regmap_config *config);
914 struct regmap *dev_get_regmap(struct device *dev, const char *name);
915 struct device *regmap_get_device(struct regmap *map);
916 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
917 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val);
918 int regmap_raw_write(struct regmap *map, unsigned int reg,
919 const void *val, size_t val_len);
920 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
922 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
924 int regmap_multi_reg_write_bypassed(struct regmap *map,
925 const struct reg_sequence *regs,
927 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
928 const void *val, size_t val_len);
929 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
930 int regmap_raw_read(struct regmap *map, unsigned int reg,
931 void *val, size_t val_len);
932 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
934 int regmap_update_bits_base(struct regmap *map, unsigned int reg,
935 unsigned int mask, unsigned int val,
936 bool *change, bool async, bool force);
937 int regmap_get_val_bytes(struct regmap *map);
938 int regmap_get_max_register(struct regmap *map);
939 int regmap_get_reg_stride(struct regmap *map);
940 int regmap_async_complete(struct regmap *map);
941 bool regmap_can_raw_write(struct regmap *map);
942 size_t regmap_get_raw_read_max(struct regmap *map);
943 size_t regmap_get_raw_write_max(struct regmap *map);
945 int regcache_sync(struct regmap *map);
946 int regcache_sync_region(struct regmap *map, unsigned int min,
948 int regcache_drop_region(struct regmap *map, unsigned int min,
950 void regcache_cache_only(struct regmap *map, bool enable);
951 void regcache_cache_bypass(struct regmap *map, bool enable);
952 void regcache_mark_dirty(struct regmap *map);
954 bool regmap_check_range_table(struct regmap *map, unsigned int reg,
955 const struct regmap_access_table *table);
957 int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
959 int regmap_parse_val(struct regmap *map, const void *buf,
962 static inline bool regmap_reg_in_range(unsigned int reg,
963 const struct regmap_range *range)
965 return reg >= range->range_min && reg <= range->range_max;
968 bool regmap_reg_in_ranges(unsigned int reg,
969 const struct regmap_range *ranges,
970 unsigned int nranges);
973 * struct reg_field - Description of an register field
975 * @reg: Offset of the register within the regmap bank
976 * @lsb: lsb of the register field.
977 * @msb: msb of the register field.
978 * @id_size: port size if it has some ports
979 * @id_offset: address offset for each ports
985 unsigned int id_size;
986 unsigned int id_offset;
989 #define REG_FIELD(_reg, _lsb, _msb) { \
995 struct regmap_field *regmap_field_alloc(struct regmap *regmap,
996 struct reg_field reg_field);
997 void regmap_field_free(struct regmap_field *field);
999 struct regmap_field *devm_regmap_field_alloc(struct device *dev,
1000 struct regmap *regmap, struct reg_field reg_field);
1001 void devm_regmap_field_free(struct device *dev, struct regmap_field *field);
1003 int regmap_field_read(struct regmap_field *field, unsigned int *val);
1004 int regmap_field_update_bits_base(struct regmap_field *field,
1005 unsigned int mask, unsigned int val,
1006 bool *change, bool async, bool force);
1007 int regmap_fields_read(struct regmap_field *field, unsigned int id,
1009 int regmap_fields_update_bits_base(struct regmap_field *field, unsigned int id,
1010 unsigned int mask, unsigned int val,
1011 bool *change, bool async, bool force);
1014 * struct regmap_irq - Description of an IRQ for the generic regmap irq_chip.
1016 * @reg_offset: Offset of the status/mask register within the bank
1017 * @mask: Mask used to flag/control the register.
1018 * @type_reg_offset: Offset register for the irq type setting.
1019 * @type_rising_mask: Mask bit to configure RISING type irq.
1020 * @type_falling_mask: Mask bit to configure FALLING type irq.
1023 unsigned int reg_offset;
1025 unsigned int type_reg_offset;
1026 unsigned int type_rising_mask;
1027 unsigned int type_falling_mask;
1030 #define REGMAP_IRQ_REG(_irq, _off, _mask) \
1031 [_irq] = { .reg_offset = (_off), .mask = (_mask) }
1034 * struct regmap_irq_chip - Description of a generic regmap irq_chip.
1036 * @name: Descriptive name for IRQ controller.
1038 * @status_base: Base status register address.
1039 * @mask_base: Base mask register address.
1040 * @mask_writeonly: Base mask register is write only.
1041 * @unmask_base: Base unmask register address. for chips who have
1042 * separate mask and unmask registers
1043 * @ack_base: Base ack address. If zero then the chip is clear on read.
1044 * Using zero value is possible with @use_ack bit.
1045 * @wake_base: Base address for wake enables. If zero unsupported.
1046 * @type_base: Base address for irq type. If zero unsupported.
1047 * @irq_reg_stride: Stride to use for chips where registers are not contiguous.
1048 * @init_ack_masked: Ack all masked interrupts once during initalization.
1049 * @mask_invert: Inverted mask register: cleared bits are masked out.
1050 * @use_ack: Use @ack register even if it is zero.
1051 * @ack_invert: Inverted ack register: cleared bits for ack.
1052 * @wake_invert: Inverted wake register: cleared bits are wake enabled.
1053 * @type_invert: Invert the type flags.
1054 * @runtime_pm: Hold a runtime PM lock on the device when accessing it.
1056 * @num_regs: Number of registers in each control bank.
1057 * @irqs: Descriptors for individual IRQs. Interrupt numbers are
1058 * assigned based on the index in the array of the interrupt.
1059 * @num_irqs: Number of descriptors.
1060 * @num_type_reg: Number of type registers.
1061 * @type_reg_stride: Stride to use for chips where type registers are not
1063 * @handle_pre_irq: Driver specific callback to handle interrupt from device
1064 * before regmap_irq_handler process the interrupts.
1065 * @handle_post_irq: Driver specific callback to handle interrupt from device
1066 * after handling the interrupts in regmap_irq_handler().
1067 * @irq_drv_data: Driver specific IRQ data which is passed as parameter when
1068 * driver specific pre/post interrupt handler is called.
1070 * This is not intended to handle every possible interrupt controller, but
1071 * it should handle a substantial proportion of those that are found in the
1074 struct regmap_irq_chip {
1077 unsigned int status_base;
1078 unsigned int mask_base;
1079 unsigned int unmask_base;
1080 unsigned int ack_base;
1081 unsigned int wake_base;
1082 unsigned int type_base;
1083 unsigned int irq_reg_stride;
1084 bool mask_writeonly:1;
1085 bool init_ack_masked:1;
1095 const struct regmap_irq *irqs;
1099 unsigned int type_reg_stride;
1101 int (*handle_pre_irq)(void *irq_drv_data);
1102 int (*handle_post_irq)(void *irq_drv_data);
1106 struct regmap_irq_chip_data;
1108 int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
1109 int irq_base, const struct regmap_irq_chip *chip,
1110 struct regmap_irq_chip_data **data);
1111 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
1113 int devm_regmap_add_irq_chip(struct device *dev, struct regmap *map, int irq,
1114 int irq_flags, int irq_base,
1115 const struct regmap_irq_chip *chip,
1116 struct regmap_irq_chip_data **data);
1117 void devm_regmap_del_irq_chip(struct device *dev, int irq,
1118 struct regmap_irq_chip_data *data);
1120 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
1121 int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
1122 struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data);
1127 * These stubs should only ever be called by generic code which has
1128 * regmap based facilities, if they ever get called at runtime
1129 * something is going wrong and something probably needs to select
1133 static inline int regmap_write(struct regmap *map, unsigned int reg,
1136 WARN_ONCE(1, "regmap API is disabled");
1140 static inline int regmap_write_async(struct regmap *map, unsigned int reg,
1143 WARN_ONCE(1, "regmap API is disabled");
1147 static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
1148 const void *val, size_t val_len)
1150 WARN_ONCE(1, "regmap API is disabled");
1154 static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg,
1155 const void *val, size_t val_len)
1157 WARN_ONCE(1, "regmap API is disabled");
1161 static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
1162 const void *val, size_t val_count)
1164 WARN_ONCE(1, "regmap API is disabled");
1168 static inline int regmap_read(struct regmap *map, unsigned int reg,
1171 WARN_ONCE(1, "regmap API is disabled");
1175 static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
1176 void *val, size_t val_len)
1178 WARN_ONCE(1, "regmap API is disabled");
1182 static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
1183 void *val, size_t val_count)
1185 WARN_ONCE(1, "regmap API is disabled");
1189 static inline int regmap_update_bits_base(struct regmap *map, unsigned int reg,
1190 unsigned int mask, unsigned int val,
1191 bool *change, bool async, bool force)
1193 WARN_ONCE(1, "regmap API is disabled");
1197 static inline int regmap_field_update_bits_base(struct regmap_field *field,
1198 unsigned int mask, unsigned int val,
1199 bool *change, bool async, bool force)
1201 WARN_ONCE(1, "regmap API is disabled");
1205 static inline int regmap_fields_update_bits_base(struct regmap_field *field,
1207 unsigned int mask, unsigned int val,
1208 bool *change, bool async, bool force)
1210 WARN_ONCE(1, "regmap API is disabled");
1214 static inline int regmap_get_val_bytes(struct regmap *map)
1216 WARN_ONCE(1, "regmap API is disabled");
1220 static inline int regmap_get_max_register(struct regmap *map)
1222 WARN_ONCE(1, "regmap API is disabled");
1226 static inline int regmap_get_reg_stride(struct regmap *map)
1228 WARN_ONCE(1, "regmap API is disabled");
1232 static inline int regcache_sync(struct regmap *map)
1234 WARN_ONCE(1, "regmap API is disabled");
1238 static inline int regcache_sync_region(struct regmap *map, unsigned int min,
1241 WARN_ONCE(1, "regmap API is disabled");
1245 static inline int regcache_drop_region(struct regmap *map, unsigned int min,
1248 WARN_ONCE(1, "regmap API is disabled");
1252 static inline void regcache_cache_only(struct regmap *map, bool enable)
1254 WARN_ONCE(1, "regmap API is disabled");
1257 static inline void regcache_cache_bypass(struct regmap *map, bool enable)
1259 WARN_ONCE(1, "regmap API is disabled");
1262 static inline void regcache_mark_dirty(struct regmap *map)
1264 WARN_ONCE(1, "regmap API is disabled");
1267 static inline void regmap_async_complete(struct regmap *map)
1269 WARN_ONCE(1, "regmap API is disabled");
1272 static inline int regmap_register_patch(struct regmap *map,
1273 const struct reg_sequence *regs,
1276 WARN_ONCE(1, "regmap API is disabled");
1280 static inline int regmap_parse_val(struct regmap *map, const void *buf,
1283 WARN_ONCE(1, "regmap API is disabled");
1287 static inline struct regmap *dev_get_regmap(struct device *dev,
1293 static inline struct device *regmap_get_device(struct regmap *map)
1295 WARN_ONCE(1, "regmap API is disabled");