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