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