regmap: Add support for padding between register and address
[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
282         map->max_register = config->max_register;
283         map->writeable_reg = config->writeable_reg;
284         map->readable_reg = config->readable_reg;
285         map->volatile_reg = config->volatile_reg;
286         map->precious_reg = config->precious_reg;
287         map->cache_type = config->cache_type;
288
289         ret = regcache_init(map, config);
290
291         mutex_unlock(&map->lock);
292
293         return ret;
294 }
295
296 /**
297  * regmap_exit(): Free a previously allocated register map
298  */
299 void regmap_exit(struct regmap *map)
300 {
301         regcache_exit(map);
302         regmap_debugfs_exit(map);
303         kfree(map->work_buf);
304         kfree(map);
305 }
306 EXPORT_SYMBOL_GPL(regmap_exit);
307
308 static int _regmap_raw_write(struct regmap *map, unsigned int reg,
309                              const void *val, size_t val_len)
310 {
311         u8 *u8 = map->work_buf;
312         void *buf;
313         int ret = -ENOTSUPP;
314         size_t len;
315         int i;
316
317         /* Check for unwritable registers before we start */
318         if (map->writeable_reg)
319                 for (i = 0; i < val_len / map->format.val_bytes; i++)
320                         if (!map->writeable_reg(map->dev, reg + i))
321                                 return -EINVAL;
322
323         map->format.format_reg(map->work_buf, reg);
324
325         u8[0] |= map->write_flag_mask;
326
327         trace_regmap_hw_write_start(map->dev, reg,
328                                     val_len / map->format.val_bytes);
329
330         /* If we're doing a single register write we can probably just
331          * send the work_buf directly, otherwise try to do a gather
332          * write.
333          */
334         if (val == (map->work_buf + map->format.pad_bytes +
335                     map->format.reg_bytes))
336                 ret = map->bus->write(map->dev, map->work_buf,
337                                       map->format.reg_bytes +
338                                       map->format.pad_bytes +
339                                       val_len);
340         else if (map->bus->gather_write)
341                 ret = map->bus->gather_write(map->dev, map->work_buf,
342                                              map->format.reg_bytes +
343                                              map->format.pad_bytes,
344                                              val, val_len);
345
346         /* If that didn't work fall back on linearising by hand. */
347         if (ret == -ENOTSUPP) {
348                 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
349                 buf = kzalloc(len, GFP_KERNEL);
350                 if (!buf)
351                         return -ENOMEM;
352
353                 memcpy(buf, map->work_buf, map->format.reg_bytes);
354                 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
355                        val, val_len);
356                 ret = map->bus->write(map->dev, buf, len);
357
358                 kfree(buf);
359         }
360
361         trace_regmap_hw_write_done(map->dev, reg,
362                                    val_len / map->format.val_bytes);
363
364         return ret;
365 }
366
367 int _regmap_write(struct regmap *map, unsigned int reg,
368                   unsigned int val)
369 {
370         int ret;
371         BUG_ON(!map->format.format_write && !map->format.format_val);
372
373         if (!map->cache_bypass) {
374                 ret = regcache_write(map, reg, val);
375                 if (ret != 0)
376                         return ret;
377                 if (map->cache_only) {
378                         map->cache_dirty = true;
379                         return 0;
380                 }
381         }
382
383         trace_regmap_reg_write(map->dev, reg, val);
384
385         if (map->format.format_write) {
386                 map->format.format_write(map, reg, val);
387
388                 trace_regmap_hw_write_start(map->dev, reg, 1);
389
390                 ret = map->bus->write(map->dev, map->work_buf,
391                                       map->format.buf_size);
392
393                 trace_regmap_hw_write_done(map->dev, reg, 1);
394
395                 return ret;
396         } else {
397                 map->format.format_val(map->work_buf + map->format.reg_bytes
398                                        + map->format.pad_bytes, val);
399                 return _regmap_raw_write(map, reg,
400                                          map->work_buf +
401                                          map->format.reg_bytes +
402                                          map->format.pad_bytes,
403                                          map->format.val_bytes);
404         }
405 }
406
407 /**
408  * regmap_write(): Write a value to a single register
409  *
410  * @map: Register map to write to
411  * @reg: Register to write to
412  * @val: Value to be written
413  *
414  * A value of zero will be returned on success, a negative errno will
415  * be returned in error cases.
416  */
417 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
418 {
419         int ret;
420
421         mutex_lock(&map->lock);
422
423         ret = _regmap_write(map, reg, val);
424
425         mutex_unlock(&map->lock);
426
427         return ret;
428 }
429 EXPORT_SYMBOL_GPL(regmap_write);
430
431 /**
432  * regmap_raw_write(): Write raw values to one or more registers
433  *
434  * @map: Register map to write to
435  * @reg: Initial register to write to
436  * @val: Block of data to be written, laid out for direct transmission to the
437  *       device
438  * @val_len: Length of data pointed to by val.
439  *
440  * This function is intended to be used for things like firmware
441  * download where a large block of data needs to be transferred to the
442  * device.  No formatting will be done on the data provided.
443  *
444  * A value of zero will be returned on success, a negative errno will
445  * be returned in error cases.
446  */
447 int regmap_raw_write(struct regmap *map, unsigned int reg,
448                      const void *val, size_t val_len)
449 {
450         size_t val_count = val_len / map->format.val_bytes;
451         int ret;
452
453         WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
454                 map->cache_type != REGCACHE_NONE);
455
456         mutex_lock(&map->lock);
457
458         ret = _regmap_raw_write(map, reg, val, val_len);
459
460         mutex_unlock(&map->lock);
461
462         return ret;
463 }
464 EXPORT_SYMBOL_GPL(regmap_raw_write);
465
466 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
467                             unsigned int val_len)
468 {
469         u8 *u8 = map->work_buf;
470         int ret;
471
472         map->format.format_reg(map->work_buf, reg);
473
474         /*
475          * Some buses or devices flag reads by setting the high bits in the
476          * register addresss; since it's always the high bits for all
477          * current formats we can do this here rather than in
478          * formatting.  This may break if we get interesting formats.
479          */
480         u8[0] |= map->read_flag_mask;
481
482         trace_regmap_hw_read_start(map->dev, reg,
483                                    val_len / map->format.val_bytes);
484
485         ret = map->bus->read(map->dev, map->work_buf,
486                              map->format.reg_bytes + map->format.pad_bytes,
487                              val, val_len);
488
489         trace_regmap_hw_read_done(map->dev, reg,
490                                   val_len / map->format.val_bytes);
491
492         return ret;
493 }
494
495 static int _regmap_read(struct regmap *map, unsigned int reg,
496                         unsigned int *val)
497 {
498         int ret;
499
500         if (!map->cache_bypass) {
501                 ret = regcache_read(map, reg, val);
502                 if (ret == 0)
503                         return 0;
504         }
505
506         if (!map->format.parse_val)
507                 return -EINVAL;
508
509         if (map->cache_only)
510                 return -EBUSY;
511
512         ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
513         if (ret == 0) {
514                 *val = map->format.parse_val(map->work_buf);
515                 trace_regmap_reg_read(map->dev, reg, *val);
516         }
517
518         return ret;
519 }
520
521 /**
522  * regmap_read(): Read a value from a single register
523  *
524  * @map: Register map to write to
525  * @reg: Register to be read from
526  * @val: Pointer to store read value
527  *
528  * A value of zero will be returned on success, a negative errno will
529  * be returned in error cases.
530  */
531 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
532 {
533         int ret;
534
535         mutex_lock(&map->lock);
536
537         ret = _regmap_read(map, reg, val);
538
539         mutex_unlock(&map->lock);
540
541         return ret;
542 }
543 EXPORT_SYMBOL_GPL(regmap_read);
544
545 /**
546  * regmap_raw_read(): Read raw data from the device
547  *
548  * @map: Register map to write to
549  * @reg: First register to be read from
550  * @val: Pointer to store read value
551  * @val_len: Size of data to read
552  *
553  * A value of zero will be returned on success, a negative errno will
554  * be returned in error cases.
555  */
556 int regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
557                     size_t val_len)
558 {
559         size_t val_count = val_len / map->format.val_bytes;
560         int ret;
561
562         WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
563                 map->cache_type != REGCACHE_NONE);
564
565         mutex_lock(&map->lock);
566
567         ret = _regmap_raw_read(map, reg, val, val_len);
568
569         mutex_unlock(&map->lock);
570
571         return ret;
572 }
573 EXPORT_SYMBOL_GPL(regmap_raw_read);
574
575 /**
576  * regmap_bulk_read(): Read multiple registers from the device
577  *
578  * @map: Register map to write to
579  * @reg: First register to be read from
580  * @val: Pointer to store read value, in native register size for device
581  * @val_count: Number of registers to read
582  *
583  * A value of zero will be returned on success, a negative errno will
584  * be returned in error cases.
585  */
586 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
587                      size_t val_count)
588 {
589         int ret, i;
590         size_t val_bytes = map->format.val_bytes;
591         bool vol = regmap_volatile_range(map, reg, val_count);
592
593         if (!map->format.parse_val)
594                 return -EINVAL;
595
596         if (vol || map->cache_type == REGCACHE_NONE) {
597                 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
598                 if (ret != 0)
599                         return ret;
600
601                 for (i = 0; i < val_count * val_bytes; i += val_bytes)
602                         map->format.parse_val(val + i);
603         } else {
604                 for (i = 0; i < val_count; i++) {
605                         ret = regmap_read(map, reg + i, val + (i * val_bytes));
606                         if (ret != 0)
607                                 return ret;
608                 }
609         }
610
611         return 0;
612 }
613 EXPORT_SYMBOL_GPL(regmap_bulk_read);
614
615 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
616                                unsigned int mask, unsigned int val,
617                                bool *change)
618 {
619         int ret;
620         unsigned int tmp, orig;
621
622         mutex_lock(&map->lock);
623
624         ret = _regmap_read(map, reg, &orig);
625         if (ret != 0)
626                 goto out;
627
628         tmp = orig & ~mask;
629         tmp |= val & mask;
630
631         if (tmp != orig) {
632                 ret = _regmap_write(map, reg, tmp);
633                 *change = true;
634         } else {
635                 *change = false;
636         }
637
638 out:
639         mutex_unlock(&map->lock);
640
641         return ret;
642 }
643
644 /**
645  * regmap_update_bits: Perform a read/modify/write cycle on the register map
646  *
647  * @map: Register map to update
648  * @reg: Register to update
649  * @mask: Bitmask to change
650  * @val: New value for bitmask
651  *
652  * Returns zero for success, a negative number on error.
653  */
654 int regmap_update_bits(struct regmap *map, unsigned int reg,
655                        unsigned int mask, unsigned int val)
656 {
657         bool change;
658         return _regmap_update_bits(map, reg, mask, val, &change);
659 }
660 EXPORT_SYMBOL_GPL(regmap_update_bits);
661
662 /**
663  * remap_update_bits_lazy: Perform a read/modify/write cycle on the register
664  * map. Only write new contents if they differ from the previous ones.
665  *
666  * @map: Register map to update
667  * @reg: Register to update
668  * @mask: Bitmask to change
669  * @val: New value for bitmask
670  *
671  * Returns zero for success, a negative number on error.
672  */
673 int regmap_update_bits_lazy(struct regmap *map, unsigned int reg,
674                        unsigned int mask, unsigned int val)
675 {
676         int ret, new;
677         unsigned int tmp;
678
679         mutex_lock(&map->lock);
680
681         ret = _regmap_read(map, reg, &tmp);
682         if (ret != 0)
683                 goto out;
684
685         new = tmp & ~mask;
686         new |= val & mask;
687         if (new != tmp) {
688                 ret = _regmap_write(map, reg, new);
689         }
690
691 out:
692         mutex_unlock(&map->lock);
693
694         return ret;
695 }
696 EXPORT_SYMBOL_GPL(regmap_update_bits_lazy);
697
698 /**
699  * regmap_update_bits_check: Perform a read/modify/write cycle on the
700  *                           register map and report if updated
701  * @map: Register map to update
702  * @reg: Register to update
703  * @mask: Bitmask to change
704  * @val: New value for bitmask
705  * @change: Boolean indicating if a write was done
706  *
707  * Returns zero for success, a negative number on error.
708  */
709 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
710                              unsigned int mask, unsigned int val,
711                              bool *change)
712 {
713         return _regmap_update_bits(map, reg, mask, val, change);
714 }
715 EXPORT_SYMBOL_GPL(regmap_update_bits_check);
716
717 static int __init regmap_initcall(void)
718 {
719         regmap_debugfs_initcall();
720
721         return 0;
722 }
723 postcore_initcall(regmap_initcall);