regmap: Fix kcalloc parameters swapped
[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         map->format.format_reg(map->work_buf, reg);
389
390         u8[0] |= map->write_flag_mask;
391
392         trace_regmap_hw_write_start(map->dev, reg,
393                                     val_len / map->format.val_bytes);
394
395         /* If we're doing a single register write we can probably just
396          * send the work_buf directly, otherwise try to do a gather
397          * write.
398          */
399         if (val == (map->work_buf + map->format.pad_bytes +
400                     map->format.reg_bytes))
401                 ret = map->bus->write(map->dev, map->work_buf,
402                                       map->format.reg_bytes +
403                                       map->format.pad_bytes +
404                                       val_len);
405         else if (map->bus->gather_write)
406                 ret = map->bus->gather_write(map->dev, map->work_buf,
407                                              map->format.reg_bytes +
408                                              map->format.pad_bytes,
409                                              val, val_len);
410
411         /* If that didn't work fall back on linearising by hand. */
412         if (ret == -ENOTSUPP) {
413                 len = map->format.reg_bytes + map->format.pad_bytes + val_len;
414                 buf = kzalloc(len, GFP_KERNEL);
415                 if (!buf)
416                         return -ENOMEM;
417
418                 memcpy(buf, map->work_buf, map->format.reg_bytes);
419                 memcpy(buf + map->format.reg_bytes + map->format.pad_bytes,
420                        val, val_len);
421                 ret = map->bus->write(map->dev, buf, len);
422
423                 kfree(buf);
424         }
425
426         trace_regmap_hw_write_done(map->dev, reg,
427                                    val_len / map->format.val_bytes);
428
429         return ret;
430 }
431
432 int _regmap_write(struct regmap *map, unsigned int reg,
433                   unsigned int val)
434 {
435         int ret;
436         BUG_ON(!map->format.format_write && !map->format.format_val);
437
438         if (!map->cache_bypass) {
439                 ret = regcache_write(map, reg, val);
440                 if (ret != 0)
441                         return ret;
442                 if (map->cache_only) {
443                         map->cache_dirty = true;
444                         return 0;
445                 }
446         }
447
448         trace_regmap_reg_write(map->dev, reg, val);
449
450         if (map->format.format_write) {
451                 map->format.format_write(map, reg, val);
452
453                 trace_regmap_hw_write_start(map->dev, reg, 1);
454
455                 ret = map->bus->write(map->dev, map->work_buf,
456                                       map->format.buf_size);
457
458                 trace_regmap_hw_write_done(map->dev, reg, 1);
459
460                 return ret;
461         } else {
462                 map->format.format_val(map->work_buf + map->format.reg_bytes
463                                        + map->format.pad_bytes, val);
464                 return _regmap_raw_write(map, reg,
465                                          map->work_buf +
466                                          map->format.reg_bytes +
467                                          map->format.pad_bytes,
468                                          map->format.val_bytes);
469         }
470 }
471
472 /**
473  * regmap_write(): Write a value to a single register
474  *
475  * @map: Register map to write to
476  * @reg: Register to write to
477  * @val: Value to be written
478  *
479  * A value of zero will be returned on success, a negative errno will
480  * be returned in error cases.
481  */
482 int regmap_write(struct regmap *map, unsigned int reg, unsigned int val)
483 {
484         int ret;
485
486         mutex_lock(&map->lock);
487
488         ret = _regmap_write(map, reg, val);
489
490         mutex_unlock(&map->lock);
491
492         return ret;
493 }
494 EXPORT_SYMBOL_GPL(regmap_write);
495
496 /**
497  * regmap_raw_write(): Write raw values to one or more registers
498  *
499  * @map: Register map to write to
500  * @reg: Initial register to write to
501  * @val: Block of data to be written, laid out for direct transmission to the
502  *       device
503  * @val_len: Length of data pointed to by val.
504  *
505  * This function is intended to be used for things like firmware
506  * download where a large block of data needs to be transferred to the
507  * device.  No formatting will be done on the data provided.
508  *
509  * A value of zero will be returned on success, a negative errno will
510  * be returned in error cases.
511  */
512 int regmap_raw_write(struct regmap *map, unsigned int reg,
513                      const void *val, size_t val_len)
514 {
515         size_t val_count = val_len / map->format.val_bytes;
516         int ret;
517
518         WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
519                 map->cache_type != REGCACHE_NONE);
520
521         mutex_lock(&map->lock);
522
523         ret = _regmap_raw_write(map, reg, val, val_len);
524
525         mutex_unlock(&map->lock);
526
527         return ret;
528 }
529 EXPORT_SYMBOL_GPL(regmap_raw_write);
530
531 static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
532                             unsigned int val_len)
533 {
534         u8 *u8 = map->work_buf;
535         int ret;
536
537         map->format.format_reg(map->work_buf, reg);
538
539         /*
540          * Some buses or devices flag reads by setting the high bits in the
541          * register addresss; since it's always the high bits for all
542          * current formats we can do this here rather than in
543          * formatting.  This may break if we get interesting formats.
544          */
545         u8[0] |= map->read_flag_mask;
546
547         trace_regmap_hw_read_start(map->dev, reg,
548                                    val_len / map->format.val_bytes);
549
550         ret = map->bus->read(map->dev, map->work_buf,
551                              map->format.reg_bytes + map->format.pad_bytes,
552                              val, val_len);
553
554         trace_regmap_hw_read_done(map->dev, reg,
555                                   val_len / map->format.val_bytes);
556
557         return ret;
558 }
559
560 static int _regmap_read(struct regmap *map, unsigned int reg,
561                         unsigned int *val)
562 {
563         int ret;
564
565         if (!map->cache_bypass) {
566                 ret = regcache_read(map, reg, val);
567                 if (ret == 0)
568                         return 0;
569         }
570
571         if (!map->format.parse_val)
572                 return -EINVAL;
573
574         if (map->cache_only)
575                 return -EBUSY;
576
577         ret = _regmap_raw_read(map, reg, map->work_buf, map->format.val_bytes);
578         if (ret == 0) {
579                 *val = map->format.parse_val(map->work_buf);
580                 trace_regmap_reg_read(map->dev, reg, *val);
581         }
582
583         return ret;
584 }
585
586 /**
587  * regmap_read(): Read a value from a single register
588  *
589  * @map: Register map to write to
590  * @reg: Register to be read from
591  * @val: Pointer to store read value
592  *
593  * A value of zero will be returned on success, a negative errno will
594  * be returned in error cases.
595  */
596 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val)
597 {
598         int ret;
599
600         mutex_lock(&map->lock);
601
602         ret = _regmap_read(map, reg, val);
603
604         mutex_unlock(&map->lock);
605
606         return ret;
607 }
608 EXPORT_SYMBOL_GPL(regmap_read);
609
610 /**
611  * regmap_raw_read(): Read raw data from the device
612  *
613  * @map: Register map to write to
614  * @reg: First register to be read from
615  * @val: Pointer to store read value
616  * @val_len: Size of data to read
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_raw_read(struct regmap *map, unsigned int reg, void *val,
622                     size_t val_len)
623 {
624         size_t val_count = val_len / map->format.val_bytes;
625         int ret;
626
627         WARN_ON(!regmap_volatile_range(map, reg, val_count) &&
628                 map->cache_type != REGCACHE_NONE);
629
630         mutex_lock(&map->lock);
631
632         ret = _regmap_raw_read(map, reg, val, val_len);
633
634         mutex_unlock(&map->lock);
635
636         return ret;
637 }
638 EXPORT_SYMBOL_GPL(regmap_raw_read);
639
640 /**
641  * regmap_bulk_read(): Read multiple registers from the device
642  *
643  * @map: Register map to write to
644  * @reg: First register to be read from
645  * @val: Pointer to store read value, in native register size for device
646  * @val_count: Number of registers to read
647  *
648  * A value of zero will be returned on success, a negative errno will
649  * be returned in error cases.
650  */
651 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
652                      size_t val_count)
653 {
654         int ret, i;
655         size_t val_bytes = map->format.val_bytes;
656         bool vol = regmap_volatile_range(map, reg, val_count);
657
658         if (!map->format.parse_val)
659                 return -EINVAL;
660
661         if (vol || map->cache_type == REGCACHE_NONE) {
662                 ret = regmap_raw_read(map, reg, val, val_bytes * val_count);
663                 if (ret != 0)
664                         return ret;
665
666                 for (i = 0; i < val_count * val_bytes; i += val_bytes)
667                         map->format.parse_val(val + i);
668         } else {
669                 for (i = 0; i < val_count; i++) {
670                         ret = regmap_read(map, reg + i, val + (i * val_bytes));
671                         if (ret != 0)
672                                 return ret;
673                 }
674         }
675
676         return 0;
677 }
678 EXPORT_SYMBOL_GPL(regmap_bulk_read);
679
680 static int _regmap_update_bits(struct regmap *map, unsigned int reg,
681                                unsigned int mask, unsigned int val,
682                                bool *change)
683 {
684         int ret;
685         unsigned int tmp, orig;
686
687         mutex_lock(&map->lock);
688
689         ret = _regmap_read(map, reg, &orig);
690         if (ret != 0)
691                 goto out;
692
693         tmp = orig & ~mask;
694         tmp |= val & mask;
695
696         if (tmp != orig) {
697                 ret = _regmap_write(map, reg, tmp);
698                 *change = true;
699         } else {
700                 *change = false;
701         }
702
703 out:
704         mutex_unlock(&map->lock);
705
706         return ret;
707 }
708
709 /**
710  * regmap_update_bits: Perform a read/modify/write cycle on the register map
711  *
712  * @map: Register map to update
713  * @reg: Register to update
714  * @mask: Bitmask to change
715  * @val: New value for bitmask
716  *
717  * Returns zero for success, a negative number on error.
718  */
719 int regmap_update_bits(struct regmap *map, unsigned int reg,
720                        unsigned int mask, unsigned int val)
721 {
722         bool change;
723         return _regmap_update_bits(map, reg, mask, val, &change);
724 }
725 EXPORT_SYMBOL_GPL(regmap_update_bits);
726
727 /**
728  * regmap_update_bits_check: Perform a read/modify/write cycle on the
729  *                           register map and report if updated
730  *
731  * @map: Register map to update
732  * @reg: Register to update
733  * @mask: Bitmask to change
734  * @val: New value for bitmask
735  * @change: Boolean indicating if a write was done
736  *
737  * Returns zero for success, a negative number on error.
738  */
739 int regmap_update_bits_check(struct regmap *map, unsigned int reg,
740                              unsigned int mask, unsigned int val,
741                              bool *change)
742 {
743         return _regmap_update_bits(map, reg, mask, val, change);
744 }
745 EXPORT_SYMBOL_GPL(regmap_update_bits_check);
746
747 /**
748  * regmap_register_patch: Register and apply register updates to be applied
749  *                        on device initialistion
750  *
751  * @map: Register map to apply updates to.
752  * @regs: Values to update.
753  * @num_regs: Number of entries in regs.
754  *
755  * Register a set of register updates to be applied to the device
756  * whenever the device registers are synchronised with the cache and
757  * apply them immediately.  Typically this is used to apply
758  * corrections to be applied to the device defaults on startup, such
759  * as the updates some vendors provide to undocumented registers.
760  */
761 int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
762                           int num_regs)
763 {
764         int i, ret;
765         bool bypass;
766
767         /* If needed the implementation can be extended to support this */
768         if (map->patch)
769                 return -EBUSY;
770
771         mutex_lock(&map->lock);
772
773         bypass = map->cache_bypass;
774
775         map->cache_bypass = true;
776
777         /* Write out first; it's useful to apply even if we fail later. */
778         for (i = 0; i < num_regs; i++) {
779                 ret = _regmap_write(map, regs[i].reg, regs[i].def);
780                 if (ret != 0) {
781                         dev_err(map->dev, "Failed to write %x = %x: %d\n",
782                                 regs[i].reg, regs[i].def, ret);
783                         goto out;
784                 }
785         }
786
787         map->patch = kcalloc(num_regs, sizeof(struct reg_default), GFP_KERNEL);
788         if (map->patch != NULL) {
789                 memcpy(map->patch, regs,
790                        num_regs * sizeof(struct reg_default));
791                 map->patch_regs = num_regs;
792         } else {
793                 ret = -ENOMEM;
794         }
795
796 out:
797         map->cache_bypass = bypass;
798
799         mutex_unlock(&map->lock);
800
801         return ret;
802 }
803 EXPORT_SYMBOL_GPL(regmap_register_patch);
804
805 static int __init regmap_initcall(void)
806 {
807         regmap_debugfs_initcall();
808
809         return 0;
810 }
811 postcore_initcall(regmap_initcall);