regmap: Add hardware spinlock support
[muen/linux.git] / drivers / base / regmap / internal.h
1 /*
2  * Register map access API internal header
3  *
4  * Copyright 2011 Wolfson Microelectronics plc
5  *
6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12
13 #ifndef _REGMAP_INTERNAL_H
14 #define _REGMAP_INTERNAL_H
15
16 #include <linux/device.h>
17 #include <linux/regmap.h>
18 #include <linux/fs.h>
19 #include <linux/list.h>
20 #include <linux/wait.h>
21
22 struct regmap;
23 struct regcache_ops;
24
25 struct regmap_debugfs_off_cache {
26         struct list_head list;
27         off_t min;
28         off_t max;
29         unsigned int base_reg;
30         unsigned int max_reg;
31 };
32
33 struct regmap_format {
34         size_t buf_size;
35         size_t reg_bytes;
36         size_t pad_bytes;
37         size_t val_bytes;
38         void (*format_write)(struct regmap *map,
39                              unsigned int reg, unsigned int val);
40         void (*format_reg)(void *buf, unsigned int reg, unsigned int shift);
41         void (*format_val)(void *buf, unsigned int val, unsigned int shift);
42         unsigned int (*parse_val)(const void *buf);
43         void (*parse_inplace)(void *buf);
44 };
45
46 struct regmap_async {
47         struct list_head list;
48         struct regmap *map;
49         void *work_buf;
50 };
51
52 struct regmap {
53         union {
54                 struct mutex mutex;
55                 struct {
56                         spinlock_t spinlock;
57                         unsigned long spinlock_flags;
58                 };
59         };
60         regmap_lock lock;
61         regmap_unlock unlock;
62         void *lock_arg; /* This is passed to lock/unlock functions */
63         gfp_t alloc_flags;
64
65         struct device *dev; /* Device we do I/O on */
66         void *work_buf;     /* Scratch buffer used to format I/O */
67         struct regmap_format format;  /* Buffer format */
68         const struct regmap_bus *bus;
69         void *bus_context;
70         const char *name;
71
72         bool async;
73         spinlock_t async_lock;
74         wait_queue_head_t async_waitq;
75         struct list_head async_list;
76         struct list_head async_free;
77         int async_ret;
78
79 #ifdef CONFIG_DEBUG_FS
80         struct dentry *debugfs;
81         const char *debugfs_name;
82
83         unsigned int debugfs_reg_len;
84         unsigned int debugfs_val_len;
85         unsigned int debugfs_tot_len;
86
87         struct list_head debugfs_off_cache;
88         struct mutex cache_lock;
89 #endif
90
91         unsigned int max_register;
92         bool (*writeable_reg)(struct device *dev, unsigned int reg);
93         bool (*readable_reg)(struct device *dev, unsigned int reg);
94         bool (*volatile_reg)(struct device *dev, unsigned int reg);
95         bool (*precious_reg)(struct device *dev, unsigned int reg);
96         const struct regmap_access_table *wr_table;
97         const struct regmap_access_table *rd_table;
98         const struct regmap_access_table *volatile_table;
99         const struct regmap_access_table *precious_table;
100
101         int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
102         int (*reg_write)(void *context, unsigned int reg, unsigned int val);
103         int (*reg_update_bits)(void *context, unsigned int reg,
104                                unsigned int mask, unsigned int val);
105
106         bool defer_caching;
107
108         unsigned long read_flag_mask;
109         unsigned long write_flag_mask;
110
111         /* number of bits to (left) shift the reg value when formatting*/
112         int reg_shift;
113         int reg_stride;
114         int reg_stride_order;
115
116         /* regcache specific members */
117         const struct regcache_ops *cache_ops;
118         enum regcache_type cache_type;
119
120         /* number of bytes in reg_defaults_raw */
121         unsigned int cache_size_raw;
122         /* number of bytes per word in reg_defaults_raw */
123         unsigned int cache_word_size;
124         /* number of entries in reg_defaults */
125         unsigned int num_reg_defaults;
126         /* number of entries in reg_defaults_raw */
127         unsigned int num_reg_defaults_raw;
128
129         /* if set, only the cache is modified not the HW */
130         bool cache_only;
131         /* if set, only the HW is modified not the cache */
132         bool cache_bypass;
133         /* if set, remember to free reg_defaults_raw */
134         bool cache_free;
135
136         struct reg_default *reg_defaults;
137         const void *reg_defaults_raw;
138         void *cache;
139         /* if set, the cache contains newer data than the HW */
140         bool cache_dirty;
141         /* if set, the HW registers are known to match map->reg_defaults */
142         bool no_sync_defaults;
143
144         struct reg_sequence *patch;
145         int patch_regs;
146
147         /* if set, converts bulk read to single read */
148         bool use_single_read;
149         /* if set, converts bulk read to single read */
150         bool use_single_write;
151         /* if set, the device supports multi write mode */
152         bool can_multi_write;
153
154         /* if set, raw reads/writes are limited to this size */
155         size_t max_raw_read;
156         size_t max_raw_write;
157
158         struct rb_root range_tree;
159         void *selector_work_buf;        /* Scratch buffer used for selector */
160
161         struct hwspinlock *hwlock;
162 };
163
164 struct regcache_ops {
165         const char *name;
166         enum regcache_type type;
167         int (*init)(struct regmap *map);
168         int (*exit)(struct regmap *map);
169 #ifdef CONFIG_DEBUG_FS
170         void (*debugfs_init)(struct regmap *map);
171 #endif
172         int (*read)(struct regmap *map, unsigned int reg, unsigned int *value);
173         int (*write)(struct regmap *map, unsigned int reg, unsigned int value);
174         int (*sync)(struct regmap *map, unsigned int min, unsigned int max);
175         int (*drop)(struct regmap *map, unsigned int min, unsigned int max);
176 };
177
178 bool regmap_cached(struct regmap *map, unsigned int reg);
179 bool regmap_writeable(struct regmap *map, unsigned int reg);
180 bool regmap_readable(struct regmap *map, unsigned int reg);
181 bool regmap_volatile(struct regmap *map, unsigned int reg);
182 bool regmap_precious(struct regmap *map, unsigned int reg);
183
184 int _regmap_write(struct regmap *map, unsigned int reg,
185                   unsigned int val);
186
187 struct regmap_range_node {
188         struct rb_node node;
189         const char *name;
190         struct regmap *map;
191
192         unsigned int range_min;
193         unsigned int range_max;
194
195         unsigned int selector_reg;
196         unsigned int selector_mask;
197         int selector_shift;
198
199         unsigned int window_start;
200         unsigned int window_len;
201 };
202
203 struct regmap_field {
204         struct regmap *regmap;
205         unsigned int mask;
206         /* lsb */
207         unsigned int shift;
208         unsigned int reg;
209
210         unsigned int id_size;
211         unsigned int id_offset;
212 };
213
214 #ifdef CONFIG_DEBUG_FS
215 extern void regmap_debugfs_initcall(void);
216 extern void regmap_debugfs_init(struct regmap *map, const char *name);
217 extern void regmap_debugfs_exit(struct regmap *map);
218 #else
219 static inline void regmap_debugfs_initcall(void) { }
220 static inline void regmap_debugfs_init(struct regmap *map, const char *name) { }
221 static inline void regmap_debugfs_exit(struct regmap *map) { }
222 #endif
223
224 /* regcache core declarations */
225 int regcache_init(struct regmap *map, const struct regmap_config *config);
226 void regcache_exit(struct regmap *map);
227 int regcache_read(struct regmap *map,
228                        unsigned int reg, unsigned int *value);
229 int regcache_write(struct regmap *map,
230                         unsigned int reg, unsigned int value);
231 int regcache_sync(struct regmap *map);
232 int regcache_sync_block(struct regmap *map, void *block,
233                         unsigned long *cache_present,
234                         unsigned int block_base, unsigned int start,
235                         unsigned int end);
236
237 static inline const void *regcache_get_val_addr(struct regmap *map,
238                                                 const void *base,
239                                                 unsigned int idx)
240 {
241         return base + (map->cache_word_size * idx);
242 }
243
244 unsigned int regcache_get_val(struct regmap *map, const void *base,
245                               unsigned int idx);
246 bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,
247                       unsigned int val);
248 int regcache_lookup_reg(struct regmap *map, unsigned int reg);
249
250 int _regmap_raw_write(struct regmap *map, unsigned int reg,
251                       const void *val, size_t val_len);
252
253 void regmap_async_complete_cb(struct regmap_async *async, int ret);
254
255 enum regmap_endian regmap_get_val_endian(struct device *dev,
256                                          const struct regmap_bus *bus,
257                                          const struct regmap_config *config);
258
259 extern struct regcache_ops regcache_rbtree_ops;
260 extern struct regcache_ops regcache_lzo_ops;
261 extern struct regcache_ops regcache_flat_ops;
262
263 static inline const char *regmap_name(const struct regmap *map)
264 {
265         if (map->dev)
266                 return dev_name(map->dev);
267
268         return map->name;
269 }
270
271 static inline unsigned int regmap_get_offset(const struct regmap *map,
272                                              unsigned int index)
273 {
274         if (map->reg_stride_order >= 0)
275                 return index << map->reg_stride_order;
276         else
277                 return index * map->reg_stride;
278 }
279
280 static inline unsigned int regcache_get_index_by_order(const struct regmap *map,
281                                                        unsigned int reg)
282 {
283         return reg >> map->reg_stride_order;
284 }
285
286 #endif