regmap: Convert regmap_irq to use irq_domain
[linux-2.6.git] / include / linux / regmap.h
1 #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
16 #include <linux/list.h>
17
18 struct module;
19 struct device;
20 struct i2c_client;
21 struct spi_device;
22 struct regmap;
23
24 /* An enum of all the supported cache types */
25 enum regcache_type {
26         REGCACHE_NONE,
27         REGCACHE_RBTREE,
28         REGCACHE_COMPRESSED
29 };
30
31 /**
32  * 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  */
39 struct reg_default {
40         unsigned int reg;
41         unsigned int def;
42 };
43
44 #ifdef CONFIG_REGMAP
45
46 /**
47  * Configuration for the register map of a device.
48  *
49  * @name: Optional name of the regmap. Useful when a device has multiple
50  *        register regions.
51  *
52  * @reg_bits: Number of bits in a register address, mandatory.
53  * @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.
56  * @pad_bits: Number of bits of padding between register and value.
57  * @val_bits: Number of bits in a register value, mandatory.
58  *
59  * @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).
68  *
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.
73  *
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.
79  *
80  * @cache_type: The actual cache type.
81  * @reg_defaults_raw: Power on reset values for registers (for use with
82  *                    register cache support).
83  * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
84  */
85 struct regmap_config {
86         const char *name;
87
88         int reg_bits;
89         int reg_stride;
90         int pad_bits;
91         int val_bits;
92
93         bool (*writeable_reg)(struct device *dev, unsigned int reg);
94         bool (*readable_reg)(struct device *dev, unsigned int reg);
95         bool (*volatile_reg)(struct device *dev, unsigned int reg);
96         bool (*precious_reg)(struct device *dev, unsigned int reg);
97
98         unsigned int max_register;
99         const struct reg_default *reg_defaults;
100         unsigned int num_reg_defaults;
101         enum regcache_type cache_type;
102         const void *reg_defaults_raw;
103         unsigned int num_reg_defaults_raw;
104
105         u8 read_flag_mask;
106         u8 write_flag_mask;
107 };
108
109 typedef int (*regmap_hw_write)(void *context, const void *data,
110                                size_t count);
111 typedef int (*regmap_hw_gather_write)(void *context,
112                                       const void *reg, size_t reg_len,
113                                       const void *val, size_t val_len);
114 typedef int (*regmap_hw_read)(void *context,
115                               const void *reg_buf, size_t reg_size,
116                               void *val_buf, size_t val_size);
117 typedef void (*regmap_hw_free_context)(void *context);
118
119 /**
120  * Description of a hardware bus for the register map infrastructure.
121  *
122  * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
123  *           to perform locking.
124  * @write: Write operation.
125  * @gather_write: Write operation with split register/value, return -ENOTSUPP
126  *                if not implemented  on a given device.
127  * @read: Read operation.  Data is returned in the buffer used to transmit
128  *         data.
129  * @read_flag_mask: Mask to be set in the top byte of the register when doing
130  *                  a read.
131  */
132 struct regmap_bus {
133         bool fast_io;
134         regmap_hw_write write;
135         regmap_hw_gather_write gather_write;
136         regmap_hw_read read;
137         regmap_hw_free_context free_context;
138         u8 read_flag_mask;
139 };
140
141 struct regmap *regmap_init(struct device *dev,
142                            const struct regmap_bus *bus,
143                            void *bus_context,
144                            const struct regmap_config *config);
145 struct regmap *regmap_init_i2c(struct i2c_client *i2c,
146                                const struct regmap_config *config);
147 struct regmap *regmap_init_spi(struct spi_device *dev,
148                                const struct regmap_config *config);
149 struct regmap *regmap_init_mmio(struct device *dev,
150                                 void __iomem *regs,
151                                 const struct regmap_config *config);
152
153 struct regmap *devm_regmap_init(struct device *dev,
154                                 const struct regmap_bus *bus,
155                                 void *bus_context,
156                                 const struct regmap_config *config);
157 struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
158                                     const struct regmap_config *config);
159 struct regmap *devm_regmap_init_spi(struct spi_device *dev,
160                                     const struct regmap_config *config);
161 struct regmap *devm_regmap_init_mmio(struct device *dev,
162                                      void __iomem *regs,
163                                      const struct regmap_config *config);
164
165 void regmap_exit(struct regmap *map);
166 int regmap_reinit_cache(struct regmap *map,
167                         const struct regmap_config *config);
168 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
169 int regmap_raw_write(struct regmap *map, unsigned int reg,
170                      const void *val, size_t val_len);
171 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
172                         size_t val_count);
173 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
174 int regmap_raw_read(struct regmap *map, unsigned int reg,
175                     void *val, size_t val_len);
176 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
177                      size_t val_count);
178 int regmap_update_bits(struct regmap *map, unsigned int reg,
179                        unsigned int mask, unsigned int val);
180 int regmap_update_bits_lazy(struct regmap *map, unsigned int reg,
181                        unsigned int mask, unsigned int val);
182 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
183                              unsigned int mask, unsigned int val,
184                              bool *change);
185 int regmap_get_val_bytes(struct regmap *map);
186
187 int regcache_sync(struct regmap *map);
188 int regcache_sync_region(struct regmap *map, unsigned int min,
189                          unsigned int max);
190 void regcache_cache_only(struct regmap *map, bool enable);
191 void regcache_cache_bypass(struct regmap *map, bool enable);
192 void regcache_mark_dirty(struct regmap *map);
193
194 int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
195                           int num_regs);
196
197 /**
198  * Description of an IRQ for the generic regmap irq_chip.
199  *
200  * @reg_offset: Offset of the status/mask register within the bank
201  * @mask:       Mask used to flag/control the register.
202  */
203 struct regmap_irq {
204         unsigned int reg_offset;
205         unsigned int mask;
206 };
207
208 /**
209  * Description of a generic regmap irq_chip.  This is not intended to
210  * handle every possible interrupt controller, but it should handle a
211  * substantial proportion of those that are found in the wild.
212  *
213  * @name:        Descriptive name for IRQ controller.
214  *
215  * @status_base: Base status register address.
216  * @mask_base:   Base mask register address.
217  * @ack_base:    Base ack address.  If zero then the chip is clear on read.
218  * @irq_reg_stride:  Stride to use for chips where registers are not contiguous.
219  *
220  * @num_regs:    Number of registers in each control bank.
221  * @irqs:        Descriptors for individual IRQs.  Interrupt numbers are
222  *               assigned based on the index in the array of the interrupt.
223  * @num_irqs:    Number of descriptors.
224  */
225 struct regmap_irq_chip {
226         const char *name;
227
228         unsigned int status_base;
229         unsigned int mask_base;
230         unsigned int ack_base;
231         unsigned int irq_reg_stride;
232
233         int num_regs;
234
235         const struct regmap_irq *irqs;
236         int num_irqs;
237 };
238
239 struct regmap_irq_chip_data;
240
241 int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
242                         int irq_base, struct regmap_irq_chip *chip,
243                         struct regmap_irq_chip_data **data);
244 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
245 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
246 int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
247
248 #else
249
250 /*
251  * These stubs should only ever be called by generic code which has
252  * regmap based facilities, if they ever get called at runtime
253  * something is going wrong and something probably needs to select
254  * REGMAP.
255  */
256
257 static inline int regmap_write(struct regmap *map, unsigned int reg,
258                                unsigned int val)
259 {
260         WARN_ONCE(1, "regmap API is disabled");
261         return -EINVAL;
262 }
263
264 static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
265                                    const void *val, size_t val_len)
266 {
267         WARN_ONCE(1, "regmap API is disabled");
268         return -EINVAL;
269 }
270
271 static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
272                                     const void *val, size_t val_count)
273 {
274         WARN_ONCE(1, "regmap API is disabled");
275         return -EINVAL;
276 }
277
278 static inline int regmap_read(struct regmap *map, unsigned int reg,
279                               unsigned int *val)
280 {
281         WARN_ONCE(1, "regmap API is disabled");
282         return -EINVAL;
283 }
284
285 static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
286                                   void *val, size_t val_len)
287 {
288         WARN_ONCE(1, "regmap API is disabled");
289         return -EINVAL;
290 }
291
292 static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
293                                    void *val, size_t val_count)
294 {
295         WARN_ONCE(1, "regmap API is disabled");
296         return -EINVAL;
297 }
298
299 static inline int regmap_update_bits(struct regmap *map, unsigned int reg,
300                                      unsigned int mask, unsigned int val)
301 {
302         WARN_ONCE(1, "regmap API is disabled");
303         return -EINVAL;
304 }
305
306 static inline int regmap_update_bits_check(struct regmap *map,
307                                            unsigned int reg,
308                                            unsigned int mask, unsigned int val,
309                                            bool *change)
310 {
311         WARN_ONCE(1, "regmap API is disabled");
312         return -EINVAL;
313 }
314
315 static inline int regmap_get_val_bytes(struct regmap *map)
316 {
317         WARN_ONCE(1, "regmap API is disabled");
318         return -EINVAL;
319 }
320
321 static inline int regcache_sync(struct regmap *map)
322 {
323         WARN_ONCE(1, "regmap API is disabled");
324         return -EINVAL;
325 }
326
327 static inline int regcache_sync_region(struct regmap *map, unsigned int min,
328                                        unsigned int max)
329 {
330         WARN_ONCE(1, "regmap API is disabled");
331         return -EINVAL;
332 }
333
334 static inline void regcache_cache_only(struct regmap *map, bool enable)
335 {
336         WARN_ONCE(1, "regmap API is disabled");
337 }
338
339 static inline void regcache_cache_bypass(struct regmap *map, bool enable)
340 {
341         WARN_ONCE(1, "regmap API is disabled");
342 }
343
344 static inline void regcache_mark_dirty(struct regmap *map)
345 {
346         WARN_ONCE(1, "regmap API is disabled");
347 }
348
349 static inline int regmap_register_patch(struct regmap *map,
350                                         const struct reg_default *regs,
351                                         int num_regs)
352 {
353         WARN_ONCE(1, "regmap API is disabled");
354         return -EINVAL;
355 }
356
357 #endif
358
359 #endif