Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit a6539c32949063c8147905512a83a98842c2d254

Authored by Mark Brown
1 parent b01543dfe6
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

regmap: Allow users to query the size of register values 

Generic infrastructure based on top of regmap may want to operate on
blocks of data and therefore find it useful to find the size of the
register values. Provide an accessor operation for this.

Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>

Showing 2 changed files with 16 additions and 0 deletions Inline Diff

drivers/base/regmap/regmap.c
Diff comments   View file @ a6539c3
1 /* 1 /*
2 * Register map access API 2 * Register map access API
3 * 3 *
4 * Copyright 2011 Wolfson Microelectronics plc 4 * Copyright 2011 Wolfson Microelectronics plc
5 * 5 *
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 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 9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation. 10 * published by the Free Software Foundation.
11 */ 11 */
12 12
13 #include <linux/slab.h> 13 #include <linux/slab.h>
14 #include <linux/module.h> 14 #include <linux/module.h>
15 #include <linux/mutex.h> 15 #include <linux/mutex.h>
16 #include <linux/err.h> 16 #include <linux/err.h>
17 17
18 #define CREATE_TRACE_POINTS 18 #define CREATE_TRACE_POINTS
19 #include <trace/events/regmap.h> 19 #include <trace/events/regmap.h>
20 20
21 #include "internal.h" 21 #include "internal.h"
22 22
23 bool regmap_writeable(struct regmap *map, unsigned int reg) 23 bool regmap_writeable(struct regmap *map, unsigned int reg)
24 { 24 {
25 if (map->max_register && reg > map->max_register) 25 if (map->max_register && reg > map->max_register)
26 return false; 26 return false;
27 27
28 if (map->writeable_reg) 28 if (map->writeable_reg)
29 return map->writeable_reg(map->dev, reg); 29 return map->writeable_reg(map->dev, reg);
30 30
31 return true; 31 return true;
32 } 32 }
33 33
34 bool regmap_readable(struct regmap *map, unsigned int reg) 34 bool regmap_readable(struct regmap *map, unsigned int reg)
35 { 35 {
36 if (map->max_register && reg > map->max_register) 36 if (map->max_register && reg > map->max_register)
37 return false; 37 return false;
38 38
39 if (map->readable_reg) 39 if (map->readable_reg)
40 return map->readable_reg(map->dev, reg); 40 return map->readable_reg(map->dev, reg);
41 41
42 return true; 42 return true;
43 } 43 }
44 44
45 bool regmap_volatile(struct regmap *map, unsigned int reg) 45 bool regmap_volatile(struct regmap *map, unsigned int reg)
46 { 46 {
47 if (map->max_register && reg > map->max_register) 47 if (map->max_register && reg > map->max_register)
48 return false; 48 return false;
49 49
50 if (map->volatile_reg) 50 if (map->volatile_reg)
51 return map->volatile_reg(map->dev, reg); 51 return map->volatile_reg(map->dev, reg);
52 52
53 return true; 53 return true;
54 } 54 }
55 55
56 bool regmap_precious(struct regmap *map, unsigned int reg) 56 bool regmap_precious(struct regmap *map, unsigned int reg)
57 { 57 {
58 if (map->max_register && reg > map->max_register) 58 if (map->max_register && reg > map->max_register)
59 return false; 59 return false;
60 60
61 if (map->precious_reg) 61 if (map->precious_reg)
62 return map->precious_reg(map->dev, reg); 62 return map->precious_reg(map->dev, reg);
63 63
64 return false; 64 return false;
65 } 65 }
66 66
67 static bool regmap_volatile_range(struct regmap *map, unsigned int reg, 67 static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
68 unsigned int num) 68 unsigned int num)
69 { 69 {
70 unsigned int i; 70 unsigned int i;
71 71
72 for (i = 0; i < num; i++) 72 for (i = 0; i < num; i++)
73 if (!regmap_volatile(map, reg + i)) 73 if (!regmap_volatile(map, reg + i))
74 return false; 74 return false;
75 75
76 return true; 76 return true;
77 } 77 }
78 78
79 static void regmap_format_4_12_write(struct regmap *map, 79 static void regmap_format_4_12_write(struct regmap *map,
80 unsigned int reg, unsigned int val) 80 unsigned int reg, unsigned int val)
81 { 81 {
82 __be16 *out = map->work_buf; 82 __be16 *out = map->work_buf;
83 *out = cpu_to_be16((reg << 12) | val); 83 *out = cpu_to_be16((reg << 12) | val);
84 } 84 }
85 85
86 static void regmap_format_7_9_write(struct regmap *map, 86 static void regmap_format_7_9_write(struct regmap *map,
87 unsigned int reg, unsigned int val) 87 unsigned int reg, unsigned int val)
88 { 88 {
89 __be16 *out = map->work_buf; 89 __be16 *out = map->work_buf;
90 *out = cpu_to_be16((reg << 9) | val); 90 *out = cpu_to_be16((reg << 9) | val);
91 } 91 }
92 92
93 static void regmap_format_10_14_write(struct regmap *map, 93 static void regmap_format_10_14_write(struct regmap *map,
94 unsigned int reg, unsigned int val) 94 unsigned int reg, unsigned int val)
95 { 95 {
96 u8 *out = map->work_buf; 96 u8 *out = map->work_buf;
97 97
98 out[2] = val; 98 out[2] = val;
99 out[1] = (val >> 8) | (reg << 6); 99 out[1] = (val >> 8) | (reg << 6);
100 out[0] = reg >> 2; 100 out[0] = reg >> 2;
101 } 101 }
102 102
103 static void regmap_format_8(void *buf, unsigned int val) 103 static void regmap_format_8(void *buf, unsigned int val)
104 { 104 {
105 u8 *b = buf; 105 u8 *b = buf;
106 106
107 b[0] = val; 107 b[0] = val;
108 } 108 }
109 109
110 static void regmap_format_16(void *buf, unsigned int val) 110 static void regmap_format_16(void *buf, unsigned int val)
111 { 111 {
112 __be16 *b = buf; 112 __be16 *b = buf;
113 113
114 b[0] = cpu_to_be16(val); 114 b[0] = cpu_to_be16(val);
115 } 115 }
116 116
117 static unsigned int regmap_parse_8(void *buf) 117 static unsigned int regmap_parse_8(void *buf)
118 { 118 {
119 u8 *b = buf; 119 u8 *b = buf;
120 120
121 return b[0]; 121 return b[0];
122 } 122 }
123 123
124 static unsigned int regmap_parse_16(void *buf) 124 static unsigned int regmap_parse_16(void *buf)
125 { 125 {
126 __be16 *b = buf; 126 __be16 *b = buf;
127 127
128 b[0] = be16_to_cpu(b[0]); 128 b[0] = be16_to_cpu(b[0]);
129 129
130 return b[0]; 130 return b[0];
131 } 131 }
132 132
133 /** 133 /**
134 * regmap_init(): Initialise register map 134 * regmap_init(): Initialise register map
135 * 135 *
136 * @dev: Device that will be interacted with 136 * @dev: Device that will be interacted with
137 * @bus: Bus-specific callbacks to use with device 137 * @bus: Bus-specific callbacks to use with device
138 * @config: Configuration for register map 138 * @config: Configuration for register map
139 * 139 *
140 * The return value will be an ERR_PTR() on error or a valid pointer to 140 * The return value will be an ERR_PTR() on error or a valid pointer to
141 * a struct regmap. This function should generally not be called 141 * a struct regmap. This function should generally not be called
142 * directly, it should be called by bus-specific init functions. 142 * directly, it should be called by bus-specific init functions.
143 */ 143 */
144 struct regmap *regmap_init(struct device *dev, 144 struct regmap *regmap_init(struct device *dev,
145 const struct regmap_bus *bus, 145 const struct regmap_bus *bus,
146 const struct regmap_config *config) 146 const struct regmap_config *config)
147 { 147 {
148 struct regmap *map; 148 struct regmap *map;
149 int ret = -EINVAL; 149 int ret = -EINVAL;
150 150
151 if (!bus || !config) 151 if (!bus || !config)
152 goto err; 152 goto err;
153 153
154 map = kzalloc(sizeof(*map), GFP_KERNEL); 154 map = kzalloc(sizeof(*map), GFP_KERNEL);
155 if (map == NULL) { 155 if (map == NULL) {
156 ret = -ENOMEM; 156 ret = -ENOMEM;
157 goto err; 157 goto err;
158 } 158 }
159 159
160 mutex_init(&map->lock); 160 mutex_init(&map->lock);
161 map->format.buf_size = (config->reg_bits + config->val_bits) / 8; 161 map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
162 map->format.reg_bytes = config->reg_bits / 8; 162 map->format.reg_bytes = config->reg_bits / 8;
163 map->format.val_bytes = config->val_bits / 8; 163 map->format.val_bytes = config->val_bits / 8;
164 map->dev = dev; 164 map->dev = dev;
165 map->bus = bus; 165 map->bus = bus;
166 map->max_register = config->max_register; 166 map->max_register = config->max_register;
167 map->writeable_reg = config->writeable_reg; 167 map->writeable_reg = config->writeable_reg;
168 map->readable_reg = config->readable_reg; 168 map->readable_reg = config->readable_reg;
169 map->volatile_reg = config->volatile_reg; 169 map->volatile_reg = config->volatile_reg;
170 map->precious_reg = config->precious_reg; 170 map->precious_reg = config->precious_reg;
171 map->cache_type = config->cache_type; 171 map->cache_type = config->cache_type;
172 172
173 if (config->read_flag_mask || config->write_flag_mask) { 173 if (config->read_flag_mask || config->write_flag_mask) {
174 map->read_flag_mask = config->read_flag_mask; 174 map->read_flag_mask = config->read_flag_mask;
175 map->write_flag_mask = config->write_flag_mask; 175 map->write_flag_mask = config->write_flag_mask;
176 } else { 176 } else {
177 map->read_flag_mask = bus->read_flag_mask; 177 map->read_flag_mask = bus->read_flag_mask;
178 } 178 }
179 179
180 switch (config->reg_bits) { 180 switch (config->reg_bits) {
181 case 4: 181 case 4:
182 switch (config->val_bits) { 182 switch (config->val_bits) {
183 case 12: 183 case 12:
184 map->format.format_write = regmap_format_4_12_write; 184 map->format.format_write = regmap_format_4_12_write;
185 break; 185 break;
186 default: 186 default:
187 goto err_map; 187 goto err_map;
188 } 188 }
189 break; 189 break;
190 190
191 case 7: 191 case 7:
192 switch (config->val_bits) { 192 switch (config->val_bits) {
193 case 9: 193 case 9:
194 map->format.format_write = regmap_format_7_9_write; 194 map->format.format_write = regmap_format_7_9_write;
195 break; 195 break;
196 default: 196 default:
197 goto err_map; 197 goto err_map;
198 } 198 }
199 break; 199 break;
200 200
201 case 10: 201 case 10:
202 switch (config->val_bits) { 202 switch (config->val_bits) {
203 case 14: 203 case 14:
204 map->format.format_write = regmap_format_10_14_write; 204 map->format.format_write = regmap_format_10_14_write;
205 break; 205 break;
206 default: 206 default:
207 goto err_map; 207 goto err_map;
208 } 208 }
209 break; 209 break;
210 210
211 case 8: 211 case 8:
212 map->format.format_reg = regmap_format_8; 212 map->format.format_reg = regmap_format_8;
213 break; 213 break;
214 214
215 case 16: 215 case 16:
216 map->format.format_reg = regmap_format_16; 216 map->format.format_reg = regmap_format_16;
217 break; 217 break;
218 218
219 default: 219 default:
220 goto err_map; 220 goto err_map;
221 } 221 }
222 222
223 switch (config->val_bits) { 223 switch (config->val_bits) {
224 case 8: 224 case 8:
225 map->format.format_val = regmap_format_8; 225 map->format.format_val = regmap_format_8;
226 map->format.parse_val = regmap_parse_8; 226 map->format.parse_val = regmap_parse_8;
227 break; 227 break;
228 case 16: 228 case 16:
229 map->format.format_val = regmap_format_16; 229 map->format.format_val = regmap_format_16;
230 map->format.parse_val = regmap_parse_16; 230 map->format.parse_val = regmap_parse_16;
231 break; 231 break;
232 } 232 }
233 233
234 if (!map->format.format_write && 234 if (!map->format.format_write &&
235 !(map->format.format_reg && map->format.format_val)) 235 !(map->format.format_reg && map->format.format_val))
236 goto err_map; 236 goto err_map;
237 237
238 map->work_buf = kmalloc(map->format.buf_size, GFP_KERNEL); 238 map->work_buf = kmalloc(map->format.buf_size, GFP_KERNEL);
239 if (map->work_buf == NULL) { 239 if (map->work_buf == NULL) {
240 ret = -ENOMEM; 240 ret = -ENOMEM;
241 goto err_map; 241 goto err_map;
242 } 242 }
243 243
244 regmap_debugfs_init(map); 244 regmap_debugfs_init(map);
245 245
246 ret = regcache_init(map, config); 246 ret = regcache_init(map, config);
247 if (ret < 0) 247 if (ret < 0)
248 goto err_free_workbuf; 248 goto err_free_workbuf;
249 249
250 return map; 250 return map;
251 251
252 err_free_workbuf: 252 err_free_workbuf:
253 kfree(map->work_buf); 253 kfree(map->work_buf);
254 err_map: 254 err_map:
255 kfree(map); 255 kfree(map);
256 err: 256 err:
257 return ERR_PTR(ret); 257 return ERR_PTR(ret);
258 } 258 }
259 EXPORT_SYMBOL_GPL(regmap_init); 259 EXPORT_SYMBOL_GPL(regmap_init);
260 260
261 /** 261 /**
262 * regmap_reinit_cache(): Reinitialise the current register cache 262 * regmap_reinit_cache(): Reinitialise the current register cache
263 * 263 *
264 * @map: Register map to operate on. 264 * @map: Register map to operate on.
265 * @config: New configuration. Only the cache data will be used. 265 * @config: New configuration. Only the cache data will be used.
266 * 266 *
267 * Discard any existing register cache for the map and initialize a 267 * Discard any existing register cache for the map and initialize a
268 * new cache. This can be used to restore the cache to defaults or to 268 * new cache. This can be used to restore the cache to defaults or to
269 * update the cache configuration to reflect runtime discovery of the 269 * update the cache configuration to reflect runtime discovery of the
270 * hardware. 270 * hardware.
271 */ 271 */
272 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config) 272 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
273 { 273 {
274 int ret; 274 int ret;
275 275
276 mutex_lock(&map->lock); 276 mutex_lock(&map->lock);
277 277
278 regcache_exit(map); 278 regcache_exit(map);
279 279
280 map->max_register = config->max_register; 280 map->max_register = config->max_register;
281 map->writeable_reg = config->writeable_reg; 281 map->writeable_reg = config->writeable_reg;
282 map->readable_reg = config->readable_reg; 282 map->readable_reg = config->readable_reg;
283 map->volatile_reg = config->volatile_reg; 283 map->volatile_reg = config->volatile_reg;
284 map->precious_reg = config->precious_reg; 284 map->precious_reg = config->precious_reg;
285 map->cache_type = config->cache_type; 285 map->cache_type = config->cache_type;
286 286
287 map->cache_bypass = false; 287 map->cache_bypass = false;
288 map->cache_only = false; 288 map->cache_only = false;
289 289
290 ret = regcache_init(map, config); 290 ret = regcache_init(map, config);
291 291
292 mutex_unlock(&map->lock); 292 mutex_unlock(&map->lock);
293 293
294 return ret; 294 return ret;
295 } 295 }
296 296
297 /** 297 /**
298 * regmap_exit(): Free a previously allocated register map 298 * regmap_exit(): Free a previously allocated register map
299 */ 299 */
300 void regmap_exit(struct regmap *map) 300 void regmap_exit(struct regmap *map)
301 { 301 {
302 regcache_exit(map); 302 regcache_exit(map);
303 regmap_debugfs_exit(map); 303 regmap_debugfs_exit(map);
304 kfree(map->work_buf); 304 kfree(map->work_buf);
305 kfree(map); 305 kfree(map);
306 } 306 }
307 EXPORT_SYMBOL_GPL(regmap_exit); 307 EXPORT_SYMBOL_GPL(regmap_exit);
308 308
309 static int _regmap_raw_write(struct regmap *map, unsigned int reg, 309 static int _regmap_raw_write(struct regmap *map, unsigned int reg,
310 const void *val, size_t val_len) 310 const void *val, size_t val_len)
311 { 311 {
312 u8 *u8 = map->work_buf; 312 u8 *u8 = map->work_buf;
313 void *buf; 313 void *buf;
314 int ret = -ENOTSUPP; 314 int ret = -ENOTSUPP;
315 size_t len; 315 size_t len;
316 int i; 316 int i;
317 317
318 /* Check for unwritable registers before we start */ 318 /* Check for unwritable registers before we start */
319 if (map->writeable_reg) 319 if (map->writeable_reg)
320 for (i = 0; i < val_len / map->format.val_bytes; i++) 320 for (i = 0; i < val_len / map->format.val_bytes; i++)
321 if (!map->writeable_reg(map->dev, reg + i)) 321 if (!map->writeable_reg(map->dev, reg + i))
322 return -EINVAL; 322 return -EINVAL;
323 323
324 map->format.format_reg(map->work_buf, reg); 324 map->format.format_reg(map->work_buf, reg);
325 325
326 u8[0] |= map->write_flag_mask; 326 u8[0] |= map->write_flag_mask;
327 327
328 trace_regmap_hw_write_start(map->dev, reg, 328 trace_regmap_hw_write_start(map->dev, reg,
329 val_len / map->format.val_bytes); 329 val_len / map->format.val_bytes);
330 330
331 /* If we're doing a single register write we can probably just 331 /* If we're doing a single register write we can probably just
332 * send the work_buf directly, otherwise try to do a gather 332 * send the work_buf directly, otherwise try to do a gather
333 * write. 333 * write.
334 */ 334 */
335 if (val == map->work_buf + map->format.reg_bytes) 335 if (val == map->work_buf + map->format.reg_bytes)
336 ret = map->bus->write(map->dev, map->work_buf, 336 ret = map->bus->write(map->dev, map->work_buf,
337 map->format.reg_bytes + val_len); 337 map->format.reg_bytes + val_len);
338 else if (map->bus->gather_write) 338 else if (map->bus->gather_write)
339 ret = map->bus->gather_write(map->dev, map->work_buf, 339 ret = map->bus->gather_write(map->dev, map->work_buf,
340 map->format.reg_bytes, 340 map->format.reg_bytes,
341 val, val_len); 341 val, val_len);
342 342
343 /* If that didn't work fall back on linearising by hand. */ 343 /* If that didn't work fall back on linearising by hand. */
344 if (ret == -ENOTSUPP) { 344 if (ret == -ENOTSUPP) {
345 len = map->format.reg_bytes + val_len; 345 len = map->format.reg_bytes + val_len;
346 buf = kmalloc(len, GFP_KERNEL); 346 buf = kmalloc(len, GFP_KERNEL);
347 if (!buf) 347 if (!buf)
348 return -ENOMEM; 348 return -ENOMEM;
349 349
350 memcpy(buf, map->work_buf, map->format.reg_bytes); 350 memcpy(buf, map->work_buf, map->format.reg_bytes);
351 memcpy(buf + map->format.reg_bytes, val, val_len); 351 memcpy(buf + map->format.reg_bytes, val, val_len);
352 ret = map->bus->write(map->dev, buf, len); 352 ret = map->bus->write(map->dev, buf, len);
353 353
354 kfree(buf); 354 kfree(buf);
355 } 355 }
356 356
357 trace_regmap_hw_write_done(map->dev, reg, 357 trace_regmap_hw_write_done(map->dev, reg,
358 val_len / map->format.val_bytes); 358 val_len / map->format.val_bytes);
359 359
360 return ret; 360 return ret;
361 } 361 }
362 362
363 int _regmap_write(struct regmap *map, unsigned int reg, 363 int _regmap_write(struct regmap *map, unsigned int reg,
364 unsigned int val) 364 unsigned int val)
365 { 365 {
366 int ret; 366 int ret;
367 BUG_ON(!map->format.format_write && !map->format.format_val); 367 BUG_ON(!map->format.format_write && !map->format.format_val);
368 368
369 if (!map->cache_bypass) { 369 if (!map->cache_bypass) {
370 ret = regcache_write(map, reg, val); 370 ret = regcache_write(map, reg, val);
371 if (ret != 0) 371 if (ret != 0)
372 return ret; 372 return ret;
373 if (map->cache_only) { 373 if (map->cache_only) {
374 map->cache_dirty = true; 374 map->cache_dirty = true;
375 return 0; 375 return 0;
376 } 376 }
377 } 377 }
378 378
379 trace_regmap_reg_write(map->dev, reg, val); 379 trace_regmap_reg_write(map->dev, reg, val);
380 380
381 if (map->format.format_write) { 381 if (map->format.format_write) {
382 map->format.format_write(map, reg, val); 382 map->format.format_write(map, reg, val);
383 383
384 trace_regmap_hw_write_start(map->dev, reg, 1); 384 trace_regmap_hw_write_start(map->dev, reg, 1);
385 385
386 ret = map->bus->write(map->dev, map->work_buf, 386 ret = map->bus->write(map->dev, map->work_buf,
387 map->format.buf_size); 387 map->format.buf_size);
388 388
389 trace_regmap_hw_write_done(map->dev, reg, 1); 389 trace_regmap_hw_write_done(map->dev, reg, 1);
390 390
391 return ret; 391 return ret;
392 } else { 392 } else {
393 map->format.format_val(map->work_buf + map->format.reg_bytes, 393 map->format.format_val(map->work_buf + map->format.reg_bytes,
394 val); 394 val);
395 return _regmap_raw_write(map, reg, 395 return _regmap_raw_write(map, reg,
396 map->work_buf + map->format.reg_bytes, 396 map->work_buf + map->format.reg_bytes,
397 map->format.val_bytes); 397 map->format.val_bytes);
398 } 398 }
399 } 399 }
400 400
401 /** 401 /**
402 * regmap_write(): Write a value to a single register 402 * regmap_write(): Write a value to a single register
403 * 403 *
404 * @map: Register map to write to 404 * @map: Register map to write to
405 * @reg: Register to write to 405 * @reg: Register to write to
406 * @val: Value to be written 406 * @val: Value to be written
407 * 407 *
408 * A value of zero will be returned on success, a negative errno will 408 * A value of zero will be returned on success, a negative errno will
409 * be returned in error cases. 409 * be returned in error cases.
410 */ 410 */
411 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val) 411 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
412 { 412 {
413 int ret; 413 int ret;
414 414
415 mutex_lock(&map->lock); 415 mutex_lock(&map->lock);
416 416
417 ret = _regmap_write(map, reg, val); 417 ret = _regmap_write(map, reg, val);
418 418
419 mutex_unlock(&map->lock); 419 mutex_unlock(&map->lock);
420 420
421 return ret; 421 return ret;
422 } 422 }
423 EXPORT_SYMBOL_GPL(regmap_write); 423 EXPORT_SYMBOL_GPL(regmap_write);
424 424
425 /** 425 /**
426 * regmap_raw_write(): Write raw values to one or more registers 426 * regmap_raw_write(): Write raw values to one or more registers
427 * 427 *
428 * @map: Register map to write to 428 * @map: Register map to write to
429 * @reg: Initial register to write to 429 * @reg: Initial register to write to
430 * @val: Block of data to be written, laid out for direct transmission to the 430 * @val: Block of data to be written, laid out for direct transmission to the
431 * device 431 * device
432 * @val_len: Length of data pointed to by val. 432 * @val_len: Length of data pointed to by val.
433 * 433 *
434 * This function is intended to be used for things like firmware 434 * This function is intended to be used for things like firmware
435 * download where a large block of data needs to be transferred to the 435 * download where a large block of data needs to be transferred to the
436 * device. No formatting will be done on the data provided. 436 * device. No formatting will be done on the data provided.
437 * 437 *
438 * A value of zero will be returned on success, a negative errno will 438 * A value of zero will be returned on success, a negative errno will
439 * be returned in error cases. 439 * be returned in error cases.
440 */ 440 */
441 int regmap_raw_write(struct regmap *map, unsigned int reg, 441 int regmap_raw_write(struct regmap *map, unsigned int reg,
442 const void *val, size_t val_len) 442 const void *val, size_t val_len)
443 { 443 {
444 size_t val_count = val_len / map->format.val_bytes; 444 size_t val_count = val_len / map->format.val_bytes;
445 int ret; 445 int ret;
446 446
447 WARN_ON(!regmap_volatile_range(map, reg, val_count) && 447 WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
448 map->cache_type != REGCACHE_NONE); 448 map->cache_type != REGCACHE_NONE);
449 449
450 mutex_lock(&map->lock); 450 mutex_lock(&map->lock);
451 451
452 ret = _regmap_raw_write(map, reg, val, val_len); 452 ret = _regmap_raw_write(map, reg, val, val_len);
453 453
454 mutex_unlock(&map->lock); 454 mutex_unlock(&map->lock);
455 455
456 return ret; 456 return ret;
457 } 457 }
458 EXPORT_SYMBOL_GPL(regmap_raw_write); 458 EXPORT_SYMBOL_GPL(regmap_raw_write);
459 459
460 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val, 460 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
461 unsigned int val_len) 461 unsigned int val_len)
462 { 462 {
463 u8 *u8 = map->work_buf; 463 u8 *u8 = map->work_buf;
464 int ret; 464 int ret;
465 465
466 map->format.format_reg(map->work_buf, reg); 466 map->format.format_reg(map->work_buf, reg);
467 467
468 /* 468 /*
469 * Some buses or devices flag reads by setting the high bits in the 469 * Some buses or devices flag reads by setting the high bits in the
470 * register addresss; since it's always the high bits for all 470 * register addresss; since it's always the high bits for all
471 * current formats we can do this here rather than in 471 * current formats we can do this here rather than in
472 * formatting. This may break if we get interesting formats. 472 * formatting. This may break if we get interesting formats.
473 */ 473 */
474 u8[0] |= map->read_flag_mask; 474 u8[0] |= map->read_flag_mask;
475 475
476 trace_regmap_hw_read_start(map->dev, reg, 476 trace_regmap_hw_read_start(map->dev, reg,
477 val_len / map->format.val_bytes); 477 val_len / map->format.val_bytes);
478 478
479 ret = map->bus->read(map->dev, map->work_buf, map->format.reg_bytes, 479 ret = map->bus->read(map->dev, map->work_buf, map->format.reg_bytes,
480 val, val_len); 480 val, val_len);
481 481
482 trace_regmap_hw_read_done(map->dev, reg, 482 trace_regmap_hw_read_done(map->dev, reg,
483 val_len / map->format.val_bytes); 483 val_len / map->format.val_bytes);
484 484
485 return ret; 485 return ret;
486 } 486 }
487 487
488 static int _regmap_read(struct regmap *map, unsigned int reg, 488 static int _regmap_read(struct regmap *map, unsigned int reg,
489 unsigned int *val) 489 unsigned int *val)
490 { 490 {
491 int ret; 491 int ret;
492 492
493 if (!map->cache_bypass) { 493 if (!map->cache_bypass) {
494 ret = regcache_read(map, reg, val); 494 ret = regcache_read(map, reg, val);
495 if (ret == 0) 495 if (ret == 0)
496 return 0; 496 return 0;
497 } 497 }
498 498
499 if (!map->format.parse_val) 499 if (!map->format.parse_val)
500 return -EINVAL; 500 return -EINVAL;
501 501
502 if (map->cache_only) 502 if (map->cache_only)
503 return -EBUSY; 503 return -EBUSY;
504 504
505 ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes); 505 ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
506 if (ret == 0) { 506 if (ret == 0) {
507 *val = map->format.parse_val(map->work_buf); 507 *val = map->format.parse_val(map->work_buf);
508 trace_regmap_reg_read(map->dev, reg, *val); 508 trace_regmap_reg_read(map->dev, reg, *val);
509 } 509 }
510 510
511 return ret; 511 return ret;
512 } 512 }
513 513
514 /** 514 /**
515 * regmap_read(): Read a value from a single register 515 * regmap_read(): Read a value from a single register
516 * 516 *
517 * @map: Register map to write to 517 * @map: Register map to write to
518 * @reg: Register to be read from 518 * @reg: Register to be read from
519 * @val: Pointer to store read value 519 * @val: Pointer to store read value
520 * 520 *
521 * A value of zero will be returned on success, a negative errno will 521 * A value of zero will be returned on success, a negative errno will
522 * be returned in error cases. 522 * be returned in error cases.
523 */ 523 */
524 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val) 524 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
525 { 525 {
526 int ret; 526 int ret;
527 527
528 mutex_lock(&map->lock); 528 mutex_lock(&map->lock);
529 529
530 ret = _regmap_read(map, reg, val); 530 ret = _regmap_read(map, reg, val);
531 531
532 mutex_unlock(&map->lock); 532 mutex_unlock(&map->lock);
533 533
534 return ret; 534 return ret;
535 } 535 }
536 EXPORT_SYMBOL_GPL(regmap_read); 536 EXPORT_SYMBOL_GPL(regmap_read);
537 537
538 /** 538 /**
539 * regmap_raw_read(): Read raw data from the device 539 * regmap_raw_read(): Read raw data from the device
540 * 540 *
541 * @map: Register map to write to 541 * @map: Register map to write to
542 * @reg: First register to be read from 542 * @reg: First register to be read from
543 * @val: Pointer to store read value 543 * @val: Pointer to store read value
544 * @val_len: Size of data to read 544 * @val_len: Size of data to read
545 * 545 *
546 * A value of zero will be returned on success, a negative errno will 546 * A value of zero will be returned on success, a negative errno will
547 * be returned in error cases. 547 * be returned in error cases.
548 */ 548 */
549 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val, 549 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
550 size_t val_len) 550 size_t val_len)
551 { 551 {
552 size_t val_count = val_len / map->format.val_bytes; 552 size_t val_count = val_len / map->format.val_bytes;
553 int ret; 553 int ret;
554 554
555 WARN_ON(!regmap_volatile_range(map, reg, val_count) && 555 WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
556 map->cache_type != REGCACHE_NONE); 556 map->cache_type != REGCACHE_NONE);
557 557
558 mutex_lock(&map->lock); 558 mutex_lock(&map->lock);
559 559
560 ret = _regmap_raw_read(map, reg, val, val_len); 560 ret = _regmap_raw_read(map, reg, val, val_len);
561 561
562 mutex_unlock(&map->lock); 562 mutex_unlock(&map->lock);
563 563
564 return ret; 564 return ret;
565 } 565 }
566 EXPORT_SYMBOL_GPL(regmap_raw_read); 566 EXPORT_SYMBOL_GPL(regmap_raw_read);
567 567
568 /** 568 /**
569 * regmap_bulk_read(): Read multiple registers from the device 569 * regmap_bulk_read(): Read multiple registers from the device
570 * 570 *
571 * @map: Register map to write to 571 * @map: Register map to write to
572 * @reg: First register to be read from 572 * @reg: First register to be read from
573 * @val: Pointer to store read value, in native register size for device 573 * @val: Pointer to store read value, in native register size for device
574 * @val_count: Number of registers to read 574 * @val_count: Number of registers to read
575 * 575 *
576 * A value of zero will be returned on success, a negative errno will 576 * A value of zero will be returned on success, a negative errno will
577 * be returned in error cases. 577 * be returned in error cases.
578 */ 578 */
579 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val, 579 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
580 size_t val_count) 580 size_t val_count)
581 { 581 {
582 int ret, i; 582 int ret, i;
583 size_t val_bytes = map->format.val_bytes; 583 size_t val_bytes = map->format.val_bytes;
584 bool vol = regmap_volatile_range(map, reg, val_count); 584 bool vol = regmap_volatile_range(map, reg, val_count);
585 585
586 if (!map->format.parse_val) 586 if (!map->format.parse_val)
587 return -EINVAL; 587 return -EINVAL;
588 588
589 if (vol || map->cache_type == REGCACHE_NONE) { 589 if (vol || map->cache_type == REGCACHE_NONE) {
590 ret = regmap_raw_read(map, reg, val, val_bytes * val_count); 590 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
591 if (ret != 0) 591 if (ret != 0)
592 return ret; 592 return ret;
593 593
594 for (i = 0; i < val_count * val_bytes; i += val_bytes) 594 for (i = 0; i < val_count * val_bytes; i += val_bytes)
595 map->format.parse_val(val + i); 595 map->format.parse_val(val + i);
596 } else { 596 } else {
597 for (i = 0; i < val_count; i++) { 597 for (i = 0; i < val_count; i++) {
598 ret = regmap_read(map, reg + i, val + (i * val_bytes)); 598 ret = regmap_read(map, reg + i, val + (i * val_bytes));
599 if (ret != 0) 599 if (ret != 0)
600 return ret; 600 return ret;
601 } 601 }
602 } 602 }
603 603
604 return 0; 604 return 0;
605 } 605 }
606 EXPORT_SYMBOL_GPL(regmap_bulk_read); 606 EXPORT_SYMBOL_GPL(regmap_bulk_read);
607 607
608 static int _regmap_update_bits(struct regmap *map, unsigned int reg, 608 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
609 unsigned int mask, unsigned int val, 609 unsigned int mask, unsigned int val,
610 bool *change) 610 bool *change)
611 { 611 {
612 int ret; 612 int ret;
613 unsigned int tmp, orig; 613 unsigned int tmp, orig;
614 614
615 mutex_lock(&map->lock); 615 mutex_lock(&map->lock);
616 616
617 ret = _regmap_read(map, reg, &orig); 617 ret = _regmap_read(map, reg, &orig);
618 if (ret != 0) 618 if (ret != 0)
619 goto out; 619 goto out;
620 620
621 tmp = orig & ~mask; 621 tmp = orig & ~mask;
622 tmp |= val & mask; 622 tmp |= val & mask;
623 623
624 if (tmp != orig) { 624 if (tmp != orig) {
625 ret = _regmap_write(map, reg, tmp); 625 ret = _regmap_write(map, reg, tmp);
626 *change = true; 626 *change = true;
627 } else { 627 } else {
628 *change = false; 628 *change = false;
629 } 629 }
630 630
631 out: 631 out:
632 mutex_unlock(&map->lock); 632 mutex_unlock(&map->lock);
633 633
634 return ret; 634 return ret;
635 } 635 }
636 636
637 /** 637 /**
638 * regmap_update_bits: Perform a read/modify/write cycle on the register map 638 * regmap_update_bits: Perform a read/modify/write cycle on the register map
639 * 639 *
640 * @map: Register map to update 640 * @map: Register map to update
641 * @reg: Register to update 641 * @reg: Register to update
642 * @mask: Bitmask to change 642 * @mask: Bitmask to change
643 * @val: New value for bitmask 643 * @val: New value for bitmask
644 * 644 *
645 * Returns zero for success, a negative number on error. 645 * Returns zero for success, a negative number on error.
646 */ 646 */
647 int regmap_update_bits(struct regmap *map, unsigned int reg, 647 int regmap_update_bits(struct regmap *map, unsigned int reg,
648 unsigned int mask, unsigned int val) 648 unsigned int mask, unsigned int val)
649 { 649 {
650 bool change; 650 bool change;
651 return _regmap_update_bits(map, reg, mask, val, &change); 651 return _regmap_update_bits(map, reg, mask, val, &change);
652 } 652 }
653 EXPORT_SYMBOL_GPL(regmap_update_bits); 653 EXPORT_SYMBOL_GPL(regmap_update_bits);
654 654
655 /** 655 /**
656 * regmap_update_bits_check: Perform a read/modify/write cycle on the 656 * regmap_update_bits_check: Perform a read/modify/write cycle on the
657 * register map and report if updated 657 * register map and report if updated
658 * 658 *
659 * @map: Register map to update 659 * @map: Register map to update
660 * @reg: Register to update 660 * @reg: Register to update
661 * @mask: Bitmask to change 661 * @mask: Bitmask to change
662 * @val: New value for bitmask 662 * @val: New value for bitmask
663 * @change: Boolean indicating if a write was done 663 * @change: Boolean indicating if a write was done
664 * 664 *
665 * Returns zero for success, a negative number on error. 665 * Returns zero for success, a negative number on error.
666 */ 666 */
667 int regmap_update_bits_check(struct regmap *map, unsigned int reg, 667 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
668 unsigned int mask, unsigned int val, 668 unsigned int mask, unsigned int val,
669 bool *change) 669 bool *change)
670 { 670 {
671 return _regmap_update_bits(map, reg, mask, val, change); 671 return _regmap_update_bits(map, reg, mask, val, change);
672 } 672 }
673 EXPORT_SYMBOL_GPL(regmap_update_bits_check); 673 EXPORT_SYMBOL_GPL(regmap_update_bits_check);
674 674
675 /**
676 * regmap_get_val_bytes(): Report the size of a register value
677 *
678 * Report the size of a register value, mainly intended to for use by
679 * generic infrastructure built on top of regmap.
680 */
681 int regmap_get_val_bytes(struct regmap *map)
682 {
683 if (map->format.format_write)
684 return -EINVAL;
685
686 return map->format.val_bytes;
687 }
688 EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
689
675 static int __init regmap_initcall(void) 690 static int __init regmap_initcall(void)
676 { 691 {
677 regmap_debugfs_initcall(); 692 regmap_debugfs_initcall();
678 693
679 return 0; 694 return 0;
680 } 695 }
681 postcore_initcall(regmap_initcall); 696 postcore_initcall(regmap_initcall);
682 697
include/linux/regmap.h
Diff comments   View file @ a6539c3
1 #ifndef __LINUX_REGMAP_H 1 #ifndef __LINUX_REGMAP_H
2 #define __LINUX_REGMAP_H 2 #define __LINUX_REGMAP_H
3 3
4 /* 4 /*
5 * Register map access API 5 * Register map access API
6 * 6 *
7 * Copyright 2011 Wolfson Microelectronics plc 7 * Copyright 2011 Wolfson Microelectronics plc
8 * 8 *
9 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 9 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
10 * 10 *
11 * This program is free software; you can redistribute it and/or modify 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 12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation. 13 * published by the Free Software Foundation.
14 */ 14 */
15 15
16 #include <linux/device.h> 16 #include <linux/device.h>
17 #include <linux/list.h> 17 #include <linux/list.h>
18 18
19 struct module; 19 struct module;
20 struct i2c_client; 20 struct i2c_client;
21 struct spi_device; 21 struct spi_device;
22 22
23 /* An enum of all the supported cache types */ 23 /* An enum of all the supported cache types */
24 enum regcache_type { 24 enum regcache_type {
25 REGCACHE_NONE, 25 REGCACHE_NONE,
26 REGCACHE_RBTREE, 26 REGCACHE_RBTREE,
27 REGCACHE_COMPRESSED 27 REGCACHE_COMPRESSED
28 }; 28 };
29 29
30 /** 30 /**
31 * Default value for a register. We use an array of structs rather 31 * Default value for a register. We use an array of structs rather
32 * than a simple array as many modern devices have very sparse 32 * than a simple array as many modern devices have very sparse
33 * register maps. 33 * register maps.
34 * 34 *
35 * @reg: Register address. 35 * @reg: Register address.
36 * @def: Register default value. 36 * @def: Register default value.
37 */ 37 */
38 struct reg_default { 38 struct reg_default {
39 unsigned int reg; 39 unsigned int reg;
40 unsigned int def; 40 unsigned int def;
41 }; 41 };
42 42
43 /** 43 /**
44 * Configuration for the register map of a device. 44 * Configuration for the register map of a device.
45 * 45 *
46 * @reg_bits: Number of bits in a register address, mandatory. 46 * @reg_bits: Number of bits in a register address, mandatory.
47 * @val_bits: Number of bits in a register value, mandatory. 47 * @val_bits: Number of bits in a register value, mandatory.
48 * 48 *
49 * @writeable_reg: Optional callback returning true if the register 49 * @writeable_reg: Optional callback returning true if the register
50 * can be written to. 50 * can be written to.
51 * @readable_reg: Optional callback returning true if the register 51 * @readable_reg: Optional callback returning true if the register
52 * can be read from. 52 * can be read from.
53 * @volatile_reg: Optional callback returning true if the register 53 * @volatile_reg: Optional callback returning true if the register
54 * value can't be cached. 54 * value can't be cached.
55 * @precious_reg: Optional callback returning true if the rgister 55 * @precious_reg: Optional callback returning true if the rgister
56 * should not be read outside of a call from the driver 56 * should not be read outside of a call from the driver
57 * (eg, a clear on read interrupt status register). 57 * (eg, a clear on read interrupt status register).
58 * 58 *
59 * @max_register: Optional, specifies the maximum valid register index. 59 * @max_register: Optional, specifies the maximum valid register index.
60 * @reg_defaults: Power on reset values for registers (for use with 60 * @reg_defaults: Power on reset values for registers (for use with
61 * register cache support). 61 * register cache support).
62 * @num_reg_defaults: Number of elements in reg_defaults. 62 * @num_reg_defaults: Number of elements in reg_defaults.
63 * 63 *
64 * @read_flag_mask: Mask to be set in the top byte of the register when doing 64 * @read_flag_mask: Mask to be set in the top byte of the register when doing
65 * a read. 65 * a read.
66 * @write_flag_mask: Mask to be set in the top byte of the register when doing 66 * @write_flag_mask: Mask to be set in the top byte of the register when doing
67 * a write. If both read_flag_mask and write_flag_mask are 67 * a write. If both read_flag_mask and write_flag_mask are
68 * empty the regmap_bus default masks are used. 68 * empty the regmap_bus default masks are used.
69 * 69 *
70 * @cache_type: The actual cache type. 70 * @cache_type: The actual cache type.
71 * @reg_defaults_raw: Power on reset values for registers (for use with 71 * @reg_defaults_raw: Power on reset values for registers (for use with
72 * register cache support). 72 * register cache support).
73 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw. 73 * @num_reg_defaults_raw: Number of elements in reg_defaults_raw.
74 */ 74 */
75 struct regmap_config { 75 struct regmap_config {
76 int reg_bits; 76 int reg_bits;
77 int val_bits; 77 int val_bits;
78 78
79 bool (*writeable_reg)(struct device *dev, unsigned int reg); 79 bool (*writeable_reg)(struct device *dev, unsigned int reg);
80 bool (*readable_reg)(struct device *dev, unsigned int reg); 80 bool (*readable_reg)(struct device *dev, unsigned int reg);
81 bool (*volatile_reg)(struct device *dev, unsigned int reg); 81 bool (*volatile_reg)(struct device *dev, unsigned int reg);
82 bool (*precious_reg)(struct device *dev, unsigned int reg); 82 bool (*precious_reg)(struct device *dev, unsigned int reg);
83 83
84 unsigned int max_register; 84 unsigned int max_register;
85 const struct reg_default *reg_defaults; 85 const struct reg_default *reg_defaults;
86 unsigned int num_reg_defaults; 86 unsigned int num_reg_defaults;
87 enum regcache_type cache_type; 87 enum regcache_type cache_type;
88 const void *reg_defaults_raw; 88 const void *reg_defaults_raw;
89 unsigned int num_reg_defaults_raw; 89 unsigned int num_reg_defaults_raw;
90 90
91 u8 read_flag_mask; 91 u8 read_flag_mask;
92 u8 write_flag_mask; 92 u8 write_flag_mask;
93 }; 93 };
94 94
95 typedef int (*regmap_hw_write)(struct device *dev, const void *data, 95 typedef int (*regmap_hw_write)(struct device *dev, const void *data,
96 size_t count); 96 size_t count);
97 typedef int (*regmap_hw_gather_write)(struct device *dev, 97 typedef int (*regmap_hw_gather_write)(struct device *dev,
98 const void *reg, size_t reg_len, 98 const void *reg, size_t reg_len,
99 const void *val, size_t val_len); 99 const void *val, size_t val_len);
100 typedef int (*regmap_hw_read)(struct device *dev, 100 typedef int (*regmap_hw_read)(struct device *dev,
101 const void *reg_buf, size_t reg_size, 101 const void *reg_buf, size_t reg_size,
102 void *val_buf, size_t val_size); 102 void *val_buf, size_t val_size);
103 103
104 /** 104 /**
105 * Description of a hardware bus for the register map infrastructure. 105 * Description of a hardware bus for the register map infrastructure.
106 * 106 *
107 * @write: Write operation. 107 * @write: Write operation.
108 * @gather_write: Write operation with split register/value, return -ENOTSUPP 108 * @gather_write: Write operation with split register/value, return -ENOTSUPP
109 * if not implemented on a given device. 109 * if not implemented on a given device.
110 * @read: Read operation. Data is returned in the buffer used to transmit 110 * @read: Read operation. Data is returned in the buffer used to transmit
111 * data. 111 * data.
112 * @read_flag_mask: Mask to be set in the top byte of the register when doing 112 * @read_flag_mask: Mask to be set in the top byte of the register when doing
113 * a read. 113 * a read.
114 */ 114 */
115 struct regmap_bus { 115 struct regmap_bus {
116 regmap_hw_write write; 116 regmap_hw_write write;
117 regmap_hw_gather_write gather_write; 117 regmap_hw_gather_write gather_write;
118 regmap_hw_read read; 118 regmap_hw_read read;
119 u8 read_flag_mask; 119 u8 read_flag_mask;
120 }; 120 };
121 121
122 struct regmap *regmap_init(struct device *dev, 122 struct regmap *regmap_init(struct device *dev,
123 const struct regmap_bus *bus, 123 const struct regmap_bus *bus,
124 const struct regmap_config *config); 124 const struct regmap_config *config);
125 struct regmap *regmap_init_i2c(struct i2c_client *i2c, 125 struct regmap *regmap_init_i2c(struct i2c_client *i2c,
126 const struct regmap_config *config); 126 const struct regmap_config *config);
127 struct regmap *regmap_init_spi(struct spi_device *dev, 127 struct regmap *regmap_init_spi(struct spi_device *dev,
128 const struct regmap_config *config); 128 const struct regmap_config *config);
129 129
130 void regmap_exit(struct regmap *map); 130 void regmap_exit(struct regmap *map);
131 int regmap_reinit_cache(struct regmap *map, 131 int regmap_reinit_cache(struct regmap *map,
132 const struct regmap_config *config); 132 const struct regmap_config *config);
133 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val); 133 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
134 int regmap_raw_write(struct regmap *map, unsigned int reg, 134 int regmap_raw_write(struct regmap *map, unsigned int reg,
135 const void *val, size_t val_len); 135 const void *val, size_t val_len);
136 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val); 136 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
137 int regmap_raw_read(struct regmap *map, unsigned int reg, 137 int regmap_raw_read(struct regmap *map, unsigned int reg,
138 void *val, size_t val_len); 138 void *val, size_t val_len);
139 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val, 139 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
140 size_t val_count); 140 size_t val_count);
141 int regmap_update_bits(struct regmap *map, unsigned int reg, 141 int regmap_update_bits(struct regmap *map, unsigned int reg,
142 unsigned int mask, unsigned int val); 142 unsigned int mask, unsigned int val);
143 int regmap_update_bits_check(struct regmap *map, unsigned int reg, 143 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
144 unsigned int mask, unsigned int val, 144 unsigned int mask, unsigned int val,
145 bool *change); 145 bool *change);
146 int regmap_get_val_bytes(struct regmap *map);
146 147
147 int regcache_sync(struct regmap *map); 148 int regcache_sync(struct regmap *map);
148 void regcache_cache_only(struct regmap *map, bool enable); 149 void regcache_cache_only(struct regmap *map, bool enable);
149 void regcache_cache_bypass(struct regmap *map, bool enable); 150 void regcache_cache_bypass(struct regmap *map, bool enable);
150 void regcache_mark_dirty(struct regmap *map); 151 void regcache_mark_dirty(struct regmap *map);
151 152
152 /** 153 /**
153 * Description of an IRQ for the generic regmap irq_chip. 154 * Description of an IRQ for the generic regmap irq_chip.
154 * 155 *
155 * @reg_offset: Offset of the status/mask register within the bank 156 * @reg_offset: Offset of the status/mask register within the bank
156 * @mask: Mask used to flag/control the register. 157 * @mask: Mask used to flag/control the register.
157 */ 158 */
158 struct regmap_irq { 159 struct regmap_irq {
159 unsigned int reg_offset; 160 unsigned int reg_offset;
160 unsigned int mask; 161 unsigned int mask;
161 }; 162 };
162 163
163 /** 164 /**
164 * Description of a generic regmap irq_chip. This is not intended to 165 * Description of a generic regmap irq_chip. This is not intended to
165 * handle every possible interrupt controller, but it should handle a 166 * handle every possible interrupt controller, but it should handle a
166 * substantial proportion of those that are found in the wild. 167 * substantial proportion of those that are found in the wild.
167 * 168 *
168 * @name: Descriptive name for IRQ controller. 169 * @name: Descriptive name for IRQ controller.
169 * 170 *
170 * @status_base: Base status register address. 171 * @status_base: Base status register address.
171 * @mask_base: Base mask register address. 172 * @mask_base: Base mask register address.
172 * @ack_base: Base ack address. If zero then the chip is clear on read. 173 * @ack_base: Base ack address. If zero then the chip is clear on read.
173 * 174 *
174 * @num_regs: Number of registers in each control bank. 175 * @num_regs: Number of registers in each control bank.
175 * @irqs: Descriptors for individual IRQs. Interrupt numbers are 176 * @irqs: Descriptors for individual IRQs. Interrupt numbers are
176 * assigned based on the index in the array of the interrupt. 177 * assigned based on the index in the array of the interrupt.
177 * @num_irqs: Number of descriptors. 178 * @num_irqs: Number of descriptors.
178 */ 179 */
179 struct regmap_irq_chip { 180 struct regmap_irq_chip {
180 const char *name; 181 const char *name;
181 182
182 unsigned int status_base; 183 unsigned int status_base;
183 unsigned int mask_base; 184 unsigned int mask_base;
184 unsigned int ack_base; 185 unsigned int ack_base;
185 186
186 int num_regs; 187 int num_regs;
187 188
188 const struct regmap_irq *irqs; 189 const struct regmap_irq *irqs;
189 int num_irqs; 190 int num_irqs;
190 }; 191 };
191 192
192 struct regmap_irq_chip_data; 193 struct regmap_irq_chip_data;
193 194
194 int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags, 195 int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
195 int irq_base, struct regmap_irq_chip *chip, 196 int irq_base, struct regmap_irq_chip *chip,
196 struct regmap_irq_chip_data **data); 197 struct regmap_irq_chip_data **data);
197 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data); 198 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
198 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data); 199 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
199 200
200 #endif 201 #endif
201 202