blob: e55907804d39c5e6c274151c0a584b8a043eed89 [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).
Mark Brown3566cc92011-08-09 10:23:22 +0900125 * @precious_reg: Optional callback returning true if the rgister
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100126 * should not be read outside of a call from the driver
127 * (eg, a clear on read interrupt status register). If this
128 * 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
139 * devices whos read operation cannot be represented as a simple read
140 * operation on a bus such as SPI, I2C, etc. Most of the devices do
141 * not need this.
142 * @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.
500 * @ack_base: Base ack address. If zero then the chip is clear on read.
Mark Browna43fd502012-06-05 14:34:03 +0100501 * @wake_base: Base address for wake enables. If zero unsupported.
Graeme Gregory022f926a2012-05-14 22:40:43 +0900502 * @irq_reg_stride: Stride to use for chips where registers are not contiguous.
Philipp Zabel2753e6f2013-07-22 17:15:52 +0200503 * @init_ack_masked: Ack all masked interrupts once during initalization.
Philipp Zabel68622bd2013-07-24 10:26:48 +0200504 * @mask_invert: Inverted mask register: cleared bits are masked out.
505 * @wake_invert: Inverted wake register: cleared bits are wake enabled.
Mark Brown0c00c502012-07-24 15:41:19 +0100506 * @runtime_pm: Hold a runtime PM lock on the device when accessing it.
Mark Brownf8beab22011-10-28 23:50:49 +0200507 *
508 * @num_regs: Number of registers in each control bank.
509 * @irqs: Descriptors for individual IRQs. Interrupt numbers are
510 * assigned based on the index in the array of the interrupt.
511 * @num_irqs: Number of descriptors.
512 */
513struct regmap_irq_chip {
514 const char *name;
515
516 unsigned int status_base;
517 unsigned int mask_base;
518 unsigned int ack_base;
Mark Browna43fd502012-06-05 14:34:03 +0100519 unsigned int wake_base;
Graeme Gregory022f926a2012-05-14 22:40:43 +0900520 unsigned int irq_reg_stride;
Philipp Zabelf484f7a2013-07-24 10:26:42 +0200521 bool init_ack_masked:1;
522 bool mask_invert:1;
523 bool wake_invert:1;
524 bool runtime_pm:1;
Mark Brownf8beab22011-10-28 23:50:49 +0200525
526 int num_regs;
527
528 const struct regmap_irq *irqs;
529 int num_irqs;
530};
531
532struct regmap_irq_chip_data;
533
534int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
Mark Brownb026ddb2012-05-31 21:01:46 +0100535 int irq_base, const struct regmap_irq_chip *chip,
Mark Brownf8beab22011-10-28 23:50:49 +0200536 struct regmap_irq_chip_data **data);
537void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
Mark Brown209a6002011-12-05 16:10:15 +0000538int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
Mark Brown4af8be62012-05-13 10:59:56 +0100539int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
Mark Brown90f790d2012-08-20 21:45:05 +0100540struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data);
Mark Brownb83a3132011-05-11 19:59:58 +0200541
Mark Brown9cde5fc2012-02-17 14:49:51 -0800542#else
543
544/*
545 * These stubs should only ever be called by generic code which has
546 * regmap based facilities, if they ever get called at runtime
547 * something is going wrong and something probably needs to select
548 * REGMAP.
549 */
550
551static inline int regmap_write(struct regmap *map, unsigned int reg,
552 unsigned int val)
553{
554 WARN_ONCE(1, "regmap API is disabled");
555 return -EINVAL;
556}
557
Mark Brown915f4412013-10-09 13:30:10 +0100558static inline int regmap_write_async(struct regmap *map, unsigned int reg,
559 unsigned int val)
560{
561 WARN_ONCE(1, "regmap API is disabled");
562 return -EINVAL;
563}
564
Mark Brown9cde5fc2012-02-17 14:49:51 -0800565static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
566 const void *val, size_t val_len)
567{
568 WARN_ONCE(1, "regmap API is disabled");
569 return -EINVAL;
570}
571
Mark Brown0d509f22013-01-27 22:07:38 +0800572static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg,
573 const void *val, size_t val_len)
574{
575 WARN_ONCE(1, "regmap API is disabled");
576 return -EINVAL;
577}
578
Mark Brown9cde5fc2012-02-17 14:49:51 -0800579static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
580 const void *val, size_t val_count)
581{
582 WARN_ONCE(1, "regmap API is disabled");
583 return -EINVAL;
584}
585
586static inline int regmap_read(struct regmap *map, unsigned int reg,
587 unsigned int *val)
588{
589 WARN_ONCE(1, "regmap API is disabled");
590 return -EINVAL;
591}
592
593static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
594 void *val, size_t val_len)
595{
596 WARN_ONCE(1, "regmap API is disabled");
597 return -EINVAL;
598}
599
600static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
601 void *val, size_t val_count)
602{
603 WARN_ONCE(1, "regmap API is disabled");
604 return -EINVAL;
605}
606
607static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
608 unsigned int mask, unsigned int val)
609{
610 WARN_ONCE(1, "regmap API is disabled");
611 return -EINVAL;
612}
613
Mark Brown915f4412013-10-09 13:30:10 +0100614static inline int regmap_update_bits_async(struct regmap *map,
615 unsigned int reg,
616 unsigned int mask, unsigned int val)
617{
618 WARN_ONCE(1, "regmap API is disabled");
619 return -EINVAL;
620}
621
Mark Brown9cde5fc2012-02-17 14:49:51 -0800622static inline int regmap_update_bits_check(struct regmap *map,
623 unsigned int reg,
624 unsigned int mask, unsigned int val,
625 bool *change)
626{
627 WARN_ONCE(1, "regmap API is disabled");
628 return -EINVAL;
629}
630
Mark Brown915f4412013-10-09 13:30:10 +0100631static inline int regmap_update_bits_check_async(struct regmap *map,
632 unsigned int reg,
633 unsigned int mask,
634 unsigned int val,
635 bool *change)
636{
637 WARN_ONCE(1, "regmap API is disabled");
638 return -EINVAL;
639}
640
Mark Brown9cde5fc2012-02-17 14:49:51 -0800641static inline int regmap_get_val_bytes(struct regmap *map)
642{
643 WARN_ONCE(1, "regmap API is disabled");
644 return -EINVAL;
645}
646
647static inline int regcache_sync(struct regmap *map)
648{
649 WARN_ONCE(1, "regmap API is disabled");
650 return -EINVAL;
651}
652
Mark Browna313f9f2012-02-23 19:49:43 +0000653static inline int regcache_sync_region(struct regmap *map, unsigned int min,
654 unsigned int max)
655{
656 WARN_ONCE(1, "regmap API is disabled");
657 return -EINVAL;
658}
659
Mark Brown697e85b2013-05-08 13:55:22 +0100660static inline int regcache_drop_region(struct regmap *map, unsigned int min,
661 unsigned int max)
662{
663 WARN_ONCE(1, "regmap API is disabled");
664 return -EINVAL;
665}
666
Mark Brown9cde5fc2012-02-17 14:49:51 -0800667static inline void regcache_cache_only(struct regmap *map, bool enable)
668{
669 WARN_ONCE(1, "regmap API is disabled");
670}
671
672static inline void regcache_cache_bypass(struct regmap *map, bool enable)
673{
674 WARN_ONCE(1, "regmap API is disabled");
675}
676
677static inline void regcache_mark_dirty(struct regmap *map)
678{
679 WARN_ONCE(1, "regmap API is disabled");
680}
681
Mark Brown0d509f22013-01-27 22:07:38 +0800682static inline void regmap_async_complete(struct regmap *map)
683{
684 WARN_ONCE(1, "regmap API is disabled");
685}
686
Mark Brown9cde5fc2012-02-17 14:49:51 -0800687static inline int regmap_register_patch(struct regmap *map,
688 const struct reg_default *regs,
689 int num_regs)
690{
691 WARN_ONCE(1, "regmap API is disabled");
692 return -EINVAL;
693}
694
Mark Brown72b39f62012-05-08 17:44:40 +0100695static inline struct regmap *dev_get_regmap(struct device *dev,
696 const char *name)
697{
Mark Brown72b39f62012-05-08 17:44:40 +0100698 return NULL;
699}
700
Mark Brown9cde5fc2012-02-17 14:49:51 -0800701#endif
702
Mark Brownb83a3132011-05-11 19:59:58 +0200703#endif