blob: b7e95bf942c9ce8936f61c61efb0261f9c09ad37 [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>
Mark Brownb83a3132011-05-11 19:59:58 +020018
Paul Gortmakerde477252011-05-26 13:46:22 -040019struct module;
Paul Gortmaker313162d2012-01-30 11:46:54 -050020struct device;
Mark Brown9943fa32011-06-20 19:02:29 +010021struct i2c_client;
Mark Brown90f790d2012-08-20 21:45:05 +010022struct irq_domain;
Mark Browna676f082011-05-12 11:42:10 +020023struct spi_device;
Mark Brownb83d2ff2012-03-11 11:49:17 +000024struct regmap;
Krystian Garbaciak6863ca62012-06-15 11:23:56 +010025struct regmap_range_cfg;
Mark Brown9943fa32011-06-20 19:02:29 +010026
Dimitris Papastamos9fabe242011-09-19 14:34:00 +010027/* An enum of all the supported cache types */
28enum regcache_type {
29 REGCACHE_NONE,
Dimitris Papastamos28644c802011-09-19 14:34:02 +010030 REGCACHE_RBTREE,
Mark Brown50b776f2011-11-02 15:00:03 +000031 REGCACHE_COMPRESSED
Dimitris Papastamos9fabe242011-09-19 14:34:00 +010032};
33
Mark Browndd898b22011-07-20 22:28:58 +010034/**
Mark Brownbd20eb52011-08-19 18:09:38 +090035 * Default value for a register. We use an array of structs rather
36 * than a simple array as many modern devices have very sparse
37 * register maps.
38 *
39 * @reg: Register address.
40 * @def: Register default value.
41 */
42struct reg_default {
43 unsigned int reg;
44 unsigned int def;
45};
46
Mark Brownb83d2ff2012-03-11 11:49:17 +000047#ifdef CONFIG_REGMAP
48
Stephen Warren141eba22012-05-24 10:47:26 -060049enum regmap_endian {
50 /* Unspecified -> 0 -> Backwards compatible default */
51 REGMAP_ENDIAN_DEFAULT = 0,
52 REGMAP_ENDIAN_BIG,
53 REGMAP_ENDIAN_LITTLE,
54 REGMAP_ENDIAN_NATIVE,
55};
56
Davide Ciminaghi76aad392012-11-20 15:20:30 +010057/**
58 * A register range, used for access related checks
59 * (readable/writeable/volatile/precious checks)
60 *
61 * @range_min: address of first register
62 * @range_max: address of last register
63 */
64struct regmap_range {
65 unsigned int range_min;
66 unsigned int range_max;
67};
68
69/*
70 * A table of ranges including some yes ranges and some no ranges.
71 * If a register belongs to a no_range, the corresponding check function
72 * will return false. If a register belongs to a yes range, the corresponding
73 * check function will return true. "no_ranges" are searched first.
74 *
75 * @yes_ranges : pointer to an array of regmap ranges used as "yes ranges"
76 * @n_yes_ranges: size of the above array
77 * @no_ranges: pointer to an array of regmap ranges used as "no ranges"
78 * @n_no_ranges: size of the above array
79 */
80struct regmap_access_table {
81 const struct regmap_range *yes_ranges;
82 unsigned int n_yes_ranges;
83 const struct regmap_range *no_ranges;
84 unsigned int n_no_ranges;
85};
86
Davide Ciminaghi0d4529c2012-10-16 15:56:59 +020087typedef void (*regmap_lock)(void *);
88typedef void (*regmap_unlock)(void *);
89
Mark Brownbd20eb52011-08-19 18:09:38 +090090/**
Mark Browndd898b22011-07-20 22:28:58 +010091 * Configuration for the register map of a device.
92 *
Stephen Warrend3c242e2012-04-04 15:48:29 -060093 * @name: Optional name of the regmap. Useful when a device has multiple
94 * register regions.
95 *
Mark Browndd898b22011-07-20 22:28:58 +010096 * @reg_bits: Number of bits in a register address, mandatory.
Stephen Warrenf01ee602012-04-09 13:40:24 -060097 * @reg_stride: The register address stride. Valid register addresses are a
98 * multiple of this value. If set to 0, a value of 1 will be
99 * used.
Mark Brown82159ba2012-01-18 10:52:25 +0000100 * @pad_bits: Number of bits of padding between register and value.
Mark Browndd898b22011-07-20 22:28:58 +0100101 * @val_bits: Number of bits in a register value, mandatory.
Mark Brown2e2ae662011-07-20 22:33:39 +0100102 *
Mark Brown3566cc92011-08-09 10:23:22 +0900103 * @writeable_reg: Optional callback returning true if the register
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100104 * can be written to. If this field is NULL but wr_table
105 * (see below) is not, the check is performed on such table
106 * (a register is writeable if it belongs to one of the ranges
107 * specified by wr_table).
Mark Brown3566cc92011-08-09 10:23:22 +0900108 * @readable_reg: Optional callback returning true if the register
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100109 * can be read from. If this field is NULL but rd_table
110 * (see below) is not, the check is performed on such table
111 * (a register is readable if it belongs to one of the ranges
112 * specified by rd_table).
Mark Brown3566cc92011-08-09 10:23:22 +0900113 * @volatile_reg: Optional callback returning true if the register
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100114 * value can't be cached. If this field is NULL but
115 * volatile_table (see below) is not, the check is performed on
116 * such table (a register is volatile if it belongs to one of
117 * the ranges specified by volatile_table).
Mark Brown3566cc92011-08-09 10:23:22 +0900118 * @precious_reg: Optional callback returning true if the rgister
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100119 * should not be read outside of a call from the driver
120 * (eg, a clear on read interrupt status register). If this
121 * field is NULL but precious_table (see below) is not, the
122 * check is performed on such table (a register is precious if
123 * it belongs to one of the ranges specified by precious_table).
124 * @lock: Optional lock callback (overrides regmap's default lock
125 * function, based on spinlock or mutex).
126 * @unlock: As above for unlocking.
127 * @lock_arg: this field is passed as the only argument of lock/unlock
128 * functions (ignored in case regular lock/unlock functions
129 * are not overridden).
Mark Brownbd20eb52011-08-19 18:09:38 +0900130 *
131 * @max_register: Optional, specifies the maximum valid register index.
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100132 * @wr_table: Optional, points to a struct regmap_access_table specifying
133 * valid ranges for write access.
134 * @rd_table: As above, for read access.
135 * @volatile_table: As above, for volatile registers.
136 * @precious_table: As above, for precious registers.
Mark Brownbd20eb52011-08-19 18:09:38 +0900137 * @reg_defaults: Power on reset values for registers (for use with
138 * register cache support).
139 * @num_reg_defaults: Number of elements in reg_defaults.
Lars-Peter Clausen6f306442011-09-05 20:46:32 +0200140 *
141 * @read_flag_mask: Mask to be set in the top byte of the register when doing
142 * a read.
143 * @write_flag_mask: Mask to be set in the top byte of the register when doing
144 * a write. If both read_flag_mask and write_flag_mask are
145 * empty the regmap_bus default masks are used.
Ashish Jangam2e33caf2012-04-30 23:23:40 +0100146 * @use_single_rw: If set, converts the bulk read and write operations into
147 * a series of single read and write operations. This is useful
148 * for device that does not support bulk read and write.
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100149 *
150 * @cache_type: The actual cache type.
151 * @reg_defaults_raw: Power on reset values for registers (for use with
152 * register cache support).
153 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
Stephen Warren141eba22012-05-24 10:47:26 -0600154 * @reg_format_endian: Endianness for formatted register addresses. If this is
155 * DEFAULT, the @reg_format_endian_default value from the
156 * regmap bus is used.
157 * @val_format_endian: Endianness for formatted register values. If this is
158 * DEFAULT, the @reg_format_endian_default value from the
159 * regmap bus is used.
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100160 *
161 * @ranges: Array of configuration entries for virtual address ranges.
162 * @num_ranges: Number of range configuration entries.
Mark Browndd898b22011-07-20 22:28:58 +0100163 */
Mark Brownb83a3132011-05-11 19:59:58 +0200164struct regmap_config {
Stephen Warrend3c242e2012-04-04 15:48:29 -0600165 const char *name;
166
Mark Brownb83a3132011-05-11 19:59:58 +0200167 int reg_bits;
Stephen Warrenf01ee602012-04-09 13:40:24 -0600168 int reg_stride;
Mark Brown82159ba2012-01-18 10:52:25 +0000169 int pad_bits;
Mark Brownb83a3132011-05-11 19:59:58 +0200170 int val_bits;
Mark Brown2e2ae662011-07-20 22:33:39 +0100171
Mark Brown2e2ae662011-07-20 22:33:39 +0100172 bool (*writeable_reg)(struct device *dev, unsigned int reg);
173 bool (*readable_reg)(struct device *dev, unsigned int reg);
174 bool (*volatile_reg)(struct device *dev, unsigned int reg);
Mark Brown18694882011-08-08 15:40:22 +0900175 bool (*precious_reg)(struct device *dev, unsigned int reg);
Davide Ciminaghi0d4529c2012-10-16 15:56:59 +0200176 regmap_lock lock;
177 regmap_unlock unlock;
178 void *lock_arg;
Mark Brownbd20eb52011-08-19 18:09:38 +0900179
180 unsigned int max_register;
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100181 const struct regmap_access_table *wr_table;
182 const struct regmap_access_table *rd_table;
183 const struct regmap_access_table *volatile_table;
184 const struct regmap_access_table *precious_table;
Lars-Peter Clausen720e4612011-11-16 16:28:17 +0100185 const struct reg_default *reg_defaults;
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100186 unsigned int num_reg_defaults;
187 enum regcache_type cache_type;
188 const void *reg_defaults_raw;
189 unsigned int num_reg_defaults_raw;
Lars-Peter Clausen6f306442011-09-05 20:46:32 +0200190
191 u8 read_flag_mask;
192 u8 write_flag_mask;
Ashish Jangam2e33caf2012-04-30 23:23:40 +0100193
194 bool use_single_rw;
Stephen Warren141eba22012-05-24 10:47:26 -0600195
196 enum regmap_endian reg_format_endian;
197 enum regmap_endian val_format_endian;
Mark Brown38e23192012-07-22 19:26:07 +0100198
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100199 const struct regmap_range_cfg *ranges;
Mark Browne3549cd2012-10-02 20:17:15 +0100200 unsigned int num_ranges;
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100201};
202
203/**
204 * Configuration for indirectly accessed or paged registers.
205 * Registers, mapped to this virtual range, are accessed in two steps:
206 * 1. page selector register update;
207 * 2. access through data window registers.
208 *
Mark Brownd058bb42012-10-03 12:40:47 +0100209 * @name: Descriptive name for diagnostics
210 *
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100211 * @range_min: Address of the lowest register address in virtual range.
212 * @range_max: Address of the highest register in virtual range.
213 *
214 * @page_sel_reg: Register with selector field.
215 * @page_sel_mask: Bit shift for selector value.
216 * @page_sel_shift: Bit mask for selector value.
217 *
218 * @window_start: Address of first (lowest) register in data window.
219 * @window_len: Number of registers in data window.
220 */
221struct regmap_range_cfg {
Mark Brownd058bb42012-10-03 12:40:47 +0100222 const char *name;
223
Krystian Garbaciak6863ca62012-06-15 11:23:56 +0100224 /* Registers of virtual address range */
225 unsigned int range_min;
226 unsigned int range_max;
227
228 /* Page selector for indirect addressing */
229 unsigned int selector_reg;
230 unsigned int selector_mask;
231 int selector_shift;
232
233 /* Data window (per each page) */
234 unsigned int window_start;
235 unsigned int window_len;
Mark Brownb83a3132011-05-11 19:59:58 +0200236};
237
Stephen Warren0135bbc2012-04-04 15:48:30 -0600238typedef int (*regmap_hw_write)(void *context, const void *data,
Mark Brownb83a3132011-05-11 19:59:58 +0200239 size_t count);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600240typedef int (*regmap_hw_gather_write)(void *context,
Mark Brownb83a3132011-05-11 19:59:58 +0200241 const void *reg, size_t reg_len,
242 const void *val, size_t val_len);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600243typedef int (*regmap_hw_read)(void *context,
Mark Brownb83a3132011-05-11 19:59:58 +0200244 const void *reg_buf, size_t reg_size,
245 void *val_buf, size_t val_size);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600246typedef void (*regmap_hw_free_context)(void *context);
Mark Brownb83a3132011-05-11 19:59:58 +0200247
248/**
249 * Description of a hardware bus for the register map infrastructure.
250 *
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600251 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
Davide Ciminaghi0d4529c2012-10-16 15:56:59 +0200252 * to perform locking. This field is ignored if custom lock/unlock
253 * functions are used (see fields lock/unlock of
254 * struct regmap_config).
Mark Brownb83a3132011-05-11 19:59:58 +0200255 * @write: Write operation.
256 * @gather_write: Write operation with split register/value, return -ENOTSUPP
257 * if not implemented on a given device.
258 * @read: Read operation. Data is returned in the buffer used to transmit
259 * data.
Mark Brownb83a3132011-05-11 19:59:58 +0200260 * @read_flag_mask: Mask to be set in the top byte of the register when doing
261 * a read.
Stephen Warren141eba22012-05-24 10:47:26 -0600262 * @reg_format_endian_default: Default endianness for formatted register
263 * addresses. Used when the regmap_config specifies DEFAULT. If this is
264 * DEFAULT, BIG is assumed.
265 * @val_format_endian_default: Default endianness for formatted register
266 * values. Used when the regmap_config specifies DEFAULT. If this is
267 * DEFAULT, BIG is assumed.
Mark Brownb83a3132011-05-11 19:59:58 +0200268 */
269struct regmap_bus {
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600270 bool fast_io;
Mark Brownb83a3132011-05-11 19:59:58 +0200271 regmap_hw_write write;
272 regmap_hw_gather_write gather_write;
273 regmap_hw_read read;
Stephen Warren0135bbc2012-04-04 15:48:30 -0600274 regmap_hw_free_context free_context;
Mark Brownb83a3132011-05-11 19:59:58 +0200275 u8 read_flag_mask;
Stephen Warren141eba22012-05-24 10:47:26 -0600276 enum regmap_endian reg_format_endian_default;
277 enum regmap_endian val_format_endian_default;
Mark Brownb83a3132011-05-11 19:59:58 +0200278};
279
280struct regmap *regmap_init(struct device *dev,
281 const struct regmap_bus *bus,
Stephen Warren0135bbc2012-04-04 15:48:30 -0600282 void *bus_context,
Mark Brownb83a3132011-05-11 19:59:58 +0200283 const struct regmap_config *config);
Mark Brown9943fa32011-06-20 19:02:29 +0100284struct regmap *regmap_init_i2c(struct i2c_client *i2c,
285 const struct regmap_config *config);
Mark Browna676f082011-05-12 11:42:10 +0200286struct regmap *regmap_init_spi(struct spi_device *dev,
287 const struct regmap_config *config);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600288struct regmap *regmap_init_mmio(struct device *dev,
289 void __iomem *regs,
290 const struct regmap_config *config);
Mark Browna676f082011-05-12 11:42:10 +0200291
Mark Brownc0eb4672012-01-30 19:56:52 +0000292struct regmap *devm_regmap_init(struct device *dev,
293 const struct regmap_bus *bus,
Stephen Warren0135bbc2012-04-04 15:48:30 -0600294 void *bus_context,
Mark Brownc0eb4672012-01-30 19:56:52 +0000295 const struct regmap_config *config);
296struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
297 const struct regmap_config *config);
298struct regmap *devm_regmap_init_spi(struct spi_device *dev,
299 const struct regmap_config *config);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600300struct regmap *devm_regmap_init_mmio(struct device *dev,
301 void __iomem *regs,
302 const struct regmap_config *config);
Mark Brownc0eb4672012-01-30 19:56:52 +0000303
Mark Brownb83a3132011-05-11 19:59:58 +0200304void regmap_exit(struct regmap *map);
Mark Brownbf315172011-12-03 17:06:20 +0000305int regmap_reinit_cache(struct regmap *map,
306 const struct regmap_config *config);
Mark Brown72b39f62012-05-08 17:44:40 +0100307struct regmap *dev_get_regmap(struct device *dev, const char *name);
Mark Brownb83a3132011-05-11 19:59:58 +0200308int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
309int regmap_raw_write(struct regmap *map, unsigned int reg,
310 const void *val, size_t val_len);
Laxman Dewangan8eaeb212012-02-12 19:49:43 +0530311int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
312 size_t val_count);
Mark Brownb83a3132011-05-11 19:59:58 +0200313int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
314int regmap_raw_read(struct regmap *map, unsigned int reg,
315 void *val, size_t val_len);
316int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
317 size_t val_count);
318int regmap_update_bits(struct regmap *map, unsigned int reg,
319 unsigned int mask, unsigned int val);
Mark Brown018690d2011-11-29 20:10:36 +0000320int regmap_update_bits_check(struct regmap *map, unsigned int reg,
321 unsigned int mask, unsigned int val,
322 bool *change);
Mark Browna6539c32012-02-17 14:20:14 -0800323int regmap_get_val_bytes(struct regmap *map);
Mark Brownb83a3132011-05-11 19:59:58 +0200324
Mark Brown39a58432011-09-19 18:21:49 +0100325int regcache_sync(struct regmap *map);
Mark Brown4d4cfd12012-02-23 20:53:37 +0000326int regcache_sync_region(struct regmap *map, unsigned int min,
327 unsigned int max);
Mark Brown92afb282011-09-19 18:22:14 +0100328void regcache_cache_only(struct regmap *map, bool enable);
Dimitris Papastamos6eb0f5e2011-09-29 14:36:27 +0100329void regcache_cache_bypass(struct regmap *map, bool enable);
Mark Brown8ae0d7e2011-10-26 10:34:22 +0200330void regcache_mark_dirty(struct regmap *map);
Mark Brown92afb282011-09-19 18:22:14 +0100331
Mark Brown22f0d902012-01-21 12:01:14 +0000332int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
333 int num_regs);
334
Davide Ciminaghi76aad392012-11-20 15:20:30 +0100335static inline bool regmap_reg_in_range(unsigned int reg,
336 const struct regmap_range *range)
337{
338 return reg >= range->range_min && reg <= range->range_max;
339}
340
341bool regmap_reg_in_ranges(unsigned int reg,
342 const struct regmap_range *ranges,
343 unsigned int nranges);
344
Mark Brownf8beab22011-10-28 23:50:49 +0200345/**
346 * Description of an IRQ for the generic regmap irq_chip.
347 *
348 * @reg_offset: Offset of the status/mask register within the bank
349 * @mask: Mask used to flag/control the register.
350 */
351struct regmap_irq {
352 unsigned int reg_offset;
353 unsigned int mask;
354};
355
356/**
357 * Description of a generic regmap irq_chip. This is not intended to
358 * handle every possible interrupt controller, but it should handle a
359 * substantial proportion of those that are found in the wild.
360 *
361 * @name: Descriptive name for IRQ controller.
362 *
363 * @status_base: Base status register address.
364 * @mask_base: Base mask register address.
365 * @ack_base: Base ack address. If zero then the chip is clear on read.
Mark Browna43fd502012-06-05 14:34:03 +0100366 * @wake_base: Base address for wake enables. If zero unsupported.
Graeme Gregory022f926a2012-05-14 22:40:43 +0900367 * @irq_reg_stride: Stride to use for chips where registers are not contiguous.
Mark Brown0c00c502012-07-24 15:41:19 +0100368 * @runtime_pm: Hold a runtime PM lock on the device when accessing it.
Mark Brownf8beab22011-10-28 23:50:49 +0200369 *
370 * @num_regs: Number of registers in each control bank.
371 * @irqs: Descriptors for individual IRQs. Interrupt numbers are
372 * assigned based on the index in the array of the interrupt.
373 * @num_irqs: Number of descriptors.
374 */
375struct regmap_irq_chip {
376 const char *name;
377
378 unsigned int status_base;
379 unsigned int mask_base;
380 unsigned int ack_base;
Mark Browna43fd502012-06-05 14:34:03 +0100381 unsigned int wake_base;
Graeme Gregory022f926a2012-05-14 22:40:43 +0900382 unsigned int irq_reg_stride;
Xiaofan Tian36ac9142012-08-30 17:03:35 +0800383 unsigned int mask_invert;
Mark Brown0c00c502012-07-24 15:41:19 +0100384 bool runtime_pm;
Mark Brownf8beab22011-10-28 23:50:49 +0200385
386 int num_regs;
387
388 const struct regmap_irq *irqs;
389 int num_irqs;
390};
391
392struct regmap_irq_chip_data;
393
394int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
Mark Brownb026ddb2012-05-31 21:01:46 +0100395 int irq_base, const struct regmap_irq_chip *chip,
Mark Brownf8beab22011-10-28 23:50:49 +0200396 struct regmap_irq_chip_data **data);
397void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
Mark Brown209a6002011-12-05 16:10:15 +0000398int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
Mark Brown4af8be62012-05-13 10:59:56 +0100399int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
Mark Brown90f790d2012-08-20 21:45:05 +0100400struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data);
Mark Brownb83a3132011-05-11 19:59:58 +0200401
Mark Brown9cde5fc2012-02-17 14:49:51 -0800402#else
403
404/*
405 * These stubs should only ever be called by generic code which has
406 * regmap based facilities, if they ever get called at runtime
407 * something is going wrong and something probably needs to select
408 * REGMAP.
409 */
410
411static inline int regmap_write(struct regmap *map, unsigned int reg,
412 unsigned int val)
413{
414 WARN_ONCE(1, "regmap API is disabled");
415 return -EINVAL;
416}
417
418static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
419 const void *val, size_t val_len)
420{
421 WARN_ONCE(1, "regmap API is disabled");
422 return -EINVAL;
423}
424
425static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
426 const void *val, size_t val_count)
427{
428 WARN_ONCE(1, "regmap API is disabled");
429 return -EINVAL;
430}
431
432static inline int regmap_read(struct regmap *map, unsigned int reg,
433 unsigned int *val)
434{
435 WARN_ONCE(1, "regmap API is disabled");
436 return -EINVAL;
437}
438
439static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
440 void *val, size_t val_len)
441{
442 WARN_ONCE(1, "regmap API is disabled");
443 return -EINVAL;
444}
445
446static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
447 void *val, size_t val_count)
448{
449 WARN_ONCE(1, "regmap API is disabled");
450 return -EINVAL;
451}
452
453static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
454 unsigned int mask, unsigned int val)
455{
456 WARN_ONCE(1, "regmap API is disabled");
457 return -EINVAL;
458}
459
460static inline int regmap_update_bits_check(struct regmap *map,
461 unsigned int reg,
462 unsigned int mask, unsigned int val,
463 bool *change)
464{
465 WARN_ONCE(1, "regmap API is disabled");
466 return -EINVAL;
467}
468
469static inline int regmap_get_val_bytes(struct regmap *map)
470{
471 WARN_ONCE(1, "regmap API is disabled");
472 return -EINVAL;
473}
474
475static inline int regcache_sync(struct regmap *map)
476{
477 WARN_ONCE(1, "regmap API is disabled");
478 return -EINVAL;
479}
480
Mark Browna313f9f2012-02-23 19:49:43 +0000481static inline int regcache_sync_region(struct regmap *map, unsigned int min,
482 unsigned int max)
483{
484 WARN_ONCE(1, "regmap API is disabled");
485 return -EINVAL;
486}
487
Mark Brown9cde5fc2012-02-17 14:49:51 -0800488static inline void regcache_cache_only(struct regmap *map, bool enable)
489{
490 WARN_ONCE(1, "regmap API is disabled");
491}
492
493static inline void regcache_cache_bypass(struct regmap *map, bool enable)
494{
495 WARN_ONCE(1, "regmap API is disabled");
496}
497
498static inline void regcache_mark_dirty(struct regmap *map)
499{
500 WARN_ONCE(1, "regmap API is disabled");
501}
502
503static inline int regmap_register_patch(struct regmap *map,
504 const struct reg_default *regs,
505 int num_regs)
506{
507 WARN_ONCE(1, "regmap API is disabled");
508 return -EINVAL;
509}
510
Mark Brown72b39f62012-05-08 17:44:40 +0100511static inline struct regmap *dev_get_regmap(struct device *dev,
512 const char *name)
513{
Mark Brown72b39f62012-05-08 17:44:40 +0100514 return NULL;
515}
516
Mark Brown9cde5fc2012-02-17 14:49:51 -0800517#endif
518
Mark Brownb83a3132011-05-11 19:59:58 +0200519#endif