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