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