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