1
2
3
4
5
6
7
8
9#include <linux/device.h>
10#include <linux/slab.h>
11#include <linux/export.h>
12#include <linux/mutex.h>
13#include <linux/err.h>
14#include <linux/of.h>
15#include <linux/rbtree.h>
16#include <linux/sched.h>
17#include <linux/delay.h>
18#include <linux/log2.h>
19#include <linux/hwspinlock.h>
20
21#define CREATE_TRACE_POINTS
22#include "trace.h"
23
24#include "internal.h"
25
26
27
28
29
30
31
32#undef LOG_DEVICE
33
34#ifdef LOG_DEVICE
35static inline bool regmap_should_log(struct regmap *map)
36{
37 return (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0);
38}
39#else
40static inline bool regmap_should_log(struct regmap *map) { return false; }
41#endif
42
43
44static int _regmap_update_bits(struct regmap *map, unsigned int reg,
45 unsigned int mask, unsigned int val,
46 bool *change, bool force_write);
47
48static int _regmap_bus_reg_read(void *context, unsigned int reg,
49 unsigned int *val);
50static int _regmap_bus_read(void *context, unsigned int reg,
51 unsigned int *val);
52static int _regmap_bus_formatted_write(void *context, unsigned int reg,
53 unsigned int val);
54static int _regmap_bus_reg_write(void *context, unsigned int reg,
55 unsigned int val);
56static int _regmap_bus_raw_write(void *context, unsigned int reg,
57 unsigned int val);
58
59bool regmap_reg_in_ranges(unsigned int reg,
60 const struct regmap_range *ranges,
61 unsigned int nranges)
62{
63 const struct regmap_range *r;
64 int i;
65
66 for (i = 0, r = ranges; i < nranges; i++, r++)
67 if (regmap_reg_in_range(reg, r))
68 return true;
69 return false;
70}
71EXPORT_SYMBOL_GPL(regmap_reg_in_ranges);
72
73bool regmap_check_range_table(struct regmap *map, unsigned int reg,
74 const struct regmap_access_table *table)
75{
76
77 if (regmap_reg_in_ranges(reg, table->no_ranges, table->n_no_ranges))
78 return false;
79
80
81 if (!table->n_yes_ranges)
82 return true;
83
84 return regmap_reg_in_ranges(reg, table->yes_ranges,
85 table->n_yes_ranges);
86}
87EXPORT_SYMBOL_GPL(regmap_check_range_table);
88
89bool regmap_writeable(struct regmap *map, unsigned int reg)
90{
91 if (map->max_register && reg > map->max_register)
92 return false;
93
94 if (map->writeable_reg)
95 return map->writeable_reg(map->dev, reg);
96
97 if (map->wr_table)
98 return regmap_check_range_table(map, reg, map->wr_table);
99
100 return true;
101}
102
103bool regmap_cached(struct regmap *map, unsigned int reg)
104{
105 int ret;
106 unsigned int val;
107
108 if (map->cache_type == REGCACHE_NONE)
109 return false;
110
111 if (!map->cache_ops)
112 return false;
113
114 if (map->max_register && reg > map->max_register)
115 return false;
116
117 map->lock(map->lock_arg);
118 ret = regcache_read(map, reg, &val);
119 map->unlock(map->lock_arg);
120 if (ret)
121 return false;
122
123 return true;
124}
125
126bool regmap_readable(struct regmap *map, unsigned int reg)
127{
128 if (!map->reg_read)
129 return false;
130
131 if (map->max_register && reg > map->max_register)
132 return false;
133
134 if (map->format.format_write)
135 return false;
136
137 if (map->readable_reg)
138 return map->readable_reg(map->dev, reg);
139
140 if (map->rd_table)
141 return regmap_check_range_table(map, reg, map->rd_table);
142
143 return true;
144}
145
146bool regmap_volatile(struct regmap *map, unsigned int reg)
147{
148 if (!map->format.format_write && !regmap_readable(map, reg))
149 return false;
150
151 if (map->volatile_reg)
152 return map->volatile_reg(map->dev, reg);
153
154 if (map->volatile_table)
155 return regmap_check_range_table(map, reg, map->volatile_table);
156
157 if (map->cache_ops)
158 return false;
159 else
160 return true;
161}
162
163bool regmap_precious(struct regmap *map, unsigned int reg)
164{
165 if (!regmap_readable(map, reg))
166 return false;
167
168 if (map->precious_reg)
169 return map->precious_reg(map->dev, reg);
170
171 if (map->precious_table)
172 return regmap_check_range_table(map, reg, map->precious_table);
173
174 return false;
175}
176
177bool regmap_writeable_noinc(struct regmap *map, unsigned int reg)
178{
179 if (map->writeable_noinc_reg)
180 return map->writeable_noinc_reg(map->dev, reg);
181
182 if (map->wr_noinc_table)
183 return regmap_check_range_table(map, reg, map->wr_noinc_table);
184
185 return true;
186}
187
188bool regmap_readable_noinc(struct regmap *map, unsigned int reg)
189{
190 if (map->readable_noinc_reg)
191 return map->readable_noinc_reg(map->dev, reg);
192
193 if (map->rd_noinc_table)
194 return regmap_check_range_table(map, reg, map->rd_noinc_table);
195
196 return true;
197}
198
199static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
200 size_t num)
201{
202 unsigned int i;
203
204 for (i = 0; i < num; i++)
205 if (!regmap_volatile(map, reg + regmap_get_offset(map, i)))
206 return false;
207
208 return true;
209}
210
211static void regmap_format_2_6_write(struct regmap *map,
212 unsigned int reg, unsigned int val)
213{
214 u8 *out = map->work_buf;
215
216 *out = (reg << 6) | val;
217}
218
219static void regmap_format_4_12_write(struct regmap *map,
220 unsigned int reg, unsigned int val)
221{
222 __be16 *out = map->work_buf;
223 *out = cpu_to_be16((reg << 12) | val);
224}
225
226static void regmap_format_7_9_write(struct regmap *map,
227 unsigned int reg, unsigned int val)
228{
229 __be16 *out = map->work_buf;
230 *out = cpu_to_be16((reg << 9) | val);
231}
232
233static void regmap_format_10_14_write(struct regmap *map,
234 unsigned int reg, unsigned int val)
235{
236 u8 *out = map->work_buf;
237
238 out[2] = val;
239 out[1] = (val >> 8) | (reg << 6);
240 out[0] = reg >> 2;
241}
242
243static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
244{
245 u8 *b = buf;
246
247 b[0] = val << shift;
248}
249
250static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
251{
252 __be16 *b = buf;
253
254 b[0] = cpu_to_be16(val << shift);
255}
256
257static void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)
258{
259 __le16 *b = buf;
260
261 b[0] = cpu_to_le16(val << shift);
262}
263
264static void regmap_format_16_native(void *buf, unsigned int val,
265 unsigned int shift)
266{
267 *(u16 *)buf = val << shift;
268}
269
270static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
271{
272 u8 *b = buf;
273
274 val <<= shift;
275
276 b[0] = val >> 16;
277 b[1] = val >> 8;
278 b[2] = val;
279}
280
281static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
282{
283 __be32 *b = buf;
284
285 b[0] = cpu_to_be32(val << shift);
286}
287
288static void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)
289{
290 __le32 *b = buf;
291
292 b[0] = cpu_to_le32(val << shift);
293}
294
295static void regmap_format_32_native(void *buf, unsigned int val,
296 unsigned int shift)
297{
298 *(u32 *)buf = val << shift;
299}
300
301#ifdef CONFIG_64BIT
302static void regmap_format_64_be(void *buf, unsigned int val, unsigned int shift)
303{
304 __be64 *b = buf;
305
306 b[0] = cpu_to_be64((u64)val << shift);
307}
308
309static void regmap_format_64_le(void *buf, unsigned int val, unsigned int shift)
310{
311 __le64 *b = buf;
312
313 b[0] = cpu_to_le64((u64)val << shift);
314}
315
316static void regmap_format_64_native(void *buf, unsigned int val,
317 unsigned int shift)
318{
319 *(u64 *)buf = (u64)val << shift;
320}
321#endif
322
323static void regmap_parse_inplace_noop(void *buf)
324{
325}
326
327static unsigned int regmap_parse_8(const void *buf)
328{
329 const u8 *b = buf;
330
331 return b[0];
332}
333
334static unsigned int regmap_parse_16_be(const void *buf)
335{
336 const __be16 *b = buf;
337
338 return be16_to_cpu(b[0]);
339}
340
341static unsigned int regmap_parse_16_le(const void *buf)
342{
343 const __le16 *b = buf;
344
345 return le16_to_cpu(b[0]);
346}
347
348static void regmap_parse_16_be_inplace(void *buf)
349{
350 __be16 *b = buf;
351
352 b[0] = be16_to_cpu(b[0]);
353}
354
355static void regmap_parse_16_le_inplace(void *buf)
356{
357 __le16 *b = buf;
358
359 b[0] = le16_to_cpu(b[0]);
360}
361
362static unsigned int regmap_parse_16_native(const void *buf)
363{
364 return *(u16 *)buf;
365}
366
367static unsigned int regmap_parse_24(const void *buf)
368{
369 const u8 *b = buf;
370 unsigned int ret = b[2];
371 ret |= ((unsigned int)b[1]) << 8;
372 ret |= ((unsigned int)b[0]) << 16;
373
374 return ret;
375}
376
377static unsigned int regmap_parse_32_be(const void *buf)
378{
379 const __be32 *b = buf;
380
381 return be32_to_cpu(b[0]);
382}
383
384static unsigned int regmap_parse_32_le(const void *buf)
385{
386 const __le32 *b = buf;
387
388 return le32_to_cpu(b[0]);
389}
390
391static void regmap_parse_32_be_inplace(void *buf)
392{
393 __be32 *b = buf;
394
395 b[0] = be32_to_cpu(b[0]);
396}
397
398static void regmap_parse_32_le_inplace(void *buf)
399{
400 __le32 *b = buf;
401
402 b[0] = le32_to_cpu(b[0]);
403}
404
405static unsigned int regmap_parse_32_native(const void *buf)
406{
407 return *(u32 *)buf;
408}
409
410#ifdef CONFIG_64BIT
411static unsigned int regmap_parse_64_be(const void *buf)
412{
413 const __be64 *b = buf;
414
415 return be64_to_cpu(b[0]);
416}
417
418static unsigned int regmap_parse_64_le(const void *buf)
419{
420 const __le64 *b = buf;
421
422 return le64_to_cpu(b[0]);
423}
424
425static void regmap_parse_64_be_inplace(void *buf)
426{
427 __be64 *b = buf;
428
429 b[0] = be64_to_cpu(b[0]);
430}
431
432static void regmap_parse_64_le_inplace(void *buf)
433{
434 __le64 *b = buf;
435
436 b[0] = le64_to_cpu(b[0]);
437}
438
439static unsigned int regmap_parse_64_native(const void *buf)
440{
441 return *(u64 *)buf;
442}
443#endif
444
445static void regmap_lock_hwlock(void *__map)
446{
447 struct regmap *map = __map;
448
449 hwspin_lock_timeout(map->hwlock, UINT_MAX);
450}
451
452static void regmap_lock_hwlock_irq(void *__map)
453{
454 struct regmap *map = __map;
455
456 hwspin_lock_timeout_irq(map->hwlock, UINT_MAX);
457}
458
459static void regmap_lock_hwlock_irqsave(void *__map)
460{
461 struct regmap *map = __map;
462
463 hwspin_lock_timeout_irqsave(map->hwlock, UINT_MAX,
464 &map->spinlock_flags);
465}
466
467static void regmap_unlock_hwlock(void *__map)
468{
469 struct regmap *map = __map;
470
471 hwspin_unlock(map->hwlock);
472}
473
474static void regmap_unlock_hwlock_irq(void *__map)
475{
476 struct regmap *map = __map;
477
478 hwspin_unlock_irq(map->hwlock);
479}
480
481static void regmap_unlock_hwlock_irqrestore(void *__map)
482{
483 struct regmap *map = __map;
484
485 hwspin_unlock_irqrestore(map->hwlock, &map->spinlock_flags);
486}
487
488static void regmap_lock_unlock_none(void *__map)
489{
490
491}
492
493static void regmap_lock_mutex(void *__map)
494{
495 struct regmap *map = __map;
496 mutex_lock(&map->mutex);
497}
498
499static void regmap_unlock_mutex(void *__map)
500{
501 struct regmap *map = __map;
502 mutex_unlock(&map->mutex);
503}
504
505static void regmap_lock_spinlock(void *__map)
506__acquires(&map->spinlock)
507{
508 struct regmap *map = __map;
509 unsigned long flags;
510
511 spin_lock_irqsave(&map->spinlock, flags);
512 map->spinlock_flags = flags;
513}
514
515static void regmap_unlock_spinlock(void *__map)
516__releases(&map->spinlock)
517{
518 struct regmap *map = __map;
519 spin_unlock_irqrestore(&map->spinlock, map->spinlock_flags);
520}
521
522static void dev_get_regmap_release(struct device *dev, void *res)
523{
524
525
526
527
528
529}
530
531static bool _regmap_range_add(struct regmap *map,
532 struct regmap_range_node *data)
533{
534 struct rb_root *root = &map->range_tree;
535 struct rb_node **new = &(root->rb_node), *parent = NULL;
536
537 while (*new) {
538 struct regmap_range_node *this =
539 rb_entry(*new, struct regmap_range_node, node);
540
541 parent = *new;
542 if (data->range_max < this->range_min)
543 new = &((*new)->rb_left);
544 else if (data->range_min > this->range_max)
545 new = &((*new)->rb_right);
546 else
547 return false;
548 }
549
550 rb_link_node(&data->node, parent, new);
551 rb_insert_color(&data->node, root);
552
553 return true;
554}
555
556static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
557 unsigned int reg)
558{
559 struct rb_node *node = map->range_tree.rb_node;
560
561 while (node) {
562 struct regmap_range_node *this =
563 rb_entry(node, struct regmap_range_node, node);
564
565 if (reg < this->range_min)
566 node = node->rb_left;
567 else if (reg > this->range_max)
568 node = node->rb_right;
569 else
570 return this;
571 }
572
573 return NULL;
574}
575
576static void regmap_range_exit(struct regmap *map)
577{
578 struct rb_node *next;
579 struct regmap_range_node *range_node;
580
581 next = rb_first(&map->range_tree);
582 while (next) {
583 range_node = rb_entry(next, struct regmap_range_node, node);
584 next = rb_next(&range_node->node);
585 rb_erase(&range_node->node, &map->range_tree);
586 kfree(range_node);
587 }
588
589 kfree(map->selector_work_buf);
590}
591
592int regmap_attach_dev(struct device *dev, struct regmap *map,
593 const struct regmap_config *config)
594{
595 struct regmap **m;
596
597 map->dev = dev;
598
599 regmap_debugfs_init(map, config->name);
600
601
602 m = devres_alloc(dev_get_regmap_release, sizeof(*m), GFP_KERNEL);
603 if (!m) {
604 regmap_debugfs_exit(map);
605 return -ENOMEM;
606 }
607 *m = map;
608 devres_add(dev, m);
609
610 return 0;
611}
612EXPORT_SYMBOL_GPL(regmap_attach_dev);
613
614static enum regmap_endian regmap_get_reg_endian(const struct regmap_bus *bus,
615 const struct regmap_config *config)
616{
617 enum regmap_endian endian;
618
619
620 endian = config->reg_format_endian;
621
622
623 if (endian != REGMAP_ENDIAN_DEFAULT)
624 return endian;
625
626
627 if (bus && bus->reg_format_endian_default)
628 endian = bus->reg_format_endian_default;
629
630
631 if (endian != REGMAP_ENDIAN_DEFAULT)
632 return endian;
633
634
635 return REGMAP_ENDIAN_BIG;
636}
637
638enum regmap_endian regmap_get_val_endian(struct device *dev,
639 const struct regmap_bus *bus,
640 const struct regmap_config *config)
641{
642 struct device_node *np;
643 enum regmap_endian endian;
644
645
646 endian = config->val_format_endian;
647
648
649 if (endian != REGMAP_ENDIAN_DEFAULT)
650 return endian;
651
652
653 if (dev && dev->of_node) {
654 np = dev->of_node;
655
656
657 if (of_property_read_bool(np, "big-endian"))
658 endian = REGMAP_ENDIAN_BIG;
659 else if (of_property_read_bool(np, "little-endian"))
660 endian = REGMAP_ENDIAN_LITTLE;
661 else if (of_property_read_bool(np, "native-endian"))
662 endian = REGMAP_ENDIAN_NATIVE;
663
664
665 if (endian != REGMAP_ENDIAN_DEFAULT)
666 return endian;
667 }
668
669
670 if (bus && bus->val_format_endian_default)
671 endian = bus->val_format_endian_default;
672
673
674 if (endian != REGMAP_ENDIAN_DEFAULT)
675 return endian;
676
677
678 return REGMAP_ENDIAN_BIG;
679}
680EXPORT_SYMBOL_GPL(regmap_get_val_endian);
681
682struct regmap *__regmap_init(struct device *dev,
683 const struct regmap_bus *bus,
684 void *bus_context,
685 const struct regmap_config *config,
686 struct lock_class_key *lock_key,
687 const char *lock_name)
688{
689 struct regmap *map;
690 int ret = -EINVAL;
691 enum regmap_endian reg_endian, val_endian;
692 int i, j;
693
694 if (!config)
695 goto err;
696
697 map = kzalloc(sizeof(*map), GFP_KERNEL);
698 if (map == NULL) {
699 ret = -ENOMEM;
700 goto err;
701 }
702
703 if (config->name) {
704 map->name = kstrdup_const(config->name, GFP_KERNEL);
705 if (!map->name) {
706 ret = -ENOMEM;
707 goto err_map;
708 }
709 }
710
711 if (config->disable_locking) {
712 map->lock = map->unlock = regmap_lock_unlock_none;
713 regmap_debugfs_disable(map);
714 } else if (config->lock && config->unlock) {
715 map->lock = config->lock;
716 map->unlock = config->unlock;
717 map->lock_arg = config->lock_arg;
718 } else if (config->use_hwlock) {
719 map->hwlock = hwspin_lock_request_specific(config->hwlock_id);
720 if (!map->hwlock) {
721 ret = -ENXIO;
722 goto err_name;
723 }
724
725 switch (config->hwlock_mode) {
726 case HWLOCK_IRQSTATE:
727 map->lock = regmap_lock_hwlock_irqsave;
728 map->unlock = regmap_unlock_hwlock_irqrestore;
729 break;
730 case HWLOCK_IRQ:
731 map->lock = regmap_lock_hwlock_irq;
732 map->unlock = regmap_unlock_hwlock_irq;
733 break;
734 default:
735 map->lock = regmap_lock_hwlock;
736 map->unlock = regmap_unlock_hwlock;
737 break;
738 }
739
740 map->lock_arg = map;
741 } else {
742 if ((bus && bus->fast_io) ||
743 config->fast_io) {
744 spin_lock_init(&map->spinlock);
745 map->lock = regmap_lock_spinlock;
746 map->unlock = regmap_unlock_spinlock;
747 lockdep_set_class_and_name(&map->spinlock,
748 lock_key, lock_name);
749 } else {
750 mutex_init(&map->mutex);
751 map->lock = regmap_lock_mutex;
752 map->unlock = regmap_unlock_mutex;
753 lockdep_set_class_and_name(&map->mutex,
754 lock_key, lock_name);
755 }
756 map->lock_arg = map;
757 }
758
759
760
761
762
763 if ((bus && bus->fast_io) || config->fast_io)
764 map->alloc_flags = GFP_ATOMIC;
765 else
766 map->alloc_flags = GFP_KERNEL;
767
768 map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
769 map->format.pad_bytes = config->pad_bits / 8;
770 map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
771 map->format.buf_size = DIV_ROUND_UP(config->reg_bits +
772 config->val_bits + config->pad_bits, 8);
773 map->reg_shift = config->pad_bits % 8;
774 if (config->reg_stride)
775 map->reg_stride = config->reg_stride;
776 else
777 map->reg_stride = 1;
778 if (is_power_of_2(map->reg_stride))
779 map->reg_stride_order = ilog2(map->reg_stride);
780 else
781 map->reg_stride_order = -1;
782 map->use_single_read = config->use_single_read || !bus || !bus->read;
783 map->use_single_write = config->use_single_write || !bus || !bus->write;
784 map->can_multi_write = config->can_multi_write && bus && bus->write;
785 if (bus) {
786 map->max_raw_read = bus->max_raw_read;
787 map->max_raw_write = bus->max_raw_write;
788 }
789 map->dev = dev;
790 map->bus = bus;
791 map->bus_context = bus_context;
792 map->max_register = config->max_register;
793 map->wr_table = config->wr_table;
794 map->rd_table = config->rd_table;
795 map->volatile_table = config->volatile_table;
796 map->precious_table = config->precious_table;
797 map->wr_noinc_table = config->wr_noinc_table;
798 map->rd_noinc_table = config->rd_noinc_table;
799 map->writeable_reg = config->writeable_reg;
800 map->readable_reg = config->readable_reg;
801 map->volatile_reg = config->volatile_reg;
802 map->precious_reg = config->precious_reg;
803 map->writeable_noinc_reg = config->writeable_noinc_reg;
804 map->readable_noinc_reg = config->readable_noinc_reg;
805 map->cache_type = config->cache_type;
806
807 spin_lock_init(&map->async_lock);
808 INIT_LIST_HEAD(&map->async_list);
809 INIT_LIST_HEAD(&map->async_free);
810 init_waitqueue_head(&map->async_waitq);
811
812 if (config->read_flag_mask ||
813 config->write_flag_mask ||
814 config->zero_flag_mask) {
815 map->read_flag_mask = config->read_flag_mask;
816 map->write_flag_mask = config->write_flag_mask;
817 } else if (bus) {
818 map->read_flag_mask = bus->read_flag_mask;
819 }
820
821 if (!bus) {
822 map->reg_read = config->reg_read;
823 map->reg_write = config->reg_write;
824
825 map->defer_caching = false;
826 goto skip_format_initialization;
827 } else if (!bus->read || !bus->write) {
828 map->reg_read = _regmap_bus_reg_read;
829 map->reg_write = _regmap_bus_reg_write;
830
831 map->defer_caching = false;
832 goto skip_format_initialization;
833 } else {
834 map->reg_read = _regmap_bus_read;
835 map->reg_update_bits = bus->reg_update_bits;
836 }
837
838 reg_endian = regmap_get_reg_endian(bus, config);
839 val_endian = regmap_get_val_endian(dev, bus, config);
840
841 switch (config->reg_bits + map->reg_shift) {
842 case 2:
843 switch (config->val_bits) {
844 case 6:
845 map->format.format_write = regmap_format_2_6_write;
846 break;
847 default:
848 goto err_hwlock;
849 }
850 break;
851
852 case 4:
853 switch (config->val_bits) {
854 case 12:
855 map->format.format_write = regmap_format_4_12_write;
856 break;
857 default:
858 goto err_hwlock;
859 }
860 break;
861
862 case 7:
863 switch (config->val_bits) {
864 case 9:
865 map->format.format_write = regmap_format_7_9_write;
866 break;
867 default:
868 goto err_hwlock;
869 }
870 break;
871
872 case 10:
873 switch (config->val_bits) {
874 case 14:
875 map->format.format_write = regmap_format_10_14_write;
876 break;
877 default:
878 goto err_hwlock;
879 }
880 break;
881
882 case 8:
883 map->format.format_reg = regmap_format_8;
884 break;
885
886 case 16:
887 switch (reg_endian) {
888 case REGMAP_ENDIAN_BIG:
889 map->format.format_reg = regmap_format_16_be;
890 break;
891 case REGMAP_ENDIAN_LITTLE:
892 map->format.format_reg = regmap_format_16_le;
893 break;
894 case REGMAP_ENDIAN_NATIVE:
895 map->format.format_reg = regmap_format_16_native;
896 break;
897 default:
898 goto err_hwlock;
899 }
900 break;
901
902 case 24:
903 if (reg_endian != REGMAP_ENDIAN_BIG)
904 goto err_hwlock;
905 map->format.format_reg = regmap_format_24;
906 break;
907
908 case 32:
909 switch (reg_endian) {
910 case REGMAP_ENDIAN_BIG:
911 map->format.format_reg = regmap_format_32_be;
912 break;
913 case REGMAP_ENDIAN_LITTLE:
914 map->format.format_reg = regmap_format_32_le;
915 break;
916 case REGMAP_ENDIAN_NATIVE:
917 map->format.format_reg = regmap_format_32_native;
918 break;
919 default:
920 goto err_hwlock;
921 }
922 break;
923
924#ifdef CONFIG_64BIT
925 case 64:
926 switch (reg_endian) {
927 case REGMAP_ENDIAN_BIG:
928 map->format.format_reg = regmap_format_64_be;
929 break;
930 case REGMAP_ENDIAN_LITTLE:
931 map->format.format_reg = regmap_format_64_le;
932 break;
933 case REGMAP_ENDIAN_NATIVE:
934 map->format.format_reg = regmap_format_64_native;
935 break;
936 default:
937 goto err_hwlock;
938 }
939 break;
940#endif
941
942 default:
943 goto err_hwlock;
944 }
945
946 if (val_endian == REGMAP_ENDIAN_NATIVE)
947 map->format.parse_inplace = regmap_parse_inplace_noop;
948
949 switch (config->val_bits) {
950 case 8:
951 map->format.format_val = regmap_format_8;
952 map->format.parse_val = regmap_parse_8;
953 map->format.parse_inplace = regmap_parse_inplace_noop;
954 break;
955 case 16:
956 switch (val_endian) {
957 case REGMAP_ENDIAN_BIG:
958 map->format.format_val = regmap_format_16_be;
959 map->format.parse_val = regmap_parse_16_be;
960 map->format.parse_inplace = regmap_parse_16_be_inplace;
961 break;
962 case REGMAP_ENDIAN_LITTLE:
963 map->format.format_val = regmap_format_16_le;
964 map->format.parse_val = regmap_parse_16_le;
965 map->format.parse_inplace = regmap_parse_16_le_inplace;
966 break;
967 case REGMAP_ENDIAN_NATIVE:
968 map->format.format_val = regmap_format_16_native;
969 map->format.parse_val = regmap_parse_16_native;
970 break;
971 default:
972 goto err_hwlock;
973 }
974 break;
975 case 24:
976 if (val_endian != REGMAP_ENDIAN_BIG)
977 goto err_hwlock;
978 map->format.format_val = regmap_format_24;
979 map->format.parse_val = regmap_parse_24;
980 break;
981 case 32:
982 switch (val_endian) {
983 case REGMAP_ENDIAN_BIG:
984 map->format.format_val = regmap_format_32_be;
985 map->format.parse_val = regmap_parse_32_be;
986 map->format.parse_inplace = regmap_parse_32_be_inplace;
987 break;
988 case REGMAP_ENDIAN_LITTLE:
989 map->format.format_val = regmap_format_32_le;
990 map->format.parse_val = regmap_parse_32_le;
991 map->format.parse_inplace = regmap_parse_32_le_inplace;
992 break;
993 case REGMAP_ENDIAN_NATIVE:
994 map->format.format_val = regmap_format_32_native;
995 map->format.parse_val = regmap_parse_32_native;
996 break;
997 default:
998 goto err_hwlock;
999 }
1000 break;
1001#ifdef CONFIG_64BIT
1002 case 64:
1003 switch (val_endian) {
1004 case REGMAP_ENDIAN_BIG:
1005 map->format.format_val = regmap_format_64_be;
1006 map->format.parse_val = regmap_parse_64_be;
1007 map->format.parse_inplace = regmap_parse_64_be_inplace;
1008 break;
1009 case REGMAP_ENDIAN_LITTLE:
1010 map->format.format_val = regmap_format_64_le;
1011 map->format.parse_val = regmap_parse_64_le;
1012 map->format.parse_inplace = regmap_parse_64_le_inplace;
1013 break;
1014 case REGMAP_ENDIAN_NATIVE:
1015 map->format.format_val = regmap_format_64_native;
1016 map->format.parse_val = regmap_parse_64_native;
1017 break;
1018 default:
1019 goto err_hwlock;
1020 }
1021 break;
1022#endif
1023 }
1024
1025 if (map->format.format_write) {
1026 if ((reg_endian != REGMAP_ENDIAN_BIG) ||
1027 (val_endian != REGMAP_ENDIAN_BIG))
1028 goto err_hwlock;
1029 map->use_single_write = true;
1030 }
1031
1032 if (!map->format.format_write &&
1033 !(map->format.format_reg && map->format.format_val))
1034 goto err_hwlock;
1035
1036 map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
1037 if (map->work_buf == NULL) {
1038 ret = -ENOMEM;
1039 goto err_hwlock;
1040 }
1041
1042 if (map->format.format_write) {
1043 map->defer_caching = false;
1044 map->reg_write = _regmap_bus_formatted_write;
1045 } else if (map->format.format_val) {
1046 map->defer_caching = true;
1047 map->reg_write = _regmap_bus_raw_write;
1048 }
1049
1050skip_format_initialization:
1051
1052 map->range_tree = RB_ROOT;
1053 for (i = 0; i < config->num_ranges; i++) {
1054 const struct regmap_range_cfg *range_cfg = &config->ranges[i];
1055 struct regmap_range_node *new;
1056
1057
1058 if (range_cfg->range_max < range_cfg->range_min) {
1059 dev_err(map->dev, "Invalid range %d: %d < %d\n", i,
1060 range_cfg->range_max, range_cfg->range_min);
1061 goto err_range;
1062 }
1063
1064 if (range_cfg->range_max > map->max_register) {
1065 dev_err(map->dev, "Invalid range %d: %d > %d\n", i,
1066 range_cfg->range_max, map->max_register);
1067 goto err_range;
1068 }
1069
1070 if (range_cfg->selector_reg > map->max_register) {
1071 dev_err(map->dev,
1072 "Invalid range %d: selector out of map\n", i);
1073 goto err_range;
1074 }
1075
1076 if (range_cfg->window_len == 0) {
1077 dev_err(map->dev, "Invalid range %d: window_len 0\n",
1078 i);
1079 goto err_range;
1080 }
1081
1082
1083
1084 for (j = 0; j < config->num_ranges; j++) {
1085 unsigned sel_reg = config->ranges[j].selector_reg;
1086 unsigned win_min = config->ranges[j].window_start;
1087 unsigned win_max = win_min +
1088 config->ranges[j].window_len - 1;
1089
1090
1091 if (j == i)
1092 continue;
1093
1094 if (range_cfg->range_min <= sel_reg &&
1095 sel_reg <= range_cfg->range_max) {
1096 dev_err(map->dev,
1097 "Range %d: selector for %d in window\n",
1098 i, j);
1099 goto err_range;
1100 }
1101
1102 if (!(win_max < range_cfg->range_min ||
1103 win_min > range_cfg->range_max)) {
1104 dev_err(map->dev,
1105 "Range %d: window for %d in window\n",
1106 i, j);
1107 goto err_range;
1108 }
1109 }
1110
1111 new = kzalloc(sizeof(*new), GFP_KERNEL);
1112 if (new == NULL) {
1113 ret = -ENOMEM;
1114 goto err_range;
1115 }
1116
1117 new->map = map;
1118 new->name = range_cfg->name;
1119 new->range_min = range_cfg->range_min;
1120 new->range_max = range_cfg->range_max;
1121 new->selector_reg = range_cfg->selector_reg;
1122 new->selector_mask = range_cfg->selector_mask;
1123 new->selector_shift = range_cfg->selector_shift;
1124 new->window_start = range_cfg->window_start;
1125 new->window_len = range_cfg->window_len;
1126
1127 if (!_regmap_range_add(map, new)) {
1128 dev_err(map->dev, "Failed to add range %d\n", i);
1129 kfree(new);
1130 goto err_range;
1131 }
1132
1133 if (map->selector_work_buf == NULL) {
1134 map->selector_work_buf =
1135 kzalloc(map->format.buf_size, GFP_KERNEL);
1136 if (map->selector_work_buf == NULL) {
1137 ret = -ENOMEM;
1138 goto err_range;
1139 }
1140 }
1141 }
1142
1143 ret = regcache_init(map, config);
1144 if (ret != 0)
1145 goto err_range;
1146
1147 if (dev) {
1148 ret = regmap_attach_dev(dev, map, config);
1149 if (ret != 0)
1150 goto err_regcache;
1151 } else {
1152 regmap_debugfs_init(map, config->name);
1153 }
1154
1155 return map;
1156
1157err_regcache:
1158 regcache_exit(map);
1159err_range:
1160 regmap_range_exit(map);
1161 kfree(map->work_buf);
1162err_hwlock:
1163 if (map->hwlock)
1164 hwspin_lock_free(map->hwlock);
1165err_name:
1166 kfree_const(map->name);
1167err_map:
1168 kfree(map);
1169err:
1170 return ERR_PTR(ret);
1171}
1172EXPORT_SYMBOL_GPL(__regmap_init);
1173
1174static void devm_regmap_release(struct device *dev, void *res)
1175{
1176 regmap_exit(*(struct regmap **)res);
1177}
1178
1179struct regmap *__devm_regmap_init(struct device *dev,
1180 const struct regmap_bus *bus,
1181 void *bus_context,
1182 const struct regmap_config *config,
1183 struct lock_class_key *lock_key,
1184 const char *lock_name)
1185{
1186 struct regmap **ptr, *regmap;
1187
1188 ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
1189 if (!ptr)
1190 return ERR_PTR(-ENOMEM);
1191
1192 regmap = __regmap_init(dev, bus, bus_context, config,
1193 lock_key, lock_name);
1194 if (!IS_ERR(regmap)) {
1195 *ptr = regmap;
1196 devres_add(dev, ptr);
1197 } else {
1198 devres_free(ptr);
1199 }
1200
1201 return regmap;
1202}
1203EXPORT_SYMBOL_GPL(__devm_regmap_init);
1204
1205static void regmap_field_init(struct regmap_field *rm_field,
1206 struct regmap *regmap, struct reg_field reg_field)
1207{
1208 rm_field->regmap = regmap;
1209 rm_field->reg = reg_field.reg;
1210 rm_field->shift = reg_field.lsb;
1211 rm_field->mask = GENMASK(reg_field.msb, reg_field.lsb);
1212 rm_field->id_size = reg_field.id_size;
1213 rm_field->id_offset = reg_field.id_offset;
1214}
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227struct regmap_field *devm_regmap_field_alloc(struct device *dev,
1228 struct regmap *regmap, struct reg_field reg_field)
1229{
1230 struct regmap_field *rm_field = devm_kzalloc(dev,
1231 sizeof(*rm_field), GFP_KERNEL);
1232 if (!rm_field)
1233 return ERR_PTR(-ENOMEM);
1234
1235 regmap_field_init(rm_field, regmap, reg_field);
1236
1237 return rm_field;
1238
1239}
1240EXPORT_SYMBOL_GPL(devm_regmap_field_alloc);
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253void devm_regmap_field_free(struct device *dev,
1254 struct regmap_field *field)
1255{
1256 devm_kfree(dev, field);
1257}
1258EXPORT_SYMBOL_GPL(devm_regmap_field_free);
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270struct regmap_field *regmap_field_alloc(struct regmap *regmap,
1271 struct reg_field reg_field)
1272{
1273 struct regmap_field *rm_field = kzalloc(sizeof(*rm_field), GFP_KERNEL);
1274
1275 if (!rm_field)
1276 return ERR_PTR(-ENOMEM);
1277
1278 regmap_field_init(rm_field, regmap, reg_field);
1279
1280 return rm_field;
1281}
1282EXPORT_SYMBOL_GPL(regmap_field_alloc);
1283
1284
1285
1286
1287
1288
1289
1290void regmap_field_free(struct regmap_field *field)
1291{
1292 kfree(field);
1293}
1294EXPORT_SYMBOL_GPL(regmap_field_free);
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
1311{
1312 regcache_exit(map);
1313 regmap_debugfs_exit(map);
1314
1315 map->max_register = config->max_register;
1316 map->writeable_reg = config->writeable_reg;
1317 map->readable_reg = config->readable_reg;
1318 map->volatile_reg = config->volatile_reg;
1319 map->precious_reg = config->precious_reg;
1320 map->writeable_noinc_reg = config->writeable_noinc_reg;
1321 map->readable_noinc_reg = config->readable_noinc_reg;
1322 map->cache_type = config->cache_type;
1323
1324 regmap_debugfs_init(map, config->name);
1325
1326 map->cache_bypass = false;
1327 map->cache_only = false;
1328
1329 return regcache_init(map, config);
1330}
1331EXPORT_SYMBOL_GPL(regmap_reinit_cache);
1332
1333
1334
1335
1336
1337
1338void regmap_exit(struct regmap *map)
1339{
1340 struct regmap_async *async;
1341
1342 regcache_exit(map);
1343 regmap_debugfs_exit(map);
1344 regmap_range_exit(map);
1345 if (map->bus && map->bus->free_context)
1346 map->bus->free_context(map->bus_context);
1347 kfree(map->work_buf);
1348 while (!list_empty(&map->async_free)) {
1349 async = list_first_entry_or_null(&map->async_free,
1350 struct regmap_async,
1351 list);
1352 list_del(&async->list);
1353 kfree(async->work_buf);
1354 kfree(async);
1355 }
1356 if (map->hwlock)
1357 hwspin_lock_free(map->hwlock);
1358 kfree_const(map->name);
1359 kfree(map);
1360}
1361EXPORT_SYMBOL_GPL(regmap_exit);
1362
1363static int dev_get_regmap_match(struct device *dev, void *res, void *data)
1364{
1365 struct regmap **r = res;
1366 if (!r || !*r) {
1367 WARN_ON(!r || !*r);
1368 return 0;
1369 }
1370
1371
1372 if (data)
1373 return (*r)->name == data;
1374 else
1375 return 1;
1376}
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390struct regmap *dev_get_regmap(struct device *dev, const char *name)
1391{
1392 struct regmap **r = devres_find(dev, dev_get_regmap_release,
1393 dev_get_regmap_match, (void *)name);
1394
1395 if (!r)
1396 return NULL;
1397 return *r;
1398}
1399EXPORT_SYMBOL_GPL(dev_get_regmap);
1400
1401
1402
1403
1404
1405
1406
1407
1408struct device *regmap_get_device(struct regmap *map)
1409{
1410 return map->dev;
1411}
1412EXPORT_SYMBOL_GPL(regmap_get_device);
1413
1414static int _regmap_select_page(struct regmap *map, unsigned int *reg,
1415 struct regmap_range_node *range,
1416 unsigned int val_num)
1417{
1418 void *orig_work_buf;
1419 unsigned int win_offset;
1420 unsigned int win_page;
1421 bool page_chg;
1422 int ret;
1423
1424 win_offset = (*reg - range->range_min) % range->window_len;
1425 win_page = (*reg - range->range_min) / range->window_len;
1426
1427 if (val_num > 1) {
1428
1429 if (*reg + val_num - 1 > range->range_max)
1430 return -EINVAL;
1431
1432
1433 if (val_num > range->window_len - win_offset)
1434 return -EINVAL;
1435 }
1436
1437
1438
1439
1440 if (val_num > 1 ||
1441 range->window_start + win_offset != range->selector_reg) {
1442
1443 orig_work_buf = map->work_buf;
1444 map->work_buf = map->selector_work_buf;
1445
1446 ret = _regmap_update_bits(map, range->selector_reg,
1447 range->selector_mask,
1448 win_page << range->selector_shift,
1449 &page_chg, false);
1450
1451 map->work_buf = orig_work_buf;
1452
1453 if (ret != 0)
1454 return ret;
1455 }
1456
1457 *reg = range->window_start + win_offset;
1458
1459 return 0;
1460}
1461
1462static void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
1463 unsigned long mask)
1464{
1465 u8 *buf;
1466 int i;
1467
1468 if (!mask || !map->work_buf)
1469 return;
1470
1471 buf = map->work_buf;
1472
1473 for (i = 0; i < max_bytes; i++)
1474 buf[i] |= (mask >> (8 * i)) & 0xff;
1475}
1476
1477static int _regmap_raw_write_impl(struct regmap *map, unsigned int reg,
1478 const void *val, size_t val_len)
1479{
1480 struct regmap_range_node *range;
1481 unsigned long flags;
1482 void *work_val = map->work_buf + map->format.reg_bytes +
1483 map->format.pad_bytes;
1484 void *buf;
1485 int ret = -ENOTSUPP;
1486 size_t len;
1487 int i;
1488
1489 WARN_ON(!map->bus);
1490
1491
1492 for (i = 0; i < val_len / map->format.val_bytes; i++)
1493 if (!regmap_writeable(map,
1494 reg + regmap_get_offset(map, i)))
1495 return -EINVAL;
1496
1497 if (!map->cache_bypass && map->format.parse_val) {
1498 unsigned int ival;
1499 int val_bytes = map->format.val_bytes;
1500 for (i = 0; i < val_len / val_bytes; i++) {
1501 ival = map->format.parse_val(val + (i * val_bytes));
1502 ret = regcache_write(map,
1503 reg + regmap_get_offset(map, i),
1504 ival);
1505 if (ret) {
1506 dev_err(map->dev,
1507 "Error in caching of register: %x ret: %d\n",
1508 reg + i, ret);
1509 return ret;
1510 }
1511 }
1512 if (map->cache_only) {
1513 map->cache_dirty = true;
1514 return 0;
1515 }
1516 }
1517
1518 range = _regmap_range_lookup(map, reg);
1519 if (range) {
1520 int val_num = val_len / map->format.val_bytes;
1521 int win_offset = (reg - range->range_min) % range->window_len;
1522 int win_residue = range->window_len - win_offset;
1523
1524
1525 while (val_num > win_residue) {
1526 dev_dbg(map->dev, "Writing window %d/%zu\n",
1527 win_residue, val_len / map->format.val_bytes);
1528 ret = _regmap_raw_write_impl(map, reg, val,
1529 win_residue *
1530 map->format.val_bytes);
1531 if (ret != 0)
1532 return ret;
1533
1534 reg += win_residue;
1535 val_num -= win_residue;
1536 val += win_residue * map->format.val_bytes;
1537 val_len -= win_residue * map->format.val_bytes;
1538
1539 win_offset = (reg - range->range_min) %
1540 range->window_len;
1541 win_residue = range->window_len - win_offset;
1542 }
1543
1544 ret = _regmap_select_page(map, ®, range, val_num);
1545 if (ret != 0)
1546 return ret;
1547 }
1548
1549 map->format.format_reg(map->work_buf, reg, map->reg_shift);
1550 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
1551 map->write_flag_mask);
1552
1553
1554
1555
1556
1557
1558 if (val != work_val && val_len == map->format.val_bytes) {
1559 memcpy(work_val, val, map->format.val_bytes);
1560 val = work_val;
1561 }
1562
1563 if (map->async && map->bus->async_write) {
1564 struct regmap_async *async;
1565
1566 trace_regmap_async_write_start(map, reg, val_len);
1567
1568 spin_lock_irqsave(&map->async_lock, flags);
1569 async = list_first_entry_or_null(&map->async_free,
1570 struct regmap_async,
1571 list);
1572 if (async)
1573 list_del(&async->list);
1574 spin_unlock_irqrestore(&map->async_lock, flags);
1575
1576 if (!async) {
1577 async = map->bus->async_alloc();
1578 if (!async)
1579 return -ENOMEM;
1580
1581 async->work_buf = kzalloc(map->format.buf_size,
1582 GFP_KERNEL | GFP_DMA);
1583 if (!async->work_buf) {
1584 kfree(async);
1585 return -ENOMEM;
1586 }
1587 }
1588
1589 async->map = map;
1590
1591
1592 memcpy(async->work_buf, map->work_buf, map->format.pad_bytes +
1593 map->format.reg_bytes + map->format.val_bytes);
1594
1595 spin_lock_irqsave(&map->async_lock, flags);
1596 list_add_tail(&async->list, &map->async_list);
1597 spin_unlock_irqrestore(&map->async_lock, flags);
1598
1599 if (val != work_val)
1600 ret = map->bus->async_write(map->bus_context,
1601 async->work_buf,
1602 map->format.reg_bytes +
1603 map->format.pad_bytes,
1604 val, val_len, async);
1605 else
1606 ret = map->bus->async_write(map->bus_context,
1607 async->work_buf,
1608 map->format.reg_bytes +
1609 map->format.pad_bytes +
1610 val_len, NULL, 0, async);
1611
1612 if (ret != 0) {
1613 dev_err(map->dev, "Failed to schedule write: %d\n",
1614 ret);
1615
1616 spin_lock_irqsave(&map->async_lock, flags);
1617 list_move(&async->list, &map->async_free);
1618 spin_unlock_irqrestore(&map->async_lock, flags);
1619 }
1620
1621 return ret;
1622 }
1623
1624 trace_regmap_hw_write_start(map, reg, val_len / map->format.val_bytes);
1625
1626
1627
1628
1629
1630 if (val == work_val)
1631 ret = map->bus->write(map->bus_context, map->work_buf,
1632 map->format.reg_bytes +
1633 map->format.pad_bytes +
1634 val_len);
1635 else if (map->bus->gather_write)
1636 ret = map->bus->gather_write(map->bus_context, map->work_buf,
1637 map->format.reg_bytes +
1638 map->format.pad_bytes,
1639 val, val_len);
1640
1641
1642 if (ret == -ENOTSUPP) {
1643 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
1644 buf = kzalloc(len, GFP_KERNEL);
1645 if (!buf)
1646 return -ENOMEM;
1647
1648 memcpy(buf, map->work_buf, map->format.reg_bytes);
1649 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
1650 val, val_len);
1651 ret = map->bus->write(map->bus_context, buf, len);
1652
1653 kfree(buf);
1654 } else if (ret != 0 && !map->cache_bypass && map->format.parse_val) {
1655
1656
1657
1658 if (map->cache_ops && map->cache_ops->drop)
1659 map->cache_ops->drop(map, reg, reg + 1);
1660 }
1661
1662 trace_regmap_hw_write_done(map, reg, val_len / map->format.val_bytes);
1663
1664 return ret;
1665}
1666
1667
1668
1669
1670
1671
1672bool regmap_can_raw_write(struct regmap *map)
1673{
1674 return map->bus && map->bus->write && map->format.format_val &&
1675 map->format.format_reg;
1676}
1677EXPORT_SYMBOL_GPL(regmap_can_raw_write);
1678
1679
1680
1681
1682
1683
1684size_t regmap_get_raw_read_max(struct regmap *map)
1685{
1686 return map->max_raw_read;
1687}
1688EXPORT_SYMBOL_GPL(regmap_get_raw_read_max);
1689
1690
1691
1692
1693
1694
1695size_t regmap_get_raw_write_max(struct regmap *map)
1696{
1697 return map->max_raw_write;
1698}
1699EXPORT_SYMBOL_GPL(regmap_get_raw_write_max);
1700
1701static int _regmap_bus_formatted_write(void *context, unsigned int reg,
1702 unsigned int val)
1703{
1704 int ret;
1705 struct regmap_range_node *range;
1706 struct regmap *map = context;
1707
1708 WARN_ON(!map->bus || !map->format.format_write);
1709
1710 range = _regmap_range_lookup(map, reg);
1711 if (range) {
1712 ret = _regmap_select_page(map, ®, range, 1);
1713 if (ret != 0)
1714 return ret;
1715 }
1716
1717 map->format.format_write(map, reg, val);
1718
1719 trace_regmap_hw_write_start(map, reg, 1);
1720
1721 ret = map->bus->write(map->bus_context, map->work_buf,
1722 map->format.buf_size);
1723
1724 trace_regmap_hw_write_done(map, reg, 1);
1725
1726 return ret;
1727}
1728
1729static int _regmap_bus_reg_write(void *context, unsigned int reg,
1730 unsigned int val)
1731{
1732 struct regmap *map = context;
1733
1734 return map->bus->reg_write(map->bus_context, reg, val);
1735}
1736
1737static int _regmap_bus_raw_write(void *context, unsigned int reg,
1738 unsigned int val)
1739{
1740 struct regmap *map = context;
1741
1742 WARN_ON(!map->bus || !map->format.format_val);
1743
1744 map->format.format_val(map->work_buf + map->format.reg_bytes
1745 + map->format.pad_bytes, val, 0);
1746 return _regmap_raw_write_impl(map, reg,
1747 map->work_buf +
1748 map->format.reg_bytes +
1749 map->format.pad_bytes,
1750 map->format.val_bytes);
1751}
1752
1753static inline void *_regmap_map_get_context(struct regmap *map)
1754{
1755 return (map->bus) ? map : map->bus_context;
1756}
1757
1758int _regmap_write(struct regmap *map, unsigned int reg,
1759 unsigned int val)
1760{
1761 int ret;
1762 void *context = _regmap_map_get_context(map);
1763
1764 if (!regmap_writeable(map, reg))
1765 return -EIO;
1766
1767 if (!map->cache_bypass && !map->defer_caching) {
1768 ret = regcache_write(map, reg, val);
1769 if (ret != 0)
1770 return ret;
1771 if (map->cache_only) {
1772 map->cache_dirty = true;
1773 return 0;
1774 }
1775 }
1776
1777 if (regmap_should_log(map))
1778 dev_info(map->dev, "%x <= %x\n", reg, val);
1779
1780 trace_regmap_reg_write(map, reg, val);
1781
1782 return map->reg_write(context, reg, val);
1783}
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
1796{
1797 int ret;
1798
1799 if (!IS_ALIGNED(reg, map->reg_stride))
1800 return -EINVAL;
1801
1802 map->lock(map->lock_arg);
1803
1804 ret = _regmap_write(map, reg, val);
1805
1806 map->unlock(map->lock_arg);
1807
1808 return ret;
1809}
1810EXPORT_SYMBOL_GPL(regmap_write);
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val)
1823{
1824 int ret;
1825
1826 if (!IS_ALIGNED(reg, map->reg_stride))
1827 return -EINVAL;
1828
1829 map->lock(map->lock_arg);
1830
1831 map->async = true;
1832
1833 ret = _regmap_write(map, reg, val);
1834
1835 map->async = false;
1836
1837 map->unlock(map->lock_arg);
1838
1839 return ret;
1840}
1841EXPORT_SYMBOL_GPL(regmap_write_async);
1842
1843int _regmap_raw_write(struct regmap *map, unsigned int reg,
1844 const void *val, size_t val_len)
1845{
1846 size_t val_bytes = map->format.val_bytes;
1847 size_t val_count = val_len / val_bytes;
1848 size_t chunk_count, chunk_bytes;
1849 size_t chunk_regs = val_count;
1850 int ret, i;
1851
1852 if (!val_count)
1853 return -EINVAL;
1854
1855 if (map->use_single_write)
1856 chunk_regs = 1;
1857 else if (map->max_raw_write && val_len > map->max_raw_write)
1858 chunk_regs = map->max_raw_write / val_bytes;
1859
1860 chunk_count = val_count / chunk_regs;
1861 chunk_bytes = chunk_regs * val_bytes;
1862
1863
1864 for (i = 0; i < chunk_count; i++) {
1865 ret = _regmap_raw_write_impl(map, reg, val, chunk_bytes);
1866 if (ret)
1867 return ret;
1868
1869 reg += regmap_get_offset(map, chunk_regs);
1870 val += chunk_bytes;
1871 val_len -= chunk_bytes;
1872 }
1873
1874
1875 if (val_len)
1876 ret = _regmap_raw_write_impl(map, reg, val, val_len);
1877
1878 return ret;
1879}
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897int regmap_raw_write(struct regmap *map, unsigned int reg,
1898 const void *val, size_t val_len)
1899{
1900 int ret;
1901
1902 if (!regmap_can_raw_write(map))
1903 return -EINVAL;
1904 if (val_len % map->format.val_bytes)
1905 return -EINVAL;
1906
1907 map->lock(map->lock_arg);
1908
1909 ret = _regmap_raw_write(map, reg, val, val_len);
1910
1911 map->unlock(map->lock_arg);
1912
1913 return ret;
1914}
1915EXPORT_SYMBOL_GPL(regmap_raw_write);
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938int regmap_noinc_write(struct regmap *map, unsigned int reg,
1939 const void *val, size_t val_len)
1940{
1941 size_t write_len;
1942 int ret;
1943
1944 if (!map->bus)
1945 return -EINVAL;
1946 if (!map->bus->write)
1947 return -ENOTSUPP;
1948 if (val_len % map->format.val_bytes)
1949 return -EINVAL;
1950 if (!IS_ALIGNED(reg, map->reg_stride))
1951 return -EINVAL;
1952 if (val_len == 0)
1953 return -EINVAL;
1954
1955 map->lock(map->lock_arg);
1956
1957 if (!regmap_volatile(map, reg) || !regmap_writeable_noinc(map, reg)) {
1958 ret = -EINVAL;
1959 goto out_unlock;
1960 }
1961
1962 while (val_len) {
1963 if (map->max_raw_write && map->max_raw_write < val_len)
1964 write_len = map->max_raw_write;
1965 else
1966 write_len = val_len;
1967 ret = _regmap_raw_write(map, reg, val, write_len);
1968 if (ret)
1969 goto out_unlock;
1970 val = ((u8 *)val) + write_len;
1971 val_len -= write_len;
1972 }
1973
1974out_unlock:
1975 map->unlock(map->lock_arg);
1976 return ret;
1977}
1978EXPORT_SYMBOL_GPL(regmap_noinc_write);
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997int regmap_field_update_bits_base(struct regmap_field *field,
1998 unsigned int mask, unsigned int val,
1999 bool *change, bool async, bool force)
2000{
2001 mask = (mask << field->shift) & field->mask;
2002
2003 return regmap_update_bits_base(field->regmap, field->reg,
2004 mask, val << field->shift,
2005 change, async, force);
2006}
2007EXPORT_SYMBOL_GPL(regmap_field_update_bits_base);
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024int regmap_fields_update_bits_base(struct regmap_field *field, unsigned int id,
2025 unsigned int mask, unsigned int val,
2026 bool *change, bool async, bool force)
2027{
2028 if (id >= field->id_size)
2029 return -EINVAL;
2030
2031 mask = (mask << field->shift) & field->mask;
2032
2033 return regmap_update_bits_base(field->regmap,
2034 field->reg + (field->id_offset * id),
2035 mask, val << field->shift,
2036 change, async, force);
2037}
2038EXPORT_SYMBOL_GPL(regmap_fields_update_bits_base);
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
2055 size_t val_count)
2056{
2057 int ret = 0, i;
2058 size_t val_bytes = map->format.val_bytes;
2059
2060 if (!IS_ALIGNED(reg, map->reg_stride))
2061 return -EINVAL;
2062
2063
2064
2065
2066
2067 if (!map->bus || !map->format.parse_inplace) {
2068 map->lock(map->lock_arg);
2069 for (i = 0; i < val_count; i++) {
2070 unsigned int ival;
2071
2072 switch (val_bytes) {
2073 case 1:
2074 ival = *(u8 *)(val + (i * val_bytes));
2075 break;
2076 case 2:
2077 ival = *(u16 *)(val + (i * val_bytes));
2078 break;
2079 case 4:
2080 ival = *(u32 *)(val + (i * val_bytes));
2081 break;
2082#ifdef CONFIG_64BIT
2083 case 8:
2084 ival = *(u64 *)(val + (i * val_bytes));
2085 break;
2086#endif
2087 default:
2088 ret = -EINVAL;
2089 goto out;
2090 }
2091
2092 ret = _regmap_write(map,
2093 reg + regmap_get_offset(map, i),
2094 ival);
2095 if (ret != 0)
2096 goto out;
2097 }
2098out:
2099 map->unlock(map->lock_arg);
2100 } else {
2101 void *wval;
2102
2103 wval = kmemdup(val, val_count * val_bytes, map->alloc_flags);
2104 if (!wval)
2105 return -ENOMEM;
2106
2107 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2108 map->format.parse_inplace(wval + i);
2109
2110 ret = regmap_raw_write(map, reg, wval, val_bytes * val_count);
2111
2112 kfree(wval);
2113 }
2114 return ret;
2115}
2116EXPORT_SYMBOL_GPL(regmap_bulk_write);
2117
2118
2119
2120
2121
2122
2123
2124
2125static int _regmap_raw_multi_reg_write(struct regmap *map,
2126 const struct reg_sequence *regs,
2127 size_t num_regs)
2128{
2129 int ret;
2130 void *buf;
2131 int i;
2132 u8 *u8;
2133 size_t val_bytes = map->format.val_bytes;
2134 size_t reg_bytes = map->format.reg_bytes;
2135 size_t pad_bytes = map->format.pad_bytes;
2136 size_t pair_size = reg_bytes + pad_bytes + val_bytes;
2137 size_t len = pair_size * num_regs;
2138
2139 if (!len)
2140 return -EINVAL;
2141
2142 buf = kzalloc(len, GFP_KERNEL);
2143 if (!buf)
2144 return -ENOMEM;
2145
2146
2147
2148 u8 = buf;
2149
2150 for (i = 0; i < num_regs; i++) {
2151 unsigned int reg = regs[i].reg;
2152 unsigned int val = regs[i].def;
2153 trace_regmap_hw_write_start(map, reg, 1);
2154 map->format.format_reg(u8, reg, map->reg_shift);
2155 u8 += reg_bytes + pad_bytes;
2156 map->format.format_val(u8, val, 0);
2157 u8 += val_bytes;
2158 }
2159 u8 = buf;
2160 *u8 |= map->write_flag_mask;
2161
2162 ret = map->bus->write(map->bus_context, buf, len);
2163
2164 kfree(buf);
2165
2166 for (i = 0; i < num_regs; i++) {
2167 int reg = regs[i].reg;
2168 trace_regmap_hw_write_done(map, reg, 1);
2169 }
2170 return ret;
2171}
2172
2173static unsigned int _regmap_register_page(struct regmap *map,
2174 unsigned int reg,
2175 struct regmap_range_node *range)
2176{
2177 unsigned int win_page = (reg - range->range_min) / range->window_len;
2178
2179 return win_page;
2180}
2181
2182static int _regmap_range_multi_paged_reg_write(struct regmap *map,
2183 struct reg_sequence *regs,
2184 size_t num_regs)
2185{
2186 int ret;
2187 int i, n;
2188 struct reg_sequence *base;
2189 unsigned int this_page = 0;
2190 unsigned int page_change = 0;
2191
2192
2193
2194
2195
2196
2197 base = regs;
2198 for (i = 0, n = 0; i < num_regs; i++, n++) {
2199 unsigned int reg = regs[i].reg;
2200 struct regmap_range_node *range;
2201
2202 range = _regmap_range_lookup(map, reg);
2203 if (range) {
2204 unsigned int win_page = _regmap_register_page(map, reg,
2205 range);
2206
2207 if (i == 0)
2208 this_page = win_page;
2209 if (win_page != this_page) {
2210 this_page = win_page;
2211 page_change = 1;
2212 }
2213 }
2214
2215
2216
2217
2218
2219
2220 if (page_change || regs[i].delay_us) {
2221
2222
2223
2224
2225
2226
2227
2228 if (regs[i].delay_us && i == 0)
2229 n = 1;
2230
2231 ret = _regmap_raw_multi_reg_write(map, base, n);
2232 if (ret != 0)
2233 return ret;
2234
2235 if (regs[i].delay_us)
2236 udelay(regs[i].delay_us);
2237
2238 base += n;
2239 n = 0;
2240
2241 if (page_change) {
2242 ret = _regmap_select_page(map,
2243 &base[n].reg,
2244 range, 1);
2245 if (ret != 0)
2246 return ret;
2247
2248 page_change = 0;
2249 }
2250
2251 }
2252
2253 }
2254 if (n > 0)
2255 return _regmap_raw_multi_reg_write(map, base, n);
2256 return 0;
2257}
2258
2259static int _regmap_multi_reg_write(struct regmap *map,
2260 const struct reg_sequence *regs,
2261 size_t num_regs)
2262{
2263 int i;
2264 int ret;
2265
2266 if (!map->can_multi_write) {
2267 for (i = 0; i < num_regs; i++) {
2268 ret = _regmap_write(map, regs[i].reg, regs[i].def);
2269 if (ret != 0)
2270 return ret;
2271
2272 if (regs[i].delay_us)
2273 udelay(regs[i].delay_us);
2274 }
2275 return 0;
2276 }
2277
2278 if (!map->format.parse_inplace)
2279 return -EINVAL;
2280
2281 if (map->writeable_reg)
2282 for (i = 0; i < num_regs; i++) {
2283 int reg = regs[i].reg;
2284 if (!map->writeable_reg(map->dev, reg))
2285 return -EINVAL;
2286 if (!IS_ALIGNED(reg, map->reg_stride))
2287 return -EINVAL;
2288 }
2289
2290 if (!map->cache_bypass) {
2291 for (i = 0; i < num_regs; i++) {
2292 unsigned int val = regs[i].def;
2293 unsigned int reg = regs[i].reg;
2294 ret = regcache_write(map, reg, val);
2295 if (ret) {
2296 dev_err(map->dev,
2297 "Error in caching of register: %x ret: %d\n",
2298 reg, ret);
2299 return ret;
2300 }
2301 }
2302 if (map->cache_only) {
2303 map->cache_dirty = true;
2304 return 0;
2305 }
2306 }
2307
2308 WARN_ON(!map->bus);
2309
2310 for (i = 0; i < num_regs; i++) {
2311 unsigned int reg = regs[i].reg;
2312 struct regmap_range_node *range;
2313
2314
2315
2316
2317 range = _regmap_range_lookup(map, reg);
2318 if (range || regs[i].delay_us) {
2319 size_t len = sizeof(struct reg_sequence)*num_regs;
2320 struct reg_sequence *base = kmemdup(regs, len,
2321 GFP_KERNEL);
2322 if (!base)
2323 return -ENOMEM;
2324 ret = _regmap_range_multi_paged_reg_write(map, base,
2325 num_regs);
2326 kfree(base);
2327
2328 return ret;
2329 }
2330 }
2331 return _regmap_raw_multi_reg_write(map, regs, num_regs);
2332}
2333
2334
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
2354 int num_regs)
2355{
2356 int ret;
2357
2358 map->lock(map->lock_arg);
2359
2360 ret = _regmap_multi_reg_write(map, regs, num_regs);
2361
2362 map->unlock(map->lock_arg);
2363
2364 return ret;
2365}
2366EXPORT_SYMBOL_GPL(regmap_multi_reg_write);
2367
2368
2369
2370
2371
2372
2373
2374
2375
2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386int regmap_multi_reg_write_bypassed(struct regmap *map,
2387 const struct reg_sequence *regs,
2388 int num_regs)
2389{
2390 int ret;
2391 bool bypass;
2392
2393 map->lock(map->lock_arg);
2394
2395 bypass = map->cache_bypass;
2396 map->cache_bypass = true;
2397
2398 ret = _regmap_multi_reg_write(map, regs, num_regs);
2399
2400 map->cache_bypass = bypass;
2401
2402 map->unlock(map->lock_arg);
2403
2404 return ret;
2405}
2406EXPORT_SYMBOL_GPL(regmap_multi_reg_write_bypassed);
2407
2408
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
2421
2422
2423
2424
2425
2426
2427
2428
2429
2430int regmap_raw_write_async(struct regmap *map, unsigned int reg,
2431 const void *val, size_t val_len)
2432{
2433 int ret;
2434
2435 if (val_len % map->format.val_bytes)
2436 return -EINVAL;
2437 if (!IS_ALIGNED(reg, map->reg_stride))
2438 return -EINVAL;
2439
2440 map->lock(map->lock_arg);
2441
2442 map->async = true;
2443
2444 ret = _regmap_raw_write(map, reg, val, val_len);
2445
2446 map->async = false;
2447
2448 map->unlock(map->lock_arg);
2449
2450 return ret;
2451}
2452EXPORT_SYMBOL_GPL(regmap_raw_write_async);
2453
2454static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2455 unsigned int val_len)
2456{
2457 struct regmap_range_node *range;
2458 int ret;
2459
2460 WARN_ON(!map->bus);
2461
2462 if (!map->bus || !map->bus->read)
2463 return -EINVAL;
2464
2465 range = _regmap_range_lookup(map, reg);
2466 if (range) {
2467 ret = _regmap_select_page(map, ®, range,
2468 val_len / map->format.val_bytes);
2469 if (ret != 0)
2470 return ret;
2471 }
2472
2473 map->format.format_reg(map->work_buf, reg, map->reg_shift);
2474 regmap_set_work_buf_flag_mask(map, map->format.reg_bytes,
2475 map->read_flag_mask);
2476 trace_regmap_hw_read_start(map, reg, val_len / map->format.val_bytes);
2477
2478 ret = map->bus->read(map->bus_context, map->work_buf,
2479 map->format.reg_bytes + map->format.pad_bytes,
2480 val, val_len);
2481
2482 trace_regmap_hw_read_done(map, reg, val_len / map->format.val_bytes);
2483
2484 return ret;
2485}
2486
2487static int _regmap_bus_reg_read(void *context, unsigned int reg,
2488 unsigned int *val)
2489{
2490 struct regmap *map = context;
2491
2492 return map->bus->reg_read(map->bus_context, reg, val);
2493}
2494
2495static int _regmap_bus_read(void *context, unsigned int reg,
2496 unsigned int *val)
2497{
2498 int ret;
2499 struct regmap *map = context;
2500 void *work_val = map->work_buf + map->format.reg_bytes +
2501 map->format.pad_bytes;
2502
2503 if (!map->format.parse_val)
2504 return -EINVAL;
2505
2506 ret = _regmap_raw_read(map, reg, work_val, map->format.val_bytes);
2507 if (ret == 0)
2508 *val = map->format.parse_val(work_val);
2509
2510 return ret;
2511}
2512
2513static int _regmap_read(struct regmap *map, unsigned int reg,
2514 unsigned int *val)
2515{
2516 int ret;
2517 void *context = _regmap_map_get_context(map);
2518
2519 if (!map->cache_bypass) {
2520 ret = regcache_read(map, reg, val);
2521 if (ret == 0)
2522 return 0;
2523 }
2524
2525 if (map->cache_only)
2526 return -EBUSY;
2527
2528 if (!regmap_readable(map, reg))
2529 return -EIO;
2530
2531 ret = map->reg_read(context, reg, val);
2532 if (ret == 0) {
2533 if (regmap_should_log(map))
2534 dev_info(map->dev, "%x => %x\n", reg, *val);
2535
2536 trace_regmap_reg_read(map, reg, *val);
2537
2538 if (!map->cache_bypass)
2539 regcache_write(map, reg, *val);
2540 }
2541
2542 return ret;
2543}
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
2555int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
2556{
2557 int ret;
2558
2559 if (!IS_ALIGNED(reg, map->reg_stride))
2560 return -EINVAL;
2561
2562 map->lock(map->lock_arg);
2563
2564 ret = _regmap_read(map, reg, val);
2565
2566 map->unlock(map->lock_arg);
2567
2568 return ret;
2569}
2570EXPORT_SYMBOL_GPL(regmap_read);
2571
2572
2573
2574
2575
2576
2577
2578
2579
2580
2581
2582
2583int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
2584 size_t val_len)
2585{
2586 size_t val_bytes = map->format.val_bytes;
2587 size_t val_count = val_len / val_bytes;
2588 unsigned int v;
2589 int ret, i;
2590
2591 if (!map->bus)
2592 return -EINVAL;
2593 if (val_len % map->format.val_bytes)
2594 return -EINVAL;
2595 if (!IS_ALIGNED(reg, map->reg_stride))
2596 return -EINVAL;
2597 if (val_count == 0)
2598 return -EINVAL;
2599
2600 map->lock(map->lock_arg);
2601
2602 if (regmap_volatile_range(map, reg, val_count) || map->cache_bypass ||
2603 map->cache_type == REGCACHE_NONE) {
2604 size_t chunk_count, chunk_bytes;
2605 size_t chunk_regs = val_count;
2606
2607 if (!map->bus->read) {
2608 ret = -ENOTSUPP;
2609 goto out;
2610 }
2611
2612 if (map->use_single_read)
2613 chunk_regs = 1;
2614 else if (map->max_raw_read && val_len > map->max_raw_read)
2615 chunk_regs = map->max_raw_read / val_bytes;
2616
2617 chunk_count = val_count / chunk_regs;
2618 chunk_bytes = chunk_regs * val_bytes;
2619
2620
2621 for (i = 0; i < chunk_count; i++) {
2622 ret = _regmap_raw_read(map, reg, val, chunk_bytes);
2623 if (ret != 0)
2624 goto out;
2625
2626 reg += regmap_get_offset(map, chunk_regs);
2627 val += chunk_bytes;
2628 val_len -= chunk_bytes;
2629 }
2630
2631
2632 if (val_len) {
2633 ret = _regmap_raw_read(map, reg, val, val_len);
2634 if (ret != 0)
2635 goto out;
2636 }
2637 } else {
2638
2639
2640
2641 for (i = 0; i < val_count; i++) {
2642 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2643 &v);
2644 if (ret != 0)
2645 goto out;
2646
2647 map->format.format_val(val + (i * val_bytes), v, 0);
2648 }
2649 }
2650
2651 out:
2652 map->unlock(map->lock_arg);
2653
2654 return ret;
2655}
2656EXPORT_SYMBOL_GPL(regmap_raw_read);
2657
2658
2659
2660
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679int regmap_noinc_read(struct regmap *map, unsigned int reg,
2680 void *val, size_t val_len)
2681{
2682 size_t read_len;
2683 int ret;
2684
2685 if (!map->bus)
2686 return -EINVAL;
2687 if (!map->bus->read)
2688 return -ENOTSUPP;
2689 if (val_len % map->format.val_bytes)
2690 return -EINVAL;
2691 if (!IS_ALIGNED(reg, map->reg_stride))
2692 return -EINVAL;
2693 if (val_len == 0)
2694 return -EINVAL;
2695
2696 map->lock(map->lock_arg);
2697
2698 if (!regmap_volatile(map, reg) || !regmap_readable_noinc(map, reg)) {
2699 ret = -EINVAL;
2700 goto out_unlock;
2701 }
2702
2703 while (val_len) {
2704 if (map->max_raw_read && map->max_raw_read < val_len)
2705 read_len = map->max_raw_read;
2706 else
2707 read_len = val_len;
2708 ret = _regmap_raw_read(map, reg, val, read_len);
2709 if (ret)
2710 goto out_unlock;
2711 val = ((u8 *)val) + read_len;
2712 val_len -= read_len;
2713 }
2714
2715out_unlock:
2716 map->unlock(map->lock_arg);
2717 return ret;
2718}
2719EXPORT_SYMBOL_GPL(regmap_noinc_read);
2720
2721
2722
2723
2724
2725
2726
2727
2728
2729
2730int regmap_field_read(struct regmap_field *field, unsigned int *val)
2731{
2732 int ret;
2733 unsigned int reg_val;
2734 ret = regmap_read(field->regmap, field->reg, ®_val);
2735 if (ret != 0)
2736 return ret;
2737
2738 reg_val &= field->mask;
2739 reg_val >>= field->shift;
2740 *val = reg_val;
2741
2742 return ret;
2743}
2744EXPORT_SYMBOL_GPL(regmap_field_read);
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756int regmap_fields_read(struct regmap_field *field, unsigned int id,
2757 unsigned int *val)
2758{
2759 int ret;
2760 unsigned int reg_val;
2761
2762 if (id >= field->id_size)
2763 return -EINVAL;
2764
2765 ret = regmap_read(field->regmap,
2766 field->reg + (field->id_offset * id),
2767 ®_val);
2768 if (ret != 0)
2769 return ret;
2770
2771 reg_val &= field->mask;
2772 reg_val >>= field->shift;
2773 *val = reg_val;
2774
2775 return ret;
2776}
2777EXPORT_SYMBOL_GPL(regmap_fields_read);
2778
2779
2780
2781
2782
2783
2784
2785
2786
2787
2788
2789
2790int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
2791 size_t val_count)
2792{
2793 int ret, i;
2794 size_t val_bytes = map->format.val_bytes;
2795 bool vol = regmap_volatile_range(map, reg, val_count);
2796
2797 if (!IS_ALIGNED(reg, map->reg_stride))
2798 return -EINVAL;
2799 if (val_count == 0)
2800 return -EINVAL;
2801
2802 if (map->bus && map->format.parse_inplace && (vol || map->cache_type == REGCACHE_NONE)) {
2803 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
2804 if (ret != 0)
2805 return ret;
2806
2807 for (i = 0; i < val_count * val_bytes; i += val_bytes)
2808 map->format.parse_inplace(val + i);
2809 } else {
2810#ifdef CONFIG_64BIT
2811 u64 *u64 = val;
2812#endif
2813 u32 *u32 = val;
2814 u16 *u16 = val;
2815 u8 *u8 = val;
2816
2817 map->lock(map->lock_arg);
2818
2819 for (i = 0; i < val_count; i++) {
2820 unsigned int ival;
2821
2822 ret = _regmap_read(map, reg + regmap_get_offset(map, i),
2823 &ival);
2824 if (ret != 0)
2825 goto out;
2826
2827 switch (map->format.val_bytes) {
2828#ifdef CONFIG_64BIT
2829 case 8:
2830 u64[i] = ival;
2831 break;
2832#endif
2833 case 4:
2834 u32[i] = ival;
2835 break;
2836 case 2:
2837 u16[i] = ival;
2838 break;
2839 case 1:
2840 u8[i] = ival;
2841 break;
2842 default:
2843 ret = -EINVAL;
2844 goto out;
2845 }
2846 }
2847
2848out:
2849 map->unlock(map->lock_arg);
2850 }
2851
2852 return ret;
2853}
2854EXPORT_SYMBOL_GPL(regmap_bulk_read);
2855
2856static int _regmap_update_bits(struct regmap *map, unsigned int reg,
2857 unsigned int mask, unsigned int val,
2858 bool *change, bool force_write)
2859{
2860 int ret;
2861 unsigned int tmp, orig;
2862
2863 if (change)
2864 *change = false;
2865
2866 if (regmap_volatile(map, reg) && map->reg_update_bits) {
2867 ret = map->reg_update_bits(map->bus_context, reg, mask, val);
2868 if (ret == 0 && change)
2869 *change = true;
2870 } else {
2871 ret = _regmap_read(map, reg, &orig);
2872 if (ret != 0)
2873 return ret;
2874
2875 tmp = orig & ~mask;
2876 tmp |= val & mask;
2877
2878 if (force_write || (tmp != orig)) {
2879 ret = _regmap_write(map, reg, tmp);
2880 if (ret == 0 && change)
2881 *change = true;
2882 }
2883 }
2884
2885 return ret;
2886}
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897
2898
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910int regmap_update_bits_base(struct regmap *map, unsigned int reg,
2911 unsigned int mask, unsigned int val,
2912 bool *change, bool async, bool force)
2913{
2914 int ret;
2915
2916 map->lock(map->lock_arg);
2917
2918 map->async = async;
2919
2920 ret = _regmap_update_bits(map, reg, mask, val, change, force);
2921
2922 map->async = false;
2923
2924 map->unlock(map->lock_arg);
2925
2926 return ret;
2927}
2928EXPORT_SYMBOL_GPL(regmap_update_bits_base);
2929
2930void regmap_async_complete_cb(struct regmap_async *async, int ret)
2931{
2932 struct regmap *map = async->map;
2933 bool wake;
2934
2935 trace_regmap_async_io_complete(map);
2936
2937 spin_lock(&map->async_lock);
2938 list_move(&async->list, &map->async_free);
2939 wake = list_empty(&map->async_list);
2940
2941 if (ret != 0)
2942 map->async_ret = ret;
2943
2944 spin_unlock(&map->async_lock);
2945
2946 if (wake)
2947 wake_up(&map->async_waitq);
2948}
2949EXPORT_SYMBOL_GPL(regmap_async_complete_cb);
2950
2951static int regmap_async_is_done(struct regmap *map)
2952{
2953 unsigned long flags;
2954 int ret;
2955
2956 spin_lock_irqsave(&map->async_lock, flags);
2957 ret = list_empty(&map->async_list);
2958 spin_unlock_irqrestore(&map->async_lock, flags);
2959
2960 return ret;
2961}
2962
2963
2964
2965
2966
2967
2968
2969
2970
2971int regmap_async_complete(struct regmap *map)
2972{
2973 unsigned long flags;
2974 int ret;
2975
2976
2977 if (!map->bus || !map->bus->async_write)
2978 return 0;
2979
2980 trace_regmap_async_complete_start(map);
2981
2982 wait_event(map->async_waitq, regmap_async_is_done(map));
2983
2984 spin_lock_irqsave(&map->async_lock, flags);
2985 ret = map->async_ret;
2986 map->async_ret = 0;
2987 spin_unlock_irqrestore(&map->async_lock, flags);
2988
2989 trace_regmap_async_complete_done(map);
2990
2991 return ret;
2992}
2993EXPORT_SYMBOL_GPL(regmap_async_complete);
2994
2995
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011
3012int regmap_register_patch(struct regmap *map, const struct reg_sequence *regs,
3013 int num_regs)
3014{
3015 struct reg_sequence *p;
3016 int ret;
3017 bool bypass;
3018
3019 if (WARN_ONCE(num_regs <= 0, "invalid registers number (%d)\n",
3020 num_regs))
3021 return 0;
3022
3023 p = krealloc(map->patch,
3024 sizeof(struct reg_sequence) * (map->patch_regs + num_regs),
3025 GFP_KERNEL);
3026 if (p) {
3027 memcpy(p + map->patch_regs, regs, num_regs * sizeof(*regs));
3028 map->patch = p;
3029 map->patch_regs += num_regs;
3030 } else {
3031 return -ENOMEM;
3032 }
3033
3034 map->lock(map->lock_arg);
3035
3036 bypass = map->cache_bypass;
3037
3038 map->cache_bypass = true;
3039 map->async = true;
3040
3041 ret = _regmap_multi_reg_write(map, regs, num_regs);
3042
3043 map->async = false;
3044 map->cache_bypass = bypass;
3045
3046 map->unlock(map->lock_arg);
3047
3048 regmap_async_complete(map);
3049
3050 return ret;
3051}
3052EXPORT_SYMBOL_GPL(regmap_register_patch);
3053
3054
3055
3056
3057
3058
3059
3060
3061
3062int regmap_get_val_bytes(struct regmap *map)
3063{
3064 if (map->format.format_write)
3065 return -EINVAL;
3066
3067 return map->format.val_bytes;
3068}
3069EXPORT_SYMBOL_GPL(regmap_get_val_bytes);
3070
3071
3072
3073
3074
3075
3076
3077
3078
3079int regmap_get_max_register(struct regmap *map)
3080{
3081 return map->max_register ? map->max_register : -EINVAL;
3082}
3083EXPORT_SYMBOL_GPL(regmap_get_max_register);
3084
3085
3086
3087
3088
3089
3090
3091
3092
3093int regmap_get_reg_stride(struct regmap *map)
3094{
3095 return map->reg_stride;
3096}
3097EXPORT_SYMBOL_GPL(regmap_get_reg_stride);
3098
3099int regmap_parse_val(struct regmap *map, const void *buf,
3100 unsigned int *val)
3101{
3102 if (!map->format.parse_val)
3103 return -EINVAL;
3104
3105 *val = map->format.parse_val(buf);
3106
3107 return 0;
3108}
3109EXPORT_SYMBOL_GPL(regmap_parse_val);
3110
3111static int __init regmap_initcall(void)
3112{
3113 regmap_debugfs_initcall();
3114
3115 return 0;
3116}
3117postcore_initcall(regmap_initcall);
3118