blob: 4149f1a9b00320dfeea8768817b2adbd2d1a4da2 [file] [log] [blame]
Mark Brownb83a3132011-05-11 19:59:58 +02001#ifndef __LINUX_REGMAP_H
2#define __LINUX_REGMAP_H
3
4/*
5 * Register map access API
6 *
7 * Copyright 2011 Wolfson Microelectronics plc
8 *
9 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
10 *
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.
14 */
15
Mark Brownb83a3132011-05-11 19:59:58 +020016#include <linux/list.h>
Krystian Garbaciak6863ca62012-06-15 11:23:56 +010017#include <linux/rbtree.h>
Mateusz Krawczuk49ccc142013-08-06 18:34:40 +020018#include <linux/err.h>
Kevin Hilman3f0fa9a2013-08-14 16:05:02 -070019#include <linux/bug.h>
Mark Brownb83a3132011-05-11 19:59:58 +020020
Paul Gortmakerde477252011-05-26 13:46:22 -040021struct module;
Paul Gortmaker313162d2012-01-30 11:46:54 -050022struct device;
Mark Brown9943fa32011-06-20 19:02:29 +010023struct i2c_client;
Mark Brown90f790d2012-08-20 21:45:05 +010024struct irq_domain;
Mark Browna676f082011-05-12 11:42:10 +020025struct spi_device;
Josh Cartwrighta01779f2013-10-28 13:12:35 -050026struct spmi_device;
Mark Brownb83d2ff2012-03-11 11:49:17 +000027struct regmap;
Krystian Garbaciak6863ca62012-06-15 11:23:56 +010028struct regmap_range_cfg;
Srinivas Kandagatla67252282013-06-11 13:18:15 +010029struct regmap_field;
Mark Brown9943fa32011-06-20 19:02:29 +010030
Dimitris Papastamos9fabe242011-09-19 14:34:00 +010031/* An enum of all the supported cache types */
32enum regcache_type {
33 REGCACHE_NONE,
Dimitris Papastamos28644c802011-09-19 14:34:02 +010034 REGCACHE_RBTREE,
Mark Brown2ac902c2012-12-19 14:51:55 +000035 REGCACHE_COMPRESSED,
36 REGCACHE_FLAT,
Dimitris Papastamos9fabe242011-09-19 14:34:00 +010037};
38
Mark Browndd898b22011-07-20 22:28:58 +010039/**
Mark Brownbd20eb52011-08-19 18:09:38 +090040 * Default value for a register. We use an array of structs rather
41 * than a simple array as many modern devices have very sparse
42 * register maps.
43 *
44 * @reg: Register address.
45 * @def: Register default value.
46 */
47struct reg_default {
48 unsigned int reg;
49 unsigned int def;
50};
51
Mark Brownb83d2ff2012-03-11 11:49:17 +000052#ifdef CONFIG_REGMAP
53
Stephen Warren141eba22012-05-24 10:47:26 -060054enum regmap_endian {
55 /* Unspecified -> 0 -> Backwards compatible default */
56 REGMAP_ENDIAN_DEFAULT = 0,
57 REGMAP_ENDIAN_BIG,
58 REGMAP_ENDIAN_LITTLE,
59 REGMAP_ENDIAN_NATIVE,
60};
61
Davide Ciminaghi76aad392012-11-20 15:20:30 +010062/**
63 * A register range, used for access related checks
64 * (readable/writeable/volatile/precious checks)
65 *
66 * @range_min: address of first register
67 * @range_max: address of last register
68 */
69struct regmap_range {
70 unsigned int range_min;
71 unsigned int range_max;
72};
73
Laxman Dewangan6112fe62013-09-20 18:00:10 +053074#define regmap_reg_range(low, high) { .range_min = low, .range_max = high, }
75
Davide Ciminaghi76aad392012-11-20 15:20:30 +010076/*
77 * A table of ranges including some yes ranges and some no ranges.
78 * If a register belongs to a no_range, the corresponding check function
79 * will return false. If a register belongs to a yes range, the corresponding
80 * check function will return true. "no_ranges" are searched first.
81 *
82 * @yes_ranges : pointer to an array of regmap ranges used as "yes ranges"
83 * @n_yes_ranges: size of the above array
84 * @no_ranges: pointer to an array of regmap ranges used as "no ranges"
85 * @n_no_ranges: size of the above array
86 */
87struct regmap_access_table {
88 const struct regmap_range *yes_ranges;
89 unsigned int n_yes_ranges;
90 const struct regmap_range *no_ranges;
91 unsigned int n_no_ranges;
92};
93
Davide Ciminaghi0d4529c2012-10-16 15:56:59 +020094typedef void (*regmap_lock)(void *);
95typedef void (*regmap_unlock)(void *);
96
Mark Brownbd20eb52011-08-19 18:09:38 +090097/**
Mark Browndd898b22011-07-20 22:28:58 +010098 * Configuration for the register map of a device.
99 *
Stephen Warrend3c242e2012-04-04 15:48:29 -0600100 * @name: Optional name of the regmap. Useful when a device has multiple
101 * register regions.
102 *
Mark Browndd898b22011-07-20 22:28:58 +0100103 * @reg_bits: Number of bits in a register address, mandatory.
Stephen Warrenf01ee602012-04-09 13:40:24 -0600104 * @reg_stride: The register address stride. Valid register addresses are a
105 * multiple of this value. If set to 0, a value of 1 will be
106 * used.
Mark Brown82159ba2012-01-18 10:52:25 +0000107 * @pad_bits: Number of bits of padding between register and value.
Mark Browndd898b22011-07-20 22:28:58 +0100108 * @val_bits: Number of bits in a register value, mandatory.
Mark Brown2e2ae662011-07-20 22:33:39 +0100109 *
Mark Brown3566cc92011-08-09 10:23:22 +0900110 * @writeable_reg: Optional callback returning true if the register
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100111 * can be written to. If this field is NULL but wr_table
112 * (see below) is not, the check is performed on such table
113 * (a register is writeable if it belongs to one of the ranges
114 * specified by wr_table).
Mark Brown3566cc92011-08-09 10:23:22 +0900115 * @readable_reg: Optional callback returning true if the register
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100116 * can be read from. If this field is NULL but rd_table
117 * (see below) is not, the check is performed on such table
118 * (a register is readable if it belongs to one of the ranges
119 * specified by rd_table).
Mark Brown3566cc92011-08-09 10:23:22 +0900120 * @volatile_reg: Optional callback returning true if the register
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100121 * value can't be cached. If this field is NULL but
122 * volatile_table (see below) is not, the check is performed on
123 * such table (a register is volatile if it belongs to one of
124 * the ranges specified by volatile_table).
Laszlo Pappbdc39642014-01-09 14:13:41 +0000125 * @precious_reg: Optional callback returning true if the register
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100126 * should not be read outside of a call from the driver
Laszlo Pappbdc39642014-01-09 14:13:41 +0000127 * (e.g., a clear on read interrupt status register). If this
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100128 * field is NULL but precious_table (see below) is not, the
129 * check is performed on such table (a register is precious if
130 * it belongs to one of the ranges specified by precious_table).
131 * @lock: Optional lock callback (overrides regmap's default lock
132 * function, based on spinlock or mutex).
133 * @unlock: As above for unlocking.
134 * @lock_arg: this field is passed as the only argument of lock/unlock
135 * functions (ignored in case regular lock/unlock functions
136 * are not overridden).
Andrey Smirnovd2a58842013-01-27 10:49:05 -0800137 * @reg_read: Optional callback that if filled will be used to perform
138 * all the reads from the registers. Should only be provided for
Laszlo Pappbdc39642014-01-09 14:13:41 +0000139 * devices whose read operation cannot be represented as a simple
140 * read operation on a bus such as SPI, I2C, etc. Most of the
141 * devices do not need this.
Andrey Smirnovd2a58842013-01-27 10:49:05 -0800142 * @reg_write: Same as above for writing.
143 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
144 * to perform locking. This field is ignored if custom lock/unlock
145 * functions are used (see fields lock/unlock of struct regmap_config).
146 * This field is a duplicate of a similar file in
147 * 'struct regmap_bus' and serves exact same purpose.
148 * Use it only for "no-bus" cases.
Mark Brownbd20eb52011-08-19 18:09:38 +0900149 * @max_register: Optional, specifies the maximum valid register index.
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100150 * @wr_table: Optional, points to a struct regmap_access_table specifying
151 * valid ranges for write access.
152 * @rd_table: As above, for read access.
153 * @volatile_table: As above, for volatile registers.
154 * @precious_table: As above, for precious registers.
Mark Brownbd20eb52011-08-19 18:09:38 +0900155 * @reg_defaults: Power on reset values for registers (for use with
156 * register cache support).
157 * @num_reg_defaults: Number of elements in reg_defaults.
Lars-Peter Clausen6f306442011-09-05 20:46:32 +0200158 *
159 * @read_flag_mask: Mask to be set in the top byte of the register when doing
160 * a read.
161 * @write_flag_mask: Mask to be set in the top byte of the register when doing
162 * a write. If both read_flag_mask and write_flag_mask are
163 * empty the regmap_bus default masks are used.
Ashish Jangam2e33caf2012-04-30 23:23:40 +0100164 * @use_single_rw: If set, converts the bulk read and write operations into
165 * a series of single read and write operations. This is useful
166 * for device that does not support bulk read and write.
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100167 *
168 * @cache_type: The actual cache type.
169 * @reg_defaults_raw: Power on reset values for registers (for use with
170 * register cache support).
171 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
Stephen Warren141eba22012-05-24 10:47:26 -0600172 * @reg_format_endian: Endianness for formatted register addresses. If this is
173 * DEFAULT, the @reg_format_endian_default value from the
174 * regmap bus is used.
175 * @val_format_endian: Endianness for formatted register values. If this is
176 * DEFAULT, the @reg_format_endian_default value from the
177 * regmap bus is used.
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100178 *
179 * @ranges: Array of configuration entries for virtual address ranges.
180 * @num_ranges: Number of range configuration entries.
Mark Browndd898b22011-07-20 22:28:58 +0100181 */
Mark Brownb83a3132011-05-11 19:59:58 +0200182struct regmap_config {
Stephen Warrend3c242e2012-04-04 15:48:29 -0600183 const char *name;
184
Mark Brownb83a3132011-05-11 19:59:58 +0200185 int reg_bits;
Stephen Warrenf01ee602012-04-09 13:40:24 -0600186 int reg_stride;
Mark Brown82159ba2012-01-18 10:52:25 +0000187 int pad_bits;
Mark Brownb83a3132011-05-11 19:59:58 +0200188 int val_bits;
Mark Brown2e2ae662011-07-20 22:33:39 +0100189
Mark Brown2e2ae662011-07-20 22:33:39 +0100190 bool (*writeable_reg)(struct device *dev, unsigned int reg);
191 bool (*readable_reg)(struct device *dev, unsigned int reg);
192 bool (*volatile_reg)(struct device *dev, unsigned int reg);
Mark Brown18694882011-08-08 15:40:22 +0900193 bool (*precious_reg)(struct device *dev, unsigned int reg);
Davide Ciminaghi0d4529c2012-10-16 15:56:59 +0200194 regmap_lock lock;
195 regmap_unlock unlock;
196 void *lock_arg;
Mark Brownbd20eb52011-08-19 18:09:38 +0900197
Andrey Smirnovd2a58842013-01-27 10:49:05 -0800198 int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
199 int (*reg_write)(void *context, unsigned int reg, unsigned int val);
200
201 bool fast_io;
202
Mark Brownbd20eb52011-08-19 18:09:38 +0900203 unsigned int max_register;
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100204 const struct regmap_access_table *wr_table;
205 const struct regmap_access_table *rd_table;
206 const struct regmap_access_table *volatile_table;
207 const struct regmap_access_table *precious_table;
Lars-Peter Clausen720e4612011-11-16 16:28:17 +0100208 const struct reg_default *reg_defaults;
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100209 unsigned int num_reg_defaults;
210 enum regcache_type cache_type;
211 const void *reg_defaults_raw;
212 unsigned int num_reg_defaults_raw;
Lars-Peter Clausen6f306442011-09-05 20:46:32 +0200213
214 u8 read_flag_mask;
215 u8 write_flag_mask;
Ashish Jangam2e33caf2012-04-30 23:23:40 +0100216
217 bool use_single_rw;
Stephen Warren141eba22012-05-24 10:47:26 -0600218
219 enum regmap_endian reg_format_endian;
220 enum regmap_endian val_format_endian;
Mark Brown38e23192012-07-22 19:26:07 +0100221
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100222 const struct regmap_range_cfg *ranges;
Mark Browne3549cd2012-10-02 20:17:15 +0100223 unsigned int num_ranges;
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100224};
225
226/**
227 * Configuration for indirectly accessed or paged registers.
228 * Registers, mapped to this virtual range, are accessed in two steps:
229 * 1. page selector register update;
230 * 2. access through data window registers.
231 *
Mark Brownd058bb42012-10-03 12:40:47 +0100232 * @name: Descriptive name for diagnostics
233 *
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100234 * @range_min: Address of the lowest register address in virtual range.
235 * @range_max: Address of the highest register in virtual range.
236 *
237 * @page_sel_reg: Register with selector field.
238 * @page_sel_mask: Bit shift for selector value.
239 * @page_sel_shift: Bit mask for selector value.
240 *
241 * @window_start: Address of first (lowest) register in data window.
242 * @window_len: Number of registers in data window.
243 */
244struct regmap_range_cfg {
Mark Brownd058bb42012-10-03 12:40:47 +0100245 const char *name;
246
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100247 /* Registers of virtual address range */
248 unsigned int range_min;
249 unsigned int range_max;
250
251 /* Page selector for indirect addressing */
252 unsigned int selector_reg;
253 unsigned int selector_mask;
254 int selector_shift;
255
256 /* Data window (per each page) */
257 unsigned int window_start;
258 unsigned int window_len;
Mark Brownb83a3132011-05-11 19:59:58 +0200259};
260
Mark Brown0d509f22013-01-27 22:07:38 +0800261struct regmap_async;
262
Stephen Warren0135bbc2012-04-04 15:48:30 -0600263typedef int (*regmap_hw_write)(void *context, const void *data,
Mark Brownb83a3132011-05-11 19:59:58 +0200264 size_t count);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600265typedef int (*regmap_hw_gather_write)(void *context,
Mark Brownb83a3132011-05-11 19:59:58 +0200266 const void *reg, size_t reg_len,
267 const void *val, size_t val_len);
Mark Brown0d509f22013-01-27 22:07:38 +0800268typedef int (*regmap_hw_async_write)(void *context,
269 const void *reg, size_t reg_len,
270 const void *val, size_t val_len,
271 struct regmap_async *async);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600272typedef int (*regmap_hw_read)(void *context,
Mark Brownb83a3132011-05-11 19:59:58 +0200273 const void *reg_buf, size_t reg_size,
274 void *val_buf, size_t val_size);
Mark Brown0d509f22013-01-27 22:07:38 +0800275typedef struct regmap_async *(*regmap_hw_async_alloc)(void);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600276typedef void (*regmap_hw_free_context)(void *context);
Mark Brownb83a3132011-05-11 19:59:58 +0200277
278/**
279 * Description of a hardware bus for the register map infrastructure.
280 *
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600281 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
Davide Ciminaghi0d4529c2012-10-16 15:56:59 +0200282 * to perform locking. This field is ignored if custom lock/unlock
283 * functions are used (see fields lock/unlock of
284 * struct regmap_config).
Mark Brownb83a3132011-05-11 19:59:58 +0200285 * @write: Write operation.
286 * @gather_write: Write operation with split register/value, return -ENOTSUPP
287 * if not implemented on a given device.
Mark Brown0d509f22013-01-27 22:07:38 +0800288 * @async_write: Write operation which completes asynchronously, optional and
289 * must serialise with respect to non-async I/O.
Mark Brownb83a3132011-05-11 19:59:58 +0200290 * @read: Read operation. Data is returned in the buffer used to transmit
291 * data.
Mark Brown0d509f22013-01-27 22:07:38 +0800292 * @async_alloc: Allocate a regmap_async() structure.
Mark Brownb83a3132011-05-11 19:59:58 +0200293 * @read_flag_mask: Mask to be set in the top byte of the register when doing
294 * a read.
Stephen Warren141eba22012-05-24 10:47:26 -0600295 * @reg_format_endian_default: Default endianness for formatted register
296 * addresses. Used when the regmap_config specifies DEFAULT. If this is
297 * DEFAULT, BIG is assumed.
298 * @val_format_endian_default: Default endianness for formatted register
299 * values. Used when the regmap_config specifies DEFAULT. If this is
300 * DEFAULT, BIG is assumed.
Mark Brown0d509f22013-01-27 22:07:38 +0800301 * @async_size: Size of struct used for async work.
Mark Brownb83a3132011-05-11 19:59:58 +0200302 */
303struct regmap_bus {
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600304 bool fast_io;
Mark Brownb83a3132011-05-11 19:59:58 +0200305 regmap_hw_write write;
306 regmap_hw_gather_write gather_write;
Mark Brown0d509f22013-01-27 22:07:38 +0800307 regmap_hw_async_write async_write;
Mark Brownb83a3132011-05-11 19:59:58 +0200308 regmap_hw_read read;
Stephen Warren0135bbc2012-04-04 15:48:30 -0600309 regmap_hw_free_context free_context;
Mark Brown0d509f22013-01-27 22:07:38 +0800310 regmap_hw_async_alloc async_alloc;
Mark Brownb83a3132011-05-11 19:59:58 +0200311 u8 read_flag_mask;
Stephen Warren141eba22012-05-24 10:47:26 -0600312 enum regmap_endian reg_format_endian_default;
313 enum regmap_endian val_format_endian_default;
Mark Brownb83a3132011-05-11 19:59:58 +0200314};
315
316struct regmap *regmap_init(struct device *dev,
317 const struct regmap_bus *bus,
Stephen Warren0135bbc2012-04-04 15:48:30 -0600318 void *bus_context,
Mark Brownb83a3132011-05-11 19:59:58 +0200319 const struct regmap_config *config);
Mark Brown9943fa32011-06-20 19:02:29 +0100320struct regmap *regmap_init_i2c(struct i2c_client *i2c,
321 const struct regmap_config *config);
Mark Browna676f082011-05-12 11:42:10 +0200322struct regmap *regmap_init_spi(struct spi_device *dev,
323 const struct regmap_config *config);
Josh Cartwrighta01779f2013-10-28 13:12:35 -0500324struct regmap *regmap_init_spmi(struct spmi_device *dev,
325 const struct regmap_config *config);
Philipp Zabel878ec672013-02-14 17:39:08 +0100326struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
327 void __iomem *regs,
328 const struct regmap_config *config);
Mark Browna676f082011-05-12 11:42:10 +0200329
Mark Brownc0eb4672012-01-30 19:56:52 +0000330struct regmap *devm_regmap_init(struct device *dev,
331 const struct regmap_bus *bus,
Stephen Warren0135bbc2012-04-04 15:48:30 -0600332 void *bus_context,
Mark Brownc0eb4672012-01-30 19:56:52 +0000333 const struct regmap_config *config);
334struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
335 const struct regmap_config *config);
336struct regmap *devm_regmap_init_spi(struct spi_device *dev,
337 const struct regmap_config *config);
Josh Cartwrighta01779f2013-10-28 13:12:35 -0500338struct regmap *devm_regmap_init_spmi(struct spmi_device *dev,
339 const struct regmap_config *config);
Philipp Zabel878ec672013-02-14 17:39:08 +0100340struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
341 void __iomem *regs,
342 const struct regmap_config *config);
343
344/**
345 * regmap_init_mmio(): Initialise register map
346 *
347 * @dev: Device that will be interacted with
348 * @regs: Pointer to memory-mapped IO region
349 * @config: Configuration for register map
350 *
351 * The return value will be an ERR_PTR() on error or a valid pointer to
352 * a struct regmap.
353 */
354static inline struct regmap *regmap_init_mmio(struct device *dev,
355 void __iomem *regs,
356 const struct regmap_config *config)
357{
358 return regmap_init_mmio_clk(dev, NULL, regs, config);
359}
360
361/**
362 * devm_regmap_init_mmio(): Initialise managed register map
363 *
364 * @dev: Device that will be interacted with
365 * @regs: Pointer to memory-mapped IO region
366 * @config: Configuration for register map
367 *
368 * The return value will be an ERR_PTR() on error or a valid pointer
369 * to a struct regmap. The regmap will be automatically freed by the
370 * device management code.
371 */
372static inline struct regmap *devm_regmap_init_mmio(struct device *dev,
373 void __iomem *regs,
374 const struct regmap_config *config)
375{
376 return devm_regmap_init_mmio_clk(dev, NULL, regs, config);
377}
Mark Brownc0eb4672012-01-30 19:56:52 +0000378
Mark Brownb83a3132011-05-11 19:59:58 +0200379void regmap_exit(struct regmap *map);
Mark Brownbf315172011-12-03 17:06:20 +0000380int regmap_reinit_cache(struct regmap *map,
381 const struct regmap_config *config);
Mark Brown72b39f62012-05-08 17:44:40 +0100382struct regmap *dev_get_regmap(struct device *dev, const char *name);
Mark Brownb83a3132011-05-11 19:59:58 +0200383int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
Mark Brown915f4412013-10-09 13:30:10 +0100384int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val);
Mark Brownb83a3132011-05-11 19:59:58 +0200385int regmap_raw_write(struct regmap *map, unsigned int reg,
386 const void *val, size_t val_len);
Laxman Dewangan8eaeb212012-02-12 19:49:43 +0530387int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
388 size_t val_count);
Anthony Oleche33fabd2013-10-11 15:31:11 +0100389int regmap_multi_reg_write(struct regmap *map, struct reg_default *regs,
390 int num_regs);
Mark Brown0d509f22013-01-27 22:07:38 +0800391int regmap_raw_write_async(struct regmap *map, unsigned int reg,
392 const void *val, size_t val_len);
Mark Brownb83a3132011-05-11 19:59:58 +0200393int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
394int regmap_raw_read(struct regmap *map, unsigned int reg,
395 void *val, size_t val_len);
396int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
397 size_t val_count);
398int regmap_update_bits(struct regmap *map, unsigned int reg,
399 unsigned int mask, unsigned int val);
Mark Brown915f4412013-10-09 13:30:10 +0100400int regmap_update_bits_async(struct regmap *map, unsigned int reg,
401 unsigned int mask, unsigned int val);
Mark Brown018690d2011-11-29 20:10:36 +0000402int regmap_update_bits_check(struct regmap *map, unsigned int reg,
403 unsigned int mask, unsigned int val,
404 bool *change);
Mark Brown915f4412013-10-09 13:30:10 +0100405int regmap_update_bits_check_async(struct regmap *map, unsigned int reg,
406 unsigned int mask, unsigned int val,
407 bool *change);
Mark Browna6539c32012-02-17 14:20:14 -0800408int regmap_get_val_bytes(struct regmap *map);
Mark Brown0d509f22013-01-27 22:07:38 +0800409int regmap_async_complete(struct regmap *map);
Mark Brown221ad7f2013-03-26 21:24:20 +0000410bool regmap_can_raw_write(struct regmap *map);
Mark Brownb83a3132011-05-11 19:59:58 +0200411
Mark Brown39a58432011-09-19 18:21:49 +0100412int regcache_sync(struct regmap *map);
Mark Brown4d4cfd12012-02-23 20:53:37 +0000413int regcache_sync_region(struct regmap *map, unsigned int min,
414 unsigned int max);
Mark Brown697e85b2013-05-08 13:55:22 +0100415int regcache_drop_region(struct regmap *map, unsigned int min,
416 unsigned int max);
Mark Brown92afb282011-09-19 18:22:14 +0100417void regcache_cache_only(struct regmap *map, bool enable);
Dimitris Papastamos6eb0f5e2011-09-29 14:36:27 +0100418void regcache_cache_bypass(struct regmap *map, bool enable);
Mark Brown8ae0d7e2011-10-26 10:34:22 +0200419void regcache_mark_dirty(struct regmap *map);
Mark Brown92afb282011-09-19 18:22:14 +0100420
Mark Brown154881e2013-05-08 13:55:23 +0100421bool regmap_check_range_table(struct regmap *map, unsigned int reg,
422 const struct regmap_access_table *table);
423
Mark Brown22f0d902012-01-21 12:01:14 +0000424int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
425 int num_regs);
426
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100427static inline bool regmap_reg_in_range(unsigned int reg,
428 const struct regmap_range *range)
429{
430 return reg >= range->range_min && reg <= range->range_max;
431}
432
433bool regmap_reg_in_ranges(unsigned int reg,
434 const struct regmap_range *ranges,
435 unsigned int nranges);
436
Mark Brownf8beab22011-10-28 23:50:49 +0200437/**
Srinivas Kandagatla67252282013-06-11 13:18:15 +0100438 * Description of an register field
439 *
440 * @reg: Offset of the register within the regmap bank
441 * @lsb: lsb of the register field.
442 * @reg: msb of the register field.
Kuninori Morimotoa0102372013-09-01 20:30:50 -0700443 * @id_size: port size if it has some ports
444 * @id_offset: address offset for each ports
Srinivas Kandagatla67252282013-06-11 13:18:15 +0100445 */
446struct reg_field {
447 unsigned int reg;
448 unsigned int lsb;
449 unsigned int msb;
Kuninori Morimotoa0102372013-09-01 20:30:50 -0700450 unsigned int id_size;
451 unsigned int id_offset;
Srinivas Kandagatla67252282013-06-11 13:18:15 +0100452};
453
454#define REG_FIELD(_reg, _lsb, _msb) { \
455 .reg = _reg, \
456 .lsb = _lsb, \
457 .msb = _msb, \
458 }
459
460struct regmap_field *regmap_field_alloc(struct regmap *regmap,
461 struct reg_field reg_field);
462void regmap_field_free(struct regmap_field *field);
463
464struct regmap_field *devm_regmap_field_alloc(struct device *dev,
465 struct regmap *regmap, struct reg_field reg_field);
466void devm_regmap_field_free(struct device *dev, struct regmap_field *field);
467
468int regmap_field_read(struct regmap_field *field, unsigned int *val);
469int regmap_field_write(struct regmap_field *field, unsigned int val);
Kuninori Morimotofdf20022013-09-01 20:24:50 -0700470int regmap_field_update_bits(struct regmap_field *field,
471 unsigned int mask, unsigned int val);
Srinivas Kandagatla67252282013-06-11 13:18:15 +0100472
Kuninori Morimotoa0102372013-09-01 20:30:50 -0700473int regmap_fields_write(struct regmap_field *field, unsigned int id,
474 unsigned int val);
475int regmap_fields_read(struct regmap_field *field, unsigned int id,
476 unsigned int *val);
477int regmap_fields_update_bits(struct regmap_field *field, unsigned int id,
478 unsigned int mask, unsigned int val);
Srinivas Kandagatla67252282013-06-11 13:18:15 +0100479
480/**
Mark Brownf8beab22011-10-28 23:50:49 +0200481 * Description of an IRQ for the generic regmap irq_chip.
482 *
483 * @reg_offset: Offset of the status/mask register within the bank
484 * @mask: Mask used to flag/control the register.
485 */
486struct regmap_irq {
487 unsigned int reg_offset;
488 unsigned int mask;
489};
490
491/**
492 * Description of a generic regmap irq_chip. This is not intended to
493 * handle every possible interrupt controller, but it should handle a
494 * substantial proportion of those that are found in the wild.
495 *
496 * @name: Descriptive name for IRQ controller.
497 *
498 * @status_base: Base status register address.
499 * @mask_base: Base mask register address.
Alexander Shiyand3233432013-12-15 13:36:51 +0400500 * @ack_base: Base ack address. If zero then the chip is clear on read.
501 * Using zero value is possible with @use_ack bit.
Mark Browna43fd502012-06-05 14:34:03 +0100502 * @wake_base: Base address for wake enables. If zero unsupported.
Graeme Gregory022f926a2012-05-14 22:40:43 +0900503 * @irq_reg_stride: Stride to use for chips where registers are not contiguous.
Philipp Zabel2753e6f2013-07-22 17:15:52 +0200504 * @init_ack_masked: Ack all masked interrupts once during initalization.
Philipp Zabel68622bd2013-07-24 10:26:48 +0200505 * @mask_invert: Inverted mask register: cleared bits are masked out.
Alexander Shiyand3233432013-12-15 13:36:51 +0400506 * @use_ack: Use @ack register even if it is zero.
Philipp Zabel68622bd2013-07-24 10:26:48 +0200507 * @wake_invert: Inverted wake register: cleared bits are wake enabled.
Mark Brown0c00c502012-07-24 15:41:19 +0100508 * @runtime_pm: Hold a runtime PM lock on the device when accessing it.
Mark Brownf8beab22011-10-28 23:50:49 +0200509 *
510 * @num_regs: Number of registers in each control bank.
511 * @irqs: Descriptors for individual IRQs. Interrupt numbers are
512 * assigned based on the index in the array of the interrupt.
513 * @num_irqs: Number of descriptors.
514 */
515struct regmap_irq_chip {
516 const char *name;
517
518 unsigned int status_base;
519 unsigned int mask_base;
520 unsigned int ack_base;
Mark Browna43fd502012-06-05 14:34:03 +0100521 unsigned int wake_base;
Graeme Gregory022f926a2012-05-14 22:40:43 +0900522 unsigned int irq_reg_stride;
Philipp Zabelf484f7a2013-07-24 10:26:42 +0200523 bool init_ack_masked:1;
524 bool mask_invert:1;
Alexander Shiyand3233432013-12-15 13:36:51 +0400525 bool use_ack:1;
Philipp Zabelf484f7a2013-07-24 10:26:42 +0200526 bool wake_invert:1;
527 bool runtime_pm:1;
Mark Brownf8beab22011-10-28 23:50:49 +0200528
529 int num_regs;
530
531 const struct regmap_irq *irqs;
532 int num_irqs;
533};
534
535struct regmap_irq_chip_data;
536
537int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
Mark Brownb026ddb2012-05-31 21:01:46 +0100538 int irq_base, const struct regmap_irq_chip *chip,
Mark Brownf8beab22011-10-28 23:50:49 +0200539 struct regmap_irq_chip_data **data);
540void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
Mark Brown209a6002011-12-05 16:10:15 +0000541int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
Mark Brown4af8be62012-05-13 10:59:56 +0100542int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
Mark Brown90f790d2012-08-20 21:45:05 +0100543struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data);
Mark Brownb83a3132011-05-11 19:59:58 +0200544
Mark Brown9cde5fc2012-02-17 14:49:51 -0800545#else
546
547/*
548 * These stubs should only ever be called by generic code which has
549 * regmap based facilities, if they ever get called at runtime
550 * something is going wrong and something probably needs to select
551 * REGMAP.
552 */
553
554static inline int regmap_write(struct regmap *map, unsigned int reg,
555 unsigned int val)
556{
557 WARN_ONCE(1, "regmap API is disabled");
558 return -EINVAL;
559}
560
Mark Brown915f4412013-10-09 13:30:10 +0100561static inline int regmap_write_async(struct regmap *map, unsigned int reg,
562 unsigned int val)
563{
564 WARN_ONCE(1, "regmap API is disabled");
565 return -EINVAL;
566}
567
Mark Brown9cde5fc2012-02-17 14:49:51 -0800568static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
569 const void *val, size_t val_len)
570{
571 WARN_ONCE(1, "regmap API is disabled");
572 return -EINVAL;
573}
574
Mark Brown0d509f22013-01-27 22:07:38 +0800575static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg,
576 const void *val, size_t val_len)
577{
578 WARN_ONCE(1, "regmap API is disabled");
579 return -EINVAL;
580}
581
Mark Brown9cde5fc2012-02-17 14:49:51 -0800582static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
583 const void *val, size_t val_count)
584{
585 WARN_ONCE(1, "regmap API is disabled");
586 return -EINVAL;
587}
588
589static inline int regmap_read(struct regmap *map, unsigned int reg,
590 unsigned int *val)
591{
592 WARN_ONCE(1, "regmap API is disabled");
593 return -EINVAL;
594}
595
596static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
597 void *val, size_t val_len)
598{
599 WARN_ONCE(1, "regmap API is disabled");
600 return -EINVAL;
601}
602
603static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
604 void *val, size_t val_count)
605{
606 WARN_ONCE(1, "regmap API is disabled");
607 return -EINVAL;
608}
609
610static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
611 unsigned int mask, unsigned int val)
612{
613 WARN_ONCE(1, "regmap API is disabled");
614 return -EINVAL;
615}
616
Mark Brown915f4412013-10-09 13:30:10 +0100617static inline int regmap_update_bits_async(struct regmap *map,
618 unsigned int reg,
619 unsigned int mask, unsigned int val)
620{
621 WARN_ONCE(1, "regmap API is disabled");
622 return -EINVAL;
623}
624
Mark Brown9cde5fc2012-02-17 14:49:51 -0800625static inline int regmap_update_bits_check(struct regmap *map,
626 unsigned int reg,
627 unsigned int mask, unsigned int val,
628 bool *change)
629{
630 WARN_ONCE(1, "regmap API is disabled");
631 return -EINVAL;
632}
633
Mark Brown915f4412013-10-09 13:30:10 +0100634static inline int regmap_update_bits_check_async(struct regmap *map,
635 unsigned int reg,
636 unsigned int mask,
637 unsigned int val,
638 bool *change)
639{
640 WARN_ONCE(1, "regmap API is disabled");
641 return -EINVAL;
642}
643
Mark Brown9cde5fc2012-02-17 14:49:51 -0800644static inline int regmap_get_val_bytes(struct regmap *map)
645{
646 WARN_ONCE(1, "regmap API is disabled");
647 return -EINVAL;
648}
649
650static inline int regcache_sync(struct regmap *map)
651{
652 WARN_ONCE(1, "regmap API is disabled");
653 return -EINVAL;
654}
655
Mark Browna313f9f2012-02-23 19:49:43 +0000656static inline int regcache_sync_region(struct regmap *map, unsigned int min,
657 unsigned int max)
658{
659 WARN_ONCE(1, "regmap API is disabled");
660 return -EINVAL;
661}
662
Mark Brown697e85b2013-05-08 13:55:22 +0100663static inline int regcache_drop_region(struct regmap *map, unsigned int min,
664 unsigned int max)
665{
666 WARN_ONCE(1, "regmap API is disabled");
667 return -EINVAL;
668}
669
Mark Brown9cde5fc2012-02-17 14:49:51 -0800670static inline void regcache_cache_only(struct regmap *map, bool enable)
671{
672 WARN_ONCE(1, "regmap API is disabled");
673}
674
675static inline void regcache_cache_bypass(struct regmap *map, bool enable)
676{
677 WARN_ONCE(1, "regmap API is disabled");
678}
679
680static inline void regcache_mark_dirty(struct regmap *map)
681{
682 WARN_ONCE(1, "regmap API is disabled");
683}
684
Mark Brown0d509f22013-01-27 22:07:38 +0800685static inline void regmap_async_complete(struct regmap *map)
686{
687 WARN_ONCE(1, "regmap API is disabled");
688}
689
Mark Brown9cde5fc2012-02-17 14:49:51 -0800690static inline int regmap_register_patch(struct regmap *map,
691 const struct reg_default *regs,
692 int num_regs)
693{
694 WARN_ONCE(1, "regmap API is disabled");
695 return -EINVAL;
696}
697
Mark Brown72b39f62012-05-08 17:44:40 +0100698static inline struct regmap *dev_get_regmap(struct device *dev,
699 const char *name)
700{
Mark Brown72b39f62012-05-08 17:44:40 +0100701 return NULL;
702}
703
Mark Brown9cde5fc2012-02-17 14:49:51 -0800704#endif
705
Mark Brownb83a3132011-05-11 19:59:58 +0200706#endif