blob: 8fd341e613d644d1fb88626f4269e68e0882c79f [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>
Mark Brownb83a3132011-05-11 19:59:58 +020017
Paul Gortmakerde477252011-05-26 13:46:22 -040018struct module;
Paul Gortmaker313162d2012-01-30 11:46:54 -050019struct device;
Mark Brown9943fa32011-06-20 19:02:29 +010020struct i2c_client;
Mark Browna676f082011-05-12 11:42:10 +020021struct spi_device;
Mark Brownb83d2ff2012-03-11 11:49:17 +000022struct regmap;
Mark Brown9943fa32011-06-20 19:02:29 +010023
Dimitris Papastamos9fabe242011-09-19 14:34:00 +010024/* An enum of all the supported cache types */
25enum regcache_type {
26 REGCACHE_NONE,
Dimitris Papastamos28644c802011-09-19 14:34:02 +010027 REGCACHE_RBTREE,
Mark Brown50b776f2011-11-02 15:00:03 +000028 REGCACHE_COMPRESSED
Dimitris Papastamos9fabe242011-09-19 14:34:00 +010029};
30
Mark Browndd898b22011-07-20 22:28:58 +010031/**
Mark Brownbd20eb52011-08-19 18:09:38 +090032 * Default value for a register. We use an array of structs rather
33 * than a simple array as many modern devices have very sparse
34 * register maps.
35 *
36 * @reg: Register address.
37 * @def: Register default value.
38 */
39struct reg_default {
40 unsigned int reg;
41 unsigned int def;
42};
43
Mark Brownb83d2ff2012-03-11 11:49:17 +000044#ifdef CONFIG_REGMAP
45
Mark Brownbd20eb52011-08-19 18:09:38 +090046/**
Mark Browndd898b22011-07-20 22:28:58 +010047 * Configuration for the register map of a device.
48 *
49 * @reg_bits: Number of bits in a register address, mandatory.
Mark Brown82159ba2012-01-18 10:52:25 +000050 * @pad_bits: Number of bits of padding between register and value.
Mark Browndd898b22011-07-20 22:28:58 +010051 * @val_bits: Number of bits in a register value, mandatory.
Mark Brown2e2ae662011-07-20 22:33:39 +010052 *
Mark Brown3566cc92011-08-09 10:23:22 +090053 * @writeable_reg: Optional callback returning true if the register
54 * can be written to.
55 * @readable_reg: Optional callback returning true if the register
56 * can be read from.
57 * @volatile_reg: Optional callback returning true if the register
58 * value can't be cached.
59 * @precious_reg: Optional callback returning true if the rgister
60 * should not be read outside of a call from the driver
61 * (eg, a clear on read interrupt status register).
Mark Brownbd20eb52011-08-19 18:09:38 +090062 *
63 * @max_register: Optional, specifies the maximum valid register index.
64 * @reg_defaults: Power on reset values for registers (for use with
65 * register cache support).
66 * @num_reg_defaults: Number of elements in reg_defaults.
Lars-Peter Clausen6f306442011-09-05 20:46:32 +020067 *
68 * @read_flag_mask: Mask to be set in the top byte of the register when doing
69 * a read.
70 * @write_flag_mask: Mask to be set in the top byte of the register when doing
71 * a write. If both read_flag_mask and write_flag_mask are
72 * empty the regmap_bus default masks are used.
Dimitris Papastamos9fabe242011-09-19 14:34:00 +010073 *
74 * @cache_type: The actual cache type.
75 * @reg_defaults_raw: Power on reset values for registers (for use with
76 * register cache support).
77 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
Mark Browndd898b22011-07-20 22:28:58 +010078 */
Mark Brownb83a3132011-05-11 19:59:58 +020079struct regmap_config {
80 int reg_bits;
Mark Brown82159ba2012-01-18 10:52:25 +000081 int pad_bits;
Mark Brownb83a3132011-05-11 19:59:58 +020082 int val_bits;
Mark Brown2e2ae662011-07-20 22:33:39 +010083
Mark Brown2e2ae662011-07-20 22:33:39 +010084 bool (*writeable_reg)(struct device *dev, unsigned int reg);
85 bool (*readable_reg)(struct device *dev, unsigned int reg);
86 bool (*volatile_reg)(struct device *dev, unsigned int reg);
Mark Brown18694882011-08-08 15:40:22 +090087 bool (*precious_reg)(struct device *dev, unsigned int reg);
Mark Brownbd20eb52011-08-19 18:09:38 +090088
89 unsigned int max_register;
Lars-Peter Clausen720e4612011-11-16 16:28:17 +010090 const struct reg_default *reg_defaults;
Dimitris Papastamos9fabe242011-09-19 14:34:00 +010091 unsigned int num_reg_defaults;
92 enum regcache_type cache_type;
93 const void *reg_defaults_raw;
94 unsigned int num_reg_defaults_raw;
Lars-Peter Clausen6f306442011-09-05 20:46:32 +020095
96 u8 read_flag_mask;
97 u8 write_flag_mask;
Mark Brownb83a3132011-05-11 19:59:58 +020098};
99
Stephen Warren0135bbc2012-04-04 15:48:30 -0600100typedef int (*regmap_hw_write)(void *context, const void *data,
Mark Brownb83a3132011-05-11 19:59:58 +0200101 size_t count);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600102typedef int (*regmap_hw_gather_write)(void *context,
Mark Brownb83a3132011-05-11 19:59:58 +0200103 const void *reg, size_t reg_len,
104 const void *val, size_t val_len);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600105typedef int (*regmap_hw_read)(void *context,
Mark Brownb83a3132011-05-11 19:59:58 +0200106 const void *reg_buf, size_t reg_size,
107 void *val_buf, size_t val_size);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600108typedef void (*regmap_hw_free_context)(void *context);
Mark Brownb83a3132011-05-11 19:59:58 +0200109
110/**
111 * Description of a hardware bus for the register map infrastructure.
112 *
Mark Brownb83a3132011-05-11 19:59:58 +0200113 * @write: Write operation.
114 * @gather_write: Write operation with split register/value, return -ENOTSUPP
115 * if not implemented on a given device.
116 * @read: Read operation. Data is returned in the buffer used to transmit
117 * data.
Mark Brownb83a3132011-05-11 19:59:58 +0200118 * @read_flag_mask: Mask to be set in the top byte of the register when doing
119 * a read.
120 */
121struct regmap_bus {
Mark Brownb83a3132011-05-11 19:59:58 +0200122 regmap_hw_write write;
123 regmap_hw_gather_write gather_write;
124 regmap_hw_read read;
Stephen Warren0135bbc2012-04-04 15:48:30 -0600125 regmap_hw_free_context free_context;
Mark Brownb83a3132011-05-11 19:59:58 +0200126 u8 read_flag_mask;
127};
128
129struct regmap *regmap_init(struct device *dev,
130 const struct regmap_bus *bus,
Stephen Warren0135bbc2012-04-04 15:48:30 -0600131 void *bus_context,
Mark Brownb83a3132011-05-11 19:59:58 +0200132 const struct regmap_config *config);
Mark Brown9943fa32011-06-20 19:02:29 +0100133struct regmap *regmap_init_i2c(struct i2c_client *i2c,
134 const struct regmap_config *config);
Mark Browna676f082011-05-12 11:42:10 +0200135struct regmap *regmap_init_spi(struct spi_device *dev,
136 const struct regmap_config *config);
137
Mark Brownc0eb4672012-01-30 19:56:52 +0000138struct regmap *devm_regmap_init(struct device *dev,
139 const struct regmap_bus *bus,
Stephen Warren0135bbc2012-04-04 15:48:30 -0600140 void *bus_context,
Mark Brownc0eb4672012-01-30 19:56:52 +0000141 const struct regmap_config *config);
142struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
143 const struct regmap_config *config);
144struct regmap *devm_regmap_init_spi(struct spi_device *dev,
145 const struct regmap_config *config);
146
Mark Brownb83a3132011-05-11 19:59:58 +0200147void regmap_exit(struct regmap *map);
Mark Brownbf315172011-12-03 17:06:20 +0000148int regmap_reinit_cache(struct regmap *map,
149 const struct regmap_config *config);
Mark Brownb83a3132011-05-11 19:59:58 +0200150int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
151int regmap_raw_write(struct regmap *map, unsigned int reg,
152 const void *val, size_t val_len);
Laxman Dewangan8eaeb212012-02-12 19:49:43 +0530153int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
154 size_t val_count);
Mark Brownb83a3132011-05-11 19:59:58 +0200155int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
156int regmap_raw_read(struct regmap *map, unsigned int reg,
157 void *val, size_t val_len);
158int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
159 size_t val_count);
160int regmap_update_bits(struct regmap *map, unsigned int reg,
161 unsigned int mask, unsigned int val);
Mark Brown018690d2011-11-29 20:10:36 +0000162int regmap_update_bits_check(struct regmap *map, unsigned int reg,
163 unsigned int mask, unsigned int val,
164 bool *change);
Mark Browna6539c32012-02-17 14:20:14 -0800165int regmap_get_val_bytes(struct regmap *map);
Mark Brownb83a3132011-05-11 19:59:58 +0200166
Mark Brown39a58432011-09-19 18:21:49 +0100167int regcache_sync(struct regmap *map);
Mark Brown4d4cfd12012-02-23 20:53:37 +0000168int regcache_sync_region(struct regmap *map, unsigned int min,
169 unsigned int max);
Mark Brown92afb282011-09-19 18:22:14 +0100170void regcache_cache_only(struct regmap *map, bool enable);
Dimitris Papastamos6eb0f5e2011-09-29 14:36:27 +0100171void regcache_cache_bypass(struct regmap *map, bool enable);
Mark Brown8ae0d7e2011-10-26 10:34:22 +0200172void regcache_mark_dirty(struct regmap *map);
Mark Brown92afb282011-09-19 18:22:14 +0100173
Mark Brown22f0d902012-01-21 12:01:14 +0000174int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
175 int num_regs);
176
Mark Brownf8beab22011-10-28 23:50:49 +0200177/**
178 * Description of an IRQ for the generic regmap irq_chip.
179 *
180 * @reg_offset: Offset of the status/mask register within the bank
181 * @mask: Mask used to flag/control the register.
182 */
183struct regmap_irq {
184 unsigned int reg_offset;
185 unsigned int mask;
186};
187
188/**
189 * Description of a generic regmap irq_chip. This is not intended to
190 * handle every possible interrupt controller, but it should handle a
191 * substantial proportion of those that are found in the wild.
192 *
193 * @name: Descriptive name for IRQ controller.
194 *
195 * @status_base: Base status register address.
196 * @mask_base: Base mask register address.
197 * @ack_base: Base ack address. If zero then the chip is clear on read.
198 *
199 * @num_regs: Number of registers in each control bank.
200 * @irqs: Descriptors for individual IRQs. Interrupt numbers are
201 * assigned based on the index in the array of the interrupt.
202 * @num_irqs: Number of descriptors.
203 */
204struct regmap_irq_chip {
205 const char *name;
206
207 unsigned int status_base;
208 unsigned int mask_base;
209 unsigned int ack_base;
210
211 int num_regs;
212
213 const struct regmap_irq *irqs;
214 int num_irqs;
215};
216
217struct regmap_irq_chip_data;
218
219int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
220 int irq_base, struct regmap_irq_chip *chip,
221 struct regmap_irq_chip_data **data);
222void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
Mark Brown209a6002011-12-05 16:10:15 +0000223int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
Mark Brownb83a3132011-05-11 19:59:58 +0200224
Mark Brown9cde5fc2012-02-17 14:49:51 -0800225#else
226
227/*
228 * These stubs should only ever be called by generic code which has
229 * regmap based facilities, if they ever get called at runtime
230 * something is going wrong and something probably needs to select
231 * REGMAP.
232 */
233
234static inline int regmap_write(struct regmap *map, unsigned int reg,
235 unsigned int val)
236{
237 WARN_ONCE(1, "regmap API is disabled");
238 return -EINVAL;
239}
240
241static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
242 const void *val, size_t val_len)
243{
244 WARN_ONCE(1, "regmap API is disabled");
245 return -EINVAL;
246}
247
248static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
249 const void *val, size_t val_count)
250{
251 WARN_ONCE(1, "regmap API is disabled");
252 return -EINVAL;
253}
254
255static inline int regmap_read(struct regmap *map, unsigned int reg,
256 unsigned int *val)
257{
258 WARN_ONCE(1, "regmap API is disabled");
259 return -EINVAL;
260}
261
262static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
263 void *val, size_t val_len)
264{
265 WARN_ONCE(1, "regmap API is disabled");
266 return -EINVAL;
267}
268
269static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
270 void *val, size_t val_count)
271{
272 WARN_ONCE(1, "regmap API is disabled");
273 return -EINVAL;
274}
275
276static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
277 unsigned int mask, unsigned int val)
278{
279 WARN_ONCE(1, "regmap API is disabled");
280 return -EINVAL;
281}
282
283static inline int regmap_update_bits_check(struct regmap *map,
284 unsigned int reg,
285 unsigned int mask, unsigned int val,
286 bool *change)
287{
288 WARN_ONCE(1, "regmap API is disabled");
289 return -EINVAL;
290}
291
292static inline int regmap_get_val_bytes(struct regmap *map)
293{
294 WARN_ONCE(1, "regmap API is disabled");
295 return -EINVAL;
296}
297
298static inline int regcache_sync(struct regmap *map)
299{
300 WARN_ONCE(1, "regmap API is disabled");
301 return -EINVAL;
302}
303
Mark Browna313f9f2012-02-23 19:49:43 +0000304static inline int regcache_sync_region(struct regmap *map, unsigned int min,
305 unsigned int max)
306{
307 WARN_ONCE(1, "regmap API is disabled");
308 return -EINVAL;
309}
310
Mark Brown9cde5fc2012-02-17 14:49:51 -0800311static inline void regcache_cache_only(struct regmap *map, bool enable)
312{
313 WARN_ONCE(1, "regmap API is disabled");
314}
315
316static inline void regcache_cache_bypass(struct regmap *map, bool enable)
317{
318 WARN_ONCE(1, "regmap API is disabled");
319}
320
321static inline void regcache_mark_dirty(struct regmap *map)
322{
323 WARN_ONCE(1, "regmap API is disabled");
324}
325
326static inline int regmap_register_patch(struct regmap *map,
327 const struct reg_default *regs,
328 int num_regs)
329{
330 WARN_ONCE(1, "regmap API is disabled");
331 return -EINVAL;
332}
333
334#endif
335
Mark Brownb83a3132011-05-11 19:59:58 +0200336#endif