blob: 56af22ec9aba3e85aa32e035897b90b1b12cc67d [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 *
Stephen Warrend3c242e2012-04-04 15:48:29 -060049 * @name: Optional name of the regmap. Useful when a device has multiple
50 * register regions.
51 *
Mark Browndd898b22011-07-20 22:28:58 +010052 * @reg_bits: Number of bits in a register address, mandatory.
Stephen Warrenf01ee602012-04-09 13:40:24 -060053 * @reg_stride: The register address stride. Valid register addresses are a
54 * multiple of this value. If set to 0, a value of 1 will be
55 * used.
Mark Brown82159ba2012-01-18 10:52:25 +000056 * @pad_bits: Number of bits of padding between register and value.
Mark Browndd898b22011-07-20 22:28:58 +010057 * @val_bits: Number of bits in a register value, mandatory.
Mark Brown2e2ae662011-07-20 22:33:39 +010058 *
Mark Brown3566cc92011-08-09 10:23:22 +090059 * @writeable_reg: Optional callback returning true if the register
60 * can be written to.
61 * @readable_reg: Optional callback returning true if the register
62 * can be read from.
63 * @volatile_reg: Optional callback returning true if the register
64 * value can't be cached.
65 * @precious_reg: Optional callback returning true if the rgister
66 * should not be read outside of a call from the driver
67 * (eg, a clear on read interrupt status register).
Mark Brownbd20eb52011-08-19 18:09:38 +090068 *
69 * @max_register: Optional, specifies the maximum valid register index.
70 * @reg_defaults: Power on reset values for registers (for use with
71 * register cache support).
72 * @num_reg_defaults: Number of elements in reg_defaults.
Lars-Peter Clausen6f306442011-09-05 20:46:32 +020073 *
74 * @read_flag_mask: Mask to be set in the top byte of the register when doing
75 * a read.
76 * @write_flag_mask: Mask to be set in the top byte of the register when doing
77 * a write. If both read_flag_mask and write_flag_mask are
78 * empty the regmap_bus default masks are used.
Ashish Jangam2e33caf2012-04-30 23:23:40 +010079 * @use_single_rw: If set, converts the bulk read and write operations into
80 * a series of single read and write operations. This is useful
81 * for device that does not support bulk read and write.
Dimitris Papastamos9fabe242011-09-19 14:34:00 +010082 *
83 * @cache_type: The actual cache type.
84 * @reg_defaults_raw: Power on reset values for registers (for use with
85 * register cache support).
86 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
Mark Browndd898b22011-07-20 22:28:58 +010087 */
Mark Brownb83a3132011-05-11 19:59:58 +020088struct regmap_config {
Stephen Warrend3c242e2012-04-04 15:48:29 -060089 const char *name;
90
Mark Brownb83a3132011-05-11 19:59:58 +020091 int reg_bits;
Stephen Warrenf01ee602012-04-09 13:40:24 -060092 int reg_stride;
Mark Brown82159ba2012-01-18 10:52:25 +000093 int pad_bits;
Mark Brownb83a3132011-05-11 19:59:58 +020094 int val_bits;
Mark Brown2e2ae662011-07-20 22:33:39 +010095
Mark Brown2e2ae662011-07-20 22:33:39 +010096 bool (*writeable_reg)(struct device *dev, unsigned int reg);
97 bool (*readable_reg)(struct device *dev, unsigned int reg);
98 bool (*volatile_reg)(struct device *dev, unsigned int reg);
Mark Brown18694882011-08-08 15:40:22 +090099 bool (*precious_reg)(struct device *dev, unsigned int reg);
Mark Brownbd20eb52011-08-19 18:09:38 +0900100
101 unsigned int max_register;
Lars-Peter Clausen720e4612011-11-16 16:28:17 +0100102 const struct reg_default *reg_defaults;
Dimitris Papastamos9fabe242011-09-19 14:34:00 +0100103 unsigned int num_reg_defaults;
104 enum regcache_type cache_type;
105 const void *reg_defaults_raw;
106 unsigned int num_reg_defaults_raw;
Lars-Peter Clausen6f306442011-09-05 20:46:32 +0200107
108 u8 read_flag_mask;
109 u8 write_flag_mask;
Ashish Jangam2e33caf2012-04-30 23:23:40 +0100110
111 bool use_single_rw;
Mark Brownb83a3132011-05-11 19:59:58 +0200112};
113
Stephen Warren0135bbc2012-04-04 15:48:30 -0600114typedef int (*regmap_hw_write)(void *context, const void *data,
Mark Brownb83a3132011-05-11 19:59:58 +0200115 size_t count);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600116typedef int (*regmap_hw_gather_write)(void *context,
Mark Brownb83a3132011-05-11 19:59:58 +0200117 const void *reg, size_t reg_len,
118 const void *val, size_t val_len);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600119typedef int (*regmap_hw_read)(void *context,
Mark Brownb83a3132011-05-11 19:59:58 +0200120 const void *reg_buf, size_t reg_size,
121 void *val_buf, size_t val_size);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600122typedef void (*regmap_hw_free_context)(void *context);
Mark Brownb83a3132011-05-11 19:59:58 +0200123
124/**
125 * Description of a hardware bus for the register map infrastructure.
126 *
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600127 * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
128 * to perform locking.
Mark Brownb83a3132011-05-11 19:59:58 +0200129 * @write: Write operation.
130 * @gather_write: Write operation with split register/value, return -ENOTSUPP
131 * if not implemented on a given device.
132 * @read: Read operation. Data is returned in the buffer used to transmit
133 * data.
Mark Brownb83a3132011-05-11 19:59:58 +0200134 * @read_flag_mask: Mask to be set in the top byte of the register when doing
135 * a read.
136 */
137struct regmap_bus {
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600138 bool fast_io;
Mark Brownb83a3132011-05-11 19:59:58 +0200139 regmap_hw_write write;
140 regmap_hw_gather_write gather_write;
141 regmap_hw_read read;
Stephen Warren0135bbc2012-04-04 15:48:30 -0600142 regmap_hw_free_context free_context;
Mark Brownb83a3132011-05-11 19:59:58 +0200143 u8 read_flag_mask;
144};
145
146struct regmap *regmap_init(struct device *dev,
147 const struct regmap_bus *bus,
Stephen Warren0135bbc2012-04-04 15:48:30 -0600148 void *bus_context,
Mark Brownb83a3132011-05-11 19:59:58 +0200149 const struct regmap_config *config);
Mark Brown9943fa32011-06-20 19:02:29 +0100150struct regmap *regmap_init_i2c(struct i2c_client *i2c,
151 const struct regmap_config *config);
Mark Browna676f082011-05-12 11:42:10 +0200152struct regmap *regmap_init_spi(struct spi_device *dev,
153 const struct regmap_config *config);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600154struct regmap *regmap_init_mmio(struct device *dev,
155 void __iomem *regs,
156 const struct regmap_config *config);
Mark Browna676f082011-05-12 11:42:10 +0200157
Mark Brownc0eb4672012-01-30 19:56:52 +0000158struct regmap *devm_regmap_init(struct device *dev,
159 const struct regmap_bus *bus,
Stephen Warren0135bbc2012-04-04 15:48:30 -0600160 void *bus_context,
Mark Brownc0eb4672012-01-30 19:56:52 +0000161 const struct regmap_config *config);
162struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
163 const struct regmap_config *config);
164struct regmap *devm_regmap_init_spi(struct spi_device *dev,
165 const struct regmap_config *config);
Stephen Warren45f5ff82012-04-04 15:48:31 -0600166struct regmap *devm_regmap_init_mmio(struct device *dev,
167 void __iomem *regs,
168 const struct regmap_config *config);
Mark Brownc0eb4672012-01-30 19:56:52 +0000169
Mark Brownb83a3132011-05-11 19:59:58 +0200170void regmap_exit(struct regmap *map);
Mark Brownbf315172011-12-03 17:06:20 +0000171int regmap_reinit_cache(struct regmap *map,
172 const struct regmap_config *config);
Mark Brown72b39f62012-05-08 17:44:40 +0100173struct regmap *dev_get_regmap(struct device *dev, const char *name);
Mark Brownb83a3132011-05-11 19:59:58 +0200174int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
175int regmap_raw_write(struct regmap *map, unsigned int reg,
176 const void *val, size_t val_len);
Laxman Dewangan8eaeb212012-02-12 19:49:43 +0530177int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
178 size_t val_count);
Mark Brownb83a3132011-05-11 19:59:58 +0200179int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
180int regmap_raw_read(struct regmap *map, unsigned int reg,
181 void *val, size_t val_len);
182int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
183 size_t val_count);
184int regmap_update_bits(struct regmap *map, unsigned int reg,
185 unsigned int mask, unsigned int val);
Mark Brown018690d2011-11-29 20:10:36 +0000186int regmap_update_bits_check(struct regmap *map, unsigned int reg,
187 unsigned int mask, unsigned int val,
188 bool *change);
Mark Browna6539c32012-02-17 14:20:14 -0800189int regmap_get_val_bytes(struct regmap *map);
Mark Brownb83a3132011-05-11 19:59:58 +0200190
Mark Brown39a58432011-09-19 18:21:49 +0100191int regcache_sync(struct regmap *map);
Mark Brown4d4cfd12012-02-23 20:53:37 +0000192int regcache_sync_region(struct regmap *map, unsigned int min,
193 unsigned int max);
Mark Brown92afb282011-09-19 18:22:14 +0100194void regcache_cache_only(struct regmap *map, bool enable);
Dimitris Papastamos6eb0f5e2011-09-29 14:36:27 +0100195void regcache_cache_bypass(struct regmap *map, bool enable);
Mark Brown8ae0d7e2011-10-26 10:34:22 +0200196void regcache_mark_dirty(struct regmap *map);
Mark Brown92afb282011-09-19 18:22:14 +0100197
Mark Brown22f0d902012-01-21 12:01:14 +0000198int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
199 int num_regs);
200
Mark Brownf8beab22011-10-28 23:50:49 +0200201/**
202 * Description of an IRQ for the generic regmap irq_chip.
203 *
204 * @reg_offset: Offset of the status/mask register within the bank
205 * @mask: Mask used to flag/control the register.
206 */
207struct regmap_irq {
208 unsigned int reg_offset;
209 unsigned int mask;
210};
211
212/**
213 * Description of a generic regmap irq_chip. This is not intended to
214 * handle every possible interrupt controller, but it should handle a
215 * substantial proportion of those that are found in the wild.
216 *
217 * @name: Descriptive name for IRQ controller.
218 *
219 * @status_base: Base status register address.
220 * @mask_base: Base mask register address.
221 * @ack_base: Base ack address. If zero then the chip is clear on read.
Graeme Gregory022f926a2012-05-14 22:40:43 +0900222 * @irq_reg_stride: Stride to use for chips where registers are not contiguous.
Mark Brownf8beab22011-10-28 23:50:49 +0200223 *
224 * @num_regs: Number of registers in each control bank.
225 * @irqs: Descriptors for individual IRQs. Interrupt numbers are
226 * assigned based on the index in the array of the interrupt.
227 * @num_irqs: Number of descriptors.
228 */
229struct regmap_irq_chip {
230 const char *name;
231
232 unsigned int status_base;
233 unsigned int mask_base;
234 unsigned int ack_base;
Graeme Gregory022f926a2012-05-14 22:40:43 +0900235 unsigned int irq_reg_stride;
Mark Brownf8beab22011-10-28 23:50:49 +0200236
237 int num_regs;
238
239 const struct regmap_irq *irqs;
240 int num_irqs;
241};
242
243struct regmap_irq_chip_data;
244
245int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
246 int irq_base, struct regmap_irq_chip *chip,
247 struct regmap_irq_chip_data **data);
248void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
Mark Brown209a6002011-12-05 16:10:15 +0000249int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
Mark Brown4af8be62012-05-13 10:59:56 +0100250int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
Mark Brownb83a3132011-05-11 19:59:58 +0200251
Mark Brown9cde5fc2012-02-17 14:49:51 -0800252#else
253
254/*
255 * These stubs should only ever be called by generic code which has
256 * regmap based facilities, if they ever get called at runtime
257 * something is going wrong and something probably needs to select
258 * REGMAP.
259 */
260
261static inline int regmap_write(struct regmap *map, unsigned int reg,
262 unsigned int val)
263{
264 WARN_ONCE(1, "regmap API is disabled");
265 return -EINVAL;
266}
267
268static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
269 const void *val, size_t val_len)
270{
271 WARN_ONCE(1, "regmap API is disabled");
272 return -EINVAL;
273}
274
275static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
276 const void *val, size_t val_count)
277{
278 WARN_ONCE(1, "regmap API is disabled");
279 return -EINVAL;
280}
281
282static inline int regmap_read(struct regmap *map, unsigned int reg,
283 unsigned int *val)
284{
285 WARN_ONCE(1, "regmap API is disabled");
286 return -EINVAL;
287}
288
289static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
290 void *val, size_t val_len)
291{
292 WARN_ONCE(1, "regmap API is disabled");
293 return -EINVAL;
294}
295
296static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
297 void *val, size_t val_count)
298{
299 WARN_ONCE(1, "regmap API is disabled");
300 return -EINVAL;
301}
302
303static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
304 unsigned int mask, unsigned int val)
305{
306 WARN_ONCE(1, "regmap API is disabled");
307 return -EINVAL;
308}
309
310static inline int regmap_update_bits_check(struct regmap *map,
311 unsigned int reg,
312 unsigned int mask, unsigned int val,
313 bool *change)
314{
315 WARN_ONCE(1, "regmap API is disabled");
316 return -EINVAL;
317}
318
319static inline int regmap_get_val_bytes(struct regmap *map)
320{
321 WARN_ONCE(1, "regmap API is disabled");
322 return -EINVAL;
323}
324
325static inline int regcache_sync(struct regmap *map)
326{
327 WARN_ONCE(1, "regmap API is disabled");
328 return -EINVAL;
329}
330
Mark Browna313f9f2012-02-23 19:49:43 +0000331static inline int regcache_sync_region(struct regmap *map, unsigned int min,
332 unsigned int max)
333{
334 WARN_ONCE(1, "regmap API is disabled");
335 return -EINVAL;
336}
337
Mark Brown9cde5fc2012-02-17 14:49:51 -0800338static inline void regcache_cache_only(struct regmap *map, bool enable)
339{
340 WARN_ONCE(1, "regmap API is disabled");
341}
342
343static inline void regcache_cache_bypass(struct regmap *map, bool enable)
344{
345 WARN_ONCE(1, "regmap API is disabled");
346}
347
348static inline void regcache_mark_dirty(struct regmap *map)
349{
350 WARN_ONCE(1, "regmap API is disabled");
351}
352
353static inline int regmap_register_patch(struct regmap *map,
354 const struct reg_default *regs,
355 int num_regs)
356{
357 WARN_ONCE(1, "regmap API is disabled");
358 return -EINVAL;
359}
360
Mark Brown72b39f62012-05-08 17:44:40 +0100361static inline struct regmap *dev_get_regmap(struct device *dev,
362 const char *name)
363{
364 WARN_ONCE(1, "regmap API is disabled");
365 return NULL;
366}
367
Mark Brown9cde5fc2012-02-17 14:49:51 -0800368#endif
369
Mark Brownb83a3132011-05-11 19:59:58 +0200370#endif