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