?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'regmap-v3.11-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie...
[linux-2.6.git] / drivers / base / regmap / regmap.c
blobe0d0c7d8a5c527867fb4ba05f4f21e74c43fcff2
1 /*
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
13 #include <linux/device.h>
14 #include <linux/slab.h>
15 #include <linux/export.h>
16 #include <linux/mutex.h>
17 #include <linux/err.h>
18 #include <linux/rbtree.h>
19 #include <linux/sched.h>
20
21 #define CREATE_TRACE_POINTS
22 #include <trace/events/regmap.h>
23
24 #include "internal.h"
25
26 /*
27 * Sometimes for failures during very early init the trace
28 * infrastructure isn't available early enough to be used. For this
29 * sort of problem defining LOG_DEVICE will add printks for basic
30 * register I/O on a specific device.
31 */
32 #undef LOG_DEVICE
33
34 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
35 unsigned int mask, unsigned int val,
36 bool *change);
37
38 static int _regmap_bus_read(void *context, unsigned int reg,
39 unsigned int *val);
40 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
41 unsigned int val);
42 static int _regmap_bus_raw_write(void *context, unsigned int reg,
43 unsigned int val);
44
45 static void async_cleanup(struct work_struct *work)
46 {
47 struct regmap_async *async = container_of(work, struct regmap_async,
48 cleanup);
49
50 kfree(async->work_buf);
51 kfree(async);
52 }
53
54 bool regmap_reg_in_ranges(unsigned int reg,
55 const struct regmap_range *ranges,
56 unsigned int nranges)
57 {
58 const struct regmap_range *r;
59 int i;
60
61 for (i = 0, r = ranges; i < nranges; i++, r++)
62 if (regmap_reg_in_range(reg, r))
63 return true;
64 return false;
65 }
66 EXPORT_SYMBOL_GPL(regmap_reg_in_ranges);
67
68 bool regmap_check_range_table(struct regmap *map, unsigned int reg,
69 const struct regmap_access_table *table)
70 {
71 /* Check "no ranges" first */
72 if (regmap_reg_in_ranges(reg, table->no_ranges, table->n_no_ranges))
73 return false;
74
75 /* In case zero "yes ranges" are supplied, any reg is OK */
76 if (!table->n_yes_ranges)
77 return true;
78
79 return regmap_reg_in_ranges(reg, table->yes_ranges,
80 table->n_yes_ranges);
81 }
82 EXPORT_SYMBOL_GPL(regmap_check_range_table);
83
84 bool regmap_writeable(struct regmap *map, unsigned int reg)
85 {
86 if (map->max_register && reg > map->max_register)
87 return false;
88
89 if (map->writeable_reg)
90 return map->writeable_reg(map->dev, reg);
91
92 if (map->wr_table)
93 return regmap_check_range_table(map, reg, map->wr_table);
94
95 return true;
96 }
97
98 bool regmap_readable(struct regmap *map, unsigned int reg)
99 {
100 if (map->max_register && reg > map->max_register)
101 return false;
102
103 if (map->format.format_write)
104 return false;
105
106 if (map->readable_reg)
107 return map->readable_reg(map->dev, reg);
108
109 if (map->rd_table)
110 return regmap_check_range_table(map, reg, map->rd_table);
111
112 return true;
113 }
114
115 bool regmap_volatile(struct regmap *map, unsigned int reg)
116 {
117 if (!regmap_readable(map, reg))
118 return false;
119
120 if (map->volatile_reg)
121 return map->volatile_reg(map->dev, reg);
122
123 if (map->volatile_table)
124 return regmap_check_range_table(map, reg, map->volatile_table);
125
126 if (map->cache_ops)
127 return false;
128 else
129 return true;
130 }
131
132 bool regmap_precious(struct regmap *map, unsigned int reg)
133 {
134 if (!regmap_readable(map, reg))
135 return false;
136
137 if (map->precious_reg)
138 return map->precious_reg(map->dev, reg);
139
140 if (map->precious_table)
141 return regmap_check_range_table(map, reg, map->precious_table);
142
143 return false;
144 }
145
146 static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
147 size_t num)
148 {
149 unsigned int i;
150
151 for (i = 0; i < num; i++)
152 if (!regmap_volatile(map, reg + i))
153 return false;
154
155 return true;
156 }
157
158 static void regmap_format_2_6_write(struct regmap *map,
159 unsigned int reg, unsigned int val)
160 {
161 u8 *out = map->work_buf;
162
163 *out = (reg << 6) | val;
164 }
165
166 static void regmap_format_4_12_write(struct regmap *map,
167 unsigned int reg, unsigned int val)
168 {
169 __be16 *out = map->work_buf;
170 *out = cpu_to_be16((reg << 12) | val);
171 }
172
173 static void regmap_format_7_9_write(struct regmap *map,
174 unsigned int reg, unsigned int val)
175 {
176 __be16 *out = map->work_buf;
177 *out = cpu_to_be16((reg << 9) | val);
178 }
179
180 static void regmap_format_10_14_write(struct regmap *map,
181 unsigned int reg, unsigned int val)
182 {
183 u8 *out = map->work_buf;
184
185 out[2] = val;
186 out[1] = (val >> 8) | (reg << 6);
187 out[0] = reg >> 2;
188 }
189
190 static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
191 {
192 u8 *b = buf;
193
194 b[0] = val << shift;
195 }
196
197 static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
198 {
199 __be16 *b = buf;
200
201 b[0] = cpu_to_be16(val << shift);
202 }
203
204 static void regmap_format_16_native(void *buf, unsigned int val,
205 unsigned int shift)
206 {
207 *(u16 *)buf = val << shift;
208 }
209
210 static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
211 {
212 u8 *b = buf;
213
214 val <<= shift;
215
216 b[0] = val >> 16;
217 b[1] = val >> 8;
218 b[2] = val;
219 }
220
221 static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
222 {
223 __be32 *b = buf;
224
225 b[0] = cpu_to_be32(val << shift);
226 }
227
228 static void regmap_format_32_native(void *buf, unsigned int val,
229 unsigned int shift)
230 {
231 *(u32 *)buf = val << shift;
232 }
233
234 static void regmap_parse_inplace_noop(void *buf)
235 {
236 }
237
238 static unsigned int regmap_parse_8(const void *buf)
239 {
240 const u8 *b = buf;
241
242 return b[0];
243 }
244
245 static unsigned int regmap_parse_16_be(const void *buf)
246 {
247 const __be16 *b = buf;
248
249 return be16_to_cpu(b[0]);
250 }
251
252 static void regmap_parse_16_be_inplace(void *buf)
253 {
254 __be16 *b = buf;
255
256 b[0] = be16_to_cpu(b[0]);
257 }
258
259 static unsigned int regmap_parse_16_native(const void *buf)
260 {
261 return *(u16 *)buf;
262 }
263
264 static unsigned int regmap_parse_24(const void *buf)
265 {
266 const u8 *b = buf;
267 unsigned int ret = b[2];
268 ret |= ((unsigned int)b[1]) << 8;
269 ret |= ((unsigned int)b[0]) << 16;
270
271 return ret;
272 }
273
274 static unsigned int regmap_parse_32_be(const void *buf)
275 {
276 const __be32 *b = buf;
277
278 return be32_to_cpu(b[0]);
279 }
280
281 static void regmap_parse_32_be_inplace(void *buf)
282 {
283 __be32 *b = buf;
284
285 b[0] = be32_to_cpu(b[0]);
286 }
287
288 static unsigned int regmap_parse_32_native(const void *buf)
289 {
290 return *(u32 *)buf;
291 }
292
293 static void regmap_lock_mutex(void *__map)
294 {
295 struct regmap *map = __map;
296 mutex_lock(&map->mutex);
297 }
298
299 static void regmap_unlock_mutex(void *__map)
300 {
301 struct regmap *map = __map;
302 mutex_unlock(&map->mutex);
303 }
304
305 static void regmap_lock_spinlock(void *__map)
306 {
307 struct regmap *map = __map;
308 unsigned long flags;
309
310 spin_lock_irqsave(&map->spinlock, flags);
311 map->spinlock_flags = flags;
312 }
313
314 static void regmap_unlock_spinlock(void *__map)
315 {
316 struct regmap *map = __map;
317 spin_unlock_irqrestore(&map->spinlock, map->spinlock_flags);
318 }
319
320 static void dev_get_regmap_release(struct device *dev, void *res)
321 {
322 /*
323 * We don't actually have anything to do here; the goal here
324 * is not to manage the regmap but to provide a simple way to
325 * get the regmap back given a struct device.
326 */
327 }
328
329 static bool _regmap_range_add(struct regmap *map,
330 struct regmap_range_node *data)
331 {
332 struct rb_root *root = &map->range_tree;
333 struct rb_node **new = &(root->rb_node), *parent = NULL;
334
335 while (*new) {
336 struct regmap_range_node *this =
337 container_of(*new, struct regmap_range_node, node);
338
339 parent = *new;
340 if (data->range_max < this->range_min)
341 new = &((*new)->rb_left);
342 else if (data->range_min > this->range_max)
343 new = &((*new)->rb_right);
344 else
345 return false;
346 }
347
348 rb_link_node(&data->node, parent, new);
349 rb_insert_color(&data->node, root);
350
351 return true;
352 }
353
354 static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
355 unsigned int reg)
356 {
357 struct rb_node *node = map->range_tree.rb_node;
358
359 while (node) {
360 struct regmap_range_node *this =
361 container_of(node, struct regmap_range_node, node);
362
363 if (reg < this->range_min)
364 node = node->rb_left;
365 else if (reg > this->range_max)
366 node = node->rb_right;
367 else
368 return this;
369 }
370
371 return NULL;
372 }
373
374 static void regmap_range_exit(struct regmap *map)
375 {
376 struct rb_node *next;
377 struct regmap_range_node *range_node;
378
379 next = rb_first(&map->range_tree);
380 while (next) {
381 range_node = rb_entry(next, struct regmap_range_node, node);
382 next = rb_next(&range_node->node);
383 rb_erase(&range_node->node, &map->range_tree);
384 kfree(range_node);
385 }
386
387 kfree(map->selector_work_buf);
388 }
389
390 /**
391 * regmap_init(): Initialise register map
392 *
393 * @dev: Device that will be interacted with
394 * @bus: Bus-specific callbacks to use with device
395 * @bus_context: Data passed to bus-specific callbacks
396 * @config: Configuration for register map
397 *
398 * The return value will be an ERR_PTR() on error or a valid pointer to
399 * a struct regmap. This function should generally not be called
400 * directly, it should be called by bus-specific init functions.
401 */
402 struct regmap *regmap_init(struct device *dev,
403 const struct regmap_bus *bus,
404 void *bus_context,
405 const struct regmap_config *config)
406 {
407 struct regmap *map, **m;
408 int ret = -EINVAL;
409 enum regmap_endian reg_endian, val_endian;
410 int i, j;
411
412 if (!config)
413 goto err;
414
415 map = kzalloc(sizeof(*map), GFP_KERNEL);
416 if (map == NULL) {
417 ret = -ENOMEM;
418 goto err;
419 }
420
421 if (config->lock && config->unlock) {
422 map->lock = config->lock;
423 map->unlock = config->unlock;
424 map->lock_arg = config->lock_arg;
425 } else {
426 if ((bus && bus->fast_io) ||
427 config->fast_io) {
428 spin_lock_init(&map->spinlock);
429 map->lock = regmap_lock_spinlock;
430 map->unlock = regmap_unlock_spinlock;
431 } else {
432 mutex_init(&map->mutex);
433 map->lock = regmap_lock_mutex;
434 map->unlock = regmap_unlock_mutex;
435 }
436 map->lock_arg = map;
437 }
438 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
439 map->format.pad_bytes = config->pad_bits / 8;
440 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
441 map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
442 config->val_bits + config->pad_bits, 8);
443 map->reg_shift = config->pad_bits % 8;
444 if (config->reg_stride)
445 map->reg_stride = config->reg_stride;
446 else
447 map->reg_stride = 1;
448 map->use_single_rw = config->use_single_rw;
449 map->dev = dev;
450 map->bus = bus;
451 map->bus_context = bus_context;
452 map->max_register = config->max_register;
453 map->wr_table = config->wr_table;
454 map->rd_table = config->rd_table;
455 map->volatile_table = config->volatile_table;
456 map->precious_table = config->precious_table;
457 map->writeable_reg = config->writeable_reg;
458 map->readable_reg = config->readable_reg;
459 map->volatile_reg = config->volatile_reg;
460 map->precious_reg = config->precious_reg;
461 map->cache_type = config->cache_type;
462 map->name = config->name;
463
464 spin_lock_init(&map->async_lock);
465 INIT_LIST_HEAD(&map->async_list);
466 init_waitqueue_head(&map->async_waitq);
467
468 if (config->read_flag_mask || config->write_flag_mask) {
469 map->read_flag_mask = config->read_flag_mask;
470 map->write_flag_mask = config->write_flag_mask;
471 } else if (bus) {
472 map->read_flag_mask = bus->read_flag_mask;
473 }
474
475 if (!bus) {
476 map->reg_read = config->reg_read;
477 map->reg_write = config->reg_write;
478
479 map->defer_caching = false;
480 goto skip_format_initialization;
481 } else {
482 map->reg_read = _regmap_bus_read;
483 }
484
485 reg_endian = config->reg_format_endian;
486 if (reg_endian == REGMAP_ENDIAN_DEFAULT)
487 reg_endian = bus->reg_format_endian_default;
488 if (reg_endian == REGMAP_ENDIAN_DEFAULT)
489 reg_endian = REGMAP_ENDIAN_BIG;
490
491 val_endian = config->val_format_endian;
492 if (val_endian == REGMAP_ENDIAN_DEFAULT)
493 val_endian = bus->val_format_endian_default;
494 if (val_endian == REGMAP_ENDIAN_DEFAULT)
495 val_endian = REGMAP_ENDIAN_BIG;
496
497 switch (config->reg_bits + map->reg_shift) {
498 case 2:
499 switch (config->val_bits) {
500 case 6:
501 map->format.format_write = regmap_format_2_6_write;
502 break;
503 default:
504 goto err_map;
505 }
506 break;
507
508 case 4:
509 switch (config->val_bits) {
510 case 12:
511 map->format.format_write = regmap_format_4_12_write;
512 break;
513 default:
514 goto err_map;
515 }
516 break;
517
518 case 7:
519 switch (config->val_bits) {
520 case 9:
521 map->format.format_write = regmap_format_7_9_write;
522 break;
523 default:
524 goto err_map;
525 }
526 break;
527
528 case 10:
529 switch (config->val_bits) {
530 case 14:
531 map->format.format_write = regmap_format_10_14_write;
532 break;
533 default:
534 goto err_map;
535 }
536 break;
537
538 case 8:
539 map->format.format_reg = regmap_format_8;
540 break;
541
542 case 16:
543 switch (reg_endian) {
544 case REGMAP_ENDIAN_BIG:
545 map->format.format_reg = regmap_format_16_be;
546 break;
547 case REGMAP_ENDIAN_NATIVE:
548 map->format.format_reg = regmap_format_16_native;
549 break;
550 default:
551 goto err_map;
552 }
553 break;
554
555 case 24:
556 if (reg_endian != REGMAP_ENDIAN_BIG)
557 goto err_map;
558 map->format.format_reg = regmap_format_24;
559 break;
560
561 case 32:
562 switch (reg_endian) {
563 case REGMAP_ENDIAN_BIG:
564 map->format.format_reg = regmap_format_32_be;
565 break;
566 case REGMAP_ENDIAN_NATIVE:
567 map->format.format_reg = regmap_format_32_native;
568 break;
569 default:
570 goto err_map;
571 }
572 break;
573
574 default:
575 goto err_map;
576 }
577
578 if (val_endian == REGMAP_ENDIAN_NATIVE)
579 map->format.parse_inplace = regmap_parse_inplace_noop;
580
581 switch (config->val_bits) {
582 case 8:
583 map->format.format_val = regmap_format_8;
584 map->format.parse_val = regmap_parse_8;
585 map->format.parse_inplace = regmap_parse_inplace_noop;
586 break;
587 case 16:
588 switch (val_endian) {
589 case REGMAP_ENDIAN_BIG:
590 map->format.format_val = regmap_format_16_be;
591 map->format.parse_val = regmap_parse_16_be;
592 map->format.parse_inplace = regmap_parse_16_be_inplace;
593 break;
594 case REGMAP_ENDIAN_NATIVE:
595 map->format.format_val = regmap_format_16_native;
596 map->format.parse_val = regmap_parse_16_native;
597 break;
598 default:
599 goto err_map;
600 }
601 break;
602 case 24:
603 if (val_endian != REGMAP_ENDIAN_BIG)
604 goto err_map;
605 map->format.format_val = regmap_format_24;
606 map->format.parse_val = regmap_parse_24;
607 break;
608 case 32:
609 switch (val_endian) {
610 case REGMAP_ENDIAN_BIG:
611 map->format.format_val = regmap_format_32_be;
612 map->format.parse_val = regmap_parse_32_be;
613 map->format.parse_inplace = regmap_parse_32_be_inplace;
614 break;
615 case REGMAP_ENDIAN_NATIVE:
616 map->format.format_val = regmap_format_32_native;
617 map->format.parse_val = regmap_parse_32_native;
618 break;
619 default:
620 goto err_map;
621 }
622 break;
623 }
624
625 if (map->format.format_write) {
626 if ((reg_endian != REGMAP_ENDIAN_BIG) ||
627 (val_endian != REGMAP_ENDIAN_BIG))
628 goto err_map;
629 map->use_single_rw = true;
630 }
631
632 if (!map->format.format_write &&
633 !(map->format.format_reg && map->format.format_val))
634 goto err_map;
635
636 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
637 if (map->work_buf == NULL) {
638 ret = -ENOMEM;
639 goto err_map;
640 }
641
642 if (map->format.format_write) {
643 map->defer_caching = false;
644 map->reg_write = _regmap_bus_formatted_write;
645 } else if (map->format.format_val) {
646 map->defer_caching = true;
647 map->reg_write = _regmap_bus_raw_write;
648 }
649
650 skip_format_initialization:
651
652 map->range_tree = RB_ROOT;
653 for (i = 0; i < config->num_ranges; i++) {
654 const struct regmap_range_cfg *range_cfg = &config->ranges[i];
655 struct regmap_range_node *new;
656
657 /* Sanity check */
658 if (range_cfg->range_max < range_cfg->range_min) {
659 dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
660 range_cfg->range_max, range_cfg->range_min);
661 goto err_range;
662 }
663
664 if (range_cfg->range_max > map->max_register) {
665 dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
666 range_cfg->range_max, map->max_register);
667 goto err_range;
668 }
669
670 if (range_cfg->selector_reg > map->max_register) {
671 dev_err(map->dev,
672 "Invalid range %d: selector out of map\n", i);
673 goto err_range;
674 }
675
676 if (range_cfg->window_len == 0) {
677 dev_err(map->dev, "Invalid range %d: window_len 0\n",
678 i);
679 goto err_range;
680 }
681
682 /* Make sure, that this register range has no selector
683 or data window within its boundary */
684 for (j = 0; j < config->num_ranges; j++) {
685 unsigned sel_reg = config->ranges[j].selector_reg;
686 unsigned win_min = config->ranges[j].window_start;
687 unsigned win_max = win_min +
688 config->ranges[j].window_len - 1;
689
690 if (range_cfg->range_min <= sel_reg &&
691 sel_reg <= range_cfg->range_max) {
692 dev_err(map->dev,
693 "Range %d: selector for %d in window\n",
694 i, j);
695 goto err_range;
696 }
697
698 if (!(win_max < range_cfg->range_min ||
699 win_min > range_cfg->range_max)) {
700 dev_err(map->dev,
701 "Range %d: window for %d in window\n",
702 i, j);
703 goto err_range;
704 }
705 }
706
707 new = kzalloc(sizeof(*new), GFP_KERNEL);
708 if (new == NULL) {
709 ret = -ENOMEM;
710 goto err_range;
711 }
712
713 new->map = map;
714 new->name = range_cfg->name;
715 new->range_min = range_cfg->range_min;
716 new->range_max = range_cfg->range_max;
717 new->selector_reg = range_cfg->selector_reg;
718 new->selector_mask = range_cfg->selector_mask;
719 new->selector_shift = range_cfg->selector_shift;
720 new->window_start = range_cfg->window_start;
721 new->window_len = range_cfg->window_len;
722
723 if (_regmap_range_add(map, new) == false) {
724 dev_err(map->dev, "Failed to add range %d\n", i);
725 kfree(new);
726 goto err_range;
727 }
728
729 if (map->selector_work_buf == NULL) {
730 map->selector_work_buf =
731 kzalloc(map->format.buf_size, GFP_KERNEL);
732 if (map->selector_work_buf == NULL) {
733 ret = -ENOMEM;
734 goto err_range;
735 }
736 }
737 }
738
739 regmap_debugfs_init(map, config->name);
740
741 ret = regcache_init(map, config);
742 if (ret != 0)
743 goto err_range;
744
745 /* Add a devres resource for dev_get_regmap() */
746 m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
747 if (!m) {
748 ret = -ENOMEM;
749 goto err_debugfs;
750 }
751 *m = map;
752 devres_add(dev, m);
753
754 return map;
755
756 err_debugfs:
757 regmap_debugfs_exit(map);
758 regcache_exit(map);
759 err_range:
760 regmap_range_exit(map);
761 kfree(map->work_buf);
762 err_map:
763 kfree(map);
764 err:
765 return ERR_PTR(ret);
766 }
767 EXPORT_SYMBOL_GPL(regmap_init);
768
769 static void devm_regmap_release(struct device *dev, void *res)
770 {
771 regmap_exit(*(struct regmap **)res);
772 }
773
774 /**
775 * devm_regmap_init(): Initialise managed register map
776 *
777 * @dev: Device that will be interacted with
778 * @bus: Bus-specific callbacks to use with device
779 * @bus_context: Data passed to bus-specific callbacks
780 * @config: Configuration for register map
781 *
782 * The return value will be an ERR_PTR() on error or a valid pointer
783 * to a struct regmap. This function should generally not be called
784 * directly, it should be called by bus-specific init functions. The
785 * map will be automatically freed by the device management code.
786 */
787 struct regmap *devm_regmap_init(struct device *dev,
788 const struct regmap_bus *bus,
789 void *bus_context,
790 const struct regmap_config *config)
791 {
792 struct regmap **ptr, *regmap;
793
794 ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
795 if (!ptr)
796 return ERR_PTR(-ENOMEM);
797
798 regmap = regmap_init(dev, bus, bus_context, config);
799 if (!IS_ERR(regmap)) {
800 *ptr = regmap;
801 devres_add(dev, ptr);
802 } else {
803 devres_free(ptr);
804 }
805
806 return regmap;
807 }
808 EXPORT_SYMBOL_GPL(devm_regmap_init);
809
810 static void regmap_field_init(struct regmap_field *rm_field,
811 struct regmap *regmap, struct reg_field reg_field)
812 {
813 int field_bits = reg_field.msb - reg_field.lsb + 1;
814 rm_field->regmap = regmap;
815 rm_field->reg = reg_field.reg;
816 rm_field->shift = reg_field.lsb;
817 rm_field->mask = ((BIT(field_bits) - 1) << reg_field.lsb);
818 }
819
820 /**
821 * devm_regmap_field_alloc(): Allocate and initialise a register field
822 * in a register map.
823 *
824 * @dev: Device that will be interacted with
825 * @regmap: regmap bank in which this register field is located.
826 * @reg_field: Register field with in the bank.
827 *
828 * The return value will be an ERR_PTR() on error or a valid pointer
829 * to a struct regmap_field. The regmap_field will be automatically freed
830 * by the device management code.
831 */
832 struct regmap_field *devm_regmap_field_alloc(struct device *dev,
833 struct regmap *regmap, struct reg_field reg_field)
834 {
835 struct regmap_field *rm_field = devm_kzalloc(dev,
836 sizeof(*rm_field), GFP_KERNEL);
837 if (!rm_field)
838 return ERR_PTR(-ENOMEM);
839
840 regmap_field_init(rm_field, regmap, reg_field);
841
842 return rm_field;
843
844 }
845 EXPORT_SYMBOL_GPL(devm_regmap_field_alloc);
846
847 /**
848 * devm_regmap_field_free(): Free register field allocated using
849 * devm_regmap_field_alloc. Usally drivers need not call this function,
850 * as the memory allocated via devm will be freed as per device-driver
851 * life-cyle.
852 *
853 * @dev: Device that will be interacted with
854 * @field: regmap field which should be freed.
855 */
856 void devm_regmap_field_free(struct device *dev,
857 struct regmap_field *field)
858 {
859 devm_kfree(dev, field);
860 }
861 EXPORT_SYMBOL_GPL(devm_regmap_field_free);
862
863 /**
864 * regmap_field_alloc(): Allocate and initialise a register field
865 * in a register map.
866 *
867 * @regmap: regmap bank in which this register field is located.
868 * @reg_field: Register field with in the bank.
869 *
870 * The return value will be an ERR_PTR() on error or a valid pointer
871 * to a struct regmap_field. The regmap_field should be freed by the
872 * user once its finished working with it using regmap_field_free().
873 */
874 struct regmap_field *regmap_field_alloc(struct regmap *regmap,
875 struct reg_field reg_field)
876 {
877 struct regmap_field *rm_field = kzalloc(sizeof(*rm_field), GFP_KERNEL);
878
879 if (!rm_field)
880 return ERR_PTR(-ENOMEM);
881
882 regmap_field_init(rm_field, regmap, reg_field);
883
884 return rm_field;
885 }
886 EXPORT_SYMBOL_GPL(regmap_field_alloc);
887
888 /**
889 * regmap_field_free(): Free register field allocated using regmap_field_alloc
890 *
891 * @field: regmap field which should be freed.
892 */
893 void regmap_field_free(struct regmap_field *field)
894 {
895 kfree(field);
896 }
897 EXPORT_SYMBOL_GPL(regmap_field_free);
898
899 /**
900 * regmap_reinit_cache(): Reinitialise the current register cache
901 *
902 * @map: Register map to operate on.
903 * @config: New configuration. Only the cache data will be used.
904 *
905 * Discard any existing register cache for the map and initialize a
906 * new cache. This can be used to restore the cache to defaults or to
907 * update the cache configuration to reflect runtime discovery of the
908 * hardware.
909 *
910 * No explicit locking is done here, the user needs to ensure that
911 * this function will not race with other calls to regmap.
912 */
913 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
914 {
915 regcache_exit(map);
916 regmap_debugfs_exit(map);
917
918 map->max_register = config->max_register;
919 map->writeable_reg = config->writeable_reg;
920 map->readable_reg = config->readable_reg;
921 map->volatile_reg = config->volatile_reg;
922 map->precious_reg = config->precious_reg;
923 map->cache_type = config->cache_type;
924
925 regmap_debugfs_init(map, config->name);
926
927 map->cache_bypass = false;
928 map->cache_only = false;
929
930 return regcache_init(map, config);
931 }
932 EXPORT_SYMBOL_GPL(regmap_reinit_cache);
933
934 /**
935 * regmap_exit(): Free a previously allocated register map
936 */
937 void regmap_exit(struct regmap *map)
938 {
939 regcache_exit(map);
940 regmap_debugfs_exit(map);
941 regmap_range_exit(map);
942 if (map->bus && map->bus->free_context)
943 map->bus->free_context(map->bus_context);
944 kfree(map->work_buf);
945 kfree(map);
946 }
947 EXPORT_SYMBOL_GPL(regmap_exit);
948
949 static int dev_get_regmap_match(struct device *dev, void *res, void *data)
950 {
951 struct regmap **r = res;
952 if (!r || !*r) {
953 WARN_ON(!r || !*r);
954 return 0;
955 }
956
957 /* If the user didn't specify a name match any */
958 if (data)
959 return (*r)->name == data;
960 else
961 return 1;
962 }
963
964 /**
965 * dev_get_regmap(): Obtain the regmap (if any) for a device
966 *
967 * @dev: Device to retrieve the map for
968 * @name: Optional name for the register map, usually NULL.
969 *
970 * Returns the regmap for the device if one is present, or NULL. If
971 * name is specified then it must match the name specified when
972 * registering the device, if it is NULL then the first regmap found
973 * will be used. Devices with multiple register maps are very rare,
974 * generic code should normally not need to specify a name.
975 */
976 struct regmap *dev_get_regmap(struct device *dev, const char *name)
977 {
978 struct regmap **r = devres_find(dev, dev_get_regmap_release,
979 dev_get_regmap_match, (void *)name);
980
981 if (!r)
982 return NULL;
983 return *r;
984 }
985 EXPORT_SYMBOL_GPL(dev_get_regmap);
986
987 static int _regmap_select_page(struct regmap *map, unsigned int *reg,
988 struct regmap_range_node *range,
989 unsigned int val_num)
990 {
991 void *orig_work_buf;
992 unsigned int win_offset;
993 unsigned int win_page;
994 bool page_chg;
995 int ret;
996
997 win_offset = (*reg - range->range_min) % range->window_len;
998 win_page = (*reg - range->range_min) / range->window_len;
999
1000 if (val_num > 1) {
1001 /* Bulk write shouldn't cross range boundary */
1002 if (*reg + val_num - 1 > range->range_max)
1003 return -EINVAL;
1004
1005 /* ... or single page boundary */
1006 if (val_num > range->window_len - win_offset)
1007 return -EINVAL;
1008 }
1009
1010 /* It is possible to have selector register inside data window.
1011 In that case, selector register is located on every page and
1012 it needs no page switching, when accessed alone. */
1013 if (val_num > 1 ||
1014 range->window_start + win_offset != range->selector_reg) {
1015 /* Use separate work_buf during page switching */
1016 orig_work_buf = map->work_buf;
1017 map->work_buf = map->selector_work_buf;
1018
1019 ret = _regmap_update_bits(map, range->selector_reg,
1020 range->selector_mask,
1021 win_page << range->selector_shift,
1022 &page_chg);
1023
1024 map->work_buf = orig_work_buf;
1025
1026 if (ret != 0)
1027 return ret;
1028 }
1029
1030 *reg = range->window_start + win_offset;
1031
1032 return 0;
1033 }
1034
1035 int _regmap_raw_write(struct regmap *map, unsigned int reg,
1036 const void *val, size_t val_len, bool async)
1037 {
1038 struct regmap_range_node *range;
1039 unsigned long flags;
1040 u8 *u8 = map->work_buf;
1041 void *work_val = map->work_buf + map->format.reg_bytes +
1042 map->format.pad_bytes;
1043 void *buf;
1044 int ret = -ENOTSUPP;
1045 size_t len;
1046 int i;
1047
1048 WARN_ON(!map->bus);
1049
1050 /* Check for unwritable registers before we start */
1051 if (map->writeable_reg)
1052 for (i = 0; i < val_len / map->format.val_bytes; i++)
1053 if (!map->writeable_reg(map->dev,
1054 reg + (i * map->reg_stride)))
1055 return -EINVAL;
1056
1057 if (!map->cache_bypass && map->format.parse_val) {
1058 unsigned int ival;
1059 int val_bytes = map->format.val_bytes;
1060 for (i = 0; i < val_len / val_bytes; i++) {
1061 ival = map->format.parse_val(val + (i * val_bytes));
1062 ret = regcache_write(map, reg + (i * map->reg_stride),
1063 ival);
1064 if (ret) {
1065 dev_err(map->dev,
1066 "Error in caching of register: %x ret: %d\n",
1067 reg + i, ret);
1068 return ret;
1069 }
1070 }
1071 if (map->cache_only) {
1072 map->cache_dirty = true;
1073 return 0;
1074 }
1075 }
1076
1077 range = _regmap_range_lookup(map, reg);
1078 if (range) {
1079 int val_num = val_len / map->format.val_bytes;
1080 int win_offset = (reg - range->range_min) % range->window_len;
1081 int win_residue = range->window_len - win_offset;
1082
1083 /* If the write goes beyond the end of the window split it */
1084 while (val_num > win_residue) {
1085 dev_dbg(map->dev, "Writing window %d/%zu\n",
1086 win_residue, val_len / map->format.val_bytes);
1087 ret = _regmap_raw_write(map, reg, val, win_residue *
1088 map->format.val_bytes, async);
1089 if (ret != 0)
1090 return ret;
1091
1092 reg += win_residue;
1093 val_num -= win_residue;
1094 val += win_residue * map->format.val_bytes;
1095 val_len -= win_residue * map->format.val_bytes;
1096
1097 win_offset = (reg - range->range_min) %
1098 range->window_len;
1099 win_residue = range->window_len - win_offset;
1100 }
1101
1102 ret = _regmap_select_page(map, &reg, range, val_num);
1103 if (ret != 0)
1104 return ret;
1105 }
1106
1107 map->format.format_reg(map->work_buf, reg, map->reg_shift);
1108
1109 u8[0] |= map->write_flag_mask;
1110
1111 if (async && map->bus->async_write) {
1112 struct regmap_async *async = map->bus->async_alloc();
1113 if (!async)
1114 return -ENOMEM;
1115
1116 trace_regmap_async_write_start(map->dev, reg, val_len);
1117
1118 async->work_buf = kzalloc(map->format.buf_size,
1119 GFP_KERNEL | GFP_DMA);
1120 if (!async->work_buf) {
1121 kfree(async);
1122 return -ENOMEM;
1123 }
1124
1125 INIT_WORK(&async->cleanup, async_cleanup);
1126 async->map = map;
1127
1128 /* If the caller supplied the value we can use it safely. */
1129 memcpy(async->work_buf, map->work_buf, map->format.pad_bytes +
1130 map->format.reg_bytes + map->format.val_bytes);
1131 if (val == work_val)
1132 val = async->work_buf + map->format.pad_bytes +
1133 map->format.reg_bytes;
1134
1135 spin_lock_irqsave(&map->async_lock, flags);
1136 list_add_tail(&async->list, &map->async_list);
1137 spin_unlock_irqrestore(&map->async_lock, flags);
1138
1139 ret = map->bus->async_write(map->bus_context, async->work_buf,
1140 map->format.reg_bytes +
1141 map->format.pad_bytes,
1142 val, val_len, async);
1143
1144 if (ret != 0) {
1145 dev_err(map->dev, "Failed to schedule write: %d\n",
1146 ret);
1147
1148 spin_lock_irqsave(&map->async_lock, flags);
1149 list_del(&async->list);
1150 spin_unlock_irqrestore(&map->async_lock, flags);
1151
1152 kfree(async->work_buf);
1153 kfree(async);
1154 }
1155
1156 return ret;
1157 }
1158
1159 trace_regmap_hw_write_start(map->dev, reg,
1160 val_len / map->format.val_bytes);
1161
1162 /* If we're doing a single register write we can probably just
1163 * send the work_buf directly, otherwise try to do a gather
1164 * write.
1165 */
1166 if (val == work_val)
1167 ret = map->bus->write(map->bus_context, map->work_buf,
1168 map->format.reg_bytes +
1169 map->format.pad_bytes +
1170 val_len);
1171 else if (map->bus->gather_write)
1172 ret = map->bus->gather_write(map->bus_context, map->work_buf,
1173 map->format.reg_bytes +
1174 map->format.pad_bytes,
1175 val, val_len);
1176
1177 /* If that didn't work fall back on linearising by hand. */
1178 if (ret == -ENOTSUPP) {
1179 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
1180 buf = kzalloc(len, GFP_KERNEL);
1181 if (!buf)
1182 return -ENOMEM;
1183
1184 memcpy(buf, map->work_buf, map->format.reg_bytes);
1185 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
1186 val, val_len);
1187 ret = map->bus->write(map->bus_context, buf, len);
1188
1189 kfree(buf);
1190 }
1191
1192 trace_regmap_hw_write_done(map->dev, reg,
1193 val_len / map->format.val_bytes);
1194
1195 return ret;
1196 }
1197
1198 /**
1199 * regmap_can_raw_write - Test if regmap_raw_write() is supported
1200 *
1201 * @map: Map to check.
1202 */
1203 bool regmap_can_raw_write(struct regmap *map)
1204 {
1205 return map->bus && map->format.format_val && map->format.format_reg;
1206 }
1207 EXPORT_SYMBOL_GPL(regmap_can_raw_write);
1208
1209 static int _regmap_bus_formatted_write(void *context, unsigned int reg,
1210 unsigned int val)
1211 {
1212 int ret;
1213 struct regmap_range_node *range;
1214 struct regmap *map = context;
1215
1216 WARN_ON(!map->bus || !map->format.format_write);
1217
1218 range = _regmap_range_lookup(map, reg);
1219 if (range) {
1220 ret = _regmap_select_page(map, &reg, range, 1);
1221 if (ret != 0)
1222 return ret;
1223 }
1224
1225 map->format.format_write(map, reg, val);
1226
1227 trace_regmap_hw_write_start(map->dev, reg, 1);
1228
1229 ret = map->bus->write(map->bus_context, map->work_buf,
1230 map->format.buf_size);
1231
1232 trace_regmap_hw_write_done(map->dev, reg, 1);
1233
1234 return ret;
1235 }
1236
1237 static int _regmap_bus_raw_write(void *context, unsigned int reg,
1238 unsigned int val)
1239 {
1240 struct regmap *map = context;
1241
1242 WARN_ON(!map->bus || !map->format.format_val);
1243
1244 map->format.format_val(map->work_buf + map->format.reg_bytes
1245 + map->format.pad_bytes, val, 0);
1246 return _regmap_raw_write(map, reg,
1247 map->work_buf +
1248 map->format.reg_bytes +
1249 map->format.pad_bytes,
1250 map->format.val_bytes, false);
1251 }
1252
1253 static inline void *_regmap_map_get_context(struct regmap *map)
1254 {
1255 return (map->bus) ? map : map->bus_context;
1256 }
1257
1258 int _regmap_write(struct regmap *map, unsigned int reg,
1259 unsigned int val)
1260 {
1261 int ret;
1262 void *context = _regmap_map_get_context(map);
1263
1264 if (!map->cache_bypass && !map->defer_caching) {
1265 ret = regcache_write(map, reg, val);
1266 if (ret != 0)
1267 return ret;
1268 if (map->cache_only) {
1269 map->cache_dirty = true;
1270 return 0;
1271 }
1272 }
1273
1274 #ifdef LOG_DEVICE
1275 if (strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
1276 dev_info(map->dev, "%x <= %x\n", reg, val);
1277 #endif
1278
1279 trace_regmap_reg_write(map->dev, reg, val);
1280
1281 return map->reg_write(context, reg, val);
1282 }
1283
1284 /**
1285 * regmap_write(): Write a value to a single register
1286 *
1287 * @map: Register map to write to
1288 * @reg: Register to write to
1289 * @val: Value to be written
1290 *
1291 * A value of zero will be returned on success, a negative errno will
1292 * be returned in error cases.
1293 */
1294 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1295 {
1296 int ret;
1297
1298 if (reg % map->reg_stride)
1299 return -EINVAL;
1300
1301 map->lock(map->lock_arg);
1302
1303 ret = _regmap_write(map, reg, val);
1304
1305 map->unlock(map->lock_arg);
1306
1307 return ret;
1308 }
1309 EXPORT_SYMBOL_GPL(regmap_write);
1310
1311 /**
1312 * regmap_raw_write(): Write raw values to one or more registers
1313 *
1314 * @map: Register map to write to
1315 * @reg: Initial register to write to
1316 * @val: Block of data to be written, laid out for direct transmission to the
1317 * device
1318 * @val_len: Length of data pointed to by val.
1319 *
1320 * This function is intended to be used for things like firmware
1321 * download where a large block of data needs to be transferred to the
1322 * device. No formatting will be done on the data provided.
1323 *
1324 * A value of zero will be returned on success, a negative errno will
1325 * be returned in error cases.
1326 */
1327 int regmap_raw_write(struct regmap *map, unsigned int reg,
1328 const void *val, size_t val_len)
1329 {
1330 int ret;
1331
1332 if (!regmap_can_raw_write(map))
1333 return -EINVAL;
1334 if (val_len % map->format.val_bytes)
1335 return -EINVAL;
1336
1337 map->lock(map->lock_arg);
1338
1339 ret = _regmap_raw_write(map, reg, val, val_len, false);
1340
1341 map->unlock(map->lock_arg);
1342
1343 return ret;
1344 }
1345 EXPORT_SYMBOL_GPL(regmap_raw_write);
1346
1347 /**
1348 * regmap_field_write(): Write a value to a single register field
1349 *
1350 * @field: Register field to write to
1351 * @val: Value to be written
1352 *
1353 * A value of zero will be returned on success, a negative errno will
1354 * be returned in error cases.
1355 */
1356 int regmap_field_write(struct regmap_field *field, unsigned int val)
1357 {
1358 return regmap_update_bits(field->regmap, field->reg,
1359 field->mask, val << field->shift);
1360 }
1361 EXPORT_SYMBOL_GPL(regmap_field_write);
1362
1363 /*
1364 * regmap_bulk_write(): Write multiple registers to the device
1365 *
1366 * @map: Register map to write to
1367 * @reg: First register to be write from
1368 * @val: Block of data to be written, in native register size for device
1369 * @val_count: Number of registers to write
1370 *
1371 * This function is intended to be used for writing a large block of
1372 * data to the device either in single transfer or multiple transfer.
1373 *
1374 * A value of zero will be returned on success, a negative errno will
1375 * be returned in error cases.
1376 */
1377 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
1378 size_t val_count)
1379 {
1380 int ret = 0, i;
1381 size_t val_bytes = map->format.val_bytes;
1382 void *wval;
1383
1384 if (!map->bus)
1385 return -EINVAL;
1386 if (!map->format.parse_inplace)
1387 return -EINVAL;
1388 if (reg % map->reg_stride)
1389 return -EINVAL;
1390
1391 map->lock(map->lock_arg);
1392
1393 /* No formatting is require if val_byte is 1 */
1394 if (val_bytes == 1) {
1395 wval = (void *)val;
1396 } else {
1397 wval = kmemdup(val, val_count * val_bytes, GFP_KERNEL);
1398 if (!wval) {
1399 ret = -ENOMEM;
1400 dev_err(map->dev, "Error in memory allocation\n");
1401 goto out;
1402 }
1403 for (i = 0; i < val_count * val_bytes; i += val_bytes)
1404 map->format.parse_inplace(wval + i);
1405 }
1406 /*
1407 * Some devices does not support bulk write, for
1408 * them we have a series of single write operations.
1409 */
1410 if (map->use_single_rw) {
1411 for (i = 0; i < val_count; i++) {
1412 ret = regmap_raw_write(map,
1413 reg + (i * map->reg_stride),
1414 val + (i * val_bytes),
1415 val_bytes);
1416 if (ret != 0)
1417 return ret;
1418 }
1419 } else {
1420 ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count,
1421 false);
1422 }
1423
1424 if (val_bytes != 1)
1425 kfree(wval);
1426
1427 out:
1428 map->unlock(map->lock_arg);
1429 return ret;
1430 }
1431 EXPORT_SYMBOL_GPL(regmap_bulk_write);
1432
1433 /**
1434 * regmap_raw_write_async(): Write raw values to one or more registers
1435 * asynchronously
1436 *
1437 * @map: Register map to write to
1438 * @reg: Initial register to write to
1439 * @val: Block of data to be written, laid out for direct transmission to the
1440 * device. Must be valid until regmap_async_complete() is called.
1441 * @val_len: Length of data pointed to by val.
1442 *
1443 * This function is intended to be used for things like firmware
1444 * download where a large block of data needs to be transferred to the
1445 * device. No formatting will be done on the data provided.
1446 *
1447 * If supported by the underlying bus the write will be scheduled
1448 * asynchronously, helping maximise I/O speed on higher speed buses
1449 * like SPI. regmap_async_complete() can be called to ensure that all
1450 * asynchrnous writes have been completed.
1451 *
1452 * A value of zero will be returned on success, a negative errno will
1453 * be returned in error cases.
1454 */
1455 int regmap_raw_write_async(struct regmap *map, unsigned int reg,
1456 const void *val, size_t val_len)
1457 {
1458 int ret;
1459
1460 if (val_len % map->format.val_bytes)
1461 return -EINVAL;
1462 if (reg % map->reg_stride)
1463 return -EINVAL;
1464
1465 map->lock(map->lock_arg);
1466
1467 ret = _regmap_raw_write(map, reg, val, val_len, true);
1468
1469 map->unlock(map->lock_arg);
1470
1471 return ret;
1472 }
1473 EXPORT_SYMBOL_GPL(regmap_raw_write_async);
1474
1475 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
1476 unsigned int val_len)
1477 {
1478 struct regmap_range_node *range;
1479 u8 *u8 = map->work_buf;
1480 int ret;
1481
1482 WARN_ON(!map->bus);
1483
1484 range = _regmap_range_lookup(map, reg);
1485 if (range) {
1486 ret = _regmap_select_page(map, &reg, range,
1487 val_len / map->format.val_bytes);
1488 if (ret != 0)
1489 return ret;
1490 }
1491
1492 map->format.format_reg(map->work_buf, reg, map->reg_shift);
1493
1494 /*
1495 * Some buses or devices flag reads by setting the high bits in the
1496 * register addresss; since it's always the high bits for all
1497 * current formats we can do this here rather than in
1498 * formatting. This may break if we get interesting formats.
1499 */
1500 u8[0] |= map->read_flag_mask;
1501
1502 trace_regmap_hw_read_start(map->dev, reg,
1503 val_len / map->format.val_bytes);
1504
1505 ret = map->bus->read(map->bus_context, map->work_buf,
1506 map->format.reg_bytes + map->format.pad_bytes,
1507 val, val_len);
1508
1509 trace_regmap_hw_read_done(map->dev, reg,
1510 val_len / map->format.val_bytes);
1511
1512 return ret;
1513 }
1514
1515 static int _regmap_bus_read(void *context, unsigned int reg,
1516 unsigned int *val)
1517 {
1518 int ret;
1519 struct regmap *map = context;
1520
1521 if (!map->format.parse_val)
1522 return -EINVAL;
1523
1524 ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
1525 if (ret == 0)
1526 *val = map->format.parse_val(map->work_buf);
1527
1528 return ret;
1529 }
1530
1531 static int _regmap_read(struct regmap *map, unsigned int reg,
1532 unsigned int *val)
1533 {
1534 int ret;
1535 void *context = _regmap_map_get_context(map);
1536
1537 WARN_ON(!map->reg_read);
1538
1539 if (!map->cache_bypass) {
1540 ret = regcache_read(map, reg, val);
1541 if (ret == 0)
1542 return 0;
1543 }
1544
1545 if (map->cache_only)
1546 return -EBUSY;
1547
1548 ret = map->reg_read(context, reg, val);
1549 if (ret == 0) {
1550 #ifdef LOG_DEVICE
1551 if (strcmp(dev_name(map->dev), LOG_DEVICE) == 0)
1552 dev_info(map->dev, "%x => %x\n", reg, *val);
1553 #endif
1554
1555 trace_regmap_reg_read(map->dev, reg, *val);
1556
1557 if (!map->cache_bypass)
1558 regcache_write(map, reg, *val);
1559 }
1560
1561 return ret;
1562 }
1563
1564 /**
1565 * regmap_read(): Read a value from a single register
1566 *
1567 * @map: Register map to write to
1568 * @reg: Register to be read from
1569 * @val: Pointer to store read value
1570 *
1571 * A value of zero will be returned on success, a negative errno will
1572 * be returned in error cases.
1573 */
1574 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
1575 {
1576 int ret;
1577
1578 if (reg % map->reg_stride)
1579 return -EINVAL;
1580
1581 map->lock(map->lock_arg);
1582
1583 ret = _regmap_read(map, reg, val);
1584
1585 map->unlock(map->lock_arg);
1586
1587 return ret;
1588 }
1589 EXPORT_SYMBOL_GPL(regmap_read);
1590
1591 /**
1592 * regmap_raw_read(): Read raw data from the device
1593 *
1594 * @map: Register map to write to
1595 * @reg: First register to be read from
1596 * @val: Pointer to store read value
1597 * @val_len: Size of data to read
1598 *
1599 * A value of zero will be returned on success, a negative errno will
1600 * be returned in error cases.
1601 */
1602 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
1603 size_t val_len)
1604 {
1605 size_t val_bytes = map->format.val_bytes;
1606 size_t val_count = val_len / val_bytes;
1607 unsigned int v;
1608 int ret, i;
1609
1610 if (!map->bus)
1611 return -EINVAL;
1612 if (val_len % map->format.val_bytes)
1613 return -EINVAL;
1614 if (reg % map->reg_stride)
1615 return -EINVAL;
1616
1617 map->lock(map->lock_arg);
1618
1619 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
1620 map->cache_type == REGCACHE_NONE) {
1621 /* Physical block read if there's no cache involved */
1622 ret = _regmap_raw_read(map, reg, val, val_len);
1623
1624 } else {
1625 /* Otherwise go word by word for the cache; should be low
1626 * cost as we expect to hit the cache.
1627 */
1628 for (i = 0; i < val_count; i++) {
1629 ret = _regmap_read(map, reg + (i * map->reg_stride),
1630 &v);
1631 if (ret != 0)
1632 goto out;
1633
1634 map->format.format_val(val + (i * val_bytes), v, 0);
1635 }
1636 }
1637
1638 out:
1639 map->unlock(map->lock_arg);
1640
1641 return ret;
1642 }
1643 EXPORT_SYMBOL_GPL(regmap_raw_read);
1644
1645 /**
1646 * regmap_field_read(): Read a value to a single register field
1647 *
1648 * @field: Register field to read from
1649 * @val: Pointer to store read value
1650 *
1651 * A value of zero will be returned on success, a negative errno will
1652 * be returned in error cases.
1653 */
1654 int regmap_field_read(struct regmap_field *field, unsigned int *val)
1655 {
1656 int ret;
1657 unsigned int reg_val;
1658 ret = regmap_read(field->regmap, field->reg, &reg_val);
1659 if (ret != 0)
1660 return ret;
1661
1662 reg_val &= field->mask;
1663 reg_val >>= field->shift;
1664 *val = reg_val;
1665
1666 return ret;
1667 }
1668 EXPORT_SYMBOL_GPL(regmap_field_read);
1669
1670 /**
1671 * regmap_bulk_read(): Read multiple registers from the device
1672 *
1673 * @map: Register map to write to
1674 * @reg: First register to be read from
1675 * @val: Pointer to store read value, in native register size for device
1676 * @val_count: Number of registers to read
1677 *
1678 * A value of zero will be returned on success, a negative errno will
1679 * be returned in error cases.
1680 */
1681 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
1682 size_t val_count)
1683 {
1684 int ret, i;
1685 size_t val_bytes = map->format.val_bytes;
1686 bool vol = regmap_volatile_range(map, reg, val_count);
1687
1688 if (!map->bus)
1689 return -EINVAL;
1690 if (!map->format.parse_inplace)
1691 return -EINVAL;
1692 if (reg % map->reg_stride)
1693 return -EINVAL;
1694
1695 if (vol || map->cache_type == REGCACHE_NONE) {
1696 /*
1697 * Some devices does not support bulk read, for
1698 * them we have a series of single read operations.
1699 */
1700 if (map->use_single_rw) {
1701 for (i = 0; i < val_count; i++) {
1702 ret = regmap_raw_read(map,
1703 reg + (i * map->reg_stride),
1704 val + (i * val_bytes),
1705 val_bytes);
1706 if (ret != 0)
1707 return ret;
1708 }
1709 } else {
1710 ret = regmap_raw_read(map, reg, val,
1711 val_bytes * val_count);
1712 if (ret != 0)
1713 return ret;
1714 }
1715
1716 for (i = 0; i < val_count * val_bytes; i += val_bytes)
1717 map->format.parse_inplace(val + i);
1718 } else {
1719 for (i = 0; i < val_count; i++) {
1720 unsigned int ival;
1721 ret = regmap_read(map, reg + (i * map->reg_stride),
1722 &ival);
1723 if (ret != 0)
1724 return ret;
1725 memcpy(val + (i * val_bytes), &ival, val_bytes);
1726 }
1727 }
1728
1729 return 0;
1730 }
1731 EXPORT_SYMBOL_GPL(regmap_bulk_read);
1732
1733 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
1734 unsigned int mask, unsigned int val,
1735 bool *change)
1736 {
1737 int ret;
1738 unsigned int tmp, orig;
1739
1740 ret = _regmap_read(map, reg, &orig);
1741 if (ret != 0)
1742 return ret;
1743
1744 tmp = orig & ~mask;
1745 tmp |= val & mask;
1746
1747 if (tmp != orig) {
1748 ret = _regmap_write(map, reg, tmp);
1749 *change = true;
1750 } else {
1751 *change = false;
1752 }
1753
1754 return ret;
1755 }
1756
1757 /**
1758 * regmap_update_bits: Perform a read/modify/write cycle on the register map
1759 *
1760 * @map: Register map to update
1761 * @reg: Register to update
1762 * @mask: Bitmask to change
1763 * @val: New value for bitmask
1764 *
1765 * Returns zero for success, a negative number on error.
1766 */
1767 int regmap_update_bits(struct regmap *map, unsigned int reg,
1768 unsigned int mask, unsigned int val)
1769 {
1770 bool change;
1771 int ret;
1772
1773 map->lock(map->lock_arg);
1774 ret = _regmap_update_bits(map, reg, mask, val, &change);
1775 map->unlock(map->lock_arg);
1776
1777 return ret;
1778 }
1779 EXPORT_SYMBOL_GPL(regmap_update_bits);
1780
1781 /**
1782 * regmap_update_bits_check: Perform a read/modify/write cycle on the
1783 * register map and report if updated
1784 *
1785 * @map: Register map to update
1786 * @reg: Register to update
1787 * @mask: Bitmask to change
1788 * @val: New value for bitmask
1789 * @change: Boolean indicating if a write was done
1790 *
1791 * Returns zero for success, a negative number on error.
1792 */
1793 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
1794 unsigned int mask, unsigned int val,
1795 bool *change)
1796 {
1797 int ret;
1798
1799 map->lock(map->lock_arg);
1800 ret = _regmap_update_bits(map, reg, mask, val, change);
1801 map->unlock(map->lock_arg);
1802 return ret;
1803 }
1804 EXPORT_SYMBOL_GPL(regmap_update_bits_check);
1805
1806 void regmap_async_complete_cb(struct regmap_async *async, int ret)
1807 {
1808 struct regmap *map = async->map;
1809 bool wake;
1810
1811 trace_regmap_async_io_complete(map->dev);
1812
1813 spin_lock(&map->async_lock);
1814
1815 list_del(&async->list);
1816 wake = list_empty(&map->async_list);
1817
1818 if (ret != 0)
1819 map->async_ret = ret;
1820
1821 spin_unlock(&map->async_lock);
1822
1823 schedule_work(&async->cleanup);
1824
1825 if (wake)
1826 wake_up(&map->async_waitq);
1827 }
1828 EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
1829
1830 static int regmap_async_is_done(struct regmap *map)
1831 {
1832 unsigned long flags;
1833 int ret;
1834
1835 spin_lock_irqsave(&map->async_lock, flags);
1836 ret = list_empty(&map->async_list);
1837 spin_unlock_irqrestore(&map->async_lock, flags);
1838
1839 return ret;
1840 }
1841
1842 /**
1843 * regmap_async_complete: Ensure all asynchronous I/O has completed.
1844 *
1845 * @map: Map to operate on.
1846 *
1847 * Blocks until any pending asynchronous I/O has completed. Returns
1848 * an error code for any failed I/O operations.
1849 */
1850 int regmap_async_complete(struct regmap *map)
1851 {
1852 unsigned long flags;
1853 int ret;
1854
1855 /* Nothing to do with no async support */
1856 if (!map->bus || !map->bus->async_write)
1857 return 0;
1858
1859 trace_regmap_async_complete_start(map->dev);
1860
1861 wait_event(map->async_waitq, regmap_async_is_done(map));
1862
1863 spin_lock_irqsave(&map->async_lock, flags);
1864 ret = map->async_ret;
1865 map->async_ret = 0;
1866 spin_unlock_irqrestore(&map->async_lock, flags);
1867
1868 trace_regmap_async_complete_done(map->dev);
1869
1870 return ret;
1871 }
1872 EXPORT_SYMBOL_GPL(regmap_async_complete);
1873
1874 /**
1875 * regmap_register_patch: Register and apply register updates to be applied
1876 * on device initialistion
1877 *
1878 * @map: Register map to apply updates to.
1879 * @regs: Values to update.
1880 * @num_regs: Number of entries in regs.
1881 *
1882 * Register a set of register updates to be applied to the device
1883 * whenever the device registers are synchronised with the cache and
1884 * apply them immediately. Typically this is used to apply
1885 * corrections to be applied to the device defaults on startup, such
1886 * as the updates some vendors provide to undocumented registers.
1887 */
1888 int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
1889 int num_regs)
1890 {
1891 int i, ret;
1892 bool bypass;
1893
1894 /* If needed the implementation can be extended to support this */
1895 if (map->patch)
1896 return -EBUSY;
1897
1898 map->lock(map->lock_arg);
1899
1900 bypass = map->cache_bypass;
1901
1902 map->cache_bypass = true;
1903
1904 /* Write out first; it's useful to apply even if we fail later. */
1905 for (i = 0; i < num_regs; i++) {
1906 ret = _regmap_write(map, regs[i].reg, regs[i].def);
1907 if (ret != 0) {
1908 dev_err(map->dev, "Failed to write %x = %x: %d\n",
1909 regs[i].reg, regs[i].def, ret);
1910 goto out;
1911 }
1912 }
1913
1914 map->patch = kcalloc(num_regs, sizeof(struct reg_default), GFP_KERNEL);
1915 if (map->patch != NULL) {
1916 memcpy(map->patch, regs,
1917 num_regs * sizeof(struct reg_default));
1918 map->patch_regs = num_regs;
1919 } else {
1920 ret = -ENOMEM;
1921 }
1922
1923 out:
1924 map->cache_bypass = bypass;
1925
1926 map->unlock(map->lock_arg);
1927
1928 return ret;
1929 }
1930 EXPORT_SYMBOL_GPL(regmap_register_patch);
1931
1932 /*
1933 * regmap_get_val_bytes(): Report the size of a register value
1934 *
1935 * Report the size of a register value, mainly intended to for use by
1936 * generic infrastructure built on top of regmap.
1937 */
1938 int regmap_get_val_bytes(struct regmap *map)
1939 {
1940 if (map->format.format_write)
1941 return -EINVAL;
1942
1943 return map->format.val_bytes;
1944 }
1945 EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
1946
1947 static int __init regmap_initcall(void)
1948 {
1949 regmap_debugfs_initcall();
1950
1951 return 0;
1952 }
1953 postcore_initcall(regmap_initcall);
Linus' kernel tree