regmap: add regmap_bulk_write() for register write
[linux-2.6.git] / drivers / base / regmap / regmap.c
1 /*
2  * Register map access API
3  *
4  * Copyright 2011 Wolfson Microelectronics plc
5  *
6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12
13 #include <linux/slab.h>
14 #include <linux/module.h>
15 #include <linux/mutex.h>
16 #include <linux/err.h>
17
18 #define CREATE_TRACE_POINTS
19 #include <trace/events/regmap.h>
20
21 #include "internal.h"
22
23 bool regmap_writeable(struct regmap *map, unsigned int reg)
24 {
25         if (map->max_register && reg > map->max_register)
26                 return false;
27
28         if (map->writeable_reg)
29                 return map->writeable_reg(map->dev, reg);
30
31         return true;
32 }
33
34 bool regmap_readable(struct regmap *map, unsigned int reg)
35 {
36         if (map->max_register && reg > map->max_register)
37                 return false;
38
39         if (map->format.format_write)
40                 return false;
41
42         if (map->readable_reg)
43                 return map->readable_reg(map->dev, reg);
44
45         return true;
46 }
47
48 bool regmap_volatile(struct regmap *map, unsigned int reg)
49 {
50         if (!regmap_readable(map, reg))
51                 return false;
52
53         if (map->volatile_reg)
54                 return map->volatile_reg(map->dev, reg);
55
56         return true;
57 }
58
59 bool regmap_precious(struct regmap *map, unsigned int reg)
60 {
61         if (!regmap_readable(map, reg))
62                 return false;
63
64         if (map->precious_reg)
65                 return map->precious_reg(map->dev, reg);
66
67         return false;
68 }
69
70 static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
71         unsigned int num)
72 {
73         unsigned int i;
74
75         for (i = 0; i < num; i++)
76                 if (!regmap_volatile(map, reg + i))
77                         return false;
78
79         return true;
80 }
81
82 static void regmap_format_2_6_write(struct regmap *map,
83                                      unsigned int reg, unsigned int val)
84 {
85         u8 *out = map->work_buf;
86
87         *out = (reg << 6) | val;
88 }
89
90 static void regmap_format_4_12_write(struct regmap *map,
91                                      unsigned int reg, unsigned int val)
92 {
93         __be16 *out = map->work_buf;
94         *out = cpu_to_be16((reg << 12) | val);
95 }
96
97 static void regmap_format_7_9_write(struct regmap *map,
98                                     unsigned int reg, unsigned int val)
99 {
100         __be16 *out = map->work_buf;
101         *out = cpu_to_be16((reg << 9) | val);
102 }
103
104 static void regmap_format_10_14_write(struct regmap *map,
105                                     unsigned int reg, unsigned int val)
106 {
107         u8 *out = map->work_buf;
108
109         out[2] = val;
110         out[1] = (val >> 8) | (reg << 6);
111         out[0] = reg >> 2;
112 }
113
114 static void regmap_format_8(void *buf, unsigned int val)
115 {
116         u8 *b = buf;
117
118         b[0] = val;
119 }
120
121 static void regmap_format_16(void *buf, unsigned int val)
122 {
123         __be16 *b = buf;
124
125         b[0] = cpu_to_be16(val);
126 }
127
128 static unsigned int regmap_parse_8(void *buf)
129 {
130         u8 *b = buf;
131
132         return b[0];
133 }
134
135 static unsigned int regmap_parse_16(void *buf)
136 {
137         __be16 *b = buf;
138
139         b[0] = be16_to_cpu(b[0]);
140
141         return b[0];
142 }
143
144 /**
145  * regmap_init(): Initialise register map
146  *
147  * @dev: Device that will be interacted with
148  * @bus: Bus-specific callbacks to use with device
149  * @config: Configuration for register map
150  *
151  * The return value will be an ERR_PTR() on error or a valid pointer to
152  * a struct regmap.  This function should generally not be called
153  * directly, it should be called by bus-specific init functions.
154  */
155 struct regmap *regmap_init(struct device *dev,
156                            const struct regmap_bus *bus,
157                            const struct regmap_config *config)
158 {
159         struct regmap *map;
160         int ret = -EINVAL;
161
162         if (!bus || !config)
163                 goto err;
164
165         map = kzalloc(sizeof(*map), GFP_KERNEL);
166         if (map == NULL) {
167                 ret = -ENOMEM;
168                 goto err;
169         }
170
171         mutex_init(&map->lock);
172         map->format.buf_size = (config->reg_bits + config->val_bits) / 8;
173         map->format.reg_bytes = DIV_ROUND_UP(config->reg_bits, 8);
174         map->format.pad_bytes = config->pad_bits / 8;
175         map->format.val_bytes = DIV_ROUND_UP(config->val_bits, 8);
176         map->format.buf_size += map->format.pad_bytes;
177         map->dev = dev;
178         map->bus = bus;
179         map->max_register = config->max_register;
180         map->writeable_reg = config->writeable_reg;
181         map->readable_reg = config->readable_reg;
182         map->volatile_reg = config->volatile_reg;
183         map->precious_reg = config->precious_reg;
184         map->cache_type = config->cache_type;
185
186         if (config->read_flag_mask || config->write_flag_mask) {
187                 map->read_flag_mask = config->read_flag_mask;
188                 map->write_flag_mask = config->write_flag_mask;
189         } else {
190                 map->read_flag_mask = bus->read_flag_mask;
191         }
192
193         switch (config->reg_bits) {
194         case 2:
195                 switch (config->val_bits) {
196                 case 6:
197                         map->format.format_write = regmap_format_2_6_write;
198                         break;
199                 default:
200                         goto err_map;
201                 }
202                 break;
203
204         case 4:
205                 switch (config->val_bits) {
206                 case 12:
207                         map->format.format_write = regmap_format_4_12_write;
208                         break;
209                 default:
210                         goto err_map;
211                 }
212                 break;
213
214         case 7:
215                 switch (config->val_bits) {
216                 case 9:
217                         map->format.format_write = regmap_format_7_9_write;
218                         break;
219                 default:
220                         goto err_map;
221                 }
222                 break;
223
224         case 10:
225                 switch (config->val_bits) {
226                 case 14:
227                         map->format.format_write = regmap_format_10_14_write;
228                         break;
229                 default:
230                         goto err_map;
231                 }
232                 break;
233
234         case 8:
235                 map->format.format_reg = regmap_format_8;
236                 break;
237
238         case 16:
239                 map->format.format_reg = regmap_format_16;
240                 break;
241
242         default:
243                 goto err_map;
244         }
245
246         switch (config->val_bits) {
247         case 8:
248                 map->format.format_val = regmap_format_8;
249                 map->format.parse_val = regmap_parse_8;
250                 break;
251         case 16:
252                 map->format.format_val = regmap_format_16;
253                 map->format.parse_val = regmap_parse_16;
254                 break;
255         }
256
257         if (!map->format.format_write &&
258             !(map->format.format_reg && map->format.format_val))
259                 goto err_map;
260
261         map->work_buf = kzalloc(map->format.buf_size, GFP_KERNEL);
262         if (map->work_buf == NULL) {
263                 ret = -ENOMEM;
264                 goto err_map;
265         }
266
267         regmap_debugfs_init(map);
268
269         ret = regcache_init(map, config);
270         if (ret < 0)
271                 goto err_free_workbuf;
272
273         return map;
274
275 err_free_workbuf:
276         kfree(map->work_buf);
277 err_map:
278         kfree(map);
279 err:
280         return ERR_PTR(ret);
281 }
282 EXPORT_SYMBOL_GPL(regmap_init);
283
284 static void devm_regmap_release(struct device *dev, void *res)
285 {
286         regmap_exit(*(struct regmap **)res);
287 }
288
289 /**
290  * devm_regmap_init(): Initialise managed register map
291  *
292  * @dev: Device that will be interacted with
293  * @bus: Bus-specific callbacks to use with device
294  * @config: Configuration for register map
295  *
296  * The return value will be an ERR_PTR() on error or a valid pointer
297  * to a struct regmap.  This function should generally not be called
298  * directly, it should be called by bus-specific init functions.  The
299  * map will be automatically freed by the device management code.
300  */
301 struct regmap *devm_regmap_init(struct device *dev,
302                                 const struct regmap_bus *bus,
303                                 const struct regmap_config *config)
304 {
305         struct regmap **ptr, *regmap;
306
307         ptr = devres_alloc(devm_regmap_release, sizeof(*ptr), GFP_KERNEL);
308         if (!ptr)
309                 return ERR_PTR(-ENOMEM);
310
311         regmap = regmap_init(dev, bus, config);
312         if (!IS_ERR(regmap)) {
313                 *ptr = regmap;
314                 devres_add(dev, ptr);
315         } else {
316                 devres_free(ptr);
317         }
318
319         return regmap;
320 }
321 EXPORT_SYMBOL_GPL(devm_regmap_init);
322
323 /**
324  * regmap_reinit_cache(): Reinitialise the current register cache
325  *
326  * @map: Register map to operate on.
327  * @config: New configuration.  Only the cache data will be used.
328  *
329  * Discard any existing register cache for the map and initialize a
330  * new cache.  This can be used to restore the cache to defaults or to
331  * update the cache configuration to reflect runtime discovery of the
332  * hardware.
333  */
334 int regmap_reinit_cache(struct regmap *map, const struct regmap_config *config)
335 {
336         int ret;
337
338         mutex_lock(&map->lock);
339
340         regcache_exit(map);
341         regmap_debugfs_exit(map);
342
343         map->max_register = config->max_register;
344         map->writeable_reg = config->writeable_reg;
345         map->readable_reg = config->readable_reg;
346         map->volatile_reg = config->volatile_reg;
347         map->precious_reg = config->precious_reg;
348         map->cache_type = config->cache_type;
349
350         map->cache_bypass = false;
351         map->cache_only = false;
352         regmap_debugfs_init(map);
353
354         ret = regcache_init(map, config);
355
356         mutex_unlock(&map->lock);
357
358         return ret;
359 }
360
361 /**
362  * regmap_exit(): Free a previously allocated register map
363  */
364 void regmap_exit(struct regmap *map)
365 {
366         regcache_exit(map);
367         regmap_debugfs_exit(map);
368         kfree(map->work_buf);
369         kfree(map);
370 }
371 EXPORT_SYMBOL_GPL(regmap_exit);
372
373 static int _regmap_raw_write(struct regmap *map, unsigned int reg,
374                              const void *val, size_t val_len)
375 {
376         u8 *u8 = map->work_buf;
377         void *buf;
378         int ret = -ENOTSUPP;
379         size_t len;
380         int i;
381
382         /* Check for unwritable registers before we start */
383         if (map->writeable_reg)
384                 for (i = 0; i < val_len / map->format.val_bytes; i++)
385                         if (!map->writeable_reg(map->dev, reg + i))
386                                 return -EINVAL;
387
388         if (!map->cache_bypass && map->format.parse_val) {
389                 unsigned int ival;
390                 int val_bytes = map->format.val_bytes;
391                 for (i = 0; i < val_len / val_bytes; i++) {
392                         memcpy(map->work_buf, val + (i * val_bytes), val_bytes);
393                         ival = map->format.parse_val(map->work_buf);
394                         ret = regcache_write(map, reg + i, ival);
395                         if (ret) {
396                                 dev_err(map->dev,
397                                    "Error in caching of register: %u ret: %d\n",
398                                         reg + i, ret);
399                                 return ret;
400                         }
401                 }
402                 if (map->cache_only) {
403                         map->cache_dirty = true;
404                         return 0;
405                 }
406         }
407
408         map->format.format_reg(map->work_buf, reg);
409
410         u8[0] |= map->write_flag_mask;
411
412         trace_regmap_hw_write_start(map->dev, reg,
413                                     val_len / map->format.val_bytes);
414
415         /* If we're doing a single register write we can probably just
416          * send the work_buf directly, otherwise try to do a gather
417          * write.
418          */
419         if (val == (map->work_buf + map->format.pad_bytes +
420                     map->format.reg_bytes))
421                 ret = map->bus->write(map->dev, map->work_buf,
422                                       map->format.reg_bytes +
423                                       map->format.pad_bytes +
424                                       val_len);
425         else if (map->bus->gather_write)
426                 ret = map->bus->gather_write(map->dev, map->work_buf,
427                                              map->format.reg_bytes +
428                                              map->format.pad_bytes,
429                                              val, val_len);
430
431         /* If that didn't work fall back on linearising by hand. */
432         if (ret == -ENOTSUPP) {
433                 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
434                 buf = kzalloc(len, GFP_KERNEL);
435                 if (!buf)
436                         return -ENOMEM;
437
438                 memcpy(buf, map->work_buf, map->format.reg_bytes);
439                 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
440                        val, val_len);
441                 ret = map->bus->write(map->dev, buf, len);
442
443                 kfree(buf);
444         }
445
446         trace_regmap_hw_write_done(map->dev, reg,
447                                    val_len / map->format.val_bytes);
448
449         return ret;
450 }
451
452 int _regmap_write(struct regmap *map, unsigned int reg,
453                   unsigned int val)
454 {
455         int ret;
456         BUG_ON(!map->format.format_write && !map->format.format_val);
457
458         if (!map->cache_bypass && map->format.format_write) {
459                 ret = regcache_write(map, reg, val);
460                 if (ret != 0)
461                         return ret;
462                 if (map->cache_only) {
463                         map->cache_dirty = true;
464                         return 0;
465                 }
466         }
467
468         trace_regmap_reg_write(map->dev, reg, val);
469
470         if (map->format.format_write) {
471                 map->format.format_write(map, reg, val);
472
473                 trace_regmap_hw_write_start(map->dev, reg, 1);
474
475                 ret = map->bus->write(map->dev, map->work_buf,
476                                       map->format.buf_size);
477
478                 trace_regmap_hw_write_done(map->dev, reg, 1);
479
480                 return ret;
481         } else {
482                 map->format.format_val(map->work_buf + map->format.reg_bytes
483                                        + map->format.pad_bytes, val);
484                 return _regmap_raw_write(map, reg,
485                                          map->work_buf +
486                                          map->format.reg_bytes +
487                                          map->format.pad_bytes,
488                                          map->format.val_bytes);
489         }
490 }
491
492 /**
493  * regmap_write(): Write a value to a single register
494  *
495  * @map: Register map to write to
496  * @reg: Register to write to
497  * @val: Value to be written
498  *
499  * A value of zero will be returned on success, a negative errno will
500  * be returned in error cases.
501  */
502 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
503 {
504         int ret;
505
506         mutex_lock(&map->lock);
507
508         ret = _regmap_write(map, reg, val);
509
510         mutex_unlock(&map->lock);
511
512         return ret;
513 }
514 EXPORT_SYMBOL_GPL(regmap_write);
515
516 /**
517  * regmap_raw_write(): Write raw values to one or more registers
518  *
519  * @map: Register map to write to
520  * @reg: Initial register to write to
521  * @val: Block of data to be written, laid out for direct transmission to the
522  *       device
523  * @val_len: Length of data pointed to by val.
524  *
525  * This function is intended to be used for things like firmware
526  * download where a large block of data needs to be transferred to the
527  * device.  No formatting will be done on the data provided.
528  *
529  * A value of zero will be returned on success, a negative errno will
530  * be returned in error cases.
531  */
532 int regmap_raw_write(struct regmap *map, unsigned int reg,
533                      const void *val, size_t val_len)
534 {
535         int ret;
536
537         mutex_lock(&map->lock);
538
539         ret = _regmap_raw_write(map, reg, val, val_len);
540
541         mutex_unlock(&map->lock);
542
543         return ret;
544 }
545 EXPORT_SYMBOL_GPL(regmap_raw_write);
546
547 /*
548  * regmap_bulk_write(): Write multiple registers to the device
549  *
550  * @map: Register map to write to
551  * @reg: First register to be write from
552  * @val: Block of data to be written, in native register size for device
553  * @val_count: Number of registers to write
554  *
555  * This function is intended to be used for writing a large block of
556  * data to be device either in single transfer or multiple transfer.
557  *
558  * A value of zero will be returned on success, a negative errno will
559  * be returned in error cases.
560  */
561 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
562                      size_t val_count)
563 {
564         int ret = 0, i;
565         size_t val_bytes = map->format.val_bytes;
566         void *wval;
567
568         if (!map->format.parse_val)
569                 return -EINVAL;
570
571         mutex_lock(&map->lock);
572
573         /* No formatting is require if val_byte is 1 */
574         if (val_bytes == 1) {
575                 wval = (void *)val;
576         } else {
577                 wval = kmemdup(val, val_count * val_bytes, GFP_KERNEL);
578                 if (!wval) {
579                         ret = -ENOMEM;
580                         dev_err(map->dev, "Error in memory allocation\n");
581                         goto out;
582                 }
583                 for (i = 0; i < val_count * val_bytes; i += val_bytes)
584                         map->format.parse_val(wval + i);
585         }
586         ret = _regmap_raw_write(map, reg, wval, val_bytes * val_count);
587
588         if (val_bytes != 1)
589                 kfree(wval);
590
591 out:
592         mutex_unlock(&map->lock);
593         return ret;
594 }
595 EXPORT_SYMBOL_GPL(regmap_bulk_write);
596
597 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
598                             unsigned int val_len)
599 {
600         u8 *u8 = map->work_buf;
601         int ret;
602
603         map->format.format_reg(map->work_buf, reg);
604
605         /*
606          * Some buses or devices flag reads by setting the high bits in the
607          * register addresss; since it's always the high bits for all
608          * current formats we can do this here rather than in
609          * formatting.  This may break if we get interesting formats.
610          */
611         u8[0] |= map->read_flag_mask;
612
613         trace_regmap_hw_read_start(map->dev, reg,
614                                    val_len / map->format.val_bytes);
615
616         ret = map->bus->read(map->dev, map->work_buf,
617                              map->format.reg_bytes + map->format.pad_bytes,
618                              val, val_len);
619
620         trace_regmap_hw_read_done(map->dev, reg,
621                                   val_len / map->format.val_bytes);
622
623         return ret;
624 }
625
626 static int _regmap_read(struct regmap *map, unsigned int reg,
627                         unsigned int *val)
628 {
629         int ret;
630
631         if (!map->cache_bypass) {
632                 ret = regcache_read(map, reg, val);
633                 if (ret == 0)
634                         return 0;
635         }
636
637         if (!map->format.parse_val)
638                 return -EINVAL;
639
640         if (map->cache_only)
641                 return -EBUSY;
642
643         ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
644         if (ret == 0) {
645                 *val = map->format.parse_val(map->work_buf);
646                 trace_regmap_reg_read(map->dev, reg, *val);
647         }
648
649         return ret;
650 }
651
652 /**
653  * regmap_read(): Read a value from a single register
654  *
655  * @map: Register map to write to
656  * @reg: Register to be read from
657  * @val: Pointer to store read value
658  *
659  * A value of zero will be returned on success, a negative errno will
660  * be returned in error cases.
661  */
662 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
663 {
664         int ret;
665
666         mutex_lock(&map->lock);
667
668         ret = _regmap_read(map, reg, val);
669
670         mutex_unlock(&map->lock);
671
672         return ret;
673 }
674 EXPORT_SYMBOL_GPL(regmap_read);
675
676 /**
677  * regmap_raw_read(): Read raw data from the device
678  *
679  * @map: Register map to write to
680  * @reg: First register to be read from
681  * @val: Pointer to store read value
682  * @val_len: Size of data to read
683  *
684  * A value of zero will be returned on success, a negative errno will
685  * be returned in error cases.
686  */
687 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
688                     size_t val_len)
689 {
690         size_t val_count = val_len / map->format.val_bytes;
691         int ret;
692
693         WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
694                 map->cache_type != REGCACHE_NONE);
695
696         mutex_lock(&map->lock);
697
698         ret = _regmap_raw_read(map, reg, val, val_len);
699
700         mutex_unlock(&map->lock);
701
702         return ret;
703 }
704 EXPORT_SYMBOL_GPL(regmap_raw_read);
705
706 /**
707  * regmap_bulk_read(): Read multiple registers from the device
708  *
709  * @map: Register map to write to
710  * @reg: First register to be read from
711  * @val: Pointer to store read value, in native register size for device
712  * @val_count: Number of registers to read
713  *
714  * A value of zero will be returned on success, a negative errno will
715  * be returned in error cases.
716  */
717 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
718                      size_t val_count)
719 {
720         int ret, i;
721         size_t val_bytes = map->format.val_bytes;
722         bool vol = regmap_volatile_range(map, reg, val_count);
723
724         if (!map->format.parse_val)
725                 return -EINVAL;
726
727         if (vol || map->cache_type == REGCACHE_NONE) {
728                 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
729                 if (ret != 0)
730                         return ret;
731
732                 for (i = 0; i < val_count * val_bytes; i += val_bytes)
733                         map->format.parse_val(val + i);
734         } else {
735                 for (i = 0; i < val_count; i++) {
736                         ret = regmap_read(map, reg + i, val + (i * val_bytes));
737                         if (ret != 0)
738                                 return ret;
739                 }
740         }
741
742         return 0;
743 }
744 EXPORT_SYMBOL_GPL(regmap_bulk_read);
745
746 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
747                                unsigned int mask, unsigned int val,
748                                bool *change)
749 {
750         int ret;
751         unsigned int tmp, orig;
752
753         mutex_lock(&map->lock);
754
755         ret = _regmap_read(map, reg, &orig);
756         if (ret != 0)
757                 goto out;
758
759         tmp = orig & ~mask;
760         tmp |= val & mask;
761
762         if (tmp != orig) {
763                 ret = _regmap_write(map, reg, tmp);
764                 *change = true;
765         } else {
766                 *change = false;
767         }
768
769 out:
770         mutex_unlock(&map->lock);
771
772         return ret;
773 }
774
775 /**
776  * regmap_update_bits: Perform a read/modify/write cycle on the register map
777  *
778  * @map: Register map to update
779  * @reg: Register to update
780  * @mask: Bitmask to change
781  * @val: New value for bitmask
782  *
783  * Returns zero for success, a negative number on error.
784  */
785 int regmap_update_bits(struct regmap *map, unsigned int reg,
786                        unsigned int mask, unsigned int val)
787 {
788         bool change;
789         return _regmap_update_bits(map, reg, mask, val, &change);
790 }
791 EXPORT_SYMBOL_GPL(regmap_update_bits);
792
793 /**
794  * regmap_update_bits_check: Perform a read/modify/write cycle on the
795  *                           register map and report if updated
796  *
797  * @map: Register map to update
798  * @reg: Register to update
799  * @mask: Bitmask to change
800  * @val: New value for bitmask
801  * @change: Boolean indicating if a write was done
802  *
803  * Returns zero for success, a negative number on error.
804  */
805 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
806                              unsigned int mask, unsigned int val,
807                              bool *change)
808 {
809         return _regmap_update_bits(map, reg, mask, val, change);
810 }
811 EXPORT_SYMBOL_GPL(regmap_update_bits_check);
812
813 /**
814  * regmap_register_patch: Register and apply register updates to be applied
815  *                        on device initialistion
816  *
817  * @map: Register map to apply updates to.
818  * @regs: Values to update.
819  * @num_regs: Number of entries in regs.
820  *
821  * Register a set of register updates to be applied to the device
822  * whenever the device registers are synchronised with the cache and
823  * apply them immediately.  Typically this is used to apply
824  * corrections to be applied to the device defaults on startup, such
825  * as the updates some vendors provide to undocumented registers.
826  */
827 int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
828                           int num_regs)
829 {
830         int i, ret;
831         bool bypass;
832
833         /* If needed the implementation can be extended to support this */
834         if (map->patch)
835                 return -EBUSY;
836
837         mutex_lock(&map->lock);
838
839         bypass = map->cache_bypass;
840
841         map->cache_bypass = true;
842
843         /* Write out first; it's useful to apply even if we fail later. */
844         for (i = 0; i < num_regs; i++) {
845                 ret = _regmap_write(map, regs[i].reg, regs[i].def);
846                 if (ret != 0) {
847                         dev_err(map->dev, "Failed to write %x = %x: %d\n",
848                                 regs[i].reg, regs[i].def, ret);
849                         goto out;
850                 }
851         }
852
853         map->patch = kcalloc(num_regs, sizeof(struct reg_default), GFP_KERNEL);
854         if (map->patch != NULL) {
855                 memcpy(map->patch, regs,
856                        num_regs * sizeof(struct reg_default));
857                 map->patch_regs = num_regs;
858         } else {
859                 ret = -ENOMEM;
860         }
861
862 out:
863         map->cache_bypass = bypass;
864
865         mutex_unlock(&map->lock);
866
867         return ret;
868 }
869 EXPORT_SYMBOL_GPL(regmap_register_patch);
870
871 static int __init regmap_initcall(void)
872 {
873         regmap_debugfs_initcall();
874
875         return 0;
876 }
877 postcore_initcall(regmap_initcall);