blob: ee4fea351220447a514b6b30731f44d7c5f94b5b [file] [log] [blame]
Mark Brownb83a3132011-05-11 19:59:58 +02001/*
2 * Register map access API
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
Stephen Warrenf5d6eba2012-03-09 13:17:28 -070013#include <linux/device.h>
Mark Brownb83a3132011-05-11 19:59:58 +020014#include <linux/slab.h>
Paul Gortmaker19694b52012-02-28 19:28:02 -050015#include <linux/export.h>
Mark Brownb83a3132011-05-11 19:59:58 +020016#include <linux/mutex.h>
17#include <linux/err.h>
18
Mark Brownfb2736b2011-07-24 21:30:55 +010019#define CREATE_TRACE_POINTS
20#include <trace/events/regmap.h>
21
Mark Brown93de9122011-07-20 22:35:37 +010022#include "internal.h"
Mark Brownb83a3132011-05-11 19:59:58 +020023
Mark Brown8de2f082011-08-10 17:14:41 +090024bool regmap_writeable(struct regmap *map, unsigned int reg)
25{
26 if (map->max_register && reg > map->max_register)
27 return false;
28
29 if (map->writeable_reg)
30 return map->writeable_reg(map->dev, reg);
31
32 return true;
33}
34
35bool regmap_readable(struct regmap *map, unsigned int reg)
36{
37 if (map->max_register && reg > map->max_register)
38 return false;
39
Wolfram Sang4191f192012-01-30 15:08:16 +010040 if (map->format.format_write)
41 return false;
42
Mark Brown8de2f082011-08-10 17:14:41 +090043 if (map->readable_reg)
44 return map->readable_reg(map->dev, reg);
45
46 return true;
47}
48
49bool regmap_volatile(struct regmap *map, unsigned int reg)
50{
Wolfram Sang4191f192012-01-30 15:08:16 +010051 if (!regmap_readable(map, reg))
Mark Brown8de2f082011-08-10 17:14:41 +090052 return false;
53
54 if (map->volatile_reg)
55 return map->volatile_reg(map->dev, reg);
56
57 return true;
58}
59
60bool regmap_precious(struct regmap *map, unsigned int reg)
61{
Wolfram Sang4191f192012-01-30 15:08:16 +010062 if (!regmap_readable(map, reg))
Mark Brown8de2f082011-08-10 17:14:41 +090063 return false;
64
65 if (map->precious_reg)
66 return map->precious_reg(map->dev, reg);
67
68 return false;
69}
70
Lars-Peter Clausen82cd9962011-11-08 18:37:25 +010071static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
72 unsigned int num)
73{
74 unsigned int i;
75
76 for (i = 0; i < num; i++)
77 if (!regmap_volatile(map, reg + i))
78 return false;
79
80 return true;
81}
82
Wolfram Sang9aa50752012-01-27 16:10:22 +010083static void regmap_format_2_6_write(struct regmap *map,
84 unsigned int reg, unsigned int val)
85{
86 u8 *out = map->work_buf;
87
88 *out = (reg << 6) | val;
89}
90
Mark Brownb83a3132011-05-11 19:59:58 +020091static void regmap_format_4_12_write(struct regmap *map,
92 unsigned int reg, unsigned int val)
93{
94 __be16 *out = map->work_buf;
95 *out = cpu_to_be16((reg << 12) | val);
96}
97
98static void regmap_format_7_9_write(struct regmap *map,
99 unsigned int reg, unsigned int val)
100{
101 __be16 *out = map->work_buf;
102 *out = cpu_to_be16((reg << 9) | val);
103}
104
Lars-Peter Clausen7e5ec632011-11-16 16:28:21 +0100105static void regmap_format_10_14_write(struct regmap *map,
106 unsigned int reg, unsigned int val)
107{
108 u8 *out = map->work_buf;
109
110 out[2] = val;
111 out[1] = (val >> 8) | (reg << 6);
112 out[0] = reg >> 2;
113}
114
Mark Brownb83a3132011-05-11 19:59:58 +0200115static void regmap_format_8(void *buf, unsigned int val)
116{
117 u8 *b = buf;
118
119 b[0] = val;
120}
121
122static void regmap_format_16(void *buf, unsigned int val)
123{
124 __be16 *b = buf;
125
126 b[0] = cpu_to_be16(val);
127}
128
Mark Brown7d5e5252012-02-17 15:58:25 -0800129static void regmap_format_32(void *buf, unsigned int val)
130{
131 __be32 *b = buf;
132
133 b[0] = cpu_to_be32(val);
134}
135
Mark Brownb83a3132011-05-11 19:59:58 +0200136static unsigned int regmap_parse_8(void *buf)
137{
138 u8 *b = buf;
139
140 return b[0];
141}
142
143static unsigned int regmap_parse_16(void *buf)
144{
145 __be16 *b = buf;
146
147 b[0] = be16_to_cpu(b[0]);
148
149 return b[0];
150}
151
Mark Brown7d5e5252012-02-17 15:58:25 -0800152static unsigned int regmap_parse_32(void *buf)
153{
154 __be32 *b = buf;
155
156 b[0] = be32_to_cpu(b[0]);
157
158 return b[0];
159}
160
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600161static void regmap_lock_mutex(struct regmap *map)
162{
163 mutex_lock(&map->mutex);
164}
165
166static void regmap_unlock_mutex(struct regmap *map)
167{
168 mutex_unlock(&map->mutex);
169}
170
171static void regmap_lock_spinlock(struct regmap *map)
172{
173 spin_lock(&map->spinlock);
174}
175
176static void regmap_unlock_spinlock(struct regmap *map)
177{
178 spin_unlock(&map->spinlock);
179}
180
Mark Brownb83a3132011-05-11 19:59:58 +0200181/**
182 * regmap_init(): Initialise register map
183 *
184 * @dev: Device that will be interacted with
185 * @bus: Bus-specific callbacks to use with device
Stephen Warren0135bbc2012-04-04 15:48:30 -0600186 * @bus_context: Data passed to bus-specific callbacks
Mark Brownb83a3132011-05-11 19:59:58 +0200187 * @config: Configuration for register map
188 *
189 * The return value will be an ERR_PTR() on error or a valid pointer to
190 * a struct regmap. This function should generally not be called
191 * directly, it should be called by bus-specific init functions.
192 */
193struct regmap *regmap_init(struct device *dev,
194 const struct regmap_bus *bus,
Stephen Warren0135bbc2012-04-04 15:48:30 -0600195 void *bus_context,
Mark Brownb83a3132011-05-11 19:59:58 +0200196 const struct regmap_config *config)
197{
198 struct regmap *map;
199 int ret = -EINVAL;
200
201 if (!bus || !config)
Lars-Peter Clausenabbb18f2011-11-14 10:40:15 +0100202 goto err;
Mark Brownb83a3132011-05-11 19:59:58 +0200203
204 map = kzalloc(sizeof(*map), GFP_KERNEL);
205 if (map == NULL) {
206 ret = -ENOMEM;
207 goto err;
208 }
209
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600210 if (bus->fast_io) {
211 spin_lock_init(&map->spinlock);
212 map->lock = regmap_lock_spinlock;
213 map->unlock = regmap_unlock_spinlock;
214 } else {
215 mutex_init(&map->mutex);
216 map->lock = regmap_lock_mutex;
217 map->unlock = regmap_unlock_mutex;
218 }
Mark Brownb83a3132011-05-11 19:59:58 +0200219 map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
Wolfram Sangc212acc2012-01-28 02:16:41 +0100220 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
Mark Brown82159ba2012-01-18 10:52:25 +0000221 map->format.pad_bytes = config->pad_bits / 8;
Wolfram Sangc212acc2012-01-28 02:16:41 +0100222 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
Mark Brown82159ba2012-01-18 10:52:25 +0000223 map->format.buf_size += map->format.pad_bytes;
Mark Brownb83a3132011-05-11 19:59:58 +0200224 map->dev = dev;
225 map->bus = bus;
Stephen Warren0135bbc2012-04-04 15:48:30 -0600226 map->bus_context = bus_context;
Mark Brown2e2ae662011-07-20 22:33:39 +0100227 map->max_register = config->max_register;
228 map->writeable_reg = config->writeable_reg;
229 map->readable_reg = config->readable_reg;
230 map->volatile_reg = config->volatile_reg;
Mark Brown2efe1642011-08-08 15:41:46 +0900231 map->precious_reg = config->precious_reg;
Dimitris Papastamos5d1729e2011-09-19 14:34:05 +0100232 map->cache_type = config->cache_type;
Mark Brownb83a3132011-05-11 19:59:58 +0200233
Lars-Peter Clausen6f306442011-09-05 20:46:32 +0200234 if (config->read_flag_mask || config->write_flag_mask) {
235 map->read_flag_mask = config->read_flag_mask;
236 map->write_flag_mask = config->write_flag_mask;
237 } else {
238 map->read_flag_mask = bus->read_flag_mask;
239 }
240
Mark Brownb83a3132011-05-11 19:59:58 +0200241 switch (config->reg_bits) {
Wolfram Sang9aa50752012-01-27 16:10:22 +0100242 case 2:
243 switch (config->val_bits) {
244 case 6:
245 map->format.format_write = regmap_format_2_6_write;
246 break;
247 default:
248 goto err_map;
249 }
250 break;
251
Mark Brownb83a3132011-05-11 19:59:58 +0200252 case 4:
253 switch (config->val_bits) {
254 case 12:
255 map->format.format_write = regmap_format_4_12_write;
256 break;
257 default:
258 goto err_map;
259 }
260 break;
261
262 case 7:
263 switch (config->val_bits) {
264 case 9:
265 map->format.format_write = regmap_format_7_9_write;
266 break;
267 default:
268 goto err_map;
269 }
270 break;
271
Lars-Peter Clausen7e5ec632011-11-16 16:28:21 +0100272 case 10:
273 switch (config->val_bits) {
274 case 14:
275 map->format.format_write = regmap_format_10_14_write;
276 break;
277 default:
278 goto err_map;
279 }
280 break;
281
Mark Brownb83a3132011-05-11 19:59:58 +0200282 case 8:
283 map->format.format_reg = regmap_format_8;
284 break;
285
286 case 16:
287 map->format.format_reg = regmap_format_16;
288 break;
289
Mark Brown7d5e5252012-02-17 15:58:25 -0800290 case 32:
291 map->format.format_reg = regmap_format_32;
292 break;
293
Mark Brownb83a3132011-05-11 19:59:58 +0200294 default:
295 goto err_map;
296 }
297
298 switch (config->val_bits) {
299 case 8:
300 map->format.format_val = regmap_format_8;
301 map->format.parse_val = regmap_parse_8;
302 break;
303 case 16:
304 map->format.format_val = regmap_format_16;
305 map->format.parse_val = regmap_parse_16;
306 break;
Mark Brown7d5e5252012-02-17 15:58:25 -0800307 case 32:
308 map->format.format_val = regmap_format_32;
309 map->format.parse_val = regmap_parse_32;
310 break;
Mark Brownb83a3132011-05-11 19:59:58 +0200311 }
312
313 if (!map->format.format_write &&
314 !(map->format.format_reg && map->format.format_val))
315 goto err_map;
316
Mark Brown82159ba2012-01-18 10:52:25 +0000317 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
Mark Brownb83a3132011-05-11 19:59:58 +0200318 if (map->work_buf == NULL) {
319 ret = -ENOMEM;
Mark Brown5204f5e2011-09-05 08:07:47 -0700320 goto err_map;
Mark Brownb83a3132011-05-11 19:59:58 +0200321 }
322
Mark Brown052d2cd2011-11-21 19:05:13 +0000323 regmap_debugfs_init(map);
324
Lars-Peter Clausene5e3b8a2011-11-16 16:28:16 +0100325 ret = regcache_init(map, config);
Dimitris Papastamos5d1729e2011-09-19 14:34:05 +0100326 if (ret < 0)
Lars-Peter Clausen58072cb2011-11-10 18:15:15 +0100327 goto err_free_workbuf;
Dimitris Papastamos5d1729e2011-09-19 14:34:05 +0100328
Mark Brownb83a3132011-05-11 19:59:58 +0200329 return map;
330
Lars-Peter Clausen58072cb2011-11-10 18:15:15 +0100331err_free_workbuf:
332 kfree(map->work_buf);
Mark Brownb83a3132011-05-11 19:59:58 +0200333err_map:
334 kfree(map);
335err:
336 return ERR_PTR(ret);
337}
338EXPORT_SYMBOL_GPL(regmap_init);
339
Mark Brownc0eb4672012-01-30 19:56:52 +0000340static void devm_regmap_release(struct device *dev, void *res)
341{
342 regmap_exit(*(struct regmap **)res);
343}
344
345/**
346 * devm_regmap_init(): Initialise managed register map
347 *
348 * @dev: Device that will be interacted with
349 * @bus: Bus-specific callbacks to use with device
Stephen Warren0135bbc2012-04-04 15:48:30 -0600350 * @bus_context: Data passed to bus-specific callbacks
Mark Brownc0eb4672012-01-30 19:56:52 +0000351 * @config: Configuration for register map
352 *
353 * The return value will be an ERR_PTR() on error or a valid pointer
354 * to a struct regmap. This function should generally not be called
355 * directly, it should be called by bus-specific init functions. The
356 * map will be automatically freed by the device management code.
357 */
358struct regmap *devm_regmap_init(struct device *dev,
359 const struct regmap_bus *bus,
Stephen Warren0135bbc2012-04-04 15:48:30 -0600360 void *bus_context,
Mark Brownc0eb4672012-01-30 19:56:52 +0000361 const struct regmap_config *config)
362{
363 struct regmap **ptr, *regmap;
364
365 ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
366 if (!ptr)
367 return ERR_PTR(-ENOMEM);
368
Stephen Warren0135bbc2012-04-04 15:48:30 -0600369 regmap = regmap_init(dev, bus, bus_context, config);
Mark Brownc0eb4672012-01-30 19:56:52 +0000370 if (!IS_ERR(regmap)) {
371 *ptr = regmap;
372 devres_add(dev, ptr);
373 } else {
374 devres_free(ptr);
375 }
376
377 return regmap;
378}
379EXPORT_SYMBOL_GPL(devm_regmap_init);
380
Mark Brownb83a3132011-05-11 19:59:58 +0200381/**
Mark Brownbf315172011-12-03 17:06:20 +0000382 * regmap_reinit_cache(): Reinitialise the current register cache
383 *
384 * @map: Register map to operate on.
385 * @config: New configuration. Only the cache data will be used.
386 *
387 * Discard any existing register cache for the map and initialize a
388 * new cache. This can be used to restore the cache to defaults or to
389 * update the cache configuration to reflect runtime discovery of the
390 * hardware.
391 */
392int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
393{
394 int ret;
395
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600396 map->lock(map);
Mark Brownbf315172011-12-03 17:06:20 +0000397
398 regcache_exit(map);
Mark Browna24f64a2012-01-26 18:30:16 +0000399 regmap_debugfs_exit(map);
Mark Brownbf315172011-12-03 17:06:20 +0000400
401 map->max_register = config->max_register;
402 map->writeable_reg = config->writeable_reg;
403 map->readable_reg = config->readable_reg;
404 map->volatile_reg = config->volatile_reg;
405 map->precious_reg = config->precious_reg;
406 map->cache_type = config->cache_type;
407
Mark Browna24f64a2012-01-26 18:30:16 +0000408 regmap_debugfs_init(map);
409
Mark Brown421e8d22012-01-20 13:39:37 +0000410 map->cache_bypass = false;
411 map->cache_only = false;
412
Mark Brownbf315172011-12-03 17:06:20 +0000413 ret = regcache_init(map, config);
414
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600415 map->unlock(map);
Mark Brownbf315172011-12-03 17:06:20 +0000416
417 return ret;
418}
419
420/**
Mark Brownb83a3132011-05-11 19:59:58 +0200421 * regmap_exit(): Free a previously allocated register map
422 */
423void regmap_exit(struct regmap *map)
424{
Dimitris Papastamos5d1729e2011-09-19 14:34:05 +0100425 regcache_exit(map);
Mark Brown31244e32011-07-20 22:56:53 +0100426 regmap_debugfs_exit(map);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600427 if (map->bus->free_context)
428 map->bus->free_context(map->bus_context);
Mark Brownb83a3132011-05-11 19:59:58 +0200429 kfree(map->work_buf);
Mark Brownb83a3132011-05-11 19:59:58 +0200430 kfree(map);
431}
432EXPORT_SYMBOL_GPL(regmap_exit);
433
434static int _regmap_raw_write(struct regmap *map, unsigned int reg,
435 const void *val, size_t val_len)
436{
Lars-Peter Clausen6f306442011-09-05 20:46:32 +0200437 u8 *u8 = map->work_buf;
Mark Brownb83a3132011-05-11 19:59:58 +0200438 void *buf;
439 int ret = -ENOTSUPP;
440 size_t len;
Mark Brown73304782011-07-24 11:46:20 +0100441 int i;
442
443 /* Check for unwritable registers before we start */
444 if (map->writeable_reg)
445 for (i = 0; i < val_len / map->format.val_bytes; i++)
446 if (!map->writeable_reg(map->dev, reg + i))
447 return -EINVAL;
Mark Brownb83a3132011-05-11 19:59:58 +0200448
Laxman Dewanganc9157192012-02-10 21:30:27 +0530449 if (!map->cache_bypass && map->format.parse_val) {
450 unsigned int ival;
451 int val_bytes = map->format.val_bytes;
452 for (i = 0; i < val_len / val_bytes; i++) {
453 memcpy(map->work_buf, val + (i * val_bytes), val_bytes);
454 ival = map->format.parse_val(map->work_buf);
455 ret = regcache_write(map, reg + i, ival);
456 if (ret) {
457 dev_err(map->dev,
458 "Error in caching of register: %u ret: %d\n",
459 reg + i, ret);
460 return ret;
461 }
462 }
463 if (map->cache_only) {
464 map->cache_dirty = true;
465 return 0;
466 }
467 }
468
Mark Brownb83a3132011-05-11 19:59:58 +0200469 map->format.format_reg(map->work_buf, reg);
470
Lars-Peter Clausen6f306442011-09-05 20:46:32 +0200471 u8[0] |= map->write_flag_mask;
472
Mark Brownfb2736b2011-07-24 21:30:55 +0100473 trace_regmap_hw_write_start(map->dev, reg,
474 val_len / map->format.val_bytes);
475
Mark Brown2547e202011-07-20 21:47:22 +0100476 /* If we're doing a single register write we can probably just
477 * send the work_buf directly, otherwise try to do a gather
478 * write.
479 */
Mark Brown82159ba2012-01-18 10:52:25 +0000480 if (val == (map->work_buf + map->format.pad_bytes +
481 map->format.reg_bytes))
Stephen Warren0135bbc2012-04-04 15:48:30 -0600482 ret = map->bus->write(map->bus_context, map->work_buf,
Mark Brown82159ba2012-01-18 10:52:25 +0000483 map->format.reg_bytes +
484 map->format.pad_bytes +
485 val_len);
Mark Brown2547e202011-07-20 21:47:22 +0100486 else if (map->bus->gather_write)
Stephen Warren0135bbc2012-04-04 15:48:30 -0600487 ret = map->bus->gather_write(map->bus_context, map->work_buf,
Mark Brown82159ba2012-01-18 10:52:25 +0000488 map->format.reg_bytes +
489 map->format.pad_bytes,
Mark Brownb83a3132011-05-11 19:59:58 +0200490 val, val_len);
491
Mark Brown2547e202011-07-20 21:47:22 +0100492 /* If that didn't work fall back on linearising by hand. */
Mark Brownb83a3132011-05-11 19:59:58 +0200493 if (ret == -ENOTSUPP) {
Mark Brown82159ba2012-01-18 10:52:25 +0000494 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
495 buf = kzalloc(len, GFP_KERNEL);
Mark Brownb83a3132011-05-11 19:59:58 +0200496 if (!buf)
497 return -ENOMEM;
498
499 memcpy(buf, map->work_buf, map->format.reg_bytes);
Mark Brown82159ba2012-01-18 10:52:25 +0000500 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
501 val, val_len);
Stephen Warren0135bbc2012-04-04 15:48:30 -0600502 ret = map->bus->write(map->bus_context, buf, len);
Mark Brownb83a3132011-05-11 19:59:58 +0200503
504 kfree(buf);
505 }
506
Mark Brownfb2736b2011-07-24 21:30:55 +0100507 trace_regmap_hw_write_done(map->dev, reg,
508 val_len / map->format.val_bytes);
509
Mark Brownb83a3132011-05-11 19:59:58 +0200510 return ret;
511}
512
Dimitris Papastamos4d2dc092011-09-29 10:39:07 +0100513int _regmap_write(struct regmap *map, unsigned int reg,
514 unsigned int val)
Mark Brownb83a3132011-05-11 19:59:58 +0200515{
Mark Brownfb2736b2011-07-24 21:30:55 +0100516 int ret;
Mark Brownb83a3132011-05-11 19:59:58 +0200517 BUG_ON(!map->format.format_write && !map->format.format_val);
518
Laxman Dewanganc9157192012-02-10 21:30:27 +0530519 if (!map->cache_bypass && map->format.format_write) {
Dimitris Papastamos5d1729e2011-09-19 14:34:05 +0100520 ret = regcache_write(map, reg, val);
521 if (ret != 0)
522 return ret;
Mark Brown8ae0d7e2011-10-26 10:34:22 +0200523 if (map->cache_only) {
524 map->cache_dirty = true;
Dimitris Papastamos5d1729e2011-09-19 14:34:05 +0100525 return 0;
Mark Brown8ae0d7e2011-10-26 10:34:22 +0200526 }
Dimitris Papastamos5d1729e2011-09-19 14:34:05 +0100527 }
528
Mark Brownfb2736b2011-07-24 21:30:55 +0100529 trace_regmap_reg_write(map->dev, reg, val);
530
Mark Brownb83a3132011-05-11 19:59:58 +0200531 if (map->format.format_write) {
532 map->format.format_write(map, reg, val);
533
Mark Brownfb2736b2011-07-24 21:30:55 +0100534 trace_regmap_hw_write_start(map->dev, reg, 1);
535
Stephen Warren0135bbc2012-04-04 15:48:30 -0600536 ret = map->bus->write(map->bus_context, map->work_buf,
Mark Brownfb2736b2011-07-24 21:30:55 +0100537 map->format.buf_size);
538
539 trace_regmap_hw_write_done(map->dev, reg, 1);
540
541 return ret;
Mark Brownb83a3132011-05-11 19:59:58 +0200542 } else {
Mark Brown82159ba2012-01-18 10:52:25 +0000543 map->format.format_val(map->work_buf + map->format.reg_bytes
544 + map->format.pad_bytes, val);
Mark Brownb83a3132011-05-11 19:59:58 +0200545 return _regmap_raw_write(map, reg,
Mark Brown82159ba2012-01-18 10:52:25 +0000546 map->work_buf +
547 map->format.reg_bytes +
548 map->format.pad_bytes,
Mark Brownb83a3132011-05-11 19:59:58 +0200549 map->format.val_bytes);
550 }
551}
552
553/**
554 * regmap_write(): Write a value to a single register
555 *
556 * @map: Register map to write to
557 * @reg: Register to write to
558 * @val: Value to be written
559 *
560 * A value of zero will be returned on success, a negative errno will
561 * be returned in error cases.
562 */
563int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
564{
565 int ret;
566
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600567 map->lock(map);
Mark Brownb83a3132011-05-11 19:59:58 +0200568
569 ret = _regmap_write(map, reg, val);
570
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600571 map->unlock(map);
Mark Brownb83a3132011-05-11 19:59:58 +0200572
573 return ret;
574}
575EXPORT_SYMBOL_GPL(regmap_write);
576
577/**
578 * regmap_raw_write(): Write raw values to one or more registers
579 *
580 * @map: Register map to write to
581 * @reg: Initial register to write to
582 * @val: Block of data to be written, laid out for direct transmission to the
583 * device
584 * @val_len: Length of data pointed to by val.
585 *
586 * This function is intended to be used for things like firmware
587 * download where a large block of data needs to be transferred to the
588 * device. No formatting will be done on the data provided.
589 *
590 * A value of zero will be returned on success, a negative errno will
591 * be returned in error cases.
592 */
593int regmap_raw_write(struct regmap *map, unsigned int reg,
594 const void *val, size_t val_len)
595{
596 int ret;
597
Stephen Warren851960b2012-04-06 15:16:03 -0600598 if (val_len % map->format.val_bytes)
599 return -EINVAL;
600
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600601 map->lock(map);
Mark Brownb83a3132011-05-11 19:59:58 +0200602
603 ret = _regmap_raw_write(map, reg, val, val_len);
604
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600605 map->unlock(map);
Mark Brownb83a3132011-05-11 19:59:58 +0200606
607 return ret;
608}
609EXPORT_SYMBOL_GPL(regmap_raw_write);
610
Laxman Dewangan8eaeb212012-02-12 19:49:43 +0530611/*
612 * regmap_bulk_write(): Write multiple registers to the device
613 *
614 * @map: Register map to write to
615 * @reg: First register to be write from
616 * @val: Block of data to be written, in native register size for device
617 * @val_count: Number of registers to write
618 *
619 * This function is intended to be used for writing a large block of
620 * data to be device either in single transfer or multiple transfer.
621 *
622 * A value of zero will be returned on success, a negative errno will
623 * be returned in error cases.
624 */
625int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
626 size_t val_count)
627{
628 int ret = 0, i;
629 size_t val_bytes = map->format.val_bytes;
630 void *wval;
631
632 if (!map->format.parse_val)
633 return -EINVAL;
634
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600635 map->lock(map);
Laxman Dewangan8eaeb212012-02-12 19:49:43 +0530636
637 /* No formatting is require if val_byte is 1 */
638 if (val_bytes == 1) {
639 wval = (void *)val;
640 } else {
641 wval = kmemdup(val, val_count * val_bytes, GFP_KERNEL);
642 if (!wval) {
643 ret = -ENOMEM;
644 dev_err(map->dev, "Error in memory allocation\n");
645 goto out;
646 }
647 for (i = 0; i < val_count * val_bytes; i += val_bytes)
648 map->format.parse_val(wval + i);
649 }
650 ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count);
651
652 if (val_bytes != 1)
653 kfree(wval);
654
655out:
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600656 map->unlock(map);
Laxman Dewangan8eaeb212012-02-12 19:49:43 +0530657 return ret;
658}
659EXPORT_SYMBOL_GPL(regmap_bulk_write);
660
Mark Brownb83a3132011-05-11 19:59:58 +0200661static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
662 unsigned int val_len)
663{
664 u8 *u8 = map->work_buf;
665 int ret;
666
667 map->format.format_reg(map->work_buf, reg);
668
669 /*
Lars-Peter Clausen6f306442011-09-05 20:46:32 +0200670 * Some buses or devices flag reads by setting the high bits in the
Mark Brownb83a3132011-05-11 19:59:58 +0200671 * register addresss; since it's always the high bits for all
672 * current formats we can do this here rather than in
673 * formatting. This may break if we get interesting formats.
674 */
Lars-Peter Clausen6f306442011-09-05 20:46:32 +0200675 u8[0] |= map->read_flag_mask;
Mark Brownb83a3132011-05-11 19:59:58 +0200676
Mark Brownfb2736b2011-07-24 21:30:55 +0100677 trace_regmap_hw_read_start(map->dev, reg,
678 val_len / map->format.val_bytes);
679
Stephen Warren0135bbc2012-04-04 15:48:30 -0600680 ret = map->bus->read(map->bus_context, map->work_buf,
Mark Brown82159ba2012-01-18 10:52:25 +0000681 map->format.reg_bytes + map->format.pad_bytes,
Mark Brown40c5cc22011-07-24 22:39:12 +0100682 val, val_len);
Mark Brownb83a3132011-05-11 19:59:58 +0200683
Mark Brownfb2736b2011-07-24 21:30:55 +0100684 trace_regmap_hw_read_done(map->dev, reg,
685 val_len / map->format.val_bytes);
686
687 return ret;
Mark Brownb83a3132011-05-11 19:59:58 +0200688}
689
690static int _regmap_read(struct regmap *map, unsigned int reg,
691 unsigned int *val)
692{
693 int ret;
694
Dimitris Papastamos5d1729e2011-09-19 14:34:05 +0100695 if (!map->cache_bypass) {
696 ret = regcache_read(map, reg, val);
697 if (ret == 0)
698 return 0;
699 }
700
Lars-Peter Clausen19254412011-11-16 16:28:19 +0100701 if (!map->format.parse_val)
702 return -EINVAL;
703
Dimitris Papastamos5d1729e2011-09-19 14:34:05 +0100704 if (map->cache_only)
705 return -EBUSY;
706
Mark Brownb83a3132011-05-11 19:59:58 +0200707 ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
Mark Brownfb2736b2011-07-24 21:30:55 +0100708 if (ret == 0) {
Mark Brownb83a3132011-05-11 19:59:58 +0200709 *val = map->format.parse_val(map->work_buf);
Mark Brownfb2736b2011-07-24 21:30:55 +0100710 trace_regmap_reg_read(map->dev, reg, *val);
711 }
Mark Brownb83a3132011-05-11 19:59:58 +0200712
713 return ret;
714}
715
716/**
717 * regmap_read(): Read a value from a single register
718 *
719 * @map: Register map to write to
720 * @reg: Register to be read from
721 * @val: Pointer to store read value
722 *
723 * A value of zero will be returned on success, a negative errno will
724 * be returned in error cases.
725 */
726int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
727{
728 int ret;
729
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600730 map->lock(map);
Mark Brownb83a3132011-05-11 19:59:58 +0200731
732 ret = _regmap_read(map, reg, val);
733
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600734 map->unlock(map);
Mark Brownb83a3132011-05-11 19:59:58 +0200735
736 return ret;
737}
738EXPORT_SYMBOL_GPL(regmap_read);
739
740/**
741 * regmap_raw_read(): Read raw data from the device
742 *
743 * @map: Register map to write to
744 * @reg: First register to be read from
745 * @val: Pointer to store read value
746 * @val_len: Size of data to read
747 *
748 * A value of zero will be returned on success, a negative errno will
749 * be returned in error cases.
750 */
751int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
752 size_t val_len)
753{
Mark Brownb8fb5ab2012-02-21 19:12:47 +0000754 size_t val_bytes = map->format.val_bytes;
755 size_t val_count = val_len / val_bytes;
756 unsigned int v;
757 int ret, i;
Mark Brown04e016a2011-10-09 13:35:43 +0100758
Stephen Warren851960b2012-04-06 15:16:03 -0600759 if (val_len % map->format.val_bytes)
760 return -EINVAL;
761
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600762 map->lock(map);
Mark Brownb83a3132011-05-11 19:59:58 +0200763
Mark Brownb8fb5ab2012-02-21 19:12:47 +0000764 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
765 map->cache_type == REGCACHE_NONE) {
766 /* Physical block read if there's no cache involved */
767 ret = _regmap_raw_read(map, reg, val, val_len);
Mark Brownb83a3132011-05-11 19:59:58 +0200768
Mark Brownb8fb5ab2012-02-21 19:12:47 +0000769 } else {
770 /* Otherwise go word by word for the cache; should be low
771 * cost as we expect to hit the cache.
772 */
773 for (i = 0; i < val_count; i++) {
774 ret = _regmap_read(map, reg + i, &v);
775 if (ret != 0)
776 goto out;
777
778 map->format.format_val(val + (i * val_bytes), v);
779 }
780 }
781
782 out:
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600783 map->unlock(map);
Mark Brownb83a3132011-05-11 19:59:58 +0200784
785 return ret;
786}
787EXPORT_SYMBOL_GPL(regmap_raw_read);
788
789/**
790 * regmap_bulk_read(): Read multiple registers from the device
791 *
792 * @map: Register map to write to
793 * @reg: First register to be read from
794 * @val: Pointer to store read value, in native register size for device
795 * @val_count: Number of registers to read
796 *
797 * A value of zero will be returned on success, a negative errno will
798 * be returned in error cases.
799 */
800int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
801 size_t val_count)
802{
803 int ret, i;
804 size_t val_bytes = map->format.val_bytes;
Lars-Peter Clausen82cd9962011-11-08 18:37:25 +0100805 bool vol = regmap_volatile_range(map, reg, val_count);
Dimitris Papastamos5d1729e2011-09-19 14:34:05 +0100806
Mark Brownb83a3132011-05-11 19:59:58 +0200807 if (!map->format.parse_val)
808 return -EINVAL;
809
Mark Brownde2d8082011-10-10 13:24:52 +0100810 if (vol || map->cache_type == REGCACHE_NONE) {
811 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
812 if (ret != 0)
813 return ret;
814
815 for (i = 0; i < val_count * val_bytes; i += val_bytes)
816 map->format.parse_val(val + i);
817 } else {
818 for (i = 0; i < val_count; i++) {
819 ret = regmap_read(map, reg + i, val + (i * val_bytes));
820 if (ret != 0)
821 return ret;
822 }
823 }
Mark Brownb83a3132011-05-11 19:59:58 +0200824
825 return 0;
826}
827EXPORT_SYMBOL_GPL(regmap_bulk_read);
828
Mark Brown018690d2011-11-29 20:10:36 +0000829static int _regmap_update_bits(struct regmap *map, unsigned int reg,
830 unsigned int mask, unsigned int val,
831 bool *change)
Mark Brownb83a3132011-05-11 19:59:58 +0200832{
833 int ret;
Mark Brownd91e8db22011-11-18 16:03:50 +0000834 unsigned int tmp, orig;
Mark Brownb83a3132011-05-11 19:59:58 +0200835
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600836 map->lock(map);
Mark Brownb83a3132011-05-11 19:59:58 +0200837
Mark Brownd91e8db22011-11-18 16:03:50 +0000838 ret = _regmap_read(map, reg, &orig);
Mark Brownb83a3132011-05-11 19:59:58 +0200839 if (ret != 0)
840 goto out;
841
Mark Brownd91e8db22011-11-18 16:03:50 +0000842 tmp = orig & ~mask;
Mark Brownb83a3132011-05-11 19:59:58 +0200843 tmp |= val & mask;
844
Mark Brown018690d2011-11-29 20:10:36 +0000845 if (tmp != orig) {
Mark Brownd91e8db22011-11-18 16:03:50 +0000846 ret = _regmap_write(map, reg, tmp);
Mark Brown018690d2011-11-29 20:10:36 +0000847 *change = true;
848 } else {
849 *change = false;
850 }
Mark Brownb83a3132011-05-11 19:59:58 +0200851
852out:
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600853 map->unlock(map);
Mark Brownb83a3132011-05-11 19:59:58 +0200854
855 return ret;
856}
Mark Brown018690d2011-11-29 20:10:36 +0000857
858/**
859 * regmap_update_bits: Perform a read/modify/write cycle on the register map
860 *
861 * @map: Register map to update
862 * @reg: Register to update
863 * @mask: Bitmask to change
864 * @val: New value for bitmask
865 *
866 * Returns zero for success, a negative number on error.
867 */
868int regmap_update_bits(struct regmap *map, unsigned int reg,
869 unsigned int mask, unsigned int val)
870{
871 bool change;
872 return _regmap_update_bits(map, reg, mask, val, &change);
873}
Mark Brownb83a3132011-05-11 19:59:58 +0200874EXPORT_SYMBOL_GPL(regmap_update_bits);
Mark Brown31244e32011-07-20 22:56:53 +0100875
Mark Brown018690d2011-11-29 20:10:36 +0000876/**
877 * regmap_update_bits_check: Perform a read/modify/write cycle on the
878 * register map and report if updated
879 *
880 * @map: Register map to update
881 * @reg: Register to update
882 * @mask: Bitmask to change
883 * @val: New value for bitmask
884 * @change: Boolean indicating if a write was done
885 *
886 * Returns zero for success, a negative number on error.
887 */
888int regmap_update_bits_check(struct regmap *map, unsigned int reg,
889 unsigned int mask, unsigned int val,
890 bool *change)
891{
892 return _regmap_update_bits(map, reg, mask, val, change);
893}
894EXPORT_SYMBOL_GPL(regmap_update_bits_check);
895
Mark Brown22f0d902012-01-21 12:01:14 +0000896/**
897 * regmap_register_patch: Register and apply register updates to be applied
898 * on device initialistion
899 *
900 * @map: Register map to apply updates to.
901 * @regs: Values to update.
902 * @num_regs: Number of entries in regs.
903 *
904 * Register a set of register updates to be applied to the device
905 * whenever the device registers are synchronised with the cache and
906 * apply them immediately. Typically this is used to apply
907 * corrections to be applied to the device defaults on startup, such
908 * as the updates some vendors provide to undocumented registers.
909 */
910int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
911 int num_regs)
912{
913 int i, ret;
914 bool bypass;
915
916 /* If needed the implementation can be extended to support this */
917 if (map->patch)
918 return -EBUSY;
919
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600920 map->lock(map);
Mark Brown22f0d902012-01-21 12:01:14 +0000921
922 bypass = map->cache_bypass;
923
924 map->cache_bypass = true;
925
926 /* Write out first; it's useful to apply even if we fail later. */
927 for (i = 0; i < num_regs; i++) {
928 ret = _regmap_write(map, regs[i].reg, regs[i].def);
929 if (ret != 0) {
930 dev_err(map->dev, "Failed to write %x = %x: %d\n",
931 regs[i].reg, regs[i].def, ret);
932 goto out;
933 }
934 }
935
Axel Lin2a14d7d92012-02-10 19:29:55 +0800936 map->patch = kcalloc(num_regs, sizeof(struct reg_default), GFP_KERNEL);
Mark Brown22f0d902012-01-21 12:01:14 +0000937 if (map->patch != NULL) {
938 memcpy(map->patch, regs,
939 num_regs * sizeof(struct reg_default));
940 map->patch_regs = num_regs;
941 } else {
942 ret = -ENOMEM;
943 }
944
945out:
946 map->cache_bypass = bypass;
947
Stephen Warrenbacdbe02012-04-04 15:48:28 -0600948 map->unlock(map);
Mark Brown22f0d902012-01-21 12:01:14 +0000949
950 return ret;
951}
952EXPORT_SYMBOL_GPL(regmap_register_patch);
953
Mark Browneae4b512012-03-14 13:15:03 +0000954/*
Mark Browna6539c32012-02-17 14:20:14 -0800955 * regmap_get_val_bytes(): Report the size of a register value
956 *
957 * Report the size of a register value, mainly intended to for use by
958 * generic infrastructure built on top of regmap.
959 */
960int regmap_get_val_bytes(struct regmap *map)
961{
962 if (map->format.format_write)
963 return -EINVAL;
964
965 return map->format.val_bytes;
966}
967EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
968
Mark Brown31244e32011-07-20 22:56:53 +0100969static int __init regmap_initcall(void)
970{
971 regmap_debugfs_initcall();
972
973 return 0;
974}
975postcore_initcall(regmap_initcall);