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