c1458849a152412a8cbe6cff9adb01a0000bfd25
[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 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
548                             unsigned int val_len)
549 {
550         u8 *u8 = map->work_buf;
551         int ret;
552
553         map->format.format_reg(map->work_buf, reg);
554
555         /*
556          * Some buses or devices flag reads by setting the high bits in the
557          * register addresss; since it's always the high bits for all
558          * current formats we can do this here rather than in
559          * formatting.  This may break if we get interesting formats.
560          */
561         u8[0] |= map->read_flag_mask;
562
563         trace_regmap_hw_read_start(map->dev, reg,
564                                    val_len / map->format.val_bytes);
565
566         ret = map->bus->read(map->dev, map->work_buf,
567                              map->format.reg_bytes + map->format.pad_bytes,
568                              val, val_len);
569
570         trace_regmap_hw_read_done(map->dev, reg,
571                                   val_len / map->format.val_bytes);
572
573         return ret;
574 }
575
576 static int _regmap_read(struct regmap *map, unsigned int reg,
577                         unsigned int *val)
578 {
579         int ret;
580
581         if (!map->cache_bypass) {
582                 ret = regcache_read(map, reg, val);
583                 if (ret == 0)
584                         return 0;
585         }
586
587         if (!map->format.parse_val)
588                 return -EINVAL;
589
590         if (map->cache_only)
591                 return -EBUSY;
592
593         ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
594         if (ret == 0) {
595                 *val = map->format.parse_val(map->work_buf);
596                 trace_regmap_reg_read(map->dev, reg, *val);
597         }
598
599         return ret;
600 }
601
602 /**
603  * regmap_read(): Read a value from a single register
604  *
605  * @map: Register map to write to
606  * @reg: Register to be read from
607  * @val: Pointer to store read value
608  *
609  * A value of zero will be returned on success, a negative errno will
610  * be returned in error cases.
611  */
612 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
613 {
614         int ret;
615
616         mutex_lock(&map->lock);
617
618         ret = _regmap_read(map, reg, val);
619
620         mutex_unlock(&map->lock);
621
622         return ret;
623 }
624 EXPORT_SYMBOL_GPL(regmap_read);
625
626 /**
627  * regmap_raw_read(): Read raw data from the device
628  *
629  * @map: Register map to write to
630  * @reg: First register to be read from
631  * @val: Pointer to store read value
632  * @val_len: Size of data to read
633  *
634  * A value of zero will be returned on success, a negative errno will
635  * be returned in error cases.
636  */
637 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
638                     size_t val_len)
639 {
640         size_t val_count = val_len / map->format.val_bytes;
641         int ret;
642
643         WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
644                 map->cache_type != REGCACHE_NONE);
645
646         mutex_lock(&map->lock);
647
648         ret = _regmap_raw_read(map, reg, val, val_len);
649
650         mutex_unlock(&map->lock);
651
652         return ret;
653 }
654 EXPORT_SYMBOL_GPL(regmap_raw_read);
655
656 /**
657  * regmap_bulk_read(): Read multiple registers from the device
658  *
659  * @map: Register map to write to
660  * @reg: First register to be read from
661  * @val: Pointer to store read value, in native register size for device
662  * @val_count: Number of registers to read
663  *
664  * A value of zero will be returned on success, a negative errno will
665  * be returned in error cases.
666  */
667 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
668                      size_t val_count)
669 {
670         int ret, i;
671         size_t val_bytes = map->format.val_bytes;
672         bool vol = regmap_volatile_range(map, reg, val_count);
673
674         if (!map->format.parse_val)
675                 return -EINVAL;
676
677         if (vol || map->cache_type == REGCACHE_NONE) {
678                 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
679                 if (ret != 0)
680                         return ret;
681
682                 for (i = 0; i < val_count * val_bytes; i += val_bytes)
683                         map->format.parse_val(val + i);
684         } else {
685                 for (i = 0; i < val_count; i++) {
686                         ret = regmap_read(map, reg + i, val + (i * val_bytes));
687                         if (ret != 0)
688                                 return ret;
689                 }
690         }
691
692         return 0;
693 }
694 EXPORT_SYMBOL_GPL(regmap_bulk_read);
695
696 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
697                                unsigned int mask, unsigned int val,
698                                bool *change)
699 {
700         int ret;
701         unsigned int tmp, orig;
702
703         mutex_lock(&map->lock);
704
705         ret = _regmap_read(map, reg, &orig);
706         if (ret != 0)
707                 goto out;
708
709         tmp = orig & ~mask;
710         tmp |= val & mask;
711
712         if (tmp != orig) {
713                 ret = _regmap_write(map, reg, tmp);
714                 *change = true;
715         } else {
716                 *change = false;
717         }
718
719 out:
720         mutex_unlock(&map->lock);
721
722         return ret;
723 }
724
725 /**
726  * regmap_update_bits: Perform a read/modify/write cycle on the register map
727  *
728  * @map: Register map to update
729  * @reg: Register to update
730  * @mask: Bitmask to change
731  * @val: New value for bitmask
732  *
733  * Returns zero for success, a negative number on error.
734  */
735 int regmap_update_bits(struct regmap *map, unsigned int reg,
736                        unsigned int mask, unsigned int val)
737 {
738         bool change;
739         return _regmap_update_bits(map, reg, mask, val, &change);
740 }
741 EXPORT_SYMBOL_GPL(regmap_update_bits);
742
743 /**
744  * regmap_update_bits_check: Perform a read/modify/write cycle on the
745  *                           register map and report if updated
746  *
747  * @map: Register map to update
748  * @reg: Register to update
749  * @mask: Bitmask to change
750  * @val: New value for bitmask
751  * @change: Boolean indicating if a write was done
752  *
753  * Returns zero for success, a negative number on error.
754  */
755 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
756                              unsigned int mask, unsigned int val,
757                              bool *change)
758 {
759         return _regmap_update_bits(map, reg, mask, val, change);
760 }
761 EXPORT_SYMBOL_GPL(regmap_update_bits_check);
762
763 /**
764  * regmap_register_patch: Register and apply register updates to be applied
765  *                        on device initialistion
766  *
767  * @map: Register map to apply updates to.
768  * @regs: Values to update.
769  * @num_regs: Number of entries in regs.
770  *
771  * Register a set of register updates to be applied to the device
772  * whenever the device registers are synchronised with the cache and
773  * apply them immediately.  Typically this is used to apply
774  * corrections to be applied to the device defaults on startup, such
775  * as the updates some vendors provide to undocumented registers.
776  */
777 int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
778                           int num_regs)
779 {
780         int i, ret;
781         bool bypass;
782
783         /* If needed the implementation can be extended to support this */
784         if (map->patch)
785                 return -EBUSY;
786
787         mutex_lock(&map->lock);
788
789         bypass = map->cache_bypass;
790
791         map->cache_bypass = true;
792
793         /* Write out first; it's useful to apply even if we fail later. */
794         for (i = 0; i < num_regs; i++) {
795                 ret = _regmap_write(map, regs[i].reg, regs[i].def);
796                 if (ret != 0) {
797                         dev_err(map->dev, "Failed to write %x = %x: %d\n",
798                                 regs[i].reg, regs[i].def, ret);
799                         goto out;
800                 }
801         }
802
803         map->patch = kcalloc(num_regs, sizeof(struct reg_default), GFP_KERNEL);
804         if (map->patch != NULL) {
805                 memcpy(map->patch, regs,
806                        num_regs * sizeof(struct reg_default));
807                 map->patch_regs = num_regs;
808         } else {
809                 ret = -ENOMEM;
810         }
811
812 out:
813         map->cache_bypass = bypass;
814
815         mutex_unlock(&map->lock);
816
817         return ret;
818 }
819 EXPORT_SYMBOL_GPL(regmap_register_patch);
820
821 static int __init regmap_initcall(void)
822 {
823         regmap_debugfs_initcall();
824
825         return 0;
826 }
827 postcore_initcall(regmap_initcall);